@skyvexsoftware/stratos-sdk 0.1.1

package/dist/ui/radio-group.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import * as RadioGroupPrimitive from "@radix-ui/react-radio-group";
+import { Circle } from "lucide-react";
+import { cn } from "../utils/cn";
+const RadioGroup = React.forwardRef(({ className, ...props }, ref) => (_jsx(RadioGroupPrimitive.Root, { className: cn("grid gap-2", className), ...props, ref: ref })));
+RadioGroup.displayName = RadioGroupPrimitive.Root.displayName;
+const RadioGroupItem = React.forwardRef(({ className, ...props }, ref) => (_jsx(RadioGroupPrimitive.Item, { ref: ref, className: cn("border-primary text-primary focus-visible:ring-ring aspect-square h-4 w-4 rounded-full border shadow-sm focus:outline-hidden focus-visible:ring-1 disabled:cursor-not-allowed disabled:opacity-50", className), ...props, children: _jsx(RadioGroupPrimitive.Indicator, { className: "flex items-center justify-center", children: _jsx(Circle, { className: "fill-primary h-2.5 w-2.5" }) }) })));
+RadioGroupItem.displayName = RadioGroupPrimitive.Item.displayName;
+export { RadioGroup, RadioGroupItem };
+//# sourceMappingURL=radio-group.js.map

package/dist/ui/select.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };
+//# sourceMappingURL=select.d.ts.map

package/dist/ui/select.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+import { Check, ChevronDown, ChevronUp } from "lucide-react";
+import { cn } from "../utils/cn";
+const Select = SelectPrimitive.Root;
+const SelectGroup = SelectPrimitive.Group;
+const SelectValue = SelectPrimitive.Value;
+const SelectTrigger = React.forwardRef(({ className, children, ...props }, ref) => (_jsxs(SelectPrimitive.Trigger, { ref: ref, className: cn("border-input bg-background ring-offset-background placeholder:text-muted-foreground focus:ring-ring flex h-10 w-full items-center justify-between rounded-md border px-3 py-2 text-sm focus:ring-2 focus:ring-offset-2 focus:outline-hidden disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1", className), ...props, children: [children, _jsx(SelectPrimitive.Icon, { asChild: true, children: _jsx(ChevronDown, { className: "h-4 w-4 opacity-50" }) })] })));
+SelectTrigger.displayName = SelectPrimitive.Trigger.displayName;
+const SelectScrollUpButton = React.forwardRef(({ className, ...props }, ref) => (_jsx(SelectPrimitive.ScrollUpButton, { ref: ref, className: cn("flex cursor-default items-center justify-center py-1", className), ...props, children: _jsx(ChevronUp, { className: "h-4 w-4" }) })));
+SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName;
+const SelectScrollDownButton = React.forwardRef(({ className, ...props }, ref) => (_jsx(SelectPrimitive.ScrollDownButton, { ref: ref, className: cn("flex cursor-default items-center justify-center py-1", className), ...props, children: _jsx(ChevronDown, { className: "h-4 w-4" }) })));
+SelectScrollDownButton.displayName =
+    SelectPrimitive.ScrollDownButton.displayName;
+const SelectContent = React.forwardRef(({ className, children, position = "popper", ...props }, ref) => (_jsx(SelectPrimitive.Portal, { children: _jsxs(SelectPrimitive.Content, { ref: ref, className: cn("bg-popover text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 relative z-50 max-h-96 min-w-[8rem] overflow-hidden rounded-md border shadow-md", position === "popper" &&
+            "data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1", className), position: position, ...props, children: [_jsx(SelectScrollUpButton, {}), _jsx(SelectPrimitive.Viewport, { className: cn("p-1", position === "popper" &&
+                    "h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]"), children: children }), _jsx(SelectScrollDownButton, {})] }) })));
+SelectContent.displayName = SelectPrimitive.Content.displayName;
+const SelectLabel = React.forwardRef(({ className, ...props }, ref) => (_jsx(SelectPrimitive.Label, { ref: ref, className: cn("py-1.5 pr-2 pl-8 text-sm font-semibold", className), ...props })));
+SelectLabel.displayName = SelectPrimitive.Label.displayName;
+const SelectItem = React.forwardRef(({ className, children, ...props }, ref) => (_jsxs(SelectPrimitive.Item, { ref: ref, className: cn("focus:bg-accent focus:text-accent-foreground relative flex w-full cursor-default items-center rounded-sm py-1.5 pr-2 pl-8 text-sm outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50", className), ...props, children: [_jsx("span", { className: "absolute left-2 flex h-3.5 w-3.5 items-center justify-center", children: _jsx(SelectPrimitive.ItemIndicator, { children: _jsx(Check, { className: "h-4 w-4" }) }) }), _jsx(SelectPrimitive.ItemText, { children: children })] })));
+SelectItem.displayName = SelectPrimitive.Item.displayName;
+const SelectSeparator = React.forwardRef(({ className, ...props }, ref) => (_jsx(SelectPrimitive.Separator, { ref: ref, className: cn("bg-muted -mx-1 my-1 h-px", className), ...props })));
+SelectSeparator.displayName = SelectPrimitive.Separator.displayName;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };
+//# sourceMappingURL=select.js.map

