@stephen-netu/design-system 0.1.0 → 0.2.0

package/dist/u0-primitives/command-palette/commandStore.svelte.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Command Store — Svelte 5 runes store for command registry and execution
+ *
+ * HDA: Surface layer (s0-state equivalent)
+ * Sovereignty:
+ *   - S-01: All executions route through kernel.request_capability()
+ *   - S-02: BTreeMap equivalent (sorted Map) for deterministic ordering
+ *   - S-04: All invocations logged with correlation IDs
+ *   - S-05: AbortController for killable operations
+ */
+import type { CommandSchema, CommandResult, CommandContext, CommandPath } from './command-types';
+/** Command with UI state (selection, etc.) */
+export interface CommandUIState {
+    schema: CommandSchema;
+    isSelected: boolean;
+    isExecutable: boolean;
+}
+/** Active command session (filling parameters) */
+export interface ActiveCommandSession {
+    command: CommandSchema;
+    filled: Map<string, string>;
+    currentParam: number;
+    correlationId: string;
+}
+declare class CommandStore {
+    commands: Map<string, CommandSchema>;
+    activeSession: ActiveCommandSession | null;
+    capabilities: Set<string>;
+    isExecuting: boolean;
+    lastResult: CommandResult | null;
+    sortedCommands: CommandSchema[];
+    currentContext: CommandContext;
+    availableCommands: CommandSchema[];
+    private abortController;
+    /**
+     * Initialize store with commands from substrate
+     * Called on app mount / realm connection
+     */
+    init(realmId: string): Promise<void>;
+    /**
+     * Register a command (for dynamic command registration)
+     * HDA: Delegates to i1-mediation CommandRegistry
+     */
+    register(schema: CommandSchema): void;
+    /**
+     * Start a command session
+     * Returns true if command found and session started
+     */
+    startCommand(path: CommandPath): boolean;
+    /**
+     * Fill current parameter and advance
+     */
+    fillParameter(value: string): boolean;
+    /**
+     * Skip optional parameter
+     */
+    skipOptional(): boolean;
+    /**
+     * Cancel active session
+     */
+    cancel(): void;
+    /**
+     * Execute the active command
+     * S-01: Routes through kernel.request_capability()
+     * S-04: Creates sigchain entry
+     * S-05: Abortable via kill signal
+     */
+    execute(): Promise<CommandResult>;
+    /**
+     * Quick execute — bypass parameter UI for programmatic use
+     */
+    quickExecute(path: CommandPath, parameters: Record<string, string>): Promise<CommandResult>;
+    /**
+     * Parse command string (for chat input parsing)
+     * Returns command info without starting session
+     */
+    parse(input: string): {
+        command?: CommandSchema;
+        args: string[];
+    };
+    /**
+     * Filter commands by search query
+     */
+    search(query: string): CommandSchema[];
+    /**
+     * Update context (called when switching realms/groves)
+     */
+    setContext(context: CommandContext): void;
+    /**
+     * Update capabilities (called after capability grants/revocations)
+     */
+    setCapabilities(caps: string[]): void;
+    /**
+     * Cleanup (S-05 killability)
+     */
+    destroy(): void;
+}
+export declare const commandStore: CommandStore;
+export {};
+//# sourceMappingURL=commandStore.svelte.d.ts.map

