@ekanos/harness 0.1.0

package/dist/internal/components/harness-widget-provider.js

@@ -0,0 +1,84 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useCallback, useMemo, useState } from "react";
+import {
+  WidgetContext
+} from "@ekanos/sdk/components";
+function HarnessWidgetProvider({
+  widgetId,
+  title,
+  subtitle,
+  description,
+  className,
+  state: renderState,
+  isEnabled = true,
+  isCollapsible = false,
+  isPinnable = false,
+  defaultCollapsed = false,
+  defaultPinned = false,
+  maxContentHeight,
+  askContext,
+  aiFooterEnabled = false,
+  health,
+  children
+}) {
+  const [toggles, setToggles] = useState({
+    collapsed: defaultCollapsed,
+    pinned: defaultPinned
+  });
+  const toggleCollapsed = useCallback(() => {
+    setToggles((current) => ({ ...current, collapsed: !current.collapsed }));
+  }, []);
+  const togglePinned = useCallback(() => {
+    setToggles((current) => ({ ...current, pinned: !current.pinned }));
+  }, []);
+  const baseRenderState = renderState !== "active" ? renderState : isEnabled ? "active" : "disabled";
+  const effectiveRenderState = baseRenderState === "active" && health?.status === "unhealthy" && health?.lastSuccessAt ? "disabled" : baseRenderState;
+  const value = useMemo(
+    () => ({
+      state: {
+        state: effectiveRenderState,
+        collapsed: toggles.collapsed,
+        pinned: toggles.pinned,
+        pendingCollapse: false,
+        pendingPin: false
+      },
+      actions: { toggleCollapsed, togglePinned },
+      meta: {
+        widgetId,
+        title,
+        subtitle,
+        description,
+        maxContentHeight,
+        isCollapsible,
+        isPinnable,
+        askContext,
+        aiFooterEnabled,
+        className,
+        health
+      }
+    }),
+    [
+      effectiveRenderState,
+      toggles.collapsed,
+      toggles.pinned,
+      toggleCollapsed,
+      togglePinned,
+      widgetId,
+      title,
+      subtitle,
+      description,
+      maxContentHeight,
+      isCollapsible,
+      isPinnable,
+      askContext,
+      aiFooterEnabled,
+      className,
+      health
+    ]
+  );
+  return /* @__PURE__ */ jsx(WidgetContext, { value, children });
+}
+export {
+  HarnessWidgetProvider
+};

package/dist/internal/components/i18n-provider.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+import '../lib/i18n.js';
+/**
+ * Initialization happens as a module side effect on import, so it runs once,
+ * synchronously, before anything below renders.
+ */
+export declare function I18nProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/internal/components/i18n-provider.js

@@ -0,0 +1,9 @@
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import "../lib/i18n.js";
+function I18nProvider({ children }) {
+  return /* @__PURE__ */ jsx(Fragment, { children });
+}
+export {
+  I18nProvider
+};

package/dist/internal/components/row-groups.d.ts

@@ -0,0 +1,23 @@
+import { WidgetConfig } from '@ekanos/sdk';
+export type RowGroup = {
+    type: 'full';
+    widget: WidgetConfig;
+} | {
+    type: 'half';
+    widgets: WidgetConfig[];
+};
+/**
+ * Build row groups that preserve widget order. Contiguous runs of half-width
+ * widgets are grouped together; full-width widgets each get their own row.
+ */
+export declare function buildRowGroups(widgets: WidgetConfig[]): RowGroup[];
+export declare function getColSpan(widget: WidgetConfig): 1 | 2;
+/**
+ * Splits a run of half-width widgets into two balanced columns, alternating
+ * into whichever column is currently shorter (left wins ties) — preserves
+ * the exact alternation `MasonryGrid` rendered inline before extraction.
+ */
+export declare function splitBalanced(widgets: WidgetConfig[]): {
+    left: WidgetConfig[];
+    right: WidgetConfig[];
+};

package/dist/internal/components/row-groups.js

