Method claimExecution

packages/runtime/src/runtime-kernel.ts:429–468

(sessionId: string)

  }

  claimExecution(sessionId: string): RuntimeExecutionClaim {
    if (this.stopIntents.has(sessionId)) {
      throw new Error(`Session ${sessionId} is stopping and cannot admit a new execution`);
    }
    let resolveSettled!: () => void;
    let rejectSettled!: (error: unknown) => void;
    const settled = new Promise<void>((resolve, reject) => {
      resolveSettled = resolve;
      rejectSettled = reject;
    });
    // A failed claim may have no concurrent stop subscriber; stop still observes this same promise.
    void settled.catch(() => undefined);
    const abortController = new AbortController();
    const cancellation = new RuntimeExecutionCancellation(sessionId);
    const handle: RuntimeExecutionClaim = {
      sessionId,
      stopSignal: abortController.signal,
      isStopRequested: () => state.stopIntent !== undefined,
      release: () => this.releaseExecutionClaim(state),
    };
    const state: PendingExecutionClaim = {
      handle,
      sessionId,
      abortController,
      cancellation,
      admissionBarrier: this.sessionMutationTails.get(sessionId) ?? Promise.resolve(),
      settled,
      resolveSettled,
      rejectSettled,
      phase: 'pending',
    };
    let claims = this.executionClaims.get(sessionId);
    if (!claims) {
      claims = new Set();
      this.executionClaims.set(sessionId, claims);
    }
    claims.add(state);
    this.executionClaimStates.set(handle, state);
    return handle;
  }

  async runSessionAdmissionMutation<T>(
    sessionIds: readonly string[],