@ketvietlab/ketsuite 0.1.2 → 0.1.5

package/dist/modules/odoo_collaboration_import/operations.js

@@ -1,1139 +0,0 @@
-import { createHash } from 'node:crypto';
-import { eq, from, KetError } from '@ketvietlab/ketjs';
-import { inboundPlainText } from '../mail_inbound/index.js';
-const MAX_ROWS = 5_000;
-const MAX_BINDINGS = 2_000;
-const SECRET_KEY = /(secret|password|passwd|token|api.?key|authorization|private.?key)/i;
-const supportedTargets = {
-    'mail.message.subtype': 'mail.Subtype',
-    'mail.activity.type': 'activity.Type',
-    'mail.message': 'mail.Message',
-    'mail.tracking.value': 'mail.TrackingValue',
-    'mail.followers': 'mail.Follower',
-    'mail.notification': 'mail.Notification',
-    'mail.activity': 'activity.Activity',
-    'mail.activity.plan': 'activity.Plan',
-    'mail.activity.plan.template': 'activity.PlanStep',
-    'calendar.recurrence': 'calendar.Recurrence',
-    'calendar.event': 'calendar.Event',
-    'calendar.attendee': 'calendar.Attendee',
-    'calendar.alarm': 'calendar.Reminder',
-    'calendar.event.type': 'calendar.Tag',
-    'calendar.event.type.rel': 'calendar.EventTag',
-    'ir.attachment': 'storage.Attachment',
-    'mail.template': 'mail_transport.Template',
-    'mail.mail': 'mail_transport.Delivery',
-    'mail.alias.domain': 'mail_inbound.AliasDomain',
-    'mail.alias': 'mail_inbound.Alias',
-};
-const rank = {
-    'mail.message.subtype': 10,
-    'mail.activity.type': 10,
-    'mail.activity.plan': 10,
-    'mail.alias.domain': 10,
-    'calendar.recurrence': 10,
-    'calendar.event.type': 10,
-    'ir.attachment': 15,
-    'mail.template': 15,
-    'mail.alias': 15,
-    'mail.message': 20,
-    'mail.followers': 20,
-    'mail.activity': 20,
-    'calendar.event': 20,
-    'mail.notification': 30,
-    'mail.tracking.value': 30,
-    'mail.activity.plan.template': 30,
-    'mail.mail': 30,
-    'calendar.attendee': 30,
-    'calendar.alarm': 30,
-    'calendar.event.type.rel': 30,
-};
-class ImportProblem extends Error {
-    code;
-    details;
-    constructor(code, message, details) {
-        super(message);
-        this.code = code;
-        this.details = details;
-    }
-}
-const object = (value, label) => {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        throw new ImportProblem('INVALID_VALUE', `${label} must be an object`);
-    return value;
-};
-const textValue = (value, label, fallback) => {
-    const valueText = value === undefined || value === null ? (fallback ?? '') : String(value);
-    const clean = valueText.trim();
-    if (!clean)
-        throw new ImportProblem('INVALID_VALUE', `${label} cannot be empty`);
-    if (clean.length > 10_000)
-        throw new ImportProblem('INVALID_VALUE', `${label} is too long`);
-    return clean;
-};
-const optionalText = (value) => {
-    if (value === undefined || value === null || value === false)
-        return undefined;
-    const clean = String(value).trim();
-    return clean || undefined;
-};
-const booleanValue = (value, fallback) => value === undefined || value === null ? fallback : Boolean(value);
-const activityCategory = (value) => {
-    const source = optionalText(value) ?? 'default';
-    return ({
-        default: 'todo',
-        todo: 'todo',
-        phonecall: 'call',
-        call: 'call',
-        email: 'email',
-        meeting: 'meeting',
-        upload_file: 'upload',
-        upload: 'upload',
-    }[source] ?? 'todo');
-};
-const activityChaining = (value) => {
-    const source = optionalText(value) ?? 'suggest';
-    return ['none', 'suggest', 'trigger'].includes(source) ? source : 'suggest';
-};
-const messageKind = (value) => {
-    const source = optionalText(value) ?? 'comment';
-    if (['comment', 'note', 'system', 'email'].includes(source))
-        return source;
-    if (source === 'notification' || source === 'user_notification')
-        return 'system';
-    return 'comment';
-};
-const integerValue = (value, label, fallback = 0) => {
-    const result = value === undefined || value === null ? fallback : Number(value);
-    if (!Number.isSafeInteger(result))
-        throw new ImportProblem('INVALID_VALUE', `${label} must be an integer`);
-    return result;
-};
-const recordId = (value, label = 'source id') => {
-    const id = textValue(value, label);
-    if (id.length > 200 || /[\r\n]/.test(id))
-        throw new ImportProblem('INVALID_SOURCE_ID', `${label} is invalid`);
-    return id;
-};
-const stableValue = (value) => {
-    if (Array.isArray(value))
-        return value.map(stableValue);
-    if (value && typeof value === 'object')
-        return Object.fromEntries(Object.entries(value)
-            .sort(([left], [right]) => left.localeCompare(right))
-            .map(([key, item]) => [key, stableValue(item)]));
-    return value;
-};
-const stableJson = (value) => JSON.stringify(stableValue(value));
-const digest = (value) => createHash('sha256').update(stableJson(value)).digest('hex');
-const shortDigest = (value, length = 24) => digest(value).slice(0, length);
-const jsonObject = (value) => (typeof value === 'string' ? JSON.parse(value) : value);
-const stableTargetId = (databaseUuid, model, id) => `odoo:${shortDigest(databaseUuid, 12)}:${model.replace(/[^a-z0-9]+/gi, '_')}:${id}`;
-const stableMapId = (sourceId, sourceModel, sourceRecordId, targetModel) => `odoo-map:${shortDigest([sourceId, sourceModel, sourceRecordId, targetModel], 32)}`;
-const parseDate = (value, label) => {
-    const result = textValue(value, label);
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(result) || Number.isNaN(Date.parse(`${result}T00:00:00.000Z`)))
-        throw new ImportProblem('INVALID_DATE', `${label} must be YYYY-MM-DD`);
-    return result;
-};
-const parseDatetime = (value, label, conversion) => {
-    const input = textValue(value, label);
-    const normalizedInput = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(input)
-        ? `${input.replace(' ', 'T')}Z`
-        : input;
-    const parsed = new Date(normalizedInput);
-    if (Number.isNaN(parsed.valueOf()))
-        throw new ImportProblem('INVALID_DATETIME', `${label} must be an ISO or Odoo UTC datetime`);
-    const result = parsed.toISOString();
-    if (input !== result)
-        conversion.count += 1;
-    return result;
-};
-const timezone = (value) => {
-    const zone = optionalText(value) ?? 'UTC';
-    try {
-        new Intl.DateTimeFormat('en', { timeZone: zone }).format(new Date(0));
-    }
-    catch {
-        throw new ImportProblem('INVALID_TIMEZONE', `unknown IANA timezone ${zone}`);
-    }
-    return zone;
-};
-const stringArray = (value) => {
-    if (value === undefined || value === null || value === false)
-        return [];
-    if (!Array.isArray(value))
-        throw new ImportProblem('INVALID_VALUE', 'expected an array');
-    return value.map((item) => recordId(item));
-};
-const emailAddresses = (value, label) => {
-    if (!Array.isArray(value))
-        throw new ImportProblem('INVALID_EMAIL_RECIPIENT', `${label} must be an array`);
-    return value.map((item, index) => {
-        const source = typeof item === 'string' ? { address: item } : object(item, `${label}[${index}]`);
-        const address = textValue(source.address, `${label}[${index}].address`).toLowerCase();
-        if (!address.includes('@') || /[\r\n]/.test(address))
-            throw new ImportProblem('INVALID_EMAIL_RECIPIENT', `${label}[${index}] is not a safe email address`);
-        const name = optionalText(source.name);
-        return { address, ...(name ? { name } : {}) };
-    });
-};
-const secretFree = (value) => {
-    const removed = [];
-    const walk = (item, path) => {
-        if (Array.isArray(item))
-            return item.map((child, index) => walk(child, `${path}[${index}]`));
-        if (!item || typeof item !== 'object')
-            return item;
-        const output = {};
-        for (const [key, child] of Object.entries(item)) {
-            if (SECRET_KEY.test(key))
-                removed.push(path ? `${path}.${key}` : key);
-            else
-                output[key] = walk(child, path ? `${path}.${key}` : key);
-        }
-        return output;
-    };
-    return { value: walk(value, ''), removed };
-};
-const emptyCount = () => ({
-    received: 0,
-    inserted: 0,
-    updated: 0,
-    skipped: 0,
-    unresolved: 0,
-});
-const parseBatch = (input) => {
-    const raw = object(input, 'batch');
-    const mode = raw.mode === 'snapshot' || raw.mode === 'delta' ? raw.mode : null;
-    if (!mode)
-        throw new ImportProblem('INVALID_MODE', 'mode must be snapshot or delta');
-    if (!Array.isArray(raw.rows))
-        throw new ImportProblem('INVALID_ROWS', 'rows must be an array');
-    if (raw.rows.length > MAX_ROWS)
-        throw new ImportProblem('BATCH_TOO_LARGE', `at most ${MAX_ROWS} rows are allowed`);
-    const bindings = raw.bindings ?? [];
-    if (!Array.isArray(bindings))
-        throw new ImportProblem('INVALID_BINDINGS', 'bindings must be an array');
-    if (bindings.length > MAX_BINDINGS)
-        throw new ImportProblem('BATCH_TOO_LARGE', `at most ${MAX_BINDINGS} bindings are allowed`);
-    const rows = raw.rows.map((item, index) => {
-        const row = object(item, `rows[${index}]`);
-        return {
-            model: textValue(row.model, `rows[${index}].model`),
-            id: recordId(row.id, `rows[${index}].id`),
-            values: object(row.values, `rows[${index}].values`),
-        };
-    });
-    const parsedBindings = bindings.map((item, index) => {
-        const binding = object(item, `bindings[${index}]`);
-        return {
-            sourceModel: textValue(binding.sourceModel, `bindings[${index}].sourceModel`),
-            sourceId: recordId(binding.sourceId, `bindings[${index}].sourceId`),
-            targetModel: textValue(binding.targetModel, `bindings[${index}].targetModel`),
-            targetId: recordId(binding.targetId, `bindings[${index}].targetId`),
-        };
-    });
-    return {
-        runId: recordId(raw.runId, 'runId'),
-        sourceId: recordId(raw.sourceId, 'sourceId'),
-        sourceName: textValue(raw.sourceName, 'sourceName'),
-        databaseUuid: textValue(raw.databaseUuid, 'databaseUuid'),
-        odooVersion: textValue(raw.odooVersion, 'odooVersion'),
-        mode,
-        ...(optionalText(raw.previousCursor) ? { previousCursor: optionalText(raw.previousCursor) } : {}),
-        cursor: textValue(raw.cursor, 'cursor'),
-        bindings: parsedBindings,
-        rows,
-    };
-};
-const allowedBindingTarget = (target) => [
-    'mail.Thread',
-    'partner.Partner',
-    'user.User',
-    'mail.Subtype',
-    'activity.Type',
-    'storage.Attachment',
-].includes(target);
-const targetExists = async (ctx, model, id) => {
-    switch (model) {
-        case 'mail.Thread': {
-            const T = ctx.table('mail.Thread');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'partner.Partner': {
-            const T = ctx.table('partner.Partner');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'user.User': {
-            const T = ctx.table('user.User');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'mail.Subtype': {
-            const T = ctx.table('mail.Subtype');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'activity.Type': {
-            const T = ctx.table('activity.Type');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'mail.Message': {
-            const T = ctx.table('mail.Message');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'mail.TrackingValue': {
-            const T = ctx.table('mail.TrackingValue');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'mail.Follower': {
-            const T = ctx.table('mail.Follower');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'mail.Notification': {
-            const T = ctx.table('mail.Notification');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'activity.Activity': {
-            const T = ctx.table('activity.Activity');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'activity.Plan': {
-            const T = ctx.table('activity.Plan');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'activity.PlanStep': {
-            const T = ctx.table('activity.PlanStep');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'calendar.Recurrence': {
-            const T = ctx.table('calendar.Recurrence');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'calendar.Event': {
-            const T = ctx.table('calendar.Event');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'calendar.Attendee': {
-            const T = ctx.table('calendar.Attendee');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'calendar.Reminder': {
-            const T = ctx.table('calendar.Reminder');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'calendar.Tag': {
-            const T = ctx.table('calendar.Tag');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'calendar.EventTag': {
-            const T = ctx.table('calendar.EventTag');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'storage.Attachment': {
-            const T = ctx.table('storage.Attachment');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'mail_inbound.AliasDomain': {
-            const T = ctx.table('mail_inbound.AliasDomain');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'mail_inbound.Alias': {
-            const T = ctx.table('mail_inbound.Alias');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'mail_transport.Template': {
-            const T = ctx.table('mail_transport.Template');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        case 'mail_transport.Delivery': {
-            const T = ctx.table('mail_transport.Delivery');
-            return Boolean(await ctx.db.one(from(T).where(eq(T.id, id))));
-        }
-        default:
-            return false;
-    }
-};
-const mapKey = (sourceModel, sourceId, targetModel) => `${sourceModel}\u0000${sourceId}\u0000${targetModel}`;
-const addIssue = (state, severity, code, sourceModel, sourceRecordId, message, details) => {
-    state.issues.push({ severity, code, sourceModel, sourceRecordId, message, ...(details ? { details } : {}) });
-};
-const existsCached = async (state, model, id) => {
-    const key = `${model}\u0000${id}`;
-    const known = state.existence.get(key);
-    if (known !== undefined)
-        return known;
-    const exists = await targetExists(state.ctx, model, id);
-    state.existence.set(key, exists);
-    return exists;
-};
-const resolve = async (state, sourceModel, sourceRecordId, targetModel, label) => {
-    const sourceId = recordId(sourceRecordId, label);
-    const key = mapKey(sourceModel, sourceId, targetModel);
-    const available = state.available.get(key);
-    if (available)
-        return available;
-    const mapped = state.maps.get(key);
-    if (!mapped)
-        throw new ImportProblem('MISSING_MAPPING', `${label} has no ${targetModel} mapping`, {
-            sourceModel,
-            sourceId,
-            targetModel,
-        });
-    const targetId = String(mapped.targetId);
-    if (!(await existsCached(state, targetModel, targetId)))
-        throw new ImportProblem('ORPHAN_MAPPING', `${label} points to missing ${targetModel} ${targetId}`);
-    state.available.set(key, targetId);
-    return targetId;
-};
-const writeMap = async (state, sourceModel, sourceRecordId, targetModel, targetId, checksum) => {
-    const key = mapKey(sourceModel, sourceRecordId, targetModel);
-    const existing = state.maps.get(key);
-    const target = { sourceModel, sourceId: sourceRecordId, targetModel, targetId };
-    state.targets.push(target);
-    state.available.set(key, targetId);
-    state.existence.set(`${targetModel}\u0000${targetId}`, true);
-    if (!state.apply)
-        return;
-    if (existing) {
-        await state.ctx.db.update('odoo_collaboration_import.Map', { id: existing.id }, { checksum, lastRunId: state.batch.runId, importedAt: state.now });
-        Object.assign(existing, { checksum, lastRunId: state.batch.runId, importedAt: state.now });
-        return;
-    }
-    const row = {
-        id: stableMapId(state.batch.sourceId, sourceModel, sourceRecordId, targetModel),
-        sourceId: state.batch.sourceId,
-        sourceModel,
-        sourceRecordId,
-        targetModel,
-        targetId,
-        checksum,
-        firstRunId: state.batch.runId,
-        lastRunId: state.batch.runId,
-        importedAt: state.now,
-    };
-    await state.ctx.db.insert('odoo_collaboration_import.Map', row);
-    state.maps.set(key, row);
-};
-const processBindings = async (state) => {
-    const count = state.counts.$bindings ?? (state.counts.$bindings = emptyCount());
-    for (const binding of state.batch.bindings ?? []) {
-        count.received += 1;
-        const sourceModel = textValue(binding.sourceModel, 'binding source model');
-        const sourceId = recordId(binding.sourceId, 'binding source id');
-        const targetModel = textValue(binding.targetModel, 'binding target model');
-        const targetId = recordId(binding.targetId, 'binding target id');
-        if (!allowedBindingTarget(targetModel)) {
-            addIssue(state, 'error', 'UNSUPPORTED_BINDING', sourceModel, sourceId, `binding to ${targetModel} is not allowed`);
-            count.unresolved += 1;
-            continue;
-        }
-        if (!(await existsCached(state, targetModel, targetId))) {
-            addIssue(state, 'error', 'MISSING_TARGET', sourceModel, sourceId, `${targetModel} ${targetId} does not exist`);
-            count.unresolved += 1;
-            continue;
-        }
-        const key = mapKey(sourceModel, sourceId, targetModel);
-        const checksum = digest(binding);
-        const existing = state.maps.get(key);
-        if (existing && String(existing.targetId) !== targetId) {
-            addIssue(state, 'error', 'BINDING_CONFLICT', sourceModel, sourceId, `stable mapping already points to ${existing.targetModel} ${existing.targetId}`);
-            count.unresolved += 1;
-            continue;
-        }
-        if (existing && existing.checksum === checksum) {
-            state.available.set(key, targetId);
-            count.skipped += 1;
-            continue;
-        }
-        await writeMap(state, sourceModel, sourceId, targetModel, targetId, checksum);
-        if (existing)
-            count.updated += 1;
-        else
-            count.inserted += 1;
-    }
-};
-const targetRow = async (state, sourceModel, sourceId, values) => {
-    const targetId = stableTargetId(state.batch.databaseUuid, sourceModel, sourceId);
-    switch (sourceModel) {
-        case 'mail.message.subtype':
-            return {
-                id: targetId,
-                code: optionalText(values.code) ?? `odoo.${sourceId}`,
-                name: textValue(values.name, 'subtype name'),
-                defaultFollower: booleanValue(values.defaultFollower, Boolean(values.default)),
-                internalOnly: booleanValue(values.internalOnly, Boolean(values.internal)),
-                active: booleanValue(values.active, true),
-            };
-        case 'mail.activity.type':
-            return {
-                id: targetId,
-                name: textValue(values.name, 'activity type name'),
-                category: activityCategory(values.category),
-                ...(optionalText(values.icon) ? { icon: optionalText(values.icon) } : {}),
-                defaultDelayDays: integerValue(values.defaultDelayDays ?? values.delayCount, 'default delay', 0),
-                chainingPolicy: activityChaining(values.chainingPolicy ?? values.chainingType),
-                sequence: integerValue(values.sequence, 'sequence', 10),
-                active: booleanValue(values.active, true),
-            };
-        case 'mail.message': {
-            const threadId = await resolve(state, textValue(values.resModel, 'message resModel'), values.resId, 'mail.Thread', 'message target');
-            const subtypeId = values.subtypeId
-                ? await resolve(state, 'mail.message.subtype', values.subtypeId, 'mail.Subtype', 'message subtype')
-                : undefined;
-            const authorPartnerId = values.authorPartnerId
-                ? await resolve(state, 'res.partner', values.authorPartnerId, 'partner.Partner', 'message author partner')
-                : undefined;
-            const authorUserId = values.authorUserId
-                ? await resolve(state, 'res.users', values.authorUserId, 'user.User', 'message author user')
-                : undefined;
-            return {
-                id: targetId,
-                threadId,
-                ...(subtypeId ? { subtypeId } : {}),
-                ...(authorPartnerId ? { authorPartnerId } : {}),
-                ...(authorUserId ? { authorUserId } : {}),
-                ...(optionalText(values.emailFrom) ? { emailFrom: optionalText(values.emailFrom) } : {}),
-                kind: messageKind(values.kind ?? values.messageType),
-                direction: optionalText(values.direction) ?? 'internal',
-                ...(optionalText(values.subject) ? { subject: optionalText(values.subject) } : {}),
-                body: inboundPlainText(optionalText(values.bodyText) ?? '', optionalText(values.bodyHtml ?? values.body)),
-                externalVisible: booleanValue(values.externalVisible, !values.internal),
-                createdAt: parseDatetime(values.createdAt ?? values.date, 'message createdAt', state.conversion),
-                ...(values.editedAt
-                    ? { editedAt: parseDatetime(values.editedAt, 'message editedAt', state.conversion) }
-                    : {}),
-            };
-        }
-        case 'mail.tracking.value':
-            return {
-                id: targetId,
-                messageId: await resolve(state, 'mail.message', values.messageId, 'mail.Message', 'tracking message'),
-                field: textValue(values.field ?? values.fieldName, 'tracked field'),
-                ...(values.oldValue !== undefined ? { oldValue: values.oldValue } : {}),
-                ...(values.newValue !== undefined ? { newValue: values.newValue } : {}),
-            };
-        case 'mail.followers':
-            return {
-                id: targetId,
-                threadId: await resolve(state, textValue(values.resModel, 'follower resModel'), values.resId, 'mail.Thread', 'follower target'),
-                partnerId: await resolve(state, 'res.partner', values.partnerId, 'partner.Partner', 'follower partner'),
-                createdAt: parseDatetime(values.createdAt ?? '1970-01-01T00:00:00.000Z', 'follower createdAt', state.conversion),
-            };
-        case 'mail.notification': {
-            const rawState = optionalText(values.state ?? values.notificationStatus) ?? 'queued';
-            const notificationState = ['sent', 'ready'].includes(rawState)
-                ? rawState === 'ready'
-                    ? 'ready'
-                    : 'sent'
-                : ['bounce', 'exception', 'failed', 'canceled'].includes(rawState)
-                    ? 'failed'
-                    : 'ready';
-            return {
-                id: targetId,
-                messageId: await resolve(state, 'mail.message', values.messageId, 'mail.Message', 'notification message'),
-                recipientPartnerId: await resolve(state, 'res.partner', values.partnerId, 'partner.Partner', 'notification partner'),
-                ...(values.userId
-                    ? {
-                        recipientUserId: await resolve(state, 'res.users', values.userId, 'user.User', 'notification user'),
-                    }
-                    : {}),
-                channel: optionalText(values.channel ?? values.notificationType) ?? 'inbox',
-                state: notificationState,
-                ...(values.readAt
-                    ? { readAt: parseDatetime(values.readAt, 'notification readAt', state.conversion) }
-                    : {}),
-                ...(optionalText(values.failureReason ?? values.failureType)
-                    ? { failureReason: optionalText(values.failureReason ?? values.failureType) }
-                    : {}),
-                createdAt: parseDatetime(values.createdAt ?? '1970-01-01T00:00:00.000Z', 'notification createdAt', state.conversion),
-            };
-        }
-        case 'mail.activity': {
-            const active = booleanValue(values.active, !(values.doneAt ?? values.canceledAt));
-            return {
-                id: targetId,
-                threadId: await resolve(state, textValue(values.resModel, 'activity resModel'), values.resId, 'mail.Thread', 'activity target'),
-                typeId: await resolve(state, 'mail.activity.type', values.activityTypeId, 'activity.Type', 'activity type'),
-                assigneeUserId: await resolve(state, 'res.users', values.userId, 'user.User', 'activity assignee'),
-                ...(values.createUid
-                    ? {
-                        createdByUserId: await resolve(state, 'res.users', values.createUid, 'user.User', 'activity creator'),
-                    }
-                    : {}),
-                summary: optionalText(values.summary) ?? 'Odoo activity',
-                ...(optionalText(values.noteText ?? values.note)
-                    ? { note: inboundPlainText(optionalText(values.noteText) ?? '', optionalText(values.note)) }
-                    : {}),
-                dueDate: parseDate(values.dueDate ?? values.dateDeadline, 'activity due date'),
-                active,
-                ...(values.doneAt
-                    ? { doneAt: parseDatetime(values.doneAt, 'activity doneAt', state.conversion) }
-                    : {}),
-                ...(values.canceledAt
-                    ? { canceledAt: parseDatetime(values.canceledAt, 'activity canceledAt', state.conversion) }
-                    : {}),
-                ...(optionalText(values.feedback) ? { feedback: optionalText(values.feedback) } : {}),
-                createdAt: parseDatetime(values.createdAt ?? '1970-01-01T00:00:00.000Z', 'activity createdAt', state.conversion),
-                updatedAt: parseDatetime(values.updatedAt ?? values.createdAt ?? '1970-01-01T00:00:00.000Z', 'activity updatedAt', state.conversion),
-            };
-        }
-        case 'mail.activity.plan':
-            return {
-                id: targetId,
-                name: textValue(values.name, 'activity plan name'),
-                ...(optionalText(values.description) ? { description: optionalText(values.description) } : {}),
-                active: booleanValue(values.active, true),
-            };
-        case 'mail.activity.plan.template': {
-            const strategy = optionalText(values.assigneeStrategy ?? values.responsibleType) === 'specific' ? 'specific' : 'actor';
-            const assigneeUserId = values.userId
-                ? await resolve(state, 'res.users', values.userId, 'user.User', 'plan step assignee')
-                : undefined;
-            if (strategy === 'specific' && !assigneeUserId)
-                throw new ImportProblem('MISSING_MAPPING', 'specific plan step requires a mapped user');
-            return {
-                id: targetId,
-                planId: await resolve(state, 'mail.activity.plan', values.planId, 'activity.Plan', 'activity plan'),
-                typeId: await resolve(state, 'mail.activity.type', values.activityTypeId, 'activity.Type', 'plan step activity type'),
-                offsetDays: integerValue(values.offsetDays ?? values.interval, 'plan step offset', 0),
-                assigneeStrategy: strategy,
-                ...(assigneeUserId ? { assigneeUserId } : {}),
-                ...(optionalText(values.summary) ? { summary: optionalText(values.summary) } : {}),
-                ...(optionalText(values.noteText ?? values.note)
-                    ? { note: inboundPlainText(optionalText(values.noteText) ?? '', optionalText(values.note)) }
-                    : {}),
-                sequence: integerValue(values.sequence, 'plan step sequence', 10),
-            };
-        }
-        case 'calendar.recurrence': {
-            const frequency = optionalText(values.frequency ?? values.rruleType) ?? 'weekly';
-            if (!['daily', 'weekly', 'monthly', 'yearly'].includes(frequency))
-                throw new ImportProblem('UNSUPPORTED_RECURRENCE', `recurrence frequency ${frequency} cannot be represented exactly`);
-            const weekdays = Array.isArray(values.weekdays) ? stringArray(values.weekdays) : [];
-            if (weekdays.some((day) => !['MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU'].includes(day)))
-                throw new ImportProblem('UNSUPPORTED_RECURRENCE', 'recurrence contains an unknown weekday');
-            return {
-                id: targetId,
-                frequency,
-                interval: integerValue(values.interval, 'recurrence interval', 1),
-                ...(weekdays.length ? { weekdays } : {}),
-                ...(values.count ? { count: integerValue(values.count, 'recurrence count') } : {}),
-                ...(values.until ? { until: parseDate(values.until, 'recurrence until') } : {}),
-                timezone: timezone(values.timezone ?? values.tz),
-                active: booleanValue(values.active, true),
-            };
-        }
-        case 'calendar.event': {
-            const allDay = booleanValue(values.allDay, Boolean(values.allday));
-            const recurrenceId = values.recurrenceId
-                ? await resolve(state, 'calendar.recurrence', values.recurrenceId, 'calendar.Recurrence', 'event recurrence')
-                : undefined;
-            return {
-                id: targetId,
-                threadId: await resolve(state, 'calendar.event', sourceId, 'mail.Thread', 'calendar event thread'),
-                organizerUserId: await resolve(state, 'res.users', values.organizerUserId ?? values.userId, 'user.User', 'event organizer'),
-                name: textValue(values.name, 'event name'),
-                ...(optionalText(values.descriptionText ?? values.description)
-                    ? {
-                        description: inboundPlainText(optionalText(values.descriptionText) ?? '', optionalText(values.description)),
-                    }
-                    : {}),
-                ...(optionalText(values.location) ? { location: optionalText(values.location) } : {}),
-                allDay,
-                ...(allDay
-                    ? {
-                        startDate: parseDate(values.startDate, 'event startDate'),
-                        stopDate: parseDate(values.stopDate, 'event stopDate'),
-                    }
-                    : {
-                        startAt: parseDatetime(values.startAt ?? values.start, 'event startAt', state.conversion),
-                        stopAt: parseDatetime(values.stopAt ?? values.stop, 'event stopAt', state.conversion),
-                    }),
-                timezone: timezone(values.timezone ?? values.tz),
-                privacy: optionalText(values.privacy) ?? 'public',
-                showAs: optionalText(values.showAs ?? values.showAsStatus) ?? 'busy',
-                ...(recurrenceId ? { recurrenceId } : {}),
-                ...(values.recurrenceDate
-                    ? { recurrenceDate: parseDate(values.recurrenceDate, 'recurrence date') }
-                    : {}),
-                active: booleanValue(values.active, true),
-                version: integerValue(values.version, 'event version', 1),
-                createdAt: parseDatetime(values.createdAt ?? '1970-01-01T00:00:00.000Z', 'event createdAt', state.conversion),
-                updatedAt: parseDatetime(values.updatedAt ?? values.createdAt ?? '1970-01-01T00:00:00.000Z', 'event updatedAt', state.conversion),
-            };
-        }
-        case 'calendar.attendee':
-            return {
-                id: targetId,
-                eventId: await resolve(state, 'calendar.event', values.eventId, 'calendar.Event', 'attendee event'),
-                ...(values.partnerId
-                    ? {
-                        partnerId: await resolve(state, 'res.partner', values.partnerId, 'partner.Partner', 'attendee partner'),
-                    }
-                    : {}),
-                ...(optionalText(values.email) ? { email: optionalText(values.email) } : {}),
-                ...(optionalText(values.name ?? values.commonName)
-                    ? { name: optionalText(values.name ?? values.commonName) }
-                    : {}),
-                state: optionalText(values.state) ?? 'needsAction',
-                token: `odoo-rsvp-${shortDigest([state.batch.databaseUuid, sourceId], 32)}`,
-                ...(values.respondedAt
-                    ? { respondedAt: parseDatetime(values.respondedAt, 'attendee respondedAt', state.conversion) }
-                    : {}),
-            };
-        case 'calendar.alarm':
-            return {
-                id: targetId,
-                eventId: await resolve(state, 'calendar.event', values.eventId, 'calendar.Event', 'reminder event'),
-                channel: optionalText(values.channel ?? values.alarmType) === 'email' ? 'email' : 'inbox',
-                offsetMinutes: integerValue(values.offsetMinutes ?? values.duration, 'reminder offset', 0),
-                version: integerValue(values.version, 'reminder version', 1),
-                active: booleanValue(values.active, true),
-                ...(values.sentAt
-                    ? { sentAt: parseDatetime(values.sentAt, 'reminder sentAt', state.conversion) }
-                    : {}),
-            };
-        case 'calendar.event.type':
-            return {
-                id: targetId,
-                name: textValue(values.name, 'calendar tag name'),
-                ...(optionalText(values.color) ? { color: optionalText(values.color) } : {}),
-                active: booleanValue(values.active, true),
-            };
-        case 'calendar.event.type.rel':
-            return {
-                id: targetId,
-                eventId: await resolve(state, 'calendar.event', values.eventId, 'calendar.Event', 'event tag event'),
-                tagId: await resolve(state, 'calendar.event.type', values.tagId, 'calendar.Tag', 'event tag'),
-            };
-        case 'ir.attachment': {
-            const rawKind = optionalText(values.kind) ?? (values.url ? 'url' : 'stored');
-            const kind = rawKind === 'upload' ? 'stored' : rawKind;
-            if (!['url', 'stored'].includes(kind))
-                throw new ImportProblem('INVALID_ATTACHMENT', 'attachment kind must be stored or url');
-            const url = optionalText(values.url);
-            const storeKey = optionalText(values.storeKey);
-            const checksum = optionalText(values.checksum);
-            if ((kind === 'url' && !url) || (kind === 'stored' && (!storeKey || !checksum)))
-                throw new ImportProblem('ATTACHMENT_BYTES_MISSING', kind === 'url'
-                    ? 'URL attachment is missing url'
-                    : 'uploaded bytes must be staged and provide storeKey');
-            if (kind === 'stored') {
-                if (!checksum || !/^[a-f0-9]{64}$/.test(checksum))
-                    throw new ImportProblem('INVALID_ATTACHMENT', 'stored attachment checksum must be SHA-256');
-                const company = state.ctx.scope.company;
-                const expected = `blobs/${company}/${checksum.slice(0, 2)}/${checksum}`;
-                if (storeKey !== expected)
-                    throw new ImportProblem('INVALID_ATTACHMENT', 'stored attachment key does not match the active company and checksum');
-            }
-            if (kind === 'url' && (storeKey || checksum))
-                throw new ImportProblem('INVALID_ATTACHMENT', 'URL attachment cannot also reference stored bytes');
-            return {
-                id: targetId,
-                name: textValue(values.name, 'attachment name'),
-                ...(optionalText(values.resModel) ? { resModel: optionalText(values.resModel) } : {}),
-                ...(values.resId ? { resId: recordId(values.resId, 'attachment resId') } : {}),
-                ...(optionalText(values.resField) ? { resField: optionalText(values.resField) } : {}),
-                kind,
-                ...(url ? { url } : {}),
-                ...(storeKey ? { storeKey } : {}),
-                mimetype: optionalText(values.mimetype) ?? 'application/octet-stream',
-                size: integerValue(values.size, 'attachment size', 0),
-                ...(checksum ? { checksum } : {}),
-                public: booleanValue(values.public, false),
-                createdAt: parseDatetime(values.createdAt ?? '1970-01-01T00:00:00.000Z', 'attachment createdAt', state.conversion),
-            };
-        }
-        case 'mail.template': {
-            const subject = textValue(values.subjectTemplate ?? values.subject, 'template subject');
-            const html = optionalText(values.htmlTemplate ?? values.bodyHtml);
-            const text = optionalText(values.textTemplate ?? values.bodyText) ?? inboundPlainText('', html);
-            const qweb = /<t\b|\$\{|\{\{|\bt-(?:esc|out|foreach|if)=/i.test(`${subject}\n${text}\n${html ?? ''}`);
-            if (qweb)
-                addIssue(state, 'warning', 'UNSUPPORTED_TEMPLATE_SYNTAX', sourceModel, sourceId, 'Odoo QWeb/Jinja syntax was retained only for review; template was disabled');
-            const allowedKeys = Array.isArray(values.allowedKeys)
-                ? values.allowedKeys.map((item) => textValue(item, 'allowed template key'))
-                : [];
-            return {
-                id: targetId,
-                name: textValue(values.name, 'template name'),
-                fromAddress: textValue(values.fromAddress ?? values.emailFrom, 'template from address'),
-                ...(optionalText(values.fromName) ? { fromName: optionalText(values.fromName) } : {}),
-                ...(optionalText(values.replyTo) ? { replyTo: optionalText(values.replyTo) } : {}),
-                subjectTemplate: subject,
-                textTemplate: text,
-                ...(html ? { htmlTemplate: html } : {}),
-                allowedKeys,
-                active: qweb ? false : booleanValue(values.active, true),
-                version: integerValue(values.version, 'template version', 1),
-                createdAt: parseDatetime(values.createdAt ?? '1970-01-01T00:00:00.000Z', 'template createdAt', state.conversion),
-                updatedAt: parseDatetime(values.updatedAt ?? values.createdAt ?? '1970-01-01T00:00:00.000Z', 'template updatedAt', state.conversion),
-            };
-        }
-        case 'mail.mail': {
-            const rawState = optionalText(values.state) ?? 'outgoing';
-            const deliveryState = ['exception', 'failed'].includes(rawState) ? 'failed' : 'queued';
-            const to = emailAddresses(values.to ?? values.recipientEmails ?? [], 'delivery to');
-            if (!to.length)
-                throw new ImportProblem('INVALID_EMAIL_RECIPIENT', 'delivery requires at least one recipient');
-            const queuedAt = parseDatetime(values.queuedAt ?? values.createdAt ?? '1970-01-01T00:00:00.000Z', 'delivery queuedAt', state.conversion);
-            return {
-                id: targetId,
-                ...(values.messageId
-                    ? {
-                        messageId: await resolve(state, 'mail.message', values.messageId, 'mail.Message', 'delivery message'),
-                    }
-                    : {}),
-                fromAddress: textValue(values.fromAddress ?? values.emailFrom, 'delivery from address'),
-                ...(optionalText(values.fromName) ? { fromName: optionalText(values.fromName) } : {}),
-                to,
-                ...(Array.isArray(values.cc) && values.cc.length
-                    ? { cc: emailAddresses(values.cc, 'delivery cc') }
-                    : {}),
-                ...(Array.isArray(values.bcc) && values.bcc.length
-                    ? { bcc: emailAddresses(values.bcc, 'delivery bcc') }
-                    : {}),
-                ...(optionalText(values.replyTo) ? { replyTo: optionalText(values.replyTo) } : {}),
-                subject: optionalText(values.subject) ?? '(no subject)',
-                text: optionalText(values.text) ?? inboundPlainText('', optionalText(values.html ?? values.bodyHtml)),
-                ...(optionalText(values.html ?? values.bodyHtml)
-                    ? { html: optionalText(values.html ?? values.bodyHtml) }
-                    : {}),
-                headers: {},
-                state: deliveryState,
-                version: 1,
-                idempotencyKey: `odoo-mail:${shortDigest([state.batch.databaseUuid, sourceId], 40)}`,
-                attempts: integerValue(values.attempts, 'delivery attempts', deliveryState === 'failed' ? 1 : 0),
-                ...(deliveryState === 'failed'
-                    ? { lastError: optionalText(values.failureReason) ?? 'Imported Odoo delivery failure' }
-                    : {}),
-                queuedAt,
-                updatedAt: parseDatetime(values.updatedAt ?? queuedAt, 'delivery updatedAt', state.conversion),
-            };
-        }
-        case 'mail.alias.domain':
-            return {
-                id: targetId,
-                name: textValue(values.name, 'alias domain').toLowerCase(),
-                active: booleanValue(values.active, true),
-                createdAt: parseDatetime(values.createdAt ?? '1970-01-01T00:00:00.000Z', 'alias domain createdAt', state.conversion),
-                updatedAt: parseDatetime(values.updatedAt ?? values.createdAt ?? '1970-01-01T00:00:00.000Z', 'alias domain updatedAt', state.conversion),
-            };
-        case 'mail.alias': {
-            const defaults = secretFree(values.defaults ?? {});
-            if (defaults.removed.length)
-                addIssue(state, 'warning', 'SECRET_CONFIG_REMOVED', sourceModel, sourceId, 'secret-like alias defaults were not imported', { removed: defaults.removed });
-            const bridge = textValue(values.bridge, 'alias bridge');
-            const supportedBridge = ['stock.receipt'].includes(bridge);
-            if (!supportedBridge)
-                addIssue(state, 'warning', 'UNSUPPORTED_ALIAS_BRIDGE', sourceModel, sourceId, `alias bridge ${bridge} was imported disabled`);
-            const localPart = textValue(values.localPart ?? values.aliasName, 'alias local part').toLowerCase();
-            if (!/^[a-z0-9][a-z0-9._+-]{0,63}$/.test(localPart))
-                throw new ImportProblem('INVALID_ALIAS', 'alias local part is invalid');
-            return {
-                id: targetId,
-                ...(values.domainId
-                    ? {
-                        domainId: await resolve(state, 'mail.alias.domain', values.domainId, 'mail_inbound.AliasDomain', 'alias domain'),
-                    }
-                    : {}),
-                localPart,
-                name: textValue(values.name, 'alias name'),
-                bridge,
-                defaults: defaults.value,
-                active: supportedBridge && booleanValue(values.active, true),
-                createdAt: parseDatetime(values.createdAt ?? '1970-01-01T00:00:00.000Z', 'alias createdAt', state.conversion),
-                updatedAt: parseDatetime(values.updatedAt ?? values.createdAt ?? '1970-01-01T00:00:00.000Z', 'alias updatedAt', state.conversion),
-            };
-        }
-        default:
-            throw new ImportProblem('UNSUPPORTED_MODEL', `Odoo model ${sourceModel} is not supported`);
-    }
-};
-const writeTarget = async (state, targetModel, targetId, values, existing) => {
-    if (!state.apply)
-        return;
-    if (existing)
-        await state.ctx.db.update(targetModel, { id: targetId }, values);
-    else
-        await state.ctx.db.insert(targetModel, values);
-};
-const processRows = async (state) => {
-    const seen = new Set();
-    const rows = [...state.batch.rows].sort((left, right) => (rank[left.model] ?? 1_000) - (rank[right.model] ?? 1_000) ||
-        left.model.localeCompare(right.model) ||
-        String(left.id).localeCompare(String(right.id), 'en', { numeric: true }));
-    const deferred = [];
-    for (const source of rows) {
-        const sourceModel = textValue(source.model, 'source model');
-        const sourceId = recordId(source.id);
-        const count = state.counts[sourceModel] ?? (state.counts[sourceModel] = emptyCount());
-        count.received += 1;
-        const targetModel = supportedTargets[sourceModel];
-        const duplicateKey = targetModel
-            ? mapKey(sourceModel, sourceId, targetModel)
-            : `${sourceModel}\u0000${sourceId}`;
-        if (seen.has(duplicateKey)) {
-            addIssue(state, 'error', 'DUPLICATE_SOURCE_ROW', sourceModel, sourceId, 'source row occurs twice in one batch');
-            count.unresolved += 1;
-            continue;
-        }
-        seen.add(duplicateKey);
-        if (!targetModel) {
-            addIssue(state, 'error', 'UNSUPPORTED_MODEL', sourceModel, sourceId, `Odoo model ${sourceModel} is not supported`);
-            count.unresolved += 1;
-            continue;
-        }
-        if (sourceModel === 'mail.mail' && String(source.values.state ?? '') === 'sent') {
-            addIssue(state, 'warning', 'SENT_DELIVERY_OMITTED', sourceModel, sourceId, 'sent Odoo delivery was omitted because its immutable history is the linked message');
-            count.skipped += 1;
-            continue;
-        }
-        const checksum = digest({ model: sourceModel, id: sourceId, values: source.values });
-        const key = mapKey(sourceModel, sourceId, targetModel);
-        const mapped = state.maps.get(key);
-        const targetId = mapped
-            ? String(mapped.targetId)
-            : stableTargetId(state.batch.databaseUuid, sourceModel, sourceId);
-        if (mapped && mapped.checksum === checksum && (await existsCached(state, targetModel, targetId))) {
-            state.available.set(key, targetId);
-            state.targets.push({ sourceModel, sourceId, targetModel, targetId });
-            count.skipped += 1;
-            deferred.push(source);
-            continue;
-        }
-        try {
-            const values = await targetRow(state, sourceModel, sourceId, source.values);
-            const targetPresent = mapped ? await existsCached(state, targetModel, targetId) : false;
-            if (mapped && !targetPresent)
-                throw new ImportProblem('ORPHAN_MAPPING', `mapped target ${targetModel} ${targetId} is missing`);
-            await writeTarget(state, targetModel, targetId, values, targetPresent ? mapped : undefined);
-            await writeMap(state, sourceModel, sourceId, targetModel, targetId, checksum);
-            if (mapped)
-                count.updated += 1;
-            else
-                count.inserted += 1;
-            deferred.push(source);
-        }
-        catch (error) {
-            const problem = error instanceof ImportProblem
-                ? error
-                : new ImportProblem('IMPORT_ROW_FAILED', error instanceof Error ? error.message : String(error));
-            addIssue(state, 'error', problem.code, sourceModel, sourceId, problem.message, problem.details);
-            count.unresolved += 1;
-        }
-    }
-    await processDeferred(state, deferred);
-};
-const processDeferred = async (state, rows) => {
-    for (const source of rows) {
-        const sourceId = String(source.id);
-        const values = source.values;
-        try {
-            if (source.model === 'mail.message' && values.parentId) {
-                const id = await resolve(state, 'mail.message', sourceId, 'mail.Message', 'message');
-                const parentId = await resolve(state, 'mail.message', values.parentId, 'mail.Message', 'message parent');
-                if (state.apply)
-                    await state.ctx.db.update('mail.Message', { id }, { parentId });
-            }
-            if (source.model === 'mail.followers') {
-                const followerId = await resolve(state, 'mail.followers', sourceId, 'mail.Follower', 'follower');
-                for (const subtypeSourceId of stringArray(values.subtypeIds)) {
-                    const subtypeId = await resolve(state, 'mail.message.subtype', subtypeSourceId, 'mail.Subtype', 'follower subtype');
-                    if (state.apply)
-                        await state.ctx.db.insertIfAbsent('mail.FollowerSubtype', {
-                            id: `odoo-follower-subtype:${shortDigest([followerId, subtypeId], 32)}`,
-                            followerId,
-                            subtypeId,
-                        });
-                }
-            }
-            if (source.model === 'mail.activity.type' && values.nextTypeId) {
-                const id = await resolve(state, 'mail.activity.type', sourceId, 'activity.Type', 'activity type');
-                const nextTypeId = await resolve(state, 'mail.activity.type', values.nextTypeId, 'activity.Type', 'next activity type');
-                if (state.apply)
-                    await state.ctx.db.update('activity.Type', { id }, { nextTypeId });
-            }
-            if (source.model === 'calendar.event' && values.exceptionOfEventId) {
-                const id = await resolve(state, 'calendar.event', sourceId, 'calendar.Event', 'calendar event');
-                const exceptionOfEventId = await resolve(state, 'calendar.event', values.exceptionOfEventId, 'calendar.Event', 'event exception parent');
-                if (state.apply)
-                    await state.ctx.db.update('calendar.Event', { id }, { exceptionOfEventId });
-            }
-            if (source.model === 'ir.attachment' && values.resModel && values.resId) {
-                const attachmentId = await resolve(state, 'ir.attachment', sourceId, 'storage.Attachment', 'attachment');
-                const resModel = String(values.resModel);
-                if (resModel === 'mail.message') {
-                    const messageId = await resolve(state, 'mail.message', values.resId, 'mail.Message', 'attachment message');
-                    if (state.apply)
-                        await state.ctx.db.insertIfAbsent('mail.MessageAttachment', {
-                            id: `odoo-message-attachment:${shortDigest([messageId, attachmentId], 32)}`,
-                            messageId,
-                            attachmentId,
-                        });
-                }
-                else if (resModel === 'mail.activity') {
-                    const activityId = await resolve(state, 'mail.activity', values.resId, 'activity.Activity', 'attachment activity');
-                    if (state.apply)
-                        await state.ctx.db.insertIfAbsent('activity.Attachment', {
-                            id: `odoo-activity-attachment:${shortDigest([activityId, attachmentId], 32)}`,
-                            activityId,
-                            attachmentId,
-                        });
-                }
-                else {
-                    addIssue(state, 'warning', 'UNRESOLVED_ATTACHMENT_TARGET', source.model, sourceId, `attachment target model ${resModel} is not linked by this importer`);
-                }
-            }
-            if (source.model === 'mail.mail' && !['exception', 'failed'].includes(String(values.state ?? ''))) {
-                const deliveryId = await resolve(state, 'mail.mail', sourceId, 'mail_transport.Delivery', 'delivery');
-                if (state.apply)
-                    await state.ctx.jobs.enqueue('mail_transport.deliver', { deliveryId, version: 1 }, { uniqueKey: `delivery:${deliveryId}:v1` });
-            }
-        }
-        catch (error) {
-            const problem = error instanceof ImportProblem
-                ? error
-                : new ImportProblem('DEFERRED_LINK_FAILED', error instanceof Error ? error.message : String(error));
-            addIssue(state, 'error', problem.code, source.model, sourceId, problem.message, problem.details);
-        }
-    }
-};
-const totals = (counts) => Object.values(counts).reduce((total, count) => ({
-    received: total.received + count.received,
-    inserted: total.inserted + count.inserted,
-    updated: total.updated + count.updated,
-    skipped: total.skipped + count.skipped,
-    unresolved: total.unresolved + count.unresolved,
-}), emptyCount());
-const processBatch = async (ctx, batch, apply) => {
-    const checksum = digest({
-        sourceId: batch.sourceId,
-        databaseUuid: batch.databaseUuid,
-        odooVersion: batch.odooVersion,
-        mode: batch.mode,
-        previousCursor: batch.previousCursor ?? null,
-        cursor: batch.cursor,
-        bindings: batch.bindings ?? [],
-        rows: batch.rows,
-    });
-    const R = ctx.table('odoo_collaboration_import.Run');
-    const existingRun = await ctx.db.one(from(R).where(eq(R.id, batch.runId)));
-    if (existingRun) {
-        if (existingRun.batchChecksum !== checksum)
-            throw new KetError({
-                code: 'E_ODOO_IMPORT_RUN_CONFLICT',
-                module: 'odoo_collaboration_import',
-                message: `run ${batch.runId} already exists with another payload`,
-            });
-        return jsonObject(existingRun.report);
-    }
-    const S = ctx.table('odoo_collaboration_import.Source');
-    const source = await ctx.db.one(from(S).where(eq(S.id, batch.sourceId)));
-    const databaseOwner = await ctx.db.one(from(S).where(eq(S.databaseUuid, batch.databaseUuid)));
-    if (source && source.databaseUuid !== batch.databaseUuid)
-        throw new ImportProblem('SOURCE_CONFLICT', `source ${batch.sourceId} belongs to another Odoo database`);
-    if (databaseOwner && databaseOwner.id !== batch.sourceId)
-        throw new ImportProblem('SOURCE_CONFLICT', `Odoo database is already registered as ${databaseOwner.id}`);
-    if (batch.mode === 'delta' && String(source?.lastCursor ?? '') !== String(batch.previousCursor ?? ''))
-        throw new KetError({
-            code: 'E_ODOO_IMPORT_CHECKPOINT',
-            module: 'odoo_collaboration_import',
-            message: `delta expected checkpoint ${batch.previousCursor ?? '(empty)'}, current checkpoint is ${source?.lastCursor ?? '(empty)'}`,
-        });
-    const now = new Date().toISOString();
-    if (apply) {
-        if (source)
-            await ctx.db.update('odoo_collaboration_import.Source', { id: batch.sourceId }, { name: batch.sourceName, odooVersion: batch.odooVersion, updatedAt: now });
-        else
-            await ctx.db.insert('odoo_collaboration_import.Source', {
-                id: batch.sourceId,
-                name: batch.sourceName,
-                databaseUuid: batch.databaseUuid,
-                odooVersion: batch.odooVersion,
-                createdAt: now,
-                updatedAt: now,
-            });
-        await ctx.db.insert('odoo_collaboration_import.Run', {
-            id: batch.runId,
-            sourceId: batch.sourceId,
-            mode: batch.mode,
-            state: 'running',
-            ...(batch.previousCursor ? { previousCursor: batch.previousCursor } : {}),
-            cursor: batch.cursor,
-            batchChecksum: checksum,
-            report: {},
-            startedAt: now,
-        });
-    }
-    const M = ctx.table('odoo_collaboration_import.Map');
-    const mapRows = await ctx.db.all(from(M).where(eq(M.sourceId, batch.sourceId)));
-    const state = {
-        ctx,
-        batch,
-        apply,
-        now,
-        batchChecksum: checksum,
-        maps: new Map(mapRows.map((row) => [
-            mapKey(String(row.sourceModel), String(row.sourceRecordId), String(row.targetModel)),
-            row,
-        ])),
-        available: new Map(),
-        existence: new Map(),
-        issues: [],
-        counts: {},
-        targets: [],
-        conversion: { count: 0 },
-    };
-    await processBindings(state);
-    await processRows(state);
-    const report = {
-        runId: batch.runId,
-        sourceId: batch.sourceId,
-        mode: batch.mode,
-        cursor: batch.cursor,
-        batchChecksum: checksum,
-        counts: state.counts,
-        totals: totals(state.counts),
-        warnings: state.issues.filter((issue) => issue.severity === 'warning').length,
-        errors: state.issues.filter((issue) => issue.severity === 'error').length,
-        timezoneConversions: state.conversion.count,
-        targets: state.targets,
-        issues: state.issues,
-    };
-    if (apply) {
-        for (const [index, issue] of state.issues.entries())
-            await ctx.db.insert('odoo_collaboration_import.Issue', {
-                id: `${batch.runId}:issue:${String(index + 1).padStart(5, '0')}`,
-                runId: batch.runId,
-                severity: issue.severity,
-                code: issue.code,
-                sourceModel: issue.sourceModel,
-                sourceRecordId: issue.sourceRecordId,
-                message: issue.message,
-                ...(issue.details ? { details: issue.details } : {}),
-                resolved: false,
-                createdAt: now,
-            });
-        await ctx.db.update('odoo_collaboration_import.Source', { id: batch.sourceId }, { lastCursor: batch.cursor, lastImportedAt: now, updatedAt: now });
-        await ctx.db.update('odoo_collaboration_import.Run', { id: batch.runId }, { state: 'completed', report, completedAt: now });
-    }
-    return report;
-};
-export const previewOdooBatch = (ctx, input) => processBatch(ctx, parseBatch(input), false);
-export const importOdooBatch = (ctx, input) => processBatch(ctx, parseBatch(input), true);
-export const odooRollbackManifest = async (ctx, runId) => {
-    const R = ctx.table('odoo_collaboration_import.Run');
-    const run = await ctx.db.one(from(R).where(eq(R.id, runId)));
-    if (!run)
-        throw new ImportProblem('RUN_NOT_FOUND', `import run ${runId} does not exist`);
-    const report = jsonObject(run.report);
-    return {
-        runId,
-        readOnly: true,
-        targets: report.targets ?? [],
-        warning: 'This manifest performs no reverse writes. Roll back cutover by returning traffic to the frozen Odoo database; preserve KetSuite for audit.',
-    };
-};
-export { parseBatch, stableTargetId };
-//# sourceMappingURL=operations.js.map