@@ -0,0 +1,37 @@
+function buildRowGroups(widgets) {
+  const groups = [];
+  let halfBatch = [];
+  for (const widget of widgets) {
+    if (getColSpan(widget) === 2) {
+      if (halfBatch.length > 0) {
+        groups.push({ type: "half", widgets: halfBatch });
+        halfBatch = [];
+      }
+      groups.push({ type: "full", widget });
+    } else {
+      halfBatch.push(widget);
+    }
+  }
+  if (halfBatch.length > 0) {
+    groups.push({ type: "half", widgets: halfBatch });
+  }
+  return groups;
+}
+function getColSpan(widget) {
+  const w = widget.layouts?.lg?.w ?? 6;
+  return w > 6 ? 2 : 1;
+}
+function splitBalanced(widgets) {
+  const left = [];
+  const right = [];
+  for (const w of widgets) {
+    if (left.length <= right.length) left.push(w);
+    else right.push(w);
+  }
+  return { left, right };
+}
+export {
+  buildRowGroups,
+  getColSpan,
+  splitBalanced
+};

package/dist/internal/components/surface-nav.d.ts

@@ -0,0 +1,4 @@
+import type { HarnessIntegration } from '../../registry.js';
+export declare function SurfaceNav({ integration, }: {
+    integration: HarnessIntegration;
+}): import("react").JSX.Element;

package/dist/internal/components/surface-nav.js

@@ -0,0 +1,70 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import Link from "next/link";
+import { usePathname } from "next/navigation";
+import { Icon } from "@ekanos/ui/icon";
+import { cn } from "@ekanos/ui/utils";
+import { HARNESS_SURFACES } from "../surfaces.js";
+function SurfaceNav({
+  integration
+}) {
+  const pathname = usePathname();
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-5 border-b px-6 py-5", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-baseline gap-3", children: [
+      /* @__PURE__ */ jsxs(
+        Link,
+        {
+          href: "/",
+          className: "text-muted-foreground hover:text-foreground text-sm",
+          children: [
+            /* @__PURE__ */ jsx(Icon, { name: "fa-solid fa-arrow-left", className: "mr-2 h-4 w-4" }),
+            "All integrations"
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx("h1", { className: "font-heading text-2xl tracking-tight", children: integration.name }),
+      /* @__PURE__ */ jsx("code", { className: "text-muted-foreground text-xs", children: integration.slug })
+    ] }),
+    /* @__PURE__ */ jsx("nav", { className: "flex flex-wrap gap-1", children: HARNESS_SURFACES.map((surface) => {
+      const href = `/${integration.slug}/${surface.segment}`;
+      const active = pathname.startsWith(href);
+      return /* @__PURE__ */ jsxs(
+        Link,
+        {
+          href,
+          className: cn(
+            "flex items-center gap-2 rounded-md px-3 py-2 text-sm transition-colors",
+            active ? "bg-accent text-accent-foreground font-medium" : "text-muted-foreground hover:bg-accent/50"
+          ),
+          children: [
+            /* @__PURE__ */ jsx(Icon, { name: surface.icon, className: "h-5 w-5" }),
+            surface.label
+          ]
+        },
+        surface.segment
+      );
+    }) }),
+    integration.widgets.length > 0 ? /* @__PURE__ */ jsxs("nav", { className: "flex flex-wrap gap-1", children: [
+      /* @__PURE__ */ jsx("span", { className: "text-muted-foreground px-3 py-2 text-xs", children: "Focus one widget:" }),
+      integration.widgets.map((widget) => {
+        const href = `/${integration.slug}/widgets/${widget.id}`;
+        const active = pathname === href;
+        return /* @__PURE__ */ jsx(
+          Link,
+          {
+            href,
+            className: cn(
+              "rounded-md px-3 py-2 text-sm transition-colors",
+              active ? "bg-accent text-accent-foreground font-medium" : "text-muted-foreground hover:bg-accent/50"
+            ),
+            children: widget.title
+          },
+          widget.id
+        );
+      })
+    ] }) : null
+  ] });
+}
+export {
+  SurfaceNav
+};

package/dist/internal/components/viewport-frame.d.ts

