@eddyskywalker/dsh-chatgpt-subscription 0.36.2 → 0.37.0

package/lib/types/host/widget-board/line-quota.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-quota.d.ts","sourceRoot":"","sources":["../../../../src/host/widget-board/line-quota.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,OAAO,KAAK,EAEV,aAAa,EAEb,cAAc,EACf,MAAM,qBAAqB,CAAA;AAE5B,2EAA2E;AAC3E,MAAM,WAAW,cAAc;IAC7B,6EAA6E;IAC7E,KAAK,EAAE,aAAa,GAAG,IAAI,CAAA;IAC3B,gEAAgE;IAChE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB;;;;;OAKG;IACH,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,6EAA6E;IAC7E,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAA;IACxB,2EAA2E;IAC3E,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CACrB;AAiZD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAmDnE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CA6BtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAkCzE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAgCzE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAmCzE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAwBpE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAsB3E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAmCtE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAsCnE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CA4BvE;AAsED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CA+BxE;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,uBAAuB;IACtC,uEAAuE;IACvE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,uEAAuE;IACvE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB;;;;;OAKG;IACH,OAAO,EAAE,cAAc,EAAE,CAAA;CAC1B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,OAAO,GAAG,uBAAuB,GAAG,IAAI,CAY1F;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,GAAG,IAAI,CAmBzF;AA0CD;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,cAAc,CAAC,CAYhG,CAAA"}

package/lib/types/host/widget-board/line-registry.d.ts

