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

package/index.js

@@ -13,6 +13,19 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+// 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;
@@ -28,16 +41,6 @@ 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";
@@ -66,7 +69,10 @@ function getRegistry2() {
       listeners: new Set,
       badgesByPlugin: new Map,
       badgesSnapshot: new Map,
-      badgeListeners: new Set
+      badgeListeners: new Set,
+      hitRenderersByPlugin: new Map,
+      hitRenderersSnapshot: new Map,
+      hitRendererListeners: new Set
     };
   }
   const registry = g.__bakinClientRegistry;
@@ -81,8 +87,35 @@ function getRegistry2() {
     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()) {
@@ -133,28 +166,11 @@ 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);
-  const hadBadges = registry.badgesByPlugin.delete(id);
   bumpVersion();
-  if (hadBadges)
-    bumpBadges();
 }
 function registerPluginCleanup(id, fn) {
   const registry = getRegistry2();
@@ -162,42 +178,6 @@ function registerPluginCleanup(id, fn) {
   list.push(fn);
   registry.cleanupByPlugin.set(id, list);
 }
-function setManifestNav(pluginId, navItems) {
-  const registry = getRegistry2();
-  if (!navItems || navItems.length === 0) {
-    if (!registry.manifestNavByPlugin.delete(pluginId))
-      return;
-    bumpVersion();
-    return;
-  }
-  const prev = registry.manifestNavByPlugin.get(pluginId);
-  if (prev && JSON.stringify(prev) === JSON.stringify(navItems))
-    return;
-  registry.manifestNavByPlugin.set(pluginId, navItems);
-  bumpVersion();
-}
-function getManifestNav(pluginId) {
-  return getRegistry2().manifestNavByPlugin.get(pluginId) ?? [];
-}
-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 setNavBadge(pluginId, navItemId, badge) {
   const registry = getRegistry2();
   let plugin = registry.badgesByPlugin.get(pluginId);
@@ -223,319 +203,6 @@ function setNavBadge(pluginId, navItemId, badge) {
 function getNavBadge(navItemId) {
   return getRegistry2().badgesSnapshot.get(navItemId);
 }
-function getNavBadgesSnapshot() {
-  return getRegistry2().badgesSnapshot;
-}
-function subscribeNavBadges(listener) {
-  const registry = getRegistry2();
-  registry.badgeListeners.add(listener);
-  return () => {
-    registry.badgeListeners.delete(listener);
-  };
-}
-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) {
-  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
-        };
-      }
-    }
-  }
-  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/sdk/src/lazy.ts
-"use client";
-function getStore() {
-  const g = globalThis;
-  if (!g.__bakinLazyPluginStore) {
-    g.__bakinLazyPluginStore = {
-      ownersBySlot: new Map,
-      routeOwners: [],
-      states: new Map,
-      errors: new Map,
-      loader: null,
-      version: 0,
-      listeners: new Set
-    };
-  }
-  return g.__bakinLazyPluginStore;
-}
-function bump() {
-  const store = getStore();
-  store.version++;
-  for (const l of store.listeners) {
-    try {
-      l();
-    } catch (err) {
-      console.error("[bakin] lazy-plugin listener threw:", err);
-    }
-  }
-}
-function configureLazyPlugins(index) {
-  const store = getStore();
-  store.ownersBySlot = new Map(index.slotOwners);
-  store.routeOwners = [...index.routeOwners];
-  bump();
-}
-function setLazyPluginLoader(loader) {
-  getStore().loader = loader;
-}
-function setPluginLoadState(pluginId, state, error) {
-  const store = getStore();
-  if (store.states.get(pluginId) === state && store.errors.get(pluginId) === error)
-    return;
-  store.states.set(pluginId, state);
-  if (state === "error" && error)
-    store.errors.set(pluginId, error);
-  else
-    store.errors.delete(pluginId);
-  bump();
-}
-function getPluginLoadState(pluginId) {
-  return getStore().states.get(pluginId) ?? "idle";
-}
-function getPluginLoadError(pluginId) {
-  return getStore().errors.get(pluginId);
-}
-function getSlotOwners(name) {
-  return getStore().ownersBySlot.get(name) ?? [];
-}
-function getRouteOwners(pathname) {
-  const owners = [];
-  for (const { pattern, pluginId } of getStore().routeOwners) {
-    if (matchRoutePattern(pattern, pathname) && !owners.includes(pluginId)) {
-      owners.push(pluginId);
-    }
-  }
-  return owners;
-}
-function demand(pluginIds) {
-  const store = getStore();
-  if (!store.loader)
-    return;
-  for (const pluginId of pluginIds) {
-    if ((store.states.get(pluginId) ?? "idle") !== "idle")
-      continue;
-    store.loader(pluginId);
-  }
-}
-function requestSlotPlugins(name) {
-  demand(getSlotOwners(name));
-}
-function requestRoutePlugins(pathname) {
-  demand(getRouteOwners(pathname));
-}
-function retryPluginLoad(pluginId) {
-  const store = getStore();
-  if (store.states.get(pluginId) !== "error")
-    return;
-  store.states.set(pluginId, "idle");
-  store.errors.delete(pluginId);
-  bump();
-  demand([pluginId]);
-}
-function getLazyPluginsVersion() {
-  return getStore().version;
-}
-function subscribeLazyPlugins(listener) {
-  const store = getStore();
-  store.listeners.add(listener);
-  return () => {
-    store.listeners.delete(listener);
-  };
-}
-// 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;
-  }
-  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();
-  }
-}
 // node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -14137,9 +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"),
-    db: join(home, "bakin.db")
+    antfly: join(home, "antfly"),
+    db: join(home, "bakin.db"),
+    bin: join(home, "bin")
   };
 }
 
@@ -14311,7 +13982,6 @@ function suppressPrettyInfo(entry) {
     "search-cleanup",
     "search-startup",
     "hot-reload-coordinator",
-    "mcporter",
     "dispatch",
     "dispatch-state",
     "dispatch-turns",
@@ -14412,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),
@@ -14431,35 +14271,12 @@ var searchResponse = exports_external.object({
 });
 var errorResponse = exports_external.object({ error: exports_external.string() });
 export {
-  unregisterPlugin,
-  subscribeRegistry,
-  subscribeNavBadges,
-  subscribeLazyPlugins,
-  setPluginLoadState,
   setNavBadge,
-  setManifestNav,
-  setLazyPluginLoader,
-  retryPluginLoad,
-  requestSlotPlugins,
-  requestRoutePlugins,
   registerPluginCleanup,
   registerPlugin,
-  getSlotOwners,
-  getRouteOwners,
-  getRegistryVersion,
-  getPluginRoutes,
-  getPluginRoute,
-  getPluginNavItems,
-  getPluginLoadState,
-  getPluginLoadError,
-  getNavItemsSnapshot,
-  getNavBadgesSnapshot,
   getNavBadge,
-  getManifestNav,
-  getLazyPluginsVersion,
-  getAllNavItems,
   defineRoute,
   definePlugin,
   defineCoreRoute,
-  configureLazyPlugins
+  HEALTH_INCIDENT_CLASSES
 };