okengine 0.12.0 → 0.14.1

package/src/kernel/http-stream.test.ts

@@ -0,0 +1,174 @@
+/**
+ * HTTP SSE via `fx.json.stream` + client-disconnect abort of the provider fetch.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { ai } from "../elements/ai.ts";
+import type { AiDriver } from "../drivers/ai-types.ts";
+import { createRunsRuntime } from "../runs/runtime.ts";
+import { createBunRuntime } from "../runtime/bun.ts";
+import type { ServerHandle } from "../runtime/types.ts";
+import { oke } from "./app.ts";
+import { flow, resetFlowSeq } from "./flow.ts";
+import { on, resetBindings } from "./on.ts";
+import { http } from "./triggers.ts";
+
+beforeEach(() => {
+  resetBindings();
+  resetFlowSeq();
+});
+
+function tokenDriver(chunks: readonly string[], delayMs = 0): AiDriver {
+  return {
+    id: "mock",
+    async open() {
+      return {
+        driverId: "mock" as const,
+        model: "smart",
+        async complete() {
+          return { text: "", model: "smart", driverId: "mock" as const };
+        },
+        async *stream() {
+          for (const text of chunks) {
+            if (delayMs > 0) await new Promise((r) => setTimeout(r, delayMs));
+            yield { text };
+          }
+        },
+      };
+    },
+  };
+}
+
+function hangingDriver(onAbort: () => void): AiDriver {
+  return {
+    id: "mock",
+    async open() {
+      return {
+        driverId: "mock" as const,
+        model: "smart",
+        async complete() {
+          return { text: "", model: "smart", driverId: "mock" as const };
+        },
+        async *stream(opts) {
+          yield { text: "start" };
+          await new Promise<void>((resolve, reject) => {
+            const t = setTimeout(resolve, 8_000);
+            opts.signal?.addEventListener(
+              "abort",
+              () => {
+                onAbort();
+                clearTimeout(t);
+                const err = new Error("aborted");
+                err.name = "AbortError";
+                reject(err);
+              },
+              { once: true },
+            );
+          });
+          yield { text: "never" };
+        },
+      };
+    },
+  };
+}
+
+describe("fx.json.stream HTTP SSE", () => {
+  let handle: ServerHandle | undefined;
+
+  afterEach(() => {
+    handle?.stop(true);
+    handle = undefined;
+  });
+
+  test("encodes token chunks as SSE and leaves JSON flows buffered", async () => {
+    const smart = ai.model("smart");
+    on(
+      http.get("/chat").gate.public,
+      flow("chat.stream", {
+        do: (_input, fx) => fx.json.stream(fx.stream(smart, { prompt: "hi" })),
+      }),
+    );
+    on(http.get("/ping").gate.public, flow("ping", { do: () => ({ ok: true as const }) }));
+
+    const app = oke({
+      name: "http-stream",
+      ai: { models: [smart], defaultDriver: tokenDriver(["Hel", "lo"]) },
+    });
+
+    const streamed = await app.fetch(new Request("http://localhost/chat"));
+    expect(streamed.headers.get("content-type")).toMatch(/text\/event-stream/);
+    const body = await streamed.text();
+    expect(body).toContain('data: "Hel"');
+    expect(body).toContain('data: "lo"');
+    expect(body).toContain("data: [DONE]");
+
+    const json = await app.fetch(new Request("http://localhost/ping"));
+    expect(json.headers.get("content-type")).toMatch(/application\/json/);
+    expect(await json.json()).toEqual({ data: { ok: true }, error: null });
+  });
+
+  test("client abort mid-stream aborts the upstream provider fetch", async () => {
+    let providerAborted = false;
+    const smart = ai.model("smart");
+    on(
+      http.get("/slow").gate.public,
+      flow("chat.slow", {
+        do: (_input, fx) => fx.json.stream(fx.stream(smart, { prompt: "long" })),
+      }),
+    );
+
+    const app = oke({
+      name: "http-stream-abort",
+      ai: { models: [smart], defaultDriver: hangingDriver(() => (providerAborted = true)) },
+    });
+
+    handle = createBunRuntime().serve(app, { port: 0, hostname: "127.0.0.1" });
+    const ac = new AbortController();
+    const res = await fetch(`http://127.0.0.1:${handle.port}/slow`, { signal: ac.signal });
+    expect(res.headers.get("content-type")).toMatch(/text\/event-stream/);
+    const reader = res.body!.getReader();
+    const first = await reader.read();
+    expect(first.done).toBe(false);
+    ac.abort();
+    await new Promise((r) => setTimeout(r, 80));
+    expect(providerAborted).toBe(true);
+  });
+
+  test("Traces stay empty until stream close; duration covers the open stream", async () => {
+    const runs = createRunsRuntime({ driver: "memory" });
+    await runs.open();
+    const smart = ai.model("smart");
+    on(
+      http.get("/chat").gate.public,
+      flow("chat.stream", {
+        do: (_input, fx) => fx.json.stream(fx.stream(smart, { prompt: "hi" })),
+      }),
+    );
+
+    const app = oke({
+      name: "http-stream-traces",
+      ai: { models: [smart], defaultDriver: tokenDriver(["Hel", "lo"], 25) },
+      runs,
+      env: "test",
+    });
+    await app.boot({ env: "test", runs, startScheduler: false });
+
+    const streamed = await app.fetch(new Request("http://localhost/chat"));
+    expect(streamed.headers.get("content-type")).toMatch(/text\/event-stream/);
+    await runs.flush();
+    expect(await runs.all()).toHaveLength(0);
+
+    const body = await streamed.text();
+    expect(body).toContain("data: [DONE]");
+
+    await runs.flush();
+    const events = await runs.all();
+    expect(events).toHaveLength(1);
+    expect(events[0]!.error ?? null).toBeNull();
+    expect(events[0]!.output).toEqual({ streamed: true });
+    expect(events[0]!.durationMs).toBeGreaterThanOrEqual(40);
+
+    await app.stop();
+    await runs.close();
+  });
+});

package/src/kernel/index.ts

@@ -137,6 +137,7 @@ export {
   createFxContext,
   freezePrincipal,
   isJsonResult,
+  isJsonStreamResult,
   jsonResultBrand,
   resolveName,
   resolveStoreRef,
@@ -160,6 +161,7 @@ export {
   type FxThunk,
   type JsonPage,
   type JsonResult,
+  type JsonStreamResult,
   type NamedRef,
   type StepOptions,
 } from "./fx.ts";

package/src/manifest/diff.test.ts

@@ -309,6 +309,19 @@ describe("diffManifest — additional branches", () => {
     expect(hasCategory(result.changes, "contract-breaking", "facet")).toBe(true);
   });
 
+  test("store.kv durable on is effect-widening; off is contract-breaking", async () => {
+    const before = await loadBase();
+    before.stores!.db!.facet = "kv";
+    before.stores!.db!.namespaces = ["cache"];
+    delete before.stores!.db!.tables;
+    const on = clone(before);
+    on.stores!.db!.durable = true;
+    expect(hasCategory(diffManifest(before, on).changes, "effect-widening", "durable")).toBe(true);
+    const off = clone(on);
+    off.stores!.db!.durable = false;
+    expect(hasCategory(diffManifest(on, off).changes, "contract-breaking", "durable")).toBe(true);
+  });
+
   test("clocks, vault, channels, journeys, drivers, i18n, topology, images", async () => {
     const before = await loadBase();
     const after = clone(before);

package/src/manifest/diff.ts

@@ -779,6 +779,21 @@ function diffStore(before: Store, after: Store, path: string, out: ManifestChang
   diffStringSet(before.namespaces, after.namespaces, `${path}/namespaces`, out);
   diffStringSet(before.buckets, after.buckets, `${path}/buckets`, out);
   diffStringSet(before.indexes, after.indexes, `${path}/indexes`, out);
+  if (
+    before.durable !== after.durable &&
+    (before.durable !== undefined || after.durable !== undefined)
+  ) {
+    out.push(
+      change(
+        `${path}/durable`,
+        after.durable === true ? "effect-widening" : "contract-breaking",
+        "changed",
+        before.durable,
+        after.durable,
+        `store durable ${String(before.durable)} → ${String(after.durable)}`,
+      ),
+    );
+  }
   if (!deepEqual(before.classifications, after.classifications)) {
     out.push(
       change(

package/src/manifest/mcp-ref.ts

@@ -0,0 +1,88 @@
+/**
+ * MCP tool resource refs — `mcp:<server>/<tool>` (capability / Manifest)
+ * and `<server>__<tool>` (provider-safe model tool name).
+ */
+
+/** Capability / Manifest ref for one declared MCP tool. */
+export type McpToolRef = `mcp:${string}/${string}`;
+
+/** Parsed `mcp:<server>/<tool>` ref. */
+export interface ParsedMcpToolRef {
+  readonly server: string;
+  readonly tool: string;
+}
+
+/**
+ * Build a capability ref.
+ *
+ * @param server - Declared MCP server name
+ * @param tool - Allowlisted tool name on that server
+ */
+export function mcpToolRef(server: string, tool: string): McpToolRef {
+  return `mcp:${server}/${tool}`;
+}
+
+/**
+ * Parse `mcp:<server>/<tool>`. Null when the prefix or parts are missing.
+ *
+ * @param ref - Effect / tool resource string
+ */
+export function parseMcpToolRef(ref: string): ParsedMcpToolRef | null {
+  if (!ref.startsWith("mcp:")) return null;
+  const rest = ref.slice(4);
+  const slash = rest.indexOf("/");
+  if (slash <= 0 || slash === rest.length - 1) return null;
+  return { server: rest.slice(0, slash), tool: rest.slice(slash + 1) };
+}
+
+/**
+ * True when `ref` is a well-formed MCP capability ref.
+ *
+ * @param ref - Candidate
+ */
+export function isMcpToolRef(ref: string): boolean {
+  return parseMcpToolRef(ref) !== null;
+}
+
+/**
+ * Graph node id for one MCP server (`mcp:github`).
+ *
+ * @param server - Declared server name
+ */
+export function mcpServerNodeId(server: string): string {
+  return `mcp:${server}`;
+}
+
+/**
+ * Provider-safe function name (`github__create_issue`).
+ *
+ * @param server - Declared server name
+ * @param tool - MCP tool name
+ */
+export function mcpModelToolName(server: string, tool: string): string {
+  return `${server}__${tool}`;
+}
+
+/**
+ * Inverse of {@link mcpModelToolName}.
+ *
+ * @param name - Model-facing tool name
+ */
+export function parseMcpModelToolName(name: string): ParsedMcpToolRef | null {
+  const sep = name.indexOf("__");
+  if (sep <= 0 || sep === name.length - 2) return null;
+  return { server: name.slice(0, sep), tool: name.slice(sep + 2) };
+}
+
+/**
+ * Capability ref from either `mcp:server/tool` or `server__tool`.
+ *
+ * @param name - Model-facing or capability name
+ */
+export function mcpCapabilityRefFromName(name: string): McpToolRef | null {
+  const fromRef = parseMcpToolRef(name);
+  if (fromRef) return mcpToolRef(fromRef.server, fromRef.tool);
+  const fromModel = parseMcpModelToolName(name);
+  if (fromModel) return mcpToolRef(fromModel.server, fromModel.tool);
+  return null;
+}

