@nlabs/reaktor 1.19.0 → 1.20.0-reactorbox.1

package/lib/actions/supportConversation.js

@@ -0,0 +1,100 @@
+/* eslint-disable no-underscore-dangle -- Native document identity and revision checks. */ import { aql } from 'arangojs';
+import { scopeContextToApp } from '../utils/appContext.js';
+import { useDb } from '../utils/arangodbUtils.js';
+import { crmCanonicalDigest } from './crmCanonicalPolicy.js';
+import { authorizeCrmExecutionGrant } from './crmExecution.js';
+export const supportConversationKey = (value)=>typeof value === 'string' && /^[\w.-]{1,160}$/.test(value);
+export const validSupportConversationInput = (input)=>Boolean(input && Object.keys(input).sort().join(',') === 'appId,ticketId,ticketRevision' && [
+        input.appId,
+        input.ticketId,
+        input.ticketRevision
+    ].every(supportConversationKey));
+export const readSupportConversationRow = async (db, input, purpose, query = db.query.bind(db))=>query(aql`
+  LET ticket = DOCUMENT('supportTickets', ${input.ticketId})
+  LET user = ticket ? DOCUMENT('users', ticket.userId) : null
+  LET matchingConsent = (FOR candidate IN supportPurposeConsents FILTER candidate.appId == ${input.appId}
+    AND candidate.userId == user._key AND candidate.purpose == ${purpose} LIMIT 2 RETURN candidate)
+  LET messages = (FOR message IN supportTicketMessages FILTER message.supportTicketId == ${input.ticketId}
+    AND (message.appId == null OR message.appId == ${input.appId}) AND message.visibility == 'customer' AND
+      message.deleted != true
+    SORT message.modified ASC, message._key ASC LIMIT 51
+    LET bindings = (FOR edge IN hasSupportTicketMessage FILTER edge._from == ${`supportTickets/${input.ticketId}`}
+      AND edge._to == CONCAT('supportTicketMessages/', message._key) AND edge.visibility == 'customer' LIMIT 2
+        RETURN edge._key)
+    RETURN {bindingCount: LENGTH(bindings), _key: message._key, _rev: message._rev, appId: message.appId, body:
+      message.body,
+      deleted: message.deleted, modified: message.modified, supportTicketId: message.supportTicketId,
+      visibility: message.visibility})
+  RETURN {consent: LENGTH(matchingConsent) == 1 ? matchingConsent[0] : null, messages,
+    ticket: ticket ? {_key: ticket._key, _rev: ticket._rev, appId: ticket.appId, deleted: ticket.deleted,
+      status: ticket.status, userId: ticket.userId} : null,
+    user: user ? {_key: user._key, _rev: user._rev, active: user.active, appId: user.appId, deleted: user.deleted,
+      email: user.email, verifiedEmail: user.verifiedEmail, emailDeliveryStatus: user.emailDeliveryStatus, supportEmailSuppressed:
+        user.supportEmailSuppressed} : null}`).then((cursor)=>cursor.next());
+export const validateSupportConversationRow = (row, input, purpose, at)=>{
+    const { consent, ticket, user } = row || {};
+    if (!ticket || ticket._key !== input.ticketId || ticket._rev !== input.ticketRevision || ticket.appId !== input.appId || ticket.deleted === true || ![
+        'submitted',
+        'open',
+        'in_progress',
+        'waiting_on_customer',
+        'waiting_on_internal'
+    ].includes(ticket.status) || !user || user._key !== ticket.userId || !supportConversationKey(user._rev) || user.appId !== input.appId || user.deleted === true || user.active === false || !consent || consent.appId !== input.appId || consent.userId !== user._key || !supportConversationKey(consent._rev) || consent.purpose !== purpose || consent.source !== 'authenticated_customer' || consent.status !== 'active' || !Number.isSafeInteger(consent.expiresAt) || consent.expiresAt <= at || !Array.isArray(row.messages) || row.messages.some((message)=>!supportConversationKey(message._key) || !supportConversationKey(message._rev) || message.appId !== undefined && message.appId !== input.appId || message.bindingCount !== 1 || message.deleted === true || message.supportTicketId !== input.ticketId || message.visibility !== 'customer' || typeof message.body !== 'string' || message.body.length > 4000 || !Number.isSafeInteger(message.modified) || message.modified < 0 || message.modified > at)) {
+        throw new Error('support_conversation_source_hold');
+    }
+    return crmCanonicalDigest([
+        ticket._rev,
+        user._rev,
+        consent._rev,
+        row.messages.map((message)=>[
+                message._key,
+                message._rev
+            ])
+    ]);
+};
+export const supportPurposeScope = {
+    support_conversation: 'support:conversation',
+    support_email_reply: 'support:email_reply',
+    support_semantic_summary: 'support:summary'
+};
+/** The bounded native customer-visible feed is an owned source, never an external transcript assertion. */ export const readSupportPurposeConversation = async (context, input, purpose, now = Date.now)=>{
+    if (!validSupportConversationInput(input)) {
+        throw new Error('invalid_support_conversation');
+    }
+    // These new scopes are added to the public grant contract during coordinated package wiring.
+    const grant = await authorizeCrmExecutionGrant(context, input.appId, supportPurposeScope[purpose], now());
+    await authorizeCrmExecutionGrant(context, input.appId, 'support:read', now());
+    const scoped = await scopeContextToApp(context, input.appId);
+    if (scoped.databaseName !== grant.databaseName) {
+        throw new Error('support_conversation_app_changed');
+    }
+    const db = useDb(grant.databaseName);
+    const row = await readSupportConversationRow(db, input, purpose);
+    const revision = validateSupportConversationRow(row, input, purpose, now());
+    const latest = await authorizeCrmExecutionGrant(context, input.appId, supportPurposeScope[purpose], now());
+    const scope = await scopeContextToApp(context, input.appId);
+    if (grant.id !== latest.id || grant.hash !== latest.hash || grant.databaseName !== latest.databaseName || scope.databaseName !== grant.databaseName || validateSupportConversationRow(await readSupportConversationRow(db, input, purpose), input, purpose, now()) !== revision) {
+        throw new Error('support_conversation_changed');
+    }
+    return {
+        appId: input.appId,
+        generatedAt: now(),
+        messages: row.messages.slice(0, 50).map((message)=>({
+                body: message.body,
+                id: message._key,
+                modifiedAt: message.modified,
+                revision: message._rev
+            })),
+        provenance: 'native_customer_visible_feed',
+        revision,
+        schemaVersion: 'support_conversation_v1',
+        ticketId: input.ticketId,
+        ticketRevision: input.ticketRevision,
+        truncated: row.messages.length > 50,
+        validUntil: Math.min(now() + 300000, latest.expires, row.consent.expiresAt)
+    };
+};
+export const readSupportConversation = async (context, input, now = Date.now)=>readSupportPurposeConversation(context, input, 'support_conversation', now);
+export const readSupportSemanticSource = async (context, input, now = Date.now)=>readSupportPurposeConversation(context, input, 'support_semantic_summary', now);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/tmp/reactorbox-support-owner-freeze-20261008/input/actions/supportConversation.ts"],"sourcesContent":["/* eslint-disable no-underscore-dangle -- Native document identity and revision checks. */\nimport {aql} from 'arangojs';\n\nimport {scopeContextToApp} from '../utils/appContext.js';\nimport {useDb} from '../utils/arangodbUtils.js';\nimport {crmCanonicalDigest} from './crmCanonicalPolicy.js';\nimport {authorizeCrmExecutionGrant} from './crmExecution.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {SupportConsentPurpose, SupportPurposeConsentRecord} from './supportPurposeConsent.js';\n\nexport interface SupportConversationInput {\n  appId: string;\n  ticketId: string;\n  ticketRevision: string;\n}\nexport const supportConversationKey = (value: unknown): value is string => typeof value === 'string' &&\n  /^[\\w.-]{1,160}$/.test(value);\nexport const validSupportConversationInput = (input: SupportConversationInput) => Boolean(input\n    && Object.keys(input).sort().join(',') === 'appId,ticketId,ticketRevision'\n    && [input.appId, input.ticketId, input.ticketRevision].every(supportConversationKey));\nexport interface SupportConversationRow {\n  consent?: SupportPurposeConsentRecord;\n  messages: {\n    _key: string;\n    _rev: string;\n    appId?: string;\n    bindingCount: number;\n    body: string;\n    deleted?: boolean;\n    modified: number;\n    supportTicketId: string;\n    visibility: string;\n  }[];\n  ticket?: {\n    _key: string;\n    _rev: string;\n    appId: string;\n    deleted?: boolean;\n    status: string;\n    userId: string;\n  };\n  user?: {\n    _key: string;\n    _rev: string;\n    active?: boolean;\n    appId: string;\n    deleted?: boolean;\n    email?: string;\n    verifiedEmail?: boolean; emailDeliveryStatus?: string;\n    supportEmailSuppressed?: boolean;\n  };\n}\nexport const readSupportConversationRow = async (db: ReturnType<typeof useDb>, input: SupportConversationInput,\n  purpose: SupportConsentPurpose, query = db.query.bind(db)): Promise<SupportConversationRow> => query(aql `\n  LET ticket = DOCUMENT('supportTickets', ${input.ticketId})\n  LET user = ticket ? DOCUMENT('users', ticket.userId) : null\n  LET matchingConsent = (FOR candidate IN supportPurposeConsents FILTER candidate.appId == ${input.appId}\n    AND candidate.userId == user._key AND candidate.purpose == ${purpose} LIMIT 2 RETURN candidate)\n  LET messages = (FOR message IN supportTicketMessages FILTER message.supportTicketId == ${input.ticketId}\n    AND (message.appId == null OR message.appId == ${input.appId}) AND message.visibility == 'customer' AND\n      message.deleted != true\n    SORT message.modified ASC, message._key ASC LIMIT 51\n    LET bindings = (FOR edge IN hasSupportTicketMessage FILTER edge._from == ${`supportTickets/${input.ticketId}`}\n      AND edge._to == CONCAT('supportTicketMessages/', message._key) AND edge.visibility == 'customer' LIMIT 2\n        RETURN edge._key)\n    RETURN {bindingCount: LENGTH(bindings), _key: message._key, _rev: message._rev, appId: message.appId, body:\n      message.body,\n      deleted: message.deleted, modified: message.modified, supportTicketId: message.supportTicketId,\n      visibility: message.visibility})\n  RETURN {consent: LENGTH(matchingConsent) == 1 ? matchingConsent[0] : null, messages,\n    ticket: ticket ? {_key: ticket._key, _rev: ticket._rev, appId: ticket.appId, deleted: ticket.deleted,\n      status: ticket.status, userId: ticket.userId} : null,\n    user: user ? {_key: user._key, _rev: user._rev, active: user.active, appId: user.appId, deleted: user.deleted,\n      email: user.email, verifiedEmail: user.verifiedEmail, emailDeliveryStatus: user.emailDeliveryStatus, supportEmailSuppressed:\n        user.supportEmailSuppressed} : null}`)\n  .then((cursor) => cursor.next());\nexport const validateSupportConversationRow = (row: SupportConversationRow | undefined, input:\nSupportConversationInput, purpose: SupportConsentPurpose, at: number) => {\n  const {consent, ticket, user} = row || {};\n  if(!ticket || ticket._key !== input.ticketId || ticket._rev !== input.ticketRevision\n        || ticket.appId !== input.appId || ticket.deleted === true\n        || !['submitted', 'open', 'in_progress', 'waiting_on_customer', 'waiting_on_internal'].includes(ticket.status)\n        || !user || user._key !== ticket.userId || !supportConversationKey(user._rev)\n        || user.appId !== input.appId || user.deleted === true || user.active === false\n        || !consent || consent.appId !== input.appId || consent.userId !== user._key\n        || !supportConversationKey(consent._rev) || consent.purpose !== purpose\n        || consent.source !== 'authenticated_customer' || consent.status !== 'active'\n        || !Number.isSafeInteger(consent.expiresAt) || consent.expiresAt <= at\n        || !Array.isArray(row.messages) || row.messages.some((message) => !supportConversationKey(message._key)\n        || !supportConversationKey(message._rev) || (message.appId !== undefined && message.appId !== input.appId)\n          || message.bindingCount !== 1 || message.deleted === true\n        || message.supportTicketId !== input.ticketId || message.visibility !== 'customer'\n        || typeof message.body !== 'string' || message.body.length > 4000\n        || !Number.isSafeInteger(message.modified) || message.modified < 0 || message.modified > at)) {\n    throw new Error('support_conversation_source_hold');\n  }\n  return crmCanonicalDigest([ticket._rev, user._rev, consent._rev,\n    row.messages.map((message) => [message._key, message._rev])]);\n};\nexport const supportPurposeScope = {\n  support_conversation: 'support:conversation',\n  support_email_reply: 'support:email_reply', support_semantic_summary: 'support:summary'\n} as const;\n/** The bounded native customer-visible feed is an owned source, never an external transcript assertion. */\nexport const readSupportPurposeConversation = async (context: ApiContext, input: SupportConversationInput,\n  purpose: SupportConsentPurpose, now = Date.now) => {\n  if(!validSupportConversationInput(input)) {\n    throw new Error('invalid_support_conversation');\n  }\n  // These new scopes are added to the public grant contract during coordinated package wiring.\n  const grant = await authorizeCrmExecutionGrant(context, input.appId, supportPurposeScope[purpose], now());\n  await authorizeCrmExecutionGrant(context, input.appId, 'support:read', now());\n  const scoped = await scopeContextToApp(context, input.appId);\n  if(scoped.databaseName !== grant.databaseName) {\n    throw new Error('support_conversation_app_changed');\n  }\n  const db = useDb(grant.databaseName);\n  const row = await readSupportConversationRow(db, input, purpose);\n  const revision = validateSupportConversationRow(row, input, purpose, now());\n  const latest = await authorizeCrmExecutionGrant(context, input.appId, supportPurposeScope[purpose], now());\n  const scope = await scopeContextToApp(context, input.appId);\n  if(grant.id !== latest.id || grant.hash !== latest.hash || grant.databaseName !== latest.databaseName\n        || scope.databaseName !== grant.databaseName\n        || validateSupportConversationRow(await readSupportConversationRow(db, input, purpose), input, purpose,\n          now()) !== revision) {\n    throw new Error('support_conversation_changed');\n  }\n  return {\n    appId: input.appId, generatedAt: now(), messages: row.messages.slice(0, 50).map((message) => ({\n      body: message.body, id: message._key, modifiedAt: message.modified, revision: message._rev\n    })),\n    provenance: 'native_customer_visible_feed', revision, schemaVersion: 'support_conversation_v1',\n    ticketId: input.ticketId, ticketRevision: input.ticketRevision, truncated: row.messages.length > 50,\n    validUntil: Math.min(now() + 300000, latest.expires, row.consent.expiresAt)\n  };\n};\nexport const readSupportConversation = async (context: ApiContext, input: SupportConversationInput, now =\n  Date.now) => readSupportPurposeConversation(context, input, 'support_conversation', now);\nexport const readSupportSemanticSource = async (context: ApiContext, input: SupportConversationInput, now =\n  Date.now) => readSupportPurposeConversation(context, input, 'support_semantic_summary', now);\n"],"names":["aql","scopeContextToApp","useDb","crmCanonicalDigest","authorizeCrmExecutionGrant","supportConversationKey","value","test","validSupportConversationInput","input","Boolean","Object","keys","sort","join","appId","ticketId","ticketRevision","every","readSupportConversationRow","db","purpose","query","bind","then","cursor","next","validateSupportConversationRow","row","at","consent","ticket","user","_key","_rev","deleted","includes","status","userId","active","source","Number","isSafeInteger","expiresAt","Array","isArray","messages","some","message","undefined","bindingCount","supportTicketId","visibility","body","length","modified","Error","map","supportPurposeScope","support_conversation","support_email_reply","support_semantic_summary","readSupportPurposeConversation","context","now","Date","grant","scoped","databaseName","revision","latest","scope","id","hash","generatedAt","slice","modifiedAt","provenance","schemaVersion","truncated","validUntil","Math","min","expires","readSupportConversation","readSupportSemanticSource"],"mappings":"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"}

