@wolfx/opencode-magic-context 0.28.0 → 0.30.1

package/src/shared/exit-abort-registry.ts

@@ -0,0 +1,46 @@
+/**
+ * Process-global registry of AbortControllers to abort on process exit, backed
+ * by a SINGLE `process.once("exit")` listener no matter how many controllers
+ * register.
+ *
+ * Why this exists: the plugin factory runs once per plugin instance, and
+ * OpenCode Desktop loads many instances in one Node process (one per open
+ * project). Registering a `process.once("exit")` per instance added one listener
+ * each, so past Node's default 10-listener cap it logged a
+ * `MaxListenersExceededWarning` ("11 exit listeners added to [process]"). One
+ * module-global listener that fans out to every registered controller keeps the
+ * count at one.
+ */
+
+const controllers = new Set<AbortController>();
+let listenerRegistered = false;
+
+function abortAll(): void {
+    for (const controller of controllers) {
+        try {
+            controller.abort();
+        } catch {
+            // best-effort: the process is exiting anyway
+        }
+    }
+}
+
+/**
+ * Abort `controller` when the process exits. The underlying `process.once("exit")`
+ * listener is installed on the first call only; subsequent calls just add to the
+ * fan-out set.
+ */
+export function registerExitAbort(controller: AbortController): void {
+    controllers.add(controller);
+    if (listenerRegistered) return;
+    listenerRegistered = true;
+    process.once("exit", abortAll);
+}
+
+/**
+ * Stop tracking `controller` (e.g. when its plugin instance is disposed) so the
+ * set doesn't grow without bound as Desktop opens and closes projects.
+ */
+export function unregisterExitAbort(controller: AbortController): void {
+    controllers.delete(controller);
+}

package/src/shared/harness-provider-map.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "bun:test";
+import { piModelRefToCanonical, resolveModelRefForPi } from "./harness-provider-map";
+
+describe("harness-provider-map", () => {
+    describe("resolveModelRefForPi (canonical -> Pi, used when spawning)", () => {
+        it("maps the diverging auth-plugin providers, preserving the model id", () => {
+            expect(resolveModelRefForPi("openai/gpt-5.5")).toBe("openai-codex/gpt-5.5");
+            expect(resolveModelRefForPi("google/antigravity-gemini-3.5-flash")).toBe(
+                "google-antigravity/antigravity-gemini-3.5-flash",
+            );
+        });
+
+        it("leaves anthropic and every other provider unchanged", () => {
+            expect(resolveModelRefForPi("anthropic/claude-opus-4-8")).toBe(
+                "anthropic/claude-opus-4-8",
+            );
+            expect(resolveModelRefForPi("cerebras/gpt-oss-120b")).toBe("cerebras/gpt-oss-120b");
+            expect(resolveModelRefForPi("openrouter/openai/gpt-5.5")).toBe(
+                "openrouter/openai/gpt-5.5",
+            );
+        });
+
+        it("is idempotent: a config already in Pi form still resolves to Pi form", () => {
+            expect(resolveModelRefForPi("openai-codex/gpt-5.5")).toBe("openai-codex/gpt-5.5");
+            expect(resolveModelRefForPi("google-antigravity/antigravity-gemini-3.1-pro")).toBe(
+                "google-antigravity/antigravity-gemini-3.1-pro",
+            );
+        });
+
+        it("preserves model ids that themselves contain slashes", () => {
+            expect(resolveModelRefForPi("openai/some/nested/id")).toBe(
+                "openai-codex/some/nested/id",
+            );
+        });
+
+        it("passes through malformed refs (no slash, empty provider) unchanged", () => {
+            expect(resolveModelRefForPi("gpt-5.5")).toBe("gpt-5.5");
+            expect(resolveModelRefForPi("/gpt-5.5")).toBe("/gpt-5.5");
+            expect(resolveModelRefForPi("")).toBe("");
+        });
+    });
+
+    describe("piModelRefToCanonical (Pi -> canonical, used by Pi setup write)", () => {
+        it("normalizes Pi-native provider ids to the OpenCode form", () => {
+            expect(piModelRefToCanonical("openai-codex/gpt-5.5")).toBe("openai/gpt-5.5");
+            expect(piModelRefToCanonical("google-antigravity/antigravity-gemini-3.5-flash")).toBe(
+                "google/antigravity-gemini-3.5-flash",
+            );
+        });
+
+        it("leaves already-canonical and unmapped providers unchanged", () => {
+            expect(piModelRefToCanonical("anthropic/claude-opus-4-8")).toBe(
+                "anthropic/claude-opus-4-8",
+            );
+            expect(piModelRefToCanonical("openai/gpt-5.5")).toBe("openai/gpt-5.5");
+        });
+
+        it("round-trips with resolveModelRefForPi", () => {
+            const piForm = "openai-codex/gpt-5.5";
+            expect(resolveModelRefForPi(piModelRefToCanonical(piForm))).toBe(piForm);
+        });
+    });
+});

