sliccy 5.73.3 → 5.74.0

package/dist/node-server/_shared/transcript-export.js

@@ -0,0 +1,804 @@
+/**
+ * Public SLICC transcript export contract.
+ *
+ * Renderer-neutral, platform-agnostic types for the v1 transcript bundle.
+ * Consumed by every task that reads, writes, or validates a SLICC transcript.
+ */
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+export const TRANSCRIPT_SCHEMA_VERSION = 1;
+export const SLICC_TRANSCRIPT_FORMAT = 'slicc-transcript';
+/** Canonical runtime list of all valid completeness reasons. */
+export const VALID_COMPLETENESS_REASONS = [
+    'canonical-agent-history-unavailable',
+    'tool-data-may-be-truncated',
+    'model-metadata-unavailable',
+    'scoop-history-unavailable',
+    'attachment-file-missing',
+    'attachment-association-unavailable',
+    'complete-snapshot-unavailable',
+];
+/** Canonical set of all valid wire error codes — use for runtime validation. */
+export const VALID_EXPORT_ERROR_CODES = new Set([
+    'permission-denied',
+    'redaction-unavailable',
+    'session-not-found',
+    'transfer-aborted',
+    'transfer-corrupt',
+    'schema-invalid',
+    'attachment-unreadable',
+]);
+// ---------------------------------------------------------------------------
+// Error class
+// ---------------------------------------------------------------------------
+export class TranscriptExportError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'TranscriptExportError';
+    }
+}
+// ---------------------------------------------------------------------------
+// Private — scalar / regex constants
+// ---------------------------------------------------------------------------
+const VALID_COMPLETENESS_REASONS_SET = new Set(VALID_COMPLETENESS_REASONS);
+const SHA256_HEX_RE = /^[0-9a-fA-F]{64}$/;
+const ISO_DATETIME_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
+// ---------------------------------------------------------------------------
+// Validator primitives — never throw for untrusted input
+// ---------------------------------------------------------------------------
+function isObj(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function isSha256Hex(v) {
+    return typeof v === 'string' && SHA256_HEX_RE.test(v);
+}
+function isIsoDateTime(v) {
+    return ISO_DATETIME_RE.test(v) && Number.isFinite(Date.parse(v));
+}
+/** Build a human-readable "must be" enum error string. */
+function enumError(label, allowed) {
+    const quoted = allowed.map((v) => `"${v}"`);
+    const last = quoted[quoted.length - 1];
+    if (quoted.length === 2)
+        return `${label} must be ${quoted[0]} or ${last}`;
+    return `${label} must be ${quoted.slice(0, -1).join(', ')}, or ${last}`;
+}
+/** Verify `value` is one of the allowed string literals. */
+function validateEnum(value, allowed, label) {
+    if (typeof value !== 'string' || !allowed.includes(value)) {
+        return { ok: false, error: enumError(label, allowed) };
+    }
+    return { ok: true };
+}
+/** Validate every item in a pre-confirmed array. */
+function validateArray(items, validator, basePath) {
+    for (let i = 0; i < items.length; i++) {
+        const result = validator(items[i], `${basePath}[${i}]`);
+        if (!result.ok)
+            return result;
+    }
+    return { ok: true };
+}
+// ---------------------------------------------------------------------------
+// Content-block validators
+// ---------------------------------------------------------------------------
+function validateContentBlockFields(block, path) {
+    const type = block['type'];
+    if (type === 'text') {
+        if (typeof block['text'] !== 'string') {
+            return { ok: false, error: `${path}.text must be a string` };
+        }
+    }
+    else if (type === 'tool-call') {
+        if (typeof block['id'] !== 'string' || block['id'] === '') {
+            return { ok: false, error: `${path}.id must be a non-empty string` };
+        }
+        if (typeof block['name'] !== 'string' || block['name'] === '') {
+            return { ok: false, error: `${path}.name must be a non-empty string` };
+        }
+        if (!('input' in block)) {
+            return { ok: false, error: `${path}.input must be present` };
+        }
+    }
+    else {
+        // attachment-ref
+        if (typeof block['attachmentId'] !== 'string' || block['attachmentId'] === '') {
+            return { ok: false, error: `${path}.attachmentId must be a non-empty string` };
+        }
+    }
+    return { ok: true };
+}
+function validateContentBlock(block, path) {
+    if (!isObj(block))
+        return { ok: false, error: `${path} must be a non-null object` };
+    const typeResult = validateEnum(block['type'], ['text', 'tool-call', 'attachment-ref'], `${path}.type`);
+    if (!typeResult.ok)
+        return typeResult;
+    return validateContentBlockFields(block, path);
+}
+// ---------------------------------------------------------------------------
+// Message validators — usage helpers, role-specific checks, structural gate
+// ---------------------------------------------------------------------------
+function validateTokenFields(usage, path) {
+    const fields = ['input', 'output', 'cacheRead', 'cacheWrite', 'totalTokens'];
+    for (const field of fields) {
+        const v = usage[field];
+        if (typeof v !== 'number') {
+            return { ok: false, error: `${path}.${field} must be a number` };
+        }
+        if (!Number.isInteger(v) || v < 0) {
+            return { ok: false, error: `${path}.${field} must be a non-negative integer` };
+        }
+    }
+    return { ok: true };
+}
+function validateCostFields(cost, path) {
+    const fields = ['input', 'output', 'cacheRead', 'cacheWrite', 'total'];
+    for (const field of fields) {
+        const v = cost[field];
+        if (typeof v !== 'number') {
+            return { ok: false, error: `${path}.${field} must be a number` };
+        }
+        if (!Number.isFinite(v) || v < 0) {
+            return { ok: false, error: `${path}.${field} must be a finite non-negative number` };
+        }
+    }
+    return { ok: true };
+}
+function validateUsage(usage, path) {
+    const tokenResult = validateTokenFields(usage, path);
+    if (!tokenResult.ok)
+        return tokenResult;
+    const cost = usage['cost'];
+    if (!isObj(cost)) {
+        return { ok: false, error: `${path}.cost must be a non-null object` };
+    }
+    return validateCostFields(cost, `${path}.cost`);
+}
+function validateMessageScalars(msg, path) {
+    if (typeof msg['id'] !== 'string')
+        return { ok: false, error: `${path}.id must be a string` };
+    if (typeof msg['sequence'] !== 'number') {
+        return { ok: false, error: `${path}.sequence must be a number` };
+    }
+    const seq = msg['sequence'];
+    if (!Number.isInteger(seq) || seq < 1) {
+        return { ok: false, error: `${path}.sequence must be a positive integer` };
+    }
+    if (typeof msg['timestamp'] !== 'string') {
+        return { ok: false, error: `${path}.timestamp must be a string` };
+    }
+    if (!isIsoDateTime(msg['timestamp'])) {
+        return { ok: false, error: `${path}.timestamp must be a valid ISO 8601 date-time string` };
+    }
+    return { ok: true };
+}
+function validateToolResultMessage(msg, path) {
+    const tcId = msg['toolCallId'];
+    if (typeof tcId !== 'string' || tcId === '') {
+        return {
+            ok: false,
+            error: `${path}.toolCallId must be a non-empty string for tool-result messages`,
+        };
+    }
+    return { ok: true };
+}
+function validateMessageOptionalUsage(msg, path) {
+    const usage = msg['usage'];
+    if (usage === undefined)
+        return { ok: true };
+    if (!isObj(usage))
+        return { ok: false, error: `${path}.usage must be a non-null object` };
+    return validateUsage(usage, `${path}.usage`);
+}
+function validateMessage(msg, path) {
+    if (!isObj(msg))
+        return { ok: false, error: `${path} must be a non-null object` };
+    const roleResult = validateEnum(msg['role'], ['user', 'assistant', 'tool-result'], `${path}.role`);
+    if (!roleResult.ok)
+        return roleResult;
+    if (msg['role'] === 'tool-result') {
+        const tcResult = validateToolResultMessage(msg, path);
+        if (!tcResult.ok)
+            return tcResult;
+    }
+    const scalarsResult = validateMessageScalars(msg, path);
+    if (!scalarsResult.ok)
+        return scalarsResult;
+    const content = msg['content'];
+    if (!Array.isArray(content))
+        return { ok: false, error: `${path}.content must be an array` };
+    const contentResult = validateArray(content, validateContentBlock, `${path}.content`);
+    if (!contentResult.ok)
+        return contentResult;
+    return validateMessageOptionalUsage(msg, path);
+}
+function validateConversation(conv, path) {
+    if (!isObj(conv))
+        return { ok: false, error: `${path} must be a non-null object` };
+    if (typeof conv['id'] !== 'string')
+        return { ok: false, error: `${path}.id must be a string` };
+    if (typeof conv['name'] !== 'string') {
+        return { ok: false, error: `${path}.name must be a string` };
+    }
+    const kindResult = validateEnum(conv['kind'], ['cone', 'scoop'], `${path}.kind`);
+    if (!kindResult.ok)
+        return kindResult;
+    const messages = conv['messages'];
+    if (!Array.isArray(messages)) {
+        return { ok: false, error: `${path}.messages must be an array` };
+    }
+    return validateArray(messages, validateMessage, `${path}.messages`);
+}
+// ---------------------------------------------------------------------------
+// Attachment validators
+// ---------------------------------------------------------------------------
+function validateAttachmentStringFields(att, path) {
+    for (const field of [
+        'id',
+        'path',
+        'originalName',
+        'mimeType',
+        'sha256',
+        'sourceConversationId',
+        'sourceMessageId',
+    ]) {
+        if (typeof att[field] !== 'string') {
+            return { ok: false, error: `${path}.${field} must be a string` };
+        }
+    }
+    return { ok: true };
+}
+function validatePresentAttachment(att, path) {
+    const attPath = att['path'];
+    const sha256 = att['sha256'];
+    const byteLength = att['byteLength'];
+    if (attPath === '')
+        return { ok: false, error: `${path}.path must be non-empty when present` };
+    if (!isSha256Hex(sha256)) {
+        return { ok: false, error: `${path}.sha256 must be a 64-char hex string when present` };
+    }
+    if (!Number.isInteger(byteLength) || byteLength < 0) {
+        return { ok: false, error: `${path}.byteLength must be a non-negative integer when present` };
+    }
+    if (att['missingReason'] !== undefined) {
+        return { ok: false, error: `${path}.missingReason must be absent when present is true` };
+    }
+    return { ok: true };
+}
+const VALID_MISSING_REASONS = [
+    'attachment-file-missing',
+    'attachment-association-unavailable',
+];
+function validateAbsentAttachment(att, path) {
+    const attPath = att['path'];
+    const sha256 = att['sha256'];
+    const byteLength = att['byteLength'];
+    if (attPath !== '')
+        return { ok: false, error: `${path}.path must be empty when not present` };
+    if (sha256 !== '')
+        return { ok: false, error: `${path}.sha256 must be empty when not present` };
+    if (byteLength !== 0) {
+        return { ok: false, error: `${path}.byteLength must be zero when not present` };
+    }
+    return validateEnum(att['missingReason'], VALID_MISSING_REASONS, `${path}.missingReason`);
+}
+function validateAttachmentStateInvariants(att, path) {
+    return att['present']
+        ? validatePresentAttachment(att, path)
+        : validateAbsentAttachment(att, path);
+}
+function validateAttachment(att, path) {
+    if (!isObj(att))
+        return { ok: false, error: `${path} must be a non-null object` };
+    const strResult = validateAttachmentStringFields(att, path);
+    if (!strResult.ok)
+        return strResult;
+    if (typeof att['byteLength'] !== 'number') {
+        return { ok: false, error: `${path}.byteLength must be a number` };
+    }
+    if (typeof att['present'] !== 'boolean') {
+        return { ok: false, error: `${path}.present must be a boolean` };
+    }
+    const handlingResult = validateEnum(att['handling'], ['text-redacted', 'binary-unchanged'], `${path}.handling`);
+    if (!handlingResult.ok)
+        return handlingResult;
+    return validateAttachmentStateInvariants(att, path);
+}
+// ---------------------------------------------------------------------------
+// Redaction validators
+// ---------------------------------------------------------------------------
+function validateRedactionTarget(target, path) {
+    const kindResult = validateEnum(target['kind'], ['json', 'attachment'], `${path}.kind`);
+    if (!kindResult.ok)
+        return kindResult;
+    if (target['kind'] === 'json') {
+        if (typeof target['pointer'] !== 'string') {
+            return { ok: false, error: `${path}.pointer must be a string` };
+        }
+        const ptr = target['pointer'];
+        if (ptr !== '' && !ptr.startsWith('/')) {
+            return { ok: false, error: `${path}.pointer must be a valid RFC 6901 JSON pointer` };
+        }
+    }
+    else {
+        // attachment kind
+        if (typeof target['attachmentId'] !== 'string' || target['attachmentId'] === '') {
+            return { ok: false, error: `${path}.attachmentId must be a non-empty string` };
+        }
+    }
+    return { ok: true };
+}
+function validateRedaction(red, path) {
+    if (!isObj(red))
+        return { ok: false, error: `${path} must be a non-null object` };
+    if (typeof red['id'] !== 'string')
+        return { ok: false, error: `${path}.id must be a string` };
+    if (typeof red['category'] !== 'string') {
+        return { ok: false, error: `${path}.category must be a string` };
+    }
+    const detectorResult = validateEnum(red['detector'], ['known-secret', 'credential-pattern', 'pre-obfuscated'], `${path}.detector`);
+    if (!detectorResult.ok)
+        return detectorResult;
+    const target = red['target'];
+    if (!isObj(target))
+        return { ok: false, error: `${path}.target must be a non-null object` };
+    return validateRedactionTarget(target, `${path}.target`);
+}
+// ---------------------------------------------------------------------------
+// Delegation validator
+// ---------------------------------------------------------------------------
+function validateDelegation(del, path) {
+    if (!isObj(del))
+        return { ok: false, error: `${path} must be a non-null object` };
+    if (typeof del['sourceConversationId'] !== 'string') {
+        return { ok: false, error: `${path}.sourceConversationId must be a string` };
+    }
+    if (typeof del['targetConversationId'] !== 'string') {
+        return { ok: false, error: `${path}.targetConversationId must be a string` };
+    }
+    return { ok: true };
+}
+// ---------------------------------------------------------------------------
+// Completeness reason validator
+// ---------------------------------------------------------------------------
+function validateCompletenessReason(item, path) {
+    if (typeof item !== 'string' || !VALID_COMPLETENESS_REASONS_SET.has(item)) {
+        return { ok: false, error: `${path} is not a valid completeness reason` };
+    }
+    return { ok: true };
+}
+// ---------------------------------------------------------------------------
+// Top-level section validators
+// ---------------------------------------------------------------------------
+function validateExport(exp) {
+    if (!isObj(exp))
+        return { ok: false, error: 'export must be a non-null object' };
+    if (typeof exp['id'] !== 'string')
+        return { ok: false, error: 'export.id must be a string' };
+    if (typeof exp['generatedAt'] !== 'string') {
+        return { ok: false, error: 'export.generatedAt must be a string' };
+    }
+    if (exp['format'] !== SLICC_TRANSCRIPT_FORMAT) {
+        return { ok: false, error: 'export.format must equal "slicc-transcript"' };
+    }
+    const producer = exp['producer'];
+    if (!isObj(producer)) {
+        return { ok: false, error: 'export.producer must be a non-null object' };
+    }
+    if (producer['application'] !== 'slicc') {
+        return { ok: false, error: 'export.producer.application must equal "slicc"' };
+    }
+    if (typeof producer['version'] !== 'string') {
+        return { ok: false, error: 'export.producer.version must be a string' };
+    }
+    return { ok: true };
+}
+function validateCompleteness(completeness) {
+    if (!isObj(completeness)) {
+        return { ok: false, error: 'session.completeness must be a non-null object' };
+    }
+    const statusResult = validateEnum(completeness['status'], ['complete', 'partial'], 'session.completeness.status');
+    if (!statusResult.ok)
+        return statusResult;
+    if (!Array.isArray(completeness['missing'])) {
+        return { ok: false, error: 'session.completeness.missing must be an array' };
+    }
+    return validateArray(completeness['missing'], validateCompletenessReason, 'session.completeness.missing');
+}
+function validateSession(session) {
+    if (!isObj(session))
+        return { ok: false, error: 'session must be a non-null object' };
+    if (typeof session['id'] !== 'string') {
+        return { ok: false, error: 'session.id must be a string' };
+    }
+    if (typeof session['title'] !== 'string') {
+        return { ok: false, error: 'session.title must be a string' };
+    }
+    const stateResult = validateEnum(session['state'], ['active', 'frozen'], 'session.state');
+    if (!stateResult.ok)
+        return stateResult;
+    return validateCompleteness(session['completeness']);
+}
+function validatePrivacy(privacy) {
+    if (!isObj(privacy))
+        return { ok: false, error: 'privacy must be a non-null object' };
+    if (privacy['reasoningExcluded'] !== true) {
+        return { ok: false, error: 'privacy.reasoningExcluded must be true' };
+    }
+    const erBlocks = privacy['excludedReasoningBlocks'];
+    if (typeof erBlocks !== 'number') {
+        return { ok: false, error: 'privacy.excludedReasoningBlocks must be a number' };
+    }
+    if (!Number.isInteger(erBlocks) || erBlocks < 0) {
+        return { ok: false, error: 'privacy.excludedReasoningBlocks must be a non-negative integer' };
+    }
+    if (privacy['binaryAttachments'] !== 'included-unchanged') {
+        return { ok: false, error: 'privacy.binaryAttachments must equal "included-unchanged"' };
+    }
+    if (!isObj(privacy['redactionCounts'])) {
+        return { ok: false, error: 'privacy.redactionCounts must be a non-null object' };
+    }
+    const redactions = privacy['redactions'];
+    if (!Array.isArray(redactions)) {
+        return { ok: false, error: 'privacy.redactions must be an array' };
+    }
+    return validateArray(redactions, validateRedaction, 'privacy.redactions');
+}
+function validateTopLevelArrays(doc) {
+    const conversations = doc['conversations'];
+    if (!Array.isArray(conversations)) {
+        return { ok: false, error: 'conversations must be an array' };
+    }
+    const convsResult = validateArray(conversations, validateConversation, 'conversations');
+    if (!convsResult.ok)
+        return convsResult;
+    const delegations = doc['delegations'];
+    if (!Array.isArray(delegations)) {
+        return { ok: false, error: 'delegations must be an array' };
+    }
+    const delsResult = validateArray(delegations, validateDelegation, 'delegations');
+    if (!delsResult.ok)
+        return delsResult;
+    const attachments = doc['attachments'];
+    if (!Array.isArray(attachments)) {
+        return { ok: false, error: 'attachments must be an array' };
+    }
+    return validateArray(attachments, validateAttachment, 'attachments');
+}
+// ---------------------------------------------------------------------------
+// Relational validation helpers — run only after structural checks pass
+// ---------------------------------------------------------------------------
+function checkUniqueConvAndMsgIds(conversations) {
+    const convIds = new Set();
+    const msgIds = new Set();
+    for (const conv of conversations) {
+        if (!isObj(conv) || typeof conv['id'] !== 'string')
+            continue;
+        if (convIds.has(conv['id'])) {
+            return { ok: false, error: `duplicate conversation id "${conv['id']}"` };
+        }
+        convIds.add(conv['id']);
+        const msgs = conv['messages'];
+        if (!Array.isArray(msgs))
+            continue;
+        for (const msg of msgs) {
+            if (!isObj(msg) || typeof msg['id'] !== 'string')
+                continue;
+            if (msgIds.has(msg['id'])) {
+                return { ok: false, error: `duplicate message id "${msg['id']}"` };
+            }
+            msgIds.add(msg['id']);
+        }
+    }
+    return { ok: true };
+}
+function checkSequences(conversations) {
+    for (const conv of conversations) {
+        if (!isObj(conv))
+            continue;
+        const msgs = conv['messages'];
+        if (!Array.isArray(msgs))
+            continue;
+        const convId = typeof conv['id'] === 'string' ? conv['id'] : '?';
+        let prev = 0;
+        for (const msg of msgs) {
+            if (!isObj(msg) || typeof msg['sequence'] !== 'number')
+                continue;
+            const seq = msg['sequence'];
+            if (seq <= prev) {
+                return {
+                    ok: false,
+                    error: `sequences in conversation "${convId}" must be strictly increasing`,
+                };
+            }
+            prev = seq;
+        }
+    }
+    return { ok: true };
+}
+/** Collect tool-call block ids from an array of raw messages. */
+function getToolCallIdsFromMessages(msgs) {
+    const ids = [];
+    for (const msg of msgs) {
+        if (!isObj(msg))
+            continue;
+        const content = msg['content'];
+        if (!Array.isArray(content))
+            continue;
+        for (const block of content) {
+            if (isObj(block) && block['type'] === 'tool-call' && typeof block['id'] === 'string') {
+                ids.push(block['id']);
+            }
+        }
+    }
+    return ids;
+}
+function collectAllToolCallIds(conversations) {
+    const ids = new Set();
+    for (const conv of conversations) {
+        if (!isObj(conv))
+            continue;
+        const msgs = conv['messages'];
+        if (!Array.isArray(msgs))
+            continue;
+        for (const id of getToolCallIdsFromMessages(msgs))
+            ids.add(id);
+    }
+    return ids;
+}
+function checkToolResultRefIds(conversations, toolCallIds) {
+    for (const conv of conversations) {
+        if (!isObj(conv))
+            continue;
+        const msgs = conv['messages'];
+        if (!Array.isArray(msgs))
+            continue;
+        for (const msg of msgs) {
+            if (!isObj(msg) || msg['role'] !== 'tool-result')
+                continue;
+            const tcId = msg['toolCallId'];
+            if (typeof tcId !== 'string' || tcId === '')
+                continue;
+            if (!toolCallIds.has(tcId)) {
+                return { ok: false, error: `tool-result message references unknown toolCallId "${tcId}"` };
+            }
+        }
+    }
+    return { ok: true };
+}
+function checkToolResultRefs(conversations) {
+    return checkToolResultRefIds(conversations, collectAllToolCallIds(conversations));
+}
+function checkAttachmentRefsInContent(content, attIds) {
+    for (const block of content) {
+        if (!isObj(block) || block['type'] !== 'attachment-ref')
+            continue;
+        const attId = block['attachmentId'];
+        if (typeof attId !== 'string' || !attIds.has(attId)) {
+            return { ok: false, error: `attachment-ref references unknown attachmentId "${attId}"` };
+        }
+    }
+    return { ok: true };
+}
+function checkAttachmentRefsInConversations(conversations, attIds) {
+    for (const conv of conversations) {
+        if (!isObj(conv))
+            continue;
+        const msgs = conv['messages'];
+        if (!Array.isArray(msgs))
+            continue;
+        for (const msg of msgs) {
+            if (!isObj(msg))
+                continue;
+            const content = msg['content'];
+            if (!Array.isArray(content))
+                continue;
+            const r = checkAttachmentRefsInContent(content, attIds);
+            if (!r.ok)
+                return r;
+        }
+    }
+    return { ok: true };
+}
+function checkAttachmentRefResolution(conversations, attachments) {
+    const attIds = new Set();
+    for (const att of attachments) {
+        if (isObj(att) && typeof att['id'] === 'string')
+            attIds.add(att['id']);
+    }
+    return checkAttachmentRefsInConversations(conversations, attIds);
+}
+/** Build a map of conversationId → Set<messageId> from the conversations array. */
+function buildConvMsgIndex(conversations) {
+    const idx = new Map();
+    for (const conv of conversations) {
+        if (!isObj(conv) || typeof conv['id'] !== 'string')
+            continue;
+        const msgIds = new Set();
+        const msgs = conv['messages'];
+        if (Array.isArray(msgs)) {
+            for (const msg of msgs) {
+                if (isObj(msg) && typeof msg['id'] === 'string')
+                    msgIds.add(msg['id']);
+            }
+        }
+        idx.set(conv['id'], msgIds);
+    }
+    return idx;
+}
+function checkAttachmentSources(attachments, conversations) {
+    const convMsgIdx = buildConvMsgIndex(conversations);
+    for (let i = 0; i < attachments.length; i++) {
+        const att = attachments[i];
+        if (!isObj(att))
+            continue;
+        const convId = att['sourceConversationId'];
+        const msgId = att['sourceMessageId'];
+        if (typeof convId !== 'string' || typeof msgId !== 'string')
+            continue;
+        const msgIds = convMsgIdx.get(convId);
+        if (!msgIds) {
+            return {
+                ok: false,
+                error: `attachments[${i}].sourceConversationId "${convId}" does not exist`,
+            };
+        }
+        if (!msgIds.has(msgId)) {
+            return {
+                ok: false,
+                error: `attachments[${i}].sourceMessageId "${msgId}" does not exist in conversation "${convId}"`,
+            };
+        }
+    }
+    return { ok: true };
+}
+/** Build a map of conversationId → Set<toolCallId> from all tool-call blocks. */
+function buildConvToolCallIndex(conversations) {
+    const idx = new Map();
+    for (const conv of conversations) {
+        if (!isObj(conv) || typeof conv['id'] !== 'string')
+            continue;
+        const msgs = Array.isArray(conv['messages']) ? conv['messages'] : [];
+        idx.set(conv['id'], new Set(getToolCallIdsFromMessages(msgs)));
+    }
+    return idx;
+}
+function checkEachDelegation(delegations, convIds, convToolCallIds) {
+    for (let i = 0; i < delegations.length; i++) {
+        const del = delegations[i];
+        if (!isObj(del))
+            continue;
+        const srcId = del['sourceConversationId'];
+        const tgtId = del['targetConversationId'];
+        if (typeof srcId !== 'string' || !convIds.has(srcId)) {
+            return {
+                ok: false,
+                error: `delegations[${i}].sourceConversationId "${srcId}" does not exist`,
+            };
+        }
+        if (typeof tgtId !== 'string' || !convIds.has(tgtId)) {
+            return {
+                ok: false,
+                error: `delegations[${i}].targetConversationId "${tgtId}" does not exist`,
+            };
+        }
+        const tcId = del['toolCallId'];
+        if (typeof tcId === 'string' && tcId !== '') {
+            const srcToolCalls = convToolCallIds.get(srcId);
+            if (!srcToolCalls?.has(tcId)) {
+                return {
+                    ok: false,
+                    error: `delegations[${i}].toolCallId "${tcId}" does not exist in source conversation "${srcId}"`,
+                };
+            }
+        }
+    }
+    return { ok: true };
+}
+function checkDelegationRefs(delegations, conversations) {
+    const convIds = new Set();
+    for (const conv of conversations) {
+        if (isObj(conv) && typeof conv['id'] === 'string')
+            convIds.add(conv['id']);
+    }
+    return checkEachDelegation(delegations, convIds, buildConvToolCallIndex(conversations));
+}
+function checkRedactionTargetRef(target, attIds, path) {
+    if (target['kind'] !== 'attachment')
+        return { ok: true };
+    const attId = target['attachmentId'];
+    if (typeof attId !== 'string' || !attIds.has(attId)) {
+        return {
+            ok: false,
+            error: `${path}.attachmentId "${attId}" does not reference a known attachment`,
+        };
+    }
+    return { ok: true };
+}
+function checkRedactionRefs(redactions, attachments) {
+    const attIds = new Set();
+    for (const att of attachments) {
+        if (isObj(att) && typeof att['id'] === 'string')
+            attIds.add(att['id']);
+    }
+    for (let i = 0; i < redactions.length; i++) {
+        const red = redactions[i];
+        if (!isObj(red))
+            continue;
+        const target = red['target'];
+        if (!isObj(target))
+            continue;
+        const r = checkRedactionTargetRef(target, attIds, `privacy.redactions[${i}].target`);
+        if (!r.ok)
+            return r;
+    }
+    return { ok: true };
+}
+function validateRelational(doc) {
+    const conversations = doc['conversations'];
+    const attachments = doc['attachments'];
+    const delegations = doc['delegations'];
+    const privacy = doc['privacy'];
+    const redactions = (Array.isArray(privacy?.['redactions']) ? privacy['redactions'] : []);
+    const r1 = checkUniqueConvAndMsgIds(conversations);
+    if (!r1.ok)
+        return r1;
+    const r2 = checkSequences(conversations);
+    if (!r2.ok)
+        return r2;
+    const r3 = checkToolResultRefs(conversations);
+    if (!r3.ok)
+        return r3;
+    const r4 = checkAttachmentRefResolution(conversations, attachments);
+    if (!r4.ok)
+        return r4;
+    const r5 = checkAttachmentSources(attachments, conversations);
+    if (!r5.ok)
+        return r5;
+    const r6 = checkDelegationRefs(delegations, conversations);
+    if (!r6.ok)
+        return r6;
+    return checkRedactionRefs(redactions, attachments);
+}
+function validateStructuredBody(doc) {
+    const r = validateTopLevelArrays(doc);
+    if (!r.ok)
+        return r;
+    return validateRelational(doc);
+}
+// ---------------------------------------------------------------------------
+// Public validator
+// ---------------------------------------------------------------------------
+/**
+ * Runtime validator for `TranscriptDocumentV1`.
+ *
+ * Validates all required discriminators, type-specific content block fields,
+ * scalar constraints (sequence ≥ 1, ISO timestamps, SHA-256 hex, attachment
+ * state invariants), and relational cross-references. Returns early with the
+ * first structural error before performing any relational checks.
+ *
+ * Never throws for untrusted input.
+ */
+export function validateTranscriptDocumentV1(value) {
+    if (!isObj(value)) {
+        return { ok: false, error: 'document must be a non-null object' };
+    }
+    if (value['schemaVersion'] !== 1) {
+        return { ok: false, error: 'schemaVersion must equal 1' };
+    }
+    const exportResult = validateExport(value['export']);
+    if (!exportResult.ok)
+        return exportResult;
+    const sessionResult = validateSession(value['session']);
+    if (!sessionResult.ok)
+        return sessionResult;
+    const privacyResult = validatePrivacy(value['privacy']);
+    if (!privacyResult.ok)
+        return privacyResult;
+    return validateStructuredBody(value);
+}
+//# sourceMappingURL=transcript-export.js.map