@treeseed/core 0.8.3 → 0.8.5

package/dist/services/workday-start.d.ts

@@ -1,195 +0,0 @@
-#!/usr/bin/env node
-export declare function runWorkdayStart(): Promise<{
-    ok: boolean;
-    mode: "reconcile";
-    managerId: string;
-    projectId: string;
-    environment: "local" | "prod" | "staging";
-    insideWorkWindow: boolean;
-    workPolicy: import("@treeseed/sdk").WorkdayPolicy;
-    workDay: Record<string, unknown>;
-    prioritySnapshot: import("@treeseed/sdk").PrioritySnapshot;
-    seededTasks: {
-        [x: string]: unknown;
-    }[];
-    queuedCount: number;
-    activeLeases: number;
-    desiredWorkers: number;
-    scaleResult: import("@treeseed/sdk").WorkerPoolScaleResult;
-    workdaySummary: Record<string, unknown>;
-} | {
-    ok: boolean;
-    created: boolean;
-    workDay: Record<string, unknown>;
-    skipped?: undefined;
-    reason?: undefined;
-    prioritySnapshot?: undefined;
-} | {
-    ok: boolean;
-    created: boolean;
-    skipped: boolean;
-    reason: string;
-    workDay?: undefined;
-    prioritySnapshot?: undefined;
-} | {
-    ok: boolean;
-    created: boolean;
-    workDay: import("@treeseed/sdk").SdkWorkDayEntity;
-    prioritySnapshot: import("@treeseed/sdk").PrioritySnapshot;
-    skipped?: undefined;
-    reason?: undefined;
-} | {
-    ok: boolean;
-    skipped: boolean;
-    reason: string;
-    workDay?: undefined;
-    summary?: undefined;
-    scale?: undefined;
-} | {
-    ok: boolean;
-    workDay: import("@treeseed/sdk").SdkWorkDayEntity;
-    summary: {
-        contentSnapshot: {
-            relativePath: string;
-            slug: string;
-            reportVersion: string;
-            title: string;
-        };
-        capacity: {
-            providerSplit: any;
-            grantedDailyCredits: number;
-            reservedCredits: number;
-            consumedCredits: number;
-            remainingDailyCredits: number | null;
-            providerCount: number;
-            laneCount: number;
-            grantCount: number;
-        };
-        projectId: string;
-        environment: "local" | "prod" | "staging";
-        workDayId: string;
-        state: string;
-        totalTasks: number;
-        completedTasks: number;
-        failedTasks: number;
-        queuedTasks: number;
-        activeTasks: number;
-        dailyTaskCreditBudget: number;
-        usedTaskCredits: number;
-        remainingTaskCredits: number;
-        creditLedgerEntries: number;
-        prioritySnapshotId: string;
-        priorityItemCount: number;
-        priorityItems: import("@treeseed/sdk").PrioritySnapshotItem[];
-        taskItems: {
-            id: string;
-            agentId: string;
-            type: string;
-            state: string;
-            priority: number;
-            idempotencyKey: string;
-            createdAt: string;
-            startedAt: string;
-            completedAt: string;
-            lastErrorCode: string;
-            lastErrorMessage: string;
-            lastEventKind: string;
-            outputCount: number;
-            changedFiles: string[];
-        }[];
-        changedFiles: string[];
-        releases: {
-            id: string;
-            deploymentKind: string;
-            status: string;
-            releaseTag: string;
-            commitSha: string;
-            sourceRef: string;
-            startedAt: string;
-            finishedAt: string;
-            createdAt: string;
-        }[];
-        scaleDecision: import("@treeseed/sdk").ScaleDecision;
-        scaleResult: import("@treeseed/sdk").WorkerPoolScaleResult;
-        generatedAt: string;
-    };
-    scale: import("@treeseed/sdk").WorkerPoolScaleResult;
-    skipped?: undefined;
-    reason?: undefined;
-} | {
-    ok: boolean;
-    skipped: boolean;
-    reason: string;
-    workDayId?: undefined;
-    summary?: undefined;
-} | {
-    ok: boolean;
-    workDayId: unknown;
-    summary: {
-        contentSnapshot: {
-            relativePath: string;
-            slug: string;
-            reportVersion: string;
-            title: string;
-        };
-        capacity: {
-            providerSplit: any;
-            grantedDailyCredits: number;
-            reservedCredits: number;
-            consumedCredits: number;
-            remainingDailyCredits: number | null;
-            providerCount: number;
-            laneCount: number;
-            grantCount: number;
-        };
-        projectId: string;
-        environment: "local" | "prod" | "staging";
-        workDayId: string;
-        state: string;
-        totalTasks: number;
-        completedTasks: number;
-        failedTasks: number;
-        queuedTasks: number;
-        activeTasks: number;
-        dailyTaskCreditBudget: number;
-        usedTaskCredits: number;
-        remainingTaskCredits: number;
-        creditLedgerEntries: number;
-        prioritySnapshotId: string;
-        priorityItemCount: number;
-        priorityItems: import("@treeseed/sdk").PrioritySnapshotItem[];
-        taskItems: {
-            id: string;
-            agentId: string;
-            type: string;
-            state: string;
-            priority: number;
-            idempotencyKey: string;
-            createdAt: string;
-            startedAt: string;
-            completedAt: string;
-            lastErrorCode: string;
-            lastErrorMessage: string;
-            lastEventKind: string;
-            outputCount: number;
-            changedFiles: string[];
-        }[];
-        changedFiles: string[];
-        releases: {
-            id: string;
-            deploymentKind: string;
-            status: string;
-            releaseTag: string;
-            commitSha: string;
-            sourceRef: string;
-            startedAt: string;
-            finishedAt: string;
-            createdAt: string;
-        }[];
-        scaleDecision: import("@treeseed/sdk").ScaleDecision;
-        scaleResult: import("@treeseed/sdk").WorkerPoolScaleResult;
-        generatedAt: string;
-    };
-    skipped?: undefined;
-    reason?: undefined;
-}>;

