deepline 0.1.212 → 0.1.214

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

@@ -0,0 +1,162 @@
+export type RuntimePostgresLane = 'receipts' | 'sheets';
+
+export type RuntimePostgresLaneTelemetry = {
+  active: number;
+  queued: number;
+  acquired: number;
+  waited: number;
+  timedOut: number;
+  rejected: number;
+  totalWaitMs: number;
+  maxWaitMs: number;
+};
+
+export type RuntimePostgresAdmissionSnapshot = Record<
+  RuntimePostgresLane,
+  RuntimePostgresLaneTelemetry
+>;
+
+export class RuntimePostgresAdmissionTimeoutError extends Error {
+  constructor(
+    readonly lane: RuntimePostgresLane,
+    readonly queueDepth: number,
+    readonly timeoutMs: number,
+  ) {
+    super(
+      `Runtime Postgres ${lane} admission timed out after ${timeoutMs}ms (${queueDepth} queued).`,
+    );
+    this.name = 'RuntimePostgresAdmissionTimeoutError';
+  }
+}
+
+export class RuntimePostgresAdmissionQueueFullError extends Error {
+  constructor(
+    readonly lane: RuntimePostgresLane,
+    readonly queueDepth: number,
+  ) {
+    super(
+      `Runtime Postgres ${lane} admission queue is full (${queueDepth} queued).`,
+    );
+    this.name = 'RuntimePostgresAdmissionQueueFullError';
+  }
+}
+
+type Waiter = {
+  enqueuedAt: number;
+  timeout: ReturnType<typeof setTimeout>;
+  resolve: (release: () => void) => void;
+  reject: (error: Error) => void;
+};
+
+type LaneState = RuntimePostgresLaneTelemetry & { waiters: Waiter[] };
+
+function createLaneState(): LaneState {
+  return {
+    active: 0,
+    queued: 0,
+    acquired: 0,
+    waited: 0,
+    timedOut: 0,
+    rejected: 0,
+    totalWaitMs: 0,
+    maxWaitMs: 0,
+    waiters: [],
+  };
+}
+
+export class RuntimePostgresAdmission {
+  readonly #maxActivePerLane: number;
+  readonly #maxQueuedPerLane: number;
+  readonly #acquireTimeoutMs: number;
+  readonly #lanes: Record<RuntimePostgresLane, LaneState> = {
+    receipts: createLaneState(),
+    sheets: createLaneState(),
+  };
+
+  constructor(input: {
+    maxActivePerLane: number;
+    maxQueuedPerLane: number;
+    acquireTimeoutMs: number;
+  }) {
+    this.#maxActivePerLane = Math.max(1, Math.floor(input.maxActivePerLane));
+    this.#maxQueuedPerLane = Math.max(0, Math.floor(input.maxQueuedPerLane));
+    this.#acquireTimeoutMs = Math.max(1, Math.floor(input.acquireTimeoutMs));
+  }
+
+  async acquire(lane: RuntimePostgresLane): Promise<() => void> {
+    const state = this.#lanes[lane];
+    if (state.active < this.#maxActivePerLane && state.waiters.length === 0) {
+      state.active += 1;
+      state.acquired += 1;
+      return this.#releaseFor(lane);
+    }
+    if (state.waiters.length >= this.#maxQueuedPerLane) {
+      state.rejected += 1;
+      throw new RuntimePostgresAdmissionQueueFullError(
+        lane,
+        state.waiters.length,
+      );
+    }
+    state.waited += 1;
+    return await new Promise<() => void>((resolve, reject) => {
+      const waiter: Waiter = {
+        enqueuedAt: Date.now(),
+        timeout: setTimeout(() => {
+          const index = state.waiters.indexOf(waiter);
+          if (index < 0) return;
+          state.waiters.splice(index, 1);
+          state.queued = state.waiters.length;
+          state.timedOut += 1;
+          reject(
+            new RuntimePostgresAdmissionTimeoutError(
+              lane,
+              state.waiters.length,
+              this.#acquireTimeoutMs,
+            ),
+          );
+        }, this.#acquireTimeoutMs),
+        resolve,
+        reject,
+      };
+      state.waiters.push(waiter);
+      state.queued = state.waiters.length;
+    });
+  }
+
+  snapshot(): RuntimePostgresAdmissionSnapshot {
+    const snapshotLane = (state: LaneState): RuntimePostgresLaneTelemetry => ({
+      active: state.active,
+      queued: state.waiters.length,
+      acquired: state.acquired,
+      waited: state.waited,
+      timedOut: state.timedOut,
+      rejected: state.rejected,
+      totalWaitMs: state.totalWaitMs,
+      maxWaitMs: state.maxWaitMs,
+    });
+    return {
+      receipts: snapshotLane(this.#lanes.receipts),
+      sheets: snapshotLane(this.#lanes.sheets),
+    };
+  }
+
+  #releaseFor(lane: RuntimePostgresLane): () => void {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      const state = this.#lanes[lane];
+      state.active -= 1;
+      const waiter = state.waiters.shift();
+      state.queued = state.waiters.length;
+      if (!waiter) return;
+      clearTimeout(waiter.timeout);
+      const waitMs = Math.max(0, Date.now() - waiter.enqueuedAt);
+      state.totalWaitMs += waitMs;
+      state.maxWaitMs = Math.max(state.maxWaitMs, waitMs);
+      state.active += 1;
+      state.acquired += 1;
+      waiter.resolve(this.#releaseFor(lane));
+    };
+  }
+}

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

@@ -4,8 +4,8 @@
  * One of three pluggable axes (alongside runner-backends and dedup-backends).
  * Selected per-run via PlayExecutionProfile.
  *
- * Cloudflare Workflows is the default production scheduler through the
- * workers_edge profile. Absurd is the durable Daytona-backed scheduler.
+ * Absurd is the default production scheduler through the absurd profile.
+ * Cloudflare Workflows remains available through the workers_edge profile.
  *
  * Customer plays are unaffected — this is purely the orchestration layer.
  */

package/dist/bundling-sources/shared_libs/play-runtime/sheet-attempt-sql.ts

@@ -5,23 +5,14 @@ export function activeRuntimeSheetAttemptFenceSql(
   attemptExpiresAtExpression: string,
   attemptSeqExpression?: string,
 ): string {
-  const activeSameOwnerNewerAttempt =
-    attemptSeqExpression === undefined
-      ? `${tableAlias}._attempt_expires_at < ${attemptExpiresAtExpression}`
-      // Same owner + same sequence is a retry of the same logical run attempt.
-      // It may reclaim non-terminal rows; terminal rows are still guarded by
-      // newerTerminalRuntimeSheetRowSql before this predicate is considered.
-      : `COALESCE(${tableAlias}._attempt_seq, 0) <= ${attemptSeqExpression}::integer`;
-  return `(
-    /* owner: runtime; remove null-attempt compat after ledger cutover M1 */
-    ${tableAlias}._attempt_id IS NULL
-    OR ${tableAlias}._attempt_id = ${attemptIdExpression}
-    OR ${tableAlias}._attempt_expires_at <= now()
-    OR (
-      coalesce(${tableAlias}._attempt_owner_run_id, ${tableAlias}._run_id) = ${attemptOwnerRunIdExpression}
-      AND ${activeSameOwnerNewerAttempt}
-    )
-  )`;
+  void tableAlias;
+  void attemptIdExpression;
+  void attemptOwnerRunIdExpression;
+  void attemptExpiresAtExpression;
+  void attemptSeqExpression;
+  // Legacy attempt columns remain during the rolling migration only. They are
+  // not row admission or correctness state; schedule-time write versions are.
+  return 'TRUE';
 }
 
 /**
@@ -68,6 +59,13 @@ export function newerTerminalRuntimeSheetRowSql(
   attemptIdExpression?: string,
   attemptOwnerRunIdExpression?: string,
 ): string {
+  void tableAlias;
+  void attemptExpiresAtExpression;
+  void attemptSeqExpression;
+  void attemptIdExpression;
+  void attemptOwnerRunIdExpression;
+  return 'FALSE';
+  /* legacy implementation intentionally unreachable during rolling cleanup
   if (attemptSeqExpression !== undefined) {
     const sameSeqDifferentAttemptSql = attemptOwnerRunIdExpression
       ? `OR (
@@ -100,4 +98,5 @@ export function newerTerminalRuntimeSheetRowSql(
     AND ${attemptExpiresAtExpression} IS NOT NULL
     AND ${tableAlias}._attempt_expires_at > ${attemptExpiresAtExpression}
   )`;
+  */
 }

