@artemis-studio/plugin-sdk 2026.9.37

package/types/kernel/slots.d.ts

@@ -0,0 +1,130 @@
+import type { ComponentType } from 'react';
+/** Queues picked by name, or every queue matching the queues screen's filter (`q`, blank for all). */
+export type QueueSelection = {
+    kind: 'names';
+    names: string[];
+} | {
+    kind: 'filter';
+    q: string;
+    total: number;
+};
+/** Messages picked by id, every message matching the messages screen's selector, or the whole queue. */
+export type MessageSelection = {
+    kind: 'ids';
+    ids: number[];
+} | {
+    kind: 'filter';
+    filter: string;
+} | {
+    kind: 'all';
+};
+/**
+ * The kernel-owned slots and what each hands its contributions (ADR-0070). A slot lets a screen
+ * show another feature's panel without importing that feature, and without a placeholder when the
+ * feature is disabled.
+ */
+export interface SlotProps {
+    /** In the application header, after the product name: status across clusters that needs attention. */
+    'shell.header': object;
+    /** In the sidebar, above the open cluster's views: how the operator moves between clusters. */
+    'shell.navbar': {
+        collapsed: boolean;
+    };
+    /** The landing page, when no cluster is open. */
+    'home.empty': object;
+    /** Above every view of a cluster: what identifies it, and what needs saying about its state. */
+    'cluster.header': {
+        clusterId: string;
+    };
+    /** Below a passing registration check: what the enabled features added to it, by feature id. */
+    'cluster.registration.afterProbe': {
+        contributions: Record<string, unknown>;
+    };
+    /** In a queue's detail drawer, below its per-node breakdown. `onClose` closes the drawer before navigating. */
+    'queue.detail.panels': {
+        clusterId: string;
+        queueName: string;
+        onClose: () => void;
+    };
+    /**
+     * Beside the queues screen's selection: what can be done to the selected queues. `count` is how
+     * many are selected, and may be zero: an action then stays visible and disabled. `clear` empties
+     * the selection.
+     */
+    'queues.selection': {
+        clusterId: string;
+        selection: QueueSelection;
+        count: number;
+        clear: () => void;
+    };
+    /**
+     * Beside the messages screen's selection: what can be done to the selected messages elsewhere.
+     * `node` is the Studio node being browsed, absent for the live node; `total` is how many messages
+     * the selection holds, null when the screen does not know. `clear` empties the selection.
+     */
+    'messages.selection': {
+        clusterId: string;
+        queueName: string;
+        node?: string;
+        selection: MessageSelection;
+        total: number | null;
+        clear: () => void;
+    };
+    /** At the foot of a cluster's metrics view. */
+    'metrics.panels': {
+        clusterId: string;
+    };
+    /** Inside a box on the topology graph, after its name. `nodeIds` are the broker endpoints the box stands for. */
+    'topology.node.marks': {
+        clusterId: string;
+        nodeIds: string[];
+    };
+    /** A section of a cluster's Settings page, under the contribution's title. */
+    'settings.sections': {
+        clusterId: string;
+    };
+    /** A tab of a cluster's Routing page, after Diverts and Bridges, labelled with the contribution's title; its id is the tab's `?tab=`. */
+    'routing.tabs': {
+        clusterId: string;
+    };
+    /** A tab of the Administration page, labelled with the contribution's title; its id is the tab's `?tab=`. */
+    'admin.tabs': object;
+    /** A section of the signed-in user's Account page, under the contribution's title. */
+    'account.sections': object;
+}
+export type SlotName = keyof SlotProps;
+/**
+ * The closed, ordered headings a Settings page groups its tabs under, in the order an operator's
+ * reach widens: their own preferences, then what is shared across Studio, then this cluster, then
+ * what plugins added. Adding one is a kernel change, like a navigation group (ADR-0070).
+ */
+export declare const SETTINGS_GROUPS: readonly [{
+    readonly id: "personal";
+    readonly label: "Yours";
+}, {
+    readonly id: "studio";
+    readonly label: "Studio";
+}, {
+    readonly id: "cluster";
+    readonly label: "This cluster";
+}, {
+    readonly id: "plugins";
+    readonly label: "Plugins";
+}];
+export type SettingsGroupId = (typeof SETTINGS_GROUPS)[number]['id'];
+export interface SlotContribution<P> {
+    /** Unique within the slot. */
+    id: string;
+    /** Position within the slot; lower comes first. */
+    order: number;
+    /** The heading or tab label, in the slots that show one. */
+    title?: string;
+    /** `settings.sections` only: the heading its tab sits under. Without one it is listed under Plugins. */
+    group?: SettingsGroupId;
+    Component: ComponentType<P>;
+}
+export type SlotContributions = {
+    [K in SlotName]?: SlotContribution<SlotProps[K]>[];
+};
+/** The enabled features' contributions to one slot, in order. */
+export declare function useSlot<K extends SlotName>(name: K): SlotContribution<SlotProps[K]>[];

