@hansenexus/hud 0.1.0

package/chunk-xztw0xyt.js

@@ -0,0 +1,113 @@
+// ../ui/lib/utils.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// ../ui/components/badge.tsx
+import { Slot } from "@radix-ui/react-slot";
+import { cva } from "class-variance-authority";
+import { jsx } from "react/jsx-runtime";
+var badgeVariants = cva("inline-flex items-center justify-center rounded-full border border-transparent px-2 py-0.5 text-xs font-medium w-fit whitespace-nowrap shrink-0 [&>svg]:size-3 gap-1 [&>svg]:pointer-events-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive transition-[color,box-shadow] overflow-hidden", {
+  variants: {
+    variant: {
+      default: "bg-primary text-primary-foreground [a&]:hover:bg-primary/90",
+      secondary: "bg-secondary text-secondary-foreground [a&]:hover:bg-secondary/90",
+      destructive: "bg-destructive text-white [a&]:hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
+      outline: "border-border text-foreground [a&]:hover:bg-accent [a&]:hover:text-accent-foreground",
+      ghost: "[a&]:hover:bg-accent [a&]:hover:text-accent-foreground",
+      link: "text-primary underline-offset-4 [a&]:hover:underline",
+      success: "bg-emerald-500/15 text-emerald-700 border-emerald-500/20 dark:text-emerald-300 dark:bg-emerald-400/15 dark:border-emerald-400/25 [a&]:hover:bg-emerald-500/25",
+      warning: "bg-amber-500/15 text-amber-700 border-amber-500/20 dark:text-amber-300 dark:bg-amber-400/15 dark:border-amber-400/25 [a&]:hover:bg-amber-500/25",
+      info: "bg-blue-500/15 text-blue-700 border-blue-500/20 dark:text-blue-300 dark:bg-blue-400/15 dark:border-blue-400/25 [a&]:hover:bg-blue-500/25",
+      muted: "bg-muted text-muted-foreground border-transparent [a&]:hover:bg-muted/80"
+    }
+  },
+  defaultVariants: {
+    variant: "default"
+  }
+});
+function Badge({
+  className,
+  variant = "default",
+  asChild = false,
+  ...props
+}) {
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx(Comp, {
+    "data-slot": "badge",
+    "data-variant": variant,
+    className: cn(badgeVariants({ variant }), className),
+    ...props
+  });
+}
+
+// ../ui/components/button.tsx
+import { Slot as Slot2 } from "@radix-ui/react-slot";
+import { cva as cva2 } from "class-variance-authority";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var buttonVariants = cva2("inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-all disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive", {
+  variants: {
+    variant: {
+      default: "bg-primary text-primary-foreground hover:bg-primary/90",
+      destructive: "bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
+      outline: "border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50",
+      secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80",
+      ghost: "hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50",
+      link: "text-primary underline-offset-4 hover:underline"
+    },
+    size: {
+      default: "h-9 px-4 py-2 has-[>svg]:px-3",
+      xs: "h-6 gap-1 rounded-md px-2 text-xs has-[>svg]:px-1.5 [&_svg:not([class*='size-'])]:size-3",
+      sm: "h-8 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5",
+      lg: "h-10 rounded-md px-6 has-[>svg]:px-4",
+      icon: "size-9",
+      "icon-xs": "size-6 rounded-md [&_svg:not([class*='size-'])]:size-3",
+      "icon-sm": "size-8",
+      "icon-lg": "size-10"
+    }
+  },
+  defaultVariants: {
+    variant: "default",
+    size: "default"
+  }
+});
+function Button({
+  className,
+  variant = "default",
+  size = "default",
+  asChild = false,
+  ...props
+}) {
+  const Comp = asChild ? Slot2 : "button";
+  return /* @__PURE__ */ jsx2(Comp, {
+    "data-slot": "button",
+    "data-variant": variant,
+    "data-size": size,
+    className: cn(buttonVariants({ variant, size, className })),
+    ...props
+  });
+}
+
+// ../ui/components/switch.tsx
+import * as SwitchPrimitive from "@radix-ui/react-switch";
+import { jsx as jsx3 } from "react/jsx-runtime";
+"use client";
+function Switch({
+  className,
+  size = "default",
+  ...props
+}) {
+  return /* @__PURE__ */ jsx3(SwitchPrimitive.Root, {
+    "data-slot": "switch",
+    "data-size": size,
+    className: cn("peer data-[state=checked]:bg-primary data-[state=unchecked]:bg-input focus-visible:border-ring focus-visible:ring-ring/50 dark:data-[state=unchecked]:bg-input/80 group/switch inline-flex shrink-0 items-center rounded-full border border-transparent shadow-xs transition-all outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 data-[size=default]:h-[1.15rem] data-[size=default]:w-8 data-[size=sm]:h-3.5 data-[size=sm]:w-6", className),
+    ...props,
+    children: /* @__PURE__ */ jsx3(SwitchPrimitive.Thumb, {
+      "data-slot": "switch-thumb",
+      className: cn("bg-background dark:data-[state=unchecked]:bg-foreground dark:data-[state=checked]:bg-primary-foreground pointer-events-none block rounded-full ring-0 transition-transform group-data-[size=default]/switch:size-4 group-data-[size=sm]/switch:size-3 data-[state=checked]:translate-x-[calc(100%-2px)] data-[state=unchecked]:translate-x-0")
+    })
+  });
+}
+export { cn, Badge, Button, Switch };

