deepline 0.3.89 → 0.3.91

package/dist/bundling-sources/shared_libs/observability/scheduled-work-manual.ts

@@ -0,0 +1,35 @@
+/**
+ * The Convex cron roots that an authenticated platform operator may run on
+ * demand. Keep this list aligned with `packages/convex/crons.ts`; the catalog
+ * check makes a newly added Convex cron fail closed until it joins here.
+ *
+ * Other scheduler types deliberately are not listed. They need their own
+ * narrowly-scoped execution authority (rather than letting a Convex deploy
+ * key impersonate GitHub, Vercel, or Inngest).
+ */
+export const MANUALLY_RUNNABLE_CONVEX_CRON_JOB_IDS = [
+  'convex.fold-usage-rollups',
+  'convex.record-neon-managed-project-usage',
+  'convex.cleanup-expired-mcp-oauth-codes',
+  'convex.cleanup-expired-analytics-ip2company-cache',
+  'convex.cleanup-expired-domain-health-cache',
+  'convex.salesforce-oauth-refresh-maintenance',
+  'convex.monitor-fleet-convergence-tick',
+  'convex.provider-monitor-global-audit-daily',
+  'convex.recover-notification-delivery-work',
+  'convex.cleanup-expired-notification-audit-records',
+  'convex.fail-stale-play-deployments',
+] as const;
+
+export type ManuallyRunnableConvexCronJobId =
+  (typeof MANUALLY_RUNNABLE_CONVEX_CRON_JOB_IDS)[number];
+
+const manuallyRunnableConvexCronJobIds = new Set<string>(
+  MANUALLY_RUNNABLE_CONVEX_CRON_JOB_IDS,
+);
+
+export function isManuallyRunnableConvexCronJob(
+  jobId: string,
+): jobId is ManuallyRunnableConvexCronJobId {
+  return manuallyRunnableConvexCronJobIds.has(jobId);
+}

package/dist/bundling-sources/shared_libs/observability/scheduled-work.ts

@@ -10,6 +10,7 @@ export type ScheduledWorkScheduler =
   | 'vercel_cron';
 
 export type ScheduledWorkOutcome = 'running' | 'succeeded' | 'failed';