package/lib/actions/supportEmailEvents.d.ts

@@ -0,0 +1,20 @@
+import type { ApiContext } from '../types/auth.types.js';
+export interface SupportEmailEventInput {
+    appId: string;
+    eventId: string;
+    kind: 'accepted' | 'delivered' | 'bounce' | 'complaint';
+    occurredAt: number;
+    providerMessageId: string;
+    receiptId: string;
+    recipient: string;
+}
+/** Trusted provider bridge only. It must verify SES/SNS authenticity before calling this scoped owner boundary.
+ * support_receipt SES tag + exact recipient bind an unknown acknowledgement to its actual submission.
+ * Ordinary Ads/customer keys never receive this scope; browser event assertions are not provider evidence.
+ */
+export declare const ingestSupportEmailEvent: (context: ApiContext, input: SupportEmailEventInput, now?: () => number) => Promise<{
+    id: string;
+    kind: string;
+    occurredAt: number;
+    receiptId: string;
+}>;

package/lib/actions/supportEmailEvents.js

@@ -0,0 +1,130 @@
+import { aql } from 'arangojs';
+import { useDb } from '../utils/arangodbUtils.js';
+import { crmCanonicalDigest } from './crmCanonicalPolicy.js';
+import { authorizeCrmExecutionGrant, ensureOwnerExecutionCollection } from './crmExecution.js';
+import { supportConversationKey } from './supportConversation.js';
+/** Trusted provider bridge only. It must verify SES/SNS authenticity before calling this scoped owner boundary.
+ * support_receipt SES tag + exact recipient bind an unknown acknowledgement to its actual submission.
+ * Ordinary Ads/customer keys never receive this scope; browser event assertions are not provider evidence.
+ */ export const ingestSupportEmailEvent = async (context, input, now = Date.now)=>{
+    if (!input || Object.keys(input).sort().join(',') !== 'appId,eventId,kind,occurredAt,providerMessageId,receiptId,recipient' || ![
+        input.appId,
+        input.eventId,
+        input.providerMessageId
+    ].every(supportConversationKey) || !/^[a-f0-9]{64}$/.test(input.receiptId) || typeof input.recipient !== 'string' || input.recipient.length > 254 || ![
+        'accepted',
+        'delivered',
+        'bounce',
+        'complaint'
+    ].includes(input.kind) || !Number.isSafeInteger(input.occurredAt) || input.occurredAt > now() + 60000 || input.occurredAt < now() - 30 * 86400000) {
+        throw new Error('invalid_support_email_event');
+    }
+    const grant = await authorizeCrmExecutionGrant(context, input.appId, 'support:delivery_events', now());
+    const db = useDb(grant.databaseName);
+    await Promise.all([
+        ensureOwnerExecutionCollection(db, 'supportEmailEvents'),
+        ensureOwnerExecutionCollection(db, 'hasSupportEmailEvent', true)
+    ]);
+    await db.collection('supportEmailEvents').ensureIndex({
+        expireAfter: 0,
+        fields: [
+            'retireAt'
+        ],
+        type: 'ttl'
+    });
+    await db.collection('hasSupportEmailEvent').ensureIndex({
+        expireAfter: 0,
+        fields: [
+            'retireAt'
+        ],
+        type: 'ttl'
+    });
+    const tx = await db.beginTransaction({
+        exclusive: [
+            'supportEmailEvents',
+            'hasSupportEmailEvent',
+            'supportEmailReceipts',
+            'users'
+        ],
+        read: [
+            'supportTickets'
+        ]
+    }, {
+        lockTimeout: 10
+    });
+    const query = (value)=>tx.step(()=>db.query(value));
+    try {
+        const receipt = await query(aql`RETURN DOCUMENT('supportEmailReceipts', ${input.receiptId})`).then((cursor)=>cursor.next());
+        if (!receipt || receipt.appId !== input.appId || receipt.id !== input.receiptId || ![
+            'submitting',
+            'unknown',
+            'accepted'
+        ].includes(receipt.state) || receipt.recipientHash !== crmCanonicalDigest(input.recipient) || receipt.providerMessageId && receipt.providerMessageId !== input.providerMessageId || input.occurredAt < receipt.createdAt - 60000 || input.occurredAt > receipt.createdAt + 30 * 86400000) {
+            throw new Error('support_email_event_submission_hold');
+        }
+        const id = crmCanonicalDigest([
+            input.appId,
+            input.eventId
+        ]);
+        const fingerprint = crmCanonicalDigest(input);
+        const prior = await query(aql`RETURN DOCUMENT('supportEmailEvents', ${id})`).then((cursor)=>cursor.next());
+        if (prior && prior.fingerprint !== fingerprint) {
+            throw new Error('support_email_event_conflict');
+        }
+        const latest = await authorizeCrmExecutionGrant(context, input.appId, 'support:delivery_events', now());
+        if (latest.hash !== grant.hash || latest.id !== grant.id || latest.databaseName !== grant.databaseName) {
+            throw new Error('support_email_relay_changed');
+        }
+        if (prior) {
+            await tx.commit();
+            return prior.receipt;
+        }
+        const events = await query(aql`FOR event IN supportEmailEvents FILTER event.appId == ${input.appId}
+      AND event.receipt.receiptId == ${input.receiptId} LIMIT 32 RETURN event._key`).then((cursor)=>cursor.all());
+        if (events.length >= 32) {
+            throw new Error('support_email_event_limit');
+        }
+        // Negative delivery evidence suppresses even when conversation consent/revision has since changed.
+        if ([
+            'bounce',
+            'complaint'
+        ].includes(input.kind)) {
+            await query(aql`LET ticket = DOCUMENT('supportTickets', ${receipt.ticketId})
+        FOR user IN users FILTER user._key == ticket.userId AND user.appId == ${input.appId}
+        AND user.email == ${input.recipient} AND user.deleted != true
+        UPDATE user WITH {emailDeliveryStatus: user.emailDeliveryStatus == 'complaint' OR ${input.kind} == 'complaint'
+          ? 'complaint' : 'bounce_hold', supportEmailSuppressed: true} IN users`);
+        }
+        const result = {
+            id,
+            kind: input.kind,
+            occurredAt: input.occurredAt,
+            receiptId: input.receiptId
+        };
+        const retireAt = Math.floor((now() + 30 * 86400000) / 1000);
+        await query(aql`INSERT ${{
+            _key: id,
+            appId: input.appId,
+            fingerprint,
+            receipt: result,
+            retireAt
+        }} IN supportEmailEvents`);
+        await query(aql`INSERT ${{
+            _from: `supportEmailReceipts/${input.receiptId}`,
+            _key: id,
+            _to: `supportEmailEvents/${id}`,
+            appId: input.appId,
+            retireAt
+        }} IN hasSupportEmailEvent`);
+        await query(aql`UPDATE ${input.receiptId} WITH {state: 'accepted', providerAcceptedAt:
+      ${receipt.providerAcceptedAt || input.occurredAt}, providerMessageId: ${input.providerMessageId}} IN
+        supportEmailReceipts`);
+        await tx.commit();
+        return result;
+    } catch (error) {
+        await tx.abort();
+        throw error;
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/tmp/reactorbox-support-owner-freeze-20261008/input/actions/supportEmailEvents.ts"],"sourcesContent":["import {aql} from 'arangojs';\n\nimport {useDb} from '../utils/arangodbUtils.js';\nimport {crmCanonicalDigest} from './crmCanonicalPolicy.js';\nimport {authorizeCrmExecutionGrant, ensureOwnerExecutionCollection} from './crmExecution.js';\nimport {supportConversationKey} from './supportConversation.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {SupportEmailReceipt} from './supportEmailHandoff.js';\n\nexport interface SupportEmailEventInput {\n  appId: string;\n  eventId: string;\n  kind: 'accepted' | 'delivered' | 'bounce' | 'complaint';\n  occurredAt: number;\n  providerMessageId: string;\n  receiptId: string;\n  recipient: string;\n}\n/** Trusted provider bridge only. It must verify SES/SNS authenticity before calling this scoped owner boundary.\n * support_receipt SES tag + exact recipient bind an unknown acknowledgement to its actual submission.\n * Ordinary Ads/customer keys never receive this scope; browser event assertions are not provider evidence.\n */\nexport const ingestSupportEmailEvent = async (context: ApiContext, input: SupportEmailEventInput, now = Date.now) => {\n  if(!input || Object.keys(input).sort().join(',') !==\n    'appId,eventId,kind,occurredAt,providerMessageId,receiptId,recipient'\n        || ![input.appId, input.eventId, input.providerMessageId].every(supportConversationKey)\n        || !/^[a-f0-9]{64}$/.test(input.receiptId) || typeof input.recipient !== 'string' ||\n          input.recipient.length > 254\n        || !['accepted', 'delivered', 'bounce', 'complaint'].includes(input.kind) ||\n          !Number.isSafeInteger(input.occurredAt)\n        || input.occurredAt > now() + 60000 || input.occurredAt < now() - (30 * 86400000)) {\n    throw new Error('invalid_support_email_event');\n  }\n  const grant = await authorizeCrmExecutionGrant(context, input.appId, 'support:delivery_events', now());\n  const db = useDb(grant.databaseName);\n  await Promise.all([ensureOwnerExecutionCollection(db, 'supportEmailEvents'),\n    ensureOwnerExecutionCollection(db, 'hasSupportEmailEvent', true)]);\n  await db.collection('supportEmailEvents').ensureIndex({\n    expireAfter: 0, fields: ['retireAt'], type: 'ttl'\n  });\n  await db.collection('hasSupportEmailEvent').ensureIndex({\n    expireAfter: 0, fields: ['retireAt'], type: 'ttl'\n  });\n  const tx = await db.beginTransaction({\n    exclusive: ['supportEmailEvents', 'hasSupportEmailEvent', 'supportEmailReceipts', 'users'],\n    read: ['supportTickets']\n  }, {\n    lockTimeout: 10\n  });\n  const query = (value: ReturnType<typeof aql>) => tx.step(() => db.query(value));\n  try {\n    const receipt = await query(aql`RETURN DOCUMENT('supportEmailReceipts', ${input.receiptId})`).then((cursor) => cursor.next()) as (SupportEmailReceipt & {\n      recipientHash: string;\n    }) | undefined;\n    if(!receipt || receipt.appId !== input.appId || receipt.id !== input.receiptId\n            || !['submitting', 'unknown', 'accepted'].includes(receipt.state)\n            || receipt.recipientHash !== crmCanonicalDigest(input.recipient)\n            || (receipt.providerMessageId && receipt.providerMessageId !== input.providerMessageId)\n            || input.occurredAt < receipt.createdAt - 60000 || input.occurredAt > receipt.createdAt + (30 * 86400000)) {\n      throw new Error('support_email_event_submission_hold');\n    }\n    const id = crmCanonicalDigest([input.appId, input.eventId]);\n    const fingerprint = crmCanonicalDigest(input);\n    const prior = await query(aql `RETURN DOCUMENT('supportEmailEvents', ${id})`).then((cursor) => cursor.next()) as {\n      fingerprint: string;\n      receipt: {\n        id: string;\n        kind: string;\n        occurredAt: number;\n        receiptId: string;\n      };\n    } | undefined;\n    if(prior && prior.fingerprint !== fingerprint) {\n      throw new Error('support_email_event_conflict');\n    }\n    const latest = await authorizeCrmExecutionGrant(context, input.appId, 'support:delivery_events', now());\n    if(latest.hash !== grant.hash || latest.id !== grant.id || latest.databaseName !== grant.databaseName) {\n      throw new Error('support_email_relay_changed');\n    }\n    if(prior) {\n      await tx.commit();\n      return prior.receipt;\n    }\n    const events = await query(aql `FOR event IN supportEmailEvents FILTER event.appId == ${input.appId}\n      AND event.receipt.receiptId == ${input.receiptId} LIMIT 32 RETURN event._key`).then((cursor) => cursor.all());\n    if(events.length >= 32) {\n      throw new Error('support_email_event_limit');\n    }\n    // Negative delivery evidence suppresses even when conversation consent/revision has since changed.\n    if(['bounce', 'complaint'].includes(input.kind)) {\n      await query(aql `LET ticket = DOCUMENT('supportTickets', ${receipt.ticketId})\n        FOR user IN users FILTER user._key == ticket.userId AND user.appId == ${input.appId}\n        AND user.email == ${input.recipient} AND user.deleted != true\n        UPDATE user WITH {emailDeliveryStatus: user.emailDeliveryStatus == 'complaint' OR ${input.kind} == 'complaint'\n          ? 'complaint' : 'bounce_hold', supportEmailSuppressed: true} IN users`);\n    }\n    const result = {\n      id, kind: input.kind, occurredAt: input.occurredAt, receiptId: input.receiptId\n    };\n    const retireAt = Math.floor((now() + (30 * 86400000)) / 1000);\n    await query(aql `INSERT ${{\n      _key: id, appId: input.appId, fingerprint, receipt: result, retireAt\n    }} IN supportEmailEvents`);\n    await query(aql `INSERT ${{\n      _from: `supportEmailReceipts/${input.receiptId}`, _key: id,\n      _to: `supportEmailEvents/${id}`, appId: input.appId, retireAt\n    }} IN hasSupportEmailEvent`);\n    await query(aql `UPDATE ${input.receiptId} WITH {state: 'accepted', providerAcceptedAt:\n      ${receipt.providerAcceptedAt || input.occurredAt}, providerMessageId: ${input.providerMessageId}} IN\n        supportEmailReceipts`);\n    await tx.commit();\n    return result;\n  } catch(error) {\n    await tx.abort();\n    throw error;\n  }\n};\n"],"names":["aql","useDb","crmCanonicalDigest","authorizeCrmExecutionGrant","ensureOwnerExecutionCollection","supportConversationKey","ingestSupportEmailEvent","context","input","now","Date","Object","keys","sort","join","appId","eventId","providerMessageId","every","test","receiptId","recipient","length","includes","kind","Number","isSafeInteger","occurredAt","Error","grant","db","databaseName","Promise","all","collection","ensureIndex","expireAfter","fields","type","tx","beginTransaction","exclusive","read","lockTimeout","query","value","step","receipt","then","cursor","next","id","state","recipientHash","createdAt","fingerprint","prior","latest","hash","commit","events","ticketId","result","retireAt","Math","floor","_key","_from","_to","providerAcceptedAt","error","abort"],"mappings":"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"}

package/lib/actions/supportEmailHandoff.d.ts

@@ -0,0 +1,114 @@
+import { sesSend } from './email.js';
+import type { ApiContext } from '../types/auth.types.js';
+import type { SupportConversationInput } from './supportConversation.js';
+export interface SupportEmailPreviewInput extends SupportConversationInput {
+    body: string;
+    expectedConversationRevision: string;
+    idempotencyKey: string;
+    subject: string;
+}
+export interface SupportEmailReceipt {
+    appId: string;
+    contentStatus: 'current' | 'redacted';
+    conversationRevision: string;
+    createdAt: number;
+    expiresAt: number;
+    id: string;
+    maxActions: 1;
+    providerAcceptedAt?: number;
+    providerMessageId?: string;
+    revision: string;
+    state: 'pending' | 'approved' | 'rejected' | 'submitting' | 'unknown' | 'accepted';
+    ticketId: string;
+    ticketRevision: string;
+}
+/** Current exact email target review; no inferred channel binding or inbound provider provenance. */
+export declare const readSupportEmailHandoffTarget: (context: ApiContext, input: SupportConversationInput, now?: () => number) => Promise<{
+    appId: string;
+    conversationRevision: string;
+    recipient: string;
+    sender: string;
+    ticketId: string;
+    ticketRevision: string;
+    validUntil: number;
+}>;
+/** Own bounded conversation revision plus a separately consented exact email recipient/body. */
+export declare const previewSupportEmailHandoff: (context: ApiContext, input: SupportEmailPreviewInput, now?: () => number) => Promise<{
+    appId: string;
+    contentStatus: 'current' | 'redacted';
+    conversationRevision: string;
+    createdAt: number;
+    expiresAt: number;
+    id: string;
+    maxActions: 1;
+    providerAcceptedAt?: number;
+    providerMessageId?: string;
+    revision: string;
+    state: 'pending' | 'approved' | 'rejected' | 'submitting' | 'unknown' | 'accepted';
+    ticketId: string;
+    ticketRevision: string;
+    body?: string;
+    recipient?: string;
+    sender?: string;
+    subject?: string;
+}>;
+/** Inspection redacts private content immediately when any current source/authority fails. */
+export declare const getSupportEmailHandoff: (context: ApiContext, appId: string, id: string, now?: () => number) => Promise<{
+    appId: string;
+    contentStatus: 'current' | 'redacted';
+    conversationRevision: string;
+    createdAt: number;
+    expiresAt: number;
+    id: string;
+    maxActions: 1;
+    providerAcceptedAt?: number;
+    providerMessageId?: string;
+    revision: string;
+    state: 'pending' | 'approved' | 'rejected' | 'submitting' | 'unknown' | 'accepted';
+    ticketId: string;
+    ticketRevision: string;
+    body?: string;
+    recipient?: string;
+    sender?: string;
+    subject?: string;
+}>;
+/** Separate explicit revision-bound approval/rejection; never granted by an Ads plan. */
+export declare const decideSupportEmailHandoff: (context: ApiContext, appId: string, id: string, revision: string, decision: 'approved' | 'rejected', now?: () => number) => Promise<{
+    appId: string;
+    contentStatus: 'current' | 'redacted';
+    conversationRevision: string;
+    createdAt: number;
+    expiresAt: number;
+    id: string;
+    maxActions: 1;
+    providerAcceptedAt?: number;
+    providerMessageId?: string;
+    revision: string;
+    state: 'pending' | 'approved' | 'rejected' | 'submitting' | 'unknown' | 'accepted';
+    ticketId: string;
+    ticketRevision: string;
+    body?: string;
+    recipient?: string;
+    sender?: string;
+    subject?: string;
+}>;
+/** Durable claim precedes exactly one SES attempt. Missing/ambiguous acknowledgement is a permanent hold. */
+export declare const executeSupportEmailHandoff: (context: ApiContext, appId: string, id: string, revision: string, now?: () => number, send?: typeof sesSend) => Promise<{
+    appId: string;
+    contentStatus: 'current' | 'redacted';
+    conversationRevision: string;
+    createdAt: number;
+    expiresAt: number;
+    id: string;
+    maxActions: 1;
+    providerAcceptedAt?: number;
+    providerMessageId?: string;
+    revision: string;
+    state: 'pending' | 'approved' | 'rejected' | 'submitting' | 'unknown' | 'accepted';
+    ticketId: string;
+    ticketRevision: string;
+    body?: string;
+    recipient?: string;
+    sender?: string;
+    subject?: string;
+}>;