package/chunk-zzrpd92r.js

@@ -0,0 +1,172 @@
+import {
+  usePoll
+} from "./chunk-xezxydm3.js";
+import {
+  useHud
+} from "./chunk-wspz08q7.js";
+import {
+  InfoRow,
+  LoadingSpinner,
+  PanelSection
+} from "./chunk-kyeb6qeq.js";
+import {
+  Badge
+} from "./chunk-xztw0xyt.js";
+
+// panels/cicd-panel.tsx
+import { GitBranch, Rocket } from "lucide-react";
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+"use client";
+function CicdPanel() {
+  const { config } = useHud();
+  const apiBase = config.apiBase ?? "/api/hud";
+  const { data, error, loading } = usePoll(`${apiBase}/cicd?app=${encodeURIComponent(config.appSlug)}`, 60000);
+  if (loading)
+    return /* @__PURE__ */ jsx(LoadingSpinner, {});
+  if (error) {
+    return /* @__PURE__ */ jsxs("p", {
+      className: "px-2 text-[10px] text-amber-500",
+      children: [
+        "hub unreachable — ",
+        error
+      ]
+    });
+  }
+  if (!data)
+    return null;
+  return /* @__PURE__ */ jsxs("div", {
+    className: "space-y-4",
+    children: [
+      /* @__PURE__ */ jsx(PanelSection, {
+        icon: Rocket,
+        title: `Deployed · ${data.app}`,
+        children: data.deployed ? /* @__PURE__ */ jsxs(Fragment, {
+          children: [
+            /* @__PURE__ */ jsx(InfoRow, {
+              label: "Image",
+              value: data.deployed.image,
+              copyable: true
+            }),
+            /* @__PURE__ */ jsx(InfoRow, {
+              label: "Sha (prod tag)",
+              value: data.deployed.sha,
+              copyable: true
+            }),
+            data.deployed.lastGoodTag && /* @__PURE__ */ jsx(InfoRow, {
+              label: "last-good-tag",
+              value: data.deployed.lastGoodTag
+            }),
+            /* @__PURE__ */ jsx(InfoRow, {
+              label: "Ready",
+              value: data.deployed.ready
+            })
+          ]
+        }) : /* @__PURE__ */ jsx("p", {
+          className: "px-2 text-[10px] text-muted-foreground/60",
+          children: "No deployment found for this app (deploy: false, or namespace mismatch)."
+        })
+      }),
+      /* @__PURE__ */ jsxs(PanelSection, {
+        icon: GitBranch,
+        title: "Recent runs",
+        children: [
+          data.githubUnconfigured && /* @__PURE__ */ jsx("p", {
+            className: "px-2 text-[10px] text-amber-500",
+            children: "GITHUB_TOKEN unset — CI runs missing."
+          }),
+          /* @__PURE__ */ jsx("div", {
+            className: "overflow-x-auto",
+            children: /* @__PURE__ */ jsxs("table", {
+              className: "w-full text-[10.5px]",
+              children: [
+                /* @__PURE__ */ jsx("thead", {
+                  children: /* @__PURE__ */ jsxs("tr", {
+                    className: "text-left text-[9px] uppercase tracking-wider text-muted-foreground",
+                    children: [
+                      /* @__PURE__ */ jsx("th", {
+                        className: "px-2 py-1 font-medium",
+                        children: "Run"
+                      }),
+                      /* @__PURE__ */ jsx("th", {
+                        className: "px-2 py-1 font-medium",
+                        children: "Source"
+                      }),
+                      /* @__PURE__ */ jsx("th", {
+                        className: "px-2 py-1 font-medium",
+                        children: "Status"
+                      }),
+                      /* @__PURE__ */ jsx("th", {
+                        className: "px-2 py-1 font-medium",
+                        children: "Branch"
+                      })
+                    ]
+                  })
+                }),
+                /* @__PURE__ */ jsx("tbody", {
+                  children: data.runs.map((run) => /* @__PURE__ */ jsx(RunRow, {
+                    run
+                  }, `${run.source}-${run.id}`))
+                })
+              ]
+            })
+          }),
+          data.runs.length === 0 && /* @__PURE__ */ jsx("p", {
+            className: "px-2 text-[10px] text-muted-foreground/60",
+            children: "No runs available."
+          })
+        ]
+      })
+    ]
+  });
+}
+function runStatusClass(run) {
+  const outcome = run.conclusion ?? run.status;
+  if (outcome === "success")
+    return "text-emerald-500";
+  if (outcome === "failure" || outcome === "cancelled")
+    return "text-red-500";
+  if (run.status === "in_progress" || run.status === "running" || run.status === "waiting") {
+    return "text-amber-500";
+  }
+  return "text-muted-foreground";
+}
+function RunRow({ run }) {
+  const title = /* @__PURE__ */ jsx("span", {
+    className: "max-w-[260px] truncate font-mono",
+    title: run.title,
+    children: run.title || run.name
+  });
+  return /* @__PURE__ */ jsxs("tr", {
+    className: "border-t border-border/40 hover:bg-muted/30",
+    children: [
+      /* @__PURE__ */ jsx("td", {
+        className: "px-2 py-1",
+        children: run.url ? /* @__PURE__ */ jsx("a", {
+          href: run.url,
+          target: "_blank",
+          rel: "noreferrer",
+          className: "hover:underline",
+          children: title
+        }) : title
+      }),
+      /* @__PURE__ */ jsx("td", {
+        className: "px-2 py-1",
+        children: /* @__PURE__ */ jsx(Badge, {
+          variant: "outline",
+          className: "h-4 px-1.5 text-[9px] text-muted-foreground",
+          children: run.source
+        })
+      }),
+      /* @__PURE__ */ jsx("td", {
+        className: `px-2 py-1 font-mono ${runStatusClass(run)}`,
+        children: run.conclusion ?? run.status
+      }),
+      /* @__PURE__ */ jsx("td", {
+        className: "px-2 py-1 font-mono text-muted-foreground",
+        children: run.branch ?? "—"
+      })
+    ]
+  });
+}
+
+export { CicdPanel };

