@undefineds.co/xpod 0.3.57 → 0.3.61

package/node_modules/@undefineds.co/extension-sdk/dist/react/workspace-layout.js

@@ -0,0 +1,132 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore, } from 'react';
+import { cn } from '@undefineds.co/shared-ui';
+import { WorkspaceLayoutContext, } from './layout-context.js';
+const stackMediaQuery = '(max-width: 767px)';
+const twoPaneGridStyle = {
+    gridTemplateColumns: '210px minmax(0, 1fr)',
+};
+const threePaneGridStyle = {
+    gridTemplateColumns: '210px minmax(0, 1fr) minmax(240px, 320px)',
+};
+function mapContextPaneToMain(pane) {
+    return pane === 'context' ? 'main' : pane;
+}
+function subscribeToStackModeChange(onStoreChange) {
+    if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') {
+        return () => undefined;
+    }
+    const media = window.matchMedia(stackMediaQuery);
+    media.addEventListener('change', onStoreChange);
+    return () => media.removeEventListener('change', onStoreChange);
+}
+function getAutoModeSnapshot() {
+    if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') {
+        return 'split';
+    }
+    return window.matchMedia(stackMediaQuery).matches ? 'stack' : 'split';
+}
+function getServerAutoModeSnapshot() {
+    return 'split';
+}
+function useResolvedMode(mode) {
+    const autoMode = useSyncExternalStore(subscribeToStackModeChange, getAutoModeSnapshot, getServerAutoModeSnapshot);
+    return mode === 'auto' ? autoMode : mode;
+}
+function useStackNavigation({ resolvedMode, history, resolvePane, }) {
+    const [activePane, setActivePane] = useState('list');
+    const focusPaneRef = useRef(null);
+    const listRef = useRef(null);
+    const mainRef = useRef(null);
+    const contextRef = useRef(null);
+    const paneRefs = useMemo(() => ({
+        list: listRef,
+        main: mainRef,
+        context: contextRef,
+    }), []);
+    const navigate = useCallback((requestedPane, options = {}) => {
+        const nextPane = resolvePane?.(requestedPane) ?? requestedPane;
+        setActivePane(nextPane);
+        if (resolvedMode !== 'stack') {
+            return;
+        }
+        focusPaneRef.current = nextPane;
+        if (!options.fromHistory) {
+            history?.push(nextPane);
+        }
+    }, [history, resolvePane, resolvedMode]);
+    const openList = useCallback(() => navigate('list'), [navigate]);
+    const openMain = useCallback(() => navigate('main'), [navigate]);
+    const openContext = useCallback(() => navigate('context'), [navigate]);
+    useLayoutEffect(() => {
+        if (resolvedMode !== 'stack') {
+            focusPaneRef.current = null;
+            return;
+        }
+        const pane = focusPaneRef.current;
+        if (!pane) {
+            return;
+        }
+        focusPaneRef.current = null;
+        paneRefs[pane].current?.focus();
+    }, [activePane, paneRefs, resolvedMode]);
+    useLayoutEffect(() => {
+        if (resolvedMode !== 'stack' || !history) {
+            return undefined;
+        }
+        return history.subscribe((pane) => {
+            navigate(pane, { fromHistory: true });
+        });
+    }, [history, navigate, resolvedMode]);
+    return {
+        activePane,
+        paneRefs,
+        openList,
+        openMain,
+        openContext,
+    };
+}
+export function TwoPaneLayout({ listHeader, list, mainHeader, main, mode = 'auto', history, className, }) {
+    const resolvedMode = useResolvedMode(mode);
+    const { activePane, paneRefs, openList, openMain, openContext, } = useStackNavigation({
+        resolvedMode,
+        history,
+        resolvePane: mapContextPaneToMain,
+    });
+    const navigation = useMemo(() => ({
+        mode: resolvedMode,
+        activePane,
+        openList,
+        openMain,
+        openContext,
+    }), [activePane, openContext, openList, openMain, resolvedMode]);
+    const isStack = resolvedMode === 'stack';
+    const listHidden = isStack && activePane !== 'list';
+    const mainHidden = isStack && activePane !== 'main';
+    return (_jsx(WorkspaceLayoutContext.Provider, { value: navigation, children: _jsx("section", { className: cn('flex min-h-0 flex-1 flex-col bg-background', className), "data-workspace-layout": "two-pane", "data-workspace-mode": resolvedMode, children: _jsxs("div", { className: cn('grid min-h-0 flex-1', isStack ? 'grid-cols-1' : null), style: isStack ? undefined : twoPaneGridStyle, "data-workspace-layout-mode": mode, "data-workspace-active-pane": activePane, children: [_jsxs("aside", { ref: paneRefs.list, className: cn('flex min-h-0 flex-col overflow-hidden bg-layout-list-item @container', isStack ? 'border-r-0' : 'border-r border-border'), "data-testid": "workspace-list-pane", "data-workspace-pane": "list", hidden: listHidden, tabIndex: isStack ? -1 : undefined, children: [_jsx("header", { className: "h-12 shrink-0 border-b border-border bg-layout-list-header", "data-workspace-list-header": "true", children: listHeader }), _jsx("div", { className: "min-h-0 flex-1 overflow-y-auto", children: list })] }), _jsxs("main", { ref: paneRefs.main, className: "flex min-h-0 flex-col overflow-hidden bg-layout-content @container", "data-testid": "workspace-main-pane", "data-workspace-pane": "main", hidden: mainHidden, tabIndex: isStack ? -1 : undefined, children: [_jsx("header", { className: "h-12 shrink-0 border-b border-border bg-layout-content", "data-workspace-main-header": "true", children: mainHeader }), _jsxs("div", { className: "min-h-0 flex-1 overflow-y-auto", children: [isStack ? (_jsx("button", { type: "button", className: "inline-flex items-center px-4 py-3 text-sm text-muted-foreground hover:text-foreground", onClick: openList, children: "\u8FD4\u56DE\u5217\u8868" })) : null, main] })] })] }) }) }));
+}
+export function SinglePaneLayout({ header, main, className, }) {
+    return (_jsxs("section", { className: cn('flex min-h-0 flex-1 flex-col bg-background', className), "data-workspace-layout": "single-pane", children: [header ? (_jsx("header", { className: "h-16 shrink-0 border-b border-border bg-layout-content", children: header })) : null, _jsx("main", { className: "min-h-0 flex-1 overflow-y-auto bg-layout-content @container", "data-testid": "workspace-content-pane", "data-workspace-pane": "content", children: main })] }));
+}
+export function ThreePaneLayout({ header, list, main, context, mode = 'auto', history, contextConfig, className, }) {
+    const resolvedMode = useResolvedMode(mode);
+    const [contextCollapsed, setContextCollapsed] = useState(contextConfig?.initiallyCollapsed ?? false);
+    const { activePane, paneRefs, openList, openMain, openContext, } = useStackNavigation({ resolvedMode, history });
+    const toggleContextCollapsed = useCallback(() => {
+        setContextCollapsed((collapsed) => !collapsed);
+    }, []);
+    const navigation = useMemo(() => ({
+        mode: resolvedMode,
+        activePane,
+        openList,
+        openMain,
+        openContext,
+    }), [activePane, openContext, openList, openMain, resolvedMode]);
+    const isStack = resolvedMode === 'stack';
+    const listHidden = isStack && activePane !== 'list';
+    const mainHidden = isStack && activePane !== 'main';
+    const contextHidden = isStack
+        ? activePane !== 'context'
+        : Boolean(contextConfig?.collapsible && contextCollapsed);
+    return (_jsx(WorkspaceLayoutContext.Provider, { value: navigation, children: _jsxs("section", { className: cn('flex min-h-0 flex-1 flex-col bg-background', className), "data-workspace-layout": "three-pane", "data-workspace-mode": resolvedMode, children: [header ? (_jsx("header", { className: "h-16 shrink-0 border-b border-border bg-layout-content", children: header })) : null, contextConfig?.collapsible && !isStack ? (_jsx("div", { className: "shrink-0 border-b border-border bg-layout-content px-3 py-2", children: _jsx("button", { type: "button", "aria-expanded": !contextCollapsed, className: "inline-flex items-center rounded-md px-3 py-1.5 text-sm text-muted-foreground hover:bg-accent hover:text-foreground", onClick: toggleContextCollapsed, children: contextCollapsed ? '展开上下文面板' : '折叠上下文面板' }) })) : null, _jsxs("div", { className: cn('grid min-h-0 flex-1', isStack ? 'grid-cols-1' : null), style: isStack ? undefined : threePaneGridStyle, "data-workspace-layout-mode": mode, "data-workspace-active-pane": activePane, children: [_jsx("aside", { ref: paneRefs.list, className: cn('min-h-0 overflow-y-auto bg-layout-list-item @container', isStack ? 'border-r-0' : 'border-r border-border'), "data-testid": "workspace-list-pane", "data-workspace-pane": "list", hidden: listHidden, tabIndex: isStack ? -1 : undefined, children: list }), _jsxs("main", { ref: paneRefs.main, className: "min-h-0 overflow-y-auto bg-layout-content @container", "data-testid": "workspace-main-pane", "data-workspace-pane": "main", hidden: mainHidden, tabIndex: isStack ? -1 : undefined, children: [isStack ? (_jsx("button", { type: "button", className: "inline-flex items-center px-4 py-3 text-sm text-muted-foreground hover:text-foreground", onClick: openList, children: "\u8FD4\u56DE\u5217\u8868" })) : null, main] }), _jsxs("aside", { ref: paneRefs.context, className: cn('min-h-0 overflow-y-auto bg-layout-content @container', isStack ? 'border-l-0' : 'border-l border-border'), "data-testid": "workspace-context-pane", "data-workspace-pane": "context", hidden: contextHidden, tabIndex: isStack ? -1 : undefined, children: [isStack ? (_jsx("button", { type: "button", className: "inline-flex items-center px-4 py-3 text-sm text-muted-foreground hover:text-foreground", onClick: openMain, children: "\u8FD4\u56DE\u4E3B\u533A\u57DF" })) : null, context] })] })] }) }));
+}