package/src/shared/harness-provider-map.ts

@@ -0,0 +1,56 @@
+/**
+ * Provider-id translation between the canonical (OpenCode) form stored in the
+ * shared magic-context config and Pi's harness-native provider ids.
+ *
+ * OpenCode and Pi now share ONE config, but a few auth-plugin providers were
+ * named differently on each side. The model id AFTER the slash is identical;
+ * only the provider prefix differs:
+ *
+ *   canonical (OpenCode)   Pi
+ *   --------------------   -------------------
+ *   openai/<model>         openai-codex/<model>
+ *   google/<model>         google-antigravity/<model>
+ *   anthropic/<model>      anthropic/<model>      (same; every other provider too)
+ *
+ * Canonical = OpenCode: the config always stores the OpenCode form. Pi
+ * translates at its edges:
+ *   - read:  canonical -> Pi when spawning a configured model (subagent-runner).
+ *   - write: Pi -> canonical in the Pi setup wizard, so a config written from
+ *            the Pi side stays readable by OpenCode.
+ *
+ * OpenCode needs no translation (canonical IS the OpenCode form).
+ */
+
+const CANONICAL_TO_PI_PROVIDER: Record<string, string> = {
+    openai: "openai-codex",
+    google: "google-antigravity",
+};
+
+const PI_TO_CANONICAL_PROVIDER: Record<string, string> = {
+    "openai-codex": "openai",
+    "google-antigravity": "google",
+};
+
+/** Remap only the provider prefix (text before the first "/"), preserving the
+ *  model id verbatim. No "/", empty provider, or unmapped provider -> unchanged. */
+function remapProviderPrefix(ref: string, map: Record<string, string>): string {
+    if (typeof ref !== "string") return ref;
+    const slash = ref.indexOf("/");
+    if (slash <= 0) return ref;
+    const provider = ref.slice(0, slash);
+    const mapped = map[provider];
+    return mapped ? `${mapped}${ref.slice(slash)}` : ref;
+}
+
+/** Pi-native `provider/model` -> canonical (OpenCode). Identity when unmapped.
+ *  Used by the Pi setup wizard so configs it writes stay OpenCode-readable. */
+export function piModelRefToCanonical(ref: string): string {
+    return remapProviderPrefix(ref, PI_TO_CANONICAL_PROVIDER);
+}
+
+/** Canonical (OpenCode) `provider/model` -> Pi-native, for spawning a model on
+ *  Pi. Idempotent: normalizes any Pi-form prefix back to canonical first, so it
+ *  is safe on a config that already holds Pi-form ids (hand-edited or pre-fix). */
+export function resolveModelRefForPi(ref: string): string {
+    return remapProviderPrefix(piModelRefToCanonical(ref), CANONICAL_TO_PI_PROVIDER);
+}

package/src/shared/tag-transcript.ts

@@ -54,6 +54,7 @@ import {
     updateTagTokenCount,
 } from "../features/magic-context/storage-tags";
 import { makeToolCompositeKey, type Tagger } from "../features/magic-context/tagger";
+import { applyEditMarkerToInput } from "../hooks/magic-context/edit-marker";
 import { estimateImageTokensFromDataUrl } from "../hooks/magic-context/image-token-estimate";
 import { estimateTokens } from "../hooks/magic-context/read-session-formatting";
 import {
@@ -692,6 +693,28 @@ function buildAggregateTarget(tagId: number, occurrences: ToolOccurrence[]): Tag
             }
             return any ? "truncated" : "absent";
         },