package/types/kernel/stream/useClusterStream.d.ts

@@ -0,0 +1,22 @@
+/** What the UI reports about the live connection (ADR-0052). */
+export type StreamStatus = 'connecting' | 'live' | 'reconnecting' | 'offline';
+/** The live-stream state, or `null` on a route that mounts no stream. */
+export declare function useStreamStatus(): StreamStatus | null;
+/**
+ * One `EventSource` per mounted cluster view (ADR-0003, ADR-0018, ADR-0027).
+ *
+ * - Each topic's frames go to the handler its feature contributes (ADR-0070). A
+ *   signal topic's handler invalidates the matching TanStack Query keys and the
+ *   normal `queryFn` refetches; a topic of a disabled feature has no handler.
+ * - `onFrame` also hands the view every frame of the topics it mounted, for a topic
+ *   that carries data with no server-side resource behind it, such as the live
+ *   broker-event feed. The browser echoes the last `id:` back as `Last-Event-ID`
+ *   on reconnect, so missed events replay automatically.
+ *
+ * It reconnects indefinitely with capped exponential backoff and full jitter, and
+ * treats silence as failure (ADR-0052): an intermediary that drops the connection
+ * without a clean close fires no `error`, so the only way to notice is to miss a
+ * keep-alive. The returned status is what the freshness indicator reports; the
+ * per-hook `refetchInterval` keeps every view updating while it is not `live`.
+ */
+export declare function useClusterStream(clusterId: string, topics: string[], onFrame?: (topic: string, data: string) => void): StreamStatus;

