chuvsu-js 5.2.2 → 5.3.1

package/dist/tt/domain/ids.d.ts

@@ -5,3 +5,5 @@ export declare class RandomLessonIdGenerator implements LessonIdGenerator {
 }
 /** Stable occurrence identity inside a persisted series. */
 export declare function occurrenceIdForSeries(seriesId: LessonSeriesId, academicWeek: number, ordinal?: number): LessonId;
+/** Convert persisted v5 UUID IDs without changing their identity. */
+export declare function migrateLegacyLessonId(id: string): string;

package/dist/tt/domain/ids.js

@@ -1,20 +1,50 @@
-function randomId(prefix) {
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+const ID_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function encodeId(bytes) {
+    let encoded = "";
+    for (let index = 0; index < bytes.length; index += 3) {
+        const block = (bytes[index] << 16) | (bytes[index + 1] << 8) | bytes[index + 2];
+        encoded += ID_ALPHABET[(block >>> 18) & 63];
+        encoded += ID_ALPHABET[(block >>> 12) & 63];
+        encoded += ID_ALPHABET[(block >>> 6) & 63];
+        encoded += ID_ALPHABET[block & 63];
+    }
+    return encoded;
+}
+function encodeLegacyUuid(uuid) {
+    const hex = uuid.replaceAll("-", "").slice(0, 18);
+    const bytes = new Uint8Array(hex.match(/.{2}/gu).map((pair) => Number.parseInt(pair, 16)));
+    return encodeId(bytes);
+}
+function randomId() {
     const cryptoApi = globalThis.crypto;
-    if (cryptoApi?.randomUUID)
-        return `${prefix}_${cryptoApi.randomUUID()}`;
-    const random = Math.random().toString(36).slice(2);
-    const time = Date.now().toString(36);
-    return `${prefix}_${time}_${random}`;
+    if (!cryptoApi?.getRandomValues)
+        throw new Error("Secure random IDs require Web Crypto");
+    return encodeId(cryptoApi.getRandomValues(new Uint8Array(9)));
 }
 export class RandomLessonIdGenerator {
     seriesId() {
-        return randomId("ser");
+        return randomId();
     }
     lessonId() {
-        return randomId("les");
+        return randomId();
     }
 }
 /** Stable occurrence identity inside a persisted series. */
 export function occurrenceIdForSeries(seriesId, academicWeek, ordinal = 0) {
-    return `les_${seriesId}_${academicWeek}_${ordinal}`;
+    return `${seriesId}.${academicWeek}.${ordinal}`;
+}
+/** Convert persisted v5 UUID IDs without changing their identity. */
+export function migrateLegacyLessonId(id) {
+    const occurrence = /^les_ser_([0-9a-f-]{36})_(\d+)_(\d+)$/iu.exec(id);
+    if (occurrence && UUID_PATTERN.test(occurrence[1])) {
+        return occurrenceIdForSeries(encodeLegacyUuid(occurrence[1]), Number(occurrence[2]), Number(occurrence[3]));
+    }
+    const series = /^ser_([0-9a-f-]{36})$/iu.exec(id);
+    if (series && UUID_PATTERN.test(series[1]))
+        return encodeLegacyUuid(series[1]);
+    const direct = /^les_([0-9a-f-]{36})$/iu.exec(id);
+    if (direct && UUID_PATTERN.test(direct[1]))
+        return encodeLegacyUuid(direct[1]);
+    return id;
 }

package/dist/tt/domain/index.d.ts

@@ -1,9 +1,9 @@
-export { RandomLessonIdGenerator, occurrenceIdForSeries } from "./ids.js";
+export { RandomLessonIdGenerator, occurrenceIdForSeries, migrateLegacyLessonId } from "./ids.js";
+export { ScheduleSnapshot, createScheduleSnapshot } from "./schedule-snapshot.js";
+export type { SerializedScheduleSnapshot } from "./schedule-snapshot.js";
 export { TimetableDirectory } from "./directory.js";
 export { entityKey, mergeEntityRefs, mergeGroups, mergeRooms, mergeTeachers, normalizeScheduleText, } from "./normalize.js";
 export { MemoryTimetableRepositoryAdapter, TimetableRepository, } from "./repository.js";
 export { Schedule } from "./schedule.js";
-export { MaterializedSchedule, materializeSchedule, materializeScheduleSnapshot, } from "./materialized-schedule.js";
 export type { ScheduleQueryOptions, ScheduleOptions, ScheduleWeekdayOptions, } from "./schedule.js";
-export type { MaterializeScheduleOptions, MaterializedScheduleSnapshot, SerializedLessonOccurrence, SerializedLessonSourceRef, } from "./materialized-schedule.js";
 export type { GroupAttendance, GroupRef, IngestResult, LessonId, LessonIdGenerator, LessonOccurrence, LessonRecurrence, LessonSeries, LessonSeriesId, RelationCompleteness, RelationSet, LessonSourceRef, LessonStatus, LessonSubstitution, LessonTransfer, NamedEntityRef, OccurrenceObservation, RoomRef, ScheduleObservation, ScheduleOwner, ScheduleSourceSnapshot, SeriesObservation, TeacherRef, TimetableDirectorySnapshot, TimetableRepositoryAdapter, TimetableRepositoryPatch, TimetableRepositorySnapshot, } from "./types.js";

package/dist/tt/domain/index.js

@@ -1,6 +1,6 @@
-export { RandomLessonIdGenerator, occurrenceIdForSeries } from "./ids.js";
+export { RandomLessonIdGenerator, occurrenceIdForSeries, migrateLegacyLessonId } from "./ids.js";
+export { ScheduleSnapshot, createScheduleSnapshot } from "./schedule-snapshot.js";
 export { TimetableDirectory } from "./directory.js";
 export { entityKey, mergeEntityRefs, mergeGroups, mergeRooms, mergeTeachers, normalizeScheduleText, } from "./normalize.js";
 export { MemoryTimetableRepositoryAdapter, TimetableRepository, } from "./repository.js";
 export { Schedule } from "./schedule.js";
-export { MaterializedSchedule, materializeSchedule, materializeScheduleSnapshot, } from "./materialized-schedule.js";

package/dist/tt/domain/schedule-snapshot.d.ts

@@ -0,0 +1,51 @@
+import type { AcademicPeriod, LocalDate } from "../../common/types.js";
+import { type Holiday } from "../utils/index.js";
+import { Schedule, type ScheduleQueryOptions } from "./schedule.js";
+import type { LessonOccurrence, LessonSeries, LessonSourceRef, ScheduleOwner } from "./types.js";
+type SerializedSource = Omit<LessonSourceRef, "observedAt"> & {
+    observedAt: string;
+};
+type SerializedSeries = Omit<LessonSeries, "sources"> & {
+    sources: SerializedSource[];
+};
+type SerializedOccurrence = Omit<LessonOccurrence, "sources"> & {
+    sources: SerializedSource[];
+};
+export interface SerializedScheduleSnapshot {
+    schemaVersion: 2;
+    repositoryRevision: number;
+    owner: ScheduleOwner;
+    academicYearStartYear: number;
+    period: AcademicPeriod;
+    start: LocalDate;
+    end: LocalDate;
+    series: SerializedSeries[];
+    direct: SerializedOccurrence[];
+    holidays?: Holiday[];
+    holidayTransfers?: {
+        dayOff: string;
+        workDay: string | null;
+    }[];
+}
+/** Browser-ready schedule backed by recurring rules and dated exceptions. */
+export declare class ScheduleSnapshot extends Schedule {
+    private readonly snapshot;
+    private readonly snapshotSeries;
+    private readonly snapshotDirect;
+    private readonly dateSetCache;
+    constructor(snapshot: SerializedScheduleSnapshot);
+    get revision(): number;
+    protected queryData(): {
+        series: LessonSeries[];
+        direct: LessonOccurrence[];
+    };
+    export(): SerializedScheduleSnapshot;
+    on(date: Date, options?: ScheduleQueryOptions): LessonOccurrence[];
+    dateKeys(options?: ScheduleQueryOptions): ReadonlySet<LocalDate>;
+}
+export declare function createScheduleSnapshot(schedule: Schedule, options?: {
+    start?: Date;
+    end?: Date;
+    includeSources?: boolean;
+}): SerializedScheduleSnapshot;
+export {};

package/dist/tt/domain/schedule-snapshot.js

@@ -0,0 +1,103 @@
+import { formatLocalDate, parseLocalDate, RUSSIAN_HOLIDAYS } from "../utils/index.js";
+import { Schedule } from "./schedule.js";
+function serializeSources(sources, include) {
+    return include
+        ? sources.map((source) => ({ ...structuredClone(source), observedAt: source.observedAt.toISOString() }))
+        : [];
+}
+function deserializeSources(sources) {
+    return sources.map((source) => ({ ...structuredClone(source), observedAt: new Date(source.observedAt) }));
+}
+function usesDefaultHolidays(holidays) {
+    return holidays.length === RUSSIAN_HOLIDAYS.length && holidays.every((holiday, index) => {
+        const standard = RUSSIAN_HOLIDAYS[index];
+        return holiday.month === standard.month && holiday.day === standard.day && holiday.name === standard.name;
+    });
+}
+/** Browser-ready schedule backed by recurring rules and dated exceptions. */
+export class ScheduleSnapshot extends Schedule {
+    snapshot;
+    snapshotSeries;
+    snapshotDirect;
+    dateSetCache = new Map();
+    constructor(snapshot) {
+        if (snapshot.schemaVersion !== 2) {
+            throw new Error(`Unsupported schedule snapshot schema: ${snapshot.schemaVersion}`);
+        }
+        const series = snapshot.series.map((value) => ({
+            ...structuredClone(value), sources: deserializeSources(value.sources),
+        }));
+        const direct = snapshot.direct.map((value) => ({
+            ...structuredClone(value), sources: deserializeSources(value.sources),
+        }));
+        const options = {
+            period: snapshot.period,
+            holidays: snapshot.holidays,
+            holidayTransfers: snapshot.holidayTransfers?.map((value) => ({
+                dayOff: new Date(value.dayOff),
+                workDay: value.workDay ? new Date(value.workDay) : null,
+            })),
+        };
+        super(undefined, snapshot.owner, snapshot.academicYearStartYear, options);
+        this.snapshotSeries = series;
+        this.snapshotDirect = direct;
+        this.snapshot = structuredClone(snapshot);
+    }
+    get revision() { return this.snapshot.repositoryRevision; }
+    queryData() {
+        return { series: this.snapshotSeries, direct: this.snapshotDirect };
+    }
+    export() { return structuredClone(this.snapshot); }
+    on(date, options) {
+        const key = formatLocalDate(date);
+        return key < this.snapshot.start || key > this.snapshot.end ? [] : super.on(date, options);
+    }
+    dateKeys(options) {
+        const subgroup = options?.subgroup;
+        const cached = this.dateSetCache.get(subgroup);
+        if (cached)
+            return new Set(cached);
+        const dates = new Set();
+        const end = parseLocalDate(this.snapshot.end);
+        for (const date = parseLocalDate(this.snapshot.start); date <= end; date.setDate(date.getDate() + 1)) {
+            if (this.on(date, options).length)
+                dates.add(formatLocalDate(date));
+        }
+        this.dateSetCache.set(subgroup, dates);
+        return new Set(dates);
+    }
+}
+export function createScheduleSnapshot(schedule, options) {
+    const start = options?.start == null ? new Date(schedule.academicYearStartYear, 8, 1) : new Date(options.start);
+    const end = options?.end == null ? new Date(schedule.academicYearStartYear + 1, 7, 31) : new Date(options.end);
+    if (!Number.isFinite(start.getTime()) || !Number.isFinite(end.getTime())) {
+        throw new RangeError("Schedule snapshot range contains an invalid date");
+    }
+    if (start > end)
+        throw new RangeError("Schedule snapshot start must not exceed end");
+    const includeSources = options?.includeSources !== false;
+    const series = schedule.series().map((value) => ({
+        ...value, sources: serializeSources(value.sources, includeSources),
+    }));
+    const direct = schedule.directOccurrences().map((value) => ({
+        ...value, sources: serializeSources(value.sources, includeSources),
+    }));
+    return {
+        schemaVersion: 2,
+        repositoryRevision: schedule.revision,
+        owner: structuredClone(schedule.owner),
+        academicYearStartYear: schedule.academicYearStartYear,
+        period: schedule.period,
+        start: formatLocalDate(start),
+        end: formatLocalDate(end),
+        series,
+        direct,
+        ...(!usesDefaultHolidays(schedule.holidays) ? { holidays: structuredClone(schedule.holidays) } : {}),
+        ...(schedule.holidayTransfers.length ? {
+            holidayTransfers: schedule.holidayTransfers.map((value) => ({
+                dayOff: value.dayOff.toISOString(),
+                workDay: value.workDay?.toISOString() ?? null,
+            })),
+        } : {}),
+    };
+}

package/dist/tt/domain/schedule.d.ts

@@ -1,7 +1,6 @@
 import { AcademicPeriod } from "../../common/types.js";
 import { type Holiday, type HolidayTransfer } from "../utils/index.js";
 import { TimetableRepository } from "./repository.js";
-import { type MaterializeScheduleOptions, type MaterializedSchedule, type MaterializedScheduleSnapshot } from "./materialized-schedule.js";
 import type { LessonOccurrence, LessonSeries, ScheduleOwner } from "./types.js";
 export interface ScheduleQueryOptions {
     subgroup?: number;
@@ -15,7 +14,7 @@ export interface ScheduleOptions {
     holidayTransfers?: HolidayTransfer[];
 }
 export declare class Schedule {
-    readonly repository: TimetableRepository;
+    readonly repository?: TimetableRepository;
     readonly owner: ScheduleOwner;
     readonly academicYearStartYear: number;
     readonly period: AcademicPeriod;
@@ -24,13 +23,15 @@ export declare class Schedule {
     private cachedRevision;
     private cachedSeries;
     private cachedDirectOccurrences;
-    constructor(repository: TimetableRepository, owner: ScheduleOwner, academicYearStartYear: number, options?: ScheduleOptions);
+    constructor(repository: TimetableRepository | undefined, owner: ScheduleOwner, academicYearStartYear: number, options?: ScheduleOptions);
     get revision(): number;
-    private queryData;
+    protected queryData(): {
+        series: LessonSeries[];
+        direct: LessonOccurrence[];
+    };
     series(): LessonSeries[];
+    directOccurrences(): LessonOccurrence[];
     on(date: Date, options?: ScheduleQueryOptions): LessonOccurrence[];
-    materialize(options?: MaterializeScheduleOptions): MaterializedSchedule;
-    materializeSnapshot(options?: MaterializeScheduleOptions): MaterializedScheduleSnapshot;
     week(week?: number, options?: ScheduleQueryOptions): LessonOccurrence[];
     weekday(weekday: number, options?: ScheduleWeekdayOptions): LessonOccurrence[];
     today(options?: ScheduleQueryOptions): LessonOccurrence[];

package/dist/tt/domain/schedule.js

@@ -2,7 +2,6 @@ import { AcademicPeriod } from "../../common/types.js";
 import { getAdjacentSemester, getCurrentPeriod, getMonday, getSemesterStart, getSemesterWeeks, getWeekNumber, formatLocalDate, isHoliday, parseLocalDate, RUSSIAN_HOLIDAYS, } from "../utils/index.js";
 import { occurrenceIdForSeries } from "./ids.js";
 import { entityKey, normalizeScheduleText } from "./normalize.js";
-import { materializeSchedule, materializeScheduleSnapshot, } from "./materialized-schedule.js";
 function dateAt(date, time) {
     const value = new Date(date);
     value.setHours(time.hours, time.minutes, 0, 0);
@@ -92,19 +91,22 @@ export class Schedule {
         }));
     }
     get revision() {
-        return this.repository.revision;
+        return this.repository?.revision ?? 0;
     }
     queryData() {
-        if (this.cachedRevision !== this.repository.revision) {
-            this.cachedSeries = this.repository.getSeries({
+        const repository = this.repository;
+        if (!repository)
+            throw new Error("Schedule has no live repository");
+        if (this.cachedRevision !== repository.revision) {
+            this.cachedSeries = repository.getSeries({
                 owner: this.owner,
                 academicYearStartYear: this.academicYearStartYear,
             });
-            this.cachedDirectOccurrences = this.repository.getDirectOccurrences({
+            this.cachedDirectOccurrences = repository.getDirectOccurrences({
                 owner: this.owner,
                 academicYearStartYear: this.academicYearStartYear,
             });
-            this.cachedRevision = this.repository.revision;
+            this.cachedRevision = repository.revision;
         }
         return {
             series: this.cachedSeries,
@@ -114,6 +116,9 @@ export class Schedule {
     series() {
         return structuredClone(this.queryData().series);
     }
+    directOccurrences() {
+        return structuredClone(this.queryData().direct);
+    }
     on(date, options) {
         if (!this.isInAcademicYear(date))
             return [];
@@ -198,12 +203,6 @@ export class Schedule {
         }
         return occurrences.sort(sortOccurrences);
     }
-    materialize(options) {
-        return materializeSchedule(this, options);
-    }
-    materializeSnapshot(options) {
-        return materializeScheduleSnapshot(this, options);
-    }
     week(week, options) {
         const period = this.period === AcademicPeriod.WinterSession ||
             this.period === AcademicPeriod.SummerSession

package/docs/v5-migration.md

@@ -292,25 +292,31 @@ const snapshot = await client.exportRepository();
 снимка. Используйте его для экспорта, резервной копии или миграции, не на пути
 каждого запроса.
 
-Для API, SSR и офлайн-кеша материализуйте только готовое расписание владельца:
+Для API, SSR и офлайн-кеша передавайте компактное расписание владельца:
 
 ```ts
-// Сервер: агрегация выполняется один раз, источники можно убрать из payload.
-const payload = schedule.materializeSnapshot({ includeSources: false });
+import { createScheduleSnapshot } from "chuvsu-js";
+
+// Сервер: повторяющиеся серии + отдельные пары с датами.
+const payload = createScheduleSnapshot(schedule, { includeSources: false });
 return Response.json(payload);
 
-// Браузер: JSON восстанавливается в индексированное по дате представление.
-import { MaterializedSchedule } from "chuvsu-js/browser";
+// Браузер: даты строятся из правил расписания.
+import { ScheduleSnapshot } from "chuvsu-js/browser";
 
-const schedule = new MaterializedSchedule(await response.json());
-schedule.on(date);                  // O(1) поиск даты
+const schedule = new ScheduleSnapshot(await response.json());
+schedule.on(date);
 schedule.dateKeys({ subgroup: 2 }); // даты для календаря
 ```
 
-`MaterializedScheduleSnapshot` содержит уже объединенные `LessonOccurrence`,
-но не канонический репозиторий. Поле `repositoryRevision` позволяет серверному
-кешу инвалидировать снимок после дополнения пары из расписания преподавателя,
-аудитории или другой группы.
+`SerializedScheduleSnapshot` содержит серии и отдельные пары, но не канонический
+репозиторий. `repositoryRevision` позволяет серверному кешу инвалидировать снимок
+после дополнения пары из другого расписания. ` ScheduleSnapshot` использует ту же
+логику дат, переносов, праздников и подгрупп, что и `Schedule`.
+
+Формат `SerializedScheduleSnapshot` имеет `schemaVersion: 2`.
+Новые UUID идентификаторы серий и пар кодируются короче; для перевода сохранённых
+идентификаторов v5 используйте `migrateLegacyLessonId`.
 
 Не передавайте экспорт `exportCache()` из v4 в `importCache()` v5: изменились
 ключи, категории и форма закешированных страниц. Старый TTL-кеш и старые blob-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chuvsu-js",
-  "version": "5.2.2",
+  "version": "5.3.1",
   "description": "Библиотека для расписания и личного кабинета ЧГУ им. И. Н. Ульянова",
   "type": "module",
   "main": "dist/index.js",

package/dist/tt/domain/materialized-schedule.d.ts

@@ -1,40 +0,0 @@
-import type { AcademicPeriod, LocalDate } from "../../common/types.js";
-import type { Schedule } from "./schedule.js";
-import type { LessonOccurrence, LessonSourceRef, ScheduleOwner } from "./types.js";
-export interface SerializedLessonSourceRef extends Omit<LessonSourceRef, "observedAt"> {
-    observedAt: string;
-}
-export interface SerializedLessonOccurrence extends Omit<LessonOccurrence, "sources"> {
-    sources: SerializedLessonSourceRef[];
-}
-export interface MaterializedScheduleSnapshot {
-    schemaVersion: 1;
-    repositoryRevision: number;
-    owner: ScheduleOwner;
-    academicYearStartYear: number;
-    period: AcademicPeriod;
-    lessonsByDate: Record<LocalDate, SerializedLessonOccurrence[]>;
-}
-export interface MaterializeScheduleOptions {
-    start?: Date;
-    end?: Date;
-    includeSources?: boolean;
-}
-export declare class MaterializedSchedule {
-    readonly owner: ScheduleOwner;
-    readonly academicYearStartYear: number;
-    readonly period: AcademicPeriod;
-    readonly repositoryRevision: number;
-    private readonly lessonsByDate;
-    private readonly dateSetCache;
-    constructor(snapshot: MaterializedScheduleSnapshot);
-    export(): MaterializedScheduleSnapshot;
-    on(date: Date, options?: {
-        subgroup?: number;
-    }): LessonOccurrence[];
-    dateKeys(options?: {
-        subgroup?: number;
-    }): ReadonlySet<LocalDate>;
-}
-export declare function materializeSchedule(schedule: Schedule, options?: MaterializeScheduleOptions): MaterializedSchedule;
-export declare function materializeScheduleSnapshot(schedule: Schedule, options?: MaterializeScheduleOptions): MaterializedScheduleSnapshot;

package/dist/tt/domain/materialized-schedule.js

@@ -1,132 +0,0 @@
-import { formatLocalDate } from "../utils/index.js";
-import { entityKey } from "./normalize.js";
-function attendanceMatchesSubgroup(groups, owner, subgroup) {
-    if (subgroup == null)
-        return true;
-    if (owner.type === "group") {
-        const ownerKey = entityKey(owner.group);
-        return groups
-            .filter((value) => entityKey(value.group) === ownerKey)
-            .some((value) => value.subgroup == null || value.subgroup === subgroup);
-    }
-    return groups.some((value) => value.subgroup == null || value.subgroup === subgroup);
-}
-function serializeOccurrence(value, includeSources) {
-    return {
-        ...structuredClone(value),
-        sources: includeSources
-            ? value.sources.map((source) => ({
-                ...structuredClone(source),
-                observedAt: source.observedAt.toISOString(),
-            }))
-            : [],
-    };
-}
-function deserializeOccurrence(value) {
-    return {
-        ...structuredClone(value),
-        sources: value.sources.map((source) => ({
-            ...structuredClone(source),
-            observedAt: new Date(source.observedAt),
-        })),
-    };
-}
-function sortOccurrences(left, right) {
-    return (left.scheduledDate.localeCompare(right.scheduledDate) ||
-        ((left.time?.start.hours ?? 24) * 60 +
-            (left.time?.start.minutes ?? 0)) -
-            ((right.time?.start.hours ?? 24) * 60 +
-                (right.time?.start.minutes ?? 0)) ||
-        (left.slotNumber ?? Number.MAX_SAFE_INTEGER) -
-            (right.slotNumber ?? Number.MAX_SAFE_INTEGER) ||
-        left.subject.localeCompare(right.subject) ||
-        left.id.localeCompare(right.id));
-}
-export class MaterializedSchedule {
-    owner;
-    academicYearStartYear;
-    period;
-    repositoryRevision;
-    lessonsByDate = new Map();
-    dateSetCache = new Map();
-    constructor(snapshot) {
-        if (snapshot.schemaVersion !== 1) {
-            throw new Error(`Unsupported materialized schedule schema: ${snapshot.schemaVersion}`);
-        }
-        this.owner = structuredClone(snapshot.owner);
-        this.academicYearStartYear = snapshot.academicYearStartYear;
-        this.period = snapshot.period;
-        this.repositoryRevision = snapshot.repositoryRevision;
-        for (const [date, lessons] of Object.entries(snapshot.lessonsByDate)) {
-            this.lessonsByDate.set(date, lessons.map(deserializeOccurrence).sort(sortOccurrences));
-        }
-    }
-    export() {
-        return {
-            schemaVersion: 1,
-            repositoryRevision: this.repositoryRevision,
-            owner: structuredClone(this.owner),
-            academicYearStartYear: this.academicYearStartYear,
-            period: this.period,
-            lessonsByDate: Object.fromEntries([...this.lessonsByDate].map(([date, lessons]) => [
-                date,
-                lessons.map((lesson) => serializeOccurrence(lesson, true)),
-            ])),
-        };
-    }
-    on(date, options) {
-        const lessons = this.lessonsByDate.get(formatLocalDate(date)) ?? [];
-        return structuredClone(options?.subgroup == null
-            ? lessons
-            : lessons.filter((lesson) => attendanceMatchesSubgroup(lesson.groups.values, this.owner, options.subgroup)));
-    }
-    dateKeys(options) {
-        const subgroup = options?.subgroup;
-        const cached = this.dateSetCache.get(subgroup);
-        if (cached)
-            return new Set(cached);
-        const dates = new Set();
-        for (const [date, lessons] of this.lessonsByDate) {
-            if (subgroup == null ||
-                lessons.some((lesson) => attendanceMatchesSubgroup(lesson.groups.values, this.owner, subgroup))) {
-                dates.add(date);
-            }
-        }
-        this.dateSetCache.set(subgroup, dates);
-        return new Set(dates);
-    }
-}
-export function materializeSchedule(schedule, options) {
-    return new MaterializedSchedule(materializeScheduleSnapshot(schedule, options));
-}
-export function materializeScheduleSnapshot(schedule, options) {
-    const start = options?.start == null
-        ? new Date(schedule.academicYearStartYear, 8, 1)
-        : new Date(options.start);
-    const end = options?.end == null
-        ? new Date(schedule.academicYearStartYear + 1, 7, 31)
-        : new Date(options.end);
-    if (!Number.isFinite(start.getTime()) || !Number.isFinite(end.getTime())) {
-        throw new RangeError("Materialized schedule range contains an invalid date");
-    }
-    if (start > end) {
-        throw new RangeError("Materialized schedule start must not exceed end");
-    }
-    const lessonsByDate = {};
-    const date = new Date(start);
-    date.setHours(0, 0, 0, 0);
-    for (; date <= end; date.setDate(date.getDate() + 1)) {
-        const lessons = schedule.on(date);
-        if (lessons.length === 0)
-            continue;
-        lessonsByDate[formatLocalDate(date)] = lessons.map((lesson) => serializeOccurrence(lesson, options?.includeSources !== false));
-    }
-    return {
-        schemaVersion: 1,
-        repositoryRevision: schedule.revision,
-        owner: schedule.owner,
-        academicYearStartYear: schedule.academicYearStartYear,
-        period: schedule.period,
-        lessonsByDate,
-    };
-}