@ekanos/harness 0.1.0

package/dist/app.d.ts

@@ -0,0 +1,4 @@
+import type { Metadata } from 'next';
+export { RootLayout } from './internal/routes/root-layout.js';
+export { IndexPage } from './internal/routes/index-page.js';
+export declare const harnessMetadata: Metadata;

package/dist/app.js

@@ -0,0 +1,11 @@
+import { RootLayout } from "./internal/routes/root-layout.js";
+import { IndexPage } from "./internal/routes/index-page.js";
+const harnessMetadata = {
+  title: "Fusion Integration Harness",
+  description: "Render integration widgets, marketplace tiles and activation forms in real Fusion chrome, from fixtures, with no Supabase, auth or network."
+};
+export {
+  IndexPage,
+  RootLayout,
+  harnessMetadata
+};

package/dist/config.d.ts

@@ -0,0 +1,18 @@
+import type { HarnessIntegration } from './registry.js';
+/**
+ * Identity function over the harness registry.
+ *
+ * It exists for the type inference, not for the runtime: wrapping the array in
+ * the partner's config module gets them completions and errors on every field
+ * of every entry — widget ids, fixture query keys, the `live` block — at the
+ * point they are typing them, rather than a wall of red on the array's closing
+ * bracket, which is what a bare `: HarnessIntegration[]` annotation produces.
+ *
+ * It also performs the few checks that TypeScript cannot: that slugs and widget
+ * ids are usable as URL segments, and that neither collides. Those are the
+ * mistakes that produce a blank page or a wrong page rather than an error, and
+ * this is the one place every registry entry passes through. Nothing else is
+ * validated or normalised — a partner can still fall back to a plain annotated
+ * array, and gets identical behaviour minus these checks.
+ */
+export declare function defineHarnessConfig(integrations: HarnessIntegration[]): HarnessIntegration[];

package/dist/config.js

@@ -0,0 +1,34 @@
+const SAFE_SEGMENT = /^[a-z0-9][a-z0-9._-]*$/i;
+function assertSafeSegment(kind, value, where) {
+  if (SAFE_SEGMENT.test(value)) return;
+  throw new Error(
+    `defineHarnessConfig(): ${kind} ${JSON.stringify(value)} (${where}) is not usable as a URL segment. It must start with a letter or digit and contain only letters, digits, dot, underscore or hyphen \u2014 the harness routes every surface at /<slug>/\u2026, so a slash, space or "#" here silently produces a page that 404s.`
+  );
+}
+function defineHarnessConfig(integrations) {
+  const seenSlugs = /* @__PURE__ */ new Map();
+  integrations.forEach((integration, index) => {
+    assertSafeSegment("slug", integration.slug, `entry ${index}`);
+    const previous = seenSlugs.get(integration.slug);
+    if (previous !== void 0) {
+      throw new Error(
+        `defineHarnessConfig(): duplicate slug ${JSON.stringify(integration.slug)} at entries ${previous} and ${index}. Every surface is routed by slug, so the later entry would be permanently unreachable and the two would collide as React keys on the index page.`
+      );
+    }
+    seenSlugs.set(integration.slug, index);
+    const seenWidgets = /* @__PURE__ */ new Set();
+    for (const widget of integration.widgets) {
+      assertSafeSegment("widget id", widget.id, `slug "${integration.slug}"`);
+      if (seenWidgets.has(widget.id)) {
+        throw new Error(
+          `defineHarnessConfig(): duplicate widget id ${JSON.stringify(widget.id)} in "${integration.slug}". Widget ids address the single-widget surface, so the second one could never be opened.`
+        );
+      }
+      seenWidgets.add(widget.id);
+    }
+  });
+  return integrations;
+}
+export {
+  defineHarnessConfig
+};

