@ekanos/harness 0.1.0

package/dist/internal/lib/http-fixtures.js

@@ -0,0 +1,256 @@
+class FixtureRequestError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FixtureRequestError";
+  }
+}
+const METHODS = /* @__PURE__ */ new Set([
+  "GET",
+  "HEAD",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS"
+]);
+function splitPath(pathname) {
+  return pathname.split("/").filter((segment) => segment.length > 0);
+}
+function compileFixture(fixture, egress, selfOrigin) {
+  const trimmed = fixture.request.trim();
+  const firstSpace = trimmed.indexOf(" ");
+  if (firstSpace === -1) {
+    throw new FixtureRequestError(
+      `Fixture request ${JSON.stringify(fixture.request)} has no method. Write it as '<METHOD> <url>', for example 'GET https://api.example.com/v1/things'.`
+    );
+  }
+  const method = trimmed.slice(0, firstSpace).toUpperCase();
+  const target = trimmed.slice(firstSpace + 1).trim();
+  if (!METHODS.has(method)) {
+    throw new FixtureRequestError(
+      `Fixture request ${JSON.stringify(fixture.request)} starts with ${JSON.stringify(method)}, which is not an HTTP method. Expected one of ${[...METHODS].join(", ")}.`
+    );
+  }
+  let url;
+  if (/^https?:\/\//i.test(target)) {
+    url = new URL(target);
+  } else {
+    if (!target.startsWith("/")) {
+      throw new FixtureRequestError(
+        `Fixture request ${JSON.stringify(fixture.request)} is neither an absolute URL nor a path starting with '/'.`
+      );
+    }
+    if (target.startsWith("/api/")) {
+      if (selfOrigin === void 0) {
+        throw new FixtureRequestError(
+          `Fixture request ${JSON.stringify(fixture.request)} addresses the host-route namespace (\`/api/\u2026\`), which resolves against the harness's own origin \u2014 and none was supplied. This is a harness wiring fault, not something to fix in your registry entry.`
+        );
+      }
+      url = new URL(target, selfOrigin);
+      return {
+        method,
+        origin: url.origin,
+        segments: splitPath(url.pathname),
+        query: trimmed.includes("?") ? [...url.searchParams.entries()].map(
+          ([key, value]) => [key, value]
+        ) : null,
+        fixture
+      };
+    }
+    if (egress.length === 0) {
+      throw new FixtureRequestError(
+        `Fixture request ${JSON.stringify(fixture.request)} uses the path-only form, which resolves against your integration's \`egress\` \u2014 and your definition declares none.
+
+Either write the absolute form:
+  { request: '${method} https://api.example.com${target}' }
+
+or declare the origin in \`defineIntegration({ egress })\`, after which the shorthand resolves against it.`
+      );
+    }
+    if (egress.length > 1) {
+      throw new FixtureRequestError(
+        `Fixture request ${JSON.stringify(fixture.request)} is path-only, but this integration declares ${egress.length} egress origins (${egress.join(", ")}). The shorthand is only unambiguous with exactly one, so name the origin you meant:
+  { request: '${method} ${egress[0]}${target}' }`
+      );
+    }
+    url = new URL(target, egress[0]);
+  }
+  const query = trimmed.includes("?") ? [...url.searchParams.entries()].map(
+    ([key, value]) => [key, value]
+  ) : null;
+  return {
+    method,
+    origin: url.origin,
+    segments: splitPath(url.pathname),
+    query,
+    fixture
+  };
+}
+function needsSelfOrigin(fixture) {
+  const trimmed = fixture.request.trim();
+  const firstSpace = trimmed.indexOf(" ");
+  if (firstSpace === -1) return false;
+  return trimmed.slice(firstSpace + 1).trim().startsWith("/api/");
+}
+function compileFixtures(fixtures, egress, selfOrigin) {
+  return fixtures.map((fixture) => compileFixture(fixture, egress, selfOrigin));
+}
+function pathMatches(pattern, actual) {
+  for (let index = 0; index < pattern.length; index++) {
+    const segment = pattern[index];
+    if (segment === "*") return true;
+    const candidate = actual[index];
+    if (candidate === void 0) return false;
+    if (segment.startsWith(":")) continue;
+    if (segment !== candidate) return false;
+  }
+  return pattern.length === actual.length;
+}
+function matchHttpFixture(method, requestUrl, compiled) {
+  const url = new URL(requestUrl);
+  const upper = method.toUpperCase();
+  const segments = splitPath(url.pathname);
+  for (const candidate of compiled) {
+    if (candidate.method !== upper) continue;
+    if (candidate.origin !== url.origin) continue;
+    if (!pathMatches(candidate.segments, segments)) continue;
+    if (candidate.query !== null && !candidate.query.every(
+      ([key, value]) => url.searchParams.get(key) === value
+    )) {
+      continue;
+    }
+    return candidate.fixture;
+  }
+  return null;
+}
+function fixtureResponse(fixture) {
+  const hasBody = fixture.response !== void 0;
+  const status = fixture.status ?? (hasBody ? 200 : 204);
+  if (!hasBody || status === 204 || status === 304) {
+    return new Response(null, { status, headers: fixture.headers });
+  }
+  const body = typeof fixture.response === "string" ? fixture.response : JSON.stringify(fixture.response);
+  return new Response(body, {
+    status,
+    headers: {
+      "content-type": typeof fixture.response === "string" ? "text/plain; charset=utf-8" : "application/json",
+      ...fixture.headers
+    }
+  });
+}
+const REDACTED_QUERY = /\?…$/;
+function noRecordedResponseMessage(method, url, deferredToClientRender) {
+  const hadQuery = REDACTED_QUERY.test(url);
+  const withoutRedaction = url.replace(REDACTED_QUERY, "");
+  const asPath = withoutRedaction.replace(/^https?:\/\/[^/]+/, "");
+  const quotable = asPath.startsWith("/api/") ? asPath : withoutRedaction;
+  if (deferredToClientRender) {
+    const path = quotable.replace(/^https?:\/\/[^/]+/, "");
+    const mechanism = [
+      "This request has no origin to resolve against here: either it is",
+      "relative, or it is a host-route (`/api/\u2026`) fixture, and both resolve",
+      "against the harness's own origin \u2014 which a server render does not have.",
+      "They are the only shape not compiled for that pass; every other fixture",
+      "is."
+    ];
+    if (!path.startsWith("/api/")) {
+      return [
+        `No recorded response for ${method} ${url} \u2014 on the SERVER render.`,
+        "",
+        "There is no fixture to write for this one. On the client the harness",
+        "passes same-origin traffic outside `/api/` straight through, as the",
+        "framework plumbing it usually is, so it is never refused there. Only",
+        "the server pass has nowhere to send it.",
+        "",
+        ...mechanism,
+        "",
+        "If it was meant to reach a vendor, give it an absolute URL and it",
+        "becomes an ordinary fixture in both passes."
+      ].join("\n");
+    }
+    return [
+      `No recorded response for ${method} ${url} \u2014 on the SERVER render.`,
+      "",
+      "If you have already recorded this one, nothing is wrong with your",
+      "registry entry and there is nothing to change in it: the client render",
+      "compiles it and answers it, so what you see after hydration is the real",
+      "result.",
+      "",
+      ...mechanism,
+      "",
+      "If you have NOT recorded it, this is the line:",
+      "",
+      `  { request: '${method} ${path}' }`,
+      "",
+      "The path form on purpose. It resolves against whatever origin the",
+      "harness is served from, so it keeps matching when the dev server picks",
+      "a different port; an absolute line would pin it to one.",
+      "",
+      "Answering the SERVER pass too \u2014 a widget that fetches during render",
+      "rather than in an effect \u2014 is the one case that needs an absolute line",
+      "on BOTH sides, fixture and widget, and that does mean hardcoding your",
+      "dev server origin. Worth it only if the server render is something you",
+      "need to see."
+    ].join("\n");
+  }
+  return [
+    `No recorded response for ${method} ${url}.`,
+    "",
+    "Fixtures mode answers every request from your registry entry and",
+    "never leaves the machine, so this call was refused rather than sent.",
+    "Record it:",
+    "",
+    "  fixtures: {",
+    `    default: [{ request: '${method} ${quotable}', response: /* \u2026 */ }],`,
+    "  }",
+    "",
+    "To exercise the failure branch instead, give it a status:",
+    "",
+    `  { request: '${method} ${quotable}', status: 403 }`,
+    "",
+    ...hadQuery ? [
+      "The query string is hidden above because it can carry",
+      "credentials. It is left off the line to paste on purpose: a",
+      "request with no `?` matches whatever query the widget sends.",
+      "Add `?key=value` only to pin params you want matched.",
+      ""
+    ] : [],
+    "If this URL looks unfamiliar, log it from the code that builds it \u2014",
+    "the path and any pinned query params must match exactly."
+  ].join("\n");
+}
+class NoRecordedResponseError extends Error {
+  constructor(method, url, deferredToClientRender = false) {
+    super(noRecordedResponseMessage(method, url, deferredToClientRender));
+    this.method = method;
+    this.url = url;
+    this.deferredToClientRender = deferredToClientRender;
+    this.name = "NoRecordedResponseError";
+  }
+}
+function fixturesToMockHandlers(compiled) {
+  return [
+    {
+      // Every URL. Egress is checked before handlers run, so this cannot widen
+      // what a handler may reach.
+      match: /^/,
+      respond: (request) => {
+        const fixture = matchHttpFixture(request.method, request.url, compiled);
+        if (!fixture) {
+          throw new NoRecordedResponseError(request.method, request.url);
+        }
+        return fixtureResponse(fixture);
+      }
+    }
+  ];
+}
+export {
+  FixtureRequestError,
+  NoRecordedResponseError,
+  compileFixture,
+  compileFixtures,
+  fixtureResponse,
+  fixturesToMockHandlers,
+  matchHttpFixture,
+  needsSelfOrigin
+};

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

