@sonicjs-cms/core 2.19.0 → 3.0.0-beta.11

package/dist/{chunk-TFNTM3OA.js → chunk-PDYRDYXI.js}

@@ -1,4 +1,6 @@
-import { PluginBuilder, manifest_default, TurnstileService } from './chunk-EXNEW5US.js';
+import { definePlugin, HOOK_CAPABILITY_MAP, SonicCapabilityError, setPluginDefinitions } from './chunk-HPAJKZAQ.js';
+import { isKnownHookEvent } from './chunk-RNZFGN4R.js';
+import { getCoreVersion } from './chunk-ZUEIQFE5.js';
 import { HOOKS } from './chunk-QXOZI5Q2.js';
 import { __commonJS, __toESM } from './chunk-V4OQ3NZ2.js';
 import { z } from 'zod';
@@ -2240,7 +2242,7 @@ var PluginValidator = class _PluginValidator {
     "auth",
     "content",
     "media",
-    "users",
+    "auth_user",
     "collections"
   ];
   static RESERVED_PATHS = [
@@ -2292,7 +2294,7 @@ var PluginValidator = class _PluginValidator {
           if (!/^[a-z][a-z0-9_]*$/.test(model.tableName)) {
             errors.push(`Invalid table name format: ${model.tableName}`);
           }
-          const systemTables = ["users", "collections", "content", "content_versions", "media", "api_tokens"];
+          const systemTables = ["auth_user", "collections", "content", "content_versions", "media", "auth_api_tokens"];
           if (systemTables.includes(model.tableName)) {
             errors.push(`Table name "${model.tableName}" conflicts with system table`);
           }
@@ -3082,6 +3084,638 @@ var PluginManager = class {
   }
 };
 
+// src/plugins/topo-sort.ts
+var PluginDependencyCycleError = class extends Error {
+  cycle;
+  constructor(pluginId2, visitStack) {
+    const idx = visitStack.indexOf(pluginId2);
+    const cycle = idx >= 0 ? [...visitStack.slice(idx), pluginId2] : [...visitStack, pluginId2];
+    super(`Plugin dependency cycle detected: ${cycle.join(" \u2192 ")}`);
+    this.name = "PluginDependencyCycleError";
+    this.cycle = cycle;
+  }
+};
+function topoSort(plugins, options = {}) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const p of plugins) {
+    const id = pluginId(p);
+    if (id) byId.set(id, p);
+  }
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(p) {
+    const id = pluginId(p) ?? Math.random().toString();
+    if (visited.has(id)) return;
+    if (visiting.has(id)) throw new PluginDependencyCycleError(id, [...visiting]);
+    visiting.add(id);
+    for (const dep of p.dependencies ?? []) {
+      const depPlugin = byId.get(dep);
+      if (!depPlugin) {
+        if (options.strict) {
+          throw new Error(
+            `Plugin "${id}" depends on "${dep}" which is not in the plugin list.`
+          );
+        } else {
+          console.warn(
+            `[plugins] Plugin "${id}" declares dependency "${dep}" which is not registered. The dependency will be skipped \u2014 boot order may be incorrect.`
+          );
+        }
+        continue;
+      }
+      visit(depPlugin);
+    }
+    visiting.delete(id);
+    visited.add(id);
+    result.push(p);
+  }
+  for (const p of plugins) visit(p);
+  return result;
+}
+function pluginId(p) {
+  return p.id ?? p.name ?? void 0;
+}
+
+// src/plugins/mount.ts
+var PluginRegisterMustBeSyncError = class extends Error {
+  constructor(pluginName) {
+    super(
+      `Plugin "${pluginName}" register() returned a Promise. register() must be synchronous because Hono's router locks after the first request. Move async work (hook subscriptions, services, crons) to onBoot()/lifecycle hooks.`
+    );
+    this.name = "PluginRegisterMustBeSyncError";
+  }
+};
+function sortRoutesByPriority(routes) {
+  return routes.map((route, index) => ({ route, index })).sort((a, b) => {
+    const pa = a.route.priority ?? 0;
+    const pb = b.route.priority ?? 0;
+    if (pb !== pa) return pb - pa;
+    return a.index - b.index;
+  }).map((entry) => entry.route);
+}
+function mountPlugin(app, plugin, result) {
+  if (!plugin || typeof plugin !== "object" || !plugin.name) {
+    result?.skipped.push({ plugin: String(plugin?.name ?? "unknown"), reason: "not a valid plugin object" });
+    return;
+  }
+  if (Array.isArray(plugin.routes) && plugin.routes.length > 0) {
+    for (const route of sortRoutesByPriority(plugin.routes)) {
+      if (!route || !route.path || !route.handler) {
+        result?.skipped.push({ plugin: plugin.name, reason: `invalid route entry (missing path or handler)` });
+        continue;
+      }
+      app.route(route.path, route.handler);
+      result?.mounted.push({ plugin: plugin.name, path: route.path });
+    }
+  }
+  if (typeof plugin.register === "function") {
+    const maybePromise = plugin.register(app);
+    if (maybePromise && typeof maybePromise.then === "function") {
+      throw new PluginRegisterMustBeSyncError(plugin.name);
+    }
+  }
+}
+function registerPluginRoutes(app, plugins, options = {}) {
+  const result = { mounted: [], skipped: [] };
+  const warnOnDuplicatePath = options.warnOnDuplicatePath ?? (typeof process === "undefined" || process.env?.NODE_ENV !== "production");
+  const seenPaths = /* @__PURE__ */ new Map();
+  const sortByDependencies = options.sortByDependencies ?? true;
+  const sorted = sortByDependencies ? topoSort(plugins.filter((p) => !!p && typeof p === "object"), {
+    strict: options.strict
+  }) : plugins.filter((p) => !!p && typeof p === "object");
+  for (const plugin of sorted) {
+    if (!plugin) continue;
+    const before = result.mounted.length;
+    mountPlugin(app, plugin, result);
+    if (warnOnDuplicatePath) {
+      for (let i = before; i < result.mounted.length; i++) {
+        const entry = result.mounted[i];
+        if (!entry) continue;
+        const { plugin: owner, path } = entry;
+        const prior = seenPaths.get(path);
+        if (prior && prior !== owner) {
+          console.warn(
+            `[plugins] Duplicate route path "${path}" mounted by "${owner}" \u2014 already claimed by "${prior}". The first registration wins; the later one is shadowed.`
+          );
+        } else if (!prior) {
+          seenPaths.set(path, owner);
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// src/plugins/wire.ts
+async function wireRegisteredPlugins(plugins, context, options = {}) {
+  const result = { subscribed: 0, booted: [], errors: [] };
+  const sortByDeps = options.sortByDependencies ?? true;
+  const raw = plugins.filter((p) => !!p && typeof p === "object");
+  const valid = sortByDeps ? topoSort(raw, { strict: options.strict }) : raw;
+  for (const plugin of valid) {
+    const name = plugin.name ?? "unknown";
+    if (!Array.isArray(plugin.hooks) || plugin.hooks.length === 0) continue;
+    for (const hook of plugin.hooks) {
+      if (!hook || typeof hook.name !== "string" || typeof hook.handler !== "function") {
+        result.errors.push({ plugin: name, phase: "subscribe", error: new Error("invalid hook entry") });
+        continue;
+      }
+      if (plugin.capabilities !== void 0 && isKnownHookEvent(hook.name)) {
+        const requiredCap = HOOK_CAPABILITY_MAP[hook.name];
+        if (requiredCap && !plugin.capabilities.includes(requiredCap)) {
+          const capErr = new SonicCapabilityError(requiredCap, name);
+          if (options.strict) {
+            result.errors.push({ plugin: name, phase: "subscribe", error: capErr });
+          } else {
+            console.warn(`[plugins] ${capErr.message} Hook "${hook.name}" will not be registered.`);
+          }
+          continue;
+        }
+      }
+      try {
+        context.hooks.register(hook.name, hook.handler, hook.priority);
+        result.subscribed++;
+      } catch (error) {
+        result.errors.push({ plugin: name, phase: "subscribe", error });
+      }
+    }
+  }
+  for (const plugin of valid) {
+    const name = plugin.name ?? "unknown";
+    if (typeof plugin.onBoot !== "function") continue;
+    try {
+      await plugin.onBoot(context);
+      result.booted.push(name);
+    } catch (error) {
+      result.errors.push({ plugin: name, phase: "onBoot", error });
+    }
+  }
+  if (context.env?.DB) {
+    reflectWiredPlugins(valid, context.env.DB).catch((err) => {
+      console.warn("[plugins] DB reflection failed (non-fatal):", err);
+    });
+  }
+  return result;
+}
+async function reflectWiredPlugins(plugins, db) {
+  const now = Date.now();
+  for (const plugin of plugins) {
+    const id = plugin.id ?? plugin.name;
+    if (!id) continue;
+    const displayName = plugin.name ?? id;
+    const version = plugin.version ?? "0.0.0";
+    const description = plugin.description ?? "";
+    const initialStatus = plugin.defaultActive ? "active" : "inactive";
+    try {
+      await db.prepare(
+        `INSERT INTO plugins (id, name, display_name, description, version, author, category,
+              status, is_core, installed_at, last_updated)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET
+             version = excluded.version,
+             display_name = excluded.display_name,
+             last_updated = excluded.last_updated`
+      ).bind(id, id, displayName, description, version, "core", "core", initialStatus, now, now).run();
+    } catch {
+    }
+  }
+}
+function createPluginWirer(plugins, ctxFactory) {
+  let started;
+  return () => {
+    if (!started) {
+      const list = typeof plugins === "function" ? plugins() : plugins;
+      started = wireRegisteredPlugins(list, ctxFactory());
+    }
+    return started;
+  };
+}
+
+// src/plugins/sdk/register-plugins.ts
+var import_semver2 = __toESM(require_semver2(), 1);
+
+// src/services/plugin-menu-singleton.ts
+var PUZZLE_PIECE = `<svg class="h-5 w-5" fill="currentColor" viewBox="0 0 20 20"><path d="M14.5 2A1.5 1.5 0 0013 3.5V4H8.5A1.5 1.5 0 007 5.5V10h-.5a1.5 1.5 0 100 3H7v4.5A1.5 1.5 0 008.5 19H13v-.5a1.5 1.5 0 113 0V19h.5a1.5 1.5 0 001.5-1.5V13h-.5a1.5 1.5 0 110-3h.5V5.5A1.5 1.5 0 0017 4h-.5v-.5A1.5 1.5 0 0014.5 2z"/></svg>`;
+var MENU_ICON_MAP = {
+  "puzzle-piece": PUZZLE_PIECE,
+  envelope: `<svg class="h-5 w-5" fill="currentColor" viewBox="0 0 20 20"><path d="M2.003 5.884L10 9.882l7.997-3.998A2 2 0 0016 4H4a2 2 0 00-1.997 1.884z"/><path d="M18 8.118l-8 4-8-4V14a2 2 0 002 2h12a2 2 0 002-2V8.118z"/></svg>`,
+  cog: `<svg class="h-5 w-5" fill="currentColor" viewBox="0 0 20 20"><path fill-rule="evenodd" d="M11.49 3.17c-.38-1.56-2.6-1.56-2.98 0a1.532 1.532 0 01-2.286.948c-1.372-.836-2.942.734-2.106 2.106.54.886.061 2.042-.947 2.287-1.561.379-1.561 2.6 0 2.978a1.532 1.532 0 01.947 2.287c-.836 1.372.734 2.942 2.106 2.106a1.532 1.532 0 012.287.947c.379 1.561 2.6 1.561 2.978 0a1.533 1.533 0 012.287-.947c1.372.836 2.942-.734 2.106-2.106a1.533 1.533 0 01.947-2.287c1.561-.379 1.561-2.6 0-2.978a1.532 1.532 0 01-.947-2.287c.836-1.372-.734-2.942-2.106-2.106a1.532 1.532 0 01-2.287-.947zM10 13a3 3 0 100-6 3 3 0 000 6z" clip-rule="evenodd"/></svg>`,
+  chart: `<svg class="h-5 w-5" fill="currentColor" viewBox="0 0 20 20"><path d="M2 11a1 1 0 011-1h2a1 1 0 011 1v5a1 1 0 01-1 1H3a1 1 0 01-1-1v-5zM8 7a1 1 0 011-1h2a1 1 0 011 1v9a1 1 0 01-1 1H9a1 1 0 01-1-1V7zM14 4a1 1 0 011-1h2a1 1 0 011 1v12a1 1 0 01-1 1h-2a1 1 0 01-1-1V4z"/></svg>`,
+  sparkles: `<svg class="h-5 w-5" fill="currentColor" viewBox="0 0 20 20"><path d="M9 4.804A7.968 7.968 0 005.5 4c-1.255 0-2.443.29-3.5.804v10A7.969 7.969 0 015.5 14c1.669 0 3.218.51 4.5 1.385A7.962 7.962 0 0114.5 14c1.255 0 2.443.29 3.5.804v-10A7.968 7.968 0 0014.5 4c-1.255 0-2.443.29-3.5.804V12a1 1 0 11-2 0V4.804z"/></svg>`,
+  bolt: `<svg class="h-5 w-5" fill="currentColor" viewBox="0 0 20 20"><path fill-rule="evenodd" d="M11.3 1.046A1 1 0 0112 2v5h4a1 1 0 01.82 1.573l-7 10A1 1 0 018 18v-5H4a1 1 0 01-.82-1.573l7-10a1 1 0 011.12-.38z" clip-rule="evenodd"/></svg>`,
+  document: `<svg class="h-5 w-5" fill="currentColor" viewBox="0 0 20 20"><path fill-rule="evenodd" d="M4 4a2 2 0 012-2h8a2 2 0 012 2v12a2 2 0 01-2 2H6a2 2 0 01-2-2V4zm3 1h6v2H7V5zm0 4h6v2H7V9zm0 4h4v2H7v-2z" clip-rule="evenodd"/></svg>`,
+  lock: `<svg class="h-5 w-5" fill="currentColor" viewBox="0 0 20 20"><path fill-rule="evenodd" d="M5 9V7a5 5 0 0110 0v2a2 2 0 012 2v5a2 2 0 01-2 2H5a2 2 0 01-2-2v-5a2 2 0 012-2zm8-2v2H7V7a3 3 0 016 0z" clip-rule="evenodd"/></svg>`,
+  photo: `<svg class="h-5 w-5" fill="currentColor" viewBox="0 0 20 20"><path fill-rule="evenodd" d="M4 3a2 2 0 00-2 2v10a2 2 0 002 2h12a2 2 0 002-2V5a2 2 0 00-2-2H4zm12 12H4l4-8 3 6 2-4 3 6z" clip-rule="evenodd"/></svg>`
+};
+function resolveIcon(name) {
+  if (!name) return PUZZLE_PIECE;
+  if (name.startsWith("<svg")) return name;
+  return MENU_ICON_MAP[name] ?? PUZZLE_PIECE;
+}
+var menuItems = [];
+function setPluginMenu(items) {
+  menuItems = [...items];
+}
+function getPluginMenu() {
+  return menuItems;
+}
+function resetPluginMenu() {
+  menuItems = [];
+}
+function resolvePluginMenuItems(user) {
+  const isAdmin = user?.role === "admin";
+  const userPerms = new Set(user?.permissions ?? []);
+  return menuItems.filter((m) => {
+    if (!m.permissions || m.permissions.length === 0) return true;
+    if (isAdmin) return true;
+    return m.permissions.some((p) => userPerms.has(p));
+  }).slice().sort((a, b) => (a.order ?? 100) - (b.order ?? 100)).map((m) => ({
+    label: m.label,
+    path: m.path,
+    icon: resolveIcon(m.icon),
+    order: m.order ?? 100
+  }));
+}
+
+// src/plugins/cron.ts
+function collectCrons(plugins) {
+  const out = [];
+  for (const plugin of plugins) {
+    if (!plugin || !Array.isArray(plugin.crons)) continue;
+    const name = plugin.name ?? "unknown";
+    for (const cron of plugin.crons) {
+      if (cron && typeof cron.schedule === "string" && typeof cron.hookFamily === "string") {
+        out.push({ plugin: name, schedule: cron.schedule, hookFamily: cron.hookFamily });
+      }
+    }
+  }
+  return out;
+}
+function collectCronSchedules(plugins) {
+  return [...new Set(collectCrons(plugins).map((c) => c.schedule))];
+}
+async function dispatchCronTick(plugins, cron, scheduledTime, context) {
+  const result = { invoked: [], errors: [], unmatched: true };
+  for (const plugin of plugins) {
+    if (!plugin || typeof plugin.onCronTick !== "function" || !Array.isArray(plugin.crons)) continue;
+    const name = plugin.name ?? "unknown";
+    const matches = plugin.crons.filter((c) => c && c.schedule === cron);
+    for (const match of matches) {
+      result.unmatched = false;
+      const event = { cron, scheduledTime, hookFamily: match.hookFamily };
+      try {
+        await plugin.onCronTick(event, context);
+        result.invoked.push({ plugin: name, hookFamily: match.hookFamily });
+      } catch (error) {
+        result.errors.push({ plugin: name, hookFamily: match.hookFamily, error });
+      }
+    }
+  }
+  return result;
+}
+function createScheduledHandler(options) {
+  return async (controller, env, ctx) => {
+    if (options.disabled) {
+      return { invoked: [], errors: [], unmatched: true };
+    }
+    if (options.boot) {
+      try {
+        await options.boot(env);
+      } catch (err) {
+        console.error("[cron] boot failed:", err);
+      }
+    }
+    const plugins = typeof options.plugins === "function" ? options.plugins() : options.plugins;
+    const work = dispatchCronTick(plugins, controller.cron, controller.scheduledTime, {
+      hooks: options.getHooks(),
+      env
+    });
+    ctx?.waitUntil?.(work.catch(() => {
+    }));
+    return work;
+  };
+}
+
+// src/plugins/sdk/register-plugins.ts
+var RegisterPluginsError = class extends Error {
+  constructor(reason, details) {
+    super(`registerPlugins(${reason}): ${JSON.stringify(details)}`);
+    this.reason = reason;
+    this.details = details;
+    this.name = "RegisterPluginsError";
+  }
+};
+function registerPlugins(app, plugins, host) {
+  const list = plugins.filter((p) => !!p && typeof p === "object");
+  const seen = /* @__PURE__ */ new Set();
+  for (const p of list) {
+    if (!p.id || typeof p.id !== "string")
+      throw new RegisterPluginsError("invalid_id", { plugin: p });
+    if (!import_semver2.default.valid(p.version))
+      throw new RegisterPluginsError("invalid_semver", { id: p.id, version: p.version });
+    if (seen.has(p.id))
+      throw new RegisterPluginsError("duplicate_id", { id: p.id });
+    seen.add(p.id);
+    if (p.sonicjsVersionRange) {
+      try {
+        if (!import_semver2.default.satisfies(getCoreVersion(), p.sonicjsVersionRange)) {
+          console.warn(
+            `[plugins] ${p.id} declares sonicjsVersionRange "${p.sonicjsVersionRange}" but core is "${getCoreVersion()}". Plugin may not work correctly.`
+          );
+        }
+      } catch {
+      }
+    }
+  }
+  let mountResult;
+  try {
+    mountResult = registerPluginRoutes(app, list, {
+      source: host.source,
+      strict: host.strict,
+      ...host.mountOptions
+    });
+  } catch (err) {
+    const pluginId2 = err && typeof err === "object" && "message" in err ? String(err.message).match(/Plugin "([^"]+)"/)?.[1] ?? "unknown" : "unknown";
+    throw new RegisterPluginsError("register_returned_promise", { id: pluginId2, error: String(err) });
+  }
+  const menu = list.flatMap((p) => p.menu ?? []);
+  setPluginMenu(menu);
+  setPluginDefinitions(list);
+  const crons = list.flatMap((p) => p.crons ?? []);
+  const cronSchedules = collectCronSchedules(list);
+  const byId = /* @__PURE__ */ new Map();
+  for (const p of list) {
+    byId.set(p.id, {
+      id: p.id,
+      displayName: p.displayName ?? p.name ?? p.id,
+      version: p.version,
+      capabilities: p.capabilities ?? []
+    });
+  }
+  let wirePromise;
+  const boot = (envOverride) => {
+    if (!wirePromise) {
+      const env = envOverride ?? host.env ?? {};
+      wirePromise = wireRegisteredPlugins(list, { hooks: host.hookSystem, env }, { strict: host.strict });
+    }
+    return wirePromise;
+  };
+  return {
+    byId,
+    order: list.map((p) => p.id),
+    menu,
+    crons,
+    cronSchedules,
+    mountResult,
+    boot
+  };
+}
+
+// src/plugins/core-plugins/turnstile-plugin/manifest.json
+var manifest_default = {
+  id: "turnstile",
+  name: "Cloudflare Turnstile",
+  description: "CAPTCHA-free bot protection using Cloudflare Turnstile. Provides reusable verification for any form.",
+  version: "1.0.0",
+  author: "SonicJS",
+  category: "security",
+  icon: "shield-check",
+  homepage: "https://developers.cloudflare.com/turnstile/",
+  repository: "https://github.com/sonicjs/sonicjs",
+  license: "MIT",
+  permissions: [
+    "settings:write",
+    "admin:access"
+  ],
+  dependencies: [],
+  configSchema: {
+    siteKey: {
+      type: "string",
+      label: "Site Key",
+      description: "Your Cloudflare Turnstile site key (public)",
+      required: true
+    },
+    secretKey: {
+      type: "string",
+      label: "Secret Key",
+      description: "Your Cloudflare Turnstile secret key (private)",
+      required: true,
+      sensitive: true
+    },
+    theme: {
+      type: "select",
+      label: "Widget Theme",
+      description: "Visual theme for the Turnstile widget",
+      default: "auto",
+      options: [
+        {
+          value: "light",
+          label: "Light"
+        },
+        {
+          value: "dark",
+          label: "Dark"
+        },
+        {
+          value: "auto",
+          label: "Auto"
+        }
+      ]
+    },
+    size: {
+      type: "select",
+      label: "Widget Size",
+      description: "Size of the Turnstile widget",
+      default: "normal",
+      options: [
+        {
+          value: "normal",
+          label: "Normal"
+        },
+        {
+          value: "compact",
+          label: "Compact"
+        }
+      ]
+    },
+    mode: {
+      type: "select",
+      label: "Widget Mode",
+      description: "Managed: Adaptive challenge. Non-Interactive: Always visible, minimal friction. Invisible: No visible widget",
+      default: "managed",
+      options: [
+        {
+          value: "managed",
+          label: "Managed (Recommended)"
+        },
+        {
+          value: "non-interactive",
+          label: "Non-Interactive"
+        },
+        {
+          value: "invisible",
+          label: "Invisible"
+        }
+      ]
+    },
+    appearance: {
+      type: "select",
+      label: "Appearance",
+      description: "When the Turnstile challenge is executed. Always: Verifies immediately. Execute: Challenge on form submit. Interaction Only: Only after user interaction",
+      default: "always",
+      options: [
+        {
+          value: "always",
+          label: "Always"
+        },
+        {
+          value: "execute",
+          label: "Execute"
+        },
+        {
+          value: "interaction-only",
+          label: "Interaction Only"
+        }
+      ]
+    },
+    preClearance: {
+      type: "boolean",
+      label: "Enable Pre-clearance",
+      description: "Issue a clearance cookie that bypasses Cloudflare Firewall Rules (as if the user passed a challenge on your proxied site)",
+      default: false
+    },
+    preClearanceLevel: {
+      type: "select",
+      label: "Pre-clearance Level",
+      description: "Controls which Cloudflare Firewall Rules the clearance cookie bypasses. Only applies if Pre-clearance is enabled",
+      default: "managed",
+      options: [
+        {
+          value: "interactive",
+          label: "Interactive - Bypasses Interactive, Managed & JS Challenge Rules"
+        },
+        {
+          value: "managed",
+          label: "Managed - Bypasses Managed & JS Challenge Rules"
+        },
+        {
+          value: "non-interactive",
+          label: "Non-interactive - Bypasses JS Challenge Rules only"
+        }
+      ]
+    },
+    enabled: {
+      type: "boolean",
+      label: "Enable Turnstile",
+      description: "Enable or disable Turnstile verification globally",
+      default: true
+    }
+  },
+  adminMenu: {
+    label: "Turnstile",
+    icon: "shield-check",
+    href: "/admin/plugins/turnstile/settings",
+    parentId: "plugins",
+    order: 100
+  },
+  codeName: "turnstile-plugin",
+  iconEmoji: "\u{1F6E1}\uFE0F",
+  is_core: true,
+  defaultSettings: {
+    siteKey: "",
+    secretKey: "",
+    theme: "auto",
+    size: "normal",
+    mode: "managed",
+    appearance: "always",
+    preClearanceEnabled: false,
+    preClearanceLevel: "managed",
+    enabled: false
+  }
+};
+
+// src/plugins/core-plugins/turnstile-plugin/services/turnstile.ts
+var TurnstileService = class {
+  db;
+  VERIFY_URL = "https://challenges.cloudflare.com/turnstile/v0/siteverify";
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Get Turnstile settings from database
+   */
+  async getSettings() {
+    try {
+      const plugin = await this.db.prepare(`SELECT settings FROM plugins WHERE id = ? LIMIT 1`).bind(manifest_default.id).first();
+      if (!plugin || !plugin.settings) {
+        return null;
+      }
+      return JSON.parse(plugin.settings);
+    } catch (error) {
+      console.error("Error getting Turnstile settings:", error);
+      return null;
+    }
+  }
+  /**
+   * Verify a Turnstile token with Cloudflare
+   */
+  async verifyToken(token, remoteIp) {
+    try {
+      const settings = await this.getSettings();
+      if (!settings) {
+        return { success: false, error: "Turnstile not configured" };
+      }
+      if (!settings.enabled) {
+        return { success: true };
+      }
+      if (!settings.secretKey) {
+        return { success: false, error: "Turnstile secret key not configured" };
+      }
+      const formData = new FormData();
+      formData.append("secret", settings.secretKey);
+      formData.append("response", token);
+      if (remoteIp) {
+        formData.append("remoteip", remoteIp);
+      }
+      const response = await fetch(this.VERIFY_URL, {
+        method: "POST",
+        body: formData
+      });
+      if (!response.ok) {
+        return { success: false, error: "Turnstile verification request failed" };
+      }
+      const result = await response.json();
+      if (!result.success) {
+        const errorCode = result["error-codes"]?.[0] || "unknown-error";
+        return { success: false, error: `Turnstile verification failed: ${errorCode}` };
+      }
+      return { success: true };
+    } catch (error) {
+      console.error("Error verifying Turnstile token:", error);
+      return { success: false, error: "Turnstile verification error" };
+    }
+  }
+  /**
+   * Save Turnstile settings to database
+   */
+  async saveSettings(settings) {
+    try {
+      await this.db.prepare(`UPDATE plugins SET settings = ?, updated_at = ? WHERE id = ?`).bind(JSON.stringify(settings), Date.now(), manifest_default.id).run();
+      console.log("Turnstile settings saved successfully");
+    } catch (error) {
+      console.error("Error saving Turnstile settings:", error);
+      throw new Error("Failed to save Turnstile settings");
+    }
+  }
+  /**
+   * Check if Turnstile is enabled
+   */
+  async isEnabled() {
+    const settings = await this.getSettings();
+    return settings?.enabled === true && !!settings.siteKey && !!settings.secretKey;
+  }
+};
+
 // src/plugins/core-plugins/turnstile-plugin/middleware/verify.ts
 async function verifyTurnstile(c, next) {
   const db = c.get("db") || c.env?.DB;
@@ -3157,19 +3791,15 @@ function createTurnstileMiddleware(options) {
 }
 
 // src/plugins/core-plugins/turnstile-plugin/index.ts
-new PluginBuilder({
-  name: manifest_default.name,
+definePlugin({
+  id: manifest_default.id,
   version: manifest_default.version,
+  name: manifest_default.name,
   description: manifest_default.description,
+  sonicjsVersionRange: "^3.0.0",
   author: { name: manifest_default.author }
-}).metadata({
-  description: manifest_default.description,
-  author: { name: manifest_default.author }
-}).addService("turnstile", TurnstileService).addSingleMiddleware("verifyTurnstile", verifyTurnstile, {
-  description: "Verify Cloudflare Turnstile token",
-  global: false
-}).build();
+});
 
-export { HookSystemImpl, HookUtils, PluginManager, PluginRegistryImpl, PluginValidator, ScopedHookSystem, createTurnstileMiddleware, verifyTurnstile };
-//# sourceMappingURL=chunk-TFNTM3OA.js.map
-//# sourceMappingURL=chunk-TFNTM3OA.js.map
+export { HookSystemImpl, HookUtils, PluginDependencyCycleError, PluginManager, PluginRegisterMustBeSyncError, PluginRegistryImpl, PluginValidator, RegisterPluginsError, ScopedHookSystem, TurnstileService, collectCronSchedules, collectCrons, createPluginWirer, createScheduledHandler, createTurnstileMiddleware, dispatchCronTick, getPluginMenu, mountPlugin, registerPluginRoutes, registerPlugins, resetPluginMenu, resolvePluginMenuItems, setPluginMenu, topoSort, verifyTurnstile, wireRegisteredPlugins };
+//# sourceMappingURL=chunk-PDYRDYXI.js.map
+//# sourceMappingURL=chunk-PDYRDYXI.js.map