package/types/kernel/time/time.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Ask the server what time it is and fold the answer in.
+ *
+ * Failures are silent on purpose: the probe is not a screen and has no operator
+ * waiting on it. A 401 or a dropped network leaves the previous estimate standing,
+ * which is strictly better than reverting to the browser's clock, and the real
+ * queries on the screen are what report that the server is unreachable.
+ *
+ * Concurrent callers join the request in flight rather than starting another.
+ */
+export declare function syncServerTime(): Promise<void>;
+/**
+ * The SSE keep-alive as a drift detector — never as a measurement.
+ *
+ * `SseHub.heartbeat` puts the server's clock in every `ping`, so the client is
+ * told the time every twenty seconds for free. It is one-way with unmeasurable
+ * latency, so it cannot teach the estimator; what it can do is notice that the
+ * estimate has gone wrong and ask for a real probe.
+ */
+export declare function offerPing(data: unknown): void;
+/** Studio's clock, as best the browser can tell. The only wall-clock read in the app. */
+export declare function serverNow(): number;
+/**
+ * Put a browser-stamped instant on Studio's timeline.
+ *
+ * The only such instants are TanStack Query's `dataUpdatedAt`, which it stamps
+ * with its own `Date.now()` when a response lands. Comparing one against
+ * {@link serverNow} without this would reintroduce exactly the error this module
+ * removes — and silently, because the number looks right.
+ */
+export declare function toServerMs(browserMs: number): number;
+/** How far the browser's clock is from Studio's, in ms. Positive means the browser is ahead. */
+export declare function browserOffsetMs(): number;
+/**
+ * Keep the estimate honest for as long as the tab lives.
+ *
+ * Three triggers, because clocks go wrong in three ways: they drift (the
+ * interval), they are corrected or the machine wakes from sleep (the step check
+ * and `visibilitychange`), and the tab is backgrounded long enough that neither
+ * timer ran (`visibilitychange` again — browsers throttle background timers).
+ *
+ * The step check is the client-side `MonotonicClockWatch`: `performance.now()`
+ * advances monotonically, so comparing its delta against the wall clock's
+ * separates a jump from ordinary drift. A step means the offset is now wrong by
+ * the size of the jump, and unlearning that slowly through the EWMA would leave
+ * every label wrong in the meantime.
+ *
+ * Called once from the application root. Returns a teardown for tests.
+ */
+export declare function startServerTimeSync(): () => void;
+/**
+ * A clock that ticks to re-render a relative label, on Studio's time.
+ *
+ * Also re-renders when the offset itself changes, which matters more than it
+ * looks: `MetricsView` ticks at the metric bucket width, up to an hour, and would
+ * otherwise hold a window computed before the first probe resolved for that long.
+ */
+export declare function useServerNow(intervalMs?: number): number;
+/**
+ * `4s`, `3m`, `2h`, `1d` — short enough to sit in a header or a table cell.
+ *
+ * Floors rather than rounds. An age is a lower bound on how long ago something
+ * happened, and `59s` reading as `1m` overstates it; the operator reading a
+ * staleness label before a destructive action is the reason to prefer the
+ * conservative direction.
+ */
+export declare function elapsedLabel(ms: number): string;
+/**
+ * A server instant, written down in the operator's chosen timezone.
+ *
+ * Fixed-width `YYYY-MM-DD HH:mm:ss` so a column of these sorts and scans by eye,
+ * and **always suffixed with the zone it is in** — `Z` for UTC, `+03:30`
+ * otherwise. The suffix is not decoration: the whole reason an operator picks a
+ * zone is to line a screen up against something else, and a timestamp that does
+ * not say which offset it is in is the one way this feature could mislead them.
+ *
+ * The offset is computed for *that instant*, not for now, so an event from last
+ * winter carries the offset that was in force when it happened.
+ *
+ * Accepts both wire shapes: the ISO-8601 strings every DTO carries, and the
+ * epoch-millis a broker's own message timestamps arrive as. Those are `0` when the
+ * broker set none, which is not a time and is rendered as such.
+ *
+ * Reads the zone from module state rather than a hook so it can be called from a
+ * table's column accessor. The consequence is that a view rendering one of these
+ * must subscribe with `useDisplayZone()` or it will not repaint when the zone
+ * changes.
+ */
+export declare function absoluteLabel(value: string | number | null | undefined): string;

package/types/kernel/time/timezone.d.ts

