deepline 0.3.348 → 0.3.350

package/dist/bundling-sources/sdk/src/release.ts

@@ -200,7 +200,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.348',
+  version: '0.3.350',
   updateSummary:
     'Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.',
   packageCapabilities: {

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

@@ -8,6 +8,26 @@ import { stringifyPostgresJson } from '../postgres-json';
 
 const MAX_BUDGET_CHARGES_PER_REQUEST = 16;
 
+/** The caller sent a charge this request can never satisfy. Retrying is futile. */
+export class BudgetStateRequestError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'BudgetStateRequestError';
+  }
+}
+
+/**
+ * Only a limit or a malformed request is the budget's own answer. Anything
+ * else (a dropped connection, an aborted transaction) says nothing about the
+ * budget and must stay retryable.
+ */
+export function isBudgetStateRejection(error: unknown): boolean {
+  return (
+    error instanceof BudgetStateLimitError ||
+    error instanceof BudgetStateRequestError
+  );
+}
+
 function quoteIdent(value: string): string {
   return `"${value.replace(/"/g, '""')}"`;
 }
@@ -52,7 +72,7 @@ export async function ensurePostgresBudgetStateSchema(
 
 function normalizedCharges(input: PlayRunnerBudgetChargeInput) {
   if (input.charges.length > MAX_BUDGET_CHARGES_PER_REQUEST) {
-    throw new Error(
+    throw new BudgetStateRequestError(
       `Governor budget accepts at most ${MAX_BUDGET_CHARGES_PER_REQUEST} charges per request.`,
     );
   }
@@ -60,15 +80,17 @@ function normalizedCharges(input: PlayRunnerBudgetChargeInput) {
   for (const charge of input.charges) {
     const key = charge.key.trim();
     if (!key || key.length > 256) {
-      throw new Error('Governor budget key must be 1-256 characters.');
+      throw new BudgetStateRequestError(
+        'Governor budget key must be 1-256 characters.',
+      );
     }
     if (!Number.isSafeInteger(charge.amount) || charge.amount <= 0) {
-      throw new Error(
+      throw new BudgetStateRequestError(
         `Governor budget ${key} amount must be a positive integer.`,
       );
     }
     if (!Number.isSafeInteger(charge.limit) || charge.limit <= 0) {
-      throw new Error(
+      throw new BudgetStateRequestError(
         `Governor budget ${key} limit must be a positive integer.`,
       );
     }
@@ -108,7 +130,9 @@ export async function chargePostgresBudgetState(
   if (charges.length === 0) return { counters: {} };
   const reservationId = input.reservationId.trim();
   if (!reservationId || reservationId.length > 256) {
-    throw new Error('Governor budget reservationId must be 1-256 characters.');
+    throw new BudgetStateRequestError(
+      'Governor budget reservationId must be 1-256 characters.',
+    );
   }
   for (const charge of charges) {
     if (charge.amount > charge.limit) {
@@ -155,7 +179,7 @@ export async function chargePostgresBudgetState(
         throw new Error('Governor budget reservation disappeared.');
       }
       if (!sameCharges(reservation.charges_json, charges)) {
-        throw new Error(
+        throw new BudgetStateRequestError(
           'Governor budget reservationId was reused with different charges.',
         );
       }

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

@@ -608,7 +608,9 @@ export function isRuntimeSchedulerServerUnavailableError(
         code === '57P03' ||
         (code === '08P01' &&
           typeof message === 'string' &&
-          recoveryMessage.test(message.trim())) ||
+          (recoveryMessage.test(message.trim()) ||
+            // PgBouncer's exact report that its backend connection dropped.
+            message.trim() === 'server conn crashed?')) ||
         // Preserve legacy connection messages without accepting every 08* code.
         (legacyConnectionCode &&
           typeof message === 'string' &&

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

@@ -18712,6 +18712,40 @@ export async function readPostgresSchedulerOutboxNextDueAt(
 ): Promise<Date | null> {
   const result = await client.query<{ due_at: Date | string | null }>(
     `
+      -- Discover only run identities before seeking each lane's causal head.
+      -- Proving that every pending fact has no predecessor can be quadratic for
+      -- a large receipt backlog, even while another replica drains that run.
+      WITH pending_runs AS MATERIALIZED (
+        SELECT DISTINCT pending.run_id
+        FROM ${tableName('outbox', options)} AS pending
+        WHERE pending.delivered_at IS NULL
+      ), heads AS MATERIALIZED (
+        SELECT pending_run.run_id, false AS search_only, head.*
+        FROM pending_runs AS pending_run
+        CROSS JOIN LATERAL (
+          SELECT pending.created_at, pending.next_attempt_at,
+                 pending.failed_at, pending.lease_expires_at
+          FROM ${tableName('outbox', options)} AS pending
+          WHERE pending.run_id = pending_run.run_id
+            AND pending.delivered_at IS NULL
+            AND ${searchLaneSql('pending')} = false
+          ORDER BY ${runLedgerOrderSql('pending')}
+          LIMIT 1
+        ) AS head
+        UNION ALL
+        SELECT pending_run.run_id, true AS search_only, head.*
+        FROM pending_runs AS pending_run
+        CROSS JOIN LATERAL (
+          SELECT pending.created_at, pending.next_attempt_at,
+                 pending.failed_at, pending.lease_expires_at
+          FROM ${tableName('outbox', options)} AS pending
+          WHERE pending.run_id = pending_run.run_id
+            AND pending.delivered_at IS NULL
+            AND ${searchLaneSql('pending')} = true
+          ORDER BY ${runLedgerOrderSql('pending')}
+          LIMIT 1
+        ) AS head
+      )
       SELECT min(greatest(
         CASE
           WHEN lease_expires_at IS NOT NULL AND lease_expires_at > now()
@@ -18721,22 +18755,13 @@ export async function readPostgresSchedulerOutboxNextDueAt(
         (SELECT max(active.lease_expires_at)
          FROM ${tableName('outbox', options)} AS active
          WHERE active.run_id = candidate.run_id
-           AND ${searchLaneSql('active')} = ${searchLaneSql('candidate')}
+           AND ${searchLaneSql('active')} = candidate.search_only
            AND active.delivered_at IS NULL AND active.lease_owner IS NOT NULL
            AND active.lease_expires_at > now())
       )) AS due_at
-      FROM ${tableName('outbox', options)} AS candidate
-      WHERE candidate.delivered_at IS NULL
-        AND candidate.failed_at IS NULL
-        -- Match the competing-consumer claim exactly. A successor blocked by
-        -- an older event must not create a zero-delay recovery spin.
-        AND NOT EXISTS (
-          SELECT 1
-          FROM ${tableName('outbox', options)} AS predecessor
-          WHERE predecessor.run_id = candidate.run_id
-            AND predecessor.delivered_at IS NULL
-            AND ${runLedgerPrecedesSql('predecessor', 'candidate')}
-        )
+      FROM heads AS candidate
+      -- A failed head quarantines its lane; never wake on its successor.
+      WHERE candidate.failed_at IS NULL
     `,
   );
   const value = result.rows[0]?.due_at;

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/run-ledger-outbox-recovery.ts

@@ -80,6 +80,9 @@ const RUN_LEDGER_OUTBOX_RECOVERY_INDEX_IN_FLIGHT = 4;
 // from starving behind continuous new admissions. An empty class never costs
 // another query: either order can select any eligible run.
 const ADMISSION_TURNS_PER_OLDEST_READY_TURN = 3;
+// Notifications are hints, not another durable queue. Overflow requests the
+// existing global drain instead of retaining an unbounded set of run ids.
+const MAX_NOTIFICATION_RUN_HINTS = RUN_LEDGER_OUTBOX_RECOVERY_MAX_IN_FLIGHT;
 
 type RecoveryTimer = ReturnType<typeof setTimeout>;
 
@@ -89,9 +92,12 @@ export type RunLedgerOutboxRecoveryDeps = {
   /** One bounded durable claim/delivery attempt. */
   dispatchOnce: (
     headPriority: RunLedgerOutboxHeadPriority,
+    runId?: string,
   ) => Promise<PostgresSchedulerOutboxProjectionResult>;
   /** Independent index deliveries share this controller and notification source. */
-  dispatchObservabilityOnce?: () => Promise<PostgresSchedulerOutboxProjectionResult>;
+  dispatchObservabilityOnce?: (
+    runId?: string,
+  ) => Promise<PostgresSchedulerOutboxProjectionResult>;
   observabilityParallelism?: number;
   /** Earliest pending retry time or active lease expiry in the durable outbox. */
   readNextDueAt: () => Promise<Date | null>;
@@ -139,6 +145,18 @@ function boundedFailureDelayMs(failures: number): number {
   );
 }
 
+function notificationRunId(payload: string): string | undefined {
+  try {
+    const message = JSON.parse(payload) as { runId?: unknown } | null;
+    if (typeof message?.runId !== 'string') return undefined;
+    const runId = message.runId.trim();
+    return runId && runId.length <= 256 ? runId : undefined;
+  } catch {
+    // Legacy, retry and repair notifications may carry no run identity.
+    return undefined;
+  }
+}
+
 /**
  * Start a bounded, work-conserving recovery controller from injected seams.
  * Subscription happens before the first database scan, so a terminal commit
@@ -189,24 +207,50 @@ export function startRunLedgerOutboxRecovery(
   let hubLease: PgNotifyHubLease | null = null;
   let unsubscribeNotify: (() => void) | undefined;
   let unsubscribeState: (() => void) | undefined;
-  let requestDrain: (reason: string) => void = () => undefined;
+  let requestDrain: (reason: string, runId?: string) => void = () => undefined;
+  const lifecycleRunHints = new Set<string>();
+  const observabilityRunHints = new Set<string>();
+  const hasRequests = () =>
+    requested ||
+    observabilityRequested ||
+    lifecycleRunHints.size > 0 ||
+    observabilityRunHints.size > 0;
+  const addRunHint = (hints: Set<string>, runId: string) => {
+    hints.add(runId);
+    if (hints.size <= MAX_NOTIFICATION_RUN_HINTS) return true;
+    hints.clear();
+    return false;
+  };
+  const takeRunHint = (hints: Set<string>): string | undefined => {
+    const runId = hints.values().next().value;
+    if (runId !== undefined) hints.delete(runId);
+    return runId;
+  };
   const inFlightStartedAt = new Map<number, number>();
   let nextDispatchId = 0;
   let lastDispatchSettledAt: number | null = null;
   let admissionTurns = 0;
   const dispatchOnce = async (
     observability = false,
+    runId?: string,
   ): Promise<PostgresSchedulerOutboxProjectionResult> => {
     const oldestReady =
       admissionTurns === ADMISSION_TURNS_PER_OLDEST_READY_TURN;
-    if (!observability) admissionTurns = oldestReady ? 0 : admissionTurns + 1;
+    // Scoped claims cannot change which run wins, so they must not consume
+    // the global drain's starvation-prevention turns.
+    if (!observability && runId === undefined)
+      admissionTurns = oldestReady ? 0 : admissionTurns + 1;
     const id = nextDispatchId++;
     inFlightStartedAt.set(id, now());
     try {
-      if (observability) return await deps.dispatchObservabilityOnce!();
-      return await deps.dispatchOnce(
-        oldestReady ? 'oldest_ready' : 'admission_first',
-      );
+      if (observability)
+        return await (runId === undefined
+          ? deps.dispatchObservabilityOnce!()
+          : deps.dispatchObservabilityOnce!(runId));
+      const headPriority = oldestReady ? 'oldest_ready' : 'admission_first';
+      return await (runId === undefined
+        ? deps.dispatchOnce(headPriority)
+        : deps.dispatchOnce(headPriority, runId));
     } finally {
       inFlightStartedAt.delete(id);
       lastDispatchSettledAt = now();
@@ -226,8 +270,8 @@ export function startRunLedgerOutboxRecovery(
     const lease = deps.acquireNotifyHub();
     if (!lease) return;
     hubLease = lease;
-    unsubscribeNotify = lease.hub.subscribe(() =>
-      requestDrain('postgres_notify'),
+    unsubscribeNotify = lease.hub.subscribe((payload) =>
+      requestDrain('postgres_notify', notificationRunId(payload)),
     );
     unsubscribeState = lease.hub.subscribeState((state) => {
       // A reconnect is a durable catch-up boundary. The controller re-reads
@@ -239,10 +283,8 @@ export function startRunLedgerOutboxRecovery(
     });
   };
 
-  requestDrain = (reason: string) => {
+  const startDrain = (reason: string) => {
     if (closed) return;
-    requested = true;
-    observabilityRequested = !!deps.dispatchObservabilityOnce;
     if (cooldownUntilMs !== null && now() < cooldownUntilMs) return;
     clearWakeTimer();
     if (drainPromise) {
@@ -260,10 +302,31 @@ export function startRunLedgerOutboxRecovery(
       })
       .finally(() => {
         drainPromise = null;
-        if (requested && !closed) requestDrain('coalesced_wake');
+        if (hasRequests() && !closed) startDrain('coalesced_wake');
       });
   };
 
+  requestDrain = (reason: string, runId?: string) => {
+    if (closed) return;
+    if (runId === undefined) {
+      requested = true;
+      observabilityRequested = !!deps.dispatchObservabilityOnce;
+      lifecycleRunHints.clear();
+      observabilityRunHints.clear();
+    } else {
+      // A pending global scan already covers these hints. Once that scan is
+      // launched its flag is consumed, so a later notification is retained.
+      if (!requested && !addRunHint(lifecycleRunHints, runId)) requested = true;
+      if (
+        deps.dispatchObservabilityOnce &&
+        !observabilityRequested &&
+        !addRunHint(observabilityRunHints, runId)
+      )
+        observabilityRequested = true;
+    }
+    startDrain(reason);
+  };
+
   const recordProjectionRetry = (retrying: number) => {
     logger.warn('[run-ledger-outbox.recovery_retry]', {
       stage: 'projection',
@@ -311,7 +374,7 @@ export function startRunLedgerOutboxRecovery(
       scheduleFailureRetry('next_due', error);
       return;
     }
-    if (closed || requested) return;
+    if (closed || hasRequests()) return;
     // When LISTEN is healthy the exact durable due time is sufficient. If the
     // optional listener is absent, down, or lost an election, an indexed
     // short safety wake discovers a fresh row that otherwise had no
@@ -337,6 +400,7 @@ export function startRunLedgerOutboxRecovery(
     type Delivery = {
       id: symbol;
       observability: boolean;
+      runId?: string;
       result:
         | PromiseSettledResult<PostgresSchedulerOutboxProjectionResult>
         | { status: 'skipped' };
@@ -371,7 +435,7 @@ export function startRunLedgerOutboxRecovery(
       completed = attempted = projected = retrying = blocked = 0;
     };
 
-    const launch = (observability = false) => {
+    const launch = (observability = false, runId?: string) => {
       const id = Symbol();
       pending.add(id);
       if (observability) pendingObservability.add(id);
@@ -380,7 +444,7 @@ export function startRunLedgerOutboxRecovery(
           dispatchFailed = true;
           scheduleFailureRetry('dispatch', result.reason);
         }
-        deliveries.push({ id, observability, result });
+        deliveries.push({ id, observability, runId, result });
         wakeActiveDrain?.();
       };
       // Subscribe once per delivery. Repeated Promise.race calls would retain
@@ -393,7 +457,7 @@ export function startRunLedgerOutboxRecovery(
         try {
           settle({
             status: 'fulfilled',
-            value: await dispatchOnce(observability),
+            value: await dispatchOnce(observability, runId),
           });
         } catch (reason) {
           settle({ status: 'rejected', reason });
@@ -404,13 +468,13 @@ export function startRunLedgerOutboxRecovery(
     const canProbeLifecycle = () =>
       !closed &&
       !dispatchFailed &&
-      requested &&
+      (requested || lifecycleRunHints.size > 0) &&
       pending.size < parallelism &&
       pending.size - pendingObservability.size < lifecycleParallelism;
     const canProbeObservability = () =>
       !closed &&
       !dispatchFailed &&
-      observabilityRequested &&
+      (observabilityRequested || observabilityRunHints.size > 0) &&
       pending.size < parallelism &&
       pendingObservability.size < observabilityParallelism;
 
@@ -420,12 +484,16 @@ export function startRunLedgerOutboxRecovery(
         // still delivering. Keep it pending when full so an empty result
         // cannot consume a notification that arrived after its query began.
         if (canProbeObservability()) {
+          const runId = observabilityRequested
+            ? undefined
+            : takeRunHint(observabilityRunHints);
           observabilityRequested = false;
-          launch(true);
+          launch(true, runId);
         }
         if (canProbeLifecycle()) {
+          const runId = requested ? undefined : takeRunHint(lifecycleRunHints);
           requested = false;
-          launch();
+          launch(false, runId);
         }
         // Productive completion permits immediate use of every free slot.
         // Empty results grant no refill, so idle work cannot spin on scans.
@@ -481,14 +549,31 @@ export function startRunLedgerOutboxRecovery(
       if (completed >= parallelism) reportDeliveries();
       // Retryable rows own durable retry clocks. The SQL claim keeps their
       // run ordered while successful slots keep unrelated runs moving.
-      if (delivery.observability) {
+      if (delivery.runId !== undefined) {
+        // Continue only the notified run. Refilling with global claims here
+        // would turn one productive scoped claim back into whole-outbox scans.
+        if (result.attempted > 0) {
+          if (delivery.observability) {
+            if (
+              !observabilityRequested &&
+              !addRunHint(observabilityRunHints, delivery.runId)
+            )
+              observabilityRequested = true;
+          } else if (
+            !requested &&
+            !addRunHint(lifecycleRunHints, delivery.runId)
+          )
+            requested = true;
+        }
+      } else if (delivery.observability) {
         observabilityRefill = result.attempted > 0;
       } else refill = result.attempted > 0;
     }
   };
 
   // Subscribe first, then scan. Notifications are lossy by design, so every
-  // wake re-reads durable state and reconnect transitions also trigger a scan.
+  // named wake re-reads that run's durable prefix. Startup, reconnect, retries
+  // and identity-less notifications retain the global recovery scan.
   attachNotifyHub();
   requestDrain('startup');
 
@@ -512,6 +597,8 @@ export function startRunLedgerOutboxRecovery(
       wakeActiveDrain?.();
       clearWakeTimer();
       cooldownUntilMs = null;
+      lifecycleRunHints.clear();
+      observabilityRunHints.clear();
       unsubscribeNotify?.();
       unsubscribeState?.();
       await drainPromise;
@@ -769,6 +856,7 @@ export function startRunLedgerOutboxRecoveryController(input: {
   const dispatch = (
     headPriority: RunLedgerOutboxHeadPriority,
     searchOnly: boolean,
+    runId?: string,
   ) =>
     dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope(
       (operation) =>
@@ -780,6 +868,7 @@ export function startRunLedgerOutboxRecoveryController(input: {
         tokenAuthority: 'gateway',
         materializeObservability: true,
         searchOnly,
+        ...(runId === undefined ? {} : { runId }),
         withObservabilityClient: (operation) =>
           withRuntimeSchedulerClient(observabilityPoolOptions, operation),
         limit: 8,
@@ -801,8 +890,8 @@ export function startRunLedgerOutboxRecoveryController(input: {
               schedulerOptions,
             }),
           ),
-    dispatchOnce: (headPriority) => dispatch(headPriority, false),
-    dispatchObservabilityOnce: () => dispatch('oldest_ready', true),
+    dispatchOnce: (headPriority, runId) => dispatch(headPriority, false, runId),
+    dispatchObservabilityOnce: (runId) => dispatch('oldest_ready', true, runId),
     observabilityParallelism: RUN_LEDGER_OUTBOX_RECOVERY_INDEX_IN_FLIGHT,
     // `dispatchRunLedgerOutboxToLedgerBatchOnceWithClientScope` releases each
     // short scheduler checkout before it calls the Vercel gateway. The two

package/dist/bundling-sources/shared_libs/product-notifications/billing-sales.ts

@@ -2,7 +2,7 @@ export const BILLING_SALES_GROUP_KEY = 'shadow.billing-sales';
 export const BILLING_SALES_DESTINATION_KEY = 'shadow.billing-sales.slack';
 export const BILLING_SALES_SLACK_CHANNEL_ID = 'C0AGWVD2TNK';
 export const BILLING_SALES_CONNECTION_ID = 'platform-reporting-bot';
-export const BILLING_SALES_CREDIT_PURCHASE_MINIMUM_CENTS = 15_000;
+export const BILLING_SALES_CREDIT_PURCHASE_MINIMUM_CENTS = 1;
 export const BILLING_PURCHASE_LATE_RULE_KEY = 'internal.billing.purchase_late';
 export const BILLING_SALES_RULE_KEYS: readonly string[] = [
   'internal.billing.credit_purchase',

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

@@ -773,7 +773,7 @@ const PRODUCT_NOTIFICATION_TYPE_REGISTRY = [
         },
       }),
       present: ({ payload }) => ({
-        title: `Credit purchase: $${(Number(payload.amountPaidCents) / 100).toFixed(2)}`,
+        title: `${payload.isFirstPurchase === true ? '🎉 First credit purchase' : 'Credit purchase'}: $${(Number(payload.amountPaidCents) / 100).toFixed(2)}`,
         summary: [
           { workspace: true },
           ` purchased ${formatCredits(Number(payload.credits))} credits.`,

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

@@ -209,7 +209,11 @@ export const PRODUCT_NOTIFICATION_EVENT_DEFINITIONS: readonly ProductNotificatio
         credits: 'number',
         targetUrl: 'string',
       },
-      optionalFacts: { amountPaidCents: 'number', currency: 'string' },
+      optionalFacts: {
+        amountPaidCents: 'number',
+        currency: 'string',
+        isFirstPurchase: 'boolean',
+      },
       orderingSubjectFact: 'accountId',
       allowedTriggers: ['threshold_crossing'],
       allowedThresholdUnits: ['credits', 'usd_cents'],

package/dist/cli/{auth-ME53BGXD.mjs → auth-7X3G2MCE.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-5UWZ52IW.mjs";
-import "./chunk-5AZNXX2S.mjs";
-import "./chunk-VWSEZMCR.mjs";
+} from "./chunk-2KLYUZI7.mjs";
+import "./chunk-4ODBHH6X.mjs";
+import "./chunk-H4MOKDCV.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-2G7KMDDI.mjs";
+import "./chunk-NZMVPYBQ.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";

package/dist/cli/auth-CYXUWRLU.js

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+var _chunkAWJ2A2CPjs = require('./chunk-AWJ2A2CP.js');
+require('./chunk-2COBRUUH.js');
+require('./chunk-ZIUELPGR.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-GMOMXQR6.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkAWJ2A2CPjs.EXIT_WORKSPACE_MISMATCH; exports.clearPendingClaim = _chunkAWJ2A2CPjs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkAWJ2A2CPjs.clearSatisfiedPendingClaim; exports.handleRegister = _chunkAWJ2A2CPjs.handleRegister; exports.handleStatus = _chunkAWJ2A2CPjs.handleStatus; exports.handleWait = _chunkAWJ2A2CPjs.handleWait; exports.readPendingAuthClaim = _chunkAWJ2A2CPjs.readPendingAuthClaim; exports.registerAuthCommands = _chunkAWJ2A2CPjs.registerAuthCommands; exports.reportSetupCompleted = _chunkAWJ2A2CPjs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkAWJ2A2CPjs.resolvePendingAuthClaimForResume;