package/core/access.d.mts

@@ -0,0 +1,53 @@
+import { HudEnv } from './types.mjs';
+import 'lucide-react';
+import 'react';
+
+/**
+ * Access ladder for the hud: the second lock on top of the env matrix.
+ *
+ * `isHudVisible()` decides whether the hud exists at all (the flag). This
+ * module decides whether the operator opening it has proved who they are:
+ * outside development every deployed tier additionally needs an unlock
+ * cookie signed with `HUD_ACCESS_PASSWORD` (server-only, 1Password).
+ *
+ * Levels mirror `resolveDevRoutesAccess()` in @hn-monorepo/dev-routes so the
+ * vocabulary is the same across both dev surfaces:
+ *
+ * - `open`:     development, no password.
+ * - `password`: preview/staging, flag + password, 12 h unlock.
+ * - `flag`:     production, flag + password, 2 h unlock, observe-only caps.
+ * - `denied`:   explicitly disabled; nothing unlocks it.
+ *
+ * The token is an HMAC over its own issue time, so it carries no secret and
+ * cannot be extended by the holder; re-issuing needs the password again.
+ */
+
+type HudAccess = "open" | "password" | "flag" | "denied";
+/** httpOnly cookie holding the signed unlock token. */
+declare const HUD_UNLOCK_COOKIE = "hud-unlock";
+/** Unlock lifetime per tier. Production is deliberately the shortest window. */
+declare const HUD_UNLOCK_TTL_MS: Record<HudAccess, number>;
+declare function resolveHudAccess(env?: HudEnv): HudAccess;
+/** Whether this tier needs a valid unlock cookie before any hud data flows. */
+declare function hudRequiresUnlock(access: HudAccess): boolean;
+/** TTL for the tier the current env resolves to. */
+declare function hudUnlockTtlMs(access: HudAccess): number;
+/** Length-independent, constant-time comparison of two hex digests. */
+declare function timingSafeEqual(a: string, b: string): boolean;
+/**
+ * Mint an unlock token. Format `<issuedAt>.<hmac>`; the issue time is in the
+ * clear on purpose so expiry is verifiable without server state, and it is
+ * covered by the signature so it cannot be back-dated.
+ */
+declare function signHudUnlockToken(password: string, issuedAt?: number): Promise<string>;
+interface HudUnlockVerifyOptions {
+    now?: number;
+    ttlMs?: number;
+}
+declare function verifyHudUnlockToken(token: string | undefined, password: string | undefined, options?: HudUnlockVerifyOptions): Promise<boolean>;
+/** Parse a single cookie out of a raw `Cookie:` header. */
+declare function readCookie(header: string | null | undefined, name: string): string | undefined;
+/** Serialized `Set-Cookie` value for the unlock token (or its removal). */
+declare function hudUnlockCookieString(token: string | null, ttlMs: number): string;
+
+export { HUD_UNLOCK_COOKIE, HUD_UNLOCK_TTL_MS, type HudAccess, type HudUnlockVerifyOptions, hudRequiresUnlock, hudUnlockCookieString, hudUnlockTtlMs, readCookie, resolveHudAccess, signHudUnlockToken, timingSafeEqual, verifyHudUnlockToken };