@@ -0,0 +1,14 @@
+import type { ReactNode } from 'react';
+/**
+ * Constrains the preview to a viewport preset.
+ *
+ * This narrows a real container rather than rendering into an iframe, which is
+ * the right trade for widgets: the whole dashboard grid is built on Tailwind
+ * `@container` queries (`@4xl/dashboard:grid-cols-2`), so container width — not
+ * window width — is what actually drives the responsive behaviour a partner
+ * needs to check. Media-query breakpoints still read the real window; see the
+ * "Known gaps" section of the README.
+ */
+export declare function ViewportFrame({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/internal/components/viewport-frame.js

@@ -0,0 +1,27 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { VIEWPORTS, useToolbar } from "../lib/toolbar-context.js";
+function ViewportFrame({ children }) {
+  const { state } = useToolbar();
+  const { width, label } = VIEWPORTS[state.viewport];
+  if (width === null) return /* @__PURE__ */ jsx(Fragment, { children });
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center gap-2", children: [
+    /* @__PURE__ */ jsxs("span", { className: "text-muted-foreground text-xs", children: [
+      label,
+      " \xB7 ",
+      width,
+      "px"
+    ] }),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "w-full overflow-hidden rounded-lg border p-5",
+        style: { maxWidth: width },
+        children
+      }
+    )
+  ] });
+}
+export {
+  ViewportFrame
+};

package/dist/internal/components/widget-boundary.d.ts

@@ -0,0 +1,25 @@
+import { Component, type ReactNode } from 'react';
+interface Props {
+    widgetId: string;
+    /** Changing this remounts the boundary, clearing a caught error. */
+    resetKey?: string;
+    children: ReactNode;
+}
+interface State {
+    error: Error | null;
+}
+/**
+ * `Widget.Active` already wraps its children in an error boundary, but only its
+ * children — a widget that throws during its own render, before reaching the
+ * compound components (a bad hook call, a fixture shaped wrongly), escapes it
+ * and takes the page with it. This catches that outer case so one broken widget
+ * degrades to one broken card.
+ */
+export declare class WidgetBoundary extends Component<Props, State> {
+    state: State;
+    static getDerivedStateFromError(error: Error): State;
+    componentDidUpdate(previous: Props): void;
+    componentDidCatch(error: Error): void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+}
+export {};

package/dist/internal/components/widget-boundary.js