package/dist/ui/separator.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as SeparatorPrimitive from "@radix-ui/react-separator";
+declare const Separator: React.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Separator };
+//# sourceMappingURL=separator.d.ts.map

package/dist/ui/separator.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import * as SeparatorPrimitive from "@radix-ui/react-separator";
+import { cn } from "../utils/cn";
+const Separator = React.forwardRef(({ className, orientation = "horizontal", decorative = true, ...props }, ref) => (_jsx(SeparatorPrimitive.Root, { ref: ref, decorative: decorative, orientation: orientation, className: cn("bg-border shrink-0", orientation === "horizontal" ? "h-[1px] w-full" : "h-full w-[1px]", className), ...props })));
+Separator.displayName = SeparatorPrimitive.Root.displayName;
+export { Separator };
+//# sourceMappingURL=separator.js.map

package/dist/ui/slider.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as SliderPrimitive from "@radix-ui/react-slider";
+declare const Slider: React.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Slider };
+//# sourceMappingURL=slider.d.ts.map

package/dist/ui/slider.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import * as SliderPrimitive from "@radix-ui/react-slider";
+import { cn } from "../utils/cn";
+const Slider = React.forwardRef(({ className, ...props }, ref) => (_jsxs(SliderPrimitive.Root, { ref: ref, className: cn("relative flex w-full touch-none items-center select-none", className), ...props, children: [_jsx(SliderPrimitive.Track, { className: "bg-primary/20 relative h-1.5 w-full grow overflow-hidden rounded-full", children: _jsx(SliderPrimitive.Range, { className: "bg-primary absolute h-full" }) }), _jsx(SliderPrimitive.Thumb, { className: "border-primary/50 bg-background focus-visible:ring-ring block h-4 w-4 rounded-full border shadow-sm transition-colors focus-visible:ring-1 focus-visible:outline-hidden disabled:pointer-events-none disabled:opacity-50" })] })));
+Slider.displayName = SliderPrimitive.Root.displayName;
+export { Slider };
+//# sourceMappingURL=slider.js.map

package/dist/ui/switch.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+type SwitchProps = {
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    className?: string;
+    id?: string;
+    name?: string;
+};
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };
+export type { SwitchProps };
+//# sourceMappingURL=switch.d.ts.map

package/dist/ui/switch.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../utils/cn";
+const Switch = React.forwardRef(({ checked = false, onCheckedChange, disabled, className, ...props }, ref) => (_jsx("button", { type: "button", role: "switch", "aria-checked": checked, ref: ref, disabled: disabled, onClick: () => onCheckedChange?.(!checked), className: cn("relative inline-flex shrink-0 cursor-pointer rounded-md transition-all duration-150", "h-[18px] w-[32px]", checked
+        ? "border-primary bg-primary border"
+        : "border-border-interactive bg-muted border", disabled && "cursor-not-allowed opacity-50", className), ...props, children: _jsx("span", { className: cn("pointer-events-none absolute top-[2px] h-[12px] w-[12px] rounded-sm bg-white transition-[left] duration-150", checked ? "left-[16px]" : "left-[2px]") }) })));
+Switch.displayName = "Switch";
+export { Switch };
+//# sourceMappingURL=switch.js.map

package/dist/ui/tabs.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent };
+//# sourceMappingURL=tabs.d.ts.map

