@odyn-app/api 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,487 @@
+// The public building kit for Odyn extensions.
+//
+// This is the ONLY part of Odyn an extension author sees. It describes what
+// an extension may ask for (its manifest), what it may draw (plain data —
+// lists, details, forms — or, from version 2, its own small page shown in a
+// sealed box), and what it may call (a short list of actions, each behind a
+// permission the user agreed to at install). From version 3 an official
+// extension may also run a background helper that drives Mac programs, show
+// live screens in the sidebar, and give the agent a guide. From version 4
+// any extension may hand the agent tools that take inputs, and an extension
+// may be nothing more than a guide or tools for the agent.
+// Keep it dependency-free: it is shared by Odyn, the store checker and every
+// extension.
+/** The newest building-kit version. Bumped when something new is added. */
+export const EXTENSION_API_VERSION = 4;
+/** The oldest building-kit version Odyn still runs. */
+export const EXTENSION_API_MIN_VERSION = 1;
+// --- Manifest -------------------------------------------------------------
+/** Everything an extension can ask the user to allow. */
+export const EXTENSION_PERMISSIONS = [
+    'chats:read',
+    'projects:read',
+    'agents:start',
+    'network',
+    /** Put a picture onto the message the user is writing. */
+    'composer:attach',
+    /** Receive a recent Mac screenshot when the user hands one over. */
+    'screenshots:read',
+    /** Run the Mac programs listed in `helper.programs`. Official extensions only. */
+    'programs:run',
+    /** Give the agent a guide, and ask before it uses the listed commands. */
+    'agent:tools',
+];
+/** Permissions only extensions made by Odyn may ask for. */
+export const OFFICIAL_ONLY_PERMISSIONS = ['programs:run'];
+/** Systems an extension can say it runs on. Leave out to run everywhere. */
+export const EXTENSION_PLATFORMS = ['darwin', 'linux', 'win32'];
+/** Where an extension can show up inside Odyn. */
+export const EXTENSION_PLACEMENTS = ['sidebarPanel', 'chatCard', 'agentTool', 'settings'];
+/** The kinds of value an agent tool's input can take. */
+export const EXTENSION_INPUT_TYPES = ['string', 'number', 'boolean'];
+/** Where an extension's own page can be shown. */
+export const EXTENSION_SURFACE_PLACEMENTS = ['composer', 'settings'];
+/** The icons Odyn can draw on the button that opens a page. */
+export const EXTENSION_SURFACE_ICONS = ['puzzle', 'pencil', 'image', 'note'];
+export const SURFACE_MIN_HEIGHT = 120;
+export const SURFACE_MAX_HEIGHT = 600;
+/** Every method name the bridge accepts, so Odyn can refuse anything else. */
+export const EXTENSION_API_METHODS = [
+    'chats.list',
+    'chats.messages',
+    'chats.current',
+    'projects.list',
+    'agents.start',
+    'fetch',
+    'showToast',
+    'preferences',
+];
+function buildOdynApi(bridge) {
+    const call = (method, ...args) => bridge.call(method, args);
+    return {
+        chats: {
+            list: (projectId) => call('chats.list', projectId ?? null),
+            messages: (chatId, limit) => call('chats.messages', chatId, limit ?? null),
+            current: () => call('chats.current'),
+        },
+        projects: { list: () => call('projects.list') },
+        agents: { start: (chatId, prompt) => call('agents.start', chatId, prompt) },
+        fetch: (url, init) => call('fetch', url, init ?? null),
+        showToast: (message) => call('showToast', message),
+        preferences: () => call('preferences'),
+    };
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * The one call an extension's entry file makes. Inside Odyn it hooks the
+ * commands up to Odyn; anywhere else (tests, the store checker) it just
+ * hands the definition back.
+ */
+export function defineExtension(definition) {
+    const bridge = globalThis.__odynBridge;
+    if (!bridge)
+        return definition;
+    const odyn = buildOdynApi(bridge);
+    bridge.onRun(({ callId, command, ...rest }) => {
+        const handler = definition.commands[command];
+        if (!handler) {
+            bridge.finish(callId, { ok: false, error: `This extension has no command called "${command}".` });
+            return;
+        }
+        handler({ odyn, ...rest })
+            .then((value) => bridge.finish(callId, { ok: true, value: value ?? null }))
+            .catch((error) => bridge.finish(callId, { ok: false, error: errorText(error) }));
+    });
+    return definition;
+}
+// --- Checking a manifest --------------------------------------------------
+const ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const ENTRY_PATTERN = /^(?:[A-Za-z0-9_-]+\/)*[A-Za-z0-9_-]+\.html$/;
+function surfaceProblems(surfaces, apiVersion) {
+    if (surfaces.length === 0)
+        return [];
+    const problems = [];
+    if (apiVersion < 2)
+        problems.push('Pages (`surfaces`) need `apiVersion` 2.');
+    const ids = new Set();
+    for (const surface of surfaces) {
+        const label = `Page "${String(surface?.id)}"`;
+        if (!ID_PATTERN.test(surface?.id ?? ''))
+            problems.push(`${label} has an invalid id.`);
+        if (ids.has(surface.id))
+            problems.push(`${label} is listed twice.`);
+        ids.add(surface.id);
+        if (typeof surface.title !== 'string' || surface.title.trim() === '')
+            problems.push(`${label} needs a title.`);
+        if (!EXTENSION_SURFACE_PLACEMENTS.includes(surface.placement))
+            problems.push(`${label} has an unknown placement.`);
+        if (typeof surface.entry !== 'string' || !ENTRY_PATTERN.test(surface.entry))
+            problems.push(`${label} needs an \`entry\` like "dist/panel/index.html".`);
+        if (surface.icon !== undefined && !EXTENSION_SURFACE_ICONS.includes(surface.icon))
+            problems.push(`${label} has an unknown icon.`);
+        if (surface.height !== undefined && (typeof surface.height !== 'number' || surface.height < SURFACE_MIN_HEIGHT || surface.height > SURFACE_MAX_HEIGHT)) {
+            problems.push(`${label} height must be between ${SURFACE_MIN_HEIGHT} and ${SURFACE_MAX_HEIGHT}.`);
+        }
+    }
+    if (surfaces.filter((surface) => surface.placement === 'composer').length > 1)
+        problems.push('Only one page can sit in the message box.');
+    if (surfaces.filter((surface) => surface.placement === 'settings').length > 1)
+        problems.push('Only one page can sit in the settings window.');
+    if (apiVersion < 3 && surfaces.some((surface) => surface.placement === 'settings'))
+        problems.push('A settings page needs `apiVersion` 3.');
+    return problems;
+}
+const NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const SCRIPT_PATTERN = /^(?:[A-Za-z0-9_-]+\/)*[A-Za-z0-9_-]+\.js$/;
+const FOLDER_PATTERN = /^(?:[A-Za-z0-9_-]+\/)*[A-Za-z0-9_-]+$/;
+function locationProblems(label, locations) {
+    if (!Array.isArray(locations) || locations.length === 0)
+        return [`${label} needs at least one location.`];
+    const bad = locations.filter((location) => typeof location !== 'string' || location.trim() === '' || location.includes('..'));
+    return bad.length > 0 ? [`${label} has a location Odyn cannot use.`] : [];
+}
+function helperProblems(manifest, apiVersion) {
+    const helper = manifest.helper;
+    const asksPrograms = Array.isArray(manifest.permissions) && manifest.permissions.includes('programs:run');
+    if (helper === undefined)
+        return asksPrograms ? ['`programs:run` needs a `helper`.'] : [];
+    const problems = [];
+    if (apiVersion < 3)
+        problems.push('A `helper` needs `apiVersion` 3.');
+    if (!asksPrograms)
+        problems.push('A `helper` needs the `programs:run` permission.');
+    if (typeof helper !== 'object' || helper === null)
+        return [...problems, '`helper` must be an object.'];
+    if (typeof helper.entry !== 'string' || !SCRIPT_PATTERN.test(helper.entry))
+        problems.push('`helper.entry` must be a script like "dist/helper.js".');
+    const named = (list, kind) => {
+        if (list === undefined && kind === 'folder')
+            return;
+        if (!Array.isArray(list)) {
+            problems.push(`\`helper.${kind}s\` must be a list.`);
+            return;
+        }
+        const names = new Set();
+        for (const item of list) {
+            const label = `Helper ${kind} "${String(item?.name)}"`;
+            if (typeof item?.name !== 'string' || !NAME_PATTERN.test(item.name))
+                problems.push(`${label} has an invalid name.`);
+            else if (names.has(item.name))
+                problems.push(`${label} is listed twice.`);
+            else
+                names.add(item.name);
+            problems.push(...locationProblems(label, item?.locations));
+        }
+    };
+    named(helper.programs, 'program');
+    named(helper.folders, 'folder');
+    if (helper.links !== undefined && (!Array.isArray(helper.links) || helper.links.some((link) => typeof link !== 'string' || !/^[a-z][a-z0-9+.-]*:\/\/\S+$/.test(link)))) {
+        problems.push('`helper.links` must be a list of full links.');
+    }
+    if (helper.downloadHosts !== undefined && (!Array.isArray(helper.downloadHosts) || helper.downloadHosts.some((host) => typeof host !== 'string' || !/^[a-z0-9.-]+$/.test(host)))) {
+        problems.push('`helper.downloadHosts` must be a list of host names.');
+    }
+    return problems;
+}
+function agentProblems(manifest, apiVersion) {
+    const agent = manifest.agent;
+    const asksAgent = Array.isArray(manifest.permissions) && manifest.permissions.includes('agent:tools');
+    if (agent === undefined)
+        return asksAgent ? ['`agent:tools` needs an `agent` section.'] : [];
+    const problems = [];
+    if (apiVersion < 3)
+        problems.push('An `agent` section needs `apiVersion` 3.');
+    if (!asksAgent)
+        problems.push('An `agent` section needs the `agent:tools` permission.');
+    if (typeof agent !== 'object' || agent === null)
+        return [...problems, '`agent` must be an object.'];
+    // From version 4 the guide is optional, but it comes as a pair.
+    const guideOptional = apiVersion >= 4 && agent.skill === undefined && agent.skillFolder === undefined;
+    if (!guideOptional) {
+        if (typeof agent.skill !== 'string' || !ID_PATTERN.test(agent.skill))
+            problems.push('`agent.skill` must be lowercase words joined by dashes.');
+        if (typeof agent.skillFolder !== 'string' || !FOLDER_PATTERN.test(agent.skillFolder))
+            problems.push('`agent.skillFolder` must be a folder inside the extension.');
+    }
+    if (typeof agent.summary !== 'string' || agent.summary.trim() === '')
+        problems.push('`agent.summary` is required.');
+    if (agent.gatedCommands !== undefined) {
+        if (!Array.isArray(agent.gatedCommands))
+            problems.push('`agent.gatedCommands` must be a list.');
+        else if (agent.gatedCommands.some((command) => typeof command?.program !== 'string' || !NAME_PATTERN.test(command.program) || (command.subcommand !== undefined && typeof command.subcommand !== 'string'))) {
+            problems.push('Every gated command needs a `program` name.');
+        }
+    }
+    return problems;
+}
+const INPUT_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]{0,63}$/;
+function inputProblems(command, apiVersion) {
+    if (command.inputs === undefined)
+        return [];
+    const label = `Agent tool "${command.name}"`;
+    if (command.placement !== 'agentTool')
+        return [`Command "${command.name}" has inputs, but only agent tools take them.`];
+    if (apiVersion < 4)
+        return [`${label} inputs need \`apiVersion\` 4.`];
+    if (!Array.isArray(command.inputs))
+        return [`${label} inputs must be a list.`];
+    const problems = [];
+    const names = new Set();
+    for (const input of command.inputs) {
+        const name = typeof input?.name === 'string' ? input.name : '';
+        if (!INPUT_NAME_PATTERN.test(name))
+            problems.push(`${label} has an input with an invalid name.`);
+        else if (names.has(name))
+            problems.push(`${label} lists the input "${name}" twice.`);
+        names.add(name);
+        if (typeof input?.description !== 'string' || input.description.trim() === '')
+            problems.push(`${label} input "${name}" needs a description.`);
+        if (!EXTENSION_INPUT_TYPES.includes(input?.type))
+            problems.push(`${label} input "${name}" must be one of: ${EXTENSION_INPUT_TYPES.join(', ')}.`);
+        if (input?.required !== undefined && typeof input.required !== 'boolean')
+            problems.push(`${label} input "${name}" has a \`required\` that is not true or false.`);
+    }
+    return problems;
+}
+export function validateManifest(value, options = {}) {
+    if (typeof value !== 'object' || value === null)
+        return ['The manifest is not an object.'];
+    const manifest = value;
+    const problems = [];
+    if (typeof manifest.id !== 'string' || !ID_PATTERN.test(manifest.id))
+        problems.push('`id` must be lowercase words joined by dashes.');
+    for (const key of ['title', 'description', 'author', 'version']) {
+        if (typeof manifest[key] !== 'string' || manifest[key].trim() === '')
+            problems.push(`\`${key}\` is required.`);
+    }
+    const apiVersion = typeof manifest.apiVersion === 'number' ? manifest.apiVersion : 0;
+    if (!Number.isInteger(apiVersion) || apiVersion < EXTENSION_API_MIN_VERSION || apiVersion > EXTENSION_API_VERSION) {
+        problems.push(`\`apiVersion\` must be between ${EXTENSION_API_MIN_VERSION} and ${EXTENSION_API_VERSION}.`);
+    }
+    const permissions = Array.isArray(manifest.permissions) ? manifest.permissions : null;
+    if (!permissions)
+        problems.push('`permissions` must be a list.');
+    else {
+        const unknown = permissions.filter((permission) => !EXTENSION_PERMISSIONS.includes(permission));
+        if (unknown.length > 0)
+            problems.push(`Unknown permissions: ${unknown.join(', ')}.`);
+        if (permissions.includes('network') && !(manifest.allowedHosts?.length))
+            problems.push('`network` needs at least one entry in `allowedHosts`.');
+    }
+    const surfaces = manifest.surfaces ?? [];
+    if (!Array.isArray(surfaces))
+        problems.push('`surfaces` must be a list.');
+    else
+        problems.push(...surfaceProblems(surfaces, apiVersion));
+    if (manifest.platforms !== undefined) {
+        if (apiVersion < 3)
+            problems.push('`platforms` needs `apiVersion` 3.');
+        if (!Array.isArray(manifest.platforms) || manifest.platforms.length === 0 || manifest.platforms.some((platform) => !EXTENSION_PLATFORMS.includes(platform))) {
+            problems.push(`\`platforms\` must list some of: ${EXTENSION_PLATFORMS.join(', ')}.`);
+        }
+    }
+    problems.push(...helperProblems(manifest, apiVersion), ...agentProblems(manifest, apiVersion));
+    const hasSurfaces = Array.isArray(surfaces) && surfaces.length > 0;
+    const hasHelper = manifest.helper !== undefined;
+    // From version 4 a guide for the agent is enough on its own.
+    const hasAgent = apiVersion >= 4 && manifest.agent !== undefined;
+    if (!Array.isArray(manifest.commands))
+        problems.push('`commands` must be a list.');
+    else if (manifest.commands.length === 0 && !hasSurfaces && !hasHelper && !hasAgent && !options.official)
+        problems.push('At least one command, page, helper or agent section is required.');
+    else {
+        const names = new Set();
+        for (const command of manifest.commands) {
+            if (!ID_PATTERN.test(command?.name ?? ''))
+                problems.push(`Command name "${String(command?.name)}" is invalid.`);
+            if (names.has(command.name))
+                problems.push(`Command "${command.name}" is listed twice.`);
+            names.add(command.name);
+            if (!EXTENSION_PLACEMENTS.includes(command.placement))
+                problems.push(`Command "${command.name}" has an unknown placement.`);
+            if (command.placement === 'agentTool' && !command.description)
+                problems.push(`Agent tool "${command.name}" needs a description.`);
+            problems.push(...inputProblems(command, apiVersion));
+        }
+    }
+    return problems;
+}
+// --- An extension's own page (kit version 2) -----------------------------
+//
+// The page runs in a sealed box inside Odyn's window. It talks to Odyn only by
+// posting messages to the box's parent; Odyn checks every call against the
+// permissions the user agreed to before doing anything.
+/** Every message between a page and Odyn carries this tag. */
+export const SURFACE_MESSAGE_TAG = 'odyn-surface';
+/** Every call a page can make, so Odyn can refuse anything else. */
+export const EXTENSION_SURFACE_METHODS = ['chatStorage.get', 'chatStorage.set', 'composer.attachImage', 'helper.call'];
+/** The most a page may keep for one chat, and the largest picture it may attach. */
+export const SURFACE_STORAGE_MAX_BYTES = 5_000_000;
+export const SURFACE_IMAGE_MAX_BYTES = 10_000_000;
+export function isSurfaceMessage(value) {
+    return typeof value === 'object' && value !== null && value.tag === SURFACE_MESSAGE_TAG;
+}
+/** The one call a page makes to start talking to Odyn. */
+export function connectSurface() {
+    const pending = new Map();
+    const contextListeners = new Set();
+    const imageListeners = new Set();
+    const helperListeners = new Set();
+    let latestContext = null;
+    let nextCallNumber = 0;
+    const post = (message) => window.parent.postMessage(message, '*');
+    window.addEventListener('message', (event) => {
+        if (event.source !== window.parent || !isSurfaceMessage(event.data))
+            return;
+        const message = event.data;
+        if (message.kind === 'context') {
+            latestContext = message.context;
+            contextListeners.forEach((listener) => listener(message.context));
+            return;
+        }
+        if (message.kind === 'image') {
+            imageListeners.forEach((listener) => listener(message.image));
+            return;
+        }
+        if (message.kind === 'helperMessage') {
+            helperListeners.forEach((listener) => listener(message.message));
+            return;
+        }
+        const call = pending.get(message.id);
+        if (!call)
+            return;
+        pending.delete(message.id);
+        if (message.ok)
+            call.resolve(message.value ?? null);
+        else
+            call.reject(new Error(message.error ?? 'Odyn refused the request.'));
+    });
+    const call = (method, ...args) => {
+        nextCallNumber += 1;
+        const id = `call-${nextCallNumber}`;
+        return new Promise((resolve, reject) => {
+            pending.set(id, { resolve: resolve, reject });
+            post({ tag: SURFACE_MESSAGE_TAG, kind: 'call', id, method, args });
+        });
+    };
+    post({ tag: SURFACE_MESSAGE_TAG, kind: 'ready' });
+    return {
+        onContext: (listener) => {
+            contextListeners.add(listener);
+            if (latestContext)
+                listener(latestContext);
+            return () => contextListeners.delete(listener);
+        },
+        onImage: (listener) => {
+            imageListeners.add(listener);
+            return () => imageListeners.delete(listener);
+        },
+        chatStorage: {
+            get: (chatId, key) => call('chatStorage.get', chatId, key),
+            set: (chatId, key, value) => call('chatStorage.set', chatId, key, value),
+        },
+        composer: {
+            attachImage: (image) => call('composer.attachImage', image),
+            close: () => post({ tag: SURFACE_MESSAGE_TAG, kind: 'close' }),
+        },
+        helper: {
+            call: (name, ...args) => call('helper.call', name, args),
+            onMessage: (listener) => {
+                helperListeners.add(listener);
+                return () => helperListeners.delete(listener);
+            },
+        },
+    };
+}
+// --- The background helper (kit version 3, official only) -----------------
+//
+// The helper runs in its own sealed box, like a command: no files, no
+// internet, no Node. Everything it does goes through Odyn, which checks the
+// manifest first: only listed programs run, only listed folders are looked
+// up, only listed links open, and downloads only reach listed hosts.
+/** Devices Odyn knows how to draw a live screen for. */
+export const SCREEN_SESSION_DEVICES = ['iphone', 'android'];
+/** Every call a helper can make, so Odyn can refuse anything else. */
+export const EXTENSION_HELPER_METHODS = [
+    'programs.find',
+    'programs.run',
+    'programs.launch',
+    'folders.find',
+    'data.path',
+    'data.download',
+    'data.remove',
+    'data.makeFolder',
+    'openLink',
+    'showToast',
+    'sessions.set',
+    'sessions.frame',
+    'pages.post',
+];
+/** The events Odyn sends a helper. */
+export const EXTENSION_HELPER_EVENTS = ['watch', 'unwatch', 'input', 'close', 'agentCommand', 'chatClosed', 'shutdown', 'pageCall'];
+/** The one call a helper's script makes. Anywhere but Odyn it just hands the definition back. */
+export function defineHelper(definition) {
+    const bridge = globalThis.__odynHelperBridge;
+    if (!bridge)
+        return definition;
+    const call = (method, ...args) => bridge.call(method, args);
+    const pageHandlers = new Map();
+    const odyn = {
+        programs: {
+            find: (name) => call('programs.find', name),
+            run: (name, args, options) => call('programs.run', name, args, options ?? null),
+            launch: (name, args, options) => call('programs.launch', name, args, options ?? null),
+        },
+        folders: { find: (name) => call('folders.find', name) },
+        data: {
+            path: () => call('data.path'),
+            download: (url, relativePath, integrity) => call('data.download', url, relativePath, integrity ?? null),
+            remove: (relativePath) => call('data.remove', relativePath),
+            makeFolder: (relativePath) => call('data.makeFolder', relativePath),
+        },
+        openLink: (url) => call('openLink', url),
+        showToast: (message) => call('showToast', message),
+        sessions: {
+            set: (sessions) => call('sessions.set', sessions),
+            frame: (sessionId, bytes, mimeType) => call('sessions.frame', sessionId, bytes, mimeType),
+        },
+        pages: {
+            handle: (name, handler) => {
+                pageHandlers.set(name, handler);
+            },
+            post: (message) => call('pages.post', message),
+        },
+    };
+    const settle = (replyId, work) => {
+        Promise.resolve()
+            .then(work)
+            .then((value) => {
+            if (replyId)
+                bridge.reply(replyId, { ok: true, value: value ?? null });
+        })
+            .catch((error) => {
+            if (replyId)
+                bridge.reply(replyId, { ok: false, error: errorText(error) });
+            else
+                console.error('[helper]', error);
+        });
+    };
+    bridge.onEvent((event, args, replyId) => {
+        if (event === 'pageCall') {
+            const [name, callArgs] = args;
+            const handler = typeof name === 'string' ? pageHandlers.get(name) : undefined;
+            settle(replyId, () => {
+                if (!handler)
+                    throw new Error(`The helper has nothing called "${String(name)}".`);
+                return handler(...(Array.isArray(callArgs) ? callArgs : []));
+            });
+            return;
+        }
+        const handler = definition[event];
+        settle(replyId, () => handler?.call(definition, ...args));
+    });
+    settle(null, () => definition.start(odyn));
+    return definition;
+}