@@ -0,0 +1,44 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Component } from "react";
+import { Icon } from "@ekanos/ui/icon";
+class WidgetBoundary extends Component {
+  constructor() {
+    super(...arguments);
+    this.state = { error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidUpdate(previous) {
+    if (previous.resetKey !== this.props.resetKey && this.state.error) {
+      this.setState({ error: null });
+    }
+  }
+  componentDidCatch(error) {
+    console.error(`[harness] Widget "${this.props.widgetId}" crashed:`, error);
+  }
+  render() {
+    const { error } = this.state;
+    if (!error) return this.props.children;
+    return /* @__PURE__ */ jsxs("div", { className: "bg-card flex flex-col gap-3 rounded-lg border p-6", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
+        /* @__PURE__ */ jsx(
+          Icon,
+          {
+            name: "fa-solid fa-triangle-exclamation",
+            className: "text-destructive h-5 w-5"
+          }
+        ),
+        /* @__PURE__ */ jsxs("p", { className: "text-sm font-medium", children: [
+          this.props.widgetId,
+          " threw during render"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx("pre", { className: "bg-muted text-destructive overflow-x-auto rounded-md p-3 text-xs whitespace-pre-wrap", children: error.message })
+    ] });
+  }
+}
+export {
+  WidgetBoundary
+};

package/dist/internal/components/widget-surface.d.ts

@@ -0,0 +1,20 @@
+import type { WidgetConfig } from '@ekanos/sdk';
+import { HARNESS_ACCOUNT_ID, HARNESS_SOURCE_ID, type HarnessWidget } from '../../registry.js';
+/**
+ * Adapts the harness registry's widget entries into the `WidgetConfig` shape
+ * the real dashboard grid consumes.
+ *
+ * Note `health` is only set when the toolbar's "Unhealthy" switch is on.
+ * Leaving it undefined the rest of the time matters: `DashboardWidgetProvider`
+ * downgrades an active widget to `disabled` whenever health is `unhealthy` AND
+ * `lastSuccessAt` is set, which would silently override the render state the
+ * toolbar is asking for. Behind the switch, it becomes something you can
+ * exercise deliberately instead of trip over.
+ */
+export declare function toWidgetConfig(widget: HarnessWidget, productSlug: string, unhealthy: boolean): WidgetConfig;
+export declare function WidgetSurface({ widgets, productSlug, layout, }: {
+    widgets: HarnessWidget[];
+    productSlug: string;
+    layout?: 'masonry' | 'two-column';
+}): import("react").JSX.Element;
+export { HARNESS_ACCOUNT_ID, HARNESS_SOURCE_ID };

package/dist/internal/components/widget-surface.js

@@ -0,0 +1,76 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import {
+  HARNESS_ACCOUNT_ID,
+  HARNESS_SOURCE_ID
+} from "../../registry.js";
+import { useToolbar } from "../lib/toolbar-context.js";
+import { DashboardGrid } from "./dashboard-grid.js";
+import { ViewportFrame } from "./viewport-frame.js";
+function toWidgetConfig(widget, productSlug, unhealthy) {
+  return {
+    id: widget.id,
+    name: widget.title,
+    component: widget.component,
+    // `w > 6` is what the grid reads as full-width.
+    widgetState: "active",
+    layouts: { lg: { x: 0, y: 0, w: widget.width === "full" ? 12 : 6, h: 4 } },
+    // Passed through ONLY when the registry entry declared them, so the
+    // default lives in exactly one place: `dashboard-grid.tsx`, which is a copy
+    // of the host's own grid and applies the host's own `?? false`.
+    //
+    // This used to default `isCollapsible` to `true` here, which silently
+    // shadowed that copy — `?? false` one layer down never saw `undefined`, so
+    // every widget grew a collapse control whether it asked for one or not, and
+    // the harness showed chrome production would not. Two defaults where one is
+    // unreachable is also the shape of thing that gets "fixed" later by
+    // deleting the wrong one.
+    ...widget.isCollapsible === void 0 ? {} : { isCollapsible: widget.isCollapsible },
+    ...widget.isPinnable === void 0 ? {} : { isPinnable: widget.isPinnable },
+    aiFooterEnabled: widget.aiFooterEnabled,
+    integrationMetadata: {
+      productId: productSlug,
+      productSlug,
+      integrationName: productSlug,
+      description: "",
+      category: "harness",
+      version: "0.0.0"
+    },
+    health: unhealthy ? {
+      status: "unhealthy",
+      lastSuccessAt: "2026-08-27T10:00:00.000Z",
+      errorMessage: "Simulated by the harness toolbar."
+    } : void 0
+  };
+}
+function WidgetSurface({
+  widgets,
+  productSlug,
+  layout = "masonry"
+}) {
+  const { state } = useToolbar();
+  const configs = useMemo(
+    () => widgets.map(
+      (widget) => toWidgetConfig(widget, productSlug, state.unhealthy)
+    ),
+    [widgets, productSlug, state.unhealthy]
+  );
+  return /* @__PURE__ */ jsx(ViewportFrame, { children: /* @__PURE__ */ jsx(
+    DashboardGrid,
+    {
+      widgets: configs,
+      accountId: HARNESS_ACCOUNT_ID,
+      layout,
+      stateOverride: state.renderState,
+      collapsedOverride: state.collapsed,
+      resetKey: `${state.variant}-${String(state.unhealthy)}`
+    }
+  ) });
+}
+export {
+  HARNESS_ACCOUNT_ID,
+  HARNESS_SOURCE_ID,
+  WidgetSurface,
+  toWidgetConfig
+};

package/dist/internal/lib/fonts.d.ts

@@ -0,0 +1,2 @@
+/** Space-joined next/font variable classes to apply to `<html>`. */
+export declare const fontVariables: string;

package/dist/internal/lib/fonts.js

@@ -0,0 +1,22 @@
+import {
+  Bricolage_Grotesque as HeadingFont,
+  Figtree as SansFont
+} from "next/font/google";
+const sans = SansFont({
+  subsets: ["latin"],
+  variable: "--font-sans-fallback",
+  fallback: ["system-ui", "Helvetica Neue", "Helvetica", "Arial"],
+  preload: true,
+  weight: ["300", "400", "500", "600", "700"]
+});
+const heading = HeadingFont({
+  subsets: ["latin"],
+  variable: "--font-heading-fallback",
+  fallback: ["system-ui", "Helvetica Neue", "Helvetica", "Arial"],
+  preload: true,
+  weight: ["200", "300", "400", "500", "600", "700", "800"]
+});
+const fontVariables = [sans, heading].map((f) => f.variable).join(" ");
+export {
+  fontVariables
+};

package/dist/internal/lib/harness-fetch-interceptor.d.ts

@@ -0,0 +1,89 @@
+import type { HttpFixture } from '../../registry.js';
+import { type CompiledFixture, NoRecordedResponseError } from './http-fixtures.js';
+/**
+ * ─────────────────────────────────────────────────────────────────────────────
+ *  THE ONE PLACE A REQUEST CAN LEAVE THE HARNESS
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ * `globalThis.fetch` is patched, once, at module import. That is a heavy
+ * instrument and it is the only one that works, for a reason worth stating
+ * plainly:
+ *
+ *   AN INTERCEPTION A PARTNER CAN DECLINE TO WIRE IS NOT REALLY AN INTERCEPTION.
+ *
+ * The previous design had two interception points — a forced react-query
+ * `queryFn`, and a fetch handed to the partner's own `FetchProvider`. Both are
+ * sound where they apply, and between them they left a third path completely
+ * open: a widget using neither, a `useEffect` calling the global `fetch`,
+ * reached the real network in fixtures mode. The provider was mounted only
+ * when the partner supplied one, so omitting it was an escape hatch.
+ *
+ * Worse, that third path is the SAME population the old query-key fixture
+ * format shut out: a partner not using react-query had no working fixture
+ * surface *and* no interception. The one least served by the design was the
+ * one whose requests escaped. Patching the global closes both at once.
+ *
+ * ── What is deliberately NOT intercepted ─────────────────────────────────────
+ *
+ * Same-origin traffic passes through untouched — with ONE exception.
+ *
+ * Measured against a running harness, same-origin traffic is `/_next/static`,
+ * the document, and the `?_rsc=` payloads client navigation fetches: the
+ * framework's own plumbing, none of it the integration talking to an API.
+ * Intercepting it would break the app to no purpose.
+ *
+ * `/api/` is the exception, because it is the integration's own namespace. A
+ * first-party integration's widgets call `/api/integrations/<slug>/…` rather
+ * than the vendor directly — the vendor call happens server-side, where the
+ * credential lives — and our own Acme example is shaped exactly that way. The
+ * harness serves no backend, so passing those through guarantees a 404; the
+ * useful answer is a fixture, or a refusal that names the URL.
+ *
+ * Scoped to `/api/` rather than "everything except `/_next/`" deliberately: a
+ * rule that has to enumerate the framework's internals is a rule that breaks
+ * the next time Next adds one.
+ *
+ * ── Fail closed ──────────────────────────────────────────────────────────────
+ *
+ * The route table starts REFUSING EVERYTHING and only opens once a provider
+ * publishes one. react-query begins fetching during the mount commit, so a
+ * table installed from an effect would arrive after the first requests; the
+ * safe direction for that race is to refuse, never to allow.
+ */
+/** How the interceptor should answer third-party requests right now. */
+export interface HarnessRoutingTable {
+    mode: 'fixtures' | 'live';
+    /** Compiled fixtures for the active variant. */
+    fixtures: readonly CompiledFixture[];
+    /** Origins live mode may reach. Empty in fixtures mode. */
+    egress: readonly string[];
+    /** Notified for every third-party call. Never throws into the caller. */
+    onCall?: (call: {
+        url: string;
+        method: string;
+        outcome: 'fixture' | 'network' | 'refused';
+    }) => void;
+}
+/**
+ * Publish the table the interceptor answers from.
+ *
+ * Called synchronously during render, which is a deliberate impurity: the
+ * alternative is an effect, and an effect runs AFTER react-query has begun
+ * fetching. The write is idempotent, so StrictMode's double invocation is
+ * harmless. Do not "fix" this into a `useEffect` — that reopens the race the
+ * fail-closed default exists to survive.
+ */
+export declare function publishHarnessRouting(table: HarnessRoutingTable): void;
+/** Restore the fail-closed default — for unmount, and for tests. */
+export declare function closeHarnessRouting(): void;
+/**
+ * Patch `globalThis.fetch`. Idempotent; safe to call from module scope.
+ *
+ * Returns the original, which is what same-origin traffic is passed through
+ * to — captured once so a second patch cannot chain onto our own wrapper.
+ */
+export declare function installHarnessFetch(): typeof globalThis.fetch;
+/** Test seam: undo the patch and reset the table. */
+export declare function uninstallHarnessFetch(original: typeof globalThis.fetch): void;
+export { NoRecordedResponseError };
+export type { HttpFixture };

package/dist/internal/lib/harness-fetch-interceptor.js

@@ -0,0 +1,101 @@
+"use client";
+import { EgressDeniedError, isEgressAllowed } from "@ekanos/sdk/context";
+import {
+  NoRecordedResponseError,
+  fixtureResponse,
+  matchHttpFixture
+} from "./http-fixtures.js";
+const CLOSED = {
+  mode: "fixtures",
+  fixtures: [],
+  egress: []
+};
+let active = CLOSED;
+let installed = false;
+let originalFetch;
+let patchedFetch;
+function redact(url) {
+  const safe = new URL(url.toString());
+  safe.username = "";
+  safe.password = "";
+  const hadQuery = safe.search !== "";
+  safe.search = "";
+  return `${safe.toString()}${hadQuery ? "?\u2026" : ""}`;
+}
+function notify(url, method, outcome) {
+  try {
+    active.onCall?.({ url: redact(url), method, outcome });
+  } catch {
+  }
+}
+function publishHarnessRouting(table) {
+  active = table;
+}
+function closeHarnessRouting() {
+  active = CLOSED;
+}
+function installHarnessFetch() {
+  if (installed && originalFetch !== void 0 && globalThis.fetch === patchedFetch) {
+    return originalFetch;
+  }
+  const original = globalThis.fetch.bind(globalThis);
+  installed = true;
+  originalFetch = original;
+  const intercept = async (input, init) => {
+    const target = typeof input === "string" || input instanceof URL ? String(input) : input.url;
+    const method = (init?.method ?? (typeof input === "object" && "method" in input ? input.method : "GET") ?? "GET").toUpperCase();
+    let url;
+    try {
+      url = new URL(target, globalThis.location?.href);
+    } catch {
+      throw new NoRecordedResponseError(method, target, true);
+    }
+    if (globalThis.location !== void 0 && url.origin === globalThis.location.origin && !url.pathname.startsWith("/api/")) {
+      return original(input, init);
+    }
+    if (active.mode === "live") {
+      if (!isEgressAllowed(url.toString(), active.egress)) {
+        notify(url, method, "refused");
+        throw new EgressDeniedError(url.origin);
+      }
+      notify(url, method, "network");
+      return original(input, {
+        ...init,
+        // An allowlist is a promise about ONE url; following a redirect would
+        // silently make it a promise about wherever that points next, and a
+        // 307/308 carries the method and body along. A browser cannot re-vet
+        // hops — `redirect: 'manual'` yields an opaque response with no
+        // readable Location — so refusing loudly is the only sound choice.
+        redirect: "error"
+      });
+    }
+    const fixture = matchHttpFixture(method, url.toString(), active.fixtures);
+    if (!fixture) {
+      notify(url, method, "refused");
+      throw new NoRecordedResponseError(
+        method,
+        redact(url),
+        globalThis.location === void 0 && url.pathname.startsWith("/api/")
+      );
+    }
+    notify(url, method, "fixture");
+    return fixtureResponse(fixture);
+  };
+  globalThis.fetch = intercept;
+  patchedFetch = intercept;
+  return original;
+}
+function uninstallHarnessFetch(original) {
+  globalThis.fetch = original;
+  installed = false;
+  originalFetch = void 0;
+  patchedFetch = void 0;
+  closeHarnessRouting();
+}
+export {
+  NoRecordedResponseError,
+  closeHarnessRouting,
+  installHarnessFetch,
+  publishHarnessRouting,
+  uninstallHarnessFetch
+};