waterplane 0.0.1 → 0.1.6

package/node_modules/@waterplane/shared/dist/sessioncost/costwords.js

@@ -0,0 +1,262 @@
+// Cut from sessioncost.ts (move only): the sentences and chips
+// The one door stays `./sessioncost.js`; this slice imports its siblings directly, never the barrel.
+import { fmtUsd, fmtUsdShort } from "../pricing.js";
+/** `n×`, at the precision the number deserves: 2.5 below ten, 12 above it. */
+export function fmtMultiple(m) {
+    return m >= 10 ? `${Math.round(m)}×` : `${(Math.round(m * 10) / 10).toFixed(1)}×`;
+}
+/** Tokens, short — `71k`, `1.2M`. Local to this module on purpose: it is used
+ *  inside the sentences, and a sentence that reads differently on two screens
+ *  because each formatted its own numbers is the bug `tokens.ts` exists over. */
+export function fmtTok(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(n >= 10_000_000 ? 0 : 1)}M`;
+    if (n >= 1_000)
+        return `${Math.round(n / 1_000)}k`;
+    return String(Math.round(n));
+}
+/**
+ * What a session has used, in one sentence — the ONE wording.
+ *
+ * Every screen that prints the total says it this way: the row's title, the
+ * session header, the context sheet's panel and the toast. It is written "so
+ * far" in all of them because the number is a floor (a truncated log, an agent
+ * log that has been cleaned up), and the agent share is named only when there
+ * IS one — "0 of it in subagents" is a sentence about nothing.
+ */
+export function usageText(usageTok, agentTok) {
+    const agents = agentTok != null && agentTok > 0
+        ? ` — ${fmtTok(agentTok)} of it in subagents`
+        : "";
+    return `This session has used ${fmtTok(usageTok)} tokens so far${agents}.`;
+}
+/**
+ * The same total as a chip: `1.4M`, or null when nothing measured it.
+ *
+ * Null rather than `0`, and rather than falling back to the carried volume: a
+ * zero beside a running session reads as a measurement that came back empty,
+ * and this one is simply absent on a host that does not send it.
+ */
+export function usageChip(usageTok) {
+    return usageTok != null && usageTok > 0 ? fmtTok(usageTok) : null;
+}
+/**
+ * What the session WOULD have cost, as a chip: `$4.21`, or null.
+ *
+ * The money twin of `usageChip`, and for the same reason it is a separate
+ * function rather than a `fmtUsdShort` call at each site: this is the one place
+ * that decides what "no figure" looks like. Null — never `$0` — when nothing
+ * measured it or nothing could be priced, so the caller falls back to the token
+ * total rather than printing an amount that reads as "this was free".
+ *
+ * Why the chip is money at all: two conversations that carried 38M and 18M
+ * tokens tell you nothing about which one was expensive, because the answer is
+ * the model they ran and how much of the traffic was cache reads at a tenth of
+ * the rate. A dollar figure is the same fact with the arithmetic already done.
+ */
+export function costChip(costUsd) {
+    return costUsd != null && Number.isFinite(costUsd) && costUsd > 0 ? fmtUsdShort(costUsd) : null;
+}
+/**
+ * Fewest weekly percent a calibration is taken from. `/usage` prints a whole
+ * percent, so the reading is ±0.5 of itself: at 5% that is ±10% on every share
+ * derived from it, at 1% it is ±50% — a number that wide is a wrong number.
+ */
+export const WEEK_CAL_MIN_PCT = 5;
+/**
+ * Dollars of list-price spend per percent of the weekly limit, or null.
+ *
+ * The account never says what one percent IS, so this measures it: what this
+ * desktop's logs priced in the weekly window up to the scrape, divided by the
+ * percentage the scrape read. The limit weighs models by price, not by raw
+ * tokens (a cache read is a tenth of an input token in both), which is why the
+ * calibration is in money. Traffic the logs never saw — claude.ai, another
+ * machine — counts against the limit but not in the spend, so a share derived
+ * from this errs LOW, and the caller's note says the estimate is this desktop's.
+ */
+export function weekUsdPerPct(weekCostUsd, weeklyPct) {
+    if (weekCostUsd == null || weeklyPct == null)
+        return null;
+    if (!Number.isFinite(weekCostUsd) || !(weekCostUsd > 0))
+        return null;
+    if (!Number.isFinite(weeklyPct) || weeklyPct < WEEK_CAL_MIN_PCT || weeklyPct > 100)
+        return null;
+    return weekCostUsd / weeklyPct;
+}
+/** A dollar figure as a share of the weekly limit — `≈0.4% of week` — or null
+ *  without a calibration or a figure. Below a thousandth it says so rather
+ *  than printing a zero. */
+export function weekShareText(costUsd, usdPerPct) {
+    if (costUsd == null || usdPerPct == null || !(costUsd > 0) || !(usdPerPct > 0))
+        return null;
+    const pct = costUsd / usdPerPct;
+    if (!Number.isFinite(pct))
+        return null;
+    if (pct < 0.001)
+        return "<0.001% of week";
+    // Significant figures, not decimals: one percent of a week is ~$18 of list
+    // price here, so a typical prompt is a few hundredths and a fixed decimal
+    // would print the same "<0.1" under every turn. One figure below 1%, two
+    // above — the calibration is good to ±10% at its worst, no finer.
+    const s = pct < 1 ? String(Number(pct.toPrecision(1))) : pct < 10 ? pct.toFixed(1) : String(Math.round(pct));
+    return `≈${s}% of week`;
+}
+/**
+ * The reader's line under one turn: what that prompt cost, what of it its
+ * subagents spent, the conversation's running total by then, and the context
+ * its last request carried — or null when none was measured.
+ *
+ * Each part is absent rather than `$0` / `0` (see `TranscriptTurn`), and the
+ * money parts end on the counterfactual in words, because a bare dollar figure
+ * under every turn reads as a bill.
+ *
+ * **Subagents are IN the figures when the host placed them** (`agentCostUsd`,
+ * `cumAgentCostUsd`) and the turn's figure then never stands without its split
+ * (`agents`: how much of it they spent). An agent can still be running when
+ * this is drawn — its call returned at once — so the figure then says "so far"
+ * and how many are still at it. Where the host could not place them (an older
+ * host, an unreadable agent directory, an agent it could not attribute) the
+ * figure is the conversation's own and the note SAYS subagents are not in it:
+ * `agents` (how many the turn started, by any evidence the caller has) and
+ * `agentsSoFar` (one was started at or before this turn) are that evidence.
+ *
+ * `usdPerWeekPct` (`weekUsdPerPct`) adds each money figure's share of the
+ * weekly limit beside it, and the note says where that share comes from.
+ */
+export function turnCostParts(t) {
+    const ok = (n) => n != null && Number.isFinite(n) && n > 0;
+    const running = ok(t.agentsRunning) ? t.agentsRunning : 0;
+    const agentUsd = ok(t.agentCostUsd) ? t.agentCostUsd : 0;
+    const week = (usd) => {
+        const w = weekShareText(usd, t.usdPerWeekPct);
+        return w ? ` (${w})` : "";
+    };
+    const turn = ok(t.costUsd)
+        ? `${fmtUsd(t.costUsd + agentUsd)} this prompt${running ? " so far" : ""}${week(t.costUsd + agentUsd)}`
+        : null;
+    const runningText = running ? `${running} subagent${running === 1 ? "" : "s"} still running` : null;
+    const agents = turn && agentUsd
+        ? `${fmtUsd(agentUsd)} of it in subagents${runningText ? ` · ${runningText}` : ""}`
+        : runningText;
+    const agentsInTotal = t.cumAgentCostUsd != null && Number.isFinite(t.cumAgentCostUsd);
+    const totalUsd = ok(t.cumCostUsd) ? t.cumCostUsd + (agentsInTotal ? t.cumAgentCostUsd : 0) : 0;
+    const total = totalUsd > 0
+        ? `${fmtUsd(totalUsd)} session so far${week(totalUsd)}`
+        : null;
+    const ctx = ok(t.ctxTok) ? `${fmtTok(t.ctxTok)} context` : null;
+    if (!turn && !total && !ctx && !agents)
+        return null;
+    // What a figure on screen leaves out. The turn's: it started agents and none
+    // of their spend (or running state) reached it. The total's: an agent before
+    // now, and the host published no agent running total beside it.
+    const turnMissing = !!t.agents && turn != null && !agentUsd && !running;
+    const totalMissing = !!t.agentsSoFar && total != null && !agentsInTotal;
+    const unpriced = ok(t.agentUnpricedTok)
+        ? `, ${fmtTok(t.agentUnpricedTok)} subagent tokens have no published rate`
+        : "";
+    // A calibration that also counted jobs sent to a peer desktop on the same account says so.
+    const incl = typeof t.weekIncl === "string" && t.weekIncl.trim() ? ` (${t.weekIncl.trim()})` : "";
+    const weekNote = (turn || total) && weekShareText(1, t.usdPerWeekPct)
+        ? `; % of week estimated from this desktop's spend${incl} against the weekly limit reading`
+        : "";
+    const note = turn || total
+        ? `API list price${turnMissing || totalMissing ? ", subagents not included" : ""}${unpriced}${weekNote}`
+        : null;
+    return { turn, agents, total, ctx, note };
+}
+/**
+ * A turn's own tokens, total FIRST and its split beside it — the ONE wording
+ * for the reader's turn foot (`TranscriptTurn.tokens`): `52k tokens — 1.2k in ·
+ * 830 out · 46k cache read · 3.2k cache write`. A total is never printed
+ * without its split, because nearly all of it is usually a cache read at a
+ * tenth of the input rate and "52k" alone overstates what was typed by orders
+ * of magnitude.
+ *
+ * A kind that is zero is left out (a measured zero is not news on a phone
+ * line); null when the field is absent or every kind is zero — never "0 tokens".
+ */
+export function turnTokensText(t) {
+    if (!t)
+        return null;
+    const n = (v) => (typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0);
+    const parts = [
+        [n(t.input), "in"], [n(t.output), "out"], [n(t.cacheRead), "cache read"], [n(t.cacheWrite), "cache write"],
+    ];
+    const total = parts.reduce((s, [v]) => s + v, 0);
+    if (!(total > 0))
+        return null;
+    const split = parts.filter(([v]) => v > 0).map(([v, w]) => `${fmtTok(v)} ${w}`).join(" · ");
+    return `${fmtTok(total)} tokens — ${split}`;
+}
+/**
+ * What the NEXT prompt here costs against a fresh session — one line under the
+ * newest finished turn, from the same reading the header chip and the context
+ * sheet use (`sessionCostOf`), so the three cannot disagree.
+ *
+ * Tokens and the multiple, never a dollar figure: the next turn's price needs
+ * the model's rate AND whether the cache is still warm, and a figure built on a
+ * guess at either would be a plausible wrong number. With no first reading
+ * (a log the host tail-read) the comparison is ABSENT and the line says only
+ * what the next prompt re-reads.
+ */
+export function nextTurnText(r) {
+    if (!r || !(r.tok > 0))
+        return null;
+    const head = `Next prompt re-reads ${fmtTok(r.tok)} of context`;
+    if (r.multiple == null || r.baseTok == null)
+        return `${head}.`;
+    if (r.multiple < 1.15)
+        return `${head} — about what a fresh session here starts with (${fmtTok(r.baseTok)}).`;
+    return `${head} — ${fmtMultiple(r.multiple)} what a fresh session here starts with (${fmtTok(r.baseTok)}).`;
+}
+/**
+ * Why a dollar figure is on screen at all for someone on a flat-fee plan —
+ * the ONE wording, shown wherever a list-price figure can be tapped or
+ * expanded (the per-prompt card, the context & cost sheet, token statistics).
+ *
+ * `costText` says what the number is NOT (a bill). This says what it IS for:
+ * a plan's session and weekly limits do not count every token the same, and
+ * the kinds differ by up to 100× in price on one model (Opus 5.5: a cache read
+ * $0.20/MTok, an output token $20/MTok). A token total adds those up as if
+ * equal, so it says almost nothing about how much of a limit a turn used; the
+ * API list price weighs each kind by its own rate, which makes it the one
+ * number that can be compared across turns, sessions and models.
+ */
+export const DOLLARS_WHY_HEAD = "Why dollars on a subscription?";
+export const DOLLARS_WHY = "Your plan's session and weekly limits don't count every token the same: on one model a cache read " +
+    "costs a hundredth of an output token. Adding tokens up treats them as equal, so the total says little " +
+    "about how much of your limit a prompt used. Pricing each kind at Anthropic's API list price weighs it " +
+    "by its own rate — the one number you can compare across prompts, sessions and models. It is not a bill.";
+/** Where the per-prompt cost card is drawn, and why the two views differ — said
+ *  under the same "?" as `DOLLARS_WHY`, in both views, so the difference is
+ *  explained wherever the card is. */
+export const COST_WHERE_HEAD = "Why only the last prompt in the CLI view?";
+export const COST_WHERE = "The reader folds this card under every prompt — tap a line to open it, and scroll up for older ones. " +
+    "The CLI view has no scroll-back of its own to hang a card on, so it keeps only the last prompt's, " +
+    "pinned under the terminal at a fixed height: opening or updating it never resizes the screen, which " +
+    "would make the CLI redraw. Same figures, same card; the newest one remembers open or folded in both.";
+/**
+ * What a session has cost, in one sentence — the ONE wording, and the framing
+ * is not optional.
+ *
+ * A dollar figure with nothing around it is read as a bill. This one is a
+ * COUNTERFACTUAL: what the same traffic would have cost billed through the API
+ * at list prices, while the CLI this app drives is usually running on a
+ * subscription, which is a flat fee no matter how many tokens go through it.
+ * `pricing.ts` states the whole argument; this is the sentence it produces.
+ *
+ * "so far" for the same reason `usageText` says it — every input is a floor —
+ * and the subagent clause only where there is one. Unpriced tokens are named
+ * rather than quietly charged at zero, because a model missing from the rate
+ * table is the one way this figure goes silently low.
+ */
+export function costText(costUsd, agentCostUsd, unpricedTok) {
+    const agents = agentCostUsd != null && agentCostUsd > 0
+        ? ` — ${fmtUsd(agentCostUsd)} of it in subagents`
+        : "";
+    const missing = unpricedTok != null && unpricedTok > 0
+        ? ` ${fmtTok(unpricedTok)} tokens ran on a model with no published rate and are not in it.`
+        : "";
+    return `At list prices that is ${fmtUsd(costUsd)} so far${agents} — an estimate of what the API would have charged, not what a subscription costs.${missing}`;
+}
+//# sourceMappingURL=costwords.js.map

