sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/statusline/formatter.js

@@ -0,0 +1,122 @@
+import { FIVE_HOUR_WINDOW_MS, formatQuotaAge } from '../quota';
+import { estimateTimeToQuota } from './BurnRateCalculator';
+export function selectStatuslineAccount(input) {
+    if (input.accounts.claude.present) {
+        return {
+            providerId: 'claude-code',
+            accountId: input.accounts.claude.accountId,
+            accountLabel: input.accounts.claude.label ?? input.accounts.claude.email ?? 'claude',
+            quota: input.claudeQuota ?? null,
+        };
+    }
+    if (input.accounts.codex.present) {
+        return {
+            providerId: 'codex',
+            accountId: input.accounts.codex.accountId,
+            accountLabel: input.accounts.codex.label ?? input.accounts.codex.email ?? 'codex',
+            quota: input.codexQuota ?? null,
+        };
+    }
+    return null;
+}
+/**
+ * One-line status. Segments, in order, each omitted when unknown:
+ * `acct:<label> · 5h 42% resets 14:00 · ~1h20m left · 7d 61% · (2h ago) · ctx 37% · $0.42 · cache 92%`
+ *
+ * The age segment appears only for cached quota older than five minutes, so
+ * a snapshot from yesterday can no longer read like a live figure.
+ */
+export function formatStatusline(input) {
+    const selected = selectStatuslineAccount(input);
+    const now = input.now ?? new Date();
+    const liveSegments = formatLiveSegments(input.live);
+    if (!selected)
+        return joinSegments(['acct:none', 'quota unavailable', ...liveSegments]);
+    const account = compactLabel(selected.accountLabel);
+    const quota = selected.quota;
+    if (!quota?.available) {
+        return joinSegments([`acct:${account}`, 'quota unavailable', ...liveSegments]);
+    }
+    const utilization = clampPercent(quota.fiveHour.utilization);
+    const reset = formatReset(quota.fiveHour.resetsAt, now);
+    const eta = estimateWindowEta(quota, now);
+    const segments = [`acct:${account}`, `5h ${Math.round(utilization)}% resets ${reset}`];
+    if (eta != null)
+        segments.push(`~${formatMinutes(eta)} left`);
+    if (quota.sevenDay.resetsAt && quota.sevenDay.utilization > 0) {
+        segments.push(`7d ${Math.round(clampPercent(quota.sevenDay.utilization))}%`);
+    }
+    if (quota.freshness && quota.freshness !== 'fresh') {
+        segments.push(`(${formatQuotaAge(quota.ageMs)})`);
+    }
+    return joinSegments([...segments, ...liveSegments]);
+}
+function formatLiveSegments(live) {
+    if (!live)
+        return [];
+    const segments = [];
+    const context = live.contextWindow?.usedPercentage;
+    if (typeof context === 'number')
+        segments.push(`ctx ${Math.round(clampPercent(context))}%`);
+    const cost = live.cost?.totalCostUsd;
+    if (typeof cost === 'number' && cost > 0)
+        segments.push(`$${formatCost(cost)}`);
+    const hitRatio = live.promptCache?.hitRatio;
+    if (typeof hitRatio === 'number')
+        segments.push(`cache ${Math.round(clampPercent(hitRatio * 100))}%`);
+    return segments;
+}
+function joinSegments(segments) {
+    return segments.join(' · ');
+}
+function formatCost(value) {
+    if (value >= 100)
+        return value.toFixed(0);
+    if (value >= 10)
+        return value.toFixed(1);
+    return value.toFixed(2);
+}
+function estimateWindowEta(quota, now) {
+    const resetAt = Date.parse(quota.fiveHour.resetsAt);
+    if (!Number.isFinite(resetAt))
+        return null;
+    const nowMs = now.getTime();
+    if (resetAt <= nowMs)
+        return null;
+    const capturedAt = quota.capturedAt ? Date.parse(quota.capturedAt) : now.getTime();
+    const sampleAt = Number.isFinite(capturedAt) ? capturedAt : now.getTime();
+    if (sampleAt >= resetAt)
+        return null;
+    const elapsedMinutes = (sampleAt - (resetAt - FIVE_HOUR_WINDOW_MS)) / 60_000;
+    if (elapsedMinutes <= 0 || quota.fiveHour.utilization <= 0)
+        return null;
+    const burnRate = quota.fiveHour.utilization / elapsedMinutes;
+    const eta = estimateTimeToQuota(quota.fiveHour.utilization, 100, burnRate);
+    const minutesUntilReset = (resetAt - nowMs) / 60_000;
+    return eta !== null && eta < minutesUntilReset ? eta : null;
+}
+function compactLabel(value) {
+    const trimmed = value.trim();
+    const localPart = trimmed.includes('@') ? trimmed.split('@')[0] : trimmed;
+    return localPart.replace(/\s+/g, '-').slice(0, 24) || 'unknown';
+}
+function clampPercent(value) {
+    return Number.isFinite(value) ? Math.min(100, Math.max(0, value)) : 0;
+}
+function formatReset(value, fallback) {
+    const reset = new Date(value);
+    const date = Number.isNaN(reset.getTime()) ? fallback : reset;
+    return new Intl.DateTimeFormat(undefined, {
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+    }).format(date);
+}
+function formatMinutes(value) {
+    const minutes = Math.max(0, Math.round(value));
+    if (minutes < 60)
+        return `${minutes}min`;
+    const hours = Math.floor(minutes / 60);
+    const remainder = minutes % 60;
+    return remainder ? `${hours}h${remainder}m` : `${hours}h`;
+}