@@ -0,0 +1,44 @@
+/** Follow the browser, re-read every time rather than captured at load. */
+export declare const AUTO = "auto";
+export declare const DEFAULT_ZONE = "auto";
+/** Whatever the browser currently believes its zone to be. */
+export declare function localZone(): string;
+/**
+ * What the operator chose, which may be {@link AUTO}. This is what the picker
+ * shows; {@link displayZone} is what formatters use.
+ */
+export declare function displayZonePreference(): string;
+/** The zone to render instants in. Read synchronously, so formatters need no hook. */
+export declare function displayZone(): string;
+export declare function setDisplayZone(next: string): void;
+/**
+ * Subscribe a view to the display zone.
+ *
+ * Any component that renders an absolute timestamp must call this, even if it
+ * ignores the returned value: `absoluteLabel` reads the zone from module state so
+ * it can be used inside a table's column accessor, which means nothing re-renders
+ * on a zone change unless something subscribed.
+ */
+export declare function useDisplayZone(): string;
+/**
+ * Every zone the runtime knows, UTC and the operator's own first.
+ *
+ * `Intl.supportedValuesOf` is the runtime's own IANA list, so it stays current
+ * without this project shipping a copy of the tz database. Where it is missing,
+ * the short list is still enough to be useful rather than empty.
+ */
+export declare function zoneOptions(): {
+    group: string;
+    items: {
+        value: string;
+        label: string;
+    }[];
+}[];
+/**
+ * `+03:30`, or `UTC` — the suffix that keeps a rendered timestamp unambiguous.
+ *
+ * Computed for a given instant, not for now: half the world changes offset twice
+ * a year, and an event from last winter must be labelled with the offset that was
+ * in force when it happened, not the one in force today.
+ */
+export declare function zoneSuffix(ms: number, inZone?: string): string;

package/types/kernel/useDismissedNotice.d.ts

@@ -0,0 +1,3 @@
+export declare function useDismissedNotice(key: string): [boolean, () => void];
+/** Forget every dismissal. Called when the signed-in identity changes. */
+export declare function clearDismissedNotices(): void;

package/types/sdk/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `@artemis-studio/plugin-sdk` — everything a plugin's UI may use from Studio (ADR-0100). The host
+ * shares this module as a singleton, so a plugin's bundle uses the running Studio's own copy:
+ * the same router roots, the same query cache, the same permission checks. Nothing outside this
+ * file is part of the contract; a plugin that reaches past it breaks on the next Studio release.
+ */
+import type { ComponentType, ReactElement } from 'react';
+import { CONTRACT, type PluginId, type StudioFeature } from '../kernel/feature.ts';
+export { CONTRACT };
+export type { NavContribution, PaletteSource, PluginId, RouteContributions, StudioFeature, TopicHandler, } from '../kernel/feature.ts';
+export { SETTINGS_GROUPS, type MessageSelection, type QueueSelection, type SettingsGroupId, type SlotContribution, type SlotContributions, type SlotName, type SlotProps, } from '../kernel/slots.ts';
+export { NAV_GROUPS, type NavGroupId } from '../kernel/nav/groups.ts';
+export { clusterRoute, rootRoute } from '../kernel/routing/roots.ts';
+export { ApiError, clusterKey, request } from '../kernel/api/request.ts';
+export { useCan } from '../kernel/auth/useCan.ts';
+export { useMe } from '../kernel/auth/api.ts';
+export { ConfirmByTyping } from '../ui/ConfirmByTyping.tsx';
+export { NodeOutcomeSummary, OutcomeSummary, type OutcomeRow } from '../ui/NodeOutcomeSummary.tsx';
+export { Pager } from '../ui/Pager.tsx';
+export { VirtualTable, type GridColumn } from '../ui/VirtualTable.tsx';
+/**
+ * Shows a notification in Studio's own notification area. Import this, never
+ * `@mantine/notifications` directly: that is not shared, so a plugin's own copy would show nothing.
+ */
+export { notifications as notify } from '@mantine/notifications';
+/** A plugin's description of itself: a {@link StudioFeature} whose id is the plugin's own. */
+export interface StudioPlugin extends StudioFeature {
+    id: PluginId;
+}
+/** Declares a plugin's UI; its bundle exposes the result as `./feature`'s default export. */
+export declare function definePlugin<T extends StudioPlugin>(plugin: T): T;
+/**
+ * A route path under the plugin's own namespace, the only place its routes may live:
+ * `pluginPath('acme-notes', 'notes/$noteId')` is `p/acme-notes/notes/$noteId`. Use it with
+ * `rootRoute` for a page outside any cluster, or `clusterRoute` for a view of one cluster.
+ */
+export declare function pluginPath(id: PluginId, path?: string): string;
+/**
+ * The API path of a plugin's own endpoints, for {@link request}: `/p/<id>/…`, or
+ * `/clusters/<clusterId>/p/<id>/…` for a cluster-scoped call.
+ */
+export declare function pluginApi(id: PluginId, path: string, clusterId?: string): string;
+/** The plugin's page, or the page explaining it is unavailable when the plugin is not running. */
+export declare function pluginView(id: PluginId, View: ComponentType): () => ReactElement;