package/node_modules/@waterplane/shared/dist/sessioncost/costwords.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"costwords.js","sourceRoot":"","sources":["../../src/sessioncost/costwords.ts"],"names":[],"mappings":"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"}

package/node_modules/@waterplane/shared/dist/sessioncost.d.ts

@@ -0,0 +1,52 @@
+/**
+ * What one more turn in THIS session costs, against what it would cost in a
+ * fresh one.
+ *
+ * ── The question this answers ───────────────────────────────────────────────
+ *
+ * Every turn re-sends the whole conversation. So the price of the next turn is
+ * not a property of what you are about to ask — it is the size of what is
+ * already there. A session at 400k spends 5-6× per turn what the same question
+ * would cost in a session opened a minute ago, and nothing on screen ever said
+ * so: the context badge says how much window is LEFT, which is a statement
+ * about when the CLI will compact, not about what the next turn costs.
+ *
+ * Measured on this desktop's own logs before any of this was written: 124
+ * conversations out of 8,968 in a fortnight grew past 200k of context, and those
+ * 124 accounted for 76% of every token spent. The turns at index 80 and beyond
+ * were 54% of the total, at an average of 312k carried per turn. The same work
+ * split into fresh sessions every ~40 turns simulates at a third of the tokens.
+ * The conversations were not doing anything unusual — they were just long.
+ *
+ * ── Why this is a READOUT and never a gate ──────────────────────────────────
+ *
+ * A long session is often exactly the right thing: the model knows the file, the
+ * failed approach and the three constraints you have not typed twice. That is
+ * worth paying for, and only the person in front of it can say whether it is
+ * worth paying for THIS turn. So everything here produces sentences and a chip,
+ * nothing produces a refusal, and no caller is given a boolean named `blocked`.
+ * A reminder that can stop you is not a reminder.
+ *
+ * ── The one number worth putting on screen ──────────────────────────────────
+ *
+ * `breakEvenTurns` — how many more turns of new work it takes before a fresh
+ * session would have been cheaper. It is derived from the cache multipliers in
+ * `pricing.ts` rather than guessed, and it answers the question people actually
+ * have ("should I just ask it here?") in the unit they are thinking in.
+ *
+ * At the measured numbers a single quick question is genuinely cheaper in the
+ * session that is already warm, and a ten-turn feature is several times cheaper
+ * somewhere new. A rule of thumb that says "always start fresh" would be wrong
+ * about the first case, and the whole point of computing this per session is to
+ * stop having a rule of thumb.
+ */
+export { MULT_WARM, MULT_HEAVY, MULT_STEEP, MIN_TURNS, CACHE_TTL_MS, CACHE_COLD_AFTER_MS, cacheLikelyCold, } from "./sessioncost/costtypes.js";
+export type { SessionCostLevel, SessionCostInput, SessionCostReading, } from "./sessioncost/costtypes.js";
+export { fmtMultiple, fmtTok, usageText, usageChip, costChip, WEEK_CAL_MIN_PCT, weekUsdPerPct, weekShareText, turnCostParts, turnTokensText, nextTurnText, DOLLARS_WHY_HEAD, DOLLARS_WHY, COST_WHERE_HEAD, COST_WHERE, costText, } from "./sessioncost/costwords.js";
+export { breakEvenTurns, agentAdvice, AGENT_LARGE_TOK, AGENT_LIVE_MS, liveAgentText, agentPushText, replanPromptText, sessionCost, costDoorsText, seriesCostFields, sessionCostOfSeries, } from "./sessioncost/costreading.js";
+export type { CacheAge, } from "./sessioncost/costreading.js";
+export { sessionCostOf, } from "./sessioncost/costofseries.js";
+export { compactionReading, compactionCountText, compactionUnmeasuredText, compactionRowFacts, compactionSavedText, compactionPendingText, compactionCostText, compactionRatioText, compactionWindowText, compactionMethodText, compactionRowLabel, } from "./sessioncost/costcompact.js";
+export type { CompactionReading, CompactionRow, } from "./sessioncost/costcompact.js";
+export { REBUILD_WROTE, REBUILD_READ, isColdRebuild, coldStartText, coldStartChip, } from "./sessioncost/costcold.js";
+export type { ColdStarts, } from "./sessioncost/costcold.js";

