@kromatv/sdk 0.1.40-canary.0

package/types/module-sdk/src/admin/hooks.d.ts

@@ -0,0 +1,39 @@
+import { type Permission, type User } from '@kroma/client/accounts';
+import { type QueryKey } from '@tanstack/react-query';
+/** Polls `fn` every `intervalMs` through TanStack Query. Prefix `key` with `'admin'`
+ * so `invalidateQueries(['admin'])` refreshes it, and put varying inputs in `key`.
+ *
+ * `loading` is true only until the FIRST answer; a later poll that fails leaves
+ * the last good `data` in place and raises `failed`. `error` is that failure's
+ * cause, for a page that says WHY rather than only that it failed. */
+export declare function usePoll<T>(key: QueryKey, fn: () => Promise<T>, intervalMs: number): {
+    data: T | null;
+    loading: boolean;
+    failed: boolean;
+    error: unknown;
+    reload: () => Promise<void>;
+};
+/** Fetches `fn` once through TanStack Query and keeps the answer, for data that
+ * does not move: a torrent's file list, a season's episode names. Same shape as
+ * {@link usePoll}, so the two are interchangeable at a call site.
+ *
+ * A `null` key holds the request back until the inputs it needs exist, and
+ * reports `loading: false` while it waits, because nothing is in flight. */
+export declare function useFetch<T>(key: QueryKey | null, fn: () => Promise<T>): {
+    data: T | null;
+    loading: boolean;
+    failed: boolean;
+    error: unknown;
+    reload: () => Promise<void>;
+};
+/** `run(fn, onError?)` flips `busy` while `fn` runs and, on failure, sets `error` to `onError(e)`. */
+export declare function useAsyncAction(): {
+    busy: boolean;
+    error: string | null;
+    run: (fn: () => Promise<void>, onError?: (e: unknown) => string) => Promise<void>;
+};
+/** True if the user holds any management capability, which unlocks the console.
+ * `requests.manage` counts: a moderator needs the shell for the requests queue. */
+export declare function isAnyAdmin(user: Pick<User, 'permissions'> | null | undefined): boolean;
+/** Whether the current user satisfies `cap` (or is any admin when `cap` is null). */
+export declare function useCap(cap?: Permission | null): boolean;

package/types/module-sdk/src/admin/page-states.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The shape of a console page, pulsing: a title, a subtitle, and the panels
+ * under them. Deliberately the page's OWN silhouette rather than a spinner -
+ * it says what is coming and holds the layout, so nothing jumps when the real
+ * page lands.
+ */
+export declare function ModuleLoading({ panels }: Readonly<{
+    panels?: number;
+}>): import("react").JSX.Element;
+/** A module that is not installed, or has been turned off: its pages vanish
+ *  with its nav, and this says so rather than 404-ing. */
+export declare function ModuleUnavailable(): import("react").JSX.Element;
+interface ModuleFailedProps {
+    /** Offered as a Retry button; a page that cannot ask again omits it. */
+    retry?: () => void;
+    /** The thrown cause, which chooses the explanation: a request that never
+     *  reached a server reads as the server being down, an HTTP answer as the
+     *  module's. Without one the state falls back to the generic wording. */
+    error?: unknown;
+    /** The raw text under that explanation. Defaults to what `error` carries. */
+    detail?: string;
+}
+/** A module page whose own data could not be fetched. Distinct from
+ *  {@link ModuleUnavailable}: the module IS there, the request failed. Pass
+ *  `retry` where the page can ask again, and the state offers the button. */
+export declare function ModuleFailed({ retry, error, detail }: Readonly<ModuleFailedProps>): import("react").JSX.Element;
+export {};

package/types/module-sdk/src/admin/settings.d.ts

@@ -0,0 +1,9 @@
+import type { MessageKey } from '@kroma/core';
+interface SettingsViewProps {
+    view: string;
+    titleKey: MessageKey;
+    subtitleKey: MessageKey;
+    embedded?: boolean;
+}
+export declare function SettingsView(props: Readonly<SettingsViewProps>): import("react").JSX.Element;
+export {};