@@ -0,0 +1,2 @@
+import i18next from 'i18next';
+export default i18next;

package/dist/internal/lib/i18n.js

@@ -0,0 +1,17 @@
+"use client";
+import i18next from "i18next";
+import { initReactI18next } from "react-i18next";
+if (!i18next.isInitialized) {
+  void i18next.use(initReactI18next).init({
+    lng: "en",
+    fallbackLng: "en",
+    supportedLngs: ["en"],
+    resources: { en: {} },
+    interpolation: { escapeValue: false },
+    react: { useSuspense: false }
+  });
+}
+var i18n_default = i18next;
+export {
+  i18n_default as default
+};

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

@@ -0,0 +1,33 @@
+/**
+ * ─────────────────────────────────────────────────────────────────────────────
+ *  REDACTION FOR THINGS THE HARNESS SHOWS YOU
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ * The harness deliberately surfaces payloads: the activation page's promise is
+ * "submitting shows you what your form handed back instead of posting it", and
+ * the fixture activation actions log their input. That is the feature.
+ *
+ * An activation form is also exactly where an API token is typed. So the same
+ * payload that a partner wants to inspect is one that ends up in a devtools
+ * console, in a screen share, and pasted into an issue. Defaulting to redacted
+ * costs a click and removes a whole category of accident.
+ *
+ * This is a KEY-NAME heuristic, not a classifier: it cannot recognise a secret
+ * that is stored under an innocuous name, and it does not try. It covers the
+ * names credentials are actually given.
+ */
+export declare function isSensitiveKey(key: string): boolean;
+/**
+ * Deep copy with sensitive values replaced.
+ *
+ * Cycles are tolerated (a payload built from form state can hold one), and
+ * anything not JSON-shaped is passed through untouched rather than mangled.
+ */
+export declare function redactSensitive(value: unknown, seen?: WeakSet<WeakKey>): unknown;
+/**
+ * Whether anything in this value WOULD be redacted.
+ *
+ * Drives the "some fields are hidden" affordance, so the reader knows there is
+ * something behind the toggle rather than assuming the payload is complete.
+ */
+export declare function hasSensitiveValues(value: unknown, seen?: WeakSet<WeakKey>): boolean;