package/node_modules/@waterplane/shared/dist/sessioncost.js

@@ -0,0 +1,51 @@
+/**
+ * What one more turn in THIS session costs, against what it would cost in a
+ * fresh one.
+ *
+ * ── The question this answers ───────────────────────────────────────────────
+ *
+ * Every turn re-sends the whole conversation. So the price of the next turn is
+ * not a property of what you are about to ask — it is the size of what is
+ * already there. A session at 400k spends 5-6× per turn what the same question
+ * would cost in a session opened a minute ago, and nothing on screen ever said
+ * so: the context badge says how much window is LEFT, which is a statement
+ * about when the CLI will compact, not about what the next turn costs.
+ *
+ * Measured on this desktop's own logs before any of this was written: 124
+ * conversations out of 8,968 in a fortnight grew past 200k of context, and those
+ * 124 accounted for 76% of every token spent. The turns at index 80 and beyond
+ * were 54% of the total, at an average of 312k carried per turn. The same work
+ * split into fresh sessions every ~40 turns simulates at a third of the tokens.
+ * The conversations were not doing anything unusual — they were just long.
+ *
+ * ── Why this is a READOUT and never a gate ──────────────────────────────────
+ *
+ * A long session is often exactly the right thing: the model knows the file, the
+ * failed approach and the three constraints you have not typed twice. That is
+ * worth paying for, and only the person in front of it can say whether it is
+ * worth paying for THIS turn. So everything here produces sentences and a chip,
+ * nothing produces a refusal, and no caller is given a boolean named `blocked`.
+ * A reminder that can stop you is not a reminder.
+ *
+ * ── The one number worth putting on screen ──────────────────────────────────
+ *
+ * `breakEvenTurns` — how many more turns of new work it takes before a fresh
+ * session would have been cheaper. It is derived from the cache multipliers in
+ * `pricing.ts` rather than guessed, and it answers the question people actually
+ * have ("should I just ask it here?") in the unit they are thinking in.
+ *
+ * At the measured numbers a single quick question is genuinely cheaper in the
+ * session that is already warm, and a ten-turn feature is several times cheaper
+ * somewhere new. A rule of thumb that says "always start fresh" would be wrong
+ * about the first case, and the whole point of computing this per session is to
+ * stop having a rule of thumb.
+ */
+// The one door. The code lives in `./sessioncost/` (a slice per subject, listed below);
+// importers keep saying `./sessioncost.js`. docs/notes/shared-architecture.md.
+export { MULT_WARM, MULT_HEAVY, MULT_STEEP, MIN_TURNS, CACHE_TTL_MS, CACHE_COLD_AFTER_MS, cacheLikelyCold, } from "./sessioncost/costtypes.js";
+export { fmtMultiple, fmtTok, usageText, usageChip, costChip, WEEK_CAL_MIN_PCT, weekUsdPerPct, weekShareText, turnCostParts, turnTokensText, nextTurnText, DOLLARS_WHY_HEAD, DOLLARS_WHY, COST_WHERE_HEAD, COST_WHERE, costText, } from "./sessioncost/costwords.js";
+export { breakEvenTurns, agentAdvice, AGENT_LARGE_TOK, AGENT_LIVE_MS, liveAgentText, agentPushText, replanPromptText, sessionCost, costDoorsText, seriesCostFields, sessionCostOfSeries, } from "./sessioncost/costreading.js";
+export { sessionCostOf, } from "./sessioncost/costofseries.js";
+export { compactionReading, compactionCountText, compactionUnmeasuredText, compactionRowFacts, compactionSavedText, compactionPendingText, compactionCostText, compactionRatioText, compactionWindowText, compactionMethodText, compactionRowLabel, } from "./sessioncost/costcompact.js";
+export { REBUILD_WROTE, REBUILD_READ, isColdRebuild, coldStartText, coldStartChip, } from "./sessioncost/costcold.js";
+//# sourceMappingURL=sessioncost.js.map

