@xnetjs/plugins 0.0.2

package/dist/index.js

@@ -0,0 +1,2640 @@
+// src/types.ts
+function getPlatformCapabilities(platform) {
+  return {
+    platform,
+    features: {
+      views: true,
+      editorExtensions: platform !== "mobile",
+      slashCommands: platform !== "mobile",
+      services: platform === "electron",
+      processes: platform === "electron",
+      localAPI: platform === "electron",
+      filesystem: platform === "electron",
+      clipboard: platform !== "mobile",
+      notifications: true,
+      p2pSync: true
+    }
+  };
+}
+function createExtensionStorage() {
+  const storage = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      return storage.get(key);
+    },
+    set(key, value) {
+      storage.set(key, value);
+    },
+    delete(key) {
+      storage.delete(key);
+    },
+    keys() {
+      return [...storage.keys()];
+    }
+  };
+}
+
+// src/manifest.ts
+var PluginValidationError = class extends Error {
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+    this.name = "PluginValidationError";
+  }
+};
+function validateManifest(manifest) {
+  const issues = [];
+  if (!manifest || typeof manifest !== "object") {
+    throw new PluginValidationError("Manifest must be an object", ["Invalid manifest type"]);
+  }
+  const m = manifest;
+  if (typeof m.id !== "string" || !m.id) {
+    issues.push("id is required and must be a non-empty string");
+  } else if (!/^[a-z][a-z0-9]*(\.[a-z][a-z0-9-]*)+$/i.test(m.id)) {
+    issues.push("id must be in reverse-domain format (e.g., com.example.my-plugin)");
+  }
+  if (typeof m.name !== "string" || !m.name) {
+    issues.push("name is required and must be a non-empty string");
+  }
+  if (typeof m.version !== "string" || !m.version) {
+    issues.push("version is required and must be a non-empty string");
+  } else if (!/^\d+\.\d+\.\d+/.test(m.version)) {
+    issues.push("version must be a valid semver (e.g., 1.0.0)");
+  }
+  if (m.description !== void 0 && typeof m.description !== "string") {
+    issues.push("description must be a string");
+  }
+  if (m.author !== void 0 && typeof m.author !== "string") {
+    issues.push("author must be a string");
+  }
+  if (m.platforms !== void 0) {
+    if (!Array.isArray(m.platforms)) {
+      issues.push("platforms must be an array");
+    } else {
+      const validPlatforms = ["web", "electron", "mobile"];
+      for (const p of m.platforms) {
+        if (!validPlatforms.includes(p)) {
+          issues.push(`Invalid platform: ${p}. Must be one of: ${validPlatforms.join(", ")}`);
+        }
+      }
+    }
+  }
+  if (m.activate !== void 0 && typeof m.activate !== "function") {
+    issues.push("activate must be a function");
+  }
+  if (m.deactivate !== void 0 && typeof m.deactivate !== "function") {
+    issues.push("deactivate must be a function");
+  }
+  if (issues.length > 0) {
+    throw new PluginValidationError(
+      `Plugin manifest validation failed: ${issues.join("; ")}`,
+      issues
+    );
+  }
+  return manifest;
+}
+function defineExtension(manifest) {
+  validateManifest(manifest);
+  return manifest;
+}
+
+// src/contributions.ts
+var TypedRegistry = class {
+  items = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  register(item) {
+    const key = item.id ?? item.type ?? crypto.randomUUID();
+    this.items.set(key, item);
+    this.notify();
+    return {
+      dispose: () => {
+        this.items.delete(key);
+        this.notify();
+      }
+    };
+  }
+  unregister(key) {
+    const deleted = this.items.delete(key);
+    if (deleted) this.notify();
+    return deleted;
+  }
+  get(key) {
+    return this.items.get(key);
+  }
+  getAll() {
+    return [...this.items.values()];
+  }
+  has(key) {
+    return this.items.has(key);
+  }
+  get size() {
+    return this.items.size;
+  }
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notify() {
+    for (const listener of this.listeners) {
+      try {
+        listener();
+      } catch (err) {
+        console.error("[TypedRegistry] Listener error:", err);
+      }
+    }
+  }
+  clear() {
+    this.items.clear();
+    this.notify();
+  }
+};
+var ContributionRegistry = class {
+  views = new TypedRegistry();
+  commands = new TypedRegistry();
+  slashCommands = new TypedRegistry();
+  sidebar = new TypedRegistry();
+  editor = new TypedRegistry();
+  propertyHandlers = new TypedRegistry();
+  blocks = new TypedRegistry();
+  settings = new TypedRegistry();
+  /**
+   * Clear all registries (for cleanup/testing)
+   */
+  clear() {
+    this.views.clear();
+    this.commands.clear();
+    this.slashCommands.clear();
+    this.sidebar.clear();
+    this.editor.clear();
+    this.propertyHandlers.clear();
+    this.blocks.clear();
+    this.settings.clear();
+  }
+};
+
+// src/shortcuts.ts
+function isMac() {
+  if (typeof navigator === "undefined") return false;
+  return navigator.platform?.includes("Mac") || navigator.userAgent?.includes("Mac");
+}
+var ShortcutManager = class {
+  shortcuts = /* @__PURE__ */ new Map();
+  enabled = true;
+  /**
+   * Register a command with a keyboard shortcut.
+   *
+   * @param command - Command with keybinding
+   * @returns Disposable to unregister the shortcut
+   */
+  register(command) {
+    if (!command.keybinding) {
+      return { dispose: () => {
+      } };
+    }
+    const normalized = this.normalize(command.keybinding);
+    this.shortcuts.set(normalized, command);
+    return {
+      dispose: () => {
+        this.shortcuts.delete(normalized);
+      }
+    };
+  }
+  /**
+   * Unregister a command by ID.
+   */
+  unregister(commandId) {
+    for (const [key, cmd] of this.shortcuts) {
+      if (cmd.id === commandId) {
+        return this.shortcuts.delete(key);
+      }
+    }
+    return false;
+  }
+  /**
+   * Handle a keyboard event.
+   *
+   * @param event - Keyboard event
+   * @returns True if a shortcut was triggered
+   */
+  handleKeyDown(event) {
+    if (!this.enabled) return false;
+    const target = event.target;
+    if (target?.tagName === "INPUT" || target?.tagName === "TEXTAREA") {
+      if (event.key !== "Escape") {
+        return false;
+      }
+    }
+    if (target?.isContentEditable) {
+      const key2 = this.eventToString(event);
+      const command2 = this.shortcuts.get(key2);
+      if (!command2) return false;
+    }
+    const key = this.eventToString(event);
+    const command = this.shortcuts.get(key);
+    if (command) {
+      if (command.when && !command.when()) {
+        return false;
+      }
+      event.preventDefault();
+      event.stopPropagation();
+      Promise.resolve(command.execute()).catch((err) => {
+        console.error(`[ShortcutManager] Command '${command.id}' failed:`, err);
+      });
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Enable or disable shortcut handling.
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  /**
+   * Check if shortcuts are enabled.
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Get all registered shortcuts.
+   */
+  getAll() {
+    return [...this.shortcuts.values()];
+  }
+  /**
+   * Get the shortcut for a command ID.
+   */
+  getShortcut(commandId) {
+    for (const [key, cmd] of this.shortcuts) {
+      if (cmd.id === commandId) {
+        return this.denormalize(key);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Format a keybinding for display (using platform-specific symbols).
+   */
+  formatForDisplay(keybinding) {
+    const mac = isMac();
+    return keybinding.replace(/Mod/g, mac ? "\u2318" : "Ctrl").replace(/Ctrl/g, mac ? "\u2303" : "Ctrl").replace(/Alt/g, mac ? "\u2325" : "Alt").replace(/Shift/g, mac ? "\u21E7" : "Shift").replace(/Meta/g, mac ? "\u2318" : "Win").replace(/-/g, mac ? "" : "+");
+  }
+  /**
+   * Normalize a keybinding string for consistent lookup.
+   */
+  normalize(keybinding) {
+    const mac = isMac();
+    const parts = keybinding.replace(/Mod/g, mac ? "Meta" : "Ctrl").split("-").map((p) => p.toLowerCase());
+    const modifiers = ["ctrl", "meta", "alt", "shift"];
+    const sortedModifiers = parts.filter((p) => modifiers.includes(p)).sort();
+    const key = parts.filter((p) => !modifiers.includes(p))[0] ?? "";
+    return [...sortedModifiers, key].join("-");
+  }
+  /**
+   * Convert normalized form back to display form.
+   */
+  denormalize(normalized) {
+    const mac = isMac();
+    return normalized.split("-").map((part) => {
+      if (part === "ctrl") return "Ctrl";
+      if (part === "meta") return mac ? "Cmd" : "Ctrl";
+      if (part === "alt") return "Alt";
+      if (part === "shift") return "Shift";
+      return part.toUpperCase();
+    }).join("-");
+  }
+  /**
+   * Convert a keyboard event to a normalized string.
+   */
+  eventToString(event) {
+    const modifiers = [];
+    if (event.ctrlKey) modifiers.push("ctrl");
+    if (event.metaKey) modifiers.push("meta");
+    if (event.altKey) modifiers.push("alt");
+    if (event.shiftKey) modifiers.push("shift");
+    let key = event.key.toLowerCase();
+    if (key === " ") key = "space";
+    if (key === "arrowup") key = "up";
+    if (key === "arrowdown") key = "down";
+    if (key === "arrowleft") key = "left";
+    if (key === "arrowright") key = "right";
+    if (["control", "meta", "alt", "shift"].includes(key)) {
+      return "";
+    }
+    return [...modifiers.sort(), key].join("-");
+  }
+  /**
+   * Clear all registered shortcuts.
+   */
+  clear() {
+    this.shortcuts.clear();
+  }
+};
+var globalShortcutManager = null;
+function getShortcutManager() {
+  if (!globalShortcutManager) {
+    globalShortcutManager = new ShortcutManager();
+  }
+  return globalShortcutManager;
+}
+function installShortcutHandler() {
+  const manager = getShortcutManager();
+  const handler = (event) => {
+    manager.handleKeyDown(event);
+  };
+  window.addEventListener("keydown", handler, true);
+  return () => {
+    window.removeEventListener("keydown", handler, true);
+  };
+}
+
+// src/middleware.ts
+var MiddlewareChain = class {
+  middlewares = [];
+  /**
+   * Add a middleware to the chain
+   */
+  add(middleware) {
+    this.middlewares.push(middleware);
+    this.middlewares.sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+    return {
+      dispose: () => {
+        this.middlewares = this.middlewares.filter((m) => m.id !== middleware.id);
+      }
+    };
+  }
+  /**
+   * Remove a middleware by ID
+   */
+  remove(id) {
+    const before = this.middlewares.length;
+    this.middlewares = this.middlewares.filter((m) => m.id !== id);
+    return this.middlewares.length < before;
+  }
+  /**
+   * Get all registered middlewares
+   */
+  getAll() {
+    return [...this.middlewares];
+  }
+  /**
+   * Execute beforeChange hooks in priority order
+   */
+  async executeBefore(change, apply) {
+    const chain = this.middlewares.filter((m) => m.beforeChange);
+    const execute = async (index) => {
+      if (index >= chain.length) {
+        return apply();
+      }
+      return chain[index].beforeChange(change, () => execute(index + 1));
+    };
+    return execute(0);
+  }
+  /**
+   * Execute afterChange hooks (errors are caught and logged)
+   */
+  executeAfter(event) {
+    for (const middleware of this.middlewares) {
+      if (middleware.afterChange) {
+        try {
+          middleware.afterChange(event);
+        } catch (err) {
+          console.error(`[Middleware ${middleware.id}] afterChange error:`, err);
+        }
+      }
+    }
+  }
+  /**
+   * Clear all middlewares
+   */
+  clear() {
+    this.middlewares = [];
+  }
+  /**
+   * Get the number of registered middlewares
+   */
+  get size() {
+    return this.middlewares.length;
+  }
+};
+
+// src/context.ts
+function createExtensionContext(options) {
+  const { pluginId, store, contributions, platform, middlewareChain } = options;
+  const disposables = [];
+  const storage = createExtensionStorage();
+  const ctx = {
+    pluginId,
+    platform,
+    store,
+    async query(schema, filter) {
+      const nodes = await store.list();
+      let filtered = schema ? nodes.filter((n) => n.schemaId === schema) : nodes;
+      if (filter?.where) {
+        filtered = filtered.filter((node) => {
+          for (const [key, value] of Object.entries(filter.where)) {
+            if (node[key] !== value) return false;
+          }
+          return true;
+        });
+      }
+      if (filter?.offset) {
+        filtered = filtered.slice(filter.offset);
+      }
+      if (filter?.limit) {
+        filtered = filtered.slice(0, filter.limit);
+      }
+      return filtered;
+    },
+    subscribe(schema, callback) {
+      const storeCallback = (event) => {
+        if (!schema || event.node?.schemaId === schema) {
+          const change = event.change;
+          callback({
+            type: change.type === "node-delete" ? "delete" : change.type === "node-change" ? "create" : "update",
+            nodeId: change.payload.nodeId,
+            node: event.node ?? void 0,
+            changes: void 0
+            // Raw change available via event.change if needed
+          });
+        }
+      };
+      const unsub = store.subscribe(storeCallback);
+      const disposable = { dispose: unsub };
+      disposables.push(disposable);
+      return disposable;
+    },
+    registerSchema(_schema) {
+      const d = {
+        dispose: () => {
+        }
+      };
+      disposables.push(d);
+      return d;
+    },
+    registerView(view) {
+      const d = contributions.views.register(view);
+      disposables.push(d);
+      return d;
+    },
+    registerPropertyHandler(type, handler) {
+      const d = contributions.propertyHandlers.register({ type, handler });
+      disposables.push(d);
+      return d;
+    },
+    registerCommand(command) {
+      const d = contributions.commands.register(command);
+      disposables.push(d);
+      return d;
+    },
+    registerSidebarItem(item) {
+      const d = contributions.sidebar.register(item);
+      disposables.push(d);
+      return d;
+    },
+    registerEditorExtension(ext) {
+      const d = contributions.editor.register(ext);
+      disposables.push(d);
+      return d;
+    },
+    registerSlashCommand(cmd) {
+      const d = contributions.slashCommands.register(cmd);
+      disposables.push(d);
+      return d;
+    },
+    registerBlockType(block) {
+      const d = contributions.blocks.register(block);
+      disposables.push(d);
+      return d;
+    },
+    addMiddleware(middleware) {
+      if (!middlewareChain) {
+        console.warn(`[Plugin ${pluginId}] Middleware not available on this platform`);
+        return { dispose: () => {
+        } };
+      }
+      const namespacedMiddleware = {
+        ...middleware,
+        id: `${pluginId}:${middleware.id}`
+      };
+      const d = middlewareChain.add(namespacedMiddleware);
+      disposables.push(d);
+      return d;
+    },
+    storage,
+    capabilities: getPlatformCapabilities(platform),
+    subscriptions: disposables
+  };
+  return ctx;
+}
+
+// src/schemas/plugin.ts
+import { defineSchema, text, checkbox, date } from "@xnetjs/data";
+var PluginSchema = defineSchema({
+  name: "Plugin",
+  namespace: "xnet://xnet.fyi/",
+  properties: {
+    /** Unique plugin identifier (reverse-domain format) */
+    pluginId: text({ required: true }),
+    /** Human-readable name */
+    name: text({ required: true }),
+    /** Semantic version */
+    version: text({ required: true }),
+    /** Plugin description */
+    description: text({}),
+    /** Author name or organization */
+    author: text({}),
+    /** Whether plugin is enabled */
+    enabled: checkbox({ default: true }),
+    /** JSON-serialized manifest */
+    manifest: text({ required: true }),
+    /** Plugin source (URL or inline bundle) */
+    source: text({}),
+    /** JSON-serialized permissions */
+    permissions: text({}),
+    /** Installation timestamp */
+    installedAt: date({})
+  }
+});
+
+// src/registry.ts
+var PluginError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PluginError";
+  }
+};
+var PluginRegistry = class {
+  constructor(store, platform) {
+    this.store = store;
+    this.platform = platform;
+  }
+  plugins = /* @__PURE__ */ new Map();
+  contributions = new ContributionRegistry();
+  middleware = new MiddlewareChain();
+  listeners = /* @__PURE__ */ new Set();
+  // ─── Lifecycle ─────────────────────────────────────────────────────────
+  /**
+   * Install and activate a plugin
+   */
+  async install(manifest) {
+    try {
+      validateManifest(manifest);
+    } catch (err) {
+      if (err instanceof PluginValidationError) {
+        throw new PluginError(`Invalid manifest: ${err.issues.join(", ")}`);
+      }
+      throw err;
+    }
+    if (manifest.platforms && !manifest.platforms.includes(this.platform)) {
+      throw new PluginError(
+        `Plugin '${manifest.id}' requires platforms: ${manifest.platforms.join(", ")} (current: ${this.platform})`
+      );
+    }
+    if (this.plugins.has(manifest.id)) {
+      throw new PluginError(`Plugin '${manifest.id}' is already installed`);
+    }
+    await this.store.create({
+      schemaId: PluginSchema._schemaId,
+      properties: {
+        pluginId: manifest.id,
+        name: manifest.name,
+        version: manifest.version,
+        description: manifest.description ?? "",
+        author: manifest.author ?? "",
+        enabled: true,
+        manifest: JSON.stringify(manifest),
+        installedAt: Date.now()
+      }
+    });
+    this.plugins.set(manifest.id, { manifest, status: "installed" });
+    this.notify();
+    await this.activate(manifest.id);
+  }
+  /**
+   * Activate an installed plugin
+   */
+  async activate(pluginId) {
+    const plugin = this.plugins.get(pluginId);
+    if (!plugin) {
+      throw new PluginError(`Plugin '${pluginId}' not found`);
+    }
+    if (plugin.status === "active") {
+      return;
+    }
+    try {
+      const context = createExtensionContext({
+        pluginId,
+        store: this.store,
+        contributions: this.contributions,
+        platform: this.platform,
+        middlewareChain: this.middleware
+      });
+      this.registerStaticContributions(plugin.manifest, context);
+      if (plugin.manifest.activate) {
+        await plugin.manifest.activate(context);
+      }
+      plugin.context = context;
+      plugin.status = "active";
+      plugin.error = void 0;
+      this.notify();
+    } catch (err) {
+      plugin.status = "error";
+      plugin.error = err instanceof Error ? err : new Error(String(err));
+      console.error(`Plugin '${pluginId}' activation failed:`, err);
+      this.notify();
+      throw plugin.error;
+    }
+  }
+  /**
+   * Deactivate an active plugin
+   */
+  async deactivate(pluginId) {
+    const plugin = this.plugins.get(pluginId);
+    if (!plugin || plugin.status !== "active") {
+      return;
+    }
+    if (plugin.manifest.deactivate) {
+      try {
+        await plugin.manifest.deactivate();
+      } catch (err) {
+        console.error(`Plugin '${pluginId}' deactivate error:`, err);
+      }
+    }
+    if (plugin.context) {
+      for (const d of plugin.context.subscriptions) {
+        try {
+          d.dispose();
+        } catch (err) {
+          console.error(`Error disposing subscription for plugin '${pluginId}':`, err);
+        }
+      }
+    }
+    plugin.context = void 0;
+    plugin.status = "disabled";
+    this.notify();
+  }
+  /**
+   * Uninstall a plugin (deactivates first if active)
+   */
+  async uninstall(pluginId) {
+    await this.deactivate(pluginId);
+    this.plugins.delete(pluginId);
+    const nodes = await this.store.list();
+    const pluginNode = nodes.find(
+      (n) => n.schemaId === PluginSchema._schemaId && n.properties.pluginId === pluginId
+    );
+    if (pluginNode) {
+      await this.store.delete(pluginNode.id);
+    }
+    this.notify();
+  }
+  // ─── Queries ───────────────────────────────────────────────────────────
+  /**
+   * Get all registered plugins
+   */
+  getAll() {
+    return [...this.plugins.values()];
+  }
+  /**
+   * Get a specific plugin
+   */
+  get(pluginId) {
+    return this.plugins.get(pluginId);
+  }
+  /**
+   * Check if a plugin is installed
+   */
+  has(pluginId) {
+    return this.plugins.has(pluginId);
+  }
+  /**
+   * 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.
+   */
+  async rehydrate(liveManifest) {
+    const plugin = this.plugins.get(liveManifest.id);
+    if (!plugin) return;
+    if (plugin.status === "active") {
+      await this.deactivate(liveManifest.id);
+    }
+    plugin.manifest = liveManifest;
+    plugin.status = "installed";
+    await this.activate(liveManifest.id);
+  }
+  /**
+   * Get contribution registry
+   */
+  getContributions() {
+    return this.contributions;
+  }
+  /**
+   * Get middleware chain
+   */
+  getMiddleware() {
+    return this.middleware;
+  }
+  // ─── Events ────────────────────────────────────────────────────────────
+  /**
+   * Subscribe to plugin changes
+   */
+  onChange(listener) {
+    this.listeners.add(listener);
+    return {
+      dispose: () => this.listeners.delete(listener)
+    };
+  }
+  notify() {
+    for (const listener of this.listeners) {
+      try {
+        listener();
+      } catch (err) {
+        console.error("[PluginRegistry] Listener error:", err);
+      }
+    }
+  }
+  // ─── Static Contributions ──────────────────────────────────────────────
+  registerStaticContributions(manifest, ctx) {
+    const c = manifest.contributes;
+    if (!c) return;
+    if (c.views) {
+      for (const view of c.views) {
+        ctx.registerView(view);
+      }
+    }
+    if (c.commands) {
+      for (const cmd of c.commands) {
+        ctx.registerCommand(cmd);
+      }
+    }
+    if (c.slashCommands) {
+      for (const cmd of c.slashCommands) {
+        ctx.registerSlashCommand(cmd);
+      }
+    }
+    if (c.sidebarItems) {
+      for (const item of c.sidebarItems) {
+        ctx.registerSidebarItem(item);
+      }
+    }
+    if (c.editorExtensions) {
+      for (const ext of c.editorExtensions) {
+        ctx.registerEditorExtension(ext);
+      }
+    }
+    if (c.propertyHandlers) {
+      for (const h of c.propertyHandlers) {
+        ctx.registerPropertyHandler(h.type, h.handler);
+      }
+    }
+    if (c.blocks) {
+      for (const block of c.blocks) {
+        ctx.registerBlockType(block);
+      }
+    }
+  }
+  // ─── Load from Store ───────────────────────────────────────────────────
+  /**
+   * Load and activate plugins from stored Nodes
+   */
+  async loadFromStore() {
+    const nodes = await this.store.list();
+    const pluginNodes = nodes.filter((n) => n.schemaId === PluginSchema._schemaId);
+    for (const node of pluginNodes) {
+      const props = node.properties;
+      if (!props.enabled) continue;
+      try {
+        const manifest = JSON.parse(props.manifest);
+        if (this.plugins.has(manifest.id)) continue;
+        this.plugins.set(manifest.id, { manifest, status: "installed" });
+        await this.activate(manifest.id);
+      } catch (err) {
+        console.error(`Failed to load plugin '${props.pluginId}':`, err);
+      }
+    }
+  }
+};
+
+// src/schemas/script.ts
+import { defineSchema as defineSchema2, text as text2, checkbox as checkbox2, date as date2, select } from "@xnetjs/data";
+var TRIGGER_OPTIONS = [
+  { id: "manual", name: "Manual", color: "gray" },
+  { id: "onChange", name: "On Change", color: "blue" },
+  { id: "onView", name: "On View", color: "green" },
+  { id: "scheduled", name: "Scheduled", color: "purple" }
+];
+var OUTPUT_OPTIONS = [
+  { id: "value", name: "Value", color: "blue" },
+  { id: "mutation", name: "Mutation", color: "orange" },
+  { id: "decoration", name: "Decoration", color: "purple" },
+  { id: "void", name: "Void", color: "gray" }
+];
+var ScriptSchema = defineSchema2({
+  name: "Script",
+  namespace: "xnet://xnet.dev/",
+  properties: {
+    /** Human-readable script name */
+    name: text2({ required: true }),
+    /** Description of what the script does */
+    description: text2({}),
+    /** The script code (JavaScript expression or arrow function) */
+    code: text2({ required: true }),
+    /** When the script should execute */
+    triggerType: select({
+      options: TRIGGER_OPTIONS,
+      default: "manual"
+    }),
+    /** For onChange trigger: which property to watch (empty = any) */
+    triggerProperty: text2({}),
+    /** For scheduled trigger: cron expression */
+    triggerCron: text2({}),
+    /** Schema IRI this script operates on (e.g., 'xnet://myapp/Task') */
+    inputSchema: text2({}),
+    /** What the script returns */
+    outputType: select({
+      options: OUTPUT_OPTIONS,
+      default: "value"
+    }),
+    /** Whether the script is active */
+    enabled: checkbox2({ default: true }),
+    /** Last execution error message (null if last run succeeded) */
+    lastError: text2({}),
+    /** Timestamp of last execution */
+    lastRun: date2({})
+  }
+});
+function isScriptNode(node) {
+  if (!node || typeof node !== "object") return false;
+  const n = node;
+  return typeof n.id === "string" && typeof n.name === "string" && typeof n.code === "string" && typeof n.triggerType === "string" && typeof n.outputType === "string" && typeof n.enabled === "boolean";
+}
+
+// src/sandbox/context.ts
+function createFormatHelpers() {
+  return {
+    date: (ts, options) => {
+      try {
+        return new Intl.DateTimeFormat("en-US", options).format(new Date(ts));
+      } catch {
+        return String(ts);
+      }
+    },
+    number: (val, options) => {
+      try {
+        return new Intl.NumberFormat("en-US", options).format(val);
+      } catch {
+        return String(val);
+      }
+    },
+    currency: (val, currency = "USD", locale = "en-US") => {
+      try {
+        return new Intl.NumberFormat(locale, {
+          style: "currency",
+          currency
+        }).format(val);
+      } catch {
+        return `${currency} ${val}`;
+      }
+    },
+    relative: (ts) => {
+      const diff = Date.now() - ts;
+      const absDiff = Math.abs(diff);
+      const suffix = diff >= 0 ? "ago" : "from now";
+      const seconds = Math.floor(absDiff / 1e3);
+      if (seconds < 60) return `${seconds}s ${suffix}`;
+      const minutes = Math.floor(seconds / 60);
+      if (minutes < 60) return `${minutes}m ${suffix}`;
+      const hours = Math.floor(minutes / 60);
+      if (hours < 24) return `${hours}h ${suffix}`;
+      const days = Math.floor(hours / 24);
+      if (days < 30) return `${days}d ${suffix}`;
+      const months = Math.floor(days / 30);
+      if (months < 12) return `${months}mo ${suffix}`;
+      const years = Math.floor(months / 12);
+      return `${years}y ${suffix}`;
+    },
+    bytes: (bytes) => {
+      const units = ["B", "KB", "MB", "GB", "TB"];
+      let size = Math.abs(bytes);
+      let unitIndex = 0;
+      while (size >= 1024 && unitIndex < units.length - 1) {
+        size /= 1024;
+        unitIndex++;
+      }
+      return `${size.toFixed(unitIndex === 0 ? 0 : 1)} ${units[unitIndex]}`;
+    }
+  };
+}
+function createMathHelpers() {
+  return {
+    sum: (vals) => {
+      if (!Array.isArray(vals) || vals.length === 0) return 0;
+      return vals.reduce((a, b) => a + (Number(b) || 0), 0);
+    },
+    avg: (vals) => {
+      if (!Array.isArray(vals) || vals.length === 0) return 0;
+      const sum = vals.reduce((a, b) => a + (Number(b) || 0), 0);
+      return sum / vals.length;
+    },
+    min: (vals) => {
+      if (!Array.isArray(vals) || vals.length === 0) return 0;
+      const numbers = vals.map((v) => Number(v) || 0);
+      return Math.min(...numbers);
+    },
+    max: (vals) => {
+      if (!Array.isArray(vals) || vals.length === 0) return 0;
+      const numbers = vals.map((v) => Number(v) || 0);
+      return Math.max(...numbers);
+    },
+    round: (val, decimals = 0) => {
+      const factor = Math.pow(10, decimals);
+      return Math.round(val * factor) / factor;
+    },
+    clamp: (val, min, max) => Math.min(Math.max(val, min), max),
+    abs: (val) => Math.abs(val),
+    floor: (val) => Math.floor(val),
+    ceil: (val) => Math.ceil(val)
+  };
+}
+function createTextHelpers() {
+  return {
+    slugify: (t) => String(t || "").toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, ""),
+    truncate: (t, len) => {
+      const str = String(t || "");
+      return str.length > len ? str.slice(0, len) + "..." : str;
+    },
+    capitalize: (t) => {
+      const str = String(t || "");
+      return str.charAt(0).toUpperCase() + str.slice(1);
+    },
+    titleCase: (t) => String(t || "").toLowerCase().replace(/\b\w/g, (c) => c.toUpperCase()),
+    contains: (t, s) => String(t || "").toLowerCase().includes(String(s || "").toLowerCase()),
+    template: (tmpl, vars) => String(tmpl || "").replace(/\{(\w+)\}/g, (_, key) => {
+      const val = vars[key];
+      return val !== void 0 && val !== null ? String(val) : "";
+    }),
+    trim: (t) => String(t || "").trim(),
+    lower: (t) => String(t || "").toLowerCase(),
+    upper: (t) => String(t || "").toUpperCase()
+  };
+}
+function createArrayHelpers() {
+  return {
+    first: (items) => Array.isArray(items) ? items[0] : void 0,
+    last: (items) => Array.isArray(items) ? items[items.length - 1] : void 0,
+    sortBy: (items, key, desc = false) => {
+      if (!Array.isArray(items)) return [];
+      return [...items].sort((a, b) => {
+        const aVal = a[key];
+        const bVal = b[key];
+        if (aVal < bVal) return desc ? 1 : -1;
+        if (aVal > bVal) return desc ? -1 : 1;
+        return 0;
+      });
+    },
+    groupBy: (items, key) => {
+      if (!Array.isArray(items)) return {};
+      const groups = {};
+      for (const item of items) {
+        const groupKey = String(item[key] ?? "undefined");
+        if (!groups[groupKey]) groups[groupKey] = [];
+        groups[groupKey].push(item);
+      }
+      return groups;
+    },
+    unique: (items) => {
+      if (!Array.isArray(items)) return [];
+      return [...new Set(items)];
+    },
+    count: (items) => Array.isArray(items) ? items.length : 0,
+    compact: (items) => {
+      if (!Array.isArray(items)) return [];
+      return items.filter((item) => item != null);
+    }
+  };
+}
+function deepFreeze(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      deepFreeze(item);
+    }
+    return Object.freeze(obj);
+  }
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (value !== null && typeof value === "object") {
+      deepFreeze(value);
+    }
+  }
+  return Object.freeze(obj);
+}
+function createScriptContext(node, queryFn) {
+  const frozenNode = deepFreeze({ ...node });
+  const format = Object.freeze(createFormatHelpers());
+  const math = Object.freeze(createMathHelpers());
+  const text3 = Object.freeze(createTextHelpers());
+  const array = Object.freeze(createArrayHelpers());
+  const context = {
+    node: frozenNode,
+    nodes: (schemaIRI) => {
+      const results = queryFn(schemaIRI);
+      return Object.freeze(results.map((n) => deepFreeze({ ...n })));
+    },
+    now: () => Date.now(),
+    format,
+    math,
+    text: text3,
+    array
+  };
+  return Object.freeze(context);
+}
+
+// src/sandbox/ast-validator.ts
+import * as acorn from "acorn";
+var FORBIDDEN_GLOBALS = /* @__PURE__ */ new Set([
+  // Browser globals
+  "window",
+  "document",
+  "globalThis",
+  "self",
+  "parent",
+  "top",
+  "frames",
+  // Network access
+  "fetch",
+  "XMLHttpRequest",
+  "WebSocket",
+  "EventSource",
+  "Request",
+  "Response",
+  // Storage
+  "localStorage",
+  "sessionStorage",
+  "indexedDB",
+  "caches",
+  // Code execution (dangerous)
+  "eval",
+  "Function",
+  // Node.js globals
+  "require",
+  "module",
+  "exports",
+  "process",
+  "Buffer",
+  "__dirname",
+  "__filename",
+  // Timers (could be used for timing attacks or resource exhaustion)
+  "setTimeout",
+  "setInterval",
+  "setImmediate",
+  "requestAnimationFrame",
+  "requestIdleCallback",
+  "clearTimeout",
+  "clearInterval",
+  "clearImmediate",
+  "cancelAnimationFrame",
+  "cancelIdleCallback",
+  // Browser APIs
+  "navigator",
+  "location",
+  "history",
+  "screen",
+  "alert",
+  "confirm",
+  "prompt",
+  "open",
+  "close",
+  "print",
+  // Web Workers
+  "Worker",
+  "SharedWorker",
+  "ServiceWorker",
+  // Other dangerous APIs
+  "Proxy",
+  "Reflect",
+  "SharedArrayBuffer",
+  "Atomics",
+  "WebAssembly",
+  "crypto",
+  "performance"
+]);
+var FORBIDDEN_PROPERTIES = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype",
+  "__defineGetter__",
+  "__defineSetter__",
+  "__lookupGetter__",
+  "__lookupSetter__"
+]);
+function walkAST(node, visitors) {
+  if (!node || typeof node !== "object") return;
+  const nodeType = node.type;
+  const visitor = visitors[nodeType];
+  if (visitor) {
+    visitor(node);
+  }
+  for (const key of Object.keys(node)) {
+    if (key === "type" || key === "start" || key === "end" || key === "loc" || key === "range") {
+      continue;
+    }
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        if (item && typeof item === "object" && "type" in item) {
+          walkAST(item, visitors);
+        }
+      }
+    } else if (child && typeof child === "object" && "type" in child) {
+      walkAST(child, visitors);
+    }
+  }
+}
+function validateScriptAST(code) {
+  const errors = [];
+  const declaredVars = /* @__PURE__ */ new Set();
+  try {
+    const trimmed = code.trim();
+    const wrappedCode = trimmed.startsWith("(") || trimmed.startsWith("function") ? trimmed : `(${trimmed})`;
+    const ast = acorn.parse(wrappedCode, {
+      ecmaVersion: 2022,
+      sourceType: "script",
+      // No import/export
+      allowReturnOutsideFunction: true
+    });
+    walkAST(ast, {
+      VariableDeclarator: (node) => {
+        if (node.id?.type === "Identifier") {
+          declaredVars.add(node.id.name);
+        }
+      },
+      FunctionDeclaration: (node) => {
+        if (node.id?.name) {
+          declaredVars.add(node.id.name);
+        }
+      },
+      FunctionExpression: (node) => {
+        if (node.id?.name) {
+          declaredVars.add(node.id.name);
+        }
+      },
+      ArrowFunctionExpression: (node) => {
+        for (const param of node.params || []) {
+          if (param.type === "Identifier") {
+            declaredVars.add(param.name);
+          }
+        }
+      }
+    });
+    walkAST(ast, {
+      FunctionDeclaration: (node) => {
+        for (const param of node.params || []) {
+          if (param.type === "Identifier") {
+            declaredVars.add(param.name);
+          }
+        }
+      },
+      FunctionExpression: (node) => {
+        for (const param of node.params || []) {
+          if (param.type === "Identifier") {
+            declaredVars.add(param.name);
+          }
+        }
+      }
+    });
+    walkAST(ast, {
+      VariableDeclarator: (node) => {
+        if (node.id.type === "Identifier") {
+          declaredVars.add(node.id.name);
+        }
+      },
+      FunctionDeclaration: (node) => {
+        if (node.id?.name) {
+          declaredVars.add(node.id.name);
+        }
+      },
+      FunctionExpression: (node) => {
+        if (node.id?.name) {
+          declaredVars.add(node.id.name);
+        }
+      },
+      ArrowFunctionExpression: (node) => {
+        for (const param of node.params) {
+          if (param.type === "Identifier") {
+            declaredVars.add(param.name);
+          }
+        }
+      }
+    });
+    walkAST(ast, {
+      FunctionDeclaration: (node) => {
+        for (const param of node.params) {
+          if (param.type === "Identifier") {
+            declaredVars.add(param.name);
+          }
+        }
+      },
+      FunctionExpression: (node) => {
+        for (const param of node.params) {
+          if (param.type === "Identifier") {
+            declaredVars.add(param.name);
+          }
+        }
+      }
+    });
+    walkAST(ast, {
+      // Check for forbidden globals
+      Identifier: (node) => {
+        const name = node.name;
+        if (declaredVars.has(name)) return;
+        const safeBuiltins = /* @__PURE__ */ new Set([
+          "undefined",
+          "null",
+          "true",
+          "false",
+          "NaN",
+          "Infinity",
+          "Array",
+          "Object",
+          "String",
+          "Number",
+          "Boolean",
+          "Date",
+          "Math",
+          "JSON",
+          "Error",
+          "TypeError",
+          "RangeError",
+          "Map",
+          "Set",
+          "WeakMap",
+          "WeakSet",
+          "Symbol",
+          "BigInt",
+          "Promise",
+          "parseInt",
+          "parseFloat",
+          "isNaN",
+          "isFinite",
+          "encodeURI",
+          "encodeURIComponent",
+          "decodeURI",
+          "decodeURIComponent"
+        ]);
+        if (safeBuiltins.has(name)) return;
+        if (FORBIDDEN_GLOBALS.has(name)) {
+          errors.push(`Forbidden global access: '${name}' at position ${node.start}`);
+        }
+      },
+      // No import statements
+      ImportDeclaration: (node) => {
+        errors.push(`Import statements are not allowed at position ${node.start}`);
+      },
+      // No export statements
+      ExportNamedDeclaration: (node) => {
+        errors.push(`Export statements are not allowed at position ${node.start}`);
+      },
+      ExportDefaultDeclaration: (node) => {
+        errors.push(`Export statements are not allowed at position ${node.start}`);
+      },
+      ExportAllDeclaration: (node) => {
+        errors.push(`Export statements are not allowed at position ${node.start}`);
+      },
+      // No dynamic import()
+      ImportExpression: (node) => {
+        errors.push(`Dynamic import() is not allowed at position ${node.start}`);
+      },
+      // No async/await (scripts must be synchronous for predictability)
+      AwaitExpression: (node) => {
+        errors.push(`Async/await is not allowed at position ${node.start}`);
+      },
+      // Check for async functions
+      FunctionDeclaration: (node) => {
+        if (node.async) {
+          errors.push(`Async functions are not allowed at position ${node.start}`);
+        }
+      },
+      FunctionExpression: (node) => {
+        if (node.async) {
+          errors.push(`Async functions are not allowed at position ${node.start}`);
+        }
+      },
+      ArrowFunctionExpression: (node) => {
+        if (node.async) {
+          errors.push(`Async arrow functions are not allowed at position ${node.start}`);
+        }
+      },
+      // No new Function()
+      NewExpression: (node) => {
+        if (node.callee?.type === "Identifier" && node.callee.name === "Function") {
+          errors.push(`new Function() is not allowed at position ${node.start}`);
+        }
+      },
+      // Check for forbidden property access
+      MemberExpression: (node) => {
+        if (node.computed && node.property?.type === "Literal") {
+          const propName = String(node.property.value);
+          if (FORBIDDEN_PROPERTIES.has(propName)) {
+            errors.push(`Access to '${propName}' is forbidden at position ${node.property.start}`);
+          }
+        }
+        if (!node.computed && node.property?.type === "Identifier") {
+          if (FORBIDDEN_PROPERTIES.has(node.property.name)) {
+            errors.push(
+              `Access to '${node.property.name}' is forbidden at position ${node.property.start}`
+            );
+          }
+        }
+      },
+      // No with statements
+      WithStatement: (node) => {
+        errors.push(`'with' statements are not allowed at position ${node.start}`);
+      },
+      // Check for eval() calls
+      CallExpression: (node) => {
+        if (node.callee?.type === "Identifier" && node.callee.name === "eval") {
+          errors.push(`eval() is not allowed at position ${node.start}`);
+        }
+      }
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    errors.push(`Syntax error: ${message}`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function quickSafetyCheck(code) {
+  const lowerCode = code.toLowerCase();
+  const dangerousPatterns = [
+    "import ",
+    "require(",
+    "eval(",
+    "__proto__",
+    "constructor(",
+    "function(",
+    "fetch(",
+    "xmlhttprequest",
+    "websocket",
+    "localstorage",
+    "sessionstorage",
+    "indexeddb",
+    "document.",
+    "window.",
+    "globalthis",
+    "process.",
+    "child_process"
+  ];
+  for (const pattern of dangerousPatterns) {
+    if (lowerCode.includes(pattern)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/sandbox/sandbox.ts
+var ScriptError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+    this.name = "ScriptError";
+  }
+};
+var ScriptTimeoutError = class extends ScriptError {
+  constructor(timeoutMs) {
+    super("Script execution timed out", [`Exceeded ${timeoutMs}ms limit`]);
+    this.name = "ScriptTimeoutError";
+  }
+};
+var ScriptValidationError = class extends ScriptError {
+  constructor(errors) {
+    super("Script validation failed", errors);
+    this.name = "ScriptValidationError";
+  }
+};
+var ScriptSandbox = class {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      timeoutMs: options.timeoutMs ?? 1e3,
+      validateAST: options.validateAST ?? true,
+      telemetry: options.telemetry
+    };
+  }
+  /**
+   * 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
+   */
+  async execute(code, context) {
+    const start = this.options.telemetry ? Date.now() : 0;
+    if (this.options.validateAST) {
+      const validation = validateScriptAST(code);
+      if (!validation.valid) {
+        this.options.telemetry?.reportUsage("plugins.ast_validation_failure", 1);
+        throw new ScriptValidationError(validation.errors);
+      }
+    }
+    const fn = this.createIsolatedFunction(code);
+    try {
+      const result = await this.executeWithTimeout(fn, context);
+      const sanitized = this.sanitizeOutput(result);
+      this.options.telemetry?.reportPerformance("plugins.execute", Date.now() - start);
+      this.options.telemetry?.reportUsage("plugins.execute", 1);
+      return sanitized;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.options.telemetry?.reportCrash(error, { codeNamespace: "plugins.ScriptSandbox.execute" });
+      this.options.telemetry?.reportUsage("plugins.execute_failure", 1);
+      throw err;
+    }
+  }
+  /**
+   * Execute a script synchronously (for computed columns).
+   * Use with caution - no timeout protection in sync mode.
+   */
+  executeSync(code, context) {
+    const start = this.options.telemetry ? Date.now() : 0;
+    if (this.options.validateAST) {
+      const validation = validateScriptAST(code);
+      if (!validation.valid) {
+        this.options.telemetry?.reportUsage("plugins.ast_validation_failure", 1);
+        throw new ScriptValidationError(validation.errors);
+      }
+    }
+    const fn = this.createIsolatedFunction(code);
+    try {
+      const result = fn(context);
+      const sanitized = this.sanitizeOutput(result);
+      this.options.telemetry?.reportPerformance("plugins.execute_sync", Date.now() - start);
+      this.options.telemetry?.reportUsage("plugins.execute_sync", 1);
+      return sanitized;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.options.telemetry?.reportCrash(error, {
+        codeNamespace: "plugins.ScriptSandbox.executeSync"
+      });
+      this.options.telemetry?.reportUsage("plugins.execute_sync_failure", 1);
+      throw new ScriptError("Script execution error", [
+        err instanceof Error ? err.message : String(err)
+      ]);
+    }
+  }
+  /**
+   * Create an isolated function from user code.
+   *
+   * The function receives context values as arguments and has dangerous
+   * globals shadowed to undefined in its scope.
+   */
+  createIsolatedFunction(code) {
+    const wrapped = `
+      "use strict";
+      // Shadow dangerous globals (except 'eval' which is reserved in strict mode)
+      var window = void 0;
+      var document = void 0;
+      var globalThis = void 0;
+      var self = void 0;
+      var parent = void 0;
+      var top = void 0;
+      var frames = void 0;
+      var fetch = void 0;
+      var XMLHttpRequest = void 0;
+      var WebSocket = void 0;
+      var require = void 0;
+      var process = void 0;
+      var Buffer = void 0;
+      var setTimeout = void 0;
+      var setInterval = void 0;
+      var setImmediate = void 0;
+      var requestAnimationFrame = void 0;
+      var localStorage = void 0;
+      var sessionStorage = void 0;
+      var indexedDB = void 0;
+      var navigator = void 0;
+      var location = void 0;
+      var history = void 0;
+      var Worker = void 0;
+      var SharedWorker = void 0;
+      var ServiceWorker = void 0;
+      var Proxy = void 0;
+      var Reflect = void 0;
+      var WebAssembly = void 0;
+      var crypto = void 0;
+      // Return the user's function/expression
+      return (${code.trim()});
+    `;
+    const factory = new Function("node", "nodes", "now", "format", "math", "text", "array", wrapped);
+    return (ctx) => {
+      const userFn = factory(
+        ctx.node,
+        ctx.nodes,
+        ctx.now,
+        ctx.format,
+        ctx.math,
+        ctx.text,
+        ctx.array
+      );
+      if (typeof userFn === "function") {
+        return userFn(ctx.node, ctx);
+      }
+      return userFn;
+    };
+  }
+  /**
+   * Execute a function with a timeout.
+   */
+  executeWithTimeout(fn, ctx) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new ScriptTimeoutError(this.options.timeoutMs));
+      }, this.options.timeoutMs);
+      try {
+        const result = fn(ctx);
+        clearTimeout(timer);
+        resolve(result);
+      } catch (err) {
+        clearTimeout(timer);
+        reject(
+          new ScriptError("Script execution error", [
+            err instanceof Error ? err.message : String(err)
+          ])
+        );
+      }
+    });
+  }
+  /**
+   * 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
+   */
+  sanitizeOutput(result, seen = /* @__PURE__ */ new WeakSet()) {
+    if (result === null || result === void 0) return result;
+    if (typeof result === "string") return result;
+    if (typeof result === "number") return Number.isFinite(result) ? result : null;
+    if (typeof result === "boolean") return result;
+    if (typeof result === "function") return void 0;
+    if (typeof result === "symbol") return void 0;
+    if (Array.isArray(result)) {
+      if (seen.has(result)) return void 0;
+      seen.add(result);
+      return result.map((item) => this.sanitizeOutput(item, seen));
+    }
+    if (typeof result === "object") {
+      if (seen.has(result)) return void 0;
+      seen.add(result);
+      const proto = Object.getPrototypeOf(result);
+      if (proto !== null && proto !== Object.prototype) {
+        if (result instanceof Date) {
+          return result.getTime();
+        }
+        return void 0;
+      }
+      const clean = {};
+      for (const [key, value] of Object.entries(result)) {
+        if (key.startsWith("__")) continue;
+        if (typeof key === "symbol") continue;
+        const sanitized = this.sanitizeOutput(value, seen);
+        if (sanitized !== void 0) {
+          clean[key] = sanitized;
+        }
+      }
+      return clean;
+    }
+    return void 0;
+  }
+};
+async function executeScript(code, context) {
+  const sandbox = new ScriptSandbox();
+  return sandbox.execute(code, context);
+}
+function validateScript(code) {
+  return validateScriptAST(code);
+}
+
+// src/sandbox/runner.ts
+var ScriptRunner = class {
+  sandbox;
+  store;
+  subscriptions = [];
+  scriptSubscriptions = /* @__PURE__ */ new Map();
+  started = false;
+  telemetry;
+  constructor(options) {
+    this.store = options.store;
+    this.telemetry = options.telemetry;
+    this.sandbox = new ScriptSandbox({ ...options.sandboxOptions, telemetry: options.telemetry });
+  }
+  /**
+   * Start the script runner.
+   * Registers all enabled scripts and sets up triggers.
+   */
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    const scripts = this.store.list({ schemaIRI: "xnet://xnet.dev/Script" });
+    for (const script of scripts) {
+      if (script.enabled) {
+        this.registerScript(script);
+      }
+    }
+    const unsubScripts = this.store.subscribe((event) => {
+      if (event.node?.schemaIRI === "xnet://xnet.dev/Script") {
+        this.handleScriptChange(event);
+      }
+    });
+    this.subscriptions.push(unsubScripts);
+  }
+  /**
+   * Stop the script runner.
+   * Removes all triggers and subscriptions.
+   */
+  stop() {
+    this.started = false;
+    for (const unsub of this.subscriptions) {
+      unsub();
+    }
+    this.subscriptions = [];
+    for (const unsub of this.scriptSubscriptions.values()) {
+      unsub();
+    }
+    this.scriptSubscriptions.clear();
+  }
+  /**
+   * Execute a script manually for testing/preview.
+   * Does not update lastRun/lastError on the script node.
+   */
+  async executeManual(code, node) {
+    const startTime = Date.now();
+    try {
+      const context = createScriptContext(node, (schemaIRI) => this.store.list({ schemaIRI }));
+      const result = await this.sandbox.execute(code, context);
+      return {
+        success: true,
+        result,
+        durationMs: Date.now() - startTime
+      };
+    } catch (err) {
+      const errorMsg = err instanceof ScriptError ? err.details.join("; ") : err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        error: errorMsg,
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  /**
+   * Execute a script as a computed value (synchronous).
+   * Used for computed columns in table views.
+   */
+  computeValue(code, node) {
+    const context = createScriptContext(node, (schemaIRI) => this.store.list({ schemaIRI }));
+    return this.sandbox.executeSync(code, context);
+  }
+  // ─── Private Methods ───────────────────────────────────────────────────────
+  /**
+   * Register a script and set up its trigger.
+   */
+  registerScript(script) {
+    this.unregisterScript(script.id);
+    const trigger = script.triggerType;
+    switch (trigger) {
+      case "onChange":
+        this.registerOnChangeTrigger(script);
+        break;
+      case "manual":
+        break;
+      case "onView":
+        break;
+      case "scheduled":
+        console.warn(`Scheduled triggers not yet implemented for script: ${script.name}`);
+        break;
+    }
+  }
+  /**
+   * Unregister a script's trigger.
+   */
+  unregisterScript(scriptId) {
+    const unsub = this.scriptSubscriptions.get(scriptId);
+    if (unsub) {
+      unsub();
+      this.scriptSubscriptions.delete(scriptId);
+    }
+  }
+  /**
+   * Register an onChange trigger for a script.
+   */
+  registerOnChangeTrigger(script) {
+    if (!script.inputSchema) {
+      console.warn(`onChange script '${script.name}' has no inputSchema`);
+      return;
+    }
+    const unsub = this.store.subscribe(async (event) => {
+      if (event.type !== "update" && event.type !== "create") return;
+      if (!event.node || event.node.schemaIRI !== script.inputSchema) return;
+      if (script.triggerProperty && event.change.payload) {
+        if (!(script.triggerProperty in event.change.payload)) {
+          return;
+        }
+      }
+      await this.executeScript(script, event.node);
+    });
+    this.scriptSubscriptions.set(script.id, unsub);
+  }
+  /**
+   * Execute a script and handle results.
+   */
+  async executeScript(script, targetNode) {
+    const startTime = Date.now();
+    try {
+      const context = createScriptContext(targetNode, (schemaIRI) => this.store.list({ schemaIRI }));
+      const result = await this.sandbox.execute(script.code, context);
+      if (result && typeof result === "object") {
+        const outputType = script.outputType;
+        if (outputType === "mutation") {
+          await this.store.update(targetNode.id, result);
+        } else if (outputType === "decoration") {
+          await this.store.update(targetNode.id, { _decoration: result });
+        }
+      }
+      this.telemetry?.reportPerformance("plugins.script_execution", Date.now() - startTime);
+      await this.store.update(script.id, {
+        lastRun: Date.now(),
+        lastError: null
+      });
+    } catch (err) {
+      const errorMsg = err instanceof ScriptError ? err.details.join("; ") : err instanceof Error ? err.message : String(err);
+      this.telemetry?.reportUsage("plugins.crash_recovery", 1);
+      await this.store.update(script.id, {
+        lastRun: Date.now(),
+        lastError: errorMsg
+      });
+      console.error(`Script '${script.name}' failed:`, errorMsg);
+    }
+  }
+  /**
+   * Handle changes to script nodes.
+   */
+  handleScriptChange(event) {
+    const script = event.node;
+    if (!script) return;
+    switch (event.type) {
+      case "create":
+        if (script.enabled) {
+          this.registerScript(script);
+        }
+        break;
+      case "update":
+        if (script.enabled) {
+          this.registerScript(script);
+        } else {
+          this.unregisterScript(script.id);
+        }
+        break;
+      case "delete":
+        this.unregisterScript(script.id);
+        break;
+    }
+  }
+};
+
+// src/ai/prompt.ts
+var SYSTEM_CONTEXT = `You are generating a JavaScript script for xNet, a collaborative data platform.
+The script is a pure function that receives a node (data record) and a context object.
+It must return a value, a mutation object, or null.
+
+CRITICAL CONSTRAINTS:
+- NO imports, require, or dynamic import
+- NO fetch, XMLHttpRequest, or network access
+- NO DOM access (window, document, globalThis)
+- NO async/await, setTimeout, setInterval
+- NO eval, Function constructor, or __proto__ access
+- Pure synchronous function only
+- Must use arrow function syntax: (node, ctx) => ...`;
+var API_DOCUMENTATION = `
+## Available API
+
+The function signature is: (node, ctx) => result
+
+### node (read-only)
+The current data record. Access properties directly: node.propertyName
+
+### ctx object (ScriptContext)
+
+**Query:**
+- ctx.nodes(schemaIRI?) - Query nodes, optionally filtered by schema. Returns frozen array.
+
+**Time:**
+- ctx.now() - Current timestamp in milliseconds
+
+**Format Helpers (ctx.format):**
+- ctx.format.date(timestamp, options?) - Format timestamp as date string
+- ctx.format.number(value, options?) - Format number with locale
+- ctx.format.currency(value, currency?, locale?) - Format as currency (default: USD)
+- ctx.format.relative(timestamp) - Relative time ("2h ago", "3d ago")
+- ctx.format.bytes(bytes) - Format bytes ("1.5 KB", "2.3 MB")
+
+**Math Helpers (ctx.math):**
+- ctx.math.sum(numbers[]) - Sum of array
+- ctx.math.avg(numbers[]) - Average of array
+- ctx.math.min(numbers[]) - Minimum value
+- ctx.math.max(numbers[]) - Maximum value
+- ctx.math.round(value, decimals?) - Round to decimal places
+- ctx.math.clamp(value, min, max) - Clamp between min and max
+- ctx.math.abs(value) - Absolute value
+- ctx.math.floor(value) - Floor
+- ctx.math.ceil(value) - Ceiling
+
+**Text Helpers (ctx.text):**
+- ctx.text.slugify(str) - Convert to URL-safe slug
+- ctx.text.truncate(str, maxLength) - Truncate with ellipsis
+- ctx.text.capitalize(str) - Capitalize first letter
+- ctx.text.titleCase(str) - Title Case Each Word
+- ctx.text.contains(str, search) - Case-insensitive contains
+- ctx.text.template(template, vars) - Simple {var} replacement
+- ctx.text.trim(str) - Trim whitespace
+- ctx.text.lower(str) - Lowercase
+- ctx.text.upper(str) - Uppercase
+
+**Array Helpers (ctx.array):**
+- ctx.array.first(items) - Get first element
+- ctx.array.last(items) - Get last element
+- ctx.array.sortBy(items, key, desc?) - Sort by property
+- ctx.array.groupBy(items, key) - Group by property
+- ctx.array.unique(items) - Remove duplicates
+- ctx.array.count(items) - Count items
+- ctx.array.compact(items) - Remove null/undefined
+`;
+function formatSchemaProperties(properties) {
+  if (properties.length === 0) {
+    return "(No properties defined)";
+  }
+  return properties.map((prop) => {
+    let line = `- node.${prop.name}: ${prop.type}`;
+    if (prop.required) line += " (required)";
+    if (prop.description) line += ` - ${prop.description}`;
+    return line;
+  }).join("\n");
+}
+function getOutputTypeDescription(type) {
+  switch (type) {
+    case "value":
+      return `Return a computed value (string, number, boolean, or object).
+Used as a virtual/computed column in table views.
+Example: (node) => node.quantity * node.unitPrice`;
+    case "mutation":
+      return `Return an object with property updates to merge into the node.
+The returned object's properties will be applied to the node.
+Example: (node) => node.amount > 1000 ? { priority: 'high' } : null`;
+    case "decoration":
+      return `Return an object with visual decorations (not persisted to node data).
+Use for tags, badges, or highlights based on conditions.
+Example: (node) => node.dueDate < ctx.now() ? { _decoration: 'OVERDUE' } : null`;
+    case "void":
+      return `Return null. Script runs for side effects only (logging, etc).
+Example: (node) => { console.log(node.id); return null }`;
+  }
+}
+function getTriggerTypeDescription(type) {
+  switch (type) {
+    case "manual":
+      return "Run manually via UI button";
+    case "onChange":
+      return "Run automatically when the node is created or updated";
+    case "onView":
+      return "Run when computing the value for display (lazy evaluation)";
+    case "scheduled":
+      return "Run on a schedule (cron)";
+  }
+}
+function formatExamples(examples) {
+  if (examples.length === 0) return "";
+  const simplified = examples.slice(0, 3).map((node) => {
+    const { id, schemaIRI, ...rest } = node;
+    return rest;
+  });
+  return `
+## Sample Data
+Here are example nodes to understand the data structure:
+\`\`\`json
+${JSON.stringify(simplified, null, 2)}
+\`\`\``;
+}
+function buildScriptPrompt(request) {
+  const {
+    intent,
+    schema,
+    outputType,
+    triggerType = "onChange",
+    examples = [],
+    constraints = []
+  } = request;
+  const sections = [];
+  sections.push(SYSTEM_CONTEXT);
+  sections.push(API_DOCUMENTATION);
+  sections.push(`
+## Schema: ${schema.name}
+Schema IRI: ${schema.schemaIRI}
+
+Available properties:
+${formatSchemaProperties(schema.properties)}`);
+  sections.push(`
+## Output Type: ${outputType}
+${getOutputTypeDescription(outputType)}`);
+  sections.push(`
+## Trigger: ${triggerType}
+${getTriggerTypeDescription(triggerType)}`);
+  if (examples.length > 0) {
+    sections.push(formatExamples(examples));
+  }
+  if (constraints.length > 0) {
+    sections.push(`
+## Additional Requirements
+${constraints.map((c) => `- ${c}`).join("\n")}`);
+  }
+  sections.push(`
+## User Request
+"${intent}"
+
+Generate ONLY the arrow function expression. No markdown code fences, no explanation.
+The function should handle edge cases (null values, missing properties) gracefully.
+
+Format: (node, ctx) => { ... } or (node, ctx) => expression`);
+  return sections.join("\n");
+}
+function buildRetryPrompt(originalPrompt, errors) {
+  return `${originalPrompt}
+
+---
+IMPORTANT: Your previous attempt had validation errors:
+${errors.map((e) => `- ${e}`).join("\n")}
+
+Please fix these issues and generate a corrected version.
+Remember: NO forbidden globals, NO async/await, NO imports.`;
+}
+
+// src/ai/providers.ts
+var AIGenerationError = class extends Error {
+  constructor(message, provider, cause) {
+    super(message);
+    this.provider = provider;
+    this.cause = cause;
+    this.name = "AIGenerationError";
+  }
+};
+var AnthropicProvider = class {
+  name = "Anthropic";
+  apiKey;
+  baseUrl;
+  model;
+  maxTokens;
+  temperature;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("Anthropic API key is required");
+    }
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl ?? "https://api.anthropic.com";
+    this.model = options.model ?? "claude-sonnet-4-20250514";
+    this.maxTokens = options.maxTokens ?? 2048;
+    this.temperature = options.temperature ?? 0.3;
+  }
+  async generate(prompt) {
+    try {
+      const response = await fetch(`${this.baseUrl}/v1/messages`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-api-key": this.apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: this.model,
+          max_tokens: this.maxTokens,
+          temperature: this.temperature,
+          messages: [{ role: "user", content: prompt }]
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new AIGenerationError(`Anthropic API error: ${response.status} ${error}`, this.name);
+      }
+      const data = await response.json();
+      const textContent = data.content.find((c) => c.type === "text");
+      if (!textContent) {
+        throw new AIGenerationError("No text content in response", this.name);
+      }
+      return textContent.text;
+    } catch (err) {
+      if (err instanceof AIGenerationError) throw err;
+      throw new AIGenerationError(
+        `Anthropic generation failed: ${err instanceof Error ? err.message : String(err)}`,
+        this.name,
+        err
+      );
+    }
+  }
+};
+var OpenAIProvider = class {
+  name = "OpenAI";
+  apiKey;
+  baseUrl;
+  model;
+  maxTokens;
+  temperature;
+  constructor(options) {
+    if (!options.apiKey) {
+      throw new Error("OpenAI API key is required");
+    }
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl ?? "https://api.openai.com";
+    this.model = options.model ?? "gpt-4o";
+    this.maxTokens = options.maxTokens ?? 2048;
+    this.temperature = options.temperature ?? 0.3;
+  }
+  async generate(prompt) {
+    try {
+      const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          model: this.model,
+          max_tokens: this.maxTokens,
+          temperature: this.temperature,
+          messages: [{ role: "user", content: prompt }]
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new AIGenerationError(`OpenAI API error: ${response.status} ${error}`, this.name);
+      }
+      const data = await response.json();
+      if (!data.choices?.[0]?.message?.content) {
+        throw new AIGenerationError("No content in response", this.name);
+      }
+      return data.choices[0].message.content;
+    } catch (err) {
+      if (err instanceof AIGenerationError) throw err;
+      throw new AIGenerationError(
+        `OpenAI generation failed: ${err instanceof Error ? err.message : String(err)}`,
+        this.name,
+        err
+      );
+    }
+  }
+};
+var OllamaProvider = class {
+  name = "Ollama";
+  baseUrl;
+  model;
+  temperature;
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl ?? "http://localhost:11434";
+    this.model = options.model ?? "codellama";
+    this.temperature = options.temperature ?? 0.3;
+  }
+  async generate(prompt) {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/generate`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          model: this.model,
+          prompt,
+          stream: false,
+          options: {
+            temperature: this.temperature
+          }
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw new AIGenerationError(`Ollama API error: ${response.status} ${error}`, this.name);
+      }
+      const data = await response.json();
+      if (!data.response) {
+        throw new AIGenerationError("No response content", this.name);
+      }
+      return data.response;
+    } catch (err) {
+      if (err instanceof AIGenerationError) throw err;
+      throw new AIGenerationError(
+        `Ollama generation failed: ${err instanceof Error ? err.message : String(err)}`,
+        this.name,
+        err
+      );
+    }
+  }
+};
+function createAIProvider(config) {
+  switch (config.type) {
+    case "anthropic":
+      return new AnthropicProvider(config.options);
+    case "openai":
+      return new OpenAIProvider(config.options);
+    case "ollama":
+      return new OllamaProvider(config.options);
+    case "custom":
+      throw new Error("Custom provider requires manual instantiation");
+    default:
+      throw new Error(`Unknown AI provider type: ${config.type}`);
+  }
+}
+async function isOllamaAvailable(baseUrl = "http://localhost:11434") {
+  try {
+    const response = await fetch(`${baseUrl}/api/tags`, {
+      method: "GET",
+      signal: AbortSignal.timeout(2e3)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function listOllamaModels(baseUrl = "http://localhost:11434") {
+  try {
+    const response = await fetch(`${baseUrl}/api/tags`);
+    if (!response.ok) return [];
+    const data = await response.json();
+    return data.models?.map((m) => m.name) ?? [];
+  } catch {
+    return [];
+  }
+}
+
+// src/ai/generator.ts
+var ScriptGenerationError = class extends Error {
+  constructor(message, validationErrors, attempts) {
+    super(message);
+    this.validationErrors = validationErrors;
+    this.attempts = attempts;
+    this.name = "ScriptGenerationError";
+  }
+};
+var ScriptGenerator = class {
+  ai;
+  maxRetries;
+  throwOnValidationFailure;
+  constructor(ai, options = {}) {
+    this.ai = ai;
+    this.maxRetries = options.maxRetries ?? 2;
+    this.throwOnValidationFailure = options.throwOnValidationFailure ?? false;
+  }
+  /**
+   * 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
+   */
+  async generate(request) {
+    const prompt = buildScriptPrompt(request);
+    let attempts = 0;
+    let lastErrors = [];
+    let currentPrompt = prompt;
+    while (attempts <= this.maxRetries) {
+      attempts++;
+      try {
+        const raw = await this.ai.generate(currentPrompt);
+        const code = this.extractCode(raw);
+        const validation = validateScriptAST(code);
+        if (validation.valid) {
+          return {
+            code,
+            explanation: this.generateExplanation(request, code),
+            suggestedName: this.generateName(request.intent),
+            suggestedTrigger: request.triggerType ?? this.inferTrigger(request),
+            validated: true,
+            attempts
+          };
+        }
+        lastErrors = validation.errors;
+        if (attempts <= this.maxRetries) {
+          currentPrompt = buildRetryPrompt(prompt, validation.errors);
+        }
+      } catch (err) {
+        if (attempts > this.maxRetries) {
+          throw new ScriptGenerationError(
+            `AI generation failed after ${attempts} attempts: ${err instanceof Error ? err.message : String(err)}`,
+            lastErrors,
+            attempts
+          );
+        }
+      }
+    }
+    if (this.throwOnValidationFailure) {
+      throw new ScriptGenerationError(
+        `Script validation failed after ${attempts} attempts`,
+        lastErrors,
+        attempts
+      );
+    }
+    const lastRaw = await this.ai.generate(currentPrompt);
+    const lastCode = this.extractCode(lastRaw);
+    return {
+      code: lastCode,
+      explanation: this.generateExplanation(request, lastCode),
+      suggestedName: this.generateName(request.intent),
+      suggestedTrigger: request.triggerType ?? this.inferTrigger(request),
+      validated: false,
+      attempts
+    };
+  }
+  /**
+   * Extract code from AI response (strips markdown fences, etc.)
+   */
+  extractCode(raw) {
+    let text3 = raw.trim();
+    const fencedMatch = text3.match(/```(?:javascript|js|typescript|ts)?\s*\n?([\s\S]*?)```/);
+    if (fencedMatch) {
+      text3 = fencedMatch[1].trim();
+    }
+    if (text3.startsWith("`") && text3.endsWith("`")) {
+      text3 = text3.slice(1, -1).trim();
+    }
+    if (!text3.startsWith("(") && !text3.startsWith("function")) {
+      const arrowMatch = text3.match(/(\([^)]*\)\s*=>\s*[\s\S]+)/);
+      if (arrowMatch) {
+        text3 = arrowMatch[1];
+      }
+    }
+    return text3;
+  }
+  /**
+   * Generate an explanation for the script
+   */
+  generateExplanation(request, _code) {
+    const intent = request.intent.toLowerCase();
+    if (intent.includes("calculat") || intent.includes("comput")) {
+      return `Calculates ${intent.replace(/calculat\w*|comput\w*/i, "").trim()}`;
+    }
+    if (intent.includes("tag") || intent.includes("mark") || intent.includes("label")) {
+      return `Automatically ${intent}`;
+    }
+    if (intent.includes("check") || intent.includes("validat") || intent.includes("verify")) {
+      return `Validates that ${intent.replace(/check\w*|validat\w*|verify\w*/i, "").trim()}`;
+    }
+    return `Script that ${intent}`;
+  }
+  /**
+   * Generate a name from the intent
+   */
+  generateName(intent) {
+    const words = intent.replace(/[^a-zA-Z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 2).slice(0, 4);
+    if (words.length === 0) {
+      return "customScript";
+    }
+    return words.map((word, index) => {
+      const lower = word.toLowerCase();
+      if (index === 0) return lower;
+      return lower.charAt(0).toUpperCase() + lower.slice(1);
+    }).join("");
+  }
+  /**
+   * Infer the best trigger type from the request
+   */
+  inferTrigger(request) {
+    const intent = request.intent.toLowerCase();
+    const outputType = request.outputType;
+    if (outputType === "value") {
+      return "onView";
+    }
+    if (outputType === "mutation") {
+      if (intent.includes("when") || intent.includes("if") || intent.includes("auto") || intent.includes("automatic")) {
+        return "onChange";
+      }
+    }
+    return "manual";
+  }
+};
+async function generateScript(provider, request) {
+  const generator = new ScriptGenerator(provider);
+  return generator.generate(request);
+}
+
+// src/services/client.ts
+var SERVICE_IPC_CHANNELS = {
+  START: "xnet:service:start",
+  STOP: "xnet:service:stop",
+  RESTART: "xnet:service:restart",
+  STATUS: "xnet:service:status",
+  LIST_ALL: "xnet:service:list-all",
+  CALL: "xnet:service:call",
+  STATUS_UPDATE: "xnet:service:status-update",
+  OUTPUT: "xnet:service:output"
+};
+function getIPC() {
+  if (typeof window === "undefined") return null;
+  return window.xnetServices ?? null;
+}
+function createServiceClient() {
+  const ipc = getIPC();
+  if (!ipc) {
+    return createMockServiceClient();
+  }
+  return {
+    start: (definition) => ipc.invoke(SERVICE_IPC_CHANNELS.START, definition),
+    stop: (serviceId) => ipc.invoke(SERVICE_IPC_CHANNELS.STOP, serviceId),
+    restart: (serviceId) => ipc.invoke(SERVICE_IPC_CHANNELS.RESTART, serviceId),
+    status: (serviceId) => ipc.invoke(SERVICE_IPC_CHANNELS.STATUS, serviceId),
+    listAll: () => ipc.invoke(SERVICE_IPC_CHANNELS.LIST_ALL),
+    call: (serviceId, method, path, body) => ipc.invoke(SERVICE_IPC_CHANNELS.CALL, serviceId, method, path, body),
+    onStatusChange: (serviceId, callback) => {
+      const handler = (event) => {
+        if (event.serviceId === serviceId) {
+          callback(event.status);
+        }
+      };
+      ipc.on(SERVICE_IPC_CHANNELS.STATUS_UPDATE, handler);
+      return () => ipc.off(SERVICE_IPC_CHANNELS.STATUS_UPDATE, handler);
+    },
+    onOutput: (serviceId, callback) => {
+      const handler = (event) => {
+        if (event.serviceId === serviceId) {
+          callback(event);
+        }
+      };
+      ipc.on(SERVICE_IPC_CHANNELS.OUTPUT, handler);
+      return () => ipc.off(SERVICE_IPC_CHANNELS.OUTPUT, handler);
+    }
+  };
+}
+function createMockServiceClient() {
+  const notAvailable = () => {
+    throw new Error(
+      "Service client is only available in Electron. Make sure you are running in the Electron renderer process."
+    );
+  };
+  return {
+    start: notAvailable,
+    stop: notAvailable,
+    restart: notAvailable,
+    status: notAvailable,
+    listAll: notAvailable,
+    call: notAvailable,
+    onStatusChange: () => () => {
+    },
+    onOutput: () => () => {
+    }
+  };
+}
+function isServiceClientAvailable() {
+  return getIPC() !== null;
+}
+
+// src/services/webhook-emitter.ts
+var WebhookEmitter = class {
+  constructor(store) {
+    this.store = store;
+  }
+  webhooks = /* @__PURE__ */ new Map();
+  unsubscribe;
+  deliveryHistory = [];
+  maxHistorySize = 100;
+  /**
+   * Start listening for store changes.
+   * Must be called before webhooks will be sent.
+   */
+  start() {
+    if (this.unsubscribe) return;
+    this.unsubscribe = this.store.subscribe((event) => {
+      this.handleEvent(event);
+    });
+  }
+  /**
+   * Stop listening for store changes.
+   */
+  stop() {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = void 0;
+    }
+  }
+  /**
+   * Register a webhook configuration.
+   * Returns a disposable to unregister.
+   */
+  register(config) {
+    this.webhooks.set(config.id, { ...config, enabled: config.enabled ?? true });
+    return {
+      dispose: () => {
+        this.webhooks.delete(config.id);
+      }
+    };
+  }
+  /**
+   * Unregister a webhook by ID.
+   */
+  unregister(id) {
+    return this.webhooks.delete(id);
+  }
+  /**
+   * Get all registered webhooks.
+   */
+  getWebhooks() {
+    return Array.from(this.webhooks.values());
+  }
+  /**
+   * Get a webhook by ID.
+   */
+  getWebhook(id) {
+    return this.webhooks.get(id);
+  }
+  /**
+   * Update a webhook configuration.
+   */
+  updateWebhook(id, updates) {
+    const existing = this.webhooks.get(id);
+    if (!existing) return false;
+    this.webhooks.set(id, { ...existing, ...updates, id });
+    return true;
+  }
+  /**
+   * Get recent delivery history.
+   */
+  getDeliveryHistory() {
+    return [...this.deliveryHistory];
+  }
+  /**
+   * Clear delivery history.
+   */
+  clearDeliveryHistory() {
+    this.deliveryHistory = [];
+  }
+  // ─── Event Handling ──────────────────────────────────────────────────────────
+  handleEvent(event) {
+    const eventType = this.getEventType(event);
+    if (!eventType) return;
+    const payload = {
+      type: eventType,
+      timestamp: Date.now(),
+      node: event.node,
+      schema: event.node?.schemaId
+    };
+    for (const webhook of this.webhooks.values()) {
+      if (!webhook.enabled) continue;
+      if (!webhook.events.includes(eventType)) continue;
+      if (webhook.schema && event.node?.schemaId !== webhook.schema) continue;
+      this.send(webhook, payload).catch((err) => {
+        console.error(`[WebhookEmitter] Failed to send to ${webhook.url}:`, err);
+      });
+    }
+  }
+  getEventType(event) {
+    const changeType = event.change.type;
+    if (changeType === "node-change") {
+      if (event.node?.deleted) return "deleted";
+      return "updated";
+    }
+    return null;
+  }
+  // ─── Delivery ────────────────────────────────────────────────────────────────
+  async send(webhook, payload) {
+    const maxRetries = webhook.retries ?? 3;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        const result = await this.deliverWebhook(webhook, payload);
+        this.recordDelivery({
+          webhookId: webhook.id,
+          success: true,
+          statusCode: result.status,
+          attempts: attempt,
+          deliveredAt: Date.now()
+        });
+        return;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < maxRetries) {
+          await this.delay(1e3 * Math.pow(2, attempt - 1));
+        }
+      }
+    }
+    this.recordDelivery({
+      webhookId: webhook.id,
+      success: false,
+      error: lastError?.message ?? "Unknown error",
+      attempts: maxRetries
+    });
+  }
+  async deliverWebhook(webhook, payload) {
+    const body = JSON.stringify(payload);
+    const headers = {
+      "content-type": "application/json",
+      "user-agent": "xNet-Webhook/1.0"
+    };
+    if (webhook.secret) {
+      const signature = await this.sign(body, webhook.secret);
+      headers["x-xnet-signature"] = signature;
+      headers["x-xnet-signature-256"] = `sha256=${signature}`;
+    }
+    const response = await fetch(webhook.url, {
+      method: "POST",
+      headers,
+      body,
+      signal: AbortSignal.timeout(1e4)
+      // 10 second timeout
+    });
+    if (!response.ok) {
+      const text3 = await response.text().catch(() => "");
+      throw new Error(`HTTP ${response.status}: ${text3.slice(0, 200)}`);
+    }
+    return { status: response.status };
+  }
+  async sign(body, secret) {
+    const encoder = new TextEncoder();
+    const key = await crypto.subtle.importKey(
+      "raw",
+      encoder.encode(secret),
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["sign"]
+    );
+    const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(body));
+    return Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  recordDelivery(result) {
+    this.deliveryHistory.push(result);
+    if (this.deliveryHistory.length > this.maxHistorySize) {
+      this.deliveryHistory.shift();
+    }
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+function createWebhookEmitter(store) {
+  return new WebhookEmitter(store);
+}
+export {
+  AIGenerationError,
+  AnthropicProvider,
+  ContributionRegistry,
+  MiddlewareChain,
+  OllamaProvider,
+  OpenAIProvider,
+  PluginError,
+  PluginRegistry,
+  PluginSchema,
+  PluginValidationError,
+  SERVICE_IPC_CHANNELS,
+  ScriptError,
+  ScriptGenerationError,
+  ScriptGenerator,
+  ScriptRunner,
+  ScriptSandbox,
+  ScriptSchema,
+  ScriptTimeoutError,
+  ScriptValidationError,
+  ShortcutManager,
+  TypedRegistry,
+  WebhookEmitter,
+  buildRetryPrompt,
+  buildScriptPrompt,
+  createAIProvider,
+  createExtensionContext,
+  createExtensionStorage,
+  createScriptContext,
+  createServiceClient,
+  createWebhookEmitter,
+  defineExtension,
+  executeScript,
+  generateScript,
+  getPlatformCapabilities,
+  getShortcutManager,
+  installShortcutHandler,
+  isOllamaAvailable,
+  isScriptNode,
+  isServiceClientAvailable,
+  listOllamaModels,
+  quickSafetyCheck,
+  validateManifest,
+  validateScript,
+  validateScriptAST
+};