package/dist/ui/button.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentProps, ReactElement } from 'react';
+import { type VariantProps } from 'class-variance-authority';
+/** The Odyn button styles, for use on other elements too. */
+export declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "link" | "outline" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ButtonProps = ComponentProps<'button'> & VariantProps<typeof buttonVariants>;
+/** A button in Odyn's style. Icon-only buttons need an `aria-label`. */
+export declare function Button({ className, variant, size, type, ...props }: ButtonProps): ReactElement;

package/dist/ui/button.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cva } from 'class-variance-authority';
+import { cn } from './cn';
+/** The Odyn button styles, for use on other elements too. */
+export const buttonVariants = cva("inline-flex shrink-0 select-none items-center justify-center gap-2 rounded-md text-sm font-medium whitespace-nowrap transition-[color,background-color,border-color,box-shadow,scale] duration-200 ease-out outline-none active:scale-[0.97] disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", {
+    variants: {
+        variant: {
+            default: 'bg-primary text-primary-foreground hover:bg-primary/90',
+            destructive: 'bg-destructive text-white hover:bg-destructive/90 dark:bg-destructive/60',
+            outline: 'border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50',
+            secondary: 'bg-secondary text-secondary-foreground hover:bg-secondary/80',
+            ghost: 'hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50',
+            link: 'text-primary underline-offset-4 hover:underline',
+        },
+        size: {
+            default: 'h-9 px-4 py-2 has-[>svg]:px-3',
+            xs: "h-6 gap-1 px-2 text-xs has-[>svg]:px-1.5 [&_svg:not([class*='size-'])]:size-3",
+            sm: 'h-8 gap-1.5 px-3 has-[>svg]:px-2.5',
+            lg: 'h-10 px-6 has-[>svg]:px-4',
+            icon: 'size-9',
+            'icon-xs': "size-6 [&_svg:not([class*='size-'])]:size-3",
+            'icon-sm': 'size-8',
+            'icon-lg': 'size-10',
+        },
+    },
+    defaultVariants: { variant: 'default', size: 'default' },
+});
+/** A button in Odyn's style. Icon-only buttons need an `aria-label`. */
+export function Button({ className, variant = 'default', size = 'default', type = 'button', ...props }) {
+    return (_jsx("button", { type: type, "data-slot": "button", "data-variant": variant, "data-size": size, className: cn(buttonVariants({ variant, size, className })), ...props }));
+}

