@oxygen-agent/cli 1.1010.721 → 1.1010.905

package/node_modules/@oxygen/shared/dist/plan-limits-view.d.ts

@@ -0,0 +1,219 @@
+/**
+ * How `GET /api/cli/limits` reads to a person: the seven plan sizes side by
+ * side, the workspace's own spend defaults, and what the 2026-09 repricing
+ * schedule moves (decision F.2: the value in force and the value pending for
+ * it). The MCP `oxygen.plan-limits` widget and the web Settings → Plan limits
+ * tab both render from here, so the two cannot disagree on a label or a
+ * pending value. Pure and browser-safe: it formats an envelope it is handed and
+ * reads nothing else.
+ */
+/** What a band's storage moves to (`plan_bands[].storage.target`, decision F.2). */
+export type PlanLimitsStorageTarget = {
+    table_row_limit?: number;
+    workspace_row_limit?: number;
+    workspace_database_limit_bytes?: number;
+    import_max_rows_per_file?: number;
+};
+export type PlanLimitsBandRow = {
+    band?: string;
+    label?: string;
+    limits_tier?: string;
+    current?: boolean;
+    monthly_price_usd?: number | null;
+    monthly_credits?: number | null;
+    volume_bonus_percent?: number | null;
+    usd_per_100_credits?: number | null;
+    api?: {
+        org_requests_per_minute?: number;
+        key_requests_per_minute?: number;
+        tenant_read_requests_per_key_per_minute?: number;
+        tenant_write_requests_per_key_per_minute?: number;
+        live_action_requests_per_key_per_minute?: number;
+    };
+    storage?: {
+        table_row_limit?: number;
+        workspace_row_limit?: number;
+        workspace_database_limit_bytes?: number;
+        import_max_rows_per_file?: number;
+        import_max_file_bytes?: number;
+        status?: string;
+        effective_at?: string | null;
+        target?: PlanLimitsStorageTarget | null;
+    };
+    spend?: {
+        trigger_run_credit_ceiling?: number | null;
+        auto_run_batch_credit_ceiling?: number | null;
+        agent_run_max_total_credits?: number;
+        copilot_approval_free_per_call_credits?: number;
+        copilot_approval_free_per_session_credits?: number;
+        org_daily_guard_block_credits?: number | null;
+        byok_column_run_max_rows?: number | null;
+    };
+    tables?: {
+        max_rows_per_write_request?: number;
+        max_columns_per_run?: number;
+    };
+    signals?: {
+        max_events?: number;
+        max_window_days?: number;
+    };
+    webhooks?: {
+        ingress_requests_per_target_per_minute?: number;
+    };
+    workflows?: {
+        cron_min_interval_minutes?: number;
+    };
+};
+export type PlanLimitsWorkflowLimits = {
+    cron_min_interval_minutes?: number;
+    code_node_max_timeout_seconds?: number;
+    run_attempt_timeout_minutes?: number;
+};
+export type PlanLimitsStorageCapacity = {
+    platform_guard?: {
+        table_row_limit?: number;
+        workspace_row_limit?: number;
+        workspace_database_limit_bytes?: number;
+    };
+    usage?: {
+        workspace_rows?: number | null;
+        largest_table_rows?: number | null;
+        largest_table?: {
+            id?: string;
+            name?: string;
+        } | null;
+        workspace_database_bytes?: number;
+    } | null;
+};
+export type PlanLimitsScheduledChange = {
+    key?: string;
+    kind?: string;
+    unit?: string;
+    description?: string;
+    value_before?: unknown;
+    value_after?: unknown;
+};
+export type PlanLimitsPricingSchedule = {
+    effective_at?: string;
+    status?: string;
+    changes?: PlanLimitsScheduledChange[];
+};
+type ChannelLimit = {
+    default_per_day?: number;
+    max_per_day?: number | null;
+};
+export type PlanLimitsSendingLimits = {
+    email_per_mailbox?: ChannelLimit;
+    whatsapp_per_number?: ChannelLimit;
+    voice_per_number?: ChannelLimit;
+    linkedin_per_account?: {
+        invites_per_day?: number;
+        invites_per_day_max?: number;
+        messages_per_day?: number;
+    };
+};
+export type PlanLimitsSpendDefaults = {
+    trigger_run_credit_ceiling?: number | null;
+    auto_run_batch_credit_ceiling?: number | null;
+    agent_run_max_total_credits?: number;
+    agent_run_max_inference_credits?: number;
+    /** The most a run approved above the default may spend (decision F.4). */
+    agent_run_approved_max_credits?: number;
+    copilot_approval_free_per_call_credits?: number;
+    copilot_approval_free_per_session_credits?: number;
+    copilot_attended_turn_backstop_credits?: number;
+    org_daily_spend_guard?: {
+        applies?: boolean;
+        source?: string;
+        warn_credits?: number | null;
+        block_credits?: number | null;
+        spent_today?: number | null;
+    };
+    applies_to?: Record<string, string>;
+};
+/** The slice of the `limits show` envelope this module reads. */
+export type PlanLimitsEnvelope = {
+    plan_band?: string;
+    plan_band_label?: string;
+    limits_tier?: string;
+    plan_bands?: PlanLimitsBandRow[];
+    sending_limits?: PlanLimitsSendingLimits;
+    workflow_limits?: PlanLimitsWorkflowLimits;
+    shared_billing?: boolean;
+    storage_capacity?: PlanLimitsStorageCapacity;
+    spend_safety_defaults?: PlanLimitsSpendDefaults;
+    pricing_schedule?: PlanLimitsPricingSchedule;
+    deepLink?: string;
+    web_url?: string;
+    billing_url?: string;
+};
+export declare function formatLimitCount(value: number | null | undefined): string;
+export declare function formatLimitCredits(value: number | null | undefined): string;
+export declare function formatLimitBytes(value: number | null | undefined): string;
+/**
+ * `storage.<band>.<field>` / `workflows.…` / `spend.…` / `agents.…` → the
+ * value it takes once the scheduled change is in force. Empty unless the
+ * schedule is still ahead (`status: "scheduled"`).
+ */
+export declare function scheduledLimitChanges(schedule: PlanLimitsPricingSchedule | undefined): Map<string, number>;
+export type PlanLimitsLadder = {
+    bands: Array<{
+        band: string;
+        label: string;
+        current: boolean;
+    }>;
+    rows: Array<{
+        label: string;
+        cells: string[];
+    }>;
+    /** What `→` and `†` mean, when a cell uses them. */
+    notes: string[];
+};
+/** Every plan size's limits side by side, with the pending value after `→`. */
+export declare function planLimitsLadder(payload: PlanLimitsEnvelope): PlanLimitsLadder;
+/**
+ * The workspace's own usage against the limits it enforces, so "how close am
+ * I?" sits beside "what would a bigger plan give me?". The largest Table is
+ * named, so a full one is identifiable (decision F.2).
+ */
+export declare function planLimitsStorageUsageLine(storage: PlanLimitsStorageCapacity | undefined): string | null;
+/** Sending limits are the same on every plan: one row per channel. */
+export declare function planLimitsSendingRows(sending: PlanLimitsSendingLimits | undefined): Array<{
+    label: string;
+    defaultPerDay: string;
+    maximumPerDay: string;
+}>;
+/**
+ * The Code step and run attempt limits are the same on every plan; the fastest
+ * schedule, which differs, is a row of the ladder.
+ */
+export declare function planLimitsWorkflowNote(workflows: PlanLimitsWorkflowLimits | undefined): string | null;
+export type PlanLimitsSpendDefaultRow = {
+    label: string;
+    value: string;
+    /** The value from the scheduled date, when one is set and it differs. */
+    next: string | null;
+    /** What the default bounds, from `spend_safety_defaults.applies_to`. */
+    scope: string | null;
+};
+/**
+ * The workspace's own spend defaults, each with what it bounds and the value
+ * it takes on the scheduled date (L5.1–L5.4). Read from the plan size the
+ * workspace is on (`plan_band`, `limits_tier`), so the pending value is the
+ * one this workspace will get.
+ */
+export declare function planLimitsSpendDefaults(payload: PlanLimitsEnvelope): PlanLimitsSpendDefaultRow[];
+export type PlanLimitsScheduleRow = {
+    key: string;
+    description: string;
+    before: string;
+    after: string;
+};
+export type PlanLimitsSchedule = {
+    effectiveAt: string;
+    inForce: boolean;
+    rows: PlanLimitsScheduleRow[];
+};
+/** Every price and limit the dated repricing moves, before and after. */
+export declare function planLimitsSchedule(schedule: PlanLimitsPricingSchedule | undefined): PlanLimitsSchedule | null;
+export {};

