background work = scheduled request + auth context + resource context + cancellation policy

setInterval(fetchData, 5000);

while current auth context is eligible:
  wait according to policy
  run request with abort support
  reconcile response with latest auth context
  render only if still current

type AuthContext = {
  authEpoch: number;
  status: 'anonymous' | 'authenticated' | 'refreshing' | 'expired' | 'revoked';
  userId?: string;
  tenantId?: string;
  sessionId?: string;
  permissionVersion?: string;
};

cancel timers
abort in-flight requests
clear query cache
close realtime connections
stop upload/autosave tasks
broadcast logout to other tabs
ignore late responses from old auth epoch

tenant A polling loop must not survive transition to tenant B

allowed at job start => allowed forever

many failed requests -> one refresh coordinator -> safe replay only

job metadata resource
generated output resource
underlying source resources

POST /api/cases/export
GET  /api/jobs/job_123
GET  /api/exports/export_456/download

{
  "id": "job_123",
  "status": "complete",
  "rows": 8942,
  "fileName": "high-risk-investigations.csv"
}

{
  "type": "https://example.com/problems/forbidden",
  "title": "Access denied",
  "status": 403,
  "code": "JOB_ACCESS_DENIED",
  "correlationId": "req_7b2f"
}

type PollContext = {
  authEpoch: number;
  tenantId: string;
  permissionVersion?: string;
};

type PollPolicy = {
  intervalMs: number;
  hiddenIntervalMs?: number;
  stopOnUnauthorized: boolean;
  stopOnForbidden: boolean;
  maxConsecutiveFailures: number;
};

type PollTask<T> = {
  name: string;
  getContext: () => PollContext | null;
  isEligible: (context: PollContext) => boolean;
  run: (context: PollContext, signal: AbortSignal) => Promise<T>;
  onResult: (result: T, context: PollContext) => void;
  onStop?: (reason: string) => void;
};

export function startAuthAwarePolling<T>(task: PollTask<T>, policy: PollPolicy) {
  let stopped = false;
  let timer: number | undefined;
  let controller: AbortController | undefined;
  let failures = 0;

  function stop(reason: string) {
    if (stopped) return;
    stopped = true;
    if (timer !== undefined) window.clearTimeout(timer);
    controller?.abort();
    task.onStop?.(reason);
  }

  function schedule(delay: number) {
    if (stopped) return;
    if (timer !== undefined) window.clearTimeout(timer);
    timer = window.setTimeout(tick, delay);
  }

  async function tick() {
    const context = task.getContext();
    if (!context) return stop('no_auth_context');
    if (!task.isEligible(context)) return stop('not_eligible');

    const startedEpoch = context.authEpoch;
    const startedTenant = context.tenantId;
    controller = new AbortController();

    try {
      const result = await task.run(context, controller.signal);
      const latest = task.getContext();

      if (!latest || latest.authEpoch !== startedEpoch) return stop('auth_epoch_changed');
      if (latest.tenantId !== startedTenant) return stop('tenant_changed');

      failures = 0;
      task.onResult(result, latest);

      const delay = document.visibilityState === 'hidden'
        ? policy.hiddenIntervalMs ?? policy.intervalMs
        : policy.intervalMs;

      schedule(delay);
    } catch (error) {
      if (controller.signal.aborted) return;

      const status = toHttpStatus(error);
      if (status === 401 && policy.stopOnUnauthorized) return stop('unauthorized');
      if (status === 403 && policy.stopOnForbidden) return stop('forbidden');

      failures += 1;
      if (failures >= policy.maxConsecutiveFailures) return stop('too_many_failures');
      schedule(backoff(policy.intervalMs, failures));
    }
  }

  schedule(0);
  return () => stop('unmounted');
}

function backoff(base: number, failures: number) {
  const jitter = Math.floor(Math.random() * 250);
  return Math.min(base * 2 ** failures + jitter, 60_000);
}

function toHttpStatus(error: unknown): number | undefined {
  if (typeof error === 'object' && error !== null && 'status' in error) {
    return Number((error as { status: unknown }).status);
  }
}

context snapshot -> request -> latest context reconciliation -> controlled continuation

type JobStatus =
  | { state: 'queued' }
  | { state: 'running'; percent?: number }
  | { state: 'complete'; outputId: string }
  | { state: 'failed'; reason: string }
  | { state: 'cancelled' };

export function useJobPolling(jobId: string, tenantId: string) {
  const auth = useAuthSnapshot();
  const can = useCan();
  const [status, setStatus] = React.useState<JobStatus | null>(null);
  const [stoppedReason, setStoppedReason] = React.useState<string | null>(null);

  React.useEffect(() => {
    if (auth.status !== 'authenticated') return;

    const allowed = can({
      action: 'job.read_status',
      resource: { type: 'job', id: jobId, tenantId },
    });

    if (!allowed.allowed) {
      setStoppedReason(allowed.reason.code);
      return;
    }

    return startAuthAwarePolling<JobStatus>(
      {
        name: `job:${jobId}`,
        getContext: () => {
          const latest = getAuthSnapshot();
          if (latest.status !== 'authenticated') return null;
          return {
            authEpoch: latest.authEpoch,
            tenantId: latest.tenantId,
            permissionVersion: latest.permissionVersion,
          };
        },
        isEligible: (ctx) => ctx.tenantId === tenantId,
        run: (_ctx, signal) => api.get(`/api/jobs/${jobId}`, { signal }),
        onResult: setStatus,
        onStop: setStoppedReason,
      },
      {
        intervalMs: 3000,
        hiddenIntervalMs: 15000,
        stopOnUnauthorized: true,
        stopOnForbidden: true,
        maxConsecutiveFailures: 5,
      }
    );
  }, [auth.status, auth.authEpoch, auth.tenantId, auth.permissionVersion, jobId, tenantId]);

  return { status, stoppedReason };
}