package/dist/ui/cn.d.ts

@@ -0,0 +1,3 @@
+import { type ClassValue } from 'clsx';
+/** Joins class names, letting a later Tailwind class override an earlier one. */
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/ui/cn.js

@@ -0,0 +1,6 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+/** Joins class names, letting a later Tailwind class override an earlier one. */
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist/ui/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Ready-made pieces in Odyn's style for extension pages. Pair them with the
+ * theme: `@import "@odyn-app/api/theme.css";` in your page's stylesheet.
+ */
+export { Button, buttonVariants, type ButtonProps } from './button';
+export { cn } from './cn';
+export { Orb, type OrbProps, type OrbVariant } from './orb/orb';
+export { ORB_TASKS } from './orb/orb-types';
+export { SettingRow, type SettingRowProps } from './setting-row';
+export { Skeleton } from './skeleton';

package/dist/ui/index.js

@@ -0,0 +1,10 @@
+/**
+ * Ready-made pieces in Odyn's style for extension pages. Pair them with the
+ * theme: `@import "@odyn-app/api/theme.css";` in your page's stylesheet.
+ */
+export { Button, buttonVariants } from './button';
+export { cn } from './cn';
+export { Orb } from './orb/orb';
+export { ORB_TASKS } from './orb/orb-types';
+export { SettingRow } from './setting-row';
+export { Skeleton } from './skeleton';