package/dist/esm/statusline/index.js

@@ -0,0 +1,8 @@
+export { getActiveAccountStatus } from '../accountStatus';
+export { readQuotaSnapshot, writeQuotaSnapshot } from '../quotaSnapshots';
+export { appendQuotaHistorySample, getWorkspaceIdFromPath } from '../quotaHistory';
+export { classifyQuotaFreshness, formatQuotaAge } from '../quota';
+export { BurnRateCalculator, estimateTimeToQuota } from './BurnRateCalculator';
+export { formatStatusline, selectStatuslineAccount } from './formatter';
+export { parseClaudeStatuslinePayload, quotaFromStatuslinePayload, } from './claudeStatuslinePayload';
+export { STATE_FILE_NAME, STATE_FILE_SCHEMA_VERSION, billingBlockToStateFile, getStateFilePath, quotaToStateFile, readStateFile, writeStateFile, } from '../stateFile';

package/dist/esm/terminalSync.js

@@ -0,0 +1,95 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { atomicWriteFileSync } from './writers/atomic';
+const LAUNCHER_MARKER = '# sidekick-launcher v1';
+const LAUNCHER_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+function providerEnvVar(provider) {
+    return provider === 'claude-code' ? 'CLAUDE_CONFIG_DIR' : 'CODEX_HOME';
+}
+function providerBinary(provider) {
+    return provider === 'claude-code' ? 'claude' : 'codex';
+}
+function getLauncherDir() {
+    return path.join(os.homedir(), '.local', 'bin');
+}
+function getLauncherPath(name) {
+    return path.join(getLauncherDir(), name);
+}
+function assertValidLauncherName(name) {
+    if (!LAUNCHER_NAME_PATTERN.test(name)) {
+        throw new Error(`Invalid launcher name "${name}". Use letters, numbers, underscores, and hyphens only.`);
+    }
+}
+function isSidekickLauncher(filePath) {
+    try {
+        return fs.readFileSync(filePath, 'utf8').includes(LAUNCHER_MARKER);
+    }
+    catch {
+        return false;
+    }
+}
+function assertNoLauncherCollision(name, targetPath) {
+    if (fs.existsSync(targetPath) && !isSidekickLauncher(targetPath)) {
+        throw new Error(`Launcher "${name}" already exists and is not managed by sidekick.`);
+    }
+    for (const dir of (process.env.PATH ?? '').split(path.delimiter).filter(Boolean)) {
+        const candidate = path.join(dir, name);
+        if (path.resolve(candidate) === path.resolve(targetPath))
+            continue;
+        if (fs.existsSync(candidate)) {
+            throw new Error(`Launcher "${name}" collides with an existing command on PATH.`);
+        }
+    }
+}
+function shellSingleQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * Write a POSIX launcher script that runs the provider CLI as a saved account.
+ * The script defers to `sidekick accounts shell` at run time, which resolves
+ * the right home then: the account's profile home while it is inactive, the
+ * live home while it is the live login (a session pinned to the profile home
+ * would otherwise be a second copy of the live login). Unix only; on Windows
+ * use `sidekick accounts env --shell powershell`.
+ */
+export function writeAccountLauncher(name, provider, accountId) {
+    assertValidLauncherName(name);
+    const launcherPath = getLauncherPath(name);
+    assertNoLauncherCollision(name, launcherPath);
+    const script = [
+        '#!/bin/sh',
+        LAUNCHER_MARKER,
+        `exec sidekick accounts shell --provider ${provider} ${shellSingleQuote(accountId)} -- ${providerBinary(provider)} "$@"`,
+        '',
+    ].join('\n');
+    atomicWriteFileSync(launcherPath, script, 0o755);
+}
+/**
+ * @deprecated Pins a launcher to one profile home; when that account becomes
+ * the live login the launcher runs a second copy of it. Use
+ * {@link writeAccountLauncher}.
+ */
+export function writeLauncher(name, provider, profileHome) {
+    assertValidLauncherName(name);
+    const launcherPath = getLauncherPath(name);
+    assertNoLauncherCollision(name, launcherPath);
+    const envVar = providerEnvVar(provider);
+    const binary = providerBinary(provider);
+    const script = [
+        '#!/bin/sh',
+        LAUNCHER_MARKER,
+        `export ${envVar}=${JSON.stringify(profileHome)}`,
+        ...(provider === 'claude-code' ? ['unset CLAUDE_SECURESTORAGE_CONFIG_DIR'] : []),
+        `exec ${binary} "$@"`,
+        '',
+    ].join('\n');
+    atomicWriteFileSync(launcherPath, script, 0o755);
+}
+export function removeLauncher(name) {
+    assertValidLauncherName(name);
+    const launcherPath = getLauncherPath(name);
+    if (!isSidekickLauncher(launcherPath))
+        return;
+    fs.rmSync(launcherPath, { force: true });
+}