package/dist/internal/components/ask-assistant-bridge.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Stands in for the AI assistant dock.
+ *
+ * In the real app, clicking a widget's "Ask about this" footer sends the
+ * widget's snapshot to the assistant. There is no assistant here — so instead
+ * the harness shows you the exact payload that would have been sent. That makes
+ * this panel the fastest way to check the snapshot rules: is the
+ * data faithful to what's on screen, are the filters included, did it recompute.
+ */
+export declare function AskAssistantBridge(): import("react").JSX.Element | null;

package/dist/internal/components/ask-assistant-bridge.js

@@ -0,0 +1,50 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useCallback, useState } from "react";
+import { useRegisterAskAssistant } from "@ekanos/sdk/hooks";
+import { Button } from "@ekanos/ui/button";
+import { Icon } from "@ekanos/ui/icon";
+function AskAssistantBridge() {
+  const [asked, setAsked] = useState(null);
+  const handler = useCallback((ctx) => {
+    setAsked(ctx);
+  }, []);
+  useRegisterAskAssistant(handler);
+  if (!asked) return null;
+  return /* @__PURE__ */ jsxs("div", { className: "fixed right-6 bottom-24 z-50 flex max-h-[60vh] w-[min(28rem,calc(100vw-3rem))] flex-col overflow-hidden rounded-lg border", children: [
+    /* @__PURE__ */ jsxs("div", { className: "bg-card flex items-center gap-3 border-b px-5 py-3", children: [
+      /* @__PURE__ */ jsx(
+        Icon,
+        {
+          name: "fa-solid fa-wand-magic-sparkles",
+          className: "text-primary h-5 w-5"
+        }
+      ),
+      /* @__PURE__ */ jsxs("div", { className: "min-w-0 flex-1", children: [
+        /* @__PURE__ */ jsx("p", { className: "truncate text-sm font-medium", children: "Ask payload" }),
+        /* @__PURE__ */ jsxs("p", { className: "text-muted-foreground truncate text-xs", children: [
+          asked.title,
+          " \xB7 ",
+          asked.widgetId
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: "ghost",
+          size: "icon",
+          onClick: () => setAsked(null),
+          "aria-label": "Close ask payload",
+          children: /* @__PURE__ */ jsx(Icon, { name: "fa-solid fa-xmark", className: "h-4 w-4" })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "bg-card min-h-0 flex-1 overflow-auto p-5", children: [
+      /* @__PURE__ */ jsx("p", { className: "text-muted-foreground mb-3 text-sm", children: asked.suggestedPrompt }),
+      /* @__PURE__ */ jsx("pre", { className: "bg-muted overflow-x-auto rounded-md p-3 text-xs", children: JSON.stringify(asked.snapshot, null, 2) ?? "null" })
+    ] })
+  ] });
+}
+export {
+  AskAssistantBridge
+};

package/dist/internal/components/dashboard-grid.d.ts

@@ -0,0 +1,45 @@
+import { WidgetConfig } from '@ekanos/sdk';
+import { type WidgetRenderState } from '@ekanos/sdk/components';
+/**
+ * A copy of the host's workspace dashboard grid.
+ *
+ * WHAT CHANGED, and why it had to be a copy rather than an import:
+ *
+ *   - REMOVED the three server-action imports (`pinWidget`, `unpinWidget`,
+ *     `setWidgetCollapsed`). They are `'use server'` + `server-only` + Supabase,
+ *     which is the entire reason the real file cannot be imported here.
+ *
+ *   - SWAPPED the host's `DashboardWidgetProvider` for `HarnessWidgetProvider`,
+ *     which fills the SAME published `WidgetContext` from local state. The host
+ *     provider is host chrome and is not on the `@ekanos/sdk` surface, because
+ *     what makes it host chrome is the widget-config persistence this app has
+ *     no database for. See the long note in `harness-widget-provider.tsx`; the
+ *     resolved render state is identical.
+ *
+ *   - ADDED `stateOverride`, so the dev toolbar can drive the REAL provider
+ *     state machine. This is not cosmetic: `WidgetConfig.widgetState` is typed
+ *     `'active' | 'inactive' | 'disabled'` and cannot express `loading` or
+ *     `error`, even though the provider accepts all five. Without
+ *     this the toolbar could not reach two of the five states at all.
+ *
+ *   - ADDED a `WidgetBoundary` around each widget so one partner's crash
+ *     renders a readable card instead of blanking the page.
+ *
+ * Everything else — grid classes, row grouping, the props handed to the
+ * provider, the two props handed to the widget — is verbatim. If the real grid
+ * changes, this needs the same change.
+ */
+type DashboardGridLayout = 'masonry' | 'two-column';
+interface DashboardGridProps {
+    widgets: WidgetConfig[];
+    accountId: string;
+    layout?: DashboardGridLayout;
+    /** Forced render state from the dev toolbar. */
+    stateOverride?: WidgetRenderState;
+    /** Forced collapsed state from the dev toolbar. */
+    collapsedOverride?: boolean;
+    /** Remount key — changing it resets crashed widget boundaries. */
+    resetKey?: string;
+}
+export declare function DashboardGrid({ widgets, accountId, layout, stateOverride, collapsedOverride, resetKey, }: DashboardGridProps): import("react").JSX.Element;
+export {};

package/dist/internal/components/dashboard-grid.js

@@ -0,0 +1,84 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { HarnessWidgetProvider } from "./harness-widget-provider.js";
+import { buildRowGroups, splitBalanced } from "./row-groups.js";
+import { WidgetBoundary } from "./widget-boundary.js";
+function DashboardGrid({
+  widgets,
+  accountId,
+  layout = "masonry",
+  stateOverride,
+  collapsedOverride,
+  resetKey
+}) {
+  const shared = { accountId, stateOverride, collapsedOverride, resetKey };
+  if (layout === "two-column") {
+    return /* @__PURE__ */ jsx("div", { className: "@container/dashboard grid grid-cols-1 items-start gap-5 @4xl/dashboard:grid-cols-2", children: widgets.map((widget) => /* @__PURE__ */ jsx(WidgetRenderer, { widget, ...shared }, widget.id)) });
+  }
+  const rowGroups = buildRowGroups(widgets);
+  return /* @__PURE__ */ jsx("div", { className: "@container/dashboard space-y-5", children: rowGroups.map((group) => {
+    if (group.type === "full") {
+      return /* @__PURE__ */ jsx(
+        WidgetRenderer,
+        {
+          widget: group.widget,
+          ...shared
+        },
+        group.widget.id
+      );
+    }
+    const { left, right } = splitBalanced(group.widgets);
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "grid grid-cols-1 gap-5 @4xl/dashboard:grid-cols-2 @4xl/dashboard:items-start",
+        children: [
+          /* @__PURE__ */ jsx("div", { className: "flex flex-col gap-5", children: left.map((widget) => /* @__PURE__ */ jsx(WidgetRenderer, { widget, ...shared }, widget.id)) }),
+          /* @__PURE__ */ jsx("div", { className: "flex flex-col gap-5", children: right.map((widget) => /* @__PURE__ */ jsx(WidgetRenderer, { widget, ...shared }, widget.id)) })
+        ]
+      },
+      group.widgets[0].id
+    );
+  }) });
+}
+function WidgetRenderer({
+  widget,
+  accountId,
+  stateOverride,
+  collapsedOverride,
+  resetKey
+}) {
+  const Component = widget.component;
+  const state = stateOverride ?? widget.widgetState;
+  return /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(
+    HarnessWidgetProvider,
+    {
+      widgetId: widget.id,
+      title: widget.name,
+      state,
+      isEnabled: state === "active",
+      isCollapsible: widget.isCollapsible ?? false,
+      isPinnable: widget.isPinnable ?? false,
+      defaultCollapsed: collapsedOverride ?? widget.collapsed ?? false,
+      defaultPinned: widget.isPinned ?? false,
+      maxContentHeight: getMaxContentHeight(widget),
+      aiFooterEnabled: widget.aiFooterEnabled,
+      health: widget.health,
+      children: /* @__PURE__ */ jsx(WidgetBoundary, { widgetId: widget.id, resetKey: `${state}-${resetKey}`, children: /* @__PURE__ */ jsx(
+        Component,
+        {
+          accountId,
+          productId: widget.integrationMetadata?.productId ?? "fusion"
+        }
+      ) })
+    },
+    `${state}-${String(collapsedOverride)}-${resetKey ?? ""}`
+  ) });
+}
+function getMaxContentHeight(widget) {
+  const maxHeight = widget.layouts?.lg?.maxHeight;
+  return maxHeight ? `${maxHeight}px` : void 0;
+}
+export {
+  DashboardGrid
+};

package/dist/internal/components/dev-toolbar.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The persistent dev toolbar. Every control here drives the real machinery
+ * rather than a harness-local imitation:
+ *
+ *  - Render state feeds `DashboardWidgetProvider`'s `state` prop, so you are
+ *    exercising the actual state machine, including the `isEnabled` and health
+ *    downgrades it computes internally.
+ *  - Fixture variant rebuilds the QueryClient with a different seed set.
+ *  - Collapsed feeds `defaultCollapsed`.
+ *  - Unhealthy feeds `health`, reproducing the one production condition that
+ *    silently downgrades an active widget to `disabled`.
+ *
+ * All choices persist to localStorage, so a reload keeps your place.
+ */
+export declare function DevToolbar(): import("react").JSX.Element;

package/dist/internal/components/dev-toolbar.js

@@ -0,0 +1,155 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { usePathname } from "next/navigation";
+import { Button } from "@ekanos/ui/button";
+import { Icon } from "@ekanos/ui/icon";
+import { Label } from "@ekanos/ui/label";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue
+} from "@ekanos/ui/select";
+import { Switch } from "@ekanos/ui/switch";
+import { cn } from "@ekanos/ui/utils";
+import { useTheme } from "next-themes";
+import {
+  DATA_MODES,
+  FIXTURE_VARIANTS,
+  findIntegration,
+  resolveEgress,
+  supportsLiveMode
+} from "../../registry.js";
+import {
+  RENDER_STATES,
+  VIEWPORTS,
+  useToolbar
+} from "../lib/toolbar-context.js";
+import { useHarnessRegistry } from "../registry-context.js";
+function Field({
+  label,
+  children
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1.5", children: [
+    /* @__PURE__ */ jsx(Label, { className: "text-muted-foreground text-xs", children: label }),
+    children
+  ] });
+}
+const DATA_MODE_LABELS = {
+  fixtures: "Fixtures",
+  live: "Live API"
+};
+function useCurrentIntegration() {
+  const integrations = useHarnessRegistry();
+  const pathname = usePathname();
+  const slug = pathname.split("/").filter(Boolean)[0] ?? null;
+  return slug ? findIntegration(integrations, slug) : null;
+}
+function DevToolbar() {
+  const { state, setState, reset } = useToolbar();
+  const { resolvedTheme, setTheme } = useTheme();
+  const integration = useCurrentIntegration();
+  const liveAvailable = supportsLiveMode(integration);
+  const live = liveAvailable && state.dataMode === "live";
+  return /* @__PURE__ */ jsx("div", { className: "bg-card sticky top-0 z-40 border-b", children: /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-end gap-5 px-6 py-3", children: [
+    /* @__PURE__ */ jsx(Field, { label: "Render state", children: /* @__PURE__ */ jsxs(
+      Select,
+      {
+        value: state.renderState,
+        onValueChange: (value) => setState({ renderState: value }),
+        children: [
+          /* @__PURE__ */ jsx(SelectTrigger, { className: "w-36", "data-test": "toolbar-render-state", children: /* @__PURE__ */ jsx(SelectValue, {}) }),
+          /* @__PURE__ */ jsx(SelectContent, { children: RENDER_STATES.map((value) => /* @__PURE__ */ jsx(SelectItem, { value, children: value }, value)) })
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx(Field, { label: "Data", children: /* @__PURE__ */ jsxs(
+      Select,
+      {
+        value: liveAvailable ? state.dataMode : "fixtures",
+        onValueChange: (value) => setState({ dataMode: value }),
+        disabled: !liveAvailable,
+        children: [
+          /* @__PURE__ */ jsx(SelectTrigger, { className: "w-32", "data-test": "toolbar-data-mode", children: /* @__PURE__ */ jsx(SelectValue, {}) }),
+          /* @__PURE__ */ jsx(SelectContent, { children: DATA_MODES.map((value) => /* @__PURE__ */ jsx(SelectItem, { value, children: DATA_MODE_LABELS[value] }, value)) })
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx(Field, { label: "Fixtures", children: /* @__PURE__ */ jsxs(
+      Select,
+      {
+        value: state.variant,
+        onValueChange: (value) => setState({ variant: value }),
+        disabled: live,
+        children: [
+          /* @__PURE__ */ jsx(SelectTrigger, { className: "w-32", "data-test": "toolbar-variant", children: /* @__PURE__ */ jsx(SelectValue, {}) }),
+          /* @__PURE__ */ jsx(SelectContent, { children: FIXTURE_VARIANTS.map((value) => /* @__PURE__ */ jsx(SelectItem, { value, children: value }, value)) })
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx(Field, { label: "Viewport", children: /* @__PURE__ */ jsx("div", { className: "flex gap-1", children: Object.keys(VIEWPORTS).map((key) => /* @__PURE__ */ jsx(
+      Button,
+      {
+        size: "sm",
+        variant: state.viewport === key ? "default" : "outline",
+        onClick: () => setState({ viewport: key }),
+        children: VIEWPORTS[key].label
+      },
+      key
+    )) }) }),
+    /* @__PURE__ */ jsx(Field, { label: "Collapsed", children: /* @__PURE__ */ jsx(
+      Switch,
+      {
+        checked: state.collapsed,
+        onCheckedChange: (checked) => setState({ collapsed: checked }),
+        "aria-label": "Toggle collapsed"
+      }
+    ) }),
+    /* @__PURE__ */ jsx(Field, { label: "Unhealthy", children: /* @__PURE__ */ jsx(
+      Switch,
+      {
+        checked: state.unhealthy,
+        onCheckedChange: (checked) => setState({ unhealthy: checked }),
+        "aria-label": "Simulate unhealthy integration"
+      }
+    ) }),
+    /* @__PURE__ */ jsxs("div", { className: "ml-auto flex items-center gap-2", children: [
+      live ? /* @__PURE__ */ jsxs(
+        "span",
+        {
+          className: "text-primary flex items-center gap-2 text-sm font-medium",
+          "data-test": "toolbar-live-badge",
+          children: [
+            /* @__PURE__ */ jsx(Icon, { name: "fa-solid fa-tower-broadcast", className: "h-4 w-4" }),
+            "Reaching ",
+            resolveEgress(integration).join(", ")
+          ]
+        }
+      ) : null,
+      /* @__PURE__ */ jsxs(
+        Button,
+        {
+          size: "sm",
+          variant: "outline",
+          onClick: () => setTheme(resolvedTheme === "dark" ? "light" : "dark"),
+          "aria-label": "Toggle theme",
+          children: [
+            /* @__PURE__ */ jsxs("span", { className: cn("flex items-center dark:hidden"), children: [
+              /* @__PURE__ */ jsx(Icon, { name: "fa-solid fa-moon", className: "mr-2 h-4 w-4" }),
+              "Dark"
+            ] }),
+            /* @__PURE__ */ jsxs("span", { className: cn("hidden items-center dark:flex"), children: [
+              /* @__PURE__ */ jsx(Icon, { name: "fa-solid fa-sun-bright", className: "mr-2 h-4 w-4" }),
+              "Light"
+            ] })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx(Button, { size: "sm", variant: "ghost", onClick: reset, children: "Reset" })
+    ] })
+  ] }) });
+}
+export {
+  DevToolbar
+};

package/dist/internal/components/harness-providers.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from 'react';
+import type { DataMode, FixtureSeed, HarnessLiveMode } from '../../registry.js';
+import type { CompiledFixture } from '../lib/http-fixtures.js';
+export declare function HarnessProviders({ seeds, mode, live, egress, httpFixtures, slug, children, }: {
+    seeds: FixtureSeed[];
+    /** `fixtures` (default) or `live`. See `lib/harness-query-client.ts`. */
+    mode?: DataMode;
+    /** The integration's live-mode descriptor, when it declares one. */
+    live?: HarnessLiveMode;
+    /** Origins live mode may reach — resolved centrally, see `resolveEgress`. */
+    egress: readonly string[];
+    /** Compiled HTTP fixtures for the active variant. */
+    httpFixtures: readonly CompiledFixture[];
+    slug: string;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/internal/components/harness-providers.js

@@ -0,0 +1,83 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Suspense, useMemo } from "react";
+import {
+  IntegrationActivationProvider
+} from "@ekanos/sdk/hooks";
+import { AskAssistantProvider } from "@ekanos/sdk/hooks";
+import { WidgetEventProvider } from "@ekanos/sdk/hooks";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { TeamAccountWorkspaceContextProvider } from "../../mocks/team-account-workspace.js";
+import {
+  installHarnessFetch,
+  publishHarnessRouting
+} from "../lib/harness-fetch-interceptor.js";
+import {
+  createAllowlistedFetch,
+  createFixturesFetch,
+  logHarnessFetch
+} from "../lib/harness-live-fetch.js";
+import { createHarnessQueryClient } from "../lib/harness-query-client.js";
+import { redactSensitive } from "../lib/redact.js";
+import { AskAssistantBridge } from "./ask-assistant-bridge.js";
+installHarnessFetch();
+const fixtureActivationActions = {
+  activate: async (input) => {
+    console.info(
+      "[harness] activate (fixture, not persisted):",
+      redactSensitive(input)
+    );
+    return { success: true };
+  },
+  deactivate: async (input) => {
+    console.info(
+      "[harness] deactivate (fixture, not persisted):",
+      redactSensitive(input)
+    );
+    return { success: true };
+  }
+};
+function HarnessProviders({
+  seeds,
+  mode = "fixtures",
+  live,
+  egress,
+  httpFixtures,
+  slug,
+  children
+}) {
+  const queryClient = useMemo(
+    () => createHarnessQueryClient(seeds, mode),
+    [seeds, mode]
+  );
+  const harnessFetch = useMemo(() => {
+    if (mode === "live") {
+      return createAllowlistedFetch(egress, { onCall: logHarnessFetch(slug) });
+    }
+    return createFixturesFetch();
+  }, [mode, egress, slug]);
+  useMemo(() => {
+    installHarnessFetch();
+    publishHarnessRouting({
+      mode,
+      fixtures: httpFixtures,
+      egress: mode === "live" ? egress : [],
+      onCall: ({ url, method, outcome }) => {
+        if (outcome === "refused") {
+          console.error(`[harness:${slug}] refused ${method} ${url}`);
+          return;
+        }
+        console.info(`[harness:${slug}] ${outcome} ${method} ${url}`);
+      }
+    });
+  }, [mode, httpFixtures, egress, slug]);
+  const FetchProvider = live?.FetchProvider;
+  const tree = /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsx(TeamAccountWorkspaceContextProvider, { children: /* @__PURE__ */ jsx(IntegrationActivationProvider, { actions: fixtureActivationActions, children: /* @__PURE__ */ jsx(WidgetEventProvider, { children: /* @__PURE__ */ jsxs(AskAssistantProvider, { children: [
+    /* @__PURE__ */ jsx(AskAssistantBridge, {}),
+    /* @__PURE__ */ jsx(Suspense, { fallback: null, children })
+  ] }) }) }) }) });
+  return FetchProvider ? /* @__PURE__ */ jsx(FetchProvider, { fetch: harnessFetch, children: tree }) : tree;
+}
+export {
+  HarnessProviders
+};

package/dist/internal/components/harness-widget-provider.d.ts

@@ -0,0 +1,60 @@
+import { type ReactNode } from 'react';
+import type { WidgetAskContext } from '@ekanos/sdk';
+import { type WidgetHealth, type WidgetRenderState } from '@ekanos/sdk/components';
+/**
+ * ─────────────────────────────────────────────────────────────────────────────
+ *  The harness's widget context provider.
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ * WHY THIS EXISTS — the one symbol the harness could not import.
+ *
+ * `Widget.*` reads everything (render state, collapse/pin, title, ask config)
+ * from `WidgetContext`, and something has to PROVIDE it. In the real app that is
+ * `DashboardWidgetProvider`, which lives in the host's own package and is not
+ * part of the published `@ekanos/sdk` surface — on purpose. It is coupled to
+ * things that only exist inside Fusion: `'use server'` persistence callbacks
+ * for the widget-config hierarchy, and the Supabase rows behind them. The SDK
+ * inversion drew the line exactly there: the SDK exports the CONSUMER side
+ * (`WidgetContext` plus `WidgetContextValue` / `WidgetState` / `WidgetActions` /
+ * `WidgetMeta` / `WidgetRenderState` / `WidgetHealth`) so any shell can fill it,
+ * and keeps the persisting provider host-side.
+ *
+ * So this is not a copy of an unpublished component — it is the documented
+ * alternative. `dashboard-widget-provider.tsx` says so in its own doc comment:
+ *
+ *   "For non-persistent contexts (e.g. admin previews), use a different
+ *    provider that implements the same `WidgetContextValue` interface but
+ *    stores state locally only."
+ *
+ * That is precisely the harness: no database, so nothing to persist. Collapse
+ * and pin toggle locally and reset on reload, which is correct harness
+ * behaviour and is what the host provider did here anyway once its optional
+ * callbacks were omitted.
+ *
+ * Kept deliberately faithful in one non-obvious respect: the `isEnabled` and
+ * `health` downgrade rules below are the host's, verbatim, because a widget's
+ * `disabled` state is reached through them and a harness that resolved state
+ * differently would show a state the product never shows. `pendingCollapse` /
+ * `pendingPin` are always false — with no persistence callback there is never
+ * anything in flight, exactly as in the real grid when it passes none.
+ */
+export interface HarnessWidgetProviderProps {
+    widgetId: string;
+    title?: string;
+    subtitle?: string;
+    description?: string;
+    className?: string;
+    state: WidgetRenderState;
+    isEnabled?: boolean;
+    isCollapsible?: boolean;
+    isPinnable?: boolean;
+    defaultCollapsed?: boolean;
+    defaultPinned?: boolean;
+    maxContentHeight?: string;
+    askContext?: WidgetAskContext;
+    aiFooterEnabled?: boolean;
+    /** Integration health; `unhealthy` downgrades the widget to `disabled`. */
+    health?: WidgetHealth;
+    children: ReactNode;
+}
+export declare function HarnessWidgetProvider({ widgetId, title, subtitle, description, className, state: renderState, isEnabled, isCollapsible, isPinnable, defaultCollapsed, defaultPinned, maxContentHeight, askContext, aiFooterEnabled, health, children, }: HarnessWidgetProviderProps): import("react").JSX.Element;