deepline 0.3.477 → 0.3.478

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

@@ -328,13 +328,13 @@ async function queryRateStateWithProbeBaseline<
   parameters: unknown[],
 ) {
   try {
-    return await client.query<Row>(sql(true), parameters);
+    return await queryBoundedRateState<Row>(client, sql(true), parameters);
   } catch (error) {
     if (!isMissingProbeBaselineColumnError(error)) throw error;
     // PostgreSQL rejects the statement before any grant or reservation writes.
     // Retry only that statement; previously accepted success feedback is not
     // applied twice. No DDL, migration preflight, or global schema floor.
-    return await client.query<Row>(sql(false), parameters);
+    return await queryBoundedRateState<Row>(client, sql(false), parameters);
   }
 }
 
@@ -1891,6 +1891,26 @@ async function boundRateStateTransaction(
   );
 }
 
+/** Bound one formerly-autocommit statement without leaking session settings. */
+async function queryBoundedRateState<
+  Row extends Record<string, unknown> = Record<string, unknown>,
+>(client: PostgresSchedulerQueryClient, sql: string, parameters?: unknown[]) {
+  await client.query('BEGIN');
+  try {
+    await boundRateStateTransaction(client);
+    const result = await client.query<Row>(sql, parameters);
+    await client.query('COMMIT');
+    return result;
+  } catch (error) {
+    try {
+      await client.query('ROLLBACK');
+    } catch {
+      // Preserve the original statement error.
+    }
+    throw rateStateLockBusyOr(error);
+  }
+}
+
 /** A scope row another transaction still holds after the lock budget. */
 class RateStateLockBusyError extends Error {
   constructor(cause: unknown) {
@@ -2530,19 +2550,23 @@ export async function acquirePostgresRateState(
 ): Promise<PlayRunnerRateStateAcquireResult> {
   return await withRateStateAvailabilityGuard(input, async () => {
     try {
-      return await acquireRateStateStatements(client, input);
+      const result = await acquireRateStateStatements(client, input);
+      return {
+        ...result,
+        acknowledgedObservationBatch: concurrencyObservationBatchFrom(
+          input.concurrencyObservationBatch,
+        ),
+      };
     } catch (error) {
-      // A store error spends the runner's fail-closed retry ladder, so a stuck
-      // holder elsewhere would fail this run. A busy scope is not a broken
-      // store: answer as for any other wait. Feedback rolled back with a busy
-      // feedback step is not re-sent, because the runner acknowledges any
-      // answer. A lost success sample only slows the next ramp, and its batch
-      // identity still prevents a double apply.
+      // A busy scope is normal backpressure. A rolled-back feedback fold must
+      // keep its exact batch on the runner; a committed fold is safe to replay
+      // after an uncertain grant because the observer watermark deduplicates it.
       if (!(error instanceof RateStateLockBusyError)) throw error;
       return {
         granted: 0,
         waitMs: RATE_STATE_LOCK_BUSY_WAIT_MS,
         leaseIds: [],
+        acknowledgedObservationBatch: null,
       };
     }
   });
@@ -2560,10 +2584,11 @@ export async function validatePostgresRateStatePermit(
   },
 ): Promise<PlayRunnerRateStateValidateResult> {
   return await withRateStateAvailabilityGuard(input, async () => {
-    const result = await client.query<{
+    const result = await queryBoundedRateState<{
       server_now_ms: string | number;
       retry_at_ms: string | number;
     }>(
+      client,
       `
         WITH now_value AS (
           SELECT COALESCE(
@@ -2621,13 +2646,14 @@ export async function claimPostgresProviderDispatch(
   }
 > {
   return withRateStateAvailabilityGuard(input, async () => {
-    const result = await client.query<{
+    const result = await queryBoundedRateState<{
       server_now_ms: string | number;
       retry_at_ms: string | number;
       allowed: boolean;
       cadence_wait: boolean;
       stale_permit: boolean;
     }>(
+      client,
       `
         WITH now_value AS (
           SELECT COALESCE($2::bigint,
@@ -2884,11 +2910,12 @@ async function concurrencyThrottleFrom(
   if (concurrencyRuleIds.length === 0) {
     return { attribution: 'not_observed', observations: [], batch: null };
   }
-  const attributedLease = await client.query<{
+  const attributedLease = await queryBoundedRateState<{
     in_flight_at_start: number | null;
     target_requests_per_second: number | null;
     minimum_rtt_ms: number | null;
   }>(
+    client,
     `
       SELECT
         in_flight_at_start,
@@ -2964,8 +2991,6 @@ async function applyConcurrencyObservations(
   rules: readonly AcquirePacingRule[],
   observations: readonly ConcurrencyObservation[],
   batch: ConcurrencyObservationBatch | null,
-  /** Acquire bounds its lock waits; release and penalty keep their behaviour. */
-  options: { bounded?: boolean } = {},
 ): Promise<{
   disposition: 'unbatched' | 'applied' | 'already_applied';
   ruleCount: number;
@@ -2978,13 +3003,17 @@ async function applyConcurrencyObservations(
   const concurrencyRules = rules.filter(
     (rule) => rule.maxConcurrency != null && rule.maxConcurrency > 0,
   );
-  const countSuccesses = async () => {
+  const countSuccesses = async (bounded = false) => {
     const successes = Math.max(
       0,
       Math.min(1_000_000, Math.trunc(input.observedSuccesses ?? 0)),
     );
     if (successes <= 0) return;
-    await client.query(
+    const query = bounded
+      ? (sql: string, params: unknown[]) =>
+          queryBoundedRateState(client, sql, params)
+      : (sql: string, params: unknown[]) => client.query(sql, params);
+    await query(
       `
       UPDATE ${scopeHoldTableName(input)}
       SET rate_successes = rate_successes + $2::bigint,
@@ -3009,7 +3038,7 @@ async function applyConcurrencyObservations(
   if (batch === null) {
     // Legacy writers have no observation identity. Preserve their success
     // input; new writers always supply the replay-safe batch below.
-    await countSuccesses();
+    await countSuccesses(true);
     return {
       disposition: 'unbatched',
       ruleCount: 0,
@@ -3023,7 +3052,7 @@ async function applyConcurrencyObservations(
 
   await client.query('BEGIN');
   try {
-    if (options.bounded) await boundRateStateTransaction(client);
+    await boundRateStateTransaction(client);
     const accepted = await client.query<{ last_sequence: number }>(
       `
         WITH now_value AS (
@@ -3232,7 +3261,7 @@ async function applyConcurrencyObservations(
     } catch {
       // Preserve the original controller/storage error.
     }
-    throw options.bounded ? rateStateLockBusyOr(error) : error;
+    throw rateStateLockBusyOr(error);
   }
 }
 
@@ -3259,8 +3288,8 @@ async function acquireRateStateStatements(
       : acquirePureRate(client, grantInput, rules, seeds, requested);
 
   // Cold path only: seed missing rows / refresh changed configuration. A warm
-  // pure-rate acquire is exactly one statement. Concurrency-bearing acquires
-  // take the scope lock before the lease-count statement gets its snapshot.
+  // pure-rate acquire has one grant statement in a bounded transaction.
+  // Concurrency-bearing acquires lock the scope before the lease snapshot.
   let seeded = false;
   if (!warmRateBuckets.has(warmKey)) {
     await seedBucketRows(client, input, seeds, nowMs);
@@ -3272,7 +3301,6 @@ async function acquireRateStateStatements(
     rules,
     concurrencyObservationsFrom(input.concurrencyObservations),
     concurrencyObservationBatchFrom(input.concurrencyObservationBatch),
-    { bounded: true },
   );
   // The buffered success count and RTT observations share one identity. If a
   // runner lost the prior acquire response, its retry still needs a fresh
@@ -3376,7 +3404,8 @@ async function releaseRateStateStatements(
     // no scope owner. Create its uninitialized hold before taking the normal
     // hold -> reservation -> rule lock path; seedBucketRows will initialize its
     // learner on the next admission and preserve this inherited deadline.
-    await client.query(
+    await queryBoundedRateState(
+      client,
       `
         INSERT INTO ${scopeHoldTableName(input)} (bucket_id, retry_at_ms)
         SELECT bucket_id, MAX(claimed_retry_at_ms)
@@ -3392,7 +3421,8 @@ async function releaseRateStateStatements(
     // a bucket, and an HTTP retry sees no reservation left to refund. The shared
     // dispatch cursor deliberately stays monotonic, so cancellation can never
     // compress provider starts into a burst.
-    await client.query(
+    await queryBoundedRateState(
+      client,
       `
         WITH now_value AS (
           SELECT COALESCE(
@@ -3478,7 +3508,8 @@ async function releaseRateStateStatements(
   ];
   if (leaseIds.length === 0) return;
   // DELETE by holder token is naturally idempotent, including HTTP retries.
-  await client.query(
+  await queryBoundedRateState(
+    client,
     `
       DELETE FROM ${concurrencyLeaseTableName(input)}
       WHERE bucket_id = $1
@@ -3536,11 +3567,12 @@ async function penalizeRateStateStatements(
   //    min_rps.
   //  - seen_backpressure flips the ramp from slow-start (x2) to additive.
   //  - tokens drained: no more grants until refill re-accrues past the cooldown.
-  await client.query(
+  await queryBoundedRateState(
+    client,
     `INSERT INTO ${scopeHoldTableName(input)} (bucket_id) VALUES ($1) ON CONFLICT DO NOTHING`,
     [input.bucketId],
   );
-  const rateStateResult = await client.query<{
+  const rateStateResult = await queryBoundedRateState<{
     retry_at_ms: string | number | null;
     cool_until_ms: string | number | null;
     rate_rule_count: string | number;
@@ -3552,6 +3584,7 @@ async function penalizeRateStateStatements(
     observation_cycle_max_ms: string | number | null;
     confirmed_successes_max: string | number | null;
   }>(
+    client,
     `
       WITH now_value AS (
         SELECT COALESCE(

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

@@ -3,9 +3,10 @@ export type { BillingEntitlements } from '../integration-contracts/billing-entit
 import { Type, type Static, type TSchema } from '@sinclair/typebox';
 import { Value } from '@sinclair/typebox/value';
 import type { PreviousCell } from './cell-staleness';
-import type {
-  PlaySandboxRuntimeLimits,
-  PlaySandboxSize,
+import {
+  PLAY_SANDBOX_SIZE_INPUTS,
+  type PlaySandboxRuntimeLimits,
+  type PlaySandboxSizeInput,
 } from './sandbox-runtime-limits';
 import type {
   BasicToolExecuteResult,
@@ -867,7 +868,7 @@ export type PlayAuthoringBindings<TInput = Record<string, unknown>> = {
    */
   runtime?: {
     timeout?: string;
-    size?: PlaySandboxSize;
+    size?: PlaySandboxSizeInput;
   };
   /**
    * Start at most one run of this Play per window, whatever started it.
@@ -2971,11 +2972,9 @@ export const PLAY_AUTHORING_FIELD_REGISTRY = {
       'rateLimit.every must be a static duration from "10s" to "24h", such as "5m".',
   },
   'runtime.size': {
-    schema: Type.Union([
-      Type.Literal('standard'),
-      Type.Literal('large'),
-      Type.Literal('xlarge'),
-    ]),
+    schema: Type.Union(
+      PLAY_SANDBOX_SIZE_INPUTS.map((size) => Type.Literal(size)),
+    ),
     fixtures: {
       valid: 'large',
       invalid: 'xxlarge',
@@ -2983,14 +2982,16 @@ export const PLAY_AUTHORING_FIELD_REGISTRY = {
       unresolved: { expression: 'size' },
       edition1: 'standard',
     },
-    referenceType: "'standard' | 'large' | 'xlarge'",
+    referenceType: PLAY_SANDBOX_SIZE_INPUTS.map((size) => `'${size}'`).join(
+      ' | ',
+    ),
     required: false,
     resolution: 'static-required',
     issueCode: 'play_authoring_binding_invalid',
     description:
-      'Deepline-managed sandbox size: standard (1 GiB memory, 1 CPU), large (4 GiB, 2 CPU), or xlarge (8 GiB, 4 CPU). Standard is the default. Compute pricing follows the workspace plan and selected size.',
+      'Deepline-managed sandbox size: standard or 1gb (1 GiB memory, 1 CPU), large or 4gb (4 GiB, 2 CPU), or xlarge or 8gb (8 GiB, 4 CPU). Standard is the default. Each alias selects the same resource profile and compute price as its named size.',
     errorMessage:
-      'runtime.size must be the static literal "standard", "large", or "xlarge".',
+      'runtime.size must be the static literal "standard", "large", "xlarge", "1gb", "4gb", or "8gb".',
   },
   'ctx.customerDb.query.statement': {
     schema: Type.Union([

package/dist/bundling-sources/shared_libs/plays/bundling/index.ts

@@ -57,7 +57,10 @@ export {
   type DocflowSymbolResolution,
 } from '../docflow-binding';
 import type { ToolExecutionErrorSchemaVersion } from '../tool-execution-error';
-import type { PlaySandboxRuntimeDeclaration } from '../sandbox-runtime-limits';
+import {
+  SUPPORTED_PLAY_SANDBOX_SIZES,
+  type PlaySandboxRuntimeDeclaration,
+} from '../sandbox-runtime-limits';
 import { validatePlaySourceFilesHaveNoInlineSecrets } from '../secret-guardrails';
 import { MAX_PLAY_BUNDLE_BYTES } from './limits';
 import {
@@ -1125,7 +1128,7 @@ function sandboxRuntimeDeclarationFromOptions(
   if (unsupportedProperties.length > 0) {
     throw new Error(
       `Unsupported runtime sandbox option${unsupportedProperties.length === 1 ? '' : 's'} "${unsupportedProperties.join('", "')}". ` +
-        'Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: "standard", "large", or "xlarge".',
+        `Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: ${SUPPORTED_PLAY_SANDBOX_SIZES}.`,
     );
   }
   const timeout = resolveStaticProperty(runtime.value, 'timeout', context);

package/dist/bundling-sources/shared_libs/plays/sandbox-runtime-limits.ts

@@ -28,6 +28,23 @@ export const PLAY_SANDBOX_SIZE_LIMITS = {
   Omit<PlaySandboxRuntimeLimits, 'timeoutSeconds'>
 >;
 
+export const PLAY_SANDBOX_SIZE_ALIASES = {
+  '1gb': 'standard',
+  '4gb': 'large',
+  '8gb': 'xlarge',
+} as const satisfies Record<string, PlaySandboxSize>;
+
+export type PlaySandboxSizeInput =
+  | PlaySandboxSize
+  | keyof typeof PLAY_SANDBOX_SIZE_ALIASES;
+
+export const PLAY_SANDBOX_SIZE_INPUTS: readonly PlaySandboxSizeInput[] = [
+  ...(Object.keys(PLAY_SANDBOX_SIZE_LIMITS) as PlaySandboxSize[]),
+  ...(Object.keys(
+    PLAY_SANDBOX_SIZE_ALIASES,
+  ) as (keyof typeof PLAY_SANDBOX_SIZE_ALIASES)[]),
+];
+
 export const STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS: PlaySandboxRuntimeLimits = {
   timeoutSeconds: 30 * 60,
   ...PLAY_SANDBOX_SIZE_LIMITS.standard,
@@ -77,15 +94,23 @@ export function playSandboxSizeForLimits(
   );
 }
 
-const supportedPlaySandboxSizes = Object.keys(PLAY_SANDBOX_SIZE_LIMITS).join(
-  ', ',
-);
+export const SUPPORTED_PLAY_SANDBOX_SIZES = PLAY_SANDBOX_SIZE_INPUTS.join(', ');
 
 export type PlaySandboxRuntimeDeclaration = {
   timeout?: string;
-  size?: PlaySandboxSize;
+  size?: PlaySandboxSizeInput;
 };
 
+function normalizePlaySandboxSize(value: unknown): PlaySandboxSize | null {
+  if (typeof value !== 'string') return null;
+  if (Object.hasOwn(PLAY_SANDBOX_SIZE_LIMITS, value)) {
+    return value as PlaySandboxSize;
+  }
+  return Object.hasOwn(PLAY_SANDBOX_SIZE_ALIASES, value)
+    ? PLAY_SANDBOX_SIZE_ALIASES[value as keyof typeof PLAY_SANDBOX_SIZE_ALIASES]
+    : null;
+}
+
 function parseTimeout(value: string): number | null {
   const match = /^(\d+)\s*([mh])$/i.exec(value.trim());
   if (!match) return null;
@@ -100,7 +125,7 @@ export function validatePlaySandboxRuntimeLimits(
   if (!playSandboxSizeForLimits(value)) {
     throw new Error(
       `Unsupported runtime sandbox resources: cpu=${value.cpu} memoryGiB=${value.memoryGiB} diskGiB=${value.diskGiB}. ` +
-        `Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: ${supportedPlaySandboxSizes}.`,
+        `Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: ${SUPPORTED_PLAY_SANDBOX_SIZES}.`,
     );
   }
   if (
@@ -130,15 +155,16 @@ export function resolvePlaySandboxRuntimeLimits(
   if (unsupportedProperties.length > 0) {
     throw new Error(
       `Unsupported runtime sandbox option${unsupportedProperties.length === 1 ? '' : 's'}: ${unsupportedProperties.join(', ')}. ` +
-        `Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: ${supportedPlaySandboxSizes}.`,
+        `Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: ${SUPPORTED_PLAY_SANDBOX_SIZES}.`,
     );
   }
-  if (
-    declaration.size !== undefined &&
-    !Object.hasOwn(PLAY_SANDBOX_SIZE_LIMITS, declaration.size)
-  ) {
+  const size =
+    declaration.size === undefined
+      ? 'standard'
+      : normalizePlaySandboxSize(declaration.size);
+  if (!size) {
     throw new Error(
-      `Unsupported runtime sandbox size "${String(declaration.size)}". Supported sizes: ${supportedPlaySandboxSizes}.`,
+      `Unsupported runtime sandbox size "${String(declaration.size)}". Supported sizes: ${SUPPORTED_PLAY_SANDBOX_SIZES}.`,
     );
   }
   const timeoutSeconds = declaration.timeout
@@ -149,7 +175,6 @@ export function resolvePlaySandboxRuntimeLimits(
       'Invalid runtime sandbox timeout. Use timeout like "90m" or "2h".',
     );
   }
-  const size = declaration.size ?? 'standard';
   return validatePlaySandboxRuntimeLimits({
     timeoutSeconds,
     ...PLAY_SANDBOX_SIZE_LIMITS[size],

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

@@ -44,6 +44,7 @@ export const BILLING_SALES_RULE_KEYS: readonly string[] = [
   'internal.billing.usage_charge',
   'internal.billing.credit_purchase',
   'internal.billing.paid_plan',
+  'internal.billing.allowance_exhausted',
   ...BILLING_DELIVERY_LATE_RULE_KEYS,
 ];
 

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

@@ -1035,6 +1035,35 @@ const PRODUCT_NOTIFICATION_TYPE_REGISTRY = [
       }),
     },
   },
+  {
+    id: 'internal.billing.allowance_exhausted',
+    eventName: ProductNotificationEvent.BillingAllowanceExhausted,
+    requiredFilter: {},
+    allowedTriggers: ['each_match'],
+    catalog: undefined,
+    shadow: true,
+    rule: {
+      default: {
+        ruleKey: 'internal.billing.allowance_exhausted',
+        groupKey: BILLING_SALES_GROUP_KEY,
+      },
+      create: (_input, base) => ({
+        ...base,
+        repeatMode: 'every_match',
+        trigger: { kind: 'each_match' },
+      }),
+      present: ({ payload }) => ({
+        title: `Free allowance reached · ${payload.allowance}`,
+        summary: [{ workspace: true }, ` used its included ${payload.limit}.`],
+        details: [
+          `Allowance period ends ${new Date(Number(payload.resetsAt)).toISOString()} (UTC).`,
+        ],
+        targetUrl: String(payload.targetUrl),
+        subjectKind: 'workspace',
+        subjectId: String(payload.accountId),
+      }),
+    },
+  },
   lateCreditDeliveryRegistration(
     BILLING_PURCHASE_LATE_RULE_KEY,
     ProductNotificationEvent.BillingPurchaseLate,

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

@@ -33,6 +33,7 @@ export const ProductNotificationEvent = {
   BillingPurchaseLate: 'billing.purchase.late',
   BillingRenewalLate: 'billing.renewal.late',
   BillingUsageChargeObserved: 'billing.usage.charge_observed',
+  BillingAllowanceExhausted: 'billing.allowance.exhausted',
   MonitorLifecycleChanged: 'monitor.lifecycle.changed',
   PlayLifecycleChanged: 'play.lifecycle.changed',
   PlayRunCompleted: 'play.run.completed',
@@ -78,6 +79,7 @@ export const PRODUCT_NOTIFICATION_EVENT_NAMES = [
   ProductNotificationEvent.BillingPurchaseLate,
   ProductNotificationEvent.BillingRenewalLate,
   ProductNotificationEvent.BillingUsageChargeObserved,
+  ProductNotificationEvent.BillingAllowanceExhausted,
 ] as const;
 
 export const PRODUCT_NOTIFICATION_COMPATIBILITY_EVENT_NAMES = [
@@ -283,6 +285,19 @@ export const PRODUCT_NOTIFICATION_EVENT_DEFINITIONS: readonly ProductNotificatio
       orderingSubjectFact: 'chargeId',
       allowedTriggers: ['each_match'],
     },
+    {
+      eventName: ProductNotificationEvent.BillingAllowanceExhausted,
+      producerKey: ProductNotificationProducerKey.BillingUsage,
+      requiredFacts: {
+        accountId: 'string',
+        allowance: 'string',
+        limit: 'string',
+        resetsAt: 'number',
+        targetUrl: 'string',
+      },
+      orderingSubjectFact: 'accountId',
+      allowedTriggers: ['each_match'],
+    },
     {
       eventName: ProductNotificationEvent.BillingRenewalLate,
       producerKey: ProductNotificationProducerKey.BillingPurchases,

package/dist/cli/{auth-XVXRRWIQ.mjs → auth-SA4DJCSO.mjs}

@@ -13,14 +13,14 @@ import {
   reportSetupCompleted,
   resolvePendingAuthClaimForResume,
   statusBannerLine
-} from "./chunk-6IJJCRE5.mjs";
-import "./chunk-QODW5ILA.mjs";
-import "./chunk-YZA5UJXM.mjs";
-import "./chunk-LJYTYNQZ.mjs";
+} from "./chunk-BLAZVZVD.mjs";
+import "./chunk-7HTWT3Z4.mjs";
+import "./chunk-75DAGCEX.mjs";
+import "./chunk-M5USVQ33.mjs";
 import "./chunk-4QF2K7TM.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-HBL4PM5Q.mjs";
-import "./chunk-PQQNMMWM.mjs";
+import "./chunk-645RNF2Y.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {

package/dist/cli/auth-U5SNVC5F.js

@@ -0,0 +1,41 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkVE25VUTEjs = require('./chunk-VE25VUTE.js');
+require('./chunk-4RV7U3RP.js');
+require('./chunk-TW3TTKW5.js');
+require('./chunk-KBBZXWXF.js');
+require('./chunk-ALJJRZNJ.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-DIAWYWT5.js');
+require('./chunk-S3BKOCVB.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkVE25VUTEjs.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunkVE25VUTEjs.authStatusLine; exports.clearPendingClaim = _chunkVE25VUTEjs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkVE25VUTEjs.clearSatisfiedPendingClaim; exports.handleRegister = _chunkVE25VUTEjs.handleRegister; exports.handleStatus = _chunkVE25VUTEjs.handleStatus; exports.handleWait = _chunkVE25VUTEjs.handleWait; exports.httpJson = _chunkVE25VUTEjs.httpJson; exports.readPendingAuthClaim = _chunkVE25VUTEjs.readPendingAuthClaim; exports.readStatusBanner = _chunkVE25VUTEjs.readStatusBanner; exports.registerAuthCommands = _chunkVE25VUTEjs.registerAuthCommands; exports.reportSetupCompleted = _chunkVE25VUTEjs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkVE25VUTEjs.resolvePendingAuthClaimForResume; exports.statusBannerLine = _chunkVE25VUTEjs.statusBannerLine;