@nlabs/reaktor 1.19.0 → 1.20.0-reactorbox.1

package/lib/actions/crmDeliveryEvents.d.ts

@@ -0,0 +1,24 @@
+import type { ApiContext } from '../types/auth.types.js';
+export interface CrmDeliveryEventInput {
+    appId: string;
+    bounceType?: 'Permanent' | 'Transient' | 'Undetermined';
+    eventId: string;
+    kind: 'delivered' | 'bounce' | 'complaint';
+    occurredAt: number;
+    providerMessageId: string;
+    receiptId: string;
+}
+export interface CrmDeliveryEventReceipt {
+    bounceType?: CrmDeliveryEventInput['bounceType'];
+    id: string;
+    kind: CrmDeliveryEventInput['kind'];
+    occurredAt: number;
+    receiptId: string;
+    suppressed: boolean;
+}
+/** Trusted server relay scope authenticates a deployed relay; it does not verify unsigned SNS claims. */
+export declare const ingestCrmDeliveryEvent: (context: ApiContext, input: CrmDeliveryEventInput, now?: () => number) => Promise<CrmDeliveryEventReceipt>;
+/** Native administrator privacy action; persistent minimized tombstone prevents prior accepted-message reingestion. */
+export declare const eraseCrmDeliveryEvidence: (context: ApiContext, appId: string, userId: string, now?: () => number) => Promise<{
+    erased: number;
+}>;

package/lib/actions/crmDeliveryEvents.js