+export type ScheduledWorkTrigger = 'scheduled' | 'manual';
 
 export type ScheduledWorkVolume = {
   unit: string;
@@ -34,6 +35,7 @@ export type ScheduledWorkObservation = {
   occurredAt: number;
   outcome: ScheduledWorkOutcome;
   expectedWithinMs: number;
+  trigger?: ScheduledWorkTrigger;
   durationMs?: number;
   errorSummary?: string;
   runUrl?: string;
@@ -53,6 +55,9 @@ export function scheduledWorkTelemetryFields(
     scheduledWorkOutcome: observation.outcome,
     scheduledWorkInvocationId: observation.invocationId,
     scheduledWorkExpectedWithinMs: observation.expectedWithinMs,
+    ...(observation.trigger === undefined
+      ? {}
+      : { scheduledWorkTrigger: observation.trigger }),
     ...(observation.durationMs === undefined
       ? {}
       : { scheduledWorkDurationMs: observation.durationMs }),

package/dist/bundling-sources/shared_libs/play-data-plane/neon-constants.ts

@@ -0,0 +1,9 @@
+/** Shared tenant data-plane topology and database role names. */
+export const TENANT_DATA_PLANE_TOPOLOGY = 'project_per_org';
+
+export const TENANT_OWNER_ROLE_NAME = 'dl_platform_owner';
+export const TENANT_RUNTIME_ROLE_NAME = 'dl_platform_runtime';
+export const TENANT_READ_ROLE_NAME = 'dl_tenant_read';
+export const TENANT_OVERRIDE_ROLE_NAME = 'dl_tenant_override';
+
+export const TENANT_BASELINE_SCHEMA_VERSION = 1;

package/dist/bundling-sources/shared_libs/play-data-plane/r2.ts

@@ -0,0 +1,272 @@
+import {
+  S3Client,
+  PutObjectCommand,
+  GetObjectCommand,
+  HeadObjectCommand,
+} from '@aws-sdk/client-s3';
+import { NodeHttpHandler } from '@smithy/node-http-handler';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { Agent as HttpsAgent } from 'node:https';
+import { isBuildContext } from '../observability/build-context';
+
+type R2PresignerClient = Parameters<typeof getSignedUrl>[0];
+type R2PresignerCommand = Parameters<typeof getSignedUrl>[1];
+
+export type R2BucketKind = 'default' | 'playArtifacts';
+
+const PLAY_ARTIFACT_BUCKETS = {
+  dev: 'plays-artifacts-v1-dev',
+  prod: 'plays-artifacts-v1-prod',
+} as const;
+
+function requireEnv(name: string): string {
+  const value = process.env[name]?.trim();
+  if (!value) {
+    throw new Error(`Missing ${name}`);
+  }
+  return value;
+}
+
+function getRuntimeEnv(): keyof typeof PLAY_ARTIFACT_BUCKETS {
+  const candidates = [
+    process.env.DEEPLINE_ENV,
+    process.env.VERCEL_ENV,
+    process.env.NODE_ENV,
+  ]
+    .filter(Boolean)
+    .map((value) => String(value).trim().toLowerCase());
+
+  for (const value of candidates) {
+    if (value === 'production' || value === 'prod' || value === 'live') {
+      return 'prod';
+    }
+    if (
+      value === 'development' ||
+      value === 'dev' ||
+      value === 'preview' ||
+      value === 'staging' ||
+      value === 'stage' ||
+      value === 'test'
+    ) {
+      return 'dev';
+    }
+  }
+
+  return 'dev';
+}
+
+function resolveBucket(kind: R2BucketKind): string {
+  if (kind === 'playArtifacts') {
+    return PLAY_ARTIFACT_BUCKETS[getRuntimeEnv()];
+  }
+  return requireEnv('CLOUDFLARE_R2_BUCKET_NAME');
+}
+
+export function getR2Config(kind: R2BucketKind = 'default') {
+  return {
+    endpoint: requireEnv('CLOUDFLARE_R2_ENDPOINT'),
+    accessKeyId: requireEnv('CLOUDFLARE_R2_ACCESS_KEY_ID'),
+    secretAccessKey: requireEnv('CLOUDFLARE_R2_SECRET_ACCESS_KEY'),
+    bucket: resolveBucket(kind),
+    publicUrl: requireEnv('CLOUDFLARE_R2_PUBLIC_URL'),
+  };
+}
+
+export function createR2Client(
+  config: ReturnType<typeof getR2Config>,
+): S3Client {
+  return new S3Client({
+    region: 'auto',
+    endpoint: config.endpoint,
+    credentials: {
+      accessKeyId: config.accessKeyId,
+      secretAccessKey: config.secretAccessKey,
+    },
+    requestHandler: new NodeHttpHandler({
+      httpsAgent: new HttpsAgent({
+        keepAlive: true,
+        maxSockets: 64,
+      }),
+    }),
+  });
+}
+
+const r2ClientMemo = new Map<string, S3Client>();
+
+function getR2Client(config: ReturnType<typeof getR2Config>): S3Client {
+  const key = `${config.endpoint}|${config.bucket}|${config.accessKeyId}`;
+  const existing = r2ClientMemo.get(key);
+  if (existing) {
+    return existing;
+  }
+  const client = createR2Client(config);
+  r2ClientMemo.set(key, client);
+  return client;
+}
+
+function logR2Perf(
+  operation: string,
+  key: string,
+  startedAt: number,
+  extra: Record<string, unknown> = {},
+) {
+  // `[perf][r2]` fires on every object op; during the prebuilt-artifact build it
+  // floods the log. Keep it at runtime (Axiom) but silence it in the build.
+  if (isBuildContext()) return;
+  console.info('[perf][r2]', {
+    operation,
+    key,
+    ms: Date.now() - startedAt,
+    ...extra,
+  });
+}
+
+export async function r2ObjectExists(
+  key: string,
+  kind: R2BucketKind = 'default',
+): Promise<boolean> {
+  const startedAt = Date.now();
+  const config = getR2Config(kind);
+  const client = getR2Client(config);
+  try {
+    await client.send(
+      new HeadObjectCommand({
+        Bucket: config.bucket,
+        Key: key,
+      }),
+    );
+    logR2Perf('head', key, startedAt, { kind, exists: true });
+    return true;
+  } catch {
+    logR2Perf('head', key, startedAt, { kind, exists: false });
+    return false;
+  }
+}
+
+export async function uploadBufferToR2(input: {
+  key: string;
+  body: Buffer | Uint8Array;
+  contentType: string;
+  bucketKind?: R2BucketKind;
+}): Promise<string> {
+  const startedAt = Date.now();
+  const bucketKind = input.bucketKind ?? 'default';
+  const configStartedAt = Date.now();
+  const config = getR2Config(bucketKind);
+  logR2Perf('config', input.key, configStartedAt, { kind: bucketKind });
+  const clientStartedAt = Date.now();
+  const client = getR2Client(config);
+  logR2Perf('client', input.key, clientStartedAt, { kind: bucketKind });
+
+  const sendStartedAt = Date.now();
+  await client.send(
+    new PutObjectCommand({
+      Bucket: config.bucket,
+      Key: input.key,
+      Body:
+        input.body instanceof Buffer ? new Uint8Array(input.body) : input.body,
+      ContentType: input.contentType,
+    }),
+  );
+  logR2Perf('put-send', input.key, sendStartedAt, {
+    kind: bucketKind,
+    bytes: input.body.byteLength,
+  });
+  logR2Perf('put', input.key, startedAt, {
+    kind: bucketKind,
+    bytes: input.body.byteLength,
+  });
+
+  if (bucketKind === 'playArtifacts') {
+    return `r2://${config.bucket}/${input.key}`;
+  }
+  return `${config.publicUrl.replace(/\/+$/, '')}/${input.key}`;
+}
+
+export async function getBufferFromR2(
+  key: string,
+  kind: R2BucketKind = 'default',
+): Promise<Buffer> {
+  const startedAt = Date.now();
+  const config = getR2Config(kind);
+  const client = getR2Client(config);
+
+  const response = await client.send(
+    new GetObjectCommand({
+      Bucket: config.bucket,
+      Key: key,
+    }),
+  );
+
+  const bytes = await response.Body!.transformToByteArray();
+  logR2Perf('get', key, startedAt, { kind, bytes: bytes.byteLength });
+  return Buffer.from(bytes);
+}
+
+export async function createSignedR2ReadUrl(input: {
+  key: string;
+  kind?: R2BucketKind;
+  expiresInSeconds: number;
+}): Promise<{ url: string; expiresAt: string }> {
+  const startedAt = Date.now();
+  const kind = input.kind ?? 'default';
+  const config = getR2Config(kind);
+  const client = createR2Client(config);
+  const expiresInSeconds = Math.max(1, Math.floor(input.expiresInSeconds));
+  const command = new GetObjectCommand({
+    Bucket: config.bucket,
+    Key: input.key,
+  });
+  const url = await getSignedUrl(
+    client as R2PresignerClient,
+    command as R2PresignerCommand,
+    { expiresIn: expiresInSeconds },
+  );
+  logR2Perf('sign-get', input.key, startedAt, {
+    kind,
+    expiresInSeconds,
+  });
+  return {
+    url,
+    expiresAt: new Date(Date.now() + expiresInSeconds * 1000).toISOString(),
+  };
+}
+
+/**
+ * Mint a short-lived presigned PUT URL so a client can upload an object body
+ * straight to R2, bypassing the serverless request-body ceiling that a proxied
+ * upload through the Next.js route would hit.
+ *
+ * The URL signs `ContentType`, so the caller MUST send a matching
+ * `Content-Type` header on the PUT for the signature to validate.
+ */
+export async function createSignedR2WriteUrl(input: {
+  key: string;
+  kind?: R2BucketKind;
+  contentType: string;
+  expiresInSeconds: number;
+}): Promise<{ url: string; expiresAt: string }> {
+  const startedAt = Date.now();
+  const kind = input.kind ?? 'default';
+  const config = getR2Config(kind);
+  const client = createR2Client(config);
+  const expiresInSeconds = Math.max(1, Math.floor(input.expiresInSeconds));
+  const command = new PutObjectCommand({
+    Bucket: config.bucket,
+    Key: input.key,
+    ContentType: input.contentType,
+  });
+  const url = await getSignedUrl(
+    client as R2PresignerClient,
+    command as R2PresignerCommand,
+    { expiresIn: expiresInSeconds },
+  );
+  logR2Perf('sign-put', input.key, startedAt, {
+    kind,
+    expiresInSeconds,
+  });
+  return {
+    url,
+    expiresAt: new Date(Date.now() + expiresInSeconds * 1000).toISOString(),
+  };
+}

package/dist/bundling-sources/shared_libs/play-runtime/app-runtime-api.ts

@@ -198,6 +198,13 @@ type RuntimeApiRequest =
       workflowId: string;
       runId: string;
       workflowFamilyKey: string;
+      /** Optional for root and older durable admission envelopes. */
+      parentRunId?: string | null;
+      rootRunId?: string | null;
+      asyncLaunchKey?: string | null;
+      asyncInvocationKey?: string | null;
+      asyncRequestFingerprint?: string | null;
+      asyncAncestryPlayIds?: string[] | null;
       definitionScope?: 'org' | 'system';
       revisionId?: string | null;
       artifactStorageKey?: string | null;
@@ -235,7 +242,7 @@ type RuntimeApiRequest =
       sheetContract?: PlaySheetContract | null;
       contractSnapshot?: unknown;
       runId: string;
-      userEmail: string;
+      userEmail?: string | null;
       updates: Array<Omit<PlayRowUpdate, 'rowId'> & { runId?: string }>;
     }
   | {
@@ -592,6 +599,17 @@ function isRetryableAppRuntimeResponse(input: {
   ) {
     return true;
   }
+  // Convex can deploy the projector before the Vercel app knows this action.
+  // That old app returns this exact unstructured 403. The projection is
+  // idempotent and the outbox keeps its delivery receipt, so retrying bridges
+  // the release skew without classifying real executor authorization failures
+  // as transient.
+  if (
+    input.action === 'project_run_created' &&
+    isLegacyProjectRunCreatedUnsupportedActionResponse(input)
+  ) {
+    return true;
+  }
   // The app runtime may explicitly classify an otherwise-client-error status
   // as transient. Keep the structured delivery contract authoritative rather
   // than reducing every 4xx to permanent at the worker boundary.
@@ -610,6 +628,32 @@ function isRetryableAppRuntimeResponse(input: {
   return isRetryableAppRuntimeResponseStatus(input.status);
 }
 
+/**
+ * The pre-reader app returns this one precise response for an action it does
+ * not yet know. Do not use a substring match here: an authorization failure
+ * that merely repeats the phrase must remain terminal and reach an operator.
+ */
+function isLegacyProjectRunCreatedUnsupportedActionResponse(input: {
+  status: number;
+  body: string;
+}): boolean {
+  if (input.status !== 403) return false;
+  const expected = 'Unsupported runtime action capability scope.';
+  try {
+    const parsed = JSON.parse(input.body) as unknown;
+    return (
+      !!parsed &&
+      typeof parsed === 'object' &&
+      !Array.isArray(parsed) &&
+      (parsed as { error?: unknown }).error === expected
+    );
+  } catch {
+    // The oldest route can return the bare legacy message. Retain that bridge
+    // while keeping it exact rather than accepting an arbitrary 403 body.
+    return input.body.trim() === expected;
+  }
+}
+
 function appRuntimeExplicitRetryable(body: string): boolean | null {
   try {
     const parsed = JSON.parse(body) as unknown;
@@ -762,6 +806,7 @@ function isRetryableAppRuntimeAction(
     action === 'rate_state_release' ||
     action === 'rate_state_penalize' ||
     action === 'record_first_claim_latency' ||
+    action === 'project_run_created' ||
     action === 'release_runtime_step_receipt' ||
     action === 'save_results' ||
     action === 'skip_runtime_step_receipt' ||

package/dist/bundling-sources/shared_libs/play-runtime/async-operation.ts

@@ -95,11 +95,26 @@ export type AsyncOperationContractWire = {
    * status. This rule applies only to that launch response; unknown poll
    * responses still use terminal.defaultOutcome.
    */
-  launch?: { unclassifiedJobOutcome: 'running' };
+  launch?: {
+    unclassifiedJobOutcome: 'running';
+    /** Ask this start action for its handle instead of its legacy sync result. */
+    preferAsync?: boolean;
+  };
   job: { idPaths: readonly string[] };
   polling: {
     initialDelayMs: number;
     intervalMs: number;
+    /**
+     * The longest one provider status/result read may wait when the caller
+     * owns the lifecycle. This is deliberately separate from the complete
+     * job timeout: a Play fan-out must release its transport slot promptly
+     * and let the next invocation perform the next check.
+     *
+     * Provider adapters translate this generic budget into their native
+     * long-poll parameter when they have one. Omit it when a poll endpoint
+     * already returns immediately.
+     */
+    checkTimeoutMs?: number;
     /** Optional public start-input field that overrides intervalMs for this call. */
     intervalInputField?: string;
     backoffMultiplier?: number;
@@ -128,6 +143,14 @@ export type AsyncOperationContractWire = {
 };
 
 export type AsyncOperationContract = AsyncOperationContractWire;
+/**
+ * Runtime projection for one lifecycle companion action. This is the single
+ * cadence fact a provider adapter receives; it does not expose a provider
+ * handle or make a result receipt into provider-job state.
+ */
+export type AsyncOperationPollExecution = {
+  checkTimeoutMs: number;
+};
 export type AsyncActionFlowCompatibilityProjection = {
   pollActions: readonly string[];
   finishAction?: string;
@@ -261,6 +284,12 @@ export function defineAsyncOperation(
   nonNegativeInteger(contract.polling.initialDelayMs, 'polling.initialDelayMs');
   positiveInteger(contract.polling.intervalMs, 'polling.intervalMs');
   positiveInteger(contract.polling.timeoutMs, 'polling.timeoutMs');
+  if (contract.polling.checkTimeoutMs !== undefined) {
+    positiveInteger(
+      contract.polling.checkTimeoutMs,
+      'polling.checkTimeoutMs',
+    );
+  }
   if (contract.polling.intervalInputField !== undefined) {
     required(contract.polling.intervalInputField, 'polling.intervalInputField');
   }
@@ -406,6 +435,17 @@ export function defineCallerManagedAsyncOperation(input: {
   pollActions: readonly string[];
   finishAction?: string;
   jobIdPaths?: readonly string[];
+  /**
+   * The provider has an explicit asynchronous launch path. A Play will receive
+   * its job handle immediately and own subsequent polling.
+   */
+  preferAsyncStart?: boolean;
+  /**
+   * Bound one provider-side status/result check for Plays. The default keeps
+   * large fan-outs nonblocking while direct SDK and CLI calls retain their
+   * provider-specific behavior.
+   */
+  checkTimeoutMs?: number;
   /**
    * Preserve an existing public asyncGetAction, or pass null when the legacy
    * action exposed only asyncFlow metadata.
@@ -431,6 +471,14 @@ export function defineCallerManagedAsyncOperation(input: {
         ? { finishAction: companion(input.finishAction) }
         : {}),
     },
+    ...(input.preferAsyncStart
+      ? {
+          launch: {
+            unclassifiedJobOutcome: 'running' as const,
+            preferAsync: true,
+          },
+        }
+      : {}),
     job: {
       idPaths: input.jobIdPaths ?? [
         'job_id',
@@ -446,6 +494,7 @@ export function defineCallerManagedAsyncOperation(input: {
     polling: {
       initialDelayMs: 0,
       intervalMs: 1_000,
+      checkTimeoutMs: input.checkTimeoutMs ?? 1_000,
       timeoutMs: 15 * 60_000,
     },
     terminal: {
@@ -462,6 +511,22 @@ export function defineCallerManagedAsyncOperation(input: {
   });
 }
 
+/**
+ * Project the generic caller-managed cadence onto each polling companion.
+ * `always` and `input_flag` operations execute their complete lifecycle at
+ * the API boundary, so exposing a bounded companion policy for them would be
+ * misleading.
+ */
+export function projectAsyncOperationPollExecution(
+  contract: AsyncOperationContractWire,
+): AsyncOperationPollExecution | null {
+  if (contract.wait.kind !== 'caller_managed') return null;
+  return {
+    checkTimeoutMs:
+      contract.polling.checkTimeoutMs ?? contract.polling.intervalMs,
+  };
+}
+
 export function asyncOperationCompanionActions(
   contract: AsyncOperationContract,
 ): string[] {

package/dist/bundling-sources/shared_libs/play-runtime/async-play-invocation.ts

@@ -42,7 +42,6 @@ export function assertAsyncPlayInvocation(input: {
       `${CTX_RUN_PLAY_ASYNC_DATASET_UNSUPPORTED}: ctx.runPlayAsync("${childPlayName}") launches one independent scalar or HITL Play Run, but the target owns ctx.dataset(), ctx.csv(), or a Runtime Sheet. Keep batch work in its top-level Play or extract a scalar per-record child.`,
     );
   }
-
 }
 
 /** Admit a child against the persisted root-to-parent Play lineage. */

package/dist/bundling-sources/shared_libs/play-runtime/bounceban-batching.ts

@@ -0,0 +1,137 @@
+import {
+  defineBatchStrategyMap,
+  type BatchOperationStrategy,
+} from './batching-types';
+
+type Single = {
+  email: string;
+  mode?: 'regular' | 'deepverify';
+  disable_catchall_verify?: '0' | '1';
+  url?: string;
+};
+type Bulk = Omit<Single, 'email'> & { emails: string[] };
+type Verdict = Record<string, unknown> & { email: string; status?: string };
+type Results = { items?: Verdict[]; data?: { items?: Verdict[] } };
+
+function options(payload: Single) {
+  return {
+    mode: payload.mode ?? 'regular',
+    disable_catchall_verify: payload.disable_catchall_verify ?? '0',
+  };
+}
+function bucket(payload: Single) {
+  // Single and bulk webhook payloads differ. Do not batch webhook callers.
+  return JSON.stringify([options(payload), payload.url ?? null]);
+}
+function emailKey(email: string) {
+  return email.trim().toLowerCase();
+}
+
+export const bouncebanVerifyBatchStrategy: BatchOperationStrategy<
+  Single,
+  Bulk | Single,
+  Results,
+  { data: Verdict }
+> = {
+  sourceOperation: 'bounceban_verify_single',
+  batchOperation: 'bounceban_verify_bulk',
+  kind: 'async_dataset_job',
+  // The async finish action retrieves at most 100 emails per request.
+  maxBatchSize: 100,
+  bucketKeyPayloadFields: ['mode', 'disable_catchall_verify', 'url'],
+  canBatchWith(left, right) {
+    return !left.url && !right.url && bucket(left) === bucket(right);
+  },
+  toBucketKey: bucket,
+  toItemKey: (payload) => emailKey(payload.email),
+  compile(payloads) {
+    const first = payloads[0];
+    if (payloads.length === 1 && first) {
+      return {
+        batchOperation: 'bounceban_verify_single',
+        batchPayload: first,
+        items: [{ itemKey: emailKey(first.email), payload: first }],
+      };
+    }
+    if (
+      !first ||
+      payloads.length > 100 ||
+      payloads.some((p) => p.url || bucket(p) !== bucket(first))
+    ) {
+      throw new Error(
+        'BounceBan batch requires 1–100 emails with matching verification options and no webhooks.',
+      );
+    }
+    return {
+      batchOperation: 'bounceban_verify_bulk',
+      batchPayload: {
+        emails: [...new Set(payloads.map((p) => emailKey(p.email)))],
+        ...options(first),
+      },
+      items: payloads.map((payload) => ({
+        itemKey: emailKey(payload.email),
+        payload,
+      })),
+    };
+  },
+  splitResult(fullResult, compiled) {
+    if (compiled.batchOperation === 'bounceban_verify_single') {
+      const row = (fullResult.data ?? fullResult) as Verdict;
+      if (
+        row.status !== 'success' ||
+        typeof row.email !== 'string' ||
+        emailKey(row.email) !== compiled.items[0]?.itemKey ||
+        !['deliverable', 'undeliverable', 'risky', 'unknown'].includes(
+          String(row.result),
+        )
+      ) {
+        throw new Error(
+          'BounceBan single verification returned an unfinished or malformed verdict.',
+        );
+      }
+      return [
+        {
+          itemKey: compiled.items[0]!.itemKey,
+          result: { data: row },
+          rawResult: row,
+        },
+      ];
+    }
+    const rows = fullResult.items ?? fullResult.data?.items;
+    if (!Array.isArray(rows))
+      throw new Error('BounceBan bulk verification returned no result list.');
+    const byEmail = new Map<string, Verdict>();
+    for (const row of rows) {
+      if (
+        !row ||
+        typeof row.email !== 'string' ||
+        (row.status !== undefined && row.status !== 'success') ||
+        !['deliverable', 'undeliverable', 'risky', 'unknown'].includes(
+          String(row.result),
+        )
+      ) {
+        throw new Error(
+          'BounceBan bulk verification returned an unfinished or malformed verdict.',
+        );
+      }
+      const key = emailKey(row.email);
+      if (byEmail.has(key))
+        throw new Error(
+          'BounceBan bulk verification returned duplicate verdicts.',
+        );
+      byEmail.set(key, row);
+    }
+    return compiled.items.map((item) => {
+      const row = byEmail.get(item.itemKey);
+      if (!row)
+        throw new Error(
+          `BounceBan bulk verification omitted a requested email result.`,
+        );
+      return { itemKey: item.itemKey, result: { data: row }, rawResult: row };
+    });
+  },
+};
+
+export const bouncebanBatchStrategies = defineBatchStrategyMap({
+  bounceban_verify_single: bouncebanVerifyBatchStrategy,
+});