@makinbakin/sdk 0.0.1-rc.2 → 0.0.1-rc.20

package/index.d.ts

@@ -20,8 +20,70 @@
  * (emitted by Bakin) resolves those to the host's bundled copies so there
  * is a single React instance and a single SDK.
  */
+/** Re-exports every plugin contract type. See `@makinbakin/sdk/types` for the full list. */
 export * from './types/index';
-export { registerPlugin, unregisterPlugin, registerPluginCleanup, getRegistryVersion, subscribeRegistry, getAllNavItems, getNavItemsSnapshot, getPluginNavItems, getPluginRoute, getPluginRoutes, } from './register';
+/** Register a plugin (single-call entry from a plugin's `client.tsx`). */
+export { registerPlugin } from './register';
+/** Tear down all registrations owned by a plugin (used during hot-swap). */
+export { unregisterPlugin } from './register';
+/** Register a cleanup callback fired when the plugin is unregistered. */
+export { registerPluginCleanup } from './register';
+/** Current registry version — bumps on every mutation (for useSyncExternalStore). */
+export { getRegistryVersion } from './register';
+/** Subscribe to registry-version changes. */
+export { subscribeRegistry } from './register';
+/** Get every registered nav item across all plugins. */
+export { getAllNavItems } from './register';
+/** Get a snapshot of the current nav items (non-subscribing). */
+export { getNavItemsSnapshot } from './register';
+/** Get nav items contributed by a specific plugin. */
+export { getPluginNavItems } from './register';
+/** Set or clear a runtime badge on a plugin-owned nav item. */
+export { setNavBadge } from './register';
+/** Read the current badge for a nav item, or undefined if none. */
+export { getNavBadge } from './register';
+/** Stable snapshot of every active nav badge keyed by navItemId. */
+export { getNavBadgesSnapshot } from './register';
+/** Subscribe to nav-badge mutations (separate channel from `subscribeRegistry`). */
+export { subscribeNavBadges } from './register';
+/** Look up a specific client route by plugin id + path. */
+export { getPluginRoute } from './register';
+/** Get all registered client routes (across all plugins). */
+export { getPluginRoutes } from './register';
+/** Seed a plugin's declarative nav from its manifest (host-side; survives unregisterPlugin). */
+export { setManifestNav } from './register';
+/** Read the manifest nav currently seeded for a plugin (drift validation). */
+export { getManifestNav } from './register';
 export type { ClientRouteEntry, MatchedPluginRoute, NavItem, PluginRegistration } from './register';
-export { defineRoute, defineCoreRoute, definePlugin } from './routing/index';
+/** Install the manifest-derived slot/route ownership index for lazy loading (host-side). */
+export { configureLazyPlugins } from './lazy/index';
+/** Install the demand loader that imports a plugin's client bundle (host-side). */
+export { setLazyPluginLoader } from './lazy/index';
+/** Report a plugin client's load progress: idle → loading → loaded | error (host-side). */
+export { setPluginLoadState } from './lazy/index';
+/** Current load state for a plugin client. Unknown plugins report 'idle'. */
+export { getPluginLoadState } from './lazy/index';
+/** Last load error message for a plugin whose state is 'error', if any. */
+export { getPluginLoadError } from './lazy/index';
+/** Plugins whose manifests declare the given slot in `contributes.slots`. */
+export { getSlotOwners } from './lazy/index';
+/** Plugins whose manifest `contributes.routes` patterns match a pathname. */
+export { getRouteOwners } from './lazy/index';
+/** Ask the host to lazy-load every idle plugin that fills the named slot. */
+export { requestSlotPlugins } from './lazy/index';
+/** Ask the host to lazy-load every idle plugin whose route patterns match the pathname. */
+export { requestRoutePlugins } from './lazy/index';
+/** Reset a failed plugin to idle and re-request its client bundle. */
+export { retryPluginLoad } from './lazy/index';
+/** Monotonic lazy-store version for useSyncExternalStore consumers. */
+export { getLazyPluginsVersion } from './lazy/index';
+/** Subscribe to lazy-plugin store mutations. Returns an unsubscribe fn. */
+export { subscribeLazyPlugins } from './lazy/index';
+export type { LazyPluginIndex, PluginLoadState } from './lazy/index';
+/** Define a plugin HTTP route with typed input/output schemas. */
+export { defineRoute } from './routing/index';
+/** Define a core (non-plugin) HTTP route. */
+export { defineCoreRoute } from './routing/index';
+/** Compose a plugin's routes into a single definition for the server. */
+export { definePlugin } from './routing/index';
 export type { APIRoute, HttpStatus, RouteContext, PluginContextLite, CoreContext, BodySpec, ResponseSpec, ParsedInput, } from './routing/index';