package/core/access.js

@@ -0,0 +1,27 @@
+import {
+  HUD_UNLOCK_COOKIE,
+  HUD_UNLOCK_TTL_MS,
+  hudRequiresUnlock,
+  hudUnlockCookieString,
+  hudUnlockTtlMs,
+  readCookie,
+  resolveHudAccess,
+  signHudUnlockToken,
+  timingSafeEqual,
+  verifyHudUnlockToken
+} from "../chunk-r06bpmy6.js";
+import"../chunk-babjpqkb.js";
+import"../chunk-v086j53b.js";
+import"../chunk-5gtx3pza.js";
+export {
+  verifyHudUnlockToken,
+  timingSafeEqual,
+  signHudUnlockToken,
+  resolveHudAccess,
+  readCookie,
+  hudUnlockTtlMs,
+  hudUnlockCookieString,
+  hudRequiresUnlock,
+  HUD_UNLOCK_TTL_MS,
+  HUD_UNLOCK_COOKIE
+};

package/core/api-types.d.mts

@@ -0,0 +1,146 @@
+/**
+ * Response shapes of the hud hub routes (served by console under /api/hud/*,
+ * thin proxies over console's src/lib clients — see the hud architecture
+ * decision). Shared so panels and routes cannot drift apart.
+ */
+interface HudSignozResponse {
+    ok: boolean;
+    service: string;
+    range: string;
+    /** "mock" when SIGNOZ_QUERY_URL is unset — the client generates demo data. */
+    source: "signoz" | "mock";
+    errorRate: number | null;
+    p95Latency: number | null;
+    requestCount: number | null;
+}
+interface HudCicdRun {
+    id: number;
+    name: string;
+    title: string;
+    status: string;
+    conclusion?: string | null;
+    branch?: string;
+    sha?: string;
+    url?: string;
+    startedAt?: string;
+    source: "github";
+}
+interface HudCicdDeployed {
+    image: string;
+    /** Prod image tags are the deployed commit sha (deploy-production.yml). */
+    sha: string;
+    lastGoodTag?: string;
+    ready: string;
+}
+interface HudCicdResponse {
+    ok: boolean;
+    app: string;
+    /** null when no deployment exists for the app (e.g. deploy: false apps). */
+    deployed: HudCicdDeployed | null;
+    runs: HudCicdRun[];
+    githubUnconfigured?: boolean;
+}
+/** Grabbed-element anchor — same shape as console's designReviewComments anchor. */
+interface HudAnchor {
+    selector: string;
+    label: string;
+    /** Rect in viewport percentages, so it survives viewport changes. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface HudComponentHint {
+    name: string;
+    path: string;
+}
+interface HudDispatchPayload {
+    app: string;
+    env: string;
+    route: string;
+    anchor: HudAnchor;
+    /** Best-effort source guesses (route manifest / component manifest). */
+    componentHints: HudComponentHint[];
+    /** Tail of captured console warns/errors — PII-scrubbed by truncation. */
+    recentErrors: string[];
+    vitals: Record<string, number>;
+    grabbedAt: string;
+}
+type HudDispatchTarget = "docket" | "queue" | "hermes";
+interface HudDispatchRequest {
+    target: HudDispatchTarget;
+    note: string;
+    payload: HudDispatchPayload;
+}
+/**
+ * A plain work order, no HUD grab attached (#424 PR3). This is what the
+ * kommandant desktop cockpit sends: a board card (or a hand-typed form)
+ * becomes a docket dispatch without any DOM anchor to point at. Always goes
+ * through docket; there is no queue fallback for orders.
+ */
+interface HudOrderDispatchRequest {
+    target: "docket";
+    order: {
+        title: string;
+        app?: string;
+        /** Comma-free strings — the docket CLI's `--criteria` splits on commas. */
+        criteria?: string[];
+        /** Extra context, written into the run dir as prompt.md. */
+        prompt?: string;
+        /** Forge issue to link: order links.issue + draft PR `Closes #N`. */
+        issue?: number;
+        /** Also spawn the headless agent. Default false: a human drives. */
+        agent?: boolean;
+    };
+}
+type HudDispatchBody = HudDispatchRequest | HudOrderDispatchRequest;
+declare function isOrderDispatch(body: HudDispatchBody): body is HudOrderDispatchRequest;
+interface HudDispatchResponse {
+    ok: boolean;
+    target: HudDispatchTarget;
+    /** docket run id, when target=docket. */
+    runId?: string;
+    /** repo-relative queue marker path, when target=queue. */
+    markerPath?: string;
+    error?: string;
+}
+interface HudBridgeInfo {
+    port: number;
+    token: string;
+}
+interface HudSessionInfo {
+    sessionId: string;
+    name?: string;
+    branch?: string;
+    toplevel?: string;
+    kind?: string;
+    /** Seconds since the registry file's mtime — the liveness signal. */
+    idleSeconds: number;
+    startedAt?: string;
+}
+/** One app-provided seed action, offered as a button in the mock/seed panel. */
+interface HudSeedDescriptor {
+    id: string;
+    label: string;
+    /** Convex function ref, `module:fn` (subdirs as `dir/module:fn`). */
+    fn: string;
+    args?: Record<string, unknown>;
+    /** Append `--local` (app runs a local `convex dev --local` backend). */
+    local?: boolean;
+    description?: string;
+}
+interface HudSeedRequest {
+    app: string;
+    fn: string;
+    args?: Record<string, unknown>;
+    local?: boolean;
+}
+interface HudSeedResponse {
+    ok: boolean;
+    fn: string;
+    /** Trimmed tail of the convex CLI output. */
+    output?: string;
+    error?: string;
+}
+
+export { type HudAnchor, type HudBridgeInfo, type HudCicdDeployed, type HudCicdResponse, type HudCicdRun, type HudComponentHint, type HudDispatchBody, type HudDispatchPayload, type HudDispatchRequest, type HudDispatchResponse, type HudDispatchTarget, type HudOrderDispatchRequest, type HudSeedDescriptor, type HudSeedRequest, type HudSeedResponse, type HudSessionInfo, type HudSignozResponse, isOrderDispatch };