package/dist/services/workday-start.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-import { fileURLToPath } from "node:url";
-import { runManagerAction } from "./manager.js";
-async function runWorkdayStart() {
-  return runManagerAction({
-    mode: "open-workday"
-  });
-}
-const currentFile = fileURLToPath(import.meta.url);
-const entryFile = process.argv[1] ?? "";
-if (entryFile === currentFile) {
-  process.stdout.write(`${JSON.stringify(await runWorkdayStart(), null, 2)}
-`);
-}
-export {
-  runWorkdayStart
-};

package/dist/services/worker-capacity.d.ts

@@ -1,58 +0,0 @@
-import type { AgentPoolAutoscalePolicy, AgentSdk, ProjectEnvironmentName, ScaleDecision, WorkerPoolScaleResult, WorkerPoolScaler } from '@treeseed/sdk';
-export interface TaskMetricsSnapshot {
-    queuedTasks: Array<Record<string, unknown>>;
-    activeTasks: Array<Record<string, unknown>>;
-    queuedCount: number;
-    activeLeases: number;
-    queuedCredits: number;
-}
-export interface WorkerPoolIdentity {
-    projectId: string;
-    environment: ProjectEnvironmentName | 'local';
-    poolName: string;
-}
-export interface CapacityAssuranceResult {
-    ok: true;
-    taskId: string;
-    queued: true;
-    workerState: 'warm' | 'cold_starting';
-    desiredWorkers: number;
-    scaleApplied: boolean;
-    scaleReason: string;
-    scaleDecision: ScaleDecision;
-    scaleResult: WorkerPoolScaleResult;
-    metrics: TaskMetricsSnapshot;
-}
-export declare function resolveAutoscalePolicyFromEnv(): AgentPoolAutoscalePolicy;
-export declare function resolveWorkerPoolIdentityFromEnv(projectId?: string): WorkerPoolIdentity;
-export declare function computeDesiredWorkerCount(autoscale: AgentPoolAutoscalePolicy, metrics: Pick<TaskMetricsSnapshot, 'queuedCount' | 'activeLeases'>): number;
-export declare function applyScaleCooldown(autoscale: AgentPoolAutoscalePolicy, latestDecision: ScaleDecision | null, nextDesired: number, now: Date): number;
-export declare function applyInteractiveWakeUpOverride(options: {
-    priorityClass?: 'interactive' | 'background';
-    queuedCount: number;
-    currentWorkers: number;
-    desiredWorkers: number;
-}): number;
-export declare function collectTaskMetrics(sdk: AgentSdk, workDayId?: string | null): Promise<TaskMetricsSnapshot>;
-export declare function enqueueTaskAndEnsureCapacity(sdk: AgentSdk, request: {
-    taskId: string;
-    actor?: string;
-    queueName?: string;
-    deliveryDelaySeconds?: number;
-    priorityClass?: 'interactive' | 'background';
-    projectId?: string;
-    identity?: WorkerPoolIdentity;
-    autoscale?: AgentPoolAutoscalePolicy;
-    scaler?: WorkerPoolScaler;
-    now?: Date;
-    enqueueTask: (sdk: AgentSdk, request: {
-        taskId: string;
-        queueName?: string;
-        deliveryDelaySeconds?: number;
-        actor?: string;
-    }) => Promise<{
-        ok: boolean;
-        taskId: string;
-        queued: boolean;
-    }>;
-}): Promise<CapacityAssuranceResult>;