package/dist/u0-primitives/command-palette/commandStore.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandStore.svelte.d.ts","sourceRoot":"","sources":["../../../src/u0-primitives/command-palette/commandStore.svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACb,cAAc,EAGd,WAAW,EACZ,MAAM,iBAAiB,CAAC;AAOzB,8CAA8C;AAC9C,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,aAAa,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,kDAAkD;AAClD,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACvB;AAgBD,cAAM,YAAY;IAEhB,QAAQ,6BAAoD;IAC5D,aAAa,8BAA6C;IAC1D,YAAY,cAAkC;IAC9C,WAAW,UAAiB;IAC5B,UAAU,uBAAsC;IAGhD,cAAc,kBAGZ;IAGF,cAAc,iBAAoC;IAGlD,iBAAiB,kBAKf;IAGF,OAAO,CAAC,eAAe,CAAgC;IAEvD;;;OAGG;IACG,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB1C;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI;IAMrC;;;OAGG;IACH,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO;IAyBxC;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAgCrC;;OAEG;IACH,YAAY,IAAI,OAAO;IAcvB;;OAEG;IACH,MAAM,IAAI,IAAI;IASd;;;;;OAKG;IACG,OAAO,IAAI,OAAO,CAAC,aAAa,CAAC;IA+DvC;;OAEG;IACG,YAAY,CAChB,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,OAAO,CAAC,aAAa,CAAC;IAczB;;;OAGG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG;QAAE,OAAO,CAAC,EAAE,aAAa,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE;IA4BjE;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,EAAE;IAQtC;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAMzC;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI;IAYrC;;OAEG;IACH,OAAO,IAAI,IAAI;CAKhB;AAGD,eAAO,MAAM,YAAY,cAAqB,CAAC"}

package/dist/u0-primitives/command-palette/commandStore.svelte.js