useQuery({
  queryKey: ['job', jobId],
  queryFn: () => api.get(`/api/jobs/${jobId}`),
  refetchInterval: 3000,
});

function useJobStatus(jobId: string) {
  const auth = useAuthSnapshot();

  return useQuery({
    queryKey: [
      'tenant', auth.tenantId,
      'authEpoch', auth.authEpoch,
      'permissionVersion', auth.permissionVersion,
      'job', jobId,
    ],
    enabled: auth.status === 'authenticated',
    queryFn: ({ signal }) => api.get(`/api/jobs/${jobId}`, { signal }),
    refetchInterval: (query) => {
      const data = query.state.data as JobStatus | undefined;
      if (!data) return 3000;
      if (data.state === 'complete' || data.state === 'failed' || data.state === 'cancelled') return false;
      if (document.visibilityState === 'hidden') return 15000;
      return 3000;
    },
    retry: (failureCount, error) => {
      const status = toHttpStatus(error);
      if (status === 401 || status === 403 || status === 404) return false;
      return failureCount < 3;
    },
  });
}

class RefreshCoordinator {
  private inFlight: Promise<void> | null = null;

  refreshOnce(refresh: () => Promise<void>) {
    if (!this.inFlight) {
      this.inFlight = refresh().finally(() => {
        this.inFlight = null;
      });
    }
    return this.inFlight;
  }
}

class PollingRegistry {
  private stops = new Map<string, () => void>();

  register(key: string, stop: () => void) {
    this.stops.set(key, stop);
    return () => this.stops.delete(key);
  }

  stopAll(reason: string) {
    for (const stop of this.stops.values()) stop();
    this.stops.clear();
    console.info('polling_stopped', { reason });
  }
}

authEvents.subscribe((event) => {
  if (event.type === 'LOGOUT') {
    pollingRegistry.stopAll('logout');
    queryClient.clear();
  }

  if (event.type === 'TENANT_SWITCH') {
    pollingRegistry.stopAll('tenant_switch');
    queryClient.removeQueries({
      predicate: (query) => query.queryKey.includes(event.fromTenantId),
    });
  }
});

If user could start job, job may complete and result remains available to that user.

User may start job, but must still be allowed to download result.

Revocation invalidates running job.

type JobPollResponse =
  | {
      kind: 'job_status';
      jobId: string;
      tenantId: string;
      status: 'queued' | 'running' | 'complete' | 'failed' | 'cancelled';
      progress?: { completed: number; total: number };
      nextPollAfterMs?: number;
    }
  | {
      kind: 'access_denied';
      code: 'JOB_PERMISSION_REVOKED' | 'TENANT_MISMATCH' | 'JOB_NOT_VISIBLE';
      correlationId: string;
    }
  | {
      kind: 'reauth_required';
      code: 'SESSION_EXPIRED' | 'STEP_UP_REQUIRED';
      returnTo: string;
    };

setInterval(() => saveDraft(formState), 5000);

authenticated only
current tenant only
current field-level write permission only
idempotency/versioning required
abort on logout/tenant switch
stop on 401/403
server enforces permission again

async function autosave(payload: DraftPatch, signal: AbortSignal) {
  const permission = permissionStore.can({
    action: 'case.update_draft',
    resource: { type: 'case', id: payload.caseId },
  });

  if (!permission.allowed) throw new ForbiddenError(permission.reason.code);

  return api.patch(`/api/cases/${payload.caseId}/draft`, payload, {
    signal,
    headers: { 'Idempotency-Key': stableAutosaveKey(payload) },
  });
}

type QueuedOperation = {
  operationId: string;
  operationType: string;
  resource: { type: string; id: string; tenantId: string };
  createdByUserId: string;
  createdUnderSessionId: string;
  createdUnderPermissionVersion: string;
  expiresAt: string;
  payloadHash: string;
};

session still valid?
user still same?
tenant still same?
permission still valid?
workflow state still allows operation?
queued operation not expired?

leader scoped by tenant and auth epoch
heartbeat expires quickly
logout releases leadership
tenant switch releases leadership
followers discard old-epoch results

{
  "event": "background_poll_stopped",
  "poller": "job-status",
  "reason": "tenant_changed",
  "authEpoch": 42,
  "tenantId": "ten_A",
  "correlationId": "req_abc"
}

it('discards job status from old auth epoch', async () => {
  const auth = createAuthStore({ authEpoch: 10, tenantId: 'A' });
  const results: JobStatus[] = [];
  const request = deferred<JobStatus>();

  const stop = startAuthAwarePolling<JobStatus>(
    {
      name: 'job:test',
      getContext: () => auth.snapshot(),
      isEligible: () => true,
      run: () => request.promise,
      onResult: (result) => results.push(result),
    },
    { intervalMs: 1, stopOnForbidden: true, stopOnUnauthorized: true, maxConsecutiveFailures: 1 }
  );

  auth.logout();
  request.resolve({ state: 'complete', outputId: 'out_1' });
  await flushPromises();

  expect(results).toEqual([]);
  stop();
});

React.useEffect(() => {
  const id = setInterval(load, 5000);
  return () => clearInterval(id);
}, []);

['notifications']

Every background request must prove it still belongs to the current authenticated context before it starts, while it runs, and before its result mutates UI state.