@@ -0,0 +1,402 @@
+/**
+ * The line registry: one entry per subscription line, and the two halves of a
+ * card answered from different authorities.
+ *
+ * WHY THE SPLIT
+ *
+ * - ACCOUNTS travel through the pools, in process. Every line's pool already
+ *   speaks the same three methods (listAccounts / setPrimary / setStrategy) and
+ *   hands back the same row DTO, so ONE generic adapter covers all of them — no
+ *   HTTP, no per-line code, and no second implementation of eligibility,
+ *   cooldowns or the rotation strategy. The line → pool mapping is injected by
+ *   src/index.ts, where every pool is in scope; nothing here imports a concrete
+ *   pool class, so a new line is a wiring change, not a change to this module.
+ *
+ * - QUOTA travels over LOOPBACK HTTP, through the line's own status route. Each
+ *   line's route already normalizes its provider payload into its own DTO and
+ *   owns the cache, the refresh flight and the error reporting for it. Reading
+ *   the provider directly from here would be a second reader of the same
+ *   upstream, free to drift from the one the settings card shows. The loopback
+ *   call needs no credential: these are the very same GET /status requests this
+ *   plugin's own settings page makes.
+ *
+ * A read is therefore two independent tasks in parallel, and NEITHER can take
+ * the other down: a pool file that will not decrypt still leaves the card with
+ * its quota, and a line whose route is unreachable still leaves it with its
+ * accounts.
+ *
+ * - PER-ACCOUNT QUOTA is the third, OPTIONAL half, and the one neither of the
+ *   other two can answer: a pool row carries a snapshot only for the account
+ *   that was actually read, so on a two-account line the second row has nothing
+ *   to draw. A line that opts in hands over a reader
+ *   ({@link LINE_ACCOUNT_QUOTA_READERS}) which — given ONE account's credential —
+ *   asks that line's own client for that account's own numbers. The reader is
+ *   INJECTED, never imported: each one needs a concrete line client, and this
+ *   module imports no line at all. A line with no reader behaves exactly as
+ *   before, which is why every line that does not opt in is untouched.
+ *
+ *   The opt-in half is bounded FOUR ways, because it is the only part of a read
+ *   that spends upstream requests per ACCOUNT: one budget for one account
+ *   ({@link LINE_ACCOUNT_QUOTA_TIMEOUT_MS}), ONE budget for the whole per-account
+ *   stage ({@link LINE_ACCOUNT_QUOTA_WHOLE_BUDGET_MS}), a cache per (line,
+ *   account) so a card polling every 60 s does not become a poll of the upstream
+ *   ({@link LINE_ACCOUNT_QUOTA_CACHE_MS} — with a much shorter TTL for a failed
+ *   entry, {@link LINE_ACCOUNT_QUOTA_FAILURE_CACHE_MS}, so a recovered account
+ *   comes back on the next poll), a small concurrency gate
+ *   ({@link LINE_ACCOUNT_QUOTA_CONCURRENCY}), and a cap on how many accounts one
+ *   read spends a request on at all ({@link LINE_ACCOUNT_QUOTA_MAX_ACCOUNTS}).
+ *   Every failure is absorbed on the ONE row it belongs to: a reader that
+ *   throws, times out or answers null leaves that row unread and touches nothing
+ *   else — no other row, no other line, and never the card's error field.
+ *
+ * EVERY failure is bounded, and the bound does NOT grow with the account count:
+ * the two halves a card reads are bounded by the HTTP budget (5 s,
+ * {@link LINE_HTTP_TIMEOUT_MS}), and the per-account stage is bounded by ITS OWN
+ * budget (6 s, {@link LINE_ACCOUNT_QUOTA_WHOLE_BUDGET_MS}) rather than by
+ * ceil(accounts / concurrency) × 5 s — so six accounts whose readers all hang
+ * answer in 6 s instead of 15 s, and a board of such cards is not a board that
+ * hangs. A row the whole stage did not reach is not a failure: it stays blank
+ * and is tried again on the next read, because the cache is per account.
+ */
+import type { AccountRotationStrategy, PoolAccountSummaryDto } from '../../shared/account-pool-contracts.ts';
+import type { LineCardData } from './line-contracts.ts';
+import { type LineAccountQuotaReading, type LineQuotaFacts } from './line-quota.ts';
+/**
+ * How long one line's HTTP read may take, in milliseconds.
+ *
+ * A board data source is read while a card paints, so this is a ceiling rather
+ * than a target: every one of these routes answers from a local cache in
+ * milliseconds, and five seconds is the point at which "slow" has already
+ * become "broken" for the user watching an empty card.
+ */
+export declare const LINE_HTTP_TIMEOUT_MS = 5000;
+/**
+ * How long ONE account's extra quota read may take, in milliseconds.
+ *
+ * Equal to the card's own HTTP budget rather than shorter. It was three seconds
+ * first, on the theory that a warm route answers in milliseconds; MEASURED
+ * against a live Qoder endpoint, the same read took 107 ms, 573 ms, 1254 ms —
+ * and twice over three seconds on a cold process. With the failure cache below,
+ * a budget that tight converts "the first card after a restart" into "a blank
+ * row for the next quarter of a minute", which is a worse answer than waiting
+ * two extra seconds once. Five seconds also cannot lengthen a card: the rows are
+ * read two at a time, so a two-account line still answers inside one budget.
+ *
+ * The same budget covers the credential lookup and the upstream call together —
+ * it is one deadline for one row, not one per step.
+ */
+export declare const LINE_ACCOUNT_QUOTA_TIMEOUT_MS = 5000;
+/**
+ * How long one SUCCESSFUL (line, account) reading is reused, in milliseconds.
+ *
+ * The board re-reads a card every 60 seconds, and there are two rows on the
+ * lines this exists for. Without a cache every poll would be two upstream
+ * requests per account — the quota endpoint is a personal, undocumented one, and
+ * hammering it on a timer is how an account gets rate-limited by its own card.
+ * Sixty seconds is therefore a FLOOR: a reading is never reused for less.
+ */
+export declare const LINE_ACCOUNT_QUOTA_CACHE_MS = 60000;
+/**
+ * How long a FAILED (line, account) reading is reused, in milliseconds.
+ *
+ * Deliberately NOT the same TTL as a success, because the two entries are
+ * remembered for opposite reasons:
+ *
+ * - a success is cached to stop the board from polling the upstream, so its TTL
+ *   is the poll interval;
+ * - a failure is cached to stop a broken account from being retried on every
+ *   tick — but every minute it lasts is also a minute of a row that HAS numbers
+ *   available and is not showing them (a transient timeout, an upstream blip, a
+ *   credential that just got renewed). Fifteen seconds bounds that cost: a
+ *   failure is retried about four times a minute, which is far below anything
+ *   the upstream would notice, and a recovered account is back on the card on
+ *   the very next poll instead of the one after it.
+ *
+ * Both entries are remembered rather than dropped: forgetting a failure would
+ * turn one dead account into one upstream request per card read.
+ */
+export declare const LINE_ACCOUNT_QUOTA_FAILURE_CACHE_MS = 15000;
+/**
+ * How many per-account quota reads one registry may have in flight at once.
+ *
+ * Two, so a single card read (one per row) is sequential at worst on the lines
+ * that exist today, while a board showing two cards of the same line still
+ * cannot fan out into a burst of upstream requests.
+ */
+export declare const LINE_ACCOUNT_QUOTA_CONCURRENCY = 2;
+/**
+ * How long the WHOLE per-account stage of ONE card read may take, in
+ * milliseconds.
+ *
+ * Not about one account: this is the ceiling on everything a card waits for while
+ * it asks each row's own upstream. The per-account budget above bounds one ROW,
+ * and on its own it composes badly — rows are read two at a time, so N accounts
+ * cost ceil(N / 2) × 5 s in the worst case, which is 15 s on six accounts and
+ * grows without limit. That is the number this constant removes: six accounts
+ * whose readers all hang now answer in six seconds rather than fifteen, and the
+ * same six seconds covers sixty accounts.
+ *
+ * Why 6 s and not 5: one account must still be able to spend its FULL
+ * per-account budget — the credential lookup and the upstream call share that
+ * deadline, and a cold upstream has been measured over three seconds twice — so a
+ * stage shorter than the row budget would silently turn every cold first read
+ * into a blank row. The extra second is what lets the first pair of a
+ * two-account line finish, failure path included, before the stage closes.
+ *
+ * Running out is NOT an error. Rows that answered before the deadline keep their
+ * numbers; rows that did not stay UNREAD — `usedPercent: null`, no window list,
+ * and no entry in the card's `error` field. The next read (the board's 60 s poll,
+ * or a manual refresh) tries them again, which works because the cache is keyed
+ * per account and a row that never answered was never cached.
+ */
+export declare const LINE_ACCOUNT_QUOTA_WHOLE_BUDGET_MS = 6000;
+/**
+ * How many accounts ONE read may spend a per-account request on.
+ *
+ * The stage budget above bounds the TIME; this bounds the WORK. A line with three
+ * hundred pooled accounts would otherwise open a hundred and fifty credential
+ * lookups and upstream quota requests per card read — each one billed to a
+ * personal, undocumented endpoint — and the rows past the first few could never be
+ * reached before the budget expired anyway. Reading eight and leaving the rest
+ * unread is the honest version of that: the extra rows stay blank instead of
+ * queueing behind a deadline they cannot meet.
+ *
+ * WHICH eight, when there are more: primary first, then most recently used
+ * ({@link PoolAccountSummaryDto.lastUsedAt} descending, pool order on ties), so
+ * the cap spends the card's requests on the rows a reader is most likely looking
+ * at. A rotation moves that window on the next read.
+ */
+export declare const LINE_ACCOUNT_QUOTA_MAX_ACCOUNTS = 8;
+/**
+ * One line, as this registry reads it.
+ *
+ * A definition carries no service: the pool arrives through the injected
+ * mapping and the routes are addressed by path, which is what lets one module
+ * describe eleven lines without importing eleven implementations.
+ */
+export interface LineDefinition {
+    /** Line id a card names, e.g. `codex`. Also the pool mapping's key. */
+    id: string;
+    /** Display name, e.g. `ChatGPT`. */
+    label: string;
+    /** The line's own status route, e.g. `/claude/api/status`. */
+    statusPath: string;
+    /**
+     * The line's own quota-refresh route, POSTed before the status route is read
+     * again. Null for a line whose status read is already authoritative.
+     */
+    refreshPath: string | null;
+    /** The line's payload → shape C's quota half. */
+    normalize(status: unknown): LineQuotaFacts;
+}
+/**
+ * Every line this plugin can serve a card for.
+ *
+ * The routes are the lines' own, verbatim: this module is not allowed to invent
+ * a prefix, because a prefix is what a line owns.
+ */
+export declare const LINE_DEFINITIONS: readonly LineDefinition[];
+/**
+ * What one line's client is handed to read ONE account's quota.
+ *
+ * @see LineAccountQuotaClient for why this is an object rather than a bare
+ *   `fetch`: the account id is not bookkeeping, it is half of the question.
+ */
+export interface LineAccountQuotaContext {
+    /**
+     * The pool account this reading is for.
+     *
+     * Load-bearing, not decoration: a line remembers a quota snapshot against the
+     * account it was read for, so a reader that cannot name the account has its
+     * snapshot stored under no key at all — and the NEXT account's read is then
+     * answered from the previous account's cache with the previous account's
+     * numbers. That is exactly the failure this whole hook exists to fix.
+     */
+    accountId: string;
+    /**
+     * The HTTP client for this one read.
+     *
+     * It already carries the row's deadline as its `signal`, so a client that
+     * honours `signal` is cancelled by the budget rather than merely abandoned.
+     * The reader must not replace it with a longer-lived one.
+     */
+    fetchFn: typeof fetch;
+}
+/**
+ * One line's quota client, as the composition hands it over.
+ *
+ * The payload is the line's OWN DTO, `unknown` here on purpose: this module
+ * reads no line's types, and the pure mapping from that DTO to
+ * {@link LineAccountQuotaReading} lives beside the normalizers in
+ * `line-quota.ts` ({@link LINE_ACCOUNT_QUOTA_READERS} names which one applies).
+ *
+ * @param credentials - This account's credential, from the pool kernel.
+ * @param context - Which account, and the client to read it with.
+ * @returns The line's raw quota payload; null when the line measured nothing.
+ */
+export type LineAccountQuotaClient = (credentials: unknown, context: {
+    fetchFn: typeof fetch;
+    accountId: string;
+}) => Promise<unknown>;
+/**
+ * One line's per-account quota reader: credentials in, the row's two facts out.
+ *
+ * @param credentials - This account's credential, from the pool kernel. Never a
+ *   credential this module chose a different account for: the row and the
+ *   reading must describe the same account.
+ * @param context - Which account, and the client to read it with.
+ * @returns The reading, or null when this account's quota was not measurable.
+ */
+export type LineAccountQuotaReader = (credentials: unknown, context: LineAccountQuotaContext) => Promise<LineAccountQuotaReading | null>;
+/**
+ * A line's reader, once its client is known.
+ *
+ * A factory rather than a plain function so the assembly of "which bucket /
+ * which window" stays HERE while "how to reach that line's upstream" stays in
+ * the composition: {@link createAccountQuotaReaders} hands the client in, and a
+ * line whose client was not injected simply produces no reader at all.
+ */
+export type LineAccountQuotaReaderFactory = (client: LineAccountQuotaClient) => LineAccountQuotaReader;
+/**
+ * THE per-account quota hook table: line id → how that line's readings are made.
+ *
+ * Keying it by line id is the whole point: a card names a line, a row names an
+ * account, and a line with no entry here keeps EXACTLY the behaviour it had
+ * before this table existed. That is not a fallback nobody exercised — it is the
+ * default for nine of the eleven lines.
+ *
+ * Nothing in this table imports a line. Each entry needs that line's client and
+ * receives it ({@link LineAccountQuotaClient}); a future line adds one entry
+ * here plus one injected client, and no other module has to learn about it.
+ *
+ * What justified the two entries:
+ *
+ * - `qoder` — the line's `quota/usage` snapshot states absolute buckets, not a
+ *   percentage; {@link qoderAccountQuotaReading} derives a share only when a
+ *   bucket bounded it (total > 0) AND stated what was used. No bounded bucket,
+ *   no bar.
+ * - `minimax-code` — the Token Plan states a 5-hour (`interval`) and a weekly
+ *   window; the row draws the 5-hour one, because that is the tightest limit the
+ *   plan has ({@link minimaxAccountQuotaReading}). The weekly window is never
+ *   substituted for it.
+ */
+export declare const LINE_ACCOUNT_QUOTA_READERS: Readonly<Record<string, LineAccountQuotaReaderFactory | undefined>>;
+/**
+ * The readers in force, built from the clients the composition injected.
+ *
+ * A line whose client was not injected gets NO reader, which is what keeps the
+ * hook optional in practice and not merely on paper: a composition that hands
+ * over none of these reads every card exactly as it did before.
+ *
+ * @param clients - Line id → that line's quota client. Omitted or partial is the
+ *   normal case, not an error.
+ * @returns Line id → the reader for it; lines without both halves are absent.
+ */
+export declare function createAccountQuotaReaders(clients: Readonly<Record<string, LineAccountQuotaClient | undefined>> | undefined): Readonly<Record<string, LineAccountQuotaReader | undefined>>;
+/**
+ * The part of a pool this registry drives.
+ *
+ * All three methods are the shared pool kernel's own, which is why the pool
+ * mapping can be one generic adapter instead of eleven: the row DTO is shared
+ * and the three calls are shared.
+ */
+export interface LineAccountSource {
+    listAccounts(): Promise<PoolAccountSummaryDto[]>;
+    setPrimary(accountId: string): Promise<void>;
+    setStrategy(strategy: AccountRotationStrategy): Promise<void>;
+    /**
+     * The whole pool document, for the two facts a list of rows cannot state:
+     * the ACTIVE account (a pool may have none yet) and the rotation strategy.
+     *
+     * Optional because not every line exposes it; when it is absent the strategy
+     * is reported as the pool's own default and the active account is the primary
+     * row, which is what a sequential pool resolves to anyway.
+     */
+    read?(): Promise<unknown>;
+    /**
+     * One NAMED account's credential, renewed if it is about to expire.
+     *
+     * This is the shared pool kernel's own `getFreshCredential`, narrowed to what
+     * a quota read needs. It is the right method rather than the routing one for
+     * the reason the kernel already documents: reading a quota is not serving a
+     * request, so it addresses an account by id, ignores cooldowns and the pin,
+     * and writes no rotation bookkeeping — switching accounts, spending the
+     * rotation state or promoting a row is explicitly NOT something a card may do
+     * behind the user's back.
+     *
+     * Optional: absent on a source that cannot hand a credential over, and a line
+     * whose source does not have it simply gets no per-account reading.
+     *
+     * A refresh here is the pool's own single-flight renewal, and it is the one
+     * write this hook can cause — the same write the settings card's quota read
+     * causes on the same method. This module writes no credential file of its own.
+     */
+    getFreshCredential?(accountId: string, fetchFn?: typeof fetch): Promise<unknown>;
+}
+/** What {@link createLineRegistry} is handed. */
+export interface LineRegistryOptions {
+    /** This host's own origin, resolved lazily so a not-yet-bound port is not fatal at load. */
+    origin(): string;
+    /** Line id → the pool to drive. A line with no entry is reported uninstalled. */
+    pools: Readonly<Record<string, LineAccountSource | undefined>>;
+    /** Test seam: the HTTP client. Defaults to the global fetch. */
+    fetchFn?: typeof fetch;
+    /** Test seam: the whole-read budget in milliseconds. */
+    timeoutMs?: number;
+    /**
+     * Line id → that line's quota client, for the lines that opt in to a
+     * per-account reading.
+     *
+     * Injected rather than imported so this module stays free of every line's
+     * implementation (and of the process-wide caches those modules keep): the
+     * composition already holds all of them, because it is where the pools are
+     * wired. A line with no client here — which is nine of eleven today — keeps
+     * the behaviour it had before this option existed.
+     */
+    accountQuotaClients?: Readonly<Record<string, LineAccountQuotaClient | undefined>>;
+    /** Test seam: how long one SUCCESSFUL (line, account) reading is reused. */
+    accountQuotaCacheMs?: number;
+    /** Test seam: how long a FAILED (line, account) reading is reused. */
+    accountQuotaFailureCacheMs?: number;
+    /** Test seam: one account's own read budget in milliseconds. */
+    accountQuotaTimeoutMs?: number;
+    /**
+     * Test seam: the budget for the WHOLE per-account stage in milliseconds,
+     * which is what bounds the card rather than any one row.
+     */
+    accountQuotaWholeBudgetMs?: number;
+    /** Test seam: how many accounts one read may spend a request on. */
+    accountQuotaMaxAccounts?: number;
+    /** Test seam: the lines to serve. Defaults to {@link LINE_DEFINITIONS}. */
+    definitions?: readonly LineDefinition[];
+}
+/** The registry a card reads through. */
+export interface LineRegistry {
+    /** Every line this registry serves, in display order. */
+    readonly definitions: readonly LineDefinition[];
+    /** The ids {@link LineRegistry.read} accepts. */
+    ids(): string[];
+    /** Read one line's card. Throws for an unknown line. */
+    read(line: string, signal?: AbortSignal): Promise<LineCardData>;
+    /** POST the line's own refresh route, then read its card. */
+    refresh(line: string, signal?: AbortSignal): Promise<LineCardData>;
+    /** Pin one of the line's pooled accounts, then read its card. */
+    switchAccount(line: string, accountId: string, signal?: AbortSignal): Promise<LineCardData>;
+    /** Change the line's rotation strategy, then read its card. */
+    changeStrategy(line: string, strategy: string, signal?: AbortSignal): Promise<LineCardData>;
+}
+/**
+ * Build a registry over the injected line → pool mapping.
+ *
+ * @param options - The mapping, the origin and the seams.
+ * @returns The registry.
+ */
+export declare function createLineRegistry(options: LineRegistryOptions): LineRegistry;
+/**
+ * The line a card names, from its props.
+ *
+ * @param props - The card's props.
+ * @returns The line id.
+ */
+export declare function lineOfProps(props: unknown): string;
+//# sourceMappingURL=line-registry.d.ts.map