package/types/module-sdk/src/bus.d.ts

@@ -0,0 +1,8 @@
+import type { KromaEvents } from './contracts';
+export type EventKey = Extract<keyof KromaEvents, string>;
+export interface EventBus {
+    emit<K extends EventKey>(key: K, payload: KromaEvents[K]): void;
+    on<K extends EventKey>(key: K, handler: (payload: KromaEvents[K]) => void): () => void;
+}
+/** Dispatch is synchronous: `emit` returns once every handler has run. */
+export declare function createEventBus(): EventBus;

package/types/module-sdk/src/contracts.d.ts

@@ -0,0 +1,6 @@
+/** Maps a module id to the API it exports for other modules to consume. */
+export interface ModuleApiRegistry {
+}
+/** Maps an event name to its payload type. */
+export interface KromaEvents {
+}

package/types/module-sdk/src/define.d.ts

@@ -0,0 +1,38 @@
+import type { ComponentType } from 'react';
+import type { KromaHost } from './host';
+import type { AnySlotContribution, KromaModule, ModuleComponentProps, NavItem, SettingsPanel } from './module';
+import type { Dependencies } from './types';
+/** The absolute URL a module page lives at: admin sections under `/admin/<path>`,
+ *  everything else under `/<path>`. The single source of truth, so the route and
+ *  the nav link cannot drift. */
+export declare function pageHref(section: string, path: string): string;
+/** One page a module contributes: a route, plus nav metadata when it should show
+ *  in a sidebar. Omit `nav` for deep links and detail pages. */
+export interface ModulePage {
+    path: string;
+    component: ComponentType<ModuleComponentProps>;
+    nav?: Omit<NavItem, 'to'> & {
+        section: string;
+    };
+}
+export interface ModuleManifestInput {
+    id: string;
+    version: string;
+    dependencies?: Dependencies;
+    optionalDependencies?: Dependencies;
+}
+export interface DefineModuleOptions<Exports = unknown> {
+    manifest?: ModuleManifestInput;
+    locales?: Record<string, Record<string, string>>;
+    pages?: ModulePage[];
+    settingsPanels?: SettingsPanel[];
+    slots?: AnySlotContribution[];
+    exports?: (host: KromaHost) => Exports;
+    setup?: (host: KromaHost) => void | Promise<void>;
+    dependencies?: Dependencies;
+    optionalDependencies?: Dependencies;
+}
+/** Build a `KromaModule` from its manifest + pages. `defineModule({ pages })` has
+ *  the manifest and locales injected by the `@kroma/module-sdk/vite` plugin;
+ *  `defineModule(manifest, { pages })` is the explicit form for when it is off. */
+export declare function defineModule<Exports = unknown>(manifestOrOptions: ModuleManifestInput | DefineModuleOptions<Exports>, maybeOptions?: DefineModuleOptions<Exports>): KromaModule<Exports>;

package/types/module-sdk/src/events.d.ts

@@ -0,0 +1,11 @@
+import { type ServerEvent } from '@kroma/client/events';
+/** Subscribe to the server's event socket. A module widens the frame union
+ *  with its own event types, declared in its package, not in core:
+ *
+ *  ```ts
+ *  useServerEvents<DownloadProgressEvent | VpnStatusEvent>((e) => { ... });
+ *  ```
+ */
+export declare function useServerEvents<M extends {
+    type: string;
+} = never>(onEvent: (e: ServerEvent | M) => void): void;

package/types/module-sdk/src/host.d.ts

