@valescoagency/runway 0.10.0 → 0.11.0

package/dist/commands/review.js

@@ -0,0 +1,315 @@
+import { Effect } from "effect";
+import { loadConfig } from "../config.js";
+import { dispatchDrainReview, dispatchRunReview, dispatchWeeklyReview, } from "../meta/runner.js";
+export function printReviewUsage() {
+    console.log(`runway review — IRA retrospective passes
+
+USAGE
+  runway review run --drain <trace-id> --issue <identifier> [--force]
+  runway review drain --id <trace-id>
+  runway review weekly [--start <iso>] [--end <iso>]
+
+OPTIONS — run
+  --drain <trace-id>     the drain's OTLP trace id (32 hex chars)
+  --issue <identifier>   the Linear issue identifier (e.g. VA-401)
+  --force                bypass the drain-age delay gate (VA-403)
+
+OPTIONS — drain
+  --id <trace-id>        the drain's OTLP trace id (32 hex chars)
+
+OPTIONS — weekly
+  --start <iso>          start of the window (default: 7 days ago, exclusive on --end)
+  --end <iso>            end of the window (default: now)
+
+ENV
+  ANTHROPIC_API_KEY            required — Claude API key for the IRA call
+  RUNWAY_DASHBOARD_DB          dashboard SQLite path (default: ./runway-dashboard.db)
+  RUNWAY_META_REVIEW_MODEL     override the Run / Drain Review model (default: claude-sonnet-4-6)
+  RUNWAY_META_WEEKLY_MODEL     override the Weekly Review model (default: claude-opus-4-7)
+  RUNWAY_META_PROJECT_NAME     override the Linear meta-project name (default: runway-meta)
+  RUNWAY_REVIEW_DELAY_HOURS    minimum drain age before grading (default: 18; 12-24h band per PRD VA-403)
+  RUNWAY_REPO_PROJECT_NAME     optional — Linear project where severity-critical Drain
+                               Review escalations + Weekly Review promotions are filed
+                               (default: team-only)
+  GITHUB_TOKEN                 optional — authenticates GitHub API for hindsight PR fetch
+
+EXIT CODES
+  0  success (run/drain reviews stub-and-continue on failure)
+  1  Weekly Review failed loud after retry exhaustion (PRD VA-408)
+  2  invalid arguments
+`);
+}
+export async function reviewCommand(argv) {
+    if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+        printReviewUsage();
+        return;
+    }
+    const verb = argv[0];
+    const rest = argv.slice(1);
+    if (verb === "run") {
+        await runVerb(rest);
+        return;
+    }
+    if (verb === "drain") {
+        await drainVerb(rest);
+        return;
+    }
+    if (verb === "weekly") {
+        await weeklyVerb(rest);
+        return;
+    }
+    console.error(`[runway review] unknown verb: ${verb}`);
+    printReviewUsage();
+    process.exit(2);
+}
+async function runVerb(rest) {
+    const parsed = parseRunArgs(rest);
+    if (parsed.kind === "error") {
+        console.error(`[runway review run] ${parsed.message}`);
+        printReviewUsage();
+        process.exit(2);
+    }
+    const config = loadConfig();
+    const anthropicApiKey = process.env.ANTHROPIC_API_KEY;
+    if (!anthropicApiKey) {
+        console.error("[runway review run] ANTHROPIC_API_KEY is required — set it in the environment before running.");
+        process.exit(2);
+    }
+    const dashboardDbPath = process.env.RUNWAY_DASHBOARD_DB ?? "./runway-dashboard.db";
+    const outcome = await Effect.runPromise(dispatchRunReview({
+        traceId: parsed.traceId,
+        issueIdentifier: parsed.issueIdentifier,
+        force: parsed.force,
+    }, {
+        config,
+        cwd: process.cwd(),
+        dashboardDbPath,
+        anthropicApiKey,
+        // VA-403: optional GitHub token. The hindsight gateway runs
+        // unauthenticated when absent (60 reqs/hr, public repos
+        // only) — sufficient for OSS workflows. Set the env var
+        // before invoking for private-repo or rate-limit headroom.
+        githubToken: process.env.GITHUB_TOKEN,
+    }));
+    if (outcome.kind === "review") {
+        console.log(`[runway review run] ok — meta_review=${outcome.metaReviewId} linear=${outcome.linearIdentifier} (${outcome.linearUrl})`);
+    }
+    else if (outcome.kind === "delayed") {
+        console.log(`[runway review run] drain too fresh — age=${outcome.drainAgeHours}h, threshold=${outcome.thresholdHours}h. Retry after ${outcome.retryAfterIso} (or pass --force to override).`);
+    }
+    else if (outcome.kind === "skipped") {
+        // VA-404: heuristic pre-filter trip. No LLM, no Linear — just the
+        // skipped row. Operator audit reads the reason off `meta_reviews`.
+        console.log(`[runway review run] skipped — meta_review=${outcome.metaReviewId} reason: ${outcome.reason}`);
+    }
+    else {
+        console.log(`[runway review run] stub-and-continue — meta_review=${outcome.metaReviewId} reason: ${outcome.reason}`);
+    }
+    // Run Review failures stub and continue per PRD — exit code stays 0
+    // regardless of outcome.kind. Weekly Review (VA-408) will diverge.
+}
+async function drainVerb(rest) {
+    const parsed = parseDrainArgs(rest);
+    if (parsed.kind === "error") {
+        console.error(`[runway review drain] ${parsed.message}`);
+        printReviewUsage();
+        process.exit(2);
+    }
+    const config = loadConfig();
+    const anthropicApiKey = process.env.ANTHROPIC_API_KEY;
+    if (!anthropicApiKey) {
+        console.error("[runway review drain] ANTHROPIC_API_KEY is required — set it in the environment before running.");
+        process.exit(2);
+    }
+    const dashboardDbPath = process.env.RUNWAY_DASHBOARD_DB ?? "./runway-dashboard.db";
+    const outcome = await Effect.runPromise(dispatchDrainReview({ traceId: parsed.traceId }, {
+        config,
+        cwd: process.cwd(),
+        dashboardDbPath,
+        anthropicApiKey,
+        githubToken: process.env.GITHUB_TOKEN,
+    }));
+    if (outcome.kind === "review") {
+        const escSuffix = outcome.severity === "critical"
+            ? ` severity=critical escalation=${outcome.escalationIdentifier ?? "(failed)"}`
+            : ` severity=routine`;
+        console.log(`[runway review drain] ok — meta_review=${outcome.metaReviewId} linear=${outcome.linearIdentifier} (${outcome.linearUrl})${escSuffix}`);
+    }
+    else if (outcome.kind === "no-run-reviews") {
+        console.log(`[runway review drain] no Run Reviews for drain — nothing to grade. ${outcome.reason}`);
+    }
+    else {
+        console.log(`[runway review drain] stub-and-continue — meta_review=${outcome.metaReviewId} reason: ${outcome.reason}`);
+    }
+    // Drain Review failures stub and continue per PRD — exit code stays
+    // 0 regardless of outcome.kind. Same contract as Run Review.
+}
+async function weeklyVerb(rest) {
+    const parsed = parseWeeklyArgs(rest, Date.now());
+    if (parsed.kind === "error") {
+        console.error(`[runway review weekly] ${parsed.message}`);
+        printReviewUsage();
+        process.exit(2);
+    }
+    const config = loadConfig();
+    const anthropicApiKey = process.env.ANTHROPIC_API_KEY;
+    if (!anthropicApiKey) {
+        console.error("[runway review weekly] ANTHROPIC_API_KEY is required — set it in the environment before running.");
+        process.exit(2);
+    }
+    const dashboardDbPath = process.env.RUNWAY_DASHBOARD_DB ?? "./runway-dashboard.db";
+    const outcome = await Effect.runPromise(dispatchWeeklyReview({ startIso: parsed.startIso, endIso: parsed.endIso }, {
+        config,
+        cwd: process.cwd(),
+        dashboardDbPath,
+        anthropicApiKey,
+        githubToken: process.env.GITHUB_TOKEN,
+    }));
+    if (outcome.kind === "review") {
+        console.log(`[runway review weekly] ok — meta_review=${outcome.metaReviewId} linear=${outcome.linearIdentifier} (${outcome.linearUrl}) promotions=${outcome.promotionsFiled}/${outcome.promotionsPlanned}`);
+        return;
+    }
+    if (outcome.kind === "no-reviews") {
+        console.log(`[runway review weekly] no Run / Drain Reviews in window — nothing to summarize. ${outcome.reason}`);
+        return;
+    }
+    // VA-408 AC: "exit code is non-zero after retry exhaustion".
+    console.error(`[runway review weekly] FAILED-LOUD — ${outcome.reason}`);
+    process.exit(1);
+}
+/**
+ * VA-408: argv parser for `runway review weekly [--start <iso>]
+ * [--end <iso>]`. Both flags optional — default window is the
+ * trailing 7 days ending at `nowMs`. Supports space-separated and
+ * `=`-form. `nowMs` is parameterized so tests can drive a stable
+ * clock; production calls pass `Date.now()`.
+ */
+export function parseWeeklyArgs(argv, nowMs) {
+    let startIso;
+    let endIso;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        const split = consumeFlag(arg, argv, i);
+        if (!split)
+            continue;
+        if (split.name === "--start") {
+            startIso = split.value;
+            i = split.advance;
+        }
+        else if (split.name === "--end") {
+            endIso = split.value;
+            i = split.advance;
+        }
+        else {
+            return { kind: "error", message: `unknown flag: ${split.name}` };
+        }
+    }
+    const resolvedEndIso = endIso ?? new Date(nowMs).toISOString();
+    const resolvedStartIso = startIso ?? new Date(nowMs - 7 * 24 * 60 * 60 * 1000).toISOString();
+    // Permissive: trust the operator's ISO string. Date.parse will
+    // surface a malformed input as NaN; reject explicitly so the
+    // operator doesn't get a Z-shaped Linear query later.
+    if (Number.isNaN(Date.parse(resolvedStartIso))) {
+        return { kind: "error", message: `--start is not a valid ISO date: ${resolvedStartIso}` };
+    }
+    if (Number.isNaN(Date.parse(resolvedEndIso))) {
+        return { kind: "error", message: `--end is not a valid ISO date: ${resolvedEndIso}` };
+    }
+    if (Date.parse(resolvedStartIso) >= Date.parse(resolvedEndIso)) {
+        return {
+            kind: "error",
+            message: `--start (${resolvedStartIso}) must be before --end (${resolvedEndIso})`,
+        };
+    }
+    return { kind: "ok", startIso: resolvedStartIso, endIso: resolvedEndIso };
+}
+/**
+ * VA-406: argv parser for `runway review drain --id <trace-id>`.
+ * Supports both space-separated (`--id X`) and equals (`--id=X`)
+ * forms. Unknown flags surface a typed error.
+ */
+export function parseDrainArgs(argv) {
+    let traceId;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        const split = consumeFlag(arg, argv, i);
+        if (!split)
+            continue;
+        if (split.name === "--id") {
+            traceId = split.value;
+            i = split.advance;
+        }
+        else {
+            return { kind: "error", message: `unknown flag: ${split.name}` };
+        }
+    }
+    if (!traceId) {
+        return { kind: "error", message: "missing required --id <trace-id>" };
+    }
+    return { kind: "ok", traceId };
+}
+/**
+ * Minimal argv parser — supports `--drain <id> --issue <id>` (with
+ * `=` allowed in either form) plus the boolean `--force` flag.
+ * Order independent.
+ */
+export function parseRunArgs(argv) {
+    let traceId;
+    let issueIdentifier;
+    let force = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        // VA-403: --force is a boolean flag — handled before consumeFlag
+        // so a stray positional after it doesn't get swallowed as the
+        // flag's value.
+        if (arg === "--force") {
+            force = true;
+            continue;
+        }
+        const split = consumeFlag(arg, argv, i);
+        if (!split)
+            continue;
+        if (split.name === "--drain") {
+            traceId = split.value;
+            i = split.advance;
+        }
+        else if (split.name === "--issue") {
+            issueIdentifier = split.value;
+            i = split.advance;
+        }
+        else if (split.name === "--force") {
+            // The `--force=true` form also accepted (operator scripted CI).
+            force = split.value !== "false";
+            i = split.advance;
+        }
+        else {
+            return { kind: "error", message: `unknown flag: ${split.name}` };
+        }
+    }
+    if (!traceId) {
+        return { kind: "error", message: "missing required --drain <trace-id>" };
+    }
+    if (!issueIdentifier) {
+        return { kind: "error", message: "missing required --issue <identifier>" };
+    }
+    return { kind: "ok", traceId, issueIdentifier, force };
+}
+function consumeFlag(arg, argv, i) {
+    if (!arg.startsWith("--"))
+        return null;
+    const eq = arg.indexOf("=");
+    if (eq > 0) {
+        return { name: arg.slice(0, eq), value: arg.slice(eq + 1), advance: i };
+    }
+    const next = argv[i + 1];
+    if (next === undefined || next.startsWith("--")) {
+        return { name: arg, value: "", advance: i };
+    }
+    return { name: arg, value: next, advance: i + 1 };
+}

