dxcomplete 0.1.0

package/dist/runtime/records.js

@@ -0,0 +1,1463 @@
+import { randomUUID } from "node:crypto";
+export const COLLECTION_NAMES = [
+    "workspaces",
+    "statements",
+    "journal_entries",
+    "environments",
+    "components",
+    "estimates",
+    "benefits",
+    "expectations",
+    "requirements",
+    "tasks",
+    "commitments",
+    "deferrals",
+    "changes",
+    "decisions",
+    "risks"
+];
+export const LEGACY_COLLECTION_NAMES = [
+    "engagements",
+    "initiatives",
+    "service_charters",
+    "cost_baselines",
+    "cost_actuals",
+    "benefit_measurements"
+];
+export const DXCOMPLETE_TICKET_COLLECTION_NAME = "dxcomplete_tickets";
+export const LEGACY_INTAKE_COLLECTION_NAME = "intake_items";
+export const LEGACY_PRIVATE_COLLECTION_NAMES = [LEGACY_INTAKE_COLLECTION_NAME];
+export const INDEX_COLLECTION_NAMES = [...COLLECTION_NAMES, DXCOMPLETE_TICKET_COLLECTION_NAME];
+export const LINK_SCAN_COLLECTION_NAMES = [...COLLECTION_NAMES, ...LEGACY_COLLECTION_NAMES];
+export const READABLE_ID_SEQUENCES_COLLECTION = "readable_id_sequences";
+export const READABLE_ID_TYPE_CODES = {
+    statements: "STM",
+    journal_entries: "JRN",
+    environments: "ENV",
+    components: "CMP",
+    expectations: "EXP",
+    requirements: "REQ",
+    tasks: "TSK",
+    commitments: "CMT",
+    deferrals: "DFR",
+    decisions: "DEC",
+    changes: "CHG",
+    risks: "RSK",
+    estimates: "EST",
+    benefits: "BFT"
+};
+export const READABLE_ID_COLLECTION_NAMES = Object.keys(READABLE_ID_TYPE_CODES);
+export const RUNTIME_ACTOR_ID = "dxcomplete-runtime";
+const REVIEW_NOTE_RECORD_TYPES = ["expectations", "requirements"];
+const VERSIONED_RECORD_TYPES = [
+    "statements",
+    "environments",
+    "components",
+    "expectations",
+    "requirements",
+    "estimates",
+    "benefits"
+];
+const VERSION_HISTORY_FIELD = "versionHistory";
+const CHANGE_MANAGED_FIELDS = [
+    "changePlan",
+    "executionSteps",
+    "rollbackPlan",
+    "riskImpact",
+    "plannedFor",
+    "events"
+];
+const COMMITMENT_MANAGED_FIELDS = ["commitmentStatement", "reservations"];
+const DEFERRAL_MANAGED_FIELDS = ["reason", "status", "conditions", "conditionEvents"];
+const ESTIMATE_MANAGED_FIELDS = ["lineItems", "rollup"];
+const BENEFITS_MANAGED_FIELDS = ["benefitItems", "rollup"];
+const ENVIRONMENT_MANAGED_FIELDS = ["name", "description"];
+const COMPONENT_MANAGED_FIELDS = [
+    "name",
+    "environmentId",
+    "kind",
+    "locator",
+    "identifiers",
+    "secretPointers",
+    "notes"
+];
+const DECISION_LEDGER_MANAGED_FIELDS = [
+    "matter",
+    "entries",
+    "currentDecision",
+    "question",
+    "decision",
+    "decidedBy",
+    "rationale",
+    "argumentsConsidered",
+    "concerns",
+    "status"
+];
+const TASK_LEDGER_MANAGED_FIELDS = [
+    "description",
+    "assignee",
+    "assignor",
+    "entries",
+    "currentStatus",
+    "details",
+    "status"
+];
+const DECISION_INPUT_MANAGED_FIELDS = ["informedBy", "informedByIds", "inputRecords"];
+const JOURNAL_ENTRY_MANAGED_FIELDS = ["kind", "body", "tag", "covers", "coveredBySummaryId"];
+const JOURNAL_COMPACTION_THRESHOLD = 200;
+const VERSIONED_TYPED_FIELDS = {
+    statements: ["statement", "source"],
+    expectations: ["statement", "successRecognition", "approvalState", "approvedBy", "approvedAt", "source"],
+    requirements: ["statement", "acceptanceCriteria", "priority", "status"],
+    estimates: ["lineItems", "rollup"],
+    benefits: ["benefitItems", "rollup"],
+    environments: ["name", "description"],
+    components: ["name", "environmentId", "kind", "locator", "identifiers", "secretPointers", "notes"]
+};
+const RESERVED_RELATIONSHIP_FIELDS = {
+    changes: ["requirementId"],
+    commitments: ["requirementIds", "expectationIds", "deferralId"],
+    deferrals: ["requirementIds", "expectationIds"],
+    estimates: ["requirementIds", "expectationIds"],
+    benefits: ["requirementIds", "expectationIds"],
+    expectations: ["statementId"],
+    requirements: ["expectationId"],
+    tasks: ["requirementId"]
+};
+const REMOVED_INITIATIVE_FIELD_RECORD_TYPES = [
+    "changes",
+    "estimates",
+    "benefits",
+    "expectations"
+];
+export function assertCollectionName(value) {
+    if (COLLECTION_NAMES.includes(value)) {
+        return value;
+    }
+    throw new Error(`Unsupported record type "${value}".`);
+}
+export async function createRecord(db, recordType, input, actorId) {
+    assertNoReservedRelationshipFields(recordType, input.fields);
+    if (input.allowManagedFields) {
+        assertNoReviewNotesField(recordType, input.fields);
+    }
+    else {
+        assertNoManagedField(recordType, input.fields);
+    }
+    const now = new Date().toISOString();
+    const workspaceId = workspaceIdForCreate(recordType, input.workspaceId);
+    if (workspaceId) {
+        await assertWorkspaceExists(db, workspaceId);
+    }
+    const record = {
+        _id: input.id ?? randomUUID(),
+        recordType,
+        ...(workspaceId ? { workspaceId } : {}),
+        title: input.title,
+        summary: input.summary,
+        fields: input.fields ?? {},
+        links: [],
+        createdAt: now,
+        createdBy: actorId,
+        updatedAt: now,
+        updatedBy: actorId
+    };
+    if (recordTypeSupportsReadableId(recordType)) {
+        const session = db.client.startSession();
+        try {
+            await session.withTransaction(async () => {
+                record.readableId = await allocateReadableId(db, recordType, workspaceId, actorId, now, session);
+                await db.collection(recordType).insertOne(record, { session });
+            });
+        }
+        finally {
+            await session.endSession();
+        }
+        return record;
+    }
+    await db.collection(recordType).insertOne(record);
+    return record;
+}
+export async function listRecords(db, recordType, limit, options = {}) {
+    const filter = {};
+    if (recordTypeRequiresWorkspace(recordType)) {
+        filter.workspaceId = readRequiredWorkspaceId(options.workspaceId, recordType);
+    }
+    if (!options.includeArchived) {
+        filter.archivedAt = { $exists: false };
+    }
+    return db
+        .collection(recordType)
+        .find(filter)
+        .sort({ createdAt: -1 })
+        .limit(limit)
+        .toArray();
+}
+export async function getRecord(db, recordType, id, options = {}) {
+    const filter = recordIdentityFilter(recordType, id);
+    if (recordTypeRequiresWorkspace(recordType) &&
+        !options.allowAnyWorkspace &&
+        isCurrentCollection(recordType)) {
+        filter.workspaceId = readRequiredWorkspaceId(options.workspaceId, recordType);
+    }
+    return db.collection(recordType).findOne(filter);
+}
+export async function listLinkedRecords(db, input) {
+    const source = await getRecord(db, input.recordType, input.id, { workspaceId: input.workspaceId });
+    if (!source) {
+        throw new Error(`Record not found: ${input.recordType}/${input.id}`);
+    }
+    const direction = input.direction ?? "both";
+    const result = {
+        source,
+        outbound: [],
+        inbound: []
+    };
+    if (direction === "outbound" || direction === "both") {
+        for (const link of source.links.filter((link) => linkMatches(link, input.relationship))) {
+            const target = await getRecord(db, link.toType, link.toId, {
+                workspaceId: source.workspaceId,
+                allowAnyWorkspace: !source.workspaceId
+            });
+            if (!target ||
+                (!input.includeArchived && target.archivedAt) ||
+                !recordBelongsToWorkspace(target, source.workspaceId)) {
+                continue;
+            }
+            result.outbound.push({
+                edge: {
+                    fromType: source.recordType,
+                    fromId: source._id,
+                    ...link
+                },
+                record: target
+            });
+        }
+    }
+    if (direction === "inbound" || direction === "both") {
+        for (const collectionName of LINK_SCAN_COLLECTION_NAMES) {
+            const filter = {
+                links: {
+                    $elemMatch: {
+                        toType: input.recordType,
+                        toId: source._id,
+                        ...(input.relationship ? { relationship: input.relationship } : {})
+                    }
+                }
+            };
+            if (source.workspaceId && recordTypeRequiresWorkspace(collectionName)) {
+                filter.workspaceId = source.workspaceId;
+            }
+            if (!input.includeArchived) {
+                filter.archivedAt = { $exists: false };
+            }
+            const records = await db.collection(collectionName).find(filter).toArray();
+            for (const record of records) {
+                for (const link of record.links.filter((link) => link.toType === input.recordType &&
+                    link.toId === source._id &&
+                    linkMatches(link, input.relationship))) {
+                    result.inbound.push({
+                        edge: {
+                            fromType: record.recordType,
+                            fromId: record._id,
+                            ...link
+                        },
+                        record
+                    });
+                }
+            }
+        }
+    }
+    return result;
+}
+export async function migrateLegacyIntakeItemsToDxcompleteTickets(db) {
+    const legacyCollection = db.collection(LEGACY_INTAKE_COLLECTION_NAME);
+    const ticketCollection = db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME);
+    const legacyRecords = await legacyCollection.find({}).toArray();
+    let copied = 0;
+    let skipped = 0;
+    for (const legacyRecord of legacyRecords) {
+        const existing = await ticketCollection.findOne({ _id: legacyRecord._id });
+        if (existing) {
+            skipped += 1;
+            continue;
+        }
+        const migratedRecord = {
+            ...legacyRecord,
+            recordType: DXCOMPLETE_TICKET_COLLECTION_NAME,
+            fields: {
+                ...legacyRecord.fields,
+                entries: normalizeTicketEntries(legacyRecord.fields.entries)
+            }
+        };
+        await ticketCollection.insertOne(migratedRecord);
+        copied += 1;
+    }
+    return { copied, skipped };
+}
+export async function createDxcompleteTicket(db, input, actor) {
+    const now = new Date().toISOString();
+    const entry = {
+        id: randomUUID(),
+        body: input.body,
+        createdAt: now,
+        createdBy: actor.actorId,
+        direction: "submitter_entry"
+    };
+    const record = {
+        _id: randomUUID(),
+        recordType: DXCOMPLETE_TICKET_COLLECTION_NAME,
+        title: input.title,
+        fields: {
+            ownerActorId: actor.actorId,
+            entries: [entry]
+        },
+        links: [],
+        createdAt: now,
+        createdBy: actor.actorId,
+        updatedAt: now,
+        updatedBy: actor.actorId
+    };
+    await db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME).insertOne(record);
+    return record;
+}
+export async function getDxcompleteTicket(db, id, actor) {
+    const record = await db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME).findOne(ticketOwnerFilter(id, actor));
+    if (!record) {
+        throw new Error(`DX Complete Ticket not found: ${id}`);
+    }
+    return record;
+}
+export async function listDxcompleteTickets(db, actor, limit, options = {}) {
+    const filter = {
+        "fields.ownerActorId": actor.actorId
+    };
+    if (!options.includeArchived) {
+        filter.archivedAt = { $exists: false };
+    }
+    return db
+        .collection(DXCOMPLETE_TICKET_COLLECTION_NAME)
+        .find(filter)
+        .sort({ updatedAt: -1 })
+        .limit(limit)
+        .toArray();
+}
+export async function appendDxcompleteTicket(db, input, actor) {
+    const collection = db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME);
+    const existing = await collection.findOne({
+        ...ticketOwnerFilter(input.id, actor),
+        archivedAt: { $exists: false }
+    });
+    if (!existing) {
+        throw new Error(`Active DX Complete Ticket not found: ${input.id}`);
+    }
+    const now = new Date().toISOString();
+    const entry = {
+        id: randomUUID(),
+        body: input.body,
+        createdAt: now,
+        createdBy: actor.actorId,
+        direction: "submitter_entry"
+    };
+    await collection.updateOne(ticketOwnerFilter(input.id, actor), {
+        $push: {
+            "fields.entries": entry
+        },
+        $set: {
+            updatedAt: now,
+            updatedBy: actor.actorId
+        }
+    });
+    return getDxcompleteTicket(db, input.id, actor);
+}
+export async function appendDxcompleteTicketReply(db, input, actorId = RUNTIME_ACTOR_ID) {
+    const collection = db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME);
+    const existing = await collection.findOne({
+        _id: input.id,
+        "fields.ownerActorId": input.addressedToActorId,
+        archivedAt: { $exists: false }
+    });
+    if (!existing) {
+        throw new Error(`Active DX Complete Ticket not found for addressed actor: ${input.id}`);
+    }
+    const now = new Date().toISOString();
+    const entry = {
+        id: randomUUID(),
+        body: input.body,
+        createdAt: now,
+        createdBy: actorId,
+        direction: "dxcomplete_reply",
+        addressedToActorId: input.addressedToActorId
+    };
+    await collection.updateOne({ _id: input.id }, {
+        $push: {
+            "fields.entries": entry
+        },
+        $set: {
+            updatedAt: now,
+            updatedBy: actorId
+        }
+    });
+    const record = await collection.findOne({ _id: input.id });
+    if (!record) {
+        throw new Error(`DX Complete Ticket not found after reply append: ${input.id}`);
+    }
+    return record;
+}
+export async function appendJournalNote(db, input, actorId) {
+    return createRecord(db, "journal_entries", {
+        workspaceId: input.workspaceId,
+        title: input.tag ? `Journal note: ${input.tag}` : "Journal note",
+        summary: input.body,
+        allowManagedFields: true,
+        fields: {
+            kind: "note",
+            body: input.body,
+            ...(input.tag ? { tag: input.tag } : {})
+        }
+    }, actorId);
+}
+export async function readJournal(db, input) {
+    const limit = clampJournalReadLimit(input.limit);
+    const filter = {
+        workspaceId: readRequiredWorkspaceId(input.workspaceId, "journal_entries")
+    };
+    if (!input.includeArchived) {
+        filter.archivedAt = { $exists: false };
+        filter["fields.kind"] = { $in: ["note", "summary"] };
+    }
+    const [entries, activeRawNoteCount] = await Promise.all([
+        db
+            .collection("journal_entries")
+            .find(filter)
+            .sort({ createdAt: 1 })
+            .limit(limit)
+            .toArray(),
+        db.collection("journal_entries").countDocuments({
+            workspaceId: input.workspaceId,
+            archivedAt: { $exists: false },
+            "fields.kind": "note"
+        })
+    ]);
+    return {
+        workspaceId: input.workspaceId,
+        readTier: input.includeArchived ? "cold" : "hot",
+        compaction: {
+            activeRawNoteCount,
+            threshold: JOURNAL_COMPACTION_THRESHOLD,
+            recommended: activeRawNoteCount >= JOURNAL_COMPACTION_THRESHOLD
+        },
+        entries
+    };
+}
+export async function getJournalEntry(db, input) {
+    const entry = await getRecord(db, "journal_entries", input.id, { workspaceId: input.workspaceId });
+    if (!entry) {
+        throw new Error(`Journal entry not found: journal_entries/${input.id}`);
+    }
+    return entry;
+}
+export async function appendJournalSummary(db, input, actorId) {
+    const coveredIds = [...new Set(input.covers.map((id) => id.trim()).filter(Boolean))];
+    if (coveredIds.length === 0) {
+        throw new Error("append_journal_summary requires at least one covered journal entry id.");
+    }
+    const coveredEntries = [];
+    for (const id of coveredIds) {
+        const entry = await getRecord(db, "journal_entries", id, { workspaceId: input.workspaceId });
+        if (!entry) {
+            throw new Error(`Covered journal entry not found: journal_entries/${id}`);
+        }
+        const kind = readJournalEntryKind(entry);
+        if (!kind) {
+            throw new Error(`Covered record is not a journal note or summary: journal_entries/${id}`);
+        }
+        coveredEntries.push(entry);
+    }
+    const summary = await createRecord(db, "journal_entries", {
+        workspaceId: input.workspaceId,
+        title: input.tag ? `Journal summary: ${input.tag}` : "Journal summary",
+        summary: input.body,
+        allowManagedFields: true,
+        fields: {
+            kind: "summary",
+            body: input.body,
+            covers: coveredEntries.map((entry) => entry._id),
+            ...(input.tag ? { tag: input.tag } : {})
+        }
+    }, actorId);
+    const now = new Date().toISOString();
+    await db.collection("journal_entries").updateMany({
+        workspaceId: input.workspaceId,
+        _id: { $in: coveredEntries.map((entry) => entry._id) },
+        archivedAt: { $exists: false }
+    }, {
+        $set: {
+            archivedAt: now,
+            archivedBy: actorId,
+            archiveReason: `Covered by journal summary ${summary._id}`,
+            "fields.coveredBySummaryId": summary._id,
+            updatedAt: now,
+            updatedBy: actorId
+        }
+    });
+    return summary;
+}
+function clampJournalReadLimit(limit) {
+    if (!limit) {
+        return 100;
+    }
+    return Math.min(Math.max(limit, 1), 500);
+}
+function readJournalEntryKind(record) {
+    if (record.fields.kind === "note" || record.fields.kind === "summary") {
+        return record.fields.kind;
+    }
+    return undefined;
+}
+export async function appendReviewNote(db, input, actorId) {
+    const collection = db.collection(input.recordType);
+    const filter = scopedRecordFilter(input.recordType, input.id, input.workspaceId);
+    const existing = await collection.findOne(filter);
+    if (!existing) {
+        throw new Error(`Record not found: ${input.recordType}/${input.id}`);
+    }
+    const now = new Date().toISOString();
+    const note = {
+        id: randomUUID(),
+        body: input.body,
+        createdAt: now,
+        createdBy: actorId,
+        ...(input.important ? { important: true } : {})
+    };
+    await collection.updateOne(filter, {
+        $push: {
+            "fields.reviewNotes": note
+        },
+        $set: {
+            updatedAt: now,
+            updatedBy: actorId
+        }
+    });
+    const updated = await getRecord(db, input.recordType, input.id, { workspaceId: input.workspaceId });
+    if (!updated) {
+        throw new Error(`Record not found after review note append: ${input.recordType}/${input.id}`);
+    }
+    return updated;
+}
+export async function appendChangeEvent(db, input, actorId) {
+    const collection = db.collection("changes");
+    const filter = scopedRecordFilter("changes", input.changeId, input.workspaceId);
+    const existing = await collection.findOne(filter);
+    if (!existing) {
+        throw new Error(`Record not found: changes/${input.changeId}`);
+    }
+    const now = new Date().toISOString();
+    const event = {
+        ...input.event,
+        id: randomUUID(),
+        eventType: input.eventType,
+        createdAt: now,
+        createdBy: actorId
+    };
+    await collection.updateOne(filter, {
+        $push: {
+            "fields.events": event
+        },
+        $set: {
+            updatedAt: now,
+            updatedBy: actorId
+        }
+    });
+    const updated = await getRecord(db, "changes", input.changeId, { workspaceId: input.workspaceId });
+    if (!updated) {
+        throw new Error(`Record not found after change event append: changes/${input.changeId}`);
+    }
+    return updated;
+}
+export async function appendDeferralEvent(db, input, actorId) {
+    const collection = db.collection("deferrals");
+    const filter = scopedRecordFilter("deferrals", input.deferralId, input.workspaceId);
+    const existing = await collection.findOne(filter);
+    if (!existing) {
+        throw new Error(`Record not found: deferrals/${input.deferralId}`);
+    }
+    const now = new Date().toISOString();
+    const event = {
+        ...input.event,
+        id: randomUUID(),
+        eventType: input.eventType,
+        createdAt: now,
+        createdBy: actorId
+    };
+    const { conditions, status } = applyDeferralEventState(existing, event, actorId, now);
+    await collection.updateOne(filter, {
+        $push: {
+            "fields.conditionEvents": event
+        },
+        $set: {
+            "fields.conditions": conditions,
+            "fields.status": status,
+            updatedAt: now,
+            updatedBy: actorId
+        }
+    });
+    const updated = await getRecord(db, "deferrals", input.deferralId, { workspaceId: input.workspaceId });
+    if (!updated) {
+        throw new Error(`Record not found after deferral event append: deferrals/${input.deferralId}`);
+    }
+    return updated;
+}
+export async function appendDecisionEntry(db, input, actorId) {
+    const collection = db.collection("decisions");
+    const filter = scopedRecordFilter("decisions", input.decisionId, input.workspaceId);
+    const existing = await collection.findOne(filter);
+    if (!existing) {
+        throw new Error(`Record not found: decisions/${input.decisionId}`);
+    }
+    assertDecisionEntryInput(input);
+    const now = new Date().toISOString();
+    const entry = {
+        id: randomUUID(),
+        entryType: input.entryType,
+        body: input.body,
+        createdAt: now,
+        createdBy: actorId,
+        ...(input.decidedBy ? { decidedBy: input.decidedBy } : {}),
+        ...(input.rationale ? { rationale: input.rationale } : {})
+    };
+    const update = {
+        $push: {
+            "fields.entries": entry
+        },
+        $set: {
+            updatedAt: now,
+            updatedBy: actorId
+        }
+    };
+    if (entry.entryType === "decision") {
+        update.$set["fields.currentDecision"] = decisionEntryToCurrentDecision(entry);
+    }
+    await collection.updateOne(filter, update);
+    const updated = await getRecord(db, "decisions", input.decisionId, { workspaceId: input.workspaceId });
+    if (!updated) {
+        throw new Error(`Record not found after decision entry append: decisions/${input.decisionId}`);
+    }
+    return updated;
+}
+export async function appendTaskEntry(db, input, actorId) {
+    const collection = db.collection("tasks");
+    const filter = scopedRecordFilter("tasks", input.taskId, input.workspaceId);
+    const existing = await collection.findOne(filter);
+    if (!existing) {
+        throw new Error(`Record not found: tasks/${input.taskId}`);
+    }
+    assertTaskEntryInput(input);
+    const now = new Date().toISOString();
+    const entry = {
+        id: randomUUID(),
+        entryType: input.entryType,
+        body: input.body,
+        createdAt: now,
+        createdBy: actorId,
+        ...(input.status ? { status: input.status } : {})
+    };
+    const update = {
+        $push: {
+            "fields.entries": entry
+        },
+        $set: {
+            updatedAt: now,
+            updatedBy: actorId
+        }
+    };
+    if (entry.entryType === "status_change") {
+        update.$set["fields.currentStatus"] = taskEntryToCurrentStatus(entry);
+    }
+    await collection.updateOne(filter, update);
+    const updated = await getRecord(db, "tasks", input.taskId, { workspaceId: input.workspaceId });
+    if (!updated) {
+        throw new Error(`Record not found after task entry append: tasks/${input.taskId}`);
+    }
+    return updated;
+}
+export function decisionEntryToCurrentDecision(entry) {
+    return {
+        entryId: entry.id,
+        body: entry.body,
+        createdAt: entry.createdAt,
+        createdBy: entry.createdBy,
+        ...(entry.decidedBy ? { decidedBy: entry.decidedBy } : {}),
+        ...(entry.rationale ? { rationale: entry.rationale } : {})
+    };
+}
+export function taskEntryToCurrentStatus(entry) {
+    if (entry.entryType !== "status_change" || !entry.status) {
+        throw new Error("Task current status can only derive from a status_change entry.");
+    }
+    return {
+        entryId: entry.id,
+        status: entry.status,
+        body: entry.body,
+        createdAt: entry.createdAt,
+        createdBy: entry.createdBy
+    };
+}
+function assertDecisionEntryInput(input) {
+    if (input.entryType !== "decision" && (input.decidedBy || input.rationale)) {
+        throw new Error("decidedBy and rationale are only valid on decision entries.");
+    }
+}
+function assertTaskEntryInput(input) {
+    if (input.entryType === "status_change" && !input.status) {
+        throw new Error("status_change entries require status.");
+    }
+    if (input.entryType !== "status_change" && input.status) {
+        throw new Error("status is only valid on status_change entries.");
+    }
+}
+function applyDeferralEventState(existing, event, actorId, now) {
+    const conditions = normalizeDeferralConditions(existing.fields.conditions);
+    let status = typeof existing.fields.status === "string" ? existing.fields.status : "open";
+    switch (event.eventType) {
+        case "condition_addressed":
+            return {
+                conditions: updateDeferralConditionState(conditions, event, "addressed", actorId, now),
+                status
+            };
+        case "condition_reopened":
+            return {
+                conditions: updateDeferralConditionState(conditions, event, "open", actorId, now),
+                status
+            };
+        case "condition_note_added":
+            assertDeferralConditionExists(conditions, event);
+            return { conditions, status };
+        case "deferral_resolved":
+            status = "resolved";
+            return { conditions, status };
+        case "deferral_abandoned":
+            status = "abandoned";
+            return { conditions, status };
+    }
+}
+function normalizeDeferralConditions(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isDeferralCondition);
+}
+function isDeferralCondition(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const condition = value;
+    return (typeof condition.id === "string" &&
+        typeof condition.statement === "string" &&
+        (condition.state === "open" || condition.state === "addressed") &&
+        typeof condition.createdAt === "string" &&
+        typeof condition.createdBy === "string" &&
+        typeof condition.updatedAt === "string" &&
+        typeof condition.updatedBy === "string");
+}
+function updateDeferralConditionState(conditions, event, state, actorId, now) {
+    const conditionId = readRequiredDeferralEventString(event, "conditionId");
+    let found = false;
+    const updated = conditions.map((condition) => {
+        if (condition.id !== conditionId) {
+            return condition;
+        }
+        found = true;
+        return {
+            ...condition,
+            state,
+            updatedAt: now,
+            updatedBy: actorId
+        };
+    });
+    if (!found) {
+        throw new Error(`Deferral condition not found: ${conditionId}`);
+    }
+    return updated;
+}
+function assertDeferralConditionExists(conditions, event) {
+    const conditionId = readRequiredDeferralEventString(event, "conditionId");
+    if (!conditions.some((condition) => condition.id === conditionId)) {
+        throw new Error(`Deferral condition not found: ${conditionId}`);
+    }
+}
+function readRequiredDeferralEventString(event, key) {
+    const value = event[key];
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`${event.eventType} requires ${key}.`);
+    }
+    return value;
+}
+export async function listUnreadDxcompleteTicketReplies(db, actor, limit) {
+    const records = await db
+        .collection(DXCOMPLETE_TICKET_COLLECTION_NAME)
+        .find({
+        "fields.ownerActorId": actor.actorId,
+        archivedAt: { $exists: false },
+        "fields.entries": {
+            $elemMatch: {
+                direction: "dxcomplete_reply",
+                addressedToActorId: actor.actorId,
+                readAt: { $exists: false }
+            }
+        }
+    })
+        .sort({ updatedAt: -1 })
+        .limit(limit)
+        .toArray();
+    return records.map((record) => {
+        const replies = normalizeTicketEntries(record.fields.entries).filter((entry) => entry.direction === "dxcomplete_reply" &&
+            entry.addressedToActorId === actor.actorId &&
+            !entry.readAt);
+        const replySummaries = replies.map((entry) => ({
+            id: entry.id,
+            createdAt: entry.createdAt,
+            createdBy: entry.createdBy,
+            direction: "dxcomplete_reply",
+            ...(entry.addressedToActorId ? { addressedToActorId: entry.addressedToActorId } : {})
+        }));
+        const newestReplyAt = replySummaries.reduce((current, entry) => (!current || entry.createdAt > current ? entry.createdAt : current), undefined);
+        return {
+            ticketId: record._id,
+            ...(record.title ? { title: record.title } : {}),
+            updatedAt: record.updatedAt,
+            unreadReplyCount: replySummaries.length,
+            ...(newestReplyAt ? { newestReplyAt } : {}),
+            replies: replySummaries
+        };
+    });
+}
+export async function readDxcompleteTicket(db, input, actor) {
+    const collection = db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME);
+    const existing = await collection.findOne(ticketOwnerFilter(input.id, actor));
+    if (!existing) {
+        throw new Error(`DX Complete Ticket not found: ${input.id}`);
+    }
+    const now = new Date().toISOString();
+    const entries = normalizeTicketEntries(existing.fields.entries);
+    let changed = false;
+    const nextEntries = entries.map((entry) => {
+        const shouldMark = entry.direction === "dxcomplete_reply" &&
+            entry.addressedToActorId === actor.actorId &&
+            !entry.readAt;
+        if (!shouldMark) {
+            return entry;
+        }
+        changed = true;
+        return {
+            ...entry,
+            readAt: now
+        };
+    });
+    if (!changed) {
+        return existing;
+    }
+    await collection.updateOne(ticketOwnerFilter(input.id, actor), {
+        $set: {
+            "fields.entries": nextEntries,
+            updatedAt: now,
+            updatedBy: actor.actorId
+        }
+    });
+    return getDxcompleteTicket(db, input.id, actor);
+}
+export async function archiveDxcompleteTicket(db, input, actor) {
+    const collection = db.collection(DXCOMPLETE_TICKET_COLLECTION_NAME);
+    const existing = await collection.findOne(ticketOwnerFilter(input.id, actor));
+    if (!existing) {
+        throw new Error(`DX Complete Ticket not found: ${input.id}`);
+    }
+    if (existing.archivedAt) {
+        return existing;
+    }
+    const now = new Date().toISOString();
+    await collection.updateOne(ticketOwnerFilter(input.id, actor), {
+        $set: {
+            archivedAt: now,
+            updatedAt: now,
+            updatedBy: actor.actorId
+        }
+    });
+    return getDxcompleteTicket(db, input.id, actor);
+}
+export async function updateRecord(db, input, actorId) {
+    const collection = db.collection(input.recordType);
+    const recordFilter = scopedRecordFilter(input.recordType, input.id, input.workspaceId);
+    const existing = await collection.findOne(recordFilter);
+    if (!existing) {
+        throw new Error(`Record not found: ${input.recordType}/${input.id}`);
+    }
+    const now = new Date().toISOString();
+    const set = {
+        updatedAt: now,
+        updatedBy: actorId
+    };
+    const unset = {};
+    const versioned = recordTypeSupportsVersionHistory(input.recordType);
+    if (input.title !== undefined) {
+        set.title = input.title;
+    }
+    if (input.summary !== undefined) {
+        set.summary = input.summary;
+    }
+    for (const [key, value] of Object.entries(input.fields ?? {})) {
+        assertFieldName(key);
+        assertNotReservedRelationshipField(input.recordType, key);
+        if (input.allowManagedFields) {
+            assertNotReviewNotesField(input.recordType, key);
+            assertNotVersionHistoryField(input.recordType, key);
+        }
+        else {
+            assertNotManagedField(input.recordType, key);
+            assertNotVersionedTypedField(input.recordType, key);
+        }
+        set[`fields.${key}`] = value;
+    }
+    for (const key of input.unsetFields ?? []) {
+        assertFieldName(key);
+        if (input.allowManagedFields) {
+            assertNotReviewNotesField(input.recordType, key);
+            assertNotVersionHistoryField(input.recordType, key);
+        }
+        else {
+            assertNotManagedField(input.recordType, key);
+            assertNotVersionedTypedField(input.recordType, key);
+        }
+        unset[`fields.${key}`] = "";
+    }
+    if (versioned) {
+        const previousSnapshot = createRecordVersionSnapshot(existing);
+        const nextSnapshot = createRecordVersionSnapshot(applyRecordUpdate(existing, input));
+        const changedFields = listSnapshotChanges(previousSnapshot, nextSnapshot);
+        const existingVersionHistory = normalizeVersionHistory(existing.fields.versionHistory);
+        if (changedFields.length === 0) {
+            return existing;
+        }
+        set["fields.versionHistory"] = [
+            ...existingVersionHistory,
+            createVersionHistoryEntry({
+                existingVersionHistory,
+                previousSnapshot,
+                nextSnapshot,
+                changedFields,
+                actorId,
+                createdAt: now,
+                revisionNote: input.revisionNote
+            })
+        ];
+    }
+    const update = Object.keys(unset).length > 0 ? { $set: set, $unset: unset } : { $set: set };
+    await collection.updateOne(recordFilter, update);
+    const updated = await collection.findOne(recordFilter);
+    if (!updated) {
+        throw new Error(`Updated record not found: ${input.recordType}/${input.id}`);
+    }
+    return updated;
+}
+function applyRecordUpdate(record, input) {
+    const fields = { ...record.fields };
+    for (const [key, value] of Object.entries(input.fields ?? {})) {
+        fields[key] = value;
+    }
+    for (const key of input.unsetFields ?? []) {
+        delete fields[key];
+    }
+    return {
+        ...record,
+        ...(input.title !== undefined ? { title: input.title } : {}),
+        ...(input.summary !== undefined ? { summary: input.summary } : {}),
+        fields
+    };
+}
+function createRecordVersionSnapshot(record) {
+    return {
+        ...(record.title !== undefined ? { title: record.title } : {}),
+        ...(record.summary !== undefined ? { summary: record.summary } : {}),
+        fields: Object.fromEntries(Object.entries(record.fields)
+            .filter(([key]) => key !== VERSION_HISTORY_FIELD && key !== "reviewNotes")
+            .map(([key, value]) => [key, cloneSnapshotValue(value)]))
+    };
+}
+function listSnapshotChanges(previousSnapshot, nextSnapshot) {
+    const changedFields = [];
+    if (!valuesEqual(previousSnapshot.title, nextSnapshot.title)) {
+        changedFields.push("title");
+    }
+    if (!valuesEqual(previousSnapshot.summary, nextSnapshot.summary)) {
+        changedFields.push("summary");
+    }
+    const fieldNames = new Set([
+        ...Object.keys(previousSnapshot.fields),
+        ...Object.keys(nextSnapshot.fields)
+    ]);
+    for (const fieldName of [...fieldNames].sort()) {
+        if (!valuesEqual(previousSnapshot.fields[fieldName], nextSnapshot.fields[fieldName])) {
+            changedFields.push(`fields.${fieldName}`);
+        }
+    }
+    return changedFields;
+}
+function normalizeVersionHistory(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isVersionHistoryEntry);
+}
+function createVersionHistoryEntry(input) {
+    const fromVersion = input.existingVersionHistory.reduce((currentVersion, entry) => Math.max(currentVersion, entry.toVersion), 1);
+    return {
+        id: randomUUID(),
+        fromVersion,
+        toVersion: fromVersion + 1,
+        createdAt: input.createdAt,
+        createdBy: input.actorId,
+        changedFields: input.changedFields,
+        previousSnapshot: input.previousSnapshot,
+        nextSnapshot: input.nextSnapshot,
+        ...(input.revisionNote ? { revisionNote: input.revisionNote } : {})
+    };
+}
+function isVersionHistoryEntry(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.id === "string" &&
+        typeof candidate.fromVersion === "number" &&
+        typeof candidate.toVersion === "number" &&
+        typeof candidate.createdAt === "string" &&
+        typeof candidate.createdBy === "string" &&
+        Array.isArray(candidate.changedFields) &&
+        typeof candidate.previousSnapshot === "object" &&
+        typeof candidate.nextSnapshot === "object");
+}
+function cloneSnapshotValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => cloneSnapshotValue(entry));
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => [key, cloneSnapshotValue(entry)]));
+    }
+    return value;
+}
+function valuesEqual(left, right) {
+    return stableStringify(left) === stableStringify(right);
+}
+function stableStringify(value) {
+    return JSON.stringify(cloneSnapshotValue(value));
+}
+export async function archiveRecord(db, input, actorId) {
+    const collection = db.collection(input.recordType);
+    const recordFilter = scopedRecordFilter(input.recordType, input.id, input.workspaceId);
+    const existing = await collection.findOne(recordFilter);
+    if (!existing) {
+        throw new Error(`Record not found: ${input.recordType}/${input.id}`);
+    }
+    if ((input.supersededByType && !input.supersededById) || (!input.supersededByType && input.supersededById)) {
+        throw new Error("supersededByType and supersededById must be provided together.");
+    }
+    const supersedingRecord = input.supersededByType && input.supersededById
+        ? await getRecord(db, input.supersededByType, input.supersededById, {
+            workspaceId: existing.workspaceId
+        })
+        : null;
+    if (input.supersededByType && input.supersededById && !supersedingRecord) {
+        throw new Error(`Superseding record not found: ${input.supersededByType}/${input.supersededById}`);
+    }
+    const now = new Date().toISOString();
+    const links = [...existing.links];
+    if (input.supersededByType && input.supersededById) {
+        links.push({
+            toType: input.supersededByType,
+            toId: supersedingRecord?._id ?? input.supersededById,
+            relationship: "superseded_by",
+            createdAt: now,
+            createdBy: actorId
+        });
+    }
+    await collection.updateOne(recordFilter, {
+        $set: {
+            links,
+            archivedAt: now,
+            archivedBy: actorId,
+            archiveReason: input.reason ?? "Archived",
+            updatedAt: now,
+            updatedBy: actorId
+        }
+    });
+    const updated = await collection.findOne(recordFilter);
+    if (!updated) {
+        throw new Error(`Archived record not found: ${input.recordType}/${input.id}`);
+    }
+    return updated;
+}
+export async function linkRecords(db, input, actorId) {
+    const sourceCollection = db.collection(input.fromType);
+    const source = await getRecord(db, input.fromType, input.fromId, {
+        workspaceId: input.workspaceId
+    });
+    const target = await getRecord(db, input.toType, input.toId, {
+        workspaceId: input.workspaceId
+    });
+    if (!source) {
+        throw new Error(`Source record not found: ${input.fromType}/${input.fromId}`);
+    }
+    if (!target) {
+        throw new Error(`Target record not found: ${input.toType}/${input.toId}`);
+    }
+    assertLinkWorkspaceBoundary(source, target);
+    const now = new Date().toISOString();
+    const link = {
+        toType: input.toType,
+        toId: target._id,
+        relationship: input.relationship ?? "related_to",
+        createdAt: now,
+        createdBy: actorId
+    };
+    await sourceCollection.updateOne(scopedRecordFilter(input.fromType, source._id, input.workspaceId), {
+        $push: { links: link },
+        $set: {
+            updatedAt: now,
+            updatedBy: actorId
+        }
+    });
+    const updated = await sourceCollection.findOne(scopedRecordFilter(input.fromType, source._id, input.workspaceId));
+    if (!updated) {
+        throw new Error(`Updated source record not found: ${input.fromType}/${input.fromId}`);
+    }
+    return updated;
+}
+export async function unlinkRecords(db, input, actorId) {
+    const sourceCollection = db.collection(input.fromType);
+    const source = await getRecord(db, input.fromType, input.fromId, {
+        workspaceId: input.workspaceId
+    });
+    const target = await getRecord(db, input.toType, input.toId, {
+        workspaceId: input.workspaceId
+    });
+    if (!source) {
+        throw new Error(`Source record not found: ${input.fromType}/${input.fromId}`);
+    }
+    if (!target) {
+        throw new Error(`Target record not found: ${input.toType}/${input.toId}`);
+    }
+    assertLinkWorkspaceBoundary(source, target);
+    const relationship = input.relationship ?? "related_to";
+    const remainingLinks = source.links.filter((link) => !(link.toType === input.toType &&
+        link.toId === target._id &&
+        link.relationship === relationship));
+    if (remainingLinks.length === source.links.length) {
+        return source;
+    }
+    const now = new Date().toISOString();
+    await sourceCollection.updateOne(scopedRecordFilter(input.fromType, source._id, input.workspaceId), {
+        $set: {
+            links: remainingLinks,
+            updatedAt: now,
+            updatedBy: actorId
+        }
+    });
+    const updated = await sourceCollection.findOne(scopedRecordFilter(input.fromType, source._id, input.workspaceId));
+    if (!updated) {
+        throw new Error(`Updated source record not found: ${input.fromType}/${input.fromId}`);
+    }
+    return updated;
+}
+function assertFieldName(key) {
+    if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(key)) {
+        throw new Error(`Invalid field name "${key}". Field updates only support top-level field names.`);
+    }
+}
+function assertNoReservedRelationshipFields(recordType, fields) {
+    for (const key of Object.keys(fields ?? {})) {
+        assertNotReservedRelationshipField(recordType, key);
+    }
+}
+function assertNoReviewNotesField(recordType, fields) {
+    for (const key of Object.keys(fields ?? {})) {
+        assertNotReviewNotesField(recordType, key);
+    }
+}
+function assertNoManagedField(recordType, fields) {
+    for (const key of Object.keys(fields ?? {})) {
+        assertNotManagedField(recordType, key);
+    }
+}
+function assertNotReservedRelationshipField(recordType, key) {
+    if (key === "workspaceId" && recordTypeRequiresWorkspace(recordType)) {
+        throw new Error(`fields.${key} is reserved for the workspace boundary on ${recordType}. Use the top-level ${key} argument instead.`);
+    }
+    if (key === "initiativeId" && REMOVED_INITIATIVE_FIELD_RECORD_TYPES.includes(recordType)) {
+        throw new Error(`fields.${key} belongs to the removed Initiative layer on ${recordType}. Records are scoped directly to workspace now.`);
+    }
+    if ((RESERVED_RELATIONSHIP_FIELDS[recordType] ?? []).includes(key)) {
+        throw new Error(`fields.${key} is reserved for relationships on ${recordType}. Use the typed relationship argument or link_records instead.`);
+    }
+}
+function assertNotManagedField(recordType, key) {
+    assertNotReviewNotesField(recordType, key);
+    assertNotVersionHistoryField(recordType, key);
+    assertNotChangeManagedField(recordType, key);
+    assertNotCommitmentManagedField(recordType, key);
+    assertNotDeferralManagedField(recordType, key);
+    assertNotEstimateManagedField(recordType, key);
+    assertNotBenefitsManagedField(recordType, key);
+    assertNotEnvironmentManagedField(recordType, key);
+    assertNotComponentManagedField(recordType, key);
+    assertNotDecisionLedgerManagedField(recordType, key);
+    assertNotTaskLedgerManagedField(recordType, key);
+    assertNotDecisionInputManagedField(recordType, key);
+    assertNotJournalEntryManagedField(recordType, key);
+}
+function assertNotVersionedTypedField(recordType, key) {
+    if (!(VERSIONED_TYPED_FIELDS[recordType] ?? []).includes(key)) {
+        return;
+    }
+    throw new Error(`fields.${key} is managed on ${recordType}. Use ${versionedUpdateToolName(recordType)} to change it.`);
+}
+function assertNotReviewNotesField(recordType, key) {
+    if (key !== "reviewNotes" || !recordTypeSupportsReviewNotes(recordType)) {
+        return;
+    }
+    throw new Error(`fields.reviewNotes is append-only on ${recordType}. Use append_review_note instead of setting or unsetting it directly.`);
+}
+function assertNotVersionHistoryField(recordType, key) {
+    if (key !== VERSION_HISTORY_FIELD || !recordTypeSupportsVersionHistory(recordType)) {
+        return;
+    }
+    throw new Error(`fields.versionHistory is append-only on ${recordType}. Current content changes record version history automatically.`);
+}
+function assertNotChangeManagedField(recordType, key) {
+    if (recordType !== "changes" || !CHANGE_MANAGED_FIELDS.includes(key)) {
+        return;
+    }
+    throw new Error(`fields.${key} is managed on changes. Use create_change for the baseline and append_change_event for event history or plan revisions.`);
+}
+function assertNotCommitmentManagedField(recordType, key) {
+    if (recordType !== "commitments" || !COMMITMENT_MANAGED_FIELDS.includes(key)) {
+        return;
+    }
+    throw new Error(`fields.${key} is managed on commitments. Use create_commitment instead of setting or unsetting it directly.`);
+}
+function assertNotDeferralManagedField(recordType, key) {
+    if (recordType !== "deferrals" || !DEFERRAL_MANAGED_FIELDS.includes(key)) {
+        return;
+    }
+    throw new Error(`fields.${key} is managed on deferrals. Use create_deferral for the baseline and append_deferral_event for condition history or resolution.`);
+}
+function assertNotEstimateManagedField(recordType, key) {
+    if (recordType !== "estimates" || !ESTIMATE_MANAGED_FIELDS.includes(key)) {
+        return;
+    }
+    throw new Error(`fields.${key} is managed on estimates. Use create_estimate or update_estimate instead of setting or unsetting it directly.`);
+}
+function assertNotBenefitsManagedField(recordType, key) {
+    if (recordType !== "benefits" || !BENEFITS_MANAGED_FIELDS.includes(key)) {
+        return;
+    }
+    throw new Error(`fields.${key} is managed on benefits. Use create_benefits or update_benefits instead of setting or unsetting it directly.`);
+}
+function assertNotEnvironmentManagedField(recordType, key) {
+    if (recordType !== "environments" || !ENVIRONMENT_MANAGED_FIELDS.includes(key)) {
+        return;
+    }
+    throw new Error(`fields.${key} is managed on environments. Use create_environment or update_environment instead of setting or unsetting it directly.`);
+}
+function assertNotComponentManagedField(recordType, key) {
+    if (recordType !== "components" || !COMPONENT_MANAGED_FIELDS.includes(key)) {
+        return;
+    }
+    throw new Error(`fields.${key} is managed on components. Use create_component or update_component instead of setting or unsetting it directly.`);
+}
+function assertNotDecisionLedgerManagedField(recordType, key) {
+    if (recordType !== "decisions" || !DECISION_LEDGER_MANAGED_FIELDS.includes(key)) {
+        return;
+    }
+    throw new Error(`fields.${key} is managed on decisions. Use create_decision or append_decision_entry instead of setting or unsetting it directly.`);
+}
+function assertNotTaskLedgerManagedField(recordType, key) {
+    if (recordType !== "tasks" || !TASK_LEDGER_MANAGED_FIELDS.includes(key)) {
+        return;
+    }
+    throw new Error(`fields.${key} is managed on tasks. Use create_task or append_task_entry instead of setting or unsetting it directly.`);
+}
+function assertNotDecisionInputManagedField(recordType, key) {
+    if (recordType !== "decisions" || !DECISION_INPUT_MANAGED_FIELDS.includes(key)) {
+        return;
+    }
+    throw new Error(`fields.${key} is managed on decisions. Use link_decision_input to record decision inputs.`);
+}
+function assertNotJournalEntryManagedField(recordType, key) {
+    if (recordType !== "journal_entries" || !JOURNAL_ENTRY_MANAGED_FIELDS.includes(key)) {
+        return;
+    }
+    throw new Error(`fields.${key} is managed on journal entries. Use append_journal_note or append_journal_summary instead of setting or unsetting it directly.`);
+}
+function linkMatches(link, relationship) {
+    return !relationship || link.relationship === relationship;
+}
+function recordTypeSupportsReviewNotes(recordType) {
+    return REVIEW_NOTE_RECORD_TYPES.includes(recordType);
+}
+function recordTypeSupportsVersionHistory(recordType) {
+    return VERSIONED_RECORD_TYPES.includes(recordType);
+}
+function versionedUpdateToolName(recordType) {
+    if (recordType === "environments") {
+        return "update_environment";
+    }
+    if (recordType === "components") {
+        return "update_component";
+    }
+    if (recordType === "estimates") {
+        return "update_estimate";
+    }
+    if (recordType === "benefits") {
+        return "update_benefits";
+    }
+    if (recordType === "statements") {
+        return "update_statement";
+    }
+    return recordType === "expectations" ? "update_expectation" : "update_requirement";
+}
+function isCurrentCollection(recordType) {
+    return COLLECTION_NAMES.includes(recordType);
+}
+function recordTypeRequiresWorkspace(recordType) {
+    return recordType !== "workspaces" && recordType !== DXCOMPLETE_TICKET_COLLECTION_NAME;
+}
+function readRequiredWorkspaceId(workspaceId, recordType) {
+    const trimmed = workspaceId?.trim();
+    if (!trimmed) {
+        throw new Error(`${recordType} records require workspaceId.`);
+    }
+    return trimmed;
+}
+function workspaceIdForCreate(recordType, workspaceId) {
+    if (!recordTypeRequiresWorkspace(recordType)) {
+        if (workspaceId?.trim()) {
+            throw new Error("Workspace records do not accept workspaceId.");
+        }
+        return undefined;
+    }
+    return readRequiredWorkspaceId(workspaceId, recordType);
+}
+async function allocateReadableId(db, recordType, workspaceId, actorId, now, session) {
+    const scopedWorkspaceId = readRequiredWorkspaceId(workspaceId, recordType);
+    const sequenceId = `${scopedWorkspaceId}:${recordType}`;
+    const sequence = await db.collection(READABLE_ID_SEQUENCES_COLLECTION).findOneAndUpdate({ _id: sequenceId }, {
+        $inc: { nextNumber: 1 },
+        $set: {
+            updatedAt: now,
+            updatedBy: actorId
+        },
+        $setOnInsert: {
+            _id: sequenceId,
+            workspaceId: scopedWorkspaceId,
+            recordType,
+            createdAt: now,
+            createdBy: actorId
+        }
+    }, {
+        upsert: true,
+        returnDocument: "after",
+        session
+    });
+    if (!sequence || !Number.isInteger(sequence.nextNumber) || sequence.nextNumber < 1) {
+        throw new Error(`Readable ID sequence was not allocated for ${recordType}.`);
+    }
+    return `${READABLE_ID_TYPE_CODES[recordType]}-${String(sequence.nextNumber).padStart(4, "0")}`;
+}
+function recordTypeSupportsReadableId(recordType) {
+    return Object.hasOwn(READABLE_ID_TYPE_CODES, recordType);
+}
+function normalizeReadableId(value) {
+    return value.trim().toUpperCase();
+}
+function recordIdentityFilter(recordType, id) {
+    if (!recordTypeSupportsReadableId(recordType)) {
+        return { _id: id };
+    }
+    return {
+        $or: [
+            { _id: id },
+            { readableId: normalizeReadableId(id) }
+        ]
+    };
+}
+function scopedRecordFilter(recordType, id, workspaceId) {
+    const filter = recordIdentityFilter(recordType, id);
+    if (recordTypeRequiresWorkspace(recordType)) {
+        filter.workspaceId = readRequiredWorkspaceId(workspaceId, recordType);
+    }
+    return filter;
+}
+async function assertWorkspaceExists(db, workspaceId) {
+    const workspace = await db.collection("workspaces").findOne({
+        _id: workspaceId,
+        archivedAt: { $exists: false }
+    });
+    if (!workspace) {
+        throw new Error(`Workspace not found: workspaces/${workspaceId}`);
+    }
+    return workspace;
+}
+function recordBelongsToWorkspace(record, workspaceId) {
+    return !workspaceId || record.recordType === "workspaces" || record.workspaceId === workspaceId;
+}
+function assertLinkWorkspaceBoundary(source, target) {
+    if (!source.workspaceId || !target.workspaceId) {
+        return;
+    }
+    if (source.workspaceId !== target.workspaceId) {
+        throw new Error(`Cannot link records across workspaces: ${source.recordType}/${source._id} is in ${source.workspaceId}, while ${target.recordType}/${target._id} is in ${target.workspaceId}.`);
+    }
+}
+function ticketOwnerFilter(id, actor) {
+    return {
+        _id: id,
+        "fields.ownerActorId": actor.actorId
+    };
+}
+function normalizeTicketEntries(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((entry, index) => normalizeTicketEntry(entry, index));
+}
+function normalizeTicketEntry(entry, index) {
+    if (!entry || typeof entry !== "object") {
+        return [];
+    }
+    const candidate = entry;
+    const body = typeof candidate.body === "string" ? candidate.body : "";
+    if (!body) {
+        return [];
+    }
+    const createdAt = typeof candidate.createdAt === "string" ? candidate.createdAt : new Date(0).toISOString();
+    const createdBy = typeof candidate.createdBy === "string" ? candidate.createdBy : RUNTIME_ACTOR_ID;
+    const direction = candidate.direction === "dxcomplete_reply" || candidate.direction === "submitter_entry"
+        ? candidate.direction
+        : "submitter_entry";
+    const normalized = {
+        id: typeof candidate.id === "string" && candidate.id ? candidate.id : `legacy-entry-${index + 1}`,
+        body,
+        createdAt,
+        createdBy,
+        direction
+    };
+    if (typeof candidate.addressedToActorId === "string" && candidate.addressedToActorId) {
+        normalized.addressedToActorId = candidate.addressedToActorId;
+    }
+    if (typeof candidate.readAt === "string" && candidate.readAt) {
+        normalized.readAt = candidate.readAt;
+    }
+    return [normalized];
+}