@openpen/module-api 1.1.0 → 1.2.0

package/dist/types/module.d.ts

@@ -0,0 +1,208 @@
+import type { z } from 'zod';
+import type { ModuleContributions } from './contributions';
+import type { NotifyPayload, NotifyHandle } from './notification';
+import type { LocaleMap } from '../locale';
+/**
+ * Public contract that every OpenPen module — first-party (`src/core/modules/*`)
+ * and third-party plugin alike — must satisfy.
+ *
+ * Modules express their behaviour entirely via `contributes` and
+ * (optionally) `setup`. They never touch host-app internals directly:
+ * cross-module communication goes through declared contribution slots
+ * and the domain event bus.
+ */
+export interface OpenPenModule {
+    /** Globally unique kebab-case id. Subject to {@link import('../validation').MODULE_ID_RE}. */
+    id: string;
+    /**
+     * i18n-independent display metadata. Used as a fallback layer in the
+     * Settings UI when the module's `contributes.locales` entries are not
+     * registered (e.g. the module is disabled and its contributions are not
+     * wired into the host). The runtime i18n contribution is always preferred
+     * as the primary source; this field is only consulted on a cache miss.
+     *
+     * Values are `LocaleMap` (`Record<string, string>`) keyed by BCP-47 tag.
+     * Resolution follows the same order as `resolveLabel`: exact tag → language
+     * prefix → `'en'` fallback → first declared value.
+     */
+    metadata?: {
+        name: LocaleMap;
+        description?: LocaleMap;
+    };
+    /**
+     * SemVer string. **Required for plugins** — the host validator
+     * rejects any non-built-in module whose `version` is missing or
+     * empty with a `'missing-version'` ValidationError, so a plugin
+     * with no version never finishes loading.
+     *
+     * Built-in modules (those bundled with the host under
+     * `src/core/modules/`) MAY omit it and inherit the host version;
+     * the type stays optional only to accommodate that case.
+     */
+    version?: string;
+    /**
+     * Minimum OpenPen app version this module requires (semver).
+     *
+     * Validated at load time by the host: a plugin whose `minAppVersion`
+     * exceeds the running host version is skipped with a console warning.
+     * Set this to `"1.0.0"` (or omit it) for broad v1.x compatibility.
+     */
+    minAppVersion?: string;
+    /**
+     * One-shot initialisation, called after manifest validation and
+     * before contributions are wired into the host. Use this for things
+     * that need to happen exactly once, like seeding default settings or
+     * subscribing to long-running event streams.
+     */
+    setup?: (ctx: ModuleSetupContext) => void | Promise<void>;
+    /** At least one field on this object is required (enforced by `defineModule`). */
+    contributes?: ModuleContributions;
+    /**
+     * Zod schema for this module's user-facing settings. The host renders
+     * the settings form from this schema and persists the parsed value
+     * under `config.json.modules[id]`. The same schema validates writes
+     * made via `ctx.updateSettings()`; writes that fail validation reject
+     * with the underlying `ZodError`.
+     *
+     * Modules that intend to call `ctx.updateSettings()` MUST declare
+     * this field; calling `updateSettings` without a schema throws at
+     * runtime so the missing contract surfaces during development.
+     */
+    settingsSchema?: z.ZodType;
+    /**
+     * Settings schema version. Increment when the schema's shape changes
+     * in a way that needs migration (renames, removals, or restructuring).
+     * Pure additive changes (new keys with `.default()` values) do not
+     * require a bump — Zod's defaults fill in on parse.
+     *
+     * Defaults to `1` if omitted. The host persists the version under
+     * `config.json.moduleMeta[id].schemaVersion` (separate from the data
+     * blob) so plugins never see this sentinel in their settings object.
+     */
+    settingsVersion?: number;
+    /**
+     * Optional migration hook run before `settingsSchema` parses persisted
+     * data. Called when the stored `schemaVersion` is less than the
+     * module's `settingsVersion`. Receives the stored version + raw data
+     * blob; returns the migrated blob, which is then validated by
+     * `settingsSchema` and persisted at the new version.
+     *
+     * Use this for renames, removals, or restructuring. For pure additive
+     * changes (new keys), Zod's `.default()` covers it — no migrate hook
+     * needed.
+     *
+     * @example
+     * migrate(stored, data) {
+     *   if (stored < 2 && 'oldName' in data) {
+     *     data.newName = data.oldName
+     *     delete data.oldName
+     *   }
+     *   return data
+     * }
+     */
+    migrate?: (storedVersion: number, data: Record<string, unknown>) => Record<string, unknown>;
+}
+/**
+ * Runtime context handed to `setup()`. Intentionally narrow — modules
+ * that need more capabilities should declare them via contribution
+ * slots so the dependency is visible at validation time.
+ */
+export interface ModuleSetupContext {
+    /** This module's id, for logging / error messages. */
+    moduleId: string;
+    /** Currently active locale, e.g. 'zh-TW'. Read-only. */
+    locale: string;
+    /**
+     * Returns this module's current settings — a live in-memory snapshot
+     * already validated by `settingsSchema`. Synchronous and zero-I/O:
+     * the host hydrates the cache before `setup()` is called and updates
+     * it in-place after every successful `updateSettings()`.
+     *
+     * Generic `T` should match the inferred type of your `settingsSchema`
+     * (use `z.infer<typeof MySchema>` at the call site).
+     *
+     * @example
+     * const settings = ctx.getSettings<z.infer<typeof MySchema>>()
+     */
+    getSettings: <T = unknown>() => T;
+    /**
+     * Shallow-merges `patch` into this module's settings, validates the
+     * result against `settingsSchema` (Zod), and persists to `config.json`.
+     * Resolves once the write is durable; rejects with the underlying
+     * `ZodError` if the merged object fails validation (no I/O happens
+     * on validation failure).
+     *
+     * The in-memory snapshot returned by `getSettings()` is updated
+     * before the Promise resolves; subscribers registered via
+     * `onSettingsChange()` then fire with the new snapshot.
+     *
+     * Note on nested objects: the merge is shallow. Updating a nested
+     * object replaces it entirely — spread the existing nested value
+     * yourself if you only want to change one inner field:
+     *
+     * ```ts
+     * const cur = ctx.getSettings<MySettings>()
+     * await ctx.updateSettings({ colors: { ...cur.colors, primary: '#0f0' } })
+     * ```
+     *
+     * Throws synchronously if the module did not declare `settingsSchema`.
+     */
+    updateSettings: <T = unknown>(patch: Partial<T>) => Promise<void>;
+    /**
+     * Subscribe to settings changes for this module. The callback fires
+     * after every successful `updateSettings()` — including writes that
+     * originated from the host's settings panel — with the fresh,
+     * already-validated snapshot.
+     *
+     * Returns an unsubscribe function. The host also calls it
+     * automatically when the module is rolled back, so manual cleanup
+     * is only needed if you want to stop listening sooner than
+     * module dispose.
+     *
+     * @example
+     * const stop = ctx.onSettingsChange<MySettings>((s) => {
+     *   redrawWithColor(s.primary)
+     * })
+     */
+    onSettingsChange: <T = unknown>(cb: (settings: T) => void) => () => void;
+    /**
+     * Invoke one of THIS module's main-side handlers (declared via
+     * `contributes.mainHandlers`). The moduleId is captured by the host
+     * so plugins cannot reach into other modules' handlers — use this
+     * helper rather than the lower-level `openPenApi.moduleCall`.
+     *
+     * Returns whatever the handler returns (typed by the caller).
+     */
+    callMain: <T = unknown>(action: string, payload?: unknown) => Promise<T>;
+    /**
+     * Register a cleanup callback. Called in reverse registration order
+     * when the module is unloaded (hot-reload, user-disable, or app quit).
+     * Use this to cancel timers, remove listeners, or release resources
+     * that `setup()` acquired.
+     */
+    onDispose: (fn: () => void | Promise<void>) => void;
+    /**
+     * Shows a short-lived toast notification in the overlay window.
+     * Visibility and position are controlled by the user's settings.
+     * Returns a NotifyHandle for early dismissal.
+     */
+    notify: (payload: NotifyPayload) => NotifyHandle;
+    /**
+     * Resolves an i18n key for this module to the current-locale string.
+     *
+     * The key is automatically namespaced as `${moduleId}.${key}`, matching
+     * the dictionary structure registered via `contributes.locales` (the host
+     * merges each locale dict into the global vue-i18n instance under the
+     * module's id namespace).
+     *
+     * Aligned with VS Code's `vscode.l10n.t()` convention:
+     * ```typescript
+     * ctx.t('notif.start')
+     * ctx.t('notif.greeting', { name: 'Alice' })  // dict entry: 'Hello {name}'
+     * ```
+     *
+     * When a key has no matching translation the namespaced key string is
+     * returned (vue-i18n's default missing-key behaviour).
+     */
+    t: (key: string, params?: Record<string, unknown>) => string;
+}