package/node_modules/@undefineds.co/extension-sdk/dist/react.d.ts

@@ -0,0 +1,12 @@
+import { type DescriptorSinglePaneAppletModule, type DescriptorThreePaneAppletModule, type DescriptorTwoPaneAppletModule, type MountedThreePaneApplet, type MountedSinglePaneApplet, type MountedTwoPaneApplet, type SinglePaneAppletModule, type TwoPaneAppletModule, type WebExtensionHost } from './web';
+export * from './react/layout-context';
+export * from './react/app-layout';
+export * from './react/workspace-layout';
+export * from './react/auth-boundary';
+export interface UseAppletOptions {
+    enabled?: boolean;
+}
+export declare function useApplet<TController, Database = unknown>(applet: TwoPaneAppletModule<TController, Database> | DescriptorTwoPaneAppletModule<TController, Database>, host: WebExtensionHost<Database>, options?: UseAppletOptions): MountedTwoPaneApplet<TController> | null;
+export declare function useApplet<TController, Database = unknown>(applet: SinglePaneAppletModule<TController, Database> | DescriptorSinglePaneAppletModule<TController, Database>, host: WebExtensionHost<Database>, options?: UseAppletOptions): MountedSinglePaneApplet<TController> | null;
+export declare function useApplet<TController, Database = unknown>(applet: DescriptorThreePaneAppletModule<TController, Database>, host: WebExtensionHost<Database>, options?: UseAppletOptions): MountedThreePaneApplet<TController> | null;
+export declare function useApplet<TController, Database = unknown>(applet: TwoPaneAppletModule<TController, Database> | SinglePaneAppletModule<TController, Database> | DescriptorTwoPaneAppletModule<TController, Database> | DescriptorSinglePaneAppletModule<TController, Database> | DescriptorThreePaneAppletModule<TController, Database>, host: WebExtensionHost<Database>, options?: UseAppletOptions): MountedTwoPaneApplet<TController> | MountedSinglePaneApplet<TController> | MountedThreePaneApplet<TController> | null;

