tokenmaxxing 1.38.0 → 1.40.0

package/src/lib/credstore.ts

@@ -3,8 +3,8 @@ import { dirname, join } from "node:path";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.ts";
 import * as kc from "./keychain.ts";
-import { credDir, keychain as kcNames, namespacedCredService, paths } from "./paths.ts";
-import { CredentialBlobSchema, ErrnoSchema } from "./types.ts";
+import { keychain as kcNames, namespacedCredService, storeDirFor } from "./paths.ts";
+import { CredentialBlobSchema, ErrnoSchema, type OAuthCreds } from "./types.ts";
 
 const CredTargetSchema = z.discriminatedUnion("kind", [
   z.object({ kind: z.literal("keychain"), service: z.string(), account: z.string() }),
@@ -14,8 +14,6 @@ export type CredTarget = z.infer<typeof CredTargetSchema>;
 
 const darwin = process.platform === "darwin";
 
-const BlobRecordSchema = z.record(z.string(), z.unknown());
-
 export async function readItem(t: CredTarget): Promise<string | null> {
   if (t.kind === "keychain") return kc.readItem(t);
   try {
@@ -43,31 +41,22 @@ export async function deleteItem(t: CredTarget): Promise<boolean> {
   }
 }
 
-export function liveTarget(): CredTarget {
+export function isolatedTarget(configDirRaw: string): CredTarget {
   return darwin
-    ? { kind: "keychain", service: kcNames.service, account: kcNames.account }
-    : { kind: "file", path: join(credDir(), ".credentials.json") };
+    ? { kind: "keychain", service: namespacedCredService(configDirRaw), account: kcNames.account }
+    : { kind: "file", path: join(configDirRaw, ".credentials.json") };
 }
 
-export function parkedTarget(itemName: string): CredTarget {
-  return darwin
-    ? { kind: "keychain", service: itemName, account: kcNames.account }
-    : { kind: "file", path: join(paths.credsDir, `${itemName}.json`) };
+export function storeTarget(accountId: string): CredTarget {
+  return isolatedTarget(storeDirFor(accountId));
 }
 
-export function isolatedTarget(configDirRaw: string): CredTarget {
-  return darwin
-    ? { kind: "keychain", service: namespacedCredService(configDirRaw), account: kcNames.account }
-    : { kind: "file", path: join(configDirRaw, ".credentials.json") };
+export async function readStore(accountId: string): Promise<OAuthCreds | null> {
+  const raw = await readItem(storeTarget(accountId));
+  return raw == null ? null : CredentialBlobSchema.parse(JSON.parse(raw)).claudeAiOauth;
 }
 
 export function claudeAiOauthOnly(fullBlobRaw: string): string {
   const b = CredentialBlobSchema.parse(JSON.parse(fullBlobRaw));
   return JSON.stringify({ claudeAiOauth: b.claudeAiOauth });
 }
-
-export function mergeIntoLive(currentLiveRaw: string | null, freshClaudeAiOauth: unknown): string {
-  const base = currentLiveRaw == null ? {} : BlobRecordSchema.parse(JSON.parse(currentLiveRaw));
-  base["claudeAiOauth"] = freshClaudeAiOauth;
-  return JSON.stringify(base);
-}

package/src/lib/decide.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { withLock } from "./lock.ts";
-import { POST_SWAP_COOLDOWN_MS, loadAccounts, loadConfig, loadDepletedWait, loadLastSwapAt, saveAccounts, saveDepletedWait } from "./state.ts";
+import { POST_SWAP_COOLDOWN_MS, loadAccounts, loadConfig, loadLastSwapAt, saveAccounts } from "./state.ts";
 import { isExhausted, limitWindows, nextWeeklyReset, pickBest, pickEarliestReset, sessionWindow, thresholdBars, usableAt, weeklyWindow, type PickCtx } from "./picker.ts";
 import { familyTokens } from "./usage.ts";
 import { log } from "./log.ts";
@@ -43,12 +43,12 @@ function enforcedWall(limit: EnforcedLimit, account: Account, now: number): numb
   return limit.resetsAt ?? cachedReset ?? now + (limit.kind === "session" ? FIVE_HOURS_MS : WEEK_MS);
 }
 
-export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), anticipatory = false, enforced: EnforcedLimit | null = null): Promise<SwapDecision> {
+export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), canRespawn = false, enforced: EnforcedLimit | null = null): Promise<SwapDecision> {
   const activeId = p.liveId();
 
   const lastSwapAt = loadLastSwapAt(p.pool);
   if (!enforced && lastSwapAt != null && now - lastSwapAt < POST_SWAP_COOLDOWN_MS) {
-    return depletedReplay(p, now) ?? { swapped: false, account: null, reason: "post-swap-cooldown" };
+    return { swapped: false, account: null, reason: "post-swap-cooldown" };
   }
 
   const cfg = loadConfig();
@@ -58,11 +58,7 @@ export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), antici
   const observed = stored0 ? await p.observeLive(stored0, cfg, now, { probe: enforced == null && !walled0 }) : null;
   const stored = loadAccounts(p.pool).accounts.find((a) => a.id === activeId);
 
-  if (!enforced && !isOver(stored, observed, { now, thresholds: bars, currentId: activeId, families: p.gatedFamilies(cfg) })) {
-    if (!observed) {
-      const replay = depletedReplay(p, now);
-      if (replay) return replay;
-    }
+  if (!enforced && !isOver(stored, observed, { now, thresholds: bars, currentId: activeId, families: p.gatedFamilies(cfg), seats: null })) {
     return { swapped: false, account: null, reason: "under-threshold-or-stale" };
   }
 
@@ -89,12 +85,16 @@ export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), antici
       return { swapped: false, account: null, reason: "live-credential-not-in-pool" };
     }
 
-    const obs2 = active ? await p.observeLive(active, cfg, now, { probe: false }) : null;
-    if (active && obs2 && (active.lastUsageAt == null || obs2.at > active.lastUsageAt)) {
-      active.windows = p.mergeWindows(obs2.windows, active.windows);
-      active.lastUsageAt = obs2.at;
-      saveAccounts(p.pool, idx);
+    let obs2: Observation | null = null;
+    for (const a of idx.accounts) {
+      const obs = await p.observeLive(a, cfg, now, { probe: false });
+      if (a === active) obs2 = obs;
+      if (obs && (a.lastUsageAt == null || obs.at > a.lastUsageAt)) {
+        a.windows = p.mergeWindows(obs.windows, a.windows);
+        a.lastUsageAt = obs.at;
+      }
     }
+    saveAccounts(p.pool, idx);
 
     const families = p.gatedFamilies(cfg);
     const walled = active?.enforcedUntil != null && active.enforcedUntil > now;
@@ -102,18 +102,22 @@ export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), antici
     const screened = blindScreen && families != null ? cfg.policy.switchModels : families;
     const family = enforced?.family ?? null;
     const switchFamilies = screened == null ? null : family != null && !screened.includes(family) ? [...screened, family] : screened;
+    const present = p.presence();
+    const seats = p.seats === "shared" ? present : null;
 
-    const seatExhausted = active != null && isExhausted(active, { now, thresholds: bars, currentId: id2, families: switchFamilies });
-    if (!enforced2 && !isOver(active, obs2, { now, thresholds: bars, currentId: id2, families }) && !(enforced && seatExhausted)) {
-      return depletedReplay(p, now) ?? { swapped: false, account: null, reason: "raced-already-swapped" };
+    const seatExhausted = active != null && isExhausted(active, { now, thresholds: bars, currentId: id2, families: switchFamilies, seats });
+    if (!enforced2 && !isOver(active, obs2, { now, thresholds: bars, currentId: id2, families, seats }) && !(enforced && seatExhausted)) {
+      return { swapped: false, account: null, reason: "raced-already-swapped" };
+    }
+    if (p.seats === "shared" && !canRespawn) {
+      return { swapped: false, account: null, reason: "needs-respawn" };
     }
 
     const seatOf = (cur: { activeId: string | null; accounts: Account[] }): Account | null =>
       cur.accounts.find((a) => a.id === id2) ?? cur.accounts.find((a) => a.id === cur.activeId) ?? null;
 
-    const present = p.presentIds();
     const rejected = new Set<string>();
-    const usable = (accounts: Account[]): Account[] => accounts.filter((a) => !rejected.has(a.id) && (a.id === id2 || !present.has(a.id)));
+    const usable = (accounts: Account[]): Account[] => accounts.filter((a) => !rejected.has(a.id) && (p.seats === "shared" || a.id === id2 || !present.has(a.id)));
     const skipOrThrow = (e: unknown, candidate: Account): void => {
       if (p.classifySwapError(e) === "fatal") throw e;
       rejected.add(candidate.id);
@@ -122,7 +126,7 @@ export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), antici
     while (true) {
       const cur = loadAccounts(p.pool);
       const seat = seatOf(cur);
-      const ctx: PickCtx = { now, thresholds: bars, currentId: seat?.id ?? null, families: switchFamilies };
+      const ctx: PickCtx = { now, thresholds: bars, currentId: seat?.id ?? null, families: switchFamilies, seats };
       const best = pickBest(usable(cur.accounts), ctx);
       if (!best) break;
       try {
@@ -143,7 +147,7 @@ export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), antici
     while (true) {
       const fresh = loadAccounts(p.pool);
       const current = seatOf(fresh);
-      const ctx: PickCtx = { now, thresholds: bars, currentId: current?.id ?? null, families: switchFamilies };
+      const ctx: PickCtx = { now, thresholds: bars, currentId: current?.id ?? null, families: switchFamilies, seats };
       const currentAt = current ? usableAt(current, ctx) : Number.POSITIVE_INFINITY;
       const other = pickEarliestReset(usable(fresh.accounts), ctx);
 
@@ -159,10 +163,6 @@ export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), antici
       }
 
       const isCurrent = target.id === (current?.id ?? null);
-      if (!isCurrent && !anticipatory) {
-        log("decide.depleted_no_park", { account: target.id.slice(0, 8), waitUntil });
-        return { swapped: false, account: null, reason: "all-depleted", waitUntil };
-      }
       if (!isCurrent) {
         try {
           await p.swap(target);
@@ -171,19 +171,8 @@ export async function evaluateAndMaybeSwap(p: Provider, now = Date.now(), antici
           continue;
         }
       }
-      saveDepletedWait({ waitUntil, id: target.id, ts: now });
       log("decide.depleted_wait", { account: target.id.slice(0, 8), waitUntil });
       return { swapped: !isCurrent, account: target, reason: "depleted-wait", waitUntil };
     }
   });
 }