package/node_modules/@waterplane/shared/dist/sessioncost.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessioncost.js","sourceRoot":"","sources":["../src/sessioncost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,wFAAwF;AACxF,+EAA+E;AAE/E,OAAO,EACL,SAAS,EACT,UAAU,EACV,UAAU,EACV,SAAS,EACT,YAAY,EACZ,mBAAmB,EACnB,eAAe,GAChB,MAAM,4BAA4B,CAAC;AAMpC,OAAO,EACL,WAAW,EACX,MAAM,EACN,SAAS,EACT,SAAS,EACT,QAAQ,EACR,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,aAAa,EACb,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,UAAU,EACV,QAAQ,GACT,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,cAAc,EACd,WAAW,EACX,eAAe,EACf,aAAa,EACb,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,mBAAmB,GACpB,MAAM,8BAA8B,CAAC;AAItC,OAAO,EACL,aAAa,GACd,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,wBAAwB,EACxB,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,8BAA8B,CAAC;AAKtC,OAAO,EACL,aAAa,EACb,YAAY,EACZ,aAAa,EACb,aAAa,EACb,aAAa,GACd,MAAM,2BAA2B,CAAC"}

package/node_modules/@waterplane/shared/dist/settings.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Settings that follow the USER, not the browser.
+ *
+ * Everything the app remembers has lived in localStorage, which was right for
+ * most of it — a send queue, a scroll watermark, a measured uplink rate all
+ * describe THIS device. But the same store also held the things the user
+ * AUTHORED: prompt templates (snippets), fan-out presets, header commands, the
+ * prompt pad, the toolbar layout, the default launch flags. Those are not
+ * properties of a browser, and keeping them there meant a phone, a desktop tab
+ * and the Android shell each had their own private copy — write a template on
+ * the phone and it does not exist anywhere else, reinstall the PWA and it is
+ * gone. There is exactly one host and it already persists far more valuable
+ * state, so that is where they belong.
+ *
+ * The design is deliberately dumb, because the alternative is a sync engine:
+ *
+ *  - **Opaque values.** The host stores the raw localStorage STRING per key and
+ *    never parses it. Shapes change with the client (`presets.ts`'s
+ *    `{ list, removed }` grew a field once already); a host that understood
+ *    them would have to be upgraded in lockstep with the UI it serves — which
+ *    it explicitly is not, since `webbundle.ts` lets the phone update its own
+ *    web bundle without touching the daemon.
+ *  - **Last write wins, per key, on a timestamp the WRITER stamps.** No
+ *    merging: two devices editing the same list concurrently is rare (one
+ *    person, one phone in hand) and a wrong merge of a prompt list is worse
+ *    than a lost edit that is still visible in the other client's UI until it
+ *    reloads. The pad is the one key whose CLIENT merges on adopt
+ *    (`shared/pad.ts`, per note, with tombstones): the host still stores a
+ *    string and still compares a `ts`, and this contract is unchanged.
+ *  - **An allow-list, not a mirror.** Syncing everything would drag the send
+ *    outbox, the paired host address and per-device cache state onto other
+ *    devices — the outbox especially, where a second device replaying another
+ *    device's queue is a prompt typed twice. Keys are opted IN, one at a time.
+ *
+ * The list below is the contract both ends check against, which is why it is
+ * here rather than in either package.
+ */
+/** One synced setting as the host holds it: the client's raw string + when. */
+export interface SettingRecord {
+    /** Exactly what the client had in localStorage — never parsed by the host. */
+    value: string;
+    /** Epoch ms stamped by the client that wrote it. Last write wins. */
+    ts: number;
+    /** Which device wrote it last, for the "changed elsewhere" notice. */
+    device?: string;
+}
+/** The whole synced document, keyed by localStorage key. */
+export type SettingsDoc = Record<string, SettingRecord>;
+/**
+ * The keys that follow the user.
+ *
+ * Every entry is content or a preference the user set ON PURPOSE and would be
+ * annoyed to re-create on another device. Anything describing the device, the
+ * link, or work in flight stays local — see the note below the list.
+ */
+export declare const SYNCED_SETTING_KEYS: readonly [string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string, string];
+/** The synced key the host reads for the local-model session cap. */
+export declare const LOCAL_SESSIONS_KEY: string;
+/** The biggest cap a person may type; anything above is "no cap" in practice. */
+export declare const LOCAL_SESSIONS_MAX = 16;
+/**
+ * The local-model cap off its raw string: a whole number 1..16 is that cap,
+ * `"0"` is NO cap (`null`), and absent, empty or garbage is `fallback` — the
+ * desktop's own default, never a guessed number.
+ */
+export declare function localSessionsSetting(raw: string | undefined | null, fallback: number | null): number | null;
+/** The synced key the host and the phone read for the large-subagent line. */
+export declare const AGENT_WINDOW_WARN_KEY: string;
+/** The smallest and largest line a person may set, in tokens. */
+export declare const AGENT_WINDOW_WARN_MIN = 50000;
+export declare const AGENT_WINDOW_WARN_MAX = 2000000;
+/**
+ * The large-subagent line off its raw synced string: a positive whole number
+ * of tokens within [50k, 2M] is that line; absent, empty, fractional, out of
+ * range or garbage is `AGENT_LARGE_TOK` — the default, never a guessed number.
+ */
+export declare function agentWindowWarnSetting(raw: string | undefined | null): number;
+/** The synced key the host reads for the global close-when-done default. */
+export declare const CLOSE_WHEN_DONE_KEY: string;
+/**
+ * The global *close automatic sessions when done* default, off the raw synced
+ * string. `"1"`/`"true"` is on (the client's flag spelling); absent, empty or
+ * anything else is OFF — the default the person chose: nothing closes a
+ * session they did not ask to have closed.
+ */
+export declare function closeWhenDoneSetting(raw: string | undefined | null): boolean;
+export type SyncedSettingKey = (typeof SYNCED_SETTING_KEYS)[number];
+/**
+ * Why the obvious candidates are NOT in the list above — kept as prose because
+ * the next person to add a key will ask exactly this.
+ *
+ *  - `<prefix>outbox` / `<prefix>compose.*` / `<prefix>deadUploads` — work in flight.
+ *    Replaying another device's queue types the same prompt twice; the ack
+ *    ledger de-dupes a RETRY of the same ackId, not a second device deciding to
+ *    send someone else's entry.
+ *  - `<prefix>hostBase`, `<prefix>deviceId` — what makes this device this device.
+ *  - `<prefix>dataSaver`, `<prefix>uploadScale`, `<prefix>upKbps` — properties of the
+ *    LINK. A phone on a DERP-relayed 5G path and a desktop on the LAN want
+ *    opposite answers, and copying one over the other makes the bad link worse.
+ *  - `<prefix>theme` — light, dark, or follow the OS (`web/theme.ts`). The one
+ *    that looks most like a fact about the PERSON and is not: the phone is held
+ *    in a dark bedroom and the desktop sits under an office window, the two
+ *    panels are different, and "dark on OLED" is a battery decision about one
+ *    of them. `system` — the DEFAULT — already carries the per-person answer,
+ *    since each OS is told the same thing by the same person; what an explicit
+ *    pick overrides is THIS device's OS, which is a fact about this device.
+ *    There is a second reason, learned while building it. Every synced key is
+ *    last-write-wins on a CLIENT-SUPPLIED timestamp, and a client that reports
+ *    a wrong clock parks that key for as long as the skew lasts: nothing ever
+ *    lowers a stored `ts`, so every later pick loses to it and is echoed back
+ *    undone. For the pad or the toolbar that risk buys a feature worth having.
+ *    For a setting whose whole job is one tap that changes what you are looking
+ *    at, a failure mode where the tap silently reverts is worse than not
+ *    syncing at all.
+ *  - `<prefix>netPulse` — the permanent connection strip (`web/netpulse.ts`). It
+ *    looks like a display preference, but switching it on spends THIS device's
+ *    radio on an extra ping every three seconds and THIS device's screen on
+ *    22 px: exactly the trade a phone on a bad tunnel wants to make and a
+ *    desktop on the LAN does not. Same reason as the row above.
+ *  - `<prefix>snap.*`, `<prefix>slashCache`, `<prefix>artMarks`, `<prefix>trSeen.*`,
+ *    `<prefix>pull.state`, `<prefix>netlog` — caches and per-device reading
+ *    positions, all re-derivable and all bigger than they look.
+ *  - `<prefix>dismiss*`, `<prefix>lastForcedReload`, `<prefix>webUpdate.*` — this
+ *    browser's own history with its own banners.
+ */
+/** Cheap membership test that also narrows the type. */
+export declare function isSyncedKey(key: string): key is SyncedSettingKey;
+/**
+ * Per-value cap, sized ABOVE what the client's own caps can produce: a full
+ * preset list is 80 items × 8000 chars ≈ 640 KB, and a value the host refuses
+ * is the worst outcome available — the two ends then disagree with nothing on
+ * screen saying so. Anything past this is a client bug, not a big list.
+ */
+export declare const MAX_SETTING_BYTES: number;
+/** Whole-document cap, so a misbehaving client cannot grow the file forever. */
+export declare const MAX_SETTINGS_BYTES: number;