deepline 0.3.365 → 0.3.367

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.365',
+  version: '0.3.367',
   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/observability/scheduled-jobs.json

@@ -9,7 +9,7 @@
     "locator": "schedule:",
     "owner": "product",
     "criticality": "critical",
-    "purpose": "Run clean Sonnet/Claude Code and Luna/Codex installs from the production homepage prompt through browser claim completion and the agent’s complete starter handoff.",
+    "purpose": "Run clean Sonnet/Claude Code and Luna/Codex installs from the production homepage prompt through browser claim completion and the agent\u2019s complete starter handoff.",
     "successDefinition": "Both latest coding harnesses install Deepline without installation warnings or errors, finish browser authorization and setup, present all four starter choices as a card or text, and verify test key revocation; after seven valid daily runs each finishes within 240 seconds.",
     "failureDefinition": "Either agent, browser claim completion, read-only setup verification, complete starter handoff, verified key cleanup, or the applicable timing gate fails.",
     "startGraceMs": 900000,
@@ -1304,37 +1304,37 @@
   {
     "id": "github.credit-purchase-readiness-scan",
     "name": "Credit Purchase Readiness Daily Scan",
-    "scheduler": "github_actions",
-    "cadence": "0 8 * * *",
-    "timezone": "America/New_York",
-    "source": ".github/workflows/credit-purchase-readiness-scan.yml",
-    "locator": "schedule:",
+    "scheduler": "convex_cron",
+    "cadence": "0 12 * * *",
+    "timezone": "UTC",
+    "source": "packages/convex/crons.ts",
+    "locator": "credit purchase readiness daily scan",
     "owner": "billing",
     "criticality": "critical",
-    "purpose": "Inspect every workspace through the production read-only credit addition check and retain private evidence.",
-    "successDefinition": "A complete, source-certified scan/report is retained and aggregate telemetry is ingested; account findings remain visible in the Better Stack monitor.",
-    "failureDefinition": "The scan or report is missing, incomplete, inaccessible, or cannot publish telemetry.",
+    "purpose": "Start a durable read-only credit readiness sweep; each continuation checks one workspace.",
+    "successDefinition": "The scan intent and first page are atomically scheduled; the morning report verifies fleet completion.",
+    "failureDefinition": "The scan cannot be started or its daily completion evidence is unavailable.",
     "startGraceMs": 900000,
     "runTimeoutMs": 3000000,
-    "failureAlert": "github_workflow_run",
+    "failureAlert": "convex_action_wrapper",
     "domainReportRequired": true
   },
   {
     "id": "github.credit-purchase-readiness-morning",
     "name": "Credit Purchase Readiness Morning Report",
-    "scheduler": "github_actions",
-    "cadence": "0 9 * * *",
-    "timezone": "America/New_York",
-    "source": ".github/workflows/credit-purchase-readiness-morning.yml",
-    "locator": "schedule:",
+    "scheduler": "convex_cron",
+    "cadence": "0 13 * * *",
+    "timezone": "UTC",
+    "source": "packages/convex/crons.ts",
+    "locator": "credit purchase readiness morning report",
     "owner": "billing",
     "criticality": "critical",
-    "purpose": "Publish daily issue counts and feed the Axiom to Better Stack readiness alert at 9 a.m. Eastern.",
-    "successDefinition": "A complete, source-certified scan/report is retained and aggregate telemetry is ingested; account findings remain visible in the Better Stack monitor.",
+    "purpose": "Publish daily credit readiness counts through existing Convex telemetry.",
+    "successDefinition": "Today\u2019s complete scan is reported to Axiom; purchase defects and unknown prerequisites remain visible in Better Stack.",
     "failureDefinition": "The scan or report is missing, incomplete, inaccessible, or cannot publish telemetry.",
     "startGraceMs": 900000,
     "runTimeoutMs": 600000,
-    "failureAlert": "github_workflow_run",
+    "failureAlert": "convex_action_wrapper",
     "domainReportRequired": true
   },
   {
@@ -1354,5 +1354,23 @@
     "runTimeoutMs": 120000,
     "failureAlert": "convex_action_wrapper",
     "domainReportRequired": true
+  },
+  {
+    "id": "convex.credit-purchase-readiness-page",
+    "name": "Credit purchase readiness page",
+    "scheduler": "convex_scheduled_action",
+    "cadence": "runAfter previous credit readiness checkpoint",
+    "timezone": "UTC",
+    "source": "packages/convex/scheduledJobsNode.ts",
+    "locator": "checkCreditReadinessPage",
+    "owner": "billing",
+    "criticality": "critical",
+    "purpose": "Inspect one workspace without a payment or grant and commit a fenced aggregate checkpoint.",
+    "successDefinition": "A read-only page is committed once with its next continuation, or a stale delivery is skipped.",
+    "failureDefinition": "A callback or checkpoint fails; the scan remains incomplete and the daily report pages.",
+    "startGraceMs": 120000,
+    "runTimeoutMs": 300000,
+    "failureAlert": "convex_action_wrapper",
+    "domainReportRequired": true
   }
 ]

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