package/dist/ui/tabs.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+import { cn } from "../utils/cn";
+const Tabs = TabsPrimitive.Root;
+const TabsList = React.forwardRef(({ className, ...props }, ref) => (_jsx(TabsPrimitive.List, { ref: ref, className: cn("bg-muted text-muted-foreground inline-flex h-10 items-center justify-center rounded-md p-1", className), ...props })));
+TabsList.displayName = TabsPrimitive.List.displayName;
+const TabsTrigger = React.forwardRef(({ className, ...props }, ref) => (_jsx(TabsPrimitive.Trigger, { ref: ref, className: cn("ring-offset-background focus-visible:ring-ring data-[state=active]:bg-background data-[state=active]:text-foreground inline-flex items-center justify-center rounded-sm px-3 py-1.5 text-sm font-medium whitespace-nowrap transition-all focus-visible:ring-2 focus-visible:ring-offset-2 focus-visible:outline-hidden disabled:pointer-events-none disabled:opacity-50 data-[state=active]:shadow-sm", className), ...props })));
+TabsTrigger.displayName = TabsPrimitive.Trigger.displayName;
+const TabsContent = React.forwardRef(({ className, ...props }, ref) => (_jsx(TabsPrimitive.Content, { ref: ref, className: cn("ring-offset-background focus-visible:ring-ring mt-2 focus-visible:ring-2 focus-visible:ring-offset-2 focus-visible:outline-hidden", className), ...props })));
+TabsContent.displayName = TabsPrimitive.Content.displayName;
+export { Tabs, TabsList, TabsTrigger, TabsContent };
+//# sourceMappingURL=tabs.js.map

package/dist/ui/textarea.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+declare function Textarea({ className, ...props }: React.ComponentProps<"textarea">): import("react/jsx-runtime").JSX.Element;
+export { Textarea };
+//# sourceMappingURL=textarea.d.ts.map

package/dist/ui/textarea.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from "../utils/cn";
+function Textarea({ className, ...props }) {
+    return (_jsx("textarea", { "data-slot": "textarea", className: cn("border-input bg-background placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 flex min-h-[60px] w-full rounded-md border px-3 py-2 text-base shadow-xs transition-[color,box-shadow] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 md:text-sm", "aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive", className), ...props }));
+}
+export { Textarea };
+//# sourceMappingURL=textarea.js.map

package/dist/ui/tooltip.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };
+//# sourceMappingURL=tooltip.d.ts.map

package/dist/ui/tooltip.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import { cn } from "../utils/cn";
+const TooltipProvider = TooltipPrimitive.Provider;
+const Tooltip = TooltipPrimitive.Root;
+const TooltipTrigger = TooltipPrimitive.Trigger;
+const TooltipContent = React.forwardRef(({ className, sideOffset = 4, ...props }, ref) => (_jsx(TooltipPrimitive.Content, { ref: ref, sideOffset: sideOffset, className: cn("bg-popover text-popover-foreground animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 overflow-hidden rounded-md border px-3 py-1.5 text-sm shadow-md", className), ...props })));
+TooltipContent.displayName = TooltipPrimitive.Content.displayName;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };
+//# sourceMappingURL=tooltip.js.map

package/dist/utils/cn.d.ts

@@ -0,0 +1,3 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;
+//# sourceMappingURL=cn.d.ts.map

package/dist/utils/cn.js

@@ -0,0 +1,6 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}
+//# sourceMappingURL=cn.js.map

package/dist/vite/externals.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Canonical list of modules provided by the Stratos shell at runtime via
+ * `window.__stratos_modules__`. This is the single source of truth — both
+ * `vite-plugin.config.ts` (build-time) and `serve-externals.ts` (dev-time)
+ * import from here.
+ */
+export declare const UI_EXTERNALS: readonly ["react", "react-dom", "react/jsx-runtime", "@tanstack/react-router", "@tanstack/react-query", "@skyvexsoftware/stratos-sdk", "sonner", "socket.io-client", "maplibre-gl", "react-map-gl/maplibre"];
+export type UIExternal = (typeof UI_EXTERNALS)[number];
+//# sourceMappingURL=externals.d.ts.map

package/dist/vite/externals.js

@@ -0,0 +1,19 @@
+/**
+ * Canonical list of modules provided by the Stratos shell at runtime via
+ * `window.__stratos_modules__`. This is the single source of truth — both
+ * `vite-plugin.config.ts` (build-time) and `serve-externals.ts` (dev-time)
+ * import from here.
+ */
+export const UI_EXTERNALS = [
+    "react",
+    "react-dom",
+    "react/jsx-runtime",
+    "@tanstack/react-router",
+    "@tanstack/react-query",
+    "@skyvexsoftware/stratos-sdk",
+    "sonner",
+    "socket.io-client",
+    "maplibre-gl",
+    "react-map-gl/maplibre",
+];
+//# sourceMappingURL=externals.js.map

