diff --git a/apps/web/app/api/admin/catalogue-directory/route.ts b/apps/web/app/api/admin/catalogue-directory/route.ts
index 4d4ddaca..33b9923f 100644
--- a/apps/web/app/api/admin/catalogue-directory/route.ts
+++ b/apps/web/app/api/admin/catalogue-directory/route.ts
@@ -1,6 +1,6 @@
 import { canManageCourseImports } from "@/lib/auth/viewer";
 import { refreshCatalogueDirectory } from "@/lib/catalogue-import/directory";
-import { isCatalogueKind } from "@/lib/catalogue-import/snapshot-write";
+import { isCatalogueKind } from "@/lib/catalogue/content";
 
 export const runtime = "nodejs";
 export const maxDuration = 60;
diff --git a/apps/web/app/api/admin/catalogue-imports/route.ts b/apps/web/app/api/admin/catalogue-imports/route.ts
index 4dca0a91..d6b3cb81 100644
--- a/apps/web/app/api/admin/catalogue-imports/route.ts
+++ b/apps/web/app/api/admin/catalogue-imports/route.ts
@@ -5,7 +5,7 @@ import {
   processImportRunInline,
 } from "@/lib/catalogue-import/queue";
 import { adapterForKind } from "@/lib/catalogue-import/process-target";
-import { isCatalogueKind } from "@/lib/catalogue-import/snapshot-write";
+import { isCatalogueKind } from "@/lib/catalogue/content";
 import { loadImportModelSetting } from "@/lib/admin/settings";
 import { createClient } from "@/lib/supabase/server";
 
diff --git a/apps/web/lib/admin/users.ts b/apps/web/lib/admin/users.ts
index 8bc48e9e..abf8ae3c 100644
--- a/apps/web/lib/admin/users.ts
+++ b/apps/web/lib/admin/users.ts
@@ -105,8 +105,7 @@ export type AdminRoleManagementData = {
 
 type AdminPlanItemRow = {
   academic_period_id: number | null;
-  academic_year_id: number;
-  course_id: number;
+  catalogue_record_id: number;
   created_at: string;
   id: string;
   planned_calendar_year: number | null;
@@ -117,8 +116,7 @@ type AdminPlanItemRow = {
 
 type AdminCourseAttemptRow = {
   academic_period_id: number;
-  course_id: number;
-  course_snapshot_id: number;
+  catalogue_version_id: number;
   created_at: string;
   id: string;
   mark: number | null;
@@ -393,20 +391,20 @@ export async function loadAdminUserDetail(
           .maybeSingle(),
         supabase
           .from("plan_structures")
-          .select("role,structure_year_id,position")
+          .select("role,catalogue_record_id,position")
           .eq("plan_id", plan.id)
           .order("position"),
         supabase
           .from("plan_items")
           .select(
-            "id,course_id,academic_year_id,academic_period_id,planned_calendar_year,planned_period_code,created_at,updated_at,sort_order",
+            "id,catalogue_record_id,academic_period_id,planned_calendar_year,planned_period_code,created_at,updated_at,sort_order",
           )
           .eq("plan_id", plan.id)
           .order("sort_order"),
         supabase
           .from("course_attempts")
           .select(
-            "id,course_id,course_snapshot_id,academic_period_id,status,mark,units_attempted,units_earned,created_at,updated_at",
+            "id,catalogue_version_id,academic_period_id,status,mark,units_attempted,units_earned,created_at,updated_at",
           )
           .eq("owner_id", userId)
           .order("created_at"),
@@ -425,15 +423,9 @@ export async function loadAdminUserDetail(
     const itemRows = (itemsResult.data ?? []) as unknown as AdminPlanItemRow[];
     const attemptRows = (attemptsResult.data ??
       []) as unknown as AdminCourseAttemptRow[];
-    const structureYearIds = structureRows.map(
-      (structure) => structure.structure_year_id,
+    const attemptVersionIds = attemptRows.map(
+      (attempt) => attempt.catalogue_version_id,
     );
-    const courseIds = [
-      ...new Set([
-        ...itemRows.map((item) => item.course_id),
-        ...attemptRows.map((attempt) => attempt.course_id),
-      ]),
-    ];
     const periodIds = [
       ...new Set([
         ...itemRows.flatMap((item) =>
@@ -443,27 +435,12 @@ export async function loadAdminUserDetail(
       ]),
     ];
 
-    const [
-      structureYearsResult,
-      courseIdentitiesResult,
-      courseYearsResult,
-      periodsResult,
-    ] = await Promise.all([
-      structureYearIds.length
-        ? supabase
-            .from("catalogue_item_years")
-            .select("id,published_snapshot_id,item_id")
-            .in("id", structureYearIds)
-        : Promise.resolve({ data: [], error: null }),
-      courseIds.length
-        ? supabase.from("catalogue_items").select("id,code").in("id", courseIds)
-        : Promise.resolve({ data: [], error: null }),
-      courseIds.length
+    const [attemptVersionsResult, periodsResult] = await Promise.all([
+      attemptVersionIds.length
         ? supabase
-            .from("catalogue_item_years")
-            .select("item_id,academic_year_id,published_snapshot_id")
-            .is("archived_at", null)
-            .in("item_id", courseIds)
+            .from("catalogue_versions")
+            .select("id,record_id")
+            .in("id", attemptVersionIds)
         : Promise.resolve({ data: [], error: null }),
       periodIds.length
         ? supabase
@@ -473,55 +450,70 @@ export async function loadAdminUserDetail(
         : Promise.resolve({ data: [], error: null }),
     ]);
 
-    const relatedError =
-      structureYearsResult.error ??
-      courseIdentitiesResult.error ??
-      courseYearsResult.error ??
-      periodsResult.error;
+    const relatedError = attemptVersionsResult.error ?? periodsResult.error;
     if (relatedError) {
       throw new Error("Coursemap could not load that user's study details.");
     }
 
-    const structureYears = structureYearsResult.data ?? [];
-    const structureIdentityIds = structureYears.map(
-      (structureYear) => structureYear.item_id,
+    const attemptRecordIdByVersionId = new Map(
+      (attemptVersionsResult.data ?? []).map((version) => [
+        version.id,
+        version.record_id,
+      ]),
     );
-    const structureIdentitiesResult = structureIdentityIds.length
+    const recordIds = [
+      ...new Set([
+        ...structureRows.map((structure) => structure.catalogue_record_id),
+        ...itemRows.map((item) => item.catalogue_record_id),
+        ...attemptRecordIdByVersionId.values(),
+      ]),
+    ];
+    const recordsResult = recordIds.length
       ? await supabase
-          .from("catalogue_items")
-          .select("id,code")
-          .in("id", structureIdentityIds)
+          .from("catalogue_records")
+          .select("id,published_version_id,code_id,academic_year_id")
+          .in("id", recordIds)
       : { data: [], error: null };
-    if (structureIdentitiesResult.error) {
+    if (recordsResult.error) {
       throw new Error("Coursemap could not load that user's programme.");
     }
+    const records = recordsResult.data ?? [];
+    const codeIds = [...new Set(records.map((record) => record.code_id))];
+    const courseIdentitiesResult = codeIds.length
+      ? await supabase
+          .from("catalogue_codes")
+          .select("id,code")
+          .in("id", codeIds)
+      : { data: [], error: null };
+    if (courseIdentitiesResult.error)
+      throw new Error("Coursemap could not load that user's catalogue codes.");
 
     const structureYearById = new Map(
-      structureYears.map((structureYear) => [structureYear.id, structureYear]),
+      records.map((record) => [record.id, record]),
     );
     const structureCodeById = new Map(
-      (structureIdentitiesResult.data ?? []).map((identity) => [
+      (courseIdentitiesResult.data ?? []).map((identity) => [
         identity.id,
         identity.code,
       ]),
     );
-    const structureSnapshotIds = structureYears.flatMap((structureYear) =>
-      structureYear.published_snapshot_id === null
+    const structureSnapshotIds = records.flatMap((structureYear) =>
+      structureYear.published_version_id === null
         ? []
-        : [structureYear.published_snapshot_id],
+        : [structureYear.published_version_id],
     );
     const structureSnapshotsResult = structureSnapshotIds.length
       ? await supabase
-          .from("structure_snapshot_details")
-          .select("snapshot_id,name,units")
-          .in("snapshot_id", structureSnapshotIds)
+          .from("structure_version_details")
+          .select("version_id,name,units")
+          .in("version_id", structureSnapshotIds)
       : { data: [], error: null };
     if (structureSnapshotsResult.error) {
       throw new Error("Coursemap could not load that user's programme.");
     }
     const structureSnapshotById = new Map(
       (structureSnapshotsResult.data ?? []).map((snapshot) => [
-        snapshot.snapshot_id,
+        snapshot.version_id,
         snapshot,
       ]),
     );
@@ -531,36 +523,27 @@ export async function loadAdminUserDetail(
         course.code,
       ]),
     );
-    const publishedSnapshotByCourseYear = new Map(
-      (courseYearsResult.data ?? []).flatMap((courseYear) =>
-        courseYear.published_snapshot_id
-          ? [
-              [
-                `${courseYear.item_id}:${courseYear.academic_year_id}`,
-                courseYear.published_snapshot_id,
-              ] as const,
-            ]
-          : [],
-      ),
-    );
+    const recordById = new Map(records.map((record) => [record.id, record]));
     const snapshotIds = [
       ...new Set([
-        ...publishedSnapshotByCourseYear.values(),
-        ...attemptRows.map((attempt) => attempt.course_snapshot_id),
+        ...records.flatMap((record) =>
+          record.published_version_id ? [record.published_version_id] : [],
+        ),
+        ...attemptRows.map((attempt) => attempt.catalogue_version_id),
       ]),
     ];
     const snapshotsResult = snapshotIds.length
       ? await supabase
-          .from("course_snapshot_details")
-          .select("snapshot_id,title,units,minimum_units,maximum_units")
-          .in("snapshot_id", snapshotIds)
+          .from("course_version_details")
+          .select("version_id,title,units,minimum_units,maximum_units")
+          .in("version_id", snapshotIds)
       : { data: [], error: null };
     if (snapshotsResult.error) {
       throw new Error("Coursemap could not load that user's course details.");
     }
     const snapshotById = new Map(
       (snapshotsResult.data ?? []).map((snapshot) => [
-        snapshot.snapshot_id,
+        snapshot.version_id,
         snapshot,
       ]),
     );
@@ -569,11 +552,10 @@ export async function loadAdminUserDetail(
     );
 
     const plannedCourses: AdminUserCourse[] = itemRows.flatMap((item) => {
-      const code = courseCodeById.get(item.course_id);
+      const record = recordById.get(item.catalogue_record_id);
+      const code = record ? courseCodeById.get(record.code_id) : undefined;
       if (!code) return [];
-      const publishedSnapshotId = publishedSnapshotByCourseYear.get(
-        `${item.course_id}:${item.academic_year_id}`,
-      );
+      const publishedSnapshotId = record?.published_version_id;
       const snapshot = publishedSnapshotId
         ? snapshotById.get(publishedSnapshotId)
         : null;
@@ -606,8 +588,12 @@ export async function loadAdminUserDetail(
     });
     const recordedCourses: AdminUserCourse[] = attemptRows.flatMap(
       (attempt) => {
-        const code = courseCodeById.get(attempt.course_id);
-        const snapshot = snapshotById.get(attempt.course_snapshot_id);
+        const recordId = attemptRecordIdByVersionId.get(
+          attempt.catalogue_version_id,
+        );
+        const record = recordId ? recordById.get(recordId) : undefined;
+        const code = record ? courseCodeById.get(record.code_id) : undefined;
+        const snapshot = snapshotById.get(attempt.catalogue_version_id);
         const period = periodById.get(attempt.academic_period_id);
         const status = courseStatus(attempt.status);
         if (!code || !status) return [];
@@ -645,13 +631,13 @@ export async function loadAdminUserDetail(
       },
       structures: structureRows.flatMap((structure) => {
         const structureYear = structureYearById.get(
-          structure.structure_year_id,
+          structure.catalogue_record_id,
         );
-        const snapshot = structureYear?.published_snapshot_id
-          ? structureSnapshotById.get(structureYear.published_snapshot_id)
+        const snapshot = structureYear?.published_version_id
+          ? structureSnapshotById.get(structureYear.published_version_id)
           : null;
         const code = structureYear
-          ? structureCodeById.get(structureYear.item_id)
+          ? structureCodeById.get(structureYear.code_id)
           : null;
         return snapshot && code
           ? [
diff --git a/apps/web/lib/catalogue-import/apply-review.ts b/apps/web/lib/catalogue-import/apply-review.ts
index f8634a8f..37185fa5 100644
--- a/apps/web/lib/catalogue-import/apply-review.ts
+++ b/apps/web/lib/catalogue-import/apply-review.ts
@@ -1,8 +1,11 @@
 import { applyAcceptedChanges } from "./changes.ts";
 import { type ImportSql, withImportDatabaseClient } from "./import-store.ts";
-import { insertSnapshotContent } from "./persist-snapshot.ts";
-import { contentHashForWrite, readSnapshotWrite } from "./snapshot-read.ts";
-import type { CatalogueKind } from "./snapshot-write.ts";
+import { insertVersionContent } from "./persist-version.ts";
+import {
+  contentHashForCatalogueContent,
+  readVersionContent,
+} from "./version-content.ts";
+import type { CatalogueKind } from "../catalogue/content.ts";
 
 export class ApplyReviewError extends Error {
   readonly code: string;
@@ -15,9 +18,9 @@ export class ApplyReviewError extends Error {
 }
 
 /**
- * Turns a reviewed target into a new draft: the baseline with every accepted
+ * Turns a reviewed target into a new immutable version: the baseline with every accepted
  * change applied, rejected changes left as they were. Refuses when changes
- * are still open or the item year's draft moved since the import ran.
+ * are still open or the record gained another meaningful version since the import ran.
  */
 export async function applyImportReview({
   targetId,
@@ -31,12 +34,26 @@ export async function applyImportReview({
   const work = async (client: ImportSql) =>
     client.begin(async (tx) => {
       const [target] = await tx`
-        select targets.id, targets.kind, targets.item_year_id, targets.academic_year_id,
-          targets.baseline_snapshot_id, targets.candidate_snapshot_id, targets.source_page_id,
+        select targets.id, targets.kind, targets.record_id, targets.academic_year_id,
+          targets.baseline_version_id, targets.candidate_version_id, targets.source_page_id,
           targets.status, targets.applied_at,
-          item_years.draft_snapshot_id, item_years.published_snapshot_id, item_years.archived_at
+          item_years.archived_at, current_version.id as current_version_id
         from public.catalogue_import_targets as targets
-        join public.catalogue_item_years as item_years on item_years.id = targets.item_year_id
+        join public.catalogue_records as item_years on item_years.id = targets.record_id
+        left join lateral (
+          select versions.id
+          from public.catalogue_versions as versions
+          left join public.catalogue_import_targets as version_targets
+            on version_targets.id = versions.import_target_id
+          where versions.record_id = item_years.id
+            and versions.sealed_at is not null
+            and (
+              versions.import_target_id is null
+              or version_targets.applied_version_id = versions.id
+            )
+          order by versions.created_at desc, versions.id desc
+          limit 1
+        ) as current_version on true
         where targets.id = ${targetId}::uuid
         for update of targets, item_years
       `;
@@ -50,7 +67,7 @@ export async function applyImportReview({
           "This review has already been applied.",
           "55000",
         );
-      if (target.status !== "ready" || !target.candidate_snapshot_id) {
+      if (target.status !== "ready" || !target.candidate_version_id) {
         throw new ApplyReviewError(
           "Only targets that are ready for review can be applied.",
           "55000",
@@ -60,18 +77,16 @@ export async function applyImportReview({
         throw new ApplyReviewError("The record is archived.", "55000");
 
       const currentBaseline =
-        target.draft_snapshot_id === null
-          ? target.published_snapshot_id === null
-            ? null
-            : Number(target.published_snapshot_id)
-          : Number(target.draft_snapshot_id);
+        target.current_version_id === null
+          ? null
+          : Number(target.current_version_id);
       const importBaseline =
-        target.baseline_snapshot_id === null
+        target.baseline_version_id === null
           ? null
-          : Number(target.baseline_snapshot_id);
+          : Number(target.baseline_version_id);
       if (currentBaseline !== importBaseline) {
         throw new ApplyReviewError(
-          "The record changed since this import ran. Start a new import to review against the current draft.",
+          "The record changed since this import ran. Start a new import to review against the current version.",
           "STALE_BASELINE",
         );
       }
@@ -91,39 +106,36 @@ export async function applyImportReview({
           .filter((entry) => entry.status === "accepted")
           .map((entry) => String(entry.field_path)),
       );
-      const candidateId = Number(target.candidate_snapshot_id);
+      const candidateId = Number(target.candidate_version_id);
       const kind = target.kind as CatalogueKind;
-      const itemYearId = Number(target.item_year_id);
+      const recordId = Number(target.record_id);
 
-      // Everything accepted: the candidate itself becomes the draft.
+      // Everything accepted: the candidate itself becomes the applied version.
       if (importBaseline === null || accepted.size === entries.length) {
-        await tx`
-          update public.catalogue_item_years set draft_snapshot_id = ${candidateId} where id = ${itemYearId}
-        `;
         await tx`
           update public.catalogue_import_targets
-          set applied_snapshot_id = ${candidateId}, applied_at = now()
+          set applied_version_id = ${candidateId}, applied_at = now()
           where id = ${targetId}::uuid
         `;
-        return { draftSnapshotId: candidateId, reusedCandidate: true };
+        return { versionId: candidateId, reusedCandidate: true };
       }
 
-      const baselineWrite = await readSnapshotWrite(tx, importBaseline);
-      const candidateWrite = await readSnapshotWrite(tx, candidateId);
+      const baselineWrite = await readVersionContent(tx, importBaseline);
+      const candidateWrite = await readVersionContent(tx, candidateId);
       if (!baselineWrite || !candidateWrite) {
         throw new ApplyReviewError(
           "The snapshots for this review could not be read.",
           "P0002",
         );
       }
-      // Nothing accepted: the baseline stays the draft and the review is closed.
+      // Nothing accepted: the baseline stays current and the review is closed.
       if (accepted.size === 0) {
         await tx`
           update public.catalogue_import_targets
-          set applied_snapshot_id = ${importBaseline}, applied_at = now()
+          set applied_version_id = ${importBaseline}, applied_at = now()
           where id = ${targetId}::uuid
         `;
-        return { draftSnapshotId: importBaseline, reusedCandidate: false };
+        return { versionId: importBaseline, reusedCandidate: false };
       }
 
       const merged = applyAcceptedChanges(
@@ -131,19 +143,19 @@ export async function applyImportReview({
         candidateWrite,
         accepted,
       );
-      merged.contentHash = contentHashForWrite(merged);
+      merged.contentHash = contentHashForCatalogueContent(merged);
       const [snapshot] = await tx`
-        insert into public.catalogue_snapshots (
-          item_year_id, kind, academic_year_id, origin, based_on_snapshot_id, source_page_id,
+        insert into public.catalogue_versions (
+          record_id, kind, academic_year_id, origin, based_on_version_id, source_page_id,
           content_hash, import_target_id, created_by
         ) values (
-          ${itemYearId}, ${kind}, ${Number(target.academic_year_id)}, 'import', ${importBaseline},
+          ${recordId}, ${kind}, ${Number(target.academic_year_id)}, 'import', ${importBaseline},
           ${target.source_page_id}, ${merged.contentHash}, ${targetId}::uuid, ${userId}::uuid
         )
         returning id
       `;
       const snapshotId = Number(snapshot.id);
-      await insertSnapshotContent(tx, {
+      await insertVersionContent(tx, {
         snapshotId,
         kind,
         academicYearId: Number(target.academic_year_id),
@@ -152,14 +164,16 @@ export async function applyImportReview({
         write: merged,
       });
       await tx`
-        update public.catalogue_item_years set draft_snapshot_id = ${snapshotId} where id = ${itemYearId}
+        update public.catalogue_versions
+        set sealed_at = greatest(statement_timestamp(), created_at)
+        where id = ${snapshotId}
       `;
       await tx`
         update public.catalogue_import_targets
-        set applied_snapshot_id = ${snapshotId}, applied_at = now()
+        set applied_version_id = ${snapshotId}, applied_at = now()
         where id = ${targetId}::uuid
       `;
-      return { draftSnapshotId: snapshotId, reusedCandidate: false };
+      return { versionId: snapshotId, reusedCandidate: false };
     });
   return sql ? work(sql) : withImportDatabaseClient(work);
 }
diff --git a/apps/web/lib/catalogue-import/changes.ts b/apps/web/lib/catalogue-import/changes.ts
index a53e1375..47f15df5 100644
--- a/apps/web/lib/catalogue-import/changes.ts
+++ b/apps/web/lib/catalogue-import/changes.ts
@@ -1,11 +1,11 @@
 import { stableStringify } from "./canonical.ts";
 import { fieldLabel } from "../coursemap/catalogue-kinds.ts";
 import type {
-  CatalogueSnapshotWrite,
+  CatalogueContent,
+  CatalogueContentFlag,
   RequirementRuleKind,
   RequirementWrite,
-  SnapshotFlagWrite,
-} from "./snapshot-write.ts";
+} from "../catalogue/content.ts";
 
 export type SnapshotChange = {
   fieldPath: string;
@@ -85,8 +85,8 @@ export function requirementRuleSlice(
  * decision replaces the section rather than merging arrays item by item.
  */
 export function diffSnapshotWrites(
-  baseline: CatalogueSnapshotWrite | null,
-  candidate: CatalogueSnapshotWrite,
+  baseline: CatalogueContent | null,
+  candidate: CatalogueContent,
 ): SnapshotChange[] {
   const changes: SnapshotChange[] = [];
   const evidenceFor = (fieldPath: string) => {
@@ -156,7 +156,7 @@ export function diffSnapshotWrites(
 }
 
 /** Errors block publication; warnings inform. */
-export function isBlockingFlag(flag: SnapshotFlagWrite) {
+export function isBlockingFlag(flag: CatalogueContentFlag) {
   return flag.severity === "error";
 }
 
@@ -168,11 +168,11 @@ type Section = Record<string, unknown>;
  * replace the whole rule slice.
  */
 export function applyAcceptedChanges(
-  baseline: CatalogueSnapshotWrite,
-  candidate: CatalogueSnapshotWrite,
+  baseline: CatalogueContent,
+  candidate: CatalogueContent,
   acceptedPaths: ReadonlySet<string>,
-): CatalogueSnapshotWrite {
-  const result: CatalogueSnapshotWrite = structuredClone(baseline);
+): CatalogueContent {
+  const result: CatalogueContent = structuredClone(baseline);
   result.evidence = candidate.evidence;
   result.flags = candidate.flags;
   const replacedRules = new Set<RequirementRuleKind>();
diff --git a/apps/web/lib/catalogue-import/directory.ts b/apps/web/lib/catalogue-import/directory.ts
index 743c6b27..c24e90c4 100644
--- a/apps/web/lib/catalogue-import/directory.ts
+++ b/apps/web/lib/catalogue-import/directory.ts
@@ -7,7 +7,7 @@ import {
   withImportDatabaseClient,
 } from "./import-store.ts";
 import type { AcademicStructureKind } from "./kinds/structure/contract.ts";
-import { type CatalogueKind, isCatalogueKind } from "./snapshot-write.ts";
+import { type CatalogueKind, isCatalogueKind } from "../catalogue/content.ts";
 
 export type DirectoryRefreshProgress = {
   phase: "fetching" | "saving" | "done";
@@ -140,11 +140,11 @@ async function saveDirectory(
   // Entries that already have an identity keep it linked.
   await tx`
     update public.catalogue_directory_entries as entries
-    set item_id = items.id
-    from public.catalogue_items as items
+    set code_id = items.id
+    from public.catalogue_codes as items
     where entries.academic_year_id = ${academicYearId}
       and entries.kind = ${kind}
-      and entries.item_id is null
+      and entries.code_id is null
       and items.kind = entries.kind
       and items.code = entries.code
   `;
diff --git a/apps/web/lib/catalogue-import/import-store.ts b/apps/web/lib/catalogue-import/import-store.ts
index e59a7be3..661c9256 100644
--- a/apps/web/lib/catalogue-import/import-store.ts
+++ b/apps/web/lib/catalogue-import/import-store.ts
@@ -8,7 +8,7 @@ import type {
   ImportArtifactLocator,
 } from "./artifact-store.ts";
 import { ANU_PROGRAMS_AND_COURSES_SOURCE } from "./import-source.ts";
-import type { CatalogueKind } from "./snapshot-write.ts";
+import type { CatalogueKind } from "../catalogue/content.ts";
 
 export type ImportStageName =
   | "source_fetch"
@@ -83,9 +83,9 @@ export type ClaimedImportTarget = {
   academicYear: number;
   academicYearId: number;
   itemId: number;
-  itemYearId: number;
+  recordId: number;
   directoryEntryId: number | null;
-  baselineSnapshotId: number | null;
+  baselineVersionId: number | null;
   requestedModel: string;
   parserVersion: string;
   promptVersion: string;
@@ -167,10 +167,10 @@ export async function claimImportTarget(
         targets.code,
         academic_years.year as academic_year,
         targets.academic_year_id,
-        targets.item_id,
-        targets.item_year_id,
+        targets.code_id,
+        targets.record_id,
         targets.directory_entry_id,
-        targets.baseline_snapshot_id,
+        targets.baseline_version_id,
         runs.requested_model,
         runs.parser_version,
         runs.prompt_version,
@@ -188,10 +188,10 @@ export async function claimImportTarget(
       code: String(row.code),
       academicYear: Number(row.academic_year),
       academicYearId: Number(row.academic_year_id),
-      itemId: Number(row.item_id),
-      itemYearId: Number(row.item_year_id),
+      itemId: Number(row.code_id),
+      recordId: Number(row.record_id),
       directoryEntryId: numberOrNull(row.directory_entry_id),
-      baselineSnapshotId: numberOrNull(row.baseline_snapshot_id),
+      baselineVersionId: numberOrNull(row.baseline_version_id),
       requestedModel: String(row.requested_model),
       parserVersion: String(row.parser_version),
       promptVersion: String(row.prompt_version),
@@ -568,7 +568,7 @@ export async function finishImportTarget(
     status,
     changeKind,
     sourcePageId,
-    candidateSnapshotId,
+    candidateVersionId,
     errorCode = null,
     errorMessage = null,
   }: {
@@ -579,7 +579,7 @@ export async function finishImportTarget(
     status: "ready" | "unchanged" | "failed";
     changeKind: "new" | "changed" | "unchanged" | null;
     sourcePageId: number | null;
-    candidateSnapshotId: number | null;
+    candidateVersionId: number | null;
     errorCode?: string | null;
     errorMessage?: string | null;
   },
@@ -590,7 +590,7 @@ export async function finishImportTarget(
       set status = ${status},
           change_kind = ${changeKind},
           source_page_id = ${sourcePageId},
-          candidate_snapshot_id = ${candidateSnapshotId},
+          candidate_version_id = ${candidateVersionId},
           error_code = ${errorCode},
           error_message = ${errorMessage},
           worker_id = null,
diff --git a/apps/web/lib/catalogue-import/kind-adapter.ts b/apps/web/lib/catalogue-import/kind-adapter.ts
index 23e0ea89..1099b90c 100644
--- a/apps/web/lib/catalogue-import/kind-adapter.ts
+++ b/apps/web/lib/catalogue-import/kind-adapter.ts
@@ -1,8 +1,5 @@
 import type { ClaimedImportTarget } from "./import-store.ts";
-import type {
-  CatalogueKind,
-  CatalogueSnapshotWrite,
-} from "./snapshot-write.ts";
+import type { CatalogueKind, CatalogueContent } from "../catalogue/content.ts";
 
 export type FetchedSourcePage = {
   sourceUrl: string;
@@ -86,5 +83,5 @@ export type CatalogueKindAdapter<Extraction = unknown> = {
     /** The provider's stop reason; `length` means the response was truncated. */
     finishReason: string | null;
   }): MergeOutcome<Extraction>;
-  project(extraction: Extraction): CatalogueSnapshotWrite;
+  project(extraction: Extraction): CatalogueContent;
 };
diff --git a/apps/web/lib/catalogue-import/kinds/course/adapter.ts b/apps/web/lib/catalogue-import/kinds/course/adapter.ts
index fc1a312f..231178ce 100644
--- a/apps/web/lib/catalogue-import/kinds/course/adapter.ts
+++ b/apps/web/lib/catalogue-import/kinds/course/adapter.ts
@@ -1,5 +1,5 @@
 import type { CatalogueKindAdapter } from "../../kind-adapter.ts";
-import { courseSnapshotWrite } from "../../snapshot-write.ts";
+import { courseCatalogueContent } from "../../../catalogue/content.ts";
 import {
   COURSE_EXTRACTION_JSON_SCHEMA,
   type CourseExtraction,
@@ -130,7 +130,7 @@ export const courseKindAdapter: CatalogueKindAdapter<CourseExtraction> = {
     };
   },
   project(extraction) {
-    return courseSnapshotWrite({
+    return courseCatalogueContent({
       projection: projectCourseSnapshot(extraction),
       evidence: extraction.evidence.map((item) => ({
         fieldPath: item.fieldKey,
diff --git a/apps/web/lib/catalogue-import/kinds/structure/adapter.ts b/apps/web/lib/catalogue-import/kinds/structure/adapter.ts
index c13041f7..62baccf4 100644
--- a/apps/web/lib/catalogue-import/kinds/structure/adapter.ts
+++ b/apps/web/lib/catalogue-import/kinds/structure/adapter.ts
@@ -1,5 +1,5 @@
 import type { CatalogueKindAdapter } from "../../kind-adapter.ts";
-import { structureSnapshotWrite } from "../../snapshot-write.ts";
+import { structureCatalogueContent } from "../../../catalogue/content.ts";
 import {
   ACADEMIC_STRUCTURE_EXTRACTION_JSON_SCHEMA,
   type AcademicStructureExtraction,
@@ -200,7 +200,7 @@ export const structureKindAdapter: CatalogueKindAdapter<AcademicStructureExtract
       };
     },
     project(extraction) {
-      return structureSnapshotWrite({
+      return structureCatalogueContent({
         projection: projectAcademicStructureSnapshot(extraction),
         evidence: extraction.evidence.map((item) => ({
           fieldPath: item.fieldKey,
diff --git a/apps/web/lib/catalogue-import/manual-snapshot.ts b/apps/web/lib/catalogue-import/manual-version.ts
similarity index 55%
rename from apps/web/lib/catalogue-import/manual-snapshot.ts
rename to apps/web/lib/catalogue-import/manual-version.ts
index c9470341..a68fd8d7 100644
--- a/apps/web/lib/catalogue-import/manual-snapshot.ts
+++ b/apps/web/lib/catalogue-import/manual-version.ts
@@ -1,8 +1,11 @@
 import { diffSnapshotWrites } from "./changes.ts";
 import { type ImportSql, withImportDatabaseClient } from "./import-store.ts";
-import { insertSnapshotContent } from "./persist-snapshot.ts";
-import { contentHashForWrite, readSnapshotWrite } from "./snapshot-read.ts";
-import type { CatalogueSnapshotWrite } from "./snapshot-write.ts";
+import { insertVersionContent } from "./persist-version.ts";
+import {
+  contentHashForCatalogueContent,
+  readVersionContent,
+} from "./version-content.ts";
+import type { CatalogueContent } from "../catalogue/content.ts";
 
 export class ManualSnapshotError extends Error {
   readonly code: string;
@@ -15,32 +18,47 @@ export class ManualSnapshotError extends Error {
 }
 
 /**
- * Saves an edited write as a new manual draft based on the snapshot the
+ * Saves edited content as a new manual version based on the version the
  * editor started from. Open review changes on the edited fields close as
  * rejected, since the administrator has decided the value directly.
  */
-export async function saveManualSnapshot({
-  itemYearId,
+export async function saveManualVersion({
+  recordId,
   baseSnapshotId,
   write,
   userId,
   sql,
 }: {
-  itemYearId: number;
+  recordId: number;
   baseSnapshotId: number | null;
-  write: CatalogueSnapshotWrite;
+  write: CatalogueContent;
   userId: string;
   sql?: ImportSql;
 }) {
   const work = async (client: ImportSql) =>
     client.begin(async (tx) => {
       const [itemYear] = await tx`
-        select item_years.id, item_years.kind, item_years.academic_year_id, item_years.draft_snapshot_id,
-          item_years.published_snapshot_id, item_years.archived_at, items.code, academic_years.year
-        from public.catalogue_item_years as item_years
-        join public.catalogue_items as items on items.id = item_years.item_id
+        select item_years.id, item_years.kind, item_years.academic_year_id,
+          item_years.archived_at, items.code, academic_years.year,
+          current_version.id as current_version_id
+        from public.catalogue_records as item_years
+        join public.catalogue_codes as items on items.id = item_years.code_id
         join public.academic_years on academic_years.id = item_years.academic_year_id
-        where item_years.id = ${itemYearId}
+        left join lateral (
+          select versions.id
+          from public.catalogue_versions as versions
+          left join public.catalogue_import_targets as targets
+            on targets.id = versions.import_target_id
+          where versions.record_id = item_years.id
+            and versions.sealed_at is not null
+            and (
+              versions.import_target_id is null
+              or targets.applied_version_id = versions.id
+            )
+          order by versions.created_at desc, versions.id desc
+          limit 1
+        ) as current_version on true
+        where item_years.id = ${recordId}
         for update of item_years
       `;
       if (!itemYear)
@@ -58,11 +76,9 @@ export async function saveManualSnapshot({
         );
       }
       const currentBase =
-        itemYear.draft_snapshot_id === null
-          ? itemYear.published_snapshot_id === null
-            ? null
-            : Number(itemYear.published_snapshot_id)
-          : Number(itemYear.draft_snapshot_id);
+        itemYear.current_version_id === null
+          ? null
+          : Number(itemYear.current_version_id);
       if (currentBase !== baseSnapshotId) {
         throw new ManualSnapshotError(
           "The record changed while you were editing. Reload and apply your changes again.",
@@ -71,10 +87,13 @@ export async function saveManualSnapshot({
       }
 
       const baseWrite = baseSnapshotId
-        ? await readSnapshotWrite(tx, baseSnapshotId)
+        ? await readVersionContent(tx, baseSnapshotId)
         : null;
-      const contentHash = contentHashForWrite(write);
-      if (baseWrite && contentHashForWrite(baseWrite) === contentHash) {
+      const contentHash = contentHashForCatalogueContent(write);
+      if (
+        baseWrite &&
+        contentHashForCatalogueContent(baseWrite) === contentHash
+      ) {
         return {
           snapshotId: baseSnapshotId!,
           unchanged: true,
@@ -86,15 +105,15 @@ export async function saveManualSnapshot({
       );
 
       const [snapshot] = await tx`
-        insert into public.catalogue_snapshots (
-          item_year_id, kind, academic_year_id, origin, based_on_snapshot_id, content_hash, created_by
+        insert into public.catalogue_versions (
+          record_id, kind, academic_year_id, origin, based_on_version_id, content_hash, created_by
         ) values (
-          ${itemYearId}, ${itemYear.kind}, ${itemYear.academic_year_id}, 'manual', ${baseSnapshotId},
+          ${recordId}, ${itemYear.kind}, ${itemYear.academic_year_id}, 'manual', ${baseSnapshotId},
           ${contentHash}, ${userId}::uuid
         ) returning id
       `;
       const snapshotId = Number(snapshot.id);
-      await insertSnapshotContent(tx, {
+      await insertVersionContent(tx, {
         snapshotId,
         kind: write.kind,
         academicYearId: Number(itemYear.academic_year_id),
@@ -108,7 +127,11 @@ export async function saveManualSnapshot({
           })),
         },
       });
-      await tx`update public.catalogue_item_years set draft_snapshot_id = ${snapshotId} where id = ${itemYearId}`;
+      await tx`
+        update public.catalogue_versions
+        set sealed_at = greatest(statement_timestamp(), created_at)
+        where id = ${snapshotId}
+      `;
 
       if (editedPaths.length > 0) {
         await tx`
@@ -117,7 +140,7 @@ export async function saveManualSnapshot({
               resolution_note = 'Superseded by a manual edit.'
           from public.catalogue_import_targets as targets
           where targets.id = changes.target_id
-            and targets.item_year_id = ${itemYearId}
+            and targets.record_id = ${recordId}
             and targets.applied_at is null
             and changes.entry_kind = 'change'
             and changes.status = 'open'
@@ -129,35 +152,49 @@ export async function saveManualSnapshot({
   return sql ? work(sql) : withImportDatabaseClient(work);
 }
 
-/** Makes a historical snapshot the draft again by copying it as a manual snapshot. */
+/** Restores historical content by copying it into a new manual version. */
 export async function restoreSnapshot({
-  itemYearId,
+  recordId,
   snapshotId,
   userId,
   sql,
 }: {
-  itemYearId: number;
+  recordId: number;
   snapshotId: number;
   userId: string;
   sql?: ImportSql;
 }) {
   const work = async (client: ImportSql) => {
-    const write = await readSnapshotWrite(client, snapshotId);
+    const write = await readVersionContent(client, snapshotId);
     if (!write)
       throw new ManualSnapshotError("The snapshot does not exist.", "P0002");
     const [itemYear] = await client`
-      select draft_snapshot_id, published_snapshot_id from public.catalogue_item_years where id = ${itemYearId}
+      select versions.id as current_version_id
+      from public.catalogue_records as records
+      left join lateral (
+        select versions.id
+        from public.catalogue_versions as versions
+        left join public.catalogue_import_targets as targets
+          on targets.id = versions.import_target_id
+        where versions.record_id = records.id
+          and versions.sealed_at is not null
+          and (
+            versions.import_target_id is null
+            or targets.applied_version_id = versions.id
+          )
+        order by versions.created_at desc, versions.id desc
+        limit 1
+      ) as versions on true
+      where records.id = ${recordId}
     `;
     if (!itemYear)
       throw new ManualSnapshotError("The record does not exist.", "P0002");
     const baseSnapshotId =
-      itemYear.draft_snapshot_id === null
-        ? itemYear.published_snapshot_id === null
-          ? null
-          : Number(itemYear.published_snapshot_id)
-        : Number(itemYear.draft_snapshot_id);
-    return saveManualSnapshot({
-      itemYearId,
+      itemYear.current_version_id === null
+        ? null
+        : Number(itemYear.current_version_id);
+    return saveManualVersion({
+      recordId,
       baseSnapshotId,
       write,
       userId,
diff --git a/apps/web/lib/catalogue-import/persist-snapshot.ts b/apps/web/lib/catalogue-import/persist-version.ts
similarity index 79%
rename from apps/web/lib/catalogue-import/persist-snapshot.ts
rename to apps/web/lib/catalogue-import/persist-version.ts
index 98ee3652..3ba694d7 100644
--- a/apps/web/lib/catalogue-import/persist-snapshot.ts
+++ b/apps/web/lib/catalogue-import/persist-version.ts
@@ -5,29 +5,29 @@ import {
   type SnapshotChange,
 } from "./changes.ts";
 import type { ClaimedImportTarget, ImportSql } from "./import-store.ts";
-import { readSnapshotWrite } from "./snapshot-read.ts";
+import { readVersionContent } from "./version-content.ts";
 import type {
   CatalogueKind,
-  CatalogueSnapshotWrite,
+  CatalogueContent,
   RequirementWrite,
-} from "./snapshot-write.ts";
+} from "../catalogue/content.ts";
 
 export type SnapshotChangeKind = "new" | "changed" | "unchanged";
 
 export type PersistedSnapshotCandidate = {
   changeKind: SnapshotChangeKind;
-  candidateSnapshotId: number | null;
-  baselineSnapshotId: number | null;
+  candidateVersionId: number | null;
+  baselineVersionId: number | null;
   becameDraft: boolean;
   changeSet: {
     changeKind: SnapshotChangeKind;
     contentHash: string;
-    baselineSnapshotId: number | null;
+    baselineVersionId: number | null;
     baselineContentHash: string | null;
-    candidateSnapshotId: number | null;
+    candidateVersionId: number | null;
     becameDraft: boolean;
     changes: SnapshotChange[];
-    flags: CatalogueSnapshotWrite["flags"];
+    flags: CatalogueContent["flags"];
   };
 };
 
@@ -43,7 +43,7 @@ function isValidCode(kind: CatalogueKind, code: string) {
 }
 
 /** Every catalogue code the write refers to, so placeholder identities exist. */
-function referencedItems(write: CatalogueSnapshotWrite) {
+function referencedItems(write: CatalogueContent) {
   const items = new Map<string, { kind: CatalogueKind; code: string }>();
   const add = (kind: CatalogueKind | null, code: string | null) => {
     if (!kind || !code) return;
@@ -72,12 +72,12 @@ async function ensureItemIds(
   const ids = new Map<string, number>();
   for (const item of items) {
     await tx`
-      insert into public.catalogue_items (kind, code)
+      insert into public.catalogue_codes (kind, code)
       values (${item.kind}, ${item.code})
       on conflict (kind, code) do nothing
     `;
     const [row] = await tx`
-      select id from public.catalogue_items where kind = ${item.kind} and code = ${item.code}
+      select id from public.catalogue_codes where kind = ${item.kind} and code = ${item.code}
     `;
     ids.set(`${item.kind}:${item.code}`, Number(row.id));
   }
@@ -99,12 +99,12 @@ async function insertCourseContent(
   academicYearId: number,
   sourcePageId: number | null,
   ids: Map<string, number>,
-  content: NonNullable<CatalogueSnapshotWrite["course"]>,
+  content: NonNullable<CatalogueContent["course"]>,
 ) {
   const details = content.details;
   await tx`
-    insert into public.course_snapshot_details (
-      snapshot_id, title, unit_value_kind, units, minimum_units, maximum_units, eftsl,
+    insert into public.course_version_details (
+      version_id, title, unit_value_kind, units, minimum_units, maximum_units, eftsl,
       level, subject_code, subject_name, school, college, academic_career,
       convener_text, delivery_summary, introduction, description, workload_text,
       workload_hours, inherent_requirements, prescribed_texts, offering_status,
@@ -121,14 +121,14 @@ async function insertCourseContent(
   `;
   for (const option of content.unitOptions) {
     await tx`
-      insert into public.course_unit_options (snapshot_id, position, units, label, source_text)
+      insert into public.course_unit_options (version_id, position, units, label, source_text)
       values (${snapshotId}, ${option.position}, ${option.units}, ${option.label}, ${option.sourceText})
     `;
   }
   for (const fee of content.fees) {
     await tx`
       insert into public.course_fees (
-        snapshot_id, position, fee_year, audience, fee_type, amount, currency, basis,
+        version_id, position, fee_year, audience, fee_type, amount, currency, basis,
         student_contribution_band, source_label, source_text
       ) values (
         ${snapshotId}, ${fee.position}, ${fee.feeYear}, ${fee.audience}, ${fee.feeType},
@@ -139,13 +139,13 @@ async function insertCourseContent(
   }
   for (const area of content.areasOfInterest) {
     await tx`
-      insert into public.course_areas_of_interest (snapshot_id, position, name)
+      insert into public.course_areas_of_interest (version_id, position, name)
       values (${snapshotId}, ${area.position}, ${area.name})
     `;
   }
   for (const attribute of content.attributes) {
     await tx`
-      insert into public.course_attributes (snapshot_id, position, attribute_kind, value, source_text)
+      insert into public.course_attributes (version_id, position, attribute_kind, value, source_text)
       values (${snapshotId}, ${attribute.position}, ${attribute.attributeKind}, ${attribute.value}, ${attribute.sourceText})
     `;
   }
@@ -154,7 +154,7 @@ async function insertCourseContent(
     if (relatedId === null) continue;
     await tx`
       insert into public.course_related_courses (
-        snapshot_id, position, relation_kind, related_course_id, source_course_code,
+        version_id, position, relation_kind, related_course_id, source_course_code,
         source_course_title, source_text
       ) values (
         ${snapshotId}, ${related.position}, ${related.relationKind}, ${relatedId},
@@ -163,7 +163,7 @@ async function insertCourseContent(
     `;
   }
   const [offering] = await tx`
-    insert into public.course_offerings (snapshot_id, academic_year_id, source_page_id, delivery_mode, location)
+    insert into public.course_offerings (version_id, academic_year_id, source_page_id, delivery_mode, location)
     values (
       ${snapshotId}, ${academicYearId}, ${sourcePageId},
       ${content.offering?.deliveryMode ?? null}, ${content.offering?.location ?? null}
@@ -173,7 +173,7 @@ async function insertCourseContent(
   for (const session of content.sessions) {
     await tx`
       insert into public.offering_sessions (
-        course_offering_id, snapshot_id, academic_year_id, source_page_id,
+        course_offering_id, version_id, academic_year_id, source_page_id,
         academic_period_id, academic_period_code, academic_period_name, position,
         class_number, starts_on, enrol_closes_on, census_on, ends_on, delivery_mode,
         location, class_summary_url, source_text
@@ -194,7 +194,7 @@ async function insertCourseContent(
   const outcomeIds = new Map<number, number>();
   for (const outcome of content.learningOutcomes) {
     const [row] = await tx`
-      insert into public.course_learning_outcomes (snapshot_id, position, body)
+      insert into public.course_learning_outcomes (version_id, position, body)
       values (${snapshotId}, ${outcome.position}, ${outcome.body})
       returning id
     `;
@@ -204,7 +204,7 @@ async function insertCourseContent(
   for (const item of content.assessmentItems) {
     const [row] = await tx`
       insert into public.course_assessment_items (
-        snapshot_id, position, title, weight, hurdle, due_text, source_text
+        version_id, position, title, weight, hurdle, due_text, source_text
       ) values (
         ${snapshotId}, ${item.position}, ${item.title}, ${item.weight}, ${item.hurdle},
         ${item.dueText}, ${item.sourceText}
@@ -218,7 +218,7 @@ async function insertCourseContent(
     const outcomeId = outcomeIds.get(link.learningOutcomePosition);
     if (!assessmentId || !outcomeId) continue;
     await tx`
-      insert into public.course_assessment_outcomes (snapshot_id, assessment_item_id, learning_outcome_id)
+      insert into public.course_assessment_outcomes (version_id, assessment_item_id, learning_outcome_id)
       values (${snapshotId}, ${assessmentId}, ${outcomeId})
       on conflict do nothing
     `;
@@ -229,12 +229,12 @@ async function insertStructureContent(
   tx: Tx,
   snapshotId: number,
   kind: CatalogueKind,
-  content: NonNullable<CatalogueSnapshotWrite["structure"]>,
+  content: NonNullable<CatalogueContent["structure"]>,
 ) {
   const details = content.details;
   await tx`
-    insert into public.structure_snapshot_details (
-      snapshot_id, kind, name, acronym, short_name, introduction, description, units,
+    insert into public.structure_version_details (
+      version_id, kind, name, acronym, short_name, introduction, description, units,
       duration_years, academic_career, college, mode_of_delivery, selection_rank, atar,
       can_combine, can_combine_vertical, study_as, contact_text
     ) values (
@@ -249,7 +249,7 @@ async function insertStructureContent(
   for (const field of content.summaryFields) {
     await tx`
       insert into public.structure_snapshot_summary_fields (
-        snapshot_id, position, value_position, field_key, label, field_value, source_text
+        version_id, position, value_position, field_key, label, field_value, source_text
       ) values (
         ${snapshotId}, ${field.position}, ${field.valuePosition}, ${field.fieldKey},
         ${field.label}, ${field.fieldValue}, ${field.sourceText}
@@ -259,7 +259,7 @@ async function insertStructureContent(
   for (const section of content.sections) {
     await tx`
       insert into public.academic_structure_snapshot_sections (
-        snapshot_id, section_key, heading, markdown, source_text, source_locator, position
+        version_id, section_key, heading, markdown, source_text, source_locator, position
       ) values (
         ${snapshotId}, ${section.sectionKey}, ${section.heading}, ${section.markdown},
         ${section.sourceText}, ${section.sourceLocator}, ${section.position}
@@ -269,7 +269,7 @@ async function insertStructureContent(
   for (const outcome of content.learningOutcomes) {
     await tx`
       insert into public.academic_structure_learning_outcomes (
-        snapshot_id, position, outcome_text, source_text, source_locator
+        version_id, position, outcome_text, source_text, source_locator
       ) values (
         ${snapshotId}, ${outcome.position}, ${outcome.outcomeText}, ${outcome.sourceText},
         ${outcome.sourceLocator}
@@ -279,7 +279,7 @@ async function insertStructureContent(
   for (const fee of content.fees) {
     await tx`
       insert into public.academic_structure_fees (
-        snapshot_id, position, fee_year, audience, fee_type, amount, currency, basis,
+        version_id, position, fee_year, audience, fee_type, amount, currency, basis,
         source_label, source_text, source_locator
       ) values (
         ${snapshotId}, ${fee.position}, ${fee.feeYear}, ${fee.audience}, ${fee.feeType},
@@ -291,7 +291,7 @@ async function insertStructureContent(
   for (const relationship of content.relationships) {
     await tx`
       insert into public.academic_structure_snapshot_relationships (
-        snapshot_id, position, relationship_kind, target_kind, target_code, target_title,
+        version_id, position, relationship_kind, target_kind, target_code, target_title,
         source_text, source_locator
       ) values (
         ${snapshotId}, ${relationship.position}, ${relationship.relationshipKind},
@@ -314,7 +314,7 @@ async function insertRequirements(
   for (const rule of requirements.rules) {
     const [row] = await tx`
       insert into public.requirement_rules (
-        snapshot_id, academic_year_id, source_page_id, rule_kind, hardness, source_text,
+        version_id, academic_year_id, source_page_id, rule_kind, hardness, source_text,
         source_locator, review_state, confidence, position
       ) values (
         ${snapshotId}, ${academicYearId}, ${sourcePageId}, ${rule.key}, ${rule.hardness},
@@ -343,7 +343,7 @@ async function insertRequirements(
       }
       const [row] = await tx`
         insert into public.requirement_groups (
-          rule_id, snapshot_id, parent_group_id, group_key, label, description, operator,
+          rule_id, version_id, parent_group_id, group_key, label, description, operator,
           minimum_count, minimum_units, maximum_units, source_text, source_locator, position
         ) values (
           ${ruleId}, ${snapshotId},
@@ -368,12 +368,12 @@ async function insertRequirements(
         `Requirement condition ${condition.key} has no group.`,
       );
     }
-    // item_kind travels with item_id so the composite foreign key can hold the
+    // item_kind travels with code_id so the composite foreign key can hold the
     // referenced item to the kind the condition expects.
     const conditionItemId = itemId(ids, condition.itemKind, condition.itemCode);
     const [row] = await tx`
       insert into public.requirement_conditions (
-        rule_id, snapshot_id, group_id, condition_key, position, condition_kind, item_id,
+        rule_id, version_id, group_id, condition_key, position, condition_kind, code_id,
         item_kind, structure_kind, requirement_mode, minimum_mark, minimum_units, maximum_units,
         minimum_count, subject_code, minimum_level, maximum_level, minimum_year,
         minimum_gpa, minimum_wam, tag, free_text, hardness, source_text, source_locator,
@@ -402,7 +402,7 @@ async function insertRequirements(
     if (!isValidCode(option.kind, code)) continue;
     await tx`
       insert into public.requirement_condition_options (
-        condition_id, snapshot_id, position, kind, code, item_id, title, source_text
+        condition_id, version_id, position, kind, code, code_id, title, source_text
       ) values (
         ${conditionId}, ${snapshotId}, ${option.position}, ${option.kind}, ${code},
         ${itemId(ids, option.kind, code)}, ${option.title}, ${option.sourceText}
@@ -417,18 +417,18 @@ async function insertRequirements(
     if (ruleId === undefined || referencedId === null) continue;
     await tx`
       insert into public.requirement_item_references (
-        rule_id, snapshot_id, item_id, source_text, confidence, review_state
+        rule_id, version_id, code_id, source_text, confidence, review_state
       ) values (
         ${ruleId}, ${snapshotId}, ${referencedId}, ${reference.sourceText},
         ${reference.confidence}, ${reference.reviewState}
       )
-      on conflict (rule_id, item_id) do nothing
+      on conflict (rule_id, code_id) do nothing
     `;
   }
 }
 
 /** Writes every content, requirement and evidence row for a new snapshot. */
-export async function insertSnapshotContent(
+export async function insertVersionContent(
   tx: Tx,
   {
     snapshotId,
@@ -441,7 +441,7 @@ export async function insertSnapshotContent(
     kind: CatalogueKind;
     academicYearId: number;
     sourcePageId: number | null;
-    write: CatalogueSnapshotWrite;
+    write: CatalogueContent;
   },
 ) {
   const ids = await ensureItemIds(tx, referencedItems(write));
@@ -468,8 +468,8 @@ export async function insertSnapshotContent(
   );
   for (const evidence of write.evidence) {
     await tx`
-      insert into public.snapshot_field_evidence (
-        snapshot_id, academic_year_id, source_page_id, field_path, method, confidence,
+      insert into public.catalogue_version_provenance (
+        version_id, academic_year_id, source_page_id, field_path, method, confidence,
         source_locator, source_excerpt
       ) values (
         ${snapshotId}, ${academicYearId}, ${sourcePageId}, ${evidence.fieldPath},
@@ -491,7 +491,7 @@ export async function insertImportChanges(
   }: {
     targetId: string;
     changes: SnapshotChange[];
-    flags: CatalogueSnapshotWrite["flags"];
+    flags: CatalogueContent["flags"];
     acceptAll: boolean;
   },
 ) {
@@ -526,12 +526,12 @@ export async function insertImportChanges(
 }
 
 /**
- * Assembles a candidate snapshot for an import target. Returns `unchanged`
+ * Assembles a candidate version for an import target. Returns `unchanged`
  * without writing when the content hash matches the baseline. A first import
- * for an item year becomes its draft immediately with every change accepted;
+ * for a record becomes its applied version immediately with every change accepted;
  * otherwise the changes stay open for review.
  */
-export async function persistSnapshotCandidate(
+export async function persistVersionCandidate(
   sql: ImportSql,
   {
     claim,
@@ -540,7 +540,7 @@ export async function persistSnapshotCandidate(
   }: {
     claim: ClaimedImportTarget;
     sourcePageId: number | null;
-    write: CatalogueSnapshotWrite;
+    write: CatalogueContent;
   },
 ): Promise<PersistedSnapshotCandidate> {
   if (
@@ -555,23 +555,15 @@ export async function persistSnapshotCandidate(
 
   return sql.begin(async (tx) => {
     const [itemYear] = await tx`
-      select id, draft_snapshot_id, published_snapshot_id
-      from public.catalogue_item_years
-      where id = ${claim.itemYearId}
+      select id
+      from public.catalogue_records
+      where id = ${claim.recordId}
       for update
     `;
     if (!itemYear) throw new Error("The catalogue item year was not resolved.");
-    const draftId =
-      itemYear.draft_snapshot_id === null
-        ? null
-        : Number(itemYear.draft_snapshot_id);
-    const publishedId =
-      itemYear.published_snapshot_id === null
-        ? null
-        : Number(itemYear.published_snapshot_id);
-    const baselineSnapshotId = draftId ?? publishedId;
-    const [baseline] = baselineSnapshotId
-      ? await tx`select content_hash from public.catalogue_snapshots where id = ${baselineSnapshotId}`
+    const baselineVersionId = claim.baselineVersionId;
+    const [baseline] = baselineVersionId
+      ? await tx`select content_hash from public.catalogue_versions where id = ${baselineVersionId}`
       : [];
     const baselineContentHash = baseline ? String(baseline.content_hash) : null;
 
@@ -584,15 +576,15 @@ export async function persistSnapshotCandidate(
       });
       return {
         changeKind: "unchanged" as const,
-        candidateSnapshotId: null,
-        baselineSnapshotId,
+        candidateVersionId: null,
+        baselineVersionId,
         becameDraft: false,
         changeSet: {
           changeKind: "unchanged" as const,
           contentHash: write.contentHash,
-          baselineSnapshotId,
+          baselineVersionId,
           baselineContentHash,
-          candidateSnapshotId: null,
+          candidateVersionId: null,
           becameDraft: false,
           changes: [],
           flags: write.flags,
@@ -600,38 +592,43 @@ export async function persistSnapshotCandidate(
       };
     }
 
-    const baselineWrite = baselineSnapshotId
-      ? await readSnapshotWrite(tx, baselineSnapshotId)
+    const baselineWrite = baselineVersionId
+      ? await readVersionContent(tx, baselineVersionId)
       : null;
     const changes = diffSnapshotWrites(baselineWrite, write);
     if (claim.directoryEntryId !== null) {
       await tx`
         update public.catalogue_directory_entries
-        set item_id = ${claim.itemId}
-        where id = ${claim.directoryEntryId} and item_id is null
+        set code_id = ${claim.itemId}
+        where id = ${claim.directoryEntryId} and code_id is null
       `;
     }
 
     const [snapshot] = await tx`
-      insert into public.catalogue_snapshots (
-        item_year_id, kind, academic_year_id, origin, based_on_snapshot_id, source_page_id,
+      insert into public.catalogue_versions (
+        record_id, kind, academic_year_id, origin, based_on_version_id, source_page_id,
         content_hash, import_target_id
       ) values (
-        ${claim.itemYearId}, ${claim.kind}, ${claim.academicYearId}, 'import',
-        ${baselineSnapshotId}, ${sourcePageId}, ${write.contentHash}, ${claim.targetId}::uuid
+        ${claim.recordId}, ${claim.kind}, ${claim.academicYearId}, 'import',
+        ${baselineVersionId}, ${sourcePageId}, ${write.contentHash}, ${claim.targetId}::uuid
       )
       returning id
     `;
     const snapshotId = Number(snapshot.id);
-    await insertSnapshotContent(tx, {
+    await insertVersionContent(tx, {
       snapshotId,
       kind: claim.kind,
       academicYearId: claim.academicYearId,
       sourcePageId,
       write,
     });
+    await tx`
+      update public.catalogue_versions
+      set sealed_at = greatest(statement_timestamp(), created_at)
+      where id = ${snapshotId}
+    `;
 
-    const becameDraft = baselineSnapshotId === null;
+    const becameDraft = baselineVersionId === null;
     await insertImportChanges(tx, {
       targetId: claim.targetId,
       changes,
@@ -639,34 +636,29 @@ export async function persistSnapshotCandidate(
       acceptAll: becameDraft,
     });
     if (becameDraft) {
-      await tx`
-        update public.catalogue_item_years
-        set draft_snapshot_id = ${snapshotId}
-        where id = ${claim.itemYearId}
-      `;
       // A first import has nothing to compare against, so its changes are
-      // recorded as already accepted and the candidate becomes the draft
+      // recorded as already accepted and the candidate becomes the applied version
       // without anyone pressing Apply. Recording that here keeps the target
-      // honest: it was applied, and leaving applied_snapshot_id null made a
+      // honest: it was applied, and leaving applied_version_id null made a
       // published record still read "Ready for review".
       await tx`
         update public.catalogue_import_targets
-        set applied_snapshot_id = ${snapshotId}, applied_at = now()
+        set applied_version_id = ${snapshotId}, applied_at = now()
         where id = ${claim.targetId}::uuid
       `;
     }
     const changeKind: SnapshotChangeKind = becameDraft ? "new" : "changed";
     return {
       changeKind,
-      candidateSnapshotId: snapshotId,
-      baselineSnapshotId,
+      candidateVersionId: snapshotId,
+      baselineVersionId,
       becameDraft,
       changeSet: {
         changeKind,
         contentHash: write.contentHash,
-        baselineSnapshotId,
+        baselineVersionId,
         baselineContentHash,
-        candidateSnapshotId: snapshotId,
+        candidateVersionId: snapshotId,
         becameDraft,
         changes,
         flags: write.flags,
diff --git a/apps/web/lib/catalogue-import/process-target.ts b/apps/web/lib/catalogue-import/process-target.ts
index f3e8f7ad..034ae274 100644
--- a/apps/web/lib/catalogue-import/process-target.ts
+++ b/apps/web/lib/catalogue-import/process-target.ts
@@ -35,8 +35,8 @@ import {
   extractWithOpenRouter,
   restoreOpenRouterExtraction,
 } from "./openrouter.ts";
-import { persistSnapshotCandidate } from "./persist-snapshot.ts";
-import type { CatalogueKind } from "./snapshot-write.ts";
+import { persistVersionCandidate } from "./persist-version.ts";
+import type { CatalogueKind } from "../catalogue/content.ts";
 
 const TERMINAL_TARGET_STATUSES = new Set([
   "ready",
@@ -550,7 +550,7 @@ async function processClaimedTarget({
     });
 
     const persisted = await runStage("snapshot_persist", async (stageId) => {
-      const result = await persistSnapshotCandidate(sql, {
+      const result = await persistVersionCandidate(sql, {
         claim,
         sourcePageId,
         write,
@@ -573,7 +573,7 @@ async function processClaimedTarget({
       status: persisted.changeKind === "unchanged" ? "unchanged" : "ready",
       changeKind: persisted.changeKind,
       sourcePageId,
-      candidateSnapshotId: persisted.candidateSnapshotId,
+      candidateVersionId: persisted.candidateVersionId,
       // Discarding the model extraction used to be silent: the target ended
       // `ready` with no error code, and only catalogue_extractions recorded
       // it. The blocking flag the merge emitted holds publication; this says
@@ -607,7 +607,7 @@ async function processClaimedTarget({
       status: "failed",
       changeKind: null,
       sourcePageId,
-      candidateSnapshotId: null,
+      candidateVersionId: null,
       errorCode: code,
       errorMessage: summary,
     });
diff --git a/apps/web/lib/catalogue-import/requirement-tree.ts b/apps/web/lib/catalogue-import/requirement-tree.ts
index 5ef9dca1..e2773c48 100644
--- a/apps/web/lib/catalogue-import/requirement-tree.ts
+++ b/apps/web/lib/catalogue-import/requirement-tree.ts
@@ -7,7 +7,7 @@ import type {
   CatalogueKind,
   RequirementRuleKind,
   RequirementWrite,
-} from "./snapshot-write.ts";
+} from "../catalogue/content.ts";
 
 /** Condition kinds the drag-and-drop editor can represent. */
 const EDITABLE_KINDS = new Set([
diff --git a/apps/web/lib/catalogue-import/snapshot-read.ts b/apps/web/lib/catalogue-import/version-content.ts
similarity index 83%
rename from apps/web/lib/catalogue-import/snapshot-read.ts
rename to apps/web/lib/catalogue-import/version-content.ts
index 11496cf4..64aa64a4 100644
--- a/apps/web/lib/catalogue-import/snapshot-read.ts
+++ b/apps/web/lib/catalogue-import/version-content.ts
@@ -3,12 +3,14 @@ import { stableFingerprint } from "./canonical.ts";
 import type { ImportSql, ImportTransactionSql } from "./import-store.ts";
 import type {
   CatalogueKind,
-  CatalogueSnapshotWrite,
+  CatalogueContent,
+  CourseContentWrite,
   RequirementConditionKind,
   RequirementRuleKind,
   RequirementWrite,
   ReviewState,
-} from "./snapshot-write.ts";
+  StructureContentWrite,
+} from "../catalogue/content.ts";
 
 type Sql = ImportSql | ImportTransactionSql | postgres.Sql;
 
@@ -33,7 +35,7 @@ async function readRequirements(
 ): Promise<RequirementWrite> {
   const rules = await sql`
     select id, rule_kind, hardness, source_text, source_locator, review_state, confidence, position
-    from public.requirement_rules where snapshot_id = ${snapshotId} order by position, rule_kind
+    from public.requirement_rules where version_id = ${snapshotId} order by position, rule_kind
   `;
   const ruleKeyById = new Map(
     rules.map((rule) => [
@@ -44,7 +46,7 @@ async function readRequirements(
   const groups = await sql`
     select id, rule_id, parent_group_id, group_key, label, description, operator, minimum_count,
       minimum_units, maximum_units, source_text, source_locator, position
-    from public.requirement_groups where snapshot_id = ${snapshotId} order by rule_id, position, id
+    from public.requirement_groups where version_id = ${snapshotId} order by rule_id, position, id
   `;
   const groupKeyById = new Map(
     groups.map((group) => [Number(group.id), String(group.group_key)]),
@@ -52,8 +54,8 @@ async function readRequirements(
   const conditions = await sql`
     select conditions.*, items.code as item_code, items.kind as item_kind
     from public.requirement_conditions as conditions
-    left join public.catalogue_items as items on items.id = conditions.item_id
-    where conditions.snapshot_id = ${snapshotId}
+    left join public.catalogue_codes as items on items.id = conditions.code_id
+    where conditions.version_id = ${snapshotId}
     order by conditions.rule_id, conditions.position, conditions.id
   `;
   const conditionKeyById = new Map(
@@ -64,15 +66,15 @@ async function readRequirements(
   );
   const options = await sql`
     select condition_id, position, kind, code, title, source_text
-    from public.requirement_condition_options where snapshot_id = ${snapshotId}
+    from public.requirement_condition_options where version_id = ${snapshotId}
     order by condition_id, position
   `;
   const references = await sql`
     select item_references.rule_id, items.code, item_references.source_text,
       item_references.confidence, item_references.review_state
     from public.requirement_item_references as item_references
-    join public.catalogue_items as items on items.id = item_references.item_id
-    where item_references.snapshot_id = ${snapshotId}
+    join public.catalogue_codes as items on items.id = item_references.code_id
+    where item_references.version_id = ${snapshotId}
     order by item_references.rule_id, items.code
   `;
   return {
@@ -153,9 +155,9 @@ async function readRequirements(
 async function readCourseContent(
   sql: Sql,
   snapshotId: number,
-): Promise<CatalogueSnapshotWrite["course"]> {
+): Promise<CourseContentWrite | null> {
   const [details] = await sql`
-    select * from public.course_snapshot_details where snapshot_id = ${snapshotId}
+    select * from public.course_version_details where version_id = ${snapshotId}
   `;
   if (!details) return null;
   const [
@@ -170,16 +172,16 @@ async function readCourseContent(
     assessments,
     links,
   ] = await Promise.all([
-    sql`select position, units, label, source_text from public.course_unit_options where snapshot_id = ${snapshotId} order by position`,
-    sql`select * from public.course_fees where snapshot_id = ${snapshotId} order by position`,
-    sql`select position, name from public.course_areas_of_interest where snapshot_id = ${snapshotId} order by position`,
-    sql`select position, attribute_kind, value, source_text from public.course_attributes where snapshot_id = ${snapshotId} order by position`,
-    sql`select position, relation_kind, source_course_code, source_course_title, source_text from public.course_related_courses where snapshot_id = ${snapshotId} order by position`,
-    sql`select delivery_mode, location from public.course_offerings where snapshot_id = ${snapshotId} limit 1`,
-    sql`select sessions.*, academic_years.year as calendar_year from public.offering_sessions as sessions join public.academic_years on academic_years.id = sessions.academic_year_id where sessions.snapshot_id = ${snapshotId} order by sessions.position`,
-    sql`select id, position, body from public.course_learning_outcomes where snapshot_id = ${snapshotId} order by position`,
-    sql`select id, position, title, weight, hurdle, due_text, source_text from public.course_assessment_items where snapshot_id = ${snapshotId} order by position`,
-    sql`select assessment_item_id, learning_outcome_id from public.course_assessment_outcomes where snapshot_id = ${snapshotId}`,
+    sql`select position, units, label, source_text from public.course_unit_options where version_id = ${snapshotId} order by position`,
+    sql`select * from public.course_fees where version_id = ${snapshotId} order by position`,
+    sql`select position, name from public.course_areas_of_interest where version_id = ${snapshotId} order by position`,
+    sql`select position, attribute_kind, value, source_text from public.course_attributes where version_id = ${snapshotId} order by position`,
+    sql`select position, relation_kind, source_course_code, source_course_title, source_text from public.course_related_courses where version_id = ${snapshotId} order by position`,
+    sql`select delivery_mode, location from public.course_offerings where version_id = ${snapshotId} limit 1`,
+    sql`select sessions.*, academic_years.year as calendar_year from public.offering_sessions as sessions join public.academic_years on academic_years.id = sessions.academic_year_id where sessions.version_id = ${snapshotId} order by sessions.position`,
+    sql`select id, position, body from public.course_learning_outcomes where version_id = ${snapshotId} order by position`,
+    sql`select id, position, title, weight, hurdle, due_text, source_text from public.course_assessment_items where version_id = ${snapshotId} order by position`,
+    sql`select assessment_item_id, learning_outcome_id from public.course_assessment_outcomes where version_id = ${snapshotId}`,
   ]);
   const outcomePosition = new Map(
     outcomes.map((row) => [Number(row.id), Number(row.position)]),
@@ -302,18 +304,18 @@ async function readCourseContent(
 async function readStructureContent(
   sql: Sql,
   snapshotId: number,
-): Promise<CatalogueSnapshotWrite["structure"]> {
+): Promise<StructureContentWrite | null> {
   const [details] = await sql`
-    select * from public.structure_snapshot_details where snapshot_id = ${snapshotId}
+    select * from public.structure_version_details where version_id = ${snapshotId}
   `;
   if (!details) return null;
   const [summaryFields, sections, outcomes, fees, relationships] =
     await Promise.all([
-      sql`select position, value_position, field_key, label, field_value, source_text from public.structure_snapshot_summary_fields where snapshot_id = ${snapshotId} order by position, value_position`,
-      sql`select section_key, heading, markdown, source_text, source_locator, position from public.academic_structure_snapshot_sections where snapshot_id = ${snapshotId} order by position`,
-      sql`select position, outcome_text, source_text, source_locator from public.academic_structure_learning_outcomes where snapshot_id = ${snapshotId} order by position`,
-      sql`select * from public.academic_structure_fees where snapshot_id = ${snapshotId} order by position`,
-      sql`select * from public.academic_structure_snapshot_relationships where snapshot_id = ${snapshotId} order by position`,
+      sql`select position, value_position, field_key, label, field_value, source_text from public.structure_snapshot_summary_fields where version_id = ${snapshotId} order by position, value_position`,
+      sql`select section_key, heading, markdown, source_text, source_locator, position from public.academic_structure_snapshot_sections where version_id = ${snapshotId} order by position`,
+      sql`select position, outcome_text, source_text, source_locator from public.academic_structure_learning_outcomes where version_id = ${snapshotId} order by position`,
+      sql`select * from public.academic_structure_fees where version_id = ${snapshotId} order by position`,
+      sql`select * from public.academic_structure_snapshot_relationships where version_id = ${snapshotId} order by position`,
     ]);
   return {
     details: {
@@ -371,7 +373,7 @@ async function readStructureContent(
       sourceLabel: str(row.source_label),
       sourceText: String(row.source_text),
       sourceLocator: String(row.source_locator),
-    })) as NonNullable<CatalogueSnapshotWrite["structure"]>["fees"],
+    })) as NonNullable<CatalogueContent["structure"]>["fees"],
     relationships: relationships.map((row) => ({
       position: Number(row.position),
       relationshipKind: row.relationship_kind,
@@ -380,7 +382,7 @@ async function readStructureContent(
       targetTitle: str(row.target_title),
       sourceText: String(row.source_text),
       sourceLocator: String(row.source_locator),
-    })) as NonNullable<CatalogueSnapshotWrite["structure"]>["relationships"],
+    })) as NonNullable<CatalogueContent["structure"]>["relationships"],
   };
 }
 
@@ -389,50 +391,48 @@ async function readStructureContent(
  * against a candidate or edited and saved as a new snapshot. Evidence is not
  * carried across; a derived snapshot records its own.
  */
-export async function readSnapshotWrite(
+export async function readVersionContent(
   sql: Sql,
   snapshotId: number,
-): Promise<CatalogueSnapshotWrite | null> {
+): Promise<CatalogueContent | null> {
   const [snapshot] = await sql`
     select snapshots.kind, snapshots.content_hash, items.code, academic_years.year
-    from public.catalogue_snapshots as snapshots
-    join public.catalogue_item_years as item_years on item_years.id = snapshots.item_year_id
-    join public.catalogue_items as items on items.id = item_years.item_id
+    from public.catalogue_versions as snapshots
+    join public.catalogue_records as item_years on item_years.id = snapshots.record_id
+    join public.catalogue_codes as items on items.id = item_years.code_id
     join public.academic_years on academic_years.id = snapshots.academic_year_id
     where snapshots.id = ${snapshotId}
   `;
   if (!snapshot) return null;
   const kind = snapshot.kind as CatalogueKind;
-  const [course, structure, requirements] = await Promise.all([
-    kind === "course"
-      ? readCourseContent(sql, snapshotId)
-      : Promise.resolve(null),
-    kind === "course"
-      ? Promise.resolve(null)
-      : readStructureContent(sql, snapshotId),
-    readRequirements(sql, snapshotId),
-  ]);
-  return {
-    kind,
+  const requirements = await readRequirements(sql, snapshotId);
+  const common = {
     code: String(snapshot.code),
     academicYear: Number(snapshot.year),
     contentHash: String(snapshot.content_hash),
-    course,
-    structure,
     requirements,
     evidence: [],
     flags: [],
   };
+  if (kind === "course") {
+    const course = await readCourseContent(sql, snapshotId);
+    return course ? { ...common, kind, course } : null;
+  }
+  const structure = await readStructureContent(sql, snapshotId);
+  return structure ? { ...common, kind, structure } : null;
 }
 
 /** Content hash over everything that reaches the database, ignoring provenance. */
-export function contentHashForWrite(write: CatalogueSnapshotWrite) {
-  return stableFingerprint({
+export function contentHashForCatalogueContent(write: CatalogueContent) {
+  const common = {
     kind: write.kind,
     code: write.code,
     academicYear: write.academicYear,
-    course: write.course,
-    structure: write.structure,
     requirements: write.requirements,
-  });
+  };
+  return stableFingerprint(
+    write.kind === "course"
+      ? { ...common, course: write.course }
+      : { ...common, structure: write.structure },
+  );
 }
diff --git a/apps/web/lib/catalogue-import/snapshot-write.ts b/apps/web/lib/catalogue/content.ts
similarity index 93%
rename from apps/web/lib/catalogue-import/snapshot-write.ts
rename to apps/web/lib/catalogue/content.ts
index 6750d07c..5e470f01 100644
--- a/apps/web/lib/catalogue-import/snapshot-write.ts
+++ b/apps/web/lib/catalogue/content.ts
@@ -1,5 +1,5 @@
-import type { CourseSnapshotProjection } from "./kinds/course/project.ts";
-import type { AcademicStructureSnapshotProjection } from "./kinds/structure/project.ts";
+import type { CourseSnapshotProjection } from "../catalogue-import/kinds/course/project.ts";
+import type { AcademicStructureSnapshotProjection } from "../catalogue-import/kinds/structure/project.ts";
 
 export type CatalogueKind =
   "course" | "programme" | "major" | "minor" | "specialisation";
@@ -116,7 +116,7 @@ export type RequirementWrite = {
   }>;
 };
 
-export type SnapshotEvidenceWrite = {
+export type CatalogueVersionProvenance = {
   fieldPath: string;
   method: "deterministic" | "model" | "manual";
   confidence: number | null;
@@ -124,7 +124,7 @@ export type SnapshotEvidenceWrite = {
   sourceExcerpt: string | null;
 };
 
-export type SnapshotFlagWrite = {
+export type CatalogueContentFlag = {
   fieldPath: string | null;
   severity: "warning" | "error";
   code: string;
@@ -173,22 +173,33 @@ export type StructureContentWrite = {
 };
 
 /**
- * Everything needed to assemble one catalogue snapshot. Kind-specific content
- * sits under `course` or `structure`; requirements, evidence and flags use the
+ * Everything needed to assemble one catalogue version. Kind-specific content
+ * is discriminated by `kind`; requirements, provenance and flags use the
  * shared shape. `contentHash` identifies the content for change detection.
  */
-export type CatalogueSnapshotWrite = {
-  kind: CatalogueKind;
+type CatalogueContentBase = {
   code: string;
   academicYear: number;
   contentHash: string;
-  course: CourseContentWrite | null;
-  structure: StructureContentWrite | null;
   requirements: RequirementWrite;
-  evidence: SnapshotEvidenceWrite[];
-  flags: SnapshotFlagWrite[];
+  evidence: CatalogueVersionProvenance[];
+  flags: CatalogueContentFlag[];
 };
 
+export type CatalogueContent = CatalogueContentBase &
+  (
+    | {
+        kind: "course";
+        course: CourseContentWrite;
+        structure?: never;
+      }
+    | {
+        kind: Exclude<CatalogueKind, "course">;
+        course?: never;
+        structure: StructureContentWrite;
+      }
+  );
+
 type CourseProjectionCondition =
   CourseSnapshotProjection["ruleConditions"][number];
 
@@ -198,15 +209,15 @@ function courseConditionKind(
   return kind === "admission" ? "structure" : kind;
 }
 
-export function courseSnapshotWrite({
+export function courseCatalogueContent({
   projection,
   evidence = [],
   flags = [],
 }: {
   projection: CourseSnapshotProjection;
-  evidence?: SnapshotEvidenceWrite[];
-  flags?: SnapshotFlagWrite[];
-}): CatalogueSnapshotWrite {
+  evidence?: CatalogueVersionProvenance[];
+  flags?: CatalogueContentFlag[];
+}): CatalogueContent {
   const ruleOrder: RequirementRuleKind[] = [
     "prerequisite",
     "corequisite",
@@ -232,7 +243,6 @@ export function courseSnapshotWrite({
       assessmentItems: projection.assessmentItems,
       assessmentOutcomes: projection.assessmentOutcomes,
     },
-    structure: null,
     requirements: {
       rules: projection.rules.map((rule) => ({
         key: rule.ruleKind,
@@ -346,15 +356,15 @@ function structureConditionKind(
   }
 }
 
-export function structureSnapshotWrite({
+export function structureCatalogueContent({
   projection,
   evidence = [],
   flags = [],
 }: {
   projection: AcademicStructureSnapshotProjection;
-  evidence?: SnapshotEvidenceWrite[];
-  flags?: SnapshotFlagWrite[];
-}): CatalogueSnapshotWrite {
+  evidence?: CatalogueVersionProvenance[];
+  flags?: CatalogueContentFlag[];
+}): CatalogueContent {
   const hasRequirements = projection.requirementRootKey !== null;
   const rootSourceText =
     projection.requirementGroups.find(
@@ -376,7 +386,6 @@ export function structureSnapshotWrite({
     code: projection.structureCode,
     academicYear: projection.academicYear,
     contentHash: projection.projectionSha256,
-    course: null,
     structure: {
       details: {
         name: projection.snapshot.title,
diff --git a/apps/web/lib/coursemap/actions.ts b/apps/web/lib/coursemap/actions.ts
index 2c4dba78..69c62b6f 100644
--- a/apps/web/lib/coursemap/actions.ts
+++ b/apps/web/lib/coursemap/actions.ts
@@ -179,7 +179,7 @@ export async function recordCourseAttempt(
     if (error) throw error;
     const { data: storedAttempt, error: storedAttemptError } = await supabase
       .from("course_attempts")
-      .select("course_snapshot_id,units_attempted,units_earned")
+      .select("catalogue_version_id,units_attempted,units_earned")
       .eq("id", data)
       .single();
     if (storedAttemptError) throw storedAttemptError;
@@ -188,7 +188,7 @@ export async function recordCourseAttempt(
       ok: true,
       id: data,
       message: "Academic history updated",
-      snapshotId: storedAttempt.course_snapshot_id,
+      snapshotId: storedAttempt.catalogue_version_id,
       unitsAttempted: Number(storedAttempt.units_attempted),
       unitsEarned: Number(storedAttempt.units_earned),
     };
diff --git a/apps/web/lib/coursemap/admin-catalogue-actions.ts b/apps/web/lib/coursemap/admin-catalogue-actions.ts
index 1e870525..8c98b893 100644
--- a/apps/web/lib/coursemap/admin-catalogue-actions.ts
+++ b/apps/web/lib/coursemap/admin-catalogue-actions.ts
@@ -13,9 +13,9 @@ import {
 import {
   ManualSnapshotError,
   restoreSnapshot,
-  saveManualSnapshot,
-} from "@/lib/catalogue-import/manual-snapshot";
-import type { CatalogueSnapshotWrite } from "@/lib/catalogue-import/snapshot-write";
+  saveManualVersion,
+} from "@/lib/catalogue-import/manual-version";
+import type { CatalogueContent } from "@/lib/catalogue/content";
 import { createClient } from "@/lib/supabase/server";
 
 export type ActionResult =
@@ -143,17 +143,17 @@ export async function applyReviewAction({
 }
 
 export async function publishDraftAction({
-  itemYearId,
+  recordId,
   path,
 }: {
-  itemYearId: number;
+  recordId: number;
   path: string;
 }): Promise<ActionResult> {
   if (!(await canWriteCatalogue()))
     return { ok: false, error: "Catalogue write permission is required." };
   const supabase = await createClient();
-  const { error } = await supabase.rpc("publish_catalogue_snapshot", {
-    p_item_year_id: itemYearId,
+  const { error } = await supabase.rpc("publish_catalogue_version", {
+    p_record_id: recordId,
   });
   if (error) return { ok: false, error: error.message };
   revalidateRecord(path);
@@ -161,17 +161,17 @@ export async function publishDraftAction({
 }
 
 export async function unpublishAction({
-  itemYearId,
+  recordId,
   path,
 }: {
-  itemYearId: number;
+  recordId: number;
   path: string;
 }): Promise<ActionResult> {
   if (!(await canWriteCatalogue()))
     return { ok: false, error: "Catalogue write permission is required." };
   const supabase = await createClient();
-  const { error } = await supabase.rpc("unpublish_catalogue_item_year", {
-    p_item_year_id: itemYearId,
+  const { error } = await supabase.rpc("unpublish_catalogue_record", {
+    p_record_id: recordId,
   });
   if (error) return { ok: false, error: error.message };
   revalidateRecord(path);
@@ -181,15 +181,15 @@ export async function unpublishAction({
   };
 }
 
-export async function saveManualSnapshotAction({
-  itemYearId,
+export async function saveManualVersionAction({
+  recordId,
   baseSnapshotId,
   write,
   path,
 }: {
-  itemYearId: number;
+  recordId: number;
   baseSnapshotId: number | null;
-  write: CatalogueSnapshotWrite;
+  write: CatalogueContent;
   path: string;
 }): Promise<ActionResult & { snapshotId?: number }> {
   if (!(await canWriteCatalogue()))
@@ -197,8 +197,8 @@ export async function saveManualSnapshotAction({
   const viewer = await getAuthViewer();
   if (!viewer) return { ok: false, error: "Authentication is required." };
   try {
-    const result = await saveManualSnapshot({
-      itemYearId,
+    const result = await saveManualVersion({
+      recordId,
       baseSnapshotId,
       write,
       userId: viewer.id,
@@ -219,11 +219,11 @@ export async function saveManualSnapshotAction({
 }
 
 export async function restoreSnapshotAction({
-  itemYearId,
+  recordId,
   snapshotId,
   path,
 }: {
-  itemYearId: number;
+  recordId: number;
   snapshotId: number;
   path: string;
 }): Promise<ActionResult> {
@@ -233,7 +233,7 @@ export async function restoreSnapshotAction({
   if (!viewer) return { ok: false, error: "Authentication is required." };
   try {
     const result = await restoreSnapshot({
-      itemYearId,
+      recordId,
       snapshotId,
       userId: viewer.id,
     });
@@ -250,24 +250,3 @@ export async function restoreSnapshotAction({
     return failure(error, "The snapshot could not be restored.");
   }
 }
-
-export async function discardDraftAction({
-  itemYearId,
-  path,
-}: {
-  itemYearId: number;
-  path: string;
-}): Promise<ActionResult> {
-  if (!(await canWriteCatalogue()))
-    return { ok: false, error: "Catalogue write permission is required." };
-  const supabase = await createClient();
-  const { error } = await supabase.rpc("discard_catalogue_draft", {
-    p_item_year_id: itemYearId,
-  });
-  if (error) return { ok: false, error: error.message };
-  revalidateRecord(path);
-  return {
-    ok: true,
-    message: "Draft discarded. The snapshot stays in history.",
-  };
-}
diff --git a/apps/web/lib/coursemap/admin-catalogue-record.ts b/apps/web/lib/coursemap/admin-catalogue-record.ts
index 335ba687..7ad02bc1 100644
--- a/apps/web/lib/coursemap/admin-catalogue-record.ts
+++ b/apps/web/lib/coursemap/admin-catalogue-record.ts
@@ -1,7 +1,7 @@
 import "server-only";
 import { withImportDatabaseClient } from "@/lib/catalogue-import/import-store";
-import { readSnapshotWrite } from "@/lib/catalogue-import/snapshot-read";
-import type { CatalogueSnapshotWrite } from "@/lib/catalogue-import/snapshot-write";
+import { readVersionContent } from "@/lib/catalogue-import/version-content";
+import type { CatalogueContent } from "@/lib/catalogue/content";
 import { createClient } from "@/lib/supabase/server";
 import type { Json } from "@/types/database";
 import type { CatalogueKind } from "./catalogue-kinds";
@@ -33,18 +33,18 @@ export type ReviewTarget = {
   createdAt: string;
   completedAt: string | null;
   appliedAt: string | null;
-  baselineSnapshotId: number | null;
-  candidateSnapshotId: number | null;
+  baselineVersionId: number | null;
+  candidateVersionId: number | null;
   entries: ReviewEntry[];
 };
 
-export type CatalogueRecordSnapshot = {
+export type CatalogueVersion = {
   id: number;
   publicId: string;
   origin: string;
   createdAt: string;
   sealedAt: string | null;
-  basedOnSnapshotId: number | null;
+  basedOnVersionId: number | null;
   importTargetId: string | null;
   contentHash: string;
 };
@@ -53,41 +53,43 @@ export type CatalogueRecord = {
   kind: CatalogueKind;
   code: string;
   academicYear: number;
-  itemId: number;
-  itemYearId: number;
-  itemYearPublicId: string;
+  codeId: number;
+  recordId: number;
+  recordPublicId: string;
   title: string;
-  draftSnapshotId: number | null;
-  publishedSnapshotId: number | null;
+  currentVersionId: number | null;
+  publishedVersionId: number | null;
   archivedAt: string | null;
   publishBlockers: string[];
-  snapshots: CatalogueRecordSnapshot[];
+  versions: CatalogueVersion[];
   publications: Array<{
-    snapshotId: number | null;
+    versionId: number;
     publishedAt: string;
     publishedBy: string | null;
+    unpublishedAt: string | null;
+    unpublishedBy: string | null;
   }>;
   reviews: ReviewTarget[];
 };
 
-async function snapshotTitle(
+async function versionTitle(
   supabase: Awaited<ReturnType<typeof createClient>>,
   kind: CatalogueKind,
-  snapshotId: number | null,
+  versionId: number | null,
 ) {
-  if (!snapshotId) return null;
+  if (!versionId) return null;
   if (kind === "course") {
     const { data } = await supabase
-      .from("course_snapshot_details")
+      .from("course_version_details")
       .select("title")
-      .eq("snapshot_id", snapshotId)
+      .eq("version_id", versionId)
       .maybeSingle();
     return data?.title ?? null;
   }
   const { data } = await supabase
-    .from("structure_snapshot_details")
+    .from("structure_version_details")
     .select("name")
-    .eq("snapshot_id", snapshotId)
+    .eq("version_id", versionId)
     .maybeSingle();
   return data?.name ?? null;
 }
@@ -104,55 +106,61 @@ export async function loadCatalogueRecord({
 }): Promise<CatalogueRecord | null> {
   const supabase = await createClient();
   const { data: itemYear, error } = await supabase
-    .from("catalogue_item_years")
+    .from("catalogue_records")
     .select(
-      "id,public_id,item_id,draft_snapshot_id,published_snapshot_id,archived_at,catalogue_items!inner(code,kind),academic_years!inner(year)",
+      "id,public_id,code_id,published_version_id,archived_at,catalogue_codes!inner(code,kind),academic_years!inner(year)",
     )
     .eq("kind", kind)
-    .eq("catalogue_items.code", code.toUpperCase())
+    .eq("catalogue_codes.code", code.toUpperCase())
     .eq("academic_years.year", academicYear)
     .maybeSingle();
   if (error) throw error;
   if (!itemYear) return null;
 
-  const [
-    snapshotsResult,
-    publicationsResult,
-    targetsResult,
-    blockersResult,
-    title,
-  ] = await Promise.all([
-    supabase
-      .from("catalogue_snapshots")
-      .select(
-        "id,public_id,origin,created_at,sealed_at,based_on_snapshot_id,import_target_id,content_hash",
-      )
-      .eq("item_year_id", itemYear.id)
-      .order("created_at", { ascending: false }),
-    supabase
-      .from("catalogue_publications")
-      .select("snapshot_id,published_at,published_by")
-      .eq("item_year_id", itemYear.id)
-      .order("published_at", { ascending: false }),
-    supabase
-      .from("catalogue_import_targets")
-      .select(
-        "id,run_id,status,change_kind,created_at,completed_at,applied_at,baseline_snapshot_id,candidate_snapshot_id,catalogue_import_runs!inner(run_number)",
-      )
-      .eq("item_year_id", itemYear.id)
-      .order("created_at", { ascending: false }),
-    supabase.rpc("catalogue_publish_blockers", { p_item_year_id: itemYear.id }),
-    snapshotTitle(
-      supabase,
-      kind,
-      itemYear.draft_snapshot_id ?? itemYear.published_snapshot_id,
-    ),
-  ]);
-  if (snapshotsResult.error) throw snapshotsResult.error;
+  const [versionsResult, publicationsResult, targetsResult, blockersResult] =
+    await Promise.all([
+      supabase
+        .from("catalogue_versions")
+        .select(
+          "id,public_id,origin,created_at,sealed_at,based_on_version_id,import_target_id,content_hash",
+        )
+        .eq("record_id", itemYear.id)
+        .order("created_at", { ascending: false }),
+      supabase
+        .from("catalogue_publications")
+        .select(
+          "version_id,published_at,published_by,unpublished_at,unpublished_by",
+        )
+        .eq("record_id", itemYear.id)
+        .order("published_at", { ascending: false }),
+      supabase
+        .from("catalogue_import_targets")
+        .select(
+          "id,run_id,status,change_kind,created_at,completed_at,applied_at,applied_version_id,baseline_version_id,candidate_version_id,catalogue_import_runs!inner(run_number)",
+        )
+        .eq("record_id", itemYear.id)
+        .order("created_at", { ascending: false }),
+      supabase.rpc("catalogue_publish_blockers", { p_record_id: itemYear.id }),
+    ]);
+  if (versionsResult.error) throw versionsResult.error;
   if (publicationsResult.error) throw publicationsResult.error;
   if (targetsResult.error) throw targetsResult.error;
   if (blockersResult.error) throw blockersResult.error;
 
+  const appliedVersionIds = new Set(
+    (targetsResult.data ?? []).flatMap((target) =>
+      target.applied_version_id === null ? [] : [target.applied_version_id],
+    ),
+  );
+  const currentVersionId =
+    (versionsResult.data ?? []).find(
+      (version) =>
+        version.sealed_at !== null &&
+        (version.import_target_id === null ||
+          appliedVersionIds.has(version.id)),
+    )?.id ?? null;
+  const title = await versionTitle(supabase, kind, currentVersionId);
+
   const targetIds = (targetsResult.data ?? []).map((target) => target.id);
   const { data: entries, error: entriesError } = targetIds.length
     ? await supabase
@@ -186,30 +194,32 @@ export async function loadCatalogueRecord({
 
   return {
     kind,
-    code: itemYear.catalogue_items.code,
+    code: itemYear.catalogue_codes.code,
     academicYear,
-    itemId: itemYear.item_id,
-    itemYearId: itemYear.id,
-    itemYearPublicId: itemYear.public_id,
-    title: title ?? itemYear.catalogue_items.code,
-    draftSnapshotId: itemYear.draft_snapshot_id,
-    publishedSnapshotId: itemYear.published_snapshot_id,
+    codeId: itemYear.code_id,
+    recordId: itemYear.id,
+    recordPublicId: itemYear.public_id,
+    title: title ?? itemYear.catalogue_codes.code,
+    currentVersionId,
+    publishedVersionId: itemYear.published_version_id,
     archivedAt: itemYear.archived_at,
     publishBlockers: (blockersResult.data as string[] | null) ?? [],
-    snapshots: (snapshotsResult.data ?? []).map((snapshot) => ({
-      id: snapshot.id,
-      publicId: snapshot.public_id,
-      origin: snapshot.origin,
-      createdAt: snapshot.created_at,
-      sealedAt: snapshot.sealed_at,
-      basedOnSnapshotId: snapshot.based_on_snapshot_id,
-      importTargetId: snapshot.import_target_id,
-      contentHash: snapshot.content_hash,
+    versions: (versionsResult.data ?? []).map((version) => ({
+      id: version.id,
+      publicId: version.public_id,
+      origin: version.origin,
+      createdAt: version.created_at,
+      sealedAt: version.sealed_at,
+      basedOnVersionId: version.based_on_version_id,
+      importTargetId: version.import_target_id,
+      contentHash: version.content_hash,
     })),
     publications: (publicationsResult.data ?? []).map((publication) => ({
-      snapshotId: publication.snapshot_id,
+      versionId: publication.version_id,
       publishedAt: publication.published_at,
       publishedBy: publication.published_by,
+      unpublishedAt: publication.unpublished_at,
+      unpublishedBy: publication.unpublished_by,
     })),
     reviews: (targetsResult.data ?? []).map((target) => ({
       id: target.id,
@@ -220,8 +230,8 @@ export async function loadCatalogueRecord({
       createdAt: target.created_at,
       completedAt: target.completed_at,
       appliedAt: target.applied_at,
-      baselineSnapshotId: target.baseline_snapshot_id,
-      candidateSnapshotId: target.candidate_snapshot_id,
+      baselineVersionId: target.baseline_version_id,
+      candidateVersionId: target.candidate_version_id,
       entries: entriesByTarget.get(target.id) ?? [],
     })),
   };
@@ -230,16 +240,19 @@ export async function loadCatalogueRecord({
 /** The editable content of a snapshot, read through the import connection. */
 export async function loadSnapshotWrite(
   snapshotId: number,
-): Promise<CatalogueSnapshotWrite | null> {
-  return withImportDatabaseClient((sql) => readSnapshotWrite(sql, snapshotId));
+): Promise<CatalogueContent | null> {
+  return withImportDatabaseClient((sql) => readVersionContent(sql, snapshotId));
 }
 
 /** The student-facing course details for a snapshot, or null for structures. */
 export async function loadSnapshotCoursePreview(snapshotId: number) {
   const supabase = await createClient();
-  const { data, error } = await supabase.rpc("admin_snapshot_projection", {
-    p_snapshot_id: snapshotId,
-  });
+  const { data, error } = await supabase.rpc(
+    "admin_catalogue_version_projection",
+    {
+      p_version_id: snapshotId,
+    },
+  );
   if (error) throw error;
   if (data === null) return null;
   return courseFromSnapshotProjection(data as Json, snapshotId);
diff --git a/apps/web/lib/coursemap/admin-catalogue.ts b/apps/web/lib/coursemap/admin-catalogue.ts
index 00df75a8..614eea2d 100644
--- a/apps/web/lib/coursemap/admin-catalogue.ts
+++ b/apps/web/lib/coursemap/admin-catalogue.ts
@@ -95,7 +95,7 @@ export async function defaultCatalogueYear(
 ) {
   const supabase = await createClient();
   const { data } = await supabase
-    .from("catalogue_item_years")
+    .from("catalogue_records")
     .select("academic_years(year)")
     .eq("kind", kind)
     .order("academic_year_id", { ascending: false })
@@ -184,7 +184,7 @@ export async function loadCatalogueDirectoryPage({
       readAllRows((from, to) =>
         supabase
           .from("catalogue_directory_entries")
-          .select("code,title,summary,item_id")
+          .select("code,title,summary,code_id")
           .eq("academic_year_id", yearRow.id)
           .eq("kind", kind)
           .eq("is_current", true)
@@ -193,13 +193,11 @@ export async function loadCatalogueDirectoryPage({
       ),
       readAllRows((from, to) =>
         supabase
-          .from("catalogue_item_years")
-          .select(
-            "item_id,public_id,draft_snapshot_id,published_snapshot_id,archived_at",
-          )
+          .from("catalogue_records")
+          .select("code_id,public_id,published_version_id,archived_at")
           .eq("academic_year_id", yearRow.id)
           .eq("kind", kind)
-          .order("item_id")
+          .order("code_id")
           .range(from, to),
       ),
       // Newest first so the first target seen per item is its latest; id breaks
@@ -208,7 +206,7 @@ export async function loadCatalogueDirectoryPage({
         supabase
           .from("catalogue_import_targets")
           .select(
-            "id,run_id,item_id,status,change_kind,error_message,completed_at,created_at",
+            "id,run_id,code_id,status,change_kind,error_message,completed_at,created_at,applied_version_id",
           )
           .eq("academic_year_id", yearRow.id)
           .eq("kind", kind)
@@ -223,28 +221,28 @@ export async function loadCatalogueDirectoryPage({
   if (targetsResult.error) throw targetsResult.error;
 
   const itemYearByItem = new Map(
-    (itemYearsResult.data ?? []).map((row) => [row.item_id, row]),
+    (itemYearsResult.data ?? []).map((row) => [row.code_id, row]),
   );
   const latestTargetByItem = new Map<
     number,
     (typeof targetsResult.data)[number]
   >();
   for (const target of targetsResult.data ?? []) {
-    if (!latestTargetByItem.has(target.item_id)) {
-      latestTargetByItem.set(target.item_id, target);
+    if (!latestTargetByItem.has(target.code_id)) {
+      latestTargetByItem.set(target.code_id, target);
     }
   }
 
   // Items imported directly (without a directory row) still appear so the
   // administrator can see everything the year holds.
   const entryCodes = new Set(entriesResult.data.map((row) => row.code));
-  const entryItemIds = new Set(entriesResult.data.map((row) => row.item_id));
+  const entryItemIds = new Set(entriesResult.data.map((row) => row.code_id));
   const extraItemIds = [...itemYearByItem.keys()].filter(
     (itemId) => !entryItemIds.has(itemId),
   );
   const { data: extraItems } = extraItemIds.length
     ? await supabase
-        .from("catalogue_items")
+        .from("catalogue_codes")
         .select("id,code")
         .in("id", extraItemIds)
     : { data: [] as Array<{ id: number; code: string }> };
@@ -254,7 +252,7 @@ export async function loadCatalogueDirectoryPage({
       code: entry.code,
       title: entry.title,
       summary: (entry.summary ?? {}) as Record<string, unknown>,
-      itemId: entry.item_id,
+      itemId: entry.code_id,
     })),
     ...(extraItems ?? [])
       .filter((item) => !entryCodes.has(item.code))
@@ -269,14 +267,17 @@ export async function loadCatalogueDirectoryPage({
       const itemYear = itemId === null ? undefined : itemYearByItem.get(itemId);
       const latest =
         itemId === null ? undefined : latestTargetByItem.get(itemId);
-      const hasDraft = Boolean(itemYear?.draft_snapshot_id);
+      const hasDraft = Boolean(
+        latest?.applied_version_id &&
+        latest.applied_version_id !== itemYear?.published_version_id,
+      );
       const isPublished =
-        Boolean(itemYear?.published_snapshot_id) && !itemYear?.archived_at;
+        Boolean(itemYear?.published_version_id) && !itemYear?.archived_at;
       return {
         code,
         title,
         summary,
-        itemYearPublicId: itemYear?.public_id ?? null,
+        recordPublicId: itemYear?.public_id ?? null,
         hasDraft,
         isPublished,
         workflow: workflowFor({
@@ -389,10 +390,10 @@ function runRow(run: RunRow): ImportRunRow {
 
 // The year is taken from the target's own column and resolved through the
 // academic year table, rather than reached by a nested embed through the run:
-// PostgREST resolves `catalogue_import_targets -> catalogue_item_years` by two
+// PostgREST resolves `catalogue_import_targets -> catalogue_records` by two
 // foreign keys of the same name, so the embedded shape is not typed.
 const RECORD_COLUMNS =
-  "id,code,academic_year_id,status,change_kind,attempt_count,error_code,error_message,applied_snapshot_id,created_at,completed_at,run_id,directory_entry_id,item_year_id";
+  "id,code,academic_year_id,status,change_kind,attempt_count,error_code,error_message,applied_version_id,created_at,completed_at,run_id,directory_entry_id,record_id";
 
 type RecordRow = {
   id: string;
@@ -403,12 +404,12 @@ type RecordRow = {
   attempt_count: number;
   error_code: string | null;
   error_message: string | null;
-  applied_snapshot_id: number | null;
+  applied_version_id: number | null;
   created_at: string;
   completed_at: string | null;
   run_id: string;
   directory_entry_id: number | null;
-  item_year_id: number;
+  record_id: number;
 };
 
 /**
@@ -542,14 +543,14 @@ export async function loadCatalogueImportRecords({
   // The labels a row needs are resolved by id over the page rather than by
   // embedding them in the select above. One page is twenty-five rows, so this
   // is four small reads, and it keeps the ambiguous embeds out: PostgREST
-  // reaches `catalogue_item_years` from a target through two foreign keys of
+  // reaches `catalogue_records` from a target through two foreign keys of
   // the same name, which it will not resolve and cannot type.
   const distinct = <Value>(values: Value[]) => [...new Set(values)];
   const entryIds = distinct(
     rows.map((row) => row.directory_entry_id).filter((id) => id !== null),
   );
   const yearIds = distinct(rows.map((row) => row.academic_year_id));
-  const itemYearIds = distinct(rows.map((row) => row.item_year_id));
+  const recordIds = distinct(rows.map((row) => row.record_id));
   // The recent runs are already loaded, so only a row from an older run than
   // the list offers costs a read.
   const olderRunIds = distinct(rows.map((row) => row.run_id)).filter(
@@ -566,11 +567,11 @@ export async function loadCatalogueImportRecords({
     yearIds.length
       ? supabase.from("academic_years").select("id,year").in("id", yearIds)
       : null,
-    itemYearIds.length
+    recordIds.length
       ? supabase
-          .from("catalogue_item_years")
+          .from("catalogue_records")
           .select("id,public_id")
-          .in("id", itemYearIds)
+          .in("id", recordIds)
       : null,
     olderRunIds.length
       ? supabase
@@ -614,8 +615,8 @@ export async function loadCatalogueImportRecords({
       attemptCount: row.attempt_count,
       errorCode: row.error_code,
       errorMessage: row.error_message,
-      appliedSnapshotId: row.applied_snapshot_id,
-      itemYearPublicId: publicIdById.get(row.item_year_id) ?? null,
+      appliedVersionId: row.applied_version_id,
+      recordPublicId: publicIdById.get(row.record_id) ?? null,
       createdAt: row.created_at,
       completedAt: row.completed_at,
       runId: row.run_id,
@@ -737,12 +738,18 @@ export async function loadImportTargetDetail(
 
 export async function loadAdminCatalogueSummary(): Promise<AdminCatalogueSummary> {
   const supabase = await createClient();
-  const [{ data: itemYears }, { data: items }] = await Promise.all([
-    supabase
-      .from("catalogue_item_years")
-      .select("kind,draft_snapshot_id,published_snapshot_id,archived_at"),
-    supabase.from("catalogue_items").select("kind"),
-  ]);
+  const [{ data: itemYears }, { data: items }, { data: appliedTargets }] =
+    await Promise.all([
+      supabase
+        .from("catalogue_records")
+        .select("id,kind,published_version_id,archived_at"),
+      supabase.from("catalogue_codes").select("kind"),
+      supabase
+        .from("catalogue_import_targets")
+        .select("record_id,applied_version_id,created_at")
+        .not("applied_version_id", "is", null)
+        .order("created_at", { ascending: false }),
+    ]);
   const summary = Object.fromEntries(
     (Object.keys(CATALOGUE_KIND_LABELS) as CatalogueKind[]).map((kind) => [
       kind,
@@ -751,10 +758,20 @@ export async function loadAdminCatalogueSummary(): Promise<AdminCatalogueSummary
   ) as AdminCatalogueSummary;
   for (const item of items ?? [])
     summary[item.kind as CatalogueKind].identities += 1;
+  const latestAppliedByRecord = new Map<number, number>();
+  for (const target of appliedTargets ?? []) {
+    if (
+      !latestAppliedByRecord.has(target.record_id) &&
+      target.applied_version_id
+    )
+      latestAppliedByRecord.set(target.record_id, target.applied_version_id);
+  }
   for (const year of itemYears ?? []) {
     const bucket = summary[year.kind as CatalogueKind];
-    if (year.published_snapshot_id && !year.archived_at) bucket.published += 1;
-    if (year.draft_snapshot_id) bucket.drafts += 1;
+    if (year.published_version_id && !year.archived_at) bucket.published += 1;
+    const appliedVersionId = latestAppliedByRecord.get(year.id);
+    if (appliedVersionId && appliedVersionId !== year.published_version_id)
+      bucket.drafts += 1;
   }
   return summary;
 }
diff --git a/apps/web/lib/coursemap/catalogue-kinds.ts b/apps/web/lib/coursemap/catalogue-kinds.ts
index b74ed6fd..3b166494 100644
--- a/apps/web/lib/coursemap/catalogue-kinds.ts
+++ b/apps/web/lib/coursemap/catalogue-kinds.ts
@@ -1,4 +1,4 @@
-import type { CatalogueKind } from "@/lib/catalogue-import/snapshot-write";
+import type { CatalogueKind } from "@/lib/catalogue/content";
 
 export type { CatalogueKind };
 
@@ -39,7 +39,7 @@ export type CatalogueDirectoryRecord = {
   code: string;
   title: string | null;
   summary: Record<string, unknown>;
-  itemYearPublicId: string | null;
+  recordPublicId: string | null;
   hasDraft: boolean;
   isPublished: boolean;
   workflow: DirectoryWorkflowStatus;
@@ -94,9 +94,9 @@ export type ImportRunSummary = {
     attemptCount: number;
     errorCode: string | null;
     errorMessage: string | null;
-    candidateSnapshotId: number | null;
-    appliedSnapshotId: number | null;
-    itemYearPublicId: string | null;
+    candidateVersionId: number | null;
+    appliedVersionId: number | null;
+    recordPublicId: string | null;
   }>;
 };
 
@@ -268,8 +268,8 @@ export type ImportRecordRow = {
   attemptCount: number;
   errorCode: string | null;
   errorMessage: string | null;
-  appliedSnapshotId: number | null;
-  itemYearPublicId: string | null;
+  appliedVersionId: number | null;
+  recordPublicId: string | null;
   createdAt: string;
   completedAt: string | null;
   runId: string;
diff --git a/apps/web/lib/coursemap/onboarding-catalogue.ts b/apps/web/lib/coursemap/onboarding-catalogue.ts
index c8fdf5c1..ca0f598a 100644
--- a/apps/web/lib/coursemap/onboarding-catalogue.ts
+++ b/apps/web/lib/coursemap/onboarding-catalogue.ts
@@ -43,19 +43,19 @@ export type OnboardingCatalogue = {
 export async function loadOnboardingCatalogue(): Promise<OnboardingCatalogue> {
   const supabase = createPublicClient();
   const { data: structureYears, error: structureYearsError } = await supabase
-    .from("catalogue_item_years")
-    .select("academic_year_id,published_snapshot_id,item_id")
+    .from("catalogue_records")
+    .select("academic_year_id,published_version_id,code_id")
     .neq("kind", "course")
     .is("archived_at", null)
-    .not("published_snapshot_id", "is", null);
+    .not("published_version_id", "is", null);
   if (structureYearsError) throw structureYearsError;
 
   const publishedYears = (structureYears ?? []).filter(
     (
       row,
     ): row is typeof row & {
-      published_snapshot_id: number;
-    } => row.published_snapshot_id !== null,
+      published_version_id: number;
+    } => row.published_version_id !== null,
   );
   if (publishedYears.length === 0) {
     return {
@@ -70,8 +70,8 @@ export async function loadOnboardingCatalogue(): Promise<OnboardingCatalogue> {
   const academicYearIds = [
     ...new Set(publishedYears.map((row) => row.academic_year_id)),
   ];
-  const structureIds = [...new Set(publishedYears.map((row) => row.item_id))];
-  const snapshotIds = publishedYears.map((row) => row.published_snapshot_id);
+  const structureIds = [...new Set(publishedYears.map((row) => row.code_id))];
+  const snapshotIds = publishedYears.map((row) => row.published_version_id);
   const [
     yearsResult,
     structuresResult,
@@ -86,26 +86,26 @@ export async function loadOnboardingCatalogue(): Promise<OnboardingCatalogue> {
       .in("id", academicYearIds)
       .order("year", { ascending: false }),
     supabase
-      .from("catalogue_items")
+      .from("catalogue_codes")
       .select("code,id,kind")
       .in("id", structureIds),
     supabase
-      .from("structure_snapshot_details")
-      .select("description,duration_years,snapshot_id,name,units")
-      .in("snapshot_id", snapshotIds),
+      .from("structure_version_details")
+      .select("description,duration_years,version_id,name,units")
+      .in("version_id", snapshotIds),
     supabase
       .from("academic_structure_snapshot_relationships")
-      .select("relationship_kind,snapshot_id,target_code,target_kind")
-      .in("snapshot_id", snapshotIds),
+      .select("relationship_kind,version_id,target_code,target_kind")
+      .in("version_id", snapshotIds),
     supabase
       .from("requirement_conditions")
-      .select("condition_kind,id,snapshot_id,structure_kind")
-      .in("snapshot_id", snapshotIds)
+      .select("condition_kind,id,version_id,structure_kind")
+      .in("version_id", snapshotIds)
       .eq("condition_kind", "structure_set"),
     supabase
       .from("requirement_condition_options")
-      .select("code,condition_id,kind,snapshot_id")
-      .in("snapshot_id", snapshotIds)
+      .select("code,condition_id,kind,version_id")
+      .in("version_id", snapshotIds)
       .neq("kind", "course"),
   ]);
   const error = [
@@ -125,12 +125,12 @@ export async function loadOnboardingCatalogue(): Promise<OnboardingCatalogue> {
     (structuresResult.data ?? []).map((structure) => [structure.id, structure]),
   );
   const publishedYearBySnapshotId = new Map(
-    publishedYears.map((row) => [row.published_snapshot_id, row]),
+    publishedYears.map((row) => [row.published_version_id, row]),
   );
   const programmeSnapshotIds = new Set(
     publishedYears.flatMap((row) => {
-      const identity = structureById.get(row.item_id);
-      return identity?.kind === "programme" ? [row.published_snapshot_id] : [];
+      const identity = structureById.get(row.code_id);
+      return identity?.kind === "programme" ? [row.published_version_id] : [];
     }),
   );
   const structureCodesByProgrammeSnapshot = collectSelectableStructureCodes({
@@ -149,10 +149,10 @@ export async function loadOnboardingCatalogue(): Promise<OnboardingCatalogue> {
     (snapshotsResult.data ?? [])
       .flatMap((snapshot) => {
         const structureYear = publishedYearBySnapshotId.get(
-          snapshot.snapshot_id,
+          snapshot.version_id,
         );
         const identity = structureYear
-          ? structureById.get(structureYear.item_id)
+          ? structureById.get(structureYear.code_id)
           : null;
         const academicYear = structureYear
           ? yearById.get(structureYear.academic_year_id)
@@ -160,7 +160,7 @@ export async function loadOnboardingCatalogue(): Promise<OnboardingCatalogue> {
         if (!identity || !academicYear || identity.kind !== kind) return [];
         const selectableCodes =
           kind === "programme"
-            ? (structureCodesByProgrammeSnapshot.get(snapshot.snapshot_id) ??
+            ? (structureCodesByProgrammeSnapshot.get(snapshot.version_id) ??
               emptySelectableStructureCodes())
             : emptySelectableStructureCodes();
         return [
@@ -184,7 +184,7 @@ export async function loadOnboardingCatalogue(): Promise<OnboardingCatalogue> {
 
   const programmeYearIds = new Set(
     publishedYears.flatMap((row) => {
-      const identity = structureById.get(row.item_id);
+      const identity = structureById.get(row.code_id);
       return identity?.kind === "programme" ? [row.academic_year_id] : [];
     }),
   );
diff --git a/apps/web/lib/coursemap/plan-catalogue.ts b/apps/web/lib/coursemap/plan-catalogue.ts
index 0127c1e6..f0aa9597 100644
--- a/apps/web/lib/coursemap/plan-catalogue.ts
+++ b/apps/web/lib/coursemap/plan-catalogue.ts
@@ -9,7 +9,7 @@ import {
 import type { CourseDetails } from "@/lib/coursemap/course-types";
 import { getAuthViewer } from "@/lib/auth/viewer";
 import { createClient } from "@/lib/supabase/server";
-import { collectPlanCatalogueCourseIds } from "@/lib/coursemap/plan-course-ids";
+import { collectPlanCatalogueRecordIds } from "@/lib/coursemap/plan-course-ids";
 
 export type PlanCatalogue = {
   academicYear: number | null;
@@ -104,7 +104,7 @@ type StructureSnapshotRow = {
   college: string | null;
   description: string | null;
   duration_years: number | null;
-  snapshot_id: number;
+  version_id: number;
   name: string;
   units: number | null;
 };
@@ -115,14 +115,16 @@ type RequirementConditionRow =
   Database["public"]["Tables"]["requirement_conditions"]["Row"];
 type RequirementOptionRow =
   Database["public"]["Tables"]["requirement_condition_options"]["Row"];
-type PlanCourseRow = { academic_year_id: number; course_id: number };
-type PlanStructureRow = { structure_year_id: number };
-type AttemptCourseRow = {
-  course_id: number;
-  course_snapshot_id: number;
+type PlanCourseRow = { catalogue_record_id: number };
+type PlanStructureRow = { catalogue_record_id: number };
+type AttemptCourseRow = { catalogue_version_id: number };
+type AttemptVersionRow = {
+  id: number;
+  record_id: number;
 };
-type AttemptSnapshotRow = {
+type CatalogueRecordRow = {
   academic_year_id: number;
+  code_id: number;
   id: number;
 };
 
@@ -286,11 +288,11 @@ async function loadAcademicYearRecord(
   }
 
   const programmeYearsResult = await supabase
-    .from("catalogue_item_years")
+    .from("catalogue_records")
     .select("academic_year_id")
     .eq("kind", "programme")
     .is("archived_at", null)
-    .not("published_snapshot_id", "is", null);
+    .not("published_version_id", "is", null);
   if (programmeYearsResult.error) throw programmeYearsResult.error;
   const academicYearIds = [
     ...new Set(
@@ -343,12 +345,12 @@ export async function loadPublishedPlanCatalogue(
         .order("calendar_year")
         .order("sort_order"),
       supabase
-        .from("catalogue_item_years")
-        .select("id,published_snapshot_id,item_id")
+        .from("catalogue_records")
+        .select("id,published_version_id,code_id")
         .eq("academic_year_id", academicYearRecord.id)
         .neq("kind", "course")
         .is("archived_at", null)
-        .not("published_snapshot_id", "is", null),
+        .not("published_version_id", "is", null),
     ]);
   if (periodsResult.error) throw periodsResult.error;
   if (structureYearsResult.error) throw structureYearsResult.error;
@@ -357,28 +359,28 @@ export async function loadPublishedPlanCatalogue(
     (
       row,
     ): row is typeof row & {
-      published_snapshot_id: number;
-    } => row.published_snapshot_id !== null,
+      published_version_id: number;
+    } => row.published_version_id !== null,
   );
   const structureIds = [
-    ...new Set(structureYears.map((structureYear) => structureYear.item_id)),
+    ...new Set(structureYears.map((structureYear) => structureYear.code_id)),
   ];
   const snapshotIds = structureYears.map(
-    (structureYear) => structureYear.published_snapshot_id,
+    (structureYear) => structureYear.published_version_id,
   );
   const [structureIdentitiesResult, structureSnapshotsResult] =
     await Promise.all([
       structureIds.length
         ? supabase
-            .from("catalogue_items")
+            .from("catalogue_codes")
             .select("code,id,kind")
             .in("id", structureIds)
         : Promise.resolve({ data: [], error: null }),
       snapshotIds.length
         ? supabase
-            .from("structure_snapshot_details")
-            .select("college,description,duration_years,snapshot_id,name,units")
-            .in("snapshot_id", snapshotIds)
+            .from("structure_version_details")
+            .select("college,description,duration_years,version_id,name,units")
+            .in("version_id", snapshotIds)
         : Promise.resolve({ data: [], error: null }),
     ]);
   const structureError = [
@@ -394,7 +396,7 @@ export async function loadPublishedPlanCatalogue(
   );
   const snapshotsById = new Map(
     ((structureSnapshotsResult.data ?? []) as StructureSnapshotRow[]).map(
-      (snapshot) => [snapshot.snapshot_id, snapshot],
+      (snapshot) => [snapshot.version_id, snapshot],
     ),
   );
 
@@ -405,11 +407,11 @@ export async function loadPublishedPlanCatalogue(
     ),
   );
   const requirementsSnapshotIds = structureYears.flatMap((structureYear) => {
-    const kind = identitiesById.get(structureYear.item_id)?.kind;
+    const kind = identitiesById.get(structureYear.code_id)?.kind;
     return selectedStructureYears.has(structureYear.id) &&
       kind !== undefined &&
       isPlanStructureKind(kind)
-      ? [structureYear.published_snapshot_id]
+      ? [structureYear.published_version_id]
       : [];
   });
   const requirementsSnapshotIdSet = new Set(requirementsSnapshotIds);
@@ -418,21 +420,21 @@ export async function loadPublishedPlanCatalogue(
       ? supabase
           .from("requirement_groups")
           .select("*")
-          .in("snapshot_id", requirementsSnapshotIds)
+          .in("version_id", requirementsSnapshotIds)
           .order("position")
       : Promise.resolve({ data: [], error: null }),
     requirementsSnapshotIds.length
       ? supabase
           .from("requirement_conditions")
           .select("*")
-          .in("snapshot_id", requirementsSnapshotIds)
+          .in("version_id", requirementsSnapshotIds)
           .order("position")
       : Promise.resolve({ data: [], error: null }),
     requirementsSnapshotIds.length
       ? supabase
           .from("requirement_condition_options")
           .select("*")
-          .in("snapshot_id", requirementsSnapshotIds)
+          .in("version_id", requirementsSnapshotIds)
           .order("position")
       : Promise.resolve({ data: [], error: null }),
   ]);
@@ -452,13 +454,13 @@ export async function loadPublishedPlanCatalogue(
   for (const option of requirementOptions) {
     if (option.kind !== "course") continue;
     const codes =
-      courseCodesBySnapshotId.get(option.snapshot_id) ?? new Set<string>();
+      courseCodesBySnapshotId.get(option.version_id) ?? new Set<string>();
     codes.add(option.code);
-    courseCodesBySnapshotId.set(option.snapshot_id, codes);
+    courseCodesBySnapshotId.set(option.version_id, codes);
   }
   const degrees = structureYears.flatMap((structureYear) => {
-    const identity = identitiesById.get(structureYear.item_id);
-    const snapshot = snapshotsById.get(structureYear.published_snapshot_id);
+    const identity = identitiesById.get(structureYear.code_id);
+    const snapshot = snapshotsById.get(structureYear.published_version_id);
     if (!identity || !snapshot || identity.kind !== "programme") return [];
     return [
       {
@@ -475,8 +477,8 @@ export async function loadPublishedPlanCatalogue(
     ];
   });
   const structures = structureYears.flatMap((structureYear) => {
-    const identity = identitiesById.get(structureYear.item_id);
-    const snapshot = snapshotsById.get(structureYear.published_snapshot_id);
+    const identity = identitiesById.get(structureYear.code_id);
+    const snapshot = snapshotsById.get(structureYear.published_version_id);
     if (!identity || !snapshot || !isPlanStructureKind(identity.kind))
       return [];
     return [
@@ -488,28 +490,28 @@ export async function loadPublishedPlanCatalogue(
     ];
   });
   const structureRequirements = structureYears.flatMap((structureYear) => {
-    const identity = identitiesById.get(structureYear.item_id);
-    const snapshot = snapshotsById.get(structureYear.published_snapshot_id);
+    const identity = identitiesById.get(structureYear.code_id);
+    const snapshot = snapshotsById.get(structureYear.published_version_id);
     if (
       !identity ||
       !snapshot ||
-      !requirementsSnapshotIdSet.has(structureYear.published_snapshot_id) ||
+      !requirementsSnapshotIdSet.has(structureYear.published_version_id) ||
       !isPlanStructureKind(identity.kind)
     ) {
       return [];
     }
-    const snapshotId = structureYear.published_snapshot_id;
+    const snapshotId = structureYear.published_version_id;
     return [
       {
         root: buildAcademicStructureRequirementTree({
           groups: requirementGroups.filter(
-            (group) => group.snapshot_id === snapshotId,
+            (group) => group.version_id === snapshotId,
           ),
           conditions: requirementConditions.filter(
-            (condition) => condition.snapshot_id === snapshotId,
+            (condition) => condition.version_id === snapshotId,
           ),
           options: requirementOptions.filter(
-            (option) => option.snapshot_id === snapshotId,
+            (option) => option.version_id === snapshotId,
           ),
         }),
         snapshotId,
@@ -521,7 +523,7 @@ export async function loadPublishedPlanCatalogue(
         unmodelled: requirementConditions
           .filter(
             (condition) =>
-              condition.snapshot_id === snapshotId &&
+              condition.version_id === snapshotId &&
               condition.condition_kind === "other" &&
               condition.free_text !== null,
           )
@@ -534,8 +536,8 @@ export async function loadPublishedPlanCatalogue(
     ];
   });
   const majors = structureYears.flatMap((structureYear) => {
-    const identity = identitiesById.get(structureYear.item_id);
-    const snapshot = snapshotsById.get(structureYear.published_snapshot_id);
+    const identity = identitiesById.get(structureYear.code_id);
+    const snapshot = snapshotsById.get(structureYear.published_version_id);
     if (!identity || !snapshot || identity.kind !== "major") return [];
     return [
       {
@@ -545,9 +547,8 @@ export async function loadPublishedPlanCatalogue(
         colour: "zinc",
         description: snapshot.description ?? "",
         courseCodes: [
-          ...(courseCodesBySnapshotId.get(
-            structureYear.published_snapshot_id,
-          ) ?? []),
+          ...(courseCodesBySnapshotId.get(structureYear.published_version_id) ??
+            []),
         ].sort(),
       } satisfies Major,
     ];
@@ -612,15 +613,15 @@ export async function loadCurrentUserPlanCatalogue(): Promise<PlanCatalogue> {
   const [itemsResult, attemptsResult, structuresResult] = await Promise.all([
     supabase
       .from("plan_items")
-      .select("course_id,academic_year_id")
+      .select("catalogue_record_id")
       .eq("plan_id", plan.id),
     supabase
       .from("course_attempts")
-      .select("course_id,course_snapshot_id")
+      .select("catalogue_version_id")
       .eq("owner_id", viewer.id),
     supabase
       .from("plan_structures")
-      .select("structure_year_id")
+      .select("catalogue_record_id")
       .eq("plan_id", plan.id),
   ]);
   if (itemsResult.error || attemptsResult.error || structuresResult.error) {
@@ -633,41 +634,50 @@ export async function loadCurrentUserPlanCatalogue(): Promise<PlanCatalogue> {
     []) as unknown as AttemptCourseRow[];
   const planStructures = (structuresResult.data ??
     []) as unknown as PlanStructureRow[];
-  const courseIds = collectPlanCatalogueCourseIds(planItems, courseAttempts);
-  const academicYearIds = [
-    ...new Set(planItems.map((item) => item.academic_year_id)),
-  ];
-  const snapshotIds = [
-    ...new Set(courseAttempts.map((attempt) => attempt.course_snapshot_id)),
+  const versionIds = [
+    ...new Set(courseAttempts.map((attempt) => attempt.catalogue_version_id)),
   ];
-  const [coursesResult, snapshotsResult] = await Promise.all([
-    courseIds.length
-      ? supabase.from("catalogue_items").select("id,code").in("id", courseIds)
-      : Promise.resolve({ data: [], error: null }),
-    snapshotIds.length
-      ? supabase
-          .from("catalogue_snapshots")
-          .select("id,academic_year_id")
-          .in("id", snapshotIds)
-      : Promise.resolve({ data: [], error: null }),
-  ]);
-  if (coursesResult.error || snapshotsResult.error) {
+  const versionsResult = versionIds.length
+    ? await supabase
+        .from("catalogue_versions")
+        .select("id,record_id")
+        .in("id", versionIds)
+    : { data: [], error: null };
+  if (versionsResult.error) {
     return loadPublishedPlanCatalogue(year.year);
   }
-  const attemptSnapshots = (snapshotsResult.data ?? []) as AttemptSnapshotRow[];
+  const attemptVersions = (versionsResult.data ?? []) as AttemptVersionRow[];
+  const recordIds = collectPlanCatalogueRecordIds(
+    planItems,
+    attemptVersions.map((version) => ({
+      catalogue_record_id: version.record_id,
+    })),
+  );
+  const recordsResult = recordIds.length
+    ? await supabase
+        .from("catalogue_records")
+        .select("id,code_id,academic_year_id")
+        .in("id", recordIds)
+    : { data: [], error: null };
+  if (recordsResult.error) return loadPublishedPlanCatalogue(year.year);
+  const records = (recordsResult.data ?? []) as CatalogueRecordRow[];
+  const courseIds = [...new Set(records.map((record) => record.code_id))];
   const allAcademicYearIds = [
-    ...new Set([
-      ...academicYearIds,
-      ...attemptSnapshots.map((snapshot) => snapshot.academic_year_id),
-    ]),
+    ...new Set(records.map((record) => record.academic_year_id)),
   ];
+  const coursesResult = courseIds.length
+    ? await supabase
+        .from("catalogue_codes")
+        .select("id,code")
+        .in("id", courseIds)
+    : { data: [], error: null };
   const academicYearsResult = allAcademicYearIds.length
     ? await supabase
         .from("academic_years")
         .select("id,year")
         .in("id", allAcademicYearIds)
     : { data: [], error: null };
-  if (academicYearsResult.error) {
+  if (coursesResult.error || academicYearsResult.error) {
     return loadPublishedPlanCatalogue(year.year);
   }
   const codeByCourseId = new Map(
@@ -679,51 +689,52 @@ export async function loadCurrentUserPlanCatalogue(): Promise<PlanCatalogue> {
       academicYear.year,
     ]),
   );
-  const academicYearIdBySnapshotId = new Map(
-    attemptSnapshots.map((snapshot) => [
-      snapshot.id,
-      snapshot.academic_year_id,
-    ]),
+  const recordById = new Map(records.map((record) => [record.id, record]));
+  const recordIdByVersionId = new Map(
+    attemptVersions.map((version) => [version.id, version.record_id]),
   );
   const selections = [
     ...planItems.flatMap((item) => {
-      const code = codeByCourseId.get(item.course_id);
-      const academicYear = yearByAcademicYearId.get(item.academic_year_id);
+      const record = recordById.get(item.catalogue_record_id);
+      const code = record ? codeByCourseId.get(record.code_id) : undefined;
+      const academicYear = record
+        ? yearByAcademicYearId.get(record.academic_year_id)
+        : undefined;
       return code && academicYear ? [{ code, year: academicYear }] : [];
     }),
     ...courseAttempts.flatMap((attempt) => {
-      const code = codeByCourseId.get(attempt.course_id);
-      const academicYear = yearByAcademicYearId.get(
-        academicYearIdBySnapshotId.get(attempt.course_snapshot_id) ?? -1,
+      const record = recordById.get(
+        recordIdByVersionId.get(attempt.catalogue_version_id) ?? -1,
       );
+      const code = record ? codeByCourseId.get(record.code_id) : undefined;
+      const academicYear = record
+        ? yearByAcademicYearId.get(record.academic_year_id)
+        : undefined;
       return code && academicYear ? [{ code, year: academicYear }] : [];
     }),
   ];
   const catalogue = await loadPublishedPlanCatalogue(
     year.year,
     selections,
-    planStructures.map((structure) => structure.structure_year_id),
+    planStructures.map((structure) => structure.catalogue_record_id),
   );
-  const publishedSnapshotIds = new Set(
+  const publishedVersionIds = new Set(
     catalogue.courses.flatMap((course) =>
       course.snapshotId === undefined ? [] : [course.snapshotId],
     ),
   );
-  const historicalSnapshotIds = snapshotIds.filter(
-    (snapshotId) => !publishedSnapshotIds.has(snapshotId),
+  const historicalSnapshotIds = versionIds.filter(
+    (snapshotId) => !publishedVersionIds.has(snapshotId),
   );
   const projectionsResult = historicalSnapshotIds.length
-    ? await supabase.rpc("current_user_course_attempt_snapshot_projections", {
-        p_snapshot_ids: historicalSnapshotIds,
+    ? await supabase.rpc("current_user_course_attempt_version_projections", {
+        p_version_ids: historicalSnapshotIds,
       })
     : { data: [], error: null };
   if (projectionsResult.error) return catalogue;
 
   const snapshotCourses = (projectionsResult.data ?? []).flatMap((row) => {
-    const course = courseFromSnapshotProjection(
-      row.projection,
-      row.snapshot_id,
-    );
+    const course = courseFromSnapshotProjection(row.projection, row.version_id);
     return course ? [planCourseFromDetails(course)] : [];
   });
   return { ...catalogue, snapshotCourses };
diff --git a/apps/web/lib/coursemap/plan-course-ids.ts b/apps/web/lib/coursemap/plan-course-ids.ts
index 0a3a9608..803361ab 100644
--- a/apps/web/lib/coursemap/plan-course-ids.ts
+++ b/apps/web/lib/coursemap/plan-course-ids.ts
@@ -1,12 +1,14 @@
-type CourseIdRow = { course_id: number };
+type CatalogueRecordIdRow = { catalogue_record_id: number };
 
-export function collectPlanCatalogueCourseIds(
-  planItems: readonly CourseIdRow[],
-  courseAttempts: readonly CourseIdRow[],
+export function collectPlanCatalogueRecordIds(
+  planItems: readonly CatalogueRecordIdRow[],
+  attemptedVersions: readonly CatalogueRecordIdRow[],
 ) {
   return [
     ...new Set(
-      [...planItems, ...courseAttempts].map((record) => record.course_id),
+      [...planItems, ...attemptedVersions].map(
+        (record) => record.catalogue_record_id,
+      ),
     ),
   ];
 }
diff --git a/apps/web/lib/coursemap/programme-structure-options.ts b/apps/web/lib/coursemap/programme-structure-options.ts
index 9a1afd4d..8ee0baa0 100644
--- a/apps/web/lib/coursemap/programme-structure-options.ts
+++ b/apps/web/lib/coursemap/programme-structure-options.ts
@@ -9,7 +9,7 @@ export type SelectableStructureKind =
 
 export type ProgrammeStructureRelationship = {
   relationship_kind: string;
-  snapshot_id: number;
+  version_id: number;
   target_code: string;
   target_kind: string;
 };
@@ -17,7 +17,7 @@ export type ProgrammeStructureRelationship = {
 export type ProgrammeStructureRequirementCondition = {
   condition_kind: string;
   id: number;
-  snapshot_id: number;
+  version_id: number;
   structure_kind: string | null;
 };
 
@@ -25,7 +25,7 @@ export type ProgrammeStructureRequirementOption = {
   code: string;
   condition_id: number;
   kind: string;
-  snapshot_id: number;
+  version_id: number;
 };
 
 export type SelectableStructureCodes = Record<
@@ -87,7 +87,7 @@ export function collectSelectableStructureCodes({
         relationship.relationship_kind === "option")
     ) {
       addCode(
-        relationship.snapshot_id,
+        relationship.version_id,
         relationship.target_kind,
         relationship.target_code,
       );
@@ -102,7 +102,7 @@ export function collectSelectableStructureCodes({
   >();
   for (const condition of requirementConditions) {
     if (
-      programmeSnapshotIds.has(condition.snapshot_id) &&
+      programmeSnapshotIds.has(condition.version_id) &&
       condition.condition_kind === "structure_set" &&
       isSelectableStructureKind(condition.structure_kind)
     ) {
@@ -117,10 +117,10 @@ export function collectSelectableStructureCodes({
     const condition = structureListConditions.get(option.condition_id);
     if (
       condition &&
-      condition.snapshot_id === option.snapshot_id &&
+      condition.version_id === option.version_id &&
       option.kind === condition.structure_kind
     ) {
-      addCode(option.snapshot_id, condition.structure_kind, option.code);
+      addCode(option.version_id, condition.structure_kind, option.code);
     }
   }
 
diff --git a/apps/web/lib/coursemap/published-courses.ts b/apps/web/lib/coursemap/published-courses.ts
index 72f635bc..9cd8c11b 100644
--- a/apps/web/lib/coursemap/published-courses.ts
+++ b/apps/web/lib/coursemap/published-courses.ts
@@ -45,7 +45,7 @@ type SnapshotListRow = {
   offering_status: string;
   prescribed_texts: string | null;
   school: string | null;
-  snapshot_id: number;
+  version_id: number;
   source_updated_at: string | null;
   subject_code: string | null;
   subject_name: string | null;
@@ -56,7 +56,7 @@ type SnapshotListRow = {
   workload_text: string | null;
 };
 type OfferingRow = {
-  snapshot_id: number;
+  version_id: number;
   delivery_mode: string | null;
   id: number;
   location: string | null;
@@ -68,7 +68,7 @@ type OfferingSessionRow = {
   class_number: string | null;
   class_summary_url: string | null;
   course_offering_id: number;
-  snapshot_id: number | null;
+  version_id: number | null;
   delivery_mode: string | null;
   ends_on: string | null;
   enrol_closes_on: string | null;
@@ -78,7 +78,7 @@ type OfferingSessionRow = {
 };
 type RuleRow = {
   confidence: number;
-  snapshot_id: number | null;
+  version_id: number | null;
   id: number;
   review_state: string;
   rule_kind: string;
@@ -86,15 +86,15 @@ type RuleRow = {
 };
 type RuleReferenceRow = {
   rule_id: number;
-  item_id: number;
+  code_id: number;
 };
 type RuleConditionRow = {
   rule_id: number;
-  item_id: number | null;
+  code_id: number | null;
 };
 
 const SNAPSHOT_LIST_SELECT =
-  "snapshot_id,code,title,unit_value_kind,units,minimum_units,maximum_units,eftsl,level,subject_code,subject_name,school,college,academic_career,convener_text,delivery_summary,introduction,description,workload_text,workload_hours,inherent_requirements,prescribed_texts,offering_status,source_updated_at";
+  "version_id,code,title,unit_value_kind,units,minimum_units,maximum_units,eftsl,level,subject_code,subject_name,school,college,academic_career,convener_text,delivery_summary,introduction,description,workload_text,workload_hours,inherent_requirements,prescribed_texts,offering_status,source_updated_at";
 
 export type PublishedCourseFilters = {
   query?: string;
@@ -927,12 +927,12 @@ async function loadAcademicYearOptionsUncached(): Promise<
   return Promise.all(
     ((years ?? []) as AcademicYearRow[]).map(async (year) => {
       const { count, error: countError } = await supabase
-        .from("catalogue_item_years")
+        .from("catalogue_records")
         .select("id", { count: "exact", head: true })
         .eq("academic_year_id", year.id)
         .eq("kind", "course")
         .is("archived_at", null)
-        .not("published_snapshot_id", "is", null);
+        .not("published_version_id", "is", null);
       if (countError) throw countError;
       return { year: year.year, hasPublishedCourses: (count ?? 0) > 0 };
     }),
@@ -968,14 +968,14 @@ async function snapshotIdsForSession(
 ) {
   const { data, error } = await supabase
     .from("offering_sessions")
-    .select("snapshot_id")
+    .select("version_id")
     .eq("academic_year_id", yearId)
     .eq("academic_period_name", session);
   if (error) throw error;
   return [
     ...new Set(
       (data ?? []).flatMap((row) =>
-        row.snapshot_id === null ? [] : [row.snapshot_id],
+        row.version_id === null ? [] : [row.version_id],
       ),
     ),
   ];
@@ -986,17 +986,17 @@ async function loadListRelationships(
   snapshots: SnapshotListRow[],
   year: AcademicYearRow,
 ) {
-  const snapshotIds = snapshots.map((snapshot) => snapshot.snapshot_id);
+  const snapshotIds = snapshots.map((snapshot) => snapshot.version_id);
   if (snapshotIds.length === 0) return [];
   const [offeringsResult, rulesResult] = await Promise.all([
     supabase
       .from("course_offerings")
-      .select("id,snapshot_id,delivery_mode,location")
-      .in("snapshot_id", snapshotIds),
+      .select("id,version_id,delivery_mode,location")
+      .in("version_id", snapshotIds),
     supabase
       .from("requirement_rules")
-      .select("id,snapshot_id,rule_kind,source_text,confidence,review_state")
-      .in("snapshot_id", snapshotIds)
+      .select("id,version_id,rule_kind,source_text,confidence,review_state")
+      .in("version_id", snapshotIds)
       .in("rule_kind", ["prerequisite", "incompatibility"]),
   ]);
   if (offeringsResult.error) throw offeringsResult.error;
@@ -1011,23 +1011,23 @@ async function loadListRelationships(
         ? supabase
             .from("offering_sessions")
             .select(
-              "course_offering_id,snapshot_id,position,academic_period_code,academic_period_name,class_number,starts_on,enrol_closes_on,census_on,ends_on,delivery_mode,location,class_summary_url",
+              "course_offering_id,version_id,position,academic_period_code,academic_period_name,class_number,starts_on,enrol_closes_on,census_on,ends_on,delivery_mode,location,class_summary_url",
             )
             .in("course_offering_id", offeringIds)
         : Promise.resolve({ data: [], error: null }),
       ruleIds.length
         ? supabase
             .from("requirement_item_references")
-            .select("rule_id,item_id")
+            .select("rule_id,code_id")
             .in("rule_id", ruleIds)
         : Promise.resolve({ data: [], error: null }),
       ruleIds.length
         ? supabase
             .from("requirement_conditions")
-            .select("rule_id,item_id")
+            .select("rule_id,code_id")
             .in("rule_id", ruleIds)
             .eq("condition_kind", "course")
-            .not("item_id", "is", null)
+            .not("code_id", "is", null)
         : Promise.resolve({ data: [], error: null }),
     ]);
   if (sessionsResult.error) throw sessionsResult.error;
@@ -1037,28 +1037,28 @@ async function loadListRelationships(
   const conditions = (conditionsResult.data ?? []) as RuleConditionRow[];
   const referencedIds = [
     ...new Set([
-      ...references.map((reference) => reference.item_id),
+      ...references.map((reference) => reference.code_id),
       ...conditions.flatMap((condition) =>
-        condition.item_id === null ? [] : [condition.item_id],
+        condition.code_id === null ? [] : [condition.code_id],
       ),
     ]),
   ];
   const [referencedResult, publishedReferencesResult] = await Promise.all([
     referencedIds.length
       ? supabase
-          .from("catalogue_items")
+          .from("catalogue_codes")
           .select("id,code")
           .in("id", referencedIds)
       : Promise.resolve({ data: [], error: null }),
     referencedIds.length
       ? supabase
-          .from("catalogue_item_years")
-          .select("item_id")
+          .from("catalogue_records")
+          .select("code_id")
           .eq("academic_year_id", year.id)
           .eq("kind", "course")
           .is("archived_at", null)
-          .in("item_id", referencedIds)
-          .not("published_snapshot_id", "is", null)
+          .in("code_id", referencedIds)
+          .not("published_version_id", "is", null)
       : Promise.resolve({ data: [], error: null }),
   ]);
   if (referencedResult.error) throw referencedResult.error;
@@ -1071,46 +1071,46 @@ async function loadListRelationships(
     ]),
   );
   const publishedReferenceIds = new Set(
-    (publishedReferencesResult.data ?? []).map((row) => row.item_id),
+    (publishedReferencesResult.data ?? []).map((row) => row.code_id),
   );
   const offeringBySnapshot = new Map(
-    offerings.map((offering) => [offering.snapshot_id, offering]),
+    offerings.map((offering) => [offering.version_id, offering]),
   );
   const sessions = (sessionsResult.data ?? []) as OfferingSessionRow[];
   const sessionsBySnapshot = new Map<number, OfferingSessionRow[]>();
   for (const session of sessions) {
-    if (session.snapshot_id === null) continue;
-    const existing = sessionsBySnapshot.get(session.snapshot_id) ?? [];
+    if (session.version_id === null) continue;
+    const existing = sessionsBySnapshot.get(session.version_id) ?? [];
     existing.push(session);
-    sessionsBySnapshot.set(session.snapshot_id, existing);
+    sessionsBySnapshot.set(session.version_id, existing);
   }
   const rulesBySnapshot = new Map<number, RuleRow[]>();
   for (const rule of rules) {
-    if (rule.snapshot_id === null) continue;
-    const existing = rulesBySnapshot.get(rule.snapshot_id) ?? [];
+    if (rule.version_id === null) continue;
+    const existing = rulesBySnapshot.get(rule.version_id) ?? [];
     existing.push(rule);
-    rulesBySnapshot.set(rule.snapshot_id, existing);
+    rulesBySnapshot.set(rule.version_id, existing);
   }
   const referencedIdsByRule = new Map<number, Set<number>>();
   for (const reference of references) {
     const existing =
       referencedIdsByRule.get(reference.rule_id) ?? new Set<number>();
-    existing.add(reference.item_id);
+    existing.add(reference.code_id);
     referencedIdsByRule.set(reference.rule_id, existing);
   }
   for (const condition of conditions) {
-    if (condition.item_id === null) continue;
+    if (condition.code_id === null) continue;
     const existing =
       referencedIdsByRule.get(condition.rule_id) ?? new Set<number>();
-    existing.add(condition.item_id);
+    existing.add(condition.code_id);
     referencedIdsByRule.set(condition.rule_id, existing);
   }
 
   return snapshots.flatMap((snapshot) => {
     const code = snapshot.code;
-    const snapshotSessions = sessionsBySnapshot.get(snapshot.snapshot_id) ?? [];
-    const offering = offeringBySnapshot.get(snapshot.snapshot_id);
-    const snapshotRules = rulesBySnapshot.get(snapshot.snapshot_id) ?? [];
+    const snapshotSessions = sessionsBySnapshot.get(snapshot.version_id) ?? [];
+    const offering = offeringBySnapshot.get(snapshot.version_id);
+    const snapshotRules = rulesBySnapshot.get(snapshot.version_id) ?? [];
     const prerequisiteRules = snapshotRules.filter(
       (rule) => rule.rule_kind === "prerequisite",
     );
@@ -1163,7 +1163,7 @@ async function loadListRelationships(
         attributes: [],
         availableCourseCodes: availableCodes,
         code,
-        snapshotId: snapshot.snapshot_id,
+        snapshotId: snapshot.version_id,
         college: snapshot.college,
         convener: snapshot.convener_text ?? "Not listed",
         corequisiteText: "",
@@ -1276,7 +1276,7 @@ async function loadPublishedCoursePageUncached({
     snapshotsQuery = snapshotsQuery.eq("level", level * 1000);
   }
   if (sessionSnapshotIds) {
-    snapshotsQuery = snapshotsQuery.in("snapshot_id", sessionSnapshotIds);
+    snapshotsQuery = snapshotsQuery.in("version_id", sessionSnapshotIds);
   }
   if (cleanedQuery) {
     const pattern = `*${cleanedQuery}*`;
diff --git a/apps/web/lib/coursemap/requisite-progress.ts b/apps/web/lib/coursemap/requisite-progress.ts
index 4b263412..b1bf31cb 100644
--- a/apps/web/lib/coursemap/requisite-progress.ts
+++ b/apps/web/lib/coursemap/requisite-progress.ts
@@ -11,7 +11,7 @@ export type RequisiteCompletionSnapshot = {
 };
 
 type AttemptRow = {
-  course_id: number;
+  catalogue_version_id: number;
   units_earned: number;
 };
 
@@ -35,18 +35,43 @@ export async function loadCurrentUserRequisiteCompletion(): Promise<RequisiteCom
     const supabase = await createClient();
     const { data: attempts, error: attemptsError } = await supabase
       .from("course_attempts")
-      .select("course_id,units_earned")
+      .select("catalogue_version_id,units_earned")
       .eq("owner_id", viewer.id)
       .eq("status", "completed");
     if (attemptsError) throw attemptsError;
 
     const attemptRows = (attempts ?? []) as AttemptRow[];
-    const courseIds = [
-      ...new Set(attemptRows.map((attempt) => attempt.course_id)),
-    ];
+    const versionIds = attemptRows.map(
+      (attempt) => attempt.catalogue_version_id,
+    );
+    const { data: versions, error: versionsError } = versionIds.length
+      ? await supabase
+          .from("catalogue_versions")
+          .select("id,record_id")
+          .in("id", versionIds)
+      : { data: [], error: null };
+    if (versionsError) throw versionsError;
+    const recordIds = (versions ?? []).map((version) => version.record_id);
+    const { data: records, error: recordsError } = recordIds.length
+      ? await supabase
+          .from("catalogue_records")
+          .select("id,code_id")
+          .in("id", recordIds)
+      : { data: [], error: null };
+    if (recordsError) throw recordsError;
+    const codeIdByRecordId = new Map(
+      (records ?? []).map((record) => [record.id, record.code_id]),
+    );
+    const codeIdByVersionId = new Map(
+      (versions ?? []).map((version) => [
+        version.id,
+        codeIdByRecordId.get(version.record_id),
+      ]),
+    );
+    const courseIds = [...new Set(codeIdByRecordId.values())];
     const { data: courses, error: coursesError } = courseIds.length
       ? await supabase
-          .from("catalogue_items")
+          .from("catalogue_codes")
           .select("code,id")
           .in("id", courseIds)
       : { data: [], error: null };
@@ -60,7 +85,8 @@ export async function loadCurrentUserRequisiteCompletion(): Promise<RequisiteCom
     );
     return {
       completedCourses: attemptRows.flatMap((attempt) => {
-        const code = codeByCourseId.get(attempt.course_id);
+        const codeId = codeIdByVersionId.get(attempt.catalogue_version_id);
+        const code = codeId ? codeByCourseId.get(codeId) : undefined;
         return code && attempt.units_earned > 0
           ? [{ code, units: attempt.units_earned }]
           : [];
@@ -98,29 +124,29 @@ async function loadEnrolledProgrammeCodes(
 
   const { data: planStructures, error: planStructuresError } = await supabase
     .from("plan_structures")
-    .select("structure_year_id")
+    .select("catalogue_record_id")
     .eq("plan_id", plan.id)
     .eq("role", "programme");
   if (planStructuresError) return [];
   const structureYearIds = (planStructures ?? []).map(
-    (row) => row.structure_year_id,
+    (row) => row.catalogue_record_id,
   );
   if (structureYearIds.length === 0) return [];
 
   const { data: structureYears, error: structureYearsError } = await supabase
-    .from("catalogue_item_years")
-    .select("item_id")
+    .from("catalogue_records")
+    .select("code_id")
     .in("id", structureYearIds);
   if (structureYearsError) return [];
   const structureIds = [
     ...new Set(
-      (structureYears ?? []).map((structureYear) => structureYear.item_id),
+      (structureYears ?? []).map((structureYear) => structureYear.code_id),
     ),
   ];
   if (structureIds.length === 0) return [];
 
   const { data: structures, error: structuresError } = await supabase
-    .from("catalogue_items")
+    .from("catalogue_codes")
     .select("code")
     .in("id", structureIds);
   if (structuresError) return [];
diff --git a/apps/web/lib/coursemap/requisite-search-actions.ts b/apps/web/lib/coursemap/requisite-search-actions.ts
index 86faf879..9b7a0a6a 100644
--- a/apps/web/lib/coursemap/requisite-search-actions.ts
+++ b/apps/web/lib/coursemap/requisite-search-actions.ts
@@ -16,17 +16,17 @@ export type RequisiteCourseSearchResult = {
 };
 
 // The details tables join through a composite key, so PostgREST types them as
-// arrays even though each snapshot has at most one details row.
+// arrays even though each version has at most one details row.
 type ItemYearEmbed = {
   academic_years: { year: number } | null;
   published: {
-    course_snapshot_details: { title: string }[];
-    structure_snapshot_details: { name: string }[];
+    course_version_details: { title: string }[];
+    structure_version_details: { name: string }[];
   } | null;
 };
 
 const ITEM_SEARCH_SELECT =
-  "code,kind,catalogue_item_years(academic_years(year),published:catalogue_snapshots!catalogue_item_years_published_snapshot_fkey(course_snapshot_details(title),structure_snapshot_details(name)))";
+  "code,kind,catalogue_records(academic_years(year),published:catalogue_versions!catalogue_records_published_version_fkey(course_version_details(title),structure_version_details(name)))";
 
 function yearsNewestFirst(itemYears: ItemYearEmbed[]) {
   return itemYears
@@ -52,7 +52,7 @@ export async function searchRequisiteCourses(
   try {
     const supabase = await createClient();
     const { data, error } = await supabase
-      .from("catalogue_items")
+      .from("catalogue_codes")
       .select(ITEM_SEARCH_SELECT)
       .eq("kind", "course")
       .ilike("code", `%${term}%`)
@@ -64,13 +64,13 @@ export async function searchRequisiteCourses(
       code: item.code,
       subject: item.code.slice(0, 4),
       title:
-        item.catalogue_item_years
+        item.catalogue_records
           .map(
             (itemYear) =>
-              itemYear.published?.course_snapshot_details[0]?.title ?? null,
+              itemYear.published?.course_version_details[0]?.title ?? null,
           )
           .find((value) => value !== null) ?? null,
-      years: yearsNewestFirst(item.catalogue_item_years),
+      years: yearsNewestFirst(item.catalogue_records),
     }));
   } catch {
     return [];
@@ -94,7 +94,7 @@ export async function searchRequisiteProgrammes(
   try {
     const supabase = await createClient();
     const { data, error } = await supabase
-      .from("catalogue_items")
+      .from("catalogue_codes")
       .select(ITEM_SEARCH_SELECT)
       .neq("kind", "course")
       .ilike("code", `%${term}%`)
@@ -106,13 +106,13 @@ export async function searchRequisiteProgrammes(
       code: item.code,
       kind: item.kind,
       title:
-        item.catalogue_item_years
+        item.catalogue_records
           .map(
             (itemYear) =>
-              itemYear.published?.structure_snapshot_details[0]?.name ?? null,
+              itemYear.published?.structure_version_details[0]?.name ?? null,
           )
           .find((value) => value !== null) ?? null,
-      years: yearsNewestFirst(item.catalogue_item_years),
+      years: yearsNewestFirst(item.catalogue_records),
     }));
   } catch {
     return [];
diff --git a/apps/web/lib/coursemap/state.ts b/apps/web/lib/coursemap/state.ts
index dadbc88a..9ceda18b 100644
--- a/apps/web/lib/coursemap/state.ts
+++ b/apps/web/lib/coursemap/state.ts
@@ -3,8 +3,7 @@ import type { AuthViewer } from "@/lib/auth/viewer";
 import { createClient } from "@/lib/supabase/server";
 
 type PlanItemRow = {
-  academic_year_id: number;
-  course_id: number;
+  catalogue_record_id: number;
   id: string;
   planned_calendar_year: number | null;
   planned_period_code: string | null;
@@ -12,8 +11,7 @@ type PlanItemRow = {
 
 type CourseAttemptRow = {
   academic_period_id: number;
-  course_id: number;
-  course_snapshot_id: number;
+  catalogue_version_id: number;
   id: string;
   mark: number | null;
   grade?: string | null;
@@ -59,7 +57,7 @@ export async function hasPrimaryPlan(viewer: AuthViewer) {
 
 export type PlanStructureSelection = {
   role: string;
-  structure_year_id: number;
+  catalogue_record_id: number;
 };
 
 /**
@@ -75,12 +73,12 @@ export function planStructureCodes(
   const codesFor = (role: string) =>
     structures.flatMap((item) => {
       if (item.role !== role) return [];
-      const code = codeByYear.get(item.structure_year_id);
+      const code = codeByYear.get(item.catalogue_record_id);
       return code ? [code] : [];
     });
   const codeForFirst = (role: string) =>
     codeByYear.get(
-      structures.find((item) => item.role === role)?.structure_year_id ?? -1,
+      structures.find((item) => item.role === role)?.catalogue_record_id ?? -1,
     );
 
   return {
@@ -133,88 +131,83 @@ export async function loadCoursemapState(
           .maybeSingle(),
         supabase
           .from("plan_structures")
-          .select("role,structure_year_id")
+          .select("role,catalogue_record_id")
           .eq("plan_id", plan.id)
           .order("position"),
         supabase
           .from("plan_items")
           .select(
-            "id,course_id,academic_year_id,planned_calendar_year,planned_period_code,sort_order",
+            "id,catalogue_record_id,planned_calendar_year,planned_period_code,sort_order",
           )
           .eq("plan_id", plan.id)
           .order("sort_order"),
         supabase
           .from("course_attempts")
           .select(
-            "id,course_id,course_snapshot_id,academic_period_id,status,mark,grade,units_attempted,units_earned",
+            "id,catalogue_version_id,academic_period_id,status,mark,grade,units_attempted,units_earned",
           )
           .eq("owner_id", viewer.id)
           .order("created_at"),
       ]);
 
     const structures = structuresResult.data ?? [];
-    const structureYearIds = structures.map((item) => item.structure_year_id);
-    const { data: structureYears } = structureYearIds.length
-      ? await supabase
-          .from("catalogue_item_years")
-          .select("id,item_id")
-          .in("id", structureYearIds)
-      : { data: [] };
-    const structureIds = (structureYears ?? []).map((item) => item.item_id);
-    const { data: structureIdentities } = structureIds.length
-      ? await supabase
-          .from("catalogue_items")
-          .select("id,code")
-          .in("id", structureIds)
-      : { data: [] };
-    const structureCodeByYear = new Map(
-      (structureYears ?? []).map((structureYear) => [
-        structureYear.id,
-        (structureIdentities ?? []).find(
-          (identity) => identity.id === structureYear.item_id,
-        )?.code,
-      ]),
-    );
-
     const items = (itemsResult.data ?? []) as unknown as PlanItemRow[];
     const attempts = (attemptsResult.data ??
       []) as unknown as CourseAttemptRow[];
-    const courseIds = [
-      ...new Set([
-        ...items.map((item) => item.course_id),
-        ...attempts.map((attempt) => attempt.course_id),
-      ]),
-    ];
     const periodIds = [
       ...new Set(attempts.map((item) => item.academic_period_id)),
     ];
     const snapshotIds = [
-      ...new Set(attempts.map((item) => item.course_snapshot_id)),
+      ...new Set(attempts.map((item) => item.catalogue_version_id)),
     ];
-    const [{ data: courseIdentities }, { data: periods }, snapshotsResult] =
-      await Promise.all([
-        courseIds.length
-          ? supabase
-              .from("catalogue_items")
-              .select("id,code")
-              .in("id", courseIds)
-          : Promise.resolve({ data: [] }),
-        periodIds.length
-          ? supabase
-              .from("academic_periods")
-              .select("id,calendar_year,code")
-              .in("id", periodIds)
-          : Promise.resolve({ data: [] }),
-        snapshotIds.length
-          ? supabase
-              .from("catalogue_snapshots")
-              .select("id,academic_year_id")
-              .in("id", snapshotIds)
-          : Promise.resolve({ data: [] }),
-      ]);
+    const [{ data: periods }, snapshotsResult] = await Promise.all([
+      periodIds.length
+        ? supabase
+            .from("academic_periods")
+            .select("id,calendar_year,code")
+            .in("id", periodIds)
+        : Promise.resolve({ data: [] }),
+      snapshotIds.length
+        ? supabase
+            .from("catalogue_versions")
+            .select("id,record_id,academic_year_id")
+            .in("id", snapshotIds)
+        : Promise.resolve({ data: [] }),
+    ]);
+    const recordIds = [
+      ...new Set([
+        ...structures.map((item) => item.catalogue_record_id),
+        ...items.map((item) => item.catalogue_record_id),
+        ...(snapshotsResult.data ?? []).map((version) => version.record_id),
+      ]),
+    ];
+    const { data: records } = recordIds.length
+      ? await supabase
+          .from("catalogue_records")
+          .select("id,code_id,academic_year_id")
+          .in("id", recordIds)
+      : { data: [] };
+    const codeIds = [
+      ...new Set((records ?? []).map((record) => record.code_id)),
+    ];
+    const { data: courseIdentities } = codeIds.length
+      ? await supabase
+          .from("catalogue_codes")
+          .select("id,code")
+          .in("id", codeIds)
+      : { data: [] };
+    const recordById = new Map(
+      (records ?? []).map((record) => [record.id, record]),
+    );
+    const versionRecordId = new Map(
+      (snapshotsResult.data ?? []).map((version) => [
+        version.id,
+        version.record_id,
+      ]),
+    );
     const academicYearIds = [
       ...new Set([
-        ...items.map((item) => item.academic_year_id),
+        ...(records ?? []).map((record) => record.academic_year_id),
         ...(snapshotsResult.data ?? []).map(
           (snapshot) => snapshot.academic_year_id,
         ),
@@ -238,17 +231,26 @@ export async function loadCoursemapState(
     const courseCode = new Map(
       (courseIdentities ?? []).map((course) => [course.id, course.code]),
     );
+    const structureCodeByYear = new Map(
+      (records ?? []).map((record) => [
+        record.id,
+        courseCode.get(record.code_id),
+      ]),
+    );
     const periodById = new Map(
       (periods ?? []).map((period) => [period.id, period]),
     );
 
     const plannedAttempts = items.flatMap((item) => {
-      const code = courseCode.get(item.course_id);
+      const record = recordById.get(item.catalogue_record_id);
+      const code = record ? courseCode.get(record.code_id) : undefined;
       if (!code) return [];
       return [
         {
           id: item.id,
-          academicYear: academicYearById.get(item.academic_year_id),
+          academicYear: record
+            ? academicYearById.get(record.academic_year_id)
+            : undefined,
           courseCode: code,
           termId:
             item.planned_calendar_year && item.planned_period_code
@@ -259,7 +261,9 @@ export async function loadCoursemapState(
       ];
     });
     const recordedAttempts = attempts.flatMap((attempt) => {
-      const code = courseCode.get(attempt.course_id);
+      const recordId = versionRecordId.get(attempt.catalogue_version_id);
+      const record = recordId ? recordById.get(recordId) : undefined;
+      const code = record ? courseCode.get(record.code_id) : undefined;
       const period = periodById.get(attempt.academic_period_id);
       if (
         !code ||
@@ -273,10 +277,10 @@ export async function loadCoursemapState(
         {
           id: attempt.id,
           academicYear: academicYearById.get(
-            snapshotAcademicYearId.get(attempt.course_snapshot_id) ?? -1,
+            snapshotAcademicYearId.get(attempt.catalogue_version_id) ?? -1,
           ),
           courseCode: code,
-          snapshotId: attempt.course_snapshot_id,
+          snapshotId: attempt.catalogue_version_id,
           termId: `${period.calendar_year}-${period.code.toLowerCase()}`,
           status: (attempt.status === "credited"
             ? "completed"
diff --git a/apps/web/lib/coursemap/structure-snapshot-view.ts b/apps/web/lib/coursemap/structure-version-view.ts
similarity index 92%
rename from apps/web/lib/coursemap/structure-snapshot-view.ts
rename to apps/web/lib/coursemap/structure-version-view.ts
index fc277fcb..d4cd65b9 100644
--- a/apps/web/lib/coursemap/structure-snapshot-view.ts
+++ b/apps/web/lib/coursemap/structure-version-view.ts
@@ -1,4 +1,4 @@
-import type { CatalogueSnapshotWrite } from "@/lib/catalogue-import/snapshot-write";
+import type { CatalogueContent } from "@/lib/catalogue/content";
 import { requirementTreeFromSource } from "@/lib/coursemap/requirement-write-tree";
 import {
   REQUIREMENT_SOURCE_SECTION_KEYS,
@@ -7,10 +7,10 @@ import {
 
 /** The reader's view of a structure snapshot that has not been published yet. */
 export function structureDetailsFromWrite(
-  write: CatalogueSnapshotWrite,
+  write: CatalogueContent,
 ): StructureDetails | null {
+  if (write.kind === "course") return null;
   const structure = write.structure;
-  if (!structure || write.kind === "course") return null;
   const details = structure.details;
   const requirements = requirementTreeFromSource(
     write.requirements,
diff --git a/apps/web/playwright/catalogue-review.spec.ts b/apps/web/playwright/catalogue-review.spec.ts
index 6d17a891..685e8b06 100644
--- a/apps/web/playwright/catalogue-review.spec.ts
+++ b/apps/web/playwright/catalogue-review.spec.ts
@@ -18,17 +18,14 @@ test("administrators review, apply and publish an import candidate", async ({
   let runId: string | null = null;
   try {
     const [seed] = await sql`
-      select item_years.id as item_year_id, item_years.academic_year_id, item_years.item_id,
-        item_years.published_snapshot_id, details.title
-      from public.catalogue_item_years as item_years
-      join public.catalogue_items as items on items.id = item_years.item_id
-      join public.course_snapshot_details as details on details.snapshot_id = item_years.published_snapshot_id
-      where items.code = 'COMP1110' and item_years.draft_snapshot_id is null
+      select item_years.id as record_id, item_years.academic_year_id, item_years.code_id,
+        item_years.published_version_id, details.title
+      from public.catalogue_records as item_years
+      join public.catalogue_codes as items on items.id = item_years.code_id
+      join public.course_version_details as details on details.version_id = item_years.published_version_id
+      where items.code = 'COMP1110'
     `;
-    expect(
-      seed,
-      "the local seed publishes COMP1110 without a draft",
-    ).toBeTruthy();
+    expect(seed, "the local seed publishes COMP1110").toBeTruthy();
 
     const [model] =
       await sql`select id from public.import_models order by id limit 1`;
@@ -44,25 +41,25 @@ test("administrators review, apply and publish an import candidate", async ({
     runId = String(run.id);
     const [target] = await sql`
       insert into public.catalogue_import_targets (
-        run_id, kind, code, academic_year_id, item_id, item_year_id, baseline_snapshot_id,
+        run_id, kind, code, academic_year_id, code_id, record_id, baseline_version_id,
         status, change_kind, attempt_count, completed_at
       ) values (
-        ${runId}::uuid, 'course', 'COMP1110', ${seed.academic_year_id}, ${seed.item_id},
-        ${seed.item_year_id}, ${seed.published_snapshot_id}, 'ready', 'changed', 1, now()
+        ${runId}::uuid, 'course', 'COMP1110', ${seed.academic_year_id}, ${seed.code_id},
+        ${seed.record_id}, ${seed.published_version_id}, 'ready', 'changed', 1, now()
       ) returning id
     `;
     // The candidate copies the published snapshot with a revised title.
     const [candidate] = await sql`
-      insert into public.catalogue_snapshots (
-        item_year_id, kind, academic_year_id, origin, based_on_snapshot_id, content_hash, import_target_id
+      insert into public.catalogue_versions (
+        record_id, kind, academic_year_id, origin, based_on_version_id, content_hash, import_target_id
       ) values (
-        ${seed.item_year_id}, 'course', ${seed.academic_year_id}, 'import', ${seed.published_snapshot_id},
+        ${seed.record_id}, 'course', ${seed.academic_year_id}, 'import', ${seed.published_version_id},
         repeat('b', 64), ${target.id}::uuid
       ) returning id
     `;
     await sql`
-      insert into public.course_snapshot_details (
-        snapshot_id, title, unit_value_kind, units, minimum_units, maximum_units, eftsl, level,
+      insert into public.course_version_details (
+        version_id, title, unit_value_kind, units, minimum_units, maximum_units, eftsl, level,
         subject_code, subject_name, school, college, academic_career, convener_text, delivery_summary,
         introduction, description, workload_text, workload_hours, inherent_requirements,
         prescribed_texts, offering_status, source_updated_at
@@ -73,9 +70,9 @@ test("administrators review, apply and publish an import candidate", async ({
         details.delivery_summary, details.introduction, 'A revised description for review.', details.workload_text,
         details.workload_hours, details.inherent_requirements, details.prescribed_texts, details.offering_status,
         details.source_updated_at
-      from public.course_snapshot_details as details where details.snapshot_id = ${seed.published_snapshot_id}
+      from public.course_version_details as details where details.version_id = ${seed.published_version_id}
     `;
-    await sql`update public.catalogue_import_targets set candidate_snapshot_id = ${candidate.id} where id = ${target.id}::uuid`;
+    await sql`update public.catalogue_import_targets set candidate_version_id = ${candidate.id} where id = ${target.id}::uuid`;
     await sql`
       insert into public.catalogue_import_changes (target_id, entry_kind, field_path, old_value, new_value, summary, position)
       values
@@ -140,9 +137,9 @@ test("administrators review, apply and publish an import candidate", async ({
 
     const [after] = await sql`
       select details.title, details.description
-      from public.catalogue_item_years as item_years
-      join public.course_snapshot_details as details on details.snapshot_id = item_years.published_snapshot_id
-      where item_years.id = ${seed.item_year_id}
+      from public.catalogue_records as item_years
+      join public.course_version_details as details on details.version_id = item_years.published_version_id
+      where item_years.id = ${seed.record_id}
     `;
     expect(after.title).toBe(`${seed.title} (revised)`);
     expect(after.description).not.toBe("A revised description for review.");
@@ -154,14 +151,14 @@ test("administrators review, apply and publish an import candidate", async ({
   } finally {
     // Restore the seed: republish the original snapshot and remove the run.
     const [seed] = await sql`
-      select item_years.id from public.catalogue_item_years as item_years
-      join public.catalogue_items as items on items.id = item_years.item_id where items.code = 'COMP1110'
+      select item_years.id from public.catalogue_records as item_years
+      join public.catalogue_codes as items on items.id = item_years.code_id where items.code = 'COMP1110'
     `;
     const [original] = await sql`
-      select id from public.catalogue_snapshots where item_year_id = ${seed.id} and import_target_id is null
+      select id from public.catalogue_versions where record_id = ${seed.id} and import_target_id is null
       order by created_at limit 1
     `;
-    await sql`update public.catalogue_item_years set draft_snapshot_id = null, published_snapshot_id = ${original.id} where id = ${seed.id}`;
+    await sql`update public.catalogue_records set published_version_id = ${original.id} where id = ${seed.id}`;
     if (runId)
       await sql`delete from public.catalogue_import_runs where id = ${runId}::uuid`;
     await sql.end();
diff --git a/apps/web/playwright/catalogue-workspace.spec.ts b/apps/web/playwright/catalogue-workspace.spec.ts
index 2212f346..81e2480b 100644
--- a/apps/web/playwright/catalogue-workspace.spec.ts
+++ b/apps/web/playwright/catalogue-workspace.spec.ts
@@ -4,10 +4,10 @@ import { expect, login, test } from "./fixtures";
 
 /**
  * The record workspace: preview the published course, edit its title and a
- * learning outcome, save as a draft, publish, then restore the original from
- * history and discard that draft.
+ * learning outcome, save a new version, publish, then restore the original
+ * content through another immutable version.
  */
-test("administrators edit, preview, publish and restore a course snapshot", async ({
+test("administrators edit, preview, publish and restore a course version", async ({
   page,
   administrator,
 }) => {
@@ -15,16 +15,13 @@ test("administrators edit, preview, publish and restore a course snapshot", asyn
     max: 1,
   });
   const [seed] = await sql`
-    select item_years.id as item_year_id, item_years.published_snapshot_id, details.title
-    from public.catalogue_item_years as item_years
-    join public.catalogue_items as items on items.id = item_years.item_id
-    join public.course_snapshot_details as details on details.snapshot_id = item_years.published_snapshot_id
-    where items.code = 'COMP1100' and item_years.draft_snapshot_id is null
+    select item_years.id as record_id, item_years.published_version_id, details.title
+    from public.catalogue_records as item_years
+    join public.catalogue_codes as items on items.id = item_years.code_id
+    join public.course_version_details as details on details.version_id = item_years.published_version_id
+    where items.code = 'COMP1100'
   `;
-  expect(
-    seed,
-    "the local seed publishes COMP1100 without a draft",
-  ).toBeTruthy();
+  expect(seed, "the local seed publishes COMP1100").toBeTruthy();
   try {
     await login(page, administrator);
     await page.goto("/admin/courses/COMP1100?year=2026&tab=preview");
@@ -55,25 +52,35 @@ test("administrators edit, preview, publish and restore a course snapshot", asyn
       page.getByRole("banner").getByRole("heading", { level: 1 }),
     ).toContainText(`${seed.title} (edited)`);
     const [afterEdit] = await sql`
-      select draft_snapshot_id, published_snapshot_id from public.catalogue_item_years where id = ${seed.item_year_id}
+      select item_years.published_version_id,
+        (select versions.id from public.catalogue_versions as versions
+         where versions.record_id = item_years.id
+         order by versions.created_at desc, versions.id desc limit 1) as current_version_id
+      from public.catalogue_records as item_years where item_years.id = ${seed.record_id}
     `;
-    expect(afterEdit.draft_snapshot_id).not.toBeNull();
-    expect(Number(afterEdit.published_snapshot_id)).toBe(
-      Number(seed.published_snapshot_id),
+    expect(afterEdit.current_version_id).not.toBeNull();
+    expect(Number(afterEdit.published_version_id)).toBe(
+      Number(seed.published_version_id),
     );
     const [outcomeCount] = await sql`
-      select count(*)::int as count from public.course_learning_outcomes where snapshot_id = ${afterEdit.draft_snapshot_id}
+      select count(*)::int as count from public.course_learning_outcomes where version_id = ${afterEdit.current_version_id}
     `;
     expect(outcomeCount.count).toBeGreaterThanOrEqual(1);
 
     await page.getByRole("button", { name: "Publish draft" }).click();
+    await page
+      .getByRole("dialog")
+      .getByRole("button", { name: "Publish", exact: true })
+      .click();
     await expect(
       page.getByText("Published. Students now see this version."),
     ).toBeVisible();
 
     await page.getByRole("tab", { name: "History" }).click();
     const originalRow = page.getByRole("listitem").filter({
-      has: page.getByText(`#${seed.published_snapshot_id}`, { exact: true }),
+      has: page.getByRole("heading", {
+        name: `Imported as #${seed.published_version_id}`,
+      }),
     });
     await originalRow.getByRole("button", { name: "Restore as draft" }).click();
     await expect(page.getByText(/is now the draft/)).toBeVisible();
@@ -83,23 +90,11 @@ test("administrators edit, preview, publish and restore a course snapshot", asyn
     await expect(
       page.getByRole("banner").getByRole("heading", { level: 1 }),
     ).not.toContainText("(edited)");
-
-    const draftRow = page
-      .getByRole("listitem")
-      .filter({ has: page.getByText("Draft", { exact: true }) })
-      .first();
-    await draftRow.getByRole("button", { name: "Discard" }).click();
-    await page.getByRole("button", { name: "Discard draft" }).click();
-    await expect(page.getByText("Draft discarded.")).toBeVisible();
-    const [afterDiscard] = await sql`
-      select draft_snapshot_id from public.catalogue_item_years where id = ${seed.item_year_id}
-    `;
-    expect(afterDiscard.draft_snapshot_id).toBeNull();
   } finally {
     await sql`
-      update public.catalogue_item_years
-      set draft_snapshot_id = null, published_snapshot_id = ${seed.published_snapshot_id}
-      where id = ${seed.item_year_id}
+      update public.catalogue_records
+      set published_version_id = ${seed.published_version_id}
+      where id = ${seed.record_id}
     `;
     await sql.end();
   }
diff --git a/apps/web/scripts/fixtures/local-preview.sql b/apps/web/scripts/fixtures/local-preview.sql
index ec6812c9..a16ad7f1 100644
--- a/apps/web/scripts/fixtures/local-preview.sql
+++ b/apps/web/scripts/fixtures/local-preview.sql
@@ -234,7 +234,7 @@ where year = 2026;
 
 -- Published academic structures for exercising the complete student selection
 -- and requirements flow locally. These remain loopback-only fixture records.
-insert into public.catalogue_items (kind, code)
+insert into public.catalogue_codes (kind, code)
 values
   ('programme', 'LOCAL-PROGRAMME'),
   ('major', 'LOCAL-MAJ'),
@@ -249,12 +249,12 @@ on conflict (kind, code) do nothing;
 -- MATH1005 deliberately remains an identity only. It is visible as a
 -- prerequisite placeholder without pretending its full 2026 course page has
 -- been imported.
-insert into public.catalogue_item_years (item_id, kind, academic_year_id)
+insert into public.catalogue_records (code_id, kind, academic_year_id)
 select items.id, items.kind, years.id
-from public.catalogue_items as items
+from public.catalogue_codes as items
 join public.academic_years as years on years.year = 2026
 where items.code <> 'MATH1005'
-on conflict (item_id, academic_year_id) do nothing;
+on conflict (code_id, academic_year_id) do nothing;
 
 insert into public.catalogue_source_pages (
   source_id,
@@ -286,8 +286,8 @@ on conflict (source_id, academic_year_id, kind, external_key, content_sha256) do
 
 -- One snapshot per item year. Course snapshots carry their source page; the
 -- structure fixtures are manual.
-insert into public.catalogue_snapshots (
-  item_year_id,
+insert into public.catalogue_versions (
+  record_id,
   kind,
   academic_year_id,
   origin,
@@ -303,15 +303,15 @@ select
   pages.id,
   md5(items.code || ':2026:local-preview') || md5('published:' || items.code),
   '90000000-0000-4000-8000-000000000001'::uuid
-from public.catalogue_item_years as item_years
-join public.catalogue_items as items on items.id = item_years.item_id
+from public.catalogue_records as item_years
+join public.catalogue_codes as items on items.id = item_years.code_id
 left join public.catalogue_source_pages as pages
   on pages.academic_year_id = item_years.academic_year_id
  and pages.kind = 'course'
  and pages.external_key = items.code;
 
-insert into public.structure_snapshot_details (
-  snapshot_id,
+insert into public.structure_version_details (
+  version_id,
   kind,
   name,
   description,
@@ -335,13 +335,13 @@ select
     else 24
   end,
   case when snapshots.kind = 'programme' then 3 else null end
-from public.catalogue_snapshots as snapshots
-join public.catalogue_item_years as item_years on item_years.id = snapshots.item_year_id
-join public.catalogue_items as items on items.id = item_years.item_id
+from public.catalogue_versions as snapshots
+join public.catalogue_records as item_years on item_years.id = snapshots.record_id
+join public.catalogue_codes as items on items.id = item_years.code_id
 where snapshots.kind <> 'course';
 
 insert into public.academic_structure_snapshot_relationships (
-  snapshot_id,
+  version_id,
   position,
   relationship_kind,
   target_kind,
@@ -359,9 +359,9 @@ select
   options.target_title,
   options.source_text,
   '#local-structure-options'
-from public.catalogue_snapshots as snapshots
-join public.catalogue_item_years as item_years on item_years.id = snapshots.item_year_id
-join public.catalogue_items as items on items.id = item_years.item_id
+from public.catalogue_versions as snapshots
+join public.catalogue_records as item_years on item_years.id = snapshots.record_id
+join public.catalogue_codes as items on items.id = item_years.code_id
 cross join (
   values
     (1, 'major'::text, 'LOCAL-MAJ'::text, 'Local Systems Major'::text, 'Choose the Local Systems Major.'::text),
@@ -375,7 +375,7 @@ where items.code = 'LOCAL-PROGRAMME';
 -- and a single condition. Programmes require 144 units; every other structure
 -- requires one listed local course.
 insert into public.requirement_rules (
-  snapshot_id, academic_year_id, rule_kind, source_text, review_state
+  version_id, academic_year_id, rule_kind, source_text, review_state
 )
 select
   snapshots.id,
@@ -383,15 +383,15 @@ select
   'structure',
   'Complete all published requirements for ' || details.name || '.',
   'verified'
-from public.catalogue_snapshots as snapshots
-join public.structure_snapshot_details as details on details.snapshot_id = snapshots.id;
+from public.catalogue_versions as snapshots
+join public.structure_version_details as details on details.version_id = snapshots.id;
 
 insert into public.requirement_groups (
-  rule_id, snapshot_id, group_key, label, operator, source_text, source_locator, position
+  rule_id, version_id, group_key, label, operator, source_text, source_locator, position
 )
 select
   rules.id,
-  rules.snapshot_id,
+  rules.version_id,
   'root',
   details.name || ' requirements',
   'all_of',
@@ -399,16 +399,16 @@ select
   '#local-requirements',
   0
 from public.requirement_rules as rules
-join public.structure_snapshot_details as details on details.snapshot_id = rules.snapshot_id
+join public.structure_version_details as details on details.version_id = rules.version_id
 where rules.rule_kind = 'structure';
 
 insert into public.requirement_conditions (
-  rule_id, snapshot_id, group_id, condition_key, position, condition_kind,
+  rule_id, version_id, group_id, condition_key, position, condition_kind,
   minimum_units, source_text, source_locator, review_state
 )
 select
   groups.rule_id,
-  groups.snapshot_id,
+  groups.version_id,
   groups.id,
   'root:local-requirement',
   0,
@@ -422,24 +422,24 @@ select
   'verified'
 from public.requirement_groups as groups
 join public.requirement_rules as rules on rules.id = groups.rule_id
-join public.catalogue_snapshots as snapshots on snapshots.id = groups.snapshot_id
+join public.catalogue_versions as snapshots on snapshots.id = groups.version_id
 where rules.rule_kind = 'structure';
 
 insert into public.requirement_condition_options (
-  condition_id, snapshot_id, position, kind, code, item_id
+  condition_id, version_id, position, kind, code, code_id
 )
 select
   conditions.id,
-  conditions.snapshot_id,
+  conditions.version_id,
   1,
   'course',
   selected.code,
   selected.id
 from public.requirement_conditions as conditions
-join public.catalogue_snapshots as snapshots on snapshots.id = conditions.snapshot_id
-join public.catalogue_item_years as item_years on item_years.id = snapshots.item_year_id
-join public.catalogue_items as items on items.id = item_years.item_id
-join public.catalogue_items as selected
+join public.catalogue_versions as snapshots on snapshots.id = conditions.version_id
+join public.catalogue_records as item_years on item_years.id = snapshots.record_id
+join public.catalogue_codes as items on items.id = item_years.code_id
+join public.catalogue_codes as selected
   on selected.kind = 'course'
  and selected.code = case items.code
    when 'LOCAL-MAJ' then 'COMP1110'
@@ -451,8 +451,8 @@ where conditions.condition_kind = 'course_set_units';
 
 -- Published courses ------------------------------------------------------------
 
-insert into public.course_snapshot_details (
-  snapshot_id,
+insert into public.course_version_details (
+  version_id,
   title,
   unit_value_kind,
   units,
@@ -502,16 +502,16 @@ select
   'No prescribed text.',
   'offered',
   '2026-08-01 00:00:00+10'
-from public.catalogue_snapshots as snapshots
-join public.catalogue_item_years as item_years on item_years.id = snapshots.item_year_id
-join public.catalogue_items as items on items.id = item_years.item_id
+from public.catalogue_versions as snapshots
+join public.catalogue_records as item_years on item_years.id = snapshots.record_id
+join public.catalogue_codes as items on items.id = item_years.code_id
 where snapshots.kind = 'course';
 
 -- Fixed-unit courses store their single value on the details row. Unit
 -- options are reserved for courses whose unit value is variable.
 
 insert into public.course_fees (
-  snapshot_id,
+  version_id,
   position,
   fee_year,
   audience,
@@ -533,27 +533,27 @@ select
   'course',
   'Indicative domestic fee',
   'Indicative domestic fee: $1,110'
-from public.catalogue_snapshots as snapshots
+from public.catalogue_versions as snapshots
 where snapshots.kind = 'course';
 
-insert into public.course_areas_of_interest (snapshot_id, position, name)
+insert into public.course_areas_of_interest (version_id, position, name)
 select snapshots.id, 1, 'Computer Science'
-from public.catalogue_snapshots as snapshots
+from public.catalogue_versions as snapshots
 where snapshots.kind = 'course';
 
 insert into public.course_attributes (
-  snapshot_id,
+  version_id,
   position,
   attribute_kind,
   value,
   source_text
 )
 select snapshots.id, 1, 'stem', 'STEM', 'STEM course'
-from public.catalogue_snapshots as snapshots
+from public.catalogue_versions as snapshots
 where snapshots.kind = 'course';
 
 insert into public.course_offerings (
-  snapshot_id,
+  version_id,
   academic_year_id,
   source_page_id,
   delivery_mode,
@@ -565,12 +565,12 @@ select
   snapshots.source_page_id,
   'In person',
   'Acton'
-from public.catalogue_snapshots as snapshots
+from public.catalogue_versions as snapshots
 where snapshots.kind = 'course';
 
 insert into public.offering_sessions (
   course_offering_id,
-  snapshot_id,
+  version_id,
   academic_year_id,
   source_page_id,
   academic_period_id,
@@ -605,22 +605,22 @@ select
   'Acton',
   'https://coursemap.local.test/2026/classes/' || lower(items.code),
   'Semester 1, in person at Acton'
-from public.catalogue_snapshots as snapshots
-join public.catalogue_item_years as item_years on item_years.id = snapshots.item_year_id
-join public.catalogue_items as items on items.id = item_years.item_id
-join public.course_offerings as offerings on offerings.snapshot_id = snapshots.id
+from public.catalogue_versions as snapshots
+join public.catalogue_records as item_years on item_years.id = snapshots.record_id
+join public.catalogue_codes as items on items.id = item_years.code_id
+join public.course_offerings as offerings on offerings.version_id = snapshots.id
 join public.academic_periods as periods
   on periods.calendar_year = 2026
  and periods.code = 'S1'
 where snapshots.kind = 'course';
 
-insert into public.course_learning_outcomes (snapshot_id, position, body)
+insert into public.course_learning_outcomes (version_id, position, body)
 select snapshots.id, 1, 'Apply foundational programming concepts.'
-from public.catalogue_snapshots as snapshots
+from public.catalogue_versions as snapshots
 where snapshots.kind = 'course';
 
 insert into public.course_assessment_items (
-  snapshot_id,
+  version_id,
   position,
   title,
   weight,
@@ -636,25 +636,25 @@ select
   false,
   'Week 8',
   'Programming assignment (40%)'
-from public.catalogue_snapshots as snapshots
+from public.catalogue_versions as snapshots
 where snapshots.kind = 'course';
 
 insert into public.course_assessment_outcomes (
-  snapshot_id,
+  version_id,
   assessment_item_id,
   learning_outcome_id
 )
 select snapshots.id, assessments.id, outcomes.id
-from public.catalogue_snapshots as snapshots
+from public.catalogue_versions as snapshots
 join public.course_assessment_items as assessments
-  on assessments.snapshot_id = snapshots.id
+  on assessments.version_id = snapshots.id
 join public.course_learning_outcomes as outcomes
-  on outcomes.snapshot_id = snapshots.id
+  on outcomes.version_id = snapshots.id
  and outcomes.position = 1
 where snapshots.kind = 'course';
 
-insert into public.snapshot_field_evidence (
-  snapshot_id,
+insert into public.catalogue_version_provenance (
+  version_id,
   academic_year_id,
   source_page_id,
   field_path,
@@ -672,11 +672,11 @@ select
   0.99,
   'h1',
   details.title
-from public.catalogue_snapshots as snapshots
-join public.course_snapshot_details as details on details.snapshot_id = snapshots.id;
+from public.catalogue_versions as snapshots
+join public.course_version_details as details on details.version_id = snapshots.id;
 
 insert into public.requirement_rules (
-  snapshot_id, academic_year_id, source_page_id, rule_kind, hardness,
+  version_id, academic_year_id, source_page_id, rule_kind, hardness,
   source_text, review_state, confidence
 )
 select
@@ -688,25 +688,25 @@ select
   'You must have completed MATH1005.',
   'verified',
   0.99
-from public.catalogue_snapshots as snapshots
-join public.catalogue_item_years as item_years on item_years.id = snapshots.item_year_id
-join public.catalogue_items as items on items.id = item_years.item_id
+from public.catalogue_versions as snapshots
+join public.catalogue_records as item_years on item_years.id = snapshots.record_id
+join public.catalogue_codes as items on items.id = item_years.code_id
 where items.code = 'COMP1110';
 
 insert into public.requirement_groups (
-  rule_id, snapshot_id, group_key, operator, position
+  rule_id, version_id, group_key, operator, position
 )
-select rules.id, rules.snapshot_id, 'prerequisite:group:root', 'all_of', 0
+select rules.id, rules.version_id, 'prerequisite:group:root', 'all_of', 0
 from public.requirement_rules as rules
 where rules.rule_kind = 'prerequisite';
 
 insert into public.requirement_conditions (
-  rule_id, snapshot_id, group_id, condition_key, position, condition_kind,
-  item_id, item_kind, requirement_mode, hardness, source_text, confidence, review_state
+  rule_id, version_id, group_id, condition_key, position, condition_kind,
+  code_id, item_kind, requirement_mode, hardness, source_text, confidence, review_state
 )
 select
   rules.id,
-  rules.snapshot_id,
+  rules.version_id,
   groups.id,
   'prerequisite:condition:0',
   0,
@@ -720,24 +720,24 @@ select
   'verified'
 from public.requirement_rules as rules
 join public.requirement_groups as groups on groups.rule_id = rules.id
-join public.catalogue_items as prerequisite
+join public.catalogue_codes as prerequisite
   on prerequisite.kind = 'course' and prerequisite.code = 'MATH1005'
 where rules.rule_kind = 'prerequisite';
 
 insert into public.requirement_item_references (
-  rule_id, snapshot_id, item_id, source_text, confidence, review_state
+  rule_id, version_id, code_id, source_text, confidence, review_state
 )
-select rules.id, rules.snapshot_id, prerequisite.id, 'MATH1005', 0.99, 'verified'
+select rules.id, rules.version_id, prerequisite.id, 'MATH1005', 0.99, 'verified'
 from public.requirement_rules as rules
-join public.catalogue_items as prerequisite
+join public.catalogue_codes as prerequisite
   on prerequisite.kind = 'course' and prerequisite.code = 'MATH1005'
 where rules.rule_kind = 'prerequisite';
 
 -- Setting the publication pointer is the only publication action. The pointer
 -- trigger seals each snapshot after every child row has been stored.
-update public.catalogue_item_years as item_years
-set published_snapshot_id = snapshots.id
-from public.catalogue_snapshots as snapshots
-where snapshots.item_year_id = item_years.id;
+update public.catalogue_records as item_years
+set published_version_id = snapshots.id
+from public.catalogue_versions as snapshots
+where snapshots.record_id = item_years.id;
 
 commit;
diff --git a/apps/web/tests/academic-withdrawal.test.ts b/apps/web/tests/academic-withdrawal.test.ts
index 262eb03f..f7081bfe 100644
--- a/apps/web/tests/academic-withdrawal.test.ts
+++ b/apps/web/tests/academic-withdrawal.test.ts
@@ -54,8 +54,7 @@ for (const grade of ["WD", "WL"]) {
       course_attempts: [
         {
           id: "withdrawal",
-          course_id: 1,
-          course_snapshot_id: 10,
+          catalogue_version_id: 10,
           academic_period_id: 1,
           status: "withdrawn",
           grade,
@@ -64,9 +63,10 @@ for (const grade of ["WD", "WL"]) {
           units_earned: 0,
         },
       ],
-      catalogue_items: [{ id: 1, code: "COMP1100" }],
+      catalogue_codes: [{ id: 1, code: "COMP1100" }],
+      catalogue_records: [{ id: 5, code_id: 1, academic_year_id: 1 }],
       academic_periods: [{ id: 1, calendar_year: 2026, code: "S1" }],
-      catalogue_snapshots: [{ id: 10, academic_year_id: 1 }],
+      catalogue_versions: [{ id: 10, record_id: 5 }],
     };
     const state = await loadCoursemapState({ id: "owner", email: null });
     expect(state.attempts).toEqual([
diff --git a/apps/web/tests/catalogue-import-pipeline-database.test.mjs b/apps/web/tests/catalogue-import-pipeline-database.test.mjs
index dde4c29b..680478eb 100644
--- a/apps/web/tests/catalogue-import-pipeline-database.test.mjs
+++ b/apps/web/tests/catalogue-import-pipeline-database.test.mjs
@@ -112,22 +112,22 @@ beforeAll(async () => {
  */
 async function removeFixtureData() {
   await sql`delete from public.catalogue_import_runs where requested_by = ${ADMIN_ID}`;
-  await sql`update public.catalogue_directory_entries set item_id = null where code in (${CODE}, 'COMP2401')`;
-  await sql`alter table public.catalogue_snapshots disable trigger catalogue_snapshots_enforce_immutability`;
+  await sql`update public.catalogue_directory_entries set code_id = null where code in (${CODE}, 'COMP2401')`;
+  await sql`alter table public.catalogue_versions disable trigger catalogue_versions_enforce_immutability`;
   try {
-    await sql`delete from public.catalogue_items where kind = 'course' and code in (${CODE}, 'COMP2401')`;
+    await sql`delete from public.catalogue_codes where kind = 'course' and code in (${CODE}, 'COMP2401')`;
     await sql`
-      delete from public.catalogue_items
+      delete from public.catalogue_codes
       where kind = 'course'
-        and id not in (select item_id from public.catalogue_item_years)
-        and id not in (select item_id from public.requirement_conditions where item_id is not null)
-        and id not in (select item_id from public.requirement_condition_options where item_id is not null)
-        and id not in (select item_id from public.requirement_item_references)
+        and id not in (select code_id from public.catalogue_records)
+        and id not in (select code_id from public.requirement_conditions where code_id is not null)
+        and id not in (select code_id from public.requirement_condition_options where code_id is not null)
+        and id not in (select code_id from public.requirement_item_references)
         and id not in (select related_course_id from public.course_related_courses)
         and code not in ('MATH1005')
     `;
   } finally {
-    await sql`alter table public.catalogue_snapshots enable trigger catalogue_snapshots_enforce_immutability`;
+    await sql`alter table public.catalogue_versions enable trigger catalogue_versions_enforce_immutability`;
   }
 }
 
@@ -154,7 +154,7 @@ async function startRun(codes) {
   return row.run;
 }
 
-test("a first import becomes the draft and a repeat import is unchanged", async () => {
+test("a first import creates an applied version and a repeat import is unchanged", async () => {
   const run = await startRun([CODE]);
   assert.equal(run.targets.length, 1);
   const targetId = run.targets[0].targetId;
@@ -162,30 +162,30 @@ test("a first import becomes the draft and a repeat import is unchanged", async
   await processImportTarget({ runId: run.runId, targetId });
 
   const [target] = await sql`
-    select status, change_kind, candidate_snapshot_id, error_message
+    select status, change_kind, candidate_version_id, applied_version_id, error_message
     from public.catalogue_import_targets where id = ${targetId}::uuid
   `;
   assert.equal(target.error_message, null);
   assert.equal(target.status, "ready");
   assert.equal(target.change_kind, "new");
-  assert.ok(target.candidate_snapshot_id);
+  assert.ok(target.candidate_version_id);
+  assert.equal(
+    Number(target.applied_version_id),
+    Number(target.candidate_version_id),
+  );
   assert.equal(openRouterCalls, 1);
 
   const [itemYear] = await sql`
-    select item_years.draft_snapshot_id, item_years.published_snapshot_id
-    from public.catalogue_item_years as item_years
-    join public.catalogue_items as items on items.id = item_years.item_id
+    select item_years.published_version_id
+    from public.catalogue_records as item_years
+    join public.catalogue_codes as items on items.id = item_years.code_id
     where items.code = ${CODE}
   `;
-  assert.equal(
-    Number(itemYear.draft_snapshot_id),
-    Number(target.candidate_snapshot_id),
-  );
-  assert.equal(itemYear.published_snapshot_id, null);
+  assert.equal(itemYear.published_version_id, null);
 
   const [details] = await sql`
-    select title, units, subject_code from public.course_snapshot_details
-    where snapshot_id = ${target.candidate_snapshot_id}
+    select title, units, subject_code from public.course_version_details
+    where version_id = ${target.candidate_version_id}
   `;
   assert.equal(details.subject_code, "COMP");
   assert.ok(details.title.length > 0);
@@ -208,7 +208,7 @@ test("a first import becomes the draft and a repeat import is unchanged", async
 
   const [{ count: rules }] = await sql`
     select count(*)::int as count from public.requirement_rules
-    where snapshot_id = ${target.candidate_snapshot_id}
+    where version_id = ${target.candidate_version_id}
   `;
   assert.ok(rules >= 1, "the fixture page carries requisite rules");
 
@@ -220,19 +220,19 @@ test("a first import becomes the draft and a repeat import is unchanged", async
   assert.equal(Number(runRow.cost_usd), 0.001);
 
   // A second run over identical content reuses the validated response and
-  // records no new snapshot.
+  // records no new version.
   const secondRun = await startRun([CODE]);
   const { completed } = await processImportRunInline({
     runId: secondRun.runId,
   });
   assert.equal(completed, 1);
   const [second] = await sql`
-    select status, change_kind, candidate_snapshot_id from public.catalogue_import_targets
+    select status, change_kind, candidate_version_id from public.catalogue_import_targets
     where run_id = ${secondRun.runId}::uuid
   `;
   assert.equal(second.status, "unchanged");
   assert.equal(second.change_kind, "unchanged");
-  assert.equal(second.candidate_snapshot_id, null);
+  assert.equal(second.candidate_version_id, null);
   assert.equal(
     openRouterCalls,
     1,
@@ -243,19 +243,19 @@ test("a first import becomes the draft and a repeat import is unchanged", async
 test("a changed import records open changes, applies accepted ones and publishes", async () => {
   // Alter the published fixture so the next import differs in the title only.
   const [item] = await sql`
-    select item_years.id as item_year_id, item_years.draft_snapshot_id
-    from public.catalogue_item_years as item_years
-    join public.catalogue_items as items on items.id = item_years.item_id
+    select item_years.id as record_id, item_years.published_version_id
+    from public.catalogue_records as item_years
+    join public.catalogue_codes as items on items.id = item_years.code_id
     where items.code = ${CODE}
   `;
   await sql.begin(async (tx) => {
     await tx`select set_config('request.jwt.claim.sub', ${ADMIN_ID}, true)`;
-    await tx`select public.publish_catalogue_snapshot(${item.item_year_id})`;
+    await tx`select public.publish_catalogue_version(${item.record_id})`;
   });
   const [{ count: acceptedOnFirst }] = await sql`
     select count(*)::int as count from public.catalogue_import_changes as changes
     join public.catalogue_import_targets as targets on targets.id = changes.target_id
-    where targets.item_year_id = ${item.item_year_id} and changes.entry_kind = 'change' and changes.status = 'accepted'
+    where targets.record_id = ${item.record_id} and changes.entry_kind = 'change' and changes.status = 'accepted'
   `;
   assert.ok(
     acceptedOnFirst > 0,
@@ -290,7 +290,7 @@ test("a changed import records open changes, applies accepted ones and publishes
     const run = await startRun([CODE]);
     await processImportRunInline({ runId: run.runId });
     const [target] = await sql`
-      select id, status, change_kind, candidate_snapshot_id from public.catalogue_import_targets
+      select id, status, change_kind, candidate_version_id from public.catalogue_import_targets
       where run_id = ${run.runId}::uuid
     `;
     assert.equal(target.status, "ready");
@@ -307,11 +307,11 @@ test("a changed import records open changes, applies accepted ones and publishes
 
     // Publishing is blocked while changes are open.
     const [{ blockers }] = await sql`
-      select public.catalogue_publish_blockers(${item.item_year_id}) as blockers
+      select public.catalogue_publish_blockers(${item.record_id}) as blockers
     `;
     assert.ok(
       blockers.some((reason) =>
-        /open changes|no draft|already published/.test(reason),
+        /open changes|no version|already published/.test(reason),
       ),
       blockers.join(" "),
     );
@@ -335,13 +335,13 @@ test("a changed import records open changes, applies accepted ones and publishes
     assert.equal(
       applied.reusedCandidate,
       false,
-      "a partial acceptance builds a merged snapshot",
+      "a partial acceptance builds a merged version",
     );
 
     const [merged] = await sql`
       select details.title, details.introduction
-      from public.course_snapshot_details as details
-      where details.snapshot_id = ${applied.draftSnapshotId}
+      from public.course_version_details as details
+      where details.version_id = ${applied.versionId}
     `;
     assert.equal(merged.title, revisedDeterministic.title);
     assert.equal(
@@ -351,13 +351,9 @@ test("a changed import records open changes, applies accepted ones and publishes
     );
 
     const [pointer] = await sql`
-      select draft_snapshot_id, published_snapshot_id from public.catalogue_item_years where id = ${item.item_year_id}
+      select published_version_id from public.catalogue_records where id = ${item.record_id}
     `;
-    assert.equal(Number(pointer.draft_snapshot_id), applied.draftSnapshotId);
-    assert.notEqual(
-      Number(pointer.published_snapshot_id),
-      applied.draftSnapshotId,
-    );
+    assert.notEqual(Number(pointer.published_version_id), applied.versionId);
 
     await assert.rejects(
       applyImportReview({ targetId: target.id, userId: ADMIN_ID, sql }),
@@ -366,15 +362,12 @@ test("a changed import records open changes, applies accepted ones and publishes
 
     await sql.begin(async (tx) => {
       await tx`select set_config('request.jwt.claim.sub', ${ADMIN_ID}, true)`;
-      await tx`select public.publish_catalogue_snapshot(${item.item_year_id})`;
+      await tx`select public.publish_catalogue_version(${item.record_id})`;
     });
     const [published] = await sql`
-      select published_snapshot_id from public.catalogue_item_years where id = ${item.item_year_id}
+      select published_version_id from public.catalogue_records where id = ${item.record_id}
     `;
-    assert.equal(
-      Number(published.published_snapshot_id),
-      applied.draftSnapshotId,
-    );
+    assert.equal(Number(published.published_version_id), applied.versionId);
   } finally {
     pageRef.current = previousPage;
     modelAnswerRef.current = previousModel;
diff --git a/apps/web/tests/catalogue-review-state.test.ts b/apps/web/tests/catalogue-review-state.test.ts
index 365638b8..d5a9b6e2 100644
--- a/apps/web/tests/catalogue-review-state.test.ts
+++ b/apps/web/tests/catalogue-review-state.test.ts
@@ -45,8 +45,8 @@ function target(overrides: Partial<ReviewTarget> = {}): ReviewTarget {
     createdAt: "2026-03-01T00:00:00Z",
     completedAt: "2026-03-01T00:01:00Z",
     appliedAt: null,
-    baselineSnapshotId: 10,
-    candidateSnapshotId: 11,
+    baselineVersionId: 10,
+    candidateVersionId: 11,
     entries: [],
     ...overrides,
   };
@@ -57,15 +57,15 @@ function record(overrides: Partial<CatalogueRecord> = {}): CatalogueRecord {
     kind: "course",
     code: "COMP3600",
     academicYear: 2026,
-    itemId: 1,
-    itemYearId: 1,
-    itemYearPublicId: "iy_1",
+    codeId: 1,
+    recordId: 1,
+    recordPublicId: "iy_1",
     title: "Algorithms",
-    draftSnapshotId: null,
-    publishedSnapshotId: null,
+    currentVersionId: null,
+    publishedVersionId: null,
     archivedAt: null,
     publishBlockers: [],
-    snapshots: [],
+    versions: [],
     publications: [],
     reviews: [],
     ...overrides,
@@ -155,7 +155,7 @@ test("the record's next step walks from decisions to published", () => {
 
   const outstanding = recordNextStep(
     record({
-      draftSnapshotId: 5,
+      currentVersionId: 5,
       reviews,
       publishBlockers: ["The import review still has open changes."],
     }),
@@ -166,7 +166,7 @@ test("the record's next step walks from decisions to published", () => {
 
   const decided = recordNextStep(
     record({
-      draftSnapshotId: 5,
+      currentVersionId: 5,
       reviews: [target({ entries: [entry({ status: "accepted" })] })],
     }),
   );
@@ -175,7 +175,7 @@ test("the record's next step walks from decisions to published", () => {
 
   const ready = recordNextStep(
     record({
-      draftSnapshotId: 5,
+      currentVersionId: 5,
       reviews: [
         target({
           appliedAt: "2026-03-02T00:00:00Z",
@@ -187,7 +187,7 @@ test("the record's next step walks from decisions to published", () => {
   expect(ready.headline).toBe("Ready to publish");
   expect(ready.next).toBe("publish");
 
-  const live = recordNextStep(record({ publishedSnapshotId: 5 }));
+  const live = recordNextStep(record({ publishedVersionId: 5 }));
   expect(live.headline).toBe("Published");
   expect(live.next).toBe("none");
 });
@@ -195,7 +195,7 @@ test("the record's next step walks from decisions to published", () => {
 test("a blocking flag holds publication and names itself", () => {
   const step = recordNextStep(
     record({
-      draftSnapshotId: 5,
+      currentVersionId: 5,
       publishBlockers: ["A blocking flag on the import review is still open."],
       reviews: [
         target({
@@ -220,15 +220,15 @@ test("decisions from a superseded import do not hold a record back", () => {
   // behind the draft, so the interface counts the same two and no others.
   const step = recordNextStep(
     record({
-      draftSnapshotId: 5,
-      snapshots: [
+      currentVersionId: 5,
+      versions: [
         {
           id: 5,
           publicId: "sn_5",
           origin: "import",
           createdAt: "2026-03-02T00:00:00Z",
           sealedAt: null,
-          basedOnSnapshotId: null,
+          basedOnVersionId: null,
           importTargetId: "target-1",
           contentHash: "abc",
         },
diff --git a/apps/web/tests/local-preview-seed.test.mjs b/apps/web/tests/local-preview-seed.test.mjs
index ce233a58..2ff68524 100644
--- a/apps/web/tests/local-preview-seed.test.mjs
+++ b/apps/web/tests/local-preview-seed.test.mjs
@@ -39,7 +39,7 @@ test("the local preview publishes every selectable academic structure kind", asy
   assert.match(previewSeed, /LOCALA-MIN/u);
   assert.match(previewSeed, /LOCALB-MIN/u);
   assert.match(previewSeed, /LOCAL-SPEC/u);
-  assert.match(previewSeed, /set published_snapshot_id = snapshots\.id/u);
+  assert.match(previewSeed, /set published_version_id = snapshots\.id/u);
 });
 
 test("passes the local server key to durable import workers", async () => {
diff --git a/apps/web/tests/plan-catalogue-requirements.test.mjs b/apps/web/tests/plan-catalogue-requirements.test.mjs
index e4a857b2..7f3caf54 100644
--- a/apps/web/tests/plan-catalogue-requirements.test.mjs
+++ b/apps/web/tests/plan-catalogue-requirements.test.mjs
@@ -18,7 +18,7 @@ function group(overrides) {
     parent_group_id: null,
     position: 1,
     rule_id: 5,
-    snapshot_id: 70,
+    version_id: 70,
     source_locator: "#program-requirements",
     source_text: "Complete all of the following requirements.",
     ...overrides,
@@ -34,7 +34,7 @@ function condition(overrides) {
     group_id: 1,
     hardness: "hard",
     id: 10,
-    item_id: null,
+    code_id: null,
     maximum_level: null,
     maximum_units: null,
     minimum_count: null,
@@ -48,7 +48,7 @@ function condition(overrides) {
     requirement_mode: null,
     review_state: "verified",
     rule_id: 5,
-    snapshot_id: 70,
+    version_id: 70,
     source_locator: "#program-requirements",
     source_text: "144 units",
     structure_kind: null,
@@ -99,10 +99,10 @@ test("rebuilds nested requirement groups with ordered alternatives and options",
         code: "COMP1100",
         condition_id: 11,
         id: 20,
-        item_id: null,
+        code_id: null,
         kind: "course",
         position: 1,
-        snapshot_id: 70,
+        version_id: 70,
         source_text: null,
         title: null,
       },
@@ -110,10 +110,10 @@ test("rebuilds nested requirement groups with ordered alternatives and options",
         code: "COMP1130",
         condition_id: 12,
         id: 21,
-        item_id: null,
+        code_id: null,
         kind: "course",
         position: 1,
-        snapshot_id: 70,
+        version_id: 70,
         source_text: null,
         title: null,
       },
@@ -161,7 +161,7 @@ test("selects the latest year through published programme pointers and loads rel
   );
 
   assert.match(source, /\.eq\("kind", "programme"\)/u);
-  assert.match(source, /\.not\("published_snapshot_id", "is", null\)/u);
+  assert.match(source, /\.not\("published_version_id", "is", null\)/u);
   assert.match(source, /\.order\("year", \{ ascending: false \}\)/u);
   assert.match(source, /from\("plan_structures"\)/u);
   assert.match(source, /selectedStructureYears\.has\(structureYear\.id\)/u);
diff --git a/apps/web/tests/plan-catalogue.test.mjs b/apps/web/tests/plan-catalogue.test.mjs
index 1c60b315..3bf8bd57 100644
--- a/apps/web/tests/plan-catalogue.test.mjs
+++ b/apps/web/tests/plan-catalogue.test.mjs
@@ -1,20 +1,27 @@
 import assert from "node:assert/strict";
 import { test } from "vitest";
 
-import { collectPlanCatalogueCourseIds } from "../lib/coursemap/plan-course-ids.ts";
+import { collectPlanCatalogueRecordIds } from "../lib/coursemap/plan-course-ids.ts";
 
-test("includes courses that only appear in recorded attempts", () => {
+test("includes records that only appear in recorded attempts", () => {
   assert.deepEqual(
-    collectPlanCatalogueCourseIds([{ course_id: 101 }], [{ course_id: 202 }]),
+    collectPlanCatalogueRecordIds(
+      [{ catalogue_record_id: 101 }],
+      [{ catalogue_record_id: 202 }],
+    ),
     [101, 202],
   );
 });
 
-test("deduplicates courses shared by the plan and recorded attempts", () => {
+test("deduplicates records shared by the plan and recorded attempts", () => {
   assert.deepEqual(
-    collectPlanCatalogueCourseIds(
-      [{ course_id: 101 }, { course_id: 202 }],
-      [{ course_id: 202 }, { course_id: 303 }, { course_id: 303 }],
+    collectPlanCatalogueRecordIds(
+      [{ catalogue_record_id: 101 }, { catalogue_record_id: 202 }],
+      [
+        { catalogue_record_id: 202 },
+        { catalogue_record_id: 303 },
+        { catalogue_record_id: 303 },
+      ],
     ),
     [101, 202, 303],
   );
diff --git a/apps/web/tests/programme-structure-options.test.mjs b/apps/web/tests/programme-structure-options.test.mjs
index 90e07e65..79974bc2 100644
--- a/apps/web/tests/programme-structure-options.test.mjs
+++ b/apps/web/tests/programme-structure-options.test.mjs
@@ -15,7 +15,7 @@ test("keeps only explicit programme structure relationship semantics", () => {
       relationship("incompatible", "ANTH-MAJ"),
       relationship("other", "ECON-MAJ"),
       relationship("required", "DATA-MIN", "minor"),
-      { ...relationship("required", "CHEM-MAJ"), snapshot_id: 202 },
+      { ...relationship("required", "CHEM-MAJ"), version_id: 202 },
     ],
     requirementConditions: [],
     requirementOptions: [],
@@ -38,7 +38,7 @@ test("includes structure options from programme structure-set requirements", ()
       condition(2, "course_set_units", "major"),
       condition(3, "structure_set", "minor"),
       condition(5, "structure_set", "specialisation"),
-      { ...condition(4, "structure_set", "major"), snapshot_id: 202 },
+      { ...condition(4, "structure_set", "major"), version_id: 202 },
     ],
     requirementOptions: [
       option(1, "MATH-MAJ"),
@@ -46,8 +46,8 @@ test("includes structure options from programme structure-set requirements", ()
       option(2, "STAT-MAJ"),
       option(3, "DATA-MIN", "minor"),
       option(5, "AI-SPEC", "specialisation"),
-      { ...option(1, "PHYS-MAJ"), snapshot_id: 202 },
-      { ...option(4, "CHEM-MAJ"), snapshot_id: 202 },
+      { ...option(1, "PHYS-MAJ"), version_id: 202 },
+      { ...option(4, "CHEM-MAJ"), version_id: 202 },
       { ...option(1, "ECON-MAJ"), kind: "course" },
     ],
   });
@@ -67,10 +67,7 @@ test("onboarding loads explicit relationship and structure-set semantics without
   );
 
   assert.match(source, /collectSelectableStructureCodes/u);
-  assert.match(
-    source,
-    /relationship_kind,snapshot_id,target_code,target_kind/u,
-  );
+  assert.match(source, /relationship_kind,version_id,target_code,target_kind/u);
   assert.match(source, /from\("requirement_conditions"\)/u);
   assert.match(source, /from\("requirement_condition_options"\)/u);
   assert.doesNotMatch(source, /snapshot\.units === null \? 0/u);
@@ -79,7 +76,7 @@ test("onboarding loads explicit relationship and structure-set semantics without
 function relationship(relationshipKind, targetCode, targetKind = "major") {
   return {
     relationship_kind: relationshipKind,
-    snapshot_id: 101,
+    version_id: 101,
     target_code: targetCode,
     target_kind: targetKind,
   };
@@ -89,7 +86,7 @@ function condition(id, conditionKind, structureKind) {
   return {
     condition_kind: conditionKind,
     id,
-    snapshot_id: 101,
+    version_id: 101,
     structure_kind: structureKind,
   };
 }
@@ -99,6 +96,6 @@ function option(conditionId, code, kind = "major") {
     code,
     condition_id: conditionId,
     kind,
-    snapshot_id: 101,
+    version_id: 101,
   };
 }
diff --git a/apps/web/tests/structure-role-selection.test.tsx b/apps/web/tests/structure-role-selection.test.tsx
index 3d0f4f44..b1eaea6d 100644
--- a/apps/web/tests/structure-role-selection.test.tsx
+++ b/apps/web/tests/structure-role-selection.test.tsx
@@ -29,11 +29,11 @@ const codeByYear = new Map([
 test("a plan keeps every selected minor and specialisation", () => {
   const codes = planStructureCodes(
     [
-      { role: "programme", structure_year_id: 1 },
-      { role: "major", structure_year_id: 2 },
-      { role: "minor", structure_year_id: 3 },
-      { role: "minor", structure_year_id: 4 },
-      { role: "specialisation", structure_year_id: 5 },
+      { role: "programme", catalogue_record_id: 1 },
+      { role: "major", catalogue_record_id: 2 },
+      { role: "minor", catalogue_record_id: 3 },
+      { role: "minor", catalogue_record_id: 4 },
+      { role: "specialisation", catalogue_record_id: 5 },
     ],
     codeByYear,
     { degreeCode: "FALLBACK" },
@@ -50,8 +50,8 @@ test("a plan keeps every selected minor and specialisation", () => {
 test("a structure with no resolvable code is dropped, not recorded blank", () => {
   const codes = planStructureCodes(
     [
-      { role: "minor", structure_year_id: 3 },
-      { role: "minor", structure_year_id: 6 },
+      { role: "minor", catalogue_record_id: 3 },
+      { role: "minor", catalogue_record_id: 6 },
     ],
     codeByYear,
     { degreeCode: "FALLBACK" },
diff --git a/apps/web/types/database.ts b/apps/web/types/database.ts
index 8c0df089..68582a60 100644
--- a/apps/web/types/database.ts
+++ b/apps/web/types/database.ts
@@ -61,10 +61,10 @@ export type Database = {
           fee_year: number | null
           id: number
           position: number
-          snapshot_id: number
           source_label: string | null
           source_locator: string
           source_text: string
+          version_id: number
         }
         Insert: {
           amount?: number | null
@@ -75,10 +75,10 @@ export type Database = {
           fee_year?: number | null
           id?: never
           position: number
-          snapshot_id: number
           source_label?: string | null
           source_locator: string
           source_text: string
+          version_id: number
         }
         Update: {
           amount?: number | null
@@ -89,25 +89,25 @@ export type Database = {
           fee_year?: number | null
           id?: never
           position?: number
-          snapshot_id?: number
           source_label?: string | null
           source_locator?: string
           source_text?: string
+          version_id?: number
         }
         Relationships: [
           {
             foreignKeyName: "academic_structure_fees_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id"]
           },
           {
             foreignKeyName: "academic_structure_fees_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
+            referencedColumns: ["version_id"]
           },
         ]
       }
@@ -116,40 +116,40 @@ export type Database = {
           id: number
           outcome_text: string
           position: number
-          snapshot_id: number
           source_locator: string
           source_text: string
+          version_id: number
         }
         Insert: {
           id?: never
           outcome_text: string
           position: number
-          snapshot_id: number
           source_locator: string
           source_text: string
+          version_id: number
         }
         Update: {
           id?: never
           outcome_text?: string
           position?: number
-          snapshot_id?: number
           source_locator?: string
           source_text?: string
+          version_id?: number
         }
         Relationships: [
           {
             foreignKeyName: "academic_structure_learning_outcomes_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id"]
           },
           {
             foreignKeyName: "academic_structure_learning_outcomes_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
+            referencedColumns: ["version_id"]
           },
         ]
       }
@@ -158,49 +158,49 @@ export type Database = {
           id: number
           position: number
           relationship_kind: string
-          snapshot_id: number
           source_locator: string
           source_text: string
           target_code: string
           target_kind: string
           target_title: string | null
+          version_id: number
         }
         Insert: {
           id?: never
           position: number
           relationship_kind: string
-          snapshot_id: number
           source_locator: string
           source_text: string
           target_code: string
           target_kind: string
           target_title?: string | null
+          version_id: number
         }
         Update: {
           id?: never
           position?: number
           relationship_kind?: string
-          snapshot_id?: number
           source_locator?: string
           source_text?: string
           target_code?: string
           target_kind?: string
           target_title?: string | null
+          version_id?: number
         }
         Relationships: [
           {
             foreignKeyName: "academic_structure_snapshot_relationships_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id"]
           },
           {
             foreignKeyName: "academic_structure_snapshot_relationships_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
+            referencedColumns: ["version_id"]
           },
         ]
       }
@@ -211,9 +211,9 @@ export type Database = {
           markdown: string
           position: number
           section_key: string
-          snapshot_id: number
           source_locator: string
           source_text: string
+          version_id: number
         }
         Insert: {
           heading: string
@@ -221,9 +221,9 @@ export type Database = {
           markdown: string
           position: number
           section_key: string
-          snapshot_id: number
           source_locator: string
           source_text: string
+          version_id: number
         }
         Update: {
           heading?: string
@@ -231,24 +231,24 @@ export type Database = {
           markdown?: string
           position?: number
           section_key?: string
-          snapshot_id?: number
           source_locator?: string
           source_text?: string
+          version_id?: number
         }
         Relationships: [
           {
             foreignKeyName: "academic_structure_snapshot_sections_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id"]
           },
           {
             foreignKeyName: "academic_structure_snapshot_sections_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
+            referencedColumns: ["version_id"]
           },
         ]
       }
@@ -800,14 +800,41 @@ export type Database = {
           },
         ]
       }
+      catalogue_codes: {
+        Row: {
+          code: string
+          created_at: string
+          id: number
+          kind: string
+          public_id: string
+          updated_at: string
+        }
+        Insert: {
+          code: string
+          created_at?: string
+          id?: never
+          kind: string
+          public_id?: string
+          updated_at?: string
+        }
+        Update: {
+          code?: string
+          created_at?: string
+          id?: never
+          kind?: string
+          public_id?: string
+          updated_at?: string
+        }
+        Relationships: []
+      }
       catalogue_directory_entries: {
         Row: {
           academic_year_id: number
           code: string
+          code_id: number | null
           first_seen_at: string
           id: number
           is_current: boolean
-          item_id: number | null
           kind: string
           last_seen_at: string
           source_page_id: number | null
@@ -817,10 +844,10 @@ export type Database = {
         Insert: {
           academic_year_id: number
           code: string
+          code_id?: number | null
           first_seen_at?: string
           id?: never
           is_current?: boolean
-          item_id?: number | null
           kind: string
           last_seen_at?: string
           source_page_id?: number | null
@@ -830,10 +857,10 @@ export type Database = {
         Update: {
           academic_year_id?: number
           code?: string
+          code_id?: number | null
           first_seen_at?: string
           id?: never
           is_current?: boolean
-          item_id?: number | null
           kind?: string
           last_seen_at?: string
           source_page_id?: number | null
@@ -850,9 +877,9 @@ export type Database = {
           },
           {
             foreignKeyName: "catalogue_directory_entries_item_fkey"
-            columns: ["item_id", "kind"]
+            columns: ["code_id", "kind"]
             isOneToOne: false
-            referencedRelation: "catalogue_items"
+            referencedRelation: "catalogue_codes"
             referencedColumns: ["id", "kind"]
           },
           {
@@ -1288,12 +1315,13 @@ export type Database = {
         Row: {
           academic_year_id: number
           applied_at: string | null
-          applied_snapshot_id: number | null
+          applied_version_id: number | null
           attempt_count: number
-          baseline_snapshot_id: number | null
-          candidate_snapshot_id: number | null
+          baseline_version_id: number | null
+          candidate_version_id: number | null
           change_kind: string | null
           code: string
+          code_id: number
           completed_at: string | null
           created_at: string
           directory_entry_id: number | null
@@ -1301,12 +1329,11 @@ export type Database = {
           error_code: string | null
           error_message: string | null
           id: string
-          item_id: number
-          item_year_id: number
           kind: string
           lease_expires_at: string | null
           lock_version: number
           queue_message_id: string | null
+          record_id: number
           run_id: string
           source_page_id: number | null
           status: string
@@ -1316,12 +1343,13 @@ export type Database = {
         Insert: {
           academic_year_id: number
           applied_at?: string | null
-          applied_snapshot_id?: number | null
+          applied_version_id?: number | null
           attempt_count?: number
-          baseline_snapshot_id?: number | null
-          candidate_snapshot_id?: number | null
+          baseline_version_id?: number | null
+          candidate_version_id?: number | null
           change_kind?: string | null
           code: string
+          code_id: number
           completed_at?: string | null
           created_at?: string
           directory_entry_id?: number | null
@@ -1329,12 +1357,11 @@ export type Database = {
           error_code?: string | null
           error_message?: string | null
           id?: string
-          item_id: number
-          item_year_id: number
           kind: string
           lease_expires_at?: string | null
           lock_version?: number
           queue_message_id?: string | null
+          record_id: number
           run_id: string
           source_page_id?: number | null
           status?: string
@@ -1344,12 +1371,13 @@ export type Database = {
         Update: {
           academic_year_id?: number
           applied_at?: string | null
-          applied_snapshot_id?: number | null
+          applied_version_id?: number | null
           attempt_count?: number
-          baseline_snapshot_id?: number | null
-          candidate_snapshot_id?: number | null
+          baseline_version_id?: number | null
+          candidate_version_id?: number | null
           change_kind?: string | null
           code?: string
+          code_id?: number
           completed_at?: string | null
           created_at?: string
           directory_entry_id?: number | null
@@ -1357,12 +1385,11 @@ export type Database = {
           error_code?: string | null
           error_message?: string | null
           id?: string
-          item_id?: number
-          item_year_id?: number
           kind?: string
           lease_expires_at?: string | null
           lock_version?: number
           queue_message_id?: string | null
+          record_id?: number
           run_id?: string
           source_page_id?: number | null
           status?: string
@@ -1372,24 +1399,24 @@ export type Database = {
         Relationships: [
           {
             foreignKeyName: "catalogue_import_targets_applied_fkey"
-            columns: ["applied_snapshot_id", "item_year_id"]
+            columns: ["applied_version_id", "record_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
-            referencedColumns: ["id", "item_year_id"]
+            referencedRelation: "catalogue_versions"
+            referencedColumns: ["id", "record_id"]
           },
           {
             foreignKeyName: "catalogue_import_targets_baseline_fkey"
-            columns: ["baseline_snapshot_id", "item_year_id"]
+            columns: ["baseline_version_id", "record_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
-            referencedColumns: ["id", "item_year_id"]
+            referencedRelation: "catalogue_versions"
+            referencedColumns: ["id", "record_id"]
           },
           {
             foreignKeyName: "catalogue_import_targets_candidate_fkey"
-            columns: ["candidate_snapshot_id", "item_year_id"]
+            columns: ["candidate_version_id", "record_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
-            referencedColumns: ["id", "item_year_id"]
+            referencedRelation: "catalogue_versions"
+            referencedColumns: ["id", "record_id"]
           },
           {
             foreignKeyName: "catalogue_import_targets_directory_entry_fkey"
@@ -1400,24 +1427,24 @@ export type Database = {
           },
           {
             foreignKeyName: "catalogue_import_targets_item_fkey"
-            columns: ["item_id", "kind"]
+            columns: ["code_id", "kind"]
             isOneToOne: false
-            referencedRelation: "catalogue_items"
+            referencedRelation: "catalogue_codes"
             referencedColumns: ["id", "kind"]
           },
           {
             foreignKeyName: "catalogue_import_targets_item_year_fkey"
-            columns: ["item_year_id", "academic_year_id"]
+            columns: ["record_id", "academic_year_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_item_years"
+            referencedRelation: "catalogue_records"
             referencedColumns: ["id", "academic_year_id"]
           },
           {
             foreignKeyName: "catalogue_import_targets_item_year_fkey"
-            columns: ["item_year_id", "academic_year_id"]
+            columns: ["record_id", "academic_year_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["item_year_id", "academic_year_id"]
+            referencedColumns: ["record_id", "academic_year_id"]
           },
           {
             foreignKeyName: "catalogue_import_targets_run_fkey"
@@ -1435,242 +1462,113 @@ export type Database = {
           },
         ]
       }
-      catalogue_item_years: {
-        Row: {
-          academic_year_id: number
-          archived_at: string | null
-          created_at: string
-          draft_snapshot_id: number | null
-          id: number
-          item_id: number
-          kind: string
-          public_id: string
-          published_snapshot_id: number | null
-          updated_at: string
-        }
-        Insert: {
-          academic_year_id: number
-          archived_at?: string | null
-          created_at?: string
-          draft_snapshot_id?: number | null
-          id?: never
-          item_id: number
-          kind: string
-          public_id?: string
-          published_snapshot_id?: number | null
-          updated_at?: string
-        }
-        Update: {
-          academic_year_id?: number
-          archived_at?: string | null
-          created_at?: string
-          draft_snapshot_id?: number | null
-          id?: never
-          item_id?: number
-          kind?: string
-          public_id?: string
-          published_snapshot_id?: number | null
-          updated_at?: string
-        }
-        Relationships: [
-          {
-            foreignKeyName: "catalogue_item_years_academic_year_id_fkey"
-            columns: ["academic_year_id"]
-            isOneToOne: false
-            referencedRelation: "academic_years"
-            referencedColumns: ["id"]
-          },
-          {
-            foreignKeyName: "catalogue_item_years_draft_snapshot_fkey"
-            columns: ["draft_snapshot_id", "id"]
-            isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
-            referencedColumns: ["id", "item_year_id"]
-          },
-          {
-            foreignKeyName: "catalogue_item_years_item_kind_fkey"
-            columns: ["item_id", "kind"]
-            isOneToOne: false
-            referencedRelation: "catalogue_items"
-            referencedColumns: ["id", "kind"]
-          },
-          {
-            foreignKeyName: "catalogue_item_years_published_snapshot_fkey"
-            columns: ["published_snapshot_id", "id"]
-            isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
-            referencedColumns: ["id", "item_year_id"]
-          },
-        ]
-      }
-      catalogue_items: {
-        Row: {
-          code: string
-          created_at: string
-          id: number
-          kind: string
-          public_id: string
-          updated_at: string
-        }
-        Insert: {
-          code: string
-          created_at?: string
-          id?: never
-          kind: string
-          public_id?: string
-          updated_at?: string
-        }
-        Update: {
-          code?: string
-          created_at?: string
-          id?: never
-          kind?: string
-          public_id?: string
-          updated_at?: string
-        }
-        Relationships: []
-      }
       catalogue_publications: {
         Row: {
           id: number
-          item_year_id: number
           published_at: string
           published_by: string | null
-          snapshot_id: number | null
+          record_id: number
+          unpublished_at: string | null
+          unpublished_by: string | null
+          version_id: number
         }
         Insert: {
           id?: never
-          item_year_id: number
           published_at?: string
           published_by?: string | null
-          snapshot_id?: number | null
+          record_id: number
+          unpublished_at?: string | null
+          unpublished_by?: string | null
+          version_id: number
         }
         Update: {
           id?: never
-          item_year_id?: number
           published_at?: string
           published_by?: string | null
-          snapshot_id?: number | null
+          record_id?: number
+          unpublished_at?: string | null
+          unpublished_by?: string | null
+          version_id?: number
         }
         Relationships: [
           {
-            foreignKeyName: "catalogue_publications_item_year_id_fkey"
-            columns: ["item_year_id"]
+            foreignKeyName: "catalogue_publications_record_id_fkey"
+            columns: ["record_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_item_years"
+            referencedRelation: "catalogue_records"
             referencedColumns: ["id"]
           },
           {
-            foreignKeyName: "catalogue_publications_item_year_id_fkey"
-            columns: ["item_year_id"]
+            foreignKeyName: "catalogue_publications_record_id_fkey"
+            columns: ["record_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["item_year_id"]
+            referencedColumns: ["record_id"]
           },
           {
-            foreignKeyName: "catalogue_publications_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            foreignKeyName: "catalogue_publications_version_record_fkey"
+            columns: ["version_id", "record_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
-            referencedColumns: ["id"]
-          },
-          {
-            foreignKeyName: "catalogue_publications_snapshot_id_fkey"
-            columns: ["snapshot_id"]
-            isOneToOne: false
-            referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
+            referencedRelation: "catalogue_versions"
+            referencedColumns: ["id", "record_id"]
           },
         ]
       }
-      catalogue_snapshots: {
+      catalogue_records: {
         Row: {
           academic_year_id: number
-          based_on_snapshot_id: number | null
-          content_hash: string
+          archived_at: string | null
+          code_id: number
           created_at: string
-          created_by: string | null
           id: number
-          import_target_id: string | null
-          item_year_id: number
           kind: string
-          origin: string
           public_id: string
-          sealed_at: string | null
-          source_page_id: number | null
+          published_version_id: number | null
+          updated_at: string
         }
         Insert: {
           academic_year_id: number
-          based_on_snapshot_id?: number | null
-          content_hash: string
+          archived_at?: string | null
+          code_id: number
           created_at?: string
-          created_by?: string | null
           id?: never
-          import_target_id?: string | null
-          item_year_id: number
           kind: string
-          origin: string
           public_id?: string
-          sealed_at?: string | null
-          source_page_id?: number | null
+          published_version_id?: number | null
+          updated_at?: string
         }
         Update: {
           academic_year_id?: number
-          based_on_snapshot_id?: number | null
-          content_hash?: string
+          archived_at?: string | null
+          code_id?: number
           created_at?: string
-          created_by?: string | null
           id?: never
-          import_target_id?: string | null
-          item_year_id?: number
           kind?: string
-          origin?: string
           public_id?: string
-          sealed_at?: string | null
-          source_page_id?: number | null
+          published_version_id?: number | null
+          updated_at?: string
         }
         Relationships: [
           {
-            foreignKeyName: "catalogue_snapshots_based_on_fkey"
-            columns: ["based_on_snapshot_id", "item_year_id"]
-            isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
-            referencedColumns: ["id", "item_year_id"]
-          },
-          {
-            foreignKeyName: "catalogue_snapshots_import_target_fkey"
-            columns: ["import_target_id"]
+            foreignKeyName: "catalogue_records_academic_year_id_fkey"
+            columns: ["academic_year_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_import_targets"
+            referencedRelation: "academic_years"
             referencedColumns: ["id"]
           },
           {
-            foreignKeyName: "catalogue_snapshots_item_year_fkey"
-            columns: ["item_year_id", "academic_year_id"]
-            isOneToOne: false
-            referencedRelation: "catalogue_item_years"
-            referencedColumns: ["id", "academic_year_id"]
-          },
-          {
-            foreignKeyName: "catalogue_snapshots_item_year_fkey"
-            columns: ["item_year_id", "academic_year_id"]
+            foreignKeyName: "catalogue_records_code_kind_fkey"
+            columns: ["code_id", "kind"]
             isOneToOne: false
-            referencedRelation: "published_course_summaries"
-            referencedColumns: ["item_year_id", "academic_year_id"]
-          },
-          {
-            foreignKeyName: "catalogue_snapshots_item_year_kind_fkey"
-            columns: ["item_year_id", "kind"]
-            isOneToOne: false
-            referencedRelation: "catalogue_item_years"
+            referencedRelation: "catalogue_codes"
             referencedColumns: ["id", "kind"]
           },
           {
-            foreignKeyName: "catalogue_snapshots_source_page_fkey"
-            columns: ["source_page_id", "academic_year_id"]
+            foreignKeyName: "catalogue_records_published_version_fkey"
+            columns: ["published_version_id", "id"]
             isOneToOne: false
-            referencedRelation: "catalogue_source_pages"
-            referencedColumns: ["id", "academic_year_id"]
+            referencedRelation: "catalogue_versions"
+            referencedColumns: ["id", "record_id"]
           },
         ]
       }
@@ -1776,42 +1674,187 @@ export type Database = {
         }
         Relationships: []
       }
+      catalogue_version_provenance: {
+        Row: {
+          academic_year_id: number
+          confidence: number | null
+          created_at: string
+          field_path: string
+          id: number
+          method: string
+          source_excerpt: string | null
+          source_locator: string | null
+          source_page_id: number | null
+          version_id: number
+        }
+        Insert: {
+          academic_year_id: number
+          confidence?: number | null
+          created_at?: string
+          field_path: string
+          id?: never
+          method: string
+          source_excerpt?: string | null
+          source_locator?: string | null
+          source_page_id?: number | null
+          version_id: number
+        }
+        Update: {
+          academic_year_id?: number
+          confidence?: number | null
+          created_at?: string
+          field_path?: string
+          id?: never
+          method?: string
+          source_excerpt?: string | null
+          source_locator?: string | null
+          source_page_id?: number | null
+          version_id?: number
+        }
+        Relationships: [
+          {
+            foreignKeyName: "catalogue_version_provenance_snapshot_fkey"
+            columns: ["version_id", "academic_year_id"]
+            isOneToOne: false
+            referencedRelation: "catalogue_versions"
+            referencedColumns: ["id", "academic_year_id"]
+          },
+          {
+            foreignKeyName: "catalogue_version_provenance_source_page_fkey"
+            columns: ["source_page_id", "academic_year_id"]
+            isOneToOne: false
+            referencedRelation: "catalogue_source_pages"
+            referencedColumns: ["id", "academic_year_id"]
+          },
+        ]
+      }
+      catalogue_versions: {
+        Row: {
+          academic_year_id: number
+          based_on_version_id: number | null
+          content_hash: string
+          created_at: string
+          created_by: string | null
+          id: number
+          import_target_id: string | null
+          kind: string
+          origin: string
+          public_id: string
+          record_id: number
+          sealed_at: string | null
+          source_page_id: number | null
+        }
+        Insert: {
+          academic_year_id: number
+          based_on_version_id?: number | null
+          content_hash: string
+          created_at?: string
+          created_by?: string | null
+          id?: never
+          import_target_id?: string | null
+          kind: string
+          origin: string
+          public_id?: string
+          record_id: number
+          sealed_at?: string | null
+          source_page_id?: number | null
+        }
+        Update: {
+          academic_year_id?: number
+          based_on_version_id?: number | null
+          content_hash?: string
+          created_at?: string
+          created_by?: string | null
+          id?: never
+          import_target_id?: string | null
+          kind?: string
+          origin?: string
+          public_id?: string
+          record_id?: number
+          sealed_at?: string | null
+          source_page_id?: number | null
+        }
+        Relationships: [
+          {
+            foreignKeyName: "catalogue_versions_based_on_fkey"
+            columns: ["based_on_version_id", "record_id"]
+            isOneToOne: false
+            referencedRelation: "catalogue_versions"
+            referencedColumns: ["id", "record_id"]
+          },
+          {
+            foreignKeyName: "catalogue_versions_import_target_fkey"
+            columns: ["import_target_id"]
+            isOneToOne: false
+            referencedRelation: "catalogue_import_targets"
+            referencedColumns: ["id"]
+          },
+          {
+            foreignKeyName: "catalogue_versions_item_year_fkey"
+            columns: ["record_id", "academic_year_id"]
+            isOneToOne: false
+            referencedRelation: "catalogue_records"
+            referencedColumns: ["id", "academic_year_id"]
+          },
+          {
+            foreignKeyName: "catalogue_versions_item_year_fkey"
+            columns: ["record_id", "academic_year_id"]
+            isOneToOne: false
+            referencedRelation: "published_course_summaries"
+            referencedColumns: ["record_id", "academic_year_id"]
+          },
+          {
+            foreignKeyName: "catalogue_versions_item_year_kind_fkey"
+            columns: ["record_id", "kind"]
+            isOneToOne: false
+            referencedRelation: "catalogue_records"
+            referencedColumns: ["id", "kind"]
+          },
+          {
+            foreignKeyName: "catalogue_versions_source_page_fkey"
+            columns: ["source_page_id", "academic_year_id"]
+            isOneToOne: false
+            referencedRelation: "catalogue_source_pages"
+            referencedColumns: ["id", "academic_year_id"]
+          },
+        ]
+      }
       course_areas_of_interest: {
         Row: {
           created_at: string
           id: number
           name: string
           position: number
-          snapshot_id: number
+          version_id: number
         }
         Insert: {
           created_at?: string
           id?: never
           name: string
           position: number
-          snapshot_id: number
+          version_id: number
         }
         Update: {
           created_at?: string
           id?: never
           name?: string
           position?: number
-          snapshot_id?: number
+          version_id?: number
         }
         Relationships: [
           {
             foreignKeyName: "course_areas_of_interest_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id"]
           },
           {
             foreignKeyName: "course_areas_of_interest_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
+            referencedColumns: ["version_id"]
           },
         ]
       }
@@ -1823,10 +1866,10 @@ export type Database = {
           id: number
           learning_outcomes: number[] | null
           position: number
-          snapshot_id: number
           source_text: string
           title: string
           updated_at: string
+          version_id: number
           weight: number | null
         }
         Insert: {
@@ -1836,10 +1879,10 @@ export type Database = {
           id?: never
           learning_outcomes?: number[] | null
           position: number
-          snapshot_id: number
           source_text: string
           title: string
           updated_at?: string
+          version_id: number
           weight?: number | null
         }
         Update: {
@@ -1849,26 +1892,26 @@ export type Database = {
           id?: never
           learning_outcomes?: number[] | null
           position?: number
-          snapshot_id?: number
           source_text?: string
           title?: string
           updated_at?: string
+          version_id?: number
           weight?: number | null
         }
         Relationships: [
           {
             foreignKeyName: "course_assessment_items_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id"]
           },
           {
             foreignKeyName: "course_assessment_items_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
+            referencedColumns: ["version_id"]
           },
         ]
       }
@@ -1877,56 +1920,55 @@ export type Database = {
           assessment_item_id: number
           created_at: string
           learning_outcome_id: number
-          snapshot_id: number
+          version_id: number
         }
         Insert: {
           assessment_item_id: number
           created_at?: string
           learning_outcome_id: number
-          snapshot_id: number
+          version_id: number
         }
         Update: {
           assessment_item_id?: number
           created_at?: string
           learning_outcome_id?: number
-          snapshot_id?: number
+          version_id?: number
         }
         Relationships: [
           {
             foreignKeyName: "course_assessment_outcomes_assessment_snapshot_fkey"
-            columns: ["assessment_item_id", "snapshot_id"]
+            columns: ["assessment_item_id", "version_id"]
             isOneToOne: false
             referencedRelation: "course_assessment_items"
-            referencedColumns: ["id", "snapshot_id"]
+            referencedColumns: ["id", "version_id"]
           },
           {
             foreignKeyName: "course_assessment_outcomes_learning_outcome_snapshot_fkey"
-            columns: ["learning_outcome_id", "snapshot_id"]
+            columns: ["learning_outcome_id", "version_id"]
             isOneToOne: false
             referencedRelation: "course_learning_outcomes"
-            referencedColumns: ["id", "snapshot_id"]
+            referencedColumns: ["id", "version_id"]
           },
           {
             foreignKeyName: "course_assessment_outcomes_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id"]
           },
           {
             foreignKeyName: "course_assessment_outcomes_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
+            referencedColumns: ["version_id"]
           },
         ]
       }
       course_attempts: {
         Row: {
           academic_period_id: number
-          course_id: number
-          course_snapshot_id: number
+          catalogue_version_id: number
           created_at: string
           grade: string | null
           id: string
@@ -1940,8 +1982,7 @@ export type Database = {
         }
         Insert: {
           academic_period_id: number
-          course_id: number
-          course_snapshot_id: number
+          catalogue_version_id: number
           created_at?: string
           grade?: string | null
           id?: string
@@ -1955,8 +1996,7 @@ export type Database = {
         }
         Update: {
           academic_period_id?: number
-          course_id?: number
-          course_snapshot_id?: number
+          catalogue_version_id?: number
           created_at?: string
           grade?: string | null
           id?: string
@@ -1977,32 +2017,18 @@ export type Database = {
             referencedColumns: ["id"]
           },
           {
-            foreignKeyName: "course_attempts_course_item_fkey"
-            columns: ["course_id"]
+            foreignKeyName: "course_attempts_catalogue_version_fkey"
+            columns: ["catalogue_version_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_items"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id"]
           },
           {
-            foreignKeyName: "course_attempts_course_item_fkey"
-            columns: ["course_id"]
+            foreignKeyName: "course_attempts_catalogue_version_fkey"
+            columns: ["catalogue_version_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["item_id"]
-          },
-          {
-            foreignKeyName: "course_attempts_snapshot_fkey"
-            columns: ["course_snapshot_id"]
-            isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
-            referencedColumns: ["id"]
-          },
-          {
-            foreignKeyName: "course_attempts_snapshot_fkey"
-            columns: ["course_snapshot_id"]
-            isOneToOne: false
-            referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
+            referencedColumns: ["version_id"]
           },
         ]
       }
@@ -2012,42 +2038,42 @@ export type Database = {
           created_at: string
           id: number
           position: number
-          snapshot_id: number
           source_text: string
           value: string
+          version_id: number
         }
         Insert: {
           attribute_kind: string
           created_at?: string
           id?: never
           position: number
-          snapshot_id: number
           source_text: string
           value: string
+          version_id: number
         }
         Update: {
           attribute_kind?: string
           created_at?: string
           id?: never
           position?: number
-          snapshot_id?: number
           source_text?: string
           value?: string
+          version_id?: number
         }
         Relationships: [
           {
             foreignKeyName: "course_attributes_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id"]
           },
           {
             foreignKeyName: "course_attributes_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
+            referencedColumns: ["version_id"]
           },
         ]
       }
@@ -2062,10 +2088,10 @@ export type Database = {
           fee_year: number | null
           id: number
           position: number
-          snapshot_id: number
           source_label: string | null
           source_text: string | null
           student_contribution_band: number | null
+          version_id: number
         }
         Insert: {
           amount?: number | null
@@ -2077,10 +2103,10 @@ export type Database = {
           fee_year?: number | null
           id?: never
           position: number
-          snapshot_id: number
           source_label?: string | null
           source_text?: string | null
           student_contribution_band?: number | null
+          version_id: number
         }
         Update: {
           amount?: number | null
@@ -2092,25 +2118,25 @@ export type Database = {
           fee_year?: number | null
           id?: never
           position?: number
-          snapshot_id?: number
           source_label?: string | null
           source_text?: string | null
           student_contribution_band?: number | null
+          version_id?: number
         }
         Relationships: [
           {
             foreignKeyName: "course_fees_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id"]
           },
           {
             foreignKeyName: "course_fees_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
+            referencedColumns: ["version_id"]
           },
         ]
       }
@@ -2120,39 +2146,39 @@ export type Database = {
           created_at: string
           id: number
           position: number
-          snapshot_id: number
           updated_at: string
+          version_id: number
         }
         Insert: {
           body: string
           created_at?: string
           id?: never
           position: number
-          snapshot_id: number
           updated_at?: string
+          version_id: number
         }
         Update: {
           body?: string
           created_at?: string
           id?: never
           position?: number
-          snapshot_id?: number
           updated_at?: string
+          version_id?: number
         }
         Relationships: [
           {
             foreignKeyName: "course_learning_outcomes_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id"]
           },
           {
             foreignKeyName: "course_learning_outcomes_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
+            referencedColumns: ["version_id"]
           },
         ]
       }
@@ -2163,9 +2189,9 @@ export type Database = {
           delivery_mode: string | null
           id: number
           location: string | null
-          snapshot_id: number
           source_page_id: number | null
           updated_at: string
+          version_id: number
         }
         Insert: {
           academic_year_id: number
@@ -2173,9 +2199,9 @@ export type Database = {
           delivery_mode?: string | null
           id?: never
           location?: string | null
-          snapshot_id: number
           source_page_id?: number | null
           updated_at?: string
+          version_id: number
         }
         Update: {
           academic_year_id?: number
@@ -2183,30 +2209,30 @@ export type Database = {
           delivery_mode?: string | null
           id?: never
           location?: string | null
-          snapshot_id?: number
           source_page_id?: number | null
           updated_at?: string
+          version_id?: number
         }
         Relationships: [
           {
             foreignKeyName: "course_offerings_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: true
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id"]
           },
           {
             foreignKeyName: "course_offerings_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: true
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
+            referencedColumns: ["version_id"]
           },
           {
             foreignKeyName: "course_offerings_snapshot_year_fkey"
-            columns: ["snapshot_id", "academic_year_id"]
+            columns: ["version_id", "academic_year_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id", "academic_year_id"]
           },
           {
@@ -2225,10 +2251,10 @@ export type Database = {
           position: number
           related_course_id: number
           relation_kind: string
-          snapshot_id: number
           source_course_code: string
           source_course_title: string | null
           source_text: string | null
+          version_id: number
         }
         Insert: {
           created_at?: string
@@ -2236,10 +2262,10 @@ export type Database = {
           position: number
           related_course_id: number
           relation_kind: string
-          snapshot_id: number
           source_course_code: string
           source_course_title?: string | null
           source_text?: string | null
+          version_id: number
         }
         Update: {
           created_at?: string
@@ -2247,17 +2273,17 @@ export type Database = {
           position?: number
           related_course_id?: number
           relation_kind?: string
-          snapshot_id?: number
           source_course_code?: string
           source_course_title?: string | null
           source_text?: string | null
+          version_id?: number
         }
         Relationships: [
           {
             foreignKeyName: "course_related_courses_related_item_fkey"
             columns: ["related_course_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_items"
+            referencedRelation: "catalogue_codes"
             referencedColumns: ["id"]
           },
           {
@@ -2265,25 +2291,70 @@ export type Database = {
             columns: ["related_course_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["item_id"]
+            referencedColumns: ["code_id"]
           },
           {
             foreignKeyName: "course_related_courses_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id"]
           },
           {
             foreignKeyName: "course_related_courses_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
+            referencedColumns: ["version_id"]
           },
         ]
       }
-      course_snapshot_details: {
+      course_unit_options: {
+        Row: {
+          created_at: string
+          id: number
+          label: string | null
+          position: number
+          source_text: string
+          units: number
+          version_id: number
+        }
+        Insert: {
+          created_at?: string
+          id?: never
+          label?: string | null
+          position: number
+          source_text: string
+          units: number
+          version_id: number
+        }
+        Update: {
+          created_at?: string
+          id?: never
+          label?: string | null
+          position?: number
+          source_text?: string
+          units?: number
+          version_id?: number
+        }
+        Relationships: [
+          {
+            foreignKeyName: "course_unit_options_snapshot_id_fkey"
+            columns: ["version_id"]
+            isOneToOne: false
+            referencedRelation: "catalogue_versions"
+            referencedColumns: ["id"]
+          },
+          {
+            foreignKeyName: "course_unit_options_snapshot_id_fkey"
+            columns: ["version_id"]
+            isOneToOne: false
+            referencedRelation: "published_course_summaries"
+            referencedColumns: ["version_id"]
+          },
+        ]
+      }
+      course_version_details: {
         Row: {
           academic_career: string | null
           college: string | null
@@ -2300,13 +2371,13 @@ export type Database = {
           offering_status: string
           prescribed_texts: string | null
           school: string | null
-          snapshot_id: number
           source_updated_at: string | null
           subject_code: string
           subject_name: string | null
           title: string
           unit_value_kind: string
           units: number | null
+          version_id: number
           workload_hours: number | null
           workload_text: string | null
         }
@@ -2326,13 +2397,13 @@ export type Database = {
           offering_status?: string
           prescribed_texts?: string | null
           school?: string | null
-          snapshot_id: number
           source_updated_at?: string | null
           subject_code: string
           subject_name?: string | null
           title: string
           unit_value_kind?: string
           units?: number | null
+          version_id: number
           workload_hours?: number | null
           workload_text?: string | null
         }
@@ -2352,71 +2423,26 @@ export type Database = {
           offering_status?: string
           prescribed_texts?: string | null
           school?: string | null
-          snapshot_id?: number
           source_updated_at?: string | null
           subject_code?: string
           subject_name?: string | null
           title?: string
           unit_value_kind?: string
           units?: number | null
+          version_id?: number
           workload_hours?: number | null
           workload_text?: string | null
         }
         Relationships: [
           {
-            foreignKeyName: "course_snapshot_details_snapshot_kind_fkey"
-            columns: ["snapshot_id", "kind"]
+            foreignKeyName: "course_version_details_snapshot_kind_fkey"
+            columns: ["version_id", "kind"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id", "kind"]
           },
         ]
       }
-      course_unit_options: {
-        Row: {
-          created_at: string
-          id: number
-          label: string | null
-          position: number
-          snapshot_id: number
-          source_text: string
-          units: number
-        }
-        Insert: {
-          created_at?: string
-          id?: never
-          label?: string | null
-          position: number
-          snapshot_id: number
-          source_text: string
-          units: number
-        }
-        Update: {
-          created_at?: string
-          id?: never
-          label?: string | null
-          position?: number
-          snapshot_id?: number
-          source_text?: string
-          units?: number
-        }
-        Relationships: [
-          {
-            foreignKeyName: "course_unit_options_snapshot_id_fkey"
-            columns: ["snapshot_id"]
-            isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
-            referencedColumns: ["id"]
-          },
-          {
-            foreignKeyName: "course_unit_options_snapshot_id_fkey"
-            columns: ["snapshot_id"]
-            isOneToOne: false
-            referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
-          },
-        ]
-      }
       import_models: {
         Row: {
           enabled: boolean
@@ -2506,11 +2532,11 @@ export type Database = {
           id: number
           location: string | null
           position: number
-          snapshot_id: number
           source_page_id: number | null
           source_text: string
           starts_on: string | null
           updated_at: string
+          version_id: number
         }
         Insert: {
           academic_period_code: string
@@ -2528,11 +2554,11 @@ export type Database = {
           id?: never
           location?: string | null
           position: number
-          snapshot_id: number
           source_page_id?: number | null
           source_text: string
           starts_on?: string | null
           updated_at?: string
+          version_id: number
         }
         Update: {
           academic_period_code?: string
@@ -2550,11 +2576,11 @@ export type Database = {
           id?: never
           location?: string | null
           position?: number
-          snapshot_id?: number
           source_page_id?: number | null
           source_text?: string
           starts_on?: string | null
           updated_at?: string
+          version_id?: number
         }
         Relationships: [
           {
@@ -2566,30 +2592,30 @@ export type Database = {
           },
           {
             foreignKeyName: "offering_sessions_offering_snapshot_fkey"
-            columns: ["course_offering_id", "snapshot_id"]
+            columns: ["course_offering_id", "version_id"]
             isOneToOne: false
             referencedRelation: "course_offerings"
-            referencedColumns: ["id", "snapshot_id"]
+            referencedColumns: ["id", "version_id"]
           },
           {
             foreignKeyName: "offering_sessions_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id"]
           },
           {
             foreignKeyName: "offering_sessions_snapshot_id_fkey"
-            columns: ["snapshot_id"]
+            columns: ["version_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
+            referencedColumns: ["version_id"]
           },
           {
             foreignKeyName: "offering_sessions_snapshot_year_fkey"
-            columns: ["snapshot_id", "academic_year_id"]
+            columns: ["version_id", "academic_year_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id", "academic_year_id"]
           },
           {
@@ -2604,8 +2630,7 @@ export type Database = {
       plan_items: {
         Row: {
           academic_period_id: number | null
-          academic_year_id: number
-          course_id: number
+          catalogue_record_id: number
           created_at: string
           id: string
           notes: string | null
@@ -2618,8 +2643,7 @@ export type Database = {
         }
         Insert: {
           academic_period_id?: number | null
-          academic_year_id: number
-          course_id: number
+          catalogue_record_id: number
           created_at?: string
           id?: string
           notes?: string | null
@@ -2632,8 +2656,7 @@ export type Database = {
         }
         Update: {
           academic_period_id?: number | null
-          academic_year_id?: number
-          course_id?: number
+          catalogue_record_id?: number
           created_at?: string
           id?: string
           notes?: string | null
@@ -2653,39 +2676,18 @@ export type Database = {
             referencedColumns: ["id"]
           },
           {
-            foreignKeyName: "plan_items_academic_year_calendar_year_fkey"
-            columns: ["academic_year_id", "planned_calendar_year"]
+            foreignKeyName: "plan_items_catalogue_record_fkey"
+            columns: ["catalogue_record_id"]
             isOneToOne: false
-            referencedRelation: "academic_years"
-            referencedColumns: ["id", "year"]
-          },
-          {
-            foreignKeyName: "plan_items_academic_year_id_fkey"
-            columns: ["academic_year_id"]
-            isOneToOne: false
-            referencedRelation: "academic_years"
+            referencedRelation: "catalogue_records"
             referencedColumns: ["id"]
           },
           {
-            foreignKeyName: "plan_items_course_item_fkey"
-            columns: ["course_id"]
-            isOneToOne: false
-            referencedRelation: "catalogue_items"
-            referencedColumns: ["id"]
-          },
-          {
-            foreignKeyName: "plan_items_course_item_fkey"
-            columns: ["course_id"]
+            foreignKeyName: "plan_items_catalogue_record_fkey"
+            columns: ["catalogue_record_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["item_id"]
-          },
-          {
-            foreignKeyName: "plan_items_course_item_year_fkey"
-            columns: ["course_id", "academic_year_id"]
-            isOneToOne: false
-            referencedRelation: "catalogue_item_years"
-            referencedColumns: ["item_id", "academic_year_id"]
+            referencedColumns: ["record_id"]
           },
           {
             foreignKeyName: "plan_items_plan_owner_fkey"
@@ -2698,59 +2700,49 @@ export type Database = {
       }
       plan_structures: {
         Row: {
-          academic_year_id: number
+          catalogue_record_id: number
           created_at: string
           id: string
           owner_id: string
           plan_id: string
           position: number
           role: string
-          structure_year_id: number
           updated_at: string
         }
         Insert: {
-          academic_year_id: number
+          catalogue_record_id: number
           created_at?: string
           id?: string
           owner_id: string
           plan_id: string
           position?: number
           role: string
-          structure_year_id: number
           updated_at?: string
         }
         Update: {
-          academic_year_id?: number
+          catalogue_record_id?: number
           created_at?: string
           id?: string
           owner_id?: string
           plan_id?: string
           position?: number
           role?: string
-          structure_year_id?: number
           updated_at?: string
         }
         Relationships: [
           {
-            foreignKeyName: "plan_structures_item_year_fkey"
-            columns: ["structure_year_id", "academic_year_id"]
+            foreignKeyName: "plan_structures_catalogue_record_fkey"
+            columns: ["catalogue_record_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_item_years"
-            referencedColumns: ["id", "academic_year_id"]
+            referencedRelation: "catalogue_records"
+            referencedColumns: ["id"]
           },
           {
-            foreignKeyName: "plan_structures_item_year_fkey"
-            columns: ["structure_year_id", "academic_year_id"]
+            foreignKeyName: "plan_structures_catalogue_record_fkey"
+            columns: ["catalogue_record_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["item_year_id", "academic_year_id"]
-          },
-          {
-            foreignKeyName: "plan_structures_plan_owner_academic_year_fkey"
-            columns: ["plan_id", "owner_id", "academic_year_id"]
-            isOneToOne: false
-            referencedRelation: "plans"
-            referencedColumns: ["id", "owner_id", "academic_year_id"]
+            referencedColumns: ["record_id"]
           },
         ]
       }
@@ -2834,56 +2826,57 @@ export type Database = {
       requirement_condition_options: {
         Row: {
           code: string
+          code_id: number | null
           condition_id: number
           id: number
-          item_id: number | null
           kind: string
           position: number
-          snapshot_id: number
           source_text: string | null
           title: string | null
+          version_id: number
         }
         Insert: {
           code: string
+          code_id?: number | null
           condition_id: number
           id?: never
-          item_id?: number | null
           kind: string
           position: number
-          snapshot_id: number
           source_text?: string | null
           title?: string | null
+          version_id: number
         }
         Update: {
           code?: string
+          code_id?: number | null
           condition_id?: number
           id?: never
-          item_id?: number | null
           kind?: string
           position?: number
-          snapshot_id?: number
           source_text?: string | null
           title?: string | null
+          version_id?: number
         }
         Relationships: [
           {
             foreignKeyName: "requirement_condition_options_condition_fkey"
-            columns: ["condition_id", "snapshot_id"]
+            columns: ["condition_id", "version_id"]
             isOneToOne: false
             referencedRelation: "requirement_conditions"
-            referencedColumns: ["id", "snapshot_id"]
+            referencedColumns: ["id", "version_id"]
           },
           {
             foreignKeyName: "requirement_condition_options_item_fkey"
-            columns: ["item_id", "kind"]
+            columns: ["code_id", "kind"]
             isOneToOne: false
-            referencedRelation: "catalogue_items"
+            referencedRelation: "catalogue_codes"
             referencedColumns: ["id", "kind"]
           },
         ]
       }
       requirement_conditions: {
         Row: {
+          code_id: number | null
           condition_key: string
           condition_kind: string
           confidence: number
@@ -2891,7 +2884,6 @@ export type Database = {
           group_id: number
           hardness: string
           id: number
-          item_id: number | null
           item_kind: string | null
           maximum_level: number | null
           maximum_units: number | null
@@ -2906,14 +2898,15 @@ export type Database = {
           requirement_mode: string | null
           review_state: string
           rule_id: number
-          snapshot_id: number
           source_locator: string | null
           source_text: string | null
           structure_kind: string | null
           subject_code: string | null
           tag: string | null
+          version_id: number
         }
         Insert: {
+          code_id?: number | null
           condition_key: string
           condition_kind: string
           confidence?: number
@@ -2921,7 +2914,6 @@ export type Database = {
           group_id: number
           hardness?: string
           id?: never
-          item_id?: number | null
           item_kind?: string | null
           maximum_level?: number | null
           maximum_units?: number | null
@@ -2936,14 +2928,15 @@ export type Database = {
           requirement_mode?: string | null
           review_state?: string
           rule_id: number
-          snapshot_id: number
           source_locator?: string | null
           source_text?: string | null
           structure_kind?: string | null
           subject_code?: string | null
           tag?: string | null
+          version_id: number
         }
         Update: {
+          code_id?: number | null
           condition_key?: string
           condition_kind?: string
           confidence?: number
@@ -2951,7 +2944,6 @@ export type Database = {
           group_id?: number
           hardness?: string
           id?: never
-          item_id?: number | null
           item_kind?: string | null
           maximum_level?: number | null
           maximum_units?: number | null
@@ -2966,12 +2958,12 @@ export type Database = {
           requirement_mode?: string | null
           review_state?: string
           rule_id?: number
-          snapshot_id?: number
           source_locator?: string | null
           source_text?: string | null
           structure_kind?: string | null
           subject_code?: string | null
           tag?: string | null
+          version_id?: number
         }
         Relationships: [
           {
@@ -2983,17 +2975,17 @@ export type Database = {
           },
           {
             foreignKeyName: "requirement_conditions_item_fkey"
-            columns: ["item_id", "item_kind"]
+            columns: ["code_id", "item_kind"]
             isOneToOne: false
-            referencedRelation: "catalogue_items"
+            referencedRelation: "catalogue_codes"
             referencedColumns: ["id", "kind"]
           },
           {
             foreignKeyName: "requirement_conditions_rule_fkey"
-            columns: ["rule_id", "snapshot_id"]
+            columns: ["rule_id", "version_id"]
             isOneToOne: false
             referencedRelation: "requirement_rules"
-            referencedColumns: ["id", "snapshot_id"]
+            referencedColumns: ["id", "version_id"]
           },
         ]
       }
@@ -3010,9 +3002,9 @@ export type Database = {
           parent_group_id: number | null
           position: number
           rule_id: number
-          snapshot_id: number
           source_locator: string | null
           source_text: string | null
+          version_id: number
         }
         Insert: {
           description?: string | null
@@ -3026,9 +3018,9 @@ export type Database = {
           parent_group_id?: number | null
           position?: number
           rule_id: number
-          snapshot_id: number
           source_locator?: string | null
           source_text?: string | null
+          version_id: number
         }
         Update: {
           description?: string | null
@@ -3042,9 +3034,9 @@ export type Database = {
           parent_group_id?: number | null
           position?: number
           rule_id?: number
-          snapshot_id?: number
           source_locator?: string | null
           source_text?: string | null
+          version_id?: number
         }
         Relationships: [
           {
@@ -3056,62 +3048,62 @@ export type Database = {
           },
           {
             foreignKeyName: "requirement_groups_rule_fkey"
-            columns: ["rule_id", "snapshot_id"]
+            columns: ["rule_id", "version_id"]
             isOneToOne: false
             referencedRelation: "requirement_rules"
-            referencedColumns: ["id", "snapshot_id"]
+            referencedColumns: ["id", "version_id"]
           },
         ]
       }
       requirement_item_references: {
         Row: {
+          code_id: number
           confidence: number
           id: number
-          item_id: number
           review_state: string
           rule_id: number
-          snapshot_id: number
           source_text: string
+          version_id: number
         }
         Insert: {
+          code_id: number
           confidence?: number
           id?: never
-          item_id: number
           review_state?: string
           rule_id: number
-          snapshot_id: number
           source_text: string
+          version_id: number
         }
         Update: {
+          code_id?: number
           confidence?: number
           id?: never
-          item_id?: number
           review_state?: string
           rule_id?: number
-          snapshot_id?: number
           source_text?: string
+          version_id?: number
         }
         Relationships: [
           {
             foreignKeyName: "requirement_item_references_item_fkey"
-            columns: ["item_id"]
+            columns: ["code_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_items"
+            referencedRelation: "catalogue_codes"
             referencedColumns: ["id"]
           },
           {
             foreignKeyName: "requirement_item_references_item_fkey"
-            columns: ["item_id"]
+            columns: ["code_id"]
             isOneToOne: false
             referencedRelation: "published_course_summaries"
-            referencedColumns: ["item_id"]
+            referencedColumns: ["code_id"]
           },
           {
             foreignKeyName: "requirement_item_references_rule_fkey"
-            columns: ["rule_id", "snapshot_id"]
+            columns: ["rule_id", "version_id"]
             isOneToOne: false
             referencedRelation: "requirement_rules"
-            referencedColumns: ["id", "snapshot_id"]
+            referencedColumns: ["id", "version_id"]
           },
         ]
       }
@@ -3125,10 +3117,10 @@ export type Database = {
           position: number
           review_state: string
           rule_kind: string
-          snapshot_id: number
           source_locator: string | null
           source_page_id: number | null
           source_text: string
+          version_id: number
         }
         Insert: {
           academic_year_id: number
@@ -3139,10 +3131,10 @@ export type Database = {
           position?: number
           review_state?: string
           rule_kind: string
-          snapshot_id: number
           source_locator?: string | null
           source_page_id?: number | null
           source_text: string
+          version_id: number
         }
         Update: {
           academic_year_id?: number
@@ -3153,17 +3145,17 @@ export type Database = {
           position?: number
           review_state?: string
           rule_kind?: string
-          snapshot_id?: number
           source_locator?: string | null
           source_page_id?: number | null
           source_text?: string
+          version_id?: number
         }
         Relationships: [
           {
             foreignKeyName: "requirement_rules_snapshot_fkey"
-            columns: ["snapshot_id", "academic_year_id"]
+            columns: ["version_id", "academic_year_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id", "academic_year_id"]
           },
           {
@@ -3175,61 +3167,52 @@ export type Database = {
           },
         ]
       }
-      snapshot_field_evidence: {
+      structure_snapshot_summary_fields: {
         Row: {
-          academic_year_id: number
-          confidence: number | null
-          created_at: string
-          field_path: string
-          id: number
-          method: string
-          snapshot_id: number
-          source_excerpt: string | null
-          source_locator: string | null
-          source_page_id: number | null
+          field_key: string
+          field_value: string
+          label: string
+          position: number
+          source_text: string
+          value_position: number
+          version_id: number
         }
         Insert: {
-          academic_year_id: number
-          confidence?: number | null
-          created_at?: string
-          field_path: string
-          id?: never
-          method: string
-          snapshot_id: number
-          source_excerpt?: string | null
-          source_locator?: string | null
-          source_page_id?: number | null
+          field_key: string
+          field_value: string
+          label: string
+          position: number
+          source_text: string
+          value_position: number
+          version_id: number
         }
         Update: {
-          academic_year_id?: number
-          confidence?: number | null
-          created_at?: string
-          field_path?: string
-          id?: never
-          method?: string
-          snapshot_id?: number
-          source_excerpt?: string | null
-          source_locator?: string | null
-          source_page_id?: number | null
+          field_key?: string
+          field_value?: string
+          label?: string
+          position?: number
+          source_text?: string
+          value_position?: number
+          version_id?: number
         }
         Relationships: [
           {
-            foreignKeyName: "snapshot_field_evidence_snapshot_fkey"
-            columns: ["snapshot_id", "academic_year_id"]
+            foreignKeyName: "structure_snapshot_summary_fields_snapshot_fkey"
+            columns: ["version_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
-            referencedColumns: ["id", "academic_year_id"]
+            referencedRelation: "catalogue_versions"
+            referencedColumns: ["id"]
           },
           {
-            foreignKeyName: "snapshot_field_evidence_source_page_fkey"
-            columns: ["source_page_id", "academic_year_id"]
+            foreignKeyName: "structure_snapshot_summary_fields_snapshot_fkey"
+            columns: ["version_id"]
             isOneToOne: false
-            referencedRelation: "catalogue_source_pages"
-            referencedColumns: ["id", "academic_year_id"]
+            referencedRelation: "published_course_summaries"
+            referencedColumns: ["version_id"]
           },
         ]
       }
-      structure_snapshot_details: {
+      structure_version_details: {
         Row: {
           academic_career: string | null
           acronym: string | null
@@ -3246,9 +3229,9 @@ export type Database = {
           name: string
           selection_rank: number | null
           short_name: string | null
-          snapshot_id: number
           study_as: string | null
           units: number | null
+          version_id: number
         }
         Insert: {
           academic_career?: string | null
@@ -3266,9 +3249,9 @@ export type Database = {
           name: string
           selection_rank?: number | null
           short_name?: string | null
-          snapshot_id: number
           study_as?: string | null
           units?: number | null
+          version_id: number
         }
         Update: {
           academic_career?: string | null
@@ -3286,65 +3269,20 @@ export type Database = {
           name?: string
           selection_rank?: number | null
           short_name?: string | null
-          snapshot_id?: number
           study_as?: string | null
           units?: number | null
+          version_id?: number
         }
         Relationships: [
           {
-            foreignKeyName: "structure_snapshot_details_snapshot_kind_fkey"
-            columns: ["snapshot_id", "kind"]
+            foreignKeyName: "structure_version_details_snapshot_kind_fkey"
+            columns: ["version_id", "kind"]
             isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
+            referencedRelation: "catalogue_versions"
             referencedColumns: ["id", "kind"]
           },
         ]
       }
-      structure_snapshot_summary_fields: {
-        Row: {
-          field_key: string
-          field_value: string
-          label: string
-          position: number
-          snapshot_id: number
-          source_text: string
-          value_position: number
-        }
-        Insert: {
-          field_key: string
-          field_value: string
-          label: string
-          position: number
-          snapshot_id: number
-          source_text: string
-          value_position: number
-        }
-        Update: {
-          field_key?: string
-          field_value?: string
-          label?: string
-          position?: number
-          snapshot_id?: number
-          source_text?: string
-          value_position?: number
-        }
-        Relationships: [
-          {
-            foreignKeyName: "structure_snapshot_summary_fields_snapshot_fkey"
-            columns: ["snapshot_id"]
-            isOneToOne: false
-            referencedRelation: "catalogue_snapshots"
-            referencedColumns: ["id"]
-          },
-          {
-            foreignKeyName: "structure_snapshot_summary_fields_snapshot_fkey"
-            columns: ["snapshot_id"]
-            isOneToOne: false
-            referencedRelation: "published_course_summaries"
-            referencedColumns: ["snapshot_id"]
-          },
-        ]
-      }
       university_calendar_events: {
         Row: {
           academic_year_id: number
@@ -3567,6 +3505,7 @@ export type Database = {
           academic_year: number | null
           academic_year_id: number | null
           code: string | null
+          code_id: number | null
           college: string | null
           convener_text: string | null
           delivery_summary: string | null
@@ -3574,27 +3513,26 @@ export type Database = {
           eftsl: number | null
           inherent_requirements: string | null
           introduction: string | null
-          item_id: number | null
-          item_year_id: number | null
           level: number | null
           maximum_units: number | null
           minimum_units: number | null
           offering_status: string | null
           prescribed_texts: string | null
+          record_id: number | null
           school: string | null
-          snapshot_id: number | null
           source_updated_at: string | null
           subject_code: string | null
           subject_name: string | null
           title: string | null
           unit_value_kind: string | null
           units: number | null
+          version_id: number | null
           workload_hours: number | null
           workload_text: string | null
         }
         Relationships: [
           {
-            foreignKeyName: "catalogue_item_years_academic_year_id_fkey"
+            foreignKeyName: "catalogue_records_academic_year_id_fkey"
             columns: ["academic_year_id"]
             isOneToOne: false
             referencedRelation: "academic_years"
@@ -3613,20 +3551,20 @@ export type Database = {
         }
         Returns: string
       }
-      admin_snapshot_projection: {
-        Args: { p_snapshot_id: number }
+      admin_catalogue_version_projection: {
+        Args: { p_version_id: number }
         Returns: Json
       }
       cancel_catalogue_import: { Args: { p_run_id: string }; Returns: number }
       catalogue_publish_blockers: {
-        Args: { p_item_year_id: number }
+        Args: { p_record_id: number }
         Returns: string[]
       }
-      current_user_course_attempt_snapshot_projections: {
-        Args: { p_snapshot_ids: number[] }
+      current_user_course_attempt_version_projections: {
+        Args: { p_version_ids: number[] }
         Returns: {
           projection: Json
-          snapshot_id: number
+          version_id: number
         }[]
       }
       current_user_has_permission: {
@@ -3637,10 +3575,6 @@ export type Database = {
         Args: { p_code: string; p_kind: string }
         Returns: undefined
       }
-      discard_catalogue_draft: {
-        Args: { p_item_year_id: number }
-        Returns: undefined
-      }
       mark_notifications_read: {
         Args: { p_notification_ids?: string[] }
         Returns: number
@@ -3654,8 +3588,8 @@ export type Database = {
         }
         Returns: undefined
       }
-      publish_catalogue_snapshot: {
-        Args: { p_item_year_id: number }
+      publish_catalogue_version: {
+        Args: { p_record_id: number }
         Returns: number
       }
       published_course_availability: {
@@ -3667,7 +3601,7 @@ export type Database = {
           course_year_id: number
           is_available: boolean
           offering_status: string
-          published_snapshot_id: number
+          published_version_id: number
         }[]
       }
       published_course_detail: {
@@ -3764,8 +3698,8 @@ export type Database = {
         }
         Returns: Json
       }
-      unpublish_catalogue_item_year: {
-        Args: { p_item_year_id: number }
+      unpublish_catalogue_record: {
+        Args: { p_record_id: number }
         Returns: undefined
       }
     }
diff --git a/apps/web/ui/admin/catalogue/catalogue-directory.tsx b/apps/web/ui/admin/catalogue/catalogue-directory.tsx
index 8fe462a1..042533a1 100644
--- a/apps/web/ui/admin/catalogue/catalogue-directory.tsx
+++ b/apps/web/ui/admin/catalogue/catalogue-directory.tsx
@@ -385,7 +385,7 @@ export function CatalogueDirectory({
                 const busy =
                   record.workflow === "queued" || record.workflow === "running";
                 const checked = selected.includes(record.code);
-                const href = record.itemYearPublicId
+                const href = record.recordPublicId
                   ? `${basePath}/${record.code}?year=${page.academicYear}`
                   : undefined;
                 return (
diff --git a/apps/web/ui/admin/catalogue/import-runs.tsx b/apps/web/ui/admin/catalogue/import-runs.tsx
index 43b84055..1e6dbc89 100644
--- a/apps/web/ui/admin/catalogue/import-runs.tsx
+++ b/apps/web/ui/admin/catalogue/import-runs.tsx
@@ -439,7 +439,7 @@ function RecordRow({
     record.errorMessage ||
     (record.errorCode ? readable(record.errorCode) : null);
   const reviewHref =
-    record.status === "ready" && record.itemYearPublicId
+    record.status === "ready" && record.recordPublicId
       ? `${basePath}/${record.code}?year=${record.academicYear}&tab=review`
       : undefined;
   return (
@@ -459,7 +459,7 @@ function RecordRow({
         <div className="flex min-w-0 flex-col items-start gap-1">
           <TargetStatusBadge
             status={record.status}
-            applied={record.appliedSnapshotId !== null}
+            applied={record.appliedVersionId !== null}
           />
           {/* Why it failed, so a column of "Failed" badges can be told apart
               without opening each pipeline in turn. The message is written for
@@ -512,7 +512,7 @@ function RecordRow({
             ...(reviewHref
               ? [{ label: "Review import", href: reviewHref }]
               : []),
-            ...(record.itemYearPublicId
+            ...(record.recordPublicId
               ? [
                   {
                     label: "Import history",
diff --git a/apps/web/ui/admin/catalogue/record-header.tsx b/apps/web/ui/admin/catalogue/record-header.tsx
index cc57eaef..4f8b7f71 100644
--- a/apps/web/ui/admin/catalogue/record-header.tsx
+++ b/apps/web/ui/admin/catalogue/record-header.tsx
@@ -46,11 +46,11 @@ export function RecordHeader({
   const labels = CATALOGUE_KIND_LABELS[record.kind];
   const step = recordNextStep(record);
   const workflow =
-    record.publishedSnapshotId && record.draftSnapshotId
+    record.publishedVersionId && record.currentVersionId
       ? "published_with_draft"
-      : record.publishedSnapshotId
+      : record.publishedVersionId
         ? "published"
-        : record.draftSnapshotId
+        : record.currentVersionId
           ? "draft"
           : "not_imported";
 
@@ -93,16 +93,14 @@ export function RecordHeader({
             </Link>
           </div>
         </div>
-        {record.publishedSnapshotId ? (
+        {record.publishedVersionId ? (
           <ConfirmDialog
             title={`Unpublish ${record.code} for ${record.academicYear}?`}
             description="Students will no longer see this record for the year. The content stays in history and can be published again."
             confirmLabel="Unpublish"
             destructive
             onConfirm={() =>
-              run(() =>
-                unpublishAction({ itemYearId: record.itemYearId, path }),
-              )
+              run(() => unpublishAction({ recordId: record.recordId, path }))
             }
             trigger={
               <Button variant="outline" disabled={pending} type="button">
@@ -191,14 +189,12 @@ function NextStep({
           <ConfirmDialog
             confirmLabel="Publish"
             description={
-              record.publishedSnapshotId
+              record.publishedVersionId
                 ? `The draft replaces the ${record.academicYear} record students see for ${record.code}. The version it replaces stays in history.`
                 : `${record.code} becomes visible to students for ${record.academicYear}. It can be unpublished again from this page.`
             }
             onConfirm={() =>
-              run(() =>
-                publishDraftAction({ itemYearId: record.itemYearId, path }),
-              )
+              run(() => publishDraftAction({ recordId: record.recordId, path }))
             }
             title={`Publish ${record.code} for ${record.academicYear}?`}
             trigger={
diff --git a/apps/web/ui/admin/catalogue/record-history.tsx b/apps/web/ui/admin/catalogue/record-history.tsx
index 7100b8aa..83704227 100644
--- a/apps/web/ui/admin/catalogue/record-history.tsx
+++ b/apps/web/ui/admin/catalogue/record-history.tsx
@@ -2,16 +2,12 @@
 
 import { Badge } from "@coursemap/ui/components/badge";
 import { Button } from "@coursemap/ui/primitives/button";
-import { Download, History, Pencil, Trash2, Undo2, Upload } from "lucide-react";
+import { Download, History, Pencil, Undo2, Upload } from "lucide-react";
 import { useTransition } from "react";
 import { toast } from "sonner";
 
-import {
-  discardDraftAction,
-  restoreSnapshotAction,
-} from "@/lib/coursemap/admin-catalogue-actions";
+import { restoreSnapshotAction } from "@/lib/coursemap/admin-catalogue-actions";
 import type { CatalogueRecord } from "@/lib/coursemap/admin-catalogue-record";
-import { ConfirmDialog } from "@/ui/common/confirm-dialog";
 
 function formatDateTime(value: string | null) {
   if (!value) return "—";
@@ -52,18 +48,18 @@ export function RecordHistory({
     origin?: string;
     title: string;
     detail: string | null;
-    snapshot: CatalogueRecord["snapshots"][number] | null;
+    snapshot: CatalogueRecord["versions"][number] | null;
   };
 
   const events: HistoryEvent[] = [
-    ...record.snapshots.map((snapshot) => {
+    ...record.versions.map((snapshot) => {
       const runNumber = snapshot.importTargetId
         ? targetRun.get(snapshot.importTargetId)
         : undefined;
       const detail = [
         runNumber ? `Run #${runNumber}` : null,
-        snapshot.basedOnSnapshotId
-          ? `based on #${snapshot.basedOnSnapshotId}`
+        snapshot.basedOnVersionId
+          ? `based on #${snapshot.basedOnVersionId}`
           : null,
       ]
         .filter(Boolean)
@@ -84,15 +80,25 @@ export function RecordHistory({
     ...record.publications.map((publication, index) => ({
       id: `publication-${publication.publishedAt}-${index}`,
       at: publication.publishedAt,
-      kind: publication.snapshotId
-        ? ("published" as const)
-        : ("unpublished" as const),
-      title: publication.snapshotId ? "Published" : "Withdrawn from students",
-      detail: publication.snapshotId
-        ? `Snapshot #${publication.snapshotId}`
-        : null,
+      kind: "published" as const,
+      title: "Published",
+      detail: `Version #${publication.versionId}`,
       snapshot: null,
     })),
+    ...record.publications.flatMap((publication, index) =>
+      publication.unpublishedAt
+        ? [
+            {
+              id: `unpublication-${publication.unpublishedAt}-${index}`,
+              at: publication.unpublishedAt,
+              kind: "unpublished" as const,
+              title: "Withdrawn from students",
+              detail: `Version #${publication.versionId}`,
+              snapshot: null,
+            },
+          ]
+        : [],
+    ),
   ].sort((left, right) => Date.parse(right.at) - Date.parse(left.at));
 
   if (events.length === 0)
@@ -129,9 +135,9 @@ export function RecordHistory({
               <div className="space-y-1">
                 <div className="flex flex-wrap items-center gap-2">
                   <h3 className="text-sm font-semibold">{event.title}</h3>
-                  {snapshot?.id === record.publishedSnapshotId ? (
+                  {snapshot?.id === record.publishedVersionId ? (
                     <Badge variant="success-light">Published</Badge>
-                  ) : snapshot?.id === record.draftSnapshotId ? (
+                  ) : snapshot?.id === record.currentVersionId ? (
                     <Badge variant="outline">Current draft</Badge>
                   ) : null}
                   {snapshot && !snapshot.sealedAt ? (
@@ -145,34 +151,7 @@ export function RecordHistory({
               </div>
               {snapshot ? (
                 <div className="flex gap-2">
-                  {snapshot.id === record.draftSnapshotId ? (
-                    <ConfirmDialog
-                      title="Discard this draft?"
-                      description="The draft pointer is cleared. The snapshot stays in history and can be restored."
-                      confirmLabel="Discard draft"
-                      destructive
-                      onConfirm={() =>
-                        run(() =>
-                          discardDraftAction({
-                            itemYearId: record.itemYearId,
-                            path,
-                          }),
-                        )
-                      }
-                      trigger={
-                        <Button
-                          size="sm"
-                          variant="ghost"
-                          disabled={locked}
-                          type="button"
-                        >
-                          <Trash2 size={14} aria-hidden="true" />
-                          Discard
-                        </Button>
-                      }
-                    />
-                  ) : snapshot.id !== record.publishedSnapshotId ||
-                    record.draftSnapshotId ? (
+                  {snapshot.id !== record.currentVersionId ? (
                     <Button
                       size="sm"
                       variant="ghost"
@@ -181,7 +160,7 @@ export function RecordHistory({
                       onClick={() =>
                         run(() =>
                           restoreSnapshotAction({
-                            itemYearId: record.itemYearId,
+                            recordId: record.recordId,
                             snapshotId: snapshot.id,
                             path,
                           }),
diff --git a/apps/web/ui/admin/catalogue/record-page.tsx b/apps/web/ui/admin/catalogue/record-page.tsx
index cde0d96f..6b5a3424 100644
--- a/apps/web/ui/admin/catalogue/record-page.tsx
+++ b/apps/web/ui/admin/catalogue/record-page.tsx
@@ -21,8 +21,8 @@ import { RecordHeader } from "./record-header";
 import { RecordTabs } from "./record-tabs";
 import { RecordHistory } from "./record-history";
 import { ReviewPanel } from "./review-panel";
-import { SnapshotEditor } from "./snapshot-editor";
-import { CoursePreview, StructurePreview } from "./snapshot-preview";
+import { VersionEditor } from "./version-editor";
+import { CoursePreview, StructurePreview } from "./version-preview";
 import type { SearchParams } from "./catalogue-pages";
 
 function first(value: string | string[] | undefined) {
@@ -56,7 +56,7 @@ export async function CatalogueRecordPage({
     ? (requestedTab as "review" | "preview" | "edit" | "history")
     : "review";
   const currentSnapshotId = record
-    ? (record.draftSnapshotId ?? record.publishedSnapshotId)
+    ? (record.currentVersionId ?? record.publishedVersionId)
     : null;
   const [write, coursePreview] = currentSnapshotId
     ? await Promise.all([
@@ -141,7 +141,7 @@ export async function CatalogueRecordPage({
               )}
             </TabsContent>
             <TabsContent value="preview" className="mt-4">
-              {record.draftSnapshotId ? (
+              {record.currentVersionId ? (
                 <p className="mb-3 text-sm text-muted-foreground">
                   Showing the draft. Students see the published version until
                   the draft is published.
@@ -159,10 +159,10 @@ export async function CatalogueRecordPage({
             </TabsContent>
             <TabsContent value="edit" className="mt-4">
               {write && currentSnapshotId ? (
-                <SnapshotEditor
+                <VersionEditor
                   key={currentSnapshotId}
                   initial={write}
-                  itemYearId={record.itemYearId}
+                  recordId={record.recordId}
                   baseSnapshotId={currentSnapshotId}
                   path={path}
                 />
diff --git a/apps/web/ui/admin/catalogue/review-panel.tsx b/apps/web/ui/admin/catalogue/review-panel.tsx
index 3772e86b..5de4a0bb 100644
--- a/apps/web/ui/admin/catalogue/review-panel.tsx
+++ b/apps/web/ui/admin/catalogue/review-panel.tsx
@@ -179,7 +179,7 @@ export function ReviewPanel({
               run={run}
               summary={summary}
             />
-            {review.baselineSnapshotId === null && review.status === "ready" ? (
+            {review.baselineVersionId === null && review.status === "ready" ? (
               <p className="text-sm text-muted-foreground">
                 There was nothing to compare against, so every field was
                 accepted and this import is the draft.
diff --git a/apps/web/ui/admin/catalogue/review-state.ts b/apps/web/ui/admin/catalogue/review-state.ts
index 646e4882..b6e69e25 100644
--- a/apps/web/ui/admin/catalogue/review-state.ts
+++ b/apps/web/ui/admin/catalogue/review-state.ts
@@ -167,7 +167,7 @@ export function reviewSummary(review: ReviewTarget): ReviewSummary {
   const openBlockingFlags = openFlags.filter((entry) => entry.isBlocking);
   const applied = review.appliedAt !== null;
   const reviewable =
-    review.status === "ready" && !applied && review.baselineSnapshotId !== null;
+    review.status === "ready" && !applied && review.baselineVersionId !== null;
   const actionable =
     reviewable || openChanges.length > 0 || openFlags.length > 0;
 
@@ -220,7 +220,7 @@ function gatingReviews(record: CatalogueRecord) {
     (review) => review.status === "ready" || review.status === "unchanged",
   );
   const draftTargetId =
-    record.snapshots.find((snapshot) => snapshot.id === record.draftSnapshotId)
+    record.versions.find((version) => version.id === record.currentVersionId)
       ?.importTargetId ?? null;
   const draftReview = draftTargetId
     ? record.reviews.find((review) => review.id === draftTargetId)
@@ -265,10 +265,10 @@ export function recordNextStep(record: CatalogueRecord): RecordStep {
     (review) =>
       review.status === "ready" &&
       review.appliedAt === null &&
-      review.baselineSnapshotId !== null,
+      review.baselineVersionId !== null,
   );
-  const hasDraft = record.draftSnapshotId !== null;
-  const published = record.publishedSnapshotId !== null;
+  const hasDraft = record.currentVersionId !== null;
+  const published = record.publishedVersionId !== null;
   // Without a draft there is nothing to publish, which is the ordinary state of
   // a finished record rather than a problem, so it is not reported as one.
   const blockers = hasDraft ? record.publishBlockers : [];
diff --git a/apps/web/ui/admin/catalogue/snapshot-editor.tsx b/apps/web/ui/admin/catalogue/version-editor.tsx
similarity index 93%
rename from apps/web/ui/admin/catalogue/snapshot-editor.tsx
rename to apps/web/ui/admin/catalogue/version-editor.tsx
index f72e9ee1..374c6087 100644
--- a/apps/web/ui/admin/catalogue/snapshot-editor.tsx
+++ b/apps/web/ui/admin/catalogue/version-editor.tsx
@@ -18,10 +18,10 @@ import {
   treeFromRequirementWrite,
 } from "@/lib/catalogue-import/requirement-tree";
 import type {
-  CatalogueSnapshotWrite,
+  CatalogueContent,
   RequirementRuleKind,
-} from "@/lib/catalogue-import/snapshot-write";
-import { saveManualSnapshotAction } from "@/lib/coursemap/admin-catalogue-actions";
+} from "@/lib/catalogue/content";
+import { saveManualVersionAction } from "@/lib/coursemap/admin-catalogue-actions";
 import { FIELD_LABELS } from "@/lib/coursemap/catalogue-kinds";
 import {
   createEmptyTree,
@@ -42,7 +42,7 @@ const COURSE_RULES: RequirementRuleKind[] = [
 ];
 
 const COURSE_COLLECTIONS: Array<{
-  key: keyof NonNullable<CatalogueSnapshotWrite["course"]>;
+  key: keyof NonNullable<CatalogueContent["course"]>;
   template: Row;
 }> = [
   {
@@ -117,7 +117,7 @@ const COURSE_COLLECTIONS: Array<{
 ];
 
 const STRUCTURE_COLLECTIONS: Array<{
-  key: keyof NonNullable<CatalogueSnapshotWrite["structure"]>;
+  key: keyof NonNullable<CatalogueContent["structure"]>;
   template: Row;
 }> = [
   {
@@ -220,19 +220,19 @@ function labelsFor(prefix: string) {
  * draft. Course requisite rules use the tree editor; every other section is
  * a typed form over its rows.
  */
-export function SnapshotEditor({
+export function VersionEditor({
   initial,
-  itemYearId,
+  recordId,
   baseSnapshotId,
   path,
 }: {
-  initial: CatalogueSnapshotWrite;
-  itemYearId: number;
+  initial: CatalogueContent;
+  recordId: number;
   baseSnapshotId: number | null;
   path: string;
 }) {
   const router = useRouter();
-  const [write, setWrite] = useState<CatalogueSnapshotWrite>(initial);
+  const [write, setWrite] = useState<CatalogueContent>(initial);
   const [pending, startTransition] = useTransition();
   const dirty = useMemo(
     () => JSON.stringify(write) !== JSON.stringify(initial),
@@ -240,7 +240,7 @@ export function SnapshotEditor({
   );
 
   function updateCourse(
-    patch: Partial<NonNullable<CatalogueSnapshotWrite["course"]>>,
+    patch: Partial<NonNullable<CatalogueContent["course"]>>,
   ) {
     setWrite((current) =>
       current.course
@@ -249,7 +249,7 @@ export function SnapshotEditor({
     );
   }
   function updateStructure(
-    patch: Partial<NonNullable<CatalogueSnapshotWrite["structure"]>>,
+    patch: Partial<NonNullable<CatalogueContent["structure"]>>,
   ) {
     setWrite((current) =>
       current.structure
@@ -275,8 +275,8 @@ export function SnapshotEditor({
 
   function save() {
     startTransition(async () => {
-      const result = await saveManualSnapshotAction({
-        itemYearId,
+      const result = await saveManualVersionAction({
+        recordId,
         baseSnapshotId,
         write,
         path,
@@ -337,7 +337,7 @@ export function SnapshotEditor({
               onChange={(details) =>
                 updateCourse({
                   details: details as unknown as NonNullable<
-                    CatalogueSnapshotWrite["course"]
+                    CatalogueContent["course"]
                   >["details"],
                 })
               }
@@ -355,7 +355,7 @@ export function SnapshotEditor({
               onChange={(offering) =>
                 updateCourse({
                   offering: offering as NonNullable<
-                    CatalogueSnapshotWrite["course"]
+                    CatalogueContent["course"]
                   >["offering"],
                 })
               }
@@ -399,7 +399,7 @@ export function SnapshotEditor({
               onChange={(details) =>
                 updateStructure({
                   details: details as unknown as NonNullable<
-                    CatalogueSnapshotWrite["structure"]
+                    CatalogueContent["structure"]
                   >["details"],
                 })
               }
@@ -447,7 +447,7 @@ function RuleSection({
   onChange,
 }: {
   ruleKey: RequirementRuleKind;
-  requirements: CatalogueSnapshotWrite["requirements"];
+  requirements: CatalogueContent["requirements"];
   onChange: (tree: ReviewedRuleTree | null, sourceText: string) => void;
 }) {
   const rule = requirements.rules.find(
diff --git a/apps/web/ui/admin/catalogue/snapshot-preview.tsx b/apps/web/ui/admin/catalogue/version-preview.tsx
similarity index 91%
rename from apps/web/ui/admin/catalogue/snapshot-preview.tsx
rename to apps/web/ui/admin/catalogue/version-preview.tsx
index 70568558..d9cb3642 100644
--- a/apps/web/ui/admin/catalogue/snapshot-preview.tsx
+++ b/apps/web/ui/admin/catalogue/version-preview.tsx
@@ -3,9 +3,9 @@
 import { Tabs } from "@coursemap/ui/primitives/tabs";
 import { useState } from "react";
 
-import type { CatalogueSnapshotWrite } from "@/lib/catalogue-import/snapshot-write";
+import type { CatalogueContent } from "@/lib/catalogue/content";
 import type { CourseDetails } from "@/lib/coursemap/course-types";
-import { structureDetailsFromWrite } from "@/lib/coursemap/structure-snapshot-view";
+import { structureDetailsFromWrite } from "@/lib/coursemap/structure-version-view";
 import {
   CourseDetailTabsList,
   CourseDetailView,
@@ -42,7 +42,7 @@ export function CoursePreview({ course }: { course: CourseDetails }) {
  * published page uses. A reviewer judges the requirement tree as a student
  * will read it rather than as stored JSON.
  */
-export function StructurePreview({ write }: { write: CatalogueSnapshotWrite }) {
+export function StructurePreview({ write }: { write: CatalogueContent }) {
   const [tab, setTab] = useState<StructureTab>("overview");
   const structure = structureDetailsFromWrite(write);
   if (!structure) return null;
diff --git a/docs/architecture.md b/docs/architecture.md
index a8c00ed7..dd275ac5 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -29,51 +29,51 @@ Next.js owns routing, server rendering and mutations. Supabase Auth owns identit
 
 ## Data model
 
-Courses, programmes, majors, minors and specialisations share one identity,
-year and snapshot model. Identity, year-specific pointers and immutable saved
-states are separate:
+Courses, programmes, majors, minors and specialisations share one code, record
+and version model. These concepts are deliberately separate:
 
 - `academic_years`
-- `catalogue_items`: permanent identity with a `kind` and `code`
-- `catalogue_item_years`: one row per item and academic year, carrying the
-  `draft_snapshot_id` and `published_snapshot_id` pointers and `archived_at`.
-  Composite foreign keys keep the kind consistent across item, year and
-  snapshot.
-- `catalogue_snapshots`: immutable versions, sealed when they become a pointer.
-  `catalogue_publications` records every change of the published pointer.
-- `course_snapshot_details` and `structure_snapshot_details` hold the scalar
+- `catalogue_codes`: a stable typed code shared across years
+- `catalogue_records`: that code in one academic year, with the current
+  `published_version_id` pointer and optional `archived_at`. There is no draft
+  pointer in the core record model.
+- `catalogue_versions`: immutable meaningful states of a record. Versions may
+  identify the earlier version they are based on and are sealed before use.
+- `catalogue_publications`: historical visibility intervals recording the
+  version, publisher, publication time, unpublisher and unpublication time.
+- `course_version_details` and `structure_version_details` hold the scalar
   content for their kind. Course child tables (offerings, sessions, outcomes,
   assessments, fees, attributes, unit options, areas of interest, related
   courses and requisite rules) and structure child tables (sections, summary
   fields, outcomes, fees, relationships, requirement groups, conditions,
-  options and unmodelled requirements) reference the shared snapshot through
-  `snapshot_id`. Child rows can be assembled until the snapshot is sealed.
-- `snapshot_field_evidence`: shared field-level source evidence
+  options and unmodelled requirements) reference the shared version through
+  `version_id`. Child rows can be assembled until the version is sealed.
+- `catalogue_version_provenance`: shared field-level source evidence
 - `requirement_rules`, nested `requirement_groups`, typed
   `requirement_conditions`, `requirement_condition_options` for set members
   and `requirement_item_references` for graph edges. One rule per kind per
-  snapshot: course requisites (`prerequisite`, `corequisite`,
+  version: course requisites (`prerequisite`, `corequisite`,
   `incompatibility`, `permission`, `assumed_knowledge`) and structure
   completion requirements (`structure`) share fifteen condition kinds
 - `catalogue_sources` and immutable `catalogue_source_pages`: retrieval
   provenance shared by every kind and the university calendar
 - `published_course_summaries`: a security-invoker view joining published
-  course snapshots to their identity for the directory
+  course versions to their code for the directory
 - `university_calendar_events` keyed by academic year, date and title, and
   `university_calendar_imports` recording each command-line import
 
-Published reads resolve through `catalogue_item_years.published_snapshot_id`
-where `archived_at` is null. Anonymous readers see published snapshots and
+Published reads resolve through `catalogue_records.published_version_id`
+where `archived_at` is null. Anonymous readers see published versions and
 their children, identities with a published year, and identities referenced
-as placeholders by a published rule. Students keep reading the exact snapshot
+as placeholders by a published rule. Students keep reading the exact version
 their recorded attempts point at.
 
 User-owned planning data is also separate:
 
 - `profiles`
-- `plans`, ordered `plan_items` referencing a course item and year, and
-  `plan_structures` referencing a structure item year
-- `course_attempts`, each pinned to the course snapshot that was published
+- `plans`, ordered `plan_items` and `plan_structures` referencing annual
+  `catalogue_records`
+- `course_attempts`, each pinned to the exact `catalogue_version_id` that was published
   when the attempt was recorded
 - approval requests and immutable approval events
 
@@ -92,22 +92,21 @@ processed through the same ten stages with `catalogue_import_stages`,
 `catalogue_import_artifacts` (in the private `course-import-artifacts` bucket)
 and `catalogue_extractions` recording every model call and its cost. Kind
 adapters under `lib/catalogue-import/kinds/` own fetching, Markdown, the
-deterministic parser, the model contract and the projection to the shared
-snapshot write shape; `process-target.ts` owns leases, retries, artefacts and
+deterministic parser, the model contract and the projection to shared
+`CatalogueContent`; `process-target.ts` owns leases, retries, artefacts and
 persistence. A target whose content matches its baseline finishes `unchanged`;
-otherwise it assembles a candidate snapshot and finishes `ready` for review.
-The first snapshot for an item year becomes its draft immediately. Runs
+otherwise it assembles an immutable candidate version and finishes `ready` for
+review. Runs
 dispatch to Vercel Queues when `COURSEMAP_QUEUE_IMPORTS_ENABLED=true` and run
 inline after the request otherwise.
 
 Review reads `catalogue_import_changes`: one `change` row per field or section
 that differs from the baseline (with old and new values and the source
 excerpt) and one `flag` row per parser review item. Administrators accept or
-reject each change and acknowledge flags; **Apply** writes a new draft from
-the baseline plus the accepted changes (or points the draft at the candidate
-when everything is accepted). **Publish** moves `published_snapshot_id` to the
-draft and clears the draft pointer once `catalogue_publish_blockers` is empty:
-no open changes and no open blocking flag on the draft's target.
+reject each change and acknowledge flags. Applying review creates and seals a
+meaningful version. Publishing sets the record's `published_version_id` once
+`catalogue_publish_blockers` is empty. Mutable working drafts are not part of
+this foundation.
 
 ## University calendar
 
diff --git a/docs/catalogue-admin-rework.md b/docs/catalogue-admin-rework.md
index 42d37664..5a7dcd96 100644
--- a/docs/catalogue-admin-rework.md
+++ b/docs/catalogue-admin-rework.md
@@ -105,7 +105,7 @@ Branch `fix/catalogue-security-and-imports`, then
 ### 1. Restore what was deleted
 
 Each was removed for schema reasons, not design reasons. Recover with
-`git show 80b95de^:<path>` and re-point the types at `CatalogueSnapshotWrite`.
+`git show 80b95de^:<path>` and re-point the types at `CatalogueContent`.
 
 Two pieces the artefact viewer depended on are still missing and are worth
 having back on their own account: `database-scroll-preview.tsx`, the viewport's
@@ -164,7 +164,7 @@ Most of this has landed. What is left:
 - A failed target stays `queued` and the active-target index then blocks every
   retry, with no interface path out. `cancel_catalogue_import` needs an
   administrator claim, so recovery is currently a manual SQL statement.
-- `catalogue_items` cannot be deleted: the immutability trigger fires on delete
+- `catalogue_codes` cannot be deleted: the immutability trigger fires on delete
   although its comment says cascades pass. Combined with placeholder creation
   from any regex-valid code, one hallucinated code is permanent.
 - `requirement_item_references` stays empty for structures.
diff --git a/docs/redesign-plan.md b/docs/redesign-plan.md
index b98cfccb..43728fda 100644
--- a/docs/redesign-plan.md
+++ b/docs/redesign-plan.md
@@ -88,46 +88,46 @@ database test. Names are proposals; keep them once the first migration lands.
 Identity and years (landed in A3b)
 
 - `academic_years`: unchanged role, gains `calendar_published_at`.
-- `catalogue_items`: `id`, `public_id`, `kind`
+- `catalogue_codes`: `id`, `public_id`, `kind`
   (`course | programme | major | minor | specialisation`), `code`. Replaces
   `courses` and `academic_structures`. Unique on `(kind, code)`.
-- `catalogue_item_years`: `item_id`, `kind`, `academic_year_id`,
-  `draft_snapshot_id`, `published_snapshot_id`, `archived_at`. Replaces
+- `catalogue_records`: `code_id`, `kind`, `academic_year_id`,
+  `published_version_id`, `archived_at`. Replaces
   `course_years` and `academic_structure_years` and the `lifecycle_status`
   and `confirmation_status` columns. `kind` is denormalised so composite
   foreign keys enforce kind consistency without triggers.
-- `catalogue_snapshots`: `id`, `public_id`, `item_year_id`, `kind`,
-  `academic_year_id`, `origin` (`import | manual`), `based_on_snapshot_id`,
+- `catalogue_versions`: `id`, `public_id`, `record_id`, `kind`,
+  `academic_year_id`, `origin` (`import | manual`), `based_on_version_id`,
   `source_page_id`, `content_hash`, `sealed_at`, `created_by`. Immutable
-  once sealed; setting a draft or published pointer seals. A5 adds
+  once sealed; publication seals the selected version. A5 adds
   `import_target_id` when the targets table exists.
-- `catalogue_publications`: `item_year_id`, `snapshot_id`, `published_by`,
-  `published_at`. Written by trigger on every published pointer change,
-  including unpublishing.
+- `catalogue_publications`: `record_id`, `version_id`, `published_by`,
+  `published_at`, `unpublished_by`, `unpublished_at`. Written by trigger on
+  every published pointer change so historical visibility is reconstructable.
 
 Kind-specific content (one row set per snapshot; landed in A3b)
 
-- Course: `course_snapshot_details` (the scalar fields formerly on
+- Course: `course_version_details` (the scalar fields formerly on
   `course_snapshots`) plus the existing child tables re-pointed at the shared
-  snapshot through `snapshot_id`: `course_offerings`, `offering_sessions`,
+  version through `version_id`: `course_offerings`, `offering_sessions`,
   `course_learning_outcomes`, `course_assessment_items`,
   `course_assessment_outcomes`, `course_fees`, `course_attributes`,
   `course_unit_options`, `course_areas_of_interest`, `course_related_courses`.
   Page provenance on offerings, sessions and rules is optional because manual
   snapshots have no source page.
-- Structure: `structure_snapshot_details` (the scalar fields formerly on
+- Structure: `structure_version_details` (the scalar fields formerly on
   `academic_structure_snapshots`). The `academic_structure_*` child tables keep
   their names for now and are renamed or replaced in A4 (requirements) and A5
   (sections, outcomes, fees, relationships); `summary_fields` and
   `unmodelled_requirements` are decided in A4.
-- Shared: `snapshot_field_evidence` (`snapshot_id`, `academic_year_id`,
+- Shared: `catalogue_version_provenance` (`version_id`, `academic_year_id`,
   `source_page_id`, `field_path`, `method`, `confidence`, `source_locator`,
   `source_excerpt`). Replaces both kind-specific evidence tables.
 - `published_course_summaries`: security-invoker view for the directory.
-- User tables keep their column names (`plan_items.course_id`,
-  `course_attempts.course_id`, `course_attempts.course_snapshot_id`,
-  `plan_structures.structure_year_id`) and now reference the shared tables.
-  Renaming them is deferred to A8 to avoid churn across the planner surface.
+- `plan_items.catalogue_record_id` and
+  `plan_structures.catalogue_record_id` identify annual catalogue records.
+  `course_attempts.catalogue_version_id` preserves the exact historical state
+  without redundant code and year columns.
 
 Requirements (shared by every kind; landed in A4)
 
@@ -191,7 +191,7 @@ Import (shared)
   `model_id`, `status` (`queued | running | completed | failed | cancelled`),
   `requested_by`, counts and token totals. A run has one kind. Concurrency is
   limited per target rather than one global active run.
-- `catalogue_import_targets`: `run_id`, `directory_entry_id`, `item_year_id`,
+- `catalogue_import_targets`: `run_id`, `directory_entry_id`, `record_id`,
   `baseline_snapshot_id` (the draft at start, or the published snapshot when
   there is no draft), `candidate_snapshot_id`, `status`
   (`queued | running | ready | unchanged | failed | cancelled`),
@@ -212,8 +212,8 @@ Retained without structural change
 
 - `plans`, `plan_items`, `plan_structures`, `course_attempts`, `profiles`,
   `approval_requests`, `approval_events`. Foreign keys move from `courses.id`
-  and `academic_structure_years.id` to `catalogue_items.id` and
-  `catalogue_item_years.id`, with a trigger asserting the referenced kind.
+  and `academic_structure_years.id` to `catalogue_codes.id` and
+  `catalogue_records.id`, with a trigger asserting the referenced kind.
 - `private.app_roles`, `app_permissions`, `role_permissions`, `user_roles` and
   the `admin_*` views.
 - `import_models`, `app_settings`.
@@ -244,7 +244,7 @@ Removed
 ### Target lifecycle
 
 1. Directory refresh for a year and kind writes `catalogue_directory_entries`
-   and creates `catalogue_items` and `catalogue_item_years` for new codes.
+   and creates `catalogue_codes` and `catalogue_records` for new codes.
 2. The administrator selects up to ten entries and starts a run. The database
    creates the run and targets, records `baseline_snapshot_id` per target and
    the application enqueues one message per target.
@@ -262,7 +262,7 @@ Removed
    stale baseline. Rejected changes leave the draft untouched.
 6. Manual editing creates a new draft snapshot based on the current draft.
    Edits to a field close any open change on that field for the same target.
-7. **Publish** sets `published_snapshot_id` to the draft when the draft differs
+7. **Publish** sets `published_version_id` to the draft when the draft differs
    from the published snapshot and no blocking flag is open on the draft or on
    the target that produced it. The disabled state states the reason.
 8. History lists runs, targets, changes, snapshots and publications for the
@@ -303,7 +303,7 @@ pointers only. There is no `review_status`, `confirmation_status`,
   requirements.
 - Planning, onboarding and public reads use `published_catalogue_item`,
   `published_requirement_graph` and `published_course_availability` functions
-  that resolve through `catalogue_item_years.published_snapshot_id`.
+  that resolve through `catalogue_records.published_version_id`.
 
 ### Stacked pull requests
 
@@ -317,7 +317,7 @@ step squashes the migration history.
 | A1    | `refactor/catalogue-redesign-01-plan`            | This document. Remove `catalogue-review-design.md` (absorbed here). Index update.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | A2    | `refactor/catalogue-redesign-02-calendar`        | Key `university_calendar_events` to `academic_years` with a composite foreign key on `(academic_year_id, calendar_year)`. Create `catalogue_sources`, `catalogue_source_pages` and `university_calendar_imports`. Update `calendar-importer.mjs`. Drop the five legacy `catalogue_*` tables. Frees the `catalogue_` names for later steps.                                                                                                                                                                                                                                                                                                                                         |
 | A3a   | `refactor/catalogue-redesign-03a-remove-import`  | Deletion only. Remove both import pipelines, the directory refresh, the admin catalogue routes and components, the import and review database tables and functions, their tests and the two guides that describe them. Keep `ui/admin/requisites` (reused by A4 and B5), `import_models`, `app_settings`, the artefact bucket and the calendar. The admin console keeps dashboard, users, roles and indoor maps.                                                                                                                                                                                                                                                                   |
-| A3b   | `refactor/catalogue-redesign-03b-items`          | `catalogue_items`, `catalogue_item_years`, `catalogue_snapshots`, `catalogue_publications`, kind detail tables, `snapshot_field_evidence`, replacing the six core tables. Re-point plans, attempts and the existing rule tables. Rewrite the student-facing functions (published reads, plan and attempt writes). Update `published-courses.ts`, planner catalogue loading and onboarding. Minimal preview seed for the new tables.                                                                                                                                                                                                                                                |
+| A3b   | `refactor/catalogue-redesign-03b-items`          | `catalogue_codes`, `catalogue_records`, `catalogue_versions`, `catalogue_publications`, kind detail tables, `catalogue_version_provenance`, replacing the six core tables. Re-point plans, attempts and the existing rule tables. Rewrite the student-facing functions (published reads, plan and attempt writes). Update `published-courses.ts`, planner catalogue loading and onboarding. Minimal preview seed for the new tables.                                                                                                                                                                                                                                               |
 | A4    | `refactor/catalogue-redesign-04-requirements`    | Landed. The shared `requirement_*` tables replace both rule families; `published_requirement_graph` replaces the course-specific graph; the planner, requirement display and editor use the shared vocabulary. The editor still offers the twelve course-oriented kinds; `structure_set`, `tagged_units` and `elective_units` are read-only until B5 extends it. Unmodelled structure text becomes `other` conditions.                                                                                                                                                                                                                                                             |
 | A5    | `refactor/catalogue-redesign-05-import-pipeline` | Landed. Shared import tables, `start_catalogue_import` and `cancel_catalogue_import`, `lib/catalogue-import/` with course and structure adapters ported from history, one queue consumer, inline processing when the queue is disabled, directory refresh for all five kinds, and admin directory and run pages under `/admin/<kind>` and `/admin/<kind>/imports`. Verified against ANU live: 3012 courses and 393 programmes listed; three courses and one programme imported. Large programmes exhaust `gemini-2.5-flash-lite`'s output budget and fall back to deterministic data; choose a larger-output model for those.                                                      |
 | A6    | `refactor/catalogue-redesign-06-review`          | Landed. `catalogue_import_changes` holds one row per differing field or section (scalars individually; collections and requirement rules as whole sections) and one per parser flag. `resolve_catalogue_import_change`, `catalogue_publish_blockers`, `publish_catalogue_snapshot` and `unpublish_catalogue_item_year` are the gate; publishing clears the draft pointer. Apply builds a merged draft from the baseline plus accepted changes and refuses a stale baseline. The record page at `/admin/<kind>/<code>?year=` shows reviews and history with Publish. Decisions: one kind per run; a blocking flag needs a note to acknowledge; rejected changes are not remembered. |
diff --git a/supabase/migrations/20260918130000_catalogue_items.sql b/supabase/migrations/20260918130000_catalogue_domain.sql
similarity index 73%
rename from supabase/migrations/20260918130000_catalogue_items.sql
rename to supabase/migrations/20260918130000_catalogue_domain.sql
index 4651bf6b..713b56c9 100644
--- a/supabase/migrations/20260918130000_catalogue_items.sql
+++ b/supabase/migrations/20260918130000_catalogue_domain.sql
@@ -1,11 +1,11 @@
 begin;
 
 -- Courses, programmes, majors, minors and specialisations share one identity,
--- year and snapshot model. catalogue_items replaces courses and
--- academic_structures, catalogue_item_years replaces course_years and
--- academic_structure_years, and catalogue_snapshots replaces course_snapshots
+-- year and snapshot model. catalogue_codes replaces courses and
+-- academic_structures, catalogue_records replaces course_years and
+-- academic_structure_years, and catalogue_versions replaces course_snapshots
 -- and academic_structure_snapshots. Kind-specific scalar content moves to
--- course_snapshot_details and structure_snapshot_details; the existing child
+-- course_version_details and structure_version_details; the existing child
 -- tables are re-pointed at the shared snapshot. This is a development cutover:
 -- every catalogue, plan and attempt row is cleared and the preview seed
 -- repopulates the local database.
@@ -159,22 +159,22 @@ drop function private.seal_course_year_snapshot_pointers();
 drop function private.guard_archived_course_year();
 drop function private.validate_academic_structure_year_snapshot_pointers();
 
--- Shared identity, year and snapshot tables ---------------------------------------
+-- Shared code, annual record and immutable version tables -------------------------
 
-create table public.catalogue_items (
+create table public.catalogue_codes (
   id bigint generated always as identity primary key,
   public_id uuid not null default gen_random_uuid(),
   kind text not null,
   code text not null,
   created_at timestamptz not null default now(),
   updated_at timestamptz not null default now(),
-  constraint catalogue_items_public_id_unique unique (public_id),
-  constraint catalogue_items_kind_code_unique unique (kind, code),
-  constraint catalogue_items_id_kind_unique unique (id, kind),
-  constraint catalogue_items_kind_check check (
+  constraint catalogue_codes_public_id_unique unique (public_id),
+  constraint catalogue_codes_kind_code_unique unique (kind, code),
+  constraint catalogue_codes_id_kind_unique unique (id, kind),
+  constraint catalogue_codes_kind_check check (
     kind in ('course', 'programme', 'major', 'minor', 'specialisation')
   ),
-  constraint catalogue_items_code_format_check check (
+  constraint catalogue_codes_code_format_check check (
     case kind
       when 'course' then code ~ '^[A-Z]{4}[0-9]{4}[A-Z]?$'
       else code ~ '^[A-Z0-9][A-Z0-9-]{1,31}$'
@@ -182,126 +182,130 @@ create table public.catalogue_items (
   )
 );
 
-create index catalogue_items_code_idx on public.catalogue_items (code);
+create index catalogue_codes_code_idx on public.catalogue_codes (code);
 
--- One row per item and academic year. draft_snapshot_id is the administrator's
--- working version and published_snapshot_id is what students read. Both point
--- at snapshots of this row; the composite foreign keys below enforce that.
-create table public.catalogue_item_years (
+-- One row per code and academic year. published_version_id is the efficient
+-- pointer to the version students currently read. Working drafts are a separate
+-- mutable domain and do not belong on this core record.
+create table public.catalogue_records (
   id bigint generated always as identity primary key,
   public_id uuid not null default gen_random_uuid(),
-  item_id bigint not null,
+  code_id bigint not null,
   kind text not null,
   academic_year_id bigint not null,
-  draft_snapshot_id bigint,
-  published_snapshot_id bigint,
+  published_version_id bigint,
   archived_at timestamptz,
   created_at timestamptz not null default now(),
   updated_at timestamptz not null default now(),
-  constraint catalogue_item_years_public_id_unique unique (public_id),
-  constraint catalogue_item_years_item_year_unique unique (item_id, academic_year_id),
-  constraint catalogue_item_years_id_year_unique unique (id, academic_year_id),
-  constraint catalogue_item_years_id_kind_unique unique (id, kind),
-  constraint catalogue_item_years_item_kind_fkey
-    foreign key (item_id, kind) references public.catalogue_items (id, kind)
+  constraint catalogue_records_public_id_unique unique (public_id),
+  constraint catalogue_records_code_year_unique unique (code_id, academic_year_id),
+  constraint catalogue_records_id_year_unique unique (id, academic_year_id),
+  constraint catalogue_records_id_kind_unique unique (id, kind),
+  constraint catalogue_records_code_kind_fkey
+    foreign key (code_id, kind) references public.catalogue_codes (id, kind)
     on delete cascade,
-  constraint catalogue_item_years_academic_year_id_fkey
-    foreign key (academic_year_id) references public.academic_years (id),
-  constraint catalogue_item_years_distinct_pointers_check check (
-    draft_snapshot_id is null
-    or published_snapshot_id is null
-    or draft_snapshot_id <> published_snapshot_id
-  )
+  constraint catalogue_records_academic_year_id_fkey
+    foreign key (academic_year_id) references public.academic_years (id)
 );
 
-create index catalogue_item_years_academic_year_idx
-  on public.catalogue_item_years (academic_year_id, kind);
+create index catalogue_records_academic_year_idx
+  on public.catalogue_records (academic_year_id, kind);
 
-create index catalogue_item_years_published_idx
-  on public.catalogue_item_years (published_snapshot_id)
-  where published_snapshot_id is not null;
+create index catalogue_records_published_idx
+  on public.catalogue_records (published_version_id)
+  where published_version_id is not null;
 
 alter table public.catalogue_source_pages
   add constraint catalogue_source_pages_id_year_unique unique (id, academic_year_id);
 
--- Immutable once sealed. A snapshot is sealed when it becomes a draft or
--- published pointer; until then its child rows may still be assembled.
-create table public.catalogue_snapshots (
+-- A version is assembled inside one transaction, then sealed before that
+-- transaction completes. Once sealed, neither it nor its normalised content
+-- can be changed.
+create table public.catalogue_versions (
   id bigint generated always as identity primary key,
   public_id uuid not null default gen_random_uuid(),
-  item_year_id bigint not null,
+  record_id bigint not null,
   kind text not null,
   academic_year_id bigint not null,
   origin text not null,
-  based_on_snapshot_id bigint,
+  based_on_version_id bigint,
   source_page_id bigint,
   content_hash text not null,
   sealed_at timestamptz,
   created_by uuid,
   created_at timestamptz not null default now(),
-  constraint catalogue_snapshots_public_id_unique unique (public_id),
-  constraint catalogue_snapshots_id_item_year_unique unique (id, item_year_id),
-  constraint catalogue_snapshots_id_year_unique unique (id, academic_year_id),
-  constraint catalogue_snapshots_id_kind_unique unique (id, kind),
-  constraint catalogue_snapshots_item_year_fkey
-    foreign key (item_year_id, academic_year_id)
-    references public.catalogue_item_years (id, academic_year_id)
+  constraint catalogue_versions_public_id_unique unique (public_id),
+  constraint catalogue_versions_id_item_year_unique unique (id, record_id),
+  constraint catalogue_versions_id_year_unique unique (id, academic_year_id),
+  constraint catalogue_versions_id_kind_unique unique (id, kind),
+  constraint catalogue_versions_item_year_fkey
+    foreign key (record_id, academic_year_id)
+    references public.catalogue_records (id, academic_year_id)
     on delete cascade,
-  constraint catalogue_snapshots_item_year_kind_fkey
-    foreign key (item_year_id, kind)
-    references public.catalogue_item_years (id, kind)
+  constraint catalogue_versions_item_year_kind_fkey
+    foreign key (record_id, kind)
+    references public.catalogue_records (id, kind)
     on delete cascade,
-  constraint catalogue_snapshots_based_on_fkey
-    foreign key (based_on_snapshot_id, item_year_id)
-    references public.catalogue_snapshots (id, item_year_id),
-  constraint catalogue_snapshots_source_page_fkey
+  constraint catalogue_versions_based_on_fkey
+    foreign key (based_on_version_id, record_id)
+    references public.catalogue_versions (id, record_id),
+  constraint catalogue_versions_source_page_fkey
     foreign key (source_page_id, academic_year_id)
     references public.catalogue_source_pages (id, academic_year_id),
-  constraint catalogue_snapshots_created_by_fkey
+  constraint catalogue_versions_created_by_fkey
     foreign key (created_by) references auth.users (id) on delete set null,
-  constraint catalogue_snapshots_origin_check check (origin in ('import', 'manual')),
-  constraint catalogue_snapshots_content_hash_check check (
+  constraint catalogue_versions_origin_check check (origin in ('import', 'manual')),
+  constraint catalogue_versions_content_hash_check check (
     content_hash ~ '^[0-9a-f]{64}$'
   ),
-  constraint catalogue_snapshots_sealed_at_check check (
+  constraint catalogue_versions_sealed_at_check check (
     sealed_at is null or sealed_at >= created_at
   )
 );
 
-create index catalogue_snapshots_item_year_idx
-  on public.catalogue_snapshots (item_year_id, created_at desc);
+create index catalogue_versions_record_idx
+  on public.catalogue_versions (record_id, created_at desc);
 
-alter table public.catalogue_item_years
-  add constraint catalogue_item_years_draft_snapshot_fkey
-    foreign key (draft_snapshot_id, id)
-    references public.catalogue_snapshots (id, item_year_id),
-  add constraint catalogue_item_years_published_snapshot_fkey
-    foreign key (published_snapshot_id, id)
-    references public.catalogue_snapshots (id, item_year_id);
+alter table public.catalogue_records
+  add constraint catalogue_records_published_version_fkey
+    foreign key (published_version_id, id)
+    references public.catalogue_versions (id, record_id);
 
--- Every change of the published pointer, including unpublishing, is recorded.
+-- Each row is one exact interval during which a version was student-visible.
 create table public.catalogue_publications (
   id bigint generated always as identity primary key,
-  item_year_id bigint not null,
-  snapshot_id bigint,
+  record_id bigint not null,
+  version_id bigint not null,
   published_by uuid,
   published_at timestamptz not null default statement_timestamp(),
-  constraint catalogue_publications_item_year_id_fkey
-    foreign key (item_year_id) references public.catalogue_item_years (id)
+  unpublished_by uuid,
+  unpublished_at timestamptz,
+  constraint catalogue_publications_record_id_fkey
+    foreign key (record_id) references public.catalogue_records (id)
     on delete cascade,
-  constraint catalogue_publications_snapshot_id_fkey
-    foreign key (snapshot_id) references public.catalogue_snapshots (id),
+  constraint catalogue_publications_version_record_fkey
+    foreign key (version_id, record_id)
+    references public.catalogue_versions (id, record_id),
   constraint catalogue_publications_published_by_fkey
-    foreign key (published_by) references auth.users (id) on delete set null
+    foreign key (published_by) references auth.users (id) on delete set null,
+  constraint catalogue_publications_unpublished_by_fkey
+    foreign key (unpublished_by) references auth.users (id) on delete set null,
+  constraint catalogue_publications_interval_check check (
+    unpublished_at is null or unpublished_at >= published_at
+  )
 );
 
-create index catalogue_publications_item_year_idx
-  on public.catalogue_publications (item_year_id, published_at desc);
+create index catalogue_publications_record_idx
+  on public.catalogue_publications (record_id, published_at desc);
+
+create unique index catalogue_publications_one_current_idx
+  on public.catalogue_publications (record_id)
+  where unpublished_at is null;
 
 -- Kind-specific scalar content ----------------------------------------------------
 
-create table public.course_snapshot_details (
-  snapshot_id bigint primary key,
+create table public.course_version_details (
+  version_id bigint primary key,
   kind text not null default 'course',
   title text not null,
   unit_value_kind text not null default 'fixed',
@@ -325,37 +329,37 @@ create table public.course_snapshot_details (
   prescribed_texts text,
   offering_status text not null default 'unknown',
   source_updated_at timestamptz,
-  constraint course_snapshot_details_snapshot_kind_fkey
-    foreign key (snapshot_id, kind) references public.catalogue_snapshots (id, kind)
+  constraint course_version_details_snapshot_kind_fkey
+    foreign key (version_id, kind) references public.catalogue_versions (id, kind)
     on delete cascade,
-  constraint course_snapshot_details_kind_check check (kind = 'course'),
-  constraint course_snapshot_details_title_not_blank_check check (btrim(title) <> ''),
-  constraint course_snapshot_details_unit_value_kind_check check (
+  constraint course_version_details_kind_check check (kind = 'course'),
+  constraint course_version_details_title_not_blank_check check (btrim(title) <> ''),
+  constraint course_version_details_unit_value_kind_check check (
     unit_value_kind in ('fixed', 'range', 'variable', 'unknown')
   ),
-  constraint course_snapshot_details_units_check check (
+  constraint course_version_details_units_check check (
     (units is null or units >= 0)
     and (minimum_units is null or minimum_units >= 0)
     and (maximum_units is null or maximum_units >= 0)
     and (minimum_units is null or maximum_units is null or maximum_units >= minimum_units)
     and (unit_value_kind <> 'fixed' or units is not null)
   ),
-  constraint course_snapshot_details_eftsl_check check (eftsl is null or eftsl >= 0),
-  constraint course_snapshot_details_level_check check (level between 0 and 9999),
-  constraint course_snapshot_details_subject_code_check check (subject_code ~ '^[A-Z]{4}$'),
-  constraint course_snapshot_details_academic_career_check check (
+  constraint course_version_details_eftsl_check check (eftsl is null or eftsl >= 0),
+  constraint course_version_details_level_check check (level between 0 and 9999),
+  constraint course_version_details_subject_code_check check (subject_code ~ '^[A-Z]{4}$'),
+  constraint course_version_details_academic_career_check check (
     academic_career is null or academic_career in ('UGRD', 'PGRD', 'RSCH', 'OTHER')
   ),
-  constraint course_snapshot_details_workload_hours_check check (
+  constraint course_version_details_workload_hours_check check (
     workload_hours is null or workload_hours >= 0
   ),
-  constraint course_snapshot_details_offering_status_check check (
+  constraint course_version_details_offering_status_check check (
     offering_status in ('offered', 'not_offered', 'unknown')
   )
 );
 
-create table public.structure_snapshot_details (
-  snapshot_id bigint primary key,
+create table public.structure_version_details (
+  version_id bigint primary key,
   kind text not null,
   name text not null,
   acronym text,
@@ -373,15 +377,15 @@ create table public.structure_snapshot_details (
   can_combine_vertical boolean,
   study_as text,
   contact_text text,
-  constraint structure_snapshot_details_snapshot_kind_fkey
-    foreign key (snapshot_id, kind) references public.catalogue_snapshots (id, kind)
+  constraint structure_version_details_snapshot_kind_fkey
+    foreign key (version_id, kind) references public.catalogue_versions (id, kind)
     on delete cascade,
-  constraint structure_snapshot_details_kind_check check (
+  constraint structure_version_details_kind_check check (
     kind in ('programme', 'major', 'minor', 'specialisation')
   ),
-  constraint structure_snapshot_details_name_check check (btrim(name) <> ''),
-  constraint structure_snapshot_details_units_check check (units is null or units > 0),
-  constraint structure_snapshot_details_duration_check check (
+  constraint structure_version_details_name_check check (btrim(name) <> ''),
+  constraint structure_version_details_units_check check (units is null or units > 0),
+  constraint structure_version_details_duration_check check (
     duration_years is null or duration_years > 0
   )
 );
@@ -390,9 +394,9 @@ create table public.structure_snapshot_details (
 drop table public.course_snapshot_field_evidence;
 drop table public.academic_structure_snapshot_evidence;
 
-create table public.snapshot_field_evidence (
+create table public.catalogue_version_provenance (
   id bigint generated always as identity primary key,
-  snapshot_id bigint not null,
+  version_id bigint not null,
   academic_year_id bigint not null,
   source_page_id bigint,
   field_path text not null,
@@ -401,24 +405,24 @@ create table public.snapshot_field_evidence (
   source_locator text,
   source_excerpt text,
   created_at timestamptz not null default now(),
-  constraint snapshot_field_evidence_snapshot_fkey
-    foreign key (snapshot_id, academic_year_id)
-    references public.catalogue_snapshots (id, academic_year_id)
+  constraint catalogue_version_provenance_snapshot_fkey
+    foreign key (version_id, academic_year_id)
+    references public.catalogue_versions (id, academic_year_id)
     on delete cascade,
-  constraint snapshot_field_evidence_source_page_fkey
+  constraint catalogue_version_provenance_source_page_fkey
     foreign key (source_page_id, academic_year_id)
     references public.catalogue_source_pages (id, academic_year_id),
-  constraint snapshot_field_evidence_field_path_check check (btrim(field_path) <> ''),
-  constraint snapshot_field_evidence_method_check check (
+  constraint catalogue_version_provenance_field_path_check check (btrim(field_path) <> ''),
+  constraint catalogue_version_provenance_method_check check (
     method in ('deterministic', 'model', 'manual')
   ),
-  constraint snapshot_field_evidence_confidence_check check (
+  constraint catalogue_version_provenance_confidence_check check (
     confidence is null or confidence between 0 and 1
   )
 );
 
-create index snapshot_field_evidence_snapshot_idx
-  on public.snapshot_field_evidence (snapshot_id, field_path);
+create index catalogue_version_provenance_snapshot_idx
+  on public.catalogue_version_provenance (version_id, field_path);
 
 -- Re-point the existing child tables -----------------------------------------------
 
@@ -495,12 +499,12 @@ begin
 
   foreach child in array course_children loop
     execute format(
-      'alter table public.%I rename column course_snapshot_id to snapshot_id',
+      'alter table public.%I rename column course_snapshot_id to version_id',
       child
     );
     execute format(
-      'alter table public.%I add constraint %I foreign key (snapshot_id) '
-      'references public.catalogue_snapshots (id) on delete cascade',
+      'alter table public.%I add constraint %I foreign key (version_id) '
+      'references public.catalogue_versions (id) on delete cascade',
       child,
       child || '_snapshot_id_fkey'
     );
@@ -513,8 +517,8 @@ begin
     );
     execute format(
       'alter table public.%I '
-      'add constraint %I foreign key (snapshot_id, academic_year_id) '
-      'references public.catalogue_snapshots (id, academic_year_id) on delete cascade, '
+      'add constraint %I foreign key (version_id, academic_year_id) '
+      'references public.catalogue_versions (id, academic_year_id) on delete cascade, '
       'add constraint %I foreign key (source_page_id, academic_year_id) '
       'references public.catalogue_source_pages (id, academic_year_id)',
       child,
@@ -525,8 +529,12 @@ begin
 
   foreach child in array structure_children loop
     execute format(
-      'alter table public.%I add constraint %I foreign key (snapshot_id) '
-      'references public.catalogue_snapshots (id) on delete cascade',
+      'alter table public.%I rename column snapshot_id to version_id',
+      child
+    );
+    execute format(
+      'alter table public.%I add constraint %I foreign key (version_id) '
+      'references public.catalogue_versions (id) on delete cascade',
       child,
       child || '_snapshot_id_fkey'
     );
@@ -542,21 +550,21 @@ alter table public.course_rules alter column source_page_id drop not null;
 
 alter table public.course_related_courses
   add constraint course_related_courses_related_item_fkey
-    foreign key (related_course_id) references public.catalogue_items (id);
+    foreign key (related_course_id) references public.catalogue_codes (id);
 
 alter table public.course_rule_conditions
   add constraint course_rule_conditions_required_course_fkey
-    foreign key (required_course_id) references public.catalogue_items (id),
+    foreign key (required_course_id) references public.catalogue_codes (id),
   add constraint course_rule_conditions_required_structure_fkey
-    foreign key (required_structure_id) references public.catalogue_items (id);
+    foreign key (required_structure_id) references public.catalogue_codes (id);
 
 alter table public.course_rule_condition_courses
   add constraint course_rule_condition_courses_referenced_item_fkey
-    foreign key (referenced_course_id) references public.catalogue_items (id);
+    foreign key (referenced_course_id) references public.catalogue_codes (id);
 
 alter table public.course_rule_course_references
   add constraint course_rule_course_references_referenced_item_fkey
-    foreign key (referenced_course_id) references public.catalogue_items (id);
+    foreign key (referenced_course_id) references public.catalogue_codes (id);
 
 create or replace function private.validate_course_rule_condition_course()
 returns trigger
@@ -568,7 +576,7 @@ begin
     select 1
     from public.course_rule_conditions as conditions
     where conditions.id = new.condition_id
-      and conditions.snapshot_id = new.snapshot_id
+      and conditions.version_id = new.version_id
       and conditions.condition_kind = 'course_set_units'
   ) then
     raise exception 'course-set members require a course_set_units condition'
@@ -578,7 +586,7 @@ begin
   if new.referenced_course_id is not null
     and not exists (
       select 1
-      from public.catalogue_items
+      from public.catalogue_codes
       where id = new.referenced_course_id
         and kind = 'course'
         and code = new.source_course_code
@@ -595,22 +603,27 @@ $function$;
 -- User-owned tables ----------------------------------------------------------------
 
 alter table public.plan_items
-  add constraint plan_items_course_item_fkey
-    foreign key (course_id) references public.catalogue_items (id),
-  add constraint plan_items_course_item_year_fkey
-    foreign key (course_id, academic_year_id)
-    references public.catalogue_item_years (item_id, academic_year_id);
+  rename column course_id to catalogue_record_id;
+
+alter table public.plan_items
+  drop column academic_year_id,
+  add constraint plan_items_catalogue_record_fkey
+    foreign key (catalogue_record_id) references public.catalogue_records (id);
+
+alter table public.course_attempts
+  rename column course_snapshot_id to catalogue_version_id;
 
 alter table public.course_attempts
-  add constraint course_attempts_course_item_fkey
-    foreign key (course_id) references public.catalogue_items (id),
-  add constraint course_attempts_snapshot_fkey
-    foreign key (course_snapshot_id) references public.catalogue_snapshots (id);
+  add constraint course_attempts_catalogue_version_fkey
+    foreign key (catalogue_version_id) references public.catalogue_versions (id);
 
 alter table public.plan_structures
-  add constraint plan_structures_item_year_fkey
-    foreign key (structure_year_id, academic_year_id)
-    references public.catalogue_item_years (id, academic_year_id);
+  rename column structure_year_id to catalogue_record_id;
+
+alter table public.plan_structures
+  drop column academic_year_id,
+  add constraint plan_structures_catalogue_record_fkey
+    foreign key (catalogue_record_id) references public.catalogue_records (id);
 
 -- The replaced tables reference each other circularly, so they go as one group.
 -- Every dependency outside the group was re-pointed above.
@@ -626,22 +639,27 @@ drop table
   public.academic_structure_source_pages,
   public.academic_structure_sources;
 
+alter table public.course_attempts
+  drop column course_id,
+  add constraint course_attempts_owner_version_period_unique
+    unique (owner_id, catalogue_version_id, academic_period_id);
+
 drop function private.can_read_academic_structure_snapshot(bigint);
 drop function private.is_published_academic_structure_snapshot(bigint);
 
 -- Integrity triggers -----------------------------------------------------------------
 
-create trigger catalogue_items_set_updated_at
-before update on public.catalogue_items
+create trigger catalogue_codes_set_updated_at
+before update on public.catalogue_codes
 for each row execute function private.set_updated_at();
 
-create trigger catalogue_item_years_set_updated_at
-before update on public.catalogue_item_years
+create trigger catalogue_records_set_updated_at
+before update on public.catalogue_records
 for each row execute function private.set_updated_at();
 
--- Only the sealing update is allowed; everything else about a snapshot is fixed
--- at creation. Cascading deletes from an item year still pass.
-create or replace function private.enforce_catalogue_snapshot_immutability()
+-- Only the one-way sealing update is allowed. Cascading record deletion may
+-- still remove versions, but application code cannot mutate materialised state.
+create or replace function private.enforce_catalogue_version_immutability()
 returns trigger
 language plpgsql
 set search_path = ''
@@ -655,40 +673,40 @@ begin
     return new;
   end if;
   raise exception
-    'catalogue_snapshots records are immutable; create a new snapshot instead'
+    'Catalogue versions are immutable; create a new version instead.'
     using errcode = '55000';
 end;
 $function$;
 
-revoke all on function private.enforce_catalogue_snapshot_immutability()
+revoke all on function private.enforce_catalogue_version_immutability()
 from public, anon, authenticated;
 
-create trigger catalogue_snapshots_enforce_immutability
-before update or delete on public.catalogue_snapshots
-for each row execute function private.enforce_catalogue_snapshot_immutability();
+create trigger catalogue_versions_enforce_immutability
+before update or delete on public.catalogue_versions
+for each row execute function private.enforce_catalogue_version_immutability();
 
-create or replace function private.seal_catalogue_item_year_pointers()
+create or replace function private.seal_published_catalogue_version()
 returns trigger
 language plpgsql
 security definer
 set search_path = ''
 as $function$
 begin
-  update public.catalogue_snapshots
+  update public.catalogue_versions
   set sealed_at = greatest(statement_timestamp(), created_at)
-  where id in (new.draft_snapshot_id, new.published_snapshot_id)
+  where id = new.published_version_id
     and sealed_at is null;
   return new;
 end;
 $function$;
 
-revoke all on function private.seal_catalogue_item_year_pointers()
+revoke all on function private.seal_published_catalogue_version()
 from public, anon, authenticated;
 
-create trigger catalogue_item_years_seal_pointers
-before insert or update of draft_snapshot_id, published_snapshot_id
-on public.catalogue_item_years
-for each row execute function private.seal_catalogue_item_year_pointers();
+create trigger catalogue_records_seal_published_version
+before insert or update of published_version_id
+on public.catalogue_records
+for each row execute function private.seal_published_catalogue_version();
 
 -- Archived years keep their pointers and cannot be edited further.
 create or replace function private.guard_archived_catalogue_item_year()
@@ -700,17 +718,15 @@ begin
   if old.archived_at is not null and new is distinct from old then
     raise exception 'Archived catalogue years are immutable.' using errcode = '55000';
   end if;
-  if new.archived_at is not null and (
-    new.draft_snapshot_id is distinct from old.draft_snapshot_id
-    or new.published_snapshot_id is distinct from old.published_snapshot_id
-  ) then
-    raise exception 'Archival cannot change snapshot pointers.' using errcode = '55000';
+  if new.archived_at is not null
+    and new.published_version_id is distinct from old.published_version_id
+  then
+    raise exception 'Archival cannot change the published version.' using errcode = '55000';
   end if;
   if new.archived_at is not null and exists (
     select 1
     from public.plan_items
-    where plan_items.course_id = old.item_id
-      and plan_items.academic_year_id = old.academic_year_id
+    where plan_items.catalogue_record_id = old.id
   ) then
     raise exception
       'This catalogue year cannot be archived while it is referenced by a student plan.'
@@ -723,8 +739,8 @@ $function$;
 revoke all on function private.guard_archived_catalogue_item_year()
 from public, anon, authenticated;
 
-create trigger catalogue_item_years_zz_guard_archived
-before update on public.catalogue_item_years
+create trigger catalogue_records_zz_guard_archived
+before update on public.catalogue_records
 for each row execute function private.guard_archived_catalogue_item_year();
 
 create or replace function private.record_catalogue_publication()
@@ -734,16 +750,25 @@ security definer
 set search_path = ''
 as $function$
 begin
-  if tg_op = 'INSERT' and new.published_snapshot_id is null then
-    return new;
-  end if;
   if tg_op = 'UPDATE'
-    and new.published_snapshot_id is not distinct from old.published_snapshot_id
+    and new.published_version_id is not distinct from old.published_version_id
   then
     return new;
   end if;
-  insert into public.catalogue_publications (item_year_id, snapshot_id, published_by)
-  values (new.id, new.published_snapshot_id, (select auth.uid()));
+
+  update public.catalogue_publications
+  set
+    unpublished_by = (select auth.uid()),
+    unpublished_at = statement_timestamp()
+  where record_id = new.id
+    and unpublished_at is null;
+
+  if new.published_version_id is null then
+    return new;
+  end if;
+
+  insert into public.catalogue_publications (record_id, version_id, published_by)
+  values (new.id, new.published_version_id, (select auth.uid()));
   return new;
 end;
 $function$;
@@ -751,8 +776,8 @@ $function$;
 revoke all on function private.record_catalogue_publication()
 from public, anon, authenticated;
 
-create trigger catalogue_item_years_record_publication
-after insert or update of published_snapshot_id on public.catalogue_item_years
+create trigger catalogue_records_record_publication
+after insert or update of published_version_id on public.catalogue_records
 for each row execute function private.record_catalogue_publication();
 
 -- Child rows are assembled before a snapshot becomes a pointer and frozen after.
@@ -764,16 +789,16 @@ set search_path = ''
 as $function$
 declare
   target_snapshot_id bigint := case
-    when tg_op = 'DELETE' then old.snapshot_id
-    else new.snapshot_id
+    when tg_op = 'DELETE' then old.version_id
+    else new.version_id
   end;
   snapshot_is_sealed boolean;
 begin
   select snapshots.sealed_at is not null
   into snapshot_is_sealed
-  from public.catalogue_snapshots as snapshots
-  join public.catalogue_item_years as item_years
-    on item_years.id = snapshots.item_year_id
+  from public.catalogue_versions as snapshots
+  join public.catalogue_records as item_years
+    on item_years.id = snapshots.record_id
   where snapshots.id = target_snapshot_id
   for update of item_years;
 
@@ -799,9 +824,9 @@ declare
   child text;
 begin
   foreach child in array array[
-    'course_snapshot_details',
-    'structure_snapshot_details',
-    'snapshot_field_evidence',
+    'course_version_details',
+    'structure_version_details',
+    'catalogue_version_provenance',
     'course_offerings',
     'offering_sessions',
     'course_learning_outcomes',
@@ -837,7 +862,7 @@ begin
 end;
 $$;
 
--- Plan items reference a course item year that is not archived.
+-- Plan items reference one active annual course record.
 create or replace function private.require_active_plan_item_course_year()
 returns trigger
 language plpgsql
@@ -849,9 +874,8 @@ declare
 begin
   select item_years.archived_at
   into selected_archived_at
-  from public.catalogue_item_years as item_years
-  where item_years.item_id = new.course_id
-    and item_years.academic_year_id = new.academic_year_id
+  from public.catalogue_records as item_years
+  where item_years.id = new.catalogue_record_id
     and item_years.kind = 'course'
   for share of item_years;
   if not found then
@@ -870,7 +894,7 @@ revoke all on function private.require_active_plan_item_course_year()
 from public, anon, authenticated;
 
 create trigger plan_items_require_active_course_year
-before insert or update of course_id, academic_year_id on public.plan_items
+before insert or update of catalogue_record_id on public.plan_items
 for each row execute function private.require_active_plan_item_course_year();
 
 create or replace function private.enforce_course_attempt_snapshot_lineage()
@@ -884,14 +908,14 @@ declare
 begin
   select academic_years.year
   into snapshot_academic_year
-  from public.catalogue_snapshots as snapshots
-  join public.catalogue_item_years as item_years
-    on item_years.id = snapshots.item_year_id
+  from public.catalogue_versions as snapshots
+  join public.catalogue_records as item_years
+    on item_years.id = snapshots.record_id
   join public.academic_years
     on academic_years.id = snapshots.academic_year_id
-  where snapshots.id = new.course_snapshot_id
+  where snapshots.id = new.catalogue_version_id
     and snapshots.kind = 'course'
-    and item_years.item_id = new.course_id;
+    and item_years.id = snapshots.record_id;
   if snapshot_academic_year is null then
     raise exception
       'course attempt snapshot does not belong to the selected course'
@@ -916,7 +940,7 @@ revoke all on function private.enforce_course_attempt_snapshot_lineage()
 from public, anon, authenticated;
 
 create trigger course_attempts_enforce_snapshot_lineage
-before insert or update of course_id, course_snapshot_id, academic_period_id
+before insert or update of catalogue_version_id, academic_period_id
 on public.course_attempts
 for each row execute function private.enforce_course_attempt_snapshot_lineage();
 
@@ -930,8 +954,8 @@ declare
 begin
   select item_years.kind
   into selected_kind
-  from public.catalogue_item_years as item_years
-  where item_years.id = new.structure_year_id;
+  from public.catalogue_records as item_years
+  where item_years.id = new.catalogue_record_id;
   if selected_kind is not null and selected_kind is distinct from new.role then
     raise exception using
       errcode = '23514',
@@ -945,12 +969,12 @@ revoke all on function private.validate_plan_structure_kind()
 from public, anon, authenticated;
 
 create trigger plan_structures_validate_kind
-before insert or update of structure_year_id, role on public.plan_structures
+before insert or update of catalogue_record_id, role on public.plan_structures
 for each row execute function private.validate_plan_structure_kind();
 
 -- Access -------------------------------------------------------------------------------
 
-create or replace function private.is_published_snapshot(p_snapshot_id bigint)
+create or replace function private.is_published_version(p_version_id bigint)
 returns boolean
 language sql
 stable
@@ -959,8 +983,8 @@ set search_path = ''
 as $function$
   select exists (
     select 1
-    from public.catalogue_item_years as item_years
-    where item_years.published_snapshot_id = p_snapshot_id
+    from public.catalogue_records as item_years
+    where item_years.published_version_id = p_version_id
       and item_years.archived_at is null
   );
 $function$;
@@ -981,19 +1005,19 @@ $function$;
 
 -- Published snapshots are public. Administrators read drafts, and students
 -- keep reading the snapshot their recorded attempts point at.
-create or replace function private.can_read_snapshot(p_snapshot_id bigint)
+create or replace function private.can_read_version(p_version_id bigint)
 returns boolean
 language sql
 stable
 security definer
 set search_path = ''
 as $function$
-  select private.is_published_snapshot(p_snapshot_id)
+  select private.is_published_version(p_version_id)
     or private.can_manage_catalogue()
     or exists (
       select 1
       from public.course_attempts as attempts
-      where attempts.course_snapshot_id = p_snapshot_id
+      where attempts.catalogue_version_id = p_version_id
         and attempts.owner_id = (select auth.uid())
     );
 $function$;
@@ -1011,9 +1035,9 @@ as $function$
   select private.can_manage_catalogue()
     or exists (
       select 1
-      from public.catalogue_item_years as item_years
-      where item_years.item_id = p_item_id
-        and item_years.published_snapshot_id is not null
+      from public.catalogue_records as item_years
+      where item_years.code_id = p_item_id
+        and item_years.published_version_id is not null
         and item_years.archived_at is null
     )
     or exists (
@@ -1021,97 +1045,102 @@ as $function$
       from public.course_rule_conditions as conditions
       where (conditions.required_course_id = p_item_id
         or conditions.required_structure_id = p_item_id)
-        and private.is_published_snapshot(conditions.snapshot_id)
+        and private.is_published_version(conditions.version_id)
     )
     or exists (
       select 1
       from public.course_rule_course_references as rule_references
       where rule_references.referenced_course_id = p_item_id
-        and private.is_published_snapshot(rule_references.snapshot_id)
+        and private.is_published_version(rule_references.version_id)
     )
     or exists (
       select 1
       from public.course_rule_condition_courses as members
       where members.referenced_course_id = p_item_id
-        and private.is_published_snapshot(members.snapshot_id)
+        and private.is_published_version(members.version_id)
     )
     or exists (
       select 1
       from public.course_related_courses as related
       where related.related_course_id = p_item_id
-        and private.is_published_snapshot(related.snapshot_id)
+        and private.is_published_version(related.version_id)
     )
     or exists (
       select 1
       from public.course_attempts as attempts
-      where attempts.course_id = p_item_id
+      join public.catalogue_versions as versions
+        on versions.id = attempts.catalogue_version_id
+      join public.catalogue_records as records on records.id = versions.record_id
+      where records.code_id = p_item_id
         and attempts.owner_id = (select auth.uid())
     )
     or exists (
       select 1
       from public.plan_items
-      where plan_items.course_id = p_item_id
+      join public.catalogue_records as records
+        on records.id = plan_items.catalogue_record_id
+      where records.code_id = p_item_id
         and plan_items.owner_id = (select auth.uid())
     );
 $function$;
 
 -- Policies evaluate these with the querying role's privileges, so the roles
 -- the policies apply to must be able to execute them.
-revoke all on function private.is_published_snapshot(bigint) from public;
+revoke all on function private.is_published_version(bigint) from public;
 revoke all on function private.can_manage_catalogue() from public;
-revoke all on function private.can_read_snapshot(bigint) from public;
+revoke all on function private.can_read_version(bigint) from public;
 revoke all on function private.can_read_catalogue_item(bigint) from public;
-grant execute on function private.is_published_snapshot(bigint) to anon, authenticated;
+grant execute on function private.is_published_version(bigint) to anon, authenticated;
 grant execute on function private.can_manage_catalogue() to anon, authenticated;
-grant execute on function private.can_read_snapshot(bigint) to anon, authenticated;
+grant execute on function private.can_read_version(bigint) to anon, authenticated;
 grant execute on function private.can_read_catalogue_item(bigint) to anon, authenticated;
 
-alter table public.catalogue_items enable row level security;
-alter table public.catalogue_item_years enable row level security;
-alter table public.catalogue_snapshots enable row level security;
+alter table public.catalogue_codes enable row level security;
+alter table public.catalogue_records enable row level security;
+alter table public.catalogue_versions enable row level security;
 alter table public.catalogue_publications enable row level security;
-alter table public.course_snapshot_details enable row level security;
-alter table public.structure_snapshot_details enable row level security;
-alter table public.snapshot_field_evidence enable row level security;
+alter table public.course_version_details enable row level security;
+alter table public.structure_version_details enable row level security;
+alter table public.catalogue_version_provenance enable row level security;
 
-create policy catalogue_items_read
-on public.catalogue_items
+create policy catalogue_codes_read
+on public.catalogue_codes
 for select
 to anon, authenticated
 using ((select private.can_read_catalogue_item(id)));
 
-create policy catalogue_items_admin_write
-on public.catalogue_items
+create policy catalogue_codes_admin_write
+on public.catalogue_codes
 for all
 to authenticated
 using ((select private.can_manage_catalogue()))
 with check ((select private.can_manage_catalogue()));
 
-create policy catalogue_item_years_read
-on public.catalogue_item_years
+create policy catalogue_records_read
+on public.catalogue_records
 for select
 to anon, authenticated
 using (
-  (published_snapshot_id is not null and archived_at is null)
+  (published_version_id is not null and archived_at is null)
   or (select private.can_manage_catalogue())
-  or (select private.can_read_catalogue_item(item_id))
+  or (select private.can_read_catalogue_item(code_id))
 );
 
-create policy catalogue_item_years_admin_write
-on public.catalogue_item_years
+create policy catalogue_records_admin_write
+on public.catalogue_records
 for all
 to authenticated
 using ((select private.can_manage_catalogue()))
 with check ((select private.can_manage_catalogue()));
 
-create policy catalogue_snapshots_read
-on public.catalogue_snapshots
+create policy catalogue_versions_read
+on public.catalogue_versions
 for select
 to anon, authenticated
-using ((select private.can_read_snapshot(id)));
+using ((select private.can_read_version(id)));
 
-create policy catalogue_snapshots_admin_insert
-on public.catalogue_snapshots
+create policy catalogue_versions_admin_insert
+on public.catalogue_versions
 for insert
 to authenticated
 with check ((select private.can_manage_catalogue()));
@@ -1121,7 +1150,7 @@ on public.catalogue_publications
 for select
 to anon, authenticated
 using (
-  (snapshot_id is not null and (select private.is_published_snapshot(snapshot_id)))
+  (version_id is not null and (select private.is_published_version(version_id)))
   or (select private.can_manage_catalogue())
 );
 
@@ -1130,9 +1159,9 @@ declare
   child text;
 begin
   foreach child in array array[
-    'course_snapshot_details',
-    'structure_snapshot_details',
-    'snapshot_field_evidence',
+    'course_version_details',
+    'structure_version_details',
+    'catalogue_version_provenance',
     'course_offerings',
     'offering_sessions',
     'course_learning_outcomes',
@@ -1160,7 +1189,7 @@ begin
   ] loop
     execute format(
       'create policy %I on public.%I for select to anon, authenticated '
-      'using ((select private.can_read_snapshot(snapshot_id)))',
+      'using ((select private.can_read_version(version_id)))',
       child || '_read',
       child
     );
@@ -1175,40 +1204,40 @@ end;
 $$;
 
 grant select on table
-  public.catalogue_items,
-  public.catalogue_item_years,
-  public.catalogue_snapshots,
+  public.catalogue_codes,
+  public.catalogue_records,
+  public.catalogue_versions,
   public.catalogue_publications,
-  public.course_snapshot_details,
-  public.structure_snapshot_details,
-  public.snapshot_field_evidence
+  public.course_version_details,
+  public.structure_version_details,
+  public.catalogue_version_provenance
 to anon, authenticated;
 
 grant insert, update on table
-  public.catalogue_items,
-  public.catalogue_item_years
+  public.catalogue_codes,
+  public.catalogue_records
 to authenticated;
 
 grant insert on table
-  public.catalogue_snapshots,
-  public.course_snapshot_details,
-  public.structure_snapshot_details,
-  public.snapshot_field_evidence
+  public.catalogue_versions,
+  public.course_version_details,
+  public.structure_version_details,
+  public.catalogue_version_provenance
 to authenticated;
 
 grant select, insert, update on table
-  public.catalogue_items,
-  public.catalogue_item_years,
-  public.catalogue_snapshots,
+  public.catalogue_codes,
+  public.catalogue_records,
+  public.catalogue_versions,
   public.catalogue_publications,
-  public.course_snapshot_details,
-  public.structure_snapshot_details,
-  public.snapshot_field_evidence
+  public.course_version_details,
+  public.structure_version_details,
+  public.catalogue_version_provenance
 to service_role;
 
 -- Published reads -----------------------------------------------------------------------
 
-create or replace function private.course_snapshot_projection(p_snapshot_id bigint)
+create or replace function private.course_version_projection(p_version_id bigint)
 returns jsonb
 language sql
 stable
@@ -1217,7 +1246,7 @@ as $function$
   with selected_snapshot as (
     select
       snapshots.id,
-      snapshots.item_year_id,
+      snapshots.record_id,
       snapshots.academic_year_id,
       snapshots.origin,
       snapshots.source_page_id,
@@ -1226,15 +1255,15 @@ as $function$
       details.*,
       items.code as course_code,
       academic_years.year as academic_year
-    from public.catalogue_snapshots as snapshots
-    join public.course_snapshot_details as details
-      on details.snapshot_id = snapshots.id
-    join public.catalogue_item_years as item_years
-      on item_years.id = snapshots.item_year_id
-    join public.catalogue_items as items on items.id = item_years.item_id
+    from public.catalogue_versions as snapshots
+    join public.course_version_details as details
+      on details.version_id = snapshots.id
+    join public.catalogue_records as item_years
+      on item_years.id = snapshots.record_id
+    join public.catalogue_codes as items on items.id = item_years.code_id
     join public.academic_years
       on academic_years.id = snapshots.academic_year_id
-    where snapshots.id = p_snapshot_id
+    where snapshots.id = p_version_id
   )
   select jsonb_build_object(
     'courseCode', snapshot.course_code,
@@ -1272,7 +1301,7 @@ as $function$
         'sourceText', options.source_text
       ) order by options.position)
       from public.course_unit_options as options
-      where options.snapshot_id = p_snapshot_id
+      where options.version_id = p_version_id
     ), '[]'::jsonb),
     'fees', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -1288,7 +1317,7 @@ as $function$
         'sourceText', fees.source_text
       ) order by fees.position)
       from public.course_fees as fees
-      where fees.snapshot_id = p_snapshot_id
+      where fees.version_id = p_version_id
     ), '[]'::jsonb),
     'areasOfInterest', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -1296,7 +1325,7 @@ as $function$
         'name', areas.name
       ) order by areas.position)
       from public.course_areas_of_interest as areas
-      where areas.snapshot_id = p_snapshot_id
+      where areas.version_id = p_version_id
     ), '[]'::jsonb),
     'attributes', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -1306,7 +1335,7 @@ as $function$
         'sourceText', attributes.source_text
       ) order by attributes.position)
       from public.course_attributes as attributes
-      where attributes.snapshot_id = p_snapshot_id
+      where attributes.version_id = p_version_id
     ), '[]'::jsonb),
     'relatedCourses', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -1317,7 +1346,7 @@ as $function$
         'sourceText', related.source_text
       ) order by related.position)
       from public.course_related_courses as related
-      where related.snapshot_id = p_snapshot_id
+      where related.version_id = p_version_id
     ), '[]'::jsonb),
     'courseOffering', (
       select jsonb_build_object(
@@ -1325,7 +1354,7 @@ as $function$
         'location', offerings.location
       )
       from public.course_offerings as offerings
-      where offerings.snapshot_id = p_snapshot_id
+      where offerings.version_id = p_version_id
     ),
     'offeringSessions', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -1344,7 +1373,7 @@ as $function$
         'sourceText', sessions.source_text
       ) order by sessions.position)
       from public.offering_sessions as sessions
-      where sessions.snapshot_id = p_snapshot_id
+      where sessions.version_id = p_version_id
     ), '[]'::jsonb),
     'learningOutcomes', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -1352,7 +1381,7 @@ as $function$
         'body', outcomes.body
       ) order by outcomes.position)
       from public.course_learning_outcomes as outcomes
-      where outcomes.snapshot_id = p_snapshot_id
+      where outcomes.version_id = p_version_id
     ), '[]'::jsonb),
     'assessmentItems', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -1364,7 +1393,7 @@ as $function$
         'sourceText', items.source_text
       ) order by items.position)
       from public.course_assessment_items as items
-      where items.snapshot_id = p_snapshot_id
+      where items.version_id = p_version_id
     ), '[]'::jsonb),
     'assessmentOutcomes', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -1376,7 +1405,7 @@ as $function$
         on items.id = links.assessment_item_id
       join public.course_learning_outcomes as outcomes
         on outcomes.id = links.learning_outcome_id
-      where links.snapshot_id = p_snapshot_id
+      where links.version_id = p_version_id
     ), '[]'::jsonb),
     'rules', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -1395,7 +1424,7 @@ as $function$
         else 6
       end)
       from public.course_rules as rules
-      where rules.snapshot_id = p_snapshot_id
+      where rules.version_id = p_version_id
     ), '[]'::jsonb),
     'ruleGroups', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -1410,7 +1439,7 @@ as $function$
       join public.course_rules as rules on rules.id = groups.course_rule_id
       left join public.course_rule_groups as parents
         on parents.id = groups.parent_group_id
-      where groups.snapshot_id = p_snapshot_id
+      where groups.version_id = p_version_id
     ), '[]'::jsonb),
     'ruleConditions', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -1439,11 +1468,11 @@ as $function$
       from public.course_rule_conditions as conditions
       join public.course_rules as rules on rules.id = conditions.course_rule_id
       join public.course_rule_groups as groups on groups.id = conditions.group_id
-      left join public.catalogue_items as required_courses
+      left join public.catalogue_codes as required_courses
         on required_courses.id = conditions.required_course_id
-      left join public.catalogue_items as required_structures
+      left join public.catalogue_codes as required_structures
         on required_structures.id = conditions.required_structure_id
-      where conditions.snapshot_id = p_snapshot_id
+      where conditions.version_id = p_version_id
     ), '[]'::jsonb),
     'ruleConditionCourses', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -1455,7 +1484,7 @@ as $function$
       from public.course_rule_condition_courses as members
       join public.course_rule_conditions as conditions
         on conditions.id = members.condition_id
-      where members.snapshot_id = p_snapshot_id
+      where members.version_id = p_version_id
     ), '[]'::jsonb),
     'ruleCourseReferences', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -1467,9 +1496,9 @@ as $function$
       ) order by rules.rule_kind, referenced.code)
       from public.course_rule_course_references as rule_references
       join public.course_rules as rules on rules.id = rule_references.course_rule_id
-      join public.catalogue_items as referenced
+      join public.catalogue_codes as referenced
         on referenced.id = rule_references.referenced_course_id
-      where rule_references.snapshot_id = p_snapshot_id
+      where rule_references.version_id = p_version_id
     ), '[]'::jsonb),
     'prerequisiteCodes', coalesce((
       select jsonb_agg(codes.code order by codes.code)
@@ -1477,17 +1506,17 @@ as $function$
         select referenced.code
         from public.course_rule_course_references as rule_references
         join public.course_rules as rules on rules.id = rule_references.course_rule_id
-        join public.catalogue_items as referenced
+        join public.catalogue_codes as referenced
           on referenced.id = rule_references.referenced_course_id
-        where rules.snapshot_id = p_snapshot_id
+        where rules.version_id = p_version_id
           and rules.rule_kind = 'prerequisite'
         union
         select required.code
         from public.course_rule_conditions as conditions
         join public.course_rules as rules on rules.id = conditions.course_rule_id
-        join public.catalogue_items as required
+        join public.catalogue_codes as required
           on required.id = conditions.required_course_id
-        where rules.snapshot_id = p_snapshot_id
+        where rules.version_id = p_version_id
           and rules.rule_kind = 'prerequisite'
           and conditions.condition_kind = 'course'
         union
@@ -1496,7 +1525,7 @@ as $function$
         join public.course_rule_conditions as conditions
           on conditions.id = members.condition_id
         join public.course_rules as rules on rules.id = conditions.course_rule_id
-        where rules.snapshot_id = p_snapshot_id
+        where rules.version_id = p_version_id
           and rules.rule_kind = 'prerequisite'
       ) as codes
     ), '[]'::jsonb),
@@ -1508,7 +1537,7 @@ as $function$
   from selected_snapshot as snapshot;
 $function$;
 
-revoke all on function private.course_snapshot_projection(bigint)
+revoke all on function private.course_version_projection(bigint)
 from public, anon, authenticated;
 
 create or replace function public.published_course_requisite_graph(
@@ -1527,52 +1556,52 @@ set search_path = ''
 as $function$
   with recursive
   published_snapshots as (
-    select item_years.item_id, item_years.published_snapshot_id as snapshot_id
-    from public.catalogue_item_years as item_years
+    select item_years.code_id, item_years.published_version_id as version_id
+    from public.catalogue_records as item_years
     join public.academic_years
       on academic_years.id = item_years.academic_year_id
      and academic_years.year = p_academic_year
     where item_years.kind = 'course'
       and item_years.archived_at is null
-      and item_years.published_snapshot_id is not null
+      and item_years.published_version_id is not null
   ),
   root as (
-    select published_snapshots.item_id
+    select published_snapshots.code_id
     from published_snapshots
-    join public.catalogue_items as items on items.id = published_snapshots.item_id
+    join public.catalogue_codes as items on items.id = published_snapshots.code_id
     where items.code = upper(btrim(p_course_code))
     limit 1
   ),
   edges as (
     select
       rule_references.referenced_course_id as from_item_id,
-      published_snapshots.item_id as to_item_id
+      published_snapshots.code_id as to_item_id
     from public.course_rule_course_references as rule_references
     join public.course_rules as rules on rules.id = rule_references.course_rule_id
-    join published_snapshots on published_snapshots.snapshot_id = rules.snapshot_id
+    join published_snapshots on published_snapshots.version_id = rules.version_id
     where rules.rule_kind = 'prerequisite'
     union
-    select conditions.required_course_id, published_snapshots.item_id
+    select conditions.required_course_id, published_snapshots.code_id
     from public.course_rule_conditions as conditions
     join public.course_rules as rules on rules.id = conditions.course_rule_id
-    join published_snapshots on published_snapshots.snapshot_id = rules.snapshot_id
+    join published_snapshots on published_snapshots.version_id = rules.version_id
     where rules.rule_kind = 'prerequisite'
       and conditions.condition_kind = 'course'
       and conditions.required_course_id is not null
     union
-    select members.referenced_course_id, published_snapshots.item_id
+    select members.referenced_course_id, published_snapshots.code_id
     from public.course_rule_condition_courses as members
     join public.course_rule_conditions as conditions
       on conditions.id = members.condition_id
     join public.course_rules as rules on rules.id = conditions.course_rule_id
-    join published_snapshots on published_snapshots.snapshot_id = rules.snapshot_id
+    join published_snapshots on published_snapshots.version_id = rules.version_id
     where rules.rule_kind = 'prerequisite'
       and members.referenced_course_id is not null
   ),
   upstream as (
     select edges.from_item_id, edges.to_item_id
     from edges
-    join root on root.item_id = edges.to_item_id
+    join root on root.code_id = edges.to_item_id
     union
     select edges.from_item_id, edges.to_item_id
     from edges
@@ -1583,22 +1612,22 @@ as $function$
     union
     select edges.from_item_id, edges.to_item_id
     from edges
-    join root on root.item_id = edges.from_item_id
+    join root on root.code_id = edges.from_item_id
   )
   select
     source_items.code as from_code,
     target_items.code as to_code,
-    source_availability.item_id is not null as from_is_available,
-    target_availability.item_id is not null as to_is_available
+    source_availability.code_id is not null as from_is_available,
+    target_availability.code_id is not null as to_is_available
   from graph_edges
-  join public.catalogue_items as source_items
+  join public.catalogue_codes as source_items
     on source_items.id = graph_edges.from_item_id
-  join public.catalogue_items as target_items
+  join public.catalogue_codes as target_items
     on target_items.id = graph_edges.to_item_id
   left join published_snapshots as source_availability
-    on source_availability.item_id = graph_edges.from_item_id
+    on source_availability.code_id = graph_edges.from_item_id
   left join published_snapshots as target_availability
-    on target_availability.item_id = graph_edges.to_item_id
+    on target_availability.code_id = graph_edges.to_item_id
   order by source_items.code, target_items.code;
 $function$;
 
@@ -1616,25 +1645,25 @@ as $function$
   -- only the published snapshot, so no draft content can be reached.
   with selected as (
     select
-      item_years.published_snapshot_id as snapshot_id,
+      item_years.published_version_id as version_id,
       items.code as course_code,
       academic_years.year as academic_year
-    from public.catalogue_items as items
-    join public.catalogue_item_years as item_years
-      on item_years.item_id = items.id
+    from public.catalogue_codes as items
+    join public.catalogue_records as item_years
+      on item_years.code_id = items.id
      and item_years.archived_at is null
     join public.academic_years
       on academic_years.id = item_years.academic_year_id
      and academic_years.year = p_academic_year
     where items.kind = 'course'
       and items.code = upper(btrim(p_course_code))
-      and item_years.published_snapshot_id is not null
+      and item_years.published_version_id is not null
     limit 1
   )
-  select private.course_snapshot_projection(selected.snapshot_id)
+  select private.course_version_projection(selected.version_id)
     || jsonb_build_object(
       'code', selected.course_code,
-      'snapshotId', selected.snapshot_id,
+      'snapshotId', selected.version_id,
       'prerequisiteEdges', coalesce((
         select jsonb_agg(jsonb_build_object(
           'from', graph.from_code,
@@ -1661,7 +1690,7 @@ returns table (
   is_available boolean,
   course_id bigint,
   course_year_id bigint,
-  published_snapshot_id bigint,
+  published_version_id bigint,
   offering_status text
 )
 language sql
@@ -1671,23 +1700,23 @@ as $function$
   select
     upper(btrim(p_course_code)) as course_code,
     p_academic_year as academic_year,
-    item_years.published_snapshot_id is not null as is_available,
+    item_years.published_version_id is not null as is_available,
     items.id as course_id,
     item_years.id as course_year_id,
-    item_years.published_snapshot_id,
+    item_years.published_version_id,
     details.offering_status
   from (values (true)) as request(single_row)
-  left join public.catalogue_items as items
+  left join public.catalogue_codes as items
     on items.kind = 'course'
    and items.code = upper(btrim(p_course_code))
   left join public.academic_years
     on academic_years.year = p_academic_year
-  left join public.catalogue_item_years as item_years
-    on item_years.item_id = items.id
+  left join public.catalogue_records as item_years
+    on item_years.code_id = items.id
    and item_years.academic_year_id = academic_years.id
    and item_years.archived_at is null
-  left join public.course_snapshot_details as details
-    on details.snapshot_id = item_years.published_snapshot_id;
+  left join public.course_version_details as details
+    on details.version_id = item_years.published_version_id;
 $function$;
 
 -- The course directory lists published snapshots with their identity in one
@@ -1696,10 +1725,10 @@ create view public.published_course_summaries
 with (security_invoker = true)
 as
 select
-  snapshots.id as snapshot_id,
-  items.id as item_id,
+  snapshots.id as version_id,
+  items.id as code_id,
   items.code,
-  item_years.id as item_year_id,
+  item_years.id as record_id,
   item_years.academic_year_id,
   academic_years.year as academic_year,
   details.title,
@@ -1724,13 +1753,13 @@ select
   details.prescribed_texts,
   details.offering_status,
   details.source_updated_at
-from public.catalogue_item_years as item_years
-join public.catalogue_items as items on items.id = item_years.item_id
+from public.catalogue_records as item_years
+join public.catalogue_codes as items on items.id = item_years.code_id
 join public.academic_years on academic_years.id = item_years.academic_year_id
-join public.catalogue_snapshots as snapshots
-  on snapshots.id = item_years.published_snapshot_id
-join public.course_snapshot_details as details
-  on details.snapshot_id = snapshots.id
+join public.catalogue_versions as snapshots
+  on snapshots.id = item_years.published_version_id
+join public.course_version_details as details
+  on details.version_id = snapshots.id
 where item_years.kind = 'course'
   and item_years.archived_at is null;
 
@@ -1745,10 +1774,10 @@ to anon, authenticated;
 
 -- Student writes ---------------------------------------------------------------------
 
-create or replace function public.current_user_course_attempt_snapshot_projections(
-  p_snapshot_ids bigint[]
+create or replace function public.current_user_course_attempt_version_projections(
+  p_version_ids bigint[]
 )
-returns table (snapshot_id bigint, projection jsonb)
+returns table (version_id bigint, projection jsonb)
 language plpgsql
 stable
 security definer
@@ -1760,16 +1789,16 @@ begin
   if user_id is null then
     raise exception 'Authentication is required.' using errcode = '28000';
   end if;
-  if p_snapshot_ids is null then
+  if p_version_ids is null then
     raise exception 'Snapshot IDs are required.' using errcode = '22023';
   end if;
-  if cardinality(p_snapshot_ids) > 200 then
+  if cardinality(p_version_ids) > 200 then
     raise exception 'At most 200 snapshot IDs may be requested.'
       using errcode = '22023';
   end if;
   if exists (
     select 1
-    from unnest(p_snapshot_ids) as requested(requested_snapshot_id)
+    from unnest(p_version_ids) as requested(requested_snapshot_id)
     where requested.requested_snapshot_id is null
   ) then
     raise exception 'Snapshot IDs cannot contain null values.'
@@ -1779,21 +1808,21 @@ begin
   return query
   select
     snapshots.id,
-    private.course_snapshot_projection(snapshots.id)
-  from public.catalogue_snapshots as snapshots
-  where snapshots.id = any(p_snapshot_ids)
+    private.course_version_projection(snapshots.id)
+  from public.catalogue_versions as snapshots
+  where snapshots.id = any(p_version_ids)
     and snapshots.kind = 'course'
     and exists (
       select 1
       from public.course_attempts as attempts
-      where attempts.course_snapshot_id = snapshots.id
+      where attempts.catalogue_version_id = snapshots.id
         and attempts.owner_id = user_id
     )
   order by snapshots.id;
 end;
 $function$;
 
-grant execute on function public.current_user_course_attempt_snapshot_projections(bigint[])
+grant execute on function public.current_user_course_attempt_version_projections(bigint[])
 to authenticated;
 
 create or replace function public.add_current_user_plan_item(
@@ -1810,8 +1839,7 @@ as $function$
 declare
   user_id uuid := (select auth.uid());
   selected_plan_id uuid;
-  selected_course_id bigint;
-  selected_academic_year_id bigint;
+  selected_record_id bigint;
   selected_period_id bigint;
   next_sort_order bigint;
   created_item_id uuid;
@@ -1855,20 +1883,20 @@ begin
       message = 'Save a primary degree plan before adding courses.';
   end if;
 
-  select items.id, academic_years.id
-  into selected_course_id, selected_academic_year_id
-  from public.catalogue_items as items
-  join public.catalogue_item_years as item_years on item_years.item_id = items.id
+  select item_years.id
+  into selected_record_id
+  from public.catalogue_codes as items
+  join public.catalogue_records as item_years on item_years.code_id = items.id
   join public.academic_years
     on academic_years.id = item_years.academic_year_id
   where items.kind = 'course'
     and items.code = upper(btrim(p_course_code))
     and academic_years.year = p_academic_year
     and item_years.archived_at is null
-    and item_years.published_snapshot_id is not null
+    and item_years.published_version_id is not null
   limit 1;
 
-  if selected_course_id is null then
+  if selected_record_id is null then
     raise exception using
       errcode = 'P0002',
       message = 'The selected course has no published snapshot for the planned year.';
@@ -1894,8 +1922,7 @@ begin
   insert into public.plan_items (
     plan_id,
     owner_id,
-    course_id,
-    academic_year_id,
+    catalogue_record_id,
     academic_period_id,
     planned_calendar_year,
     planned_period_code,
@@ -1903,8 +1930,7 @@ begin
   ) values (
     selected_plan_id,
     user_id,
-    selected_course_id,
-    selected_academic_year_id,
+    selected_record_id,
     selected_period_id,
     p_planned_calendar_year,
     period_code,
@@ -1919,6 +1945,123 @@ $function$;
 grant execute on function public.add_current_user_plan_item(text, smallint, smallint, text)
 to authenticated;
 
+create or replace function public.move_current_user_plan_item(
+  p_plan_item_id uuid,
+  p_planned_calendar_year smallint default null,
+  p_planned_period_code text default null,
+  p_before_plan_item_id uuid default null
+)
+returns void
+language plpgsql
+security definer
+set search_path = ''
+as $function$
+declare
+  user_id uuid := (select auth.uid());
+  selected_plan_id uuid;
+  selected_academic_year smallint;
+  selected_period_id bigint;
+  destination_sort_order bigint;
+  period_code text := nullif(upper(btrim(p_planned_period_code)), '');
+begin
+  if user_id is null then
+    raise exception using errcode = '28000', message = 'Authentication is required.';
+  end if;
+
+  if (p_planned_calendar_year is null) <> (period_code is null) then
+    raise exception using
+      errcode = '22023',
+      message = 'Planned year and period must be supplied together.';
+  end if;
+
+  select plan_items.plan_id, academic_years.year
+  into selected_plan_id, selected_academic_year
+  from public.plan_items
+  join public.catalogue_records
+    on catalogue_records.id = plan_items.catalogue_record_id
+  join public.academic_years
+    on academic_years.id = catalogue_records.academic_year_id
+  where plan_items.id = p_plan_item_id
+    and plan_items.owner_id = user_id
+  for update of plan_items;
+
+  if selected_plan_id is null then
+    raise exception using errcode = 'P0002', message = 'Plan item not found.';
+  end if;
+
+  if p_planned_calendar_year is not null
+    and p_planned_calendar_year <> selected_academic_year
+  then
+    raise exception using
+      errcode = '22023',
+      message = 'A planned course cannot be moved outside its selected academic year.';
+  end if;
+
+  perform 1
+  from public.plan_items
+  where plan_items.plan_id = selected_plan_id
+    and plan_items.owner_id = user_id
+  for update of plan_items;
+
+  if p_planned_calendar_year is not null then
+    select academic_periods.id
+    into selected_period_id
+    from public.academic_periods
+    where academic_periods.calendar_year = p_planned_calendar_year
+      and academic_periods.code = period_code
+    limit 1;
+  end if;
+
+  if p_before_plan_item_id is not null then
+    select plan_items.sort_order
+    into destination_sort_order
+    from public.plan_items
+    where plan_items.id = p_before_plan_item_id
+      and plan_items.owner_id = user_id
+      and plan_items.plan_id = selected_plan_id
+      and plan_items.id <> p_plan_item_id
+      and plan_items.planned_calendar_year is not distinct from
+        p_planned_calendar_year
+      and plan_items.planned_period_code is not distinct from period_code;
+
+    if destination_sort_order is null then
+      raise exception using
+        errcode = 'P0002',
+        message = 'The requested destination item was not found.';
+    end if;
+
+    update public.plan_items
+    set sort_order = plan_items.sort_order + 1
+    where plan_items.plan_id = selected_plan_id
+      and plan_items.owner_id = user_id
+      and plan_items.id <> p_plan_item_id
+      and plan_items.planned_calendar_year is not distinct from
+        p_planned_calendar_year
+      and plan_items.planned_period_code is not distinct from period_code
+      and plan_items.sort_order >= destination_sort_order;
+  else
+    select coalesce(max(plan_items.sort_order), -1) + 1
+    into destination_sort_order
+    from public.plan_items
+    where plan_items.plan_id = selected_plan_id
+      and plan_items.owner_id = user_id
+      and plan_items.id <> p_plan_item_id
+      and plan_items.planned_calendar_year is not distinct from
+        p_planned_calendar_year
+      and plan_items.planned_period_code is not distinct from period_code;
+  end if;
+
+  update public.plan_items
+  set
+    academic_period_id = selected_period_id,
+    planned_calendar_year = p_planned_calendar_year,
+    planned_period_code = period_code,
+    sort_order = destination_sort_order
+  where plan_items.id = p_plan_item_id
+    and plan_items.owner_id = user_id;
+end;
+$function$;
+
 create or replace function public.record_current_user_course_attempt(
   p_plan_item_id uuid,
   p_attempt_status text,
@@ -1932,8 +2075,7 @@ set search_path = ''
 as $function$
 declare
   user_id uuid := (select auth.uid());
-  selected_course_id bigint;
-  selected_academic_year_id bigint;
+  selected_record_id bigint;
   selected_calendar_year smallint;
   selected_period_code text;
   selected_period_id bigint;
@@ -1981,13 +2123,11 @@ begin
   end;
 
   select
-    plan_items.course_id,
-    plan_items.academic_year_id,
+    plan_items.catalogue_record_id,
     plan_items.planned_calendar_year,
     plan_items.planned_period_code
   into
-    selected_course_id,
-    selected_academic_year_id,
+    selected_record_id,
     selected_calendar_year,
     selected_period_code
   from public.plan_items
@@ -1997,7 +2137,7 @@ begin
     and plans.owner_id = user_id
   for update of plan_items;
 
-  if selected_course_id is null then
+  if selected_record_id is null then
     raise exception using errcode = 'P0002', message = 'Plan item not found.';
   end if;
 
@@ -2021,15 +2161,17 @@ begin
 
   select
     course_attempts.id,
-    course_attempts.course_snapshot_id,
+    course_attempts.catalogue_version_id,
     course_attempts.units_attempted
   into
     existing_attempt_id,
     existing_snapshot_id,
     existing_attempted_units
   from public.course_attempts
+  join public.catalogue_versions as versions
+    on versions.id = course_attempts.catalogue_version_id
   where course_attempts.owner_id = user_id
-    and course_attempts.course_id = selected_course_id
+    and versions.record_id = selected_record_id
     and course_attempts.academic_period_id = selected_period_id
   for update;
 
@@ -2046,7 +2188,7 @@ begin
     attempted_units := existing_attempted_units;
   else
     select
-      item_years.published_snapshot_id,
+      item_years.published_version_id,
       details.unit_value_kind,
       details.units,
       details.minimum_units,
@@ -2057,11 +2199,10 @@ begin
       selected_fixed_units,
       selected_minimum_units,
       selected_maximum_units
-    from public.catalogue_item_years as item_years
-    join public.course_snapshot_details as details
-      on details.snapshot_id = item_years.published_snapshot_id
-    where item_years.item_id = selected_course_id
-      and item_years.academic_year_id = selected_academic_year_id
+    from public.catalogue_records as item_years
+    join public.course_version_details as details
+      on details.version_id = item_years.published_version_id
+    where item_years.id = selected_record_id
       and item_years.archived_at is null;
 
     if selected_snapshot_id is null then
@@ -2118,7 +2259,7 @@ begin
         if not exists (
           select 1
           from public.course_unit_options
-          where course_unit_options.snapshot_id = selected_snapshot_id
+          where course_unit_options.version_id = selected_snapshot_id
             and course_unit_options.units = p_units_attempted
         ) then
           raise exception using
@@ -2137,8 +2278,7 @@ begin
 
   insert into public.course_attempts (
     owner_id,
-    course_id,
-    course_snapshot_id,
+    catalogue_version_id,
     academic_period_id,
     status,
     mark,
@@ -2148,7 +2288,6 @@ begin
     source
   ) values (
     user_id,
-    selected_course_id,
     selected_snapshot_id,
     selected_period_id,
     p_attempt_status,
@@ -2158,7 +2297,7 @@ begin
     case when p_attempt_status = 'completed' then attempted_units else 0 end,
     'user_entered'
   )
-  on conflict (owner_id, course_id, academic_period_id) do update
+  on conflict (owner_id, catalogue_version_id, academic_period_id) do update
   set
     status = excluded.status,
     mark = excluded.mark,
@@ -2314,7 +2453,7 @@ declare
   selected_programme_units numeric;
   selected_programme_duration_years numeric;
   selected_structure record;
-  selected_structure_year_id bigint;
+  selected_structure_record_id bigint;
   inserted_structure_count integer;
   expected_structure_count integer;
 begin
@@ -2374,7 +2513,7 @@ begin
 
   select
     item_years.id,
-    item_years.published_snapshot_id,
+    item_years.published_version_id,
     details.units,
     details.duration_years
   into
@@ -2382,15 +2521,15 @@ begin
     selected_programme_snapshot_id,
     selected_programme_units,
     selected_programme_duration_years
-  from public.catalogue_item_years as item_years
-  join public.catalogue_items as items on items.id = item_years.item_id
-  join public.structure_snapshot_details as details
-    on details.snapshot_id = item_years.published_snapshot_id
+  from public.catalogue_records as item_years
+  join public.catalogue_codes as items on items.id = item_years.code_id
+  join public.structure_version_details as details
+    on details.version_id = item_years.published_version_id
   where items.code = upper(btrim(p_programme_code))
     and items.kind = 'programme'
     and item_years.academic_year_id = selected_academic_year_id
     and item_years.archived_at is null
-    and item_years.published_snapshot_id is not null
+    and item_years.published_version_id is not null
   limit 1;
   if selected_programme_year_id is null then
     raise exception using
@@ -2423,20 +2562,20 @@ begin
     from unnest(p_specialisation_codes) with ordinality as requested(code, position)
     order by position
   loop
-    selected_structure_year_id := null;
+    selected_structure_record_id := null;
 
     select item_years.id
-    into selected_structure_year_id
-    from public.catalogue_item_years as item_years
-    join public.catalogue_items as items on items.id = item_years.item_id
+    into selected_structure_record_id
+    from public.catalogue_records as item_years
+    join public.catalogue_codes as items on items.id = item_years.code_id
     where items.code = selected_structure.code
       and items.kind = selected_structure.role
       and item_years.academic_year_id = selected_academic_year_id
       and item_years.archived_at is null
-      and item_years.published_snapshot_id is not null
+      and item_years.published_version_id is not null
     limit 1;
 
-    if selected_structure_year_id is null then
+    if selected_structure_record_id is null then
       raise exception using
         errcode = 'P0002',
         message = format(
@@ -2448,7 +2587,7 @@ begin
     if not exists (
       select 1
       from public.academic_structure_snapshot_relationships as relationships
-      where relationships.snapshot_id = selected_programme_snapshot_id
+      where relationships.version_id = selected_programme_snapshot_id
         and relationships.relationship_kind in ('required', 'option')
         and relationships.target_kind = selected_structure.role
         and relationships.target_code = selected_structure.code
@@ -2457,8 +2596,8 @@ begin
       from public.academic_structure_requirement_options as options
       join public.academic_structure_requirement_conditions as conditions
         on conditions.id = options.requirement_condition_id
-       and conditions.snapshot_id = options.snapshot_id
-      where options.snapshot_id = selected_programme_snapshot_id
+       and conditions.version_id = options.version_id
+      where options.version_id = selected_programme_snapshot_id
         and conditions.condition_kind = 'structure_list'
         and conditions.structure_kind = selected_structure.role
         and options.option_kind = 'structure'
@@ -2522,18 +2661,17 @@ begin
   returning id into selected_plan_id;
 
   insert into public.plan_structures (
-    plan_id, owner_id, academic_year_id, structure_year_id, role, position
+    plan_id, owner_id, catalogue_record_id, role, position
   ) values (
-    selected_plan_id, user_id, selected_academic_year_id, selected_programme_year_id, 'programme', 0
+    selected_plan_id, user_id, selected_programme_year_id, 'programme', 0
   );
 
   insert into public.plan_structures (
-    plan_id, owner_id, academic_year_id, structure_year_id, role, position
+    plan_id, owner_id, catalogue_record_id, role, position
   )
   select
     selected_plan_id,
     user_id,
-    selected_academic_year_id,
     item_years.id,
     requested.role,
     requested.position
@@ -2555,14 +2693,14 @@ begin
         + cardinality(p_minor_codes)
     from unnest(p_specialisation_codes) with ordinality as specialisations(code, position)
   ) as requested
-  join public.catalogue_items as items
+  join public.catalogue_codes as items
     on items.code = requested.code
    and items.kind = requested.role
-  join public.catalogue_item_years as item_years
-    on item_years.item_id = items.id
+  join public.catalogue_records as item_years
+    on item_years.code_id = items.id
    and item_years.academic_year_id = selected_academic_year_id
    and item_years.archived_at is null
-   and item_years.published_snapshot_id is not null
+   and item_years.published_version_id is not null
   order by requested.position;
 
   get diagnostics inserted_structure_count = row_count;
@@ -2587,7 +2725,7 @@ grant execute on function public.save_current_user_primary_plan(
 
 -- Recreating a function restores the default public execute grant, so the
 -- student write functions are re-restricted to authenticated callers.
-revoke all on function public.current_user_course_attempt_snapshot_projections(bigint[])
+revoke all on function public.current_user_course_attempt_version_projections(bigint[])
 from public, anon;
 revoke all on function public.add_current_user_plan_item(text, smallint, smallint, text)
 from public, anon;
@@ -2602,11 +2740,11 @@ revoke all on function public.published_course_detail(text, smallint) from publi
 revoke all on function public.published_course_requisite_graph(text, smallint) from public;
 revoke all on function public.published_course_availability(text, smallint) from public;
 
-comment on table public.catalogue_items is
+comment on table public.catalogue_codes is
   'Permanent identity for courses, programmes, majors, minors and specialisations.';
-comment on table public.catalogue_item_years is
+comment on table public.catalogue_records is
   'One row per catalogue item and academic year, holding the draft and published snapshot pointers.';
-comment on table public.catalogue_snapshots is
+comment on table public.catalogue_versions is
   'Immutable versions of a catalogue item year. Kind-specific content lives in the details and child tables.';
 comment on table public.catalogue_publications is
   'Ledger of every published pointer change for a catalogue item year.';
diff --git a/supabase/migrations/20260918150000_requirements.sql b/supabase/migrations/20260918150000_requirements.sql
index 12bb4ccf..b582bf48 100644
--- a/supabase/migrations/20260918150000_requirements.sql
+++ b/supabase/migrations/20260918150000_requirements.sql
@@ -13,7 +13,7 @@ drop function public.published_course_requisite_graph(text, smallint);
 
 create table public.requirement_rules (
   id bigint generated always as identity primary key,
-  snapshot_id bigint not null,
+  version_id bigint not null,
   academic_year_id bigint not null,
   source_page_id bigint,
   rule_kind text not null,
@@ -24,11 +24,11 @@ create table public.requirement_rules (
   confidence numeric(5, 4) not null default 1,
   position integer not null default 0,
   created_at timestamptz not null default now(),
-  constraint requirement_rules_snapshot_kind_unique unique (snapshot_id, rule_kind),
-  constraint requirement_rules_id_snapshot_unique unique (id, snapshot_id),
+  constraint requirement_rules_snapshot_kind_unique unique (version_id, rule_kind),
+  constraint requirement_rules_id_snapshot_unique unique (id, version_id),
   constraint requirement_rules_snapshot_fkey
-    foreign key (snapshot_id, academic_year_id)
-    references public.catalogue_snapshots (id, academic_year_id) on delete cascade,
+    foreign key (version_id, academic_year_id)
+    references public.catalogue_versions (id, academic_year_id) on delete cascade,
   constraint requirement_rules_source_page_fkey
     foreign key (source_page_id, academic_year_id)
     references public.catalogue_source_pages (id, academic_year_id),
@@ -47,14 +47,14 @@ create table public.requirement_rules (
   constraint requirement_rules_position_check check (position >= 0)
 );
 
-create index requirement_rules_snapshot_idx on public.requirement_rules (snapshot_id);
+create index requirement_rules_snapshot_idx on public.requirement_rules (version_id);
 
 -- label carries structure headings such as "Major" or "Electives"; unit bounds
 -- express "24 to 48 units from" on structure groups.
 create table public.requirement_groups (
   id bigint generated always as identity primary key,
   rule_id bigint not null,
-  snapshot_id bigint not null,
+  version_id bigint not null,
   parent_group_id bigint,
   group_key text not null,
   label text,
@@ -66,12 +66,12 @@ create table public.requirement_groups (
   source_text text,
   source_locator text,
   position integer not null default 0,
-  constraint requirement_groups_key_unique unique (snapshot_id, group_key),
+  constraint requirement_groups_key_unique unique (version_id, group_key),
   constraint requirement_groups_id_rule_unique unique (id, rule_id),
-  constraint requirement_groups_id_snapshot_unique unique (id, snapshot_id),
+  constraint requirement_groups_id_snapshot_unique unique (id, version_id),
   constraint requirement_groups_rule_fkey
-    foreign key (rule_id, snapshot_id)
-    references public.requirement_rules (id, snapshot_id) on delete cascade,
+    foreign key (rule_id, version_id)
+    references public.requirement_rules (id, version_id) on delete cascade,
   constraint requirement_groups_parent_fkey
     foreign key (parent_group_id, rule_id)
     references public.requirement_groups (id, rule_id) on delete cascade,
@@ -100,12 +100,12 @@ create index requirement_groups_rule_idx on public.requirement_groups (rule_id,
 create table public.requirement_conditions (
   id bigint generated always as identity primary key,
   rule_id bigint not null,
-  snapshot_id bigint not null,
+  version_id bigint not null,
   group_id bigint not null,
   condition_key text not null,
   position integer not null default 0,
   condition_kind text not null,
-  item_id bigint,
+  code_id bigint,
   structure_kind text,
   requirement_mode text,
   minimum_mark numeric(5, 2),
@@ -125,17 +125,17 @@ create table public.requirement_conditions (
   source_locator text,
   review_state text not null default 'automatic',
   confidence numeric(5, 4) not null default 1,
-  constraint requirement_conditions_key_unique unique (snapshot_id, condition_key),
+  constraint requirement_conditions_key_unique unique (version_id, condition_key),
   constraint requirement_conditions_group_position_unique unique (group_id, position),
-  constraint requirement_conditions_id_snapshot_unique unique (id, snapshot_id),
+  constraint requirement_conditions_id_snapshot_unique unique (id, version_id),
   constraint requirement_conditions_rule_fkey
-    foreign key (rule_id, snapshot_id)
-    references public.requirement_rules (id, snapshot_id) on delete cascade,
+    foreign key (rule_id, version_id)
+    references public.requirement_rules (id, version_id) on delete cascade,
   constraint requirement_conditions_group_fkey
     foreign key (group_id, rule_id)
     references public.requirement_groups (id, rule_id) on delete cascade,
   constraint requirement_conditions_item_fkey
-    foreign key (item_id) references public.catalogue_items (id),
+    foreign key (code_id) references public.catalogue_codes (id),
   constraint requirement_conditions_kind_check check (
     condition_kind in (
       'course', 'incompatible', 'structure', 'structure_set', 'course_set_units',
@@ -153,9 +153,9 @@ create table public.requirement_conditions (
   ),
   constraint requirement_conditions_typed_value_check check (
     case condition_kind
-      when 'course' then item_id is not null
-      when 'incompatible' then item_id is not null
-      when 'structure' then item_id is not null or free_text is not null
+      when 'course' then code_id is not null
+      when 'incompatible' then code_id is not null
+      when 'structure' then code_id is not null or free_text is not null
       when 'structure_set' then structure_kind is not null
       when 'course_set_units' then minimum_units is not null or minimum_count is not null
       when 'units_total' then minimum_units is not null
@@ -208,28 +208,28 @@ create table public.requirement_conditions (
 );
 
 create index requirement_conditions_rule_idx on public.requirement_conditions (rule_id);
-create index requirement_conditions_item_idx on public.requirement_conditions (item_id)
-  where item_id is not null;
+create index requirement_conditions_item_idx on public.requirement_conditions (code_id)
+  where code_id is not null;
 
--- Members of set-based conditions. item_id is null when the code has no
+-- Members of set-based conditions. code_id is null when the code has no
 -- catalogue identity yet; code is always kept as the source wrote it.
 create table public.requirement_condition_options (
   id bigint generated always as identity primary key,
   condition_id bigint not null,
-  snapshot_id bigint not null,
+  version_id bigint not null,
   position integer not null,
   kind text not null,
   code text not null,
-  item_id bigint,
+  code_id bigint,
   title text,
   source_text text,
   constraint requirement_condition_options_code_unique unique (condition_id, code),
   constraint requirement_condition_options_position_unique unique (condition_id, position),
   constraint requirement_condition_options_condition_fkey
-    foreign key (condition_id, snapshot_id)
-    references public.requirement_conditions (id, snapshot_id) on delete cascade,
+    foreign key (condition_id, version_id)
+    references public.requirement_conditions (id, version_id) on delete cascade,
   constraint requirement_condition_options_item_fkey
-    foreign key (item_id, kind) references public.catalogue_items (id, kind),
+    foreign key (code_id, kind) references public.catalogue_codes (id, kind),
   constraint requirement_condition_options_kind_check check (
     kind in ('course', 'programme', 'major', 'minor', 'specialisation')
   ),
@@ -243,23 +243,23 @@ create table public.requirement_condition_options (
 );
 
 create index requirement_condition_options_item_idx
-  on public.requirement_condition_options (item_id) where item_id is not null;
+  on public.requirement_condition_options (code_id) where code_id is not null;
 
 -- Flattened item references per rule for graph queries and placeholder access.
 create table public.requirement_item_references (
   id bigint generated always as identity primary key,
   rule_id bigint not null,
-  snapshot_id bigint not null,
-  item_id bigint not null,
+  version_id bigint not null,
+  code_id bigint not null,
   source_text text not null,
   confidence numeric(5, 4) not null default 0,
   review_state text not null default 'review',
-  constraint requirement_item_references_unique unique (rule_id, item_id),
+  constraint requirement_item_references_unique unique (rule_id, code_id),
   constraint requirement_item_references_rule_fkey
-    foreign key (rule_id, snapshot_id)
-    references public.requirement_rules (id, snapshot_id) on delete cascade,
+    foreign key (rule_id, version_id)
+    references public.requirement_rules (id, version_id) on delete cascade,
   constraint requirement_item_references_item_fkey
-    foreign key (item_id) references public.catalogue_items (id),
+    foreign key (code_id) references public.catalogue_codes (id),
   constraint requirement_item_references_source_text_check check (btrim(source_text) <> ''),
   constraint requirement_item_references_confidence_check check (confidence between 0 and 1),
   constraint requirement_item_references_review_state_check check (
@@ -268,7 +268,7 @@ create table public.requirement_item_references (
 );
 
 create index requirement_item_references_item_idx
-  on public.requirement_item_references (item_id);
+  on public.requirement_item_references (code_id);
 
 -- Integrity ---------------------------------------------------------------------------
 
@@ -364,9 +364,9 @@ begin
       using errcode = '23503';
   end if;
 
-  if new.item_id is not null and not exists (
-    select 1 from public.catalogue_items
-    where id = new.item_id and kind = new.kind and code = new.code
+  if new.code_id is not null and not exists (
+    select 1 from public.catalogue_codes
+    where id = new.code_id and kind = new.kind and code = new.code
   ) then
     raise exception 'requirement option item does not match its code'
       using errcode = '23503';
@@ -402,7 +402,7 @@ begin
     execute format('alter table public.%I enable row level security', child);
     execute format(
       'create policy %I on public.%I for select to anon, authenticated '
-      'using ((select private.can_read_snapshot(snapshot_id)))',
+      'using ((select private.can_read_version(version_id)))',
       child || '_read', child
     );
     execute format(
@@ -444,45 +444,50 @@ as $function$
   select private.can_manage_catalogue()
     or exists (
       select 1
-      from public.catalogue_item_years as item_years
-      where item_years.item_id = p_item_id
-        and item_years.published_snapshot_id is not null
+      from public.catalogue_records as item_years
+      where item_years.code_id = p_item_id
+        and item_years.published_version_id is not null
         and item_years.archived_at is null
     )
     or exists (
       select 1
       from public.requirement_conditions as conditions
-      where conditions.item_id = p_item_id
-        and private.is_published_snapshot(conditions.snapshot_id)
+      where conditions.code_id = p_item_id
+        and private.is_published_version(conditions.version_id)
     )
     or exists (
       select 1
       from public.requirement_condition_options as options
-      where options.item_id = p_item_id
-        and private.is_published_snapshot(options.snapshot_id)
+      where options.code_id = p_item_id
+        and private.is_published_version(options.version_id)
     )
     or exists (
       select 1
       from public.requirement_item_references as item_references
-      where item_references.item_id = p_item_id
-        and private.is_published_snapshot(item_references.snapshot_id)
+      where item_references.code_id = p_item_id
+        and private.is_published_version(item_references.version_id)
     )
     or exists (
       select 1
       from public.course_related_courses as related
       where related.related_course_id = p_item_id
-        and private.is_published_snapshot(related.snapshot_id)
+        and private.is_published_version(related.version_id)
     )
     or exists (
       select 1
       from public.course_attempts as attempts
-      where attempts.course_id = p_item_id
+      join public.catalogue_versions as versions
+        on versions.id = attempts.catalogue_version_id
+      join public.catalogue_records as records on records.id = versions.record_id
+      where records.code_id = p_item_id
         and attempts.owner_id = (select auth.uid())
     )
     or exists (
       select 1
       from public.plan_items
-      where plan_items.course_id = p_item_id
+      join public.catalogue_records as records
+        on records.id = plan_items.catalogue_record_id
+      where records.code_id = p_item_id
         and plan_items.owner_id = (select auth.uid())
     );
 $function$;
@@ -490,7 +495,7 @@ $function$;
 -- Projections ---------------------------------------------------------------------------
 
 -- The requirement part of a snapshot projection, shared by every kind.
-create or replace function private.requirement_projection(p_snapshot_id bigint)
+create or replace function private.requirement_projection(p_version_id bigint)
 returns jsonb
 language sql
 stable
@@ -510,7 +515,7 @@ as $function$
         when 'incompatibility' then 3 when 'permission' then 4
         when 'assumed_knowledge' then 5 else 6 end)
       from public.requirement_rules as rules
-      where rules.snapshot_id = p_snapshot_id
+      where rules.version_id = p_version_id
     ), '[]'::jsonb),
     'ruleGroups', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -529,7 +534,7 @@ as $function$
       from public.requirement_groups as groups
       join public.requirement_rules as rules on rules.id = groups.rule_id
       left join public.requirement_groups as parents on parents.id = groups.parent_group_id
-      where groups.snapshot_id = p_snapshot_id
+      where groups.version_id = p_version_id
     ), '[]'::jsonb),
     'ruleConditions', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -566,8 +571,8 @@ as $function$
       from public.requirement_conditions as conditions
       join public.requirement_rules as rules on rules.id = conditions.rule_id
       join public.requirement_groups as groups on groups.id = conditions.group_id
-      left join public.catalogue_items as items on items.id = conditions.item_id
-      where conditions.snapshot_id = p_snapshot_id
+      left join public.catalogue_codes as items on items.id = conditions.code_id
+      where conditions.version_id = p_version_id
     ), '[]'::jsonb),
     'ruleConditionCourses', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -580,7 +585,7 @@ as $function$
       ) order by conditions.id, options.position)
       from public.requirement_condition_options as options
       join public.requirement_conditions as conditions on conditions.id = options.condition_id
-      where options.snapshot_id = p_snapshot_id
+      where options.version_id = p_version_id
     ), '[]'::jsonb),
     'ruleCourseReferences', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -592,8 +597,8 @@ as $function$
       ) order by rules.rule_kind, items.code)
       from public.requirement_item_references as item_references
       join public.requirement_rules as rules on rules.id = item_references.rule_id
-      join public.catalogue_items as items on items.id = item_references.item_id
-      where item_references.snapshot_id = p_snapshot_id
+      join public.catalogue_codes as items on items.id = item_references.code_id
+      where item_references.version_id = p_version_id
     ), '[]'::jsonb),
     'prerequisiteCodes', coalesce((
       select jsonb_agg(codes.code order by codes.code)
@@ -601,14 +606,14 @@ as $function$
         select items.code
         from public.requirement_item_references as item_references
         join public.requirement_rules as rules on rules.id = item_references.rule_id
-        join public.catalogue_items as items on items.id = item_references.item_id
-        where rules.snapshot_id = p_snapshot_id and rules.rule_kind = 'prerequisite'
+        join public.catalogue_codes as items on items.id = item_references.code_id
+        where rules.version_id = p_version_id and rules.rule_kind = 'prerequisite'
         union
         select items.code
         from public.requirement_conditions as conditions
         join public.requirement_rules as rules on rules.id = conditions.rule_id
-        join public.catalogue_items as items on items.id = conditions.item_id
-        where rules.snapshot_id = p_snapshot_id
+        join public.catalogue_codes as items on items.id = conditions.code_id
+        where rules.version_id = p_version_id
           and rules.rule_kind = 'prerequisite'
           and conditions.condition_kind = 'course'
         union
@@ -616,7 +621,7 @@ as $function$
         from public.requirement_condition_options as options
         join public.requirement_conditions as conditions on conditions.id = options.condition_id
         join public.requirement_rules as rules on rules.id = conditions.rule_id
-        where rules.snapshot_id = p_snapshot_id
+        where rules.version_id = p_version_id
           and rules.rule_kind = 'prerequisite'
           and options.kind = 'course'
       ) as codes
@@ -626,7 +631,7 @@ $function$;
 
 revoke all on function private.requirement_projection(bigint) from public, anon, authenticated;
 
-create or replace function private.course_snapshot_projection(p_snapshot_id bigint)
+create or replace function private.course_version_projection(p_version_id bigint)
 returns jsonb
 language sql
 stable
@@ -635,7 +640,7 @@ as $function$
   with selected_snapshot as (
     select
       snapshots.id,
-      snapshots.item_year_id,
+      snapshots.record_id,
       snapshots.academic_year_id,
       snapshots.origin,
       snapshots.source_page_id,
@@ -644,12 +649,12 @@ as $function$
       details.*,
       items.code as course_code,
       academic_years.year as academic_year
-    from public.catalogue_snapshots as snapshots
-    join public.course_snapshot_details as details on details.snapshot_id = snapshots.id
-    join public.catalogue_item_years as item_years on item_years.id = snapshots.item_year_id
-    join public.catalogue_items as items on items.id = item_years.item_id
+    from public.catalogue_versions as snapshots
+    join public.course_version_details as details on details.version_id = snapshots.id
+    join public.catalogue_records as item_years on item_years.id = snapshots.record_id
+    join public.catalogue_codes as items on items.id = item_years.code_id
     join public.academic_years on academic_years.id = snapshots.academic_year_id
-    where snapshots.id = p_snapshot_id
+    where snapshots.id = p_version_id
   )
   select jsonb_build_object(
     'courseCode', snapshot.course_code,
@@ -684,7 +689,7 @@ as $function$
         'position', options.position, 'units', options.units,
         'label', options.label, 'sourceText', options.source_text
       ) order by options.position)
-      from public.course_unit_options as options where options.snapshot_id = p_snapshot_id
+      from public.course_unit_options as options where options.version_id = p_version_id
     ), '[]'::jsonb),
     'fees', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -693,19 +698,19 @@ as $function$
         'basis', fees.basis, 'studentContributionBand', fees.student_contribution_band,
         'sourceLabel', fees.source_label, 'sourceText', fees.source_text
       ) order by fees.position)
-      from public.course_fees as fees where fees.snapshot_id = p_snapshot_id
+      from public.course_fees as fees where fees.version_id = p_version_id
     ), '[]'::jsonb),
     'areasOfInterest', coalesce((
       select jsonb_agg(jsonb_build_object('position', areas.position, 'name', areas.name)
         order by areas.position)
-      from public.course_areas_of_interest as areas where areas.snapshot_id = p_snapshot_id
+      from public.course_areas_of_interest as areas where areas.version_id = p_version_id
     ), '[]'::jsonb),
     'attributes', coalesce((
       select jsonb_agg(jsonb_build_object(
         'position', attributes.position, 'attributeKind', attributes.attribute_kind,
         'value', attributes.value, 'sourceText', attributes.source_text
       ) order by attributes.position)
-      from public.course_attributes as attributes where attributes.snapshot_id = p_snapshot_id
+      from public.course_attributes as attributes where attributes.version_id = p_version_id
     ), '[]'::jsonb),
     'relatedCourses', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -713,11 +718,11 @@ as $function$
         'sourceCourseCode', related.source_course_code,
         'sourceCourseTitle', related.source_course_title, 'sourceText', related.source_text
       ) order by related.position)
-      from public.course_related_courses as related where related.snapshot_id = p_snapshot_id
+      from public.course_related_courses as related where related.version_id = p_version_id
     ), '[]'::jsonb),
     'courseOffering', (
       select jsonb_build_object('deliveryMode', offerings.delivery_mode, 'location', offerings.location)
-      from public.course_offerings as offerings where offerings.snapshot_id = p_snapshot_id
+      from public.course_offerings as offerings where offerings.version_id = p_version_id
     ),
     'offeringSessions', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -730,19 +735,19 @@ as $function$
         'location', sessions.location, 'classSummaryUrl', sessions.class_summary_url,
         'sourceText', sessions.source_text
       ) order by sessions.position)
-      from public.offering_sessions as sessions where sessions.snapshot_id = p_snapshot_id
+      from public.offering_sessions as sessions where sessions.version_id = p_version_id
     ), '[]'::jsonb),
     'learningOutcomes', coalesce((
       select jsonb_agg(jsonb_build_object('position', outcomes.position, 'body', outcomes.body)
         order by outcomes.position)
-      from public.course_learning_outcomes as outcomes where outcomes.snapshot_id = p_snapshot_id
+      from public.course_learning_outcomes as outcomes where outcomes.version_id = p_version_id
     ), '[]'::jsonb),
     'assessmentItems', coalesce((
       select jsonb_agg(jsonb_build_object(
         'position', items.position, 'title', items.title, 'weight', items.weight,
         'hurdle', items.hurdle, 'dueText', items.due_text, 'sourceText', items.source_text
       ) order by items.position)
-      from public.course_assessment_items as items where items.snapshot_id = p_snapshot_id
+      from public.course_assessment_items as items where items.version_id = p_version_id
     ), '[]'::jsonb),
     'assessmentOutcomes', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -751,13 +756,13 @@ as $function$
       from public.course_assessment_outcomes as links
       join public.course_assessment_items as items on items.id = links.assessment_item_id
       join public.course_learning_outcomes as outcomes on outcomes.id = links.learning_outcome_id
-      where links.snapshot_id = p_snapshot_id
+      where links.version_id = p_version_id
     ), '[]'::jsonb),
     'sourcePageId', snapshot.source_page_id,
     'sourceUpdatedAt', snapshot.source_updated_at,
     'createdAt', snapshot.created_at,
     'sealedAt', snapshot.sealed_at
-  ) || private.requirement_projection(p_snapshot_id)
+  ) || private.requirement_projection(p_version_id)
   from selected_snapshot as snapshot;
 $function$;
 
@@ -778,49 +783,49 @@ set search_path = ''
 as $function$
   with recursive
   published_snapshots as (
-    select item_years.item_id, item_years.published_snapshot_id as snapshot_id
-    from public.catalogue_item_years as item_years
+    select item_years.code_id, item_years.published_version_id as version_id
+    from public.catalogue_records as item_years
     join public.academic_years
       on academic_years.id = item_years.academic_year_id
      and academic_years.year = p_academic_year
     where item_years.kind = 'course'
       and item_years.archived_at is null
-      and item_years.published_snapshot_id is not null
+      and item_years.published_version_id is not null
   ),
   root as (
-    select published_snapshots.item_id
+    select published_snapshots.code_id
     from published_snapshots
-    join public.catalogue_items as items on items.id = published_snapshots.item_id
+    join public.catalogue_codes as items on items.id = published_snapshots.code_id
     where items.code = upper(btrim(p_course_code))
     limit 1
   ),
   edges as (
-    select item_references.item_id as from_item_id, published_snapshots.item_id as to_item_id
+    select item_references.code_id as from_item_id, published_snapshots.code_id as to_item_id
     from public.requirement_item_references as item_references
     join public.requirement_rules as rules on rules.id = item_references.rule_id
-    join published_snapshots on published_snapshots.snapshot_id = rules.snapshot_id
+    join published_snapshots on published_snapshots.version_id = rules.version_id
     where rules.rule_kind = 'prerequisite'
     union
-    select conditions.item_id, published_snapshots.item_id
+    select conditions.code_id, published_snapshots.code_id
     from public.requirement_conditions as conditions
     join public.requirement_rules as rules on rules.id = conditions.rule_id
-    join published_snapshots on published_snapshots.snapshot_id = rules.snapshot_id
+    join published_snapshots on published_snapshots.version_id = rules.version_id
     where rules.rule_kind = 'prerequisite'
       and conditions.condition_kind = 'course'
-      and conditions.item_id is not null
+      and conditions.code_id is not null
     union
-    select options.item_id, published_snapshots.item_id
+    select options.code_id, published_snapshots.code_id
     from public.requirement_condition_options as options
     join public.requirement_conditions as conditions on conditions.id = options.condition_id
     join public.requirement_rules as rules on rules.id = conditions.rule_id
-    join published_snapshots on published_snapshots.snapshot_id = rules.snapshot_id
+    join published_snapshots on published_snapshots.version_id = rules.version_id
     where rules.rule_kind = 'prerequisite'
       and options.kind = 'course'
-      and options.item_id is not null
+      and options.code_id is not null
   ),
   upstream as (
     select edges.from_item_id, edges.to_item_id from edges
-    join root on root.item_id = edges.to_item_id
+    join root on root.code_id = edges.to_item_id
     union
     select edges.from_item_id, edges.to_item_id from edges
     join upstream on upstream.from_item_id = edges.to_item_id
@@ -829,20 +834,20 @@ as $function$
     select upstream.from_item_id, upstream.to_item_id from upstream
     union
     select edges.from_item_id, edges.to_item_id from edges
-    join root on root.item_id = edges.from_item_id
+    join root on root.code_id = edges.from_item_id
   )
   select
     source_items.code as from_code,
     target_items.code as to_code,
-    source_availability.item_id is not null as from_is_available,
-    target_availability.item_id is not null as to_is_available
+    source_availability.code_id is not null as from_is_available,
+    target_availability.code_id is not null as to_is_available
   from graph_edges
-  join public.catalogue_items as source_items on source_items.id = graph_edges.from_item_id
-  join public.catalogue_items as target_items on target_items.id = graph_edges.to_item_id
+  join public.catalogue_codes as source_items on source_items.id = graph_edges.from_item_id
+  join public.catalogue_codes as target_items on target_items.id = graph_edges.to_item_id
   left join published_snapshots as source_availability
-    on source_availability.item_id = graph_edges.from_item_id
+    on source_availability.code_id = graph_edges.from_item_id
   left join published_snapshots as target_availability
-    on target_availability.item_id = graph_edges.to_item_id
+    on target_availability.code_id = graph_edges.to_item_id
   order by source_items.code, target_items.code;
 $function$;
 
@@ -861,25 +866,25 @@ set search_path = ''
 as $function$
   with selected as (
     select
-      item_years.published_snapshot_id as snapshot_id,
+      item_years.published_version_id as version_id,
       items.code as course_code,
       academic_years.year as academic_year
-    from public.catalogue_items as items
-    join public.catalogue_item_years as item_years
-      on item_years.item_id = items.id
+    from public.catalogue_codes as items
+    join public.catalogue_records as item_years
+      on item_years.code_id = items.id
      and item_years.archived_at is null
     join public.academic_years
       on academic_years.id = item_years.academic_year_id
      and academic_years.year = p_academic_year
     where items.kind = 'course'
       and items.code = upper(btrim(p_course_code))
-      and item_years.published_snapshot_id is not null
+      and item_years.published_version_id is not null
     limit 1
   )
-  select private.course_snapshot_projection(selected.snapshot_id)
+  select private.course_version_projection(selected.version_id)
     || jsonb_build_object(
       'code', selected.course_code,
-      'snapshotId', selected.snapshot_id,
+      'snapshotId', selected.version_id,
       'prerequisiteEdges', coalesce((
         select jsonb_agg(jsonb_build_object(
           'from', graph.from_code, 'to', graph.to_code,
@@ -905,7 +910,7 @@ as $function$
   select exists (
     select 1
     from public.academic_structure_snapshot_relationships as relationships
-    where relationships.snapshot_id = p_programme_snapshot_id
+    where relationships.version_id = p_programme_snapshot_id
       and relationships.relationship_kind in ('required', 'option')
       and relationships.target_kind = p_structure_kind
       and relationships.target_code = p_structure_code
@@ -913,15 +918,15 @@ as $function$
     select 1
     from public.requirement_condition_options as options
     join public.requirement_conditions as conditions on conditions.id = options.condition_id
-    where options.snapshot_id = p_programme_snapshot_id
+    where options.version_id = p_programme_snapshot_id
       and conditions.condition_kind = 'structure_set'
       and options.kind = p_structure_kind
       and options.code = p_structure_code
   ) or exists (
     select 1
     from public.requirement_conditions as conditions
-    join public.catalogue_items as items on items.id = conditions.item_id
-    where conditions.snapshot_id = p_programme_snapshot_id
+    join public.catalogue_codes as items on items.id = conditions.code_id
+    where conditions.version_id = p_programme_snapshot_id
       and conditions.condition_kind = 'structure'
       and items.kind = p_structure_kind
       and items.code = p_structure_code
@@ -957,7 +962,7 @@ declare
   selected_programme_units numeric;
   selected_programme_duration_years numeric;
   selected_structure record;
-  selected_structure_year_id bigint;
+  selected_structure_record_id bigint;
   inserted_structure_count integer;
   expected_structure_count integer;
 begin
@@ -1017,7 +1022,7 @@ begin
 
   select
     item_years.id,
-    item_years.published_snapshot_id,
+    item_years.published_version_id,
     details.units,
     details.duration_years
   into
@@ -1025,15 +1030,15 @@ begin
     selected_programme_snapshot_id,
     selected_programme_units,
     selected_programme_duration_years
-  from public.catalogue_item_years as item_years
-  join public.catalogue_items as items on items.id = item_years.item_id
-  join public.structure_snapshot_details as details
-    on details.snapshot_id = item_years.published_snapshot_id
+  from public.catalogue_records as item_years
+  join public.catalogue_codes as items on items.id = item_years.code_id
+  join public.structure_version_details as details
+    on details.version_id = item_years.published_version_id
   where items.code = upper(btrim(p_programme_code))
     and items.kind = 'programme'
     and item_years.academic_year_id = selected_academic_year_id
     and item_years.archived_at is null
-    and item_years.published_snapshot_id is not null
+    and item_years.published_version_id is not null
   limit 1;
   if selected_programme_year_id is null then
     raise exception using
@@ -1066,20 +1071,20 @@ begin
     from unnest(p_specialisation_codes) with ordinality as requested(code, position)
     order by position
   loop
-    selected_structure_year_id := null;
+    selected_structure_record_id := null;
 
     select item_years.id
-    into selected_structure_year_id
-    from public.catalogue_item_years as item_years
-    join public.catalogue_items as items on items.id = item_years.item_id
+    into selected_structure_record_id
+    from public.catalogue_records as item_years
+    join public.catalogue_codes as items on items.id = item_years.code_id
     where items.code = selected_structure.code
       and items.kind = selected_structure.role
       and item_years.academic_year_id = selected_academic_year_id
       and item_years.archived_at is null
-      and item_years.published_snapshot_id is not null
+      and item_years.published_version_id is not null
     limit 1;
 
-    if selected_structure_year_id is null then
+    if selected_structure_record_id is null then
       raise exception using
         errcode = 'P0002',
         message = format(
@@ -1150,18 +1155,17 @@ begin
   returning id into selected_plan_id;
 
   insert into public.plan_structures (
-    plan_id, owner_id, academic_year_id, structure_year_id, role, position
+    plan_id, owner_id, catalogue_record_id, role, position
   ) values (
-    selected_plan_id, user_id, selected_academic_year_id, selected_programme_year_id, 'programme', 0
+    selected_plan_id, user_id, selected_programme_year_id, 'programme', 0
   );
 
   insert into public.plan_structures (
-    plan_id, owner_id, academic_year_id, structure_year_id, role, position
+    plan_id, owner_id, catalogue_record_id, role, position
   )
   select
     selected_plan_id,
     user_id,
-    selected_academic_year_id,
     item_years.id,
     requested.role,
     requested.position
@@ -1183,14 +1187,14 @@ begin
         + cardinality(p_minor_codes)
     from unnest(p_specialisation_codes) with ordinality as specialisations(code, position)
   ) as requested
-  join public.catalogue_items as items
+  join public.catalogue_codes as items
     on items.code = requested.code
    and items.kind = requested.role
-  join public.catalogue_item_years as item_years
-    on item_years.item_id = items.id
+  join public.catalogue_records as item_years
+    on item_years.code_id = items.id
    and item_years.academic_year_id = selected_academic_year_id
    and item_years.archived_at is null
-   and item_years.published_snapshot_id is not null
+   and item_years.published_version_id is not null
   order by requested.position;
 
   get diagnostics inserted_structure_count = row_count;
diff --git a/supabase/migrations/20260918170000_catalogue_import_pipeline.sql b/supabase/migrations/20260918170000_catalogue_import_pipeline.sql
index 7e06e9b2..e5bcdf16 100644
--- a/supabase/migrations/20260918170000_catalogue_import_pipeline.sql
+++ b/supabase/migrations/20260918170000_catalogue_import_pipeline.sql
@@ -2,8 +2,8 @@ begin;
 
 -- One import pipeline for every catalogue kind. A run targets one kind and
 -- one academic year; each target processes one directory entry through the
--- same stages and, when the content differs from the baseline snapshot,
--- produces a candidate snapshot for review.
+-- same stages and, when the content differs from the baseline version,
+-- produces a candidate version for review.
 
 -- Directory ----------------------------------------------------------------------------
 
@@ -13,7 +13,7 @@ create table public.catalogue_directory_entries (
   kind text not null,
   code text not null,
   title text,
-  item_id bigint,
+  code_id bigint,
   source_page_id bigint,
   summary jsonb not null default '{}'::jsonb,
   is_current boolean not null default true,
@@ -23,7 +23,7 @@ create table public.catalogue_directory_entries (
   constraint catalogue_directory_entries_academic_year_fkey
     foreign key (academic_year_id) references public.academic_years (id),
   constraint catalogue_directory_entries_item_fkey
-    foreign key (item_id, kind) references public.catalogue_items (id, kind),
+    foreign key (code_id, kind) references public.catalogue_codes (id, kind),
   constraint catalogue_directory_entries_source_page_fkey
     foreign key (source_page_id, academic_year_id)
     references public.catalogue_source_pages (id, academic_year_id),
@@ -105,11 +105,11 @@ create table public.catalogue_import_targets (
   kind text not null,
   code text not null,
   academic_year_id bigint not null,
-  item_id bigint not null,
-  item_year_id bigint not null,
+  code_id bigint not null,
+  record_id bigint not null,
   directory_entry_id bigint,
-  baseline_snapshot_id bigint,
-  candidate_snapshot_id bigint,
+  baseline_version_id bigint,
+  candidate_version_id bigint,
   source_page_id bigint,
   status text not null default 'queued',
   change_kind text,
@@ -124,22 +124,22 @@ create table public.catalogue_import_targets (
   created_at timestamptz not null default now(),
   updated_at timestamptz not null default now(),
   completed_at timestamptz,
-  constraint catalogue_import_targets_run_item_unique unique (run_id, item_id),
+  constraint catalogue_import_targets_run_item_unique unique (run_id, code_id),
   constraint catalogue_import_targets_run_fkey
     foreign key (run_id) references public.catalogue_import_runs (id) on delete cascade,
   constraint catalogue_import_targets_item_fkey
-    foreign key (item_id, kind) references public.catalogue_items (id, kind),
+    foreign key (code_id, kind) references public.catalogue_codes (id, kind),
   constraint catalogue_import_targets_item_year_fkey
-    foreign key (item_year_id, academic_year_id)
-    references public.catalogue_item_years (id, academic_year_id),
+    foreign key (record_id, academic_year_id)
+    references public.catalogue_records (id, academic_year_id),
   constraint catalogue_import_targets_directory_entry_fkey
     foreign key (directory_entry_id) references public.catalogue_directory_entries (id),
   constraint catalogue_import_targets_baseline_fkey
-    foreign key (baseline_snapshot_id, item_year_id)
-    references public.catalogue_snapshots (id, item_year_id),
+    foreign key (baseline_version_id, record_id)
+    references public.catalogue_versions (id, record_id),
   constraint catalogue_import_targets_candidate_fkey
-    foreign key (candidate_snapshot_id, item_year_id)
-    references public.catalogue_snapshots (id, item_year_id),
+    foreign key (candidate_version_id, record_id)
+    references public.catalogue_versions (id, record_id),
   constraint catalogue_import_targets_source_page_fkey
     foreign key (source_page_id, academic_year_id)
     references public.catalogue_source_pages (id, academic_year_id),
@@ -155,27 +155,27 @@ create table public.catalogue_import_targets (
 create index catalogue_import_targets_run_idx
   on public.catalogue_import_targets (run_id, created_at);
 
-create index catalogue_import_targets_item_year_idx
-  on public.catalogue_import_targets (item_year_id, created_at desc);
+create index catalogue_import_targets_record_idx
+  on public.catalogue_import_targets (record_id, created_at desc);
 
 -- An item year has at most one unfinished target across all runs.
-create unique index catalogue_import_targets_active_item_year_idx
-  on public.catalogue_import_targets (item_year_id)
+create unique index catalogue_import_targets_active_record_idx
+  on public.catalogue_import_targets (record_id)
   where status in ('queued', 'running');
 
 create trigger catalogue_import_targets_set_updated_at
 before update on public.catalogue_import_targets
 for each row execute function private.set_updated_at();
 
-alter table public.catalogue_snapshots
+alter table public.catalogue_versions
   add column import_target_id uuid,
-  add constraint catalogue_snapshots_import_target_fkey
+  add constraint catalogue_versions_import_target_fkey
     foreign key (import_target_id) references public.catalogue_import_targets (id)
     on delete set null;
 
--- Removing a run or a user detaches the snapshot's provenance links. Those
--- and the sealing itself are the only changes a sealed snapshot accepts.
-create or replace function private.enforce_catalogue_snapshot_immutability()
+-- Removing a run or a user detaches the version's provenance links. Those
+-- and the sealing itself are the only changes a sealed version accepts.
+create or replace function private.enforce_catalogue_version_immutability()
 returns trigger
 language plpgsql
 set search_path = ''
@@ -197,7 +197,7 @@ begin
     return new;
   end if;
   raise exception
-    'catalogue_snapshots records are immutable; create a new snapshot instead'
+    'Catalogue versions are immutable; create a new version instead.'
     using errcode = '55000';
 end;
 $function$;
@@ -459,7 +459,7 @@ declare
   requested_code text;
   created_targets jsonb := '[]'::jsonb;
   selected_item_id bigint;
-  selected_item_year_id bigint;
+  selected_record_id bigint;
   selected_baseline bigint;
   selected_directory_entry_id bigint;
   created_target_id uuid;
@@ -505,25 +505,40 @@ begin
     select distinct upper(btrim(code)) from unnest(p_codes) as requested(code)
     where nullif(btrim(code), '') is not null
   loop
-    insert into public.catalogue_items (kind, code)
+    insert into public.catalogue_codes (kind, code)
     values (p_kind, requested_code)
     on conflict (kind, code) do nothing;
 
     select id into selected_item_id
-    from public.catalogue_items where kind = p_kind and code = requested_code;
+    from public.catalogue_codes where kind = p_kind and code = requested_code;
 
-    insert into public.catalogue_item_years (item_id, kind, academic_year_id)
+    insert into public.catalogue_records (code_id, kind, academic_year_id)
     values (selected_item_id, p_kind, selected_year_id)
-    on conflict (item_id, academic_year_id) do nothing;
-
-    select id, coalesce(draft_snapshot_id, published_snapshot_id)
-    into selected_item_year_id, selected_baseline
-    from public.catalogue_item_years
-    where item_id = selected_item_id and academic_year_id = selected_year_id;
+    on conflict (code_id, academic_year_id) do nothing;
+
+    select records.id, latest.id
+    into selected_record_id, selected_baseline
+    from public.catalogue_records as records
+    left join lateral (
+      select versions.id
+      from public.catalogue_versions as versions
+      left join public.catalogue_import_targets as targets
+        on targets.id = versions.import_target_id
+      where versions.record_id = records.id
+        and versions.sealed_at is not null
+        and (
+          versions.import_target_id is null
+          or targets.applied_version_id = versions.id
+        )
+      order by versions.created_at desc, versions.id desc
+      limit 1
+    ) as latest on true
+    where records.code_id = selected_item_id
+      and records.academic_year_id = selected_year_id;
 
     if exists (
-      select 1 from public.catalogue_item_years
-      where id = selected_item_year_id and archived_at is not null
+      select 1 from public.catalogue_records
+      where id = selected_record_id and archived_at is not null
     ) then
       raise exception using
         errcode = '55000',
@@ -532,7 +547,7 @@ begin
 
     if exists (
       select 1 from public.catalogue_import_targets
-      where item_year_id = selected_item_year_id and status in ('queued', 'running')
+      where record_id = selected_record_id and status in ('queued', 'running')
     ) then
       raise exception using
         errcode = '55000',
@@ -544,11 +559,11 @@ begin
     where academic_year_id = selected_year_id and kind = p_kind and code = requested_code;
 
     insert into public.catalogue_import_targets (
-      run_id, kind, code, academic_year_id, item_id, item_year_id,
-      directory_entry_id, baseline_snapshot_id
+      run_id, kind, code, academic_year_id, code_id, record_id,
+      directory_entry_id, baseline_version_id
     ) values (
       created_run_id, p_kind, requested_code, selected_year_id, selected_item_id,
-      selected_item_year_id, selected_directory_entry_id, selected_baseline
+      selected_record_id, selected_directory_entry_id, selected_baseline
     )
     returning id into created_target_id;
 
diff --git a/supabase/migrations/20260918200000_catalogue_review.sql b/supabase/migrations/20260918200000_catalogue_review.sql
index 2e7d158a..198dc5f1 100644
--- a/supabase/migrations/20260918200000_catalogue_review.sql
+++ b/supabase/migrations/20260918200000_catalogue_review.sql
@@ -1,9 +1,9 @@
 begin;
 
 -- Review of import candidates. Each target records the differences between
--- its baseline and candidate snapshots as changes, and the parser's review
--- items as flags. Applying accepted changes produces a new draft; publishing
--- moves the draft pointer once no blocking flag is open.
+-- its baseline and candidate versions as changes, and the parser's review
+-- items as flags. Applying accepted changes identifies the immutable version
+-- that may be published once no blocking flag is open.
 
 create table public.catalogue_import_changes (
   id bigint generated always as identity primary key,
@@ -63,11 +63,11 @@ grant select, insert, update, delete on table public.catalogue_import_changes to
 
 -- Applying a candidate records which snapshot the review produced.
 alter table public.catalogue_import_targets
-  add column applied_snapshot_id bigint,
+  add column applied_version_id bigint,
   add column applied_at timestamptz,
   add constraint catalogue_import_targets_applied_fkey
-    foreign key (applied_snapshot_id, item_year_id)
-    references public.catalogue_snapshots (id, item_year_id);
+    foreign key (applied_version_id, record_id)
+    references public.catalogue_versions (id, record_id);
 
 -- Resolution ---------------------------------------------------------------------------
 
@@ -132,8 +132,8 @@ grant execute on function public.resolve_catalogue_import_change(bigint, text, t
 
 -- Publication gate ---------------------------------------------------------------------
 
--- Reasons the draft of an item year cannot be published, empty when it can.
-create or replace function public.catalogue_publish_blockers(p_item_year_id bigint)
+-- Reasons the latest applied version cannot be published, empty when it can.
+create or replace function public.catalogue_publish_blockers(p_record_id bigint)
 returns text[]
 language sql
 stable
@@ -141,25 +141,37 @@ security definer
 set search_path = ''
 as $function$
   with item_year as (
-    select * from public.catalogue_item_years where id = p_item_year_id
+    select * from public.catalogue_records where id = p_record_id
   ),
-  draft as (
-    select snapshots.* from public.catalogue_snapshots as snapshots
-    join item_year on item_year.draft_snapshot_id = snapshots.id
+  publishable_version as (
+    select versions.*
+    from public.catalogue_versions as versions
+    join item_year on item_year.id = versions.record_id
+    left join public.catalogue_import_targets as targets
+      on targets.id = versions.import_target_id
+    where versions.sealed_at is not null
+      and (
+        versions.import_target_id is null
+        or targets.applied_version_id = versions.id
+      )
+    order by versions.created_at desc, versions.id desc
+    limit 1
   )
   select array_remove(array[
     case when not exists (select 1 from item_year) then 'The record does not exist.' end,
     case when exists (select 1 from item_year where archived_at is not null) then 'The record is archived.' end,
-    case when exists (select 1 from item_year where draft_snapshot_id is null) then 'There is no draft to publish.' end,
+    case when not exists (select 1 from publishable_version) then 'There is no version to publish.' end,
 
     case when exists (
-      select 1 from draft
-      join public.catalogue_import_changes as changes on changes.target_id = draft.import_target_id
+      select 1 from publishable_version
+      join public.catalogue_import_changes as changes
+        on changes.target_id = publishable_version.import_target_id
       where changes.entry_kind = 'flag' and changes.is_blocking and changes.status = 'open'
-    ) then 'A blocking flag on the draft is still open.' end,
+    ) then 'A blocking flag on the version is still open.' end,
     case when exists (
-      select 1 from draft
-      join public.catalogue_import_changes as changes on changes.target_id = draft.import_target_id
+      select 1 from publishable_version
+      join public.catalogue_import_changes as changes
+        on changes.target_id = publishable_version.import_target_id
       where changes.entry_kind = 'change' and changes.status = 'open'
     ) then 'The import review still has open changes.' end
   ], null);
@@ -168,7 +180,7 @@ $function$;
 revoke all on function public.catalogue_publish_blockers(bigint) from public, anon;
 grant execute on function public.catalogue_publish_blockers(bigint) to authenticated;
 
-create or replace function public.publish_catalogue_snapshot(p_item_year_id bigint)
+create or replace function public.publish_catalogue_version(p_record_id bigint)
 returns bigint
 language plpgsql
 security definer
@@ -176,7 +188,7 @@ set search_path = ''
 as $function$
 declare
   blockers text[];
-  draft_id bigint;
+  version_id bigint;
 begin
   if (select auth.uid()) is null then
     raise exception using errcode = '28000', message = 'Authentication is required.';
@@ -185,28 +197,37 @@ begin
     raise exception using errcode = '42501', message = 'Publishing requires the catalogue.write permission.';
   end if;
 
-  perform 1 from public.catalogue_item_years where id = p_item_year_id for update;
-  blockers := public.catalogue_publish_blockers(p_item_year_id);
+  perform 1 from public.catalogue_records where id = p_record_id for update;
+  blockers := public.catalogue_publish_blockers(p_record_id);
   if cardinality(blockers) > 0 then
     raise exception using errcode = '55000', message = array_to_string(blockers, ' ');
   end if;
 
-  -- A draft exists only while it differs from what is published, so
-  -- publishing moves the pointer and clears the draft.
-  update public.catalogue_item_years
-  set published_snapshot_id = draft_snapshot_id,
-      draft_snapshot_id = null
-  where id = p_item_year_id
-  returning published_snapshot_id into draft_id;
-  return draft_id;
+  select versions.id
+  into version_id
+  from public.catalogue_versions as versions
+  left join public.catalogue_import_targets as targets
+    on targets.id = versions.import_target_id
+  where versions.record_id = p_record_id
+    and versions.sealed_at is not null
+    and (
+      versions.import_target_id is null
+      or targets.applied_version_id = versions.id
+    )
+  order by versions.created_at desc, versions.id desc
+  limit 1;
+
+  update public.catalogue_records
+  set published_version_id = version_id
+  where id = p_record_id;
+  return version_id;
 end;
 $function$;
 
-revoke all on function public.publish_catalogue_snapshot(bigint) from public, anon;
-grant execute on function public.publish_catalogue_snapshot(bigint) to authenticated;
+revoke all on function public.publish_catalogue_version(bigint) from public, anon;
+grant execute on function public.publish_catalogue_version(bigint) to authenticated;
 
--- Withdraws the published snapshot; the draft pointer is unchanged.
-create or replace function public.unpublish_catalogue_item_year(p_item_year_id bigint)
+create or replace function public.unpublish_catalogue_record(p_record_id bigint)
 returns void
 language plpgsql
 security definer
@@ -219,16 +240,16 @@ begin
   if not private.has_permission('catalogue.write') then
     raise exception using errcode = '42501', message = 'Publishing requires the catalogue.write permission.';
   end if;
-  update public.catalogue_item_years
-  set published_snapshot_id = null
-  where id = p_item_year_id and published_snapshot_id is not null;
+  update public.catalogue_records
+  set published_version_id = null
+  where id = p_record_id and published_version_id is not null;
   if not found then
     raise exception using errcode = '55000', message = 'Nothing is published for this record.';
   end if;
 end;
 $function$;
 
-revoke all on function public.unpublish_catalogue_item_year(bigint) from public, anon;
-grant execute on function public.unpublish_catalogue_item_year(bigint) to authenticated;
+revoke all on function public.unpublish_catalogue_record(bigint) from public, anon;
+grant execute on function public.unpublish_catalogue_record(bigint) to authenticated;
 
 commit;
diff --git a/supabase/migrations/20260918220000_catalogue_workspace.sql b/supabase/migrations/20260918220000_catalogue_workspace.sql
index f18df397..2de857ea 100644
--- a/supabase/migrations/20260918220000_catalogue_workspace.sql
+++ b/supabase/migrations/20260918220000_catalogue_workspace.sql
@@ -1,11 +1,11 @@
 begin;
 
--- Workspace support: administrators preview any snapshot they may read and
--- discard a draft they no longer want.
+-- Workspace support: administrators preview any immutable catalogue version
+-- they may read.
 
--- The student-facing projection of a snapshot for administrators, including
--- drafts and history. Only course snapshots have a projection today.
-create or replace function public.admin_snapshot_projection(p_snapshot_id bigint)
+-- The student-facing projection of a version for administrators. Only course
+-- versions have a projection today.
+create or replace function public.admin_catalogue_version_projection(p_version_id bigint)
 returns jsonb
 language plpgsql
 stable
@@ -13,50 +13,24 @@ security definer
 set search_path = ''
 as $function$
 declare
-  snapshot_kind text;
+  version_kind text;
 begin
   if not private.can_manage_catalogue() then
     raise exception using errcode = '42501', message = 'Catalogue permission is required.';
   end if;
-  select kind into snapshot_kind from public.catalogue_snapshots where id = p_snapshot_id;
-  if snapshot_kind is null then
-    raise exception using errcode = 'P0002', message = 'The snapshot does not exist.';
+  select kind into version_kind from public.catalogue_versions where id = p_version_id;
+  if version_kind is null then
+    raise exception using errcode = 'P0002', message = 'The catalogue version does not exist.';
   end if;
-  if snapshot_kind <> 'course' then
+  if version_kind <> 'course' then
     return null;
   end if;
-  return private.course_snapshot_projection(p_snapshot_id)
-    || jsonb_build_object('snapshotId', p_snapshot_id);
+  return private.course_version_projection(p_version_id)
+    || jsonb_build_object('versionId', p_version_id);
 end;
 $function$;
 
-revoke all on function public.admin_snapshot_projection(bigint) from public, anon;
-grant execute on function public.admin_snapshot_projection(bigint) to authenticated;
-
--- Clears the draft pointer. The snapshot stays in history and can be restored.
-create or replace function public.discard_catalogue_draft(p_item_year_id bigint)
-returns void
-language plpgsql
-security definer
-set search_path = ''
-as $function$
-begin
-  if (select auth.uid()) is null then
-    raise exception using errcode = '28000', message = 'Authentication is required.';
-  end if;
-  if not private.has_permission('catalogue.write') then
-    raise exception using errcode = '42501', message = 'Editing requires the catalogue.write permission.';
-  end if;
-  update public.catalogue_item_years
-  set draft_snapshot_id = null
-  where id = p_item_year_id and draft_snapshot_id is not null;
-  if not found then
-    raise exception using errcode = '55000', message = 'There is no draft to discard.';
-  end if;
-end;
-$function$;
-
-revoke all on function public.discard_catalogue_draft(bigint) from public, anon;
-grant execute on function public.discard_catalogue_draft(bigint) to authenticated;
+revoke all on function public.admin_catalogue_version_projection(bigint) from public, anon;
+grant execute on function public.admin_catalogue_version_projection(bigint) to authenticated;
 
 commit;
diff --git a/supabase/migrations/20260920100000_catalogue_write_permissions.sql b/supabase/migrations/20260920100000_catalogue_write_permissions.sql
index 47e3b76c..f3b9772a 100644
--- a/supabase/migrations/20260920100000_catalogue_write_permissions.sql
+++ b/supabase/migrations/20260920100000_catalogue_write_permissions.sql
@@ -4,9 +4,9 @@
 -- returned true for anyone holding courses.read_drafts or catalogue.read_drafts,
 -- and the default `user` role granted to every sign-up holds both. Combined with
 -- insert and update grants to `authenticated`, any signed-in account could create
--- catalogue items, seal snapshots and move published_snapshot_id -- publishing
+-- catalogue items, seal snapshots and move published_version_id -- publishing
 -- arbitrary content to the anonymous catalogue and bypassing the publication gate
--- in publish_catalogue_snapshot() entirely.
+-- in publish_catalogue_version() entirely.
 --
 -- Reading drafts and writing content are now separate helpers. No application
 -- code depends on the revoked grants: every mutation runs through a SECURITY
@@ -47,19 +47,19 @@ grant execute on function private.can_write_catalogue() to authenticated;
 grant execute on function private.can_read_catalogue_drafts() to anon, authenticated;
 
 -- Read helpers follow the draft-reading side.
-create or replace function private.can_read_snapshot(p_snapshot_id bigint)
+create or replace function private.can_read_version(p_version_id bigint)
 returns boolean
 language sql
 stable
 security definer
 set search_path = ''
 as $function$
-  select private.is_published_snapshot(p_snapshot_id)
+  select private.is_published_version(p_version_id)
     or private.can_read_catalogue_drafts()
     or exists (
       select 1
       from public.course_attempts as attempts
-      where attempts.course_snapshot_id = p_snapshot_id
+      where attempts.catalogue_version_id = p_version_id
         and attempts.owner_id = (select auth.uid())
     );
 $function$;
@@ -74,51 +74,56 @@ as $function$
   select private.can_read_catalogue_drafts()
     or exists (
       select 1
-      from public.catalogue_item_years as item_years
-      where item_years.item_id = p_item_id
-        and item_years.published_snapshot_id is not null
+      from public.catalogue_records as item_years
+      where item_years.code_id = p_item_id
+        and item_years.published_version_id is not null
         and item_years.archived_at is null
     )
     or exists (
       select 1
       from public.requirement_conditions as conditions
-      where conditions.item_id = p_item_id
-        and private.is_published_snapshot(conditions.snapshot_id)
+      where conditions.code_id = p_item_id
+        and private.is_published_version(conditions.version_id)
     )
     or exists (
       select 1
       from public.requirement_condition_options as options
-      where options.item_id = p_item_id
-        and private.is_published_snapshot(options.snapshot_id)
+      where options.code_id = p_item_id
+        and private.is_published_version(options.version_id)
     )
     or exists (
       select 1
       from public.requirement_item_references as item_references
-      where item_references.item_id = p_item_id
-        and private.is_published_snapshot(item_references.snapshot_id)
+      where item_references.code_id = p_item_id
+        and private.is_published_version(item_references.version_id)
     )
     or exists (
       select 1
       from public.course_related_courses as related
       where related.related_course_id = p_item_id
-        and private.is_published_snapshot(related.snapshot_id)
+        and private.is_published_version(related.version_id)
     )
     or exists (
       select 1
       from public.course_attempts as attempts
-      where attempts.course_id = p_item_id
+      join public.catalogue_versions as versions
+        on versions.id = attempts.catalogue_version_id
+      join public.catalogue_records as records on records.id = versions.record_id
+      where records.code_id = p_item_id
         and attempts.owner_id = (select auth.uid())
     )
     or exists (
       select 1
       from public.plan_items
-      where plan_items.course_id = p_item_id
+      join public.catalogue_records as records
+        on records.id = plan_items.catalogue_record_id
+      where records.code_id = p_item_id
         and plan_items.owner_id = (select auth.uid())
     );
 $function$;
 
 -- The admin preview projection is a read, so it follows the draft-reading side.
-create or replace function public.admin_snapshot_projection(p_snapshot_id bigint)
+create or replace function public.admin_catalogue_version_projection(p_version_id bigint)
 returns jsonb
 language plpgsql
 stable
@@ -131,45 +136,45 @@ begin
   if not private.can_read_catalogue_drafts() then
     raise exception using errcode = '42501', message = 'Catalogue permission is required.';
   end if;
-  select kind into snapshot_kind from public.catalogue_snapshots where id = p_snapshot_id;
+  select kind into snapshot_kind from public.catalogue_versions where id = p_version_id;
   if snapshot_kind is null then
     raise exception using errcode = 'P0002', message = 'The snapshot does not exist.';
   end if;
   if snapshot_kind <> 'course' then
     return null;
   end if;
-  return private.course_snapshot_projection(p_snapshot_id)
-    || jsonb_build_object('snapshotId', p_snapshot_id);
+  return private.course_version_projection(p_version_id)
+    || jsonb_build_object('snapshotId', p_version_id);
 end;
 $function$;
 
 -- Identity and year write policies.
-drop policy catalogue_items_admin_write on public.catalogue_items;
-create policy catalogue_items_admin_write
-on public.catalogue_items
+drop policy catalogue_codes_admin_write on public.catalogue_codes;
+create policy catalogue_codes_admin_write
+on public.catalogue_codes
 for all
 to authenticated
 using ((select private.can_write_catalogue()))
 with check ((select private.can_write_catalogue()));
 
-drop policy catalogue_item_years_admin_write on public.catalogue_item_years;
-create policy catalogue_item_years_admin_write
-on public.catalogue_item_years
+drop policy catalogue_records_admin_write on public.catalogue_records;
+create policy catalogue_records_admin_write
+on public.catalogue_records
 for all
 to authenticated
 using ((select private.can_write_catalogue()))
 with check ((select private.can_write_catalogue()));
 
 -- Read policies that named the old helper directly.
-drop policy catalogue_item_years_read on public.catalogue_item_years;
-create policy catalogue_item_years_read
-on public.catalogue_item_years
+drop policy catalogue_records_read on public.catalogue_records;
+create policy catalogue_records_read
+on public.catalogue_records
 for select
 to anon, authenticated
 using (
-  (published_snapshot_id is not null and archived_at is null)
+  (published_version_id is not null and archived_at is null)
   or (select private.can_read_catalogue_drafts())
-  or (select private.can_read_catalogue_item(item_id))
+  or (select private.can_read_catalogue_item(code_id))
 );
 
 drop policy catalogue_publications_read on public.catalogue_publications;
@@ -178,7 +183,7 @@ on public.catalogue_publications
 for select
 to anon, authenticated
 using (
-  (snapshot_id is not null and (select private.is_published_snapshot(snapshot_id)))
+  (version_id is not null and (select private.is_published_version(version_id)))
   or (select private.can_read_catalogue_drafts())
 );
 
@@ -188,10 +193,10 @@ declare
   child text;
 begin
   foreach child in array array[
-    'catalogue_snapshots',
-    'course_snapshot_details',
-    'structure_snapshot_details',
-    'snapshot_field_evidence',
+    'catalogue_versions',
+    'course_version_details',
+    'structure_version_details',
+    'catalogue_version_provenance',
     'course_offerings',
     'offering_sessions',
     'course_learning_outcomes',
@@ -225,15 +230,15 @@ $$;
 
 -- Nothing in the application writes these tables through PostgREST.
 revoke insert, update on table
-  public.catalogue_items,
-  public.catalogue_item_years
+  public.catalogue_codes,
+  public.catalogue_records
 from authenticated;
 
 revoke insert on table
-  public.catalogue_snapshots,
-  public.course_snapshot_details,
-  public.structure_snapshot_details,
-  public.snapshot_field_evidence,
+  public.catalogue_versions,
+  public.course_version_details,
+  public.structure_version_details,
+  public.catalogue_version_provenance,
   public.requirement_rules,
   public.requirement_groups,
   public.requirement_conditions,
diff --git a/supabase/migrations/20260920110000_requirement_condition_integrity.sql b/supabase/migrations/20260920110000_requirement_condition_integrity.sql
index 0895e278..9dd248c0 100644
--- a/supabase/migrations/20260920110000_requirement_condition_integrity.sql
+++ b/supabase/migrations/20260920110000_requirement_condition_integrity.sql
@@ -1,8 +1,8 @@
 -- Two integrity gaps in requirement_conditions.
 --
--- 1. item_id referenced catalogue_items (id) alone, the only child table in the
+-- 1. code_id referenced catalogue_codes (id) alone, the only child table in the
 --    model that skipped the composite (id, kind) pattern used everywhere else
---    (catalogue_item_years, catalogue_snapshots, both detail tables,
+--    (catalogue_records, catalogue_versions, both detail tables,
 --    catalogue_directory_entries, catalogue_import_targets and, notably, the
 --    sibling requirement_condition_options). A condition_kind = 'course' row
 --    could therefore point at a programme and silently corrupt the requirement.
@@ -23,9 +23,9 @@ alter table public.requirement_conditions
 
 update public.requirement_conditions as conditions
    set item_kind = items.kind
-  from public.catalogue_items as items
- where items.id = conditions.item_id
-   and conditions.item_id is not null;
+  from public.catalogue_codes as items
+ where items.id = conditions.code_id
+   and conditions.code_id is not null;
 
 alter table public.requirement_conditions
   enable trigger requirement_conditions_guard_sealed;
@@ -35,14 +35,14 @@ alter table public.requirement_conditions
 
 alter table public.requirement_conditions
   add constraint requirement_conditions_item_fkey
-    foreign key (item_id, item_kind) references public.catalogue_items (id, kind);
+    foreign key (code_id, item_kind) references public.catalogue_codes (id, kind);
 
--- item_kind travels with item_id and must suit the condition that carries it.
+-- item_kind travels with code_id and must suit the condition that carries it.
 alter table public.requirement_conditions
   add constraint requirement_conditions_item_kind_check check (
-    (item_id is null and item_kind is null)
+    (code_id is null and item_kind is null)
     or (
-      item_id is not null
+      code_id is not null
       and item_kind is not null
       and case
         when condition_kind in ('course', 'incompatible') then item_kind = 'course'
diff --git a/supabase/migrations/20260920120000_maximum_only_unit_conditions.sql b/supabase/migrations/20260920120000_maximum_only_unit_conditions.sql
index 1bd6bbfb..eb94ca26 100644
--- a/supabase/migrations/20260920120000_maximum_only_unit_conditions.sql
+++ b/supabase/migrations/20260920120000_maximum_only_unit_conditions.sql
@@ -17,9 +17,9 @@ alter table public.requirement_conditions
 alter table public.requirement_conditions
   add constraint requirement_conditions_typed_value_check check (
     case condition_kind
-      when 'course' then item_id is not null
-      when 'incompatible' then item_id is not null
-      when 'structure' then item_id is not null or free_text is not null
+      when 'course' then code_id is not null
+      when 'incompatible' then code_id is not null
+      when 'structure' then code_id is not null or free_text is not null
       when 'structure_set' then structure_kind is not null
       when 'course_set_units' then
         minimum_units is not null
diff --git a/supabase/migrations/20260920200000_published_structure_detail.sql b/supabase/migrations/20260920200000_published_structure_detail.sql
index 33bb143b..92450f84 100644
--- a/supabase/migrations/20260920200000_published_structure_detail.sql
+++ b/supabase/migrations/20260920200000_published_structure_detail.sql
@@ -4,9 +4,9 @@ begin;
 -- specialisation had no way of reaching a reader. This adds the structure
 -- equivalent of `published_course_detail`, with the same security posture:
 -- the projection stays private, and the public entry point resolves through
--- `catalogue_item_years.published_snapshot_id` so no draft can be reached.
+-- `catalogue_records.published_version_id` so no draft can be reached.
 
-create or replace function private.structure_snapshot_projection(p_snapshot_id bigint)
+create or replace function private.structure_version_projection(p_version_id bigint)
 returns jsonb
 language sql
 stable
@@ -19,12 +19,12 @@ as $function$
       details.*,
       items.code as structure_code,
       academic_years.year as academic_year
-    from public.catalogue_snapshots as snapshots
-    join public.structure_snapshot_details as details on details.snapshot_id = snapshots.id
-    join public.catalogue_item_years as item_years on item_years.id = snapshots.item_year_id
-    join public.catalogue_items as items on items.id = item_years.item_id
+    from public.catalogue_versions as snapshots
+    join public.structure_version_details as details on details.version_id = snapshots.id
+    join public.catalogue_records as item_years on item_years.id = snapshots.record_id
+    join public.catalogue_codes as items on items.id = item_years.code_id
     join public.academic_years on academic_years.id = snapshots.academic_year_id
-    where snapshots.id = p_snapshot_id
+    where snapshots.id = p_version_id
   )
   select jsonb_build_object(
     'structureCode', snapshot.structure_code,
@@ -57,7 +57,7 @@ as $function$
         'markdown', sections.markdown
       ) order by sections.position)
       from public.academic_structure_snapshot_sections as sections
-      where sections.snapshot_id = p_snapshot_id
+      where sections.version_id = p_version_id
     ), '[]'::jsonb),
     'learningOutcomes', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -65,7 +65,7 @@ as $function$
         'outcomeText', outcomes.outcome_text
       ) order by outcomes.position)
       from public.academic_structure_learning_outcomes as outcomes
-      where outcomes.snapshot_id = p_snapshot_id
+      where outcomes.version_id = p_version_id
     ), '[]'::jsonb),
     'fees', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -80,7 +80,7 @@ as $function$
         'sourceText', fees.source_text
       ) order by fees.position)
       from public.academic_structure_fees as fees
-      where fees.snapshot_id = p_snapshot_id
+      where fees.version_id = p_version_id
     ), '[]'::jsonb),
     'relationships', coalesce((
       select jsonb_agg(jsonb_build_object(
@@ -91,9 +91,9 @@ as $function$
         'targetTitle', relationships.target_title
       ) order by relationships.position)
       from public.academic_structure_snapshot_relationships as relationships
-      where relationships.snapshot_id = p_snapshot_id
+      where relationships.version_id = p_version_id
     ), '[]'::jsonb),
-    'requirements', private.requirement_projection(p_snapshot_id),
+    'requirements', private.requirement_projection(p_version_id),
     -- Structure options store a code and nothing else, so a reader would see
     -- "COMS-MAJ" with no name. Resolve each one through its own published
     -- snapshot for the same year.
@@ -104,18 +104,18 @@ as $function$
           option_items.code,
           option_details.name
         from public.requirement_condition_options as options
-        join public.catalogue_items as option_items on option_items.id = options.item_id
-        join public.catalogue_item_years as option_years
-          on option_years.item_id = option_items.id
+        join public.catalogue_codes as option_items on option_items.id = options.code_id
+        join public.catalogue_records as option_years
+          on option_years.code_id = option_items.id
          and option_years.academic_year_id = (
            select snapshots.academic_year_id
-           from public.catalogue_snapshots as snapshots
-           where snapshots.id = p_snapshot_id
+           from public.catalogue_versions as snapshots
+           where snapshots.id = p_version_id
          )
          and option_years.archived_at is null
-        join public.structure_snapshot_details as option_details
-          on option_details.snapshot_id = option_years.published_snapshot_id
-        where options.snapshot_id = p_snapshot_id
+        join public.structure_version_details as option_details
+          on option_details.version_id = option_years.published_version_id
+        where options.version_id = p_version_id
           and options.kind <> 'course'
       ) as resolved
     ), '{}'::jsonb)
@@ -123,7 +123,7 @@ as $function$
   from selected_snapshot as snapshot;
 $function$;
 
-revoke all on function private.structure_snapshot_projection(bigint)
+revoke all on function private.structure_version_projection(bigint)
 from public, anon, authenticated;
 
 create or replace function public.published_structure_detail(
@@ -139,21 +139,21 @@ as $function$
   -- Security definer so the private projection is callable; the CTE selects
   -- only the published snapshot, so no draft content can be reached.
   with selected as (
-    select item_years.published_snapshot_id as snapshot_id
-    from public.catalogue_items as items
-    join public.catalogue_item_years as item_years
-      on item_years.item_id = items.id
+    select item_years.published_version_id as version_id
+    from public.catalogue_codes as items
+    join public.catalogue_records as item_years
+      on item_years.code_id = items.id
      and item_years.archived_at is null
     join public.academic_years
       on academic_years.id = item_years.academic_year_id
      and academic_years.year = p_academic_year
     where items.kind in ('programme', 'major', 'minor', 'specialisation')
       and items.code = upper(btrim(p_structure_code))
-      and item_years.published_snapshot_id is not null
+      and item_years.published_version_id is not null
     limit 1
   )
-  select private.structure_snapshot_projection(selected.snapshot_id)
-    || jsonb_build_object('snapshotId', selected.snapshot_id)
+  select private.structure_version_projection(selected.version_id)
+    || jsonb_build_object('snapshotId', selected.version_id)
   from selected;
 $function$;
 
@@ -173,11 +173,11 @@ as $function$
   select
     academic_years.year as academic_year,
     items.kind as structure_kind
-  from public.catalogue_items as items
-  join public.catalogue_item_years as item_years
-    on item_years.item_id = items.id
+  from public.catalogue_codes as items
+  join public.catalogue_records as item_years
+    on item_years.code_id = items.id
    and item_years.archived_at is null
-   and item_years.published_snapshot_id is not null
+   and item_years.published_version_id is not null
   join public.academic_years on academic_years.id = item_years.academic_year_id
   where items.kind in ('programme', 'major', 'minor', 'specialisation')
     and items.code = upper(btrim(p_structure_code))
diff --git a/supabase/migrations/20260920300000_structure_summary_fields.sql b/supabase/migrations/20260920300000_structure_summary_fields.sql
index ffb24661..c1483b5c 100644
--- a/supabase/migrations/20260920300000_structure_summary_fields.sql
+++ b/supabase/migrations/20260920300000_structure_summary_fields.sql
@@ -6,7 +6,7 @@ begin;
 -- The structure extraction has always parsed them, the projection has always
 -- carried them, and projectionSha256 hashes them, so they take part in change
 -- detection. They had nowhere to land: 20260918150000_requirements.sql dropped
--- academic_structure_summary_fields and structure_snapshot_details has no
+-- academic_structure_summary_fields and structure_version_details has no
 -- equivalent columns, so every programme import silently discarded them. A
 -- content hash that covers data the database never stores also means two
 -- snapshots can differ by their hash alone, with no visible difference.
@@ -14,7 +14,7 @@ begin;
 -- One row per value, because a field such as "Academic plan" lists several.
 
 create table public.structure_snapshot_summary_fields (
-  snapshot_id bigint not null,
+  version_id bigint not null,
   position integer not null,
   value_position integer not null,
   field_key text not null,
@@ -22,9 +22,9 @@ create table public.structure_snapshot_summary_fields (
   field_value text not null,
   source_text text not null,
   constraint structure_snapshot_summary_fields_pkey
-    primary key (snapshot_id, position, value_position),
+    primary key (version_id, position, value_position),
   constraint structure_snapshot_summary_fields_snapshot_fkey
-    foreign key (snapshot_id) references public.catalogue_snapshots (id)
+    foreign key (version_id) references public.catalogue_versions (id)
     on delete cascade,
   constraint structure_snapshot_summary_fields_position_check check (position > 0),
   constraint structure_snapshot_summary_fields_value_position_check check (value_position > 0),
@@ -51,7 +51,7 @@ create policy structure_snapshot_summary_fields_read
 on public.structure_snapshot_summary_fields
 for select
 to anon, authenticated
-using ((select private.can_read_snapshot(snapshot_id)));
+using ((select private.can_read_version(version_id)));
 
 create policy structure_snapshot_summary_fields_admin_insert
 on public.structure_snapshot_summary_fields
diff --git a/supabase/migrations/20260920310000_catalogue_publication_gate.sql b/supabase/migrations/20260920310000_catalogue_publication_gate.sql
index 57e70432..6868e542 100644
--- a/supabase/migrations/20260920310000_catalogue_publication_gate.sql
+++ b/supabase/migrations/20260920310000_catalogue_publication_gate.sql
@@ -1,32 +1,17 @@
 begin;
 
--- A manual edit must not clear the publication gate.
+-- A manual version must not clear the publication gate.
 --
--- catalogue_publish_blockers() looked for open review entries by joining
--- catalogue_import_changes on the draft snapshot's import_target_id. Only
--- persist-snapshot.ts and apply-review.ts ever set that column, so any draft
--- produced by lib/catalogue-import/manual-snapshot.ts carries null and the
--- join matched nothing. Opening a review with a blocking flag and making one
--- trivial manual edit therefore produced a draft with no target, an empty
--- blocker list and a Publish button that worked. Open changes on fields the
--- edit never touched disappeared from the gate the same way.
+-- catalogue_publish_blockers() must consider both the latest review and the
+-- version selected by that review. Manual versions do not have an import
+-- target, so resolving only through version provenance would let an open
+-- review disappear from the gate.
 --
--- The fix resolves the review through the item year rather than through the
--- draft. Two targets govern a record: the most recent one that produced a
--- review, and whichever target the current draft descends from. The first
--- catches the manual-edit bypass and also the plainer hole where a ready
--- target has never been applied, so its open changes never gated anything.
--- The second preserves the previous behaviour for an applied review whose
--- flags are still open.
---
--- Carrying import_target_id into manual snapshots was the alternative. It was
--- rejected because it does not actually close the hole: an import against a
--- record that already has a draft leaves the draft pointer alone, so the
--- draft descends from the *previous* target, and carrying that one through an
--- edit still misses the review that is open now. It would also put import
--- provenance on a snapshot whose origin is 'manual'.
+-- Two targets can therefore govern a record: the most recent one that
+-- produced a review, and whichever target produced the latest applied
+-- version. This also covers a ready target that has not yet been applied.
 
-create or replace function public.catalogue_publish_blockers(p_item_year_id bigint)
+create or replace function public.catalogue_publish_blockers(p_record_id bigint)
 returns text[]
 language sql
 stable
@@ -34,16 +19,26 @@ security definer
 set search_path = ''
 as $function$
   with item_year as (
-    select * from public.catalogue_item_years where id = p_item_year_id
+    select * from public.catalogue_records where id = p_record_id
   ),
-  draft as (
-    select snapshots.* from public.catalogue_snapshots as snapshots
-    join item_year on item_year.draft_snapshot_id = snapshots.id
+  publishable_version as (
+    select versions.*
+    from public.catalogue_versions as versions
+    join item_year on item_year.id = versions.record_id
+    left join public.catalogue_import_targets as targets
+      on targets.id = versions.import_target_id
+    where versions.sealed_at is not null
+      and (
+        versions.import_target_id is null
+        or targets.applied_version_id = versions.id
+      )
+    order by versions.created_at desc, versions.id desc
+    limit 1
   ),
   latest_review as (
     select targets.id
     from public.catalogue_import_targets as targets
-    join item_year on item_year.id = targets.item_year_id
+    join item_year on item_year.id = targets.record_id
     where targets.status in ('ready', 'unchanged')
     order by targets.created_at desc, targets.id desc
     limit 1
@@ -51,12 +46,14 @@ as $function$
   review as (
     select id from latest_review
     union
-    select import_target_id from draft where import_target_id is not null
+    select import_target_id
+    from publishable_version
+    where import_target_id is not null
   )
   select array_remove(array[
     case when not exists (select 1 from item_year) then 'The record does not exist.' end,
     case when exists (select 1 from item_year where archived_at is not null) then 'The record is archived.' end,
-    case when exists (select 1 from item_year where draft_snapshot_id is null) then 'There is no draft to publish.' end,
+    case when not exists (select 1 from publishable_version) then 'There is no version to publish.' end,
 
     case when exists (
       select 1 from review
@@ -75,11 +72,11 @@ revoke all on function public.catalogue_publish_blockers(bigint) from public, an
 grant execute on function public.catalogue_publish_blockers(bigint) to authenticated;
 
 comment on function public.catalogue_publish_blockers(bigint) is
-  'Reasons the draft of an item year cannot be published, resolved through the item year''s import review rather than through the draft snapshot alone.';
+  'Reasons the latest applied version of a catalogue record cannot be published.';
 
--- The gate reads targets by item year and status; the existing item-year index
--- does not carry status.
+-- The gate reads targets by record and status; the existing record index does
+-- not carry status.
 create index if not exists catalogue_import_targets_item_year_status_idx
-  on public.catalogue_import_targets (item_year_id, status, created_at desc);
+  on public.catalogue_import_targets (record_id, status, created_at desc);
 
 commit;
diff --git a/supabase/migrations/20260920320000_catalogue_import_recovery.sql b/supabase/migrations/20260920320000_catalogue_import_recovery.sql
index 0ea231b2..b4add81e 100644
--- a/supabase/migrations/20260920320000_catalogue_import_recovery.sql
+++ b/supabase/migrations/20260920320000_catalogue_import_recovery.sql
@@ -6,7 +6,7 @@ begin;
 -- statement to escape:
 --
 -- 1. A target whose worker dies mid-flight goes back to 'queued'. The partial
---    unique index catalogue_import_targets_active_item_year_idx then refuses
+--    unique index catalogue_import_targets_active_record_idx then refuses
 --    every further import for that item year, and start_catalogue_import
 --    raises "already has an unfinished import". The only sweep that could
 --    clear it, private.recover_stale_catalogue_import_targets(), waits thirty
@@ -19,7 +19,7 @@ begin;
 --    delete trigger that raises unconditionally on DELETE, although its own
 --    comment says "Cascading deletes from an item year still pass". They did
 --    not. Combined with ensureItemIds() in persist-snapshot.ts creating a
---    placeholder catalogue_items row for any regex-valid code a model emits,
+--    placeholder catalogue_codes row for any regex-valid code a model emits,
 --    one hallucinated code was permanent.
 
 -- 1 and 2: recovery ---------------------------------------------------------------------
@@ -252,12 +252,12 @@ begin
       return old;
     end if;
     if not exists (
-      select 1 from public.catalogue_item_years where id = old.item_year_id
+      select 1 from public.catalogue_records where id = old.record_id
     ) then
       return old;
     end if;
     raise exception
-      'catalogue_snapshots records are immutable; a sealed snapshot cannot be deleted'
+      'catalogue_versions records are immutable; a sealed snapshot cannot be deleted'
       using errcode = '55000';
   end if;
   if old.sealed_at is null
@@ -274,7 +274,7 @@ begin
     return new;
   end if;
   raise exception
-    'catalogue_snapshots records are immutable; create a new snapshot instead'
+    'catalogue_versions records are immutable; create a new snapshot instead'
     using errcode = '55000';
 end;
 $function$;
@@ -308,7 +308,7 @@ begin
   end if;
 
   select id into selected_item_id
-  from public.catalogue_items
+  from public.catalogue_codes
   where kind = p_kind and code = normalised_code;
 
   if selected_item_id is null then
@@ -317,21 +317,34 @@ begin
 
   if exists (
     select 1
-    from public.catalogue_snapshots as snapshots
-    join public.catalogue_item_years as item_years on item_years.id = snapshots.item_year_id
-    where item_years.item_id = selected_item_id and snapshots.sealed_at is not null
+    from public.catalogue_versions as snapshots
+    join public.catalogue_records as item_years on item_years.id = snapshots.record_id
+    where item_years.code_id = selected_item_id and snapshots.sealed_at is not null
   ) then
     raise exception using
       errcode = '55000',
       message = 'This record has drafted or published content and cannot be deleted.';
   end if;
 
-  if exists (select 1 from public.requirement_conditions where item_id = selected_item_id)
-    or exists (select 1 from public.requirement_condition_options where item_id = selected_item_id)
-    or exists (select 1 from public.requirement_item_references where item_id = selected_item_id)
+  if exists (select 1 from public.requirement_conditions where code_id = selected_item_id)
+    or exists (select 1 from public.requirement_condition_options where code_id = selected_item_id)
+    or exists (select 1 from public.requirement_item_references where code_id = selected_item_id)
     or exists (select 1 from public.course_related_courses where related_course_id = selected_item_id)
-    or exists (select 1 from public.plan_items where course_id = selected_item_id)
-    or exists (select 1 from public.course_attempts where course_id = selected_item_id)
+    or exists (
+      select 1
+      from public.plan_items
+      join public.catalogue_records as records
+        on records.id = plan_items.catalogue_record_id
+      where records.code_id = selected_item_id
+    )
+    or exists (
+      select 1
+      from public.course_attempts
+      join public.catalogue_versions as versions
+        on versions.id = course_attempts.catalogue_version_id
+      join public.catalogue_records as records on records.id = versions.record_id
+      where records.code_id = selected_item_id
+    )
   then
     raise exception using
       errcode = '55000',
@@ -339,19 +352,19 @@ begin
   end if;
 
   update public.catalogue_directory_entries
-  set item_id = null
-  where item_id = selected_item_id;
+  set code_id = null
+  where code_id = selected_item_id;
 
   with removed as (
     delete from public.catalogue_import_targets as targets
-    using public.catalogue_item_years as item_years
-    where item_years.item_id = selected_item_id
-      and targets.item_year_id = item_years.id
+    using public.catalogue_records as item_years
+    where item_years.code_id = selected_item_id
+      and targets.record_id = item_years.id
     returning targets.run_id
   )
   select array_agg(distinct run_id) into affected_runs from removed;
 
-  delete from public.catalogue_items where id = selected_item_id;
+  delete from public.catalogue_codes where id = selected_item_id;
 
   if affected_runs is not null then
     perform private.refresh_catalogue_import_run(run_id)
diff --git a/supabase/migrations/20260920330000_backfill_applied_first_imports.sql b/supabase/migrations/20260920330000_backfill_applied_first_imports.sql
index f5f977bd..8205a5f0 100644
--- a/supabase/migrations/20260920330000_backfill_applied_first_imports.sql
+++ b/supabase/migrations/20260920330000_backfill_applied_first_imports.sql
@@ -3,26 +3,17 @@ begin;
 -- A first import records itself as applied.
 --
 -- When a target has no baseline its changes are recorded as already accepted
--- and the candidate becomes the draft without anyone pressing Apply, so
--- applied_snapshot_id was never set. The target then kept reporting "ready",
+-- and the candidate becomes the applied version without anyone pressing Apply, so
+-- applied_version_id was never set. The target then kept reporting "ready",
 -- which the import runs list showed as "Ready for review" for a record that
 -- had since been published. persist-snapshot.ts now sets it at the point the
--- candidate becomes the draft; this backfills the rows written before that.
+-- candidate becomes current; this backfills the rows written before that.
 --
--- Only targets whose candidate is still the record's draft or published
--- snapshot are touched. A candidate that was superseded was never applied.
-
 update public.catalogue_import_targets as targets
-set applied_snapshot_id = targets.candidate_snapshot_id,
+set applied_version_id = targets.candidate_version_id,
     applied_at = coalesce(targets.applied_at, targets.completed_at, now())
-from public.catalogue_item_years as item_years
-where item_years.id = targets.item_year_id
-  and targets.change_kind = 'new'
-  and targets.applied_snapshot_id is null
-  and targets.candidate_snapshot_id is not null
-  and targets.candidate_snapshot_id in (
-    item_years.draft_snapshot_id,
-    item_years.published_snapshot_id
-  );
+where targets.change_kind = 'new'
+  and targets.applied_version_id is null
+  and targets.candidate_version_id is not null;
 
 commit;
diff --git a/supabase/tests/database/academic_result_editing.sql b/supabase/tests/database/academic_result_editing.sql
index 143920cd..b3eab14e 100644
--- a/supabase/tests/database/academic_result_editing.sql
+++ b/supabase/tests/database/academic_result_editing.sql
@@ -1,5 +1,11 @@
 begin;
+\ir ../helpers/catalogue-fixtures.inc
 select extensions.plan(10);
+select pg_temp.publish_course('COMP1100', 2026::smallint, 'Programming as Problem Solving', 'fixed', 6);
+insert into public.academic_periods (
+  calendar_year, code, name, short_name, starts_on, ends_on, sort_order, status
+) values (2026, 'S1', 'Semester 1', 'S1', '2026-02-23', '2026-05-29', 1, 'published')
+on conflict (calendar_year, code) do nothing;
 select extensions.ok(not has_function_privilege('anon','public.save_current_user_academic_result(uuid,text,numeric,text,numeric)','execute'),'anonymous users cannot edit results');
 insert into auth.users (instance_id,id,aud,role,email,raw_app_meta_data,raw_user_meta_data,created_at,updated_at) values ('00000000-0000-0000-0000-000000000000','96000000-0000-4000-8000-000000000001','authenticated','authenticated','academic-edit@example.test','{}','{}',now(),now());
 insert into public.plans(owner_id,academic_year_id,name,is_primary,commencement_year,study_load) values ('96000000-0000-4000-8000-000000000001',(select id from public.academic_years where year=2026),'Academic test',true,2026,'full_time');
diff --git a/supabase/tests/database/approval_workflow.sql b/supabase/tests/database/approval_workflow.sql
index 0e399270..fcc2de72 100644
--- a/supabase/tests/database/approval_workflow.sql
+++ b/supabase/tests/database/approval_workflow.sql
@@ -63,15 +63,17 @@ insert into public.plan_items (
   id,
   plan_id,
   owner_id,
-  course_id,
-  academic_year_id
+  catalogue_record_id
 )
 values (
   '32000000-0000-4000-8000-000000000001',
   '31000000-0000-4000-8000-000000000001',
   '30000000-0000-4000-8000-000000000001',
-  (select id from public.catalogue_items where code = 'TEST1000'),
-  (select id from public.academic_years where year = 2029)
+  (select item_years.id
+   from public.catalogue_records as item_years
+   join public.catalogue_codes as items on items.id = item_years.code_id
+   join public.academic_years as years on years.id = item_years.academic_year_id
+   where items.code = 'TEST1000' and years.year = 2029)
 );
 
 select set_config(
diff --git a/supabase/tests/database/catalogue_items.sql b/supabase/tests/database/catalogue_domain.sql
similarity index 51%
rename from supabase/tests/database/catalogue_items.sql
rename to supabase/tests/database/catalogue_domain.sql
index 94227819..8a6d2102 100644
--- a/supabase/tests/database/catalogue_items.sql
+++ b/supabase/tests/database/catalogue_domain.sql
@@ -3,7 +3,7 @@ begin;
 
 create extension if not exists pgtap with schema extensions;
 
-select extensions.plan(30);
+select extensions.plan(34);
 
 -- Structure -------------------------------------------------------------------------
 
@@ -13,13 +13,13 @@ select extensions.is(
     from information_schema.tables
     where table_schema = 'public'
       and table_name in (
-        'catalogue_items',
-        'catalogue_item_years',
-        'catalogue_snapshots',
+        'catalogue_codes',
+        'catalogue_records',
+        'catalogue_versions',
         'catalogue_publications',
-        'course_snapshot_details',
-        'structure_snapshot_details',
-        'snapshot_field_evidence'
+        'course_version_details',
+        'structure_version_details',
+        'catalogue_version_provenance'
       )
   ),
   7::bigint,
@@ -46,13 +46,13 @@ select extensions.is(
       on namespaces.oid = relations.relnamespace
     where namespaces.nspname = 'public'
       and relations.relname in (
-        'catalogue_items',
-        'catalogue_item_years',
-        'catalogue_snapshots',
+        'catalogue_codes',
+        'catalogue_records',
+        'catalogue_versions',
         'catalogue_publications',
-        'course_snapshot_details',
-        'structure_snapshot_details',
-        'snapshot_field_evidence'
+        'course_version_details',
+        'structure_version_details',
+        'catalogue_version_provenance'
       )
       and relations.relrowsecurity
   ),
@@ -61,28 +61,62 @@ select extensions.is(
 );
 
 select extensions.throws_ok(
-  $$ insert into public.catalogue_items (kind, code) values ('course', 'not-a-code') $$,
+  $$ insert into public.catalogue_codes (kind, code) values ('course', 'not-a-code') $$,
   '23514',
   null,
   'course codes follow the ANU format'
 );
 
 select extensions.throws_ok(
-  $$ insert into public.catalogue_items (kind, code) values ('degree', 'X') $$,
+  $$ insert into public.catalogue_codes (kind, code) values ('degree', 'X') $$,
   '23514',
   null,
   'only the five catalogue kinds are accepted'
 );
 
+insert into public.catalogue_codes (kind, code)
+values
+  ('course', 'KIND1000'),
+  ('programme', 'KIND-PROG'),
+  ('major', 'KIND-MAJ'),
+  ('minor', 'KINDA-MIN'),
+  ('specialisation', 'KIND-SPEC');
+
+select extensions.is(
+  (select count(distinct kind) from public.catalogue_codes where code like 'KIND%'),
+  5::bigint,
+  'all five catalogue kinds share the code model'
+);
+
+select extensions.throws_ok(
+  $$ insert into public.catalogue_codes (kind, code) values ('course', 'KIND1000') $$,
+  '23505',
+  null,
+  'a typed catalogue code is unique'
+);
+
 -- Kind consistency --------------------------------------------------------------------
 
 select pg_temp.catalogue_item_year('programme', 'FIX-PROG', 2029::smallint);
 
 select extensions.throws_ok(
   $$
-    insert into public.catalogue_item_years (item_id, kind, academic_year_id)
+    insert into public.catalogue_records (code_id, kind, academic_year_id)
+    select records.code_id, records.kind, records.academic_year_id
+    from public.catalogue_records as records
+    join public.catalogue_codes as codes on codes.id = records.code_id
+    where codes.code = 'FIX-PROG'
+  $$,
+  '23505',
+  null,
+  'a catalogue code has only one record in an academic year'
+);
+
+select extensions.throws_ok(
+  $$
+    insert into public.catalogue_records (code_id, kind, academic_year_id)
     select items.id, 'course', years.id
-    from public.catalogue_items as items
+    from public.catalogue_codes as items
     cross join public.academic_years as years
     where items.code = 'FIX-PROG' and years.year = 2028
   $$,
@@ -95,11 +129,11 @@ select pg_temp.create_structure_snapshot('programme', 'FIX-PROG', 2029::smallint
 
 select extensions.throws_ok(
   $$
-    insert into public.course_snapshot_details (snapshot_id, title, units, level, subject_code)
+    insert into public.course_version_details (version_id, title, units, level, subject_code)
     select snapshots.id, 'Wrong kind', 6, 1000, 'FIXP'
-    from public.catalogue_snapshots as snapshots
-    join public.catalogue_item_years as item_years on item_years.id = snapshots.item_year_id
-    join public.catalogue_items as items on items.id = item_years.item_id
+    from public.catalogue_versions as snapshots
+    join public.catalogue_records as item_years on item_years.id = snapshots.record_id
+    join public.catalogue_codes as items on items.id = item_years.code_id
     where items.code = 'FIX-PROG'
   $$,
   '23503',
@@ -113,10 +147,10 @@ select pg_temp.create_course_snapshot('FIXT1000', 2029::smallint, 'Fixture draft
 
 select extensions.lives_ok(
   $$
-    insert into public.course_fees (snapshot_id, position, fee_year, audience, fee_type, amount, currency, basis, source_label, source_text)
+    insert into public.course_fees (version_id, position, fee_year, audience, fee_type, amount, currency, basis, source_label, source_text)
     select snapshots.id, 1, 2029, 'domestic', 'indicative', 1000, 'AUD', 'course', 'Fee', 'Fee'
-    from public.catalogue_snapshots as snapshots
-    join public.course_snapshot_details as details on details.snapshot_id = snapshots.id
+    from public.catalogue_versions as snapshots
+    join public.course_version_details as details on details.version_id = snapshots.id
     where details.title = 'Fixture draft'
   $$,
   'child rows can be assembled while a snapshot is unsealed'
@@ -126,8 +160,8 @@ select extensions.is(
   (
     select count(*)
     from public.catalogue_publications as publications
-    join public.catalogue_item_years as item_years on item_years.id = publications.item_year_id
-    join public.catalogue_items as items on items.id = item_years.item_id
+    join public.catalogue_records as item_years on item_years.id = publications.record_id
+    join public.catalogue_codes as items on items.id = item_years.code_id
     where items.code = 'FIXT1000'
   ),
   0::bigint,
@@ -136,16 +170,16 @@ select extensions.is(
 
 select pg_temp.publish_snapshot((
   select snapshots.id
-  from public.catalogue_snapshots as snapshots
-  join public.course_snapshot_details as details on details.snapshot_id = snapshots.id
+  from public.catalogue_versions as snapshots
+  join public.course_version_details as details on details.version_id = snapshots.id
   where details.title = 'Fixture draft'
 ));
 
 select extensions.ok(
   (
     select snapshots.sealed_at is not null
-    from public.catalogue_snapshots as snapshots
-    join public.course_snapshot_details as details on details.snapshot_id = snapshots.id
+    from public.catalogue_versions as snapshots
+    join public.course_version_details as details on details.version_id = snapshots.id
     where details.title = 'Fixture draft'
   ),
   'setting the published pointer seals the snapshot'
@@ -155,8 +189,8 @@ select extensions.is(
   (
     select count(*)
     from public.catalogue_publications as publications
-    join public.catalogue_snapshots as snapshots on snapshots.id = publications.snapshot_id
-    join public.course_snapshot_details as details on details.snapshot_id = snapshots.id
+    join public.catalogue_versions as snapshots on snapshots.id = publications.version_id
+    join public.course_version_details as details on details.version_id = snapshots.id
     where details.title = 'Fixture draft'
   ),
   1::bigint,
@@ -165,10 +199,10 @@ select extensions.is(
 
 select extensions.throws_ok(
   $$
-    insert into public.course_fees (snapshot_id, position, fee_year, audience, fee_type, amount, currency, basis, source_label, source_text)
+    insert into public.course_fees (version_id, position, fee_year, audience, fee_type, amount, currency, basis, source_label, source_text)
     select snapshots.id, 2, 2029, 'domestic', 'indicative', 1000, 'AUD', 'course', 'Fee', 'Fee'
-    from public.catalogue_snapshots as snapshots
-    join public.course_snapshot_details as details on details.snapshot_id = snapshots.id
+    from public.catalogue_versions as snapshots
+    join public.course_version_details as details on details.version_id = snapshots.id
     where details.title = 'Fixture draft'
   $$,
   '55000',
@@ -178,7 +212,7 @@ select extensions.throws_ok(
 
 select extensions.throws_ok(
   $$
-    update public.course_snapshot_details set title = 'Edited' where title = 'Fixture draft'
+    update public.course_version_details set title = 'Edited' where title = 'Fixture draft'
   $$,
   '55000',
   null,
@@ -186,14 +220,14 @@ select extensions.throws_ok(
 );
 
 select extensions.throws_ok(
-  $$ update public.catalogue_snapshots set origin = 'import' where kind = 'course' $$,
+  $$ update public.catalogue_versions set origin = 'import' where kind = 'course' $$,
   '55000',
   null,
   'sealed snapshots are immutable'
 );
 
 select extensions.throws_ok(
-  $$ delete from public.catalogue_snapshots where kind = 'course' $$,
+  $$ delete from public.catalogue_versions where kind = 'course' $$,
   '55000',
   null,
   'snapshots cannot be deleted'
@@ -201,69 +235,80 @@ select extensions.throws_ok(
 
 select pg_temp.create_course_snapshot('FIXT1000', 2029::smallint, 'Fixture revision');
 
-update public.catalogue_item_years as item_years
-set draft_snapshot_id = snapshots.id
-from public.catalogue_snapshots as snapshots
-join public.course_snapshot_details as details on details.snapshot_id = snapshots.id
-where details.title = 'Fixture revision'
-  and item_years.id = snapshots.item_year_id;
+select extensions.lives_ok(
+  $$
+    insert into public.catalogue_versions (
+      record_id, kind, academic_year_id, origin, based_on_version_id, content_hash
+    )
+    select revisions.record_id, revisions.kind, revisions.academic_year_id,
+      'manual', originals.id, repeat('a', 64)
+    from public.catalogue_versions as revisions
+    join public.course_version_details as revision_details
+      on revision_details.version_id = revisions.id
+    join public.catalogue_versions as originals
+      on originals.record_id = revisions.record_id
+    join public.course_version_details as original_details
+      on original_details.version_id = originals.id
+    where revision_details.title = 'Fixture revision'
+      and original_details.title = 'Fixture draft'
+  $$,
+  'version lineage can reference an earlier version of the same record'
+);
 
 select extensions.ok(
   (
-    select snapshots.sealed_at is not null
-    from public.catalogue_snapshots as snapshots
-    join public.course_snapshot_details as details on details.snapshot_id = snapshots.id
+    select versions.sealed_at is null
+    from public.catalogue_versions as versions
+    join public.course_version_details as details on details.version_id = versions.id
     where details.title = 'Fixture revision'
   ),
-  'setting the draft pointer also seals the snapshot'
+  'a new version remains mutable while it is assembled'
 );
 
 select extensions.is(
   (
     select count(*)
     from public.catalogue_publications as publications
-    join public.catalogue_item_years as item_years on item_years.id = publications.item_year_id
-    join public.catalogue_items as items on items.id = item_years.item_id
+    join public.catalogue_records as item_years on item_years.id = publications.record_id
+    join public.catalogue_codes as items on items.id = item_years.code_id
     where items.code = 'FIXT1000'
   ),
   1::bigint,
-  'a draft pointer does not create a publication record'
+  'creating a new version does not publish it'
 );
 
-select extensions.throws_ok(
+select extensions.lives_ok(
   $$
-    update public.catalogue_item_years
-    set published_snapshot_id = draft_snapshot_id
-    where draft_snapshot_id is not null
+    select pg_temp.publish_snapshot((
+      select versions.id
+      from public.catalogue_versions as versions
+      join public.course_version_details as details on details.version_id = versions.id
+      where details.title = 'Fixture revision'
+    ))
   $$,
-  '23514',
-  null,
-  'a snapshot cannot be both the draft and the published version'
+  'publishing a new version seals it without a draft phase'
 );
 
-update public.catalogue_item_years
-set published_snapshot_id = draft_snapshot_id, draft_snapshot_id = null
-where draft_snapshot_id is not null;
-
 select extensions.is(
   (
-    select count(*)
+    select count(*) filter (where unpublished_at is not null) * 10
+      + count(*) filter (where unpublished_at is null)
     from public.catalogue_publications as publications
-    join public.catalogue_item_years as item_years on item_years.id = publications.item_year_id
-    join public.catalogue_items as items on items.id = item_years.item_id
+    join public.catalogue_records as item_years on item_years.id = publications.record_id
+    join public.catalogue_codes as items on items.id = item_years.code_id
     where items.code = 'FIXT1000'
   ),
-  2::bigint,
-  'republishing appends to the ledger'
+  11::bigint,
+  'publishing a new version closes the old interval and opens the new one'
 );
 
 select extensions.throws_ok(
   $$
-    update public.catalogue_item_years
-    set published_snapshot_id = (
+    update public.catalogue_records
+    set published_version_id = (
       select snapshots.id
-      from public.catalogue_snapshots as snapshots
-      join public.course_snapshot_details as details on details.snapshot_id = snapshots.id
+      from public.catalogue_versions as snapshots
+      join public.course_version_details as details on details.version_id = snapshots.id
       where details.title = 'Fixture draft'
     )
     where kind = 'programme'
@@ -295,16 +340,19 @@ values (
   'Catalogue test', true, 2029, 'full_time'
 );
 
-insert into public.plan_items (plan_id, owner_id, course_id, academic_year_id)
-select plans.id, plans.owner_id, items.id, plans.academic_year_id
+insert into public.plan_items (plan_id, owner_id, catalogue_record_id)
+select plans.id, plans.owner_id, item_years.id
 from public.plans
-join public.catalogue_items as items on items.code = 'FIXT2000'
+join public.catalogue_codes as items on items.code = 'FIXT2000'
+join public.catalogue_records as item_years
+  on item_years.code_id = items.id
+  and item_years.academic_year_id = plans.academic_year_id
 where plans.owner_id = '97000000-0000-4000-8000-000000000001';
 
 select extensions.throws_ok(
   $$
-    update public.catalogue_item_years set archived_at = now()
-    where item_id = (select id from public.catalogue_items where code = 'FIXT2000')
+    update public.catalogue_records set archived_at = now()
+    where code_id = (select id from public.catalogue_codes where code = 'FIXT2000')
   $$,
   '55000',
   null,
@@ -313,10 +361,13 @@ select extensions.throws_ok(
 
 select extensions.throws_ok(
   $$
-    insert into public.plan_items (plan_id, owner_id, course_id, academic_year_id)
-    select plans.id, plans.owner_id, items.id, plans.academic_year_id
+    insert into public.plan_items (plan_id, owner_id, catalogue_record_id)
+    select plans.id, plans.owner_id, item_years.id
     from public.plans
-    join public.catalogue_items as items on items.code = 'FIX-PROG'
+    join public.catalogue_codes as items on items.code = 'FIX-PROG'
+    join public.catalogue_records as item_years
+      on item_years.code_id = items.id
+      and item_years.academic_year_id = plans.academic_year_id
     where plans.owner_id = '97000000-0000-4000-8000-000000000001'
   $$,
   'P0002',
@@ -326,13 +377,13 @@ select extensions.throws_ok(
 
 delete from public.plan_items where owner_id = '97000000-0000-4000-8000-000000000001';
 
-update public.catalogue_item_years set archived_at = now()
-where item_id = (select id from public.catalogue_items where code = 'FIXT2000');
+update public.catalogue_records set archived_at = now()
+where code_id = (select id from public.catalogue_codes where code = 'FIXT2000');
 
 select extensions.throws_ok(
   $$
-    update public.catalogue_item_years set archived_at = null
-    where item_id = (select id from public.catalogue_items where code = 'FIXT2000')
+    update public.catalogue_records set archived_at = null
+    where code_id = (select id from public.catalogue_codes where code = 'FIXT2000')
   $$,
   '55000',
   null,
@@ -341,10 +392,13 @@ select extensions.throws_ok(
 
 select extensions.throws_ok(
   $$
-    insert into public.plan_items (plan_id, owner_id, course_id, academic_year_id)
-    select plans.id, plans.owner_id, items.id, plans.academic_year_id
+    insert into public.plan_items (plan_id, owner_id, catalogue_record_id)
+    select plans.id, plans.owner_id, item_years.id
     from public.plans
-    join public.catalogue_items as items on items.code = 'FIXT2000'
+    join public.catalogue_codes as items on items.code = 'FIXT2000'
+    join public.catalogue_records as item_years
+      on item_years.code_id = items.id
+      and item_years.academic_year_id = plans.academic_year_id
     where plans.owner_id = '97000000-0000-4000-8000-000000000001'
   $$,
   '55000',
@@ -360,32 +414,33 @@ insert into public.academic_periods (
 
 select extensions.throws_ok(
   $$
-    insert into public.course_attempts (owner_id, course_id, course_snapshot_id, academic_period_id, status, units_attempted)
+    insert into public.course_attempts (owner_id, catalogue_version_id, academic_period_id, status, units_attempted)
     select
       '97000000-0000-4000-8000-000000000001',
-      (select id from public.catalogue_items where code = 'FIXT1000'),
-      (select published_snapshot_id from public.catalogue_item_years where item_id = (select id from public.catalogue_items where code = 'FIXT2000')),
+      (select versions.id
+       from public.catalogue_versions as versions
+       join public.catalogue_records as records on records.id = versions.record_id
+       where records.kind = 'programme' limit 1),
       (select id from public.academic_periods where code = 'FIX-S1'),
       'completed',
       6
   $$,
   '23503',
   null,
-  'an attempt snapshot must belong to the attempted course'
+  'an attempt version must belong to a course record'
 );
 
 select extensions.lives_ok(
   $$
-    insert into public.course_attempts (owner_id, course_id, course_snapshot_id, academic_period_id, status, units_attempted)
+    insert into public.course_attempts (owner_id, catalogue_version_id, academic_period_id, status, units_attempted)
     select
       '97000000-0000-4000-8000-000000000001',
-      (select id from public.catalogue_items where code = 'FIXT1000'),
-      (select published_snapshot_id from public.catalogue_item_years where item_id = (select id from public.catalogue_items where code = 'FIXT1000')),
+      (select published_version_id from public.catalogue_records where code_id = (select id from public.catalogue_codes where code = 'FIXT1000')),
       (select id from public.academic_periods where code = 'FIX-S1'),
       'completed',
       6
   $$,
-  'an attempt records the published snapshot of its course'
+  'an attempt records an exact course version'
 );
 
 -- Access --------------------------------------------------------------------------------
@@ -396,14 +451,14 @@ set local role anon;
 
 select extensions.results_eq(
   $$
-    select code from public.catalogue_items where code like 'FIXT%' order by code
+    select code from public.catalogue_codes where code like 'FIXT%' order by code
   $$,
   $$ values ('FIXT1000'::text) $$,
   'anonymous readers see identities with a published, unarchived year only'
 );
 
 select extensions.is(
-  (select count(*) from public.course_snapshot_details where title in ('Fixture draft', 'Never published')),
+  (select count(*) from public.course_version_details where title in ('Fixture draft', 'Never published')),
   0::bigint,
   'anonymous readers cannot see superseded or unpublished snapshots'
 );
diff --git a/supabase/tests/database/catalogue_write_permissions.sql b/supabase/tests/database/catalogue_write_permissions.sql
index 71e19dd0..58e5eece 100644
--- a/supabase/tests/database/catalogue_write_permissions.sql
+++ b/supabase/tests/database/catalogue_write_permissions.sql
@@ -73,14 +73,14 @@ select extensions.ok(
 );
 
 select extensions.throws_ok(
-  $$ insert into public.catalogue_items (kind, code) values ('course', 'PWND1234') $$,
+  $$ insert into public.catalogue_codes (kind, code) values ('course', 'PWND1234') $$,
   '42501',
   null,
   'a student cannot create a catalogue item'
 );
 
 select extensions.throws_ok(
-  $$ update public.catalogue_item_years set published_snapshot_id = null $$,
+  $$ update public.catalogue_records set published_version_id = null $$,
   '42501',
   null,
   'a student cannot unpublish a catalogue record'
@@ -88,9 +88,9 @@ select extensions.throws_ok(
 
 select extensions.throws_ok(
   $$
-    insert into public.catalogue_snapshots (item_year_id, kind, academic_year_id, origin)
+    insert into public.catalogue_versions (record_id, kind, academic_year_id, origin)
     select item_years.id, item_years.kind, item_years.academic_year_id, 'manual'
-    from public.catalogue_item_years as item_years limit 1
+    from public.catalogue_records as item_years limit 1
   $$,
   '42501',
   null,
diff --git a/supabase/tests/database/course_attempt_units.sql b/supabase/tests/database/course_attempt_units.sql
index 2f99eb06..a0fe7e52 100644
--- a/supabase/tests/database/course_attempt_units.sql
+++ b/supabase/tests/database/course_attempt_units.sql
@@ -5,6 +5,15 @@ create extension if not exists pgtap with schema extensions;
 
 select extensions.plan(27);
 
+select pg_temp.publish_course(
+  'COMP1100', 2026::smallint, 'Programming as Problem Solving', 'fixed', 6
+);
+
+insert into public.academic_periods (
+  calendar_year, code, name, short_name, starts_on, ends_on, sort_order, status
+) values (2026, 'S1', 'Semester 1', 'S1', '2026-02-23', '2026-05-29', 1, 'published')
+on conflict (calendar_year, code) do nothing;
+
 select extensions.ok(
   has_function_privilege(
     'authenticated',
@@ -25,12 +34,12 @@ select extensions.ok(
 select extensions.ok(
   has_function_privilege(
     'authenticated',
-    'public.current_user_course_attempt_snapshot_projections(bigint[])',
+    'public.current_user_course_attempt_version_projections(bigint[])',
     'execute'
   )
   and not has_function_privilege(
     'anon',
-    'public.current_user_course_attempt_snapshot_projections(bigint[])',
+    'public.current_user_course_attempt_version_projections(bigint[])',
     'execute'
   )
   and (
@@ -38,7 +47,7 @@ select extensions.ok(
     from pg_catalog.pg_policies
     where schemaname = 'public'
       and tablename in (
-        'course_snapshot_details', 'course_offerings', 'offering_sessions',
+        'course_version_details', 'course_offerings', 'offering_sessions',
         'course_learning_outcomes', 'course_assessment_items',
         'course_assessment_outcomes', 'course_fees', 'course_attributes',
         'course_unit_options', 'course_areas_of_interest',
@@ -47,7 +56,7 @@ select extensions.ok(
         'requirement_item_references'
       )
       and policyname like '%\_read'
-      and qual like '%can_read_snapshot(%.snapshot_id)%'
+      and qual like '%can_read_version(%.version_id)%'
   ),
   'attempt owners alone receive the exact historical projection contract and rich-row policies'
 );
@@ -84,7 +93,7 @@ create temporary table fixture_snapshots on commit drop as
 select
   'RANG1000'::text as code,
   1 as version,
-  pg_temp.create_course_snapshot('RANG1000', 2026::smallint, 'Range course', 'range', null, 6, 12) as snapshot_id
+  pg_temp.create_course_snapshot('RANG1000', 2026::smallint, 'Range course', 'range', null, 6, 12) as version_id
 union all
 select
   'VARI1000',
@@ -99,10 +108,10 @@ select
 grant select on table fixture_snapshots to authenticated;
 
 insert into public.course_unit_options (
-  snapshot_id, position, units, label, source_text
+  version_id, position, units, label, source_text
 )
 select
-  fixture.snapshot_id,
+  fixture.version_id,
   options.position,
   options.units,
   options.units::text || ' units',
@@ -120,7 +129,7 @@ cross join lateral (
 where fixture.code = 'VARI1000';
 
 insert into public.requirement_rules (
-  snapshot_id,
+  version_id,
   academic_year_id,
   rule_kind,
   hardness,
@@ -129,7 +138,7 @@ insert into public.requirement_rules (
   confidence
 )
 select
-  fixture.snapshot_id,
+  fixture.version_id,
   snapshots.academic_year_id,
   'prerequisite',
   'hard',
@@ -137,30 +146,30 @@ select
   case fixture.version when 1 then 'verified' else 'review' end,
   case fixture.version when 1 then 0.91 else 0.41 end
 from fixture_snapshots as fixture
-join public.catalogue_snapshots as snapshots on snapshots.id = fixture.snapshot_id
+join public.catalogue_versions as snapshots on snapshots.id = fixture.version_id
 where fixture.code = 'VARI1000';
 
 insert into public.requirement_groups (
   rule_id,
-  snapshot_id,
+  version_id,
   group_key,
   parent_group_id,
   operator,
   minimum_count,
   position
 )
-select rules.id, rules.snapshot_id, 'prerequisite:group:root', null, 'all_of', null, 0
+select rules.id, rules.version_id, 'prerequisite:group:root', null, 'all_of', null, 0
 from public.requirement_rules as rules
-join fixture_snapshots as fixture on fixture.snapshot_id = rules.snapshot_id
+join fixture_snapshots as fixture on fixture.version_id = rules.version_id
 where fixture.code = 'VARI1000';
 
 insert into public.requirement_conditions (
   rule_id,
-  snapshot_id,
+  version_id,
   condition_key,
   group_id,
   condition_kind,
-  item_id,
+  code_id,
   item_kind,
   requirement_mode,
   hardness,
@@ -171,7 +180,7 @@ insert into public.requirement_conditions (
 )
 select
   rules.id,
-  rules.snapshot_id,
+  rules.version_id,
   'prerequisite:condition:direct',
   groups.id,
   'course',
@@ -184,36 +193,36 @@ select
   case fixture.version when 1 then 'verified' else 'review' end,
   0
 from public.requirement_rules as rules
-join fixture_snapshots as fixture on fixture.snapshot_id = rules.snapshot_id
+join fixture_snapshots as fixture on fixture.version_id = rules.version_id
 join public.requirement_groups as groups on groups.rule_id = rules.id
-join public.catalogue_items as prerequisites
+join public.catalogue_codes as prerequisites
   on prerequisites.kind = 'course'
  and prerequisites.code = case when fixture.version = 1 then 'RANG1000' else 'COMP1100' end
 where fixture.code = 'VARI1000';
 
 insert into public.requirement_item_references (
   rule_id,
-  snapshot_id,
-  item_id,
+  version_id,
+  code_id,
   source_text,
   confidence,
   review_state
 )
 select
   rules.id,
-  rules.snapshot_id,
+  rules.version_id,
   prerequisites.id,
   rules.source_text,
   case fixture.version when 1 then 0.83 else 0.33 end,
   case fixture.version when 1 then 'verified' else 'automatic' end
 from public.requirement_rules as rules
-join fixture_snapshots as fixture on fixture.snapshot_id = rules.snapshot_id
-join public.catalogue_items as prerequisites
+join fixture_snapshots as fixture on fixture.version_id = rules.version_id
+join public.catalogue_codes as prerequisites
   on prerequisites.kind = 'course'
  and prerequisites.code = case when fixture.version = 1 then 'RANG1000' else 'COMP1100' end
 where fixture.code = 'VARI1000';
 
-select pg_temp.publish_snapshot(fixture.snapshot_id)
+select pg_temp.publish_snapshot(fixture.version_id)
 from fixture_snapshots as fixture
 where fixture.version = 1;
 
@@ -240,7 +249,8 @@ select extensions.throws_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'COMP1100'
       ),
@@ -258,7 +268,8 @@ select extensions.ok(
   exists (
     select 1
     from public.plan_items
-    join public.catalogue_items as courses on courses.id = plan_items.course_id
+    join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
     where plan_items.owner_id = (select auth.uid())
       and courses.code = 'COMP1100'
   ),
@@ -271,7 +282,8 @@ select extensions.lives_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'COMP1100'
       ),
@@ -286,7 +298,9 @@ select extensions.ok(
   exists (
     select 1
     from public.course_attempts
-    join public.catalogue_items as courses on courses.id = course_attempts.course_id
+    join public.catalogue_versions as attempt_versions on attempt_versions.id = course_attempts.catalogue_version_id
+    join public.catalogue_records as attempt_records on attempt_records.id = attempt_versions.record_id
+    join public.catalogue_codes as courses on courses.id = attempt_records.code_id
     where course_attempts.owner_id = (select auth.uid())
       and courses.code = 'COMP1100'
       and course_attempts.units_attempted = 6
@@ -310,7 +324,8 @@ select extensions.throws_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'RANG1000'
       ),
@@ -329,7 +344,8 @@ select extensions.throws_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'RANG1000'
       ),
@@ -349,7 +365,8 @@ select extensions.throws_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'RANG1000'
       ),
@@ -369,7 +386,8 @@ select extensions.lives_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'RANG1000'
       ),
@@ -385,7 +403,9 @@ select extensions.ok(
   exists (
     select 1
     from public.course_attempts
-    join public.catalogue_items as courses on courses.id = course_attempts.course_id
+    join public.catalogue_versions as attempt_versions on attempt_versions.id = course_attempts.catalogue_version_id
+    join public.catalogue_records as attempt_records on attempt_records.id = attempt_versions.record_id
+    join public.catalogue_codes as courses on courses.id = attempt_records.code_id
     where course_attempts.owner_id = (select auth.uid())
       and courses.code = 'RANG1000'
       and course_attempts.units_attempted = 9
@@ -409,7 +429,8 @@ select extensions.throws_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'VARI1000'
       ),
@@ -428,7 +449,8 @@ select extensions.throws_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'VARI1000'
       ),
@@ -448,7 +470,8 @@ select extensions.lives_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'VARI1000'
       ),
@@ -464,9 +487,11 @@ select extensions.ok(
   exists (
     select 1
     from public.course_attempts
-    join public.catalogue_items as courses on courses.id = course_attempts.course_id
-    join public.course_snapshot_details as course_snapshots
-      on course_snapshots.snapshot_id = course_attempts.course_snapshot_id
+    join public.catalogue_versions as attempt_versions on attempt_versions.id = course_attempts.catalogue_version_id
+    join public.catalogue_records as attempt_records on attempt_records.id = attempt_versions.record_id
+    join public.catalogue_codes as courses on courses.id = attempt_records.code_id
+    join public.course_version_details as course_snapshots
+      on course_snapshots.version_id = course_attempts.catalogue_version_id
     where course_attempts.owner_id = (select auth.uid())
       and courses.code = 'VARI1000'
       and course_snapshots.title = 'Variable course v1'
@@ -478,16 +503,18 @@ select extensions.ok(
 
 reset role;
 
-select pg_temp.publish_snapshot(fixture.snapshot_id)
+select pg_temp.publish_snapshot(fixture.version_id)
 from fixture_snapshots as fixture
 where fixture.code = 'VARI1000' and fixture.version = 2;
 
 create temporary table historical_attempt_snapshots
 on commit drop
 as
-select course_attempts.course_snapshot_id as snapshot_id
+select course_attempts.catalogue_version_id as version_id
 from public.course_attempts
-join public.catalogue_items as courses on courses.id = course_attempts.course_id
+join public.catalogue_versions as attempt_versions on attempt_versions.id = course_attempts.catalogue_version_id
+    join public.catalogue_records as attempt_records on attempt_records.id = attempt_versions.record_id
+    join public.catalogue_codes as courses on courses.id = attempt_records.code_id
 where course_attempts.owner_id = '95000000-0000-4000-8000-000000000001'
   and courses.code = 'VARI1000';
 
@@ -498,10 +525,10 @@ set local role authenticated;
 select extensions.ok(
   exists (
     select 1
-    from public.catalogue_item_years as course_years
-    join public.catalogue_items as courses on courses.id = course_years.item_id
-    join public.course_snapshot_details as course_snapshots
-      on course_snapshots.snapshot_id = course_years.published_snapshot_id
+    from public.catalogue_records as course_years
+    join public.catalogue_codes as courses on courses.id = course_years.code_id
+    join public.course_version_details as course_snapshots
+      on course_snapshots.version_id = course_years.published_version_id
     where courses.code = 'VARI1000'
       and course_snapshots.title = 'Variable course v2'
   ),
@@ -512,8 +539,8 @@ select extensions.is(
   (
     select count(*)
     from public.course_unit_options
-    where course_unit_options.snapshot_id = (
-      select snapshot_id from historical_attempt_snapshots
+    where course_unit_options.version_id = (
+      select version_id from historical_attempt_snapshots
     )
   ),
   2::bigint,
@@ -523,8 +550,8 @@ select extensions.is(
 select extensions.ok(
   exists (
     select 1
-    from public.current_user_course_attempt_snapshot_projections(array[
-      (select snapshot_id from historical_attempt_snapshots)
+    from public.current_user_course_attempt_version_projections(array[
+      (select version_id from historical_attempt_snapshots)
     ]) as projections
     where projections.projection #>> '{snapshot,title}' = 'Variable course v1'
       and jsonb_array_length(projections.projection -> 'unitOptions') = 2
@@ -564,7 +591,8 @@ select extensions.throws_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'VARI1000'
       ),
@@ -582,16 +610,19 @@ select extensions.ok(
   exists (
     select 1
     from public.plan_items
-    join public.catalogue_items as courses on courses.id = plan_items.course_id
+    join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
     where plan_items.owner_id = (select auth.uid())
       and courses.code = 'VARI1000'
   )
   and exists (
     select 1
     from public.course_attempts
-    join public.catalogue_items as courses on courses.id = course_attempts.course_id
-    join public.course_snapshot_details as course_snapshots
-      on course_snapshots.snapshot_id = course_attempts.course_snapshot_id
+    join public.catalogue_versions as attempt_versions on attempt_versions.id = course_attempts.catalogue_version_id
+    join public.catalogue_records as attempt_records on attempt_records.id = attempt_versions.record_id
+    join public.catalogue_codes as courses on courses.id = attempt_records.code_id
+    join public.course_version_details as course_snapshots
+      on course_snapshots.version_id = course_attempts.catalogue_version_id
     where course_attempts.owner_id = (select auth.uid())
       and courses.code = 'VARI1000'
       and course_snapshots.title = 'Variable course v1'
@@ -607,7 +638,8 @@ select extensions.lives_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'VARI1000'
       ),
@@ -622,9 +654,11 @@ select extensions.ok(
   exists (
     select 1
     from public.course_attempts
-    join public.catalogue_items as courses on courses.id = course_attempts.course_id
-    join public.course_snapshot_details as course_snapshots
-      on course_snapshots.snapshot_id = course_attempts.course_snapshot_id
+    join public.catalogue_versions as attempt_versions on attempt_versions.id = course_attempts.catalogue_version_id
+    join public.catalogue_records as attempt_records on attempt_records.id = attempt_versions.record_id
+    join public.catalogue_codes as courses on courses.id = attempt_records.code_id
+    join public.course_version_details as course_snapshots
+      on course_snapshots.version_id = course_attempts.catalogue_version_id
     where course_attempts.owner_id = (select auth.uid())
       and courses.code = 'VARI1000'
       and course_snapshots.title = 'Variable course v1'
@@ -637,7 +671,8 @@ select extensions.ok(
   and not exists (
     select 1
     from public.plan_items
-    join public.catalogue_items as courses on courses.id = plan_items.course_id
+    join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
     where plan_items.owner_id = (select auth.uid())
       and courses.code = 'VARI1000'
   ),
@@ -654,14 +689,14 @@ select extensions.ok(
   not exists (
     select 1
     from public.course_unit_options
-    where course_unit_options.snapshot_id = (
-      select snapshot_id from historical_attempt_snapshots
+    where course_unit_options.version_id = (
+      select version_id from historical_attempt_snapshots
     )
   )
   and not exists (
     select 1
-    from public.current_user_course_attempt_snapshot_projections(array[
-      (select snapshot_id from historical_attempt_snapshots)
+    from public.current_user_course_attempt_version_projections(array[
+      (select version_id from historical_attempt_snapshots)
     ])
   ),
   'another authenticated user cannot read the owner''s historical rich rows or projection'
diff --git a/supabase/tests/database/course_planner_write_hardening.sql b/supabase/tests/database/course_planner_write_hardening.sql
index 99626911..9abf54ea 100644
--- a/supabase/tests/database/course_planner_write_hardening.sql
+++ b/supabase/tests/database/course_planner_write_hardening.sql
@@ -48,6 +48,15 @@ select pg_temp.publish_course(
   'COMP1110', 2030::smallint, 'Structured Programming 2030', 'fixed', 6
 );
 
+select pg_temp.publish_course(
+  'COMP1100', 2026::smallint, 'Programming as Problem Solving', 'fixed', 6
+);
+
+insert into public.academic_periods (
+  calendar_year, code, name, short_name, starts_on, ends_on, sort_order, status
+) values (2026, 'S1', 'Semester 1', 'S1', '2026-02-23', '2026-05-29', 1, 'published')
+on conflict (calendar_year, code) do nothing;
+
 select extensions.ok(
   not has_table_privilege('authenticated', 'public.plan_items', 'insert')
   and not has_table_privilege('authenticated', 'public.plan_items', 'update')
@@ -79,12 +88,15 @@ set local role authenticated;
 select extensions.throws_ok(
   $$
     insert into public.plan_items (
-      plan_id, owner_id, course_id, academic_year_id
+      plan_id, owner_id, catalogue_record_id
     ) values (
       (select id from public.plans where name = 'Planner hardening plan'),
       '94000000-0000-4000-8000-000000000001',
-      (select id from public.catalogue_items where code = 'COMP1100'),
-      (select id from public.academic_years where year = 2026)
+      (select records.id
+       from public.catalogue_records as records
+       join public.catalogue_codes as codes on codes.id = records.code_id
+       join public.academic_years as years on years.id = records.academic_year_id
+       where codes.code = 'COMP1100' and years.year = 2026)
     )
   $$,
   '42501',
@@ -105,8 +117,9 @@ select extensions.ok(
   exists (
     select 1
     from public.plan_items
-    join public.catalogue_items as courses on courses.id = plan_items.course_id
-    join public.academic_years on academic_years.id = plan_items.academic_year_id
+    join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
+    join public.academic_years on academic_years.id = plan_records.academic_year_id
     where plan_items.owner_id = (select auth.uid())
       and courses.code = 'COMP1110'
       and academic_years.year = 2030
@@ -123,7 +136,8 @@ select extensions.lives_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'COMP1110'
       ),
@@ -139,8 +153,9 @@ select extensions.ok(
   exists (
     select 1
     from public.plan_items
-    join public.catalogue_items as courses on courses.id = plan_items.course_id
-    join public.academic_years on academic_years.id = plan_items.academic_year_id
+    join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
+    join public.academic_years on academic_years.id = plan_records.academic_year_id
     where plan_items.owner_id = (select auth.uid())
       and courses.code = 'COMP1110'
       and academic_years.year = 2030
@@ -157,7 +172,8 @@ select extensions.throws_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'COMP1110'
       ),
@@ -177,7 +193,8 @@ select extensions.throws_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'COMP1110'
       ),
@@ -194,14 +211,17 @@ select extensions.ok(
   exists (
     select 1
     from public.plan_items
-    join public.catalogue_items as courses on courses.id = plan_items.course_id
+    join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
     where plan_items.owner_id = (select auth.uid())
       and courses.code = 'COMP1110'
   )
   and not exists (
     select 1
     from public.course_attempts
-    join public.catalogue_items as courses on courses.id = course_attempts.course_id
+    join public.catalogue_versions as attempt_versions on attempt_versions.id = course_attempts.catalogue_version_id
+    join public.catalogue_records as attempt_records on attempt_records.id = attempt_versions.record_id
+    join public.catalogue_codes as courses on courses.id = attempt_records.code_id
     where course_attempts.owner_id = (select auth.uid())
       and courses.code = 'COMP1110'
   ),
@@ -244,7 +264,8 @@ select extensions.lives_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'COMP1100'
       ),
@@ -259,8 +280,8 @@ select extensions.ok(
   exists (
     select 1
     from public.course_attempts
-    join public.course_snapshot_details as course_snapshots
-      on course_snapshots.snapshot_id = course_attempts.course_snapshot_id
+    join public.course_version_details as course_snapshots
+      on course_snapshots.version_id = course_attempts.catalogue_version_id
     where course_attempts.owner_id = (select auth.uid())
       and course_snapshots.title = 'Programming as Problem Solving'
       and course_attempts.status = 'completed'
@@ -274,11 +295,11 @@ select extensions.ok(
 select extensions.throws_ok(
   $$
     insert into public.course_attempts (
-      owner_id, course_id, course_snapshot_id, academic_period_id,
+      owner_id, catalogue_version_id, academic_period_id,
       status, mark, units_attempted, units_earned, source
     )
     select
-      owner_id, course_id, course_snapshot_id, academic_period_id,
+      owner_id, catalogue_version_id, academic_period_id,
       status, mark, units_attempted, units_earned, source
     from public.course_attempts
     where owner_id = (select auth.uid())
@@ -294,10 +315,12 @@ reset role;
 create temporary table first_attempt_state as
 select
   course_attempts.id,
-  course_attempts.course_snapshot_id,
+  course_attempts.catalogue_version_id,
   course_attempts.units_attempted
 from public.course_attempts
-join public.catalogue_items as courses on courses.id = course_attempts.course_id
+join public.catalogue_versions as attempt_versions on attempt_versions.id = course_attempts.catalogue_version_id
+    join public.catalogue_records as attempt_records on attempt_records.id = attempt_versions.record_id
+    join public.catalogue_codes as courses on courses.id = attempt_records.code_id
 where course_attempts.owner_id = '94000000-0000-4000-8000-000000000001'
   and courses.code = 'COMP1100';
 
@@ -309,28 +332,28 @@ create temporary table later_snapshot as
 select
   pg_temp.create_course_snapshot(
     'COMP1100', 2026::smallint, 'Programming as Problem Solving, revised', 'fixed', 12
-  ) as snapshot_id,
+  ) as version_id,
   item_years.id as course_year_id,
-  item_years.published_snapshot_id as previous_published_snapshot_id
-from public.catalogue_item_years as item_years
-join public.catalogue_items as items on items.id = item_years.item_id
+  item_years.published_version_id as previous_published_version_id
+from public.catalogue_records as item_years
+join public.catalogue_codes as items on items.id = item_years.code_id
 join public.academic_years on academic_years.id = item_years.academic_year_id
 where items.code = 'COMP1100'
   and academic_years.year = 2026;
 
 grant select on table first_attempt_state, later_snapshot to authenticated;
 
-select pg_temp.publish_snapshot(later_snapshot.snapshot_id) from later_snapshot;
+select pg_temp.publish_snapshot(later_snapshot.version_id) from later_snapshot;
 
 set local role authenticated;
 
 select extensions.ok(
   exists (
     select 1
-    from public.catalogue_item_years as course_years
+    from public.catalogue_records as course_years
     join later_snapshot on later_snapshot.course_year_id = course_years.id
-    where course_years.published_snapshot_id = later_snapshot.snapshot_id
-      and later_snapshot.snapshot_id <> later_snapshot.previous_published_snapshot_id
+    where course_years.published_version_id = later_snapshot.version_id
+      and later_snapshot.version_id <> later_snapshot.previous_published_version_id
   ),
   'a later revised snapshot can be published for the same course year'
 );
@@ -350,7 +373,8 @@ select extensions.lives_ok(
       (
         select plan_items.id
         from public.plan_items
-        join public.catalogue_items as courses on courses.id = plan_items.course_id
+        join public.catalogue_records as plan_records on plan_records.id = plan_items.catalogue_record_id
+    join public.catalogue_codes as courses on courses.id = plan_records.code_id
         where plan_items.owner_id = (select auth.uid())
           and courses.code = 'COMP1100'
       ),
@@ -368,8 +392,8 @@ select extensions.ok(
     join first_attempt_state on first_attempt_state.id = course_attempts.id
     join later_snapshot on true
     where course_attempts.owner_id = (select auth.uid())
-      and course_attempts.course_snapshot_id = first_attempt_state.course_snapshot_id
-      and course_attempts.course_snapshot_id <> later_snapshot.snapshot_id
+      and course_attempts.catalogue_version_id = first_attempt_state.catalogue_version_id
+      and course_attempts.catalogue_version_id <> later_snapshot.version_id
       and course_attempts.units_attempted = first_attempt_state.units_attempted
       and course_attempts.units_attempted = 6
       and course_attempts.status = 'failed'
diff --git a/supabase/tests/database/initial_coursemap_schema.sql b/supabase/tests/database/initial_coursemap_schema.sql
index 587ff7bb..0fd15ed3 100644
--- a/supabase/tests/database/initial_coursemap_schema.sql
+++ b/supabase/tests/database/initial_coursemap_schema.sql
@@ -11,12 +11,12 @@ select extensions.is(
     where table_schema = 'public'
       and table_name in (
         'academic_years',
-        'catalogue_items',
-        'catalogue_item_years',
-        'catalogue_snapshots',
+        'catalogue_codes',
+        'catalogue_records',
+        'catalogue_versions',
         'catalogue_sources',
         'catalogue_source_pages',
-        'course_snapshot_details'
+        'course_version_details'
       )
   ),
   7::bigint,
@@ -44,12 +44,12 @@ select extensions.is(
     where namespaces.nspname = 'public'
       and relations.relname in (
         'academic_years',
-        'catalogue_items',
-        'catalogue_item_years',
-        'catalogue_snapshots',
+        'catalogue_codes',
+        'catalogue_records',
+        'catalogue_versions',
         'catalogue_sources',
         'catalogue_source_pages',
-        'course_snapshot_details',
+        'course_version_details',
         'course_offerings',
         'offering_sessions',
         'course_learning_outcomes',
diff --git a/supabase/tests/database/local_preview_seed.sql b/supabase/tests/database/local_preview_seed.sql
index 3f675be5..f8696e11 100644
--- a/supabase/tests/database/local_preview_seed.sql
+++ b/supabase/tests/database/local_preview_seed.sql
@@ -66,12 +66,12 @@ select extensions.is(
 select extensions.is(
   (
     select count(*)
-    from public.catalogue_item_years
+    from public.catalogue_records
     where academic_year_id = (
       select id from public.academic_years where year = 2026
     )
       and kind = 'course'
-      and published_snapshot_id is not null
+      and published_version_id is not null
   ),
   2::bigint,
   'only the two explicitly imported preview courses have published snapshots'
@@ -80,13 +80,13 @@ select extensions.is(
 select extensions.ok(
   exists (
     select 1
-    from public.catalogue_items
+    from public.catalogue_codes
     where kind = 'course' and code = 'MATH1005'
   )
   and not exists (
     select 1
-    from public.catalogue_item_years
-    join public.catalogue_items as items on items.id = catalogue_item_years.item_id
+    from public.catalogue_records
+    join public.catalogue_codes as items on items.id = catalogue_records.code_id
     where items.code = 'MATH1005'
   ),
   'the prerequisite has an identity without invented imported content'
@@ -127,7 +127,7 @@ set local role anon;
 select extensions.is(
   (
     select count(*)
-    from public.catalogue_items
+    from public.catalogue_codes
     where code in ('COMP1100', 'COMP1110', 'MATH1005')
   ),
   3::bigint,
@@ -140,16 +140,16 @@ select extensions.ok(
   (select count(*) from public.plans) = 0
   and (
     select count(*)
-    from public.catalogue_item_years
-    where kind <> 'course' and published_snapshot_id is not null
+    from public.catalogue_records
+    where kind <> 'course' and published_version_id is not null
   ) = 5,
   'the preview keeps plans empty while publishing every selectable structure fixture'
 );
 
 select extensions.ok(
   not exists (
-    select 1 from public.course_snapshot_details as details
-    join public.course_unit_options as options on options.snapshot_id = details.snapshot_id
+    select 1 from public.course_version_details as details
+    join public.course_unit_options as options on options.version_id = details.version_id
     where details.unit_value_kind = 'fixed'
   ),
   'fixed-unit preview courses have no variable unit options'
diff --git a/supabase/tests/database/plan_structure_selection.sql b/supabase/tests/database/plan_structure_selection.sql
index 7757c4f0..d483bf41 100644
--- a/supabase/tests/database/plan_structure_selection.sql
+++ b/supabase/tests/database/plan_structure_selection.sql
@@ -88,7 +88,7 @@ from (
 ) as selected(kind, code);
 
 insert into public.academic_structure_snapshot_relationships (
-  snapshot_id,
+  version_id,
   position,
   relationship_kind,
   target_kind,
@@ -104,9 +104,9 @@ select
   selected.target_code,
   'Explicit programme structure option.',
   '#test-structure-option'
-from public.catalogue_snapshots as snapshots
-join public.catalogue_item_years as item_years on item_years.id = snapshots.item_year_id
-join public.catalogue_items as items on items.id = item_years.item_id
+from public.catalogue_versions as snapshots
+join public.catalogue_records as item_years on item_years.id = snapshots.record_id
+join public.catalogue_codes as items on items.id = item_years.code_id
 cross join (
   values
     (1, 'major'::text, 'PLAN-LINK-MAJOR'::text),
@@ -117,9 +117,9 @@ cross join (
 where items.code = 'PLAN-LINK-PROG';
 
 select pg_temp.publish_snapshot(snapshots.id)
-from public.catalogue_snapshots as snapshots
-join public.catalogue_item_years as item_years on item_years.id = snapshots.item_year_id
-join public.catalogue_items as items on items.id = item_years.item_id
+from public.catalogue_versions as snapshots
+join public.catalogue_records as item_years on item_years.id = snapshots.record_id
+join public.catalogue_codes as items on items.id = item_years.code_id
 where items.code like 'PLAN-LINK-%';
 
 select set_config(
@@ -151,10 +151,10 @@ select extensions.results_eq(
   $$
     select plan_structures.role, structures.code, plan_structures.position
     from public.plan_structures
-    join public.catalogue_item_years as structure_years
-      on structure_years.id = plan_structures.structure_year_id
-    join public.catalogue_items as structures
-      on structures.id = structure_years.item_id
+    join public.catalogue_records as structure_years
+      on structure_years.id = plan_structures.catalogue_record_id
+    join public.catalogue_codes as structures
+      on structures.id = structure_years.code_id
     where plan_structures.owner_id = '97000000-0000-4000-8000-000000000001'
     order by plan_structures.position
   $$,
@@ -190,10 +190,10 @@ select extensions.results_eq(
   $$
     select plan_structures.role, structures.code, plan_structures.position
     from public.plan_structures
-    join public.catalogue_item_years as structure_years
-      on structure_years.id = plan_structures.structure_year_id
-    join public.catalogue_items as structures
-      on structures.id = structure_years.item_id
+    join public.catalogue_records as structure_years
+      on structure_years.id = plan_structures.catalogue_record_id
+    join public.catalogue_codes as structures
+      on structures.id = structure_years.code_id
     where plan_structures.owner_id = '97000000-0000-4000-8000-000000000001'
     order by plan_structures.position
   $$,
@@ -259,23 +259,21 @@ select extensions.throws_ok(
     insert into public.plan_structures (
       plan_id,
       owner_id,
-      academic_year_id,
-      structure_year_id,
+      catalogue_record_id,
       role,
       position
     )
     select
       plans.id,
       plans.owner_id,
-      plans.academic_year_id,
       structure_years.id,
       'specialisation',
       99
     from public.plans
-    join public.catalogue_item_years as structure_years
+    join public.catalogue_records as structure_years
       on structure_years.academic_year_id = plans.academic_year_id
-    join public.catalogue_items as structures
-      on structures.id = structure_years.item_id
+    join public.catalogue_codes as structures
+      on structures.id = structure_years.code_id
     where plans.owner_id = '97000000-0000-4000-8000-000000000001'
       and structures.code = 'PLAN-LINK-MIN-A'
   $$,
@@ -289,23 +287,21 @@ select extensions.throws_ok(
     insert into public.plan_structures (
       plan_id,
       owner_id,
-      academic_year_id,
-      structure_year_id,
+      catalogue_record_id,
       role,
       position
     )
     select
       plans.id,
       plans.owner_id,
-      plans.academic_year_id,
       structure_years.id,
       'major',
       99
     from public.plans
-    join public.catalogue_item_years as structure_years
+    join public.catalogue_records as structure_years
       on structure_years.academic_year_id = plans.academic_year_id
-    join public.catalogue_items as structures
-      on structures.id = structure_years.item_id
+    join public.catalogue_codes as structures
+      on structures.id = structure_years.code_id
     where plans.owner_id = '97000000-0000-4000-8000-000000000001'
       and structures.code = 'PLAN-LINK-MAJOR'
   $$,
diff --git a/supabase/tests/database/requirement_conditions.sql b/supabase/tests/database/requirement_conditions.sql
index a1abd954..1c16c9ec 100644
--- a/supabase/tests/database/requirement_conditions.sql
+++ b/supabase/tests/database/requirement_conditions.sql
@@ -20,33 +20,33 @@ select pg_temp.catalogue_item_year('course', 'REQT1001', 2029::smallint);
 select pg_temp.catalogue_item_year('major', 'REQT-MAJ', 2029::smallint);
 
 create temporary table fixture on commit drop as
-select snapshots.id as snapshot_id, snapshots.academic_year_id
-from public.catalogue_snapshots as snapshots
-join public.course_snapshot_details as details on details.snapshot_id = snapshots.id
+select snapshots.id as version_id, snapshots.academic_year_id
+from public.catalogue_versions as snapshots
+join public.course_version_details as details on details.version_id = snapshots.id
 where details.title = 'Requirement fixture';
 
-insert into public.requirement_rules (snapshot_id, academic_year_id, rule_kind, source_text)
-select snapshot_id, academic_year_id, 'prerequisite', 'Complete REQT1001 and 24 units.' from fixture;
+insert into public.requirement_rules (version_id, academic_year_id, rule_kind, source_text)
+select version_id, academic_year_id, 'prerequisite', 'Complete REQT1001 and 24 units.' from fixture;
 
 select extensions.throws_ok(
   $$
-    insert into public.requirement_rules (snapshot_id, academic_year_id, rule_kind, source_text)
-    select snapshot_id, academic_year_id, 'prerequisite', 'Duplicate' from fixture
+    insert into public.requirement_rules (version_id, academic_year_id, rule_kind, source_text)
+    select version_id, academic_year_id, 'prerequisite', 'Duplicate' from fixture
   $$,
   '23505',
   null,
   'a snapshot holds one rule per kind'
 );
 
-insert into public.requirement_groups (rule_id, snapshot_id, group_key, operator)
-select rules.id, rules.snapshot_id, 'root', 'all_of'
-from public.requirement_rules as rules join fixture on fixture.snapshot_id = rules.snapshot_id;
+insert into public.requirement_groups (rule_id, version_id, group_key, operator)
+select rules.id, rules.version_id, 'root', 'all_of'
+from public.requirement_rules as rules join fixture on fixture.version_id = rules.version_id;
 
 select extensions.throws_ok(
   $$
-    insert into public.requirement_groups (rule_id, snapshot_id, group_key, operator)
-    select rules.id, rules.snapshot_id, 'second-root', 'any_of'
-    from public.requirement_rules as rules join fixture on fixture.snapshot_id = rules.snapshot_id;
+    insert into public.requirement_groups (rule_id, version_id, group_key, operator)
+    select rules.id, rules.version_id, 'second-root', 'any_of'
+    from public.requirement_rules as rules join fixture on fixture.version_id = rules.version_id;
     set constraints all immediate
   $$,
   '23514',
@@ -56,9 +56,9 @@ select extensions.throws_ok(
 
 select extensions.throws_ok(
   $$
-    insert into public.requirement_groups (rule_id, snapshot_id, group_key, operator)
-    select rules.id, rules.snapshot_id, 'no-count', 'at_least'
-    from public.requirement_rules as rules join fixture on fixture.snapshot_id = rules.snapshot_id
+    insert into public.requirement_groups (rule_id, version_id, group_key, operator)
+    select rules.id, rules.version_id, 'no-count', 'at_least'
+    from public.requirement_rules as rules join fixture on fixture.version_id = rules.version_id
   $$,
   '23514',
   null,
@@ -68,12 +68,12 @@ select extensions.throws_ok(
 select extensions.lives_ok(
   $$
     insert into public.requirement_conditions (
-      rule_id, snapshot_id, group_id, condition_key, position, condition_kind,
-      item_id, item_kind, requirement_mode
+      rule_id, version_id, group_id, condition_key, position, condition_kind,
+      code_id, item_kind, requirement_mode
     )
-    select groups.rule_id, groups.snapshot_id, groups.id, 'course', 0, 'course',
-      (select id from public.catalogue_items where code = 'REQT1001'), 'course', 'completed'
-    from public.requirement_groups as groups join fixture on fixture.snapshot_id = groups.snapshot_id
+    select groups.rule_id, groups.version_id, groups.id, 'course', 0, 'course',
+      (select id from public.catalogue_codes where code = 'REQT1001'), 'course', 'completed'
+    from public.requirement_groups as groups join fixture on fixture.version_id = groups.version_id
   $$,
   'course conditions reference a catalogue item'
 );
@@ -81,10 +81,10 @@ select extensions.lives_ok(
 select extensions.throws_ok(
   $$
     insert into public.requirement_conditions (
-      rule_id, snapshot_id, group_id, condition_key, position, condition_kind
+      rule_id, version_id, group_id, condition_key, position, condition_kind
     )
-    select groups.rule_id, groups.snapshot_id, groups.id, 'gpa', 1, 'gpa'
-    from public.requirement_groups as groups join fixture on fixture.snapshot_id = groups.snapshot_id
+    select groups.rule_id, groups.version_id, groups.id, 'gpa', 1, 'gpa'
+    from public.requirement_groups as groups join fixture on fixture.version_id = groups.version_id
   $$,
   '23514',
   null,
@@ -94,10 +94,10 @@ select extensions.throws_ok(
 select extensions.throws_ok(
   $$
     insert into public.requirement_conditions (
-      rule_id, snapshot_id, group_id, condition_key, position, condition_kind, minimum_units
+      rule_id, version_id, group_id, condition_key, position, condition_kind, minimum_units
     )
-    select groups.rule_id, groups.snapshot_id, groups.id, 'legacy', 1, 'unit_total', 24
-    from public.requirement_groups as groups join fixture on fixture.snapshot_id = groups.snapshot_id
+    select groups.rule_id, groups.version_id, groups.id, 'legacy', 1, 'unit_total', 24
+    from public.requirement_groups as groups join fixture on fixture.version_id = groups.version_id
   $$,
   '23514',
   null,
@@ -105,16 +105,16 @@ select extensions.throws_ok(
 );
 
 insert into public.requirement_conditions (
-  rule_id, snapshot_id, group_id, condition_key, position, condition_kind, structure_kind, minimum_count
+  rule_id, version_id, group_id, condition_key, position, condition_kind, structure_kind, minimum_count
 )
-select groups.rule_id, groups.snapshot_id, groups.id, 'majors', 1, 'structure_set', 'major', 1
-from public.requirement_groups as groups join fixture on fixture.snapshot_id = groups.snapshot_id;
+select groups.rule_id, groups.version_id, groups.id, 'majors', 1, 'structure_set', 'major', 1
+from public.requirement_groups as groups join fixture on fixture.version_id = groups.version_id;
 
 select extensions.lives_ok(
   $$
-    insert into public.requirement_condition_options (condition_id, snapshot_id, position, kind, code, item_id)
-    select conditions.id, conditions.snapshot_id, 1, 'major', 'REQT-MAJ',
-      (select id from public.catalogue_items where code = 'REQT-MAJ')
+    insert into public.requirement_condition_options (condition_id, version_id, position, kind, code, code_id)
+    select conditions.id, conditions.version_id, 1, 'major', 'REQT-MAJ',
+      (select id from public.catalogue_codes where code = 'REQT-MAJ')
     from public.requirement_conditions as conditions where conditions.condition_key = 'majors'
   $$,
   'set conditions accept resolved options'
@@ -122,9 +122,9 @@ select extensions.lives_ok(
 
 select extensions.throws_ok(
   $$
-    insert into public.requirement_condition_options (condition_id, snapshot_id, position, kind, code, item_id)
-    select conditions.id, conditions.snapshot_id, 2, 'major', 'REQT-OTHER',
-      (select id from public.catalogue_items where code = 'REQT-MAJ')
+    insert into public.requirement_condition_options (condition_id, version_id, position, kind, code, code_id)
+    select conditions.id, conditions.version_id, 2, 'major', 'REQT-OTHER',
+      (select id from public.catalogue_codes where code = 'REQT-MAJ')
     from public.requirement_conditions as conditions where conditions.condition_key = 'majors'
   $$,
   '23503',
@@ -134,8 +134,8 @@ select extensions.throws_ok(
 
 select extensions.throws_ok(
   $$
-    insert into public.requirement_condition_options (condition_id, snapshot_id, position, kind, code)
-    select conditions.id, conditions.snapshot_id, 1, 'course', 'REQT1001'
+    insert into public.requirement_condition_options (condition_id, version_id, position, kind, code)
+    select conditions.id, conditions.version_id, 1, 'course', 'REQT1001'
     from public.requirement_conditions as conditions where conditions.condition_key = 'course'
   $$,
   '23503',
@@ -143,15 +143,15 @@ select extensions.throws_ok(
   'options belong to set conditions only'
 );
 
-select pg_temp.publish_snapshot((select snapshot_id from fixture));
+select pg_temp.publish_snapshot((select version_id from fixture));
 
 select extensions.throws_ok(
   $$
     insert into public.requirement_conditions (
-      rule_id, snapshot_id, group_id, condition_key, position, condition_kind, minimum_units
+      rule_id, version_id, group_id, condition_key, position, condition_kind, minimum_units
     )
-    select groups.rule_id, groups.snapshot_id, groups.id, 'late', 5, 'units_total', 24
-    from public.requirement_groups as groups join fixture on fixture.snapshot_id = groups.snapshot_id
+    select groups.rule_id, groups.version_id, groups.id, 'late', 5, 'units_total', 24
+    from public.requirement_groups as groups join fixture on fixture.version_id = groups.version_id
   $$,
   '55000',
   null,
@@ -165,7 +165,7 @@ select extensions.ok(
     select public.published_course_detail('REQT1000', 2029::smallint) -> 'prerequisiteCodes'
   ) = '["REQT1001"]'::jsonb
   and exists (
-    select 1 from public.catalogue_items where code in ('REQT1001', 'REQT-MAJ')
+    select 1 from public.catalogue_codes where code in ('REQT1001', 'REQT-MAJ')
   ),
   'published requirements expose prerequisite codes and keep referenced placeholders visible'
 );
diff --git a/supabase/tests/helpers/catalogue-fixtures.inc b/supabase/tests/helpers/catalogue-fixtures.inc
index 108e5a20..a43ca96e 100644
--- a/supabase/tests/helpers/catalogue-fixtures.inc
+++ b/supabase/tests/helpers/catalogue-fixtures.inc
@@ -11,34 +11,34 @@ as $$
 declare
   selected_item_id bigint;
   selected_year_id bigint;
-  selected_item_year_id bigint;
+  selected_record_id bigint;
 begin
   insert into public.academic_years (year)
   values (p_year)
   on conflict (year) do nothing;
 
-  insert into public.catalogue_items (kind, code)
+  insert into public.catalogue_codes (kind, code)
   values (p_kind, p_code)
   on conflict (kind, code) do nothing;
 
   select items.id into selected_item_id
-  from public.catalogue_items as items
+  from public.catalogue_codes as items
   where items.kind = p_kind and items.code = p_code;
 
   select years.id into selected_year_id
   from public.academic_years as years
   where years.year = p_year;
 
-  insert into public.catalogue_item_years (item_id, kind, academic_year_id)
+  insert into public.catalogue_records (code_id, kind, academic_year_id)
   values (selected_item_id, p_kind, selected_year_id)
-  on conflict (item_id, academic_year_id) do nothing;
+  on conflict (code_id, academic_year_id) do nothing;
 
-  select item_years.id into selected_item_year_id
-  from public.catalogue_item_years as item_years
-  where item_years.item_id = selected_item_id
+  select item_years.id into selected_record_id
+  from public.catalogue_records as item_years
+  where item_years.code_id = selected_item_id
     and item_years.academic_year_id = selected_year_id;
 
-  return selected_item_year_id;
+  return selected_record_id;
 end;
 $$;
 
@@ -57,25 +57,25 @@ language plpgsql
 set search_path = ''
 as $$
 declare
-  selected_item_year_id bigint := pg_temp.catalogue_item_year('course', p_code, p_year);
+  selected_record_id bigint := pg_temp.catalogue_item_year('course', p_code, p_year);
   created_snapshot_id bigint;
 begin
-  insert into public.catalogue_snapshots (
-    item_year_id, kind, academic_year_id, origin, content_hash
+  insert into public.catalogue_versions (
+    record_id, kind, academic_year_id, origin, content_hash
   )
   select
-    selected_item_year_id,
+    selected_record_id,
     'course',
     item_years.academic_year_id,
     'manual',
     md5(p_code || ':' || p_year::text || ':' || clock_timestamp()::text)
       || md5(p_title)
-  from public.catalogue_item_years as item_years
-  where item_years.id = selected_item_year_id
+  from public.catalogue_records as item_years
+  where item_years.id = selected_record_id
   returning id into created_snapshot_id;
 
-  insert into public.course_snapshot_details (
-    snapshot_id, title, unit_value_kind, units, minimum_units, maximum_units,
+  insert into public.course_version_details (
+    version_id, title, unit_value_kind, units, minimum_units, maximum_units,
     level, subject_code, offering_status
   ) values (
     created_snapshot_id, p_title, p_unit_value_kind, p_units, p_minimum_units,
@@ -86,18 +86,18 @@ begin
 end;
 $$;
 
-create function pg_temp.publish_snapshot(p_snapshot_id bigint)
+create function pg_temp.publish_snapshot(p_version_id bigint)
 returns bigint
 language plpgsql
 set search_path = ''
 as $$
 begin
-  update public.catalogue_item_years as item_years
-  set published_snapshot_id = p_snapshot_id
-  from public.catalogue_snapshots as snapshots
-  where snapshots.id = p_snapshot_id
-    and item_years.id = snapshots.item_year_id;
-  return p_snapshot_id;
+  update public.catalogue_records as item_years
+  set published_version_id = p_version_id
+  from public.catalogue_versions as snapshots
+  where snapshots.id = p_version_id
+    and item_years.id = snapshots.record_id;
+  return p_version_id;
 end;
 $$;
 
@@ -136,25 +136,25 @@ language plpgsql
 set search_path = ''
 as $$
 declare
-  selected_item_year_id bigint := pg_temp.catalogue_item_year(p_kind, p_code, p_year);
+  selected_record_id bigint := pg_temp.catalogue_item_year(p_kind, p_code, p_year);
   created_snapshot_id bigint;
 begin
-  insert into public.catalogue_snapshots (
-    item_year_id, kind, academic_year_id, origin, content_hash
+  insert into public.catalogue_versions (
+    record_id, kind, academic_year_id, origin, content_hash
   )
   select
-    selected_item_year_id,
+    selected_record_id,
     p_kind,
     item_years.academic_year_id,
     'manual',
     md5(p_code || ':' || p_year::text || ':' || clock_timestamp()::text)
       || md5(p_name)
-  from public.catalogue_item_years as item_years
-  where item_years.id = selected_item_year_id
+  from public.catalogue_records as item_years
+  where item_years.id = selected_record_id
   returning id into created_snapshot_id;
 
-  insert into public.structure_snapshot_details (
-    snapshot_id, kind, name, units, duration_years
+  insert into public.structure_version_details (
+    version_id, kind, name, units, duration_years
   ) values (created_snapshot_id, p_kind, p_name, p_units, p_duration_years);
 
   return created_snapshot_id;
diff --git a/supabase/tests/helpers/catalogue-review.inc b/supabase/tests/helpers/catalogue-review.inc
index af7e8623..0df1cf7b 100644
--- a/supabase/tests/helpers/catalogue-review.inc
+++ b/supabase/tests/helpers/catalogue-review.inc
@@ -1,7 +1,7 @@
 -- Section approval no longer gates publication. The fixtures that call this
 -- helper are rewritten with the shared catalogue model; until then the call
 -- sites stay valid and do nothing.
-create function pg_temp.approve_catalogue_fixture(kind text, snapshot_id bigint)
+create function pg_temp.approve_catalogue_fixture(kind text, version_id bigint)
 returns void
 language sql
 as $$ select null::void $$;