package/core/api-types.js

@@ -0,0 +1,9 @@
+import"../chunk-5gtx3pza.js";
+
+// core/api-types.ts
+function isOrderDispatch(body) {
+  return "order" in body && typeof body.order?.title === "string";
+}
+export {
+  isOrderDispatch
+};

package/core/capabilities.d.mts

@@ -0,0 +1,27 @@
+import { HudEnv, HudCapability } from './types.mjs';
+import 'lucide-react';
+import 'react';
+
+/**
+ * Default-deny capability matrix (see the hud plan). Client-side filtering is
+ * convenience only — every server route re-checks its env, and estate calls
+ * are additionally scoped by the console hub's token. Staging's
+ * `auth.impersonate` is further flag-gated server-side.
+ */
+declare const CAPABILITY_MATRIX: Record<HudEnv, readonly HudCapability[]>;
+/**
+ * Env ladder, following `resolveDevRoutesAccess()` in @hn-monorepo/dev-routes:
+ * explicit kill switch → NODE_ENV (inlined by Next, so prod bundles tree-shake
+ * the dev branch) → explicit NEXT_PUBLIC_HUD_ENV (k8s overlays; k3s has no
+ * VERCEL_ENV) → VERCEL_ENV heuristic → production.
+ */
+declare function resolveHudEnv(): HudEnv;
+/**
+ * Whether the hud renders at all. Outside development this requires the
+ * explicit opt-in flag — deployed envs get the hud only when their overlay
+ * turns it on (staging/preview in M6, production read-only in M7).
+ */
+declare function isHudVisible(env?: HudEnv): boolean;
+declare function hasCapability(env: HudEnv, capability: HudCapability): boolean;
+
+export { CAPABILITY_MATRIX, hasCapability, isHudVisible, resolveHudEnv };

