@xnetjs/plugins 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,2047 @@
+import * as _xnetjs_data from '@xnetjs/data';
+import { SchemaIRI, NodeStore, NodeState } from '@xnetjs/data';
+import { Extension } from '@tiptap/core';
+import { ComponentType } from 'react';
+
+/**
+ * Core types for the plugin system
+ */
+
+/**
+ * A resource that can be disposed/cleaned up
+ */
+interface Disposable$1 {
+    dispose(): void;
+}
+type Platform = 'web' | 'electron' | 'mobile';
+interface PluginPermissions {
+    schemas?: {
+        read?: SchemaIRI[] | '*';
+        write?: SchemaIRI[] | '*';
+        create?: SchemaIRI[];
+    };
+    capabilities?: {
+        /** Network access: true for all, or array of allowed domains */
+        network?: boolean | string[];
+        /** Storage scope: 'local' (plugin only) or 'shared' (visible to other plugins) */
+        storage?: 'local' | 'shared';
+        /** Clipboard access */
+        clipboard?: boolean;
+        /** System notifications */
+        notifications?: boolean;
+        /** Spawn child processes (Electron only) */
+        processes?: boolean;
+    };
+}
+interface PlatformCapabilities {
+    platform: Platform;
+    features: {
+        views: boolean;
+        editorExtensions: boolean;
+        slashCommands: boolean;
+        services: boolean;
+        processes: boolean;
+        localAPI: boolean;
+        filesystem: boolean;
+        clipboard: boolean;
+        notifications: boolean;
+        p2pSync: boolean;
+    };
+}
+declare function getPlatformCapabilities(platform: Platform): PlatformCapabilities;
+interface ExtensionStorage {
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T): void;
+    delete(key: string): void;
+    keys(): string[];
+}
+declare function createExtensionStorage(): ExtensionStorage;
+
+/**
+ * Contribution types and registry for plugin-provided extensions
+ */
+
+interface ViewContribution {
+    /** Unique view type identifier */
+    type: string;
+    /** Display name */
+    name: string;
+    /** Icon (Lucide icon name or component) */
+    icon?: string | ComponentType;
+    /** React component for rendering the view */
+    component: ComponentType<ViewProps>;
+    /** Schema IRIs this view supports (empty = all) */
+    supportedSchemas?: string[];
+}
+interface ViewProps {
+    nodeId: string;
+    schemaId: string;
+}
+interface CommandContribution {
+    /** Unique command ID */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Description for command palette */
+    description?: string;
+    /** Keyboard shortcut (e.g., 'Mod-Shift-P') */
+    keybinding?: string;
+    /** Search keywords for fuzzy matching */
+    keywords?: string[];
+    /** Icon (Lucide icon name) */
+    icon?: string;
+    /** Command handler */
+    execute: () => void | Promise<void>;
+    /** Whether command is currently enabled */
+    when?: () => boolean;
+}
+interface SlashCommandContribution {
+    /** Unique command ID */
+    id: string;
+    /** Display name in slash menu */
+    name: string;
+    /** Description shown in menu */
+    description?: string;
+    /** Search aliases */
+    aliases?: string[];
+    /** Icon (Lucide icon name) */
+    icon?: string;
+    /** Insert content or execute action */
+    execute: (props: SlashCommandContext) => void;
+}
+interface SlashCommandContext {
+    editor: unknown;
+    range: {
+        from: number;
+        to: number;
+    };
+}
+/**
+ * Toolbar button contribution for the editor
+ */
+interface ToolbarContribution {
+    /** Icon name (Lucide) or React component */
+    icon: string | ComponentType;
+    /** Tooltip/title text */
+    title: string;
+    /** Toolbar section: format, insert, block, or custom */
+    group?: 'format' | 'insert' | 'block' | 'custom';
+    /** Check if button should appear active */
+    isActive?: (editor: unknown) => boolean;
+    /** Button click handler */
+    action: (editor: unknown) => void;
+    /** Keyboard shortcut display (e.g., 'Mod-Shift-H') */
+    shortcut?: string;
+}
+interface EditorContribution {
+    /** Unique extension ID */
+    id: string;
+    /** TipTap extension (Extension, Node, or Mark) */
+    extension: Extension;
+    /** Optional toolbar button for this extension */
+    toolbar?: ToolbarContribution;
+    /** Priority for extension ordering (lower = earlier, default: 100) */
+    priority?: number;
+}
+interface SidebarContribution {
+    /** Unique item ID */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Icon (Lucide icon name or React component) */
+    icon: string | ComponentType;
+    /** Position in sidebar: top, bottom, or within a section */
+    position?: 'top' | 'bottom' | 'section';
+    /** Section name for 'section' position */
+    section?: string;
+    /** Priority within position (lower = higher) */
+    priority?: number;
+    /** Dynamic badge (e.g., unread count) */
+    badge?: () => string | number | null;
+    /** Click handler or route path */
+    action: (() => void) | string;
+    /** Optional panel component to render */
+    panel?: ComponentType;
+}
+interface PropertyHandlerContribution {
+    /** Property type this handler manages */
+    type: string;
+    /** Handler implementation */
+    handler: PropertyHandler;
+}
+interface PropertyHandler {
+    /** Render the property cell in table view */
+    Cell: ComponentType<PropertyCellProps>;
+    /** Render the property editor */
+    Editor: ComponentType<PropertyEditorProps>;
+    /** Parse string input to property value */
+    parse?: (input: string) => unknown;
+    /** Format value for display */
+    format?: (value: unknown) => string;
+    /** Validate value */
+    validate?: (value: unknown) => boolean;
+}
+interface PropertyCellProps {
+    value: unknown;
+    config?: Record<string, unknown>;
+}
+interface PropertyEditorProps {
+    value: unknown;
+    onChange: (value: unknown) => void;
+    config?: Record<string, unknown>;
+}
+interface BlockContribution {
+    /** Block type identifier */
+    type: string;
+    /** Display name */
+    name: string;
+    /** React component */
+    component: ComponentType<BlockProps>;
+}
+interface BlockProps {
+    node: unknown;
+    updateAttributes: (attrs: Record<string, unknown>) => void;
+}
+interface SettingContribution {
+    /** Setting section ID */
+    id: string;
+    /** Section title */
+    title: string;
+    /** Description for the settings panel */
+    description?: string;
+    /** Icon (Lucide icon name) */
+    icon?: string;
+    /** Which settings section this belongs to */
+    section?: 'general' | 'appearance' | 'plugins' | 'data' | 'network';
+    /** Settings panel component */
+    component: ComponentType<SettingsPanelProps>;
+}
+interface SettingsPanelProps {
+    /** Plugin's key-value storage */
+    storage: {
+        get: <T>(key: string) => T | undefined;
+        set: <T>(key: string, value: T) => void;
+        keys: () => string[];
+    };
+}
+interface SchemaContribution {
+    /** The schema definition */
+    schema: unknown;
+}
+/**
+ * A registry for typed contributions with change notifications
+ */
+declare class TypedRegistry<T extends {
+    id?: string;
+    type?: string;
+}> {
+    private items;
+    private listeners;
+    register(item: T): Disposable$1;
+    unregister(key: string): boolean;
+    get(key: string): T | undefined;
+    getAll(): T[];
+    has(key: string): boolean;
+    get size(): number;
+    onChange(listener: () => void): () => void;
+    private notify;
+    clear(): void;
+}
+/**
+ * Central registry for all plugin contributions
+ */
+declare class ContributionRegistry {
+    readonly views: TypedRegistry<ViewContribution>;
+    readonly commands: TypedRegistry<CommandContribution>;
+    readonly slashCommands: TypedRegistry<SlashCommandContribution>;
+    readonly sidebar: TypedRegistry<SidebarContribution>;
+    readonly editor: TypedRegistry<EditorContribution>;
+    readonly propertyHandlers: TypedRegistry<PropertyHandlerContribution>;
+    readonly blocks: TypedRegistry<BlockContribution>;
+    readonly settings: TypedRegistry<SettingContribution>;
+    /**
+     * Clear all registries (for cleanup/testing)
+     */
+    clear(): void;
+}
+
+/**
+ * NodeStore middleware chain for pre/post change hooks
+ */
+
+interface PendingChange {
+    type: 'create' | 'update' | 'delete' | 'restore';
+    nodeId: string;
+    schemaIRI?: string;
+    payload?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+}
+interface NodeChangeEvent {
+    change: PendingChange;
+    node: unknown;
+    isRemote: boolean;
+}
+interface NodeStoreMiddleware {
+    /** Unique middleware ID */
+    id: string;
+    /** Priority (lower = runs first, default 100) */
+    priority?: number;
+    /**
+     * Called before a change is applied.
+     * Can modify the change, reject by throwing, or pass through.
+     */
+    beforeChange?(change: PendingChange, next: () => Promise<unknown>): Promise<unknown>;
+    /**
+     * Called after a change is applied (observe only, cannot modify).
+     */
+    afterChange?(event: NodeChangeEvent): void;
+}
+/**
+ * Manages a chain of middleware for NodeStore operations
+ */
+declare class MiddlewareChain {
+    private middlewares;
+    /**
+     * Add a middleware to the chain
+     */
+    add(middleware: NodeStoreMiddleware): Disposable$1;
+    /**
+     * Remove a middleware by ID
+     */
+    remove(id: string): boolean;
+    /**
+     * Get all registered middlewares
+     */
+    getAll(): NodeStoreMiddleware[];
+    /**
+     * Execute beforeChange hooks in priority order
+     */
+    executeBefore(change: PendingChange, apply: () => Promise<unknown>): Promise<unknown>;
+    /**
+     * Execute afterChange hooks (errors are caught and logged)
+     */
+    executeAfter(event: NodeChangeEvent): void;
+    /**
+     * Clear all middlewares
+     */
+    clear(): void;
+    /**
+     * Get the number of registered middlewares
+     */
+    get size(): number;
+}
+
+/**
+ * ExtensionContext - The API surface available to plugins
+ */
+
+interface PluginNodeChangeEvent {
+    type: 'create' | 'update' | 'delete';
+    nodeId: string;
+    node?: NodeState;
+    changes?: Record<string, {
+        old: unknown;
+        new: unknown;
+    }>;
+}
+type PluginNodeChangeListener = (event: PluginNodeChangeEvent) => void;
+interface QueryFilter {
+    where?: Record<string, unknown>;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Context provided to plugins during activation.
+ * All registration methods return Disposables that are auto-disposed on deactivation.
+ */
+interface ExtensionContext {
+    /** Plugin ID */
+    readonly pluginId: string;
+    /** Current platform */
+    readonly platform: Platform;
+    /** NodeStore instance */
+    readonly store: NodeStore;
+    /** Query nodes by schema (async) */
+    query(schema: SchemaIRI, filter?: QueryFilter): Promise<NodeState[]>;
+    /** Subscribe to node changes */
+    subscribe(schema: SchemaIRI | null, callback: PluginNodeChangeListener): Disposable$1;
+    /** Register a custom schema */
+    registerSchema(schema: unknown): Disposable$1;
+    /** Register a custom view type */
+    registerView(view: ViewContribution): Disposable$1;
+    /** Register a property type handler */
+    registerPropertyHandler(type: string, handler: PropertyHandlerContribution['handler']): Disposable$1;
+    /** Register a command */
+    registerCommand(command: CommandContribution): Disposable$1;
+    /** Register a sidebar item */
+    registerSidebarItem(item: SidebarContribution): Disposable$1;
+    /** Register a TipTap editor extension */
+    registerEditorExtension(ext: EditorContribution): Disposable$1;
+    /** Register a slash command */
+    registerSlashCommand(cmd: SlashCommandContribution): Disposable$1;
+    /** Register a custom block type */
+    registerBlockType(block: BlockContribution): Disposable$1;
+    /** Add middleware to NodeStore */
+    addMiddleware(middleware: NodeStoreMiddleware): Disposable$1;
+    /** Plugin-private storage */
+    readonly storage: ExtensionStorage;
+    /** Platform capabilities */
+    readonly capabilities: PlatformCapabilities;
+    /** Auto-cleanup list - disposed when plugin deactivates */
+    readonly subscriptions: Disposable$1[];
+}
+interface CreateContextOptions {
+    pluginId: string;
+    store: NodeStore;
+    contributions: ContributionRegistry;
+    platform: Platform;
+    middlewareChain?: {
+        add(middleware: NodeStoreMiddleware): Disposable$1;
+    };
+}
+/**
+ * Create an ExtensionContext for a plugin
+ */
+declare function createExtensionContext(options: CreateContextOptions): ExtensionContext;
+
+/**
+ * Plugin manifest types and validation
+ */
+
+/**
+ * Plugin manifest - defines what a plugin provides and how it integrates
+ */
+interface XNetExtension {
+    /** Unique plugin ID (reverse-domain format: 'com.example.my-plugin') */
+    id: string;
+    /** Human-readable plugin name */
+    name: string;
+    /** Semantic version */
+    version: string;
+    /** Plugin description */
+    description?: string;
+    /** Author name or organization */
+    author?: string;
+    /** Minimum compatible xNet version */
+    xnetVersion?: string;
+    /** Platforms this plugin supports (default: all) */
+    platforms?: Platform[];
+    /** Permission declarations */
+    permissions?: PluginPermissions;
+    /** Static contributions declared in manifest */
+    contributes?: PluginContributions;
+    /** Called when plugin is activated */
+    activate?(ctx: ExtensionContext): void | Promise<void>;
+    /** Called when plugin is deactivated */
+    deactivate?(): void | Promise<void>;
+}
+/**
+ * Contributions a plugin can declare
+ */
+interface PluginContributions {
+    schemas?: SchemaContribution[];
+    views?: ViewContribution[];
+    editorExtensions?: EditorContribution[];
+    propertyHandlers?: PropertyHandlerContribution[];
+    blocks?: BlockContribution[];
+    commands?: CommandContribution[];
+    settings?: SettingContribution[];
+    sidebarItems?: SidebarContribution[];
+    slashCommands?: SlashCommandContribution[];
+}
+declare class PluginValidationError extends Error {
+    readonly issues: string[];
+    constructor(message: string, issues: string[]);
+}
+/**
+ * Validate a plugin manifest
+ * @throws PluginValidationError if validation fails
+ */
+declare function validateManifest(manifest: unknown): XNetExtension;
+/**
+ * Define a plugin extension with type checking
+ */
+declare function defineExtension(manifest: XNetExtension): XNetExtension;
+
+/**
+ * Keyboard Shortcut Manager
+ *
+ * Handles registration and execution of keyboard shortcuts from plugins.
+ */
+
+/**
+ * Manages keyboard shortcuts for commands.
+ *
+ * Shortcuts are specified in the format: "Mod-Shift-K" where:
+ * - Mod = Cmd on Mac, Ctrl elsewhere
+ * - Shift, Alt, Ctrl, Meta are modifier keys
+ * - The last part is the key name (e.g., K, Enter, Escape)
+ *
+ * @example
+ * ```typescript
+ * const manager = new ShortcutManager()
+ *
+ * manager.register({
+ *   id: 'my-command',
+ *   name: 'My Command',
+ *   keybinding: 'Mod-Shift-P',
+ *   execute: () => console.log('Executed!')
+ * })
+ *
+ * // Attach to window
+ * window.addEventListener('keydown', (e) => manager.handleKeyDown(e))
+ * ```
+ */
+declare class ShortcutManager {
+    private shortcuts;
+    private enabled;
+    /**
+     * Register a command with a keyboard shortcut.
+     *
+     * @param command - Command with keybinding
+     * @returns Disposable to unregister the shortcut
+     */
+    register(command: CommandContribution): Disposable$1;
+    /**
+     * Unregister a command by ID.
+     */
+    unregister(commandId: string): boolean;
+    /**
+     * Handle a keyboard event.
+     *
+     * @param event - Keyboard event
+     * @returns True if a shortcut was triggered
+     */
+    handleKeyDown(event: KeyboardEvent): boolean;
+    /**
+     * Enable or disable shortcut handling.
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Check if shortcuts are enabled.
+     */
+    isEnabled(): boolean;
+    /**
+     * Get all registered shortcuts.
+     */
+    getAll(): CommandContribution[];
+    /**
+     * Get the shortcut for a command ID.
+     */
+    getShortcut(commandId: string): string | undefined;
+    /**
+     * Format a keybinding for display (using platform-specific symbols).
+     */
+    formatForDisplay(keybinding: string): string;
+    /**
+     * Normalize a keybinding string for consistent lookup.
+     */
+    private normalize;
+    /**
+     * Convert normalized form back to display form.
+     */
+    private denormalize;
+    /**
+     * Convert a keyboard event to a normalized string.
+     */
+    private eventToString;
+    /**
+     * Clear all registered shortcuts.
+     */
+    clear(): void;
+}
+/**
+ * Get or create the global ShortcutManager instance.
+ */
+declare function getShortcutManager(): ShortcutManager;
+/**
+ * Install the global shortcut manager on the window.
+ * Call this once at app startup.
+ */
+declare function installShortcutHandler(): () => void;
+
+/**
+ * PluginRegistry - Central coordinator for plugin lifecycle
+ */
+
+type PluginStatus = 'installed' | 'active' | 'disabled' | 'error';
+interface RegisteredPlugin {
+    manifest: XNetExtension;
+    status: PluginStatus;
+    context?: ExtensionContext;
+    error?: Error;
+}
+declare class PluginError extends Error {
+    constructor(message: string);
+}
+/**
+ * Manages plugin lifecycle: install, activate, deactivate, uninstall
+ */
+declare class PluginRegistry {
+    private store;
+    private platform;
+    private plugins;
+    private contributions;
+    private middleware;
+    private listeners;
+    constructor(store: NodeStore, platform: Platform);
+    /**
+     * Install and activate a plugin
+     */
+    install(manifest: XNetExtension): Promise<void>;
+    /**
+     * Activate an installed plugin
+     */
+    activate(pluginId: string): Promise<void>;
+    /**
+     * Deactivate an active plugin
+     */
+    deactivate(pluginId: string): Promise<void>;
+    /**
+     * Uninstall a plugin (deactivates first if active)
+     */
+    uninstall(pluginId: string): Promise<void>;
+    /**
+     * Get all registered plugins
+     */
+    getAll(): RegisteredPlugin[];
+    /**
+     * Get a specific plugin
+     */
+    get(pluginId: string): RegisteredPlugin | undefined;
+    /**
+     * Check if a plugin is installed
+     */
+    has(pluginId: string): boolean;
+    /**
+     * Rehydrate a plugin loaded from store with a live manifest.
+     *
+     * When plugins are persisted via `install()`, the manifest is serialized
+     * with `JSON.stringify()`, which strips non-serializable values like
+     * TipTap Extension instances, React components, and functions. When
+     * `loadFromStore()` deserializes with `JSON.parse()`, these values are
+     * lost and the plugin's contributions (e.g., editor extensions) are broken.
+     *
+     * For bundled plugins, the `BundledPluginInstaller` has access to the live
+     * manifest objects. This method replaces the deserialized manifest with the
+     * live one and re-registers its static contributions so that extension
+     * objects with methods (like `renderHTML`, `addNodeView`) are properly
+     * available to the editor.
+     */
+    rehydrate(liveManifest: XNetExtension): Promise<void>;
+    /**
+     * Get contribution registry
+     */
+    getContributions(): ContributionRegistry;
+    /**
+     * Get middleware chain
+     */
+    getMiddleware(): MiddlewareChain;
+    /**
+     * Subscribe to plugin changes
+     */
+    onChange(listener: () => void): Disposable$1;
+    private notify;
+    private registerStaticContributions;
+    /**
+     * Load and activate plugins from stored Nodes
+     */
+    loadFromStore(): Promise<void>;
+}
+
+/**
+ * Plugin schema - stores plugin metadata as Nodes for P2P sync
+ */
+declare const PluginSchema: _xnetjs_data.DefinedSchema<{
+    /** Unique plugin identifier (reverse-domain format) */
+    pluginId: _xnetjs_data.PropertyBuilder<string>;
+    /** Human-readable name */
+    name: _xnetjs_data.PropertyBuilder<string>;
+    /** Semantic version */
+    version: _xnetjs_data.PropertyBuilder<string>;
+    /** Plugin description */
+    description: _xnetjs_data.PropertyBuilder<string>;
+    /** Author name or organization */
+    author: _xnetjs_data.PropertyBuilder<string>;
+    /** Whether plugin is enabled */
+    enabled: _xnetjs_data.PropertyBuilder<boolean>;
+    /** JSON-serialized manifest */
+    manifest: _xnetjs_data.PropertyBuilder<string>;
+    /** Plugin source (URL or inline bundle) */
+    source: _xnetjs_data.PropertyBuilder<string>;
+    /** JSON-serialized permissions */
+    permissions: _xnetjs_data.PropertyBuilder<string>;
+    /** Installation timestamp */
+    installedAt: _xnetjs_data.PropertyBuilder<number>;
+}>;
+type PluginNode = {
+    id: string;
+    schemaId: string;
+    pluginId: string;
+    name: string;
+    version: string;
+    description?: string;
+    author?: string;
+    enabled: boolean;
+    manifest: string;
+    source?: string;
+    permissions?: string;
+    installedAt?: number;
+};
+
+/**
+ * Script schema - stores user-created scripts as Nodes for P2P sync
+ *
+ * Scripts are the simplest plugin type (Layer 1) - single functions that
+ * transform or react to data. They run in a sandboxed environment with
+ * no network, DOM, or import access.
+ */
+/**
+ * Script trigger types:
+ * - manual: Run via UI button or command
+ * - onChange: Run when a node matching inputSchema changes
+ * - onView: Run when computing a column value (lazy evaluation)
+ * - scheduled: Run on a cron schedule (future)
+ */
+type ScriptTriggerType = 'manual' | 'onChange' | 'onView' | 'scheduled';
+/**
+ * Script output types:
+ * - value: Returns a computed value (for computed columns)
+ * - mutation: Returns partial node to merge into target
+ * - decoration: Returns visual decorations/tags
+ * - void: Side-effect only (logging, etc.)
+ */
+type ScriptOutputType = 'value' | 'mutation' | 'decoration' | 'void';
+/**
+ * Script schema for user-created scripts.
+ *
+ * Scripts are stored as Nodes and sync via P2P like any other data.
+ * They can be created manually, via AI generation, or imported.
+ *
+ * @example
+ * ```typescript
+ * // Create a tax calculator script
+ * await store.create(ScriptSchema, {
+ *   name: 'Calculate Tax',
+ *   description: 'Adds 8% tax to subtotal',
+ *   code: '(node) => node.subtotal * 0.08',
+ *   triggerType: 'onView',
+ *   outputType: 'value',
+ *   inputSchema: 'xnet://myapp/Invoice',
+ *   enabled: true
+ * })
+ * ```
+ */
+declare const ScriptSchema: _xnetjs_data.DefinedSchema<{
+    /** Human-readable script name */
+    name: _xnetjs_data.PropertyBuilder<string>;
+    /** Description of what the script does */
+    description: _xnetjs_data.PropertyBuilder<string>;
+    /** The script code (JavaScript expression or arrow function) */
+    code: _xnetjs_data.PropertyBuilder<string>;
+    /** When the script should execute */
+    triggerType: _xnetjs_data.PropertyBuilder<"manual" | "onChange" | "onView" | "scheduled">;
+    /** For onChange trigger: which property to watch (empty = any) */
+    triggerProperty: _xnetjs_data.PropertyBuilder<string>;
+    /** For scheduled trigger: cron expression */
+    triggerCron: _xnetjs_data.PropertyBuilder<string>;
+    /** Schema IRI this script operates on (e.g., 'xnet://myapp/Task') */
+    inputSchema: _xnetjs_data.PropertyBuilder<string>;
+    /** What the script returns */
+    outputType: _xnetjs_data.PropertyBuilder<"value" | "mutation" | "decoration" | "void">;
+    /** Whether the script is active */
+    enabled: _xnetjs_data.PropertyBuilder<boolean>;
+    /** Last execution error message (null if last run succeeded) */
+    lastError: _xnetjs_data.PropertyBuilder<string>;
+    /** Timestamp of last execution */
+    lastRun: _xnetjs_data.PropertyBuilder<number>;
+}>;
+/**
+ * Type-safe representation of a Script node
+ */
+interface ScriptNode {
+    id: string;
+    schemaId: string;
+    name: string;
+    description?: string;
+    code: string;
+    triggerType: ScriptTriggerType;
+    triggerProperty?: string;
+    triggerCron?: string;
+    inputSchema?: string;
+    outputType: ScriptOutputType;
+    enabled: boolean;
+    lastError?: string;
+    lastRun?: number;
+}
+/**
+ * Type guard to check if a node is a Script
+ */
+declare function isScriptNode(node: unknown): node is ScriptNode;
+
+/**
+ * ScriptContext - Safe API surface for user scripts
+ *
+ * Provides a frozen, read-only context with utility functions.
+ * Scripts cannot modify nodes directly - they return values/mutations
+ * that the runtime applies.
+ */
+/**
+ * A flat node representation (simplified for script access)
+ */
+interface FlatNode {
+    id: string;
+    schemaIRI: string;
+    [key: string]: unknown;
+}
+/**
+ * Format helper functions (no side effects)
+ */
+interface FormatHelpers {
+    /** Format a timestamp as a date string */
+    date: (timestamp: number, options?: Intl.DateTimeFormatOptions) => string;
+    /** Format a number with options */
+    number: (value: number, options?: Intl.NumberFormatOptions) => string;
+    /** Format a number as currency */
+    currency: (value: number, currency?: string, locale?: string) => string;
+    /** Format a timestamp as relative time (e.g., "5m ago") */
+    relative: (timestamp: number) => string;
+    /** Format bytes as human-readable size */
+    bytes: (bytes: number) => string;
+}
+/**
+ * Math helper functions (pure functions)
+ */
+interface MathHelpers {
+    /** Sum an array of numbers */
+    sum: (values: number[]) => number;
+    /** Average of an array of numbers */
+    avg: (values: number[]) => number;
+    /** Minimum value */
+    min: (values: number[]) => number;
+    /** Maximum value */
+    max: (values: number[]) => number;
+    /** Round to decimal places */
+    round: (value: number, decimals?: number) => number;
+    /** Clamp value between min and max */
+    clamp: (value: number, min: number, max: number) => number;
+    /** Absolute value */
+    abs: (value: number) => number;
+    /** Floor */
+    floor: (value: number) => number;
+    /** Ceiling */
+    ceil: (value: number) => number;
+}
+/**
+ * Text helper functions (pure functions)
+ */
+interface TextHelpers {
+    /** Convert to URL-safe slug */
+    slugify: (text: string) => string;
+    /** Truncate with ellipsis */
+    truncate: (text: string, maxLength: number) => string;
+    /** Capitalize first letter */
+    capitalize: (text: string) => string;
+    /** Title case */
+    titleCase: (text: string) => string;
+    /** Check if text contains search (case-insensitive) */
+    contains: (text: string, search: string) => boolean;
+    /** Simple template substitution: {key} replaced by vars[key] */
+    template: (template: string, vars: Record<string, unknown>) => string;
+    /** Trim whitespace */
+    trim: (text: string) => string;
+    /** Convert to lowercase */
+    lower: (text: string) => string;
+    /** Convert to uppercase */
+    upper: (text: string) => string;
+}
+/**
+ * Array helper functions (pure functions)
+ */
+interface ArrayHelpers {
+    /** Get first element */
+    first: <T>(items: T[]) => T | undefined;
+    /** Get last element */
+    last: <T>(items: T[]) => T | undefined;
+    /** Sort by property */
+    sortBy: <T>(items: T[], key: keyof T, desc?: boolean) => T[];
+    /** Group by property */
+    groupBy: <T>(items: T[], key: keyof T) => Record<string, T[]>;
+    /** Unique values */
+    unique: <T>(items: T[]) => T[];
+    /** Count items */
+    count: <T>(items: T[]) => number;
+    /** Filter truthy */
+    compact: <T>(items: (T | null | undefined)[]) => T[];
+}
+/**
+ * The context object passed to scripts.
+ * All properties and nested objects are frozen (immutable).
+ */
+interface ScriptContext {
+    /** The current node being processed (read-only, frozen) */
+    node: Readonly<FlatNode>;
+    /**
+     * Query sibling nodes by schema.
+     * Returns a frozen array of frozen nodes.
+     */
+    nodes: (schemaIRI?: string) => ReadonlyArray<Readonly<FlatNode>>;
+    /** Current timestamp in milliseconds */
+    now: () => number;
+    /** Format helpers */
+    format: Readonly<FormatHelpers>;
+    /** Math helpers */
+    math: Readonly<MathHelpers>;
+    /** Text helpers */
+    text: Readonly<TextHelpers>;
+    /** Array helpers */
+    array: Readonly<ArrayHelpers>;
+}
+/**
+ * Create a frozen ScriptContext for sandbox execution.
+ *
+ * @param node - The current node being processed
+ * @param queryFn - Function to query other nodes by schema
+ * @returns A frozen ScriptContext
+ *
+ * @example
+ * ```typescript
+ * const context = createScriptContext(
+ *   targetNode,
+ *   (schema) => store.list({ schemaIRI: schema })
+ * )
+ *
+ * const result = await sandbox.execute(code, context)
+ * ```
+ */
+declare function createScriptContext(node: FlatNode, queryFn: (schemaIRI?: string) => FlatNode[]): ScriptContext;
+
+/**
+ * AST Validator - Security checks for user scripts
+ *
+ * Parses JavaScript code and validates against forbidden patterns
+ * to ensure scripts cannot escape the sandbox.
+ */
+interface ValidationResult {
+    /** Whether the script passed validation */
+    valid: boolean;
+    /** List of validation errors (empty if valid) */
+    errors: string[];
+}
+/**
+ * Validate a script's AST for forbidden patterns.
+ *
+ * Checks for:
+ * - Forbidden global variable access
+ * - Import/export statements
+ * - Dynamic import()
+ * - Async/await (scripts must be synchronous)
+ * - new Function() constructor
+ * - Forbidden property access (__proto__, constructor, etc.)
+ * - with statements
+ * - eval calls
+ *
+ * @param code - JavaScript code to validate
+ * @returns Validation result with errors if any
+ *
+ * @example
+ * ```typescript
+ * const result = validateScriptAST('(node) => node.amount * 1.08')
+ * if (!result.valid) {
+ *   console.error('Invalid script:', result.errors)
+ * }
+ * ```
+ */
+declare function validateScriptAST(code: string): ValidationResult;
+/**
+ * Quick check if code is likely safe (doesn't do full AST parse).
+ * Use this for fast rejection before full validation.
+ */
+declare function quickSafetyCheck(code: string): boolean;
+
+/**
+ * ScriptSandbox - Isolated execution environment for user scripts
+ *
+ * Executes scripts with:
+ * - AST validation before execution
+ * - Timeout protection
+ * - Global shadowing to prevent escape
+ * - Output sanitization
+ */
+
+/**
+ * Duck-typed telemetry interface to avoid circular dependencies.
+ */
+interface TelemetryReporter {
+    reportPerformance(metricName: string, durationMs: number): void;
+    reportUsage(metricName: string, count: number): void;
+    reportCrash(error: Error, context?: Record<string, unknown>): void;
+}
+interface SandboxOptions {
+    /** Maximum execution time in milliseconds (default: 1000) */
+    timeoutMs?: number;
+    /** Whether to run AST validation (default: true) */
+    validateAST?: boolean;
+    /** Optional telemetry reporter */
+    telemetry?: TelemetryReporter;
+}
+/**
+ * Error thrown when a script fails validation or execution
+ */
+declare class ScriptError extends Error {
+    details: string[];
+    constructor(message: string, details: string[]);
+}
+/**
+ * Error thrown when a script times out
+ */
+declare class ScriptTimeoutError extends ScriptError {
+    constructor(timeoutMs: number);
+}
+/**
+ * Error thrown when a script fails AST validation
+ */
+declare class ScriptValidationError extends ScriptError {
+    constructor(errors: string[]);
+}
+/**
+ * Sandbox for executing user scripts safely.
+ *
+ * Scripts are validated via AST analysis and executed in an environment
+ * where dangerous globals are shadowed to undefined.
+ *
+ * @example
+ * ```typescript
+ * const sandbox = new ScriptSandbox({ timeoutMs: 500 })
+ *
+ * const context = createScriptContext(node, queryFn)
+ * const result = await sandbox.execute('(node) => node.amount * 1.08', context)
+ * ```
+ */
+declare class ScriptSandbox {
+    private options;
+    constructor(options?: SandboxOptions);
+    /**
+     * Execute a script in the sandbox.
+     *
+     * @param code - JavaScript code (expression or arrow function)
+     * @param context - The frozen ScriptContext
+     * @returns The script's return value (sanitized)
+     * @throws ScriptValidationError if AST validation fails
+     * @throws ScriptTimeoutError if execution exceeds timeout
+     * @throws ScriptError for other execution errors
+     */
+    execute(code: string, context: ScriptContext): Promise<unknown>;
+    /**
+     * Execute a script synchronously (for computed columns).
+     * Use with caution - no timeout protection in sync mode.
+     */
+    executeSync(code: string, context: ScriptContext): unknown;
+    /**
+     * Create an isolated function from user code.
+     *
+     * The function receives context values as arguments and has dangerous
+     * globals shadowed to undefined in its scope.
+     */
+    private createIsolatedFunction;
+    /**
+     * Execute a function with a timeout.
+     */
+    private executeWithTimeout;
+    /**
+     * Sanitize script output to ensure only safe values are returned.
+     *
+     * Allowed types: null, undefined, string, number, boolean, plain objects, arrays
+     * Stripped: functions, symbols, circular references, dunder properties
+     */
+    private sanitizeOutput;
+}
+/**
+ * Quick execution with default options.
+ */
+declare function executeScript(code: string, context: ScriptContext): Promise<unknown>;
+/**
+ * Validate script code without executing.
+ */
+declare function validateScript(code: string): {
+    valid: boolean;
+    errors: string[];
+};
+
+/**
+ * ScriptRunner - Reactive script execution system
+ *
+ * Manages script lifecycle:
+ * - Registers scripts based on their trigger type
+ * - Executes scripts when triggers fire
+ * - Handles errors gracefully
+ * - Updates script status (lastRun, lastError)
+ */
+
+/**
+ * Minimal store interface for the script runner.
+ * This avoids a hard dependency on @xnetjs/data.
+ */
+interface ScriptStore {
+    /** List nodes matching a query */
+    list(query: {
+        schemaIRI?: string;
+    }): FlatNode[];
+    /** Update a node by ID */
+    update(id: string, payload: Partial<Record<string, unknown>>): Promise<void> | void;
+    /** Subscribe to node changes */
+    subscribe(callback: (event: ScriptNodeChangeEvent) => void): () => void;
+}
+interface ScriptNodeChangeEvent {
+    type: 'create' | 'update' | 'delete';
+    node?: FlatNode;
+    change: {
+        payload?: Record<string, unknown>;
+    };
+}
+interface ScriptRunnerOptions {
+    /** Store instance */
+    store: ScriptStore;
+    /** Sandbox options */
+    sandboxOptions?: {
+        timeoutMs?: number;
+        validateAST?: boolean;
+    };
+    /** Optional telemetry reporter */
+    telemetry?: TelemetryReporter;
+}
+interface ScriptExecutionResult {
+    /** Whether execution succeeded */
+    success: boolean;
+    /** The script's return value (if successful) */
+    result?: unknown;
+    /** Error message (if failed) */
+    error?: string;
+    /** Execution time in milliseconds */
+    durationMs: number;
+}
+/**
+ * Manages reactive script execution.
+ *
+ * @example
+ * ```typescript
+ * const runner = new ScriptRunner({ store })
+ *
+ * // Start listening for triggers
+ * await runner.start()
+ *
+ * // Execute a script manually
+ * const result = await runner.executeManual(code, targetNode)
+ *
+ * // Stop all listeners
+ * runner.stop()
+ * ```
+ */
+declare class ScriptRunner {
+    private sandbox;
+    private store;
+    private subscriptions;
+    private scriptSubscriptions;
+    private started;
+    private telemetry?;
+    constructor(options: ScriptRunnerOptions);
+    /**
+     * Start the script runner.
+     * Registers all enabled scripts and sets up triggers.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the script runner.
+     * Removes all triggers and subscriptions.
+     */
+    stop(): void;
+    /**
+     * Execute a script manually for testing/preview.
+     * Does not update lastRun/lastError on the script node.
+     */
+    executeManual(code: string, node: FlatNode): Promise<ScriptExecutionResult>;
+    /**
+     * Execute a script as a computed value (synchronous).
+     * Used for computed columns in table views.
+     */
+    computeValue(code: string, node: FlatNode): unknown;
+    /**
+     * Register a script and set up its trigger.
+     */
+    private registerScript;
+    /**
+     * Unregister a script's trigger.
+     */
+    private unregisterScript;
+    /**
+     * Register an onChange trigger for a script.
+     */
+    private registerOnChangeTrigger;
+    /**
+     * Execute a script and handle results.
+     */
+    private executeScript;
+    /**
+     * Handle changes to script nodes.
+     */
+    private handleScriptChange;
+}
+
+/**
+ * AI Prompt Builder for Script Generation
+ *
+ * Creates structured prompts that guide AI models to generate
+ * valid, sandboxed scripts for xNet.
+ */
+
+/**
+ * Schema property definition (simplified for prompt building)
+ */
+interface SchemaProperty {
+    name: string;
+    type: string;
+    required?: boolean;
+    description?: string;
+}
+/**
+ * Schema definition for prompt context
+ */
+interface SchemaDefinition {
+    name: string;
+    schemaIRI: string;
+    properties: SchemaProperty[];
+}
+/**
+ * Request for AI script generation
+ */
+interface AIScriptRequest {
+    /** Natural language description of what the script should do */
+    intent: string;
+    /** Schema definition with available fields */
+    schema: SchemaDefinition;
+    /** Expected output type */
+    outputType: ScriptOutputType;
+    /** Suggested trigger type */
+    triggerType?: ScriptTriggerType;
+    /** Sample data nodes for context */
+    examples?: FlatNode[];
+    /** Additional constraints or requirements */
+    constraints?: string[];
+}
+/**
+ * Build a complete prompt for AI script generation.
+ *
+ * @param request - The script generation request
+ * @returns Complete prompt string for the AI model
+ *
+ * @example
+ * ```typescript
+ * const prompt = buildScriptPrompt({
+ *   intent: 'Calculate total with 8% tax',
+ *   schema: {
+ *     name: 'Invoice',
+ *     schemaIRI: 'xnet://myapp/Invoice',
+ *     properties: [
+ *       { name: 'subtotal', type: 'number', required: true },
+ *       { name: 'taxRate', type: 'number' }
+ *     ]
+ *   },
+ *   outputType: 'value'
+ * })
+ * ```
+ */
+declare function buildScriptPrompt(request: AIScriptRequest): string;
+/**
+ * Build a retry prompt when the first attempt fails validation.
+ *
+ * @param originalPrompt - The original prompt
+ * @param errors - Validation errors from the first attempt
+ * @returns Updated prompt with error feedback
+ */
+declare function buildRetryPrompt(originalPrompt: string, errors: string[]): string;
+
+/**
+ * AI Provider Abstraction
+ *
+ * Defines a common interface for AI providers and includes
+ * implementations for Anthropic, OpenAI, and local (Ollama).
+ */
+/**
+ * Common interface for AI text generation providers
+ */
+interface AIProvider {
+    /** Provider name for display/logging */
+    readonly name: string;
+    /**
+     * Generate text from a prompt.
+     *
+     * @param prompt - The input prompt
+     * @returns Generated text response
+     * @throws Error if generation fails
+     */
+    generate(prompt: string): Promise<string>;
+}
+/**
+ * Options for configuring AI providers
+ */
+interface AIProviderOptions {
+    /** API key (for cloud providers) */
+    apiKey?: string;
+    /** Base URL (for self-hosted or proxy) */
+    baseUrl?: string;
+    /** Model to use */
+    model?: string;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Temperature (0-1, higher = more creative) */
+    temperature?: number;
+}
+/**
+ * AI provider type identifier
+ */
+type AIProviderType = 'anthropic' | 'openai' | 'ollama' | 'custom';
+/**
+ * Configuration for selecting an AI provider
+ */
+interface AIProviderConfig {
+    type: AIProviderType;
+    options: AIProviderOptions;
+}
+/**
+ * Error thrown when AI generation fails
+ */
+declare class AIGenerationError extends Error {
+    readonly provider: string;
+    readonly cause?: unknown | undefined;
+    constructor(message: string, provider: string, cause?: unknown | undefined);
+}
+/**
+ * AI provider for Anthropic's Claude models.
+ *
+ * @example
+ * ```typescript
+ * const provider = new AnthropicProvider({ apiKey: 'sk-...' })
+ * const response = await provider.generate('Hello!')
+ * ```
+ */
+declare class AnthropicProvider implements AIProvider {
+    readonly name = "Anthropic";
+    private apiKey;
+    private baseUrl;
+    private model;
+    private maxTokens;
+    private temperature;
+    constructor(options: AIProviderOptions);
+    generate(prompt: string): Promise<string>;
+}
+/**
+ * AI provider for OpenAI's GPT models.
+ *
+ * @example
+ * ```typescript
+ * const provider = new OpenAIProvider({ apiKey: 'sk-...' })
+ * const response = await provider.generate('Hello!')
+ * ```
+ */
+declare class OpenAIProvider implements AIProvider {
+    readonly name = "OpenAI";
+    private apiKey;
+    private baseUrl;
+    private model;
+    private maxTokens;
+    private temperature;
+    constructor(options: AIProviderOptions);
+    generate(prompt: string): Promise<string>;
+}
+/**
+ * AI provider for local Ollama instance.
+ *
+ * @example
+ * ```typescript
+ * const provider = new OllamaProvider({ baseUrl: 'http://localhost:11434' })
+ * const response = await provider.generate('Hello!')
+ * ```
+ */
+declare class OllamaProvider implements AIProvider {
+    readonly name = "Ollama";
+    private baseUrl;
+    private model;
+    private temperature;
+    constructor(options?: AIProviderOptions);
+    generate(prompt: string): Promise<string>;
+}
+/**
+ * Create an AI provider from configuration.
+ *
+ * @param config - Provider configuration
+ * @returns Configured AI provider instance
+ *
+ * @example
+ * ```typescript
+ * const provider = createAIProvider({
+ *   type: 'anthropic',
+ *   options: { apiKey: 'sk-...' }
+ * })
+ * ```
+ */
+declare function createAIProvider(config: AIProviderConfig): AIProvider;
+/**
+ * Check if Ollama is available locally.
+ *
+ * @param baseUrl - Ollama base URL (default: http://localhost:11434)
+ * @returns True if Ollama is responding
+ */
+declare function isOllamaAvailable(baseUrl?: string): Promise<boolean>;
+/**
+ * List available Ollama models.
+ *
+ * @param baseUrl - Ollama base URL
+ * @returns Array of model names
+ */
+declare function listOllamaModels(baseUrl?: string): Promise<string[]>;
+
+/**
+ * Script Generator - AI-powered script generation with validation
+ *
+ * Uses AI to generate scripts from natural language descriptions,
+ * validates them against the sandbox rules, and provides retry logic.
+ */
+
+/**
+ * Response from AI script generation
+ */
+interface AIScriptResponse {
+    /** The generated script code */
+    code: string;
+    /** AI-generated explanation of what the script does */
+    explanation: string;
+    /** Suggested name for the script */
+    suggestedName: string;
+    /** Suggested trigger type */
+    suggestedTrigger: ScriptTriggerType;
+    /** Whether the code passed validation */
+    validated: boolean;
+    /** Number of generation attempts */
+    attempts: number;
+}
+/**
+ * Options for the ScriptGenerator
+ */
+interface ScriptGeneratorOptions {
+    /** Maximum number of retry attempts on validation failure */
+    maxRetries?: number;
+    /** Whether to throw on final validation failure (default: false, returns invalid code) */
+    throwOnValidationFailure?: boolean;
+}
+/**
+ * Error thrown when script generation fails
+ */
+declare class ScriptGenerationError extends Error {
+    readonly validationErrors?: string[] | undefined;
+    readonly attempts?: number | undefined;
+    constructor(message: string, validationErrors?: string[] | undefined, attempts?: number | undefined);
+}
+/**
+ * Generates validated scripts from natural language using AI.
+ *
+ * @example
+ * ```typescript
+ * const generator = new ScriptGenerator(aiProvider, { maxRetries: 2 })
+ *
+ * const response = await generator.generate({
+ *   intent: 'Calculate total with 8% tax',
+ *   schema: invoiceSchema,
+ *   outputType: 'value'
+ * })
+ *
+ * if (response.validated) {
+ *   // Use response.code
+ * }
+ * ```
+ */
+declare class ScriptGenerator {
+    private ai;
+    private maxRetries;
+    private throwOnValidationFailure;
+    constructor(ai: AIProvider, options?: ScriptGeneratorOptions);
+    /**
+     * Generate a script from a natural language request.
+     *
+     * @param request - The script generation request
+     * @returns Generated script response
+     * @throws ScriptGenerationError if throwOnValidationFailure is true and validation fails
+     */
+    generate(request: AIScriptRequest): Promise<AIScriptResponse>;
+    /**
+     * Extract code from AI response (strips markdown fences, etc.)
+     */
+    private extractCode;
+    /**
+     * Generate an explanation for the script
+     */
+    private generateExplanation;
+    /**
+     * Generate a name from the intent
+     */
+    private generateName;
+    /**
+     * Infer the best trigger type from the request
+     */
+    private inferTrigger;
+}
+/**
+ * Convenience function for one-off script generation.
+ *
+ * @param provider - AI provider to use
+ * @param request - Script generation request
+ * @returns Generated script response
+ */
+declare function generateScript(provider: AIProvider, request: AIScriptRequest): Promise<AIScriptResponse>;
+
+/**
+ * Service Plugin Types
+ *
+ * Defines the types for background service plugins that run as separate processes.
+ * These are primarily used in Electron but the types are shared.
+ */
+/**
+ * Process configuration for a service
+ */
+interface ServiceProcessConfig {
+    /** Executable command (e.g., 'node', 'python', 'ollama') */
+    command: string;
+    /** Command arguments */
+    args?: string[];
+    /** Working directory */
+    cwd?: string;
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Run in shell (for PATH resolution) */
+    shell?: boolean;
+}
+/**
+ * Health check configuration
+ */
+interface ServiceHealthCheck {
+    /** Type of health check */
+    type: 'http' | 'stdout' | 'tcp';
+    /** URL to check for HTTP health checks */
+    url?: string;
+    /** Port to check for TCP health checks */
+    port?: number;
+    /** Regex pattern to match in stdout */
+    pattern?: string;
+    /** Interval between checks in milliseconds (default: 5000) */
+    intervalMs?: number;
+    /** Timeout for each check in milliseconds (default: 5000) */
+    timeoutMs?: number;
+}
+/**
+ * Lifecycle configuration for a service
+ */
+interface ServiceLifecycle {
+    /** Restart policy */
+    restart: 'always' | 'on-failure' | 'never';
+    /** Maximum number of restarts (default: 5) */
+    maxRestarts?: number;
+    /** Delay between restarts in milliseconds (default: 1000) */
+    restartDelayMs?: number;
+    /** Timeout for service startup in milliseconds (default: 10000) */
+    startTimeoutMs?: number;
+    /** Health check configuration */
+    healthCheck?: ServiceHealthCheck;
+    /** Graceful shutdown timeout in milliseconds (default: 5000) */
+    shutdownTimeoutMs?: number;
+}
+/**
+ * Communication configuration for a service
+ */
+interface ServiceCommunication {
+    /** Communication protocol */
+    protocol: 'stdio' | 'http' | 'websocket' | 'ipc';
+    /** Port for HTTP/WebSocket (0 = auto-assign) */
+    port?: number;
+    /** Host address (default: '127.0.0.1') */
+    host?: string;
+}
+/**
+ * Capabilities provided by a service
+ */
+interface ServiceProvides {
+    /** MCP tool definitions */
+    mcp?: {
+        tools: string[];
+    };
+    /** HTTP API routes */
+    api?: {
+        routes: string[];
+    };
+}
+/**
+ * Complete service definition
+ */
+interface ServiceDefinition {
+    /** Unique service identifier */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Process configuration */
+    process: ServiceProcessConfig;
+    /** Lifecycle configuration */
+    lifecycle: ServiceLifecycle;
+    /** Communication configuration */
+    communication: ServiceCommunication;
+    /** Capabilities this service provides */
+    provides?: ServiceProvides;
+}
+/**
+ * Service state
+ */
+type ServiceState = 'starting' | 'running' | 'stopping' | 'stopped' | 'error';
+/**
+ * Service status
+ */
+interface ServiceStatus {
+    /** Service ID */
+    id: string;
+    /** Current state */
+    state: ServiceState;
+    /** Process ID (when running) */
+    pid?: number;
+    /** Port (when running with HTTP/WebSocket) */
+    port?: number;
+    /** Timestamp when service started */
+    startedAt?: number;
+    /** Last error message */
+    lastError?: string;
+    /** Number of restarts since initial start */
+    restartCount: number;
+    /** Uptime in milliseconds (if running) */
+    uptime?: number;
+}
+/**
+ * Event emitted when service status changes
+ */
+interface ServiceStatusEvent {
+    serviceId: string;
+    status: ServiceStatus;
+    previousState?: ServiceState;
+}
+/**
+ * Event emitted when service outputs data
+ */
+interface ServiceOutputEvent {
+    serviceId: string;
+    stream: 'stdout' | 'stderr';
+    data: string;
+    timestamp: number;
+}
+/**
+ * Client interface for interacting with services from the renderer process
+ */
+interface ServiceClient {
+    /** Start a service */
+    start(definition: ServiceDefinition): Promise<ServiceStatus>;
+    /** Stop a service */
+    stop(serviceId: string): Promise<void>;
+    /** Restart a service */
+    restart(serviceId: string): Promise<ServiceStatus>;
+    /** Get service status */
+    status(serviceId: string): Promise<ServiceStatus | undefined>;
+    /** Get all service statuses */
+    listAll(): Promise<ServiceStatus[]>;
+    /** Call a service via HTTP */
+    call<T>(serviceId: string, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', path: string, body?: unknown): Promise<T>;
+    /** Subscribe to status changes */
+    onStatusChange(serviceId: string, callback: (status: ServiceStatus) => void): () => void;
+    /** Subscribe to service output */
+    onOutput(serviceId: string, callback: (event: ServiceOutputEvent) => void): () => void;
+}
+/**
+ * Events emitted by the ProcessManager
+ */
+interface ProcessManagerEvents {
+    'service:status': (event: ServiceStatusEvent) => void;
+    'service:output': (event: ServiceOutputEvent) => void;
+    'service:error': (event: {
+        serviceId: string;
+        error: Error;
+    }) => void;
+}
+/**
+ * Interface for the process manager (implemented in Electron main process)
+ */
+interface IProcessManager {
+    /** Start a service */
+    start(definition: ServiceDefinition): Promise<ServiceStatus>;
+    /** Stop a service */
+    stop(serviceId: string): Promise<void>;
+    /** Restart a service */
+    restart(serviceId: string): Promise<ServiceStatus>;
+    /** Get service status */
+    getStatus(serviceId: string): ServiceStatus | undefined;
+    /** Get all service statuses */
+    getAllStatuses(): ServiceStatus[];
+    /** Stop all services */
+    stopAll(): Promise<void>;
+    /** Subscribe to events */
+    on<K extends keyof ProcessManagerEvents>(event: K, listener: ProcessManagerEvents[K]): void;
+    /** Unsubscribe from events */
+    off<K extends keyof ProcessManagerEvents>(event: K, listener: ProcessManagerEvents[K]): void;
+}
+
+/**
+ * Local HTTP API Server
+ *
+ * Provides a REST API for external integrations (N8N, MCP, etc.) to interact
+ * with xNet data. Runs on localhost only (port 31415 by default).
+ *
+ * This is designed to run in the Electron main process.
+ */
+/**
+ * Node store interface (minimal subset needed by API)
+ */
+interface NodeStoreAPI {
+    get(id: string): Promise<NodeData | null>;
+    list(options?: {
+        schemaId?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<NodeData[]>;
+    create(options: {
+        schemaId: string;
+        properties: Record<string, unknown>;
+    }): Promise<NodeData>;
+    update(id: string, options: {
+        properties: Record<string, unknown>;
+    }): Promise<NodeData>;
+    delete(id: string): Promise<void>;
+    subscribe(listener: (event: NodeChangeEventData) => void): () => void;
+}
+/**
+ * Schema registry interface (minimal subset needed by API)
+ */
+interface SchemaRegistryAPI {
+    getAllIRIs(): string[];
+    get(iri: string): Promise<SchemaData | null>;
+}
+/**
+ * Node data returned by API
+ */
+interface NodeData {
+    id: string;
+    schemaId: string;
+    properties: Record<string, unknown>;
+    deleted: boolean;
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * Schema data returned by API
+ */
+interface SchemaData {
+    iri: string;
+    name: string;
+    properties: Record<string, unknown>;
+}
+/**
+ * Node change event data
+ */
+interface NodeChangeEventData {
+    change: {
+        type: string;
+    };
+    node: NodeData | null;
+    isRemote: boolean;
+}
+/**
+ * API configuration
+ */
+interface LocalAPIConfig {
+    /** Port to listen on (default: 31415) */
+    port?: number;
+    /** Host to bind to (default: '127.0.0.1') */
+    host?: string;
+    /** API token for authentication (optional) */
+    token?: string;
+    /**
+     * Allowed CORS origins (default: none).
+     * Set to specific origins like ['http://localhost:3000'] for local dev,
+     * or ['*'] to allow all origins (not recommended for production).
+     * Empty array or undefined disables CORS entirely.
+     */
+    allowedOrigins?: string[];
+    /** NodeStore instance */
+    store: NodeStoreAPI;
+    /** SchemaRegistry instance */
+    schemas: SchemaRegistryAPI;
+}
+
+/**
+ * Service Client
+ *
+ * Client API for interacting with services from the renderer process.
+ * Uses IPC to communicate with the ProcessManager in the main process.
+ */
+
+declare const SERVICE_IPC_CHANNELS: {
+    readonly START: "xnet:service:start";
+    readonly STOP: "xnet:service:stop";
+    readonly RESTART: "xnet:service:restart";
+    readonly STATUS: "xnet:service:status";
+    readonly LIST_ALL: "xnet:service:list-all";
+    readonly CALL: "xnet:service:call";
+    readonly STATUS_UPDATE: "xnet:service:status-update";
+    readonly OUTPUT: "xnet:service:output";
+};
+/**
+ * Create a service client for the renderer process.
+ *
+ * @example
+ * ```typescript
+ * const client = createServiceClient()
+ *
+ * // Start a service
+ * const status = await client.start({
+ *   id: 'my-service',
+ *   name: 'My Service',
+ *   process: { command: 'node', args: ['server.js'] },
+ *   lifecycle: { restart: 'on-failure' },
+ *   communication: { protocol: 'http', port: 3000 }
+ * })
+ *
+ * // Call the service
+ * const result = await client.call('my-service', 'GET', '/api/data')
+ *
+ * // Listen for status changes
+ * const unsubscribe = client.onStatusChange('my-service', (status) => {
+ *   console.log('Status:', status.state)
+ * })
+ * ```
+ */
+declare function createServiceClient(): ServiceClient;
+/**
+ * Check if service client is available
+ */
+declare function isServiceClientAvailable(): boolean;
+
+/**
+ * Webhook Event Emitter
+ *
+ * Sends webhook notifications when nodes change in the store.
+ * Supports filtering by schema, event type, and includes HMAC signing.
+ */
+
+/**
+ * Webhook configuration
+ */
+interface WebhookConfig {
+    /** Unique identifier for this webhook */
+    id: string;
+    /** URL to send webhooks to */
+    url: string;
+    /** Event types to send */
+    events: ('created' | 'updated' | 'deleted')[];
+    /** Filter by schema IRI (optional) */
+    schema?: string;
+    /** HMAC secret for signing (optional) */
+    secret?: string;
+    /** Maximum retry attempts (default: 3) */
+    retries?: number;
+    /** Enabled flag */
+    enabled?: boolean;
+}
+/**
+ * Webhook payload sent to subscribers
+ */
+interface WebhookPayload {
+    /** Event type */
+    type: 'created' | 'updated' | 'deleted';
+    /** Timestamp when event occurred */
+    timestamp: number;
+    /** The affected node */
+    node: NodeData | null;
+    /** Schema IRI of the node */
+    schema?: string;
+}
+/**
+ * Delivery result
+ */
+interface DeliveryResult {
+    webhookId: string;
+    success: boolean;
+    statusCode?: number;
+    error?: string;
+    attempts: number;
+    deliveredAt?: number;
+}
+/**
+ * Disposable interface for cleanup
+ */
+interface Disposable {
+    dispose(): void;
+}
+/**
+ * WebhookEmitter sends HTTP notifications when nodes change.
+ *
+ * @example
+ * ```typescript
+ * const emitter = new WebhookEmitter(store)
+ *
+ * // Register a webhook
+ * const dispose = emitter.register({
+ *   id: 'my-webhook',
+ *   url: 'https://example.com/webhook',
+ *   events: ['created', 'updated'],
+ *   schema: 'xnet://xnet.dev/Task',
+ *   secret: 'my-secret-key'
+ * })
+ *
+ * // Later: dispose.dispose() to unregister
+ * ```
+ */
+declare class WebhookEmitter {
+    private store;
+    private webhooks;
+    private unsubscribe?;
+    private deliveryHistory;
+    private maxHistorySize;
+    constructor(store: NodeStoreAPI);
+    /**
+     * Start listening for store changes.
+     * Must be called before webhooks will be sent.
+     */
+    start(): void;
+    /**
+     * Stop listening for store changes.
+     */
+    stop(): void;
+    /**
+     * Register a webhook configuration.
+     * Returns a disposable to unregister.
+     */
+    register(config: WebhookConfig): Disposable;
+    /**
+     * Unregister a webhook by ID.
+     */
+    unregister(id: string): boolean;
+    /**
+     * Get all registered webhooks.
+     */
+    getWebhooks(): WebhookConfig[];
+    /**
+     * Get a webhook by ID.
+     */
+    getWebhook(id: string): WebhookConfig | undefined;
+    /**
+     * Update a webhook configuration.
+     */
+    updateWebhook(id: string, updates: Partial<WebhookConfig>): boolean;
+    /**
+     * Get recent delivery history.
+     */
+    getDeliveryHistory(): DeliveryResult[];
+    /**
+     * Clear delivery history.
+     */
+    clearDeliveryHistory(): void;
+    private handleEvent;
+    private getEventType;
+    private send;
+    private deliverWebhook;
+    private sign;
+    private recordDelivery;
+    private delay;
+}
+/**
+ * Create a webhook emitter.
+ *
+ * @example
+ * ```typescript
+ * const emitter = createWebhookEmitter(store)
+ * emitter.start()
+ *
+ * emitter.register({
+ *   id: 'n8n',
+ *   url: 'http://localhost:5678/webhook/xnet',
+ *   events: ['created', 'updated', 'deleted']
+ * })
+ * ```
+ */
+declare function createWebhookEmitter(store: NodeStoreAPI): WebhookEmitter;
+
+/**
+ * MCP Server for xNet
+ *
+ * Exposes xNet data to AI agents via the Model Context Protocol.
+ * Provides tools for querying, creating, and updating nodes.
+ *
+ * This runs as a stdio-based MCP server, typically spawned by an MCP client.
+ */
+
+/**
+ * MCP Tool definition
+ */
+interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, MCPPropertySchema>;
+        required?: string[];
+    };
+}
+/**
+ * MCP property schema
+ */
+interface MCPPropertySchema {
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    description?: string;
+    items?: MCPPropertySchema;
+}
+/**
+ * MCP Resource definition
+ */
+interface MCPResource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+}
+/**
+ * MCP Request from client
+ */
+interface MCPRequest {
+    jsonrpc: '2.0';
+    id: number | string;
+    method: string;
+    params?: Record<string, unknown>;
+}
+/**
+ * MCP Response to client
+ */
+interface MCPResponse {
+    jsonrpc: '2.0';
+    id: number | string;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+/**
+ * MCP Server configuration
+ */
+interface MCPServerConfig {
+    store: NodeStoreAPI;
+    schemas: SchemaRegistryAPI;
+    /** Server name (default: 'xnet') */
+    name?: string;
+    /** Server version (default: '1.0.0') */
+    version?: string;
+}
+
+export { AIGenerationError, type AIProvider, type AIProviderConfig, type AIProviderOptions, type AIProviderType, type AIScriptRequest, type AIScriptResponse, AnthropicProvider, type ArrayHelpers, type BlockContribution, type BlockProps, type CommandContribution, ContributionRegistry, type DeliveryResult, type Disposable$1 as Disposable, type EditorContribution, type ExtensionContext, type ExtensionStorage, type FlatNode, type FormatHelpers, type IProcessManager, type LocalAPIConfig, type MCPPropertySchema, type MCPRequest, type MCPResource, type MCPResponse, type MCPServerConfig, type MCPTool, type MathHelpers, MiddlewareChain, type NodeChangeEvent, type NodeChangeEventData, type NodeData, type NodeStoreAPI, type NodeStoreMiddleware, OllamaProvider, OpenAIProvider, type PendingChange, type Platform, type PlatformCapabilities, type PluginContributions, PluginError, type PluginNode, type PluginNodeChangeEvent, type PluginNodeChangeListener, type PluginPermissions, PluginRegistry, PluginSchema, type PluginStatus, PluginValidationError, type ProcessManagerEvents, type PropertyCellProps, type PropertyEditorProps, type PropertyHandler, type PropertyHandlerContribution, type QueryFilter, type RegisteredPlugin, SERVICE_IPC_CHANNELS, type SandboxOptions, type SchemaContribution, type SchemaData, type SchemaDefinition, type SchemaProperty, type SchemaRegistryAPI, type ScriptContext, ScriptError, type ScriptExecutionResult, ScriptGenerationError, ScriptGenerator, type ScriptGeneratorOptions, type ScriptNode, type ScriptNodeChangeEvent, type ScriptOutputType, ScriptRunner, type ScriptRunnerOptions, ScriptSandbox, ScriptSchema, type ScriptStore, ScriptTimeoutError, type ScriptTriggerType, ScriptValidationError, type ServiceClient, type ServiceCommunication, type ServiceDefinition, type ServiceHealthCheck, type ServiceLifecycle, type ServiceOutputEvent, type ServiceProcessConfig, type ServiceProvides, type ServiceState, type ServiceStatus, type ServiceStatusEvent, type SettingContribution, type SettingsPanelProps, ShortcutManager, type SidebarContribution, type SlashCommandContext, type SlashCommandContribution, type TelemetryReporter, type TextHelpers, type ToolbarContribution, TypedRegistry, type ValidationResult, type ViewContribution, type ViewProps, type WebhookConfig, WebhookEmitter, type WebhookPayload, type XNetExtension, buildRetryPrompt, buildScriptPrompt, createAIProvider, createExtensionContext, createExtensionStorage, createScriptContext, createServiceClient, createWebhookEmitter, defineExtension, executeScript, generateScript, getPlatformCapabilities, getShortcutManager, installShortcutHandler, isOllamaAvailable, isScriptNode, isServiceClientAvailable, listOllamaModels, quickSafetyCheck, validateManifest, validateScript, validateScriptAST };