chuvsu-js 4.2.0 → 5.0.0

package/dist/tt/domain/repository.js

@@ -0,0 +1,805 @@
+import { isLocalDate } from "../utils/date.js";
+import { TimetableDirectory } from "./directory.js";
+import { RandomLessonIdGenerator } from "./ids.js";
+import { entityKey, mergeGroups, mergeRooms, mergeTeachers, normalizeScheduleText, } from "./normalize.js";
+function claimKey(sourceKey, observationKey) {
+    return `${sourceKey}\u0000${observationKey}`;
+}
+function sourceObservationKey(sourceKey, observationKey) {
+    return claimKey(sourceKey, observationKey);
+}
+function sameDate(a, b) {
+    return a === b;
+}
+function rangesOverlap(a, b) {
+    const aFrom = a?.from ?? 1;
+    const aTo = a?.to ?? 17;
+    const bFrom = b?.from ?? 1;
+    const bTo = b?.to ?? 17;
+    return Math.max(aFrom, bFrom) <= Math.min(aTo, bTo);
+}
+function recurrenceWeeks(observation) {
+    const from = observation.recurrence.weeks?.from ?? 1;
+    const to = observation.recurrence.weeks?.to ?? 17;
+    const weeks = [];
+    for (let week = from; week <= to; week++) {
+        if (observation.recurrence.parity === "even" && week % 2 !== 0)
+            continue;
+        if (observation.recurrence.parity === "odd" && week % 2 === 0)
+            continue;
+        weeks.push(week);
+    }
+    return weeks.join(",");
+}
+function sameTimeRange(left, right) {
+    return left.start.hours === right.start.hours &&
+        left.start.minutes === right.start.minutes &&
+        left.end.hours === right.end.hours &&
+        left.end.minutes === right.end.minutes;
+}
+function valuesOverlap(left, right) {
+    if (!left?.length || !right?.length)
+        return undefined;
+    const keys = new Set(left.map(entityKey));
+    return right.some((value) => keys.has(entityKey(value)));
+}
+function groupsOverlap(left, right) {
+    if (!left?.length || !right?.length)
+        return undefined;
+    const keys = new Set(left.map((value) => entityKey(value.group)));
+    return right.some((value) => keys.has(entityKey(value.group)));
+}
+function relationScore(overlap) {
+    if (overlap === true)
+        return 14;
+    if (overlap === false)
+        return -18;
+    return 0;
+}
+function observationScore(left, right, sameSource, directory) {
+    if (left.kind !== right.kind)
+        return Number.NEGATIVE_INFINITY;
+    if (normalizeScheduleText(left.subject) !== normalizeScheduleText(right.subject)) {
+        return Number.NEGATIVE_INFINITY;
+    }
+    if (left.kind === "series" && right.kind === "series") {
+        if (left.recurrence.weekday !== right.recurrence.weekday) {
+            return Number.NEGATIVE_INFINITY;
+        }
+        if (!rangesOverlap(left.recurrence.weeks, right.recurrence.weeks) ||
+            recurrenceWeeks(left) !== recurrenceWeeks(right)) {
+            return Number.NEGATIVE_INFINITY;
+        }
+        if (left.recurrence.parity != null &&
+            right.recurrence.parity != null &&
+            left.recurrence.parity !== right.recurrence.parity) {
+            return Number.NEGATIVE_INFINITY;
+        }
+    }
+    if (left.kind === "occurrence" &&
+        right.kind === "occurrence" &&
+        !sameDate(left.date, right.date)) {
+        return Number.NEGATIVE_INFINITY;
+    }
+    let score = 35;
+    if (normalizeScheduleText(left.type) === normalizeScheduleText(right.type)) {
+        score += 10;
+    }
+    else if (left.type && right.type) {
+        score -= 12;
+    }
+    if (left.slotNumber != null &&
+        right.slotNumber != null &&
+        left.slotNumber === right.slotNumber)
+        score += 12;
+    if (left.time &&
+        right.time &&
+        sameTimeRange(left.time, right.time)) {
+        score += 12;
+    }
+    if (left.kind === "series" && right.kind === "series") {
+        score += 24;
+        if (left.recurrence.parity === right.recurrence.parity)
+            score += 5;
+    }
+    if (left.kind === "occurrence" && right.kind === "occurrence") {
+        score += 34;
+        if (left.transfer &&
+            right.transfer &&
+            sameDate(left.transfer.fromDate, right.transfer.fromDate) &&
+            left.transfer.fromSlot === right.transfer.fromSlot) {
+            score += 30;
+        }
+    }
+    score += relationScore(valuesOverlap(left.rooms.values.map((value) => directory.resolveRoom(value)), right.rooms.values.map((value) => directory.resolveRoom(value))));
+    score += relationScore(valuesOverlap(left.teachers.values.map((value) => directory.resolveTeacher(value)), right.teachers.values.map((value) => directory.resolveTeacher(value))));
+    score += relationScore(groupsOverlap(left.groups.values.map((value) => ({
+        ...value,
+        group: directory.resolveGroup(value.group),
+    })), right.groups.values.map((value) => ({
+        ...value,
+        group: directory.resolveGroup(value.group),
+    }))));
+    if (sameSource)
+        score += 8;
+    return score;
+}
+function serializeObservation(observation) {
+    return structuredClone(observation);
+}
+function deserializeObservation(observation) {
+    return structuredClone(observation);
+}
+function serializeSource(source) {
+    return {
+        ...source,
+        observedAt: source.observedAt.toISOString(),
+        observations: source.observations.map(serializeObservation),
+    };
+}
+function deserializeSource(source) {
+    return {
+        ...source,
+        observedAt: new Date(source.observedAt),
+        observations: source.observations.map(deserializeObservation),
+    };
+}
+function sourceRef(claim) {
+    return {
+        sourceKey: claim.source.sourceKey,
+        observationKey: claim.observation.key,
+        observedAt: new Date(claim.source.observedAt),
+        owner: claim.source.owner,
+    };
+}
+function deterministicClaims(record) {
+    return [...record.claims.values()].sort((a, b) => {
+        const source = a.source.sourceKey.localeCompare(b.source.sourceKey);
+        return source || a.observation.key.localeCompare(b.observation.key);
+    });
+}
+function preferredClaim(claims) {
+    return [...claims].sort((a, b) => {
+        const completeness = (claim) => claim.observation.groups.values.length +
+            claim.observation.teachers.values.length +
+            claim.observation.rooms.values.length;
+        return (completeness(b) - completeness(a) ||
+            a.source.sourceKey.localeCompare(b.source.sourceKey) ||
+            a.observation.key.localeCompare(b.observation.key));
+    })[0];
+}
+function consensusField(claims, select, key) {
+    const ranked = [...claims].sort((a, b) => {
+        const completeness = (claim) => claim.observation.groups.values.length +
+            claim.observation.teachers.values.length +
+            claim.observation.rooms.values.length;
+        return (completeness(b) - completeness(a) ||
+            a.source.sourceKey.localeCompare(b.source.sourceKey) ||
+            a.observation.key.localeCompare(b.observation.key));
+    });
+    const evidence = new Map();
+    for (const [rank, claim] of ranked.entries()) {
+        const value = select(claim.observation);
+        if (value === undefined)
+            continue;
+        const evidenceKey = key(value);
+        const current = evidence.get(evidenceKey);
+        if (current == null) {
+            evidence.set(evidenceKey, { value, count: 1, rank });
+        }
+        else {
+            current.count++;
+        }
+    }
+    return [...evidence.values()].sort((a, b) => b.count - a.count || a.rank - b.rank)[0]?.value;
+}
+function ownerEntity(owner) {
+    if (owner.type === "group") {
+        return { kind: "group", value: { group: owner.group } };
+    }
+    if (owner.type === "teacher")
+        return { kind: "teacher", value: owner };
+    return { kind: "room", value: owner };
+}
+function aggregateCompleteness(sets) {
+    if (sets.some((value) => value.completeness === "partial" || value.values.length > 0)) {
+        return "partial";
+    }
+    if (sets.some((value) => value.completeness === "complete"))
+        return "complete";
+    return "unknown";
+}
+function aggregateRelations(claims) {
+    const groups = [];
+    const teachers = [];
+    const rooms = [];
+    for (const claim of claims) {
+        groups.push(...claim.observation.groups.values);
+        teachers.push(...claim.observation.teachers.values);
+        rooms.push(...claim.observation.rooms.values);
+        const implicit = ownerEntity(claim.source.owner);
+        if (implicit.kind === "group" &&
+            !claim.observation.groups.values.some((value) => entityKey(value.group) === entityKey(implicit.value.group))) {
+            groups.push(implicit.value);
+        }
+        if (implicit.kind === "teacher")
+            teachers.push(implicit.value.teacher);
+        if (implicit.kind === "room")
+            rooms.push(implicit.value.room);
+    }
+    return {
+        groups: {
+            values: mergeGroups(groups),
+            completeness: claims.some((value) => value.source.owner.type === "group")
+                ? "partial"
+                : aggregateCompleteness(claims.map((value) => value.observation.groups)),
+        },
+        teachers: {
+            values: mergeTeachers(teachers),
+            completeness: claims.some((value) => value.source.owner.type === "teacher")
+                ? "partial"
+                : aggregateCompleteness(claims.map((value) => value.observation.teachers)),
+        },
+        rooms: {
+            values: mergeRooms(rooms),
+            completeness: claims.some((value) => value.source.owner.type === "room")
+                ? "partial"
+                : aggregateCompleteness(claims.map((value) => value.observation.rooms)),
+        },
+    };
+}
+function ownerMatches(owner, relations) {
+    if (owner.type === "group") {
+        const key = entityKey(owner.group);
+        return relations.groups.values.some((value) => entityKey(value.group) === key);
+    }
+    if (owner.type === "teacher") {
+        const key = entityKey(owner.teacher);
+        return relations.teachers.values.some((value) => entityKey(value) === key);
+    }
+    const key = entityKey(owner.room);
+    return relations.rooms.values.some((value) => entityKey(value) === key);
+}
+export class TimetableRepository {
+    idGenerator;
+    _directory;
+    sources = new Map();
+    links = new Map();
+    seriesRecords = new Map();
+    occurrenceRecords = new Map();
+    _revision = 0;
+    constructor(opts) {
+        this.idGenerator = opts?.idGenerator ?? new RandomLessonIdGenerator();
+        this._directory = new TimetableDirectory();
+        if (opts?.snapshot)
+            this.restore(opts.snapshot);
+    }
+    get directory() {
+        return this._directory;
+    }
+    get revision() {
+        return this._revision;
+    }
+    rememberGroups(values) {
+        if (this.directory.rememberGroups(values))
+            this._revision++;
+    }
+    rememberTeachers(values) {
+        if (this.directory.rememberTeachers(values))
+            this._revision++;
+    }
+    rememberRooms(values) {
+        if (this.directory.rememberRooms(values))
+            this._revision++;
+    }
+    ingest(snapshot) {
+        const incoming = structuredClone(snapshot);
+        this.validateSource(incoming);
+        this.rememberSourceEntities(incoming);
+        const prior = this.sources.get(incoming.sourceKey);
+        const priorClaims = new Map();
+        if (prior) {
+            for (const observation of prior.observations) {
+                priorClaims.set(observation.key, { source: prior, observation });
+                this.removeClaim(incoming.sourceKey, observation.key);
+            }
+        }
+        this.sources.set(incoming.sourceKey, incoming);
+        const usedTargets = new Set();
+        const seriesIds = [];
+        const lessonIds = [];
+        let created = 0;
+        let updated = 0;
+        const currentKeys = new Set(incoming.observations.map((value) => value.key));
+        for (const observation of incoming.observations) {
+            const linkKey = sourceObservationKey(incoming.sourceKey, observation.key);
+            const exact = this.links.get(linkKey);
+            const exactPrior = priorClaims.get(observation.key);
+            let target = exact?.kind === observation.kind &&
+                exactPrior?.observation.kind === observation.kind &&
+                observationScore(observation, exactPrior.observation, true, this.directory) >= 55 &&
+                !usedTargets.has(exact.id)
+                ? exact
+                : undefined;
+            if (!target) {
+                target = this.findPriorTarget(observation, priorClaims, usedTargets);
+            }
+            if (!target) {
+                target = this.findCanonicalTarget(observation, incoming, usedTargets);
+            }
+            if (!target) {
+                target =
+                    observation.kind === "series"
+                        ? { kind: "series", id: this.idGenerator.seriesId() }
+                        : { kind: "occurrence", id: this.idGenerator.lessonId() };
+                created++;
+            }
+            else {
+                updated++;
+            }
+            this.links.set(linkKey, target);
+            usedTargets.add(target.id);
+            this.addClaim(target, incoming, observation);
+            if (target.kind === "series")
+                seriesIds.push(target.id);
+            else
+                lessonIds.push(target.id);
+        }
+        if (prior) {
+            for (const observation of prior.observations) {
+                if (!currentKeys.has(observation.key)) {
+                    this.links.delete(sourceObservationKey(incoming.sourceKey, observation.key));
+                }
+            }
+        }
+        this.pruneEmptyRecords();
+        this._revision++;
+        return {
+            revision: this._revision,
+            seriesIds,
+            lessonIds,
+            created,
+            updated,
+            removedObservations: Math.max(0, prior?.observations.filter((value) => !currentKeys.has(value.key)).length ?? 0),
+        };
+    }
+    getSeries(opts) {
+        const values = [];
+        for (const record of this.seriesRecords.values()) {
+            if (record.claims.size === 0)
+                continue;
+            const value = this.aggregateSeries(record);
+            if (opts?.academicYearStartYear != null &&
+                value.academicYearStartYear !== opts.academicYearStartYear) {
+                continue;
+            }
+            if (opts?.periods && !opts.periods.includes(value.period))
+                continue;
+            if (opts?.owner && !ownerMatches(opts.owner, value))
+                continue;
+            values.push(value);
+        }
+        return values.sort((a, b) => a.recurrence.weekday - b.recurrence.weekday ||
+            (a.slotNumber ?? Number.MAX_SAFE_INTEGER) -
+                (b.slotNumber ?? Number.MAX_SAFE_INTEGER) ||
+            a.subject.localeCompare(b.subject) ||
+            a.id.localeCompare(b.id));
+    }
+    getDirectOccurrences(opts) {
+        const values = [];
+        for (const record of this.occurrenceRecords.values()) {
+            if (record.claims.size === 0)
+                continue;
+            const value = this.aggregateOccurrence(record);
+            if (opts?.academicYearStartYear != null &&
+                value.academicYearStartYear !== opts.academicYearStartYear) {
+                continue;
+            }
+            if (opts?.periods && !opts.periods.includes(value.period))
+                continue;
+            if (opts?.owner && !ownerMatches(opts.owner, value))
+                continue;
+            values.push(value);
+        }
+        return values.sort((a, b) => a.scheduledDate.localeCompare(b.scheduledDate) ||
+            ((a.time?.start.hours ?? 24) * 60 + (a.time?.start.minutes ?? 0)) -
+                ((b.time?.start.hours ?? 24) * 60 + (b.time?.start.minutes ?? 0)) ||
+            a.id.localeCompare(b.id));
+    }
+    export() {
+        return {
+            schemaVersion: 5,
+            revision: this._revision,
+            directory: this.directory.export(),
+            sources: [...this.sources.values()]
+                .sort((a, b) => a.sourceKey.localeCompare(b.sourceKey))
+                .map(serializeSource),
+            links: [...this.links.entries()]
+                .map(([key, value]) => {
+                const separator = key.indexOf("\u0000");
+                return {
+                    sourceKey: key.slice(0, separator),
+                    observationKey: key.slice(separator + 1),
+                    ...value,
+                };
+            })
+                .sort((a, b) => a.sourceKey.localeCompare(b.sourceKey) ||
+                a.observationKey.localeCompare(b.observationKey)),
+        };
+    }
+    replaceSnapshot(snapshot) {
+        this.restore(snapshot);
+    }
+    restore(snapshot) {
+        if (snapshot.schemaVersion !== 5) {
+            throw new Error(`Unsupported timetable repository schema: ${snapshot.schemaVersion}`);
+        }
+        if (!Number.isInteger(snapshot.revision) || snapshot.revision < 0) {
+            throw new Error("Invalid timetable repository revision");
+        }
+        const sources = snapshot.sources.map(deserializeSource);
+        const sourceKeys = new Set();
+        for (const source of sources) {
+            this.validateSource(source);
+            if (sourceKeys.has(source.sourceKey)) {
+                throw new Error(`Duplicate timetable source: ${source.sourceKey}`);
+            }
+            sourceKeys.add(source.sourceKey);
+        }
+        this.sources.clear();
+        this.links.clear();
+        this.seriesRecords.clear();
+        this.occurrenceRecords.clear();
+        this._directory = new TimetableDirectory(snapshot.directory);
+        this._revision = snapshot.revision;
+        for (const source of sources) {
+            this.sources.set(source.sourceKey, source);
+        }
+        const linkedObservations = new Set();
+        for (const link of snapshot.links) {
+            const key = sourceObservationKey(link.sourceKey, link.observationKey);
+            if (!link.id || linkedObservations.has(key)) {
+                throw new Error(`Invalid or duplicate timetable link: ${link.sourceKey}/${link.observationKey}`);
+            }
+            const source = this.sources.get(link.sourceKey);
+            const observation = source?.observations.find((value) => value.key === link.observationKey);
+            if (!observation || observation.kind !== link.kind) {
+                throw new Error(`Dangling timetable link: ${link.sourceKey}/${link.observationKey}`);
+            }
+            linkedObservations.add(key);
+            this.links.set(key, { kind: link.kind, id: link.id });
+        }
+        for (const source of this.sources.values()) {
+            for (const observation of source.observations) {
+                const link = this.links.get(sourceObservationKey(source.sourceKey, observation.key));
+                if (!link) {
+                    throw new Error(`Missing timetable link: ${source.sourceKey}/${observation.key}`);
+                }
+                this.addClaim(link, source, observation);
+            }
+        }
+    }
+    validateSource(source) {
+        if (!source.sourceKey.trim())
+            throw new Error("Timetable source key is empty");
+        if (!Number.isInteger(source.academicYearStartYear)) {
+            throw new Error(`Invalid academic year for source ${source.sourceKey}`);
+        }
+        if (!Number.isInteger(source.period) || source.period < 1 || source.period > 4) {
+            throw new Error(`Invalid academic period for source ${source.sourceKey}`);
+        }
+        if (!(source.observedAt instanceof Date) || !Number.isFinite(source.observedAt.getTime())) {
+            throw new Error(`Invalid observation time for source ${source.sourceKey}`);
+        }
+        const validateRef = (value, label) => {
+            if (!value.name.trim())
+                throw new Error(`Empty ${label} in ${source.sourceKey}`);
+            if (value.id != null && (!Number.isInteger(value.id) || value.id < 1)) {
+                throw new Error(`Invalid ${label} ID in ${source.sourceKey}`);
+            }
+        };
+        const ownerRef = source.owner.type === "group"
+            ? source.owner.group
+            : source.owner.type === "teacher"
+                ? source.owner.teacher
+                : source.owner.room;
+        validateRef(ownerRef, `${source.owner.type} owner`);
+        const keys = new Set();
+        for (const observation of source.observations) {
+            if (!observation.key.trim() || keys.has(observation.key)) {
+                throw new Error(`Invalid or duplicate observation key in ${source.sourceKey}`);
+            }
+            if (!observation.subject.trim()) {
+                throw new Error(`Empty lesson subject in ${source.sourceKey}/${observation.key}`);
+            }
+            if (!observation.type.trim()) {
+                throw new Error(`Empty lesson type in ${source.sourceKey}/${observation.key}`);
+            }
+            const relations = [
+                ["group", observation.groups, observation.groups.values.map((value) => value.group)],
+                ["teacher", observation.teachers, observation.teachers.values],
+                ["room", observation.rooms, observation.rooms.values],
+            ];
+            for (const [label, relation, values] of relations) {
+                if (!["unknown", "partial", "complete"].includes(relation.completeness)) {
+                    throw new Error(`Invalid ${label} completeness in ${source.sourceKey}/${observation.key}`);
+                }
+                if (relation.completeness === "unknown" && values.length > 0) {
+                    throw new Error(`Unknown ${label} relation has values in ${source.sourceKey}/${observation.key}`);
+                }
+                for (const value of values)
+                    validateRef(value, label);
+            }
+            if (observation.slotNumber != null &&
+                (!Number.isInteger(observation.slotNumber) || observation.slotNumber < 1)) {
+                throw new Error(`Invalid slot number in ${source.sourceKey}/${observation.key}`);
+            }
+            if (observation.time) {
+                const start = observation.time.start.hours * 60 + observation.time.start.minutes;
+                const end = observation.time.end.hours * 60 + observation.time.end.minutes;
+                const validPart = (value) => Number.isInteger(value.hours) && value.hours >= 0 && value.hours <= 23 &&
+                    Number.isInteger(value.minutes) && value.minutes >= 0 && value.minutes <= 59;
+                if (!validPart(observation.time.start) || !validPart(observation.time.end) || end <= start) {
+                    throw new Error(`Invalid lesson time in ${source.sourceKey}/${observation.key}`);
+                }
+            }
+            for (const substitution of observation.substitutions ?? []) {
+                if (!isLocalDate(substitution.date)) {
+                    throw new Error(`Invalid substitution date in ${source.sourceKey}/${observation.key}`);
+                }
+                for (const value of substitution.rooms ?? [])
+                    validateRef(value, "substitution room");
+                for (const value of substitution.teachers ?? [])
+                    validateRef(value, "substitution teacher");
+            }
+            if (observation.kind === "series") {
+                const { weekday, weeks } = observation.recurrence;
+                if (!Number.isInteger(weekday) || weekday < 0 || weekday > 6) {
+                    throw new Error(`Invalid recurrence weekday in ${source.sourceKey}/${observation.key}`);
+                }
+                if (weeks && (!Number.isInteger(weeks.from) || !Number.isInteger(weeks.to) ||
+                    weeks.from < 1 || weeks.to < weeks.from)) {
+                    throw new Error(`Invalid recurrence weeks in ${source.sourceKey}/${observation.key}`);
+                }
+            }
+            else {
+                if (!isLocalDate(observation.date)) {
+                    throw new Error(`Invalid lesson date in ${source.sourceKey}/${observation.key}`);
+                }
+                if (observation.transfer && (!isLocalDate(observation.transfer.fromDate) ||
+                    !isLocalDate(observation.transfer.targetDate) ||
+                    !Number.isInteger(observation.transfer.fromSlot) ||
+                    observation.transfer.fromSlot < 1)) {
+                    throw new Error(`Invalid lesson transfer in ${source.sourceKey}/${observation.key}`);
+                }
+            }
+            keys.add(observation.key);
+        }
+    }
+    rememberSourceEntities(source) {
+        const groups = [];
+        const teachers = [];
+        const rooms = [];
+        if (source.owner.type === "group")
+            groups.push(source.owner.group);
+        if (source.owner.type === "teacher")
+            teachers.push(source.owner.teacher);
+        if (source.owner.type === "room")
+            rooms.push(source.owner.room);
+        for (const observation of source.observations) {
+            groups.push(...observation.groups.values.map((value) => value.group));
+            teachers.push(...observation.teachers.values);
+            rooms.push(...observation.rooms.values);
+            for (const substitution of observation.substitutions ?? []) {
+                teachers.push(...(substitution.teachers ?? []));
+                rooms.push(...(substitution.rooms ?? []));
+            }
+        }
+        this.directory.rememberGroups(groups);
+        this.directory.rememberTeachers(teachers);
+        this.directory.rememberRooms(rooms);
+    }
+    pruneEmptyRecords() {
+        for (const [id, record] of this.seriesRecords) {
+            if (record.claims.size === 0)
+                this.seriesRecords.delete(id);
+        }
+        for (const [id, record] of this.occurrenceRecords) {
+            if (record.claims.size === 0)
+                this.occurrenceRecords.delete(id);
+        }
+    }
+    removeClaim(sourceKey, observationKey) {
+        const link = this.links.get(sourceObservationKey(sourceKey, observationKey));
+        if (!link)
+            return;
+        const record = link.kind === "series"
+            ? this.seriesRecords.get(link.id)
+            : this.occurrenceRecords.get(link.id);
+        record?.claims.delete(claimKey(sourceKey, observationKey));
+    }
+    addClaim(link, source, observation) {
+        const key = claimKey(source.sourceKey, observation.key);
+        if (link.kind === "series" && observation.kind === "series") {
+            let record = this.seriesRecords.get(link.id);
+            if (!record) {
+                record = { id: link.id, claims: new Map() };
+                this.seriesRecords.set(link.id, record);
+            }
+            record.claims.set(key, { source, observation });
+        }
+        if (link.kind === "occurrence" && observation.kind === "occurrence") {
+            let record = this.occurrenceRecords.get(link.id);
+            if (!record) {
+                record = { id: link.id, claims: new Map() };
+                this.occurrenceRecords.set(link.id, record);
+            }
+            record.claims.set(key, { source, observation });
+        }
+    }
+    findPriorTarget(observation, prior, usedTargets) {
+        let best;
+        let tied = false;
+        for (const claim of prior.values()) {
+            const link = this.links.get(sourceObservationKey(claim.source.sourceKey, claim.observation.key));
+            if (!link || link.kind !== observation.kind || usedTargets.has(link.id)) {
+                continue;
+            }
+            const score = observationScore(observation, claim.observation, true, this.directory);
+            if (!best || score > best.score) {
+                best = { link, score };
+                tied = false;
+            }
+            else if (score === best.score) {
+                tied = true;
+            }
+        }
+        return best && best.score >= 55 && !tied ? best.link : undefined;
+    }
+    findCanonicalTarget(observation, source, usedTargets) {
+        const records = observation.kind === "series"
+            ? this.seriesRecords.values()
+            : this.occurrenceRecords.values();
+        let best;
+        let second = Number.NEGATIVE_INFINITY;
+        for (const record of records) {
+            if (usedTargets.has(record.id) || record.claims.size === 0)
+                continue;
+            let recordScore = Number.NEGATIVE_INFINITY;
+            for (const claim of record.claims.values()) {
+                if (claim.source.academicYearStartYear !==
+                    source.academicYearStartYear ||
+                    claim.source.period !== source.period) {
+                    continue;
+                }
+                recordScore = Math.max(recordScore, observationScore(observation, claim.observation, false, this.directory));
+            }
+            if (!best || recordScore > best.score) {
+                second = best?.score ?? Number.NEGATIVE_INFINITY;
+                best = { id: record.id, score: recordScore };
+            }
+            else if (recordScore > second) {
+                second = recordScore;
+            }
+        }
+        if (!best || best.score < 95 || best.score - second < 10)
+            return undefined;
+        return { kind: observation.kind, id: best.id };
+    }
+    aggregateSubstitutions(claims) {
+        const byDate = new Map();
+        for (const substitution of claims.flatMap((value) => value.observation.substitutions ?? [])) {
+            const current = byDate.get(substitution.date);
+            const rooms = mergeRooms([...(current?.rooms ?? []), ...(substitution.rooms ?? [])].map((value) => this.directory.resolveRoom(value)));
+            const teachers = mergeTeachers([...(current?.teachers ?? []), ...(substitution.teachers ?? [])].map((value) => this.directory.resolveTeacher(value)));
+            byDate.set(substitution.date, {
+                date: substitution.date,
+                rooms: rooms.length > 0 ? rooms : undefined,
+                teachers: teachers.length > 0 ? teachers : undefined,
+                isDistance: current?.isDistance === true || substitution.isDistance === true
+                    ? true
+                    : current?.isDistance ?? substitution.isDistance,
+            });
+        }
+        return [...byDate.values()].sort((a, b) => a.date.localeCompare(b.date));
+    }
+    aggregateSeries(record) {
+        const claims = deterministicClaims(record);
+        const preferred = preferredClaim(claims);
+        const rawRelations = aggregateRelations(claims);
+        const relations = {
+            groups: {
+                values: mergeGroups(rawRelations.groups.values.map((value) => ({
+                    ...value,
+                    group: this.directory.resolveGroup(value.group),
+                }))),
+                completeness: rawRelations.groups.completeness,
+            },
+            teachers: {
+                values: mergeTeachers(rawRelations.teachers.values.map((value) => this.directory.resolveTeacher(value))),
+                completeness: rawRelations.teachers.completeness,
+            },
+            rooms: {
+                values: mergeRooms(rawRelations.rooms.values.map((value) => this.directory.resolveRoom(value))),
+                completeness: rawRelations.rooms.completeness,
+            },
+        };
+        return {
+            id: record.id,
+            academicYearStartYear: preferred.source.academicYearStartYear,
+            period: preferred.source.period,
+            subject: preferred.observation.subject,
+            type: preferred.observation.type,
+            slotNumber: consensusField(claims, (value) => value.slotNumber, String),
+            time: consensusField(claims, (value) => value.time, (value) => JSON.stringify(value)),
+            recurrence: preferred.observation.recurrence,
+            ...relations,
+            isDistance: claims.some((value) => value.observation.isDistance === true),
+            possibleChanges: claims.some((value) => value.observation.possibleChanges === true),
+            substitutions: this.aggregateSubstitutions(claims),
+            sources: claims.map(sourceRef),
+        };
+    }
+    aggregateOccurrence(record) {
+        const claims = deterministicClaims(record);
+        const preferred = preferredClaim(claims);
+        const rawRelations = aggregateRelations(claims);
+        const relations = {
+            groups: {
+                values: mergeGroups(rawRelations.groups.values.map((value) => ({
+                    ...value,
+                    group: this.directory.resolveGroup(value.group),
+                }))),
+                completeness: rawRelations.groups.completeness,
+            },
+            teachers: {
+                values: mergeTeachers(rawRelations.teachers.values.map((value) => this.directory.resolveTeacher(value))),
+                completeness: rawRelations.teachers.completeness,
+            },
+            rooms: {
+                values: mergeRooms(rawRelations.rooms.values.map((value) => this.directory.resolveRoom(value))),
+                completeness: rawRelations.rooms.completeness,
+            },
+        };
+        const transfer = claims
+            .map((value) => value.observation.transfer)
+            .find((value) => value != null);
+        return {
+            id: record.id,
+            academicYearStartYear: preferred.source.academicYearStartYear,
+            period: preferred.source.period,
+            nominalDate: transfer?.fromDate ?? preferred.observation.date,
+            scheduledDate: transfer?.targetDate ?? preferred.observation.date,
+            subject: preferred.observation.subject,
+            type: preferred.observation.type,
+            slotNumber: consensusField(claims, (value) => value.slotNumber, String),
+            time: consensusField(claims, (value) => value.time, (value) => JSON.stringify(value)),
+            ...relations,
+            isDistance: claims.some((value) => value.observation.isDistance === true),
+            possibleChanges: claims.some((value) => value.observation.possibleChanges === true),
+            status: transfer ? "moved" : "scheduled",
+            movedFrom: transfer
+                ? { date: transfer.fromDate, slotNumber: transfer.fromSlot }
+                : undefined,
+            sources: claims.map(sourceRef),
+        };
+    }
+}
+export class MemoryTimetableRepositoryAdapter {
+    snapshot = null;
+    async load() {
+        return this.snapshot == null
+            ? null
+            : structuredClone(this.snapshot);
+    }
+    async compareAndSet(expectedRevision, snapshot) {
+        const currentRevision = this.snapshot?.revision ?? 0;
+        if (currentRevision !== expectedRevision)
+            return false;
+        this.snapshot = structuredClone(snapshot);
+        return true;
+    }
+    async clear() {
+        this.snapshot = null;
+    }
+}