-
-function depletedReplay(p: Provider, now: number): SwapDecision | null {
-  if (!p.waitsWhenDepleted) return null;
-  const rec = loadDepletedWait();
-  if (!rec || rec.waitUntil <= now) return null;
-  const account = loadAccounts(p.pool).accounts.find((a) => a.id === rec.id) ?? null;
-  if (!account) return null;
-  if (account.id !== p.liveId()) return null;
-  return { swapped: false, account, reason: "depleted-wait", waitUntil: rec.waitUntil };
-}

package/src/lib/oauth.ts

@@ -1,19 +1,9 @@
-import { http, oauthErrorCode, safeErrorDetail } from "./http.ts";
+import { http, safeErrorDetail } from "./http.ts";
 import { env } from "./paths.ts";
-import { JsonTextSchema, ProfileResponseSchema, RefreshResponseSchema, TokenIdentitySchema, type OAuthCreds, type TokenIdentity } from "./types.ts";
+import { JsonTextSchema, ProfileResponseSchema, TokenIdentitySchema, type OAuthCreds, type TokenIdentity } from "./types.ts";
 
-const TOKEN_URL = env("TOKENMAXXING_OAUTH_TOKEN_URL", "https://platform.claude.com/v1/oauth/token");
-const CLIENT_ID = env("TOKENMAXXING_OAUTH_CLIENT_ID", "9d1c250a-e61b-44d9-88ed-5944d1962f5e");
 const PROFILE_URL = env("TOKENMAXXING_OAUTH_PROFILE_URL", "https://api.anthropic.com/api/oauth/profile");
 