package/dist/internal/lib/redact.js

@@ -0,0 +1,43 @@
+const SENSITIVE_KEY_PATTERN = /(^|[^a-z])(token|secret|password|passwd|pwd|api[-_]?key|access[-_]?key|private[-_]?key|credential|auth|authorization|bearer|signature|sig|session|cookie|salt|otp|pin)([^a-z]|$)/i;
+const ALLOWED_KEYS = /* @__PURE__ */ new Set(["queryKey", "publicKey", "keyName", "authType"]);
+function isSensitiveKey(key) {
+  if (ALLOWED_KEYS.has(key)) return false;
+  const snake = key.replace(/([a-z0-9])([A-Z])/g, "$1_$2");
+  return SENSITIVE_KEY_PATTERN.test(key) || SENSITIVE_KEY_PATTERN.test(snake);
+}
+function placeholder(value) {
+  if (typeof value === "string") {
+    return `\u2039redacted \u2014 ${value.length}-char string\u203A`;
+  }
+  return `\u2039redacted \u2014 ${typeof value}\u203A`;
+}
+function redactSensitive(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return "\u2039circular\u203A";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactSensitive(entry, seen));
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      isSensitiveKey(key) ? placeholder(entry) : redactSensitive(entry, seen)
+    ])
+  );
+}
+function hasSensitiveValues(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value !== "object") return false;
+  if (seen.has(value)) return false;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.some((entry) => hasSensitiveValues(entry, seen));
+  }
+  return Object.entries(value).some(
+    ([key, entry]) => isSensitiveKey(key) || hasSensitiveValues(entry, seen)
+  );
+}
+export {
+  hasSensitiveValues,
+  isSensitiveKey,
+  redactSensitive
+};