package/dist/services/worker-capacity.js

@@ -1,208 +0,0 @@
-import { createWorkerPoolScaler } from "./worker-pool-scaler.js";
-function integerFromEnv(name, fallback) {
-  const value = process.env[name];
-  if (!value) return fallback;
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) ? parsed : fallback;
-}
-function envValue(name) {
-  const value = process.env[name]?.trim();
-  return value ? value : "";
-}
-function parseJson(value, fallback) {
-  if (typeof value !== "string" || !value.trim()) {
-    return fallback;
-  }
-  try {
-    return JSON.parse(value);
-  } catch {
-    return fallback;
-  }
-}
-function readNumber(record, ...keys) {
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "number" && Number.isFinite(value)) {
-      return value;
-    }
-    if (typeof value === "string" && value.trim()) {
-      const parsed = Number.parseFloat(value);
-      if (Number.isFinite(parsed)) {
-        return parsed;
-      }
-    }
-  }
-  return null;
-}
-function asRecords(value) {
-  return Array.isArray(value) ? value : [];
-}
-function resolveAutoscalePolicyFromEnv() {
-  return {
-    minWorkers: integerFromEnv("TREESEED_AGENT_POOL_MIN_WORKERS", 0),
-    maxWorkers: integerFromEnv("TREESEED_AGENT_POOL_MAX_WORKERS", 1),
-    targetQueueDepth: Math.max(1, integerFromEnv("TREESEED_AGENT_POOL_TARGET_QUEUE_DEPTH", 1)),
-    cooldownSeconds: Math.max(0, integerFromEnv("TREESEED_AGENT_POOL_COOLDOWN_SECONDS", 60))
-  };
-}
-function resolveWorkerPoolIdentityFromEnv(projectId) {
-  const environment = envValue("TREESEED_DEPLOY_ENVIRONMENT") || (process.env.NODE_ENV === "production" ? "prod" : "local");
-  const resolvedProjectId = projectId?.trim() || envValue("TREESEED_PROJECT_ID") || "treeseed-market";
-  return {
-    projectId: resolvedProjectId,
-    environment,
-    poolName: envValue("TREESEED_AGENT_POOL_NAME") || `${resolvedProjectId}-${environment}`
-  };
-}
-function computeDesiredWorkerCount(autoscale, metrics) {
-  const { minWorkers, maxWorkers, targetQueueDepth } = autoscale;
-  if (metrics.queuedCount <= 0 && metrics.activeLeases <= 0) {
-    return minWorkers;
-  }
-  const requiredByQueue = Math.ceil(metrics.queuedCount / Math.max(1, targetQueueDepth));
-  const minimumActive = metrics.activeLeases > 0 ? 1 : 0;
-  return Math.max(minWorkers, Math.min(maxWorkers, Math.max(requiredByQueue, minimumActive)));
-}
-function applyScaleCooldown(autoscale, latestDecision, nextDesired, now) {
-  if (!latestDecision) {
-    return nextDesired;
-  }
-  if (nextDesired >= latestDecision.desiredWorkers) {
-    return nextDesired;
-  }
-  const cooldownMs = Math.max(0, autoscale.cooldownSeconds) * 1e3;
-  if (cooldownMs === 0) {
-    return nextDesired;
-  }
-  const lastChangedAt = new Date(latestDecision.createdAt);
-  if (!Number.isFinite(lastChangedAt.valueOf())) {
-    return nextDesired;
-  }
-  return now.valueOf() - lastChangedAt.valueOf() < cooldownMs ? latestDecision.desiredWorkers : nextDesired;
-}
-function applyInteractiveWakeUpOverride(options) {
-  if (options.priorityClass !== "interactive") {
-    return options.desiredWorkers;
-  }
-  if (options.queuedCount <= 0 || options.currentWorkers > 0 || options.desiredWorkers > 0) {
-    return options.desiredWorkers;
-  }
-  return 1;
-}
-async function collectTaskMetrics(sdk, workDayId) {
-  const [queuedEnvelope, activeEnvelope] = await Promise.all([
-    sdk.searchTasks({
-      workDayId: workDayId ?? void 0,
-      limit: 500,
-      state: ["pending", "queued"]
-    }),
-    sdk.searchTasks({
-      workDayId: workDayId ?? void 0,
-      limit: 500,
-      state: ["claimed", "running"]
-    })
-  ]);
-  const queuedTasks = asRecords(queuedEnvelope.payload);
-  const activeTasks = asRecords(activeEnvelope.payload);
-  const queuedCredits = queuedTasks.reduce((total, task) => {
-    const payload = parseJson(String(task.payloadJson ?? "{}"), {});
-    const credits = readNumber(payload, "estimatedCredits") ?? 1;
-    return total + credits;
-  }, 0);
-  return {
-    queuedTasks,
-    activeTasks,
-    queuedCount: queuedTasks.length,
-    activeLeases: activeTasks.length,
-    queuedCredits
-  };
-}
-async function enqueueTaskAndEnsureCapacity(sdk, request) {
-  await request.enqueueTask(sdk, {
-    taskId: request.taskId,
-    queueName: request.queueName,
-    deliveryDelaySeconds: request.deliveryDelaySeconds,
-    actor: request.actor
-  });
-  const now = request.now ?? /* @__PURE__ */ new Date();
-  const identity = request.identity ?? resolveWorkerPoolIdentityFromEnv(request.projectId);
-  const autoscale = request.autoscale ?? resolveAutoscalePolicyFromEnv();
-  const scaler = request.scaler ?? createWorkerPoolScaler();
-  const metrics = await collectTaskMetrics(sdk);
-  const latestScaleDecision = await sdk.getLatestScaleDecision(identity.projectId, identity.environment, identity.poolName);
-  const currentWorkers = Math.max(0, Number(latestScaleDecision.payload?.desiredWorkers ?? 0));
-  const rawDesiredWorkers = computeDesiredWorkerCount(autoscale, metrics);
-  const desiredAfterCooldown = applyScaleCooldown(autoscale, latestScaleDecision.payload, rawDesiredWorkers, now);
-  const desiredWorkers = applyInteractiveWakeUpOverride({
-    priorityClass: request.priorityClass ?? "background",
-    queuedCount: metrics.queuedCount,
-    currentWorkers,
-    desiredWorkers: desiredAfterCooldown
-  });
-  const coldStartTriggered = (request.priorityClass ?? "background") === "interactive" && currentWorkers <= 0 && desiredWorkers > 0;
-  const scaleReason = desiredWorkers !== desiredAfterCooldown ? "interactive_cold_start" : coldStartTriggered ? "interactive_cold_start" : desiredWorkers !== rawDesiredWorkers ? "cooldown_hold" : request.priorityClass === "interactive" ? "interactive_enqueue" : "enqueue";
-  const recordedScaleDecision = await sdk.recordScaleDecision({
-    projectId: identity.projectId,
-    environment: identity.environment,
-    poolName: identity.poolName,
-    workDayId: null,
-    desiredWorkers,
-    observedQueueDepth: metrics.queuedCount,
-    observedActiveLeases: metrics.activeLeases,
-    reason: scaleReason,
-    metadata: {
-      priorityClass: request.priorityClass ?? "background",
-      taskId: request.taskId
-    }
-  });
-  const scaleDecision = recordedScaleDecision.payload ?? {
-    projectId: identity.projectId,
-    environment: identity.environment,
-    poolName: identity.poolName,
-    workDayId: null,
-    desiredWorkers,
-    observedQueueDepth: metrics.queuedCount,
-    observedActiveLeases: metrics.activeLeases,
-    reason: scaleReason,
-    metadata: {
-      priorityClass: request.priorityClass ?? "background",
-      taskId: request.taskId
-    },
-    createdAt: now.toISOString()
-  };
-  let scaleResult;
-  try {
-    scaleResult = await scaler.scale(scaleDecision);
-  } catch (error) {
-    scaleResult = {
-      applied: false,
-      provider: "error",
-      desiredWorkers,
-      metadata: {
-        reason: "scale_failed",
-        error: error instanceof Error ? error.message : String(error)
-      }
-    };
-  }
-  return {
-    ok: true,
-    taskId: request.taskId,
-    queued: true,
-    workerState: currentWorkers > 0 ? "warm" : desiredWorkers > 0 ? "cold_starting" : "warm",
-    desiredWorkers,
-    scaleApplied: scaleResult.applied,
-    scaleReason,
-    scaleDecision,
-    scaleResult,
-    metrics
-  };
-}
-export {
-  applyInteractiveWakeUpOverride,
-  applyScaleCooldown,
-  collectTaskMetrics,
-  computeDesiredWorkerCount,
-  enqueueTaskAndEnsureCapacity,
-  resolveAutoscalePolicyFromEnv,
-  resolveWorkerPoolIdentityFromEnv
-};

