@xenosystem/blocks 0.6.0 → 0.8.0

package/dist/auth/index.js

@@ -3,7 +3,7 @@ import "../chunk-2KG3PWR4.js";
 // src/auth/gate/panel.ts
 import { createElement } from "react";
 import { createRoot } from "react-dom/client";
-import { bindConfig } from "@xenosystem/panel-sdk";
+import { bindConfig } from "@xenosystem/block-sdk";
 
 // src/auth/gate/types.ts
 function deriveAuthGatePhase(state) {
@@ -348,24 +348,641 @@ function Behind({ render }) {
   return render();
 }
 
-// src/auth/index.ts
-export * from "@xenosystem/panel-account";
+// src/auth/account/panel.ts
+import { createElement as createElement3 } from "react";
+import { createRoot as createRoot3 } from "react-dom/client";
+import {
+  bindConfig as bindConfig2
+} from "@xenosystem/block-sdk";
+
+// src/auth/account/types.ts
+var STEP_UP_ACTIONS = /* @__PURE__ */ new Set([
+  "signOut",
+  "manageBilling",
+  "purchase"
+]);
+function isSignedIn(status) {
+  return status === "signedIn" || status === "refreshing" || status === "offline";
+}
+function requiresStepUp(kind) {
+  return STEP_UP_ACTIONS.has(kind);
+}
+function creditsAge(credits, now) {
+  if (!credits) return null;
+  return Math.max(0, now - credits.asOf);
+}
+function formatAmount(amount, unit = "") {
+  const sign = amount > 0 ? "+" : "";
+  const suffix = unit ? ` ${unit}` : "";
+  return `${sign}${amount.toLocaleString()}${suffix}`;
+}
+function formatAge(ms) {
+  if (ms < 6e4) return `${Math.round(ms / 1e3)}s ago`;
+  if (ms < 36e5) return `${Math.round(ms / 6e4)}m ago`;
+  if (ms < 864e5) return `${Math.round(ms / 36e5)}h ago`;
+  return `${Math.round(ms / 864e5)}d ago`;
+}
+
+// src/auth/account/controller.ts
+var EMPTY_STATE = { status: "unknown" };
+function ageBucket(ms) {
+  if (ms < 6e4) return `s${Math.round(ms / 1e3)}`;
+  if (ms < 36e5) return `m${Math.round(ms / 6e4)}`;
+  if (ms < 864e5) return `h${Math.round(ms / 36e5)}`;
+  return `d${Math.round(ms / 864e5)}`;
+}
+var AccountController = class {
+  host;
+  now;
+  staleAfterMs;
+  maxLedger;
+  account = EMPTY_STATE;
+  ledger = [];
+  ledgerHasMore = false;
+  ledgerRev = -1;
+  ledgerExpanded = false;
+  listeners = /* @__PURE__ */ new Set();
+  snapshot = null;
+  constructor(options) {
+    this.host = options.host;
+    this.now = options.host.now ?? (() => Date.now());
+    this.staleAfterMs = options.staleAfterMs ?? 6e4;
+    this.maxLedger = Math.max(1, options.maxLedger ?? 500);
+  }
+  /* ── Subscription ──────────────────────────────────────────────────────── */
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+  getState = () => {
+    if (!this.snapshot) {
+      const ageMs = creditsAge(this.account.credits, this.now());
+      this.snapshot = {
+        status: this.account.status,
+        identity: this.account.identity ?? null,
+        plan: this.account.plan ?? null,
+        credits: this.account.credits ?? null,
+        entitlements: this.account.entitlements ?? [],
+        seats: this.account.seats ?? [],
+        message: this.account.message ?? null,
+        ledger: this.ledger,
+        ledgerHasMore: this.ledgerHasMore,
+        ledgerExpanded: this.ledgerExpanded,
+        creditsAgeMs: ageMs,
+        // Stale is a fact about the DATA, not about the session. A signed-in user with a
+        // ten-minute-old balance is looking at a stale number and must be told so.
+        creditsStale: ageMs !== null && ageMs > this.staleAfterMs
+      };
+    }
+    return this.snapshot;
+  };
+  notify() {
+    this.snapshot = null;
+    for (const listener of this.listeners) listener();
+  }
+  /* ── Host-pushed state ─────────────────────────────────────────────────── */
+  /**
+   * Replace the account state.
+   *
+   * The host is authoritative. The panel does not merge cleverly, does not keep a "better" older
+   * value, and does not infer a status the host did not send — a panel that second-guesses its host
+   * is a second source of truth about who is signed in.
+   *
+   * @param next - The new state.
+   */
+  setAccount(next) {
+    this.account = next;
+    this.notify();
+  }
+  /**
+   * A partial update, for hosts that push only what changed.
+   *
+   * `credits` is replaced wholesale rather than field-merged: a balance and its `asOf` are one fact,
+   * and merging a new number onto an old timestamp manufactures a lie.
+   *
+   * @param patch - Fields to overwrite.
+   */
+  patchAccount(patch) {
+    this.account = { ...this.account, ...patch };
+    this.notify();
+  }
+  /** Set the session status alone. */
+  setStatus(status, message) {
+    if (status === "signedOut") {
+      this.account = { status, message };
+      this.ledger = [];
+      this.ledgerHasMore = false;
+      this.ledgerRev = -1;
+      this.notify();
+      return;
+    }
+    this.account = { ...this.account, status, message };
+    this.notify();
+  }
+  /* ── Ledger ────────────────────────────────────────────────────────────── */
+  /**
+   * Apply a ledger delta.
+   *
+   * Append-oriented, with `rev` gating out-of-order deliveries — the same discipline as runs and
+   * console.
+   *
+   * @param delta - The update.
+   * @returns Whether it was applied.
+   */
+  applyLedger(delta) {
+    if (delta.rev !== void 0 && delta.rev <= this.ledgerRev) return false;
+    if (delta.rev !== void 0) this.ledgerRev = delta.rev;
+    if (delta.clear) {
+      this.ledger = [];
+      this.ledgerHasMore = false;
+    }
+    if (delta.replace) {
+      this.ledger = delta.replace.slice(-this.maxLedger);
+    }
+    if (delta.append?.length) {
+      const byId = new Map(this.ledger.map((e) => [e.id, e]));
+      for (const entry of delta.append) byId.set(entry.id, entry);
+      this.ledger = [...byId.values()].sort((a, b) => b.ts - a.ts).slice(0, this.maxLedger);
+    }
+    if (delta.hasMore !== void 0) this.ledgerHasMore = delta.hasMore;
+    this.notify();
+    return true;
+  }
+  /* ── The passage of time ───────────────────────────────────────────────── */
+  /**
+   * Re-evaluate the balance's age.
+   *
+   * `getState` memoizes — it must, or `useSyncExternalStore` re-renders forever — which means the
+   * age would otherwise freeze at the moment of the last push, and a balance would sit on screen
+   * reading "as of 2s ago" for an hour. That is precisely the stale-as-fresh failure `asOf` exists
+   * to prevent, reintroduced by a caching bug.
+   *
+   * So time is an INPUT here, and the panel drives this on an interval. Notifying only when the
+   * rendered age actually changes keeps it off the re-render hot path: a one-second tick that
+   * re-renders once per second is honest; one that re-renders sixty times is waste.
+   *
+   * @returns Whether anything the view shows changed.
+   */
+  tick() {
+    if (!this.account.credits) return false;
+    const previous = this.snapshot;
+    if (!previous) return false;
+    const ageMs = creditsAge(this.account.credits, this.now()) ?? 0;
+    const stale = ageMs > this.staleAfterMs;
+    if (stale === previous.creditsStale && ageBucket(ageMs) === ageBucket(previous.creditsAgeMs ?? 0)) {
+      return false;
+    }
+    this.notify();
+    return true;
+  }
+  /** Expand or collapse the ledger. A view preference. */
+  setLedgerExpanded(expanded) {
+    this.ledgerExpanded = expanded;
+    this.notify();
+  }
+  /* ── Intents ───────────────────────────────────────────────────────────── */
+  /**
+   * Ask the host to do something.
+   *
+   * **The panel never renders the result.** It does not flip to `signedOut` because the user
+   * clicked Sign out, and it does not add credits because the user clicked Purchase. It emits, and
+   * waits to be told — the same intents-only doctrine the rest of the family follows, and the only
+   * shape compatible with `XENO AUTH - SPEC.md` L12, where a sensitive action may be REFUSED at the
+   * step-up prompt after the click.
+   *
+   * @param kind - What to ask for.
+   * @param extra - `seatId` or `productId`.
+   * @returns The emitted action.
+   */
+  request(kind, extra = {}) {
+    const action = { kind, ...extra };
+    if (requiresStepUp(kind)) action.stepUp = true;
+    this.host.emit("action", action);
+    return action;
+  }
+  /** Ask the host to re-read the balance. Cheap, idempotent, no step-up. */
+  refresh() {
+    return this.request("refresh");
+  }
+  /* ── Lifecycle ─────────────────────────────────────────────────────────── */
+  /**
+   * Serialize.
+   *
+   * **View preferences only.** No identity, no plan, no balance, no token.
+   *
+   * `XENO AUTH - SPEC.md` L9 forbids a refresh token in `localStorage` or `~/.xeno/*`, and this
+   * panel's one capability is `storage.local` — the very store L9 names. Persisting a balance would
+   * also reintroduce the stale-as-fresh problem `asOf` exists to solve: a number restored from disk
+   * has no honest timestamp.
+   */
+  serialize() {
+    return { ledgerExpanded: this.ledgerExpanded };
+  }
+  /** Restore view preferences. */
+  deserialize(state) {
+    if (!state || typeof state !== "object") return;
+    const s = state;
+    if (typeof s.ledgerExpanded === "boolean") this.ledgerExpanded = s.ledgerExpanded;
+    this.notify();
+  }
+  /** Tear down. */
+  dispose() {
+    this.listeners.clear();
+    this.account = EMPTY_STATE;
+    this.ledger = [];
+  }
+};
+
+// src/auth/account/manifest.ts
+import { WELL_KNOWN_PORT_SCHEMAS } from "@xenosystem/block-sdk";
+var ACCOUNT_PANEL_ID = "xeno.core.account";
+var accountManifest = {
+  id: ACCOUNT_PANEL_ID,
+  version: "0.1.0",
+  title: "Account",
+  icon: "user-round",
+  description: "Identity, plan, credits, entitlements and ledger \u2014 all host-pushed, never fetched. Balances carry the moment they were true. Sensitive actions are emitted as step-up intents, never performed.",
+  defaultSlot: "inspector",
+  inputs: [
+    {
+      id: "account",
+      name: "Account",
+      type: "object",
+      schema: WELL_KNOWN_PORT_SCHEMAS.ACCOUNT,
+      description: "{status, identity?, plan?, credits?, entitlements?, seats?, message?}. The host is authoritative. Contains NO token \u2014 see AUTH L9.",
+      multiple: false
+    },
+    {
+      id: "ledger",
+      name: "Ledger",
+      type: "object",
+      schema: WELL_KNOWN_PORT_SCHEMAS.LEDGER,
+      description: "{rev?, append?, replace?, clear?, hasMore?}. Append-oriented; `rev` gates out-of-order deliveries.",
+      multiple: true
+    }
+  ],
+  outputs: [
+    {
+      id: "action",
+      name: "Action",
+      type: "object",
+      schema: WELL_KNOWN_PORT_SCHEMAS.ACCOUNT_ACTION,
+      description: "{kind, seatId?, productId?, stepUp?}. An INTENT. `stepUp: true` marks an action AUTH L12 requires a fresh interactive re-auth for; the host must not satisfy it silently from the broker."
+    }
+  ],
+  commands: [
+    {
+      id: "refresh",
+      title: "Refresh",
+      description: "Ask the host to re-read the balance. Idempotent; no step-up.",
+      parameters: {}
+    },
+    {
+      id: "get_account",
+      title: "Get Account",
+      description: "Return the rendered account state \u2014 status, plan, balance and its asOf. Never a token.",
+      parameters: {}
+    },
+    {
+      id: "get_ledger",
+      title: "Get Ledger",
+      description: "Return the held ledger entries, newest first.",
+      parameters: {}
+    }
+    // NOTE: `signOut`, `purchase` and `manageBilling` are deliberately NOT commands. They require a
+    // fresh interactive re-auth (AUTH L12), and an agent-invocable command is by definition not
+    // interactive. Exposing them would make this panel the bypass for the step-up requirement.
+  ],
+  config: [
+    {
+      key: "showLedger",
+      label: "Show ledger",
+      type: "boolean",
+      defaultValue: true,
+      description: "Show recent credit activity."
+    },
+    {
+      key: "showEntitlements",
+      label: "Show entitlements",
+      type: "boolean",
+      defaultValue: true,
+      description: "List what the plan includes. Display only \u2014 entitlement is enforced server-side (AUTH L10)."
+    },
+    {
+      key: "staleAfterMs",
+      label: "Stale after (ms)",
+      type: "number",
+      defaultValue: 6e4,
+      description: "How old a balance may be before it is labelled stale."
+    },
+    {
+      key: "maxLedger",
+      label: "Max ledger entries",
+      type: "number",
+      defaultValue: 500,
+      description: "Entries retained in memory."
+    },
+    {
+      key: "emptyHint",
+      label: "Empty hint",
+      type: "text",
+      description: "Shown when no account state has arrived.",
+      placeholder: "Waiting for account state\u2026"
+    }
+  ],
+  capabilities: ["storage.local"],
+  sdk: "^1.1.0"
+};
+
+// src/auth/account/react/AccountPanelView.tsx
+import { useSyncExternalStore } from "react";
+import {
+  Badge,
+  EmptyState,
+  Row,
+  RowList,
+  ScrollArea,
+  Section,
+  StatTile,
+  StatusBar,
+  TextButton,
+  Toolbar,
+  ToolbarGroup
+} from "@xenosystem/workbench/primitives/react";
+import { Fragment as Fragment2, jsx as jsx2, jsxs } from "react/jsx-runtime";
+var STATUS_LABEL = {
+  unknown: "Loading",
+  signedOut: "Signed out",
+  signedIn: "Signed in",
+  refreshing: "Refreshing",
+  expired: "Session expired",
+  offline: "Offline"
+};
+var STATUS_TONE = {
+  unknown: "neutral",
+  signedOut: "neutral",
+  signedIn: "success",
+  refreshing: "neutral",
+  expired: "warning",
+  offline: "warning"
+};
+function AccountPanelView({
+  controller,
+  showLedger = true,
+  showEntitlements = true,
+  emptyHint
+}) {
+  const state = useSyncExternalStore(controller.subscribe, controller.getState, controller.getState);
+  if (state.status === "unknown") {
+    return /* @__PURE__ */ jsx2(EmptyState, { title: "Account", hint: emptyHint ?? "Waiting for account state\u2026" });
+  }
+  if (!isSignedIn(state.status)) {
+    return /* @__PURE__ */ jsx2(
+      EmptyState,
+      {
+        title: STATUS_LABEL[state.status],
+        hint: state.message ?? "Sign in to see your plan and credits.",
+        action: /* @__PURE__ */ jsx2(TextButton, { strong: true, onClick: () => controller.request("signIn"), children: "Sign in" })
+      }
+    );
+  }
+  const { identity, plan, credits } = state;
+  const unit = credits?.unit ?? "credits";
+  return /* @__PURE__ */ jsxs("div", { style: { display: "flex", flexDirection: "column", height: "100%", minHeight: 0 }, children: [
+    /* @__PURE__ */ jsx2(
+      Toolbar,
+      {
+        left: /* @__PURE__ */ jsxs(Fragment2, { children: [
+          /* @__PURE__ */ jsx2(Badge, { tone: STATUS_TONE[state.status], children: STATUS_LABEL[state.status] }),
+          plan ? /* @__PURE__ */ jsx2(Badge, { title: `Plan: ${plan.label}`, children: plan.label }) : null
+        ] }),
+        right: /* @__PURE__ */ jsx2(ToolbarGroup, { end: true, children: /* @__PURE__ */ jsx2(TextButton, { onClick: () => controller.refresh(), children: "Refresh" }) })
+      }
+    ),
+    /* @__PURE__ */ jsxs(ScrollArea, { children: [
+      /* @__PURE__ */ jsxs("div", { style: { padding: 8, display: "flex", flexDirection: "column", gap: 2 }, children: [
+        /* @__PURE__ */ jsx2("div", { style: { fontSize: 12, fontWeight: 600 }, children: identity?.name ?? identity?.sub }),
+        identity?.email ? /* @__PURE__ */ jsx2("div", { style: { fontSize: 10, opacity: 0.65 }, children: identity.email }) : null,
+        state.message ? /* @__PURE__ */ jsx2("div", { style: { fontSize: 10, opacity: 0.75, marginTop: 4 }, children: state.message }) : null
+      ] }),
+      credits ? /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: 6, padding: "0 8px 8px" }, children: [
+        /* @__PURE__ */ jsx2(
+          StatTile,
+          {
+            label: unit,
+            value: credits.balance.toLocaleString(),
+            sub: state.creditsAgeMs === null ? void 0 : state.creditsStale ? `as of ${formatAge(state.creditsAgeMs)} \u2014 may be out of date` : `as of ${formatAge(state.creditsAgeMs)}`,
+            icon: state.creditsStale ? /* @__PURE__ */ jsx2(Badge, { tone: "warning", children: "stale" }) : void 0,
+            title: "Pushed by the host, not fetched by this panel."
+          }
+        ),
+        credits.included !== void 0 ? /* @__PURE__ */ jsx2(
+          StatTile,
+          {
+            label: "included",
+            value: credits.included.toLocaleString(),
+            sub: credits.used === void 0 ? void 0 : `${credits.used.toLocaleString()} used`
+          }
+        ) : null
+      ] }) : null,
+      state.seats.length > 1 ? /* @__PURE__ */ jsx2(Section, { title: "Seats", flush: true, children: /* @__PURE__ */ jsx2(RowList, { children: state.seats.map((seat) => /* @__PURE__ */ jsx2(
+        Row,
+        {
+          noIcon: true,
+          label: seat.label,
+          trailing: seat.active ? /* @__PURE__ */ jsx2(Badge, { children: "active" }) : /* @__PURE__ */ jsx2(
+            TextButton,
+            {
+              onClick: () => controller.request("switchSeat", { seatId: seat.id }),
+              children: "Switch"
+            }
+          )
+        },
+        seat.id
+      )) }) }) : null,
+      showEntitlements && state.entitlements.length > 0 ? /* @__PURE__ */ jsx2(Section, { title: "Included", flush: true, children: /* @__PURE__ */ jsx2(RowList, { children: state.entitlements.map((ent) => /* @__PURE__ */ jsx2(
+        Row,
+        {
+          noIcon: true,
+          label: ent.label,
+          meta: ent.detail,
+          trailing: /* @__PURE__ */ jsx2(Badge, { tone: ent.included ? "success" : "neutral", children: ent.included ? "yes" : "no" })
+        },
+        ent.id
+      )) }) }) : null,
+      showLedger ? /* @__PURE__ */ jsxs(
+        Section,
+        {
+          title: "Recent activity",
+          flush: true,
+          collapsed: !state.ledgerExpanded,
+          onCollapsedChange: (collapsed) => controller.setLedgerExpanded(!collapsed),
+          badge: state.ledger.length > 0 ? /* @__PURE__ */ jsx2(Badge, { children: state.ledger.length }) : void 0,
+          children: [
+            state.ledger.length === 0 ? /* @__PURE__ */ jsx2(EmptyState, { title: "No activity", hint: "Credit spends and grants appear here." }) : /* @__PURE__ */ jsx2(RowList, { children: state.ledger.map((entry) => /* @__PURE__ */ jsx2(
+              Row,
+              {
+                noIcon: true,
+                label: entry.description,
+                meta: entry.source,
+                trailing: /* @__PURE__ */ jsx2("span", { style: { fontVariantNumeric: "tabular-nums", fontSize: 11 }, children: formatAmount(entry.amount) })
+              },
+              entry.id
+            )) }),
+            state.ledgerHasMore ? /* @__PURE__ */ jsx2("div", { style: { padding: "2px 8px", fontSize: 9, opacity: 0.6 }, children: "Older entries are not held by this panel." }) : null
+          ]
+        }
+      ) : null
+    ] }),
+    /* @__PURE__ */ jsx2("div", { style: { padding: "0 8px", fontSize: 9, opacity: 0.55 }, children: "Billing and sign-out ask you to confirm who you are." }),
+    /* @__PURE__ */ jsx2(
+      Toolbar,
+      {
+        divided: false,
+        right: /* @__PURE__ */ jsxs(ToolbarGroup, { end: true, children: [
+          /* @__PURE__ */ jsx2(TextButton, { onClick: () => controller.request("manageBilling"), children: "Billing\u2026" }),
+          /* @__PURE__ */ jsx2(TextButton, { onClick: () => controller.request("signOut"), children: "Sign out\u2026" })
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      StatusBar,
+      {
+        left: plan?.renewsAt ? `renews ${new Date(plan.renewsAt).toLocaleDateString()}` : void 0,
+        right: state.status === "offline" ? "offline \u2014 showing last known" : void 0
+      }
+    )
+  ] });
+}
+
+// src/auth/account/panel.ts
+function createAccountPanel(options = {}) {
+  return {
+    manifest: accountManifest,
+    activate(host) {
+      const config = host.config ?? {};
+      const controller = new AccountController({
+        host: { emit: (portId, value) => host.emit(portId, value) },
+        staleAfterMs: typeof config.staleAfterMs === "number" ? config.staleAfterMs : void 0,
+        maxLedger: typeof config.maxLedger === "number" ? config.maxLedger : void 0
+      });
+      const resolve = (config2) => ({
+        showLedger: config2.showLedger !== false,
+        showEntitlements: config2.showEntitlements !== false,
+        emptyHint: typeof config2.emptyHint === "string" ? config2.emptyHint : void 0
+      });
+      let renderConfig = resolve(host.config ?? {});
+      let unrender = null;
+      let root = null;
+      let ticker = null;
+      let currentEl = null;
+      const draw = (el) => {
+        unrender?.();
+        if (ticker === null) ticker = setInterval(() => controller.tick(), 1e3);
+        if (options.render) {
+          unrender = options.render(el, { controller, config: renderConfig });
+          return;
+        }
+        root = createRoot3(el);
+        root.render(createElement3(AccountPanelView, { controller, ...renderConfig }));
+        unrender = () => {
+          root?.unmount();
+          root = null;
+        };
+      };
+      const unbindConfig = bindConfig2(host, (config2) => {
+        renderConfig = resolve(config2);
+        if (currentEl) draw(currentEl);
+      });
+      return {
+        render(el) {
+          currentEl = el;
+          draw(el);
+        },
+        onInput(portId, value) {
+          if (portId === "account") {
+            if (value && typeof value === "object" && "status" in value) {
+              controller.setAccount(value);
+            }
+          } else if (portId === "ledger") {
+            if (Array.isArray(value)) {
+              controller.applyLedger({ append: value });
+            } else if (value && typeof value === "object") {
+              controller.applyLedger(value);
+            }
+          }
+        },
+        async onCommand(commandId) {
+          switch (commandId) {
+            case "refresh":
+              return controller.refresh();
+            case "get_account": {
+              const s = controller.getState();
+              return {
+                status: s.status,
+                sub: s.identity?.sub,
+                plan: s.plan?.id,
+                balance: s.credits?.balance,
+                asOf: s.credits?.asOf,
+                stale: s.creditsStale
+              };
+            }
+            case "get_ledger":
+              return controller.getState().ledger;
+            default:
+              return;
+          }
+        },
+        serialize() {
+          return controller.serialize();
+        },
+        deserialize(state) {
+          controller.deserialize(state);
+        },
+        dispose() {
+          unbindConfig();
+          currentEl = null;
+          if (ticker !== null) {
+            clearInterval(ticker);
+            ticker = null;
+          }
+          unrender?.();
+          unrender = null;
+          controller.dispose();
+        }
+      };
+    }
+  };
+}
+var accountPanel = createAccountPanel();
 export {
+  ACCOUNT_PANEL_ID,
   AUTH_GATE_DECLARATION,
   AUTH_GATE_INITIAL,
   AUTH_GATE_PANEL_ID,
+  AccountController,
+  AccountPanelView,
   AuthGateController,
   AuthGateView,
   BEHAVIOURS,
   PHASE_INTENTS,
+  STEP_UP_ACTIONS,
+  accountManifest,
+  accountPanel,
   authGateManifest,
   authGatePanel,
   authGateView,
+  createAccountPanel,
   createAuthGatePanel,
+  creditsAge,
   deriveAuthGatePhase,
+  formatAge,
+  formatAmount,
   formatSince,
   hostContradiction,
   intentOffered,
+  isSignedIn,
   mountXenoAuthGate,
-  plateCopy
+  plateCopy,
+  requiresStepUp
 };

package/dist/data/index.d.ts

@@ -1,4 +1,4 @@
-import { PanelModule, PanelManifest, LogSink } from '@xenosystem/panel-sdk';
+import { PanelModule, PanelManifest, LogSink } from '@xenosystem/block-sdk';
 import * as _xenosystem_data_core from '@xenosystem/data-core';
 import { XenoColumn, XenoQuery, XenoResultSet, XenoValue, XenoRow, XenoAggFn, XenoValueFormat, XenoFilterGroup, XenoColumnRole, XenoSchemaCatalog, XenoFilter, XenoSourceSchema } from '@xenosystem/data-core';
 import { ReactNode } from 'react';