deepline 0.1.291 → 0.1.293

package/dist/bundling-sources/shared_libs/play-runtime/receipt-completion-sink.ts

@@ -1,343 +0,0 @@
-import {
-  RUNTIME_RECEIPT_COMPLETION_BUFFER_MAX_BYTES,
-  RUNTIME_RECEIPT_OUTPUT_MAX_BYTES,
-} from './output-size-limits';
-
-export const DEFAULT_RECEIPT_COMPLETION_SINK_MAX_BATCH_SIZE = 200;
-export const DEFAULT_RECEIPT_COMPLETION_SINK_MAX_FLUSH_MS = 10;
-export const DEFAULT_RECEIPT_COMPLETION_SINK_MAX_BUFFERED_BYTES =
-  RUNTIME_RECEIPT_COMPLETION_BUFFER_MAX_BYTES;
-export const DEFAULT_RECEIPT_COMPLETION_SINK_MAX_BATCH_BYTES = 1_000_000;
-export const DEFAULT_RECEIPT_COMPLETION_SINK_MAX_INPUT_BYTES =
-  RUNTIME_RECEIPT_OUTPUT_MAX_BYTES;
-
-type ReceiptCompletionSinkTimer = ReturnType<typeof setTimeout>;
-
-export interface ReceiptCompletionSinkFlushEvent {
-  count: number;
-  bytes: number;
-  elapsedMs?: number;
-}
-
-export interface RuntimeReceiptCompletionSinkOptions<TInput, TOutput> {
-  maxBatchSize?: number;
-  maxFlushMs?: number;
-  maxBufferedBytes?: number;
-  /** Flush trigger and maximum ordinary transport batch size. */
-  maxBatchBytes?: number;
-  maxInputBytes?: number;
-  estimateBytes?: (input: TInput) => number;
-  completeMany: (inputs: TInput[]) => Promise<TOutput[]>;
-  onFlushStart?: (event: ReceiptCompletionSinkFlushEvent) => void;
-  onFlushDone?: (event: ReceiptCompletionSinkFlushEvent) => void;
-  onFlushError?: (
-    event: ReceiptCompletionSinkFlushEvent & { error: unknown },
-  ) => void;
-  now?: () => number;
-}
-
-interface PendingReceiptCompletion<TInput, TOutput> {
-  input: TInput;
-  bytes: number;
-  resolve: (output: TOutput) => void;
-  reject: (error: unknown) => void;
-}
-
-type CapacityWaiter = {
-  resolve: () => void;
-  reject: (error: unknown) => void;
-};
-
-function normalizePositiveInteger(
-  value: number | undefined,
-  fallback: number,
-): number {
-  if (typeof value !== 'number' || !Number.isFinite(value)) return fallback;
-  return Math.max(1, Math.floor(value));
-}
-
-function defaultReceiptCompletionByteEstimate(input: unknown): number {
-  try {
-    return new TextEncoder().encode(JSON.stringify(input)).byteLength;
-  } catch {
-    return 1024;
-  }
-}
-
-export class ReceiptCompletionBufferLimitError extends Error {
-  readonly code = 'RECEIPT_COMPLETION_BUFFER_LIMIT_EXCEEDED';
-
-  constructor(message: string) {
-    super(message);
-    this.name = 'ReceiptCompletionBufferLimitError';
-  }
-}
-
-export class ReceiptCompletionResultCountError extends Error {
-  readonly code = 'RECEIPT_COMPLETION_RESULT_COUNT_MISMATCH';
-
-  constructor(message: string) {
-    super(message);
-    this.name = 'ReceiptCompletionResultCountError';
-  }
-}
-
-export class RuntimeReceiptCompletionSink<TInput, TOutput> {
-  readonly maxBatchSize: number;
-  readonly maxFlushMs: number;
-  readonly maxBufferedBytes: number;
-  readonly maxBatchBytes: number;
-  readonly maxInputBytes: number;
-
-  #pending: Array<PendingReceiptCompletion<TInput, TOutput>> = [];
-  #pendingHead = 0;
-  /** Pending plus in-flight bytes. Released only after transport settles. */
-  #residentBytes = 0;
-  #pendingBytes = 0;
-  #capacityWaiters: CapacityWaiter[] = [];
-  #flushTimer: ReceiptCompletionSinkTimer | null = null;
-  #flushPromise: Promise<void> | null = null;
-  #closed = false;
-  #failure: Error | null = null;
-  #completeMany: (inputs: TInput[]) => Promise<TOutput[]>;
-  #estimateBytes: (input: TInput) => number;
-  #onFlushStart?: (event: ReceiptCompletionSinkFlushEvent) => void;
-  #onFlushDone?: (event: ReceiptCompletionSinkFlushEvent) => void;
-  #onFlushError?: (
-    event: ReceiptCompletionSinkFlushEvent & { error: unknown },
-  ) => void;
-  #now: () => number;
-
-  constructor(options: RuntimeReceiptCompletionSinkOptions<TInput, TOutput>) {
-    this.maxBatchSize = normalizePositiveInteger(
-      options.maxBatchSize,
-      DEFAULT_RECEIPT_COMPLETION_SINK_MAX_BATCH_SIZE,
-    );
-    this.maxFlushMs = normalizePositiveInteger(
-      options.maxFlushMs,
-      DEFAULT_RECEIPT_COMPLETION_SINK_MAX_FLUSH_MS,
-    );
-    this.maxBufferedBytes = normalizePositiveInteger(
-      options.maxBufferedBytes,
-      DEFAULT_RECEIPT_COMPLETION_SINK_MAX_BUFFERED_BYTES,
-    );
-    this.maxBatchBytes = normalizePositiveInteger(
-      options.maxBatchBytes,
-      DEFAULT_RECEIPT_COMPLETION_SINK_MAX_BATCH_BYTES,
-    );
-    this.maxInputBytes = normalizePositiveInteger(
-      options.maxInputBytes,
-      DEFAULT_RECEIPT_COMPLETION_SINK_MAX_INPUT_BYTES,
-    );
-    this.#completeMany = options.completeMany;
-    this.#estimateBytes =
-      options.estimateBytes ?? defaultReceiptCompletionByteEstimate;
-    this.#onFlushStart = options.onFlushStart;
-    this.#onFlushDone = options.onFlushDone;
-    this.#onFlushError = options.onFlushError;
-    this.#now = options.now ?? Date.now;
-  }
-
-  addComplete(input: TInput): Promise<TOutput> {
-    return this.addMany([input]).then((outputs) => outputs[0]!);
-  }
-
-  async addMany(inputs: readonly TInput[]): Promise<TOutput[]> {
-    if (inputs.length === 0) return Promise.resolve([]);
-    this.#throwIfUnavailable();
-    const outputPromises = inputs.map((input) => this.#admit(input));
-    this.#scheduleFlush();
-    return await Promise.all(outputPromises);
-  }
-
-  async addManyAndFlush(inputs: readonly TInput[]): Promise<TOutput[]> {
-    const outputsPromise = this.addMany(inputs);
-    const flushPromise = this.flush();
-    const [outputs] = await Promise.all([outputsPromise, flushPromise]);
-    return outputs;
-  }
-
-  async flush(): Promise<void> {
-    if (this.#failure) throw this.#failure;
-    this.#clearFlushTimer();
-    this.#flushPromise ??= this.#runFlushLoop().finally(() => {
-      this.#flushPromise = null;
-    });
-    return await this.#flushPromise;
-  }
-
-  async close(): Promise<void> {
-    this.#closed = true;
-    this.#wakeCapacityWaiters();
-    await this.flush();
-  }
-
-  getStats(): { pending: number; pendingBytes: number; flushing: boolean } {
-    return {
-      pending: this.#pendingCount(),
-      pendingBytes: this.#residentBytes,
-      flushing: Boolean(this.#flushPromise),
-    };
-  }
-
-  async #admit(input: TInput): Promise<TOutput> {
-    const bytes = Math.max(1, Math.ceil(this.#estimateBytes(input)));
-    if (bytes > this.maxInputBytes) {
-      return Promise.reject(
-        new ReceiptCompletionBufferLimitError(
-          `Runtime receipt completion payload is ${bytes} bytes, above the ${this.maxInputBytes} byte per-receipt limit. Parse large provider/search responses before returning them from the tool boundary.`,
-        ),
-      );
-    }
-    if (bytes > this.maxBufferedBytes) {
-      throw new ReceiptCompletionBufferLimitError(
-        `Runtime receipt completion payload is ${bytes} bytes, above the ${this.maxBufferedBytes} byte sink capacity.`,
-      );
-    }
-    while (this.#residentBytes + bytes > this.maxBufferedBytes) {
-      this.#throwIfUnavailable();
-      void this.flush().catch(() => undefined);
-      await new Promise<void>((resolve, reject) => {
-        this.#capacityWaiters.push({ resolve, reject });
-      });
-    }
-    this.#throwIfUnavailable();
-    this.#residentBytes += bytes;
-    this.#pendingBytes += bytes;
-    const completion = new Promise<TOutput>((resolve, reject) => {
-      this.#pending.push({ input, bytes, resolve, reject });
-      if (this.#pendingCount() >= this.maxBatchSize) {
-        void this.flush().catch(() => undefined);
-      }
-    });
-    if (this.#pendingBytes >= this.maxBatchBytes) {
-      void this.flush().catch(() => undefined);
-    }
-    this.#scheduleFlush();
-    return await completion;
-  }
-
-  #scheduleFlush(): void {
-    if (this.#flushTimer || this.#flushPromise || this.#pendingCount() === 0) {
-      return;
-    }
-    this.#flushTimer = setTimeout(() => {
-      this.#flushTimer = null;
-      void this.flush().catch(() => undefined);
-    }, this.maxFlushMs);
-  }
-
-  #clearFlushTimer(): void {
-    if (!this.#flushTimer) return;
-    clearTimeout(this.#flushTimer);
-    this.#flushTimer = null;
-  }
-
-  async #runFlushLoop(): Promise<void> {
-    while (this.#pendingCount() > 0) {
-      const batch = this.#takeBatch();
-      try {
-        await this.#flushBatch(batch);
-      } catch (error) {
-        this.#fail(error);
-        throw this.#failure;
-      }
-    }
-  }
-
-  #takeBatch(): Array<PendingReceiptCompletion<TInput, TOutput>> {
-    const batch: Array<PendingReceiptCompletion<TInput, TOutput>> = [];
-    let batchBytes = 0;
-    while (this.#pendingCount() > 0 && batch.length < this.maxBatchSize) {
-      const next = this.#pending[this.#pendingHead]!;
-      if (batch.length > 0 && batchBytes + next.bytes > this.maxBatchBytes) {
-        break;
-      }
-      this.#pendingHead += 1;
-      batch.push(next);
-      batchBytes += next.bytes;
-      this.#pendingBytes = Math.max(0, this.#pendingBytes - next.bytes);
-    }
-    if (
-      this.#pendingHead > 1_024 &&
-      this.#pendingHead * 2 >= this.#pending.length
-    ) {
-      this.#pending = this.#pending.slice(this.#pendingHead);
-      this.#pendingHead = 0;
-    }
-    return batch;
-  }
-
-  async #flushBatch(
-    batch: Array<PendingReceiptCompletion<TInput, TOutput>>,
-  ): Promise<void> {
-    const inputs = batch.map((item) => item.input);
-    const bytes = batch.reduce((sum, item) => sum + item.bytes, 0);
-    const startedAt = this.#now();
-    this.#onFlushStart?.({ count: inputs.length, bytes });
-    try {
-      const outputs = await this.#completeMany(inputs);
-      if (outputs.length !== batch.length) {
-        throw new ReceiptCompletionResultCountError(
-          `Runtime receipt completion sink expected ${batch.length} result(s), received ${outputs.length}.`,
-        );
-      }
-      outputs.forEach((output, index) => batch[index]!.resolve(output));
-      this.#onFlushDone?.({
-        count: inputs.length,
-        bytes,
-        elapsedMs: this.#now() - startedAt,
-      });
-    } catch (error) {
-      for (const item of batch) {
-        item.reject(error);
-      }
-      this.#onFlushError?.({
-        count: inputs.length,
-        bytes,
-        elapsedMs: this.#now() - startedAt,
-        error,
-      });
-      throw error;
-    } finally {
-      this.#residentBytes = Math.max(0, this.#residentBytes - bytes);
-      this.#wakeCapacityWaiters();
-    }
-  }
-
-  #pendingCount(): number {
-    return this.#pending.length - this.#pendingHead;
-  }
-
-  #throwIfUnavailable(): void {
-    if (this.#failure) throw this.#failure;
-    if (this.#closed) {
-      throw new Error('Runtime receipt completion sink is already closed.');
-    }
-  }
-
-  #wakeCapacityWaiters(): void {
-    const waiters = this.#capacityWaiters;
-    this.#capacityWaiters = [];
-    for (const waiter of waiters) {
-      if (this.#failure) waiter.reject(this.#failure);
-      else if (this.#closed) {
-        waiter.reject(
-          new Error('Runtime receipt completion sink is already closed.'),
-        );
-      } else waiter.resolve();
-    }
-  }
-
-  #fail(error: unknown): void {
-    this.#failure =
-      error instanceof Error ? error : new Error(String(error ?? 'Unknown'));
-    while (this.#pendingCount() > 0) {
-      const pending = this.#pending[this.#pendingHead++]!;
-      this.#residentBytes = Math.max(0, this.#residentBytes - pending.bytes);
-      this.#pendingBytes = Math.max(0, this.#pendingBytes - pending.bytes);
-      pending.reject(this.#failure);
-    }
-    this.#wakeCapacityWaiters();
-  }
-}