@@ -0,0 +1,32 @@
+import type { EventBus } from './bus';
+import type { ModuleApiRegistry } from './contracts';
+import type { ModuleManifest } from './types';
+/** The slice of the server API the host grants modules. The web host adapts its
+ *  concrete `KromaClient` to this; a module never depends on the client package. */
+export interface HostApi {
+    get<T>(path: string): Promise<T>;
+    listModules(): Promise<ModuleManifest[]>;
+}
+export interface HostAuth {
+    readonly userId: string | null;
+    can(capability: string): boolean;
+}
+export interface HostI18n {
+    t(key: string, vars?: Record<string, unknown>): string;
+    readonly locale: string;
+}
+export interface HostNav {
+    navigate(to: string): void;
+}
+/** Everything a module receives at setup. */
+export interface KromaHost {
+    api: HostApi;
+    auth: HostAuth;
+    i18n: HostI18n;
+    nav: HostNav;
+    bus: EventBus;
+    getModuleApi<K extends keyof ModuleApiRegistry>(id: K): ModuleApiRegistry[K] | undefined;
+}
+/** What the host provides to the registry; `getModuleApi` is wired by the
+ *  registry itself, so the caller supplies everything except that. */
+export type HostBase = Omit<KromaHost, 'getModuleApi'>;

package/types/module-sdk/src/icon.d.ts

@@ -0,0 +1 @@
+export declare function moduleIconUrl(id: string, baseUrl?: string): string;

package/types/module-sdk/src/index.d.ts

@@ -0,0 +1,35 @@
+export { apiErrorText, brandedId, type KromaClient } from '@kroma/client';
+export { KromaEvents as KromaEventStream, type ServerEvent } from '@kroma/client/events';
+export { ItemId } from '@kroma/client/media';
+export { type EngineContribution, type ModuleApi, ModuleId } from '@kroma/client/modules';
+export { IndexerId, RequestId } from '@kroma/client/requests';
+export type { MessageKey } from '@kroma/core';
+export { useFormat, useLocale } from '@kroma/ui';
+export type { AdminHostValue } from './admin/context';
+export { AdminHostProvider, useAdminHost } from './admin/context';
+export { Denied } from './admin/denied';
+export type { AddEngineOptions, EngineChoice } from './admin/engines';
+export { AddEngineHost, addEngine, FieldForm, useEnabledEngines, useModuleEnabled, useModuleEnabledCheck, } from './admin/engines';
+export { isAnyAdmin, useAsyncAction, useCap, useFetch, usePoll } from './admin/hooks';
+export { ModuleFailed, ModuleLoading, ModuleUnavailable } from './admin/page-states';
+export { SettingsView } from './admin/settings';
+export type { EventBus, EventKey } from './bus';
+export { createEventBus } from './bus';
+export type { KromaEvents, ModuleApiRegistry } from './contracts';
+export type { DefineModuleOptions, ModuleManifestInput, ModulePage } from './define';
+export { defineModule, pageHref } from './define';
+export { useServerEvents } from './events';
+export type { HostApi, HostAuth, HostBase, HostI18n, HostNav, KromaHost } from './host';
+export { moduleIconUrl } from './icon';
+export type { KromaModule, ModuleComponentProps, NavItem, RouteDef, SettingsPanel, SlotContribution, SlotName, SlotProps, } from './module';
+export type { ModuleNav, ModulePanel, ModuleRoute, ModuleSlotEntry, ModuleStatus, } from './registry';
+export { depEntries, ModuleRegistry } from './registry';
+export { ModuleScope, moduleApiHook, useModuleApi, useT } from './scope';
+export type { SharedModule } from './shared';
+export { PUBLIC_NAME, REMOTE_ENTRY, REMOTE_STYLES, remoteEntryUrl, SHARED_GLOBAL, SHARED_MODULES, sharedKey, } from './shared';
+export { ModuleSlot, ModuleSlotProvider, useSlotEntries } from './slot';
+export type { ConfigField, Contribution, Dependencies, FeRemote, ModuleManifest, PointReq, } from './types';
+export type { SortColumn, TableActionProps, TableCellProps, TableColumn, TableColumnProps, TableRootProps, TableRowProps, } from './ui/table';
+export { TABULAR, Table } from './ui/table';
+export type { PlainColumn, SortableColumn, SortDirection, SortedColumn, SortedTable, SortedTableOptions, TableHeading, TableOrder, TablePage, TableQuery, } from './use-sorted-table';
+export { useSortedTable } from './use-sorted-table';