-const DEFAULT_SCOPES = [
-  "user:profile",
-  "user:inference",
-  "user:sessions:claude_code",
-  "user:mcp_servers",
-  "user:file_upload",
-];
-
 export class InvalidGrantError extends Error {
   constructor(public readonly detail: string) {
     super(`invalid_grant: ${detail}`);
@@ -21,13 +11,6 @@ export class InvalidGrantError extends Error {
   }
 }
 
-export class RefreshRejectedError extends Error {
-  constructor(public readonly status: number, public readonly detail: string) {
-    super(`token refresh rejected (HTTP ${status}): ${detail}`);
-    this.name = "RefreshRejectedError";
-  }
-}
-
 export class IdentityUnavailableError extends Error {
   constructor(public readonly status: number | null, public readonly detail: string) {
     super(status == null ? `profile endpoint unreachable: ${detail}` : `identity check failed (HTTP ${status}): ${detail}`);
@@ -46,55 +29,6 @@ export function claudeTierLabel(input: { subscriptionType?: string; rateLimitTie
   return multiplier ? `${input.subscriptionType} ${multiplier}` : input.subscriptionType;
 }
 
-export async function refreshCredential(creds: OAuthCreds, now = Date.now(), signal?: AbortSignal): Promise<OAuthCreds> {
-  if (isDeadCredential(creds)) throw new InvalidGrantError("credential was cleared after a failed refresh");
-  const scope = (creds.scopes?.length ? creds.scopes : DEFAULT_SCOPES).join(" ");
-  const body = {
-    grant_type: "refresh_token",
-    refresh_token: creds.refreshToken,
-    client_id: CLIENT_ID,
-    scope,
-  };
-
-  let res: Response;
-  try {
-    res = await http.post(TOKEN_URL, {
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body),
-      signal,
-    });
-  } catch (e) {
-    throw new Error(`token endpoint unreachable: ${e instanceof Error ? e.message : String(e)}`);
-  }
-
-  const text = await res.text();
-  if (!res.ok) {
-    const detail = safeErrorDetail({ text });
-    if (res.status === 400 && oauthErrorCode({ text }) === "invalid_grant") throw new InvalidGrantError(detail);
-    if (res.status >= 400 && res.status < 500) throw new RefreshRejectedError(res.status, detail);
-    throw new Error(`token refresh failed (HTTP ${res.status}): ${detail}`);
-  }
-
-  const parsed = RefreshResponseSchema.safeParse(JsonTextSchema.safeParse(text).data);
-  if (!parsed.success) {
-    throw new Error(`token endpoint returned an unrecognized body (${text.length} bytes, withheld)`);
-  }
-  const json = parsed.data;
-
-  const expiresIn = json.expires_in ?? 8 * 3600;
-  const refreshExpiresIn = json.refresh_token_expires_in;
-
-  return {
-    ...creds,
-    accessToken: json.access_token,
-    refreshToken: json.refresh_token ?? creds.refreshToken,
-    expiresAt: now + expiresIn * 1000,
-    refreshTokenExpiresAt:
-      refreshExpiresIn != null ? now + refreshExpiresIn * 1000 : creds.refreshTokenExpiresAt,
-    scopes: json.scope ? json.scope.split(" ").filter(Boolean) : creds.scopes,
-  };
-}
-
 export function isAccessTokenExpiring(creds: OAuthCreds, skewMs = 120_000, now = Date.now()): boolean {
   return !creds.expiresAt || creds.expiresAt - now <= skewMs;
 }

package/src/lib/paths.ts

@@ -15,22 +15,21 @@ const TM_HOME = env("TOKENMAXXING_HOME", join(HOME, ".config", "tokenmaxxing"));
 export const paths = {
   home: TM_HOME,
   configJson: join(TM_HOME, "config.json"),
-  usageJson: join(TM_HOME, "usage.json"),
-  depletedJson: join(TM_HOME, "depleted.json"),
+  usageDir: join(TM_HOME, "usage"),
   respawnDir: join(TM_HOME, "respawn"),
+  presenceDir: join(TM_HOME, "live"),
   binDir: join(TM_HOME, "bin"),
   supervisorLink: join(TM_HOME, "bin", "claude"),
   logFile: join(TM_HOME, "tokenmaxxing.log"),
   onboardDir: join(TM_HOME, "onboard"),
   sampleDir: join(TM_HOME, "sample"),
-  credsDir: join(TM_HOME, "creds"),
+  storesDir: join(TM_HOME, "stores"),
   setupTokensJson: join(TM_HOME, "setup-tokens.json"),
   setupTokenDir: join(TM_HOME, "setup-token"),
   cloudSessionsJson: join(TM_HOME, "cloud", "sessions.json"),
   cloudWalledJson: join(TM_HOME, "cloud", "walled.json"),
   cloudLockFile: join(TM_HOME, "cloud", "lock"),
 
-  claudeJson: env("TOKENMAXXING_CLAUDE_JSON", join(HOME, ".claude.json")),
   claudeSettings: env(
     "TOKENMAXXING_CLAUDE_SETTINGS",
     join(env("CLAUDE_CONFIG_DIR", join(HOME, ".claude")), "settings.json"),
@@ -43,7 +42,7 @@ export const paths = {
 
 export const claudePool = {
   accountsJson: join(TM_HOME, "accounts.json"),
-  lastSwapJson: join(TM_HOME, "lastswap.json"),
+  lastSwapJson: null,
   lockFile: join(TM_HOME, "lock"),
 } as const;
 
@@ -53,7 +52,7 @@ export const codexPool = {
   lockFile: join(TM_HOME, "codex-lock"),
 } as const;
 
-export type PoolPaths = { accountsJson: string; lastSwapJson: string; lockFile: string };
+export type PoolPaths = { accountsJson: string; lastSwapJson: string | null; lockFile: string };
 
 const CODEX_HOME = env("TOKENMAXXING_CODEX_HOME", env("CODEX_HOME", join(HOME, ".codex")));
 
@@ -73,18 +72,29 @@ export function codexCredItemFor(accountId: string): string {
 }
 
 export const keychain = {
-  service: env("TOKENMAXXING_KEYCHAIN_SERVICE", "Claude Code-credentials"),
   account: env("TOKENMAXXING_KEYCHAIN_ACCOUNT", process.env.USER ?? "unknown"),
 } as const;
 
-export function credItemFor(accountUuid: string): string {
-  return `tokenmaxxing-cred-${accountUuid.slice(0, 8)}`;
+export function shortId(accountId: string): string {
+  return accountId.slice(0, 8);
 }
 
-export function credDir(): string {
-  const secure = process.env.CLAUDE_SECURESTORAGE_CONFIG_DIR;
-  if (secure !== undefined) return (secure || join(HOME, ".claude")).normalize("NFC");
-  return paths.claudeDir;
+export function storeDirFor(accountId: string): string {
+  return join(paths.storesDir, shortId(accountId));
+}
+
+export function sampleDirFor(accountId: string, suffix = ""): string {
+  return join(paths.sampleDir, `${shortId(accountId)}${suffix}`);
+}
+
+export function usageJsonFor(accountId: string): string {
+  return join(paths.usageDir, `${shortId(accountId)}.json`);
+}
+
+export function seatFromEnv(accountIds: string[], env: Record<string, string | undefined> = process.env): string | null {
+  const store = env.CLAUDE_SECURESTORAGE_CONFIG_DIR;
+  if (store == null || store === "") return null;
+  return accountIds.find((id) => storeDirFor(id) === store) ?? null;
 }
 
 export function namespacedCredService(configDirRaw: string): string {

package/src/lib/picker.ts

@@ -15,6 +15,7 @@ const PickCtxSchema = z.object({
   thresholds: ThresholdsSchema,
   currentId: z.string().nullable(),
   families: z.array(z.string()).nullable(),
+  seats: z.map(z.string(), z.number()).nullable(),
 });
 export type PickCtx = z.infer<typeof PickCtxSchema>;
 
@@ -93,7 +94,14 @@ export function pacePressure(a: Account, now: number): number {
   return Math.max(0, 100 - liveUsed(weekly, now)) / Math.max(1, reset - now);
 }
 
+export function seatHeadroom(a: Account, ctx: PickCtx): number {
+  const session = sessionWindow(a);
+  if (session == null) return Number.NEGATIVE_INFINITY;
+  return (ctx.thresholds.session - liveUsed(session, ctx.now)) / ((ctx.seats?.get(a.id) ?? 0) + 1);
+}
+
 const swapPreference = (ctx: PickCtx) => [
+  ...(ctx.seats == null ? [] : [(a: Account) => -seatHeadroom(a, ctx)]),
   (a: Account) => -pacePressure(a, ctx.now),
   (a: Account) => weeklyExpiry(a, ctx.now),
   (a: Account) => weeklyWindow(a)?.usedPercentage ?? 101,

package/src/lib/presence.ts

@@ -0,0 +1,67 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { writeFileAtomic } from "./atomic.ts";
+import { pidExists, pidStartTime } from "./proc.ts";
+
+const PresenceSchema = z.object({
+  accountId: z.string(),
+  pid: z.number(),
+  startedAt: z.string(),
+});
+
+export function writePresence(input: { dir: string; id: string; accountId: string; pid: number }): void {
+  const startedAt = pidStartTime(input.pid);
+  if (startedAt == null) throw new Error(`could not read pid ${input.pid}'s start time (ps lstart) - refusing to write an unverifiable presence file`);
+  mkdirSync(input.dir, { recursive: true });
+  writeFileAtomic(join(input.dir, input.id), JSON.stringify(PresenceSchema.parse({ accountId: input.accountId, pid: input.pid, startedAt })));
+}
+
+export function clearPresence(input: { dir: string; id: string }): void {
+  rmSync(join(input.dir, input.id), { force: true });
+}
+
+const LivingPresenceSchema = z.object({ id: z.string(), accountId: z.string() });
+export type LivingPresence = z.infer<typeof LivingPresenceSchema>;
+
+export function livingPresences(dir: string): LivingPresence[] {
+  const living: LivingPresence[] = [];
+  if (!existsSync(dir)) return living;
+  for (const name of readdirSync(dir)) {
+    const file = join(dir, name);
+    let raw: string;
+    try {
+      raw = readFileSync(file, "utf8");
+    } catch (e) {
+      const errno = z.object({ code: z.string() }).safeParse(e);
+      if (errno.success && errno.data.code === "ENOENT") continue;
+      throw e;
+    }
+    const parsed = PresenceSchema.safeParse((() => {
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return null;
+      }
+    })());
+    if (!parsed.success) {
+      throw new Error(`${file} is not a readable presence record - it may belong to a RUNNING session, refusing to treat it as absent; remove the file (or respawn that session) to proceed`);
+    }
+    const observed = pidStartTime(parsed.data.pid);
+    if (observed !== parsed.data.startedAt) {
+      if (observed == null && pidExists(parsed.data.pid)) {
+        throw new Error(`ps could not read the start time of live pid ${parsed.data.pid} (${file}) - refusing to clear a presence file that may guard a RUNNING session`);
+      }
+      rmSync(file, { force: true });
+      continue;
+    }
+    living.push(LivingPresenceSchema.parse({ id: name, accountId: parsed.data.accountId }));
+  }
+  return living;
+}
+
+export function seatCounts(dir: string): Map<string, number> {
+  const counts = new Map<string, number>();
+  for (const presence of livingPresences(dir)) counts.set(presence.accountId, (counts.get(presence.accountId) ?? 0) + 1);
+  return counts;
+}

package/src/lib/provider.ts

@@ -12,12 +12,10 @@ export type Provider = {
   name: "claude" | "codex";
   flag: string;
   pool: PoolPaths;
+  seats: "shared" | "live";
   waitsWhenDepleted: boolean;
-  switchMargin: number;
-  switchNote: string;
   liveId(): string | null;
-  liveOwner(): Promise<string | null>;
-  presentIds(): Set<string>;
+  presence(): Map<string, number>;
   gatedFamilies(cfg: Config): string[] | null;
   observeLive(account: Account, cfg: Config, now: number, opts: { probe: boolean }): Promise<Observation | null>;
   samplePool(accounts: Account[], liveId: string | null, now: number): Promise<Map<string, SampleReport>>;