package/dist/bundling-sources/shared_libs/play-runtime/receipt-state-sink.ts

@@ -1,69 +0,0 @@
-import { RuntimeReceiptCompletionSink } from './receipt-completion-sink';
-
-/** Claims/state transitions are small; flush once a 512 KB SQL payload forms. */
-export const DEFAULT_RECEIPT_STATE_SINK_MAX_BATCH_BYTES = 512_000;
-
-export interface RuntimeReceiptStateSinkOptions<TInput, TOutput> {
-  maxBatchSize?: number;
-  maxFlushMs?: number;
-  maxBatchBytes?: number;
-  maxBufferedBytes?: number;
-  maxInputBytes?: number;
-  estimateBytes?: (input: TInput) => number;
-  applyMany: (inputs: TInput[]) => Promise<TOutput[]>;
-  onFlushStart?: (event: { count: number; bytes: number }) => void;
-  onFlushDone?: (event: {
-    count: number;
-    bytes: number;
-    elapsedMs?: number;
-  }) => void;
-  onFlushError?: (event: {
-    count: number;
-    bytes: number;
-    elapsedMs?: number;
-    error: unknown;
-  }) => void;
-}
-
-/**
- * Small coalescing sink for receipt state transitions where callers need the
- * resulting receipt before continuing, but sibling row/tool promises arrive in
- * the same event-loop turn. It is intentionally thin over the proven completion
- * sink so mark-running, mark-queued, and future state changes share one
- * batching shape.
- */
-export class RuntimeReceiptStateSink<TInput, TOutput> {
-  #sink: RuntimeReceiptCompletionSink<TInput, TOutput>;
-
-  constructor(options: RuntimeReceiptStateSinkOptions<TInput, TOutput>) {
-    this.#sink = new RuntimeReceiptCompletionSink<TInput, TOutput>({
-      maxBatchSize: options.maxBatchSize,
-      maxFlushMs: options.maxFlushMs,
-      maxBatchBytes:
-        options.maxBatchBytes ?? DEFAULT_RECEIPT_STATE_SINK_MAX_BATCH_BYTES,
-      maxBufferedBytes: options.maxBufferedBytes,
-      maxInputBytes: options.maxInputBytes,
-      estimateBytes: options.estimateBytes,
-      completeMany: options.applyMany,
-      onFlushStart: options.onFlushStart,
-      onFlushDone: options.onFlushDone,
-      onFlushError: options.onFlushError,
-    });
-  }
-
-  add(input: TInput): Promise<TOutput> {
-    return this.#sink.addComplete(input);
-  }
-
-  addMany(inputs: readonly TInput[]): Promise<TOutput[]> {
-    return this.#sink.addMany(inputs);
-  }
-
-  async flush(): Promise<void> {
-    await this.#sink.flush();
-  }
-
-  async close(): Promise<void> {
-    await this.#sink.close();
-  }
-}