package/lib/types/host/widget-board/line-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-registry.d.ts","sourceRoot":"","sources":["../../../../src/host/widget-board/line-registry.ts"],"names":[],"mappings":"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"}

package/lib/types/host/widget-board/provider.d.ts

@@ -0,0 +1,140 @@
+import { type LineAccountQuotaClient, type LineAccountSource } from './line-registry.ts';
+/** The card a data source or a capability is called for. */
+export interface WidgetBoardInstance {
+    id: string;
+    widget: string;
+    props: Record<string, unknown>;
+}
+/** A data source registration, as this provider fills it in. */
+export interface WidgetBoardDataSourceRegistration {
+    apiVersion: number;
+    provider: string;
+    id: string;
+    read(instance: WidgetBoardInstance): unknown | Promise<unknown>;
+}
+/** A capability registration, as this provider fills it in. */
+export interface WidgetBoardCapabilityRegistration {
+    apiVersion: number;
+    provider: string;
+    id: string;
+    title?: {
+        zh: string;
+        en: string;
+    };
+    description?: {
+        zh: string;
+        en: string;
+    };
+    input?: Record<string, unknown>;
+    output?: Record<string, unknown>;
+    call(instance: WidgetBoardInstance, args: unknown, signal: AbortSignal): unknown | Promise<unknown>;
+}
+/** The lifecycle handle one widget-type registration answers with. */
+export interface WidgetBoardHandle {
+    readonly provider: string;
+    readonly widgets: readonly string[];
+    register(registrations?: {
+        dataSources?: WidgetBoardDataSourceRegistration[];
+        capabilities?: WidgetBoardCapabilityRegistration[];
+    }): () => void;
+    dispose(): Promise<void>;
+}
+/** The `widgetBoard` service, as this module uses it. */
+export interface WidgetBoardService {
+    readonly apiVersion: number;
+    registerWidgetType(registration: {
+        apiVersion: number;
+        provider: string;
+        directory: string;
+    }): Promise<WidgetBoardHandle>;
+    /**
+     * Present from the board generation that introduced capabilities.
+     *
+     * Probed, never assumed: an older board publishes no such method, and this
+     * provider then registers its data sources alone instead of failing.
+     */
+    registerCapability?(registration: WidgetBoardCapabilityRegistration): () => void;
+}
+/** The scoped context an inject callback receives. */
+export interface WidgetBoardScope {
+    get(name: string): unknown;
+    logger: {
+        warn(message: string): void;
+    };
+    effect(callback: () => () => void, label?: string): void;
+}
+/**
+ * The host context, narrowed to what this module touches.
+ *
+ * A structural subset of the Cordis `Context`, so the caller casts once at the
+ * wiring site and a test can drive the real registration function with a
+ * plain object.
+ */
+export interface WidgetBoardContext {
+    inject(names: string[], callback: (scope: WidgetBoardScope) => void): void;
+}
+/**
+ * The line registry this provider publishes when the composition hands one over.
+ *
+ * Deliberately a plain bag of already-resolved services rather than the pools
+ * themselves: the mapping's key is a line id the board also knows, its value is
+ * whatever that line's pool object is, and this module never learns which class
+ * it is talking to.
+ */
+export interface WidgetBoardLineOptions {
+    /**
+     * This host's own origin, resolved per read.
+     *
+     * A thunk rather than a string because the web server may not have bound a
+     * port yet when this provider registers, and a value captured then would be a
+     * guess that outlives the fact.
+     */
+    origin(): string;
+    /** Line id → its pool. A line with no entry is reported as not installed. */
+    pools: Readonly<Record<string, LineAccountSource | undefined>>;
+    /** Test seam: the HTTP client the loopback reads use. */
+    fetchFn?: typeof fetch;
+    /** Test seam: the whole-read budget in milliseconds. */
+    timeoutMs?: number;
+    /**
+     * Line id → that line's quota client, for the lines that read a quota PER
+     * ACCOUNT (see `LINE_ACCOUNT_QUOTA_READERS` in the registry).
+     *
+     * Passed through untouched: the composition holds these clients, this module
+     * never learns which line they belong to, and a line omitted here is a line
+     * that keeps the pool's own single-account snapshot.
+     */
+    accountQuotaClients?: Readonly<Record<string, LineAccountQuotaClient | undefined>>;
+}
+/** What {@link registerWidgetBoard} is handed. */
+export interface WidgetBoardProviderOptions {
+    /**
+     * The per-line registry, when the composition has one.
+     *
+     * Absent leaves this provider with nothing to register at all — no
+     * `line-card` data source and no line capabilities — which is exactly what a
+     * caller that has not wired the line pools wants. There is no ChatGPT-only
+     * fallback any more: one card per line is the whole contribution.
+     */
+    lines?: WidgetBoardLineOptions;
+    /** Test seam: overrides the widget directory found from `import.meta.url`. */
+    widgetsDirectory?: string;
+}
+/**
+ * Register this plugin's board contribution, if the host has a board.
+ *
+ * @param ctx - The host context; only `inject` is used.
+ * @param options - The line registry to publish through, and the widget directory override.
+ */
+export declare function registerWidgetBoard(ctx: WidgetBoardContext, options: WidgetBoardProviderOptions): void;
+/**
+ * This package's widget directory, resolved from the loaded module.
+ *
+ * `import.meta.url` points at `lib/index.js` in a built package and at a source
+ * file under `src/` in a test run, so the root is found by walking up to the
+ * `package.json` that names THIS package rather than by assuming a depth.
+ *
+ * @returns The absolute directory, or undefined when no such manifest was found.
+ */
+export declare function widgetsDirectory(): string | undefined;
+//# sourceMappingURL=provider.d.ts.map