package/{src/types/notification.ts → dist/types/notification.d.ts}

@@ -9,7 +9,6 @@
  * for module manifest metadata (name, description, contribution label),
  * following the VS Code package.nls.json / JetBrains plugin.xml convention.
  */
-
 /**
  * Input payload for ctx.notify().
  *
@@ -21,20 +20,19 @@
  * for guidance on choosing notify() versus your own UI surface.
  */
 export interface NotifyPayload {
-  /** Required. Already-resolved plain string; use ctx.t(key) for i18n. */
-  message: string
-  /** Subtitle text. Already-resolved plain string, e.g. "Press again to exit". */
-  description?: string
-  /** Inline SVG string, same convention as ToolContribution.icon. */
-  icon?: string
-  /** Semantic colour variant. Defaults to 'default'. */
-  variant?: 'default' | 'success' | 'warning' | 'danger'
-  /** Auto-dismiss delay in milliseconds. Defaults to 1800. */
-  duration?: number
+    /** Required. Already-resolved plain string; use ctx.t(key) for i18n. */
+    message: string;
+    /** Subtitle text. Already-resolved plain string, e.g. "Press again to exit". */
+    description?: string;
+    /** Inline SVG string, same convention as ToolContribution.icon. */
+    icon?: string;
+    /** Semantic colour variant. Defaults to 'default'. */
+    variant?: 'default' | 'success' | 'warning' | 'danger';
+    /** Auto-dismiss delay in milliseconds. Defaults to 1800. */
+    duration?: number;
 }
