@ekanos/harness 0.1.0

package/dist/internal/routes/triggers-page.js

@@ -0,0 +1,386 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { notFound } from "next/navigation";
+import { isEgressAllowed } from "@ekanos/sdk/context";
+import {
+  createMockContext,
+  invokeSchedule,
+  invokeWebhook
+} from "@ekanos/sdk/testing";
+import { Alert, AlertDescription, AlertTitle } from "@ekanos/ui/alert";
+import { Badge } from "@ekanos/ui/badge";
+import { Button } from "@ekanos/ui/button";
+import { Textarea } from "@ekanos/ui/textarea";
+import {
+  HARNESS_ACCOUNT_ID,
+  resolveEgress
+} from "../../registry.js";
+import { compileFixtures, fixturesToMockHandlers } from "../lib/http-fixtures.js";
+import { useToolbar } from "../lib/toolbar-context.js";
+import { useHarnessIntegration } from "../registry-context.js";
+function useTriggerContext(integration, variant) {
+  const [ctx] = useState(() => {
+    const definition = integration.definition;
+    if (!definition) return null;
+    const mocks = integration.triggerMocks ?? {};
+    return createMockContext({
+      accountId: HARNESS_ACCOUNT_ID,
+      integration: { slug: definition.slug },
+      ...definition.storage ? { storageSchemas: definition.storage } : {},
+      egress: definition.egress ?? [],
+      ...mocks.storage ? {
+        storage: mocks.storage
+      } : {},
+      ...mocks.secrets ? { secrets: mocks.secrets } : {},
+      fetchHandlers: [
+        ...mocks.fetchHandlers ?? [],
+        ...fixturesToMockHandlers(
+          // Client-only, like the layout: no origin on the server, and
+          // nothing fetches there.
+          globalThis.location === void 0 ? [] : compileFixtures(
+            integration.fixtures?.[variant] ?? [],
+            resolveEgress(integration),
+            globalThis.location.origin
+          )
+        )
+      ]
+    });
+  });
+  return ctx;
+}
+function OutcomePanel({ outcome }) {
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-3", "data-test": "trigger-outcome", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx(Badge, { variant: outcome.ok ? "default" : "destructive", children: outcome.summary }),
+      outcome.detail ? /* @__PURE__ */ jsx("span", { className: "text-muted-foreground text-sm", children: outcome.detail }) : null
+    ] }),
+    outcome.logs.length > 0 ? /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1", children: [
+      /* @__PURE__ */ jsx("span", { className: "text-muted-foreground text-xs", children: "Handler logs" }),
+      /* @__PURE__ */ jsx("pre", { className: "bg-muted max-h-48 overflow-auto rounded-md p-3 text-xs", children: outcome.logs.map((log) => `[${log.level}] ${log.message}`).join("\n") })
+    ] }) : null,
+    /* @__PURE__ */ jsx("div", { className: "flex flex-col gap-3", children: ["account", "user"].map((scope) => /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1", children: [
+      /* @__PURE__ */ jsxs("span", { className: "text-muted-foreground text-xs", children: [
+        scope === "account" ? "Account" : "User",
+        " storage after this run",
+        Object.keys(outcome.storage[scope]).length === 0 ? " (empty)" : ""
+      ] }),
+      /* @__PURE__ */ jsx("pre", { className: "bg-muted max-h-64 overflow-auto rounded-md p-3 text-xs", children: JSON.stringify(outcome.storage[scope], null, 2) })
+    ] }, scope)) })
+  ] });
+}
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function WebhookCard({
+  definition,
+  webhook,
+  ctx
+}) {
+  const [state, setState] = useState(() => ({
+    payload: JSON.stringify(webhook.examplePayload ?? {}, null, 2),
+    outcome: null,
+    busy: false
+  }));
+  const deliver = async () => {
+    setState((s) => ({ ...s, busy: true }));
+    const logsBefore = ctx.logs.length;
+    let outcome;
+    try {
+      const payload = JSON.parse(state.payload);
+      const { result } = await invokeWebhook(definition, webhook.id, payload, {
+        context: ctx,
+        headers: webhook.signature === "none" ? {} : { [webhook.signature.header]: "(unverified \u2014 local transport)" }
+      });
+      outcome = {
+        ok: true,
+        summary: result.status,
+        ...result.detail ? { detail: result.detail } : {},
+        logs: ctx.logs.slice(logsBefore),
+        storage: ctx.dumpStorage()
+      };
+    } catch (error) {
+      console.error("[harness] webhook invocation failed:", error);
+      outcome = {
+        ok: false,
+        summary: "failed",
+        detail: describeError(error),
+        logs: ctx.logs.slice(logsBefore),
+        storage: ctx.dumpStorage()
+      };
+    }
+    setState((s) => ({ ...s, outcome, busy: false }));
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "bg-card flex flex-col gap-5 rounded-lg border p-6",
+      "data-test": `webhook-${webhook.id}`,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-3", children: [
+          /* @__PURE__ */ jsx("h3", { className: "font-heading text-lg tracking-tight", children: /* @__PURE__ */ jsx("code", { children: webhook.id }) }),
+          /* @__PURE__ */ jsx(Badge, { variant: "outline", children: "webhook" }),
+          webhook.signature === "none" ? /* @__PURE__ */ jsx(Badge, { variant: "secondary", children: "unsigned" }) : /* @__PURE__ */ jsxs(Badge, { variant: "secondary", children: [
+            "signed: ",
+            webhook.signature.header,
+            ' \u21D0 secret "',
+            webhook.signature.secretName,
+            '"'
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-sm", children: webhook.description }),
+        webhook.signature !== "none" ? /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-xs", children: "Signature verification is the transport's job \u2014 the harness skips it (and says so in the handler logs); the host ingress will enforce it before your handler ever runs." }) : null,
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2", children: [
+          /* @__PURE__ */ jsxs("span", { className: "text-muted-foreground text-xs", children: [
+            "Payload (validated against ",
+            /* @__PURE__ */ jsx("code", { children: "payloadSchema" }),
+            " before the handler runs)"
+          ] }),
+          /* @__PURE__ */ jsx(
+            Textarea,
+            {
+              value: state.payload,
+              onChange: (event) => setState((s) => ({ ...s, payload: event.target.value })),
+              rows: 10,
+              className: "font-mono text-xs",
+              "data-test": `webhook-payload-${webhook.id}`
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(
+          Button,
+          {
+            onClick: deliver,
+            disabled: state.busy,
+            "data-test": `webhook-deliver-${webhook.id}`,
+            children: "Deliver webhook"
+          }
+        ) }),
+        state.outcome ? /* @__PURE__ */ jsx(OutcomePanel, { outcome: state.outcome }) : null
+      ]
+    }
+  );
+}
+function ScheduleCard({
+  definition,
+  schedule,
+  ctx
+}) {
+  const [state, setState] = useState({ outcome: null, busy: false });
+  const runNow = async () => {
+    setState((s) => ({ ...s, busy: true }));
+    const logsBefore = ctx.logs.length;
+    let outcome;
+    try {
+      const { result } = await invokeSchedule(definition, schedule.id, {
+        context: ctx
+      });
+      outcome = {
+        ok: true,
+        summary: result.status,
+        ...result.detail ? { detail: result.detail } : {},
+        logs: ctx.logs.slice(logsBefore),
+        storage: ctx.dumpStorage()
+      };
+    } catch (error) {
+      console.error("[harness] schedule invocation failed:", error);
+      outcome = {
+        ok: false,
+        summary: "failed",
+        detail: describeError(error),
+        logs: ctx.logs.slice(logsBefore),
+        storage: ctx.dumpStorage()
+      };
+    }
+    setState({ outcome, busy: false });
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "bg-card flex flex-col gap-5 rounded-lg border p-6",
+      "data-test": `schedule-${schedule.id}`,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-3", children: [
+          /* @__PURE__ */ jsx("h3", { className: "font-heading text-lg tracking-tight", children: /* @__PURE__ */ jsx("code", { children: schedule.id }) }),
+          /* @__PURE__ */ jsx(Badge, { variant: "outline", children: "schedule" }),
+          /* @__PURE__ */ jsx(Badge, { variant: "secondary", children: /* @__PURE__ */ jsx("code", { children: schedule.cron }) })
+        ] }),
+        /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-sm", children: schedule.description }),
+        /* @__PURE__ */ jsxs("p", { className: "text-muted-foreground text-xs", children: [
+          "The host scheduler fires this cron with",
+          " ",
+          /* @__PURE__ */ jsx("code", { children: "trigger: 'schedule'" }),
+          '. "Run now" invokes the same handler with ',
+          /* @__PURE__ */ jsx("code", { children: "trigger: 'manual'" }),
+          " \u2014 your handler must be safe under both."
+        ] }),
+        /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(
+          Button,
+          {
+            onClick: runNow,
+            disabled: state.busy,
+            "data-test": `schedule-run-${schedule.id}`,
+            children: "Run now"
+          }
+        ) }),
+        state.outcome ? /* @__PURE__ */ jsx(OutcomePanel, { outcome: state.outcome }) : null
+      ]
+    }
+  );
+}
+function OAuthCard({ definition }) {
+  const oauth = definition.oauth;
+  if (!oauth) return null;
+  const egress = definition.egress ?? [];
+  const rows = [
+    ["Authorization URL", oauth.provider.authorizationUrl],
+    ["Token URL", oauth.provider.tokenUrl],
+    ["Scopes", oauth.provider.scopes.join(" ") || "(none)"],
+    ["PKCE", oauth.provider.pkce ? "yes" : "no"],
+    ["Client id secret", oauth.credentials.clientIdSecretName],
+    ["Client secret secret", oauth.credentials.clientSecretSecretName]
+  ];
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "bg-card flex flex-col gap-5 rounded-lg border p-6",
+      "data-test": "oauth-declaration",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-3", children: [
+          /* @__PURE__ */ jsx("h3", { className: "font-heading text-lg tracking-tight", children: "OAuth declaration" }),
+          /* @__PURE__ */ jsx(Badge, { variant: "outline", children: "oauth" })
+        ] }),
+        /* @__PURE__ */ jsxs("dl", { className: "grid grid-cols-1 gap-x-6 gap-y-2 text-sm sm:grid-cols-[auto_1fr]", children: [
+          rows.map(([label, value]) => /* @__PURE__ */ jsxs("div", { className: "contents", children: [
+            /* @__PURE__ */ jsx("dt", { className: "text-muted-foreground", children: label }),
+            /* @__PURE__ */ jsx("dd", { children: /* @__PURE__ */ jsx("code", { className: "break-all", children: value }) })
+          ] }, label)),
+          /* @__PURE__ */ jsxs("div", { className: "contents", children: [
+            /* @__PURE__ */ jsx("dt", { className: "text-muted-foreground", children: "Egress coverage" }),
+            /* @__PURE__ */ jsx("dd", { className: "flex gap-2", children: [
+              ...new Map(
+                [oauth.provider.authorizationUrl, oauth.provider.tokenUrl].map(
+                  (url) => [new URL(url).origin, url]
+                )
+              )
+            ].map(([origin]) => {
+              const covered = [
+                oauth.provider.authorizationUrl,
+                oauth.provider.tokenUrl
+              ].filter((url) => new URL(url).origin === origin).every((url) => isEgressAllowed(url, egress));
+              return /* @__PURE__ */ jsx(
+                Badge,
+                {
+                  variant: covered ? "secondary" : "destructive",
+                  children: origin
+                },
+                origin
+              );
+            }) })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs(Alert, { children: [
+          /* @__PURE__ */ jsx(AlertTitle, { children: "Declaration only \u2014 the flow is the transport" }),
+          /* @__PURE__ */ jsxs(AlertDescription, { children: [
+            /* @__PURE__ */ jsxs("p", { children: [
+              "The authorize \u2192 callback \u2192 code-exchange loop is owned by the transport, not by integration code: your package declares the endpoints and persists tokens in ",
+              /* @__PURE__ */ jsx("code", { children: "onTokens" }),
+              " via",
+              " ",
+              /* @__PURE__ */ jsx("code", { children: "ctx.secrets" }),
+              ". This harness renders the declaration and checks its egress coverage; it does not run the flow."
+            ] }),
+            /* @__PURE__ */ jsxs("p", { children: [
+              /* @__PURE__ */ jsx("strong", { children: "Redirect URI \u2014 host-derived, and not something you declare." }),
+              " ",
+              "The host owns the callback route and builds the URI from its own origin, so there is no field for it in",
+              " ",
+              /* @__PURE__ */ jsx("code", { children: "defineIntegration()" }),
+              " and adding one would either be ignored or point the host's callback somewhere it should not go. Register this with your provider, against whichever host will run the flow:"
+            ] }),
+            /* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsxs("code", { children: [
+              "https://<your-fusion-host>/api/integrations/",
+              definition.slug,
+              "/callback"
+            ] }) }),
+            /* @__PURE__ */ jsxs("p", { children: [
+              "The harness does not serve that route, so you cannot complete a round trip here. What you CAN check is above: that the endpoints you declared are inside your egress list. Until a transport exists, unit test ",
+              /* @__PURE__ */ jsx("code", { children: "onTokens" }),
+              " directly with",
+              " ",
+              /* @__PURE__ */ jsx("code", { children: "createMockContext()" }),
+              " \u2014 it is an ordinary async function."
+            ] })
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+function TriggersPage() {
+  const integration = useHarnessIntegration();
+  const { state } = useToolbar();
+  const ctx = useTriggerContext(
+    integration ?? { slug: "", name: "", description: "", widgets: [] },
+    state.variant
+  );
+  if (!integration) notFound();
+  const definition = integration.definition;
+  const webhooks = definition?.webhooks ?? [];
+  const schedules = definition?.schedules ?? [];
+  const declaresAnything = webhooks.length > 0 || schedules.length > 0 || Boolean(definition?.oauth);
+  return /* @__PURE__ */ jsxs(
+    "main",
+    {
+      className: "mx-auto flex w-full max-w-3xl flex-col gap-6 px-6 py-8",
+      "data-test": "triggers",
+      children: [
+        /* @__PURE__ */ jsxs(Alert, { children: [
+          /* @__PURE__ */ jsx(AlertTitle, { children: "The local transport for declared event surfaces" }),
+          /* @__PURE__ */ jsx(AlertDescription, { children: /* @__PURE__ */ jsxs("p", { children: [
+            "Webhooks and schedules below run their REAL handlers against one in-memory mock context (state accumulates until you leave the page). Payloads are validated against each webhook's",
+            " ",
+            /* @__PURE__ */ jsx("code", { children: "payloadSchema" }),
+            ", signature checks are logged as skipped, and egress is enforced from the definition \u2014 the same declarations the host's ingress, scheduler, and hosted OAuth callback bind to later."
+          ] }) })
+        ] }),
+        !definition ? /* @__PURE__ */ jsxs("p", { className: "text-muted-foreground text-sm", children: [
+          "This harness entry does not link its ",
+          /* @__PURE__ */ jsx("code", { children: "defineIntegration()" }),
+          " ",
+          "output. Add ",
+          /* @__PURE__ */ jsx("code", { children: "definition: integration" }),
+          " to the entry in your harness config to light this surface up."
+        ] }) : !declaresAnything ? /* @__PURE__ */ jsxs("p", { className: "text-muted-foreground text-sm", children: [
+          /* @__PURE__ */ jsx("code", { children: definition.slug }),
+          " declares no webhooks, schedules, or OAuth \u2014 which is a perfectly good answer for an integration that only reads. The ",
+          /* @__PURE__ */ jsx("code", { children: "@ekanos/sdk" }),
+          " README has a worked example of each, under \u201CDeclarable surfaces\u201D."
+        ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+          ctx ? webhooks.map((webhook) => /* @__PURE__ */ jsx(
+            WebhookCard,
+            {
+              definition,
+              webhook,
+              ctx
+            },
+            webhook.id
+          )) : null,
+          ctx ? schedules.map((schedule) => /* @__PURE__ */ jsx(
+            ScheduleCard,
+            {
+              definition,
+              schedule,
+              ctx
+            },
+            schedule.id
+          )) : null,
+          /* @__PURE__ */ jsx(OAuthCard, { definition })
+        ] })
+      ]
+    }
+  );
+}
+export {
+  TriggersPage
+};

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

@@ -0,0 +1 @@
+export declare function WidgetsPage(): import("react").JSX.Element;

package/dist/internal/routes/widgets-page.js

@@ -0,0 +1,19 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { notFound } from "next/navigation";
+import { WidgetSurface } from "../components/widget-surface.js";
+import { useHarnessIntegration } from "../registry-context.js";
+function WidgetsPage() {
+  const integration = useHarnessIntegration();
+  if (!integration) notFound();
+  return /* @__PURE__ */ jsx("main", { className: "mx-auto w-full max-w-5xl px-6 py-8", "data-test": "widgets", children: integration.widgets.length === 0 ? /* @__PURE__ */ jsx("p", { className: "text-muted-foreground text-sm", children: "This integration registers no widgets." }) : /* @__PURE__ */ jsx(
+    WidgetSurface,
+    {
+      widgets: integration.widgets,
+      productSlug: integration.slug
+    }
+  ) });
+}
+export {
+  WidgetsPage
+};

package/dist/internal/surfaces.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The per-integration surfaces, in tab order — declared ONCE.
+ *
+ * This list used to exist twice: `surface-nav.tsx` had four entries and
+ * `index-page.tsx` had three, and the one the index dropped was Triggers. A
+ * partner dogfooding the harness called Triggers the best surface in the
+ * product and found it only by reading our clean-room script, because nothing
+ * on the landing page linked to it.
+ *
+ * Two lists of the same thing drift silently; a missing tab is invisible until
+ * someone counts. Both consumers now read this, so adding a surface is one
+ * edit. No `'use client'` — the index page is a server component and must
+ * stay one.
+ */
+export interface HarnessSurface {
+    /** URL segment under `/[slug]/`. */
+    segment: string;
+    /** Tab-bar label. */
+    label: string;
+    /** Shorter label for the landing page's link row, where space is tight. */
+    shortLabel: string;
+    /** Font Awesome spec — a weight the FREE package actually ships. */
+    icon: string;
+}
+export declare const HARNESS_SURFACES: readonly HarnessSurface[];

package/dist/internal/surfaces.js

@@ -0,0 +1,29 @@
+const HARNESS_SURFACES = [
+  {
+    segment: "widgets",
+    label: "Widgets",
+    shortLabel: "Widgets",
+    icon: "fa-solid fa-table-cells-large"
+  },
+  {
+    segment: "tile",
+    label: "Marketplace tile",
+    shortLabel: "Tile",
+    icon: "fa-solid fa-store"
+  },
+  {
+    segment: "activation",
+    label: "Activation",
+    shortLabel: "Activation",
+    icon: "fa-solid fa-plug"
+  },
+  {
+    segment: "triggers",
+    label: "Triggers",
+    shortLabel: "Triggers",
+    icon: "fa-solid fa-bolt"
+  }
+];
+export {
+  HARNESS_SURFACES
+};

package/dist/mocks/team-account-workspace.d.ts

@@ -0,0 +1,78 @@
+import { type ReactNode } from 'react';
+/**
+ * A drop-in mock of the host's `use-team-account-workspace` hook.
+ *
+ * WHY THIS EXISTS: most first-party widgets call `useTeamAccountWorkspace()`
+ * for `account.slug` when building navigation links. Importing the genuine hook
+ * would be fine on its own, but it re-exports through the host's team-accounts
+ * component barrel, which reaches Supabase — and the harness is meant to have
+ * no Supabase in it at all.
+ *
+ * So the harness aliases that specifier onto this module. The specifier itself
+ * is named ONLY in build config — `next.config.mjs` →
+ * `turbopack.resolveAlias`, and the matching `paths` entry in `tsconfig.json` —
+ * never in harness source, which imports nothing from the host workspace.
+ * Unmodified first-party widget source keeps compiling and running; it just
+ * gets harness values. Partner integrations built on `@ekanos/sdk` never reach
+ * for the hook at all (neither the SDK nor either example imports it), so a
+ * scaffolded copy can drop the alias and this file together.
+ *
+ * Two behaviours of the real hook are reproduced deliberately:
+ *   - the context holds a PROMISE, not a resolved value;
+ *   - the hook calls `use()` on it, so it suspends.
+ * The promise below is created once at module scope and already resolved, so
+ * `use()` settles on the first attempt and nothing visibly suspends — but a
+ * `<Suspense>` boundary above it is still the correct thing to have.
+ */
+export interface HarnessAccount {
+    id: string;
+    name: string;
+    permissions: string[];
+    picture_url: string;
+    primary_owner_user_id: string;
+    role: string;
+    role_hierarchy_level: number;
+    slug: string;
+    source_id: string;
+    subscription_status: string;
+}
+export interface HarnessUser {
+    id: string;
+    email: string;
+    phone: string;
+    is_anonymous: boolean;
+    aal: 'aal1' | 'aal2';
+    app_metadata: Record<string, unknown>;
+    user_metadata: Record<string, unknown>;
+    amr: unknown[];
+}
+export interface AccountWorkspace {
+    accounts: {
+        id: string | null;
+        name: string | null;
+        picture_url: string | null;
+        role: string | null;
+        slug: string | null;
+        source_id: string | null;
+    }[];
+    account: HarnessAccount;
+    user: HarnessUser;
+    membership?: {
+        preferences: {
+            first_use: {
+                completed: boolean;
+                completed_at: string | null;
+                skipped: boolean;
+                steps_completed: string[];
+            };
+            landing_zone: 'dashboard' | 'integrations' | 'workspace' | null;
+        };
+    };
+}
+export declare const TeamAccountWorkspaceContext: import("react").Context<Promise<AccountWorkspace> | null>;
+export declare function TeamAccountWorkspaceContextProvider({ children, value, }: {
+    children: ReactNode;
+    value?: Promise<AccountWorkspace>;
+}): import("react").JSX.Element;
+export declare function useTeamAccountWorkspace(): AccountWorkspace;
+export declare function useTeamAccountWorkspaceOptional(): AccountWorkspace | null;

package/dist/mocks/team-account-workspace.js

@@ -0,0 +1,86 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { createContext, use, useContext } from "react";
+import {
+  HARNESS_ACCOUNT_ID,
+  HARNESS_ACCOUNT_SLUG,
+  HARNESS_SOURCE_ID
+} from "../registry.js";
+const HARNESS_WORKSPACE = {
+  accounts: [
+    {
+      id: HARNESS_ACCOUNT_ID,
+      name: "Harness Team",
+      picture_url: null,
+      role: "owner",
+      slug: HARNESS_ACCOUNT_SLUG,
+      source_id: HARNESS_SOURCE_ID
+    }
+  ],
+  account: {
+    id: HARNESS_ACCOUNT_ID,
+    name: "Harness Team",
+    permissions: [
+      "roles.manage",
+      "billing.manage",
+      "settings.manage",
+      "members.manage",
+      "invites.manage"
+    ],
+    picture_url: "",
+    primary_owner_user_id: "00000000-0000-4000-8000-000000000003",
+    role: "owner",
+    role_hierarchy_level: 1,
+    slug: HARNESS_ACCOUNT_SLUG,
+    source_id: HARNESS_SOURCE_ID,
+    subscription_status: "active"
+  },
+  user: {
+    id: "00000000-0000-4000-8000-000000000003",
+    email: "developer@harness.local",
+    phone: "",
+    is_anonymous: false,
+    aal: "aal1",
+    app_metadata: {},
+    user_metadata: {},
+    amr: []
+  },
+  membership: {
+    preferences: {
+      first_use: {
+        completed: true,
+        completed_at: null,
+        skipped: true,
+        steps_completed: []
+      },
+      landing_zone: "dashboard"
+    }
+  }
+};
+const HARNESS_WORKSPACE_PROMISE = Promise.resolve(HARNESS_WORKSPACE);
+const TeamAccountWorkspaceContext = createContext(HARNESS_WORKSPACE_PROMISE);
+function TeamAccountWorkspaceContextProvider({
+  children,
+  value = HARNESS_WORKSPACE_PROMISE
+}) {
+  return /* @__PURE__ */ jsx(TeamAccountWorkspaceContext.Provider, { value, children });
+}
+function useTeamAccountWorkspace() {
+  const ctx = useContext(TeamAccountWorkspaceContext);
+  if (!ctx) {
+    throw new Error(
+      "useTeamAccountWorkspace must be used within a TeamAccountWorkspaceContext.Provider."
+    );
+  }
+  return use(ctx);
+}
+function useTeamAccountWorkspaceOptional() {
+  const ctx = useContext(TeamAccountWorkspaceContext);
+  return ctx ? use(ctx) : null;
+}
+export {
+  TeamAccountWorkspaceContext,
+  TeamAccountWorkspaceContextProvider,
+  useTeamAccountWorkspace,
+  useTeamAccountWorkspaceOptional
+};