package/lib/types/host/widget-board/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../src/host/widget-board/provider.ts"],"names":[],"mappings":"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"}

package/lib/types/index.d.ts

@@ -2,6 +2,7 @@ import type { Context, Volatile } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
 import { type GuardOptions } from './host/reasoning-collapse-guard/index.ts';
 import { type NoAnswerResumeOptions } from './host/no-answer-resume/index.ts';
+import type { ProgressUpdateLanguage } from './host/progress-updates/prompt.ts';
 /**
  * 运行期配置形状：标了 `volatile()` 的字段在 loader 解析之后是**活引用**。
  *
@@ -81,6 +82,13 @@ export interface Config {
      * 条提醒。默认 8（与 `NUDGE_THRESHOLD` 同一个数，两处不会漂移）。
      */
     progressUpdatesNudgeThreshold?: Volatile<number>;
+    /**
+     * 进展更新的输出语言：`auto` 跟随对话（默认）、`zh` 中文、`en` 英文。
+     *
+     * 只约束 `progress_update` 的标题与正文——提示词本身固定英文，用户看到的
+     * 文字才跟着这个字段走。同样是 `volatile()`：设置一保存就生效，不重挂插件行。
+     */
+    progressUpdatesLanguage?: Volatile<ProgressUpdateLanguage>;
 }
 /**
  * profile 里写的配置形状：volatile 字段在这里仍是普通值。
@@ -118,6 +126,8 @@ export interface ConfigInput {
     progressUpdates?: boolean;
     /** 进展更新的催促阈值（默认 8）。 */
     progressUpdatesNudgeThreshold?: number;
+    /** 进展更新的输出语言（默认 auto：跟随对话）。 */
+    progressUpdatesLanguage?: ProgressUpdateLanguage;
 }
 export declare const Config: z<ConfigInput, Config>;
 export declare const inject: string[];