package/dist/internal/lib/toolbar-context.d.ts

@@ -0,0 +1,59 @@
+import { type ReactNode } from 'react';
+import type { WidgetRenderState } from '@ekanos/sdk/components';
+import { type DataMode, type FixtureVariant } from '../../registry.js';
+export declare const RENDER_STATES: readonly ["active", "loading", "error", "inactive", "disabled"];
+export declare const VIEWPORTS: {
+    readonly mobile: {
+        readonly label: "Mobile";
+        readonly width: 390;
+    };
+    readonly tablet: {
+        readonly label: "Tablet";
+        readonly width: 820;
+    };
+    readonly desktop: {
+        readonly label: "Desktop";
+        readonly width: 1280;
+    };
+    readonly full: {
+        readonly label: "Full";
+        readonly width: null;
+    };
+};
+export type ViewportKey = keyof typeof VIEWPORTS;
+export interface ToolbarState {
+    renderState: WidgetRenderState;
+    /**
+     * Where a widget's data comes from. `fixtures` seeds the react-query cache
+     * and blocks every request; `live` lets the widget's own query functions run
+     * against the real third-party API, through a fetch bound to the
+     * integration's declared egress allowlist. Fusion stays mocked in both.
+     *
+     * Only honoured for integrations that declare a `live` block in the registry.
+     */
+    dataMode: DataMode;
+    variant: FixtureVariant;
+    viewport: ViewportKey;
+    collapsed: boolean;
+    /**
+     * Simulates an integration whose health probe is failing after having
+     * previously succeeded — the one condition that makes
+     * `DashboardWidgetProvider` downgrade an otherwise-active widget to
+     * `disabled`. Off by default so the forced render state above is always the
+     * state you actually get.
+     */
+    unhealthy: boolean;
+}
+/**
+ * Kept as a provider component even though the store is module-level, so the
+ * harness has one obvious place to mount toolbar state and callers use a hook
+ * rather than reaching into module internals.
+ */
+export declare function ToolbarProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function useToolbar(): {
+    state: ToolbarState;
+    setState: (patch: Partial<ToolbarState>) => void;
+    reset: () => void;
+};

package/dist/internal/lib/toolbar-context.js

