Function makeExecutionLimitGate

apps/cloud/src/engine/execution-gate.ts:123–187

(checkBalance: ExecutionBalanceCheck)

 * instance so all engines it decorates share it.
 */
export const makeExecutionLimitGate = (checkBalance: ExecutionBalanceCheck) => {
  const timeoutMs = BALANCE_CHECK_TIMEOUT_MS;
  const cache = new Map<string, { readonly allowed: boolean; readonly expiresAtMs: number }>();

  const writeCache = (organizationId: string, allowed: boolean, nowMs: number): void => {
    if (cache.size >= BALANCE_CACHE_MAX_ENTRIES) {
      for (const [key, entry] of cache) {
        if (entry.expiresAtMs <= nowMs) cache.delete(key);
      }
      // Still saturated after dropping expired entries: reset rather than grow.
      if (cache.size >= BALANCE_CACHE_MAX_ENTRIES) cache.clear();
    }
    cache.set(organizationId, { allowed, expiresAtMs: nowMs + BALANCE_CACHE_TTL_MS });
  };

  const toDecision = (organizationId: string, allowed: boolean): GateDecision =>
    allowed
      ? { blocked: false }
      : {
          blocked: true,
          error: new ExecutionLimitReachedError({
            organizationId,
            message: EXECUTION_LIMIT_BLOCKED_MESSAGE,
          }),
        };

  const decide = (organizationId: string): Effect.Effect<GateDecision> =>
    Effect.suspend(() => {
      const nowMs = Date.now();
      const cached = cache.get(organizationId);
      if (cached && cached.expiresAtMs > nowMs) {
        return Effect.succeed(toDecision(organizationId, cached.allowed));
      }
      return checkBalance(organizationId).pipe(
        Effect.timeoutOrElse({
          duration: `${timeoutMs} millis`,
          orElse: () => Effect.fail(new GateCheckTimeoutError({ timeoutMs })),
        }),
        Effect.map(({ allowed }) => {
          writeCache(organizationId, allowed, nowMs);
          return toDecision(organizationId, allowed);
        }),
        // FAIL OPEN: Autumn errors, timeouts, and missing customers/features
        // must never block executions. Reported like `trackExecution` so a
        // billing outage still pages; the error outcome is never cached.
        Effect.catch((error: unknown) =>
          Effect.gen(function* () {
            yield* Effect.sync(() => {
              console.warn("[billing] execution balance check failed open:", error);
            });
            yield* captureCauseEffect(error);
            return { blocked: false } as const satisfies GateDecision;
          }),
        ),
      );
    });

  return {