@@ -0,0 +1,207 @@
+/* eslint-disable no-await-in-loop, no-underscore-dangle -- Sequential collection setup and native graph metadata. */ import { aql } from 'arangojs';
+import { createHash } from 'node:crypto';
+import { scopeContextToApp } from '../utils/appContext.js';
+import { useDb } from '../utils/arangodbUtils.js';
+import { requireCrmAdministrator } from './crm.js';
+import { crmDeliveryPrivacyKey } from './crmDeliveryEvidence.js';
+import { authorizeCrmExecutionGrant, ensureOwnerExecutionCollection } from './crmExecution.js';
+const digest = (value)=>createHash('sha256').update(JSON.stringify(value)).digest('hex');
+const identifier = (value)=>typeof value === 'string' && /^[\w.-]{1,200}$/.test(value);
+const valid = (input, at)=>Boolean(input && identifier(input.appId) && input.appId.length <= 100 && identifier(input.eventId) && /^[a-f0-9]{64}$/.test(input.receiptId) && identifier(input.providerMessageId) && [
+        'delivered',
+        'bounce',
+        'complaint'
+    ].includes(input.kind) && Object.keys(input).every((key)=>[
+            'appId',
+            'bounceType',
+            'eventId',
+            'kind',
+            'occurredAt',
+            'providerMessageId',
+            'receiptId'
+        ].includes(key)) && (input.kind === 'bounce' ? [
+        'Permanent',
+        'Transient',
+        'Undetermined'
+    ].includes(input.bounceType || '') : input.bounceType === undefined) && Number.isSafeInteger(input.occurredAt) && input.occurredAt <= at + 60000 && input.occurredAt >= at - 30 * 86400000);
+/** Trusted server relay scope authenticates a deployed relay; it does not verify unsigned SNS claims. */ export const ingestCrmDeliveryEvent = async (context, input, now = Date.now)=>{
+    if (!valid(input, now())) {
+        throw new Error('invalid_crm_delivery_event');
+    }
+    const grant = await authorizeCrmExecutionGrant(context, input.appId, 'crm:delivery_events', now());
+    const db = useDb(grant.databaseName);
+    const documents = [
+        'crmDeliveryEvents',
+        'crmExecutionReceipts',
+        'crmDeliveryPrivacy',
+        'users'
+    ];
+    const edges = [
+        'hasCrmExecutionDelivery',
+        'hasUserCrmDelivery'
+    ];
+    for (const name of [
+        ...documents,
+        ...edges
+    ]){
+        await ensureOwnerExecutionCollection(db, name, edges.includes(name));
+    }
+    const tx = await db.beginTransaction({
+        exclusive: [
+            ...documents,
+            ...edges
+        ]
+    }, {
+        lockTimeout: 10
+    });
+    const query = (value)=>tx.step(()=>db.query(value));
+    try {
+        const receipt = await query(aql`RETURN DOCUMENT('crmExecutionReceipts', ${input.receiptId})`).then((cursor)=>cursor.next());
+        if (!receipt || receipt.appId !== input.appId || receipt.id !== input.receiptId || receipt.state !== 'applied' || ![
+            'crm_outreach',
+            'scheduling_reminder'
+        ].includes(receipt.kind) || receipt.providerMessageId !== input.providerMessageId || !Number.isSafeInteger(receipt.providerAcceptedAt) || receipt.providerAcceptedAt < receipt.createdAt || receipt.providerAcceptedAt > now() || input.occurredAt < receipt.providerAcceptedAt - 60000 || input.occurredAt > receipt.providerAcceptedAt + 30 * 86400000) {
+            throw new Error('crm_delivery_accepted_message_required');
+        }
+        const user = await query(aql`RETURN DOCUMENT('users', ${receipt.recipient.id})`).then((cursor)=>cursor.next());
+        if (!user || user.deleted === true || user.email !== receipt.recipient.email || user._key !== receipt.recipient.id) {
+            throw new Error('crm_delivery_recipient_changed');
+        }
+        const erased = await query(aql`RETURN DOCUMENT('crmDeliveryPrivacy', ${crmDeliveryPrivacyKey(input.appId, user._key)})`).then((cursor)=>cursor.next());
+        if (erased && receipt.providerAcceptedAt <= erased.erasedAt) {
+            throw new Error('crm_delivery_privacy_erased');
+        }
+        const id = digest([
+            input.appId,
+            input.eventId
+        ]);
+        const fingerprint = digest([
+            input.appId,
+            input.receiptId,
+            input.providerMessageId,
+            input.kind,
+            input.bounceType,
+            input.occurredAt
+        ]);
+        const previous = await query(aql`RETURN DOCUMENT('crmDeliveryEvents', ${id})`).then((cursor)=>cursor.next());
+        if (previous && previous.fingerprint !== fingerprint) {
+            throw new Error('crm_delivery_event_conflict');
+        }
+        const current = await authorizeCrmExecutionGrant(context, input.appId, 'crm:delivery_events', now());
+        if (current.id !== grant.id || current.hash !== grant.hash || current.databaseName !== grant.databaseName) {
+            throw new Error('crm_delivery_relay_changed');
+        }
+        const suppressed = input.kind !== 'delivered' || Boolean(user.emailDeliveryStatus && user.emailDeliveryStatus !== 'valid');
+        if (previous) {
+            await tx.commit();
+            return {
+                ...previous.receipt,
+                suppressed
+            };
+        }
+        const timeline = await query(aql`FOR event IN crmDeliveryEvents
+      FILTER event.appId == ${input.appId} AND event.receipt.receiptId == ${input.receiptId}
+      LIMIT 32 RETURN event._key`).then((cursor)=>cursor.all());
+        if (timeline.length >= 32) {
+            throw new Error('crm_delivery_timeline_limit');
+        }
+        const result = {
+            bounceType: input.bounceType,
+            id,
+            kind: input.kind,
+            occurredAt: input.occurredAt,
+            receiptId: input.receiptId,
+            suppressed
+        };
+        await query(aql`INSERT ${{
+            _key: id,
+            appId: input.appId,
+            fingerprint,
+            receipt: result,
+            receivedAt: now(),
+            relayGrantId: grant.id
+        }} INTO crmDeliveryEvents`);
+        if (input.kind !== 'delivered') {
+            // Any bounce holds sends; classification is evidence, not a claim that a transient bounce is permanent.
+            const status = input.kind === 'complaint' || user.emailDeliveryStatus === 'complaint' ? 'complaint' : 'bounce_hold';
+            await query(aql`UPDATE ${user._key} WITH {emailDeliveryStatus: ${status}, modified: ${now()}} IN users`);
+        }
+        await query(aql`INSERT ${{
+            _from: `crmExecutionReceipts/${input.receiptId}`,
+            _key: id,
+            _to: `crmDeliveryEvents/${id}`,
+            appId: input.appId
+        }} INTO hasCrmExecutionDelivery`);
+        await query(aql`INSERT ${{
+            _from: `users/${user._key}`,
+            _key: id,
+            _to: `crmDeliveryEvents/${id}`,
+            appId: input.appId
+        }} INTO hasUserCrmDelivery`);
+        const closing = await authorizeCrmExecutionGrant(context, input.appId, 'crm:delivery_events', now());
+        if (closing.id !== grant.id || closing.hash !== grant.hash || closing.databaseName !== grant.databaseName) {
+            throw new Error('crm_delivery_relay_changed');
+        }
+        await tx.commit();
+        return result;
+    } catch (error) {
+        await tx.abort();
+        throw error;
+    }
+};
+/** Native administrator privacy action; persistent minimized tombstone prevents prior accepted-message reingestion. */ export const eraseCrmDeliveryEvidence = async (context, appId, userId, now = Date.now)=>{
+    requireCrmAdministrator(context);
+    if (!identifier(appId) || appId.length > 100 || !identifier(userId) || userId.length > 100) {
+        throw new Error('invalid_crm_delivery_erasure');
+    }
+    const scoped = await scopeContextToApp(context, appId);
+    const db = useDb(scoped.databaseName);
+    const documents = [
+        'crmDeliveryEvents',
+        'crmDeliveryPrivacy'
+    ];
+    const edges = [
+        'hasCrmExecutionDelivery',
+        'hasUserCrmDelivery'
+    ];
+    for (const name of [
+        ...documents,
+        ...edges
+    ]){
+        await ensureOwnerExecutionCollection(db, name, edges.includes(name));
+    }
+    const tx = await db.beginTransaction({
+        exclusive: [
+            ...documents,
+            ...edges
+        ]
+    }, {
+        lockTimeout: 10
+    });
+    const query = (value)=>tx.step(()=>db.query(value));
+    try {
+        const ids = await query(aql`FOR edge IN hasUserCrmDelivery
+      FILTER edge.appId == ${appId} AND edge._from == ${`users/${userId}`}
+      RETURN PARSE_IDENTIFIER(edge._to).key`).then((cursor)=>cursor.all());
+        const id = crmDeliveryPrivacyKey(appId, userId);
+        await query(aql`UPSERT {_key: ${id}} INSERT ${{
+            _key: id,
+            erasedAt: now()
+        }}
+      UPDATE {erasedAt: MAX([OLD.erasedAt, ${now()}])} IN crmDeliveryPrivacy`);
+        await query(aql`FOR event IN crmDeliveryEvents FILTER event._key IN ${ids} REMOVE event IN crmDeliveryEvents`);
+        await query(aql`FOR edge IN hasCrmExecutionDelivery FILTER edge.appId == ${appId}
+      AND PARSE_IDENTIFIER(edge._to).key IN ${ids} REMOVE edge IN hasCrmExecutionDelivery`);
+        await query(aql`FOR edge IN hasUserCrmDelivery FILTER edge.appId == ${appId}
+      AND edge._from == ${`users/${userId}`} REMOVE edge IN hasUserCrmDelivery`);
+        await tx.commit();
+        return {
+            erased: ids.length
+        };
+    } catch (error) {
+        await tx.abort();
+        throw error;
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/crmDeliveryEvents.ts"],"sourcesContent":["/* eslint-disable no-await-in-loop, no-underscore-dangle -- Sequential collection setup and native graph metadata. */\nimport {aql} from 'arangojs';\nimport {createHash} from 'node:crypto';\n\nimport {scopeContextToApp} from '../utils/appContext.js';\nimport {useDb} from '../utils/arangodbUtils.js';\nimport {requireCrmAdministrator} from './crm.js';\nimport {crmDeliveryPrivacyKey} from './crmDeliveryEvidence.js';\nimport {authorizeCrmExecutionGrant, ensureOwnerExecutionCollection} from './crmExecution.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {CrmExecutionReceipt} from './crmExecution.js';\n\nexport interface CrmDeliveryEventInput {\n  appId: string;\n  bounceType?: 'Permanent' | 'Transient' | 'Undetermined';\n  eventId: string;\n  kind: 'delivered' | 'bounce' | 'complaint';\n  occurredAt: number;\n  providerMessageId: string;\n  receiptId: string;\n}\nexport interface CrmDeliveryEventReceipt {\n  bounceType?: CrmDeliveryEventInput['bounceType'];\n  id: string;\n  kind: CrmDeliveryEventInput['kind'];\n  occurredAt: number;\n  receiptId: string;\n  suppressed: boolean;\n}\nconst digest = (value: unknown): string => createHash('sha256').update(JSON.stringify(value)).digest('hex');\nconst identifier = (value: unknown): value is string => typeof value === 'string' && /^[\\w.-]{1,200}$/.test(value);\nconst valid = (input: CrmDeliveryEventInput, at: number): boolean => Boolean(input && identifier(input.appId)\n  && input.appId.length <= 100 && identifier(input.eventId) && /^[a-f0-9]{64}$/.test(input.receiptId)\n  && identifier(input.providerMessageId) && ['delivered', 'bounce', 'complaint'].includes(input.kind)\n  && Object.keys(input).every((key) => ['appId', 'bounceType', 'eventId', 'kind', 'occurredAt', 'providerMessageId', 'receiptId'].includes(key))\n  && (input.kind === 'bounce' ? ['Permanent', 'Transient', 'Undetermined'].includes(input.bounceType || '') : input.bounceType === undefined)\n  && Number.isSafeInteger(input.occurredAt) && input.occurredAt <= at + 60000\n  && input.occurredAt >= at - (30 * 86400000));\n\n/** Trusted server relay scope authenticates a deployed relay; it does not verify unsigned SNS claims. */\nexport const ingestCrmDeliveryEvent = async (\n  context: ApiContext, input: CrmDeliveryEventInput, now = Date.now\n): Promise<CrmDeliveryEventReceipt> => {\n  if(!valid(input, now())) {\n    throw new Error('invalid_crm_delivery_event');\n  }\n  const grant = await authorizeCrmExecutionGrant(context, input.appId, 'crm:delivery_events', now());\n  const db = useDb(grant.databaseName);\n  const documents = ['crmDeliveryEvents', 'crmExecutionReceipts', 'crmDeliveryPrivacy', 'users'];\n  const edges = ['hasCrmExecutionDelivery', 'hasUserCrmDelivery'];\n  for(const name of [...documents, ...edges]) {\n    await ensureOwnerExecutionCollection(db, name, edges.includes(name));\n  }\n  const tx = await db.beginTransaction({exclusive: [...documents, ...edges]}, {lockTimeout: 10});\n  const query = (value: ReturnType<typeof aql>) => tx.step(() => db.query(value));\n  try {\n    const receipt = await query(aql`RETURN DOCUMENT('crmExecutionReceipts', ${input.receiptId})`)\n      .then((cursor) => cursor.next()) as CrmExecutionReceipt;\n    if(!receipt || receipt.appId !== input.appId || receipt.id !== input.receiptId || receipt.state !== 'applied'\n      || !['crm_outreach', 'scheduling_reminder'].includes(receipt.kind) || receipt.providerMessageId !== input.providerMessageId\n      || !Number.isSafeInteger(receipt.providerAcceptedAt) || receipt.providerAcceptedAt! < receipt.createdAt\n      || receipt.providerAcceptedAt! > now() || input.occurredAt < receipt.providerAcceptedAt! - 60000\n      || input.occurredAt > receipt.providerAcceptedAt! + (30 * 86400000)) {\n      throw new Error('crm_delivery_accepted_message_required');\n    }\n    const user = await query(aql`RETURN DOCUMENT('users', ${receipt.recipient.id})`)\n      .then((cursor) => cursor.next()) as {\n      _key: string; deleted?: boolean; email: string; emailDeliveryStatus?: string;\n    };\n    if(!user || user.deleted === true || user.email !== receipt.recipient.email || user._key !== receipt.recipient.id) {\n      throw new Error('crm_delivery_recipient_changed');\n    }\n    const erased = await query(aql`RETURN DOCUMENT('crmDeliveryPrivacy', ${crmDeliveryPrivacyKey(input.appId, user._key)})`)\n      .then((cursor) => cursor.next()) as {erasedAt: number} | undefined;\n    if(erased && receipt.providerAcceptedAt! <= erased.erasedAt) {\n      throw new Error('crm_delivery_privacy_erased');\n    }\n    const id = digest([input.appId, input.eventId]);\n    const fingerprint = digest([input.appId, input.receiptId, input.providerMessageId, input.kind,\n      input.bounceType, input.occurredAt]);\n    const previous = await query(aql`RETURN DOCUMENT('crmDeliveryEvents', ${id})`)\n      .then((cursor) => cursor.next()) as {fingerprint: string; receipt: CrmDeliveryEventReceipt} | undefined;\n    if(previous && previous.fingerprint !== fingerprint) {\n      throw new Error('crm_delivery_event_conflict');\n    }\n    const current = await authorizeCrmExecutionGrant(context, input.appId, 'crm:delivery_events', now());\n    if(current.id !== grant.id || current.hash !== grant.hash || current.databaseName !== grant.databaseName) {\n      throw new Error('crm_delivery_relay_changed');\n    }\n    const suppressed = input.kind !== 'delivered' || Boolean(user.emailDeliveryStatus && user.emailDeliveryStatus !== 'valid');\n    if(previous) {\n      await tx.commit();\n      return {...previous.receipt, suppressed};\n    }\n    const timeline = await query(aql`FOR event IN crmDeliveryEvents\n      FILTER event.appId == ${input.appId} AND event.receipt.receiptId == ${input.receiptId}\n      LIMIT 32 RETURN event._key`).then((cursor) => cursor.all()) as string[];\n    if(timeline.length >= 32) {\n      throw new Error('crm_delivery_timeline_limit');\n    }\n    const result: CrmDeliveryEventReceipt = {bounceType: input.bounceType, id, kind: input.kind,\n      occurredAt: input.occurredAt, receiptId: input.receiptId, suppressed};\n    await query(aql`INSERT ${{_key: id, appId: input.appId, fingerprint, receipt: result, receivedAt: now(),\n      relayGrantId: grant.id}} INTO crmDeliveryEvents`);\n    if(input.kind !== 'delivered') {\n      // Any bounce holds sends; classification is evidence, not a claim that a transient bounce is permanent.\n      const status = input.kind === 'complaint' || user.emailDeliveryStatus === 'complaint' ? 'complaint' : 'bounce_hold';\n      await query(aql`UPDATE ${user._key} WITH {emailDeliveryStatus: ${status}, modified: ${now()}} IN users`);\n    }\n    await query(aql`INSERT ${{_from: `crmExecutionReceipts/${input.receiptId}`, _key: id,\n      _to: `crmDeliveryEvents/${id}`, appId: input.appId}} INTO hasCrmExecutionDelivery`);\n    await query(aql`INSERT ${{_from: `users/${user._key}`, _key: id,\n      _to: `crmDeliveryEvents/${id}`, appId: input.appId}} INTO hasUserCrmDelivery`);\n    const closing = await authorizeCrmExecutionGrant(context, input.appId, 'crm:delivery_events', now());\n    if(closing.id !== grant.id || closing.hash !== grant.hash || closing.databaseName !== grant.databaseName) {\n      throw new Error('crm_delivery_relay_changed');\n    }\n    await tx.commit();\n    return result;\n  } catch(error) {\n    await tx.abort();\n    throw error;\n  }\n};\n\n\n/** Native administrator privacy action; persistent minimized tombstone prevents prior accepted-message reingestion. */\nexport const eraseCrmDeliveryEvidence = async (\n  context: ApiContext, appId: string, userId: string, now = Date.now\n): Promise<{erased: number}> => {\n  requireCrmAdministrator(context);\n  if(!identifier(appId) || appId.length > 100 || !identifier(userId) || userId.length > 100) {\n    throw new Error('invalid_crm_delivery_erasure');\n  }\n  const scoped = await scopeContextToApp(context, appId);\n  const db = useDb(scoped.databaseName);\n  const documents = ['crmDeliveryEvents', 'crmDeliveryPrivacy'];\n  const edges = ['hasCrmExecutionDelivery', 'hasUserCrmDelivery'];\n  for(const name of [...documents, ...edges]) {\n    await ensureOwnerExecutionCollection(db, name, edges.includes(name));\n  }\n  const tx = await db.beginTransaction({exclusive: [...documents, ...edges]}, {lockTimeout: 10});\n  const query = (value: ReturnType<typeof aql>) => tx.step(() => db.query(value));\n  try {\n    const ids = await query(aql`FOR edge IN hasUserCrmDelivery\n      FILTER edge.appId == ${appId} AND edge._from == ${`users/${userId}`}\n      RETURN PARSE_IDENTIFIER(edge._to).key`).then((cursor) => cursor.all()) as string[];\n    const id = crmDeliveryPrivacyKey(appId, userId);\n    await query(aql`UPSERT {_key: ${id}} INSERT ${{_key: id, erasedAt: now()}}\n      UPDATE {erasedAt: MAX([OLD.erasedAt, ${now()}])} IN crmDeliveryPrivacy`);\n    await query(aql`FOR event IN crmDeliveryEvents FILTER event._key IN ${ids} REMOVE event IN crmDeliveryEvents`);\n    await query(aql`FOR edge IN hasCrmExecutionDelivery FILTER edge.appId == ${appId}\n      AND PARSE_IDENTIFIER(edge._to).key IN ${ids} REMOVE edge IN hasCrmExecutionDelivery`);\n    await query(aql`FOR edge IN hasUserCrmDelivery FILTER edge.appId == ${appId}\n      AND edge._from == ${`users/${userId}`} REMOVE edge IN hasUserCrmDelivery`);\n    await tx.commit();\n    return {erased: ids.length};\n  } catch(error) {\n    await tx.abort();\n    throw error;\n  }\n};\n"],"names":["aql","createHash","scopeContextToApp","useDb","requireCrmAdministrator","crmDeliveryPrivacyKey","authorizeCrmExecutionGrant","ensureOwnerExecutionCollection","digest","value","update","JSON","stringify","identifier","test","valid","input","at","Boolean","appId","length","eventId","receiptId","providerMessageId","includes","kind","Object","keys","every","key","bounceType","undefined","Number","isSafeInteger","occurredAt","ingestCrmDeliveryEvent","context","now","Date","Error","grant","db","databaseName","documents","edges","name","tx","beginTransaction","exclusive","lockTimeout","query","step","receipt","then","cursor","next","id","state","providerAcceptedAt","createdAt","user","recipient","deleted","email","_key","erased","erasedAt","fingerprint","previous","current","hash","suppressed","emailDeliveryStatus","commit","timeline","all","result","receivedAt","relayGrantId","status","_from","_to","closing","error","abort","eraseCrmDeliveryEvidence","userId","scoped","ids"],"mappings":"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"}

package/lib/actions/crmDeliveryEvidence.d.ts

@@ -0,0 +1,17 @@
+import type { useDb } from '../utils/arangodbUtils.js';
+import type { CrmExecutionReceipt } from './crmExecution.js';
+export interface CrmDeliveryEvidence {
+    events: {
+        bounceType?: 'Permanent' | 'Transient' | 'Undetermined';
+        kind: 'delivered' | 'bounce' | 'complaint';
+        occurredAt: number;
+    }[];
+    generatedAt: number;
+    negativeHold: boolean | null;
+    schemaVersion: 'crm_delivery_evidence_v1';
+    status: 'available' | 'erased' | 'unavailable';
+    validUntil: number;
+}
+export declare const crmDeliveryPrivacyKey: (appId: string, userId: string) => string;
+/** Internal projection composed only after the ordinary exact native receipt-read authority check. */
+export declare const readCrmDeliveryEvidence: (db: ReturnType<typeof useDb>, receipt: CrmExecutionReceipt, now: number, expires: number) => Promise<CrmDeliveryEvidence>;

package/lib/actions/crmDeliveryEvidence.js

@@ -0,0 +1,58 @@
+/* eslint-disable no-underscore-dangle -- Native minimized owner recipient and ledger metadata. */ import { aql } from 'arangojs';
+import { createHash } from 'node:crypto';
+export const crmDeliveryPrivacyKey = (appId, userId)=>createHash('sha256').update(JSON.stringify([
+        appId,
+        userId
+    ])).digest('hex');
+/** Internal projection composed only after the ordinary exact native receipt-read authority check. */ export const readCrmDeliveryEvidence = async (db, receipt, now, expires)=>{
+    const base = {
+        events: [],
+        generatedAt: now,
+        negativeHold: null,
+        schemaVersion: 'crm_delivery_evidence_v1',
+        status: 'unavailable',
+        validUntil: Math.min(expires, now + 900000)
+    };
+    if (receipt.state !== 'applied' || !receipt.providerMessageId || !Number.isSafeInteger(receipt.providerAcceptedAt) || ![
+        'crm_outreach',
+        'scheduling_reminder'
+    ].includes(receipt.kind) || expires <= now || !await db.collection('crmDeliveryEvents').exists() || !await db.collection('crmDeliveryPrivacy').exists()) {
+        return base;
+    }
+    const row = await db.query(aql`LET user = DOCUMENT('users', ${receipt.recipient.id})
+    LET privacy = DOCUMENT('crmDeliveryPrivacy', ${crmDeliveryPrivacyKey(receipt.appId, receipt.recipient.id)})
+    LET events = (FOR event IN crmDeliveryEvents
+      FILTER event.appId == ${receipt.appId} AND event.receipt.receiptId == ${receipt.id}
+      SORT event.receipt.occurredAt ASC, event._key ASC LIMIT 33
+      RETURN KEEP(event.receipt, 'bounceType', 'kind', 'occurredAt'))
+    RETURN {events, privacy, user: user ? KEEP(user, '_key', 'deleted', 'email', 'emailDeliveryStatus') : null}`).then((cursor)=>cursor.next());
+    if (row?.privacy && receipt.providerAcceptedAt <= row.privacy.erasedAt) {
+        return {
+            ...base,
+            status: 'erased'
+        };
+    }
+    if (!row?.user || row.user.deleted === true || row.user._key !== receipt.recipient.id || row.user.email !== receipt.recipient.email || !Array.isArray(row.events) || row.events.length > 32 || row.events.some((event)=>![
+            'delivered',
+            'bounce',
+            'complaint'
+        ].includes(event.kind) || !Number.isSafeInteger(event.occurredAt) || event.occurredAt > now + 60000 || event.occurredAt < receipt.providerAcceptedAt - 60000 || (event.kind === 'bounce' ? ![
+            'Permanent',
+            'Transient',
+            'Undetermined'
+        ].includes(event.bounceType || '') : event.bounceType !== undefined))) {
+        return base;
+    }
+    return {
+        ...base,
+        events: row.events.map((event)=>({
+                bounceType: event.bounceType,
+                kind: event.kind,
+                occurredAt: event.occurredAt
+            })),
+        negativeHold: Boolean(row.user.emailDeliveryStatus && row.user.emailDeliveryStatus !== 'valid'),
+        status: 'available'
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/packages/reaktor/src/actions/crmDeliveryEvidence.ts"],"sourcesContent":["/* eslint-disable no-underscore-dangle -- Native minimized owner recipient and ledger metadata. */\nimport {aql} from 'arangojs';\nimport {createHash} from 'node:crypto';\n\nimport type {useDb} from '../utils/arangodbUtils.js';\nimport type {CrmExecutionReceipt} from './crmExecution.js';\n\nexport interface CrmDeliveryEvidence {\n  events: {bounceType?: 'Permanent' | 'Transient' | 'Undetermined'; kind: 'delivered' | 'bounce' | 'complaint'; occurredAt: number}[];\n  generatedAt: number;\n  negativeHold: boolean | null;\n  schemaVersion: 'crm_delivery_evidence_v1';\n  status: 'available' | 'erased' | 'unavailable';\n  validUntil: number;\n}\nexport const crmDeliveryPrivacyKey = (appId: string, userId: string): string =>\n  createHash('sha256').update(JSON.stringify([appId, userId])).digest('hex');\n\n/** Internal projection composed only after the ordinary exact native receipt-read authority check. */\nexport const readCrmDeliveryEvidence = async (\n  db: ReturnType<typeof useDb>, receipt: CrmExecutionReceipt, now: number, expires: number\n): Promise<CrmDeliveryEvidence> => {\n  const base: CrmDeliveryEvidence = {events: [], generatedAt: now, negativeHold: null,\n    schemaVersion: 'crm_delivery_evidence_v1', status: 'unavailable', validUntil: Math.min(expires, now + 900000)};\n  if(receipt.state !== 'applied' || !receipt.providerMessageId || !Number.isSafeInteger(receipt.providerAcceptedAt)\n    || !['crm_outreach', 'scheduling_reminder'].includes(receipt.kind) || expires <= now\n    || !await db.collection('crmDeliveryEvents').exists() || !await db.collection('crmDeliveryPrivacy').exists()) {\n    return base;\n  }\n  const row = await db.query(aql`LET user = DOCUMENT('users', ${receipt.recipient.id})\n    LET privacy = DOCUMENT('crmDeliveryPrivacy', ${crmDeliveryPrivacyKey(receipt.appId, receipt.recipient.id)})\n    LET events = (FOR event IN crmDeliveryEvents\n      FILTER event.appId == ${receipt.appId} AND event.receipt.receiptId == ${receipt.id}\n      SORT event.receipt.occurredAt ASC, event._key ASC LIMIT 33\n      RETURN KEEP(event.receipt, 'bounceType', 'kind', 'occurredAt'))\n    RETURN {events, privacy, user: user ? KEEP(user, '_key', 'deleted', 'email', 'emailDeliveryStatus') : null}`)\n    .then((cursor) => cursor.next()) as {events: CrmDeliveryEvidence['events']; privacy?: {erasedAt: number};\n      user?: {_key: string; deleted?: boolean; email: string; emailDeliveryStatus?: string};} | undefined;\n  if(row?.privacy && receipt.providerAcceptedAt! <= row.privacy.erasedAt) {\n    return {...base, status: 'erased'};\n  }\n  if(!row?.user || row.user.deleted === true || row.user._key !== receipt.recipient.id\n    || row.user.email !== receipt.recipient.email || !Array.isArray(row.events) || row.events.length > 32\n    || row.events.some((event) => !['delivered', 'bounce', 'complaint'].includes(event.kind)\n      || !Number.isSafeInteger(event.occurredAt) || event.occurredAt > now + 60000\n      || event.occurredAt < receipt.providerAcceptedAt! - 60000\n      || (event.kind === 'bounce' ? !['Permanent', 'Transient', 'Undetermined'].includes(event.bounceType || '')\n        : event.bounceType !== undefined))) {\n    return base;\n  }\n  return {...base, events: row.events.map((event) => ({bounceType: event.bounceType,\n    kind: event.kind, occurredAt: event.occurredAt})),\n  negativeHold: Boolean(row.user.emailDeliveryStatus && row.user.emailDeliveryStatus !== 'valid'), status: 'available'};\n};\n"],"names":["aql","createHash","crmDeliveryPrivacyKey","appId","userId","update","JSON","stringify","digest","readCrmDeliveryEvidence","db","receipt","now","expires","base","events","generatedAt","negativeHold","schemaVersion","status","validUntil","Math","min","state","providerMessageId","Number","isSafeInteger","providerAcceptedAt","includes","kind","collection","exists","row","query","recipient","id","then","cursor","next","privacy","erasedAt","user","deleted","_key","email","Array","isArray","length","some","event","occurredAt","bounceType","undefined","map","Boolean","emailDeliveryStatus"],"mappings":"AAAA,gGAAgG,GAChG,SAAQA,GAAG,QAAO,WAAW;AAC7B,SAAQC,UAAU,QAAO,cAAc;AAavC,OAAO,MAAMC,wBAAwB,CAACC,OAAeC,SACnDH,WAAW,UAAUI,MAAM,CAACC,KAAKC,SAAS,CAAC;QAACJ;QAAOC;KAAO,GAAGI,MAAM,CAAC,OAAO;AAE7E,oGAAoG,GACpG,OAAO,MAAMC,0BAA0B,OACrCC,IAA8BC,SAA8BC,KAAaC;IAEzE,MAAMC,OAA4B;QAACC,QAAQ,EAAE;QAAEC,aAAaJ;QAAKK,cAAc;QAC7EC,eAAe;QAA4BC,QAAQ;QAAeC,YAAYC,KAAKC,GAAG,CAACT,SAASD,MAAM;IAAO;IAC/G,IAAGD,QAAQY,KAAK,KAAK,aAAa,CAACZ,QAAQa,iBAAiB,IAAI,CAACC,OAAOC,aAAa,CAACf,QAAQgB,kBAAkB,KAC3G,CAAC;QAAC;QAAgB;KAAsB,CAACC,QAAQ,CAACjB,QAAQkB,IAAI,KAAKhB,WAAWD,OAC9E,CAAC,MAAMF,GAAGoB,UAAU,CAAC,qBAAqBC,MAAM,MAAM,CAAC,MAAMrB,GAAGoB,UAAU,CAAC,sBAAsBC,MAAM,IAAI;QAC9G,OAAOjB;IACT;IACA,MAAMkB,MAAM,MAAMtB,GAAGuB,KAAK,CAACjC,GAAG,CAAC,6BAA6B,EAAEW,QAAQuB,SAAS,CAACC,EAAE,CAAC;iDACpC,EAAEjC,sBAAsBS,QAAQR,KAAK,EAAEQ,QAAQuB,SAAS,CAACC,EAAE,EAAE;;4BAElF,EAAExB,QAAQR,KAAK,CAAC,gCAAgC,EAAEQ,QAAQwB,EAAE,CAAC;;;+GAGsB,CAAC,EAC3GC,IAAI,CAAC,CAACC,SAAWA,OAAOC,IAAI;IAE/B,IAAGN,KAAKO,WAAW5B,QAAQgB,kBAAkB,IAAKK,IAAIO,OAAO,CAACC,QAAQ,EAAE;QACtE,OAAO;YAAC,GAAG1B,IAAI;YAAEK,QAAQ;QAAQ;IACnC;IACA,IAAG,CAACa,KAAKS,QAAQT,IAAIS,IAAI,CAACC,OAAO,KAAK,QAAQV,IAAIS,IAAI,CAACE,IAAI,KAAKhC,QAAQuB,SAAS,CAACC,EAAE,IAC/EH,IAAIS,IAAI,CAACG,KAAK,KAAKjC,QAAQuB,SAAS,CAACU,KAAK,IAAI,CAACC,MAAMC,OAAO,CAACd,IAAIjB,MAAM,KAAKiB,IAAIjB,MAAM,CAACgC,MAAM,GAAG,MAChGf,IAAIjB,MAAM,CAACiC,IAAI,CAAC,CAACC,QAAU,CAAC;YAAC;YAAa;YAAU;SAAY,CAACrB,QAAQ,CAACqB,MAAMpB,IAAI,KAClF,CAACJ,OAAOC,aAAa,CAACuB,MAAMC,UAAU,KAAKD,MAAMC,UAAU,GAAGtC,MAAM,SACpEqC,MAAMC,UAAU,GAAGvC,QAAQgB,kBAAkB,GAAI,SAChDsB,CAAAA,MAAMpB,IAAI,KAAK,WAAW,CAAC;YAAC;YAAa;YAAa;SAAe,CAACD,QAAQ,CAACqB,MAAME,UAAU,IAAI,MACnGF,MAAME,UAAU,KAAKC,SAAQ,IAAK;QACxC,OAAOtC;IACT;IACA,OAAO;QAAC,GAAGA,IAAI;QAAEC,QAAQiB,IAAIjB,MAAM,CAACsC,GAAG,CAAC,CAACJ,QAAW,CAAA;gBAACE,YAAYF,MAAME,UAAU;gBAC/EtB,MAAMoB,MAAMpB,IAAI;gBAAEqB,YAAYD,MAAMC,UAAU;YAAA,CAAA;QAChDjC,cAAcqC,QAAQtB,IAAIS,IAAI,CAACc,mBAAmB,IAAIvB,IAAIS,IAAI,CAACc,mBAAmB,KAAK;QAAUpC,QAAQ;IAAW;AACtH,EAAE"}

package/lib/actions/crmExecution.d.ts

@@ -0,0 +1,125 @@
+import { useDb } from '../utils/arangodbUtils.js';
+import { sesSend } from './email.js';
+import type { ApiContext } from '../types/auth.types.js';
+import type { CrmCheckoutRecoveryBinding, CrmCheckoutRecoveryBounds } from './crmCheckoutRecoveryPolicy.js';
+import type { CrmDeliveryEvidence } from './crmDeliveryEvidence.js';
+import type { CrmLeadFollowupBinding, CrmLeadFollowupBounds } from './crmLeadFollowups.js';
+import type { CrmWinbackBinding } from './crmWinback.js';
+import type { CrmWinbackBounds } from './crmWinbackPolicy.js';
+import type { SupportManagement } from './supportPolicy.js';
+export type CrmExecutionScope = 'crm:checkout_recovery' | 'crm:delivery_events' | 'crm:lead_followup' | 'crm:outreach' | 'crm:winback' | 'support:commerce' | 'support:conversation' | 'support:summary' | 'support:email_reply' | 'support:delivery_events' | 'support:channel_ingest' | 'support:context' | 'support:read' | 'support:triage' | 'support:reply' | 'support:manage' | 'scheduling:calendar_sync' | 'scheduling:calendar_invite' | 'scheduling:read' | 'scheduling:book' | 'scheduling:remind' | 'finance:provider_read' | 'finance:read' | 'finance:invoice';
+export interface CrmExecutionGrantInput {
+    appId: string;
+    expiresAt: string;
+    followupBounds?: CrmLeadFollowupBounds;
+    recoveryBounds?: CrmCheckoutRecoveryBounds;
+    winbackBounds?: CrmWinbackBounds;
+    scopes: CrmExecutionScope[];
+    senderEmail: string;
+    unsubscribeUrl?: string;
+}
+export interface CrmExecutionInput {
+    appId: string;
+    body: string;
+    expectedSourceRevision: string;
+    includeVerifiedRecoveryLink?: boolean;
+    followup?: CrmLeadFollowupBinding;
+    recovery?: CrmCheckoutRecoveryBinding;
+    winback?: CrmWinbackBinding;
+    idempotencyKey: string;
+    kind: 'crm_outreach' | 'support_triage' | 'support_reply' | 'support_manage' | 'scheduling_reminder';
+    management?: SupportManagement;
+    status?: 'in_progress' | 'waiting_on_customer' | 'waiting_on_internal';
+    subject: string;
+    targetId: string;
+}
+export interface CrmExecutionReceipt {
+    appId: string;
+    body?: string;
+    contentStatus?: 'current' | 'redacted';
+    createdAt: number;
+    deliveryEvidence?: CrmDeliveryEvidence;
+    expiresAt: number;
+    followup?: CrmLeadFollowupBinding;
+    recovery?: CrmCheckoutRecoveryBinding;
+    winback?: CrmWinbackBinding;
+    grantId: string;
+    id: string;
+    kind: CrmExecutionInput['kind'];
+    management?: SupportManagement;
+    maxActions: 1;
+    notBefore?: number;
+    providerAcceptedAt?: number;
+    providerMessageId?: string;
+    recipient: {
+        email?: string;
+        id: string;
+    };
+    recoveryLinkHash?: string;
+    revision: string;
+    sourceRevision: string;
+    scheduled?: boolean;
+    scheduleStatus?: 'scheduled' | 'cancelled' | 'held' | 'completed';
+    scheduleUpdatedAt?: number;
+    state: 'pending' | 'approved' | 'rejected' | 'submitting' | 'unknown' | 'applied';
+    status?: CrmExecutionInput['status'];
+    subject?: string;
+    targetId: string;
+}
+interface Grant extends CrmExecutionGrantInput {
+    databaseName: string;
+    expires: number;
+    hash: string;
+    id: string;
+    ownerId: string;
+    revokedAt?: number;
+}
+interface Source {
+    email: string;
+    id: string;
+    revision: string;
+    notBefore?: number;
+    reminderConsentId?: string;
+    subject?: string;
+    ticketStatus?: string;
+}
+/** Native hosts can expire capability content in bounded maintenance without altering send claims. */
+export declare const retainCrmCheckoutRecoveryContent: (context: ApiContext, appId: string, now?: () => number) => Promise<number>;
+export declare const ensureOwnerExecutionCollection: (db: ReturnType<typeof useDb>, name: string, edge?: boolean) => Promise<void>;
+/** Grant writes are administrator-only; the secret is returned once and never stored. */
+export declare const createCrmExecutionKey: (context: ApiContext, input: CrmExecutionGrantInput, now?: () => number) => Promise<{
+    appId: string;
+    executionKey: string;
+    expiresAt: string;
+    followupBounds: CrmLeadFollowupBounds;
+    id: `${string}-${string}-${string}-${string}-${string}`;
+    recoveryBounds: CrmCheckoutRecoveryBounds;
+    scopes: CrmExecutionScope[];
+    winbackBounds: CrmWinbackBounds;
+}>;
+export declare const revokeCrmExecutionKey: (context: ApiContext, appId: string, id: string, now?: () => number) => Promise<boolean>;
+export declare const authorizeCrmExecutionGrant: (context: ApiContext, appId: string, scope: CrmExecutionScope, now: number) => Promise<Grant>;
+declare const source: (db: ReturnType<typeof useDb>, kind: CrmExecutionInput['kind'], targetId: string, query?: any, at?: number, appId?: string) => Promise<Source>;
+/** Source policy shared by already-authorized owner workflows; never exposed as an HTTP resolver. */
+export declare const readCrmExecutionTargetSource: typeof source;
+/** Minimized authorized target read; no ticket descriptions, history or unrelated customer fields. */
+export declare const readCrmExecutionTarget: (context: ApiContext, appId: string, kind: CrmExecutionInput['kind'], targetId: string, now?: () => number) => Promise<{
+    email: string;
+    id: string;
+    revision: string;
+    notBefore?: number;
+    reminderConsentId?: string;
+    subject?: string;
+    ticketStatus?: string;
+    appId: string;
+    targetId: string;
+}>;
+export declare const getCrmExecutionReceipt: (context: ApiContext, appId: string, id: string, now?: () => number) => Promise<CrmExecutionReceipt>;
+/** Freeze exactly one recipient and plain-text action. Approval is a separate revision-bound operation. */
+export declare const previewCrmExecution: (context: ApiContext, input: CrmExecutionInput, now?: () => number) => Promise<CrmExecutionReceipt>;
+export declare const decideCrmExecution: (context: ApiContext, appId: string, id: string, revision: string, decision: 'approved' | 'rejected', now?: () => number) => Promise<CrmExecutionReceipt>;
+/** Customer-facing Support reply/triage commits atomically. SES submissions are never blindly retried. */
+export declare const executeCrmExecution: (context: ApiContext, appId: string, id: string, revision: string, now?: () => number, send?: (params: Parameters<typeof sesSend>[0]) => Promise<import("@aws-sdk/client-ses").SendEmailCommandOutput>, scheduled?: boolean) => Promise<CrmExecutionReceipt>;
+/** Public opaque unsubscribe capability; only updates the exact consent-bound recipient. */
+export declare const unsubscribeCrmExecution: (context: ApiContext, appId: string, token: string, now?: () => number) => Promise<boolean>;
+export {};