package/dist/ui/orb/orb-base.module.css

@@ -0,0 +1,21 @@
+/* Shared stage and inherited animation tokens for every orb family. */
+.root {
+  --orb-ease-smooth: cubic-bezier(0.22, 1, 0.36, 1);
+  --orb-ease-out: cubic-bezier(0.17, 1, 0.32, 1);
+  --orb-ease-in-out: cubic-bezier(0.66, 0, 0.34, 1);
+
+  display: inline-flex;
+  align-items: center;
+  vertical-align: middle;
+  color: inherit;
+}
+
+.glyph {
+  position: relative;
+  display: block;
+  flex: none;
+  width: 20px;
+  height: 20px;
+  overflow: hidden;
+  contain: strict;
+}

package/dist/ui/orb/orb-geometry-cache.d.ts

@@ -0,0 +1 @@
+export declare function memoiseByVariant<Variant, Value>(build: (variant: Variant) => Value): (variant: Variant) => Value;

package/dist/ui/orb/orb-geometry-cache.js

@@ -0,0 +1,11 @@
+export function memoiseByVariant(build) {
+    const cache = new Map();
+    return (variant) => {
+        const cached = cache.get(variant);
+        if (cached !== undefined)
+            return cached;
+        const built = build(variant);
+        cache.set(variant, built);
+        return built;
+    };
+}

package/dist/ui/orb/orb-helix-geometry.d.ts

@@ -0,0 +1,7 @@
+import type { CSSProperties } from 'react';
+import type { HelixVariant } from './orb-types';
+export interface GlobeDot {
+    readonly key: number;
+    readonly style: CSSProperties;
+}
+export declare const globeDots: (variant: HelixVariant) => readonly GlobeDot[];