package/core/capabilities.js

@@ -0,0 +1,14 @@
+import {
+  CAPABILITY_MATRIX,
+  hasCapability,
+  isHudVisible,
+  resolveHudEnv
+} from "../chunk-babjpqkb.js";
+import"../chunk-v086j53b.js";
+import"../chunk-5gtx3pza.js";
+export {
+  resolveHudEnv,
+  isHudVisible,
+  hasCapability,
+  CAPABILITY_MATRIX
+};

package/core/capture-buffer.d.mts

@@ -0,0 +1,37 @@
+type CaptureKind = "log" | "warn" | "error" | "fetch" | "longtask";
+interface CaptureEntry {
+    id: number;
+    ts: number;
+    kind: CaptureKind;
+    text: string;
+    status?: number;
+    durationMs?: number;
+}
+interface CaptureEntryInput {
+    kind: CaptureKind;
+    text: string;
+    status?: number;
+    durationMs?: number;
+}
+/**
+ * Fixed-size ring buffer with a referentially-stable snapshot, shaped for
+ * `useSyncExternalStore`: the snapshot array is replaced on every mutation
+ * and reused between mutations.
+ */
+declare class CaptureBuffer {
+    private entries;
+    private snapshot;
+    private listeners;
+    private nextId;
+    private readonly maxEntries;
+    constructor(maxEntries?: number);
+    push(input: CaptureEntryInput): CaptureEntry;
+    clear(): void;
+    getSnapshot: () => readonly CaptureEntry[];
+    subscribe: (listener: () => void) => (() => void);
+    private emit;
+}
+/** Shared buffer the capture patches write into and the net panel reads from. */
+declare const captureBuffer: CaptureBuffer;
+
+export { CaptureBuffer, type CaptureEntry, type CaptureEntryInput, type CaptureKind, captureBuffer };