package/types/module-sdk/src/module.d.ts

@@ -0,0 +1,83 @@
+import type { RequestId } from '@kroma/client/requests';
+import type { ComponentType } from 'react';
+import type { KromaHost } from './host';
+import type { Dependencies } from './types';
+export interface NavItem {
+    to: string;
+    label: string;
+    icon?: string;
+    section?: string;
+    requires?: string;
+}
+export interface ModuleComponentProps {
+    host: KromaHost;
+}
+/** A route registered under the host's module mount point. */
+export interface RouteDef {
+    path: string;
+    component: ComponentType<ModuleComponentProps>;
+}
+export interface SettingsPanel {
+    id: string;
+    label: string;
+    component: ComponentType<ModuleComponentProps>;
+}
+/**
+ * A place a CORE page opens for modules to fill.
+ *
+ * The core cannot import a module -- it does not know which are installed, and
+ * a page that named one would break the moment it was disabled. So the page
+ * renders a named slot and passes it props; a module answers the name. The name
+ * is the contract between them, and its props are declared in {@link SlotProps}.
+ */
+export interface SlotContribution<Name extends SlotName = SlotName> {
+    slot: Name;
+    component: ComponentType<SlotProps[Name]>;
+    /** Lower renders first when several modules fill one slot. Defaults to 0. */
+    order?: number;
+}
+/**
+ * Every slot a core page opens, and what it hands whoever fills it.
+ *
+ * Declared here so both sides typecheck against one definition: a core page
+ * cannot pass props no module expects, and a module cannot claim a slot that
+ * does not exist. Adding a slot is a change to this map first.
+ */
+export interface SlotProps {
+    /** The acquisition half of the admin request page: search for releases of
+     *  this request and grab one. Everything about indexers, releases and
+     *  downloads lives behind it. */
+    'requests.detail': {
+        requestId: RequestId;
+        kind: 'movie' | 'show';
+        title: string;
+        canGrab: boolean;
+    };
+    /** Beside one episode row of the request page's catalogue: how far along the
+     *  download of that episode is, if anything is downloading it. */
+    'requests.episode.progress': {
+        requestId: RequestId;
+        season: number;
+        episode: number;
+    };
+}
+export type SlotName = keyof SlotProps;
+/** A contribution to SOME slot, each element matched to its own slot's props.
+ *  `SlotContribution` alone would default to the union of every slot's props and
+ *  demand a component that accepts all of them at once. */
+export type AnySlotContribution = {
+    [Name in SlotName]: SlotContribution<Name>;
+}[SlotName];
+export interface KromaModule<Exports = unknown> {
+    id: string;
+    version: string;
+    dependencies?: Dependencies;
+    optionalDependencies?: Dependencies;
+    routes?: RouteDef[];
+    navItems?: NavItem[];
+    settingsPanels?: SettingsPanel[];
+    slots?: AnySlotContribution[];
+    locales?: Record<string, Record<string, string>>;
+    exports?: (host: KromaHost) => Exports;
+    setup?: (host: KromaHost) => void | Promise<void>;
+}

package/types/module-sdk/src/registry.d.ts

