@signaliz/sdk 1.0.61 → 1.0.63

package/dist/{chunk-ENA7AVFB.mjs → chunk-VWO2GEYQ.mjs}

@@ -48,9 +48,13 @@ function publicRetryDetails(body) {
     ...body?.credits_used !== void 0 ? { credits_used: body.credits_used } : {},
     ...body?.credits_charged !== void 0 ? { credits_charged: body.credits_charged } : {},
     ...body?.job_id !== void 0 ? { job_id: body.job_id } : {},
+    ...body?.idempotency_key !== void 0 ? { idempotency_key: body.idempotency_key } : {},
     ...body?.verification_run_id !== void 0 ? { verification_run_id: body.verification_run_id } : {},
     ...body?.run_id !== void 0 ? { run_id: body.run_id } : {},
     ...body?.suggested_action !== void 0 ? { suggested_action: body.suggested_action } : {},
+    ...body?.do_not_auto_resubmit !== void 0 ? { do_not_auto_resubmit: body.do_not_auto_resubmit } : {},
+    ...body?.results_cleaned !== void 0 ? { results_cleaned: body.results_cleaned } : {},
+    ...body?.results_expired !== void 0 ? { results_expired: body.results_expired } : {},
     ...body?.signal_run_id !== void 0 ? { signal_run_id: body.signal_run_id } : {},
     ...body?.company_signal_run_id !== void 0 ? { company_signal_run_id: body.company_signal_run_id } : {},
     ...body?.resume_context_persisted !== void 0 ? { resume_context_persisted: body.resume_context_persisted } : {}
@@ -66,8 +70,9 @@ function mergePublicErrorDetails(body, explicitDetails) {
 }
 function mapErrorType(code, status) {
   if (code === "RATE_LIMITED" || status === 429) return "rate_limited";
-  if (code === "VALIDATION_ERROR" || code === "SIGNAL_RUN_COMPANY_MISMATCH" || status === 400) return "validation";
+  if (code === "PAYLOAD_TOO_LARGE" || code === "VALIDATION_ERROR" || code === "SIGNAL_RUN_COMPANY_MISMATCH" || status === 400 || status === 413) return "validation";
   if (code === "NOT_FOUND" || status === 404) return "not_found";
+  if (code === "BATCH_RESULTS_EXPIRED" || status === 410) return "not_found";
   if (code === "NO_SUPPORTED_SIGNAL") return "not_found";
   if (code === "AUTH_EXPIRED" || status === 401) return "auth_expired";
   if (code === "INSUFFICIENT_CREDITS" || status === 402) return "insufficient_credits";
@@ -78,7 +83,7 @@ function mapErrorType(code, status) {
 
 // src/client.ts
 var DEFAULT_BASE_URL = "https://api.signaliz.com/functions/v1";
-var DEFAULT_TIMEOUT = 12e4;
+var DEFAULT_TIMEOUT = 13e4;
 var DEFAULT_MAX_RETRIES = 3;
 var HttpClient = class {
   constructor(config) {
@@ -92,9 +97,9 @@ var HttpClient = class {
       throw new Error("Signaliz: provide either apiKey or clientId + clientSecret");
     }
   }
-  async request(functionName, body, method = "POST") {
+  async request(functionName, body, method = "POST", options = {}) {
     let lastError;
-    const idempotencyKey = method === "POST" ? requestIdempotencyKey(body) : void 0;
+    const idempotencyKey = method === "POST" ? requestIdempotencyKey(body, options.automaticIdempotency !== false) : void 0;
     for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
       let timer;
       try {
@@ -162,8 +167,8 @@ var HttpClient = class {
     throw lastError || new Error("Request failed after retries");
   }
   /** Convenience wrapper for POST-based edge function calls */
-  async post(functionName, body) {
-    return this.request(functionName, body, "POST");
+  async post(functionName, body, options = {}) {
+    return this.request(functionName, body, "POST", options);
   }
   /** Convenience wrapper for GET-based edge function calls with query params */
   async get(functionName, query = {}) {
@@ -280,10 +285,12 @@ var HttpClient = class {
     return this.accessTokenPromise;
   }
 };
-function requestIdempotencyKey(body) {
+function requestIdempotencyKey(body, automaticIdempotency) {
   const requested = typeof body.idempotency_key === "string" ? body.idempotency_key.trim() : "";
+  if (requested) return requested;
+  if (!automaticIdempotency) return void 0;
   const nonce = globalThis.crypto?.randomUUID?.() || `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  return requested || `sdk_${nonce}`;
+  return `sdk_${nonce}`;
 }
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
@@ -385,7 +392,7 @@ function mapMcpErrorType(error) {
 function mapErrorTypeFromCode(code) {
   if (!code) return "unknown";
   if (code === "RATE_LIMITED") return "rate_limited";
-  if (code === "INVALID_ARGUMENT" || code === "VALIDATION_ERROR" || code === "VALIDATION_001" || code === "SIGNAL_RUN_COMPANY_MISMATCH" || code === "APPROVAL_REQUIRED" || code === "WEBHOOK_APPROVAL_REQUIRED" || code === "TARGET_LIMIT_EXCEEDED") return "validation";
+  if (code === "INVALID_ARGUMENT" || code === "PAYLOAD_TOO_LARGE" || code === "VALIDATION_ERROR" || code === "VALIDATION_001" || code === "SIGNAL_RUN_COMPANY_MISMATCH" || code === "APPROVAL_REQUIRED" || code === "WEBHOOK_APPROVAL_REQUIRED" || code === "TARGET_LIMIT_EXCEEDED") return "validation";
   if (code === "AUTH_REQUIRED" || code === "AUTH_001") return "auth_expired";
   if (code === "QUOTA_EXCEEDED") return "insufficient_credits";
   if (code === "BUILD_NOT_READY" || code === "ARTIFACT_NOT_READY") return "not_found";
@@ -393,6 +400,166 @@ function mapErrorTypeFromCode(code) {
   return "unknown";
 }
 
+// src/email-validation.ts
+function isValidEmailString(value) {
+  if (typeof value !== "string") return false;
+  const email = value.trim();
+  if (!email || email.length > 254) return false;
+  const separator = email.indexOf("@");
+  if (separator <= 0 || separator !== email.lastIndexOf("@")) return false;
+  const local = email.slice(0, separator);
+  const domain = email.slice(separator + 1).toLowerCase();
+  if (local.length > 64 || domain.length > 253 || local.startsWith(".") || local.endsWith(".") || local.includes("..") || domain.startsWith(".") || domain.endsWith(".") || domain.includes("..")) return false;
+  if (!/^[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+$/.test(local)) return false;
+  const labels = domain.split(".");
+  if (labels.length < 2) return false;
+  return labels.every(
+    (label) => label.length > 0 && label.length <= 63 && /^[a-z0-9-]+$/.test(label) && !label.startsWith("-") && !label.endsWith("-")
+  );
+}
+
+// src/core-product-input-bounds.ts
+var LARGE_BATCH_MAX_ENCODED_BYTES = 8 * 1024 * 1024;
+var DOMAIN_MAX_UTF8_BYTES = 253;
+var NAME_MAX_UTF8_BYTES = 500;
+var TITLE_MAX_UTF8_BYTES = 500;
+var ID_MAX_UTF8_BYTES = 200;
+var RESEARCH_PROMPT_MAX_UTF8_BYTES = 2e3;
+var CAMPAIGN_OFFER_MAX_UTF8_BYTES = 4e3;
+var SIGNAL_TYPE_MAX_UTF8_BYTES = 100;
+var UTF8_ENCODER = new TextEncoder();
+function byteLength(value) {
+  return UTF8_ENCODER.encode(value).byteLength;
+}
+function payloadTooLarge(message, details) {
+  throw new SignalizError({
+    code: "PAYLOAD_TOO_LARGE",
+    message,
+    errorType: "validation",
+    details: {
+      ...details,
+      retry_eligible: false,
+      credits_used: 0,
+      credits_charged: 0
+    }
+  });
+}
+function assertStringBytes(value, field, maxBytes, index) {
+  if (typeof value !== "string") return;
+  const encodedBytes = byteLength(value);
+  if (encodedBytes <= maxBytes) return;
+  payloadTooLarge(
+    `${field} is ${encodedBytes} UTF-8 bytes; maximum is ${maxBytes} bytes`,
+    {
+      field,
+      ...index !== void 0 ? { index } : {},
+      encoded_bytes: encodedBytes,
+      max_bytes: maxBytes
+    }
+  );
+}
+function assertCompanySignalRows(body) {
+  const requests = Array.isArray(body.requests) ? body.requests : [];
+  assertStringBytes(
+    body.research_prompt,
+    "research_prompt",
+    RESEARCH_PROMPT_MAX_UTF8_BYTES
+  );
+  if (Array.isArray(body.signal_types)) {
+    body.signal_types.forEach(
+      (signalType, index) => assertStringBytes(
+        signalType,
+        `signal_types[${index}]`,
+        SIGNAL_TYPE_MAX_UTF8_BYTES,
+        index
+      )
+    );
+  }
+  requests.forEach((value, index) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return;
+    const request = value;
+    assertStringBytes(
+      request.company_domain,
+      `requests[${index}].company_domain`,
+      DOMAIN_MAX_UTF8_BYTES,
+      index
+    );
+    assertStringBytes(
+      request.company_name,
+      `requests[${index}].company_name`,
+      NAME_MAX_UTF8_BYTES,
+      index
+    );
+  });
+}
+function assertSignalCopyRows(body) {
+  const requests = Array.isArray(body.requests) ? body.requests : [];
+  requests.forEach((value, index) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return;
+    const request = value;
+    assertStringBytes(
+      request.company_domain,
+      `requests[${index}].company_domain`,
+      DOMAIN_MAX_UTF8_BYTES,
+      index
+    );
+    assertStringBytes(
+      request.person_name,
+      `requests[${index}].person_name`,
+      NAME_MAX_UTF8_BYTES,
+      index
+    );
+    assertStringBytes(
+      request.title,
+      `requests[${index}].title`,
+      TITLE_MAX_UTF8_BYTES,
+      index
+    );
+    assertStringBytes(
+      request.campaign_offer,
+      `requests[${index}].campaign_offer`,
+      CAMPAIGN_OFFER_MAX_UTF8_BYTES,
+      index
+    );
+    assertStringBytes(
+      request.research_prompt,
+      `requests[${index}].research_prompt`,
+      RESEARCH_PROMPT_MAX_UTF8_BYTES,
+      index
+    );
+    assertStringBytes(
+      request.signal_run_id,
+      `requests[${index}].signal_run_id`,
+      ID_MAX_UTF8_BYTES,
+      index
+    );
+  });
+}
+function assertLargeCoreProductInputBounds(path, body) {
+  const requests = Array.isArray(body.requests) ? body.requests : [];
+  if (requests.length <= 25) return;
+  assertStringBytes(body.idempotency_key, "idempotency_key", ID_MAX_UTF8_BYTES);
+  if (path === "api/v1/company-signals") {
+    assertCompanySignalRows(body);
+  } else {
+    assertSignalCopyRows(body);
+  }
+  const encoded = JSON.stringify(body);
+  if (typeof encoded !== "string") {
+    throw new TypeError("Core product batch input must be JSON serializable.");
+  }
+  const encodedBytes = byteLength(encoded);
+  if (encodedBytes <= LARGE_BATCH_MAX_ENCODED_BYTES) return;
+  payloadTooLarge(
+    `${path === "api/v1/company-signals" ? "Company Signal" : "Signal Copy"} batch request is ${encodedBytes} UTF-8 bytes after JSON encoding; maximum is ${LARGE_BATCH_MAX_ENCODED_BYTES} bytes`,
+    {
+      field: "requests",
+      encoded_bytes: encodedBytes,
+      max_bytes: LARGE_BATCH_MAX_ENCODED_BYTES
+    }
+  );
+}
+
 // src/index.ts
 var MAX_ROW_RATE_LIMIT_RETRIES = 2;
 var Signaliz = class {
@@ -426,9 +593,25 @@ var Signaliz = class {
       options
     );
   }
+  async resumeFindEmailBatch(jobId, options) {
+    const startedAt = Date.now();
+    const { rows, total } = await this.readRecoverableCoreBatchJob(
+      "api/v1/find-email",
+      jobId,
+      "Find Email",
+      options
+    );
+    return finalizeCoreBatch(
+      total,
+      startedAt,
+      recoverableRowsToRound(rows, "Find Email"),
+      (item) => normalizeFindEmailResult(item.raw),
+      options
+    );
+  }
   async verifyEmail(email, options) {
     const normalizedEmail = typeof email === "string" ? email.trim() : "";
-    if (options?.dryRun !== true && !options?.verificationRunId && normalizedEmail && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(normalizedEmail)) {
+    if (options?.dryRun !== true && !options?.verificationRunId && normalizedEmail && !isValidEmailString(normalizedEmail)) {
       const error = `Invalid email format: "${normalizedEmail}"`;
       return normalizeVerifyEmailResult(normalizedEmail, {
         success: false,
@@ -478,19 +661,20 @@ var Signaliz = class {
   }
   async verifyEmails(emails, options) {
     validateBatchSize(emails);
+    const requests = emails.map((email) => verifyEmailBatchRequestBody(email, options));
     if (options?.dryRun === true) {
       return this.runCoreProductDryRun(
         "api/v1/verify-email",
-        emails.map((email) => ({ email, skip_cache: options.skipCache })),
+        requests,
         options.idempotencyKey
       );
     }
     const startedAt = Date.now();
     const round = await this.runCoreBatchRound(
       "api/v1/verify-email",
-      emails.map((email, index) => ({
+      requests.map((request, index) => ({
         index,
-        request: { email, skip_cache: options?.skipCache }
+        request
       })),
       options
     );
@@ -498,7 +682,23 @@ var Signaliz = class {
       emails.length,
       startedAt,
       round,
-      (item) => normalizeVerifyEmailResult(emails[item.index], item.raw),
+      (item) => normalizeVerifyEmailResult(String(requests[item.index].email ?? ""), item.raw),
+      options
+    );
+  }
+  async resumeVerifyEmailBatch(jobId, options) {
+    const startedAt = Date.now();
+    const { rows, total } = await this.readRecoverableCoreBatchJob(
+      "api/v1/verify-email",
+      jobId,
+      "Verify Email",
+      options
+    );
+    return finalizeCoreBatch(
+      total,
+      startedAt,
+      recoverableRowsToRound(rows, "Verify Email"),
+      (item) => normalizeVerifyEmailResult(String(item.raw?.email || ""), item.raw),
       options
     );
   }
@@ -514,25 +714,92 @@ var Signaliz = class {
     validateSignalDiscoveryParams(params);
     const data = await this.client.post(
       "api/v1/signals",
-      signalDiscoveryRequestBody(params)
+      signalDiscoveryRequestBody(params),
+      // Signals Everything owns a normalized, workspace-scoped automatic key
+      // at the API boundary so SDK, CLI, MCP, and direct REST calls coalesce.
+      { automaticIdempotency: false }
     );
     return normalizeSignalDiscoveryResult(params, data);
   }
   async enrichCompanies(companies, options) {
     validateBatchSize(companies);
     companies.forEach((params) => validateCoreProductMaxWaitMs(params.maxWaitMs));
+    const requests = companies.map(companySignalRequestBody);
+    if (companies.length > 25 && requests.some((request) => request.include_candidate_evidence === true)) {
+      throw new RangeError(
+        "includeCandidateEvidence is not supported in Company Signals batches larger than 25 because rejected evidence diagnostics are intentionally excluded from durable scale storage; split diagnostic requests into batches of at most 25."
+      );
+    }
+    const largeBatch = companySignalLargeBatchSubmission(requests);
+    if (companies.length > 25 && !largeBatch) {
+      throw new RangeError(
+        "Company Signals batches larger than 25 require homogeneous new-enrichment rows with company identity only and uniform controls; split recovery or mixed-control rows into batches of at most 25."
+      );
+    }
     if (options?.dryRun === true) {
       return this.runCoreProductDryRun(
         "api/v1/company-signals",
-        companies.map(companySignalRequestBody),
-        options.idempotencyKey
+        largeBatch?.requests || requests,
+        options.idempotencyKey,
+        largeBatch?.submissionFields
       );
     }
     const startedAt = Date.now();
-    const initialTasks = companies.map((params, index) => ({
-      index,
-      request: companySignalRequestBody(params)
-    }));
+    if (options?.waitForResult === false) {
+      if (!largeBatch) {
+        throw new RangeError(
+          "Company Signals --no-wait requires more than 25 homogeneous new-enrichment rows; recovery reads and mixed controls must use batches of at most 25."
+        );
+      }
+      return this.submitRecoverableCoreBatchJob(
+        "api/v1/company-signals",
+        largeBatch.requests,
+        "Company Signals",
+        options.idempotencyKey,
+        companies.map((_, index) => index),
+        largeBatch.submissionFields
+      );
+    }
+    if (largeBatch) {
+      const job = await this.submitRecoverableCoreBatchJob(
+        "api/v1/company-signals",
+        largeBatch.requests,
+        "Company Signals",
+        options?.idempotencyKey,
+        companies.map((_, index) => index),
+        largeBatch.submissionFields
+      );
+      const { rows, total } = await this.readRecoverableCoreBatchJob(
+        "api/v1/company-signals",
+        job.jobId,
+        "Company Signals",
+        {
+          pageSize: 25,
+          maxWaitMs: options?.maxWaitMs,
+          pollIntervalMs: options?.pollIntervalMs,
+          idempotencyKey: job.idempotencyKey,
+          compactDuplicates: options?.compactDuplicates === true
+        }
+      );
+      if (total !== companies.length) {
+        throw new Error(`Company Signals batch returned ${total} results for ${companies.length} requests`);
+      }
+      const batch = finalizeCoreBatch(
+        companies.length,
+        startedAt,
+        recoverableRowsToRound(rows, "Company Signals"),
+        (item) => normalizeCompanySignalResult(companies[item.index], item.raw)
+      );
+      return compactKnownDuplicateBatch(
+        batch,
+        dedupeExactBatchItems(
+          requests,
+          (request) => coreProductBatchRequestKey("api/v1/company-signals", request)
+        ).sourceIndexByInput,
+        options?.compactDuplicates === true
+      );
+    }
+    const initialTasks = requests.map((request, index) => ({ index, request }));
     const round = await this.runCoreBatchRound("api/v1/company-signals", initialTasks, options);
     const results = round.map((item) => {
       if (!item.success || !item.raw) {
@@ -555,6 +822,22 @@ var Signaliz = class {
       results: compactedResults
     };
   }
+  async resumeCompanySignalBatch(jobId, options) {
+    const startedAt = Date.now();
+    const { rows, total } = await this.readRecoverableCoreBatchJob(
+      "api/v1/company-signals",
+      jobId,
+      "Company Signals",
+      options
+    );
+    return finalizeRecoveredCoreBatch(
+      total,
+      startedAt,
+      recoverableRowsToRound(rows, "Company Signals"),
+      (item) => normalizeCompanySignalResult(companySignalParamsFromRecoveredRow(item.raw), item.raw),
+      options
+    );
+  }
   async signalToCopy(params) {
     validateSignalToCopyParams(params);
     const request = signalToCopyRequestBody(params);
@@ -566,6 +849,7 @@ var Signaliz = class {
   async createSignalCopyBatch(requests, options) {
     validateBatchSize(requests);
     requests.forEach(validateSignalToCopyParams);
+    validateLargeAvailableDataSignalCopyBatch(requests);
     if (options?.dryRun === true) {
       return this.runCoreProductDryRun(
         "api/v1/signal-to-copy",
@@ -574,6 +858,59 @@ var Signaliz = class {
       );
     }
     const startedAt = Date.now();
+    if (requests.length > 25) {
+      if (options?.waitForResult === false) {
+        return this.submitRecoverableCoreBatchJob(
+          "api/v1/signal-to-copy",
+          requests.map(availableDataSignalCopyRequestBody),
+          "Signal to Copy",
+          options.idempotencyKey,
+          requests.map((_, index) => index)
+        );
+      }
+      const job = await this.submitRecoverableCoreBatchJob(
+        "api/v1/signal-to-copy",
+        requests.map(availableDataSignalCopyRequestBody),
+        "Signal to Copy",
+        options?.idempotencyKey,
+        requests.map((_, index) => index)
+      );
+      const { rows, total } = await this.readRecoverableCoreBatchJob(
+        "api/v1/signal-to-copy",
+        job.jobId,
+        "Signal to Copy",
+        {
+          pageSize: 100,
+          maxWaitMs: options?.maxWaitMs,
+          pollIntervalMs: options?.pollIntervalMs,
+          idempotencyKey: job.idempotencyKey,
+          compactDuplicates: options?.compactDuplicates === true
+        }
+      );
+      if (total !== requests.length) {
+        throw new Error(`Signal to Copy batch returned ${total} results for ${requests.length} requests`);
+      }
+      const results2 = recoverableSignalCopyRows(rows);
+      const succeeded2 = results2.filter((item) => item.success).length;
+      const batch = {
+        total: requests.length,
+        succeeded: succeeded2,
+        failed: requests.length - succeeded2,
+        durationMs: Date.now() - startedAt,
+        results: results2
+      };
+      return compactKnownDuplicateBatch(
+        batch,
+        dedupeExactBatchItems(
+          requests,
+          (params) => coreProductBatchRequestKey("api/v1/signal-to-copy", signalToCopyRequestBody(params))
+        ).sourceIndexByInput,
+        options?.compactDuplicates === true
+      );
+    }
+    if (options?.waitForResult === false) {
+      throw new RangeError("Signal to Copy --no-wait requires a durable batch of more than 25 rows.");
+    }
     const deduplicated = dedupeExactBatchItems(
       requests,
       (params) => coreProductBatchRequestKey("api/v1/signal-to-copy", signalToCopyRequestBody(params))
@@ -598,12 +935,36 @@ var Signaliz = class {
       results: compactedResults
     };
   }
-  async runCoreProductDryRun(path, requests, idempotencyKey) {
-    const data = await this.client.post(path, compact({
+  async resumeSignalCopyBatch(jobId, options) {
+    const startedAt = Date.now();
+    const { rows, total } = await this.readRecoverableCoreBatchJob(
+      "api/v1/signal-to-copy",
+      jobId,
+      "Signal to Copy",
+      options
+    );
+    const results = recoverableSignalCopyRows(rows);
+    const compactedResults = compactExactDuplicateResults(results, options?.compactDuplicates === true);
+    const succeeded = compactedResults.filter((item) => item.success).length;
+    return {
+      total,
+      succeeded,
+      failed: total - succeeded,
+      durationMs: Date.now() - startedAt,
+      results: compactedResults
+    };
+  }
+  async runCoreProductDryRun(path, requests, idempotencyKey, defaults = {}) {
+    const requestBody = compact({
       requests,
+      ...defaults,
       dry_run: true,
       idempotency_key: idempotencyKey
-    }));
+    });
+    if (path === "api/v1/company-signals" || path === "api/v1/signal-to-copy") {
+      assertLargeCoreProductInputBounds(path, requestBody);
+    }
+    const data = await this.client.post(path, requestBody);
     if (!isCoreProductDryRun(data)) {
       throw new Error(`${path} dry run returned a live-result contract`);
     }
@@ -649,76 +1010,206 @@ var Signaliz = class {
     }
     return uniqueResults;
   }
-  async runRecoverableCoreBatchJob(path, requests, label, pageSize = 500, maxWaitMs = 20 * 6e4, idempotencyKey, idempotencyItemIndices) {
-    const startedAt = Date.now();
+  async runRecoverableCoreBatchJob(path, requests, label, pageSize = 500, maxWaitMs = 20 * 6e4, pollIntervalMs, idempotencyKey, idempotencyItemIndices, submissionFields = {}) {
+    validateCoreBatchPollingOptions({ maxWaitMs, pollIntervalMs });
+    const job = await this.submitRecoverableCoreBatchJob(
+      path,
+      requests,
+      label,
+      idempotencyKey,
+      idempotencyItemIndices,
+      submissionFields
+    );
+    const recovered = await this.readRecoverableCoreBatchJob(path, job.jobId, label, {
+      pageSize,
+      maxWaitMs,
+      pollIntervalMs,
+      idempotencyKey: job.idempotencyKey
+    });
+    if (recovered.total !== requests.length) {
+      throw new Error(`${label} batch returned ${recovered.total} results for ${requests.length} requests`);
+    }
+    return recovered.rows;
+  }
+  async submitRecoverableCoreBatchJob(path, requests, label, idempotencyKey, idempotencyItemIndices, submissionFields = {}) {
     const submissionIdempotencyKey = idempotencyKey?.trim() || newBatchIdempotencyKey(label);
+    const requestBody = {
+      ...submissionFields,
+      requests,
+      idempotency_key: submissionIdempotencyKey,
+      batch_item_indices: idempotencyItemIndices
+    };
+    if (path === "api/v1/company-signals" || path === "api/v1/signal-to-copy") {
+      assertLargeCoreProductInputBounds(path, requestBody);
+    }
     let submission;
     try {
-      submission = await this.client.post(path, {
-        requests,
-        idempotency_key: submissionIdempotencyKey,
-        batch_item_indices: idempotencyItemIndices
-      });
+      submission = await this.client.post(path, requestBody);
     } catch (error) {
       if (error instanceof SignalizError && !error.isRetryable) throw error;
       const message = error instanceof Error ? error.message : String(error);
-      throw new Error(
-        `${label} batch submission was not confirmed. Retry with idempotency key "${submissionIdempotencyKey}" to recover the same job. ${message}`
-      );
+      throw new SignalizError({
+        code: "BATCH_SUBMISSION_UNCONFIRMED",
+        message: `${label} batch submission was not confirmed. Retry with idempotency key "${submissionIdempotencyKey}" to recover the same job. ${message}`,
+        errorType: "provider_error",
+        details: {
+          idempotency_key: submissionIdempotencyKey,
+          suggested_action: "retry_with_idempotency_key",
+          retry_eligible: true
+        }
+      });
     }
     const jobId = String(submission.job_id || "").trim();
-    if (!jobId) throw new Error(`${label} batch did not return a recoverable job_id`);
-    let status = await this.client.post(path, {
-      job_id: jobId,
-      page: 1,
-      page_size: pageSize
-    });
-    while (!["completed", "partial", "failed"].includes(String(status.status || "").toLowerCase())) {
-      if (Date.now() - startedAt >= maxWaitMs) {
-        throw new Error(`${label} batch ${jobId} did not complete within ${maxWaitMs}ms`);
-      }
-      const retryAfterMs = Number(status.next_poll_after_seconds || 2) * 1e3;
-      await sleep2(Math.min(Math.max(250, retryAfterMs), maxWaitMs - (Date.now() - startedAt)));
-      status = await this.client.post(path, {
+    if (!jobId) {
+      throw new SignalizError({
+        code: "INVALID_JOB_RESPONSE",
+        message: `${label} batch did not return a recoverable job_id`,
+        errorType: "provider_error",
+        details: {
+          idempotency_key: submissionIdempotencyKey,
+          suggested_action: "retry_with_idempotency_key",
+          retry_eligible: true
+        }
+      });
+    }
+    const submissionStatus = String(submission.status || "").toLowerCase();
+    const status = ["queued", "processing", "completed", "partial", "failed"].includes(submissionStatus) ? submissionStatus : "queued";
+    return {
+      success: true,
+      status,
+      capability: path === "api/v1/company-signals" ? "company_signals" : "signal_to_copy",
+      jobId,
+      idempotencyKey: String(submission.idempotency_key || submissionIdempotencyKey),
+      total: Math.max(0, Number(submission.total ?? submission.items_total ?? requests.length)),
+      ...Number.isFinite(Number(submission.next_poll_after_seconds)) ? {
+        nextPollAfterSeconds: Number(submission.next_poll_after_seconds)
+      } : {}
+    };
+  }
+  async readRecoverableCoreBatchJob(path, jobIdInput, label, options = {}) {
+    const jobId = String(jobIdInput || "").trim();
+    if (!jobId) throw new RangeError(`${label} jobId is required`);
+    if (options.pageSize !== void 0 && (!Number.isFinite(options.pageSize) || options.pageSize <= 0)) {
+      throw new RangeError("pageSize must be a positive finite number");
+    }
+    validateCoreBatchPollingOptions(options);
+    const maximumPageSize = path === "api/v1/signal-to-copy" ? 100 : 25;
+    const pageSize = Math.min(maximumPageSize, Math.max(1, Math.trunc(options.pageSize ?? maximumPageSize)));
+    const emailJob = path === "api/v1/find-email" || path === "api/v1/verify-email";
+    const maxWaitMs = options.maxWaitMs ?? (emailJob ? 20 * 6e4 : void 0);
+    const startedAt = Date.now();
+    let observedIdempotencyKey = String(options.idempotencyKey || "").trim();
+    try {
+      let status = await this.client.post(path, {
         job_id: jobId,
         page: 1,
-        page_size: pageSize
+        page_size: pageSize,
+        compact_duplicates: options.compactDuplicates === true
       });
-    }
-    const totalPages = Math.max(1, Number(status.total_pages || 1));
-    const pages = [Array.isArray(status.results) ? status.results : []];
-    if (totalPages > 1) {
-      const pageNumbers = Array.from({ length: totalPages - 1 }, (_, index) => index + 2);
-      const remainingPages = await runBatch(
-        pageNumbers,
-        async (page) => await this.client.post(path, {
-          job_id: jobId,
-          page,
-          page_size: pageSize
-        }),
-        { concurrency: Math.min(10, pageNumbers.length) }
+      observedIdempotencyKey = String(status.idempotency_key || observedIdempotencyKey).trim();
+      assertRecoverableBatchResultsRetained(
+        status,
+        label,
+        jobId,
+        observedIdempotencyKey
       );
-      for (const page of remainingPages.results) {
-        if (!page.success || !page.data) {
-          throw new Error(`${label} batch result page ${page.index + 2} failed: ${page.error || "unknown error"}`);
+      while (!["completed", "partial", "failed"].includes(String(status.status || "").toLowerCase())) {
+        if (maxWaitMs !== void 0 && Date.now() - startedAt >= maxWaitMs) {
+          throw new SignalizError({
+            code: "TIMEOUT",
+            message: `${label} batch ${jobId} did not complete within ${maxWaitMs}ms`,
+            errorType: "timeout",
+            retryAfter: Number(status.next_poll_after_seconds || 2),
+            details: {
+              job_id: jobId,
+              ...observedIdempotencyKey ? { idempotency_key: observedIdempotencyKey } : {},
+              suggested_action: "check_job_status",
+              retry_eligible: true
+            }
+          });
         }
-        pages.push(Array.isArray(page.data.results) ? page.data.results : []);
+        const retryAfterMs = options.pollIntervalMs ?? Number(status.next_poll_after_seconds || 2) * 1e3;
+        const boundedDelay = maxWaitMs === void 0 ? Math.max(250, retryAfterMs) : Math.min(Math.max(250, retryAfterMs), maxWaitMs - (Date.now() - startedAt));
+        await sleep2(boundedDelay);
+        status = await this.client.post(path, {
+          job_id: jobId,
+          page: 1,
+          page_size: pageSize,
+          compact_duplicates: options.compactDuplicates === true
+        });
+        observedIdempotencyKey = String(status.idempotency_key || observedIdempotencyKey).trim();
+        assertRecoverableBatchResultsRetained(
+          status,
+          label,
+          jobId,
+          observedIdempotencyKey
+        );
       }
-    }
-    const rows = pages.flat();
-    if (rows.length !== requests.length) {
-      throw new Error(`${label} batch returned ${rows.length} results for ${requests.length} requests`);
-    }
-    const seen = /* @__PURE__ */ new Set();
-    for (const row of rows) {
-      const index = Number(row.index);
-      if (!Number.isInteger(index) || index < 0 || index >= requests.length || seen.has(index)) {
-        throw new Error(`${label} batch returned an invalid result index`);
+      const totalPages = Math.max(1, Number(status.total_pages || 1));
+      const pages = [Array.isArray(status.results) ? status.results : []];
+      if (totalPages > 1) {
+        const pageNumbers = Array.from({ length: totalPages - 1 }, (_, index) => index + 2);
+        const remainingPages = await runBatch(
+          pageNumbers,
+          async (page) => await this.client.post(path, {
+            job_id: jobId,
+            page,
+            page_size: pageSize,
+            compact_duplicates: options.compactDuplicates === true
+          }),
+          { concurrency: Math.min(10, pageNumbers.length) }
+        );
+        for (const page of remainingPages.results) {
+          if (!page.success || !page.data) {
+            throw new Error(`${label} batch result page ${page.index + 2} failed: ${page.error || "unknown error"}`);
+          }
+          observedIdempotencyKey = String(
+            page.data.idempotency_key || observedIdempotencyKey
+          ).trim();
+          assertRecoverableBatchResultsRetained(
+            page.data,
+            label,
+            jobId,
+            observedIdempotencyKey
+          );
+          pages.push(Array.isArray(page.data.results) ? page.data.results : []);
+        }
+      }
+      const rows = pages.flat();
+      const total = Math.max(0, Number(status.total_results ?? status.total ?? status.items_total ?? rows.length));
+      if (rows.length !== total) {
+        throw new Error(`${label} batch returned ${rows.length} results for ${total} job rows`);
+      }
+      const seen = /* @__PURE__ */ new Set();
+      for (const row of rows) {
+        const index = Number(row.index);
+        if (!Number.isInteger(index) || index < 0 || seen.has(index)) {
+          throw new Error(`${label} batch returned an invalid result index`);
+        }
+        seen.add(index);
+      }
+      if (seen.size !== total) throw new Error(`${label} batch returned incomplete indexed results`);
+      return { rows, total };
+    } catch (error) {
+      if (error instanceof SignalizError && String(error.details?.job_id || "") === jobId) {
+        throw error;
       }
-      seen.add(index);
+      const signalizError = error instanceof SignalizError ? error : null;
+      const message = error instanceof Error ? error.message : String(error);
+      throw new SignalizError({
+        code: signalizError?.code || "BATCH_RECOVERY_FAILED",
+        message: `${label} batch ${jobId} could not be fully retrieved. Resume the existing job instead of resubmitting it. ${message}`,
+        errorType: signalizError?.errorType || "provider_error",
+        retryAfter: signalizError?.retryAfter,
+        details: {
+          ...signalizError?.details || {},
+          job_id: jobId,
+          ...observedIdempotencyKey ? { idempotency_key: observedIdempotencyKey } : {},
+          suggested_action: "check_job_status",
+          retry_eligible: true
+        }
+      });
     }
-    if (seen.size !== requests.length) throw new Error(`${label} batch returned incomplete indexed results`);
-    return rows;
   }
   async runSignalCopyBatchChunk(requests, concurrency, rowRateLimitAttempt = 0, idempotencyKey, idempotencyItemIndices = requests.map((_, index) => index)) {
     const results = new Array(requests.length);
@@ -783,17 +1274,18 @@ var Signaliz = class {
       (task) => coreProductBatchRequestKey(path, task.request)
     );
     const uniqueTasks = deduplicated.uniqueItems;
-    const recoverableBatch = path === "api/v1/find-email" ? { label: "Find Email", pageSize: 500, maxWaitMs: 20 * 6e4 } : path === "api/v1/verify-email" ? { label: "Verify Email", pageSize: 500, maxWaitMs: 20 * 6e4 } : void 0;
+    const recoverableBatch = path === "api/v1/find-email" ? { label: "Find Email", pageSize: 25, maxWaitMs: 20 * 6e4 } : path === "api/v1/verify-email" ? { label: "Verify Email", pageSize: 25, maxWaitMs: 20 * 6e4 } : void 0;
     const containsFindRecoveryReads = path === "api/v1/find-email" && uniqueTasks.some(
       (task) => typeof task.request.run_id === "string" && task.request.run_id.trim()
     );
-    if (path !== "api/v1/company-signals" && recoverableBatch && uniqueTasks.length > 25 && !containsFindRecoveryReads) {
+    if (recoverableBatch && uniqueTasks.length > 25 && !containsFindRecoveryReads) {
       const rows = await this.runRecoverableCoreBatchJob(
         path,
         uniqueTasks.map((task) => task.request),
         recoverableBatch.label,
         recoverableBatch.pageSize,
-        recoverableBatch.maxWaitMs,
+        options?.maxWaitMs ?? recoverableBatch.maxWaitMs,
+        options?.pollIntervalMs,
         options?.idempotencyKey,
         uniqueTasks.map((task) => task.index)
       );
@@ -916,7 +1408,7 @@ function batchItemFailure(index, error, raw) {
   const retryStrategy = raw?.retry_strategy ?? raw?.retryStrategy;
   const creditsUsed = raw?.credits_used ?? raw?.creditsUsed;
   const creditsCharged = raw?.credits_charged ?? raw?.creditsCharged;
-  const runId = raw?.run_id ?? raw?.runId;
+  const runId = [raw?.run_id, raw?.runId, raw?.signal_run_id, raw?.signalRunId].find((value) => typeof value === "string" && value.trim());
   const verificationRunId = raw?.verification_run_id ?? raw?.verificationRunId;
   const jobId = raw?.job_id ?? raw?.jobId;
   const suggestedAction = raw?.suggested_action ?? raw?.suggestedAction;
@@ -939,6 +1431,42 @@ function batchItemFailure(index, error, raw) {
 function recoverableJobRowFailed(row) {
   return coreProductResponseFailed(row) || ["failed", "skipped"].includes(String(row._status || "").toLowerCase());
 }
+function recoverableRowsToRound(rows, label) {
+  return rows.map((raw) => {
+    const index = Number(raw.index);
+    const failed = recoverableJobRowFailed(raw);
+    return {
+      index,
+      success: !failed,
+      raw,
+      error: failed ? raw.error || raw._error || raw.message || raw.failure_reason || `${label} item failed` : void 0
+    };
+  });
+}
+function recoverableSignalCopyRows(rows) {
+  return rows.map((raw) => {
+    const index = Number(raw.index);
+    const duplicateOf = recoveredDuplicateOf(raw);
+    if (duplicateOf !== void 0) return { index, success: true, duplicateOf };
+    if (recoverableJobRowFailed(raw)) {
+      return batchItemFailure(
+        index,
+        raw.error || raw._error || raw.message || "Signal to Copy item failed",
+        raw
+      );
+    }
+    try {
+      assertTerminalSignalResponse(raw, "Signal to Copy");
+      return { index, success: true, data: normalizeSignalToCopyResult(raw) };
+    } catch (error) {
+      return batchItemFailure(index, error instanceof Error ? error.message : String(error), raw);
+    }
+  });
+}
+function recoveredDuplicateOf(raw) {
+  const value = Number(raw.duplicate_of ?? raw.duplicateOf ?? raw._duplicate_of);
+  return Number.isInteger(value) && value >= 0 ? value : void 0;
+}
 function newBatchIdempotencyKey(label) {
   const nonce = globalThis.crypto?.randomUUID?.() || `${Date.now()}-${Math.random().toString(16).slice(2)}`;
   return `signaliz-${label.toLowerCase().replace(/[^a-z0-9]+/g, "-")}-${nonce}`;
@@ -960,6 +1488,16 @@ function findEmailRequestBody(params) {
     idempotency_key: params.idempotencyKey
   });
 }
+function verifyEmailBatchRequestBody(input, options) {
+  if (typeof input === "string") {
+    return compact({ email: input, skip_cache: options?.skipCache });
+  }
+  return compact({
+    email: input.email,
+    skip_cache: input.skipCache ?? options?.skipCache,
+    idempotency_key: input.idempotencyKey
+  });
+}
 function isCoreProductDryRun(data) {
   return data.dry_run === true && data.status === "planned";
 }
@@ -994,12 +1532,17 @@ function normalizeFindEmailResult(data) {
   const email = failed ? null : rawEmail;
   const found = Boolean(email) && data.found !== false;
   const verificationStatus = data.verification_status ?? (data.is_valid === true ? "valid" : data.status ?? "unknown");
+  const deliverabilityStatus = data.deliverability_status ?? verificationStatus;
+  const verificationVerdict = data.verification_verdict ?? verificationStatus;
   const rawFreshness = String(data.verification_freshness ?? "").toLowerCase();
   const verificationFreshness = rawFreshness === "fresh" || rawFreshness === "stale" ? rawFreshness : "unknown";
   const needsReverification = data.needs_reverification === true || verificationFreshness === "stale";
   const explicitlyNotSendSafe = data.verified_for_sending === false || needsReverification;
   const verified = !explicitlyNotSendSafe && (data.is_valid === true || data.isValid === true || data.email_verified === true || data.verified_for_sending === true || ["valid", "deliverable"].includes(String(verificationStatus).toLowerCase()));
   const verificationAgeDays = typeof data.verification_age_days === "number" && Number.isFinite(data.verification_age_days) ? data.verification_age_days : null;
+  const providerUsed = data.provider_used ?? data.provider ?? data.email_source ?? data.source ?? "unknown";
+  const verificationSource = data.verification_source ?? providerUsed;
+  const billingMetadata = data.billing_metadata && typeof data.billing_metadata === "object" && !Array.isArray(data.billing_metadata) ? data.billing_metadata : void 0;
   return {
     success: processing || !failed && found,
     found,
@@ -1008,61 +1551,86 @@ function normalizeFindEmailResult(data) {
     lastName: data.last_name,
     confidence: failed ? 0 : data.confidence ?? data.confidence_score ?? (verified ? 1 : 0),
     verificationStatus: failed ? "error" : verificationStatus,
+    deliverabilityStatus: failed ? "error" : deliverabilityStatus,
+    verificationVerdict: failed ? "error" : verificationVerdict,
     isVerified: !failed && verified,
     isVerifiedForSending: !failed && !needsReverification && data.verified_for_sending === true,
+    isDeliverable: !failed && !needsReverification && data.verified_for_sending === true,
     isCatchAll: data.email_is_catch_all === true || data.is_catch_all === true,
     verificationFreshness,
     verificationAgeDays,
     verifiedAt: typeof data.verified_at === "string" ? data.verified_at : null,
     needsReverification: failed || needsReverification,
-    providerUsed: data.provider_used ?? data.provider ?? data.email_source ?? data.source ?? "unknown",
-    creditsUsed: data.credits_used,
-    estimatedExternalCostUsd: data.estimated_external_cost_usd,
-    billingMetadata: data.billing_metadata,
-    resultReturnedFrom: data.result_returned_from,
-    cacheHit: data.cache_hit,
+    providerUsed,
+    verificationSource,
+    verificationObservedAt: typeof data.verification_observed_at === "string" ? data.verification_observed_at : void 0,
+    failureReason: data.failure_reason ?? (failed || !found ? "no_verified_email_found" : "none"),
+    creditsUsed: data.credits_used ?? billingMetadata?.credits_used,
+    estimatedExternalCostUsd: data.estimated_external_cost_usd ?? billingMetadata?.estimated_external_cost_usd,
+    billingMetadata,
+    historicalBillingMetadata: data.historical_billing_metadata,
+    resultReturnedFrom: data.result_returned_from ?? billingMetadata?.result_returned_from,
+    cacheHit: typeof data.cache_hit === "boolean" ? data.cache_hit : billingMetadata?.cache_hit,
     negativeCacheHit: data.negative_cache_hit,
     negativeCacheTtlSeconds: data.negative_cache_ttl_seconds,
     cacheTier: data.cache_tier,
-    freshEnrichmentUsed: data.fresh_enrichment_used,
-    liveProviderCalled: data.live_provider_called,
-    openrouterCalled: data.openrouter_called,
-    byoOpenrouterUsed: data.byo_openrouter_used,
+    freshEnrichmentUsed: typeof data.fresh_enrichment_used === "boolean" ? data.fresh_enrichment_used : billingMetadata?.fresh_enrichment_used,
+    liveProviderCalled: typeof data.live_provider_called === "boolean" ? data.live_provider_called : billingMetadata?.live_provider_called,
+    openrouterCalled: typeof data.openrouter_called === "boolean" ? data.openrouter_called : billingMetadata?.openrouter_called,
+    byoOpenrouterUsed: typeof data.byo_openrouter_used === "boolean" ? data.byo_openrouter_used : billingMetadata?.byo_openrouter_used,
     error: processing || found ? void 0 : coreProductErrorMessage(data) ?? "No verified email found",
     errorCode: processing || found ? void 0 : coreProductErrorCode(data) ?? "EMAIL_NOT_FOUND",
     status: processing ? "processing" : "completed",
     runId: data.run_id,
     nextPollAfterSeconds: data.next_poll_after_seconds,
     suggestedAction: data.suggested_action,
+    cachePublicationStatus: data.cache_publication_status,
+    cachePublicationRetryEligible: data.cache_publication_retry_eligible,
     raw: data
   };
 }
 function normalizeVerifyEmailResult(email, data) {
   const failed = coreProductResponseFailed(data);
-  const verificationStatus = String(data.verification_status ?? "").toLowerCase();
-  const verified = !failed && (data.email_verified === true || ["valid", "deliverable"].includes(verificationStatus));
   const malformed = data.is_malformed === true || data.verification_verdict === "malformed" || data.verification_status === "malformed" || data.deliverability_status === "malformed";
+  const verificationStatus = String(
+    failed ? malformed ? "malformed" : "error" : data.verification_status ?? data.verification_verdict ?? data.deliverability_status ?? "unknown"
+  ).toLowerCase();
+  const deliverabilityStatus = String(data.deliverability_status ?? verificationStatus).toLowerCase();
+  const verified = !failed && (data.email_verified === true || ["valid", "deliverable"].includes(verificationStatus));
+  const isCatchAll = data.email_is_catch_all ?? data.is_catch_all ?? data.catch_all ?? data.diagnostics?.is_catch_all ?? false;
+  const verifiedForSending = !failed && data.verified_for_sending === true;
+  const verificationRunId = data.verification_run_id ?? data.run_id;
   return {
     success: !failed,
     error: failed ? coreProductErrorMessage(data) : void 0,
     errorCode: failed ? coreProductErrorCode(data) : void 0,
     email: data.email ?? email,
     status: !failed && String(data.status || "").toLowerCase() === "processing" ? "processing" : "completed",
-    verificationRunId: data.verification_run_id ?? data.run_id,
+    verificationRunId,
     retryAfterMs: data.retry_after_ms,
     nextPollAfterSeconds: data.next_poll_after_seconds,
     isValid: failed ? false : data.is_valid ?? data.valid ?? verified,
     isDeliverable: failed ? false : data.is_deliverable ?? data.deliverable ?? verified,
     isMalformed: malformed,
-    isCatchAll: data.email_is_catch_all ?? data.is_catch_all ?? data.catch_all ?? data.diagnostics?.is_catch_all ?? false,
-    verifiedForSending: !failed && data.verified_for_sending === true,
+    isCatchAll,
+    verifiedForSending,
+    verificationStatus,
+    deliverabilityStatus,
     verificationVerdict: failed ? malformed ? "malformed" : "error" : data.verification_verdict ?? data.verification_status ?? "unknown",
+    isRoleAccount: data.is_role_account === true || data.email_is_role_account === true || data.role === true,
+    quality: typeof data.quality === "string" ? data.quality : null,
+    recommendation: typeof data.recommendation === "string" ? data.recommendation : verifiedForSending ? "send" : ["unknown", "verifier_error"].includes(verificationStatus) ? "manual_review" : "do_not_send",
+    smtpStatus: data.smtp_status ?? (isCatchAll ? "accept_all" : verifiedForSending ? "accepted" : "not_checked"),
+    providerStatus: data.provider_status ?? verificationStatus,
+    failureReason: data.failure_reason ?? (verifiedForSending ? "none" : isCatchAll ? "catch_all_domain_not_send_safe" : "verification_not_send_safe"),
     confidenceScore: failed ? 0 : data.confidence_score ?? data.confidence ?? data.diagnostics?.confidence_score ?? (verified ? 1 : 0),
     provider: data.provider,
     verificationSource: data.verification_source,
+    verificationObservedAt: typeof data.verification_observed_at === "string" ? data.verification_observed_at : void 0,
     billingReplayed: data.billing_replayed,
     creditsUsed: data.credits_used,
     billingMetadata: data.billing_metadata,
+    historicalBillingMetadata: data.historical_billing_metadata,
     resultReturnedFrom: data.result_returned_from,
     cacheHit: data.cache_hit,
     negativeCacheHit: data.negative_cache_hit,
@@ -1072,6 +1640,11 @@ function normalizeVerifyEmailResult(email, data) {
     liveProviderCalled: data.live_provider_called,
     openrouterCalled: data.openrouter_called,
     byoOpenrouterUsed: data.byo_openrouter_used,
+    estimatedExternalCostUsd: data.estimated_external_cost_usd,
+    runId: data.run_id ?? verificationRunId,
+    cachePublicationStatus: data.cache_publication_status,
+    cachePublicationRetryEligible: data.cache_publication_retry_eligible,
+    suggestedAction: data.suggested_action,
     raw: data
   };
 }
@@ -1099,6 +1672,54 @@ function companySignalRequestBody(params) {
     idempotency_key: params.idempotencyKey
   });
 }
+function companySignalParamsFromRecoveredRow(row) {
+  return {
+    companyDomain: row.company?.domain ?? row.company_domain,
+    companyName: row.company?.name ?? row.company_name,
+    signalRunId: row.signal_run_id ?? row.run_id
+  };
+}
+var COMPANY_SIGNAL_LARGE_BATCH_CONTROL_FIELDS = [
+  "research_prompt",
+  "signal_types",
+  "target_signal_count",
+  "lookback_days",
+  "online",
+  "enable_deep_search",
+  "search_mode",
+  "include_summary",
+  "enable_outreach_intelligence",
+  "enable_predictive_intelligence",
+  "skip_cache",
+  "include_candidate_evidence"
+];
+function companySignalLargeBatchSubmission(requests) {
+  if (requests.length <= 25) return null;
+  if (requests.some(
+    (request) => typeof request.signal_run_id === "string" && request.signal_run_id.trim() || typeof request.idempotency_key === "string" && request.idempotency_key.trim()
+  )) {
+    return null;
+  }
+  const submissionFields = Object.fromEntries(
+    COMPANY_SIGNAL_LARGE_BATCH_CONTROL_FIELDS.filter((field) => requests[0]?.[field] !== void 0).map((field) => [field, requests[0][field]])
+  );
+  const controlKey = JSON.stringify(submissionFields);
+  for (const request of requests) {
+    const requestControls = Object.fromEntries(
+      COMPANY_SIGNAL_LARGE_BATCH_CONTROL_FIELDS.filter((field) => request[field] !== void 0).map((field) => [field, request[field]])
+    );
+    if (JSON.stringify(requestControls) !== controlKey) return null;
+    const hasIdentity = typeof request.company_domain === "string" && request.company_domain.trim() || typeof request.company_name === "string" && request.company_name.trim();
+    if (!hasIdentity) return null;
+  }
+  return {
+    requests: requests.map((request) => compact({
+      company_domain: request.company_domain,
+      company_name: request.company_name
+    })),
+    submissionFields
+  };
+}
 function normalizeCompanySignalResult(params, data) {
   const failed = coreProductResponseFailed(data);
   const rawSignals = failed ? [] : data.signals ?? data.signal_feed ?? [];
@@ -1349,6 +1970,9 @@ function dedupeExactBatchItems(items, keyForItem) {
 function normalizedBatchText(value) {
   return typeof value === "string" ? value.trim().toLowerCase().replace(/\s+/g, " ") : "";
 }
+function normalizedBatchIdempotencyKey(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
 function normalizedBatchDomain(value) {
   return normalizedBatchText(value).replace(/^https?:\/\//, "").replace(/^www\./, "").split(/[/?#]/, 1)[0].replace(/\.+$/, "");
 }
@@ -1372,7 +1996,8 @@ function coreProductBatchRequestKey(path, request) {
       normalizedBatchDomain(request.company_domain),
       normalizedBatchLinkedIn(request.linkedin_url),
       normalizedBatchText(request.company_name),
-      request.skip_cache === true || request.bypass_cache === true
+      request.skip_cache === true || request.bypass_cache === true,
+      normalizedBatchIdempotencyKey(request.idempotency_key)
     ]);
   }
   if (path === "api/v1/verify-email") {
@@ -1380,7 +2005,8 @@ function coreProductBatchRequestKey(path, request) {
       normalizedBatchText(request.email),
       request.skip_cache === true || request.bypass_cache === true,
       request.skip_catch_all_verification === true,
-      request.skip_esp_check === true
+      request.skip_esp_check === true,
+      normalizedBatchIdempotencyKey(request.idempotency_key)
     ]);
   }
   if (path === "api/v1/company-signals") {
@@ -1402,7 +2028,8 @@ function coreProductBatchRequestKey(path, request) {
       normalizedBatchText(request.search_mode || "balanced"),
       request.enable_outreach_intelligence === true,
       request.enable_predictive_intelligence === true,
-      request.skip_cache === true || request.bypass_cache === true
+      request.skip_cache === true || request.bypass_cache === true,
+      normalizedBatchIdempotencyKey(request.idempotency_key)
     ]);
   }
   return JSON.stringify([
@@ -1411,9 +2038,11 @@ function coreProductBatchRequestKey(path, request) {
     typeof request.title === "string" ? request.title.trim() : "",
     typeof request.campaign_offer === "string" ? request.campaign_offer.trim() : "",
     typeof request.research_prompt === "string" ? request.research_prompt.trim() : "",
+    Number(request.lookback_days) || null,
     typeof request.signal_run_id === "string" ? request.signal_run_id.trim() : "",
     request.skip_cache === true,
-    request.enable_deep_search === true
+    request.enable_deep_search === true,
+    normalizedBatchIdempotencyKey(request.idempotency_key)
   ]);
 }
 function finalizeCoreBatch(total, startedAt, round, normalize, options) {
@@ -1451,6 +2080,37 @@ function finalizeCoreBatch(total, startedAt, round, normalize, options) {
     results: compactedResults
   };
 }
+function finalizeRecoveredCoreBatch(total, startedAt, round, normalize, options) {
+  const results = round.map((item) => {
+    const duplicateOf = item.raw ? recoveredDuplicateOf(item.raw) : void 0;
+    if (duplicateOf !== void 0) return { index: item.index, success: true, duplicateOf };
+    if (!item.success || !item.raw) {
+      return batchItemFailure(
+        item.index,
+        item.error || "Signaliz batch item failed",
+        item.raw ?? item
+      );
+    }
+    try {
+      return { index: item.index, success: true, data: normalize(item) };
+    } catch (error) {
+      return {
+        index: item.index,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  const compactedResults = compactExactDuplicateResults(results, options?.compactDuplicates === true);
+  const succeeded = compactedResults.filter((item) => item.success).length;
+  return {
+    total,
+    succeeded,
+    failed: total - succeeded,
+    durationMs: Date.now() - startedAt,
+    results: compactedResults
+  };
+}
 function compactExactDuplicateResults(results, enabled) {
   if (!enabled) return results;
   const sourceIndexByRaw = /* @__PURE__ */ new WeakMap();
@@ -1466,6 +2126,19 @@ function compactExactDuplicateResults(results, enabled) {
     return item;
   });
 }
+function compactKnownDuplicateBatch(batch, sourceIndexByInput, enabled) {
+  if (!enabled) return batch;
+  const canonicalInputByUniqueIndex = /* @__PURE__ */ new Map();
+  sourceIndexByInput.forEach((uniqueIndex, inputIndex) => {
+    if (!canonicalInputByUniqueIndex.has(uniqueIndex)) canonicalInputByUniqueIndex.set(uniqueIndex, inputIndex);
+  });
+  const results = batch.results.map((item, index) => {
+    const canonicalIndex = canonicalInputByUniqueIndex.get(sourceIndexByInput[index]) ?? index;
+    if (canonicalIndex === index || !item.success || !batch.results[canonicalIndex]?.success) return item;
+    return { index, success: true, duplicateOf: canonicalIndex };
+  });
+  return { ...batch, results };
+}
 function signalToCopyRequestBody(params) {
   return compact({
     company_domain: params.companyDomain,
@@ -1482,6 +2155,28 @@ function signalToCopyRequestBody(params) {
     idempotency_key: params.idempotencyKey
   });
 }
+function validateLargeAvailableDataSignalCopyBatch(requests) {
+  if (requests.length <= 25) return;
+  const invalidIndex = requests.findIndex(
+    (request) => request.skipCache === true || request.enableDeepSearch === true || Boolean(request.idempotencyKey?.trim()) || request.maxWaitMs !== void 0 || request.pollIntervalMs !== void 0 || request.waitForResult === false || !request.companyDomain?.trim() || !request.personName?.trim() || !request.title?.trim() || !request.campaignOffer?.trim()
+  );
+  if (invalidIndex >= 0) {
+    throw new RangeError(
+      `Signal to Copy batches larger than 25 are available-data-only; row ${invalidIndex} requests fresh/deep/synchronous controls or lacks required recipient fields. Split fresh requests into batches of at most 25.`
+    );
+  }
+}
+function availableDataSignalCopyRequestBody(params) {
+  return compact({
+    company_domain: params.companyDomain,
+    person_name: params.personName,
+    title: params.title,
+    campaign_offer: params.campaignOffer,
+    research_prompt: params.researchPrompt,
+    lookback_days: params.lookbackDays,
+    signal_run_id: params.signalRunId
+  });
+}
 function validateSignalToCopyParams(params) {
   validateCoreProductMaxWaitMs(params.maxWaitMs);
   if (params.lookbackDays !== void 0 && (!Number.isInteger(params.lookbackDays) || params.lookbackDays < 1 || params.lookbackDays > 365)) {
@@ -1532,6 +2227,8 @@ function normalizeSignalToCopyResult(data) {
     liveProviderCalled: data.live_provider_called,
     aiProviderCalled: data.ai_provider_called,
     byoAiUsed: data.byo_ai_used,
+    unlimitedSignalToCopy: data.unlimited_signal_to_copy,
+    signalToCopyEntitlement: data.signal_to_copy_entitlement,
     variations: (failed ? [] : data.variations ?? []).map((variation) => ({
       style: variation.style,
       subjectLine: variation.subject_line ?? "",
@@ -1615,6 +2312,29 @@ async function waitForNextSignalPoll(data, override, startedAt, maxWaitMs) {
 function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function validateCoreBatchPollingOptions(options) {
+  if (options.maxWaitMs !== void 0 && (!Number.isFinite(options.maxWaitMs) || options.maxWaitMs <= 0)) {
+    throw new RangeError("maxWaitMs must be a positive finite number");
+  }
+  if (options.pollIntervalMs !== void 0 && (!Number.isFinite(options.pollIntervalMs) || options.pollIntervalMs <= 0)) {
+    throw new RangeError("pollIntervalMs must be a positive finite number");
+  }
+}
+function assertRecoverableBatchResultsRetained(status, label, jobId, idempotencyKey) {
+  if (status.results_expired !== true && status.results_cleaned !== true) return;
+  throw new SignalizError({
+    code: "BATCH_RESULTS_EXPIRED",
+    message: `${label} batch ${jobId} completed, but its retained result pages have expired and cannot be recovered. Do not automatically resubmit provider work.`,
+    errorType: "not_found",
+    details: {
+      job_id: jobId,
+      ...idempotencyKey ? { idempotency_key: idempotencyKey } : {},
+      suggested_action: "review_before_resubmitting",
+      retry_eligible: false,
+      results_expired: true
+    }
+  });
+}
 async function runBatch(items, execute, options) {
   validateBatchSize(items);
   const concurrency = validatedBatchConcurrency(options);