+        editMarker(): "truncated" | "absent" {
+            // Edit-marker: preserve the tool_use input's filePath + a region
+            // hint of the diff, sentinelize the result half. Separate from
+            // truncate() so the existing skeleton bytes are never touched.
+            // Deterministic + idempotent (re-derived from source each pass; the
+            // region-hint clamp self-guards via ...[truncated]).
+            const sentinel = `[dropped \u00a7${tagId}\u00a7]`;
+            let any = false;
+            for (const occ of occurrences) {
+                if (occ.kind === "tool_use") {
+                    const input = occ.part.getToolInput?.();
+                    if (input) {
+                        const next = { ...input };
+                        applyEditMarkerToInput(next);
+                        if (occ.part.setToolInput?.(next)) any = true;
+                    }
+                } else if (setToolContentOrText(occ.part, sentinel)) {
+                    any = true;
+                }
+            }
+            return any ? "truncated" : "absent";
+        },
         // Non-mutating reclaim predicate (Pi parity with OpenCode's canDrop).
         // Pi sentinelizes BOTH halves, so unlike OpenCode there's no
         // result-part requirement — a target reclaims as long as it still has
@@ -699,6 +722,15 @@ function buildAggregateTarget(tagId: number, occurrences: ToolOccurrence[]): Tag
         canDrop(): boolean {
             return occurrences.length > 0;
         },