@@ -0,0 +1,63 @@
+import type { HostBase, KromaHost } from './host';
+import type { AnySlotContribution, KromaModule, NavItem, RouteDef, SettingsPanel, SlotName } from './module';
+import type { Dependencies, ModuleManifest } from './types';
+/** A `{ id: range }` dependency map as a flat list; `"*"` means no constraint. */
+export declare function depEntries(deps?: Dependencies | null): {
+    id: string;
+    version?: string;
+}[];
+export type ModuleRoute = RouteDef & {
+    moduleId: string;
+};
+export type ModuleNav = NavItem & {
+    moduleId: string;
+};
+export type ModulePanel = SettingsPanel & {
+    moduleId: string;
+};
+export type ModuleSlotEntry = AnySlotContribution & {
+    moduleId: string;
+};
+export interface ModuleStatus {
+    id: string;
+    frontend: true;
+    backend: boolean;
+    manifest?: ModuleManifest;
+}
+/** Where a module's own message catalogs go when it registers. The host passes
+ *  its i18n instance's `addCatalogs`; a registry built without one, as a test
+ *  or a story does, simply keeps the messages to itself. */
+export type CatalogSink = (scope: string, catalogs: Record<string, Record<string, string>>) => () => void;
+export declare class ModuleRegistry {
+    private readonly catalogs;
+    private readonly modules;
+    private readonly setupDone;
+    private readonly disposers;
+    /** @param catalogs where a registering module's messages are published. The
+     *  default drops them, so a registry is inert until a host wires one in and
+     *  two registries in one process cannot tread on each other. */
+    constructor(catalogs?: CatalogSink);
+    register(module: KromaModule): this;
+    /** Remove a module, e.g. to roll back a runtime remote whose deps don't
+     *  resolve before it breaks `order()` for everyone else. */
+    unregister(id: string): void;
+    has(id: string): boolean;
+    ids(): string[];
+    /** Modules in initialization order (dependencies first). Throws on a missing
+     *  hard dependency or a cycle; version ranges are the backend's business. */
+    order(): KromaModule[];
+    /** Resolve the graph, compute each module's exports and run its setup in
+     *  dependency order, then return the wired host. Ids in `skipSetup` are not
+     *  set up, and a module's setup runs at most once across calls. */
+    start(base: HostBase, skipSetup?: ReadonlySet<string>): Promise<KromaHost>;
+    navItems(): ModuleNav[];
+    routes(): ModuleRoute[];
+    /** Everything registered for one slot, in `order` then dependency order. The
+     *  caller decides whether a module is ENABLED: this registry only knows what
+     *  was registered. */
+    slotsFor(slot: SlotName): ModuleSlotEntry[];
+    settingsPanels(): ModulePanel[];
+    /** Cross-check registered frontend modules against the backend manifest: an
+     *  id absent from `/api/modules` comes back `backend: false`. */
+    reconcile(manifest: ModuleManifest[]): ModuleStatus[];
+}

package/types/module-sdk/src/scope.d.ts

@@ -0,0 +1,23 @@
+import { type ModuleApi } from '@kroma/client/modules';
+import { useScopedT } from '@kroma/ui';
+import { type ReactNode } from 'react';
+/** Mounted by the host around a module's page, carrying that module's id. */
+export declare function ModuleScope({ id, children }: Readonly<{
+    id: string;
+    children: ReactNode;
+}>): import("react").JSX.Element;
+/** Translate against THIS module's catalog first, then the app's. Outside a
+ *  module page it is the app's translator unchanged. */
+export declare function useT(): ReturnType<ReturnType<typeof useScopedT>>;
+/** This module's own admin API, bound to `/api/admin/m/<its id>`. Paths are
+ *  relative to that mount, so `get('/vpn')` reads the module's own `/vpn`. */
+export declare function useModuleApi(): ModuleApi;
+/** Build a module's typed API hook from a factory over its `ModuleApi`.
+ *
+ *  `moduleApiHook(factory)` binds to whichever module the host is rendering
+ *  (via `ModuleScope`), so the module never names itself. The `(id, factory)`
+ *  form binds an explicit id instead: that is the shape for an API other
+ *  packages call: the id others reach the module at, published once, next to
+ *  the methods it addresses. */
+export declare function moduleApiHook<T>(factory: (api: ModuleApi) => T): () => T;
+export declare function moduleApiHook<T>(id: string, factory: (api: ModuleApi) => T): () => T;

package/types/module-sdk/src/shared.d.ts