package/dist/vite/plugin-config.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Shared Vite configuration for Stratos plugin builds.
+ *
+ * Plugins import `createPluginConfig` to get a Vite config that handles:
+ * - UI bundle (ESM, shared deps externalized to window.__stratos_modules__)
+ * - Background bundle (ESM for Node.js, Electron + SDK externalized)
+ * - Manifest and asset copying to dist/
+ *
+ * Usage in a plugin's vite.config.ts:
+ *
+ *   import { createPluginConfig } from '../../sdk/src/vite/plugin-config';
+ *   export default createPluginConfig({
+ *     pluginDir: import.meta.dirname,
+ *     ui: { entry: 'src/ui/index.ts' },
+ *     background: { entry: 'src/background/index.ts' },
+ *   });
+ */
+import type { Plugin, UserConfig } from "vite";
+import { UI_EXTERNALS } from "./externals";
+/** Modules external in background builds (available in Electron main process) */
+declare const BG_EXTERNALS: string[];
+/**
+ * Rollup plugin that transforms ESM import statements for externalized modules
+ * into runtime lookups from window.__stratos_modules__.
+ *
+ * This allows plugin UI bundles to remain valid ES modules that can be loaded
+ * via dynamic import() while resolving shared dependencies from the shell's
+ * global registry.
+ */
+declare function stratosExternals(): Plugin;
+export type PluginBuildOptions = {
+    pluginDir: string;
+    ui?: {
+        entry: string;
+    };
+    background?: {
+        entry: string;
+    };
+};
+/**
+ * Create a Vite config for building a Stratos plugin.
+ *
+ * The build target is determined by the BUILD_TARGET environment variable:
+ * - undefined / "ui" → builds the UI module (renderer, ESM with externals)
+ * - "background"     → builds the background module (Node.js, ESM)
+ */
+export declare function createPluginConfig(options: PluginBuildOptions): UserConfig;
+export { UI_EXTERNALS, BG_EXTERNALS, stratosExternals };
+//# sourceMappingURL=plugin-config.d.ts.map

package/dist/vite/plugin-config.js

