src/overnight-plan.ts

Functions

Imports

It imports src/env.ts, src/github/client.ts, src/log.ts, src/ops-types/views.ts, src/time.ts. Imported by src/digest.ts, src/portal-overnight.ts, src/tools/jobs.ts.

Source

1import type { Env } from "./env";
2import type { DigestBlocked, DigestJob, DigestPr, OvernightDigest, OvernightPlan, PlanLane, SkippedJob, UsageSource, UsageTotals } from "./ops-types/views";
3import { resolveRepo } from "./github/client";
4import { logEvent } from "./log";
5import { HOUR_MS } from "./time";
6
7// THE OVERNIGHT PLAN AND THE MORNING DIGEST (capsid/research/design-automation-for-speed.md,
8// D2, ruled by Dustin 2026-10-04). Both are read-only views through `capsid_work_jobs` action `list`
9// (view "plan" and view "digest"), so no tool is added and a hand-started VS Code tab reads
10// them with the credential it already holds.
11//
12// THE PLAN says what an overnight run of about eight hours should work, per repo:
13//   - queued jobs, in priority order, that fit the budget. A gated job is planned too
14//     (conventions 2.3, Dustin 2026-10-07: gates apply to risky steps, not whole jobs):
15//     the session does its ordinary work, lists each risky step in the pull request for
16//     the seat, and moves on. It is marked `gated` so the session knows to. A parked job
17//     is never read: the query takes only queued rows;
18//   - one lane, so one session, per repo, however many namespaces map to it;
19//   - repos that run heavy suites share one budget, because their sessions run one at a
20//     time. With no policy document every repo counts as heavy: unknown fails closed.
21// It plans; it starts nothing. A job that blocks stops only itself, and the next job in
22// its lane is claimed by the session that was running it.
23//
24// THE DIGEST says what happened: pull requests ready, what blocked and why, and what each
25// job cost, from the outcome row (telemetry) or the agent's own claim.usage, never summed.
26
27const OVERNIGHT_POLICY_NAMESPACE = "capsid";
28const OVERNIGHT_POLICY_PATH = "policy/overnight.md";
29
30export const DEFAULT_BUDGET_MINUTES = 480;
31// What a job is assumed to take when its namespace has too few unblocked outcomes to
32// say. Deliberately on the long side: an estimate that is too short overfills the night.
33export const DEFAULT_ESTIMATE_MINUTES = 60;
34// Outcomes a namespace needs before its own record is trusted over the default.
35export const MIN_SAMPLES = 5;
36export const FLOOR_ESTIMATE_MINUTES = 15;
37const PLAN_JOBS_MAX = 500;
38const DIGEST_ROWS_MAX = 200;
39const DIGEST_DEFAULT_HOURS = 24;
40const SUMMARY_CHARS = 600;
41
42// THE POLICY DOCUMENT. `- heavy <namespace>` marks a repo whose suites are heavy,
43// `- budget-minutes <n>` sets the night, `- estimate <namespace> <minutes>` overrides a
44// namespace's estimate. Only lines that begin `- ` and name one of those are read; the
45// rest is prose. An unrecognised rule line refuses the document, because a rule that
46// silently did not apply reads as a repo that was planned correctly.
47
48export interface OvernightPolicy {
49  budget_minutes: number;
50  // "all" when no document says otherwise.
51  heavy: ReadonlySet<string> | "all";
52  estimates: ReadonlyMap<string, number>;
53}
54
55export const DEFAULT_POLICY: OvernightPolicy = { budget_minutes: DEFAULT_BUDGET_MINUTES, heavy: "all", estimates: new Map() };
56
57export function parseOvernightPolicy(body: string): { policy: OvernightPolicy } | { error: string } {
58  let budget = DEFAULT_BUDGET_MINUTES;
59  const heavy = new Set<string>();
60  const estimates = new Map<string, number>();
61  for (const [index, raw] of body.split(/\r?\n/).entries()) {
62    const line = raw.trim();
63    const m = /^- (heavy|budget-minutes|estimate)(?:\s+(.*))?$/.exec(line);
64    if (!m) continue;
65    const where = `line ${index + 1} (${line.slice(0, 80)})`;
66    const args = (m[2] ?? "").trim().split(/\s+/).filter(Boolean);
67    const ns = /^[a-z0-9][a-z0-9-]{0,62}$/;
68    if (m[1] === "heavy") {
69      if (args.length !== 1 || !ns.test(args[0])) return { error: `${where}: heavy takes one namespace` };
70      heavy.add(args[0]);
71    } else if (m[1] === "budget-minutes") {
72      const n = Number(args[0]);
73      if (args.length !== 1 || !Number.isInteger(n) || n < 60 || n > 1440) return { error: `${where}: budget-minutes takes one whole number from 60 to 1440` };
74      budget = n;
75    } else {
76      const n = Number(args[1]);
77      if (args.length !== 2 || !ns.test(args[0]) || !Number.isInteger(n) || n < 5 || n > 720) {
78        return { error: `${where}: estimate takes a namespace and whole minutes from 5 to 720` };
79      }
80      estimates.set(args[0], n);
81    }
82  }
83  return { policy: { budget_minutes: budget, heavy: heavy.size > 0 ? heavy : "all", estimates } };
84}
85
86// THE PLAN.
87
88export interface PlanJobRow {
89  id: string;
90  namespace: string;
91  title: string;
92  priority: number;
93  gate_required: number;
94  required_scopes: string | null;
95  min_record: string | null;
96  blocked_count: number;
97  created_at: string;
98}
99
100export interface Estimate {
101  minutes: number;
102  // Where the number came from: the policy document, the namespace's own record, or the default.
103  source: "policy" | "record" | "default";
104}
105
106// A namespace's repo, or why it has none: no mapping, and a corrupt one, are different facts.
107export type RepoOf = { repo: string } | { problem: string };
108
109/** Why a queued job is not planned, or null when it is. Order is the order the reasons read best in. */
110export function ineligibleReason(job: PlanJobRow, repoOf: ReadonlyMap<string, RepoOf>): string | null {
111  if (job.required_scopes !== null && job.required_scopes !== "" && job.required_scopes !== "{}") return `requires flags a driver does not hold (${job.required_scopes.slice(0, 80)})`;
112  if (job.min_record !== null && job.min_record !== "" && job.min_record !== "{}") return `requires a track record (min_record ${job.min_record.slice(0, 40)}), which a plan cannot check`;
113  if (/^LATER\b/.test(job.title)) return "its title defers it (LATER)";
114  const repo = repoOf.get(job.namespace);
115  if (!repo) return `namespace ${job.namespace} was not resolved to a repo`;
116  if ("problem" in repo) return `namespace ${job.namespace} has no usable repo, so there is no clone to run a session in: ${repo.problem}`;
117  return null;
118}
119
120export function buildOvernightPlan(input: {
121  jobs: readonly PlanJobRow[];
122  repoOf: ReadonlyMap<string, RepoOf>;
123  estimateOf: (namespace: string) => Estimate;
124  policy: OvernightPolicy;
125  policyState: { source: OvernightPlan["policy"]; note: string | null };
126  now: Date;
127  truncated?: boolean;
128}): OvernightPlan {
129  const { policy } = input;
130  const ordered = [...input.jobs].sort((a, b) => b.priority - a.priority || a.created_at.localeCompare(b.created_at));
131  const skipped: SkippedJob[] = [];
132  const lanes = new Map<string, PlanLane>();
133  const isHeavy = (namespace: string) => policy.heavy === "all" || policy.heavy.has(namespace);
134  // Minutes used per budget: one pool for every heavy repo, one per light repo.
135  const HEAVY_POOL = "\u0000heavy";
136  const used = new Map<string, number>();
137
138  for (const job of ordered) {
139    const why = ineligibleReason(job, input.repoOf);
140    if (why) {
141      skipped.push({ id: job.id, namespace: job.namespace, title: job.title, reason: why });
142      continue;
143    }
144    const repo = (input.repoOf.get(job.namespace) as { repo: string }).repo;
145    const heavy = isHeavy(job.namespace);
146    const pool = heavy ? HEAVY_POOL : repo;
147    const est = input.estimateOf(job.namespace);
148    const before = used.get(pool) ?? 0;
149    if (before + est.minutes > policy.budget_minutes) {
150      skipped.push({
151        id: job.id,
152        namespace: job.namespace,
153        title: job.title,
154        reason: `does not fit: ${est.minutes} minutes on top of ${before} already planned in ${heavy ? "the heavy repos' shared budget" : repo} exceeds ${policy.budget_minutes}`,
155      });
156      continue;
157    }
158    used.set(pool, before + est.minutes);
159    const lane = lanes.get(repo) ?? { repo, namespaces: [], heavy, jobs: [], planned_minutes: 0 };
160    if (!lane.namespaces.includes(job.namespace)) lane.namespaces.push(job.namespace);
161    // A repo reached by two namespaces is heavy if either says so, because its one session runs both.
162    lane.heavy = lane.heavy || heavy;
163    lane.jobs.push({ id: job.id, namespace: job.namespace, title: job.title, priority: job.priority, estimate_minutes: est.minutes, estimate_source: est.source, gated: job.gate_required === 1 });
164    lane.planned_minutes += est.minutes;
165    lanes.set(repo, lane);
166  }
167
168  return {
169    generated: input.now.toISOString(),
170    budget_minutes: policy.budget_minutes,
171    policy: input.policyState.source,
172    policy_note: input.policyState.note,
173    heavy_planned_minutes: used.get(HEAVY_POOL) ?? 0,
174    lanes: [...lanes.values()].sort((a, b) => a.repo.localeCompare(b.repo)),
175    skipped,
176    queued_read: input.jobs.length,
177    truncated: input.truncated === true,
178  };
179}
180
181/** The p75 of a namespace's unblocked-job durations, floored, or null with too few samples. */
182export function estimateFromDurations(durations: readonly number[]): number | null {
183  if (durations.length < MIN_SAMPLES) return null;
184  const sorted = [...durations].sort((a, b) => a - b);
185  const p75 = sorted[Math.min(sorted.length - 1, Math.ceil(sorted.length * 0.75) - 1)];
186  return Math.max(FLOOR_ESTIMATE_MINUTES, Math.ceil(p75));
187}
188
189interface DurationRow {
190  namespace: string;
191  duration_minutes: number | null;
192}
193
194export async function readOvernightPlan(env: Env, args: { namespace?: string }, now: Date): Promise<OvernightPlan & { for_namespace: string | null }> {
195  const { results } = await env.DB.prepare(
196    `SELECT id, namespace, title, priority, gate_required, required_scopes, min_record, blocked_count, created_at
197     FROM jobs WHERE status = 'queued' ORDER BY priority DESC, created_at ASC LIMIT ?1`
198  )
199    .bind(PLAN_JOBS_MAX + 1)
200    .all<PlanJobRow>();
201  const rows = results ?? [];
202  const truncated = rows.length > PLAN_JOBS_MAX;
203  const jobs = truncated ? rows.slice(0, PLAN_JOBS_MAX) : rows;
204
205  // The policy document. Absent is the default, and a document that does not parse is the
206  // default too, said aloud: a bad edit must not stop the night from having a plan.
207  const doc = await env.DB.prepare("SELECT body FROM documents WHERE namespace = ?1 AND path = ?2 AND status = 'published'")
208    .bind(OVERNIGHT_POLICY_NAMESPACE, OVERNIGHT_POLICY_PATH)
209    .first<{ body: string | null }>();
210  let policy = DEFAULT_POLICY;
211  let policyState: { source: OvernightPlan["policy"]; note: string | null } = {
212    source: "default",
213    note: `No ${OVERNIGHT_POLICY_NAMESPACE}/${OVERNIGHT_POLICY_PATH}: a ${DEFAULT_BUDGET_MINUTES} minute night and every repo treated as heavy, so one session at a time.`,
214  };
215  if (doc?.body != null) {
216    const parsed = parseOvernightPolicy(doc.body);
217    if ("policy" in parsed) {
218      policy = parsed.policy;
219      policyState = { source: "document", note: policy.heavy === "all" ? "The document names no heavy repo, so every repo is treated as heavy." : null };
220    } else {
221      policyState = { source: "invalid", note: `${OVERNIGHT_POLICY_NAMESPACE}/${OVERNIGHT_POLICY_PATH} was ignored: ${parsed.error}. The default applies.` };
222    }
223  }
224
225  // Each namespace's repo and estimate, read once.
226  const namespaces = [...new Set(jobs.map((j) => j.namespace))];
227  const repoOf = new Map<string, RepoOf>();
228  for (const ns of namespaces) {
229    try {
230      const { owner, repo } = await resolveRepo(env, ns);
231      repoOf.set(ns, { repo: `${owner}/${repo}` });
232    } catch (err) {
233      // Said in the skip reason, not swallowed: an unmapped namespace and a corrupt
234      // mapping have different fixes.
235      const problem = err instanceof Error ? err.message : String(err);
236      logEvent("error", "OVERNIGHT_PLAN", { message: `OVERNIGHT_PLAN no repo for ${ns}: ${problem}` });
237      repoOf.set(ns, { problem });
238    }
239  }
240  const durations = await env.DB.prepare(
241    `SELECT namespace, duration_minutes FROM job_outcomes WHERE blocked_count = 0 AND duration_minutes IS NOT NULL ORDER BY rowid DESC LIMIT ?1`
242  )
243    .bind(2000)
244    .all<DurationRow>();
245  const byNamespace = new Map<string, number[]>();
246  for (const row of durations.results ?? []) {
247    if (row.duration_minutes === null) continue;
248    const list = byNamespace.get(row.namespace) ?? [];
249    list.push(row.duration_minutes);
250    byNamespace.set(row.namespace, list);
251  }
252  const estimateOf = (namespace: string): Estimate => {
253    const fixed = policy.estimates.get(namespace);
254    if (fixed !== undefined) return { minutes: fixed, source: "policy" };
255    const own = estimateFromDurations(byNamespace.get(namespace) ?? []);
256    return own !== null ? { minutes: own, source: "record" } : { minutes: DEFAULT_ESTIMATE_MINUTES, source: "default" };
257  };
258
259  const plan = buildOvernightPlan({ jobs, repoOf, estimateOf, policy, policyState, now, truncated });
260  if (!args.namespace) return { ...plan, for_namespace: null };
261  // The plan is built over every namespace, because the heavy budget is shared across
262  // repos, and then narrowed to what the caller asked for.
263  const ns = args.namespace;
264  return {
265    ...plan,
266    lanes: plan.lanes.filter((l) => l.namespaces.includes(ns)).map((l) => ({ ...l, jobs: l.jobs.filter((j) => j.namespace === ns) })),
267    skipped: plan.skipped.filter((s) => s.namespace === ns),
268    for_namespace: ns,
269  };
270}
271
272// THE DIGEST.
273
274const NO_USAGE: UsageTotals = { cost_usd: null, active_seconds: null, tokens_input: null, tokens_output: null, tokens_cache_read: null, tokens_cache_creation: null };
275
276interface OutcomeRow {
277  job_id: string;
278  namespace: string;
279  title: string | null;
280  status: string | null;
281  result_kind: string | null;
282  duration_minutes: number | null;
283  blocked_count: number | null;
284  cost_usd: number | null;
285  tokens_input: number | null;
286  tokens_output: number | null;
287  tokens_cache_read: number | null;
288  tokens_cache_creation: number | null;
289  active_seconds: number | null;
290}
291
292interface BlockedRow {
293  id: string;
294  namespace: string;
295  title: string;
296  result_summary: string | null;
297  updated_at: string;
298}
299
300interface PrRow {
301  job_id: string;
302  namespace: string;
303  pr_url: string;
304  merged: number | null;
305}
306
307interface ReportedRow extends UsageTotals {
308  job_id: string;
309}
310
311const PR_URL = /https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/pull\/\d+/g;
312
313export const pullRequestsIn = (text: string | null): string[] => [...new Set(text?.match(PR_URL) ?? [])];
314
315const hasUsage = (u: UsageTotals): boolean => Object.values(u).some((v) => v !== null);
316
317const sum = (a: number | null, b: number | null): number | null => (a === null && b === null ? null : (a ?? 0) + (b ?? 0));
318
319function addUsage(total: UsageTotals, u: UsageTotals): UsageTotals {
320  return {
321    cost_usd: sum(total.cost_usd, u.cost_usd),
322    active_seconds: sum(total.active_seconds, u.active_seconds),
323    tokens_input: sum(total.tokens_input, u.tokens_input),
324    tokens_output: sum(total.tokens_output, u.tokens_output),
325    tokens_cache_read: sum(total.tokens_cache_read, u.tokens_cache_read),
326    tokens_cache_creation: sum(total.tokens_cache_creation, u.tokens_cache_creation),
327  };
328}
329
330/** One job's usage: the telemetry on its outcome row if any, else what the agent reported, else none. */
331export function chooseUsage(telemetry: UsageTotals, reported: UsageTotals | undefined): { usage: UsageTotals; source: UsageSource } {
332  if (hasUsage(telemetry)) return { usage: telemetry, source: "telemetry" };
333  if (reported && hasUsage(reported)) return { usage: reported, source: "reported" };
334  return { usage: NO_USAGE, source: "none" };
335}
336
337export function digestSinceFrom(since: string | undefined, now: Date): { ok: true; since: string } | { ok: false; refusal: string } {
338  if (since === undefined || since.trim() === "") return { ok: true, since: new Date(now.getTime() - DIGEST_DEFAULT_HOURS * HOUR_MS).toISOString() };
339  const parsed = Date.parse(since);
340  if (!/^\d{4}-\d{2}-\d{2}(T|$)/.test(since) || Number.isNaN(parsed)) {
341    return { ok: false, refusal: `since must be an ISO 8601 time such as 2026-10-04 or 2026-10-04T22:00:00Z; got '${since}'.` };
342  }
343  return { ok: true, since: new Date(parsed).toISOString() };
344}
345
346export async function readOvernightDigest(env: Env, args: { namespace?: string; since: string }, now: Date): Promise<OvernightDigest> {
347  const ns = args.namespace ?? null;
348  const bound = DIGEST_ROWS_MAX + 1;
349  const [outcomes, blocked, prs, reported] = await Promise.all([
350    env.DB.prepare(
351      `SELECT o.job_id AS job_id, o.namespace AS namespace, j.title AS title, j.status AS status, o.result_kind AS result_kind,
352         o.duration_minutes AS duration_minutes, o.blocked_count AS blocked_count, o.cost_usd AS cost_usd,
353         o.tokens_input AS tokens_input, o.tokens_output AS tokens_output, o.tokens_cache_read AS tokens_cache_read,
354         o.tokens_cache_creation AS tokens_cache_creation, o.active_seconds AS active_seconds
355       FROM job_outcomes o LEFT JOIN jobs j ON j.id = o.job_id
356       WHERE o.recorded_at >= ?1 AND (?2 IS NULL OR o.namespace = ?2) ORDER BY o.recorded_at DESC LIMIT ?3`
357    )
358      .bind(args.since, ns, bound)
359      .all<OutcomeRow>(),
360    env.DB.prepare(
361      `SELECT id, namespace, title, result_summary, updated_at FROM jobs
362       WHERE status = 'blocked' AND updated_at >= ?1 AND (?2 IS NULL OR namespace = ?2) ORDER BY updated_at DESC LIMIT ?3`
363    )
364      .bind(args.since, ns, bound)
365      .all<BlockedRow>(),
366    env.DB.prepare(
367      `SELECT p.job_id AS job_id, o.namespace AS namespace, p.pr_url AS pr_url, p.merged AS merged
368       FROM job_outcome_prs p JOIN job_outcomes o ON o.job_id = p.job_id
369       WHERE o.recorded_at >= ?1 AND (?2 IS NULL OR o.namespace = ?2) ORDER BY o.recorded_at DESC LIMIT ?3`
370    )
371      .bind(args.since, ns, bound)
372      .all<PrRow>(),
373    // What each job's agent reported (claim.usage), summed per job. The job set is a
374    // subquery on the same window, never a list of ids: D1 allows 100 bound parameters.
375    env.DB.prepare(
376      `SELECT job_id,
377         SUM(json_extract(raw, '$.claim.usage.cost_usd')) AS cost_usd,
378         SUM(json_extract(raw, '$.claim.usage.active_seconds')) AS active_seconds,
379         SUM(json_extract(raw, '$.claim.usage.tokens.input')) AS tokens_input,
380         SUM(json_extract(raw, '$.claim.usage.tokens.output')) AS tokens_output,
381         SUM(json_extract(raw, '$.claim.usage.tokens.cache_read')) AS tokens_cache_read,
382         SUM(json_extract(raw, '$.claim.usage.tokens.cache_creation')) AS tokens_cache_creation
383       FROM job_claims
384       WHERE json_extract(raw, '$.claim.usage') IS NOT NULL
385         AND job_id IN (SELECT job_id FROM job_outcomes WHERE recorded_at >= ?1 AND (?2 IS NULL OR namespace = ?2)
386                        UNION SELECT id FROM jobs WHERE status = 'blocked' AND updated_at >= ?1 AND (?2 IS NULL OR namespace = ?2))
387       GROUP BY job_id LIMIT ?3`
388    )
389      .bind(args.since, ns, bound)
390      .all<ReportedRow>(),
391  ]);
392
393  const truncated: string[] = [];
394  const within = <T>(name: string, rows: T[] | undefined): T[] => {
395    const list = rows ?? [];
396    if (list.length <= DIGEST_ROWS_MAX) return list;
397    truncated.push(name);
398    return list.slice(0, DIGEST_ROWS_MAX);
399  };
400  const reportedBy = new Map(within("reported", reported.results).map((r) => [r.job_id, r]));
401  const reportedOf = (id: string): UsageTotals | undefined => {
402    const r = reportedBy.get(id);
403    return r ? { cost_usd: r.cost_usd, active_seconds: r.active_seconds, tokens_input: r.tokens_input, tokens_output: r.tokens_output, tokens_cache_read: r.tokens_cache_read, tokens_cache_creation: r.tokens_cache_creation } : undefined;
404  };
405
406  const totals = {
407    telemetry: { ...NO_USAGE, jobs: 0 },
408    reported: { ...NO_USAGE, jobs: 0 },
409    jobs_without_usage: 0,
410  };
411  const tally = (source: UsageSource, usage: UsageTotals) => {
412    if (source === "none") {
413      totals.jobs_without_usage += 1;
414      return;
415    }
416    totals[source] = { ...addUsage(totals[source], usage), jobs: totals[source].jobs + 1 };
417  };
418
419  const finished: DigestJob[] = within("finished", outcomes.results).map((r) => {
420    const telemetry: UsageTotals = {
421      cost_usd: r.cost_usd,
422      active_seconds: r.active_seconds,
423      tokens_input: r.tokens_input,
424      tokens_output: r.tokens_output,
425      tokens_cache_read: r.tokens_cache_read,
426      tokens_cache_creation: r.tokens_cache_creation,
427    };
428    const { usage, source } = chooseUsage(telemetry, reportedOf(r.job_id));
429    tally(source, usage);
430    return {
431      id: r.job_id,
432      namespace: r.namespace,
433      title: r.title ?? "(job row not found)",
434      status: r.status ?? "unknown",
435      result_kind: r.result_kind,
436      duration_minutes: r.duration_minutes,
437      blocked_count: r.blocked_count,
438      usage,
439      usage_source: source,
440    };
441  });
442
443  const blockedJobs: DigestBlocked[] = within("blocked", blocked.results).map((r) => {
444    const { usage, source } = chooseUsage(NO_USAGE, reportedOf(r.id));
445    tally(source, usage);
446    return {
447      id: r.id,
448      namespace: r.namespace,
449      title: r.title,
450      at: r.updated_at,
451      summary: (r.result_summary ?? "").slice(0, SUMMARY_CHARS),
452      pull_requests: pullRequestsIn(r.result_summary),
453      usage,
454      usage_source: source,
455    };
456  });
457
458  const prRows = within("pull_requests", prs.results);
459  const ready: DigestPr[] = prRows
460    .filter((p) => p.merged !== 1)
461    .map((p) => ({ job_id: p.job_id, namespace: p.namespace, url: p.pr_url, state: p.merged === 0 ? ("open" as const) : ("unchecked" as const), source: "outcome" as const }));
462  const seen = new Set(ready.map((p) => p.url));
463  for (const b of blockedJobs) {
464    for (const url of b.pull_requests) {
465      if (seen.has(url)) continue;
466      seen.add(url);
467      ready.push({ job_id: b.id, namespace: b.namespace, url, state: "unchecked", source: "blocked summary" });
468    }
469  }
470
471  return {
472    generated: now.toISOString(),
473    since: args.since,
474    for_namespace: ns,
475    finished,
476    blocked: blockedJobs,
477    pull_requests_ready: ready,
478    pull_requests_merged: prRows.filter((p) => p.merged === 1).length,
479    totals,
480    truncated,
481  };
482}