package/dist/services/worker-pool-scaler.d.ts

@@ -1,27 +0,0 @@
-import type { ScaleDecision, WorkerPoolScaleResult, WorkerPoolScaler } from '@treeseed/sdk';
-export type WorkerPoolScalerKind = 'noop' | 'railway';
-export interface RailwayWorkerPoolScalerOptions {
-    apiToken?: string | null;
-    apiUrl?: string | null;
-    serviceId?: string | null;
-    environmentId?: string | null;
-    projectId?: string | null;
-    fetchImpl?: typeof fetch;
-}
-export declare class NoopWorkerPoolScaler implements WorkerPoolScaler {
-    scale(decision: ScaleDecision): Promise<WorkerPoolScaleResult>;
-}
-export declare class RailwayWorkerPoolScaler implements WorkerPoolScaler {
-    private readonly apiToken;
-    private readonly apiUrl;
-    private readonly serviceId;
-    private readonly environmentId;
-    private readonly projectId;
-    private readonly fetchImpl;
-    constructor(options?: RailwayWorkerPoolScalerOptions);
-    private railwayMutation;
-    private wakeRunner;
-    private sleepRunner;
-    scale(decision: ScaleDecision): Promise<WorkerPoolScaleResult>;
-}
-export declare function createWorkerPoolScaler(kind?: WorkerPoolScalerKind | null, options?: RailwayWorkerPoolScalerOptions): WorkerPoolScaler;