package/node_modules/@undefineds.co/extension-sdk/dist/react.js

@@ -0,0 +1,19 @@
+import { useEffect, useMemo } from 'react';
+import { mountApplet, } from './web.js';
+export * from './react/layout-context.js';
+export * from './react/app-layout.js';
+export * from './react/workspace-layout.js';
+export * from './react/auth-boundary.js';
+export function useApplet(applet, host, options = {}) {
+    const enabled = options.enabled ?? true;
+    const mounted = useMemo(() => enabled
+        ? mountApplet(applet, host)
+        : null, [applet, enabled, host]);
+    useEffect(() => {
+        if (!mounted) {
+            return undefined;
+        }
+        return applet.activate?.(mounted.controller, host);
+    }, [applet, host, mounted]);
+    return mounted;
+}

package/node_modules/@undefineds.co/extension-sdk/dist/testing.d.ts

@@ -0,0 +1,7 @@
+import type { WebExtensionHost, WebExtensionSolidCapability } from './web';
+export interface MockWebExtensionHostOverrides {
+    solid?: WebExtensionSolidCapability;
+    navigation?: Partial<WebExtensionHost['navigation']>;
+    capabilities?: WebExtensionHost['capabilities'];
+}
+export declare function createMockWebExtensionHost(overrides?: MockWebExtensionHostOverrides): WebExtensionHost;