package/src/manifest/types.ts

@@ -46,6 +46,12 @@ export type ResourceRef = `${StoreFacet}:${string}`;
  */
 export type RunsResourceRef = "runs";
 
+/**
+ * Dead-letter read capability for `fx.deadLetters` — not a store facet.
+ * Declare on `effects.reads` (never `writes`).
+ */
+export type SignalResourceRef = `signal:${string}`;
+
 /** Signal name reference. */
 export type SignalRef = string;
 
@@ -74,8 +80,8 @@ export type JsonSchema = string | Record<string, unknown>;
  * `sends` / `asks` are irreversible (asks also nondeterministic + cost).
  */
 export interface Effects {
-  /** Store reads, plus optional `"runs"` for `fx.runs`. */
-  reads?: Array<ResourceRef | RunsResourceRef>;
+  /** Store reads, plus `"runs"` for `fx.runs` and `signal:name` for `fx.deadLetters`. */
+  reads?: Array<ResourceRef | RunsResourceRef | SignalResourceRef>;
   /** Store writes. */
   writes?: ResourceRef[];
   /** Emitted signals. */
@@ -234,6 +240,11 @@ export interface Store {
   buckets?: string[];
   indexes?: string[];
   classifications?: Record<string, ClassificationValue>;
+  /**
+   * KV only — namespace persists in SQL (`oke_kv`), not the cache Redis.
+   * Distinct from Flow `durable` (journaled steps).
+   */
+  durable?: boolean;
 }
 
 /** Named clock / schedule. */
@@ -292,6 +303,8 @@ export interface AiModel {
   provider?: string;
   tier?: string;
   model?: string;
+  /** Protocol driver override for this logical binding. */
+  driverId?: string;
 }
 
 /** Prompt / agent budget. */
@@ -322,11 +335,29 @@ export interface AiAgent {
   budget?: AiBudget;
 }
 
+/**
+ * External MCP server the app consumes — tools join the existing `fx.call`
+ * / `toolLoop` path as `mcp:<server>/<tool>` capability refs.
+ */
+export interface AiMcpServer {
+  /** Streamable HTTP endpoint. */
+  url?: string;
+  /** stdio executable (no shell string). */
+  command?: string;
+  /** Arguments for {@link command}. */
+  args?: string[];
+  /** Bearer secret contract name (never the value). */
+  auth?: SecretRef;
+  /** Required allowlist — never trust whatever `tools/list` exposes. */
+  tools: string[];
+}
+
 /** AI element catalogue. */
 export interface Ai {
   models?: Record<string, AiModel>;
   prompts?: Record<string, AiPrompt>;
   agents?: Record<string, AiAgent>;
+  mcpServers?: Record<string, AiMcpServer>;
 }
 
 /** Per-table metadata on a Manifest {@link Plugin}. */

package/src/manifest/validate.test.ts

@@ -75,6 +75,26 @@ describe("validateManifest", () => {
     expect(result.ok).toBe(false);
   });
 
+  test("accepts signal resource refs on reads only", async () => {
+    const reads = await validateManifest({
+      oke: "1.0",
+      app: "x",
+      flows: {
+        f: { effects: { reads: ["signal:notify"] } },
+      },
+    });
+    expect(reads.ok).toBe(true);
+
+    const writes = await validateManifest({
+      oke: "1.0",
+      app: "x",
+      flows: {
+        f: { effects: { writes: ["signal:notify"] } },
+      },
+    });
+    expect(writes.ok).toBe(false);
+  });
+
   test("parseManifest throws ManifestValidationError on invalid JSON", async () => {
     expect(parseManifest("{")).rejects.toBeInstanceOf(ManifestValidationError);
   });

package/src/mcp/docs-server.ts

@@ -197,7 +197,7 @@ export async function serveDocsMcp(
     hostname: boundHost,
     fetch: mcp.fetch,
     stop(closeActive = false) {
-      server.stop(closeActive);
+      return server.stop(closeActive);
     },
   };
 }

