deepline 0.3.470 → 0.3.472

package/dist/bundling-sources/sdk/src/client-core.ts

@@ -126,6 +126,7 @@ import type {
   PlayRunListItem,
   PlaysActivityResponse,
   PlayDetail,
+  PlayCostEstimateResult,
   PlayCheckResult,
   PlayRunResult,
   PlayRunStart,
@@ -593,6 +594,8 @@ export type RunsHistoryPage = {
 };
 
 export type PlaysListOptions = {
+  /** Load compact inventory metadata without authored source or revisions. */
+  summaryOnly?: boolean;
   origin?: 'prebuilt' | 'owned';
   grep?: string;
   /**
@@ -2072,6 +2075,11 @@ export type TargetBillingPlan = {
     | 'legacy-growth-v1';
   name: string;
   recurring_price_usd: number;
+  /**
+   * The first month's fee for switching to this plan when a first-month
+   * discount is offered; null or absent means the list price.
+   */
+  first_month_price_usd?: number | null;
   interval: 'month' | 'year';
   included_credits: number;
   /** Offered benefit terms; omitted by older API deployments. */
@@ -5338,6 +5346,7 @@ export class DeeplineClient {
     if (paginateInventory && !options?.grep?.trim())
       params.set('inventory_paginated', '1');
     if (options?.origin) params.set('origin', options.origin);
+    if (options?.summaryOnly) params.set('summary_only', '1');
     if (options?.categories) {
       params.set(
         'categories',
@@ -5922,6 +5931,11 @@ export class DeeplineClient {
     return this.playClient.getPlay(name, options);
   }
 
+  /** Estimate one Play without reading the rest of the workspace catalog. */
+  async getPlayCostEstimate(name: string): Promise<PlayCostEstimateResult> {
+    return this.http.get(`/api/v2/plays/${encodeURIComponent(name)}/cost`);
+  }
+
   /** Read one trigger inventory page without loading run histories. */
   async listPlayTriggerInventory(options?: { cursor?: string }): Promise<{
     page: Array<{

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

@@ -331,6 +331,7 @@ export type {
   PlayRunActionPackage,
   PlayRunDatasetActions,
   PlayRunPackage,
+  PlayRunRateLimited,
   PlayActivityObservation,
   PlayActivityState,
   PlayActivityTarget,
@@ -343,6 +344,7 @@ export type {
   PublishPlayVersionResult,
   StartPlayRunRequest,
   PlayCostEstimate,
+  PlayCostEstimateResult,
   PlayListItem,
   PlaysActivityResponse,
   CustomerDbQueryResult,

package/dist/bundling-sources/sdk/src/plays/run-request.ts

@@ -453,6 +453,7 @@ export function normalizePlayRunStart(
     ...(runPackage.run.dashboardUrl
       ? { dashboardUrl: runPackage.run.dashboardUrl }
       : {}),
+    ...(runPackage.rateLimited ? { rateLimited: runPackage.rateLimited } : {}),
     ...(isTerminalPlayRunLifecycleStatus(status)
       ? raw.finalStatusView === 'full' && raw.runId === runPackage.run.id
         ? { finalStatus: raw, finalStatusView: 'full' as const }

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

@@ -205,7 +205,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.470',
+  version: '0.3.472',
   updateSummary: {
     introducedIn: '0.3.90',
     summary:

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

@@ -847,6 +847,22 @@ export type PlayRunDatasetActions = {
   };
 };
 
+/**
+ * Present when no run started because the Play's `rateLimit` window is held.
+ * The response then describes `latestRunId`, an earlier run, not a new one.
+ */
+export interface PlayRunRateLimited {
+  code: 'PLAY_RUN_RATE_LIMITED';
+  latestRunId: string;
+  /** ISO time the latest run started its window. */
+  latestRunStartedAt: string;
+  /** ISO time the next run can start. */
+  nextAllowedAt: string;
+  everySeconds: number;
+  /** One-line explanation to show the caller. */
+  message: string;
+}
+
 /**
  * Compact canonical run package for SDK/CLI consumers: stable metadata,
  * output handles and follow-up actions without dashboard internals.
@@ -856,6 +872,8 @@ export interface PlayRunPackage {
   schemaVersion: 1;
   /** Package discriminator. */
   kind: 'play_run';
+  /** Set when this package is the latest run returned instead of a new one. */
+  rateLimited?: PlayRunRateLimited;
   /** Retained return structure with dataset references, not flattened output previews. */
   result?: unknown;
   /** Full-only values are omitted as a whole, never replaced with partial authored data. */
@@ -1266,6 +1284,8 @@ export interface RerunPlayRunResult {
    * servers.
    */
   deduplicated?: boolean;
+  /** Set when no rerun started; `runId` is then the Play's latest run. */
+  rateLimited?: PlayRunRateLimited;
   next: { inspect: string; input: string };
 }
 
@@ -1612,6 +1632,13 @@ export interface PlayDefinitionDetail {
   currentPublishedVersion?: number | null;
 }
 
+/** Advisory pricing for one saved or prebuilt Play in the current workspace. */
+export type PlayCostEstimateResult = {
+  reference: string;
+  costEstimate: PlayCostEstimate;
+  observedCost?: PrebuiltPlayObservedCost;
+};
+
 export type PlayCostEstimate =
   | {
       status: 'available';
@@ -1902,6 +1929,8 @@ export interface PlayRunStart {
   finalStatusView?: 'full';
   /** Canonical compact run package returned by current SDK/API responses. */
   package?: PlayRunPackage;
+  /** Set when no run started; `workflowId` is then the Play's latest run. */
+  rateLimited?: PlayRunRateLimited;
 }
 
 /**

package/dist/bundling-sources/shared_libs/play-runtime/context.ts

@@ -15565,7 +15565,9 @@ export class PlayContextImpl implements ScalarPlayAuthoringRuntimeContext {
       this.steps.push(step);
     }
     this.log(
-      `ctx.runPlayAsync(${normalizedKey}): admitted ${resolvedName} as ${launched.runId}`,
+      launched.rateLimited
+        ? `ctx.runPlayAsync(${normalizedKey}): ${launched.rateLimited.message}`
+        : `ctx.runPlayAsync(${normalizedKey}): admitted ${resolvedName} as ${launched.runId}`,
     );
     return launched;
   }

package/dist/bundling-sources/shared_libs/play-runtime/play-admission-outcome.ts

@@ -40,6 +40,14 @@ export const PLAY_RUN_LAUNCH_CONFLICT = 'PLAY_RUN_LAUNCH_CONFLICT' as const;
 export const PLAY_RUNTIME_CALLBACK_UNCONFIGURED =
   'PLAY_RUNTIME_CALLBACK_UNCONFIGURED' as const;
 
+/**
+ * The Play's declared `rateLimit` already started a run in the current
+ * window. The source is settled as skipped: no Run, no retry, not a DLQ item.
+ */
+export const PLAY_RUN_RATE_LIMITED = 'PLAY_RUN_RATE_LIMITED' as const;
+
+export type PlayAdmissionSkippedCode = typeof PLAY_RUN_RATE_LIMITED;
+
 export type PlayAdmissionBlockedCode =
   | typeof PLAY_ADMISSION_PAYLOAD_UNREADABLE
   | typeof PLAY_SECRET_UNAVAILABLE
@@ -63,6 +71,12 @@ export type PlayAdmissionFailure =
       disposition: 'blocked';
       code: PlayAdmissionBlockedCode;
       message: string;
+    }
+  | {
+      /** Settle the source terminally without a Run; nothing to repair or retry. */
+      disposition: 'skipped';
+      code: PlayAdmissionSkippedCode;
+      message: string;
     };
 
 const TERMINAL_PRE_ADMISSION_CODES = new Set<PlayAdmissionBlockedCode>([
@@ -87,18 +101,23 @@ function blocked(code: PlayAdmissionBlockedCode): PlayAdmissionFailure {
   };
 }
 
+const PLAY_RUN_RATE_LIMITED_MESSAGE =
+  "Rate limited: this Play's rateLimit already started a run in the current window, so this delivery started no run. It is not retried.";
+
 /**
- * The customer-facing reason for a blocked source. A deferred batch settles by
+ * The customer-facing reason for a blocked or skipped source. A deferred batch settles by
  * code alone, so the reason must be derivable from the stable code.
  */
 export function playAdmissionBlockedMessage(code: string): string {
-  return code === PLAY_SECRET_UNAVAILABLE
-        ? 'The Play configuration is unavailable. Repair it, then retry this delivery.'
-        : code === PLAY_RUN_LAUNCH_CONFLICT
-          ? 'This run identity is already bound to a different launch. Repair the trigger identity before retrying this delivery.'
-          : code === PLAY_RUNTIME_CALLBACK_UNCONFIGURED
-            ? 'This deployment has no public runtime callback URL, so Play workers cannot report progress. Configure the callback (local dev: start the dev tunnel), then retry this delivery.'
-            : 'This delivery needs attention before it can be retried.';
+  return code === PLAY_RUN_RATE_LIMITED
+    ? PLAY_RUN_RATE_LIMITED_MESSAGE
+    : code === PLAY_SECRET_UNAVAILABLE
+      ? 'The Play configuration is unavailable. Repair it, then retry this delivery.'
+      : code === PLAY_RUN_LAUNCH_CONFLICT
+        ? 'This run identity is already bound to a different launch. Repair the trigger identity before retrying this delivery.'
+        : code === PLAY_RUNTIME_CALLBACK_UNCONFIGURED
+          ? 'This deployment has no public runtime callback URL, so Play workers cannot report progress. Configure the callback (local dev: start the dev tunnel), then retry this delivery.'
+          : 'This delivery needs attention before it can be retried.';
 }
 
 /**
@@ -135,6 +154,13 @@ export function classifyPlayAdmissionFailure(
     return blocked(PLAY_SECRET_UNAVAILABLE);
   }
   const code = stableErrorCode(error);
+  if (code === PLAY_RUN_RATE_LIMITED) {
+    return {
+      disposition: 'skipped',
+      code,
+      message: PLAY_RUN_RATE_LIMITED_MESSAGE,
+    };
+  }
   if (
     code !== null &&
     TERMINAL_PRE_ADMISSION_CODES.has(code as PlayAdmissionBlockedCode)

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

@@ -6330,6 +6330,32 @@ function cronOccurrenceLaunch(input: {
   });
 }
 
+function cronSuccessorDueAtMs(schedule: PostgresSchedulerCronSchedule): number {
+  let successorDueAtMs: number;
+  try {
+    successorDueAtMs = advanceWorkflowCronSchedule(
+      schedule.cron,
+      Math.max(Date.now(), schedule.dueAtMs),
+      schedule.timezone,
+    );
+  } catch (error) {
+    throw new PostgresSchedulerCronScheduleConfigurationError(
+      `Cron schedule "${schedule.scheduleId}" has an invalid pinned expression or timezone: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    );
+  }
+  if (
+    !Number.isSafeInteger(successorDueAtMs) ||
+    successorDueAtMs <= schedule.dueAtMs
+  ) {
+    throw new PostgresSchedulerCronScheduleConfigurationError(
+      `Cron schedule "${schedule.scheduleId}" did not produce a future successor occurrence.`,
+    );
+  }
+  return successorDueAtMs;
+}
+
 export type FirePostgresSchedulerCronScheduleInput = {
   scheduleId: string;
   generation: number;
@@ -6388,28 +6414,7 @@ export async function firePostgresSchedulerCronSchedule(
   ) {
     return { status: 'superseded' };
   }
-  let successorDueAtMs: number;
-  try {
-    successorDueAtMs = advanceWorkflowCronSchedule(
-      schedule.cron,
-      Math.max(Date.now(), schedule.dueAtMs),
-      schedule.timezone,
-    );
-  } catch (error) {
-    throw new PostgresSchedulerCronScheduleConfigurationError(
-      `Cron schedule "${schedule.scheduleId}" has an invalid pinned expression or timezone: ${
-        error instanceof Error ? error.message : String(error)
-      }`,
-    );
-  }
-  if (
-    !Number.isSafeInteger(successorDueAtMs) ||
-    successorDueAtMs <= schedule.dueAtMs
-  ) {
-    throw new PostgresSchedulerCronScheduleConfigurationError(
-      `Cron schedule "${schedule.scheduleId}" did not produce a future successor occurrence.`,
-    );
-  }
+  const successorDueAtMs = cronSuccessorDueAtMs(schedule);
   const launch = cronOccurrenceLaunch({
     schedule,
     launch: input.launch,
@@ -6724,6 +6729,110 @@ export async function firePostgresSchedulerCronSchedule(
   return { status: 'superseded' };
 }
 
+/**
+ * Advance a cron cursor past an occurrence that deliberately starts no Run (a
+ * Play's `rateLimit` window is held). Under the same schedule lock and fences
+ * as `firePostgresSchedulerCronSchedule`, it spawns only the successor timer,
+ * so the schedule keeps ticking. A replay after commit is `superseded`.
+ */
+export async function skipPostgresSchedulerCronOccurrence(
+  client: PostgresSchedulerQueryClient,
+  input: Pick<
+    FirePostgresSchedulerCronScheduleInput,
+    'scheduleId' | 'generation' | 'fireGeneration' | 'dueAtMs' | 'queueName'
+  >,
+  options?: Pick<PostgresSchedulerOptions, 'schema'>,
+): Promise<
+  { status: 'skipped'; successorDueAtMs: number } | { status: 'superseded' }
+> {
+  assertPostgresSchedulerCronScheduleInput(input);
+  const schedule = await readPostgresSchedulerCronSchedule(
+    client,
+    input.scheduleId,
+    options,
+  );
+  if (
+    !schedule ||
+    schedule.state !== 'active' ||
+    schedule.generation !== input.generation ||
+    schedule.dueAtMs !== input.dueAtMs ||
+    schedule.currentFireGeneration !== input.fireGeneration
+  ) {
+    return { status: 'superseded' };
+  }
+  const successorDueAtMs = cronSuccessorDueAtMs(schedule);
+  const successorTask = buildAbsurdCronFireTask({
+    scheduleId: schedule.scheduleId,
+    generation: schedule.generation,
+    fireGeneration: 1,
+    dueAtMs: successorDueAtMs,
+    schedulerSchema:
+      options?.schema ?? schedule.sourcePin.schedulerSchema ?? null,
+    orgId: schedule.sourcePin.orgId,
+  });
+  const result = await client.query<{ advanced: boolean }>(
+    `
+      WITH schedule_lock AS MATERIALIZED (
+        SELECT pg_advisory_xact_lock(
+          ${POSTGRES_SCHEDULER_RELEASE_ADMISSION_LOCK_NAMESPACE},
+          ${quoteIdent(schemaName(options))}.runtime_release_admission_lock_id(
+            'cron-schedule:' || $1::text
+          )
+        )
+      ), matching_schedule AS MATERIALIZED (
+        SELECT schedule.schedule_id
+        FROM schedule_lock
+        JOIN ${tableName(POSTGRES_SCHEDULER_CRON_SCHEDULES_TABLE, options)} AS schedule
+          ON schedule.schedule_id = $1::text
+        WHERE schedule.generation = $2::bigint
+          AND schedule.state = 'active'
+          AND schedule.current_due_at = to_timestamp($3::double precision / 1000.0)
+          AND schedule.current_fire_generation = $4::bigint
+        FOR UPDATE
+      ), successor_task_spawn AS MATERIALIZED (
+        SELECT spawned.task_id::text AS task_id
+        FROM matching_schedule
+        CROSS JOIN LATERAL absurd.spawn_task(
+          $6::text,
+          $7::text,
+          $8::jsonb,
+          $9::jsonb
+        ) AS spawned
+      ), schedule_advance AS (
+        UPDATE ${tableName(POSTGRES_SCHEDULER_CRON_SCHEDULES_TABLE, options)} AS schedule
+        SET current_due_at = to_timestamp($5::double precision / 1000.0),
+            current_fire_task_id = (SELECT task_id FROM successor_task_spawn),
+            current_fire_generation = 1,
+            current_fire_queue_name = $6::text,
+            last_fired_at = clock_timestamp(),
+            updated_at = now()
+        WHERE schedule.schedule_id = $1::text
+          AND schedule.generation = $2::bigint
+          AND schedule.state = 'active'
+          AND schedule.current_due_at = to_timestamp($3::double precision / 1000.0)
+          AND schedule.current_fire_generation = $4::bigint
+          AND EXISTS (SELECT 1 FROM successor_task_spawn)
+        RETURNING schedule.schedule_id
+      )
+      SELECT EXISTS (SELECT 1 FROM schedule_advance) AS advanced
+    `,
+    [
+      schedule.scheduleId,
+      schedule.generation,
+      schedule.dueAtMs,
+      schedule.currentFireGeneration,
+      successorDueAtMs,
+      input.queueName,
+      successorTask.taskName,
+      stringifyPostgresJson(successorTask.params),
+      stringifyPostgresJson(successorTask.options),
+    ],
+  );
+  return result.rows[0]?.advanced === true
+    ? { status: 'skipped', successorDueAtMs }
+    : { status: 'superseded' };
+}
+
 /** Fence a malformed/invalid timer so it cannot repeatedly consume workers. */
 export async function blockPostgresSchedulerCronSchedule(
   client: PostgresSchedulerQueryClient,

package/dist/bundling-sources/shared_libs/plays/authoring-contract.ts

@@ -795,6 +795,7 @@ export const PLAY_AUTHORING_BINDING_FIELDS = {
     'compatibility',
     'cron',
     'inline',
+    'rateLimit',
     'runtime',
     'secrets',
     'sqlListeners',
@@ -864,6 +865,14 @@ export type PlayAuthoringBindings<TInput = Record<string, unknown>> = {
     timeout?: string;
     size?: 'standard';
   };
+  /**
+   * Start at most one run of this Play per window, whatever started it.
+   * Inside the window a caller gets the latest run, marked rate limited;
+   * webhook, cron, and listener starts are skipped and never retried.
+   */
+  rateLimit?: {
+    every: string;
+  };
   webhook?: {
     hmac?: {
       algorithm?: 'sha256';
@@ -1291,6 +1300,11 @@ export type PlayRunId = string & {
  */
 export type AsyncPlayRunRef = Readonly<{
   runId: PlayRunId;
+  /**
+   * Set when the child's `rateLimit` window was held: no child started and
+   * `runId` is that Play's latest run.
+   */
+  rateLimited?: { latestRunId: string; nextAllowedAt: string; message: string };
 }>;
 
 export type PlayAuthoringAsyncCallOptions = Readonly<{
@@ -2934,6 +2948,24 @@ export const PLAY_AUTHORING_FIELD_REGISTRY = {
     errorMessage:
       'runtime.timeout must be a static duration such as "90m" or "2h".',
   },
+  'rateLimit.every': {
+    schema: Type.String({ pattern: '^\\d+\\s*[smh]$' }),
+    fixtures: {
+      valid: '5m',
+      invalid: '5 minutes',
+      absent: undefined,
+      unresolved: { expression: 'every' },
+      edition1: '5m',
+    },
+    referenceType: 'string',
+    required: false,
+    resolution: 'static-required',
+    issueCode: 'play_authoring_binding_invalid',
+    description:
+      'Start at most one run per window, such as 30s, 5m, or 1h (10s to 24h).',
+    errorMessage:
+      'rateLimit.every must be a static duration from "10s" to "24h", such as "5m".',
+  },
   'runtime.size': {
     schema: Type.Literal('standard'),
     fixtures: {
@@ -3251,6 +3283,8 @@ export type AdmittedPlayAuthoringContract = {
   bindings: PlayAuthoringBindingsSnapshot | null;
   billingLimit: { maxCreditsPerRun: number } | null;
   runtimeLimit: PlaySandboxRuntimeLimits;
+  /** Absent on artifacts admitted before `rateLimit` existed: unlimited. */
+  rateLimit?: { everySeconds: number };
   allowedSecrets: string[];
 };
 
@@ -3396,6 +3430,7 @@ export const PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   `  inline?: ${cloudReferenceType('inline')};`,
   `  billing?: { maxCreditsPerRun?: ${cloudReferenceType('billing.maxCreditsPerRun')} };`,
   `  runtime?: { timeout?: ${cloudReferenceType('runtime.timeout')}; size?: ${cloudReferenceType('runtime.size')} };`,
+  `  rateLimit?: { every: ${cloudReferenceType('rateLimit.every')} };`,
   `  webhook?: { hmac?: { algorithm?: ${cloudReferenceType('bindings.webhook.hmac.algorithm')}; header?: ${cloudReferenceType('bindings.webhook.hmac.header')}; signaturePrefix?: ${cloudReferenceType('bindings.webhook.hmac.signaturePrefix')}; secretEnv: ${cloudReferenceType('bindings.webhook.hmac.secretEnv')} }; auth?: { type: ${cloudReferenceType('bindings.webhook.auth.type')}; headerFamily: ${cloudReferenceType('bindings.webhook.auth.headerFamily')}; signingSecrets: readonly ${cloudReferenceType('bindings.webhook.auth.signingSecrets[]')}[]; toleranceSeconds?: ${cloudReferenceType('bindings.webhook.auth.toleranceSeconds')} } };`,
   `  cron?: { schedule: ${cloudReferenceType('bindings.cron.schedule')}; timezone?: ${cloudReferenceType('bindings.cron.timezone')}; input?: PlayCronInput<TInput> };`,
   '  sqlListeners?: readonly SqlListenerDeclaration[];',
@@ -3420,7 +3455,7 @@ export const PLAY_AUTHORING_CLOUD_TYPE_DECLARATIONS = [
   `export type PlayAsyncCallOptions = { description: ${cloudReferenceType('ctx.runPlayAsync.options.description')} };`,
   'declare const PLAY_RUN_ID_BRAND: unique symbol;',
   "export type PlayRunId = string & { readonly [PLAY_RUN_ID_BRAND]: 'PlayRunId' };",
-  'export type AsyncPlayRunRef = Readonly<{ runId: PlayRunId }>;',
+  'export type AsyncPlayRunRef = Readonly<{ runId: PlayRunId; rateLimited?: { latestRunId: string; nextAllowedAt: string; message: string } }>;',
   `export type RuntimeStepOptions = { semanticKey?: ${cloudReferenceType('ctx.step.semanticKey')}; staleAfterSeconds?: ${cloudReferenceType('ctx.step.staleAfterSeconds')} };`,
   `export type FetchOptions = { staleAfterSeconds?: ${cloudReferenceType('ctx.fetch.staleAfterSeconds')}; transient?: boolean };`,
   "export type CallFreshnessMetadata = { requestedStaleAfterSeconds: number | null; effectiveStaleAfterSeconds: number | null; source: 'executed' | 'operation_recovery' | 'reusable_result' | 'live_observation'; resultAgeMs: number; completedAt: number; operationReceiptKey?: string; unavailableReason?: string };",

package/dist/cli/{auth-7J52UEWO.mjs → auth-35DAEPHC.mjs}

@@ -13,14 +13,14 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-BWLXHUKH.mjs";
-import "./chunk-QG7UPPOK.mjs";
-import "./chunk-VL7OL7YR.mjs";
-import "./chunk-SETIOXN4.mjs";
+} from "./chunk-ZZQIS3TH.mjs";
+import "./chunk-4NFBYW7X.mjs";
+import "./chunk-KQJHIVCE.mjs";
+import "./chunk-OMPW5ELS.mjs";
 import "./chunk-4QF2K7TM.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-HBL4PM5Q.mjs";
-import "./chunk-DSOTGAXS.mjs";
+import "./chunk-JRZW4LWK.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {

package/dist/cli/auth-Q5TM66UI.js

@@ -0,0 +1,41 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkLQUOZGM6js = require('./chunk-LQUOZGM6.js');
+require('./chunk-H7YFUC3J.js');
+require('./chunk-5FHU67AT.js');
+require('./chunk-SYWOSAW7.js');
+require('./chunk-ALJJRZNJ.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-DIAWYWT5.js');
+require('./chunk-UKKCS6Z4.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkLQUOZGM6js.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunkLQUOZGM6js.authStatusLine; exports.clearPendingClaim = _chunkLQUOZGM6js.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkLQUOZGM6js.clearSatisfiedPendingClaim; exports.handleRegister = _chunkLQUOZGM6js.handleRegister; exports.handleStatus = _chunkLQUOZGM6js.handleStatus; exports.handleWait = _chunkLQUOZGM6js.handleWait; exports.httpJson = _chunkLQUOZGM6js.httpJson; exports.readPendingAuthClaim = _chunkLQUOZGM6js.readPendingAuthClaim; exports.readStatusBanner = _chunkLQUOZGM6js.readStatusBanner; exports.registerAuthCommands = _chunkLQUOZGM6js.registerAuthCommands; exports.reportSetupCompleted = _chunkLQUOZGM6js.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkLQUOZGM6js.resolvePendingAuthClaimForResume; exports.statusBannerLine = _chunkLQUOZGM6js.statusBannerLine;