package/node_modules/@undefineds.co/extension-sdk/dist/testing.js

@@ -0,0 +1,27 @@
+function createMockSolidSession(snapshot, fetcher) {
+    return {
+        fetch: fetcher,
+        getSnapshot: () => snapshot,
+        subscribe: () => () => undefined,
+    };
+}
+function createSolidCapability() {
+    return {
+        session: createMockSolidSession({ status: 'anonymous' }, globalThis.fetch),
+        pod: { status: 'unavailable' },
+        requireLogin: async () => undefined,
+    };
+}
+export function createMockWebExtensionHost(overrides = {}) {
+    const solid = overrides.solid ?? createSolidCapability();
+    return {
+        solid,
+        navigation: {
+            openExternal: async () => undefined,
+            ...overrides.navigation,
+        },
+        capabilities: {
+            ...overrides.capabilities,
+        },
+    };
+}

package/node_modules/@undefineds.co/extension-sdk/dist/web.d.ts

@@ -0,0 +1,225 @@
+import type { OpenPodRuntime, SolidSessionRuntime } from '@undefineds.co/solid-sdk';
+import { type ReactElement } from 'react';
+import { type AppletLayoutType, SinglePaneAppletLayoutDescriptor, ThreePaneAppletLayoutDescriptor, TwoPaneAppletLayoutDescriptor } from './layout';
+import type { AppletManifest, ExtensionManifest } from './manifest';
+export { defineAppletLayout } from './layout';
+export type { AppletLayoutDescriptor } from './layout';
+export type WebExtensionSessionStatus = 'anonymous' | 'authenticating' | 'authenticated' | 'expired';
+export type AiClientId = 'codex' | 'claude-code' | 'pi' | 'codebuddy';
+export interface AiClientConfigurationStatus {
+    status: 'notConfigured' | 'configured' | 'drifted' | 'unavailable' | 'unverifiable' | 'failedAndRestored';
+    message?: string;
+}
+export interface AiClientConfigurationConfirmation {
+    required: boolean;
+    token: string;
+    targetHash: string;
+    message?: string;
+}
+export interface AiClientConfigurationPlan {
+    planId: string;
+    client: AiClientId;
+    confirmation?: AiClientConfigurationConfirmation;
+    changes: Array<{
+        target: string;
+        action: 'update' | 'createOrUpdate' | 'delete';
+        backup: boolean;
+    }>;
+}
+export interface AiClientConfigurationCapability {
+    readonly available?: boolean;
+    readonly authority?: 'local-filesystem';
+    readonly manualInstructions?: string;
+    inspect(client: AiClientId): Promise<AiClientConfigurationStatus>;
+    plan(input: {
+        client: AiClientId;
+        endpoint: string;
+    }): Promise<AiClientConfigurationPlan>;
+    apply(input: {
+        client: AiClientId;
+        planId: string;
+        gatewayKey: string;
+        confirmation?: {
+            token: string;
+            targetHash: string;
+        };
+    }): Promise<{
+        applied: true;
+    }>;
+    verify(input: {
+        client: AiClientId;
+        planId: string;
+    }): Promise<AiClientConfigurationStatus>;
+    restore(client: AiClientId): Promise<AiClientConfigurationStatus>;
+}
+export type WebExtensionSolidPodStatus = 'unavailable' | 'opening' | 'ready' | 'error';
+export type WebExtensionSolidSession = Readonly<Pick<SolidSessionRuntime, 'fetch' | 'getSnapshot' | 'subscribe'>>;
+export type WebExtensionSolidPod<Database = unknown> = {
+    readonly status: 'unavailable';
+} | {
+    readonly status: 'opening';
+} | {
+    readonly status: 'ready';
+    readonly current: OpenPodRuntime<Database>;
+} | {
+    readonly status: 'error';
+    readonly error: Error;
+};
+export interface SolidAgentAccess {
+    read?: boolean;
+    append?: boolean;
+    write?: boolean;
+}
+export interface SolidServiceAccessResource {
+    id: string;
+    url: string;
+    mediaType: 'text/turtle';
+    access: SolidAgentAccess;
+}
+export interface SolidServiceAccessRequest {
+    appletId: string;
+    service: {
+        webId: string;
+        label: string;
+    };
+    resources: SolidServiceAccessResource[];
+}
+export interface SolidServiceAccessStatus {
+    status: 'granted' | 'missing' | 'permissionDenied' | 'capabilityUnavailable';
+    resources: SolidServiceAccessResource[];
+    message?: string;
+}
+export interface SolidPermissionCapability {
+    inspectAgentAccess(request: SolidServiceAccessRequest): Promise<SolidServiceAccessStatus>;
+    ensureAgentAccess(request: SolidServiceAccessRequest): Promise<SolidServiceAccessStatus>;
+    revokeAgentAccess(request: SolidServiceAccessRequest): Promise<SolidServiceAccessStatus>;
+}
+export interface WebExtensionSolidCapability<Database = unknown> {
+    readonly session: WebExtensionSolidSession;
+    readonly pod: WebExtensionSolidPod<Database>;
+    readonly permissions?: SolidPermissionCapability;
+    requireLogin(): Promise<void>;
+}
+export interface WebExtensionNavigationCapability {
+    openExternal(url: string): Promise<void>;
+}
+export interface WebExtensionHostCapabilities {
+    aiClientConfiguration?: AiClientConfigurationCapability;
+}
+export interface WebExtensionHost<Database = unknown> {
+    readonly solid: WebExtensionSolidCapability<Database>;
+    readonly navigation: WebExtensionNavigationCapability;
+    readonly capabilities: WebExtensionHostCapabilities;
+}
+export interface AppletSlotProps<TController, Database = unknown> {
+    controller: TController;
+    host: WebExtensionHost<Database>;
+}
+export type AppletSlot<TController, Database = unknown> = {
+    bivarianceHack(props: AppletSlotProps<TController, Database>): ReactElement;
+}['bivarianceHack'];
+export interface AppletLifecycle<TController, Database = unknown> {
+    createController(host: WebExtensionHost<Database>): TController;
+    activate?(controller: TController, host: WebExtensionHost<Database>): void | (() => void);
+}
+export interface TwoPaneAppletModule<TController = unknown, Database = unknown> extends AppletLifecycle<TController, Database> {
+    manifest: AppletManifest & {
+        layout: 'two-pane';
+    };
+    slots: TwoPaneAppletSlots<TController, Database>;
+}
+export interface DescriptorTwoPaneAppletModule<TController = unknown, Database = unknown> extends AppletLifecycle<TController, Database> {
+    manifest: AppletManifest & {
+        layout: 'two-pane';
+    };
+    layout: {
+        descriptor: TwoPaneAppletLayoutDescriptor;
+        slots: TwoPaneAppletSlots<TController, Database>;
+    };
+}
+export interface DescriptorSinglePaneAppletModule<TController = unknown, Database = unknown> extends AppletLifecycle<TController, Database> {
+    manifest: AppletManifest & {
+        layout: 'single-pane';
+    };
+    layout: {
+        descriptor: SinglePaneAppletLayoutDescriptor;
+        render: AppletSlot<TController, Database>;
+    };
+}
+export interface DescriptorThreePaneAppletModule<TController = unknown, Database = unknown> extends AppletLifecycle<TController, Database> {
+    manifest: Omit<AppletManifest, 'layout'> & {
+        layout: 'three-pane';
+    };
+    layout: {
+        descriptor: ThreePaneAppletLayoutDescriptor;
+        slots: ThreePaneAppletSlots<TController, Database>;
+    };
+}
+export type TwoPaneAppletSlots<TController, Database = unknown> = {
+    listHeader: AppletSlot<TController, Database>;
+    list: AppletSlot<TController, Database>;
+    mainHeader: AppletSlot<TController, Database>;
+    main: AppletSlot<TController, Database>;
+};
+export type ThreePaneAppletSlots<TController, Database = unknown> = TwoPaneAppletSlots<TController, Database> & {
+    context: AppletSlot<TController, Database>;
+};
+export interface MountedTwoPaneApplet<TController> {
+    layout: 'two-pane';
+    controller: TController;
+    slots: {
+        listHeader: ReactElement;
+        list: ReactElement;
+        mainHeader: ReactElement;
+        main: ReactElement;
+    };
+}
+export interface MountedSinglePaneApplet<TController> {
+    layout: 'single-pane';
+    controller: TController;
+    element: ReactElement;
+}
+export interface MountedThreePaneApplet<TController> {
+    layout: 'three-pane';
+    controller: TController;
+    contextConfig?: ThreePaneAppletLayoutDescriptor['context'];
+    slots: {
+        listHeader: ReactElement;
+        list: ReactElement;
+        mainHeader: ReactElement;
+        main: ReactElement;
+        context: ReactElement;
+    };
+}
+export type MountedApplet<TController = unknown> = MountedTwoPaneApplet<TController> | MountedSinglePaneApplet<TController> | MountedThreePaneApplet<TController>;
+export declare function defineApplet<TController, Database = unknown>(applet: TwoPaneAppletModule<TController, Database>): TwoPaneAppletModule<TController, Database>;
+export declare function defineApplet<TController, Database = unknown>(applet: SinglePaneAppletModule<TController, Database>): SinglePaneAppletModule<TController, Database>;
+export declare function defineApplet<TController, Database = unknown>(applet: DescriptorTwoPaneAppletModule<TController, Database>): DescriptorTwoPaneAppletModule<TController, Database>;
+export declare function defineApplet<TController, Database = unknown>(applet: DescriptorSinglePaneAppletModule<TController, Database>): DescriptorSinglePaneAppletModule<TController, Database>;
+export declare function defineApplet<TController, Database = unknown>(applet: DescriptorThreePaneAppletModule<TController, Database>): DescriptorThreePaneAppletModule<TController, Database>;
+export declare function mountTwoPaneApplet<TController, Database = unknown>(applet: TwoPaneAppletModule<TController, Database> | DescriptorTwoPaneAppletModule<TController, Database>, host: WebExtensionHost<Database>): Omit<MountedTwoPaneApplet<TController>, 'layout'>['slots'] & {
+    controller: TController;
+};
+export interface SinglePaneAppletModule<TController = unknown, Database = unknown> extends AppletLifecycle<TController, Database> {
+    manifest: AppletManifest & {
+        layout: 'single-pane';
+    };
+    render: AppletSlot<TController, Database>;
+}
+export type AppletModule<Database = unknown> = SinglePaneAppletModule<unknown, Database> | TwoPaneAppletModule<unknown, Database> | DescriptorSinglePaneAppletModule<unknown, Database> | DescriptorTwoPaneAppletModule<unknown, Database> | DescriptorThreePaneAppletModule<unknown, Database>;
+export type WebExtensionAppletManifest = Omit<AppletManifest, 'layout'> & {
+    layout: AppletLayoutType;
+};
+export interface WebExtensionManifest extends Omit<ExtensionManifest, 'contributes'> {
+    contributes: Omit<ExtensionManifest['contributes'], 'applets'> & {
+        applets: WebExtensionAppletManifest[];
+    };
+}
+export declare function mountApplet<TController, Database = unknown>(applet: TwoPaneAppletModule<TController, Database> | DescriptorTwoPaneAppletModule<TController, Database>, host: WebExtensionHost<Database>): MountedTwoPaneApplet<TController>;
+export declare function mountApplet<TController, Database = unknown>(applet: SinglePaneAppletModule<TController, Database> | DescriptorSinglePaneAppletModule<TController, Database>, host: WebExtensionHost<Database>): MountedSinglePaneApplet<TController>;
+export declare function mountApplet<TController, Database = unknown>(applet: DescriptorThreePaneAppletModule<TController, Database>, host: WebExtensionHost<Database>): MountedThreePaneApplet<TController>;
+export declare function mountApplet<TController, Database = unknown>(applet: SinglePaneAppletModule<TController, Database> | TwoPaneAppletModule<TController, Database> | DescriptorSinglePaneAppletModule<TController, Database> | DescriptorTwoPaneAppletModule<TController, Database> | DescriptorThreePaneAppletModule<TController, Database>, host: WebExtensionHost<Database>): MountedApplet<TController>;
+export interface WebExtensionModule<Database = unknown> {
+    manifest: WebExtensionManifest;
+    applets: Record<string, AppletModule<Database>>;
+}

