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

package/routing/index.js

@@ -14,151 +14,6 @@ var __export = (target, all) => {
     });
 };
 
-// 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, {
@@ -13760,8 +13615,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")
   };
 }
 
@@ -13925,11 +13785,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"
@@ -14023,6 +13893,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),

package/slots/index.d.ts

@@ -19,29 +19,15 @@
  * Registration happens at plugin client-module load time (import side effect).
  * Test-only helpers are not exported — tests use the public unregister path.
  */
-import { type ComponentType, type JSX } from 'react';
-interface SlotEntry {
-    component: ComponentType<Record<string, unknown>>;
-    order: number;
-    owner?: string;
-}
-/**
- * Register a component for a named slot. Lower `order` renders first; entries
- * with the same order render in registration order. Default `order` is 100.
- * `owner` is the pluginId for teardown-on-hot-swap; omit in test setups.
- */
-export declare function registerSlot<TProps>(name: string, component: ComponentType<TProps>, order?: number, owner?: string): void;
-/**
- * Read the registered entries for a slot. Exported for tooling / tests.
- */
-export declare function getSlotEntries(name: string): ReadonlyArray<SlotEntry>;
-/**
- * Remove every slot entry owned by the given plugin. Used by
- * `unregisterPlugin` during v2 hot-swap. Entries without an `owner`
- * (test registrations, pre-v2 legacy registrations) survive — callers
- * that want to wipe unowned entries should re-register them after.
- */
-export declare function clearSlotsOwnedBy(pluginId: string): void;
+import { type JSX } from 'react';
+/** Register a component for a named slot. Lower `order` renders first; default `order` is 100. */
+export { registerSlot } from './registry/index';
+/** Read the registered entries for a slot. Exported for tooling / tests. */
+export { getSlotEntries } from './registry/index';
+/** Slot names with at least one entry owned by the given plugin (manifest drift checks). */
+export { getSlotNamesOwnedBy } from './registry/index';
+/** Remove every slot entry owned by the given plugin (hot-swap teardown). */
+export { clearSlotsOwnedBy } from './registry/index';
 interface SlotProps {
     name: string;
     [key: string]: unknown;
@@ -50,6 +36,12 @@ interface SlotProps {
  * Render all components registered for the named slot, in order. Extra props
  * are passed through to every registered component unchanged. Returns `null`
  * if nothing is registered.
+ *
+ * Lazy loading: rendering a slot is a demand signal — if a manifest declares
+ * an owner for this slot whose client bundle hasn't loaded yet, the host's
+ * loader fires and the slot re-renders once `registerPlugin` runs. While an
+ * owner is loading the slot renders nothing (page slots resolve in one
+ * paint on the LAN); if an owner's bundle failed to import, an inline error
+ * with a retry button renders instead of silent emptiness.
  */
 export declare function Slot({ name, ...props }: SlotProps): JSX.Element | null;
-export {};