@@ -0,0 +1,278 @@
+/**
+ * Command Store — Svelte 5 runes store for command registry and execution
+ *
+ * HDA: Surface layer (s0-state equivalent)
+ * Sovereignty:
+ *   - S-01: All executions route through kernel.request_capability()
+ *   - S-02: BTreeMap equivalent (sorted Map) for deterministic ordering
+ *   - S-04: All invocations logged with correlation IDs
+ *   - S-05: AbortController for killable operations
+ */
+async function tauriInvoke(command, payload) {
+    const mod = await import('@tauri-apps/api/core');
+    return mod.invoke(command, payload);
+}
+class CommandStore {
+    // Svelte 5 runes state
+    commands = $state(new Map());
+    activeSession = $state(null);
+    capabilities = $state(new Set());
+    isExecuting = $state(false);
+    lastResult = $state(null);
+    // Derived: commands sorted by path for deterministic display (S-02)
+    sortedCommands = $derived(Array.from(this.commands.values())
+        .sort((a, b) => a.path.join('.').localeCompare(b.path.join('.'))));
+    // Derived: current context (from leapStore or context provider)
+    currentContext = $state('global');
+    // Derived: available commands for current context + capabilities
+    availableCommands = $derived(this.sortedCommands.filter(cmd => cmd.contexts.includes(this.currentContext) &&
+        cmd.requiredCapabilities.every(cap => this.capabilities.has(cap))));
+    // AbortController for killable operations (S-05)
+    abortController = null;
+    /**
+     * Initialize store with commands from substrate
+     * Called on app mount / realm connection
+     */
+    async init(realmId) {
+        try {
+            // Fetch commands and capabilities from substrate
+            const [commands, caps] = await Promise.all([
+                tauriInvoke('plugin:substrate|get_commands', { realmId }),
+                tauriInvoke('plugin:substrate|get_capabilities', { realmId })
+            ]);
+            // S-02: Preserve deterministic order
+            this.commands = new Map(commands.map(c => [c.id, c]));
+            this.capabilities = new Set(caps);
+        }
+        catch (err) {
+            console.error('[CommandStore] Init failed:', err);
+            // Graceful degradation — commands won't show but app continues
+        }
+    }
+    /**
+     * Register a command (for dynamic command registration)
+     * HDA: Delegates to i1-mediation CommandRegistry
+     */
+    register(schema) {
+        this.commands.set(schema.id, schema);
+        // Trigger reactivity by reassigning
+        this.commands = new Map(this.commands);
+    }
+    /**
+     * Start a command session
+     * Returns true if command found and session started
+     */
+    startCommand(path) {
+        const pathStr = path.join('.');
+        const command = this.sortedCommands.find(c => c.path.join('.') === pathStr);
+        if (!command)
+            return false;
+        // Check capabilities
+        if (!command.requiredCapabilities.every(cap => this.capabilities.has(cap))) {
+            console.warn(`[CommandStore] Missing capabilities for /${pathStr}`);
+            return false;
+        }
+        // Generate correlation ID for audit trail (S-04)
+        const correlationId = `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+        this.activeSession = {
+            command,
+            filled: new Map(),
+            currentParam: 0,
+            correlationId
+        };
+        return true;
+    }
+    /**
+     * Fill current parameter and advance
+     */
+    fillParameter(value) {
+        if (!this.activeSession)
+            return false;
+        const { command, filled, currentParam } = this.activeSession;
+        const param = command.parameters[currentParam];
+        if (!param) {
+            // No more params — execute
+            this.execute();
+            return true;
+        }
+        // Store value
+        filled.set(param.name, value);
+        // Advance to next parameter
+        const nextIndex = currentParam + 1;
+        if (nextIndex >= command.parameters.length) {
+            // All params filled — execute
+            this.execute();
+            return true;
+        }
+        // Continue to next param
+        this.activeSession = {
+            ...this.activeSession,
+            currentParam: nextIndex
+        };
+        return false; // Not done yet
+    }
+    /**
+     * Skip optional parameter
+     */
+    skipOptional() {
+        if (!this.activeSession)
+            return false;
+        const { command, currentParam } = this.activeSession;
+        const param = command.parameters[currentParam];
+        if (param?.required) {
+            console.warn(`[CommandStore] Cannot skip required parameter: ${param.name}`);
+            return false;
+        }
+        return this.fillParameter(''); // Empty string for optional
+    }
+    /**
+     * Cancel active session
+     */
+    cancel() {
+        if (this.abortController) {
+            this.abortController.abort();
+            this.abortController = null;
+        }
+        this.activeSession = null;
+        this.isExecuting = false;
+    }
+    /**
+     * Execute the active command
+     * S-01: Routes through kernel.request_capability()
+     * S-04: Creates sigchain entry
+     * S-05: Abortable via kill signal
+     */
+    async execute() {
+        if (!this.activeSession || this.isExecuting) {
+            return { success: false, message: 'No active command or already executing' };
+        }
+        const { command, filled, correlationId } = this.activeSession;
+        // Validate all required params present
+        for (const param of command.parameters) {
+            if (param.required && !filled.has(param.name)) {
+                return {
+                    success: false,
+                    message: `Missing required parameter: ${param.name}`
+                };
+            }
+        }
+        // S-05: Create abort controller for killability
+        this.abortController = new AbortController();
+        this.isExecuting = true;
+        try {
+            // Convert Map to plain object for IPC
+            const parameters = Object.fromEntries(filled);
+            // Build invocation context
+            const context = {
+                realmId: 'current', // Resolved by substrate
+                userId: 'current', // Resolved by substrate
+            };
+            // Invoke through substrate (S-01 authority check happens in kernel)
+            const result = await tauriInvoke('plugin:substrate|invoke_command', {
+                commandId: command.id,
+                parameters,
+                context,
+                correlationId
+            });
+            this.lastResult = result;
+            if (result.success) {
+                // Clear session on success
+                this.activeSession = null;
+            }
+            return result;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const result = {
+                success: false,
+                message,
+                // Note: sigchain entry created even for failures (S-04)
+            };
+            this.lastResult = result;
+            return result;
+        }
+        finally {
+            this.isExecuting = false;
+            this.abortController = null;
+        }
+    }
+    /**
+     * Quick execute — bypass parameter UI for programmatic use
+     */
+    async quickExecute(path, parameters) {
+        const started = this.startCommand(path);
+        if (!started) {
+            return { success: false, message: `Unknown command: /${path.join(' ')}` };
+        }
+        // Fill all provided parameters
+        for (const [name, value] of Object.entries(parameters)) {
+            this.activeSession.filled.set(name, value);
+        }
+        return this.execute();
+    }
+    /**
+     * Parse command string (for chat input parsing)
+     * Returns command info without starting session
+     */
+    parse(input) {
+        if (!input.startsWith('/')) {
+            return { args: [] };
+        }
+        const parts = input.slice(1).split(/\s+/);
+        const path = [];
+        let cmd;
+        // Try to match longest path first
+        for (let i = 0; i < parts.length; i++) {
+            path.push(parts[i]);
+            const found = this.sortedCommands.find(c => c.path.length === path.length &&
+                c.path.every((p, idx) => p === path[idx]));
+            if (found) {
+                cmd = found;
+            }
+        }
+        // Remaining parts are arguments
+        const matchedPathLength = cmd?.path.length ?? 0;
+        const args = parts.slice(matchedPathLength);
+        return { command: cmd, args };
+    }
+    /**
+     * Filter commands by search query
+     */
+    search(query) {
+        const lower = query.toLowerCase();
+        return this.availableCommands.filter(cmd => cmd.path.join(' ').toLowerCase().includes(lower) ||
+            cmd.description.toLowerCase().includes(lower));
+    }
+    /**
+     * Update context (called when switching realms/groves)
+     */
+    setContext(context) {
+        this.currentContext = context;
+        // Cancel any active session — context changed
+        this.cancel();
+    }
+    /**
+     * Update capabilities (called after capability grants/revocations)
+     */
+    setCapabilities(caps) {
+        this.capabilities = new Set(caps);
+        // Check if active session still valid
+        if (this.activeSession) {
+            const canExecute = this.activeSession.command.requiredCapabilities
+                .every(cap => this.capabilities.has(cap));
+            if (!canExecute) {
+                this.cancel();
+            }
+        }
+    }
+    /**
+     * Cleanup (S-05 killability)
+     */
+    destroy() {
+        this.cancel();
+        this.commands.clear();
+        this.capabilities.clear();
+    }
+}
+// Export singleton
+export const commandStore = new CommandStore();

package/dist/u0-primitives/command-palette/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Command Palette — Slash command interface for LEAP
+ *
+ * Exports:
+ * - CommandPalette.svelte — Main UI component
+ * - command-types.ts — TypeScript type definitions (mirror of i0-primitives)
+ * - commandStore.svelte.ts — Svelte 5 runes store for registry + execution
+ *
+ * HDA: u0-primitives (atom component)
+ * Domain: Interfaces (I)
+ * Layer: 0-1 (pure types → mediation)
+ */
+export { default as CommandPalette } from './CommandPalette.svelte';
+export { commandStore } from './commandStore.svelte';
+export type { CommandId, CommandPath, CommandContext, ParameterType, AutocompleteSource, CommandParameter, CommandSchema, InvocationContext, CommandResult, ValidationError, ParseResult, ICommandRegistry, CommandUIState, ActiveCommandSession, } from './command-types';
+//# sourceMappingURL=index.d.ts.map

package/dist/u0-primitives/command-palette/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/u0-primitives/command-palette/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,YAAY,EACV,SAAS,EACT,WAAW,EACX,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,oBAAoB,GACrB,MAAM,iBAAiB,CAAC"}

package/dist/u0-primitives/command-palette/index.js

@@ -0,0 +1,14 @@
+/**
+ * Command Palette — Slash command interface for LEAP
+ *
+ * Exports:
+ * - CommandPalette.svelte — Main UI component
+ * - command-types.ts — TypeScript type definitions (mirror of i0-primitives)
+ * - commandStore.svelte.ts — Svelte 5 runes store for registry + execution
+ *
+ * HDA: u0-primitives (atom component)
+ * Domain: Interfaces (I)
+ * Layer: 0-1 (pure types → mediation)
+ */
+export { default as CommandPalette } from './CommandPalette.svelte';
+export { commandStore } from './commandStore.svelte';

package/{src → dist}/u0-primitives/dropdown/Dropdown.svelte

@@ -10,7 +10,7 @@
     danger?: boolean;
   }
 
-  interface Props {
+  export interface Props {
     items: DropdownItem[];
     trigger: Snippet;
     align?: 'left' | 'right' | 'center';
@@ -159,10 +159,13 @@
       style="width: {width};"
       role="menu"
       tabindex="-1"
+      aria-orientation="vertical"
+      aria-activedescendant={focusedIndex >= 0 ? `dropdown-item-${items[focusedIndex]?.id}` : undefined}
       onkeydown={handleKeydown}
     >
       {#each items as item, i (item.id)}
         <button
+          id={`dropdown-item-${item.id}`}
           class="ds-dropdown-item"
           class:is-danger={item.danger}
           role="menuitem"
@@ -205,7 +208,7 @@
     background: var(--color-bg-panel-elevated);
     border: 1px solid var(--border-default);
     border-radius: var(--radius-md);
-    box-shadow: var(--shadow-lg), 0 0 0 1px rgba(0,0,0,0.5);
+     box-shadow: var(--shadow-lg), 0 0 0 1px rgba(0,0,0,0.3);
     padding: var(--space-1);
     z-index: 1000;
     animation: ds-scale-in var(--transition-fast) transform-origin;
@@ -239,7 +242,7 @@
   }
 
   .ds-dropdown-item:focus-visible {
-    background: rgba(184, 115, 51, 0.15); /* Suble brass focus */
+    background: var(--color-accent-muted); /* Suble brass focus */
   }
 
   .ds-dropdown-item:disabled {
@@ -254,7 +257,7 @@
 
   .ds-dropdown-item.is-danger:hover,
   .ds-dropdown-item.is-danger:focus {
-    background: rgba(166, 94, 94, 0.1);
+     background: color-mix(in srgb, var(--color-error) 12%, transparent);
   }
 
   .ds-dropdown-icon {

package/dist/u0-primitives/dropdown/Dropdown.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { Snippet } from 'svelte';
+export interface DropdownItem {
+    id: string;
+    label: string;
+    icon?: Snippet;
+    shortcut?: string;
+    disabled?: boolean;
+    danger?: boolean;
+}
+export interface Props {
+    items: DropdownItem[];
+    trigger: Snippet;
+    align?: 'left' | 'right' | 'center';
+    width?: string;
+    class?: string;
+    onselect?: (item: DropdownItem) => void;
+}
+declare const Dropdown: import("svelte").Component<Props, {}, "">;
+type Dropdown = ReturnType<typeof Dropdown>;
+export default Dropdown;
+//# sourceMappingURL=Dropdown.svelte.d.ts.map

package/dist/u0-primitives/dropdown/Dropdown.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dropdown.svelte.d.ts","sourceRoot":"","sources":["../../../src/u0-primitives/dropdown/Dropdown.svelte.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAGpC,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;CACzC;AA2JH,QAAA,MAAM,QAAQ,2CAAwC,CAAC;AACvD,KAAK,QAAQ,GAAG,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC;AAC5C,eAAe,QAAQ,CAAC"}

package/dist/u0-primitives/dropdown/Dropdown.test.js

@@ -0,0 +1,108 @@
+import { afterEach, describe, it, expect, vi } from 'vitest';
+import { cleanup, render, fireEvent } from '@testing-library/svelte';
+import Dropdown from './Dropdown.svelte';
+const sampleItems = [
+    { id: 'a', label: 'Alpha' },
+    { id: 'b', label: 'Beta' },
+    { id: 'c', label: 'Gamma' },
+];
+function renderDropdown(props = {}) {
+    return render(Dropdown, {
+        items: sampleItems,
+        trigger: () => '<button>Open</button>',
+        ...props,
+    });
+}
+describe('Dropdown', () => {
+    afterEach(() => cleanup());
+    it('renders the trigger button element', () => {
+        const { container } = renderDropdown();
+        expect(container.querySelector('[role="button"]')).not.toBeNull();
+    });
+    it('does not render the menu initially', () => {
+        const { container } = renderDropdown();
+        expect(container.querySelector('.ds-dropdown-menu')).toBeNull();
+    });
+    it('opens the menu when trigger is clicked', async () => {
+        const { container } = renderDropdown();
+        const trigger = container.querySelector('[role="button"]');
+        await fireEvent.click(trigger);
+        expect(container.querySelector('.ds-dropdown-menu')).not.toBeNull();
+    });
+    it('renders all items when open', async () => {
+        const { container } = renderDropdown();
+        await fireEvent.click(container.querySelector('[role="button"]'));
+        expect(container.querySelectorAll('[role="menuitem"]').length).toBe(3);
+    });
+    it('calls onselect when an item is clicked', async () => {
+        const handleSelect = vi.fn();
+        const { container } = renderDropdown({ onselect: handleSelect });
+        await fireEvent.click(container.querySelector('[role="button"]'));
+        const items = container.querySelectorAll('[role="menuitem"]');
+        await fireEvent.click(items[1]);
+        expect(handleSelect).toHaveBeenCalledWith({ id: 'b', label: 'Beta' });
+    });
+    it('does not call onselect for disabled items', async () => {
+        const handleSelect = vi.fn();
+        const { container } = renderDropdown({
+            items: [
+                { id: 'a', label: 'Alpha', disabled: true },
+                { id: 'b', label: 'Beta' },
+            ],
+            onselect: handleSelect,
+        });
+        await fireEvent.click(container.querySelector('[role="button"]'));
+        const items = container.querySelectorAll('[role="menuitem"]');
+        await fireEvent.click(items[0]);
+        expect(handleSelect).not.toHaveBeenCalled();
+    });
+    it('closes the menu after selecting an item', async () => {
+        const { container } = renderDropdown();
+        await fireEvent.click(container.querySelector('[role="button"]'));
+        expect(container.querySelector('.ds-dropdown-menu')).not.toBeNull();
+        const items = container.querySelectorAll('[role="menuitem"]');
+        await fireEvent.click(items[2]);
+        expect(container.querySelector('.ds-dropdown-menu')).toBeNull();
+    });
+    it('applies align class', async () => {
+        const { container } = renderDropdown({ align: 'right' });
+        await fireEvent.click(container.querySelector('[role="button"]'));
+        expect(container.querySelector('.ds-dropdown-menu')?.classList.contains('align-right')).toBe(true);
+    });
+    it('sets aria-expanded on trigger', async () => {
+        const { container } = renderDropdown();
+        const trigger = container.querySelector('[role="button"]');
+        expect(trigger.getAttribute('aria-expanded')).toBe('false');
+        await fireEvent.click(trigger);
+        expect(trigger.getAttribute('aria-expanded')).toBe('true');
+    });
+    it('applies aria-disabled to disabled items', async () => {
+        const { container } = renderDropdown({
+            items: [{ id: 'x', label: 'Blocked', disabled: true }],
+        });
+        await fireEvent.click(container.querySelector('[role="button"]'));
+        const item = container.querySelector('[role="menuitem"]');
+        expect(item?.getAttribute('aria-disabled')).toBe('true');
+    });
+    it('renders menu items with correct labels', async () => {
+        const { container } = renderDropdown();
+        await fireEvent.click(container.querySelector('[role="button"]'));
+        expect(container.querySelector('[role="menuitem"]')?.textContent?.trim()).toBe('Alpha');
+    });
+    it('menu has role="menu" when open', async () => {
+        const { container } = renderDropdown();
+        await fireEvent.click(container.querySelector('[role="button"]'));
+        expect(container.querySelector('[role="menu"]')).not.toBeNull();
+    });
+    it('menu has aria-orientation when open', async () => {
+        const { container } = renderDropdown();
+        await fireEvent.click(container.querySelector('[role="button"]'));
+        const menu = container.querySelector('[role="menu"]');
+        expect(menu?.getAttribute('aria-orientation')).not.toBeNull();
+    });
+    it('trigger has aria-haspopup', () => {
+        const { container } = renderDropdown();
+        const trigger = container.querySelector('[role="button"]');
+        expect(trigger?.getAttribute('aria-haspopup')).not.toBeNull();
+    });
+});

package/dist/u0-primitives/dropdown/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Dropdown } from './Dropdown.svelte';
+export type { Props } from './Dropdown.svelte';
+//# sourceMappingURL=index.d.ts.map

package/dist/u0-primitives/dropdown/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/u0-primitives/dropdown/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AACxD,YAAY,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/u0-primitives/dropdown/index.js

@@ -0,0 +1 @@
+export { default as Dropdown } from './Dropdown.svelte';