package/node_modules/@undefineds.co/extension-sdk/dist/web.js

@@ -0,0 +1,142 @@
+import { createElement } from 'react';
+import { defineAppletLayout as validateAppletLayout, } from './layout.js';
+export { defineAppletLayout } from './layout.js';
+const validateRawAppletLayout = validateAppletLayout;
+export function defineApplet(applet) {
+    return applet;
+}
+export function mountTwoPaneApplet(applet, host) {
+    const mounted = mountResolvedApplet(applet, host);
+    if (mounted.layout !== 'two-pane') {
+        throw new Error(`Applet manifest declares ${applet.manifest.layout} but no two-pane slots were provided`);
+    }
+    return {
+        controller: mounted.controller,
+        listHeader: mounted.slots.listHeader,
+        list: mounted.slots.list,
+        mainHeader: mounted.slots.mainHeader,
+        main: mounted.slots.main,
+    };
+}
+export function mountApplet(applet, host) {
+    return mountResolvedApplet(applet, host);
+}
+function mountResolvedApplet(applet, host) {
+    const layout = resolveAppletLayout(applet);
+    const controller = applet.createController(host);
+    if (layout.type === 'single-pane') {
+        return {
+            layout: 'single-pane',
+            controller,
+            element: createElement(layout.render, { controller, host }),
+        };
+    }
+    if (layout.type === 'two-pane') {
+        return {
+            layout: 'two-pane',
+            controller,
+            slots: {
+                listHeader: createElement(layout.slots.listHeader, { controller, host }),
+                list: createElement(layout.slots.list, { controller, host }),
+                mainHeader: createElement(layout.slots.mainHeader, { controller, host }),
+                main: createElement(layout.slots.main, { controller, host }),
+            },
+        };
+    }
+    return {
+        layout: 'three-pane',
+        controller,
+        contextConfig: layout.contextConfig,
+        slots: {
+            listHeader: createElement(layout.slots.listHeader, { controller, host }),
+            list: createElement(layout.slots.list, { controller, host }),
+            mainHeader: createElement(layout.slots.mainHeader, { controller, host }),
+            main: createElement(layout.slots.main, { controller, host }),
+            context: createElement(layout.slots.context, { controller, host }),
+        },
+    };
+}
+function resolveAppletLayout(applet) {
+    if ('layout' in applet) {
+        const descriptorLayout = requireDescriptorLayout(applet.layout);
+        const descriptor = validateRawAppletLayout(descriptorLayout.descriptor);
+        const descriptorType = descriptor.type;
+        if (applet.manifest.layout !== descriptorType) {
+            throw new Error(`Applet manifest layout ${applet.manifest.layout} does not match descriptor layout ${descriptorType}`);
+        }
+        if (descriptorType === 'single-pane') {
+            if (!('render' in descriptorLayout)) {
+                throw new Error('Applet descriptor single-pane render must be a function');
+            }
+            assertSlotFunction(descriptorLayout.render, 'Applet descriptor single-pane render');
+            return {
+                type: 'single-pane',
+                render: descriptorLayout.render,
+            };
+        }
+        if (!('slots' in descriptorLayout)) {
+            throw new Error(`Applet descriptor declares ${descriptorType} but no slots were provided`);
+        }
+        if (descriptorType === 'two-pane') {
+            assertTwoPaneSlots(descriptorLayout.slots, 'Applet descriptor two-pane');
+            return {
+                type: 'two-pane',
+                slots: descriptorLayout.slots,
+            };
+        }
+        assertThreePaneSlots(descriptorLayout.slots, 'Applet descriptor three-pane');
+        return {
+            type: 'three-pane',
+            contextConfig: descriptor.context,
+            slots: descriptorLayout.slots,
+        };
+    }
+    if (applet.manifest.layout === 'single-pane') {
+        if (!('render' in applet)) {
+            throw new Error('Applet manifest declares single-pane but no single-pane renderer was provided');
+        }
+        assertSlotFunction(applet.render, 'Applet single-pane render');
+        return {
+            type: 'single-pane',
+            render: applet.render,
+        };
+    }
+    if (applet.manifest.layout === 'two-pane' && 'slots' in applet) {
+        assertTwoPaneSlots(applet.slots, 'Applet two-pane');
+        return {
+            type: 'two-pane',
+            slots: applet.slots,
+        };
+    }
+    throw new Error(`Applet manifest declares ${applet.manifest.layout} but no supported applet layout was provided`);
+}
+function assertTwoPaneSlots(slots, label) {
+    assertSlotContainer(slots, label);
+    assertSlotFunction(slots.listHeader, `${label} slot listHeader`);
+    assertSlotFunction(slots.list, `${label} slot list`);
+    assertSlotFunction(slots.mainHeader, `${label} slot mainHeader`);
+    assertSlotFunction(slots.main, `${label} slot main`);
+}
+function assertThreePaneSlots(slots, label) {
+    assertTwoPaneSlots(slots, label);
+    assertSlotFunction(slots.context, `${label} slot context`);
+}
+function assertSlotContainer(value, label) {
+    if (typeof value !== 'object' || value === null) {
+        throw new Error(`${label} slots must be an object`);
+    }
+}
+function assertSlotFunction(value, label) {
+    if (typeof value !== 'function') {
+        throw new Error(`${label} must be a function`);
+    }
+}
+function requireDescriptorLayout(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error('Applet descriptor layout must be an object');
+    }
+    if (!('descriptor' in value) || value.descriptor === undefined) {
+        throw new Error('Applet descriptor required');
+    }
+    return value;
+}

