@llblab/pi-kit 0.25.0 → 0.26.0

package/node_modules/@llblab/pi-codex-usage/lib/usage.ts

@@ -0,0 +1,425 @@
+/** Domain: quota report. Owns: normalization, parsing and selection. Excludes: provider I/O and display. */
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+const SECOND_MS = 1000;
+const CODEX_USAGE_LIMIT_ID = "codex";
+type PiModel = NonNullable<ExtensionContext["model"]>;
+export type CodexUsageModel = Pick<PiModel, "id" | "name" | "provider">;
+export function isOpenAICodexModel(model: Pick<PiModel, "provider"> | undefined): boolean {
+  return model?.provider === "openai-codex";
+}
+export type UsageSource = "pi-auth" | "codex-app-server";
+export type UsageQueryError = { source: UsageSource; message: string; cause?: unknown };
+export type CodexUsageReport = {
+  snapshots: NormalizedRateLimitSnapshot[];
+  credits?: NormalizedCreditUsage;
+};
+
+export type NormalizedCreditUsage = {
+  remainingPercent: number;
+  resetAt?: number;
+};
+
+export type NormalizedRateLimitSnapshot = {
+  limitId: string;
+  primary?: NormalizedRateLimitWindow;
+  secondary?: NormalizedRateLimitWindow;
+};
+
+export type NormalizedRateLimitWindow = {
+  usedPercent: number;
+  resetAt?: number;
+};
+
+export type RateLimitStatusPayload = {
+  rate_limit?: unknown;
+  additional_rate_limits?: unknown;
+  credits?: unknown;
+  spend_control?: unknown;
+};
+
+type BackendRateLimitDetails = {
+  primary_window?: unknown;
+  secondary_window?: unknown;
+};
+
+type BackendWindowSnapshot = {
+  used_percent?: unknown;
+  reset_at?: unknown;
+  resets_at?: unknown;
+  reset_time?: unknown;
+  end_time?: unknown;
+  ends_at?: unknown;
+  expires_at?: unknown;
+  reset_after_seconds?: unknown;
+};
+
+export type AppServerRateLimitResponse = {
+  rateLimits?: unknown;
+};
+
+type AppServerRateLimitSnapshot = {
+  limitId?: unknown;
+  primary?: unknown;
+  secondary?: unknown;
+};
+
+type AppServerWindowSnapshot = {
+  usedPercent?: unknown;
+  resetAt?: unknown;
+  resetsAt?: unknown;
+  resetTime?: unknown;
+  endTime?: unknown;
+  endsAt?: unknown;
+  expiresAt?: unknown;
+  resetAfterSeconds?: unknown;
+};
+
+
+export function normalizeBackendPayload(
+  payload: RateLimitStatusPayload,
+  _capturedAt: number,
+  _source: UsageSource,
+): CodexUsageReport {
+  const snapshots: NormalizedRateLimitSnapshot[] = [];
+  const primarySnapshot = normalizeBackendSnapshot(
+    CODEX_USAGE_LIMIT_ID,
+    payload.rate_limit,
+    _capturedAt,
+  );
+  if (primarySnapshot) snapshots.push(primarySnapshot);
+
+  const credits = normalizeBackendCredits(payload, _capturedAt);
+  if (snapshots.length === 0 && !credits) {
+    throw new Error(
+      "Codex usage endpoint returned no displayable rate-limit windows or credits.",
+    );
+  }
+  return credits ? { snapshots, credits } : { snapshots };
+}
+
+function normalizeBackendCredits(
+  payload: RateLimitStatusPayload,
+  capturedAt: number,
+): NormalizedCreditUsage | undefined {
+  const spendControl = payload.spend_control as
+    | Record<string, unknown>
+    | undefined;
+  const individualLimit = spendControl?.individual_limit as
+    | Record<string, unknown>
+    | undefined;
+  const credits = payload.credits as Record<string, unknown> | undefined;
+  const limit = asNumber(individualLimit?.limit);
+  const used = asNumber(individualLimit?.used);
+  const remaining = asNumber(individualLimit?.remaining);
+  const resetAt = asResetTime(
+    [
+      individualLimit?.reset_at,
+      individualLimit?.resets_at,
+      individualLimit?.reset_time,
+      spendControl?.reset_at,
+      spendControl?.resets_at,
+      credits?.reset_at,
+      credits?.resets_at,
+    ],
+    individualLimit?.reset_after_seconds ?? spendControl?.reset_after_seconds,
+    capturedAt,
+  );
+  if (
+    limit === undefined ||
+    used === undefined ||
+    remaining === undefined ||
+    limit <= 0
+  )
+    return undefined;
+  const remainingPercent = Math.min(
+    100,
+    Math.max(0, (remaining / limit) * 100),
+  );
+  return resetAt === undefined
+    ? { remainingPercent }
+    : { remainingPercent, resetAt };
+}
+
+function normalizeBackendSnapshot(
+  limitId: string,
+  rateLimit: unknown,
+  capturedAt: number,
+): NormalizedRateLimitSnapshot | undefined {
+  if (rateLimit === null || rateLimit === undefined) return undefined;
+  const details = assertObject(
+    rateLimit,
+    "rate limit",
+  ) as BackendRateLimitDetails;
+  const primary = normalizeBackendWindow(details.primary_window, capturedAt);
+  const secondary = normalizeBackendWindow(
+    details.secondary_window,
+    capturedAt,
+  );
+  if (!primary && !secondary) return undefined;
+  return { limitId, primary, secondary };
+}
+
+function normalizeBackendWindow(
+  value: unknown,
+  capturedAt: number,
+): NormalizedRateLimitWindow | undefined {
+  if (value === null || value === undefined) return undefined;
+  const window = assertObject(
+    value,
+    "rate-limit window",
+  ) as BackendWindowSnapshot;
+  const usedPercent = asNumber(window.used_percent);
+  if (usedPercent === undefined) return undefined;
+  const resetAt = asResetTime(
+    [
+      window.reset_at,
+      window.resets_at,
+      window.reset_time,
+      window.end_time,
+      window.ends_at,
+      window.expires_at,
+    ],
+    window.reset_after_seconds,
+    capturedAt,
+  );
+  return resetAt === undefined ? { usedPercent } : { usedPercent, resetAt };
+}
+
+export function normalizeAppServerResponse(
+  response: AppServerRateLimitResponse,
+  _capturedAt: number,
+): CodexUsageReport {
+  const snapshots: NormalizedRateLimitSnapshot[] = [];
+  const addSnapshot = (raw: unknown, fallbackId: string) => {
+    const snapshot = normalizeAppServerSnapshot(raw, fallbackId, _capturedAt);
+    if (!snapshot) return;
+    const existingIndex = snapshots.findIndex(
+      (item) => item.limitId === snapshot.limitId,
+    );
+    if (existingIndex >= 0)
+      snapshots[existingIndex] = mergeSnapshot(
+        snapshots[existingIndex],
+        snapshot,
+      );
+    else snapshots.push(snapshot);
+  };
+
+  if (Array.isArray(response.rateLimits)) {
+    for (const item of response.rateLimits) addSnapshot(item, "codex");
+  } else {
+    addSnapshot(response.rateLimits, "codex");
+  }
+  if (snapshots.length === 0) {
+    throw new Error(
+      "codex app-server returned no displayable rate-limit windows.",
+    );
+  }
+
+  return { snapshots };
+}
+
+function normalizeAppServerSnapshot(
+  raw: unknown,
+  fallbackId: string,
+  capturedAt: number,
+): NormalizedRateLimitSnapshot | undefined {
+  if (raw === null || raw === undefined) return undefined;
+  const snapshot = assertObject(
+    raw,
+    "app-server rate-limit snapshot",
+  ) as AppServerRateLimitSnapshot;
+  const limitId = asString(snapshot.limitId) ?? fallbackId;
+  if (normalizedUsageKey(limitId) !== CODEX_USAGE_LIMIT_ID) return undefined;
+  const primary = normalizeAppServerWindow(snapshot.primary, capturedAt);
+  const secondary = normalizeAppServerWindow(snapshot.secondary, capturedAt);
+  if (!primary && !secondary) return undefined;
+  return { limitId, primary, secondary };
+}
+
+function normalizeAppServerWindow(
+  value: unknown,
+  capturedAt: number,
+): NormalizedRateLimitWindow | undefined {
+  if (value === null || value === undefined) return undefined;
+  const window = assertObject(
+    value,
+    "app-server rate-limit window",
+  ) as AppServerWindowSnapshot;
+  const usedPercent = asNumber(window.usedPercent);
+  if (usedPercent === undefined) return undefined;
+  const resetAt = asResetTime(
+    [
+      window.resetAt,
+      window.resetsAt,
+      window.resetTime,
+      window.endTime,
+      window.endsAt,
+      window.expiresAt,
+    ],
+    window.resetAfterSeconds,
+    capturedAt,
+  );
+  return resetAt === undefined ? { usedPercent } : { usedPercent, resetAt };
+}
+
+function mergeSnapshot(
+  left: NormalizedRateLimitSnapshot,
+  right: NormalizedRateLimitSnapshot,
+): NormalizedRateLimitSnapshot {
+  return {
+    limitId: right.limitId || left.limitId,
+    primary: right.primary ?? left.primary,
+    secondary: right.secondary ?? left.secondary,
+  };
+}
+
+
+export function isUsageUnavailable(errors: UsageQueryError[]): boolean {
+  return errors.length > 0 && errors.every(isUnavailableError);
+}
+
+function isUnavailableError(error: UsageQueryError): boolean {
+  const message = error.message.toLowerCase();
+  return (
+    message.includes("no pi openai codex subscription auth") ||
+    message.includes("no displayable rate-limit windows") ||
+    message.includes("returned no displayable rate-limit windows") ||
+    message.includes("returned 401") ||
+    message.includes("returned 403") ||
+    message.includes("unauthorized") ||
+    message.includes("forbidden") ||
+    message.includes("subscription") ||
+    message.includes("no active plan") ||
+    message.includes("plan unavailable") ||
+    message.includes("quota unavailable") ||
+    message.includes("rate limits unavailable")
+  );
+}
+
+function normalizedUsageKey(value: string | undefined): string | undefined {
+  const key = value
+    ?.toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  return key || undefined;
+}
+
+
+export function canReuseCachedReport(
+  report: CodexUsageReport,
+  model: CodexUsageModel | undefined,
+): boolean {
+  return (
+    selectActiveUsageSnapshot(report, model) !== undefined ||
+    report.credits !== undefined
+  );
+}
+
+export function isFullyAvailableReport(
+  report: CodexUsageReport,
+  model?: CodexUsageModel,
+): boolean {
+  const snapshot = selectActiveUsageSnapshot(report, model);
+  const windows = [snapshot?.primary, snapshot?.secondary].filter(
+    (window): window is NormalizedRateLimitWindow => window !== undefined,
+  );
+  return (
+    windows.length > 0 &&
+    windows.every((window) => clampPercent(window.usedPercent) === 0)
+  );
+}
+
+
+export function selectActiveUsageSnapshot(
+  report: CodexUsageReport,
+  _model: CodexUsageModel | undefined,
+): NormalizedRateLimitSnapshot | undefined {
+  return selectUsageSnapshot(report, CODEX_USAGE_LIMIT_ID);
+}
+
+export function selectUsageSnapshot(
+  report: CodexUsageReport,
+  limitId: string,
+): NormalizedRateLimitSnapshot | undefined {
+  const normalizedLimitId = normalizedUsageKey(limitId);
+  return report.snapshots.find(
+    (snapshot) => normalizedUsageKey(snapshot.limitId) === normalizedLimitId,
+  );
+}
+
+export function clampPercent(value: number): number {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(100, Math.max(0, value));
+}
+
+
+export function parseJsonObject(
+  text: string,
+  description: string,
+): Record<string, unknown> {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text) as unknown;
+  } catch (error) {
+    throw new Error(
+      `${description} was not valid JSON: ${errorMessage(error)}`,
+    );
+  }
+  return assertObject(parsed, description);
+}
+
+export function assertObject(
+  value: unknown,
+  description: string,
+): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${description} was not an object.`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function asString(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
+function asNumber(value: unknown): number | undefined {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+  return undefined;
+}
+
+function asResetTime(
+  absoluteValues: unknown[],
+  relativeSeconds: unknown,
+  capturedAt: number,
+): number | undefined {
+  for (const value of absoluteValues) {
+    const timestamp = asTimestampMs(value);
+    if (timestamp !== undefined) return timestamp;
+  }
+  const seconds = asNumber(relativeSeconds);
+  if (seconds === undefined || seconds < 0) return undefined;
+  return capturedAt + seconds * SECOND_MS;
+}
+
+function asTimestampMs(value: unknown): number | undefined {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    if (value <= 0) return undefined;
+    return value < 10_000_000_000 ? value * SECOND_MS : value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return asTimestampMs(numeric);
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+  return undefined;
+}
+
+
+export function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/node_modules/@llblab/pi-codex-usage/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@llblab/pi-codex-usage",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "private": false,
-  "description": "Minimal Pi extension that shows primary Codex ChatGPT subscription usage limits",
+  "description": "Pi extension for Codex subscription usage and an optional Fast toggle",
   "keywords": [
     "pi-package",
     "pi-extension",
@@ -26,7 +26,7 @@
   },
   "scripts": {
     "check": "node --experimental-strip-types -e \"await import('./index.ts'); console.log('pi-codex-usage: extension import ok')\"",
-    "test": "node --experimental-strip-types --test test/*.test.ts",
+    "test": "node --experimental-strip-types --test tests/*.test.ts",
     "typecheck": "tsc --noEmit",
     "audit": "npm audit --omit=peer",
     "pack:dry": "npm pack --dry-run",
@@ -34,6 +34,7 @@
   },
   "files": [
     "index.ts",
+    "lib/",
     "README.md",
     "AGENTS.md",
     "BACKLOG.md",
@@ -48,13 +49,17 @@
     "image": "https://github.com/llblab/pi-codex-usage/raw/main/banner.jpg"
   },
   "peerDependencies": {
-    "@earendil-works/pi-agent-core": "*",
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-agent-core": ">=1.0.0",
+    "@earendil-works/pi-ai": ">=1.0.0",
+    "@earendil-works/pi-coding-agent": ">=1.0.0",
     "@sinclair/typebox": "*"
   },
   "devDependencies": {
     "@types/node": "latest",
+    "jsonc-parser": "^3.3.1",
     "typescript": "latest"
+  },
+  "dependencies": {
+    "@llblab/pi-command-fast": "^0.1.0"
   }
 }

package/node_modules/@llblab/pi-command-fast/AGENTS.md

@@ -0,0 +1,7 @@
+# Agent Notes
+
+- `Pi baseline`: All declared Pi peers require ≥1.0.0; keep lockfile identity aligned and verify packed consumers offline. Do not claim compatibility with earlier hosts.
+- `Library only`: No Pi extension factory, Pi resource metadata, provider semantics, model IDs, status, auth, or background work.
+- `Command ownership`: Register from session_start; release on session_shutdown. A process-global versioned Symbol owns only a WeakMap of sessionManager identities, never current-provider or Fast state.
+- `Model state`: models.json is authoritative. Enabled is exact configured value; OFF deletes the property. Always re-read; preserve user JSONC and unrelated data; use atomic replacement without quota mutexes.
+- `Domain DAG`: index is exports only; command and models-json are independent owners. Tests mirror domain names. Pack ESM and declarations; test physically separate copies.

package/node_modules/@llblab/pi-command-fast/BACKLOG.md

@@ -0,0 +1,9 @@
+# Backlog
+
+## Concurrent validation gate
+
+- Telegram's feature owner must rebuild and validate its current tree after parallel edits settle. Pi 1.0.0 compatibility passed for a consistent isolated source snapshot (`8b92be0f6679c6c1deb86d32f4a9a66cd42a1defbab2d05710845c2191601da7`); later journal edits are not covered by that evidence. This is not a request to take over unrelated Telegram feature work, reconnect transport, or reload the operator session.
+
+## Release gate
+
+- Publish 0.1.0 before dependent usage releases, only with explicit authorization; consumers currently use local `file:` dependencies for tests. Before their publication, restore registry `^0.1.0` dependencies and regenerate/validate registry locks and packed artifacts.

package/node_modules/@llblab/pi-command-fast/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## 0.1.0 (unreleased)
+
+- Requires Pi ≥1.0.0 for a consistent host baseline across the library and usage consumers.
+- Added session-scoped provider registration for exactly one argument-free `/fast`, including duplicate installed library copies and shutdown/reload reset.
+- Added generic per-model JSONC override reads and atomic toggles using Pi's canonical models.json path. No provider request logic or Pi extension entrypoint.

package/node_modules/@llblab/pi-command-fast/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 llblab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@llblab/pi-command-fast/README.md

@@ -0,0 +1,42 @@
+# pi-command-fast
+
+`@llblab/pi-command-fast` is a shared library for coordinating one `/fast` command across multiple Pi extensions. **It is not a Pi extension and should not be installed as one.**
+
+Register provider-level handlers; keep model capability checks inside the owning consumer, not this command registry. Consumers define Fast semantics and eligibility; each model owns its persisted override in Pi's `models.json`. The library itself has no model-ID allowlists, status, auth, provider transport, timers or separate config.
+
+```ts
+import { registerFastProvider, toggleModelOverrideValue } from "@llblab/pi-command-fast";
+
+let release: (() => void) | undefined;
+pi.on("session_start", (_event, ctx) => {
+  release = registerFastProvider(pi, ctx, {
+    provider: "my-provider",
+    toggle(commandCtx) {
+      toggleModelOverrideValue({
+        provider: commandCtx.model!.provider,
+        id: commandCtx.model!.id,
+        property: "providerNativeField",
+        enabledValue: "providerNativeValue",
+      });
+      redrawExistingUsageStatus(commandCtx); // Consumer-owned, no quota request.
+    },
+  });
+});
+pi.on("session_shutdown", () => { release?.(); release = undefined; });
+```
+
+Public API: `registerFastProvider`, `modelsJsonPath`, `isModelOverrideValue`, `toggleModelOverrideValue`. OFF deletes only the property. Reads fail closed; writes report concrete errors. Edits preserve JSONC, BOM, unrelated fields and object order, re-read before toggling, and replace via a sibling temporary file/atomic rename. This is corruption protection, not cross-process transaction isolation.
+
+Duplicate installed library copies discover a versioned `Symbol.for` WeakMap keyed by `ctx.sessionManager`. Invocation resolves the current session and provider, independent of load order. Release all registrations on shutdown: Pi reload keeps the session manager but replaces command maps. Late releases cannot delete a fresh registry. The command handler never captures a current model or Fast boolean.
+
+Requires Node ≥22.19.0 and Pi ≥1.0.0, with dynamic command registration. Pi 1.0.0 has no public unregister/conditional-visibility API: `/fast` stays listed while consumers are loaded and rejects unrelated providers. It is registered during session_start; Pi builds interactive autocomplete after extension binding. `npm run validate` builds ESM/declarations, tests duplicate-copy/session/config behavior, checks import, audit and package contents.
+
+Packed-consumer integration in an actual Pi host (offline, synthetic credentials, no paid requests):
+
+```bash
+npm run test:pi -- /path/to/pi-coding-agent fast.tgz codex-usage.tgz claude-usage.tgz
+```
+
+This extracts both consumers, installs the packed library into separate physical dependency directories, and exercises single/dual load order, dispatch, arbitrary Codex model IDs and supported/rejected Claude model eligibility, session isolation, reload, restart, statuses and native HTTP assembly. All fetches are intercepted before network access; it does not prove provider-side Fast availability or real terminal rendering. The HTTP inspection needs Node ≥22.15 for zstd decompression when Pi compresses a request.
+
+[Agent Notes](./AGENTS.md) · [Backlog](./BACKLOG.md) · [Changelog](./CHANGELOG.md)

package/node_modules/@llblab/pi-command-fast/dist/command.d.ts

@@ -0,0 +1,8 @@
+/** Domain: Fast command. Owns: session-scoped provider dispatch. Excludes: UI status, auth and persisted Fast values. */
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+export interface FastProviderRegistration {
+    provider: string;
+    toggle(ctx: ExtensionCommandContext): Promise<void> | void;
+}
+/** Call from session_start; call the returned release function from session_shutdown. */
+export declare function registerFastProvider(pi: ExtensionAPI, ctx: ExtensionContext, registration: FastProviderRegistration): () => void;

package/node_modules/@llblab/pi-command-fast/dist/command.js

@@ -0,0 +1,52 @@
+const KEY = Symbol.for("@llblab/pi-command-fast/registry/v1");
+const globals = globalThis;
+const registries = globals[KEY] ??= new WeakMap();
+/** Call from session_start; call the returned release function from session_shutdown. */
+export function registerFastProvider(pi, ctx, registration) {
+    const session = ctx.sessionManager;
+    let registry = registries.get(session);
+    if (!registry) {
+        registry = { providers: new Map() };
+        registries.set(session, registry);
+        try {
+            pi.registerCommand("fast", {
+                description: "Toggle Fast mode for the current provider/model",
+                getArgumentCompletions: () => null,
+                handler: async (args, invocation) => {
+                    if (args.trim()) {
+                        invocation.ui.notify("Usage: /fast", "warning");
+                        return;
+                    }
+                    const provider = invocation.model?.provider;
+                    const handler = provider && registries.get(invocation.sessionManager)?.providers.get(provider);
+                    if (!handler) {
+                        invocation.ui.notify("Fast mode is not supported for the current provider", "warning");
+                        return;
+                    }
+                    try {
+                        await handler.toggle(invocation);
+                    }
+                    catch (error) {
+                        invocation.ui.notify(error instanceof Error ? error.message : String(error), "error");
+                    }
+                },
+            });
+        }
+        catch (error) {
+            registries.delete(session);
+            throw error;
+        }
+    }
+    if (registry.providers.has(registration.provider))
+        throw new Error(`Fast provider already registered: ${registration.provider}`);
+    registry.providers.set(registration.provider, registration);
+    const owned = registry;
+    return () => {
+        if (registries.get(session) !== owned || owned.providers.get(registration.provider) !== registration)
+            return;
+        owned.providers.delete(registration.provider);
+        // Reload retains the sessionManager, but destroys all commands: reset after last release.
+        if (owned.providers.size === 0)
+            registries.delete(session);
+    };
+}

package/node_modules/@llblab/pi-command-fast/dist/index.d.ts

@@ -0,0 +1,3 @@
+/** Domain: public contract. Owns: library exports. Excludes: Pi extension entrypoint. */
+export { registerFastProvider, type FastProviderRegistration } from "./command.js";
+export { modelsJsonPath, isModelOverrideValue, toggleModelOverrideValue, type ModelOverrideTarget } from "./models-json.js";

package/node_modules/@llblab/pi-command-fast/dist/index.js

@@ -0,0 +1,3 @@
+/** Domain: public contract. Owns: library exports. Excludes: Pi extension entrypoint. */
+export { registerFastProvider } from "./command.js";
+export { modelsJsonPath, isModelOverrideValue, toggleModelOverrideValue } from "./models-json.js";

package/node_modules/@llblab/pi-command-fast/dist/models-json.d.ts

@@ -0,0 +1,10 @@
+export interface ModelOverrideTarget {
+    provider: string;
+    id: string;
+    property: string;
+    enabledValue: string;
+}
+export declare function modelsJsonPath(): string;
+export declare function isModelOverrideValue(target: ModelOverrideTarget, path?: string): boolean;
+/** Re-read at every toggle; OFF is property absence, never a sentinel value. */
+export declare function toggleModelOverrideValue(target: ModelOverrideTarget, path?: string): boolean;