+        // Non-mutating read of the invocation input (the tool_use occurrence
+        // carries the arguments). Used by smart-drops supersession selection.
+        readInput(): Record<string, unknown> | null {
+            for (const occ of occurrences) {
+                const input = occ.part.getToolInput?.();
+                if (input) return input;
+            }
+            return null;
+        },
         message: {
             info: { id: messageId, role },
             parts: [],

package/src/shared/transcript-opencode.ts

@@ -137,6 +137,12 @@ function createOpenCodePart(
         } {
             return readOpenCodeToolMetadata(rawPart);
         },
+        getToolInput(): Record<string, unknown> | null {
+            return readOpenCodeToolInput(rawPart);
+        },
+        setToolInput(input: Record<string, unknown>): boolean {
+            return writeOpenCodeToolInput(rawPart, input);
+        },
         replaceWithSentinel(sentinelText: string): boolean {
             // Build a synthetic text part that carries the sentinel as
             // its content. Subsequent passes see this as a normal text
@@ -267,3 +273,30 @@ function readOpenCodeToolMetadata(part: unknown): {
 
     return { toolName, inputByteSize, inputTokenCount };
 }
+
+/** Non-mutating read of an OpenCode tool part's input object (or null). */
+function readOpenCodeToolInput(part: unknown): Record<string, unknown> | null {
+    if (!isRecord(part)) return null;
+    const state = isRecord(part.state) ? part.state : null;
+    const input = state?.input ?? part.args ?? part.input;
+    return isRecord(input) ? input : null;
+}
+
+/** Replace an OpenCode tool part's input object in place. Returns true if a
+ *  writable input slot was found. */
+function writeOpenCodeToolInput(part: unknown, input: Record<string, unknown>): boolean {
+    if (!isRecord(part)) return false;
+    if (isRecord(part.state) && isRecord(part.state.input)) {
+        part.state.input = input;
+        return true;
+    }
+    if (isRecord(part.args)) {
+        part.args = input;
+        return true;
+    }
+    if (isRecord(part.input)) {
+        part.input = input;
+        return true;
+    }
+    return false;
+}

package/src/shared/transcript.ts

@@ -133,6 +133,23 @@ export interface TranscriptPart {
         inputTokenCount: number;
     };
 
+    /**
+     * Non-mutating read of this tool invocation's input object, or null for
+     * non-tool parts / parts without an input. Used by smart-drops supersession
+     * selection (read `ctx_note`'s action, an edit's `filePath`) without
+     * touching the wire. Returns the live object reference; callers must NOT
+     * mutate it.
+     */
+    getToolInput?(): Record<string, unknown> | null;
+
+    /**
+     * Replace this tool invocation's input object with `input`. Used by the
+     * smart-drops edit_marker path to write back a filePath-preserving,
+     * region-hint-clamped copy of an edit's arguments. Returns true if the part
+     * carried a writable tool input. No-op (false) for non-tool parts.
+     */
+    setToolInput?(input: Record<string, unknown>): boolean;
+
     /**
      * Replace this part with a sentinel placeholder. Sentinels look like
      * `[dropped §N§]` or `[truncated §N§]` and survive cache-busting

package/src/tui/badge-contrast.test.ts

@@ -1,5 +1,43 @@
 import { describe, expect, test } from "bun:test";
-import { readableTextColorOn } from "./badge-contrast";
+import { badgeTextColor, readableTextColorOn } from "./badge-contrast";
+
+describe("badgeTextColor (AFT parity with #186 safety net)", () => {
+    // A purple/lavender accent on a dark theme: the badge label should be the
+    // theme background (the inverse-of-panel look), the same fixed token the AFT
+    // sidebar uses, so two sibling badges never disagree on the same accent.
+    const accent = { r: 0.6, g: 0.5, b: 0.9, a: 1 };
+
+    test("opaque distinct background is used verbatim as the label", () => {
+        const background = { r: 0.05, g: 0.05, b: 0.07, a: 1 }; // near-black dark theme
+        // Returns the SAME background token rather than a computed color.
+        expect(badgeTextColor(accent, background)).toBe(background);
+    });
+
+    test("light theme: background is used verbatim too (near-white label inverse)", () => {
+        const background = { r: 0.97, g: 0.97, b: 0.95, a: 1 };
+        expect(badgeTextColor(accent, background)).toBe(background);
+    });
+
+    test("transparent background (alpha 0) falls back to a visible pick (#186)", () => {
+        // background:"none" resolves to RGBA(0,0,0,0); using it as text would
+        // render the label invisible, so fall back to a contrast pick on accent.
+        const transparent = { r: 0, g: 0, b: 0, a: 0 };
+        const result = badgeTextColor(accent, transparent);
+        expect(result).not.toBe(transparent);
+        expect(result).toBe(readableTextColorOn(accent));
+    });
+
+    test("background ~= accent falls back to a visible pick", () => {
+        const sameAsAccent = { r: 0.6, g: 0.5, b: 0.9, a: 1 };
+        const result = badgeTextColor(accent, sameAsAccent);
+        expect(result).toBe(readableTextColorOn(accent));
+    });
+
+    test("missing alpha is treated as opaque", () => {
+        const background = { r: 0.05, g: 0.05, b: 0.07 };
+        expect(badgeTextColor(accent, background)).toBe(background);
+    });
+});
 
 describe("readableTextColorOn", () => {
     test("dark accent gets white text", () => {

package/src/tui/badge-contrast.ts

@@ -1,39 +1,52 @@
 /**
- * Pick a readable text color (black or white) for text drawn ON TOP of a given
- * background color.
+ * Pick the text color for the sidebar header badge (a bold label drawn on a
+ * `theme.accent` background).
  *
- * The sidebar header badge previously drew its label with `fg={theme.background}`
- * on a `theme.accent` background. That breaks for themes that set
- * `background: "none"` (transparent) to respect terminal transparency: the
- * resolved background is `RGBA(0,0,0,0)`, so the badge text renders fully
- * transparent and disappears (issue #186). The badge background (`accent`) is
- * always opaque, so deriving the text color from it is transparency-proof.
+ * Primary rule (matches AFT's sidebar by construction): paint the theme's own
+ * `background` color as the label, the inverse-of-panel look. Because it is a
+ * fixed theme token rather than an accent-derived computation, MC's badge and
+ * AFT's badge agree on EVERY accent automatically, so the same theme can never
+ * make one badge black and the other white (issue #198).
  *
- * The pick is WHITE-BIASED off the accent's relative luminance: white for any
- * accent in the dark half (luminance < 0.5), black only for genuinely light
- * accents. A strict "higher-contrast-wins" pick (crossover at luminance 0.179)
- * flips ordinary mid-tone accents to black: a typical orange/amber sidebar
- * accent (luminance ~0.3) reads black ~5:1 vs white ~3.7:1, so contrast-wins
- * picks black even though white at ~3.7:1 is perfectly legible for a short bold
- * label. That looks heavy and clashes with the sibling status badges, so we
- * prefer white across the whole dark half and only fall to black once the accent
- * is actually light (pale/pastel/near-white), where white would be unreadable.
+ * Fallback rule (the reason a luminance pick exists at all): `theme.background`
+ * can be unusable as a label color in two degenerate cases, where it would
+ * render the label invisible on the accent:
+ *   1. Transparent background. Themes that respect terminal transparency set
+ *      `background: "none"`, which resolves to `RGBA(0,0,0,0)`; drawing it as
+ *      text renders fully transparent and the label disappears (issue #186).
+ *   2. Background ~= accent. If the theme's background and accent are nearly the
+ *      same color, background-on-accent text has no contrast.
+ * In either case we fall back to a black/white pick that is guaranteed visible
+ * on the always-opaque accent.
  *
- * `RGBA` channels from @opentui/core are normalized 0..1 floats. We accept the
- * minimal `{ r, g, b }` shape so this stays a pure, trivially testable function
- * independent of the native color class.
+ * `RGBA` channels from @opentui/core are normalized 0..1 floats (alpha included).
+ * We accept the minimal `{ r, g, b, a? }` shape so this stays a pure, trivially
+ * testable function independent of the native color class, and we return the
+ * passed-in `background` object unchanged on the primary path so it stays the
+ * exact same theme token AFT uses.
  */
 
-// Luminance midpoint: accents below this keep white text, accents at/above it
-// (light/pastel/near-white) get black. White-biased relative to the strict
-// equal-contrast crossover (~0.179) so saturated mid-tone accents stay white.
+type Color = { r: number; g: number; b: number; a?: number };
+
+// Below this alpha the theme background is too transparent to read as a label on
+// the accent (issue #186: background:"none" resolves to alpha 0).
+const MIN_OPAQUE_ALPHA = 0.5;
+
+// If the theme background and accent are within this per-channel distance they
+// are effectively the same color, so background-on-accent text is unreadable.
+const MIN_CHANNEL_DISTANCE = 0.06;
+
+// Luminance midpoint for the fallback pick: accents below this keep white text,
+// accents at/above it (light/pastel/near-white) get black. White-biased relative
+// to the strict equal-contrast crossover (~0.179) so saturated mid-tone accents
+// stay white. Only consulted on the degenerate fallback path.
 const LIGHT_ACCENT_LUMINANCE = 0.5;
 
 function srgbChannelToLinear(c: number): number {
     return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
 }
 
-function relativeLuminance(bg: { r: number; g: number; b: number }): number {
+function relativeLuminance(bg: Color): number {
     return (
         0.2126 * srgbChannelToLinear(bg.r) +
         0.7152 * srgbChannelToLinear(bg.g) +
@@ -41,6 +54,31 @@ function relativeLuminance(bg: { r: number; g: number; b: number }): number {
     );
 }
 
-export function readableTextColorOn(bg: { r: number; g: number; b: number }): string {
+function nearlyEqual(a: Color, b: Color): boolean {
+    return (
+        Math.abs(a.r - b.r) < MIN_CHANNEL_DISTANCE &&
+        Math.abs(a.g - b.g) < MIN_CHANNEL_DISTANCE &&
+        Math.abs(a.b - b.b) < MIN_CHANNEL_DISTANCE
+    );
+}
+
+/**
+ * Pure black/white pick by accent luminance. Used as the badge fallback and kept
+ * exported for callers that only have the accent.
+ */
+export function readableTextColorOn(bg: Color): string {
     return relativeLuminance(bg) < LIGHT_ACCENT_LUMINANCE ? "#ffffff" : "#000000";
 }
+
+/**
+ * Badge label color on the accent: the theme background (AFT parity) when it is
+ * usable, else a guaranteed-visible black/white fallback. Returns the passed-in
+ * `background` reference unchanged on the primary path.
+ */
+export function badgeTextColor<T extends Color>(accent: T, background: T): T | string {
+    const alpha = background.a ?? 1;
+    if (alpha >= MIN_OPAQUE_ALPHA && !nearlyEqual(accent, background)) {
+        return background;
+    }
+    return readableTextColorOn(accent);
+}

package/src/tui/slots/sidebar-content.tsx

@@ -2,7 +2,7 @@
 import { Show, createEffect, createMemo, createSignal, on, onCleanup } from "solid-js"
 import type { TuiSlotPlugin, TuiPluginApi, TuiThemeCurrent } from "@opencode-ai/plugin/tui"
 import packageJson from "../../../package.json"
-import { readableTextColorOn } from '../badge-contrast';
+import { badgeTextColor } from '../badge-contrast';
 import { loadSidebarSnapshot, type SidebarSnapshot } from "../data/context-db"
 import { formatThresholdPercent } from "../../shared/format-threshold"
 import {
@@ -693,7 +693,7 @@ const SidebarContent = (props: {
                 onMouseDown={() => props.controller.toggleCollapsed()}
             >
                 <box paddingLeft={1} paddingRight={1} backgroundColor={props.theme.accent}>
-                    <text fg={readableTextColorOn(props.theme.accent)}>
+                    <text fg={badgeTextColor(props.theme.accent, props.theme.background)}>
                         <b>{collapsed() ? "▶ " : "▼ "}{headerLabel()}</b>
                     </text>
                 </box>

package/dist/hooks/is-anthropic-provider.d.ts

@@ -1,2 +0,0 @@
-export declare function isAnthropicProvider(providerID: string): boolean;
-//# sourceMappingURL=is-anthropic-provider.d.ts.map

package/dist/hooks/is-anthropic-provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-anthropic-provider.d.ts","sourceRoot":"","sources":["../../src/hooks/is-anthropic-provider.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAE/D"}

package/dist/shared/live-server-client.d.ts

@@ -1,50 +0,0 @@
-/**
- * Live-server client for the Channel 2 ctx_reduce ceiling nudge (a synthetic
- * user `<system-reminder>` delivered via `promptAsync`).
- *
- * WHY a separate client instead of the plugin-provided `input.client`:
- * OpenCode's plugin `input.client` routes through `Server.Default().app.fetch`,
- * which uses a SEPARATE Effect `memoMap` from the live HTTP listener the UI
- * uses. `SessionRunState` lives per-memoMap, so a plugin-origin `promptAsync`
- * observes an "idle" runner while the live turn is still running, `ensureRunning`
- * fails to coalesce, and OpenCode persists duplicate assistant children
- * (upstream bug anomalyco/opencode#28202). Building a `createOpencodeClient`
- * aimed at `input.serverUrl` via `globalThis.fetch` enters the SAME live
- * listener, so `ensureRunning` sees the real run and coalesces — the synthetic
- * message lands at the tail after the current assistant step.
- *
- * The live listener is only reachable on OpenCode Desktop (Electron+Node) and
- * TUI launched with `--port 0`; plain TUI binds an internal listener that 404s
- * `/session/*`. We probe once at init and cache per `serverUrl`. When
- * unreachable, Channel 2 is DISABLED (Channel 1 + 85% force-materialization
- * remain the backstop) — MC deliberately does NOT fall back to the in-process
- * client because that would knowingly trigger #28202.
- */
-import { createOpencodeClient } from "@opencode-ai/sdk";
-export type LiveServerClient = ReturnType<typeof createOpencodeClient>;
-/**
- * Cached `createOpencodeClient` aimed at the live HTTP listener for the given
- * `(serverUrl, directory)`. One client is reused across deliveries.
- */
-export declare function getLiveServerClient(serverUrl: string, directory: string): LiveServerClient;
-/**
- * Probe whether `serverUrl` serves OpenCode's HTTP API within `timeoutMs`.
- * `true` only when `/session` proves the API is usable: any 2xx, or 401/403
- * (auth-protected listener still exists). `false` for 404 (plain TUI internal
- * listener), 5xx, connection refused, DNS failure, timeout, or malformed URL.
- * Records the result + timestamp in the per-serverUrl cache.
- */
-export declare function probeServerReachable(serverUrl: string | undefined, timeoutMs?: number): Promise<boolean>;
-/** Record a probe result directly (test helper / explicit override). */
-export declare function setLiveServerWakeAvailable(serverUrl: string | undefined, available: boolean): void;
-/**
- * Should Channel 2 deliver through the live-server client for `serverUrl`?
- * Returns false when never probed or the last probe failed. A stale decision
- * (older than the TTL) returns false so the caller re-probes before delivering.
- */
-export declare function useLiveServerWake(serverUrl?: string): boolean;
-/** True when a usable (non-stale) probe decision exists, regardless of outcome. */
-export declare function hasFreshProbe(serverUrl?: string): boolean;
-/** Test helper — reset both caches between cases. */
-export declare function __resetLiveServerClientForTests(): void;
-//# sourceMappingURL=live-server-client.d.ts.map

package/dist/shared/live-server-client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"live-server-client.d.ts","sourceRoot":"","sources":["../../src/shared/live-server-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;AA0BvE;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,gBAAgB,CAY1F;AAcD;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACtC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,SAAS,SAAO,GACjB,OAAO,CAAC,OAAO,CAAC,CAqBlB;AAED,wEAAwE;AACxE,wBAAgB,0BAA0B,CACtC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,SAAS,EAAE,OAAO,GACnB,IAAI,CAMN;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAM7D;AAED,mFAAmF;AACnF,wBAAgB,aAAa,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAKzD;AAED,qDAAqD;AACrD,wBAAgB,+BAA+B,IAAI,IAAI,CAGtD"}