package/node_modules/@undefineds.co/extension-sdk/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@undefineds.co/extension-sdk",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./manifest": {
+      "types": "./dist/manifest.d.ts",
+      "import": "./dist/manifest.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
+    },
+    "./web": {
+      "types": "./dist/web.d.ts",
+      "import": "./dist/web.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json && node ../../scripts/fix-dist-js-imports.mjs dist",
+    "test": "vitest run test --config ../../vitest.packages.config.mts"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "react": "^19.2.0"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.3.2",
+    "@types/react": "^19.2.14",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7"
+  }
+}

package/node_modules/@undefineds.co/shared-ui/dist/badge.d.ts

@@ -0,0 +1,8 @@
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+export declare const badgeVariants: (props?: ({
+    variant?: "default" | "secondary" | "destructive" | "outline" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+export declare function Badge({ className, variant, ...props }: BadgeProps): React.JSX.Element;

package/node_modules/@undefineds.co/shared-ui/dist/badge.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cva } from 'class-variance-authority';
+import { cn } from './utils.js';
+export const badgeVariants = cva('inline-flex items-center rounded-lg border px-2.5 py-0.5 text-xs font-semibold transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-ring/50 focus:ring-offset-2', {
+    variants: {
+        variant: {
+            default: 'border-transparent bg-primary text-primary-foreground shadow-sm shadow-primary/20 hover:bg-primary/90',
+            secondary: 'border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80',
+            destructive: 'border-transparent bg-destructive text-destructive-foreground shadow-sm shadow-destructive/20 hover:bg-destructive/90',
+            outline: 'border-border/40 text-foreground bg-muted/30 backdrop-blur-sm',
+        },
+    },
+    defaultVariants: { variant: 'default' },
+});
+export function Badge({ className, variant, ...props }) {
+    return _jsx("div", { className: cn(badgeVariants({ variant }), className), ...props });
+}