deepline 0.3.201 → 0.3.203

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/postgres.ts

@@ -84,6 +84,7 @@ import {
   type PlayRunLedgerIngressEvent,
 } from '../run-ledger';
 import { stableStringify } from '../../plays/row-identity';
+import { runtimeWorkCountersFromResources } from '../runtime-work-counters';
 import {
   isCtxFetchHttpFailureDiagnostic,
   parseCtxFetchHttpFailureDiagnostic,
@@ -13045,7 +13046,7 @@ function terminalLogLinesForOutbox(
     .slice(-LOG_TAIL_LIMIT);
 }
 
-function attachRunnerWorkProgressMetadata(
+export function attachRunnerWorkProgressMetadata(
   output: unknown,
   runnerResult: unknown,
   options: {
@@ -13097,6 +13098,13 @@ function attachRunnerWorkProgressMetadata(
   const runtimeResources = metadata?.runtimeResources
     ? null
     : boundedRuntimeResourcesMetadata(runnerResult);
+  // Keep the two scalar counts when the detailed runtimeResources record
+  // exceeds its metadata budget. Compact status must not scan a call log to
+  // reconstruct physical work.
+  const runtimeCounters = runtimeWorkCountersFromResources(
+    (runnerResult as { stats?: { runtimeResources?: unknown } }).stats
+      ?.runtimeResources,
+  );
   const outputWarnings = Array.isArray(
     (runnerResult as { outputWarnings?: unknown }).outputWarnings,
   )
@@ -13139,6 +13147,8 @@ function attachRunnerWorkProgressMetadata(
     (total === null || skipped === null || metadata?.workProgress) &&
     !runLogTail &&
     !runtimeResources &&
+    !runtimeCounters &&
+    !metadata?.runtimeCounters &&
     !rowOutcomes &&
     mergedOutputWarnings.length === 0
   ) {
@@ -13170,6 +13180,9 @@ function attachRunnerWorkProgressMetadata(
     ...record,
     _metadata: {
       ...(metadata ?? {}),
+      // A previous attempt's scalar evidence cannot describe this terminal
+      // attempt. Undefined removes it from persisted JSON when unavailable.
+      runtimeCounters: runtimeCounters ?? undefined,
       ...(workProgress ? { workProgress } : {}),
       ...(rowOutcomes ? { rowOutcomes } : {}),
       ...(runLogTail ? { runLogTail } : {}),
@@ -15667,8 +15680,63 @@ export async function readPostgresSchedulerResult(
 export async function readPostgresSchedulerRunStatus(
   client: PostgresSchedulerQueryClient,
   runId: string,
-  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+  options?: Pick<PostgresSchedulerOptions, 'schema'> & {
+    includeDetails?: boolean;
+  },
 ): Promise<PostgresSchedulerRunStatusSnapshot | null> {
+  if (options?.includeDetails === false) {
+    // An admission projection gap needs lifecycle truth only. Launch, result,
+    // suspension and error JSON may contain row/call-sized detail: never even
+    // select them for status polling. Missing progress remains unconfirmed.
+    const result = await client.query<
+      Pick<
+        RunStatusRow,
+        | 'run_id'
+        | 'org_id'
+        | 'status'
+        | 'play_name'
+        | 'graph_hash'
+        | 'runtime_profile'
+        | 'created_at'
+        | 'updated_at'
+        | 'started_at'
+        | 'finished_at'
+      >
+    >(
+      `
+      SELECT run_id, org_id, status, play_name, graph_hash, runtime_profile,
+        created_at, updated_at, started_at, finished_at
+      FROM ${tableName('runs', options)}
+      WHERE run_id = $1
+    `,
+      [runId],
+    );
+    const row = result.rows[0];
+    if (!row) return null;
+    return {
+      runId: row.run_id,
+      orgId: row.org_id ?? '',
+      status: row.status,
+      playName: row.play_name,
+      graphHash: row.graph_hash,
+      runtimeBackend: null,
+      schedulerBackend: 'absurd',
+      executionProfile: row.runtime_profile,
+      createdAt: row.created_at?.getTime() ?? null,
+      updatedAt: row.updated_at?.getTime() ?? null,
+      startedAt: row.started_at?.getTime() ?? null,
+      finishedAt: row.finished_at?.getTime() ?? null,
+      durationMs:
+        row.finished_at && row.started_at
+          ? Math.max(0, row.finished_at.getTime() - row.started_at.getTime())
+          : null,
+      runtimeTiming: null,
+      result: null,
+      error: null,
+      suspension: null,
+      staticPipeline: null,
+    };
+  }
   const result = await client.query<RunStatusRow>(
     `
       SELECT run_id, org_id, status, play_name, graph_hash, runtime_profile,
@@ -15883,6 +15951,10 @@ export async function assertPostgresRunLedgerDelivery(
     runId: string;
     idempotencyKey: string;
     leaseOwner?: string;
+    projectedEvents?: readonly AcceptedPlayRunLedgerEvent[];
+    normalizeProjectedEvents?: (
+      events: readonly PlayRunLedgerIngressEvent[],
+    ) => readonly AcceptedPlayRunLedgerEvent[];
   },
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<void> {
@@ -15893,6 +15965,8 @@ export async function assertPostgresRunLedgerDelivery(
     lease_live: boolean;
     due: boolean;
     blocked: boolean;
+    payload_json: unknown;
+    created_at: Date;
   }>(
     `
     SELECT outbox.delivery_key,
@@ -15900,7 +15974,9 @@ export async function assertPostgresRunLedgerDelivery(
            outbox.lease_owner,
            outbox.lease_expires_at > now() AS lease_live,
            coalesce(outbox.next_attempt_at, outbox.created_at) <= now() AS due,
-           outbox.failed_at IS NOT NULL AS blocked
+           outbox.failed_at IS NOT NULL AS blocked,
+           outbox.payload_json,
+           outbox.created_at
     FROM ${tableName('outbox', options)} AS outbox
     JOIN ${tableName('runs', options)} AS runs ON runs.run_id = outbox.run_id
     WHERE outbox.run_id = $1 AND runs.org_id = $2
@@ -15915,12 +15991,9 @@ export async function assertPostgresRunLedgerDelivery(
     throw new RunLedgerProjectionLeaseLostError();
   }
 
-  // A normal projector leases only the batch it is about to send. Cancellation
-  // intentionally transfers the entire pending causal prefix to one stable
-  // owner before synchronously draining it, while run.events are still claimed
-  // one row at a time. Validate the submitted key against a *contiguous due
-  // prefix*, not every row carrying that owner; otherwise a valid cancellation
-  // head is rejected whenever later facts share the cancellation lease.
+  // Cancellation may own several pending facts at once. Validate the exact
+  // contiguous, due prefix named by the receipt instead of all rows sharing
+  // that cancellation lease.
   const prefix: typeof rows = [];
   for (const row of rows) {
     if (
@@ -15940,6 +16013,9 @@ export async function assertPostgresRunLedgerDelivery(
         candidate.event_type,
       ),
     );
+    const prefixDigest = createHash('sha256')
+      .update(prefix.map((candidate) => candidate.delivery_key).join('\n'))
+      .digest('hex');
     let expectedKey: string;
     if (terminal) {
       expectedKey = buildRunLedgerTerminalIdempotencyKey({
@@ -15955,29 +16031,58 @@ export async function assertPostgresRunLedgerDelivery(
         deliveryKey: first.delivery_key,
       });
     } else {
-      const digest = createHash('sha256')
-        .update(prefix.map((candidate) => candidate.delivery_key).join('\n'))
-        .digest('hex');
       expectedKey = buildRunLedgerEventsIdempotencyKey({
         runId: input.runId,
-        deliveryDigest: digest,
+        deliveryDigest: prefixDigest,
       });
     }
-    if (input.idempotencyKey === expectedKey) return;
 
-    // The pre-batch projector used run-terminal:<delivery-key> for a single
-    // nonterminal fact. Retain that wire-compatibility key for the current
-    // singleton head, but never let it authorize a later row in the prefix.
-    if (
+    // Older batch dispatchers may use the digest receipt even when the batch
+    // contains a terminal fact. Keep accepting it for this exact prefix.
+    const batchKey = buildRunLedgerEventsIdempotencyKey({
+      runId: input.runId,
+      deliveryDigest: prefixDigest,
+    });
+
+    // Preserve the old singleton key for non-start, nonterminal facts.
+    const legacySingletonKey =
       prefix.length === 1 &&
       !['run.created', 'run.started'].includes(first.event_type) &&
       input.idempotencyKey ===
         buildRunLedgerTerminalIdempotencyKey({
           runId: input.runId,
           deliveryKey: first.delivery_key,
-        })
+        });
+    if (
+      input.idempotencyKey === expectedKey ||
+      input.idempotencyKey === batchKey ||
+      legacySingletonKey
     ) {
-      return;
+      if (input.projectedEvents === undefined) return;
+      const prefixEvents: PlayRunLedgerIngressEvent[] = [];
+      for (const prefixRow of prefix) {
+        prefixEvents.push(
+          ...buildRunLedgerEventsFromPostgresSchedulerOutbox({
+            eventId: prefixRow.delivery_key,
+            runId: input.runId,
+            eventType: prefixRow.event_type,
+            payload: prefixRow.payload_json,
+            createdAt: new Date(prefixRow.created_at),
+            leaseOwner: prefixRow.lease_owner ?? undefined,
+            deliveryKey: prefixRow.delivery_key,
+          }),
+        );
+      }
+      const comparablePrefixEvents = input.normalizeProjectedEvents
+        ? input.normalizeProjectedEvents(prefixEvents)
+        : prefixEvents;
+      if (
+        stableStringify(input.projectedEvents) ===
+        stableStringify(comparablePrefixEvents)
+      ) {
+        return;
+      }
+      throw new RunLedgerProjectionLeaseLostError();
     }
 
     if (
@@ -16157,7 +16262,7 @@ export async function readPendingPostgresSchedulerOutboxEvents(
                 )
               )
           )
-        ORDER BY outbox.created_at, outbox.event_id
+        ORDER BY ${runLedgerOrderSql('outbox')}
         FOR UPDATE OF outbox
         LIMIT $1
       ), terminal_batch AS (
@@ -16193,7 +16298,7 @@ export async function readPendingPostgresSchedulerOutboxEvents(
       SELECT event_id, run_id, event_type, payload_json, created_at, lease_owner,
              delivery_key
       FROM claimed
-      ORDER BY created_at, event_id
+      ORDER BY ${runLedgerOrderSql('claimed')}
     `,
       [limit, runId, leaseOwner, leaseSeconds],
     );
@@ -16287,7 +16392,9 @@ export async function readPostgresSchedulerOutboxNextDueAt(
 export async function readPostgresSchedulerOutboxDeliveryStatus(
   client: PostgresSchedulerQueryClient,
   input: { runId: string; eventId: string },
-  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+  options?: Pick<PostgresSchedulerOptions, 'schema'> & {
+    includeBlocked?: boolean;
+  },
 ): Promise<PostgresSchedulerOutboxDeliveryStatus> {
   const runId = input.runId.trim();
   const eventId = input.eventId.trim();
@@ -16298,13 +16405,17 @@ export async function readPostgresSchedulerOutboxDeliveryStatus(
   }
   const result = await client.query<{ delivered: boolean; blocked: boolean }>(
     `SELECT target.delivered_at IS NOT NULL AS delivered,
-            target.failed_at IS NOT NULL OR EXISTS (
+            ${
+              options?.includeBlocked === false
+                ? 'false'
+                : `target.failed_at IS NOT NULL OR EXISTS (
               SELECT 1
               FROM ${tableName('outbox', options)} predecessor
               WHERE predecessor.run_id = target.run_id
                 AND predecessor.failed_at IS NOT NULL
                 AND ${runLedgerPrecedesSql('predecessor', 'target', true)}
-            ) AS blocked
+            )`
+            } AS blocked
      FROM ${tableName('outbox', options)} target
      WHERE target.run_id = $1 AND target.event_id = $2`,
     [runId, eventId],

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/receipt-gateway.ts

@@ -66,6 +66,7 @@ import {
   createRuntimeReceiptValuePersister,
   createRuntimeReceiptValueReader,
   RUNTIME_RECEIPT_VALUE_INLINE_MAX_BYTES,
+  RuntimeValueStoreUnavailableError,
   type RuntimeReceiptValueBlobStore,
   type RuntimeReceiptValuePersister,
   type RuntimeReceiptValueReader,
@@ -250,6 +251,26 @@ export function receiptGatewayFailureResponse(
       },
     );
   }
+  if (error instanceof RuntimeValueStoreUnavailableError) {
+    return receiptGatewayJsonResponse(
+      {
+        error: `${operationLabel} object store is temporarily unavailable.`,
+        code: 'runtime_value_store_unavailable',
+        retryable: true,
+        retry_after_ms: 1_000,
+        detail: error.message,
+        ...(context.action ? { action: context.action } : {}),
+      },
+      {
+        status: 503,
+        headers: {
+          'retry-after': '1',
+          'x-deepline-error-code': 'runtime_value_store_unavailable',
+          'x-deepline-error-detail': error.message,
+        },
+      },
+    );
+  }
   if (isRuntimeSchedulerCapacityError(error)) {
     const retryAfterMs = runtimeSchedulerCapacityRetryAfterMs(error);
     return receiptGatewayJsonResponse(

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/runtime-receipt-value-storage.ts

@@ -25,6 +25,40 @@ export type RuntimeValueBlobStore = {
 /** Backward-compatible receipt-specific name for the shared object store. */
 export type RuntimeReceiptValueBlobStore = RuntimeValueBlobStore;
 
+export class RuntimeValueStoreUnavailableError extends Error {
+  constructor(
+    readonly operation: 'put' | 'head',
+    readonly status: number,
+    cause: unknown,
+  ) {
+    super(`Runtime value object store ${operation} returned HTTP ${status}.`, {
+      cause,
+    });
+    this.name = 'RuntimeValueStoreUnavailableError';
+  }
+}
+
+function transientStoreStatus(error: unknown): number | null {
+  if (!error || typeof error !== 'object') return null;
+  const metadata = (error as { $metadata?: { httpStatusCode?: unknown } })
+    .$metadata;
+  const status = metadata?.httpStatusCode;
+  return typeof status === 'number' &&
+    (status === 408 || status === 429 || status >= 500)
+    ? status
+    : null;
+}
+
+function transientStoreError(
+  operation: 'put' | 'head',
+  error: unknown,
+): RuntimeValueStoreUnavailableError | null {
+  const status = transientStoreStatus(error);
+  return status === null
+    ? null
+    : new RuntimeValueStoreUnavailableError(operation, status, error);
+}
+
 /**
  * Foundation owns value references and bounded I/O admission; the deployment
  * injects its object-store adapter. This keeps R2 credentials and transport
@@ -185,7 +219,13 @@ export async function persistRuntimeReceiptValue(
     // An immutable deterministic object that is observable after a failed PUT
     // is the same attempted publication. Treat it as a recovered write, never
     // as permission to call the provider again.
-    if (!(await store.exists(outputRef.key))) throw error;
+    let exists: boolean;
+    try {
+      exists = await store.exists(outputRef.key);
+    } catch (probeError) {
+      throw transientStoreError('head', probeError) ?? probeError;
+    }
+    if (!exists) throw transientStoreError('put', error) ?? error;
   }
   return { kind: 'reference', outputJson: null, outputRef };
 }
@@ -209,11 +249,10 @@ export function createRuntimeReceiptValuePersister(
     serialized: string;
     inlineFields?: RuntimeReceiptValueInlineFields;
   };
-  const writes = new BoundedBatchFunction<
-    Write,
-    PersistedRuntimeReceiptValue,
-    'r2'
-  >({
+  type WriteOutcome =
+    | { ok: true; value: PersistedRuntimeReceiptValue }
+    | { ok: false; error: unknown };
+  const writes = new BoundedBatchFunction<Write, WriteOutcome, 'r2'>({
     keyId: () => 'r2',
     estimateBytes: (value) => Buffer.byteLength(value.serialized, 'utf8'),
     maxBatchItems: 4,
@@ -224,16 +263,24 @@ export function createRuntimeReceiptValuePersister(
     maxRetainedUnits: 32,
     maxInFlightBatches: 2,
     flushMs: 0,
+    // R2 has no multi-PUT. One failed object must not reject the other
+    // independent receipts admitted alongside it.
     execute: async ({ values }) =>
       await Promise.all(
-        values.map(
-          async (value) =>
-            await persistRuntimeReceiptValue({
-              ...value,
-              inlineMaxBytes,
-              ...(input.store ? { store: input.store } : {}),
-            }),
-        ),
+        values.map(async (value): Promise<WriteOutcome> => {
+          try {
+            return {
+              ok: true,
+              value: await persistRuntimeReceiptValue({
+                ...value,
+                inlineMaxBytes,
+                ...(input.store ? { store: input.store } : {}),
+              }),
+            };
+          } catch (error) {
+            return { ok: false, error };
+          }
+        }),
       ),
   });
   return async (value) => {
@@ -244,7 +291,9 @@ export function createRuntimeReceiptValuePersister(
         ...(input.store ? { store: input.store } : {}),
       });
     }
-    return await writes.submit({ key: 'r2', value });
+    const outcome = await writes.submit({ key: 'r2', value });
+    if (!outcome.ok) throw outcome.error;
+    return outcome.value;
   };
 }
 

package/dist/bundling-sources/shared_libs/play-runtime/sheet-attempt-sql.ts

@@ -41,11 +41,11 @@ export function releasableRuntimeSheetAttemptFenceSql(
 }
 
 /**
- * Predicate for durable replay idempotency: matches rows that are already
- * terminal (enriched or failed) from the same attempt owner + epoch. Used to
- * suppress same-version conflicts when a worker restarts and re-runs map rows
- * that it already completed. First terminal state wins; payload/error drift on
- * replay is accepted as a no-op rather than rejected as a conflict.
+ * Predicate for callers that need to identify a terminal row from the same
+ * attempt owner + epoch. Runtime map persistence now enforces first-terminal
+ * idempotency inline because its write-version and row-key context are also
+ * required; keep this helper exported for compatibility with external
+ * conformance checks and integrations.
  */
 export function sameOwnerTerminalAttemptEpochSql(
   tableAlias: string,

package/dist/bundling-sources/shared_libs/play-runtime/tool-call/index.ts

@@ -35,6 +35,7 @@ export {
   type AlwaysFreshToolCall,
   type AlwaysFreshToolCallInput,
 } from './always-fresh-adapter';
+export { resolveToolCallResultReceiptPolicy } from './result-receipt-policy';
 
 export type {
   ToolCallCompatibilityIdentity,

package/dist/bundling-sources/shared_libs/play-runtime/tool-call/result-receipt-policy.ts

@@ -0,0 +1,46 @@
+import { scopeToolReceiptToInvocation } from '../durable-call-cache';
+
+/**
+ * Freshness chooses which completed results a run may reuse. It never turns
+ * off durable progress inside that run. A forced invocation gets an immutable
+ * result of its own; a scheduler retry reads it like any other completed key.
+ *
+ * The canonical key already binds payload, authorization, action and response
+ * semantics. Keep it in the derivation so a changed input cannot recover an
+ * unrelated result. Provider operation identities and public receipt metadata
+ * remain canonical and are deliberately outside this storage policy.
+ */
+export function resolveToolCallResultReceiptPolicy(input: {
+  orgId?: string | null;
+  toolId: string;
+  resultReceiptKey: string;
+  runId: string;
+  logicalCallId: string;
+  force: boolean;
+  /** Historical local contexts may have no durable result store. */
+  canStoreResult?: boolean;
+}): { resultReceiptKey: string; force: boolean } {
+  if (!input.resultReceiptKey.trim()) {
+    throw new Error('Tool Call result policy requires a result receipt key.');
+  }
+  if (!input.force) {
+    return { resultReceiptKey: input.resultReceiptKey, force: false };
+  }
+  if (input.canStoreResult === false) {
+    return { resultReceiptKey: input.resultReceiptKey, force: true };
+  }
+  if (!input.runId.trim() || !input.logicalCallId.trim()) {
+    throw new Error(
+      'Forced Tool Call requires stable run and call identities.',
+    );
+  }
+  return {
+    resultReceiptKey: scopeToolReceiptToInvocation({
+      orgId: input.orgId,
+      toolId: input.toolId,
+      receiptKey: input.resultReceiptKey,
+      invocationIdentity: `forced-result:${input.runId}:${input.logicalCallId}`,
+    }),
+    force: false,
+  };
+}

package/dist/bundling-sources/shared_libs/play-runtime/tool-execute-retry-policy.ts

@@ -425,20 +425,29 @@ export function createToolExecuteHttpFailureAttemptTracker(): ToolExecuteHttpFai
   };
 }
 
-export function parseToolExecuteRetryAfterMs(
+// Keep expired absolute deadlines intact: durable response replay must not
+// turn old provider feedback into a new AIMD throttle episode.
+export function parseToolExecuteRetryAtMs(
   header: string | null | undefined,
   nowMs = Date.now(),
 ): number {
-  if (!header) return TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS;
+  if (!header) return nowMs + TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS;
   const seconds = Number(header);
   if (Number.isFinite(seconds) && seconds >= 0) {
-    return Math.ceil(seconds * 1000);
+    return nowMs + Math.ceil(seconds * 1000);
   }
   const retryAt = Date.parse(header);
   if (Number.isFinite(retryAt)) {
-    return Math.max(0, retryAt - nowMs);
+    return retryAt;
   }
-  return TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS;
+  return nowMs + TOOL_EXECUTE_RETRY_DELAY_FALLBACK_MS;
+}
+
+export function parseToolExecuteRetryAfterMs(
+  header: string | null | undefined,
+  nowMs = Date.now(),
+): number {
+  return Math.max(0, parseToolExecuteRetryAtMs(header, nowMs) - nowMs);
 }
 
 export function classifyToolExecuteHttpFailure(input: {

package/dist/bundling-sources/shared_libs/play-runtime/tool-http-errors.ts

@@ -265,7 +265,11 @@ function receiptFailureKindForToolErrorPayload(
   // A credential connection can be added or replaced between play runs. Keep
   // the failure terminal within its owning run, but let a later run reclaim
   // the durable receipt instead of replaying stale authorization state.
-  return code === 'INTEGRATION_CREDENTIALS_MISSING' ? 'repairable' : 'terminal';
+  if (code === 'INTEGRATION_CREDENTIALS_MISSING') return 'repairable';
+  // Managed AI has billing evidence for completed model steps, but no stored
+  // responses from which to resume the later rate-limited step. Its 409 stops
+  // automatic replay; an explicit later run may intentionally repeat work.
+  return code === 'UPSTREAM_PARTIAL_EXECUTION' ? 'repairable' : 'terminal';
 }
 
 function formatHardBillingFailureMessage(input: {

package/dist/bundling-sources/shared_libs/play-runtime/work-receipt-state-machine.ts

@@ -246,17 +246,11 @@ export function decideWorkReceiptClaim(input: {
   const sameLogicalRun =
     normalize(input.claimantRunId) !== null &&
     normalize(input.claimantRunId) === normalize(input.receipt.runId);
-  const sameRunNewerLeaseAttempt =
-    state.reusable &&
-    state.lease.kind === 'active' &&
-    state.lease.ownerRunId === normalize(input.claimantRunId) &&
-    state.lease.ownerAttempt < normalizeAttempt(input.claimantRunAttempt);
   // Force refresh means new intent across runs. Within one run it is a replay,
   // so reuse terminal output instead of creating a second terminal payload
-  // under the run's existing Runtime Sheet write version. A newer lease
-  // generation is the exception: it is a new attempt and retains the existing
-  // stale-owner fence semantics.
-  if (state.reusable && sameLogicalRun && !sameRunNewerLeaseAttempt) {
+  // under the run's existing Runtime Sheet write version. A scheduler resume
+  // increases the attempt number but does not create another refresh intent.
+  if (state.reusable && sameLogicalRun) {
     return { kind: 'reuse_terminal' };
   }
   if (state.reusable && input.forceRefresh !== true) {

package/dist/bundling-sources/shared_libs/product-notifications/catalog.ts

@@ -239,7 +239,7 @@ function defaultThreshold(
 }
 
 function formatCredits(value: number): string {
-  return value.toLocaleString('en-US', { maximumFractionDigits: 2 });
+  return value.toLocaleString('en-US', { maximumFractionDigits: 3 });
 }
 
 export const DEEPLINE_DOCS_URL = 'https://deepline.com/docs';