deepline 0.3.306 → 0.3.307

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.306',
+  version: '0.3.307',
   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/absurd-shared.ts

@@ -614,9 +614,15 @@ export function ensureAbsurdRuntimeReady(
   const existing = absurdReadyPromises.get(key);
   if (existing) return existing;
   const promise = (async () => {
-    await withRuntimeSchedulerClient(poolOptions, (client) =>
-      assertAbsurdSchemaReady(client),
-    );
+    const absurd = createAbsurdRuntimeClient(poolOptions, runsQueue);
+    // Cold admission pays both reads. Queue inventory does not depend on the
+    // compatibility result, but maintenance and queue writes require both.
+    const [, queueNames] = await Promise.all([
+      withRuntimeSchedulerClient(poolOptions, (client) =>
+        assertAbsurdSchemaReady(client),
+      ),
+      absurd.listQueues(),
+    ]);
     // Hard-cutover cleanup: an old worker may have persisted a run waiting
     // on a scheduled ctx.runPlay child. This runtime intentionally has no such
     // scheduler anymore, so make the affected run visibly failed and emit
@@ -624,8 +630,7 @@ export function ensureAbsurdRuntimeReady(
     await withRuntimeSchedulerClient(poolOptions, (client) =>
       failPostgresSchedulerScheduledChildWaits(client, schedulerOptions),
     );
-    const absurd = createAbsurdRuntimeClient(poolOptions, runsQueue);
-    const existingQueues = new Set(await absurd.listQueues());
+    const existingQueues = new Set(queueNames);
     if (!existingQueues.has(runsQueue)) {
       await absurd.createQueue(runsQueue);
     }

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

@@ -351,8 +351,10 @@ const POSTGRES_SCHEDULER_SCHEMA_INIT_STATEMENT_TIMEOUT_MS = 60_000;
 // until the separately operated, reader-first cutover.
 // v59 adds origin identity bulk projection and independent durable search progress.
 // v60 indexes all sandbox leases by Run, including released custody history.
+// v61 adds an operator-owned new-run projection cutover and admission pin.
+// Existing namespace mode values and unpinned runs keep their behavior.
 // This marker records deployment work, never a runtime schema floor.
-export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 60;
+export const POSTGRES_SCHEDULER_SCHEMA_VERSION = 61;
 const POSTGRES_SCHEDULER_SCHEMA_MIGRATIONS_TABLE =
   'scheduler_schema_migrations';
 export const POSTGRES_SCHEDULER_OPEN_RECOVERY_INDEX =
@@ -2499,6 +2501,7 @@ export async function ensurePostgresSchedulerLaunchAdmissionFunctions(
           launch_json - ARRAY[
             'launchIdentityDigest',
             'runtimeLogIdentity',
+            'runtimeEventProjection',
             'executorToken',
             'inputFileId',
             'preloadedDbSessionUnwrapKey',

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

@@ -61,7 +61,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-batches-log-metadata-point-replay';
+  'runtime-event-search-origin-batches-new-run-cutover-fresh-origin';
 /** Trusted trigger-authored state; absent on already-projected legacy rows. */
 export const RUNTIME_EVENT_DEFERRED_PROJECTION_FIELD =
   '_runtimeSearchProjectionPending';
@@ -976,6 +976,7 @@ export async function setRuntimeEventDeferredProjection(
   runtimeScope: string,
   deferred: boolean,
   independent?: boolean,
+  newRunsOnly?: true,
 ): Promise<void> {
   const schema = quoteIdent(requiredScope(runtimeScope));
   if (!(await hasRuntimeEventSearchShape(client, runtimeScope))) {
@@ -991,11 +992,38 @@ export async function setRuntimeEventDeferredProjection(
   await client.query('BEGIN');
   try {
     await client.query("SELECT set_config('lock_timeout', '1000', true)");
+    // Fence admission before outbox writes, in the normal Run -> outbox order.
+    // The admission pin and producer flags change at one committed boundary.
+    await client.query(`LOCK TABLE ${schema}.runs IN SHARE ROW EXCLUSIVE MODE`);
     // Fence trigger execution while changing mode. This operator-only lock
     // never spans projection; normal producer writes acquire no such lock.
     await client.query(
       `LOCK TABLE ${schema}.outbox IN SHARE ROW EXCLUSIVE MODE`,
     );
+    const previous = await client.query<{
+      deferred: boolean;
+      new_runs_only: boolean;
+    }>(`SELECT ${schema}.defer_runtime_event_projection() AS deferred,
+        ${schema}.new_runs_only_runtime_event_projection() AS new_runs_only`);
+    const scoped =
+      newRunsOnly === true || previous.rows[0]?.new_runs_only === true;
+    if (deferred && scoped && independent === false) {
+      throw new Error(
+        'Scoped cutover requires independent projection; use disable to stop it.',
+      );
+    }
+    if (newRunsOnly === true) {
+      if (!deferred || independent !== true) {
+        throw new Error(
+          'New-run cutover requires independent deferred projection.',
+        );
+      }
+      if (previous.rows[0]?.deferred && !previous.rows[0]?.new_runs_only) {
+        throw new Error(
+          'Drain and disable global deferred projection before a new-run cutover.',
+        );
+      }
+    }
     if (!deferred) {
       const pending = await client.query<{ event_id: string }>(
         `SELECT event_id FROM ${schema}.outbox
@@ -1019,12 +1047,14 @@ export async function setRuntimeEventDeferredProjection(
         );
     }
     await installRuntimeEventProjectionMode(client, schema, deferred);
-    if (independent !== undefined || !deferred)
+    if (independent !== undefined || !deferred || scoped)
       await installIndependentProjectionMode(
         client,
         schema,
-        deferred && independent === true,
+        deferred && (independent === true || scoped),
       );
+    if (newRunsOnly !== undefined)
+      await installNewRunProjectionMode(client, schema, newRunsOnly);
     await client.query('COMMIT');
   } catch (error) {
     await client.query('ROLLBACK');
@@ -1036,10 +1066,12 @@ export type RuntimeEventProjectionModes = {
   runtimeScope: string;
   deferred: boolean | null;
   independent: boolean | null;
+  newRunsOnly?: boolean | null;
   unavailableReason:
     | 'projection_mode_readers_missing'
     | 'deferred_projection_reader_missing'
     | 'independent_projection_reader_missing'
+    | 'new_run_projection_reader_missing'
     | null;
 };
 
@@ -1053,25 +1085,31 @@ export async function readRuntimeEventProjectionModes(
   const installed = await client.query<{
     deferred_installed: boolean;
     independent_installed: boolean;
+    new_runs_only_installed: boolean;
   }>(
     `SELECT to_regprocedure($1) IS NOT NULL AS deferred_installed,
-            to_regprocedure($2) IS NOT NULL AS independent_installed`,
+            to_regprocedure($2) IS NOT NULL AS independent_installed,
+            to_regprocedure($3) IS NOT NULL AS new_runs_only_installed`,
     [
       `${schema}.defer_runtime_event_projection()`,
       `${schema}.independent_runtime_event_projection()`,
+      `${schema}.new_runs_only_runtime_event_projection()`,
     ],
   );
   const readers = installed.rows[0];
   if (
     !readers ||
     typeof readers.deferred_installed !== 'boolean' ||
-    typeof readers.independent_installed !== 'boolean'
+    typeof readers.independent_installed !== 'boolean' ||
+    typeof readers.new_runs_only_installed !== 'boolean'
   ) {
     throw new Error('Runtime projection mode lookup returned no reader state.');
   }
   const unavailableReason = readers.deferred_installed
     ? readers.independent_installed
-      ? null
+      ? readers.new_runs_only_installed
+        ? null
+        : 'new_run_projection_reader_missing'
       : 'independent_projection_reader_missing'
     : readers.independent_installed
       ? 'deferred_projection_reader_missing'
@@ -1081,6 +1119,7 @@ export async function readRuntimeEventProjectionModes(
       runtimeScope: scope,
       deferred: null,
       independent: null,
+      newRunsOnly: null,
       unavailableReason,
     };
   }
@@ -1091,18 +1130,25 @@ export async function readRuntimeEventProjectionModes(
   const independentExpression = readers.independent_installed
     ? `${schema}.independent_runtime_event_projection()`
     : 'NULL::boolean';
+  const newRunsOnlyExpression = readers.new_runs_only_installed
+    ? `${schema}.new_runs_only_runtime_event_projection()`
+    : 'NULL::boolean';
   const result = await client.query<{
     deferred: boolean | null;
     independent: boolean | null;
+    new_runs_only: boolean | null;
   }>(
     `SELECT ${deferredExpression} AS deferred,
-            ${independentExpression} AS independent`,
+            ${independentExpression} AS independent,
+            ${newRunsOnlyExpression} AS new_runs_only`,
   );
   const modes = result.rows[0];
   if (
     !modes ||
     (readers.deferred_installed && typeof modes.deferred !== 'boolean') ||
-    (readers.independent_installed && typeof modes.independent !== 'boolean')
+    (readers.independent_installed && typeof modes.independent !== 'boolean') ||
+    (readers.new_runs_only_installed &&
+      typeof modes.new_runs_only !== 'boolean')
   ) {
     throw new Error('Runtime projection mode lookup returned invalid values.');
   }
@@ -1110,6 +1156,7 @@ export async function readRuntimeEventProjectionModes(
     runtimeScope: scope,
     deferred: modes.deferred,
     independent: modes.independent,
+    newRunsOnly: modes.new_runs_only,
     unavailableReason,
   };
 }
@@ -1121,27 +1168,32 @@ export async function inspectRuntimeEventProjection(
 ): Promise<{
   deferred: boolean;
   independent: boolean;
+  newRunsOnly: boolean | null;
   pending: number;
   blocked: number;
   oldestPendingAt: string | null;
 }> {
   const schema = quoteIdent(requiredScope(runtimeScope));
+  const modes = await readRuntimeEventProjectionModes(client, runtimeScope);
+  if (modes.deferred === null || modes.independent === null) {
+    throw new Error(
+      'Install the deferred projection readers before inspecting the outbox.',
+    );
+  }
   const result = await client.query<{
-    deferred: boolean;
-    independent: boolean;
     pending: string | number;
     blocked: string | number;
     oldest: Date | string | null;
-  }>(`SELECT ${schema}.defer_runtime_event_projection() AS deferred, ${schema}.independent_runtime_event_projection() AS independent,
-      count(*) AS pending, count(*) FILTER (WHERE failed_at IS NOT NULL) AS blocked,
+  }>(`SELECT count(*) AS pending, count(*) FILTER (WHERE failed_at IS NOT NULL) AS blocked,
       min(created_at) AS oldest
     FROM ${schema}.outbox
     WHERE delivered_at IS NULL
       AND payload_json->'${RUNTIME_EVENT_DEFERRED_PROJECTION_FIELD}' = 'true'::jsonb`);
   const state = result.rows[0]!;
   return {
-    deferred: state.deferred,
-    independent: state.independent,
+    deferred: modes.deferred,
+    independent: modes.independent,
+    newRunsOnly: modes.newRunsOnly ?? null,
     pending: Number(state.pending),
     blocked: Number(state.blocked),
     oldestPendingAt: state.oldest === null ? null : iso(state.oldest),
@@ -1173,6 +1225,18 @@ async function installIndependentProjectionMode(
   );
 }
 
+async function installNewRunProjectionMode(
+  client: PostgresSchedulerQueryClient,
+  schema: string,
+  enabled: boolean,
+): Promise<void> {
+  await client.query(`CREATE OR REPLACE FUNCTION ${schema}.new_runs_only_runtime_event_projection()
+    RETURNS boolean LANGUAGE sql VOLATILE SET search_path = pg_catalog AS 'SELECT ${enabled ? 'true' : 'false'}'`);
+  await client.query(
+    `REVOKE ALL ON FUNCTION ${schema}.new_runs_only_runtime_event_projection() FROM PUBLIC`,
+  );
+}
+
 /**
  * Migration installs readers with synchronous production unchanged. After
  * cutover, the producer persists raw input and only the leased dispatcher
@@ -1198,6 +1262,19 @@ export async function attachRuntimeEventSearchTriggers(
   );
   if (!independentMode.rows[0]?.installed)
     await installIndependentProjectionMode(client, schema, false);
+  const newRunMode = await client.query<{ installed: boolean }>(
+    `SELECT to_regprocedure($1) IS NOT NULL AS installed`,
+    [`${schema}.new_runs_only_runtime_event_projection()`],
+  );
+  if (!newRunMode.rows[0]?.installed)
+    await installNewRunProjectionMode(client, schema, false);
+  await client.query(`CREATE OR REPLACE FUNCTION ${schema}.defer_runtime_event_projection_for_run(rid text)
+    RETURNS boolean LANGUAGE sql VOLATILE SECURITY DEFINER SET search_path = pg_catalog AS $function$
+      SELECT ${schema}.defer_runtime_event_projection() AND
+        (NOT ${schema}.new_runs_only_runtime_event_projection() OR coalesce(
+          (SELECT admission_json->>'runtimeEventProjection' = 'independent'
+            FROM ${schema}.runs WHERE run_id = rid), false))
+    $function$`);
   // Stamp new admissions once. Existing launches never acquire a producer pin
   // on replay or worker upgrade. Ignore a caller-supplied pin before cutover.
   await client.query(`CREATE OR REPLACE FUNCTION ${schema}.pin_runtime_log_identity() RETURNS trigger
@@ -1205,6 +1282,25 @@ export async function attachRuntimeEventSearchTriggers(
     BEGIN
       NEW.launch_json := NEW.launch_json - 'runtimeLogIdentity';
       NEW.admission_json := NEW.admission_json - 'runtimeLogIdentity';
+      NEW.launch_json := NEW.launch_json - 'runtimeEventProjection';
+      NEW.admission_json := NEW.admission_json - 'runtimeEventProjection';
+      IF ${schema}.new_runs_only_runtime_event_projection()
+        AND ${schema}.defer_runtime_event_projection()
+        AND ${schema}.independent_runtime_event_projection() THEN
+        -- Older writers may omit admission_json. Preserve their authority
+        -- using the same transport-free projection as normal admission.
+        NEW.admission_json := coalesce(NEW.admission_json,
+          NEW.launch_json - ARRAY[
+            'executorToken',
+            'preloadedDbSessionUnwrapKey',
+            'preloadedDbSessions',
+            'submittedAtMs',
+            'runtimeDeployVersion',
+            'coordinatorInternalToken',
+            'vercelProtectionBypassToken'
+          ]::text[])
+          || '{"runtimeEventProjection":"independent"}'::jsonb;
+      END IF;
       IF ${schema}.independent_runtime_event_projection() THEN
         NEW.launch_json := NEW.launch_json || '{"runtimeLogIdentity":"origin"}'::jsonb;
         NEW.admission_json := NEW.admission_json || '{"runtimeLogIdentity":"origin"}'::jsonb;
@@ -1227,7 +1323,7 @@ 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() THEN
+      IF ${schema}.defer_runtime_event_projection_for_run(NEW.run_id) 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';
@@ -1388,6 +1484,12 @@ export async function attachRuntimeEventSearchTriggers(
         ON CONFLICT (runtime_scope, org_id, event_id) DO NOTHING RETURNING event_id
       ) SELECT coalesce(array_agg(inserted.event_id ORDER BY entries.ordinal), ARRAY[]::text[])
         INTO fresh FROM inserted JOIN entries ON entries.eid = inserted.event_id;
+      -- The INSERT already proves the content of every fresh identity. Only
+      -- retries or a concurrent uniqueness winner need a journal read-back.
+      -- This fast path serves both inline and background origin projection.
+      IF cardinality(fresh) = jsonb_array_length(item->'lines') THEN
+        RETURN fresh;
+      END IF;
       -- A new READ COMMITTED statement sees a concurrent uniqueness winner.
       -- Tombstones retain digest/identity: retry never restores an expired body.
       SELECT count(*) INTO mismatches
@@ -1432,7 +1534,7 @@ export async function attachRuntimeEventSearchTriggers(
       -- writers lock attempt before Run; this recorder must not invert that.
       -- Stable batches are ordered by the leased background prefix and cursor row.
       -- The legacy alias path still needs its old transaction mutex.
-      IF NOT ${schema}.defer_runtime_event_projection() THEN
+      IF NOT ${schema}.defer_runtime_event_projection_for_run(observation.run_id) THEN
         PERFORM pg_advisory_xact_lock(hashtext(${quoteLiteral(scope)}), hashtext(observation.run_id));
       END IF;
       SELECT org_id, play_name, run_log_store = 'planet_scale', status,
@@ -1549,7 +1651,7 @@ export async function attachRuntimeEventSearchTriggers(
         ));
       END IF;
       IF event_batch IS NOT NULL THEN
-        IF ${schema}.defer_runtime_event_projection() AND EXISTS (SELECT 1 FROM jsonb_array_elements(event_batch) entry WHERE entry->>'type' = ${RUN_EVENT_KIND_SQL_LITERAL.logAppended} AND (NOT (entry ? 'lineIds') OR jsonb_typeof(entry->'lineIds') IS DISTINCT FROM 'array' OR EXISTS (SELECT 1 FROM jsonb_array_elements(CASE WHEN jsonb_typeof(entry->'lineIds') = 'array' THEN entry->'lineIds' ELSE '[]'::jsonb END) id WHERE id = 'null'::jsonb))) THEN
+        IF ${schema}.defer_runtime_event_projection_for_run(observation.run_id) AND EXISTS (SELECT 1 FROM jsonb_array_elements(event_batch) entry WHERE entry->>'type' = ${RUN_EVENT_KIND_SQL_LITERAL.logAppended} AND (NOT (entry ? 'lineIds') OR jsonb_typeof(entry->'lineIds') IS DISTINCT FROM 'array' OR EXISTS (SELECT 1 FROM jsonb_array_elements(CASE WHEN jsonb_typeof(entry->'lineIds') = 'array' THEN entry->'lineIds' ELSE '[]'::jsonb END) id WHERE id = 'null'::jsonb))) THEN
           PERFORM pg_advisory_xact_lock(hashtext(${quoteLiteral(scope)}), hashtext(observation.run_id));
         END IF;
         -- Normalize old positional writers once per batch under the run mutex.
@@ -2252,7 +2354,7 @@ export async function attachRuntimeEventSearchTriggers(
     DECLARE run_closed boolean; search_payload jsonb;
     BEGIN
       IF NEW.payload_json->'${RUNTIME_EVENT_SEARCH_ONLY_FIELD}' = 'true'::jsonb THEN RETURN NEW; END IF;
-      IF ${schema}.defer_runtime_event_projection()
+      IF ${schema}.defer_runtime_event_projection_for_run(NEW.run_id)
         AND NEW.event_type <> ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runCreated} THEN
         IF NEW.event_type = ${RUN_SCHEDULER_OUTBOX_EVENT_TYPE_SQL_LITERAL.runEvents} THEN
           -- One cheap Run fence captures whether ingress preceded terminal
@@ -2378,7 +2480,7 @@ export async function attachRuntimeEventSearchTriggers(
                 THEN NEW.runner_log_payload_json->'terminalProgressEvents'
               ELSE '[]'::jsonb END) WITH ORDINALITY AS progress(event, position)
           ));
-        IF ${schema}.defer_runtime_event_projection() THEN
+        IF ${schema}.defer_runtime_event_projection_for_run(NEW.run_id) THEN
           INSERT INTO ${schema}.outbox (event_id, run_id, event_type, payload_json, created_at)
           VALUES (observation.event_id, observation.run_id, observation.event_type,
             observation.payload_json,
@@ -2474,6 +2576,8 @@ export async function attachRuntimeEventSearchTriggers(
   await client.query(`REVOKE ALL ON FUNCTION ${schema}.project_outbox_event(${schema}.outbox),
     ${schema}.project_origin_log_batch(${schema}.outbox, jsonb, text, text, boolean, boolean, timestamptz, jsonb, boolean),
     ${schema}.independent_runtime_event_projection(),
+    ${schema}.new_runs_only_runtime_event_projection(),
+    ${schema}.defer_runtime_event_projection_for_run(text),
     ${schema}.pin_runtime_log_identity(),
     ${schema}.materialize_runtime_outbox_event(text, text),
     ${schema}.guard_runtime_outbox_ack(),
@@ -2499,6 +2603,8 @@ export async function hasRuntimeEventSearchShape(
       AND EXISTS (SELECT 1 FROM pg_trigger WHERE tgrelid = to_regclass('${schema}.outbox')
         AND tgname = 'runtime_outbox_projection_ack_v1' AND tgenabled <> 'D')
       AND to_regprocedure('${schema}.defer_runtime_event_projection()') IS NOT NULL
+      AND to_regprocedure('${schema}.new_runs_only_runtime_event_projection()') IS NOT NULL
+      AND to_regprocedure('${schema}.defer_runtime_event_projection_for_run(text)') IS NOT NULL
       AND to_regclass('runtime_observability.events') IS NOT NULL
       AND to_regclass('runtime_observability.run_log_cursors') IS NOT NULL
       AND EXISTS (SELECT 1 FROM pg_attribute

package/dist/cli/{auth-WTC7LCQ6.mjs → auth-AJPTFFC7.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-7XORS6WQ.mjs";
-import "./chunk-5V56XCQN.mjs";
-import "./chunk-4PSSDZQB.mjs";
+} from "./chunk-ZGICKTW7.mjs";
+import "./chunk-D55NIPGU.mjs";
+import "./chunk-MPVXXDWH.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-WWPI4GJI.mjs";
+import "./chunk-QACDLYNO.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";

package/dist/cli/auth-TUQTQIH4.js

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

package/dist/cli/{billing-VQM65LVP.mjs → billing-LPDYJLIL.mjs}

@@ -1,7 +1,7 @@
 import {
   DeeplineClient,
   iterateCursorPages
-} from "./chunk-LLGF6V6I.mjs";
+} from "./chunk-TLTKAJ6S.mjs";
 import "./chunk-CBVIJSHF.mjs";
 import {
   createTimestampedName,
@@ -9,13 +9,13 @@ import {
   openInBrowser,
   printCommandEnvelope,
   shouldEmitJson
-} from "./chunk-5V56XCQN.mjs";
+} from "./chunk-D55NIPGU.mjs";
 import {
   AuthError,
   ConfigError
-} from "./chunk-4PSSDZQB.mjs";
+} from "./chunk-MPVXXDWH.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-WWPI4GJI.mjs";
+import "./chunk-QACDLYNO.mjs";
 import "./chunk-6IKARAYD.mjs";
 import {
   DeeplineError