@@ -9,6 +9,8 @@
  */
 export const MANUALLY_RUNNABLE_CONVEX_CRON_JOB_IDS = [
   // These persisted operations ids predate the move of their clocks to Convex.
+  'github.credit-purchase-readiness-scan',
+  'github.credit-purchase-readiness-morning',
   'inngest.play-cron-tick',
   'convex.fold-usage-rollups',
   'convex.cleanup-expired-org-day-usage-shards',

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

@@ -17960,14 +17960,18 @@ export async function renewPostgresRunLedgerDelivery(
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<void> {
   const renew = (freezeReceipt: boolean) =>
-    client.query<{ event_id: string }>(
+    client.query<{ event_id: string; pending: boolean }>(
       `
-    UPDATE ${tableName('outbox', options)}
+    WITH ${outboxByEventIdSql('target', '$1', options)}
+    UPDATE ${tableName('outbox', options)} AS outbox
     SET lease_expires_at = now() + make_interval(secs => $3::integer)
-        ${freezeReceipt ? ', delivery_batch_started_at = coalesce(delivery_batch_started_at, statement_timestamp())' : ''}
-    WHERE event_id = ANY($1::text[]) AND lease_owner = $2
-      AND delivered_at IS NULL AND failed_at IS NULL AND lease_expires_at > now()
-    RETURNING event_id
+        ${freezeReceipt ? ', delivery_batch_started_at = coalesce(outbox.delivery_batch_started_at, statement_timestamp())' : ''}
+    FROM target
+    WHERE outbox.event_id = target.event_id
+      AND target.delivered_at IS NULL AND target.failed_at IS NULL
+      AND outbox.lease_owner = $2 AND outbox.lease_expires_at > now()
+    RETURNING outbox.event_id,
+              outbox.delivered_at IS NULL AND outbox.failed_at IS NULL AS pending
   `,
       [
         input.eventIds,
@@ -17987,10 +17991,36 @@ export async function renewPostgresRunLedgerDelivery(
     markOutboxDeliveryBatchMarkerUnavailable(options);
     result = await renew(false);
   }
-  if (result.rows.length !== input.eventIds.length)
+  if (
+    result.rows.length !== input.eventIds.length ||
+    result.rows.some((row) => !row.pending)
+  )
     throw new RunLedgerProjectionLeaseLostError('delivery_lease_not_current');
 }
 
+/**
+ * Outbox rows named by event ID, read through the primary key alone. Lease
+ * statements filter this snapshot's state rather than the outbox scan: a
+ * pending-state predicate there lets a plan built from a drained outbox's
+ * statistics scan a whole pending partial index for every ID. An UPDATE that
+ * joins it re-checks its lease predicates on a concurrent change and returns
+ * the state of the version it wrote.
+ */
+function outboxByEventIdSql(
+  alias: string,
+  eventIdsParameter: string,
+  options: Pick<PostgresSchedulerOptions, 'schema'> | undefined,
+  forUpdate = false,
+): string {
+  return `${alias} AS MATERIALIZED (
+      SELECT event_id, run_id, lease_owner, lease_expires_at,
+             delivered_at, failed_at, projection_attempts
+      FROM ${tableName('outbox', options)}
+      WHERE event_id = ANY(${eventIdsParameter}::text[])
+      ${forUpdate ? 'FOR UPDATE' : ''}
+    )`;
+}
+
 // A projection receipt has always admitted at most eight ordered outbox facts.
 // Share that existing boundary between its SQL snapshot and prefix validation.
 const RUN_LEDGER_PROJECTION_PREFIX_MAX_FACTS = 8;
@@ -19266,14 +19296,13 @@ export async function settlePostgresSchedulerOutboxFailure(
     blocked: boolean;
   }>(
     `
-      WITH current_outbox AS (
+      WITH ${outboxByEventIdSql('locked', 'ARRAY[$1::text]', options, true)},
+      current_outbox AS (
         SELECT event_id, projection_attempts
-        FROM ${tableName('outbox', options)}
-        WHERE event_id = $1
-          AND delivered_at IS NULL
+        FROM locked
+        WHERE delivered_at IS NULL
           AND failed_at IS NULL
           AND ($4::text IS NULL OR lease_owner = $4)
-        FOR UPDATE
       ), settled AS (
         UPDATE ${tableName('outbox', options)} outbox
         SET projection_attempts = current_outbox.projection_attempts + 1,
@@ -19461,14 +19490,16 @@ export async function releasePostgresSchedulerOutboxLease(
   if (eventIds.length === 0 || !leaseOwner) return [];
   const result = await client.query<{ event_id: string }>(
     `
-      WITH released AS (
-        UPDATE ${tableName('outbox', options)}
+      WITH ${outboxByEventIdSql('target', '$1', options)},
+      released AS (
+        UPDATE ${tableName('outbox', options)} AS outbox
         SET lease_owner = NULL,
             lease_expires_at = NULL
-        WHERE event_id = ANY($1::text[])
-          AND delivered_at IS NULL
-          AND lease_owner = $2
-        RETURNING event_id
+        FROM target
+        WHERE outbox.event_id = target.event_id
+          AND target.delivered_at IS NULL
+          AND outbox.lease_owner = $2
+        RETURNING outbox.event_id, outbox.delivered_at IS NULL AS pending
       )
       SELECT event_id,
              pg_notify(
@@ -19476,6 +19507,7 @@ export async function releasePostgresSchedulerOutboxLease(
                json_build_object('eventId', event_id, 'kind', 'outbox_released')::text
              )
       FROM released
+      WHERE pending
     `,
     [eventIds, leaseOwner, postgresSchedulerNotifyChannel('outbox', options)],
   );
@@ -22396,14 +22428,15 @@ export async function readRunLedgerDispatchLaunchForLease(
     launch_json: unknown;
     first_claim_latency_ms: string | null;
   }>(
-    `SELECT runs.launch_json,
+    `WITH ${outboxByEventIdSql('leased', 'ARRAY[$1::text]', options)}
+     SELECT runs.launch_json,
             CASE
               WHEN runs.started_at IS NULL THEN NULL
               ELSE (
                 extract(epoch FROM (runs.started_at - runs.created_at)) * 1000
               )::bigint::text
             END AS first_claim_latency_ms
-     FROM ${tableName('outbox', options)} outbox
+     FROM leased outbox
      JOIN ${tableName('runs', options)} runs ON runs.run_id = outbox.run_id
      WHERE outbox.event_id = $1
        AND outbox.run_id = $2

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/run-ledger-dispatch-authority.ts

@@ -81,8 +81,15 @@ export async function readRunLedgerDispatchAuthorityForLease(
   options?: Pick<PostgresSchedulerOptions, 'schema'>,
 ): Promise<RunLedgerDispatchLaunch | null> {
   const result = await client.query<{ launch_json: unknown }>(
-    `SELECT ${runLedgerDispatchLaunchSql('runs')} AS launch_json
-     FROM ${dispatchTableName('outbox', options)} outbox
+    // Read the row by primary key, then filter its lease and state. A
+    // pending-state predicate on the scan lets stale statistics choose a whole
+    // pending partial index instead.
+    `WITH leased AS MATERIALIZED (
+       SELECT event_id, run_id, lease_owner, lease_expires_at, delivered_at, failed_at
+       FROM ${dispatchTableName('outbox', options)} WHERE event_id = $1
+     )
+     SELECT ${runLedgerDispatchLaunchSql('runs')} AS launch_json
+     FROM leased outbox
      JOIN ${dispatchTableName('runs', options)} runs ON runs.run_id = outbox.run_id
      WHERE outbox.event_id = $1
        AND outbox.run_id = $2

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

@@ -86,7 +86,7 @@ const RUNTIME_EVENT_LOG_POSITION_EXPRESSION = `jsonb_set(
 // Migration readiness tracks this projection body independently of scheduler
 // wire and schema versions. Bump when a changed trigger must be reinstalled.
 export const RUNTIME_EVENT_SEARCH_OUTBOX_PROJECTION_MARKER =
-  'runtime-event-search-origin-batch-fields-once';
+  'runtime-event-search-primary-key-fence-direct-independent-receipts';
 /** Trusted trigger-authored state; absent on already-projected legacy rows. */
 export const RUNTIME_EVENT_DEFERRED_PROJECTION_FIELD =
   '_runtimeSearchProjectionPending';
@@ -1905,7 +1905,7 @@ export async function attachRuntimeEventSearchTriggers(
   await client.query(`
     CREATE OR REPLACE FUNCTION ${schema}.search_receipt_event() RETURNS trigger
     LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog AS $function$
-    DECLARE play text; ref uuid; canonical_events boolean;
+    DECLARE play text; ref uuid; canonical_events boolean; deferred_run boolean;
     BEGIN
       IF NEW.status NOT IN ('completed', 'failed', 'skipped') THEN RETURN NEW; END IF;
       IF TG_OP = 'UPDATE' THEN
@@ -1918,7 +1918,10 @@ export async function attachRuntimeEventSearchTriggers(
       IF NEW.run_id IS NULL OR NEW.org_id IS NULL THEN
         RAISE EXCEPTION 'Terminal receipt search projection requires run and organization';
       END IF;
-      IF ${schema}.defer_runtime_event_projection_for_run(NEW.run_id) THEN
+      deferred_run := ${schema}.defer_runtime_event_projection_for_run(NEW.run_id);
+      -- Independent projection indexes the receipt row directly below. Only
+      -- the deferred compatibility stage still queues a receipt carrier.
+      IF deferred_run AND NOT ${schema}.independent_runtime_event_projection() THEN
         IF NOT EXISTS (SELECT 1 FROM ${schema}.runs
           WHERE run_id = NEW.run_id AND org_id = NEW.org_id) THEN
           RAISE EXCEPTION 'Terminal receipt search projection has no matching run';
@@ -1935,8 +1938,12 @@ export async function attachRuntimeEventSearchTriggers(
             FROM ${schema}.outbox WHERE run_id = NEW.run_id), clock_timestamp())));
         RETURN NEW;
       END IF;
-      -- Serialize event ordering with the same per-run lock as outbox facts.
-      PERFORM pg_advisory_xact_lock(hashtext(${quoteLiteral(scope)}), hashtext(NEW.run_id));
+      -- Inline runs serialize event ordering with the same per-run lock as
+      -- outbox facts. Independent runs index logs from a background prefix,
+      -- so this one-row receipt insert takes no log mutex and need not wait.
+      IF NOT deferred_run THEN
+        PERFORM pg_advisory_xact_lock(hashtext(${quoteLiteral(scope)}), hashtext(NEW.run_id));
+      END IF;
       SELECT play_name, run_event_store = 'planet_scale'
         INTO play, canonical_events FROM ${schema}.runs
        WHERE run_id = NEW.run_id AND org_id = NEW.org_id;
@@ -1961,7 +1968,8 @@ export async function attachRuntimeEventSearchTriggers(
           'source', 'receipt', 'producerAttempt', NEW.lease_owner_attempt,
           -- Only the reserved runtime diagnostic record supplies this flat
           -- context. Ordinary authored receipt outputs are never indexed.
-          'context', CASE WHEN NEW.k LIKE 'tool-evidence:%'
+          -- The reserved key is buildDurableToolReceiptPrefix(call-evidence).
+          'context', CASE WHEN NEW.k LIKE 'ctx:%:call:tool:call\\_evidence:%'
             AND NEW.output_json->>'kind' = 'tool_call_evidence' THEN jsonb_strip_nulls(jsonb_build_object(
               'callKey', NEW.output_json#>'{context,callKey}',
               'toolId', NEW.output_json#>'{context,toolId}',
@@ -3033,12 +3041,15 @@ export async function attachRuntimeEventSearchTriggers(
   await client.query(`
     CREATE OR REPLACE FUNCTION ${schema}.materialize_runtime_outbox_event(eid text, owner text) RETURNS jsonb
     LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog AS $function$
-    DECLARE observation ${schema}.outbox; projection_observation ${schema}.outbox;
+    DECLARE observation ${schema}.outbox; projection_observation ${schema}.outbox; still_pending boolean;
     BEGIN
-      SELECT * INTO observation FROM ${schema}.outbox
-       WHERE event_id = eid AND lease_owner = owner AND lease_expires_at > clock_timestamp()
-         AND delivered_at IS NULL AND failed_at IS NULL;
-      IF NOT FOUND THEN
+      -- Both fences probe only the primary key, then check lease and state on
+      -- that row. A pending-state predicate lets a plan built from statistics
+      -- of a drained outbox scan a whole pending partial index for every fact.
+      SELECT * INTO observation FROM ${schema}.outbox WHERE event_id = eid;
+      IF NOT FOUND OR NOT coalesce(observation.lease_owner = owner, false)
+        OR NOT coalesce(observation.lease_expires_at > clock_timestamp(), false)
+        OR observation.delivered_at IS NOT NULL OR observation.failed_at IS NOT NULL THEN
         RAISE EXCEPTION 'Deferred event projection lease is not current' USING ERRCODE = '40001';
       END IF;
       IF observation.payload_json->'${RUNTIME_EVENT_DEFERRED_PROJECTION_FIELD}' = 'true'::jsonb THEN
@@ -3049,10 +3060,11 @@ export async function attachRuntimeEventSearchTriggers(
         -- Project against immutable input without locking the outbox row.
         -- Cancellation may transfer its lease while indexing is in flight.
         -- This final fence rolls the journal back if ownership changed.
+        -- A settled row that still names this owner rolls back as well.
         UPDATE ${schema}.outbox SET payload_json = observation.payload_json
          WHERE event_id = eid AND lease_owner = owner AND lease_expires_at > clock_timestamp()
-           AND delivered_at IS NULL AND failed_at IS NULL;
-        IF NOT FOUND THEN
+        RETURNING delivered_at IS NULL AND failed_at IS NULL INTO still_pending;
+        IF NOT coalesce(still_pending, false) THEN
           RAISE EXCEPTION 'Deferred event projection lease is not current' USING ERRCODE = '40001';
         END IF;
       END IF;

package/dist/bundling-sources/shared_libs/security/receipt-admission-token.ts

@@ -75,6 +75,75 @@ async function mint(claims: Record<string, unknown>): Promise<string> {
   return `${signingInput}.${await sign(signingInput)}`;
 }
 
+/** One read-only billing observer page; cannot authorize a payment or grant. */
+export async function mintCreditReadinessToken(input: {
+  scanId: string;
+  cursor: string | null;
+  nowMs?: number;
+}): Promise<string> {
+  const issuedAt = Math.floor((input.nowMs ?? Date.now()) / 1000);
+  return mint({
+    v: TOKEN_VERSION,
+    iss: TOKEN_ISSUER,
+    aud: 'deepline.credit_readiness',
+    scanId: input.scanId,
+    cursor: input.cursor,
+    iat: issuedAt,
+    exp: issuedAt + TOKEN_TTL_SECONDS,
+  });
+}
+
+export async function verifyCreditReadinessToken(
+  token: string,
+  nowMs = Date.now(),
+): Promise<{
+  scanId: string;
+  cursor: string | null;
+}> {
+  const parts = token.split('.');
+  if (parts.length !== 3) throw new Error('Invalid credit readiness token.');
+  const decode = (value: string) =>
+    JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+  const key = await crypto.subtle.importKey(
+    'raw',
+    new TextEncoder().encode(rootSecret()),
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    ['verify'],
+  );
+  const header = decode(parts[0]);
+  const claims = decode(parts[1]);
+  const valid = await crypto.subtle.verify(
+    'HMAC',
+    key,
+    Buffer.from(parts[2], 'base64url'),
+    new TextEncoder().encode(`${parts[0]}.${parts[1]}`),
+  );
+  const now = Math.floor(nowMs / 1000);
+  if (
+    !valid ||
+    header.alg !== 'HS256' ||
+    header.typ !== 'JWT' ||
+    claims.v !== TOKEN_VERSION ||
+    claims.iss !== TOKEN_ISSUER ||
+    claims.aud !== 'deepline.credit_readiness' ||
+    typeof claims.scanId !== 'string' ||
+    !claims.scanId ||
+    (claims.cursor !== null &&
+      (typeof claims.cursor !== 'string' || !claims.cursor)) ||
+    !Number.isSafeInteger(claims.iat) ||
+    !Number.isSafeInteger(claims.exp) ||
+    claims.iat > now + 30 ||
+    claims.exp <= now ||
+    claims.exp - claims.iat !== TOKEN_TTL_SECONDS
+  )
+    throw new Error('Invalid credit readiness token.');
+  return {
+    scanId: claims.scanId,
+    cursor: claims.cursor,
+  };
+}
+
 /**
  * Bind a large request body to its capability without putting up to 1,024
  * receipt IDs in an HTTP header. JSON preserves order and length, so this is

package/dist/cli/{auth-4S26H44S.mjs → auth-2DHYG3WZ.mjs}

@@ -10,12 +10,12 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-YME4BTRK.mjs";
-import "./chunk-NDQBGF6U.mjs";
-import "./chunk-5OMKEQGL.mjs";
+} from "./chunk-3ZO2O2LE.mjs";
+import "./chunk-K4V4FX76.mjs";
+import "./chunk-OCX5D2WI.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-NXGCO4JB.mjs";
-import "./chunk-YKRINWA2.mjs";
+import "./chunk-GD2VVYGB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {

package/dist/cli/auth-I2E45QZK.js

@@ -0,0 +1,33 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+var _chunkXPIZKTYZjs = require('./chunk-XPIZKTYZ.js');
+require('./chunk-D7SELX66.js');
+require('./chunk-R2HHZLOP.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-B7JTGFDS.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkXPIZKTYZjs.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunkXPIZKTYZjs.authStatusLine; exports.clearPendingClaim = _chunkXPIZKTYZjs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkXPIZKTYZjs.clearSatisfiedPendingClaim; exports.handleRegister = _chunkXPIZKTYZjs.handleRegister; exports.handleStatus = _chunkXPIZKTYZjs.handleStatus; exports.handleWait = _chunkXPIZKTYZjs.handleWait; exports.readPendingAuthClaim = _chunkXPIZKTYZjs.readPendingAuthClaim; exports.registerAuthCommands = _chunkXPIZKTYZjs.registerAuthCommands; exports.reportSetupCompleted = _chunkXPIZKTYZjs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkXPIZKTYZjs.resolvePendingAuthClaimForResume;

package/dist/cli/{billing-IMSQT3SR.mjs → billing-VFBFBOO5.mjs}

@@ -2,7 +2,7 @@ import {
   DeeplineClient,
   iterateCursorPages,
   requireBillingIdempotencyKey
-} from "./chunk-6RX64O34.mjs";
+} from "./chunk-JNQECSK5.mjs";
 import "./chunk-6IKARAYD.mjs";
 import "./chunk-CBVIJSHF.mjs";
 import {
@@ -11,16 +11,16 @@ import {
   openInBrowser,
   printCommandEnvelope,
   shouldEmitJson
-} from "./chunk-NDQBGF6U.mjs";
+} from "./chunk-K4V4FX76.mjs";
 import {
   AuthError,
   ConfigError
-} from "./chunk-5OMKEQGL.mjs";
+} from "./chunk-OCX5D2WI.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import {
   DeeplineError
 } from "./chunk-NXGCO4JB.mjs";
-import "./chunk-YKRINWA2.mjs";
+import "./chunk-GD2VVYGB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";