package/index.js

@@ -13,10 +13,7 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
-// packages/sdk/src/slots/index.tsx
-import { useSyncExternalStore } from "react";
-import { jsxDEV, Fragment } from "react/jsx-dev-runtime";
-"use client";
+// packages/sdk/src/slots/registry.ts
 function getRegistry() {
   const g = globalThis;
   if (!g.__bakinSlotRegistry) {
@@ -46,6 +43,11 @@ function clearSlotsOwnedBy(pluginId) {
 "use client";
 function buildNavItemsSnapshot(registry) {
   const items = [];
+  for (const [pluginId, navItems] of registry.manifestNavByPlugin.entries()) {
+    if (registry.navByPlugin.has(pluginId))
+      continue;
+    items.push(...navItems);
+  }
   for (const navItems of registry.navByPlugin.values()) {
     items.push(...navItems);
   }
@@ -56,19 +58,52 @@ function getRegistry2() {
   if (!g.__bakinClientRegistry) {
     g.__bakinClientRegistry = {
       navByPlugin: new Map,
+      manifestNavByPlugin: new Map,
       routesByPlugin: new Map,
       cleanupByPlugin: new Map,
       navItemsSnapshot: [],
       version: 0,
-      listeners: new Set
+      listeners: new Set,
+      badgesByPlugin: new Map,
+      badgesSnapshot: new Map,
+      badgeListeners: new Set
     };
   }
   const registry = g.__bakinClientRegistry;
+  if (!registry.manifestNavByPlugin)
+    registry.manifestNavByPlugin = new Map;
   if (!Array.isArray(registry.navItemsSnapshot)) {
     registry.navItemsSnapshot = buildNavItemsSnapshot(registry);
   }
+  if (!registry.badgesByPlugin)
+    registry.badgesByPlugin = new Map;
+  if (!registry.badgesSnapshot)
+    registry.badgesSnapshot = buildBadgesSnapshot(registry);
+  if (!registry.badgeListeners)
+    registry.badgeListeners = new Set;
   return registry;
 }
+function buildBadgesSnapshot(registry) {
+  const snapshot = new Map;
+  for (const byNavItemId of registry.badgesByPlugin.values()) {
+    for (const [navItemId, badge] of byNavItemId) {
+      if (!snapshot.has(navItemId))
+        snapshot.set(navItemId, badge);
+    }
+  }
+  return snapshot;
+}
+function bumpBadges() {
+  const registry = getRegistry2();
+  registry.badgesSnapshot = buildBadgesSnapshot(registry);
+  for (const l of registry.badgeListeners) {
+    try {
+      l();
+    } catch (err) {
+      console.error("[bakin] badge listener threw:", err);
+    }
+  }
+}
 function bumpVersion() {
   const registry = getRegistry2();
   registry.navItemsSnapshot = buildNavItemsSnapshot(registry);
@@ -116,7 +151,10 @@ function unregisterPlugin(id) {
   registry.navByPlugin.delete(id);
   registry.routesByPlugin.delete(id);
   clearSlotsOwnedBy(id);
+  const hadBadges = registry.badgesByPlugin.delete(id);
   bumpVersion();
+  if (hadBadges)
+    bumpBadges();
 }
 function registerPluginCleanup(id, fn) {
   const registry = getRegistry2();
@@ -124,6 +162,23 @@ function registerPluginCleanup(id, fn) {
   list.push(fn);
   registry.cleanupByPlugin.set(id, list);
 }
+function setManifestNav(pluginId, navItems) {
+  const registry = getRegistry2();
+  if (!navItems || navItems.length === 0) {
+    if (!registry.manifestNavByPlugin.delete(pluginId))
+      return;
+    bumpVersion();
+    return;
+  }
+  const prev = registry.manifestNavByPlugin.get(pluginId);
+  if (prev && JSON.stringify(prev) === JSON.stringify(navItems))
+    return;
+  registry.manifestNavByPlugin.set(pluginId, navItems);
+  bumpVersion();
+}
+function getManifestNav(pluginId) {
+  return getRegistry2().manifestNavByPlugin.get(pluginId) ?? [];
+}
 function getRegistryVersion() {
   return getRegistry2().version;
 }
@@ -143,6 +198,41 @@ function getNavItemsSnapshot() {
 function getPluginNavItems(pluginId) {
   return getRegistry2().navByPlugin.get(pluginId) ?? [];
 }
+function setNavBadge(pluginId, navItemId, badge) {
+  const registry = getRegistry2();
+  let plugin = registry.badgesByPlugin.get(pluginId);
+  if (badge === null) {
+    if (!plugin?.has(navItemId))
+      return;
+    plugin.delete(navItemId);
+    if (plugin.size === 0)
+      registry.badgesByPlugin.delete(pluginId);
+    bumpBadges();
+    return;
+  }
+  const prev = plugin?.get(navItemId);
+  if (prev && prev.count === badge.count && prev.tone === badge.tone)
+    return;
+  if (!plugin) {
+    plugin = new Map;
+    registry.badgesByPlugin.set(pluginId, plugin);
+  }
+  plugin.set(navItemId, { count: badge.count, tone: badge.tone });
+  bumpBadges();
+}
+function getNavBadge(navItemId) {
+  return getRegistry2().badgesSnapshot.get(navItemId);
+}
+function getNavBadgesSnapshot() {
+  return getRegistry2().badgesSnapshot;
+}
+function subscribeNavBadges(listener) {
+  const registry = getRegistry2();
+  registry.badgeListeners.add(listener);
+  return () => {
+    registry.badgeListeners.delete(listener);
+  };
+}
 function normalizePattern(pattern) {
   return pattern.split("/").filter(Boolean);
 }
@@ -200,6 +290,107 @@ function getPluginRoutes(pluginId) {
     return registry.routesByPlugin.get(pluginId) ?? [];
   return [...registry.routesByPlugin.values()].flat();
 }
+// packages/sdk/src/lazy.ts
+"use client";
+function getStore() {
+  const g = globalThis;
+  if (!g.__bakinLazyPluginStore) {
+    g.__bakinLazyPluginStore = {
+      ownersBySlot: new Map,
+      routeOwners: [],
+      states: new Map,
+      errors: new Map,
+      loader: null,
+      version: 0,
+      listeners: new Set
+    };
+  }
+  return g.__bakinLazyPluginStore;
+}
+function bump() {
+  const store = getStore();
+  store.version++;
+  for (const l of store.listeners) {
+    try {
+      l();
+    } catch (err) {
+      console.error("[bakin] lazy-plugin listener threw:", err);
+    }
+  }
+}
+function configureLazyPlugins(index) {
+  const store = getStore();
+  store.ownersBySlot = new Map(index.slotOwners);
+  store.routeOwners = [...index.routeOwners];
+  bump();
+}
+function setLazyPluginLoader(loader) {
+  getStore().loader = loader;
+}
+function setPluginLoadState(pluginId, state, error) {
+  const store = getStore();
+  if (store.states.get(pluginId) === state && store.errors.get(pluginId) === error)
+    return;
+  store.states.set(pluginId, state);
+  if (state === "error" && error)
+    store.errors.set(pluginId, error);
+  else
+    store.errors.delete(pluginId);
+  bump();
+}
+function getPluginLoadState(pluginId) {
+  return getStore().states.get(pluginId) ?? "idle";
+}
+function getPluginLoadError(pluginId) {
+  return getStore().errors.get(pluginId);
+}
+function getSlotOwners(name) {
+  return getStore().ownersBySlot.get(name) ?? [];
+}
+function getRouteOwners(pathname) {
+  const owners = [];
+  for (const { pattern, pluginId } of getStore().routeOwners) {
+    if (matchRoutePattern(pattern, pathname) && !owners.includes(pluginId)) {
+      owners.push(pluginId);
+    }
+  }
+  return owners;
+}
+function demand(pluginIds) {
+  const store = getStore();
+  if (!store.loader)
+    return;
+  for (const pluginId of pluginIds) {
+    if ((store.states.get(pluginId) ?? "idle") !== "idle")
+      continue;
+    store.loader(pluginId);
+  }
+}
+function requestSlotPlugins(name) {
+  demand(getSlotOwners(name));
+}
+function requestRoutePlugins(pathname) {
+  demand(getRouteOwners(pathname));
+}
+function retryPluginLoad(pluginId) {
+  const store = getStore();
+  if (store.states.get(pluginId) !== "error")
+    return;
+  store.states.set(pluginId, "idle");
+  store.errors.delete(pluginId);
+  bump();
+  demand([pluginId]);
+}
+function getLazyPluginsVersion() {
+  return getStore().version;
+}
+function subscribeLazyPlugins(listener) {
+  const store = getStore();
+  store.listeners.add(listener);
+  return () => {
+    store.listeners.delete(listener);
+  };
+}
 // packages/core/src/routing/define.ts
 function defineRoute(route) {
   return route;
@@ -13947,7 +14138,8 @@ function getBakinPaths() {
     tasks: join(home, "tasks"),
     workflows: join(home, "workflows"),
     settings: join(home, "settings.json"),
-    logs: join(home, "logs")
+    logs: join(home, "logs"),
+    db: join(home, "bakin.db")
   };
 }
 
@@ -14111,11 +14303,22 @@ function suppressPrettyInfo(entry) {
   }
   return [
     "search-registry",
+    "search-registry-core",
+    "search-plugin-api",
+    "search-reindex",
+    "search-query",
     "search-reconcile",
     "search-cleanup",
+    "search-startup",
     "hot-reload-coordinator",
     "mcporter",
     "dispatch",
+    "dispatch-state",
+    "dispatch-turns",
+    "dispatch-session-death",
+    "dispatch-workflow",
+    "dispatch-cycle",
+    "dispatch-single",
     "watchdog",
     "doctor",
     "lifecycle"
@@ -14230,15 +14433,33 @@ var errorResponse = exports_external.object({ error: exports_external.string() }
 export {
   unregisterPlugin,
   subscribeRegistry,
+  subscribeNavBadges,
+  subscribeLazyPlugins,
+  setPluginLoadState,
+  setNavBadge,
+  setManifestNav,
+  setLazyPluginLoader,
+  retryPluginLoad,
+  requestSlotPlugins,
+  requestRoutePlugins,
   registerPluginCleanup,
   registerPlugin,
+  getSlotOwners,
+  getRouteOwners,
   getRegistryVersion,
   getPluginRoutes,
   getPluginRoute,
   getPluginNavItems,
+  getPluginLoadState,
+  getPluginLoadError,
   getNavItemsSnapshot,
+  getNavBadgesSnapshot,
+  getNavBadge,
+  getManifestNav,
+  getLazyPluginsVersion,
   getAllNavItems,
   defineRoute,
   definePlugin,
-  defineCoreRoute
+  defineCoreRoute,
+  configureLazyPlugins
 };

package/metadata/index.d.ts

@@ -13,4 +13,17 @@
  * from `@makinbakin/sdk/routing` (the typed declarative shape).
  */
 export type { ContractMetadata, ContractStability, ContractVisibility, CliCommandContract, DocsAwareAPIRoute, DocsExample, ExecToolContract, HookContract, HookKind, PublicContract, RouteContract, SchemaLike, SlotContract, SourceLocation, } from '../_internal/core/docs';
-export { defineApiRoute, defineCliCommandContract, defineExecToolContract, defineHookContract, definePluginRoute, defineRouteContract, defineSlotContract, } from '../_internal/core/docs';
+/** Legacy: declare an API route with docs metadata. Prefer `defineRoute` from `/routing`. */
+export { defineApiRoute } from '../_internal/core/docs';
+/** Define a CLI command contract for documentation. */
+export { defineCliCommandContract } from '../_internal/core/docs';
+/** Define an MCP exec tool contract for documentation. */
+export { defineExecToolContract } from '../_internal/core/docs';
+/** Define a cross-plugin hook contract for documentation. */
+export { defineHookContract } from '../_internal/core/docs';
+/** Legacy: declare a plugin route with docs metadata. Prefer `defineRoute` from `/routing`. */
+export { definePluginRoute } from '../_internal/core/docs';
+/** Define a generic route contract (shared shape for API + plugin routes). */
+export { defineRouteContract } from '../_internal/core/docs';
+/** Define a UI slot contract for documentation. */
+export { defineSlotContract } from '../_internal/core/docs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makinbakin/sdk",
-  "version": "0.0.1-rc.2",
+  "version": "0.0.1-rc.20",
   "description": "SDK for building Bakin plugins — UI components, slot types, hooks, and the runtime registerPlugin helper.",
   "type": "module",
   "sideEffects": false,

package/register.d.ts

@@ -17,15 +17,7 @@
  * nav + slot trees re-render when plugins come or go at runtime.
  */
 import type { ComponentType } from 'react';
-interface NavItem {
-    id: string;
-    label: string;
-    icon?: string;
-    href?: string;
-    order?: number;
-    alwaysExpanded?: boolean;
-    children?: NavItem[];
-}
+import type { NavBadge, NavItem } from './types/index';
 interface PluginRegistration {
     id: string;
     navItems?: NavItem[];
@@ -68,6 +60,23 @@ export declare function unregisterPlugin(id: string): void;
  * use this to hook into the unified teardown path.
  */
 export declare function registerPluginCleanup(id: string, fn: () => void): void;
+/**
+ * Seed (or replace) a plugin's declarative nav from its manifest
+ * `contributes.nav`. Called by the host's PluginHost after every manifest
+ * fetch — including hot-swap refreshes — so the sidebar renders before any
+ * client bundle loads. Pass `null` (or an empty array) to clear.
+ *
+ * Manifest nav lives on its own map: `unregisterPlugin` never touches it,
+ * and a plugin that registers `navItems` at runtime overrides its manifest
+ * nav while registered (the conditional-nav escape hatch).
+ */
+export declare function setManifestNav(pluginId: string, navItems: NavItem[] | null): void;
+/**
+ * The declarative manifest nav currently seeded for a plugin (empty if none).
+ * Used by the drift validation check to compare manifest nav against what a
+ * loaded client registered at runtime.
+ */
+export declare function getManifestNav(pluginId: string): ReadonlyArray<NavItem>;
 /**
  * Monotonic counter bumped on every register / unregister. Used with
  * React's `useSyncExternalStore` (via `subscribeRegistry`) so the shell
@@ -92,6 +101,33 @@ export declare function getNavItemsSnapshot(): readonly NavItem[];
  * Nav items for a specific plugin. Returned as a readonly copy.
  */
 export declare function getPluginNavItems(pluginId: string): ReadonlyArray<NavItem>;
+/**
+ * Set or clear the badge for a nav item owned by a plugin. Pass `null` to
+ * clear. Safe to call before the nav item itself is registered — the badge
+ * survives in the registry until the owning plugin is unregistered.
+ */
+export declare function setNavBadge(pluginId: string, navItemId: string, badge: NavBadge | null): void;
+/** Read the current badge for a nav item, or undefined if none. */
+export declare function getNavBadge(navItemId: string): NavBadge | undefined;
+/**
+ * Stable snapshot of every active badge keyed by navItemId. The identity
+ * of the returned Map only changes when a badge is set, cleared, or its
+ * owning plugin is unregistered — safe for React's `useSyncExternalStore`.
+ */
+export declare function getNavBadgesSnapshot(): ReadonlyMap<string, NavBadge>;
+/**
+ * Subscribe to badge mutations on a channel separate from `subscribeRegistry`
+ * so high-frequency badge ticks don't force the whole nav to re-render.
+ */
+export declare function subscribeNavBadges(listener: () => void): () => void;
+/**
+ * Match a route pattern (`/projects/[id]`, `/x/:id`, `/y/$id`) against a
+ * concrete pathname. Internal SDK helper shared with the lazy-loading index.
+ */
+export declare function matchRoutePattern(pattern: string, pathname: string): {
+    params: Record<string, string>;
+    score: number;
+} | null;
 export interface MatchedPluginRoute {
     pluginId: string;
     path: string;

package/routing/index.d.ts

@@ -7,5 +7,10 @@
  * two parallel `APIRoute<...>` definitions in sync is a debt we are
  * deliberately avoiding.
  */
-export { defineRoute, defineCoreRoute, definePlugin, } from '../_internal/core/routing';
+/** Define a plugin HTTP route with typed input/output and handler. */
+export { defineRoute } from '../_internal/core/routing';
+/** Define a core (non-plugin) HTTP route. */
+export { defineCoreRoute } from '../_internal/core/routing';
+/** Compose a plugin's routes into a single definition for the server. */
+export { definePlugin } from '../_internal/core/routing';
 export type { HttpMethod, HttpStatus, RouteContext, PluginContextLite, CoreContext, JsonBodySpec, MultipartBodySpec, RawBodySpec, NoBodySpec, BodySpec, JsonResponseSpec, NoContentResponseSpec, NonJsonResponseSpec, ResponseSpec, ParsedInput, APIRoute, PluginWithRoutes, DefinePluginInput, } from '../_internal/core/routing';

package/routing/index.js

@@ -13761,7 +13761,8 @@ function getBakinPaths() {
     tasks: join(home, "tasks"),
     workflows: join(home, "workflows"),
     settings: join(home, "settings.json"),
-    logs: join(home, "logs")
+    logs: join(home, "logs"),
+    db: join(home, "bakin.db")
   };
 }
 
@@ -13925,11 +13926,22 @@ function suppressPrettyInfo(entry) {
   }
   return [
     "search-registry",
+    "search-registry-core",
+    "search-plugin-api",
+    "search-reindex",
+    "search-query",
     "search-reconcile",
     "search-cleanup",
+    "search-startup",
     "hot-reload-coordinator",
     "mcporter",
     "dispatch",
+    "dispatch-state",
+    "dispatch-turns",
+    "dispatch-session-death",
+    "dispatch-workflow",
+    "dispatch-cycle",
+    "dispatch-single",
     "watchdog",
     "doctor",
     "lifecycle"

package/slots/index.d.ts

@@ -19,29 +19,15 @@
  * Registration happens at plugin client-module load time (import side effect).
  * Test-only helpers are not exported — tests use the public unregister path.
  */
-import { type ComponentType, type JSX } from 'react';
-interface SlotEntry {
-    component: ComponentType<Record<string, unknown>>;
-    order: number;
-    owner?: string;
-}
-/**
- * Register a component for a named slot. Lower `order` renders first; entries
- * with the same order render in registration order. Default `order` is 100.
- * `owner` is the pluginId for teardown-on-hot-swap; omit in test setups.
- */
-export declare function registerSlot<TProps>(name: string, component: ComponentType<TProps>, order?: number, owner?: string): void;
-/**
- * Read the registered entries for a slot. Exported for tooling / tests.
- */
-export declare function getSlotEntries(name: string): ReadonlyArray<SlotEntry>;
-/**
- * Remove every slot entry owned by the given plugin. Used by
- * `unregisterPlugin` during v2 hot-swap. Entries without an `owner`
- * (test registrations, pre-v2 legacy registrations) survive — callers
- * that want to wipe unowned entries should re-register them after.
- */
-export declare function clearSlotsOwnedBy(pluginId: string): void;
+import { type JSX } from 'react';
+/** Register a component for a named slot. Lower `order` renders first; default `order` is 100. */
+export { registerSlot } from './registry/index';
+/** Read the registered entries for a slot. Exported for tooling / tests. */
+export { getSlotEntries } from './registry/index';
+/** Slot names with at least one entry owned by the given plugin (manifest drift checks). */
+export { getSlotNamesOwnedBy } from './registry/index';
+/** Remove every slot entry owned by the given plugin (hot-swap teardown). */
+export { clearSlotsOwnedBy } from './registry/index';
 interface SlotProps {
     name: string;
     [key: string]: unknown;
@@ -50,6 +36,12 @@ interface SlotProps {
  * Render all components registered for the named slot, in order. Extra props
  * are passed through to every registered component unchanged. Returns `null`
  * if nothing is registered.
+ *
+ * Lazy loading: rendering a slot is a demand signal — if a manifest declares
+ * an owner for this slot whose client bundle hasn't loaded yet, the host's
+ * loader fires and the slot re-renders once `registerPlugin` runs. While an
+ * owner is loading the slot renders nothing (page slots resolve in one
+ * paint on the LAN); if an owner's bundle failed to import, an inline error
+ * with a retry button renders instead of silent emptiness.
  */
 export declare function Slot({ name, ...props }: SlotProps): JSX.Element | null;
-export {};