package/dist/bundling-sources/shared_libs/play-runtime/work-receipts.ts

@@ -63,6 +63,7 @@ export type WorkReceiptBatchClaimCommand = {
   playName: string;
   runId: string;
   keys: string[];
+  leaseIds?: string[];
   leaseAware?: boolean;
   reclaimRunning?: boolean;
   forceRefresh?: boolean;

package/dist/bundling-sources/shared_libs/plays/static-pipeline.ts

@@ -308,10 +308,7 @@ function truncateStaticSubstepsForStorage(
       return truncateStaticSubstepShallowForStorage(base);
     }
 
-    if (
-      base.type !== 'play_call' &&
-      'pipeline' in substepWithoutSourceText
-    ) {
+    if (base.type !== 'play_call' && 'pipeline' in substepWithoutSourceText) {
       const nestedPipeline = substepWithoutSourceText.pipeline;
       (base as { pipeline?: PlayStaticPipeline | null }).pipeline =
         nestedPipeline
@@ -588,6 +585,7 @@ export type PlayStaticSubstep = PlayStaticSubstepMetadata &
     | {
         type: 'play_call';
         playId: string;
+        execution?: 'inline' | 'child-workflow';
         field: string;
         inLoop?: boolean;
         pipeline?: PlayStaticPipeline | null;