package/types/ui/ConfirmByTyping.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Typed-name confirmation for a destructive action (non-negotiable #2). The
+ * button arms only on an exact match of {@code token}. Extracted from the
+ * hand-rolled copies in `AddManagementUrl` (remove cluster) and `SettingsView`
+ * (credential rotation).
+ */
+export declare function ConfirmByTyping({ token, label, confirmLabel, loading, disabled, color, onConfirm, }: {
+    token: string;
+    label?: string;
+    confirmLabel: string;
+    loading?: boolean;
+    disabled?: boolean;
+    color?: string;
+    onConfirm: () => void;
+}): import("react").JSX.Element;

package/types/ui/NodeOutcomeSummary.d.ts

@@ -0,0 +1,69 @@
+import type { components } from '../kernel/api/schema.d.ts';
+type LifecycleOutcomeView = components['schemas']['LifecycleOutcomeView'];
+/**
+ * One cluster-wide lifecycle result, rendered as a single object (ADR-0049 D2).
+ *
+ * <p>Used for both the dry-run preview and the result, so what the operator
+ * confirmed and what actually happened are visually comparable — a preview that
+ * looks nothing like its outcome makes the two impossible to check against each
+ * other.
+ *
+ * <p>Every node's state is carried in words. Colour is redundant with the text
+ * and appears only where something is wrong, so a fully applied command reads as
+ * near-monochrome and the eye stops at the one row that did not.
+ */
+export declare function NodeOutcomeSummary({ outcome, destructive, alreadyLabel, countNoun, verbFuture, verbPast, }: {
+    outcome: LifecycleOutcomeView;
+    /** A destroy shows the message counts; a pause has none worth a column. */
+    destructive?: boolean;
+    /**
+     * What `ALREADY` means for this command. It defaults to the lifecycle wording,
+     * but a connection close needs "already gone" — "already in this state" reads
+     * as though the operator had asked for something else.
+     */
+    alreadyLabel?: string;
+    /**
+     * What the counts are counting, and the verb for them. Defaults to the queue
+     * delete's wording; a connection close affects consumers, not messages, and
+     * saying "destroyed" there would overstate what happened.
+     */
+    countNoun?: string;
+    verbFuture?: string;
+    verbPast?: string;
+}): import("react").JSX.Element;
+/** One node's contribution, already in the words the caller's command uses. */
+export interface OutcomeRow {
+    key: string;
+    name: string;
+    /** A right-aligned figure, when the command has one worth comparing between nodes. */
+    count?: string;
+    status: string;
+    tone?: 'warning' | 'danger';
+    /** A failure's reason, or anything else that needs a second line. */
+    detail?: string | null;
+}
+/**
+ * The per-node result as a shape, without an opinion about what the command was.
+ *
+ * <p>{@link NodeOutcomeSummary} is this with the lifecycle vocabulary; the SQL
+ * Console is this with a query's. Both go through here so a fan-out result reads
+ * the same wherever it appears — which is the point of the house rule, and is
+ * lost the moment a second screen re-implements the layout with its own spacing.
+ */
+export declare function OutcomeSummary({ verdict, verdictTone, total, rows, }: {
+    verdict: string;
+    verdictTone?: 'warning' | 'danger';
+    total?: string;
+    rows: OutcomeRow[];
+}): import("react").JSX.Element;
+/**
+ * Whether the command actually landed on every node it named — the one question a
+ * caller asks before treating the resource as changed.
+ *
+ * <p>Stated positively on purpose. `partial` is false both when everything worked
+ * and when nothing did (a cluster with no live node settles nowhere), so a caller
+ * that asks "not partial and nothing failed" concludes a delete succeeded against
+ * a cluster it never reached.
+ */
+export declare function appliedEverywhere(outcome: LifecycleOutcomeView): boolean;
+export {};

package/types/ui/Pager.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Previous/Next over a server-side page, with the position stated.
+ *
+ * One implementation rather than one per view: a paged view that does not say
+ * where it is leaves the operator unable to tell whether they are looking at
+ * everything, which is exactly the failure ADR-0056 is about.
+ *
+ * Rendered even on a single page, because "1–14 of 14" is the sentence that
+ * settles the question; hiding it leaves the same doubt a missing pager does.
+ */
+export declare function Pager({ page, pageSize, total, onChange, label, }: {
+    /** 1-based. */
+    page: number;
+    pageSize: number;
+    total: number;
+    onChange: (page: number) => void;
+    /** Plural noun for the rows, e.g. `flows`. */
+    label: string;
+}): import("react").JSX.Element;

package/types/ui/VirtualTable.d.ts

@@ -0,0 +1,56 @@
+export interface GridColumn<T> {
+    id: string;
+    header: string;
+    accessor: (row: T) => unknown;
+    cell?: (row: T) => React.ReactNode;
+    numeric?: boolean;
+    /** The `sort` query value this column sorts by, if sortable. */
+    sortKey?: string;
+    /**
+     * Fixed track width in px, for a column whose values have a known shape — a
+     * count, a routing type, a yes/no. Omit it for a column carrying free text
+     * (an address, a queue name, a client id): those share whatever space the
+     * fixed columns leave over, which is where a wide window is worth having.
+     */
+    width?: number;
+}
+interface VirtualTableProps<T> {
+    columns: GridColumn<T>[];
+    data: T[];
+    sort?: string;
+    onSortChange?: (sort: string | undefined) => void;
+    onRowClick?: (row: T) => void;
+    rowKey: (row: T) => string;
+    emptyLabel?: React.ReactNode;
+    /** An extra class per row, for state the caller owns — a live tail's fresh rows. */
+    rowClassName?: (row: T) => string | undefined;
+    /** Opt-in leading checkbox column. Selection state is owned by the caller (ephemeral React state). */
+    selectable?: boolean;
+    selected?: ReadonlySet<string>;
+    onToggleRow?: (key: string) => void;
+    /** Header select-all across the loaded page. `allSelected` is the current state; the caller flips it. */
+    onToggleAll?: (keys: string[], allSelected: boolean) => void;
+    /**
+     * Called when the grid's own scroll leaves or returns to the top. A live feed
+     * that prepends rows moves the content under a reader who has scrolled away, so
+     * the caller needs to know in order to hold new rows back.
+     */
+    onAtTopChange?: (atTop: boolean) => void;
+}
+/**
+ * A virtualized data grid: one CSS grid track list, declared once and shared by
+ * the header row and every body row, row-virtualized with
+ * `@tanstack/react-virtual`. Smooth at a few thousand rows.
+ *
+ * <p>Columns are either fixed or free. A fixed column gets exactly its declared
+ * px; a free column gets `minmax(floor, 1fr)`, so every pixel the window has
+ * over the fixed columns' needs goes to the values that actually vary in length.
+ * Below the floors the grid stops shrinking and its own container scrolls — the
+ * page never does.
+ *
+ * <p>Sorting is a URL round-trip, not local state: the header carries
+ * `aria-sort` from the current `sort` param and clicking it navigates. Row
+ * selection is opt-in (`selectable`) and its state lives with the caller.
+ */
+export declare function VirtualTable<T>({ columns, data, sort, onSortChange, onRowClick, rowKey, emptyLabel, rowClassName, selectable, selected, onToggleRow, onToggleAll, onAtTopChange, }: VirtualTableProps<T>): import("react").JSX.Element;
+export {};

package/vite.d.ts

@@ -0,0 +1,14 @@
+import type { PluginOption } from 'vite';
+
+/** Options for {@link studioPlugin}. */
+export interface StudioPluginOptions {
+  /** The plugin's id, exactly as its `plugin.json` declares it. */
+  id: string;
+  /** The module whose default export is the plugin (`definePlugin(...)`). Default `./src/feature.tsx`. */
+  entry?: string;
+  /** Where the bundle goes. Default `target/classes/META-INF/artemis-studio/ui`, inside the plugin jar. */
+  outDir?: string;
+}
+
+/** Vite configuration for a plugin's UI: a Module Federation remote that shares Studio's libraries. */
+export function studioPlugin(options: StudioPluginOptions): PluginOption[];

package/vite.js

@@ -0,0 +1,60 @@
+import { federation } from '@module-federation/vite';
+
+import { SDK, SHARED_LIBRARIES, packageOf } from './shared.js';
+import peers from './peers.json' with { type: 'json' };
+
+/**
+ * Vite configuration for a plugin's UI (ADR-0100): a Module Federation remote named after the
+ * plugin, exposing `./feature`, that takes React, Mantine, TanStack and this SDK from the running
+ * Studio (`import: false`), with a relative base so it is served from wherever Studio mounts it,
+ * built into the jar's `META-INF/artemis-studio/ui/`.
+ *
+ * The build fails on an import Studio does not share — `@mantine/notifications`, say, or
+ * Mantine's CSS — since a plugin's own copy would load beside Studio's and silently misbehave.
+ *
+ * @param {{ id: string, entry?: string, outDir?: string }} options
+ * @returns {import('vite').PluginOption[]}
+ */
+export function studioPlugin({ id, entry = './src/feature.tsx', outDir = 'target/classes/META-INF/artemis-studio/ui' }) {
+  if (!/^[a-z][a-z0-9]*(-[a-z0-9]+)+$/.test(id)) {
+    throw new Error(`studioPlugin: "${id}" is not a plugin id (lowercase kebab-case, at least two segments, as in plugin.json)`);
+  }
+  const shared = Object.fromEntries([
+    ...SHARED_LIBRARIES.map((name) => [
+      name,
+      { singleton: true, import: false, requiredVersion: peers[packageOf(name)] },
+    ]),
+    [SDK, { singleton: true, import: false, requiredVersion: false }],
+  ]);
+  const allowed = new Set([...SHARED_LIBRARIES.map(packageOf), SDK]);
+
+  return [
+    {
+      name: 'artemis-studio-plugin',
+      // A remote has no index.html: the exposed module is the build's input, remoteEntry.js its entry.
+      config: () => ({
+        base: './',
+        build: { outDir, emptyOutDir: true, target: 'esnext', rolldownOptions: { input: entry } },
+      }),
+      resolveId(source, importer) {
+        if (!importer || !source.startsWith('@mantine/')) return null;
+        if (allowed.has(packageOf(source)) && !source.endsWith('.css')) return null;
+        this.error(
+          `${source} is not shared by Studio, so a plugin would load its own copy beside Studio's. ` +
+            (source.startsWith('@mantine/notifications')
+              ? 'Use notify from @artemis-studio/plugin-sdk instead.'
+              : source.endsWith('.css')
+                ? "Studio already loads Mantine's styles; remove this import."
+                : 'Use @mantine/core and @mantine/hooks only.'),
+        );
+      },
+    },
+    federation({
+      name: `plugin_${id.replace(/-/g, '_')}`,
+      filename: 'remoteEntry.js',
+      exposes: { './feature': entry },
+      shared,
+      dts: false,
+    }),
+  ];
+}