package/core/capture-buffer.js

@@ -0,0 +1,9 @@
+import {
+  CaptureBuffer,
+  captureBuffer
+} from "../chunk-24vrg16w.js";
+import"../chunk-5gtx3pza.js";
+export {
+  captureBuffer,
+  CaptureBuffer
+};

package/core/force-state.d.mts

@@ -0,0 +1,68 @@
+/**
+ * Force-state store: lets a reviewer (HUD panel) or an agent (`?__state=`)
+ * render any registered state boundary as loading, empty or error without
+ * faking data (PRD #2110, issue #2117).
+ *
+ * Development only. The only importer outside the hud is `state-boundary.tsx`,
+ * which reaches this module behind a `NODE_ENV === "development"` constant, so
+ * production builds drop it; `scripts/ci/assert-no-hud-in-bundle.sh` greps the
+ * client chunks for FORCE_STATE_MARKER to prove it.
+ */
+declare const FORCED_STATES: readonly ["loading", "empty", "error"];
+type ForcedState = (typeof FORCED_STATES)[number];
+/** `?__state=loading` forces top-level boundaries; `?__state=<id>:error` one boundary. */
+declare const FORCE_STATE_PARAM = "__state";
+/**
+ * globalThis key of the store singleton, and the bundle-gate marker. Holding
+ * the store on globalThis keeps one instance even if the module is evaluated
+ * twice (HMR, or a second copy resolved through another node_modules path).
+ */
+declare const FORCE_STATE_MARKER = "__HN_FORCE_STATE__";
+interface ForceStateParam {
+    state: ForcedState;
+    /** Boundary id the param targets; null = every top-level boundary. */
+    target: string | null;
+}
+interface StateBoundaryInfo {
+    id: string;
+    /** Id of the enclosing boundary; null for a top-level one. */
+    parentId: string | null;
+}
+interface ForceStateSnapshot {
+    boundaries: readonly StateBoundaryInfo[];
+    overrides: Readonly<Record<string, ForcedState>>;
+    param: ForceStateParam | null;
+}
+/** Parses the value of `?__state=`; anything unrecognised is ignored (null). */
+declare function parseForceStateParam(value: string | null | undefined): ForceStateParam | null;
+/** Reads the param out of a `location.search` string. */
+declare function forceStateParamFromSearch(search: string): ForceStateParam | null;
+/**
+ * The state a boundary renders. A panel override for the boundary wins; else
+ * the URL param applies to its target, or, untargeted, to the nearest
+ * boundaries: the top-level ones. Forcing an outer boundary unmounts the
+ * inner ones anyway, so the page-level state is what a screenshot wants.
+ */
+declare function resolveForcedState(snapshot: ForceStateSnapshot, boundary: StateBoundaryInfo): ForcedState | null;
+type Listener = () => void;
+declare class ForceStateStore {
+    private registrations;
+    private overrides;
+    private search;
+    private snapshot;
+    private listeners;
+    getSnapshot: () => ForceStateSnapshot;
+    subscribe: (listener: Listener) => (() => void);
+    /** Registers a mounted boundary; the returned function unregisters it. Mounts are counted. */
+    register(id: string, parentId: string | null): () => void;
+    /** Forces one boundary (panel toggle); null returns it to auto. */
+    force(id: string, state: ForcedState | null): void;
+    clearOverrides(): void;
+    /** Feeds the current `location.search`; a no-op when it did not change. */
+    syncSearch(search: string): void;
+    private emit;
+}
+/** The page's store, created on first use. */
+declare function getForceStateStore(): ForceStateStore;
+
+export { FORCED_STATES, FORCE_STATE_MARKER, FORCE_STATE_PARAM, type ForceStateParam, type ForceStateSnapshot, ForceStateStore, type ForcedState, type StateBoundaryInfo, forceStateParamFromSearch, getForceStateStore, parseForceStateParam, resolveForcedState };