package/dist/bundling-sources/shared_libs/plays/legacy-webhook-drain.ts

@@ -1,110 +0,0 @@
-export const LEGACY_WEBHOOK_RETRY_CODES = [
-  'ACTIVE_CONCURRENCY_LIMIT',
-  'SCHEDULER_CAPACITY',
-  'TRANSIENT_LAUNCH_FAILURE',
-] as const;
-
-export type LegacyWebhookRetryCode =
-  (typeof LEGACY_WEBHOOK_RETRY_CODES)[number];
-
-export const LEGACY_WEBHOOK_QUARANTINE_CODES = [
-  'PLAY_DEFINITION_MISSING',
-  'PLAY_BINDING_MISSING',
-  'PLAY_BINDING_DISABLED',
-  'PLAY_REVISION_MISSING',
-  'PLAY_REVISION_MISMATCH',
-  'ARTIFACT_RUNTIME_INCOMPATIBLE',
-  'ARTIFACT_REFERENCE_MISSING',
-  'WEBHOOK_PAYLOAD_INVALID',
-  'PLAY_PRE_RUN_VALIDATION_FAILED',
-  'RUN_IDENTITY_CONFLICT',
-  'MAX_DELIVERY_ATTEMPTS_EXCEEDED',
-] as const;
-
-export type LegacyWebhookQuarantineCode =
-  (typeof LEGACY_WEBHOOK_QUARANTINE_CODES)[number];
-
-export function isLegacyWebhookQuarantineCode(
-  value: unknown,
-): value is LegacyWebhookQuarantineCode {
-  return (
-    typeof value === 'string' &&
-    (LEGACY_WEBHOOK_QUARANTINE_CODES as readonly string[]).includes(value)
-  );
-}
-
-export type LegacyWebhookQuarantineFailure =
-  | { code: 'PLAY_DEFINITION_MISSING' }
-  | { code: 'PLAY_BINDING_MISSING' }
-  | { code: 'PLAY_BINDING_DISABLED'; actualStatus: string }
-  | { code: 'PLAY_REVISION_MISSING' }
-  | {
-      code: 'PLAY_REVISION_MISMATCH';
-      expectedDefinitionId: string;
-      actualDefinitionId: string;
-    }
-  | {
-      code: 'ARTIFACT_RUNTIME_INCOMPATIBLE';
-      expectedArtifactKind: 'cjs_node20';
-      actualArtifactKind: string;
-    }
-  | { code: 'ARTIFACT_REFERENCE_MISSING' }
-  | {
-      code: 'WEBHOOK_PAYLOAD_INVALID';
-      reason: 'unsupported_shape';
-    }
-  | { code: 'PLAY_PRE_RUN_VALIDATION_FAILED' }
-  | { code: 'RUN_IDENTITY_CONFLICT' }
-  | { code: 'MAX_DELIVERY_ATTEMPTS_EXCEEDED' };
-
-export type LegacyWebhookDrainState =
-  | { kind: 'pending' }
-  | {
-      kind: 'leased';
-      leaseOwner: string;
-      leaseExpiresAt: number;
-      attempts: number;
-    }
-  | {
-      kind: 'retry';
-      failureCode: LegacyWebhookRetryCode;
-      retryAt: number;
-      attempts: number;
-      error: string;
-    }
-  | {
-      kind: 'quarantined';
-      failure: LegacyWebhookQuarantineFailure;
-      quarantinedAt: number;
-      attempts: number;
-      error: string;
-    }
-  | { kind: 'launched'; launchedAt: number }
-  | {
-      kind: 'migrated';
-      migratedAt: number;
-      migratedWebhookEventId: string;
-      migratedAbsurdTaskId: string;
-    }
-  | {
-      kind: 'retired';
-      retiredAt: number;
-      retiredBy: string;
-      reason: string;
-    };
-
-export type LegacyWebhookDrainOutcome =
-  | { kind: 'started' }
-  | { kind: 'quarantined'; failure: LegacyWebhookQuarantineFailure }
-  | { kind: 'retry'; failureCode: LegacyWebhookRetryCode }
-  | { kind: 'lease_lost' };
-
-export function isLegacyWebhookPayload(
-  value: unknown,
-): value is Record<string, unknown> | unknown[] {
-  return Array.isArray(value) || (value !== null && typeof value === 'object');
-}
-
-export function assertNever(value: never, context: string): never {
-  throw new Error(`${context}: ${JSON.stringify(value)}`);
-}