@@ -0,0 +1,236 @@
+/**
+ * Shared Vite configuration for Stratos plugin builds.
+ *
+ * Plugins import `createPluginConfig` to get a Vite config that handles:
+ * - UI bundle (ESM, shared deps externalized to window.__stratos_modules__)
+ * - Background bundle (ESM for Node.js, Electron + SDK externalized)
+ * - Manifest and asset copying to dist/
+ *
+ * Usage in a plugin's vite.config.ts:
+ *
+ *   import { createPluginConfig } from '../../sdk/src/vite/plugin-config';
+ *   export default createPluginConfig({
+ *     pluginDir: import.meta.dirname,
+ *     ui: { entry: 'src/ui/index.ts' },
+ *     background: { entry: 'src/background/index.ts' },
+ *   });
+ */
+import * as fs from "fs";
+import * as path from "path";
+import react from "@vitejs/plugin-react";
+import { UI_EXTERNALS } from "./externals";
+import { serveExternals } from "./serve-externals";
+import { stratosDevServer } from "./stratos-dev-server";
+/** Modules external in background builds (available in Electron main process) */
+const BG_EXTERNALS = [
+    "electron",
+    "@skyvexsoftware/stratos-sdk",
+    "socket.io-client",
+];
+/** Node.js built-in modules to externalize in background builds */
+const NODE_BUILTINS = [
+    "assert",
+    "buffer",
+    "child_process",
+    "cluster",
+    "crypto",
+    "dgram",
+    "dns",
+    "events",
+    "fs",
+    "http",
+    "https",
+    "module",
+    "net",
+    "os",
+    "path",
+    "perf_hooks",
+    "querystring",
+    "readline",
+    "stream",
+    "tls",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "worker_threads",
+    "zlib",
+];
+/**
+ * Rollup plugin that transforms ESM import statements for externalized modules
+ * into runtime lookups from window.__stratos_modules__.
+ *
+ * This allows plugin UI bundles to remain valid ES modules that can be loaded
+ * via dynamic import() while resolving shared dependencies from the shell's
+ * global registry.
+ */
+function stratosExternals() {
+    return {
+        name: "stratos-externals",
+        renderChunk(code) {
+            let result = code;
+            for (const modId of UI_EXTERNALS) {
+                const escaped = modId.replace(/[-/\\^$*+?.()|[\]{}@]/g, "\\$&");
+                const global = `window.__stratos_modules__[${JSON.stringify(modId)}]`;
+                // 1. import Default, { named as alias } from 'mod';
+                // Note: [\w$]+ handles Rollup's conflict-resolution names like Map$1
+                result = result.replace(new RegExp(`import\\s+([\\w$]+)\\s*,\\s*\\{([^}]+)\\}\\s+from\\s+['"]${escaped}['"]\\s*;?`, "g"), (_, def, names) => {
+                    const destructured = names.replace(/([\w$]+)\s+as\s+([\w$]+)/g, "$1: $2");
+                    return `const ${def} = ${global}.default || ${global};\nconst {${destructured}} = ${global};`;
+                });
+                // 2. import { named as alias } from 'mod';
+                result = result.replace(new RegExp(`import\\s*\\{([^}]+)\\}\\s+from\\s+['"]${escaped}['"]\\s*;?`, "g"), (_, names) => {
+                    const destructured = names.replace(/([\w$]+)\s+as\s+([\w$]+)/g, "$1: $2");
+                    return `const {${destructured}} = ${global};`;
+                });
+                // 3. import * as ns from 'mod';
+                result = result.replace(new RegExp(`import\\s+\\*\\s+as\\s+([\\w$]+)\\s+from\\s+['"]${escaped}['"]\\s*;?`, "g"), (_, name) => `const ${name} = ${global};`);
+                // 4. import Default from 'mod';
+                result = result.replace(new RegExp(`import\\s+([\\w$]+)\\s+from\\s+['"]${escaped}['"]\\s*;?`, "g"), (_, def) => `const ${def} = ${global}.default || ${global};`);
+                // 5. import 'mod'; (side effect only)
+                result = result.replace(new RegExp(`import\\s+['"]${escaped}['"]\\s*;?`, "g"), "");
+                // 6. export { name } from 'mod'; (re-export)
+                result = result.replace(new RegExp(`export\\s*\\{([^}]+)\\}\\s+from\\s+['"]${escaped}['"]\\s*;?`, "g"), (_, names) => {
+                    const parts = names.split(",").map((n) => n.trim());
+                    const decls = [];
+                    const exportNames = [];
+                    for (const part of parts) {
+                        const asMatch = part.match(/^([\w$]+)\s+as\s+([\w$]+)$/);
+                        if (asMatch) {
+                            decls.push(`const ${asMatch[2]} = ${global}[${JSON.stringify(asMatch[1])}];`);
+                            exportNames.push(asMatch[2]);
+                        }
+                        else {
+                            exportNames.push(part);
+                        }
+                    }
+                    if (decls.length > 0) {
+                        return `${decls.join("\n")}\nconst {${exportNames.join(", ")}} = ${global};\nexport {${exportNames.join(", ")}};`;
+                    }
+                    return `const {${exportNames.join(", ")}} = ${global};\nexport {${exportNames.join(", ")}};`;
+                });
+            }
+            return result;
+        },
+    };
+}
+/**
+ * Rollup plugin that copies plugin.json and assets/ to dist/ after the build.
+ * Only runs during the UI build (not background) to avoid duplicate copies.
+ */
+function copyPluginAssets(pluginDir) {
+    return {
+        name: "copy-plugin-assets",
+        closeBundle() {
+            const distDir = path.resolve(pluginDir, "dist");
+            fs.mkdirSync(distDir, { recursive: true });
+            // Copy plugin.json
+            const manifestSrc = path.resolve(pluginDir, "plugin.json");
+            if (fs.existsSync(manifestSrc)) {
+                fs.copyFileSync(manifestSrc, path.resolve(distDir, "plugin.json"));
+            }
+            // Copy assets/ directory
+            const assetsSrc = path.resolve(pluginDir, "assets");
+            if (fs.existsSync(assetsSrc)) {
+                copyDirSync(assetsSrc, path.resolve(distDir, "assets"));
+            }
+        },
+    };
+}
+function copyDirSync(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirSync(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+/**
+ * Create a Vite config for building a Stratos plugin.
+ *
+ * The build target is determined by the BUILD_TARGET environment variable:
+ * - undefined / "ui" → builds the UI module (renderer, ESM with externals)
+ * - "background"     → builds the background module (Node.js, ESM)
+ */
+export function createPluginConfig(options) {
+    const { pluginDir, ui, background } = options;
+    const target = process.env.BUILD_TARGET;
+    if (target === "background" && background) {
+        return createBackgroundConfig(pluginDir, background.entry);
+    }
+    if (ui) {
+        return createUIConfig(pluginDir, ui.entry);
+    }
+    throw new Error("No build target. Provide a ui entry or set BUILD_TARGET=background.");
+}
+function createUIConfig(pluginDir, entry) {
+    const isProduction = process.env.NODE_ENV === "production";
+    return {
+        root: pluginDir,
+        plugins: [
+            { ...react(), apply: "serve" },
+            serveExternals(),
+            stratosDevServer({ pluginDir }),
+            stratosExternals(),
+            copyPluginAssets(pluginDir),
+        ],
+        server: {
+            cors: {
+                origin: [
+                    "http://localhost:2066",
+                    "http://127.0.0.1:2066",
+                    /^http:\/\/localhost:\d+$/,
+                ],
+            },
+        },
+        build: {
+            outDir: path.resolve(pluginDir, "dist/ui"),
+            emptyOutDir: true,
+            lib: {
+                entry: path.resolve(pluginDir, entry),
+                formats: ["es"],
+                fileName: () => "index.js",
+            },
+            rollupOptions: {
+                external: [...UI_EXTERNALS],
+            },
+            sourcemap: !isProduction,
+            minify: isProduction ? "esbuild" : false,
+        },
+        esbuild: {
+            jsx: "automatic",
+            jsxImportSource: "react",
+        },
+    };
+}
+function createBackgroundConfig(pluginDir, entry) {
+    const isProduction = process.env.NODE_ENV === "production";
+    return {
+        root: pluginDir,
+        build: {
+            outDir: path.resolve(pluginDir, "dist/background"),
+            emptyOutDir: true,
+            lib: {
+                entry: path.resolve(pluginDir, entry),
+                formats: ["es"],
+                fileName: () => "index.js",
+            },
+            rollupOptions: {
+                external: [
+                    ...BG_EXTERNALS,
+                    ...NODE_BUILTINS,
+                    ...NODE_BUILTINS.map((b) => `node:${b}`),
+                ],
+            },
+            sourcemap: !isProduction,
+            minify: false,
+        },
+    };
+}
+export { UI_EXTERNALS, BG_EXTERNALS, stratosExternals };
+//# sourceMappingURL=plugin-config.js.map

package/dist/vite/serve-externals.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from "vite";
+/**
+ * Vite plugin that rewrites external imports to `window.__stratos_modules__`
+ * lookups in serve (dev) mode. This mirrors what `stratosExternals()` does at
+ * build time via `renderChunk`, but operates on source-level files so that
+ * the Vite dev server can resolve shared shell dependencies correctly.
+ */
+export declare function serveExternals(): Plugin;
+//# sourceMappingURL=serve-externals.d.ts.map

package/dist/vite/serve-externals.js

@@ -0,0 +1,78 @@
+import { UI_EXTERNALS } from "./externals";
+const EXTERNAL_PACKAGES = [
+    ...UI_EXTERNALS,
+    "react/jsx-runtime",
+    "react/jsx-dev-runtime",
+    "react-dom/client",
+];
+const JS_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx"]);
+function escapeRegExp(str) {
+    return str.replace(/[-/\\^$*+?.()|[\]{}@]/g, "\\$&");
+}
+/**
+ * Vite plugin that rewrites external imports to `window.__stratos_modules__`
+ * lookups in serve (dev) mode. This mirrors what `stratosExternals()` does at
+ * build time via `renderChunk`, but operates on source-level files so that
+ * the Vite dev server can resolve shared shell dependencies correctly.
+ */
+export function serveExternals() {
+    return {
+        name: "stratos-serve-externals",
+        apply: "serve",
+        enforce: "pre",
+        transform(code, id) {
+            // Only process JS/TS source files
+            const ext = id.slice(id.lastIndexOf("."));
+            if (!JS_EXTENSIONS.has(ext))
+                return null;
+            // Skip node_modules
+            if (id.includes("/node_modules/"))
+                return null;
+            let result = code;
+            for (const modId of EXTERNAL_PACKAGES) {
+                const escaped = escapeRegExp(modId);
+                const global = `window.__stratos_modules__[${JSON.stringify(modId)}]`;
+                // 1. Combined default + named: import Default, { Named } from "pkg"
+                result = result.replace(new RegExp(`import\\s+([\\w$]+)\\s*,\\s*\\{([^}]+)\\}\\s+from\\s+['"]${escaped}['"]\\s*;?`, "g"), (_, def, names) => {
+                    const destructured = names.replace(/([\w$]+)\s+as\s+([\w$]+)/g, "$1: $2");
+                    return `const ${def} = ${global}.default || ${global};\nconst {${destructured}} = ${global};`;
+                });
+                // 2. Named imports: import { Foo, Bar } from "pkg"
+                result = result.replace(new RegExp(`import\\s*\\{([^}]+)\\}\\s+from\\s+['"]${escaped}['"]\\s*;?`, "g"), (_, names) => {
+                    const destructured = names.replace(/([\w$]+)\s+as\s+([\w$]+)/g, "$1: $2");
+                    return `const {${destructured}} = ${global};`;
+                });
+                // 3. Namespace imports: import * as Foo from "pkg"
+                result = result.replace(new RegExp(`import\\s+\\*\\s+as\\s+([\\w$]+)\\s+from\\s+['"]${escaped}['"]\\s*;?`, "g"), (_, name) => `const ${name} = ${global};`);
+                // 4. Default imports: import Foo from "pkg"
+                result = result.replace(new RegExp(`import\\s+([\\w$]+)\\s+from\\s+['"]${escaped}['"]\\s*;?`, "g"), (_, def) => `const ${def} = ${global}.default || ${global};`);
+                // 5. Re-exports: export { name } from "pkg"
+                result = result.replace(new RegExp(`export\\s*\\{([^}]+)\\}\\s+from\\s+['"]${escaped}['"]\\s*;?`, "g"), (_, names) => {
+                    const parts = names.split(",").map((n) => n.trim());
+                    const decls = [];
+                    const exportNames = [];
+                    for (const part of parts) {
+                        const asMatch = part.match(/^([\w$]+)\s+as\s+([\w$]+)$/);
+                        if (asMatch) {
+                            decls.push(`const ${asMatch[2]} = ${global}[${JSON.stringify(asMatch[1])}];`);
+                            exportNames.push(asMatch[2]);
+                        }
+                        else {
+                            exportNames.push(part);
+                        }
+                    }
+                    if (decls.length > 0) {
+                        return `${decls.join("\n")}\nconst {${exportNames.join(", ")}} = ${global};\nexport {${exportNames.join(", ")}};`;
+                    }
+                    return `const {${exportNames.join(", ")}} = ${global};\nexport {${exportNames.join(", ")}};`;
+                });
+                // 6. Side-effect imports: import "pkg"
+                result = result.replace(new RegExp(`import\\s+['"]${escaped}['"]\\s*;?`, "g"), `// (stratos-serve-externals: side-effect import of "${modId}" removed)`);
+            }
+            if (result === code)
+                return null;
+            return { code: result, map: null };
+        },
+    };
+}
+//# sourceMappingURL=serve-externals.js.map

package/dist/vite/stratos-dev-server.d.ts

@@ -0,0 +1,21 @@
+import type { Plugin } from "vite";
+type StratosDevServerOptions = {
+    pluginDir: string;
+    stratosPort?: number;
+};
+/**
+ * Vite plugin that auto-connects a plugin's dev server to a running Stratos
+ * app. Only active in serve (dev) mode.
+ *
+ * On startup it:
+ *  - Reads plugin.json from the plugin directory
+ *  - Derives the dev URL from the Vite HTTP server address
+ *  - Connects to Stratos's Socket.io server and emits dev:plugin-connect
+ *  - Retries with exponential backoff if Stratos isn't running
+ *
+ * If src/background/ exists, it watches for changes and rebuilds the
+ * background bundle, then notifies Stratos via dev:plugin-bg-updated.
+ */
+export declare function stratosDevServer(options: StratosDevServerOptions): Plugin;
+export {};
+//# sourceMappingURL=stratos-dev-server.d.ts.map