@@ -0,0 +1,21 @@
+/** Every import specifier a module bundle takes from the host, by exact name. */
+export declare const SHARED_MODULES: readonly ['react', 'react/jsx-runtime', 'react/jsx-dev-runtime', 'react-dom', 'react-native', '@kroma/module-sdk', '@kroma/ui', '@kroma/ui/kit', '@kroma/ui/tokens', '@kroma/core', '@kroma/core/react', '@kroma/client', '@kroma/client/query', '@kroma/i18n', '@kroma/i18n/react', '@tanstack/react-query', '@tanstack/react-router', 'react-call'];
+export type SharedModule = (typeof SHARED_MODULES)[number];
+/**
+ * What the host provides for an import specifier: the specifier itself when it
+ * is shared, `@kroma/ui/kit` for a deep kit import (the barrel exports every
+ * component, and the host holds one copy of it), and `null` for a package the
+ * bundle carries itself.
+ */
+export declare function sharedKey(specifier: string): string | null;
+/** The published package's name, and the specifier a module written against it
+ *  imports the SDK by. The host provides it as `@kroma/module-sdk`. */
+export declare const PUBLIC_NAME = "@kromatv/sdk";
+/** The global the host fills with `{ [specifier]: module namespace }` before it
+ *  imports a module's remote entry. */
+export declare const SHARED_GLOBAL = "__KROMA_SHARED__";
+/** The bundle's entry file under `fe/`, and the stylesheet beside it. */
+export declare const REMOTE_ENTRY = "remoteEntry.js";
+export declare const REMOTE_STYLES = "style.css";
+/** Where the server serves a module's `fe/` from. */
+export declare function remoteEntryUrl(baseUrl: string, id: string): string;

package/types/module-sdk/src/slot.d.ts

@@ -0,0 +1,34 @@
+import { type ReactNode } from 'react';
+import type { SlotName, SlotProps } from './module';
+import type { ModuleRegistry, ModuleSlotEntry } from './registry';
+/** Hands the shell's registry to every `<ModuleSlot>` below it. Mounted once,
+ *  beside `<AdminHostProvider>`. Without it a slot renders its fallback, which
+ *  is what a shell that contributes no modules should show anyway. */
+export declare function ModuleSlotProvider({ registry, children, }: Readonly<{
+    registry: ModuleRegistry;
+    children: ReactNode;
+}>): import("react").JSX.Element;
+/** What is registered for `slot`, before the enabled check. */
+export declare function useSlotEntries(slot: SlotName): ModuleSlotEntry[];
+type ModuleSlotProps<Name extends SlotName> = {
+    name: Name;
+    /** Shown when no enabled module fills the slot: the module is absent, or off.
+     *  Absent fallback renders nothing, for a slot that is a decoration. */
+    fallback?: ReactNode;
+} & SlotProps[Name];
+/**
+ * Render whatever enabled modules contribute to `name`, in their declared order.
+ *
+ * ```tsx
+ * <ModuleSlot
+ *   name="requests.detail"
+ *   requestId={req.id}
+ *   kind={req.kind}
+ *   title={req.title}
+ *   canGrab={canModerate}
+ *   fallback={<NoAcquisitionModule />}
+ * />
+ * ```
+ */
+export declare function ModuleSlot<Name extends SlotName>({ name, fallback, ...props }: Readonly<ModuleSlotProps<Name>>): import("react").JSX.Element;
+export {};

package/types/module-sdk/src/types.d.ts

@@ -0,0 +1,39 @@
+import type { ConfigField, Manifest } from '@kroma/registry';
+export type { ConfigField } from '@kroma/registry';
+/** One thing a backend module contributes: the `point` it answers, and the `id`
+ *  of this instance when the point takes several. A contribution the admin can
+ *  add an instance of also carries UI metadata, so the add-picker is
+ *  data-driven. */
+export interface Contribution {
+    point: string;
+    id?: string;
+    label?: string;
+    fields?: ConfigField[];
+    flow?: string;
+}
+/** A map of module id to semver range; a bare `"*"` means any version. Ranges
+ *  are enforced on the backend, so the frontend registry reads only the id, for
+ *  setup ordering. */
+export type Dependencies = Record<string, string>;
+/** A point a module calls: answered by any module whose `contributes` matches. */
+export interface PointReq {
+    point: string;
+    id?: string;
+}
+/** The frontend remote a runtime-loaded module ships (Module Federation). The
+ *  entry URL is derived by the host as `/modules/<id>/remoteEntry.js`. */
+export interface FeRemote {
+    module: string;
+}
+/** A backend module's self-description: the manifest contract, plus whether the
+ *  server currently has it enabled. */
+export type ModuleManifest = Manifest & {
+    feRemote?: FeRemote;
+    /** Whether the server currently has it enabled; runtime state, not manifest. */
+    enabled?: boolean;
+    /** Points this module `consumes` that no enabled module answers, as `point` or
+     *  `point#id`. Absent when there are none. A module with entries here is
+     *  installed and INERT: it runs and answers nothing useful, which is otherwise
+     *  silent. */
+    unmet?: string[];
+};