package/dist/services/worker-pool-scaler.js

@@ -1,127 +0,0 @@
-function envValue(name) {
-  const value = process.env[name]?.trim();
-  return value ? value : "";
-}
-class NoopWorkerPoolScaler {
-  async scale(decision) {
-    return {
-      applied: false,
-      provider: "noop",
-      desiredWorkers: decision.desiredWorkers,
-      metadata: {
-        reason: "scaler_unconfigured"
-      }
-    };
-  }
-}
-class RailwayWorkerPoolScaler {
-  apiToken;
-  apiUrl;
-  serviceId;
-  environmentId;
-  projectId;
-  fetchImpl;
-  constructor(options = {}) {
-    this.apiToken = options.apiToken?.trim() || envValue("RAILWAY_API_TOKEN") || null;
-    this.apiUrl = options.apiUrl?.trim() || envValue("TREESEED_RAILWAY_API_URL") || "https://backboard.railway.com/graphql/v2";
-    this.serviceId = options.serviceId?.trim() || envValue("TREESEED_RAILWAY_WORKER_SERVICE_ID") || envValue("TREESEED_WORKER_SERVICE_ID") || null;
-    this.environmentId = options.environmentId?.trim() || envValue("TREESEED_RAILWAY_ENVIRONMENT_ID") || null;
-    this.projectId = options.projectId?.trim() || envValue("TREESEED_RAILWAY_PROJECT_ID") || null;
-    this.fetchImpl = options.fetchImpl ?? fetch;
-  }
-  async railwayMutation(query, variables) {
-    if (!this.apiToken) {
-      throw new Error("Configure RAILWAY_API_TOKEN before waking Railway worker runners.");
-    }
-    const response = await this.fetchImpl(this.apiUrl, {
-      method: "POST",
-      headers: {
-        authorization: `Bearer ${this.apiToken}`,
-        "content-type": "application/json"
-      },
-      body: JSON.stringify({ query, variables })
-    });
-    const payload = await response.json().catch(() => ({}));
-    if (!response.ok || Array.isArray(payload.errors) && payload.errors.length > 0) {
-      throw new Error(payload.errors?.[0]?.message ?? `Railway runner request failed with ${response.status}.`);
-    }
-    return payload.data;
-  }
-  async wakeRunner() {
-    if (!this.serviceId || !this.environmentId) {
-      throw new Error("Railway runner wake requires serviceId and environmentId.");
-    }
-    const mutation = envValue("TREESEED_RAILWAY_RUNNER_WAKE_MUTATION") || `
-mutation TreeseedRailwayRunnerWake($serviceId: String!, $environmentId: String!) {
-	serviceInstanceRedeploy(serviceId: $serviceId, environmentId: $environmentId)
-}
-`.trim();
-    return await this.railwayMutation(mutation, {
-      serviceId: this.serviceId,
-      environmentId: this.environmentId,
-      projectId: this.projectId
-    });
-  }
-  async sleepRunner() {
-    if (!this.serviceId || !this.environmentId) {
-      throw new Error("Railway runner sleep requires serviceId and environmentId.");
-    }
-    const mutation = envValue("TREESEED_RAILWAY_RUNNER_SLEEP_MUTATION") || `
-mutation TreeseedRailwayRunnerSleep($serviceId: String!, $environmentId: String!) {
-	deploymentRemove(serviceId: $serviceId, environmentId: $environmentId)
-}
-`.trim();
-    return await this.railwayMutation(mutation, {
-      serviceId: this.serviceId,
-      environmentId: this.environmentId,
-      projectId: this.projectId
-    });
-  }
-  async scale(decision) {
-    const desiredWorkers = Math.max(0, Number(decision.desiredWorkers ?? 0));
-    const action = desiredWorkers > 0 ? "wake" : "sleep";
-    try {
-      const result = action === "wake" ? await this.wakeRunner() : await this.sleepRunner();
-      return {
-        applied: true,
-        provider: "railway",
-        desiredWorkers,
-        metadata: {
-          action,
-          projectId: this.projectId,
-          serviceId: this.serviceId,
-          environmentId: this.environmentId,
-          result
-        }
-      };
-    } catch (error) {
-      return {
-        applied: false,
-        provider: "railway",
-        desiredWorkers,
-        metadata: {
-          action,
-          reason: "named_runner_action_failed",
-          projectId: this.projectId,
-          serviceId: this.serviceId,
-          environmentId: this.environmentId,
-          error: error instanceof Error ? error.message : String(error)
-        }
-      };
-    }
-  }
-}
-function createWorkerPoolScaler(kind, options = {}) {
-  const configuredKind = envValue("TREESEED_WORKER_POOL_SCALER") || null;
-  const inferredKind = envValue("RAILWAY_API_TOKEN") && (envValue("TREESEED_RAILWAY_WORKER_SERVICE_ID") || envValue("TREESEED_WORKER_SERVICE_ID")) && envValue("TREESEED_RAILWAY_ENVIRONMENT_ID") ? "railway" : "noop";
-  const resolvedKind = kind ?? configuredKind ?? inferredKind;
-  if (resolvedKind === "railway") {
-    return new RailwayWorkerPoolScaler(options);
-  }
-  return new NoopWorkerPoolScaler();
-}
-export {
-  NoopWorkerPoolScaler,
-  RailwayWorkerPoolScaler,
-  createWorkerPoolScaler
-};

package/dist/services/worker.d.ts

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-export declare function runWorkerCycle(): Promise<{
-    ok: boolean;
-    processed: number;
-    idle: boolean;
-    reason: string;
-} | {
-    ok: boolean;
-    processed: number;
-    idle?: undefined;
-    reason?: undefined;
-}>;
-export declare function shouldExitWorkerLoopAfterIdle(options: {
-    idleExitMs?: number | null;
-    idleSince: number | null;
-    now: number;
-    processed: number;
-}): boolean;
-export declare function startWorkerLoop(): Promise<void>;