@@ -0,0 +1,124 @@
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import {
+  useCallback,
+  useMemo,
+  useSyncExternalStore
+} from "react";
+import {
+  DATA_MODES,
+  FIXTURE_VARIANTS
+} from "../../registry.js";
+const RENDER_STATES = [
+  "active",
+  "loading",
+  "error",
+  "inactive",
+  "disabled"
+];
+const VIEWPORTS = {
+  mobile: { label: "Mobile", width: 390 },
+  tablet: { label: "Tablet", width: 820 },
+  desktop: { label: "Desktop", width: 1280 },
+  full: { label: "Full", width: null }
+};
+const DEFAULT_STATE = {
+  renderState: "active",
+  // Fixtures by default, always. Opening the harness must never fire a request
+  // at somebody's API just because a previous session left a switch flipped for
+  // a different integration.
+  dataMode: "fixtures",
+  variant: "default",
+  viewport: "full",
+  collapsed: false,
+  unhealthy: false
+};
+const STORAGE_KEY = "fusion-harness-toolbar";
+function isRenderState(value) {
+  return RENDER_STATES.includes(value);
+}
+function isVariant(value) {
+  return FIXTURE_VARIANTS.includes(value);
+}
+function isDataMode(value) {
+  return DATA_MODES.includes(value);
+}
+function isViewport(value) {
+  return Object.hasOwn(VIEWPORTS, value);
+}
+function readStored() {
+  try {
+    const raw = window.localStorage.getItem(STORAGE_KEY);
+    if (!raw) return DEFAULT_STATE;
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) return DEFAULT_STATE;
+    const candidate = parsed;
+    return {
+      renderState: isRenderState(candidate.renderState) ? candidate.renderState : DEFAULT_STATE.renderState,
+      dataMode: isDataMode(candidate.dataMode) ? candidate.dataMode : DEFAULT_STATE.dataMode,
+      variant: isVariant(candidate.variant) ? candidate.variant : DEFAULT_STATE.variant,
+      viewport: isViewport(candidate.viewport) ? candidate.viewport : DEFAULT_STATE.viewport,
+      collapsed: typeof candidate.collapsed === "boolean" ? candidate.collapsed : DEFAULT_STATE.collapsed,
+      unhealthy: typeof candidate.unhealthy === "boolean" ? candidate.unhealthy : DEFAULT_STATE.unhealthy
+    };
+  } catch (error) {
+    console.warn("[harness] Could not read stored toolbar state:", error);
+    return DEFAULT_STATE;
+  }
+}
+let cached = null;
+const listeners = /* @__PURE__ */ new Set();
+function getSnapshot() {
+  cached ??= readStored();
+  return cached;
+}
+function getServerSnapshot() {
+  return DEFAULT_STATE;
+}
+function subscribe(listener) {
+  listeners.add(listener);
+  const onStorage = (event) => {
+    if (event.key !== STORAGE_KEY) return;
+    cached = null;
+    listeners.forEach((l) => l());
+  };
+  window.addEventListener("storage", onStorage);
+  return () => {
+    listeners.delete(listener);
+    window.removeEventListener("storage", onStorage);
+  };
+}
+function writeState(next) {
+  cached = next;
+  try {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(next));
+  } catch (error) {
+    console.warn("[harness] Could not persist toolbar state:", error);
+  }
+  listeners.forEach((listener) => listener());
+}
+function ToolbarProvider({ children }) {
+  return /* @__PURE__ */ jsx(Fragment, { children });
+}
+function useToolbar() {
+  const state = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+  const setState = useCallback((patch) => {
+    writeState({ ...getSnapshot(), ...patch });
+  }, []);
+  const reset = useCallback(() => {
+    try {
+      window.localStorage.removeItem(STORAGE_KEY);
+    } catch (error) {
+      console.warn("[harness] Could not clear toolbar state:", error);
+    }
+    cached = DEFAULT_STATE;
+    listeners.forEach((listener) => listener());
+  }, []);
+  return useMemo(() => ({ state, setState, reset }), [state, setState, reset]);
+}
+export {
+  RENDER_STATES,
+  ToolbarProvider,
+  VIEWPORTS,
+  useToolbar
+};

package/dist/internal/registry-context.d.ts