package/src/mcp/server.ts

@@ -268,7 +268,7 @@ export async function serveMcp(options: ServeMcpOptions): Promise<McpServerHandl
     hostname: boundHost,
     fetch: mcp.fetch,
     stop(closeActive = false) {
-      server.stop(closeActive);
+      return server.stop(closeActive);
     },
   };
 }

package/src/plugins/compression.test.ts

@@ -122,4 +122,25 @@ describe("compression plugin", () => {
     );
     expect(nt.headers.get("content-encoding")).toBeNull();
   });
+
+  test("skips text/event-stream even when Accept-Encoding is gzip", async () => {
+    on(
+      http.get("/sse"),
+      flow("sse.get", {
+        do: (_input, fx) =>
+          fx.json.stream(
+            (async function* () {
+              yield "hello";
+            })(),
+          ),
+      }),
+    );
+    const app = oke({ autoBoot: false, name: "zip-sse" }).plug(compression({ minSize: 0 }));
+    const res = await app.fetch(
+      new Request("http://localhost/sse", { headers: { "accept-encoding": "gzip" } }),
+    );
+    expect(res.headers.get("content-type")).toMatch(/text\/event-stream/);
+    expect(res.headers.get("content-encoding")).toBeNull();
+    expect(await res.text()).toContain('data: "hello"');
+  });
 });