package/dist/esm/testing/credentialGuard.js

@@ -0,0 +1,197 @@
+/**
+ * Credential guard for test runners, published as `sidekick-shared/testing`.
+ *
+ * No test may reach the real macOS `security` binary, the real `claude` /
+ * `codex` CLIs, or the developer's real Claude, Codex, or Sidekick homes: a
+ * stray keychain write copies a live refresh token, and Claude Code rotates
+ * that token on every refresh, so a second copy is a login waiting to die.
+ *
+ * Three layers:
+ * - `HOME` (and the Windows equivalents) point at a per-process temp dir,
+ *   removed on exit, and the home overrides (`CLAUDE_CONFIG_DIR`,
+ *   `CLAUDE_SECURESTORAGE_CONFIG_DIR`, `CODEX_HOME`, `SIDEKICK_CONFIG_DIR`)
+ *   are unset, so every `os.homedir()`-derived path is isolated structurally;
+ * - the real `child_process` module object is patched, which reaches both ESM
+ *   named imports (after `syncBuiltinESMExports`) and CommonJS code loaded
+ *   through native `require`; per-file `vi.mock('child_process')` factories
+ *   replace the module and never get here;
+ * - the real `fs` module refuses writes under the real homes and records reads.
+ *
+ * Production code swallows most errors, so violations are also recorded;
+ * call `assertNoViolations()` after each test (see `credentialGuard.setup.ts`
+ * for a vitest wiring). Framework-free; the real modules come from
+ * `process.getBuiltinModule` (Node 20.16+), or `require` in CommonJS.
+ *
+ * @module testing/credentialGuard
+ */
+import * as os from 'node:os';
+import * as path from 'node:path';
+const GUARD_KEY = '__sidekickCredentialGuard';
+const DEFAULT_BLOCKED_BINARIES = ['security', 'claude', 'codex'];
+const CHILD_PROCESS_FUNCTIONS = [
+    'spawn',
+    'spawnSync',
+    'execFile',
+    'execFileSync',
+    'exec',
+    'execSync',
+];
+const FS_WRITE_FUNCTIONS = [
+    'writeFileSync',
+    'appendFileSync',
+    'mkdirSync',
+    'rmSync',
+    'rmdirSync',
+    'unlinkSync',
+    'renameSync',
+    'copyFileSync',
+    'cpSync',
+    'chmodSync',
+    'symlinkSync',
+];
+const FS_READ_FUNCTIONS = [
+    'readFileSync',
+    'existsSync',
+    'statSync',
+    'lstatSync',
+    'readdirSync',
+    'openSync',
+    'watch',
+];
+/**
+ * Installs the guard once per process and returns it; later calls return the
+ * same guard and ignore their options.
+ */
+export function installCredentialGuard(options = {}) {
+    const existing = globalThis[GUARD_KEY];
+    if (existing)
+        return existing;
+    const childProcess = builtin('node:child_process');
+    const realFs = builtin('node:fs');
+    const fs = realFs;
+    const { syncBuiltinESMExports } = builtin('node:module');
+    const blockedBinaries = new Set((options.blockedBinaries ?? DEFAULT_BLOCKED_BINARIES).map((name) => name.toLowerCase()));
+    // os.userInfo() reads the passwd entry, so it still names the real home
+    // after HOME is redirected below.
+    const realHome = os.userInfo().homedir;
+    const testHome = realFs.mkdtempSync(path.join(os.tmpdir(), 'sidekick-test-home-'));
+    const removeTestHome = realFs.rmSync.bind(realFs);
+    process.once('exit', () => {
+        try {
+            removeTestHome(testHome, { recursive: true, force: true });
+        }
+        catch {
+            /* best effort */
+        }
+    });
+    const state = {
+        realHome,
+        testHome,
+        violations: [],
+        take() {
+            return state.violations.splice(0, state.violations.length);
+        },
+        assertNoViolations() {
+            const violations = state.take();
+            if (violations.length > 0) {
+                throw new Error(`Credential guard: this test reached real credentials or homes:\n- ${violations.join('\n- ')}`);
+            }
+        },
+    };
+    process.env.HOME = testHome;
+    process.env.USERPROFILE = testHome;
+    process.env.APPDATA = path.join(testHome, 'AppData', 'Roaming');
+    process.env.LOCALAPPDATA = path.join(testHome, 'AppData', 'Local');
+    delete process.env.CLAUDE_CONFIG_DIR;
+    delete process.env.CLAUDE_SECURESTORAGE_CONFIG_DIR;
+    delete process.env.CODEX_HOME;
+    delete process.env.SIDEKICK_CONFIG_DIR;
+    const protectedRoots = path.resolve(realHome) === path.resolve(testHome)
+        ? []
+        : [
+            path.join(realHome, '.claude'),
+            path.join(realHome, '.claude.json'),
+            path.join(realHome, '.codex'),
+            path.join(realHome, '.config', 'sidekick'),
+            ...(options.protectedPaths ?? []),
+        ];
+    const isProtected = (target) => {
+        let candidate = null;
+        if (typeof target === 'string')
+            candidate = target;
+        else if (target instanceof URL && target.protocol === 'file:')
+            candidate = target.pathname;
+        if (!candidate)
+            return null;
+        const resolved = path.resolve(candidate);
+        return protectedRoots.some((root) => resolved === root || resolved.startsWith(root + path.sep))
+            ? resolved
+            : null;
+    };
+    const binaryName = (command) => {
+        if (typeof command !== 'string')
+            return '';
+        const first = command.trim().split(/\s+/)[0] ?? '';
+        return path
+            .basename(first.replace(/^["']|["']$/g, ''))
+            .replace(/\.(exe|cmd|bat)$/i, '')
+            .toLowerCase();
+    };
+    const record = (message) => {
+        state.violations.push(message);
+        throw new Error(`[credential guard] ${message}`);
+    };
+    for (const name of CHILD_PROCESS_FUNCTIONS) {
+        const original = childProcess[name];
+        if (typeof original !== 'function')
+            continue;
+        childProcess[name] = function guarded(...args) {
+            const binary = binaryName(args[0]);
+            if (blockedBinaries.has(binary)) {
+                record(`child_process.${name}('${binary}') reached the real binary; mock child_process or inject a runner`);
+            }
+            return original.apply(this, args);
+        };
+    }
+    for (const name of FS_WRITE_FUNCTIONS) {
+        const original = fs[name];
+        if (typeof original !== 'function')
+            continue;
+        fs[name] = function guarded(...args) {
+            for (const arg of args.slice(0, 2)) {
+                const hit = isProtected(arg);
+                if (hit)
+                    record(`fs.${name}(${hit}) would write inside the real home`);
+            }
+            return original.apply(this, args);
+        };
+    }
+    for (const name of FS_READ_FUNCTIONS) {
+        const original = fs[name];
+        if (typeof original !== 'function')
+            continue;
+        fs[name] = function guarded(...args) {
+            const hit = isProtected(args[0]);
+            // Reads are recorded rather than thrown so existsSync keeps its
+            // never-throws contract; the afterEach below still fails the test.
+            if (hit)
+                state.violations.push(`fs.${name}(${hit}) read the real home`);
+            return original.apply(this, args);
+        };
+    }
+    syncBuiltinESMExports();
+    globalThis[GUARD_KEY] = state;
+    return state;
+}
+/**
+ * The real module object of a Node built-in: `process.getBuiltinModule`
+ * (Node 20.16+), or `require` in CommonJS on older Node.
+ */
+function builtin(id) {
+    if (typeof process.getBuiltinModule === 'function')
+        return process.getBuiltinModule(id);
+    // eslint-disable-next-line @typescript-eslint/no-require-imports -- CommonJS fallback for Node < 20.16
+    if (typeof require === 'function')
+        return require(id);
+    throw new Error('installCredentialGuard() needs Node 20.16+ outside CommonJS.');
+}

package/dist/esm/testing/index.js

@@ -0,0 +1,12 @@
+/**
+ * Testing entry (`sidekick-shared/testing`): helpers for test suites that
+ * exercise sidekick-shared against Claude Code and Codex session data.
+ *
+ * - `installCredentialGuard()` keeps tests away from the real `security`,
+ *   `claude`, and `codex` binaries and the real Claude, Codex, and Sidekick
+ *   homes.
+ * - The session-log builders write Claude Code and Codex logs in the shapes
+ *   the readers parse.
+ */
+export { installCredentialGuard } from './credentialGuard';
+export { appendJsonl, claudeFiller, codexFiller, createSessionLogFixtures, ts, writeJsonl, } from './sessionLogFixtures';

package/dist/esm/testing/sessionLogFixtures.js

@@ -0,0 +1,128 @@
+/**
+ * Claude Code and Codex session-log builders shared by the prompt-history
+ * tests, published through `sidekick-shared/testing`.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { encodeWorkspacePath as encodeClaudeWorkspacePath } from '../parsers/sessionPathResolver';
+export function ts(second) {
+    return new Date(Date.UTC(2026, 8, 1, 10, 0, second)).toISOString();
+}
+export function writeJsonl(file, rows) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, rows.map((row) => JSON.stringify(row)).join('\n') + '\n');
+}
+export function appendJsonl(file, rows) {
+    fs.appendFileSync(file, rows.map((row) => JSON.stringify(row)).join('\n') + '\n');
+}
+/** A Claude Code line with no message: read and ignored, like progress records. */
+export function claudeFiller(bytes, second) {
+    return { type: 'system', subtype: 'filler', timestamp: ts(second), content: 'f'.repeat(bytes) };
+}
+/** A Codex line that is neither a prompt nor usage. */
+export function codexFiller(bytes, second) {
+    return {
+        timestamp: ts(second),
+        type: 'event_msg',
+        payload: { type: 'agent_message', message: 'f'.repeat(bytes) },
+    };
+}
+/** Builders that read the per-test home and repo lazily from `context`. */
+export function createSessionLogFixtures(context) {
+    let codexCounter = 0;
+    function claudeFile(workspace, sessionId) {
+        return path.join(context().home, '.claude', 'projects', encodeClaudeWorkspacePath(workspace), `${sessionId}.jsonl`);
+    }
+    function claudeUser(content, second, extra = {}) {
+        return {
+            type: 'user',
+            entrypoint: 'cli',
+            cwd: context().repo,
+            gitBranch: 'main',
+            timestamp: ts(second),
+            message: { role: 'user', content },
+            ...extra,
+        };
+    }
+    /** One Claude Code assistant record; `message` fields are merged over the defaults. */
+    function claudeAssistant(id, second, extra = {}, message = {}) {
+        return {
+            type: 'assistant',
+            entrypoint: 'cli',
+            cwd: context().repo,
+            timestamp: ts(second),
+            message: {
+                id,
+                role: 'assistant',
+                model: 'claude-opus-5',
+                content: [{ type: 'text', text: 'ok' }],
+                stop_reason: 'end_turn',
+                usage: {
+                    input_tokens: 10,
+                    output_tokens: 20,
+                    cache_read_input_tokens: 30,
+                    cache_creation_input_tokens: 40,
+                },
+                ...message,
+            },
+            ...extra,
+        };
+    }
+    function codexFile() {
+        codexCounter++;
+        const id = `019d86b0-b20c-7b02-a3b2-${String(codexCounter).padStart(12, '0')}`;
+        return path.join(context().home, '.codex', 'sessions', '2026', '09', '01', `rollout-2026-09-01T10-00-${String(codexCounter).padStart(2, '0')}-${id}.jsonl`);
+    }
+    function codexMeta(cwd, source = 'cli', extra = {}) {
+        return {
+            timestamp: ts(0),
+            type: 'session_meta',
+            payload: {
+                id: 'meta',
+                timestamp: ts(0),
+                ...(cwd !== undefined ? { cwd } : {}),
+                originator: 'codex-tui',
+                source,
+                git: { branch: 'feature/x' },
+                ...extra,
+            },
+        };
+    }
+    function codexUser(texts, second) {
+        return {
+            timestamp: ts(second),
+            type: 'response_item',
+            payload: {
+                type: 'message',
+                role: 'user',
+                content: texts.map((text) => ({ type: 'input_text', text })),
+            },
+        };
+    }
+    function codexTokenCount(second) {
+        return {
+            timestamp: ts(second),
+            type: 'event_msg',
+            payload: {
+                type: 'token_count',
+                info: {
+                    last_token_usage: {
+                        input_tokens: 100,
+                        cached_input_tokens: 60,
+                        output_tokens: 7,
+                        cache_write_input_tokens: 5,
+                    },
+                },
+            },
+        };
+    }
+    return {
+        claudeFile,
+        claudeUser,
+        claudeAssistant,
+        codexFile,
+        codexMeta,
+        codexUser,
+        codexTokenCount,
+    };
+}

package/dist/esm/tokenEstimation.js

@@ -0,0 +1,67 @@
+/** Latin/source-code characters per token in the fallback estimate. */
+export const ASCII_CHARS_PER_TOKEN = 3.5;
+const CJK = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+const EMOJI = /\p{Extended_Pictographic}/u;
+/**
+ * Estimate tokens without bundling a tokenizer.
+ *
+ * Fallback v1 counts Latin/source-code runs at 3.5 UTF-16 characters per
+ * token, CJK code points at one token, emoji at two, and other non-ASCII code
+ * points at one. The result is deliberately conservative for context budgets.
+ */
+export function estimateTextTokens(text, options = {}) {
+    if (text.length === 0) {
+        return { count: 0, method: 'sidekick-fallback-v1', confidence: 'medium', provenance: 'empty' };
+    }
+    let exact;
+    try {
+        exact = options.exactCounter?.(text, { model: options.model });
+    }
+    catch {
+        exact = undefined;
+    }
+    if (typeof exact === 'number' && Number.isFinite(exact) && exact >= 0) {
+        return {
+            count: Math.ceil(exact),
+            method: 'exact',
+            confidence: 'exact',
+            provenance: options.model ?? 'injected-counter',
+        };
+    }
+    // ASCII is never CJK or pictographic, so the leading ASCII run is counted
+    // without the per-code-point regex tests; most source text is all ASCII.
+    let firstNonAscii = 0;
+    while (firstNonAscii < text.length && text.charCodeAt(firstNonAscii) <= 127)
+        firstNonAscii++;
+    let asciiChars = firstNonAscii;
+    let conservativeTokens = 0;
+    if (firstNonAscii < text.length) {
+        for (const codePoint of text.slice(firstNonAscii)) {
+            if (EMOJI.test(codePoint))
+                conservativeTokens += 2;
+            else if (CJK.test(codePoint))
+                conservativeTokens += 1;
+            else if ((codePoint.codePointAt(0) ?? 128) <= 127)
+                asciiChars += codePoint.length;
+            else
+                conservativeTokens += 1;
+        }
+    }
+    const count = Math.ceil(asciiChars / ASCII_CHARS_PER_TOKEN) + conservativeTokens;
+    return {
+        count: Number.isFinite(count) && count >= 0 ? count : 0,
+        method: 'sidekick-fallback-v1',
+        confidence: conservativeTokens > 0 ? 'low' : 'medium',
+        provenance: 'chars-per-token-3.5+cjk1+emoji2',
+    };
+}
+export function estimateSerializedTokens(value, options = {}) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(value) ?? '';
+    }
+    catch {
+        serialized = String(value);
+    }
+    return estimateTextTokens(serialized, options);
+}