package/dist/commands/run.js

@@ -139,10 +139,24 @@ ENVIRONMENT
                               branch (the branch runway diffs against
                               and targets with PRs). Detected from
                               origin/HEAD when unset.
-  RUNWAY_READY_STATUS         default "Todo"
-  RUNWAY_IN_PROGRESS_STATUS   default "In Progress"
-  RUNWAY_IN_REVIEW_STATUS     default "In Review"
-  RUNWAY_HITL_LABEL           default "ready-for-human"
+  RUNWAY_READY_LABEL          default "ready-for-agent" — the
+                              flightplan v1.1.0 contract. Runway's
+                              drain queue filters by this label, not
+                              by workflow status, because Linear's
+                              GitHub integration auto-mutates status
+                              on PR cross-references. Labels are
+                              immune to that integration. Runway
+                              removes the label on pickup (the
+                              atomic claim signal).
+  RUNWAY_HITL_LABEL           default "ready-for-human" — applied
+                              when the agent or reviewer can't
+                              finish, AND when a run fails outright.
+                              Runway never re-applies the ready
+                              label on failure (terminal failures
+                              shouldn't retry indefinitely); an
+                              operator triages and re-applies
+                              the ready label manually if the
+                              cause was transient.
   RUNWAY_MAX_ITERATIONS       default 5  — outer impl re-prompt loop
                               (only fires when the agent fails to
                               signal IMPL: DONE / BLOCKED at all)
@@ -191,7 +205,7 @@ export async function runCommand(argv) {
         const scope = config.linearProject
             ? `team ${config.linearTeam} / project ${config.linearProject}`
             : `team ${config.linearTeam}`;
-        yield* Effect.logInfo(`draining queue from ${scope} (status="${config.readyStatus}") against ${cwd}`);
+        yield* Effect.logInfo(`draining queue from ${scope} (label="${config.readyLabel}") against ${cwd}`);
         const linearLimiter = yield* RateLimiter.make({
             limit: 30,
             interval: "1 minute",
@@ -201,12 +215,12 @@ export async function runCommand(argv) {
         return yield* drainQueue({ config, linear, github, cwd }, { max: opts.max, allowPaths: opts.allowPaths });
     }).pipe(Effect.scoped, Effect.provide(MainLayer));
     const result = await Effect.runPromise(program);
-    console.log(`[runway] done — attempts=${result.attempts} opened=${result.opened} hitl=${result.hitl} errored=${result.errored}`);
+    console.log(`[runway] done — attempts=${result.attempts} opened=${result.opened} hitl=${result.hitl} errored=${result.errored} skipped=${result.skipped}`);
     // Single-line, parser-friendly completion marker. Background
     // watchers (Claude Code's `run_in_background` bash task, CI,
     // scripts) can grep for `[runway:exit]` instead of guessing
     // whether the drain is still in flight.
-    console.log(`[runway:exit] status=success attempts=${result.attempts} opened=${result.opened} hitl=${result.hitl} errored=${result.errored}`);
+    console.log(`[runway:exit] status=success attempts=${result.attempts} opened=${result.opened} hitl=${result.hitl} errored=${result.errored} skipped=${result.skipped}`);
     // Hard exit so any lingering handle (OTel BatchSpanProcessor's
     // interval when OTEL_EXPORTER_OTLP_ENDPOINT is set, a Docker
     // stream Sandcastle left open, etc.) can't keep the process — and

package/dist/config.js

@@ -12,9 +12,7 @@ const configEffect = EConfig.all({
     linearTeam: EConfig.string("RUNWAY_LINEAR_TEAM").pipe(EConfig.withDefault("VA")),
     linearProject: EConfig.option(EConfig.string("RUNWAY_LINEAR_PROJECT")),
     baseBranch: EConfig.option(EConfig.string("RUNWAY_BASE_BRANCH")),
-    readyStatus: EConfig.string("RUNWAY_READY_STATUS").pipe(EConfig.withDefault("Todo")),
-    inProgressStatus: EConfig.string("RUNWAY_IN_PROGRESS_STATUS").pipe(EConfig.withDefault("In Progress")),
-    inReviewStatus: EConfig.string("RUNWAY_IN_REVIEW_STATUS").pipe(EConfig.withDefault("In Review")),
+    readyLabel: EConfig.string("RUNWAY_READY_LABEL").pipe(EConfig.withDefault("ready-for-agent")),
     hitlLabel: EConfig.string("RUNWAY_HITL_LABEL").pipe(EConfig.withDefault("ready-for-human")),
     maxIterations: EConfig.integer("RUNWAY_MAX_ITERATIONS").pipe(EConfig.withDefault(5), EConfig.validate({
         message: "RUNWAY_MAX_ITERATIONS must be a positive integer",
@@ -32,15 +30,28 @@ const configEffect = EConfig.all({
         validation: (n) => n >= 0,
     })),
     commentAuthorAllowlist: EConfig.option(EConfig.string("RUNWAY_COMMENT_AUTHOR_ALLOWLIST")),
+    metaReviewModel: EConfig.option(EConfig.string("RUNWAY_META_REVIEW_MODEL")),
+    metaProjectName: EConfig.option(EConfig.string("RUNWAY_META_PROJECT_NAME")),
+    // VA-403: PRD constrains the configurable delay to the 12–24h
+    // band — too short and the IRA judges before hindsight lands; too
+    // long and operators lose the freshness operators expect from a
+    // ~daily retrospective. The explicit `--force` CLI flag (or
+    // `force: true` to dispatchRunReview) is the supported bypass
+    // for one-off operator overrides; persistent disable isn't.
+    metaReviewDelayHours: EConfig.option(EConfig.number("RUNWAY_REVIEW_DELAY_HOURS").pipe(EConfig.validate({
+        message: "RUNWAY_REVIEW_DELAY_HOURS must be in the 12-24 hour band (PRD VA-403); use --force on the CLI for one-off bypass",
+        validation: (n) => n >= 12 && n <= 24,
+    }))),
+    metaFilterThresholdsJson: EConfig.option(EConfig.string("RUNWAY_META_FILTER_THRESHOLDS")),
+    runwayRepoProjectName: EConfig.option(EConfig.string("RUNWAY_REPO_PROJECT_NAME")),
+    metaWeeklyModel: EConfig.option(EConfig.string("RUNWAY_META_WEEKLY_MODEL")),
 }).pipe(Effect.map((raw) => ({
     linearApiKey: raw.linearApiKey,
     opServiceAccountToken: Option.getOrUndefined(raw.opServiceAccountToken),
     linearTeam: raw.linearTeam,
     linearProject: Option.getOrUndefined(raw.linearProject),
     baseBranch: Option.getOrUndefined(raw.baseBranch),
-    readyStatus: raw.readyStatus,
-    inProgressStatus: raw.inProgressStatus,
-    inReviewStatus: raw.inReviewStatus,
+    readyLabel: raw.readyLabel,
     hitlLabel: raw.hitlLabel,
     maxIterations: raw.maxIterations,
     implTurns: raw.implTurns,
@@ -49,6 +60,12 @@ const configEffect = EConfig.all({
         ?.split(",")
         .map((s) => s.trim())
         .filter(Boolean),
+    metaReviewModel: Option.getOrUndefined(raw.metaReviewModel),
+    metaProjectName: Option.getOrUndefined(raw.metaProjectName),
+    metaReviewDelayHours: Option.getOrUndefined(raw.metaReviewDelayHours),
+    metaFilterThresholds: parseMetaFilterThresholdsJson(Option.getOrUndefined(raw.metaFilterThresholdsJson)),
+    runwayRepoProjectName: Option.getOrUndefined(raw.runwayRepoProjectName),
+    metaWeeklyModel: Option.getOrUndefined(raw.metaWeeklyModel),
 })));
 /**
  * VA-359: Context tag for the resolved RunwayConfig. Provided by
@@ -101,3 +118,31 @@ export const ConfigLive = makeConfigLive();
 export function loadConfig(env = process.env) {
     return Effect.runSync(configEffect.pipe(Effect.withConfigProvider(providerFromEnv(env))));
 }
+// VA-404: parse the optional `RUNWAY_META_FILTER_THRESHOLDS` env JSON.
+// Malformed JSON or out-of-range numbers are silently ignored —
+// per-threshold env vars are an anti-feature; if the operator wants
+// safety they edit `.runway/config.yml`. We accept partial objects.
+function parseMetaFilterThresholdsJson(raw) {
+    if (!raw)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return undefined;
+    }
+    const obj = parsed;
+    const out = {};
+    if (typeof obj.minIterationCount === "number" && obj.minIterationCount >= 1) {
+        out.minIterationCount = Math.floor(obj.minIterationCount);
+    }
+    if (typeof obj.minReviewerRejections === "number" &&
+        obj.minReviewerRejections >= 1) {
+        out.minReviewerRejections = Math.floor(obj.minReviewerRejections);
+    }
+    return Object.keys(out).length === 0 ? undefined : out;
+}

package/dist/dashboard/events.js

@@ -0,0 +1,71 @@
+/**
+ * VA-391: in-process pub/sub for live dashboard updates. The OTLP
+ * ingest path publishes events when storage rows change; SSE
+ * handlers subscribe and stream matching events to the browser.
+ * No external broker — single-process, single-listener-set, fan-out
+ * happens here.
+ *
+ * Two event shapes today; more can be added by extending the union:
+ *
+ *   issueProcessChanged — a new or upserted issue_processes row.
+ *                         The list view polls every 3s and doesn't
+ *                         strictly need this, but the SSE detail
+ *                         pane uses it to refresh phase-timeline
+ *                         data when an iteration lands.
+ *
+ *   logRecordAppended   — a new log_records row. The SSE detail
+ *                         pane consumes this to live-tail logs into
+ *                         the Logs section.
+ *
+ * Subscribers pass a filter so the SSE handler at
+ * `/issue-processes/:id/stream` only sees events tied to that issue
+ * process's trace_id. The bus does the matching inside `publish` so
+ * an inactive subscription costs nothing on the hot path beyond a
+ * comparison.
+ */
+/**
+ * Construct a fresh in-process event bus. Each dashboard server gets
+ * one; storage stays oblivious — the server is the publish boundary.
+ */
+export function createEventBus() {
+    // Set semantics: every subscribe returns a fresh `Entry`, so unsub
+    // can `Set.delete` the exact slot without comparing listeners. A
+    // duplicate subscribe with the same listener registers a second
+    // entry on purpose — the SSE handler doesn't, but we don't want a
+    // future caller's bug masked by silent dedup.
+    const entries = new Set();
+    return {
+        publish(event) {
+            for (const e of entries) {
+                if (e.filter.traceId !== undefined && e.filter.traceId !== event.traceId) {
+                    continue;
+                }
+                try {
+                    e.listener(event);
+                }
+                catch {
+                    // A misbehaving subscriber must not break the publish loop —
+                    // SSE handlers stream over the network and can fail in any
+                    // number of ways. Swallow and continue; the next iteration
+                    // delivers to other subscribers.
+                }
+            }
+        },
+        subscribe(filter, listener) {
+            const entry = { filter, listener };
+            entries.add(entry);
+            let removed = false;
+            return {
+                unsubscribe() {
+                    if (removed)
+                        return;
+                    entries.delete(entry);
+                    removed = true;
+                },
+            };
+        },
+        subscriberCount() {
+            return entries.size;
+        },
+    };
+}