-
 /** Return value of ctx.notify(), allowing early dismissal. */
 export interface NotifyHandle {
-  /** Immediately closes this notification. */
-  dismiss(): void
+    /** Immediately closes this notification. */
+    dismiss(): void;
 }

package/dist/types/tool.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Public Tool / Stroke / Point primitives shared by host code and
+ * every module / plugin. Declared inside @openpen/module-api so
+ * third parties don't need to import host internals to type their
+ * `canvas.tools` contributions.
+ */
+export interface Point {
+    x: number;
+    y: number;
+}
+/** Solid color or linear gradient between two stops. */
+export type StrokeColor = string | {
+    type: 'linear';
+    from: string;
+    to: string;
+};
+/**
+ * Reduce a `StrokeColor` to a single CSS colour string.
+ *
+ * `CanvasRenderingContext2D.strokeStyle` accepts a single colour string but
+ * not a structured gradient descriptor; custom `renderStroke` implementations
+ * that don't draw the gradient natively need a representative fallback.
+ * Returns the string as-is for solid colours, and the `from` stop for linear
+ * gradients. Future gradient kinds can pick their own representative without
+ * touching callers.
+ */
+export declare function resolveStrokeColor(color: StrokeColor): string;
+export interface StrokeStyle {
+    color: StrokeColor;
+    lineWidth: number;
+    lineCap: CanvasLineCap;
+    lineJoin: CanvasLineJoin;
+}
+export interface Stroke {
+    id: string;
+    /** Id of the tool that produced this stroke (matches a ToolContribution.id). */
+    tool: string;
+    points: Point[];
+    style: StrokeStyle;
+    /**
+     * Tool-specific extra state. Tools MAY store arbitrary keys here during
+     * `onPointerDown` / `onPointerMove` / `onPointerUp`; those keys survive
+     * into `renderStroke(stroke, canvasCtx)` calls so the renderer can read
+     * them back.
+     *
+     * The host treats extra keys as `unknown` — type-cast at the read site is
+     * the plugin author's responsibility (TypeScript cannot infer the shape).
+     *
+     * @example
+     * // Store during onPointerUp:
+     * const stroke: Stroke = { id, tool: 'my-tool', points, style, opacity: 0.5 }
+     *
+     * // Read back in renderStroke:
+     * const opacity = (stroke.opacity as number) ?? 1
+     * canvasCtx.globalAlpha = opacity
+     */
+    [key: string]: unknown;
+}
+export interface PointerModifiers {
+    shiftKey?: boolean;
+}
+export interface Tool {
+    onPointerDown(canvasCtx: CanvasRenderingContext2D, point: Point, style: StrokeStyle): void;
+    /**
+     * Returns `true` when the engine should perform a full redraw
+     * (e.g. stroke-eraser removed an existing stroke). Otherwise `void`.
+     */
+    onPointerMove(canvasCtx: CanvasRenderingContext2D, point: Point, modifiers?: PointerModifiers): void | boolean;
+    /**
+     * Returns the finished `Stroke` to push into the store, or `null`
+     * to discard (e.g. an eraser that doesn't accumulate state).
+     */
+    onPointerUp(canvasCtx: CanvasRenderingContext2D, point: Point, modifiers?: PointerModifiers): Stroke | null;
+    /** When true, canvas-engine clears + redraws all strokes before each move. */
+    needsPreviewRedraw?: boolean;
+    renderPreview?(canvasCtx: CanvasRenderingContext2D): void;
+}

