@makinbakin/sdk 0.0.1-rc.2 → 0.0.1-rc.21

package/index.js

@@ -13,10 +13,20 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
-// packages/sdk/src/slots/index.tsx
-import { useSyncExternalStore } from "react";
-import { jsxDEV, Fragment } from "react/jsx-dev-runtime";
-"use client";
+// packages/sdk/src/types/health.ts
+var HEALTH_INCIDENT_CLASSES = [
+  "service_failure",
+  "data_integrity",
+  "budget_block",
+  "evidence_gap",
+  "usage_anomaly",
+  "unattributed_usage",
+  "runaway_usage",
+  "cleanup_backlog",
+  "policy_denial",
+  "unsupported_surface"
+];
+// packages/sdk/src/slots/registry.ts
 function getRegistry() {
   const g = globalThis;
   if (!g.__bakinSlotRegistry) {
@@ -31,21 +41,16 @@ function registerSlot(name, component, order = 100, owner) {
   entries.sort((a, b) => a.order - b.order);
   reg.set(name, entries);
 }
-function clearSlotsOwnedBy(pluginId) {
-  const reg = getRegistry();
-  for (const [name, entries] of reg.entries()) {
-    const filtered = entries.filter((e) => e.owner !== pluginId);
-    if (filtered.length === 0)
-      reg.delete(name);
-    else
-      reg.set(name, filtered);
-  }
-}
 
 // packages/sdk/src/register.ts
 "use client";
 function buildNavItemsSnapshot(registry) {
   const items = [];
+  for (const [pluginId, navItems] of registry.manifestNavByPlugin.entries()) {
+    if (registry.navByPlugin.has(pluginId))
+      continue;
+    items.push(...navItems);
+  }
   for (const navItems of registry.navByPlugin.values()) {
     items.push(...navItems);
   }
@@ -56,19 +61,82 @@ function getRegistry2() {
   if (!g.__bakinClientRegistry) {
     g.__bakinClientRegistry = {
       navByPlugin: new Map,
+      manifestNavByPlugin: new Map,
       routesByPlugin: new Map,
       cleanupByPlugin: new Map,
       navItemsSnapshot: [],
       version: 0,
-      listeners: new Set
+      listeners: new Set,
+      badgesByPlugin: new Map,
+      badgesSnapshot: new Map,
+      badgeListeners: new Set,
+      hitRenderersByPlugin: new Map,
+      hitRenderersSnapshot: new Map,
+      hitRendererListeners: new Set
     };
   }
   const registry = g.__bakinClientRegistry;
+  if (!registry.manifestNavByPlugin)
+    registry.manifestNavByPlugin = new Map;
   if (!Array.isArray(registry.navItemsSnapshot)) {
     registry.navItemsSnapshot = buildNavItemsSnapshot(registry);
   }
+  if (!registry.badgesByPlugin)
+    registry.badgesByPlugin = new Map;
+  if (!registry.badgesSnapshot)
+    registry.badgesSnapshot = buildBadgesSnapshot(registry);
+  if (!registry.badgeListeners)
+    registry.badgeListeners = new Set;
+  if (!registry.hitRenderersByPlugin)
+    registry.hitRenderersByPlugin = new Map;
+  if (!registry.hitRenderersSnapshot)
+    registry.hitRenderersSnapshot = buildHitRenderersSnapshot(registry);
+  if (!registry.hitRendererListeners)
+    registry.hitRendererListeners = new Set;
   return registry;
 }
+function buildHitRenderersSnapshot(registry) {
+  const snapshot = new Map;
+  for (const byType of registry.hitRenderersByPlugin.values()) {
+    for (const [type, renderer] of byType) {
+      if (!snapshot.has(type))
+        snapshot.set(type, renderer);
+    }
+  }
+  return snapshot;
+}
+function bumpHitRenderers() {
+  const registry = getRegistry2();
+  registry.hitRenderersSnapshot = buildHitRenderersSnapshot(registry);
+  for (const l of registry.hitRendererListeners) {
+    try {
+      l();
+    } catch (err) {
+      console.error("[bakin] hit-renderer listener threw:", err);
+    }
+  }
+}
+function buildBadgesSnapshot(registry) {
+  const snapshot = new Map;
+  for (const byNavItemId of registry.badgesByPlugin.values()) {
+    for (const [navItemId, badge] of byNavItemId) {
+      if (!snapshot.has(navItemId))
+        snapshot.set(navItemId, badge);
+    }
+  }
+  return snapshot;
+}
+function bumpBadges() {
+  const registry = getRegistry2();
+  registry.badgesSnapshot = buildBadgesSnapshot(registry);
+  for (const l of registry.badgeListeners) {
+    try {
+      l();
+    } catch (err) {
+      console.error("[bakin] badge listener threw:", err);
+    }
+  }
+}
 function bumpVersion() {
   const registry = getRegistry2();
   registry.navItemsSnapshot = buildNavItemsSnapshot(registry);
@@ -98,24 +166,10 @@ function registerPlugin(reg) {
       registerSlot(slotName, component, 100, reg.id);
     }
   }
-  bumpVersion();
-}
-function unregisterPlugin(id) {
-  const registry = getRegistry2();
-  const cleanups = registry.cleanupByPlugin.get(id);
-  if (cleanups) {
-    for (const fn of cleanups) {
-      try {
-        fn();
-      } catch (err) {
-        console.error(`[bakin] cleanup fn for ${id} threw:`, err);
-      }
-    }
-    registry.cleanupByPlugin.delete(id);
+  if (reg.search?.hitRenderers && Object.keys(reg.search.hitRenderers).length > 0) {
+    registry.hitRenderersByPlugin.set(reg.id, new Map(Object.entries(reg.search.hitRenderers)));
+    bumpHitRenderers();
   }
-  registry.navByPlugin.delete(id);
-  registry.routesByPlugin.delete(id);
-  clearSlotsOwnedBy(id);
   bumpVersion();
 }
 function registerPluginCleanup(id, fn) {
@@ -124,226 +178,30 @@ function registerPluginCleanup(id, fn) {
   list.push(fn);
   registry.cleanupByPlugin.set(id, list);
 }
-function getRegistryVersion() {
-  return getRegistry2().version;
-}
-function subscribeRegistry(listener) {
-  const registry = getRegistry2();
-  registry.listeners.add(listener);
-  return () => {
-    registry.listeners.delete(listener);
-  };
-}
-function getAllNavItems() {
-  return [...getRegistry2().navItemsSnapshot];
-}
-function getNavItemsSnapshot() {
-  return getRegistry2().navItemsSnapshot;
-}
-function getPluginNavItems(pluginId) {
-  return getRegistry2().navByPlugin.get(pluginId) ?? [];
-}
-function normalizePattern(pattern) {
-  return pattern.split("/").filter(Boolean);
-}
-function matchRoutePattern(pattern, pathname) {
-  const patternSegments = normalizePattern(pattern);
-  const pathSegments = normalizePattern(pathname);
-  if (patternSegments.length !== pathSegments.length)
-    return null;
-  const params = {};
-  let score = 0;
-  for (let i = 0;i < patternSegments.length; i++) {
-    const patternSegment = patternSegments[i];
-    const pathSegment = pathSegments[i];
-    const bracket = patternSegment.match(/^\[([^\]]+)\]$/);
-    const isColon = patternSegment.startsWith(":");
-    const isDollar = patternSegment.startsWith("$");
-    if (bracket || isColon || isDollar) {
-      const key = bracket?.[1] ?? patternSegment.slice(1);
-      params[key] = decodeURIComponent(pathSegment);
-      continue;
-    }
-    if (patternSegment !== pathSegment)
-      return null;
-    score += 1;
-  }
-  return { params, score };
-}
-function getPluginRoute(pathname) {
+function setNavBadge(pluginId, navItemId, badge) {
   const registry = getRegistry2();
-  let best = null;
-  for (const [pluginId, routes] of registry.routesByPlugin.entries()) {
-    for (const route2 of routes) {
-      const match = matchRoutePattern(route2.path, pathname);
-      if (!match)
-        continue;
-      if (!best || match.score > best.score) {
-        best = {
-          pluginId,
-          path: route2.path,
-          component: route2.component,
-          params: match.params,
-          score: match.score
-        };
-      }
-    }
+  let plugin = registry.badgesByPlugin.get(pluginId);
+  if (badge === null) {
+    if (!plugin?.has(navItemId))
+      return;
+    plugin.delete(navItemId);
+    if (plugin.size === 0)
+      registry.badgesByPlugin.delete(pluginId);
+    bumpBadges();
+    return;
   }
-  if (!best)
-    return null;
-  const { score: _score, ...route } = best;
-  return route;
-}
-function getPluginRoutes(pluginId) {
-  const registry = getRegistry2();
-  if (pluginId)
-    return registry.routesByPlugin.get(pluginId) ?? [];
-  return [...registry.routesByPlugin.values()].flat();
-}
-// packages/core/src/routing/define.ts
-function defineRoute(route) {
-  return route;
-}
-function defineCoreRoute(route) {
-  return route;
-}
-function definePlugin(plugin) {
-  return plugin;
-}
-// packages/core/src/routing/operation-id.ts
-function operationIdFor(scope, method, path) {
-  return `${scope}.${method.toLowerCase()}.${slugifyPath(path)}`;
-}
-function slugifyPath(path) {
-  const trimmed = path.replace(/^\/+/, "").replace(/\/+$/, "");
-  if (trimmed === "")
-    return "root";
-  const segments = trimmed.split("/").map((seg) => {
-    if (seg.startsWith(":"))
-      return camelToKebab(seg.slice(1));
-    if (seg.startsWith("{") && seg.endsWith("}"))
-      return camelToKebab(seg.slice(1, -1));
-    return camelToKebab(seg);
-  }).filter(Boolean);
-  return segments.join("-");
-}
-function camelToKebab(input) {
-  return input.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
-}
-
-// packages/core/src/routing/registry.ts
-function parseSegments(path) {
-  return path.split("/").filter(Boolean).map((seg) => {
-    if (seg === "*" || seg.startsWith("..."))
-      return { kind: "wildcard" };
-    if (seg.startsWith(":"))
-      return { kind: "param", name: seg.slice(1) };
-    if (seg.startsWith("{") && seg.endsWith("}")) {
-      return { kind: "param", name: seg.slice(1, -1) };
-    }
-    return { kind: "literal", value: seg };
-  });
-}
-function specificityScore(segments) {
-  let score = 0;
-  for (const seg of segments) {
-    if (seg.kind === "literal")
-      score += 2;
-    else if (seg.kind === "param")
-      score += 1;
+  const prev = plugin?.get(navItemId);
+  if (prev && prev.count === badge.count && prev.tone === badge.tone)
+    return;
+  if (!plugin) {
+    plugin = new Map;
+    registry.badgesByPlugin.set(pluginId, plugin);
   }
-  return score;
+  plugin.set(navItemId, { count: badge.count, tone: badge.tone });
+  bumpBadges();
 }
-function matchSegments(pathSegments, routeSegments) {
-  const lastIsWildcard = routeSegments.length > 0 && routeSegments[routeSegments.length - 1].kind === "wildcard";
-  if (!lastIsWildcard && pathSegments.length !== routeSegments.length)
-    return null;
-  if (lastIsWildcard && pathSegments.length < routeSegments.length - 1)
-    return null;
-  const params = {};
-  for (let i = 0;i < routeSegments.length; i++) {
-    const rseg = routeSegments[i];
-    if (rseg.kind === "wildcard")
-      return params;
-    const pseg = pathSegments[i];
-    if (rseg.kind === "literal") {
-      if (rseg.value !== pseg)
-        return null;
-    } else {
-      params[rseg.name] = pseg;
-    }
-  }
-  return params;
-}
-
-class RouteRegistry {
-  byMethod = new Map;
-  operationIds = new Set;
-  fullPaths = new Set;
-  register(input) {
-    const { route } = input;
-    const pluginId = input.scope === "plugin" ? input.pluginId : null;
-    const fullPath = pluginId !== null ? `/api/plugins/${pluginId}${route.path}` : route.path;
-    const operationId = route.operationId ?? operationIdFor(pluginId ?? "core", route.method, route.path);
-    const dupKey = `${route.method} ${fullPath}`;
-    if (this.fullPaths.has(dupKey)) {
-      throw new Error(`duplicate route registration: ${dupKey}`);
-    }
-    if (this.operationIds.has(operationId)) {
-      throw new Error(`duplicate operationId: ${operationId} (route: ${dupKey})`);
-    }
-    this.fullPaths.add(dupKey);
-    this.operationIds.add(operationId);
-    const segments = parseSegments(fullPath);
-    const indexed = {
-      registered: {
-        route,
-        scope: pluginId ?? "core",
-        fullPath,
-        operationId
-      },
-      segments,
-      score: specificityScore(segments)
-    };
-    let bucket = this.byMethod.get(route.method);
-    if (!bucket) {
-      bucket = [];
-      this.byMethod.set(route.method, bucket);
-    }
-    bucket.push(indexed);
-    bucket.sort((a, b) => b.score - a.score);
-    return indexed.registered;
-  }
-  match(method, path) {
-    const bucket = this.byMethod.get(method);
-    if (!bucket)
-      return null;
-    const normalized = path.replace(/\/+$/, "") || "/";
-    const pathSegments = normalized.split("/").filter(Boolean);
-    for (const indexed of bucket) {
-      const params = matchSegments(pathSegments, indexed.segments);
-      if (params !== null) {
-        return {
-          ...indexed.registered,
-          params
-        };
-      }
-    }
-    return null;
-  }
-  all() {
-    const out = [];
-    for (const bucket of this.byMethod.values()) {
-      for (const entry of bucket)
-        out.push(entry.registered);
-    }
-    return out;
-  }
-  clear() {
-    this.byMethod.clear();
-    this.operationIds.clear();
-    this.fullPaths.clear();
-  }
+function getNavBadge(navItemId) {
+  return getRegistry2().badgesSnapshot.get(navItemId);
 }
 // node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -13946,8 +13804,13 @@ function getBakinPaths() {
     inbox: join(home, "inbox"),
     tasks: join(home, "tasks"),
     workflows: join(home, "workflows"),
+    brands: join(home, "brands"),
+    chat: join(home, "chat"),
     settings: join(home, "settings.json"),
-    logs: join(home, "logs")
+    logs: join(home, "logs"),
+    antfly: join(home, "antfly"),
+    db: join(home, "bakin.db"),
+    bin: join(home, "bin")
   };
 }
 
@@ -14111,11 +13974,21 @@ function suppressPrettyInfo(entry) {
   }
   return [
     "search-registry",
+    "search-registry-core",
+    "search-plugin-api",
+    "search-reindex",
+    "search-query",
     "search-reconcile",
     "search-cleanup",
+    "search-startup",
     "hot-reload-coordinator",
-    "mcporter",
     "dispatch",
+    "dispatch-state",
+    "dispatch-turns",
+    "dispatch-session-death",
+    "dispatch-workflow",
+    "dispatch-cycle",
+    "dispatch-single",
     "watchdog",
     "doctor",
     "lifecycle"
@@ -14209,6 +14082,176 @@ function createLogger(module) {
 
 // packages/core/src/routing/dispatcher.ts
 var log = createLogger("dispatcher");
+var VALID_BODY_CONTENT_TYPES = ["application/json", "multipart/form-data", "*/*", "none"];
+function assertValidBodySpec(body, label) {
+  if (body === undefined || body === null)
+    return;
+  if (isZodType(body))
+    return;
+  if (typeof body !== "object" || !("contentType" in body)) {
+    throw new Error(`route ${label}: body spec must be a zod schema or declare a contentType (got ${JSON.stringify(body)})`);
+  }
+  const ct = body.contentType;
+  if (!VALID_BODY_CONTENT_TYPES.includes(ct)) {
+    throw new Error(`route ${label}: unknown body contentType '${String(ct)}' \u2014 valid values: ${VALID_BODY_CONTENT_TYPES.join(", ")}`);
+  }
+  if (ct === "application/json" && !isZodType(body.schema)) {
+    throw new Error(`route ${label}: contentType 'application/json' requires a zod schema`);
+  }
+}
+function isZodType(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  return value instanceof exports_external.ZodType || typeof value._zod === "object" && value._zod !== null;
+}
+
+// packages/core/src/routing/define.ts
+function defineRoute(route) {
+  assertValidBodySpec(route.body, `${route.method} ${route.path}`);
+  return route;
+}
+function defineCoreRoute(route) {
+  assertValidBodySpec(route.body, `${route.method} ${route.path}`);
+  return route;
+}
+function definePlugin(plugin) {
+  return plugin;
+}
+// packages/core/src/routing/operation-id.ts
+function operationIdFor(scope, method, path) {
+  return `${scope}.${method.toLowerCase()}.${slugifyPath(path)}`;
+}
+function slugifyPath(path) {
+  const trimmed = path.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (trimmed === "")
+    return "root";
+  const segments = trimmed.split("/").map((seg) => {
+    if (seg.startsWith(":"))
+      return camelToKebab(seg.slice(1));
+    if (seg.startsWith("{") && seg.endsWith("}"))
+      return camelToKebab(seg.slice(1, -1));
+    return camelToKebab(seg);
+  }).filter(Boolean);
+  return segments.join("-");
+}
+function camelToKebab(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+}
+
+// packages/core/src/routing/registry.ts
+function parseSegments(path) {
+  return path.split("/").filter(Boolean).map((seg) => {
+    if (seg === "*" || seg.startsWith("..."))
+      return { kind: "wildcard" };
+    if (seg.startsWith(":"))
+      return { kind: "param", name: seg.slice(1) };
+    if (seg.startsWith("{") && seg.endsWith("}")) {
+      return { kind: "param", name: seg.slice(1, -1) };
+    }
+    return { kind: "literal", value: seg };
+  });
+}
+function specificityScore(segments) {
+  let score = 0;
+  for (const seg of segments) {
+    if (seg.kind === "literal")
+      score += 2;
+    else if (seg.kind === "param")
+      score += 1;
+  }
+  return score;
+}
+function matchSegments(pathSegments, routeSegments) {
+  const lastIsWildcard = routeSegments.length > 0 && routeSegments[routeSegments.length - 1].kind === "wildcard";
+  if (!lastIsWildcard && pathSegments.length !== routeSegments.length)
+    return null;
+  if (lastIsWildcard && pathSegments.length < routeSegments.length - 1)
+    return null;
+  const params = {};
+  for (let i = 0;i < routeSegments.length; i++) {
+    const rseg = routeSegments[i];
+    if (rseg.kind === "wildcard")
+      return params;
+    const pseg = pathSegments[i];
+    if (rseg.kind === "literal") {
+      if (rseg.value !== pseg)
+        return null;
+    } else {
+      params[rseg.name] = pseg;
+    }
+  }
+  return params;
+}
+
+class RouteRegistry {
+  byMethod = new Map;
+  operationIds = new Set;
+  fullPaths = new Set;
+  register(input) {
+    const { route } = input;
+    const pluginId = input.scope === "plugin" ? input.pluginId : null;
+    const fullPath = pluginId !== null ? `/api/plugins/${pluginId}${route.path}` : route.path;
+    const operationId = route.operationId ?? operationIdFor(pluginId ?? "core", route.method, route.path);
+    const dupKey = `${route.method} ${fullPath}`;
+    if (this.fullPaths.has(dupKey)) {
+      throw new Error(`duplicate route registration: ${dupKey}`);
+    }
+    if (this.operationIds.has(operationId)) {
+      throw new Error(`duplicate operationId: ${operationId} (route: ${dupKey})`);
+    }
+    this.fullPaths.add(dupKey);
+    this.operationIds.add(operationId);
+    const segments = parseSegments(fullPath);
+    const indexed = {
+      registered: {
+        route,
+        scope: pluginId ?? "core",
+        fullPath,
+        operationId
+      },
+      segments,
+      score: specificityScore(segments)
+    };
+    let bucket = this.byMethod.get(route.method);
+    if (!bucket) {
+      bucket = [];
+      this.byMethod.set(route.method, bucket);
+    }
+    bucket.push(indexed);
+    bucket.sort((a, b) => b.score - a.score);
+    return indexed.registered;
+  }
+  match(method, path) {
+    const bucket = this.byMethod.get(method);
+    if (!bucket)
+      return null;
+    const normalized = path.replace(/\/+$/, "") || "/";
+    const pathSegments = normalized.split("/").filter(Boolean);
+    for (const indexed of bucket) {
+      const params = matchSegments(pathSegments, indexed.segments);
+      if (params !== null) {
+        return {
+          ...indexed.registered,
+          params
+        };
+      }
+    }
+    return null;
+  }
+  all() {
+    const out = [];
+    for (const bucket of this.byMethod.values()) {
+      for (const entry of bucket)
+        out.push(entry.registered);
+    }
+    return out;
+  }
+  clear() {
+    this.byMethod.clear();
+    this.operationIds.clear();
+    this.fullPaths.clear();
+  }
+}
 // packages/core/src/routing/search-route.ts
 var searchQuery = exports_external.object({
   q: exports_external.string().min(1),
@@ -14228,17 +14271,12 @@ var searchResponse = exports_external.object({
 });
 var errorResponse = exports_external.object({ error: exports_external.string() });
 export {
-  unregisterPlugin,
-  subscribeRegistry,
+  setNavBadge,
   registerPluginCleanup,
   registerPlugin,
-  getRegistryVersion,
-  getPluginRoutes,
-  getPluginRoute,
-  getPluginNavItems,
-  getNavItemsSnapshot,
-  getAllNavItems,
+  getNavBadge,
   defineRoute,
   definePlugin,
-  defineCoreRoute
+  defineCoreRoute,
+  HEALTH_INCIDENT_CLASSES
 };