package/types/module-sdk/src/ui/table.d.ts

@@ -0,0 +1,88 @@
+import { type BoxProps, type ColorToken, type IconName, type SortColumn, type TableColumn } from '@kroma/ui/kit';
+import { type ReactNode } from 'react';
+/** Numerals that line up from row to row, for a date or a count column. */
+export declare const TABULAR: import("#ui/core/types").AnyStyle;
+interface TableRootProps {
+    /** One entry per column, in the order the cells are written. A column with
+     *  `from: 'md'` is drawn from that breakpoint up and absent below it, in the
+     *  header and in every row. */
+    columns: readonly TableColumn[];
+    /** Names the table to assistive tech. Draws nothing. */
+    label?: string;
+    /** The columns the rows are ordered by, and the press that changes it: given
+     *  both, every heading whose column has a name becomes the sort control. */
+    sort?: readonly SortColumn[];
+    onSortChange?: (next: readonly SortColumn[], details: {
+        column: string;
+    }) => void;
+    /** A <Table.Header>, then the rows. */
+    children: ReactNode;
+}
+declare function Root({ columns, label, sort, onSortChange, children }: Readonly<TableRootProps>): import("react").JSX.Element;
+/** The heading band above the rows: one <Table.Column> per column. */
+declare function Header({ children }: Readonly<{
+    children: ReactNode;
+}>): import("react").JSX.Element;
+interface TableRowProps {
+    /** Makes the whole row the control, so it is one pointer target and one tab
+     *  stop rather than a row of them. The controls a cell carries stay their own
+     *  buttons beside it. */
+    onPress?: () => void;
+    children: ReactNode;
+}
+/** One record. */
+declare function Row({ onPress, children }: Readonly<TableRowProps>): import("react").JSX.Element;
+interface TableCellProps extends Omit<BoxProps, 'children'> {
+    children?: ReactNode;
+}
+/** One column of one row. The box props lay its content out; the column's own
+ *  width and place come from the Root's `columns`. */
+declare function Cell({ children, ...box }: Readonly<TableCellProps>): import("react").JSX.Element;
+interface TableColumnProps {
+    children?: ReactNode;
+}
+/** A column's name, in the header band. */
+declare function Column({ children }: Readonly<TableColumnProps>): import("react").JSX.Element;
+interface TableActionProps {
+    /** The hue the whole control is built from: its glyph, its edge and its two
+     *  fills. */
+    tone: ColorToken;
+    icon: IconName;
+    label: string;
+    onPress: () => void;
+    disabled?: boolean;
+}
+/** A shortcut sitting in a row, next to whatever the row's own press does.
+ *
+ *  The kit's ghost icon button, with only the GLYPH tinted: the surface, the
+ *  hover wash, the press and the focus ring all come from the one control every
+ *  other button in the console is built from.
+ *
+ *  `label` names it to assistive tech and is not drawn: a row of squares that
+ *  each raise a tip as the cursor crosses them is a row that flickers. */
+declare function Action({ tone, icon, label, onPress, disabled }: Readonly<TableActionProps>): import("react").JSX.Element;
+/**
+ * An aligned admin table.
+ *
+ * ```tsx
+ * <Table.Root columns={[{}, { width: 190, from: 'md' }, { width: 76 }]}>
+ *   <Table.Header>
+ *     <Table.Column>Titre</Table.Column>
+ *     <Table.Column>Demandeur</Table.Column>
+ *     <Table.Cell />
+ *   </Table.Header>
+ *   <Table.Row onPress={open}>…</Table.Row>
+ * </Table.Root>
+ * ```
+ */
+declare const Table: {
+    Root: typeof Root;
+    Header: typeof Header;
+    Row: typeof Row;
+    Cell: typeof Cell;
+    Column: typeof Column;
+    Action: typeof Action;
+};
+export type { SortColumn, TableColumn } from '@kroma/ui/kit';
+export type { TableActionProps, TableCellProps, TableColumnProps, TableRootProps, TableRowProps };
+export { Table };