package/dist/uikit/components/AppBanner.vue.d.ts

@@ -0,0 +1,34 @@
+/**
+ * AppBanner — High-level wrapper (Layer 1).
+ *
+ * Presents info / warning / success / error status messages using the
+ * --openpen-color-state-* design tokens. The icon is auto-rendered based on
+ * the variant; message content goes in the default slot; optional inline action
+ * buttons (e.g. restart / dismiss) go in the `#actions` slot.
+ *
+ * Inline mode (compact single-line) is enabled via the `inline` prop and is
+ * suited for form validation feedback and status lines inside dialogs.
+ */
+export type BannerVariant = 'info' | 'warning' | 'success' | 'error';
+type __VLS_Props = {
+    variant: BannerVariant;
+    /** Compact single-line layout: smaller padding, vertically centered. */
+    inline?: boolean;
+};
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    actions?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    inline: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/uikit/components/AppButton.vue.d.ts

@@ -0,0 +1,30 @@
+type __VLS_Props = {
+    variant?: 'default' | 'danger';
+    active?: boolean;
+    disabled?: boolean;
+    tooltip?: string;
+    ariaLabel?: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    ariaLabel: string;
+    active: boolean;
+    variant: "default" | "danger";
+    tooltip: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/uikit/components/AppButtonDropdown.vue.d.ts

@@ -0,0 +1,52 @@
+type __VLS_Props = {
+    /** Globally unique popover id (passed through to the inner AppPopover). */
+    popoverId: string;
+    /** Preferred popover placement; defaults to 'auto'. */
+    popoverPlacement?: 'auto' | 'top' | 'bottom' | 'left' | 'right';
+    /** Main button active state (drives accent highlight). */
+    active?: boolean;
+    /** Disables both main and caret buttons; tooltip remains active. */
+    disabled?: boolean;
+    /** Main button variant (passed through to AppButton). */
+    variant?: 'default' | 'danger';
+    /** Tooltip shown above the main button. */
+    mainTooltip?: string;
+    /** Main button aria-label. */
+    mainAriaLabel?: string;
+    /** Caret button aria-label. Required for screen-reader users. */
+    caretAriaLabel?: string;
+    /** Optional test ids forwarded to the rendered buttons. */
+    mainTestid?: string;
+    caretTestid?: string;
+};
+declare var __VLS_9: {}, __VLS_19: {};
+type __VLS_Slots = {} & {
+    'main-content'?: (props: typeof __VLS_9) => any;
+} & {
+    'popover-content'?: (props: typeof __VLS_19) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    mainClick: () => any;
+    caretClick: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onMainClick?: (() => any) | undefined;
+    onCaretClick?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    active: boolean;
+    variant: "default" | "danger";
+    popoverPlacement: "auto" | "top" | "bottom" | "left" | "right";
+    mainTooltip: string;
+    mainAriaLabel: string;
+    caretAriaLabel: string;
+    mainTestid: string;
+    caretTestid: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/uikit/components/AppDialog.vue.d.ts

@@ -0,0 +1,53 @@
+export interface AppDialogProps {
+    /** Globally unique modal id; used for modal-stack mutual exclusion. */
+    modalId: string;
+    /** Dialog title displayed in the dialog header. */
+    title: string;
+    /** Controlled open state. The parent must handle update:open to toggle. */
+    open: boolean;
+    /**
+     * When true, ESC key and backdrop clicks do not close the dialog.
+     * Use for confirmations that require an explicit button press.
+     */
+    persistent?: boolean;
+    /**
+     * When true, adds the `openpen-modal-danger` CSS class on the content
+     * element — a hook for styling destructive-action dialogs.
+     */
+    danger?: boolean;
+}
+export interface AppDialogSlots {
+    /**
+     * Trigger slot; scope exposes active state + toggle / open / close actions.
+     * MUST NOT write @click="toggle" on the trigger — DialogTrigger's as-child
+     * handles activation automatically; toggle/open/close are escape hatches for
+     * programmatic control only.
+     */
+    trigger: (scope: {
+        active: boolean;
+        toggle: () => void;
+        open: () => void;
+        close: () => void;
+    }) => unknown;
+    /** Dialog body content slot. */
+    default: () => unknown;
+    /** Optional footer slot (action buttons etc.). */
+    footer?: () => unknown;
+}
+type __VLS_Slots = AppDialogSlots;
+declare const __VLS_base: import("vue").DefineComponent<AppDialogProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<AppDialogProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    danger: boolean;
+    persistent: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/uikit/components/AppPopover.vue.d.ts

@@ -0,0 +1,43 @@
+/** Preferred placement for the popover content relative to the trigger. */
+export type Placement = 'auto' | 'top' | 'bottom' | 'left' | 'right';
+export interface AppPopoverProps {
+    /** Globally unique popover id; used for modal-stack mutual exclusion. */
+    popoverId: string;
+    /**
+     * Popover placement direction.
+     * - 'auto' (default, recommended): the host's snap-edge hint picks the side that
+     *   keeps the popover on-screen across all control-bar modes.
+     * - explicit values ('top' | 'bottom' | 'left' | 'right'): bypass the auto hint.
+     *   In dev mode a console warning is emitted because explicit values can position
+     *   popovers off-screen or away from the trigger button when the control bar is
+     *   in a vertical mode. Only use when you have verified the placement stays
+     *   on-screen across all snap layouts.
+     */
+    placement?: Placement;
+    /** Gap between trigger and content in px. Default 8. */
+    gap?: number;
+}
+export interface AppPopoverSlots {
+    /** Trigger slot; scope exposes active state + toggle / open / close actions. */
+    trigger: (scope: {
+        active: boolean;
+        toggle: () => void;
+        open: () => void;
+        close: () => void;
+    }) => unknown;
+    /** Popover content slot. */
+    content: () => unknown;
+}
+type __VLS_Slots = AppPopoverSlots;
+declare const __VLS_base: import("vue").DefineComponent<AppPopoverProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AppPopoverProps> & Readonly<{}>, {
+    placement: Placement;
+    gap: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/uikit/components/AppSegmented.vue.d.ts

@@ -0,0 +1,19 @@
+interface Option {
+    value: string;
+    label: string;
+    icon?: string;
+    testid?: string;
+}
+type __VLS_Props = {
+    modelValue: string;
+    options: Option[];
+    /** When true, all options are non-interactive and visually dimmed. */
+    disabled?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/uikit/components/AppSelect.vue.d.ts

@@ -0,0 +1,26 @@
+/** A single option in the dropdown list. */
+export interface SelectOption {
+    /** The value emitted on selection. */
+    value: string;
+    /** The label shown to the user. */
+    label: string;
+}
+export interface AppSelectProps {
+    /** Currently selected value (bind with v-model). */
+    modelValue: string;
+    /** List of selectable options. */
+    options: SelectOption[];
+    /** Placeholder shown when no option is selected. */
+    placeholder: string;
+    /** Whether the select is disabled. */
+    disabled?: boolean;
+}
+declare const __VLS_export: import("vue").DefineComponent<AppSelectProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<AppSelectProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/uikit/components/AppSlider.vue.d.ts

@@ -0,0 +1,43 @@
+type __VLS_Props = {
+    modelValue: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Container width (e.g. '100%', '72px'). In vertical mode this sets the height. */
+    width?: string;
+    orientation?: 'horizontal' | 'vertical';
+    trackHeight?: string;
+    trackRadius?: string;
+    thumbWidth?: string;
+    thumbHeight?: string;
+    thumbRadius?: string;
+    /**
+     * Reverse the value-to-position mapping. With orientation='vertical', sets
+     * top=min and bottom=max (drag down to increase). With orientation='horizontal',
+     * sets right=min and left=max (drag left to increase). Useful when an icon
+     * legend implies the opposite direction of the underlying control.
+     *
+     * Delegates to reka-ui SliderRoot's native `inverted` prop, which swaps
+     * startEdge/endEdge on SliderRange — no manual value transformation needed.
+     */
+    inverted?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: number) => any) | undefined;
+}>, {
+    width: string;
+    min: number;
+    max: number;
+    step: number;
+    orientation: "horizontal" | "vertical";
+    trackHeight: string;
+    trackRadius: string;
+    thumbWidth: string;
+    thumbHeight: string;
+    thumbRadius: string;
+    inverted: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/uikit/components/AppTabs.vue.d.ts

@@ -0,0 +1,35 @@
+export interface AppTabItem {
+    /** Unique identifier for this tab. Used as the v-model value. */
+    id: string;
+    /** Human-readable label rendered in the tab trigger button. */
+    label: string;
+}
+export interface AppTabsProps {
+    /** Currently active tab id (controlled mode). */
+    modelValue: string;
+    /** Ordered list of tab descriptors. */
+    tabs: AppTabItem[];
+}
+export interface AppTabsSlots {
+    /**
+     * Default slot for tab content area.
+     * Receives the currently active tab id via scoped slot.
+     */
+    default: (scope: {
+        activeTabId: string;
+    }) => unknown;
+}
+type __VLS_Slots = AppTabsSlots;
+declare const __VLS_base: import("vue").DefineComponent<AppTabsProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<AppTabsProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};