package/src/plugins/compression.ts

@@ -73,6 +73,7 @@ export function compression(
     if (cacheControl !== null && /\bno-transform\b/i.test(cacheControl)) return;
 
     const contentType = headers.get("content-type") ?? "";
+    if (/^text\/event-stream\b/i.test(contentType.split(";")[0]?.trim() ?? "")) return;
     if (!match.test(contentType)) return;
 
     const body = await ctx.response.arrayBuffer();

package/src/runtime/bun.ts

@@ -81,7 +81,29 @@ export function isBunNativeMethod(method: string): boolean {
   );
 }
 
-type MethodHandlers = Partial<Record<string, (req: Request) => Response | Promise<Response>>>;
+/** Bun.serve `fetch` / route handler — second arg is the live server. */
+type ServeFetch = (
+  req: Request,
+  server: { timeout(request: Request, seconds: number): void },
+) => Response | Promise<Response>;
+
+type MethodHandlers = Partial<Record<string, ServeFetch>>;
+
+/**
+ * Disable the 10s idle timeout for SSE so a quiet token stream is not reset.
+ *
+ * @param inner - App fetch
+ */
+function holdSseIdle(inner: (request: Request) => Promise<Response>): ServeFetch {
+  return async (req, server) => {
+    const res = await inner(req);
+    const ct = (res.headers.get("content-type") ?? "").split(";")[0]?.trim() ?? "";
+    if (/^text\/event-stream$/i.test(ct)) {
+      server.timeout(req, 0);
+    }
+    return res;
+  };
+}
 
 /**
  * Build Bun.serve `routes` from app HTTP bindings.
@@ -103,7 +125,7 @@ export function buildBunRoutes(
     if (typeof path !== "string" || typeof method !== "string") continue;
     if (!isBunNativePath(path) || !isBunNativeMethod(method)) continue;
     const methods = routes[path] ?? (routes[path] = {});
-    methods[method] = (req) => fetchHandler(req);
+    methods[method] = holdSseIdle(fetchHandler);
   }
   return routes;
 }
@@ -128,10 +150,15 @@ export function serveBunHttp(options: {
   readonly routes?: Record<string, MethodHandlers>;
   readonly id?: string;
 }): ReturnType<typeof Bun.serve> {
+  const fetch = holdSseIdle(
+    typeof options.fetch === "function"
+      ? (req: Request) => Promise.resolve(options.fetch(req))
+      : options.fetch,
+  );
   const base = {
     port: options.port,
     hostname: options.hostname,
-    fetch: options.fetch,
+    fetch,
     ...(options.id !== undefined ? { id: options.id } : {}),
   };
   const table = options.routes;
@@ -160,6 +187,15 @@ function listenBun(app: FetchApp, options?: ServeOptions): ServerHandle {
     ...(options?.id !== undefined ? { id: options.id } : {}),
   });
 
+  const closeIdle = (
+    server as typeof server & { closeIdleConnections(): void }
+  ).closeIdleConnections.bind(server);
+  const onPressure = (): void => {
+    closeIdle();
+  };
+  const proc = process as NodeJS.EventEmitter;
+  proc.on("memoryPressure", onPressure);
+
   const boundPort = server.port ?? port;
   const boundHost = server.hostname ?? hostname;
   const url = new URL(`http://${formatHostForUrl(boundHost)}:${boundPort}/`);
@@ -170,7 +206,8 @@ function listenBun(app: FetchApp, options?: ServeOptions): ServerHandle {
     hostname: boundHost,
     fetch: fetchHandler,
     stop(closeActiveConnections = false) {
-      server.stop(closeActiveConnections);
+      proc.off("memoryPressure", onPressure);
+      return server.stop(closeActiveConnections);
     },
   };
 }

package/src/test/reset-element-registries.ts

@@ -19,6 +19,7 @@ import { afterEach } from "bun:test";
 import {
   aiAgentRegistry,
   aiEmbedRegistry,
+  aiMcpServerRegistry,
   aiModelRegistry,
   aiPromptRegistry,
   channelTemplateRegistry,
@@ -38,4 +39,5 @@ afterEach(() => {
   aiPromptRegistry.length = 0;
   aiEmbedRegistry.length = 0;
   aiAgentRegistry.length = 0;
+  aiMcpServerRegistry.length = 0;
 });

package/src/console/ui-next/dist/assets/cache-glyph-CLPBqZeb.js

@@ -1 +0,0 @@
-import{Cr as e,F as t,L as n,P as r,wr as i}from"./shortcut-keys-DO4IsVqv.js";import{A as a,f as o}from"./xyflow-D7n4g6go.js";import{t as s}from"./dagre.esm-ZwcdTuZZ.js";import{C as c,S as l,_ as u,o as d,v as f}from"./http-method-BJ92Z_ke.js";function p(e){let t=e.indexOf(`.`);return t===-1?e:e.slice(0,t)}function m(e){let t=e.indexOf(`.`);return t===-1?e:e.slice(t+1)}function h(e){let t=e?.flows??{},n=new Map;for(let e of Object.keys(t)){let r=t[e]?.effects?.calls??[];for(let t of r){let r=n.get(t)??[];r.push(e),n.set(t,r)}}for(let[e,t]of n)t.sort((e,t)=>e.localeCompare(t)),n.set(e,t);return n}function g(e,t){return h(e).get(t)??[]}function _(e){return e.startsWith(`sql:`)?{id:e,kind:`store`,label:e.slice(4),facet:`sql`}:e.startsWith(`kv:`)?{id:e,kind:`store`,label:e.slice(3),facet:`kv`}:e.startsWith(`files:`)?{id:e,kind:`store`,label:e.slice(6),facet:`files`}:e.startsWith(`index:`)?{id:e,kind:`store`,label:e.slice(6),facet:`index`}:e.startsWith(`signal:`)?{id:e,kind:`signal`,label:e.slice(7)}:e.startsWith(`ai:`)?{id:e,kind:`ai`,label:e.slice(3)}:e.startsWith(`vault:`)?{id:e,kind:`vault`,label:e.slice(6)}:e.startsWith(`channel:`)?{id:e,kind:`channel`,label:e.slice(8)}:e.startsWith(`gate:`)?{id:e,kind:`gate`,label:e.slice(5)}:e.startsWith(`clock:`)?{id:e,kind:`clock`,label:e.slice(6)}:null}function v(e,t,n,r,i=!1){let a=u[r];return{id:e,source:t,target:n,type:`smoothstep`,animated:i,data:{kind:r},style:{stroke:a,strokeWidth:r===`calls`?2.5:2.25},pathOptions:{borderRadius:28},zIndex:f.edge,markerEnd:{type:o.ArrowClosed,width:14,height:14,color:a}}}function y(e){let t=e?.flows??{},n=new Set(Object.keys(t)),r=[],i=new Map;for(let e of[...n].sort()){let t=p(e),n=i.get(t)??[];n.push(e),i.set(t,n)}let a=new Map,o=new Map;for(let e of n){let n=t[e];if(!n)continue;if(n.trigger?.signal){let t=`signal:${n.trigger.signal}`,i=_(t);i&&a.set(t,i),r.push(v(`e:${t}->flow:${e}`,t,`flow:${e}`,`trigger`))}if(n.trigger?.cron||n.trigger?.every){let t=`clock:${e}`,i=n.trigger.cron??n.trigger.every??e;a.set(t,{id:t,kind:`clock`,label:i,facet:n.trigger.cron?`cron`:`every`}),r.push(v(`e:${t}->flow:${e}`,t,`flow:${e}`,`trigger`))}for(let t of n.gates??[]){let n=`gate:${t}`;a.set(n,{id:n,kind:`gate`,label:t}),o.set(n,(o.get(n)??0)+1),r.push(v(`e:flow:${e}-gates->${n}`,`flow:${e}`,n,`gates`))}let i=n.effects;if(i){for(let t of i.reads??[]){let n=_(t);n&&(a.set(t,n),o.set(t,(o.get(t)??0)+1),r.push(v(`e:flow:${e}-reads->${t}`,`flow:${e}`,t,`reads`)))}for(let t of i.writes??[]){let n=_(t);n&&(a.set(t,n),o.set(t,(o.get(t)??0)+1),r.push(v(`e:flow:${e}-writes->${t}`,`flow:${e}`,t,`writes`)))}for(let t of i.emits??[]){let n=`signal:${t}`,i=_(n);i&&(a.set(n,i),o.set(n,(o.get(n)??0)+1),r.push(v(`e:flow:${e}->${n}`,`flow:${e}`,n,`emits`)))}for(let t of i.asks??[]){let n=`ai:${t}`,i=_(n);i&&(a.set(n,i),o.set(n,(o.get(n)??0)+1),r.push(v(`e:flow:${e}->${n}`,`flow:${e}`,n,`asks`)))}for(let t of i.sends??[]){let n=`channel:${t}`,i=_(n);i&&(a.set(n,i),o.set(n,(o.get(n)??0)+1),r.push(v(`e:flow:${e}->${n}`,`flow:${e}`,n,`sends`)))}for(let t of i.secrets??[]){let n=`vault:${t}`,i=_(n);i&&(a.set(n,i),o.set(n,(o.get(n)??0)+1),r.push(v(`e:flow:${e}->${n}`,`flow:${e}`,n,`secrets`)))}for(let t of i.calls??[])r.push(v(`e:flow:${e}->flow:${t}`,`flow:${e}`,`flow:${t}`,`calls`,!0))}}return{nodes:b(i,t,a,o),edges:r,flowIds:n}}function b(e,t,n,r){let i=new s.graphlib.Graph({compound:!0});i.setGraph({rankdir:`LR`,align:`UL`,nodesep:16,ranksep:88,edgesep:12,marginx:8,marginy:8}),i.setDefaultEdgeLabel(()=>({}));for(let[t,n]of[...e.entries()].sort()){i.setNode(`unit:${t}`,{});for(let e of n)i.setNode(`flow:${e}`,{...l.flow}),i.setParent(`flow:${e}`,`unit:${t}`)}for(let e of n.values())i.setNode(e.id,{...l[e.kind]});let a=new Set;for(let n of e.values())for(let e of n){let n=t[e];if(!n)continue;let r=(e,t)=>{let n=`${e}->${t}`;a.has(n)||!i.hasNode(e)||!i.hasNode(t)||(a.add(n),i.setEdge(e,t))};n.trigger?.signal&&r(`signal:${n.trigger.signal}`,`flow:${e}`),(n.trigger?.cron||n.trigger?.every)&&r(`clock:${e}`,`flow:${e}`);for(let t of n.gates??[])r(`flow:${e}`,`gate:${t}`);let o=n.effects;if(o){for(let t of o.reads??[])r(`flow:${e}`,t);for(let t of o.writes??[])r(`flow:${e}`,t);for(let t of o.emits??[])r(`flow:${e}`,`signal:${t}`);for(let t of o.asks??[])r(`flow:${e}`,`ai:${t}`);for(let t of o.sends??[])r(`flow:${e}`,`channel:${t}`);for(let t of o.secrets??[])r(`flow:${e}`,`vault:${t}`);for(let t of o.calls??[])r(`flow:${e}`,`flow:${t}`)}}s.layout(i);let o=[],{headerH:u,padX:d,padBottom:p}=c;for(let[n,r]of[...e.entries()].sort()){let e=`unit:${n}`,a=i.node(e);if(!a)continue;let s=a.x??0,c=a.y??0,h=r.length*l.flow.height+Math.max(0,r.length-1)*10,g=l.flow.width+d*2,_=u+h+p,v=s-g/2,y=c-_/2;o.push({id:e,type:`unit`,position:{x:v,y},data:{kind:`unit`,label:n,refId:e,badge:String(r.length)},selectable:!1,draggable:!1,zIndex:f.unit,width:g,height:_,style:{width:g,height:_}}),r.forEach((r,i)=>{let a=t[r];a&&o.push({id:`flow:${r}`,type:`flow`,position:{x:d,y:u+i*(l.flow.height+10)},parentId:e,extent:`parent`,zIndex:f.leaf,data:{kind:`flow`,label:m(r),refId:r,unit:n,plane:a.plane??`user`,badge:a.plane??`user`},draggable:!1,width:l.flow.width,height:l.flow.height,style:{width:l.flow.width,height:l.flow.height}})})}let h=[...n.values()].sort((e,t)=>e.kind.localeCompare(t.kind)||e.label.localeCompare(t.label));for(let e of h){let t=i.node(e.id),n=l[e.kind],a=r.get(e.id)??0;o.push({id:e.id,type:e.kind,position:{x:(t?.x??0)-n.width/2,y:(t?.y??0)-n.height/2},data:{kind:e.kind,label:e.label,refId:e.id,...e.facet===void 0?{}:{facet:e.facet},badge:e.facet??(a>0?String(a):e.kind)},draggable:!1,zIndex:f.leaf,width:n.width,height:n.height,style:{width:n.width,height:n.height}})}return o}function x(e,t,n,r={}){let i=t.size>0||n.size>0;return e.map(e=>{if(e.data.kind===`unit`||e.data.kind===`law`)return e;let a=e.data.kind===`flow`?t.has(e.data.refId):n.has(e.id);return{...e,data:{...e.data,highlighted:a,dimmed:i&&!a,active:r.activeNodeId!=null&&e.id===r.activeNodeId,focused:r.focusedNodeId!=null&&e.id===r.focusedNodeId}}})}function S(e,t){let n=new Map(t.map(e=>[e.id,e]));return t.some(e=>e.data.highlighted===!0)?e.map(e=>{let t=n.get(e.source),r=n.get(e.target),i=t?.data.highlighted===!0&&r?.data.highlighted===!0,a=u[e.data?.kind??`reads`];return{...e,animated:i?!0:e.animated,style:{...e.style,stroke:a,opacity:i?1:.32,strokeWidth:i?2.75:1.75},markerEnd:e.markerEnd&&typeof e.markerEnd==`object`?{...e.markerEnd,color:a}:e.markerEnd}}):e.map(e=>({...e,style:{...e.style,opacity:1}}))}var C=100;function w(e,t){return e.filter(e=>t.has(e.flow)).sort((e,t)=>t.startedAt-e.startedAt).slice(0,C)}var T=a();function E({cache:a,dataSlot:o}){let s=d(a);return(0,T.jsxs)(r,{children:[(0,T.jsx)(n,{render:t=>(0,T.jsx)(`span`,{...t,className:e(`flex w-4 shrink-0 items-center justify-center`,s.className),"data-slot":o,"data-cache":a,"aria-label":s.label,children:(0,T.jsx)(i,{icon:s.icon,className:`size-3`,"aria-hidden":!0})})}),(0,T.jsx)(t,{side:`top`,children:s.label})]})}export{S as a,p as c,x as i,w as n,y as o,m as r,g as s,E as t};