package/types/module-sdk/src/use-sorted-table.d.ts

@@ -0,0 +1,56 @@
+import { type Table as TableInstance } from '@tanstack/react-table';
+export type SortDirection = 'asc' | 'desc';
+export interface TableOrder<Key extends string = string> {
+    sort: Key;
+    dir: SortDirection;
+}
+export interface TableQuery<Key extends string = string> {
+    page?: number;
+    sort?: Key;
+    dir?: SortDirection;
+}
+export interface TablePage {
+    page: number;
+    perPage: number;
+    total: number;
+}
+export interface SortableColumn<Row, Key extends string = string> {
+    sortKey: Key;
+    labelKey?: string;
+    valueField: keyof Row & string;
+    ascendingFirst?: boolean;
+    wide?: boolean;
+}
+export interface PlainColumn {
+    id: string;
+    labelKey?: string;
+    valueField?: undefined;
+    wide?: boolean;
+}
+export type SortedColumn<Row, Key extends string = string> = SortableColumn<Row, Key> | PlainColumn;
+export interface TableHeading {
+    id: string;
+    labelKey?: string;
+    wide?: boolean;
+    sorted: SortDirection | false;
+    onSortPress?: () => void;
+}
+export interface SortedTableOptions<Row, Key extends string, Query extends TableQuery<Key>> {
+    columns: readonly SortedColumn<Row, Key>[];
+    rows?: Row[];
+    page?: TablePage;
+    query: Query;
+    onQueryChange: (next: Query) => void;
+    defaultOrder: TableOrder<Key>;
+    rowId?: (row: Row) => string;
+}
+export interface SortedTable<Row> {
+    table: TableInstance<Row>;
+    headings: TableHeading[];
+}
+/**
+ * A table ordered and paged by the server. The query stays authoritative, and a
+ * new order asks for page 1 because page 4 of a different order is a different
+ * list.
+ */
+export declare function useSortedTable<Row, Key extends string, Query extends TableQuery<Key>>({ columns, rows, page, query, onQueryChange, defaultOrder, rowId, }: Readonly<SortedTableOptions<Row, Key, Query>>): SortedTable<Row>;

package/types/registry/src/build.d.ts

@@ -0,0 +1,16 @@
+import { type ModuleRecord, type RegistryDescriptor, type RegistryEntry } from './documents/index.ts';
+import { type DescribedModule } from './manifest/index.ts';
+/** A hex sha256 (what the packer records) as a Subresource-Integrity string, or
+ *  `null` when the input is not one - an artifact nothing vouches for is dropped
+ *  rather than described with an integrity a client cannot check. */
+export declare function sriFromHex(hexSha256: string | null | undefined): string | null;
+/** The versions a registry already serves for a module, folded under the one
+ *  being published. */
+export type KnownVersions = Partial<Pick<ModuleRecord, 'versions' | 'distTags'>>;
+/** One module's full record. `known` folds this version into the versions a
+ *  registry already publishes, so republishing does not drop history. */
+export declare function buildModuleRecord(entry: DescribedModule, known?: KnownVersions): ModuleRecord;
+/** `GET /index.json`, sorted by id so the same module set produces the same bytes. */
+export declare function buildIndex(entries: DescribedModule[]): RegistryEntry[];
+/** `GET /registry.json`. `url` is the registry's own root, not the bundle host. */
+export declare function buildDescriptor(name: string, url: string, entries: DescribedModule[]): RegistryDescriptor;