@@ -0,0 +1,27 @@
+import { type ReactNode } from 'react';
+import type { HarnessIntegration } from '../registry.js';
+export declare function HarnessRegistryProvider({ integrations, children, }: {
+    integrations: HarnessIntegration[];
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * The registry the shell injected.
+ *
+ * Throws rather than returning `[]` when the provider is missing. An empty
+ * registry is a legitimate state — a partner who has not registered anything
+ * yet — and the index page renders a specific "nothing registered" panel for
+ * it. Conflating that with "the shell forgot to mount the provider" would turn
+ * a wiring bug into a page that looks like it is working correctly.
+ */
+export declare function useHarnessRegistry(): HarnessIntegration[];
+/**
+ * The integration named by the current `[slug]` segment, or `null`.
+ *
+ * `useParams()` is how a route component under `app/[slug]/` reads its own
+ * segment now that the shell's route files are one-line re-exports with no
+ * `params` prop to forward. It returns the same value the `params` promise
+ * used to resolve to, without the `use()` unwrap.
+ */
+export declare function useHarnessIntegration(): HarnessIntegration | null;
+/** The `[widgetId]` segment of the current route. */
+export declare function useHarnessWidgetId(): string;

package/dist/internal/registry-context.js

@@ -0,0 +1,51 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { createContext, use, useEffect } from "react";
+import { useParams } from "next/navigation";
+import { findIntegration } from "../registry.js";
+const HarnessRegistryContext = createContext(null);
+function warnAboutBundledSecrets(integrations) {
+  const withSecrets = integrations.filter((integration) => {
+    const secrets = integration.triggerMocks?.secrets;
+    return Object.keys(secrets?.account ?? {}).length > 0 || Object.keys(secrets?.admin ?? {}).length > 0;
+  }).map((integration) => integration.slug);
+  if (withSecrets.length === 0) return;
+  console.warn(
+    `[harness] ${withSecrets.join(", ")} seed triggerMocks.secrets, and those literals are compiled into the browser bundle and written into the .next build output \u2014 the registry has to reach the client, so this is inherent, not a bug. Keep them fake, and do not commit or deploy the build directory.`
+  );
+}
+let warnedAboutSecrets = false;
+function HarnessRegistryProvider({
+  integrations,
+  children
+}) {
+  useEffect(() => {
+    if (warnedAboutSecrets) return;
+    warnedAboutSecrets = true;
+    warnAboutBundledSecrets(integrations);
+  }, [integrations]);
+  return /* @__PURE__ */ jsx(HarnessRegistryContext, { value: integrations, children });
+}
+function useHarnessRegistry() {
+  const integrations = use(HarnessRegistryContext);
+  if (integrations === null) {
+    throw new Error(
+      "useHarnessRegistry() was called outside HarnessRegistryProvider. The shell's app/harness-shell.tsx must render `<RootLayout integrations={harnessIntegrations}>` from @ekanos/harness/app. (app/layout.tsx only re-exports it \u2014 the injection lives in harness-shell.tsx, which is `use client` because the registry holds component references that cannot cross the server boundary.)"
+    );
+  }
+  return integrations;
+}
+function useHarnessIntegration() {
+  const integrations = useHarnessRegistry();
+  const params = useParams();
+  return findIntegration(integrations, params.slug);
+}
+function useHarnessWidgetId() {
+  return useParams().widgetId;
+}
+export {
+  HarnessRegistryProvider,
+  useHarnessIntegration,
+  useHarnessRegistry,
+  useHarnessWidgetId
+};

package/dist/internal/routes/activation-page.d.ts

@@ -0,0 +1,33 @@
+/**
+ * ─────────────────────────────────────────────────────────────────────────────
+ *  ACTIVATION — the real connect FLOW, not just the form
+ * ─────────────────────────────────────────────────────────────────────────────
+ *
+ * In production a user never sees an activation form on a page of its own. They
+ * see the connect MODAL on `/integrations`
+ * (the host's integration connect dialog),
+ * which wraps the partner's form in four things the form itself does not own:
+ *
+ *   1. dialog chrome — logo/monogram, integration name, one-line summary;
+ *   2. "What it does"      — rendered from `definition.capabilities`;
+ *   3. "What it can access" — rendered from `definition.permissions`, with a
+ *      Read/Write badge per row. This is the SCOPE DISCLOSURE a user consents
+ *      against, so a partner needs to see how their declaration actually reads;
+ *   4. the connected state — once activated, the form is replaced by a manage
+ *      view whose only action is Disconnect.
+ *
+ * Rendering the bare form told a partner nothing about (2) and (3), which are
+ * generated entirely from their own definition and are the two things most
+ * likely to read badly. So this surface reproduces the whole flow: connect →
+ * connected → disconnect, against the same declarations the host reads.
+ *
+ * What stays harness-specific is the payload readout below the dialog. There is
+ * no backend to post to, and the `ActivationResult` the form handed back is the
+ * exact object the real server action would have persisted — so showing it is
+ * more useful here than swallowing it.
+ *
+ * NOTE: the dialog renders through a portal on `<body>`, so the toolbar's
+ * viewport presets cannot constrain it — the same is true of the real modal, and
+ * it is why this surface has no `ViewportFrame`.
+ */
+export declare function ActivationPage(): import("react").JSX.Element;