deepline 0.3.303 → 0.3.305

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.303',
+  version: '0.3.305',
   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/app-runtime-api.ts

@@ -2452,7 +2452,9 @@ export async function projectRunEventsViaAppRuntime(
   const batches = partitionRunEventsForAppRuntime(input.events);
   const receiptBatch = runLedgerReceiptBatchIndex(batches);
   for (const [index, events] of batches.entries()) {
+    const beforeBatchStartedAt = Date.now();
     await input.beforeBatch();
+    const beforeBatchMs = Math.max(0, Date.now() - beforeBatchStartedAt);
     // Retain the original receipt for the terminal (or final) piece so an acknowledged
     // legacy delivery stays acknowledged across the reader rollout.
     const idempotencyKey =
@@ -2476,7 +2478,16 @@ export async function projectRunEventsViaAppRuntime(
     };
     // The durable outbox owns recovery; this helper does not retry OCCs or
     // other delivery failures inside an already-leased invocation.
-    const deliveryContext = { ...context, retryPolicy: 'none' as const };
+    let responseMeta: RuntimeApiResponseMeta | null = null;
+    const deliveryContext = {
+      ...context,
+      retryPolicy: 'none' as const,
+      onResponseMeta(meta: RuntimeApiResponseMeta) {
+        context.onResponseMeta?.(meta);
+        if (meta.action === 'project_run_events') responseMeta = meta;
+      },
+    };
+    const requestStartedAt = Date.now();
     try {
       await postAppRuntimeApi(deliveryContext, {
         action: 'project_run_events',
@@ -2501,6 +2512,25 @@ export async function projectRunEventsViaAppRuntime(
         ...request,
       });
     }
+    const requestWallMs = Math.max(0, Date.now() - requestStartedAt);
+    if (beforeBatchMs >= 500 || requestWallMs >= 500) {
+      const observedResponse = responseMeta as RuntimeApiResponseMeta | null;
+      console.info('[run-ledger-outbox.project_transport_slow]', {
+        runId: input.playId,
+        eventCount: events.length,
+        batchIndex: index,
+        batchCount: batches.length,
+        beforeBatchMs,
+        requestWallMs,
+        roundTripMs: observedResponse?.roundTripMs ?? null,
+        requestId: observedResponse?.requestId ?? null,
+        requestBodyRawBytes: observedResponse?.requestBodyRawBytes ?? null,
+        requestBodyWireBytes: observedResponse?.requestBodyWireBytes ?? null,
+        requestBodySerializeMs:
+          observedResponse?.requestBodySerializeMs ?? null,
+        requestBodyPackMs: observedResponse?.requestBodyPackMs ?? null,
+      });
+    }
   }
 }
 

package/dist/bundling-sources/shared_libs/play-runtime/execute-server-timing.ts

@@ -33,6 +33,36 @@ export const EXECUTE_SERVER_TIMING_STAGES = [
   'execute',
   'identity',
   'usage_schedule',
+  // Managed AI inference slices: `ai_prepare` includes request preparation and
+  // contains `ai_billing_authorize`; `ai_provider_work_start` is the durable
+  // pre-call transition; `ai_gateway_first_output` is the time to the first
+  // model-output part (excluding SDK control chunks); and
+  // `ai_gateway_stream_wall` is the end-to-end SDK stream
+  // collection wall. Stream wall includes awaited finish callbacks, so evidence
+  // persistence and settlement overlap it. First-output and stream wall both
+  // include Gateway/network/upstream time; neither claims provider-internal
+  // model time.
+  'ai_prepare',
+  'ai_billing_authorize',
+  'ai_provider_work_start',
+  'ai_gateway_first_output',
+  'ai_gateway_stream_wall',
+  'ai_generation_evidence_persist',
+  'ai_billing_settlement',
+  'ai_output_canonicalization',
+  'ai_result_persist',
+  // Provider HTTP slices are only nonzero for calls that take this path:
+  // admission; `provider_fetch_headers` until response headers arrive (or
+  // `provider_fetch_error_wait` for a rejected fetch); retry backoff; body
+  // read, JSON parse, result transform and output normalization are separate.
+  'provider_admission',
+  'provider_fetch_headers',
+  'provider_fetch_error_wait',
+  'provider_retry_wait',
+  'provider_body_read',
+  'provider_json_parse',
+  'provider_result_transform',
+  'provider_output_normalization',
   'total',
   // The execution gateway preserves these disjoint stages beside the app
   // handler's stages. They are deliberately part of this small, additive

package/dist/bundling-sources/shared_libs/play-runtime/resource-governor.ts

@@ -12,7 +12,10 @@ import type {
   ProviderConcurrencyGrant,
   ProviderPacingGrant,
 } from './governor/rate-state-backend';
-import type { ExecuteServerTiming } from './execute-server-timing';
+import type {
+  ExecuteServerTiming,
+  ExecuteServerTimingStage,
+} from './execute-server-timing';
 
 export type RuntimeResourceLease = WorkLease;
 export type RuntimeProviderPermit = ProviderPermit;
@@ -511,6 +514,29 @@ export type RuntimePhaseTiming = {
   ewmaMs: number | null;
 };
 
+const AI_INFERENCE_EXECUTE_STAGES = [
+  'ai_prepare',
+  'ai_billing_authorize',
+  'ai_provider_work_start',
+  'ai_gateway_first_output',
+  'ai_gateway_stream_wall',
+  'ai_generation_evidence_persist',
+  'ai_billing_settlement',
+  'ai_output_canonicalization',
+  'ai_result_persist',
+] as const satisfies readonly ExecuteServerTimingStage[];
+
+const PROVIDER_HTTP_EXECUTE_STAGES = [
+  'provider_admission',
+  'provider_fetch_headers',
+  'provider_fetch_error_wait',
+  'provider_retry_wait',
+  'provider_body_read',
+  'provider_json_parse',
+  'provider_result_transform',
+  'provider_output_normalization',
+] as const satisfies readonly ExecuteServerTimingStage[];
+
 /**
  * Selected execute-route stages for the same population as `fetchToHeaders`.
  * These are nested because they partition handler work inside that wall; they
@@ -523,6 +549,26 @@ export type RuntimeExecuteRouteTiming = {
   chargeOpenMs: number;
   fixtureLoadMs: number;
   executeMs: number;
+  /**
+   * Managed `ai_inference` stages, accumulated independently because each can
+   * observe a different request population. `count` is the number of requests
+   * with a non-zero `ai_prepare` marker. Stage counters include positive
+   * durations only: the header serializes milliseconds to three decimal
+   * places, so an absent stage cannot be distinguished from a duration
+   * rounded to zero. These slices overlap; in particular stream wall contains
+   * awaited evidence persistence and billing settlement.
+   */
+  aiInference?: RuntimeExecuteStageGroup<
+    (typeof AI_INFERENCE_EXECUTE_STAGES)[number]
+  >;
+  /**
+   * Deepline-owned HTTP provider stages. `count` is the number of requests
+   * with a non-zero provider-admission marker; each stage retains its own
+   * positive-duration denominator for rolling-build compatibility.
+   */
+  providerHttp?: RuntimeExecuteStageGroup<
+    (typeof PROVIDER_HTTP_EXECUTE_STAGES)[number]
+  >;
   /**
    * Where `chargeOpenMs` went, nested rather than summed: these are disjoint
    * slices of it, never independent phases. Present only when the deployed app
@@ -557,6 +603,18 @@ export type RuntimeExecuteRouteTiming = {
   };
 };
 
+/** Fixed-size run summary for one execute-route stage. */
+export type RuntimeExecuteStageTiming = {
+  count: number;
+  totalMs: number;
+  maxMs: number | null;
+};
+
+/** A fixed set of named execute stages with one run-level request count. */
+export type RuntimeExecuteStageGroup<Stage extends ExecuteServerTimingStage> = {
+  count: number;
+} & Record<Stage, RuntimeExecuteStageTiming>;
+
 /**
  * A compact, unitless sample aggregate. Provider permits use it for bucket
  * occupancy at admission, rather than mislabelling an in-flight count as ms.
@@ -854,6 +912,71 @@ function createPhaseTiming(): {
   };
 }
 
+function createExecuteStageAccumulator(): {
+  observe(value: number): void;
+  snapshot(): RuntimeExecuteStageTiming;
+} {
+  let count = 0;
+  let totalMs = 0;
+  let maxMs: number | null = null;
+  return {
+    observe(value) {
+      count += 1;
+      totalMs += value;
+      maxMs = maxMs === null ? value : Math.max(maxMs, value);
+    },
+    snapshot() {
+      return { count, totalMs, maxMs };
+    },
+  };
+}
+
+function createExecuteStageGroup<
+  const Stages extends readonly ExecuteServerTimingStage[],
+>(stages: Stages) {
+  type Stage = Stages[number];
+  // Keep the tuple's element type explicit through iteration. TypeScript can
+  // widen a generic readonly tuple to the full timing-stage union in loops,
+  // even though every value here came from this group's stage list.
+  const stageNames = stages as readonly Stage[];
+  const metrics = Object.fromEntries(
+    stageNames.map((stage) => [stage, createExecuteStageAccumulator()]),
+  ) as Record<Stage, ReturnType<typeof createExecuteStageAccumulator>>;
+  let count = 0;
+  return {
+    get count() {
+      return count;
+    },
+    observe(markerMs: number | null, timing: ExecuteServerTiming) {
+      // The execute header renders absent stages as zero, so zero cannot be
+      // attributed to an observed stage with confidence. The positive marker
+      // selects calls in this group; stage populations remain explicit.
+      if (markerMs === null || !Number.isFinite(markerMs) || markerMs <= 0) {
+        return;
+      }
+      count += 1;
+      for (const stage of stageNames) {
+        const durationMs = timing[stage];
+        if (
+          durationMs !== null &&
+          Number.isFinite(durationMs) &&
+          durationMs > 0
+        ) {
+          metrics[stage].observe(durationMs);
+        }
+      }
+    },
+    snapshot(): RuntimeExecuteStageGroup<Stage> {
+      return {
+        count,
+        ...Object.fromEntries(
+          stageNames.map((stage) => [stage, metrics[stage].snapshot()]),
+        ),
+      } as RuntimeExecuteStageGroup<Stage>;
+    },
+  };
+}
+
 function createSampleTiming(): {
   observe(value: number | null | undefined): void;
   snapshot(): RuntimeSampleTiming;
@@ -979,6 +1102,12 @@ export function createRuntimeResourceGovernor(input: {
     fixtureLoadMs: 0,
     executeMs: 0,
   };
+  const executeAiInference = createExecuteStageGroup(
+    AI_INFERENCE_EXECUTE_STAGES,
+  );
+  const executeProviderHttp = createExecuteStageGroup(
+    PROVIDER_HTTP_EXECUTE_STAGES,
+  );
   const executeChargeOpen = {
     count: 0,
     eligibilityMs: 0,
@@ -1288,6 +1417,14 @@ export function createRuntimeResourceGovernor(input: {
       executeRoute.chargeOpenMs += executeRouteTiming.charge_open;
       executeRoute.fixtureLoadMs += executeRouteTiming.fixture_load;
       executeRoute.executeMs += executeRouteTiming.execute;
+      executeAiInference.observe(
+        executeRouteTiming.ai_prepare,
+        executeRouteTiming,
+      );
+      executeProviderHttp.observe(
+        executeRouteTiming.provider_admission,
+        executeRouteTiming,
+      );
       // Same rule as the gateway block below: require the complete substage
       // set this app version emits, so an older build that reports only
       // `charge_open` does not silently contribute a partial split.
@@ -1734,6 +1871,12 @@ export function createRuntimeResourceGovernor(input: {
           ? {
               executeRoute: {
                 ...executeRoute,
+                ...(executeAiInference.count > 0
+                  ? { aiInference: executeAiInference.snapshot() }
+                  : {}),
+                ...(executeProviderHttp.count > 0
+                  ? { providerHttp: executeProviderHttp.snapshot() }
+                  : {}),
                 ...(executeChargeOpen.count > 0
                   ? { chargeOpen: { ...executeChargeOpen } }
                   : {}),

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

@@ -1070,7 +1070,7 @@ export async function withRuntimeSchedulerClient<T>(
       let queryCount = 0;
       let queryMs = 0;
       try {
-        if (!entry.databasePoolAttached) {
+        if (process.env.VERCEL?.trim() && !entry.databasePoolAttached) {
           attachDatabasePool(entry.pool);
           entry.databasePoolAttached = true;
         }

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

@@ -14701,8 +14701,10 @@ function terminalLogProjectionForOutbox(
         metadata: PlayLogMetadata | null;
         entryId: string | null;
       } => entry !== null,
-    )
-    .slice(-LOG_TAIL_LIMIT);
+    );
+  // This carrier is consumed into the paginated log store by the terminal
+  // statement. The runner already bounds its envelope by bytes; applying the
+  // status tail here loses retained lines when live delivery was interrupted.
   return {
     lines: entries.map((entry) => entry.line),
     lineContexts: entries.map((entry) => entry.context),
@@ -18091,10 +18093,10 @@ async function claimPostgresSchedulerOutboxPrefix(
           ? `owned_run AS MATERIALIZED (
         SELECT run_id FROM ${tableName('runs', options)}
         WHERE run_id = $2
-        -- This dispatcher already owns the head. A producer holding the run
-        -- lock is not a lost delivery lease: wait for its short transaction,
-        -- then revalidate the head below. New-run selection still skips locks.
-        FOR UPDATE
+        -- The head is already owned. Wait for the producer, then revalidate
+        -- its lease below; initial selection still skips unrelated busy runs.
+        -- Child-row foreign-key share locks can coexist with this fence.
+        FOR NO KEY UPDATE
       ),`
           : ''
       } head AS MATERIALIZED (
@@ -18117,7 +18119,7 @@ async function claimPostgresSchedulerOutboxPrefix(
           ${
             input.extendOwnedHead
               ? `AND candidate.event_id = $5
-          AND candidate.lease_owner = $3 AND candidate.lease_expires_at > now()`
+          AND candidate.lease_owner = $3 AND candidate.lease_expires_at > clock_timestamp()`
               : ''
           }
           AND candidate.failed_at IS NULL
@@ -20340,23 +20342,47 @@ async function dispatchRunLedgerOutboxBatchWithScope(
       events.length === 1 &&
       first.eventType === RUN_SCHEDULER_OUTBOX_EVENT_TYPE.runEvents
     ) {
-      const widened = await withClient((client) =>
-        readPendingPostgresSchedulerOutboxEvents(
-          client,
-          {
-            runId: first.runId,
-            leaseOwner,
-            leaseSeconds: input.leaseSeconds ?? 120,
-            limit: Math.min(
-              RUN_LEDGER_PROJECTION_PREFIX_MAX_FACTS,
-              remainingEvents ?? RUN_LEDGER_PROJECTION_PREFIX_MAX_FACTS,
-            ),
-            allowIngressPrefix: true,
-            extendOwnedHead: first.eventId,
-          },
-          options,
-        ),
-      );
+      const widened = await withClient(async (client) => {
+        await client.query('BEGIN');
+        try {
+          await client.query(
+            `SELECT set_config('lock_timeout', $1, true),
+                    set_config('statement_timeout', $2, true)`,
+            [
+              `${RUNTIME_SCHEDULER_CANCEL_LOCK_TIMEOUT_MS}ms`,
+              `${RUNTIME_SCHEDULER_CANCEL_STATEMENT_TIMEOUT_MS}ms`,
+            ],
+          );
+          // An owned head must extend from a fresh snapshot after the producer
+          // commits. Keep the wait inside the existing SQL budget and permit
+          // child-row foreign-key share locks under the ingress fence.
+          await client.query(
+            `SELECT run_id FROM ${tableName('runs', options)} WHERE run_id = $1 FOR NO KEY UPDATE`,
+            [first.runId],
+          );
+          const prefix = await readPendingPostgresSchedulerOutboxEvents(
+            client,
+            {
+              runId: first.runId,
+              leaseOwner,
+              leaseSeconds: input.leaseSeconds ?? 120,
+              limit: Math.min(
+                RUN_LEDGER_PROJECTION_PREFIX_MAX_FACTS,
+                remainingEvents ?? RUN_LEDGER_PROJECTION_PREFIX_MAX_FACTS,
+              ),
+              allowIngressPrefix: true,
+              extendOwnedHead: first.eventId,
+              inTransaction: true,
+            },
+            options,
+          );
+          await client.query('COMMIT');
+          return prefix;
+        } catch (error) {
+          await client.query('ROLLBACK');
+          throw error;
+        }
+      });
       if (widened[0]?.eventId !== first.eventId) {
         throw new RunLedgerProjectionLeaseLostError(
           'head_lease_owner_mismatch',
@@ -20729,10 +20755,11 @@ async function dispatchRunLedgerOutboxBatchWithScope(
     }
     const failure = runLedgerDeliveryFailure({ error });
     console.warn('[run-ledger-outbox.batch_dispatch_failed]', {
-      runId: input.runId ?? null,
+      runId: input.runId ?? events[0]?.runId ?? null,
       eventIds: events.map((event) => event.eventId),
       error: error instanceof Error ? error.message : String(error),
       code: failure.code,
+      responseStatus: failure.status,
       failureReason: failure.failureReason,
       ...(failure.projectionMismatch
         ? { projectionMismatch: failure.projectionMismatch }

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

@@ -2793,6 +2793,16 @@ export async function hasRuntimeEventLogPositionIndex(
   return true;
 }
 
+/** Deployment-only check for all supported legacy and current log reads. */
+export async function hasRuntimeEventQueryIndexes(
+  client: PostgresSchedulerQueryClient,
+): Promise<boolean> {
+  for (const expected of RUNTIME_EVENT_QUERY_INDEXES) {
+    if (!(await hasRuntimeEventQueryIndex(client, expected))) return false;
+  }
+  return true;
+}
+
 /** Prepare old and new position indexes before replacing the projection body. */
 export async function prepareRuntimeEventLogPositionIndex(
   client: PostgresSchedulerQueryClient,

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

@@ -0,0 +1,13 @@
+export const BILLING_SALES_GROUP_KEY = 'shadow.billing-sales';
+export const BILLING_SALES_DESTINATION_KEY = 'shadow.billing-sales.slack';
+export const BILLING_SALES_SLACK_CHANNEL_ID = 'C0AGWVD2TNK';
+export const BILLING_SALES_CONNECTION_ID = 'platform-reporting-bot';
+export const BILLING_SALES_CREDIT_PURCHASE_MINIMUM_CENTS = 15_000;
+export const BILLING_SALES_RULE_KEYS: readonly string[] = [
+  'internal.billing.credit_purchase',
+  'internal.billing.paid_plan',
+];
+
+export function isPlatformNotificationGroup(groupKey: string): boolean {
+  return groupKey === 'shadow' || groupKey === BILLING_SALES_GROUP_KEY;
+}

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

@@ -13,6 +13,10 @@ import {
 } from './events';
 import { legacySlackNotificationType } from './legacy-slack';
 import type { NotificationText } from './content';
+import {
+  BILLING_SALES_CREDIT_PURCHASE_MINIMUM_CENTS,
+  BILLING_SALES_GROUP_KEY,
+} from './billing-sales';
 
 type NotificationTypeDefinition = {
   id: string;
@@ -734,6 +738,71 @@ const PRODUCT_NOTIFICATION_TYPE_REGISTRY = [
       }),
     },
   },
+  {
+    id: 'internal.billing.credit_purchase',
+    eventName: ProductNotificationEvent.CreditsPurchaseCompleted,
+    requiredFilter: { currency: 'usd' },
+    allowedTriggers: ['threshold_crossing'],
+    catalog: undefined,
+    shadow: true,
+    rule: {
+      default: {
+        ruleKey: 'internal.billing.credit_purchase',
+        groupKey: BILLING_SALES_GROUP_KEY,
+      },
+      create: (_input, base) => ({
+        ...base,
+        repeatMode: 'every_match',
+        trigger: {
+          kind: 'threshold_crossing',
+          direction: 'at_or_above',
+          threshold: BILLING_SALES_CREDIT_PURCHASE_MINIMUM_CENTS,
+          unit: 'usd_cents',
+        },
+      }),
+      present: ({ payload }) => ({
+        title: `Credit purchase: $${(Number(payload.amountPaidCents) / 100).toFixed(2)}`,
+        summary: [
+          { workspace: true },
+          ` purchased ${formatCredits(Number(payload.credits))} credits.`,
+        ],
+        details: [],
+        targetUrl: String(payload.targetUrl),
+        subjectKind: 'workspace',
+        subjectId: String(payload.accountId),
+      }),
+    },
+  },
+  {
+    id: 'internal.billing.paid_plan',
+    eventName: ProductNotificationEvent.BillingPlanPurchased,
+    requiredFilter: {},
+    allowedTriggers: ['each_match'],
+    catalog: undefined,
+    shadow: true,
+    rule: {
+      default: {
+        ruleKey: 'internal.billing.paid_plan',
+        groupKey: BILLING_SALES_GROUP_KEY,
+      },
+      create: (_input, base) => ({
+        ...base,
+        repeatMode: 'every_match',
+        trigger: { kind: 'each_match' },
+      }),
+      present: ({ payload }) => ({
+        title: 'New paid plan signup',
+        summary: [
+          { workspace: true },
+          ` signed up for the ${payload.planName} plan.`,
+        ],
+        details: [],
+        targetUrl: String(payload.targetUrl),
+        subjectKind: 'workspace',
+        subjectId: String(payload.accountId),
+      }),
+    },
+  },
   {
     id: 'play.failed',
     eventName: ProductNotificationEvent.PlayRunCompleted,

package/dist/bundling-sources/shared_libs/product-notifications/default-policy.ts

@@ -8,13 +8,19 @@ import {
   validateProductNotificationDeliveryTiming,
   type ProductNotificationDefaultPolicy,
 } from './configuration';
+import {
+  BILLING_SALES_CONNECTION_ID,
+  BILLING_SALES_DESTINATION_KEY,
+  BILLING_SALES_GROUP_KEY,
+  BILLING_SALES_SLACK_CHANNEL_ID,
+} from './billing-sales';
 
 /**
  * Product defaults stay in code. Workspaces see these rows synthetically until
  * they create sparse copy-on-write overrides.
  */
 export const CURRENT_PRODUCT_NOTIFICATION_DEFAULT_POLICY = {
-  version: 8,
+  version: 9,
   groups: [
     {
       groupKey: 'default',
@@ -32,6 +38,12 @@ export const CURRENT_PRODUCT_NOTIFICATION_DEFAULT_POLICY = {
       enabled: true,
       deliveryTiming: DEFAULT_PRODUCT_NOTIFICATION_DELIVERY_TIMING,
     },
+    {
+      groupKey: BILLING_SALES_GROUP_KEY,
+      name: 'Billing sales alerts',
+      enabled: true,
+      deliveryTiming: { mode: 'immediate' },
+    },
   ],
   destinations: [
     {
@@ -48,6 +60,19 @@ export const CURRENT_PRODUCT_NOTIFICATION_DEFAULT_POLICY = {
       enabled: true,
       settings: { kind: 'email_roles', roles: ['owner'] },
     },
+    {
+      destinationKey: BILLING_SALES_DESTINATION_KEY,
+      groupKey: BILLING_SALES_GROUP_KEY,
+      name: 'Deepline signup channel',
+      enabled: true,
+      settings: {
+        kind: 'slack',
+        targetKind: 'channel',
+        targetId: BILLING_SALES_SLACK_CHANNEL_ID,
+        targetName: 'Deepline signup channel',
+        oauthConnectionId: BILLING_SALES_CONNECTION_ID,
+      },
+    },
   ],
   rules: PRODUCT_NOTIFICATION_DEFAULT_RULES,
 } satisfies ProductNotificationDefaultPolicy;

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

@@ -206,9 +206,10 @@ export const PRODUCT_NOTIFICATION_EVENT_DEFINITIONS: readonly ProductNotificatio
         credits: 'number',
         targetUrl: 'string',
       },
+      optionalFacts: { amountPaidCents: 'number', currency: 'string' },
       orderingSubjectFact: 'accountId',
       allowedTriggers: ['threshold_crossing'],
-      allowedThresholdUnits: ['credits'],
+      allowedThresholdUnits: ['credits', 'usd_cents'],
     },
     {
       // The workspace moved onto a paid acquisition offer.
@@ -451,6 +452,13 @@ export function adaptProductNotificationObservation(input: {
     };
   }
   if (event.eventName === ProductNotificationEvent.CreditsPurchaseCompleted) {
+    if (trigger.kind === 'threshold_crossing' && trigger.unit === 'usd_cents') {
+      return {
+        kind: 'threshold_state',
+        currentValue: Number(event.payload.amountPaidCents ?? 0),
+        unit: 'usd_cents',
+      };
+    }
     return {
       kind: 'threshold_state',
       currentValue: Number(event.payload.credits),

package/dist/cli/auth-WRUUITRZ.js

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

package/dist/cli/{auth-337SVWQD.mjs → auth-XMYFUM5L.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-4LRG6AJZ.mjs";
-import "./chunk-XKW6HTWO.mjs";
-import "./chunk-JWUOPLAR.mjs";
+} from "./chunk-SCX2AZFY.mjs";
+import "./chunk-QFSISXKO.mjs";
+import "./chunk-6C4SD4U3.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-MTICVDNY.mjs";
+import "./chunk-KNK42P4M.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";