package/node_modules/@oxygen/shared/dist/plan-limits-view.js

@@ -0,0 +1,330 @@
+/**
+ * How `GET /api/cli/limits` reads to a person: the seven plan sizes side by
+ * side, the workspace's own spend defaults, and what the 2026-09 repricing
+ * schedule moves (decision F.2: the value in force and the value pending for
+ * it). The MCP `oxygen.plan-limits` widget and the web Settings → Plan limits
+ * tab both render from here, so the two cannot disagree on a label or a
+ * pending value. Pure and browser-safe: it formats an envelope it is handed and
+ * reads nothing else.
+ */
+// Agent run ceilings are scheduled per limits rung (`agents.<rung>.<field>`),
+// the rung each plan size enforces at.
+const AGENT_LIMITS_TIER_BY_BAND = {
+    free: "free",
+    "49": "starter",
+    "99": "starter",
+    "199": "pro",
+    "499": "pro",
+    "999": "team",
+    "1999": "scale",
+};
+const GIB = 1024 ** 3;
+const MIB = 1024 ** 2;
+export function formatLimitCount(value) {
+    return typeof value === "number" ? value.toLocaleString("en-US") : "—";
+}
+export function formatLimitCredits(value) {
+    return typeof value === "number" ? `${value.toLocaleString("en-US")} cr` : "—";
+}
+function everyMinutes(value) {
+    if (typeof value !== "number")
+        return "—";
+    return value === 1 ? "every minute" : `every ${formatLimitCount(value)} min`;
+}
+export function formatLimitBytes(value) {
+    if (typeof value !== "number")
+        return "—";
+    return value >= GIB ? `${Number((value / GIB).toFixed(2))} GiB` : `${Number((value / MIB).toFixed(0))} MiB`;
+}
+function storageKey(field) {
+    return (band) => `storage.${band}.${field}`;
+}
+// One line per limit a founder asks about before sizing a plan: API rate,
+// storage, and what unattended work may spend without asking. The full matrix
+// stays in the JSON (`limits`, `spend_safety_defaults`).
+const LINES = [
+    { label: "Price / month", value: (row) => (typeof row.monthly_price_usd === "number" ? `$${formatLimitCount(row.monthly_price_usd)}` : "$0") },
+    { label: "Credits / month", value: (row) => formatLimitCredits(row.monthly_credits) },
+    { label: "Volume bonus", value: (row) => (typeof row.volume_bonus_percent === "number" && row.volume_bonus_percent > 0 ? `+${row.volume_bonus_percent}%` : "—") },
+    { label: "Price / 100 credits", value: (row) => (typeof row.usd_per_100_credits === "number" ? `$${row.usd_per_100_credits.toFixed(row.usd_per_100_credits === 1 ? 2 : 4)}` : "—") },
+    { label: "API requests / min (workspace)", value: (row) => formatLimitCount(row.api?.org_requests_per_minute) },
+    { label: "API requests / min (per key)", value: (row) => formatLimitCount(row.api?.key_requests_per_minute) },
+    { label: "Table reads / min (per key)", value: (row) => formatLimitCount(row.api?.tenant_read_requests_per_key_per_minute) },
+    { label: "Table writes / min (per key)", value: (row) => formatLimitCount(row.api?.tenant_write_requests_per_key_per_minute) },
+    { label: "Live tool and AI calls / min (per key)", value: (row) => formatLimitCount(row.api?.live_action_requests_per_key_per_minute) },
+    { label: "Webhook deliveries / min (per target)", value: (row) => formatLimitCount(row.webhooks?.ingress_requests_per_target_per_minute) },
+    {
+        label: "Rows per table",
+        value: (row) => formatLimitCount(row.storage?.table_row_limit),
+        scheduledKey: storageKey("table_row_limit"),
+        target: (target) => target.table_row_limit,
+        format: formatLimitCount,
+    },
+    {
+        label: "Rows per workspace",
+        value: (row) => formatLimitCount(row.storage?.workspace_row_limit),
+        scheduledKey: storageKey("workspace_row_limit"),
+        target: (target) => target.workspace_row_limit,
+        format: formatLimitCount,
+    },
+    {
+        label: "Workspace database",
+        value: (row) => formatLimitBytes(row.storage?.workspace_database_limit_bytes),
+        scheduledKey: storageKey("workspace_database_limit_bytes"),
+        target: (target) => target.workspace_database_limit_bytes,
+        format: formatLimitBytes,
+    },
+    {
+        label: "Rows per import file",
+        value: (row) => formatLimitCount(row.storage?.import_max_rows_per_file),
+        scheduledKey: storageKey("table_row_limit"),
+        target: (target) => target.import_max_rows_per_file,
+        format: formatLimitCount,
+    },
+    { label: "Import file size", value: (row) => formatLimitBytes(row.storage?.import_max_file_bytes) },
+    { label: "Rows per write request", value: (row) => formatLimitCount(row.tables?.max_rows_per_write_request) },
+    { label: "Columns per auto-run", value: (row) => formatLimitCount(row.tables?.max_columns_per_run) },
+    {
+        label: "Unattended trigger default cap",
+        value: (row) => formatLimitCredits(row.spend?.trigger_run_credit_ceiling),
+        scheduledKey: (band) => `spend.${band}.default_delivery_credit_ceiling`,
+        format: formatLimitCredits,
+    },
+    {
+        label: "Table auto-run default cap",
+        value: (row) => formatLimitCredits(row.spend?.auto_run_batch_credit_ceiling),
+        scheduledKey: (band) => `spend.${band}.default_delivery_credit_ceiling`,
+        format: formatLimitCredits,
+    },
+    {
+        label: "Agent run default cap (approve more per run)",
+        value: (row) => formatLimitCredits(row.spend?.agent_run_max_total_credits),
+        scheduledKey: agentRunKey("max_total_credits"),
+        format: formatLimitCredits,
+    },
+    {
+        label: "Copilot without approval (step / chat)",
+        value: (row) => `${formatLimitCount(row.spend?.copilot_approval_free_per_call_credits)} / ${formatLimitCredits(row.spend?.copilot_approval_free_per_session_credits)}`,
+    },
+    {
+        label: "Daily spend block",
+        value: (row) => formatLimitCredits(row.spend?.org_daily_guard_block_credits),
+        scheduledKey: (band) => `spend.${band}.org_daily_guard_block_credits`,
+        format: formatLimitCredits,
+    },
+    { label: "BYOK column-run rows", value: (row) => formatLimitCount(row.spend?.byok_column_run_max_rows) },
+    {
+        label: "Signals feed",
+        value: (row) => `${formatLimitCount(row.signals?.max_events)} / ${formatLimitCount(row.signals?.max_window_days)} d`,
+    },
+    {
+        label: "Fastest workflow schedule",
+        value: (row) => everyMinutes(row.workflows?.cron_min_interval_minutes),
+        scheduledKey: (band) => `workflows.${band}.cron_min_interval_minutes`,
+        format: everyMinutes,
+    },
+];
+function agentRunKey(field) {
+    return (band) => `agents.${AGENT_LIMITS_TIER_BY_BAND[band] ?? band}.${field}`;
+}
+/**
+ * `storage.<band>.<field>` / `workflows.…` / `spend.…` / `agents.…` → the
+ * value it takes once the scheduled change is in force. Empty unless the
+ * schedule is still ahead (`status: "scheduled"`).
+ */
+export function scheduledLimitChanges(schedule) {
+    const changes = new Map();
+    if (schedule?.status !== "scheduled")
+        return changes;
+    for (const change of schedule.changes ?? []) {
+        if (typeof change.key === "string"
+            && /^(storage|workflows|spend|agents)\./.test(change.key)
+            && typeof change.value_after === "number") {
+            changes.set(change.key, change.value_after);
+        }
+    }
+    return changes;
+}
+const AWAITING_TEST_MARK = "†";
+function awaitingCapacityTest(row) {
+    return row.storage?.status === "awaiting_capacity_test";
+}
+/**
+ * The value in force, then `→` and the value pending for it: the band's own
+ * storage target (a scheduled change, or a raise awaiting its capacity test,
+ * marked †), else the dated repricing schedule.
+ */
+function cellText(line, row, scheduled) {
+    const current = line.value(row);
+    if (!line.format)
+        return current;
+    const target = row.storage?.target;
+    const fromTarget = line.target && target && (row.storage?.status === "scheduled" || awaitingCapacityTest(row))
+        ? line.target(target)
+        : undefined;
+    if (fromTarget !== undefined) {
+        const next = line.format(fromTarget);
+        if (next === current)
+            return current;
+        return `${current} → ${next}${awaitingCapacityTest(row) ? ` ${AWAITING_TEST_MARK}` : ""}`;
+    }
+    const next = line.scheduledKey ? scheduled.get(line.scheduledKey(row.band ?? "")) : undefined;
+    return next === undefined ? current : `${current} → ${line.format(next)}`;
+}
+/** Every plan size's limits side by side, with the pending value after `→`. */
+export function planLimitsLadder(payload) {
+    const bands = Array.isArray(payload.plan_bands) ? payload.plan_bands : [];
+    const scheduled = scheduledLimitChanges(payload.pricing_schedule);
+    const notes = [];
+    if (scheduled.size > 0 && payload.pricing_schedule?.effective_at) {
+        notes.push(`"→" marks a limit that changes on ${payload.pricing_schedule.effective_at.slice(0, 10)}.`);
+    }
+    if (bands.some(awaitingCapacityTest)) {
+        notes.push(`"${AWAITING_TEST_MARK}" rises once the rows-per-table capacity test at that plan size passes.`);
+    }
+    return {
+        bands: bands.map((row) => ({ band: row.band ?? "", label: row.label ?? row.band ?? "", current: row.current === true })),
+        rows: bands.length === 0
+            ? []
+            : LINES.map((line) => ({ label: line.label, cells: bands.map((row) => cellText(line, row, scheduled)) })),
+        notes,
+    };
+}
+/**
+ * The workspace's own usage against the limits it enforces, so "how close am
+ * I?" sits beside "what would a bigger plan give me?". The largest Table is
+ * named, so a full one is identifiable (decision F.2).
+ */
+export function planLimitsStorageUsageLine(storage) {
+    const guard = storage?.platform_guard;
+    const usage = storage?.usage;
+    if (!guard || !usage)
+        return null;
+    const largest = usage.largest_table?.name ? `Largest table “${usage.largest_table.name}”` : "Largest table";
+    const parts = [
+        `${largest} ${formatLimitCount(usage.largest_table_rows)} / ${formatLimitCount(guard.table_row_limit)} rows`,
+        `workspace ${formatLimitCount(usage.workspace_rows)} / ${formatLimitCount(guard.workspace_row_limit)} rows`,
+        `database ${formatLimitBytes(usage.workspace_database_bytes)} / ${formatLimitBytes(guard.workspace_database_limit_bytes)}`,
+    ];
+    return `Your storage: ${parts.join(" · ")}`;
+}
+/** Sending limits are the same on every plan: one row per channel. */
+export function planLimitsSendingRows(sending) {
+    if (!sending)
+        return [];
+    const maximum = (limit) => limit?.max_per_day === null ? "no maximum" : formatLimitCount(limit?.max_per_day);
+    return [
+        { label: "Email per mailbox", defaultPerDay: formatLimitCount(sending.email_per_mailbox?.default_per_day), maximumPerDay: maximum(sending.email_per_mailbox) },
+        { label: "WhatsApp per number", defaultPerDay: formatLimitCount(sending.whatsapp_per_number?.default_per_day), maximumPerDay: maximum(sending.whatsapp_per_number) },
+        {
+            label: "LinkedIn invites per account",
+            defaultPerDay: formatLimitCount(sending.linkedin_per_account?.invites_per_day),
+            maximumPerDay: formatLimitCount(sending.linkedin_per_account?.invites_per_day_max),
+        },
+        { label: "Calls per number", defaultPerDay: formatLimitCount(sending.voice_per_number?.default_per_day), maximumPerDay: maximum(sending.voice_per_number) },
+    ];
+}
+/**
+ * The Code step and run attempt limits are the same on every plan; the fastest
+ * schedule, which differs, is a row of the ladder.
+ */
+export function planLimitsWorkflowNote(workflows) {
+    if (!workflows)
+        return null;
+    const parts = [
+        typeof workflows.code_node_max_timeout_seconds === "number"
+            ? `a Code step may run ${formatLimitCount(workflows.code_node_max_timeout_seconds)} s`
+            : null,
+        typeof workflows.run_attempt_timeout_minutes === "number"
+            ? `one run attempt ${formatLimitCount(workflows.run_attempt_timeout_minutes)} min, then it resumes from its last checkpoint`
+            : null,
+    ].filter((part) => part !== null);
+    if (parts.length === 0)
+        return null;
+    return `Workflows on every plan: ${parts.join("; ")}.`;
+}
+/**
+ * The workspace's own spend defaults, each with what it bounds and the value
+ * it takes on the scheduled date (L5.1–L5.4). Read from the plan size the
+ * workspace is on (`plan_band`, `limits_tier`), so the pending value is the
+ * one this workspace will get.
+ */
+export function planLimitsSpendDefaults(payload) {
+    const spend = payload.spend_safety_defaults;
+    if (!spend)
+        return [];
+    const scheduled = scheduledLimitChanges(payload.pricing_schedule);
+    const band = payload.plan_band ?? "";
+    const agentKey = (field) => `agents.${payload.limits_tier ?? AGENT_LIMITS_TIER_BY_BAND[band] ?? band}.${field}`;
+    const appliesTo = spend.applies_to ?? {};
+    const row = (label, value, scopeKey, scheduledKey) => {
+        const next = scheduledKey ? scheduled.get(scheduledKey) : undefined;
+        return {
+            label,
+            value: formatLimitCredits(value),
+            next: next === undefined || next === value ? null : formatLimitCredits(next),
+            scope: appliesTo[scopeKey] ?? null,
+        };
+    };
+    const rows = [
+        row("Unattended trigger default cap", spend.trigger_run_credit_ceiling, "trigger_run_credit_ceiling", `spend.${band}.default_delivery_credit_ceiling`),
+        row("Table auto-run default cap", spend.auto_run_batch_credit_ceiling, "auto_run_batch_credit_ceiling", `spend.${band}.default_delivery_credit_ceiling`),
+        row("Agent run default cap", spend.agent_run_max_total_credits, "agent_run_max_total_credits", agentKey("max_total_credits")),
+        row("Agent model calls", spend.agent_run_max_inference_credits, "agent_run_max_inference_credits", agentKey("max_inference_credits")),
+        row("Copilot without approval, per step", spend.copilot_approval_free_per_call_credits, "copilot_approval_free_per_call_credits"),
+        row("Copilot without approval, per chat", spend.copilot_approval_free_per_session_credits, "copilot_approval_free_per_session_credits"),
+        row("Copilot turn limit", spend.copilot_attended_turn_backstop_credits, "copilot_attended_turn_backstop_credits"),
+    ];
+    if (typeof spend.agent_run_approved_max_credits === "number") {
+        rows.push({
+            label: "Agent run with approval, at most",
+            value: formatLimitCredits(spend.agent_run_approved_max_credits),
+            next: null,
+            scope: "A run or trigger you approve above the default may spend up to this.",
+        });
+    }
+    const guard = spend.org_daily_spend_guard;
+    if (guard) {
+        const next = scheduled.get(`spend.${band}.org_daily_guard_block_credits`);
+        rows.push({
+            label: "Daily spend block",
+            value: guard.applies && typeof guard.block_credits === "number"
+                ? `${formatLimitCredits(guard.block_credits)} (warns at ${formatLimitCredits(guard.warn_credits)})`
+                : guard.source === "explicit_org_daily_policy"
+                    ? "Your own daily budget"
+                    : "—",
+            next: next === undefined || next === guard.block_credits ? null : formatLimitCredits(next),
+            scope: "Managed spend stops for the rest of the UTC day at this amount.",
+        });
+    }
+    return rows;
+}
+/** Every price and limit the dated repricing moves, before and after. */
+export function planLimitsSchedule(schedule) {
+    if (!schedule?.effective_at || (schedule.status !== "scheduled" && schedule.status !== "in_force"))
+        return null;
+    return {
+        effectiveAt: schedule.effective_at.slice(0, 10),
+        inForce: schedule.status === "in_force",
+        rows: (schedule.changes ?? []).map((change) => ({
+            key: change.key ?? "",
+            description: change.description ?? change.key ?? "",
+            before: formatScheduledValue(change.value_before, change.unit),
+            after: formatScheduledValue(change.value_after, change.unit),
+        })),
+    };
+}
+function formatScheduledValue(value, unit) {
+    if (value === null || value === undefined)
+        return "no limit";
+    if (typeof value === "boolean")
+        return value ? "yes" : "no";
+    if (typeof value !== "number")
+        return String(value);
+    if (unit === "bytes")
+        return formatLimitBytes(value);
+    if (unit === "usd_cents_per_100_credits")
+        return `$${(value / 100).toFixed(2)} per 100 credits`;
+    const words = (unit ?? "").replace(/_/g, " ").trim();
+    return words ? `${formatLimitCount(value)} ${words}` : formatLimitCount(value);
+}