station-kit 1.0.8 → 1.0.9

package/src/app/broadcasts/page.tsx

@@ -1,10 +1,12 @@
 "use client";
 
 import { useEffect, useState } from "react";
+import Link from "next/link";
 import { useRouter } from "next/navigation";
-import { useApi, type BroadcastMeta } from "../hooks/use-api";
+import { useApi, type BroadcastMeta, type DynamicBroadcastSpec } from "../hooks/use-api";
 import { useBreadcrumb } from "../hooks/use-breadcrumb";
 import { SchemaForm } from "../components/schema-form";
+import { ApiPanel } from "../components/api-panel";
 
 function formatMs(ms: number): string {
   if (ms < 1000) return `${ms}ms`;
@@ -17,6 +19,7 @@ export default function BroadcastsPage() {
   const api = useApi();
   const router = useRouter();
   const [broadcasts, setBroadcasts] = useState<BroadcastMeta[]>([]);
+  const [definitions, setDefinitions] = useState<DynamicBroadcastSpec[]>([]);
   const [loading, setLoading] = useState(true);
   const [triggerTarget, setTriggerTarget] = useState<string | null>(null);
   const [inputJson, setInputJson] = useState("{}");
@@ -25,27 +28,30 @@ export default function BroadcastsPage() {
   useBreadcrumb([{ label: "Broadcasts" }], "broadcasts");
 
   useEffect(() => {
-    api.getBroadcasts()
-      .then((res) => setBroadcasts(res.data))
-      .catch((err: unknown) => {
-        if (err instanceof Error) {
-          console.error("Failed to load broadcasts:", err.message);
-        }
+    Promise.all([
+      api.getBroadcasts().catch(() => ({ data: [] as BroadcastMeta[] })),
+      api.getBroadcastDefinitions().catch(() => ({ data: [] as DynamicBroadcastSpec[] })),
+    ])
+      .then(([staticRes, dynamicRes]) => {
+        setBroadcasts(staticRes.data);
+        setDefinitions(dynamicRes.data);
       })
       .finally(() => setLoading(false));
   }, []);
 
-  async function handleTrigger(name: string) {
+  async function handleTrigger(name: string, isDynamic: boolean) {
     setTriggering(true);
     try {
       const input = JSON.parse(inputJson);
-      await api.triggerBroadcast(name, input);
+      if (isDynamic) {
+        await api.triggerDynamicBroadcast(name, input);
+      } else {
+        await api.triggerBroadcast(name, input);
+      }
       setTriggerTarget(null);
       setInputJson("{}");
     } catch (err: unknown) {
-      if (err instanceof Error) {
-        console.error("Trigger failed:", err.message);
-      }
+      if (err instanceof Error) console.error("Trigger failed:", err.message);
     }
     setTriggering(false);
   }
@@ -69,90 +75,169 @@ export default function BroadcastsPage() {
     );
   }
 
-  if (broadcasts.length === 0) {
-    return (
-      <div>
-        <h1 className="page-title">Broadcasts</h1>
-        <div className="empty-state">
-          <p className="empty-state-text">No broadcasts discovered.</p>
-        </div>
-      </div>
-    );
-  }
-
   return (
     <div>
-      <h1 className="page-title">Broadcasts</h1>
+      <div style={{ display: "flex", alignItems: "center", justifyContent: "space-between", marginBottom: "1rem" }}>
+        <h1 className="page-title" style={{ margin: 0 }}>Broadcasts</h1>
+        <Link href="/broadcasts/new" className="btn btn--primary">+ New dynamic broadcast</Link>
+      </div>
 
-      <table className="station-table">
-        <thead>
-          <tr>
-            <th>Name</th>
-            <th>Nodes</th>
-            <th>Failure Policy</th>
-            <th>Timeout</th>
-            <th></th>
-          </tr>
-        </thead>
-        <tbody>
-          {broadcasts.map((b, i) => {
-            const isOpen = triggerTarget === b.name;
-            return isOpen ? (
-              <tr key={b.name} className="reveal-item" style={{ animationDelay: `${i * 40}ms` }}>
-                <td colSpan={5} style={{ padding: 0 }}>
-                  <div style={{ padding: "0.75rem" }}>
-                    <div style={{ display: "flex", alignItems: "center", justifyContent: "space-between", marginBottom: "0.75rem" }}>
-                      <span className="mono" style={{ fontWeight: 600 }}>{b.name}</span>
-                      <span style={{ color: "var(--muted)", fontSize: "0.8125rem" }}>
-                        {b.nodes.length} nodes / {b.failurePolicy} / {b.timeout !== null ? formatMs(b.timeout) : "\u2014"}
-                      </span>
+      <h2 style={{ fontSize: "0.875rem", textTransform: "uppercase", letterSpacing: "0.05em", color: "var(--muted)", marginTop: "1.5rem", marginBottom: "0.5rem" }}>
+        File-defined ({broadcasts.length})
+      </h2>
+      {broadcasts.length === 0 ? (
+        <div className="empty-state">
+          <p className="empty-state-text">No file-defined broadcasts discovered.</p>
+        </div>
+      ) : (
+        <table className="station-table">
+          <thead>
+            <tr>
+              <th>Name</th>
+              <th>Nodes</th>
+              <th>Failure Policy</th>
+              <th>Timeout</th>
+              <th></th>
+            </tr>
+          </thead>
+          <tbody>
+            {broadcasts.map((b, i) => {
+              const isOpen = triggerTarget === b.name;
+              return isOpen ? (
+                <tr key={b.name} className="reveal-item" style={{ animationDelay: `${i * 40}ms` }}>
+                  <td colSpan={5} style={{ padding: 0 }}>
+                    <div style={{ padding: "0.75rem" }}>
+                      <div style={{ display: "flex", alignItems: "center", justifyContent: "space-between", marginBottom: "0.75rem" }}>
+                        <span className="mono" style={{ fontWeight: 600 }}>{b.name}</span>
+                        <span style={{ color: "var(--muted)", fontSize: "0.8125rem" }}>
+                          {b.nodes.length} nodes / {b.failurePolicy} / {b.timeout !== null ? formatMs(b.timeout) : "—"}
+                        </span>
+                      </div>
+                      <SchemaForm schema={null} value={inputJson} onChange={setInputJson} />
+                      <div style={{ marginTop: "0.5rem", display: "flex", gap: "0.5rem" }}>
+                        <button className="btn btn--primary" onClick={() => handleTrigger(b.name, false)} disabled={triggering}>
+                          {triggering ? "Dispatching..." : "Dispatch"}
+                        </button>
+                        <button className="btn" onClick={() => toggleTrigger(b.name)}>Cancel</button>
+                      </div>
                     </div>
-                    <SchemaForm
-                      schema={null}
-                      value={inputJson}
-                      onChange={setInputJson}
-                    />
-                    <div style={{ marginTop: "0.5rem", display: "flex", gap: "0.5rem" }}>
-                      <button
-                        className="btn btn--primary"
-                        onClick={() => handleTrigger(b.name)}
-                        disabled={triggering}
-                      >
-                        {triggering ? "Dispatching..." : "Dispatch"}
-                      </button>
-                      <button className="btn" onClick={() => toggleTrigger(b.name)}>
-                        Cancel
-                      </button>
+                  </td>
+                </tr>
+              ) : (
+                <tr
+                  key={b.name}
+                  className="reveal-item clickable-row"
+                  style={{ animationDelay: `${i * 40}ms` }}
+                  onClick={() => router.push(`/broadcasts/${encodeURIComponent(b.name)}`)}
+                >
+                  <td className="mono">{b.name}</td>
+                  <td className="mono">{b.nodes.length}</td>
+                  <td className="mono" style={{ color: "var(--muted)" }}>{b.failurePolicy}</td>
+                  <td className="mono" style={{ fontSize: "0.8125rem" }}>
+                    {b.timeout !== null ? formatMs(b.timeout) : "—"}
+                  </td>
+                  <td>
+                    <button
+                      className="btn btn--sm btn--primary"
+                      onClick={(e) => { e.stopPropagation(); toggleTrigger(b.name); }}
+                    >Trigger</button>
+                  </td>
+                </tr>
+              );
+            })}
+          </tbody>
+        </table>
+      )}
+
+      <h2 style={{ fontSize: "0.875rem", textTransform: "uppercase", letterSpacing: "0.05em", color: "var(--muted)", marginTop: "2rem", marginBottom: "0.5rem" }}>
+        Dynamic ({definitions.length})
+      </h2>
+      {definitions.length === 0 ? (
+        <div className="empty-state">
+          <p className="empty-state-text">No dynamic broadcasts. <Link href="/broadcasts/new">Create one</Link>.</p>
+        </div>
+      ) : (
+        <table className="station-table">
+          <thead>
+            <tr>
+              <th>Name</th>
+              <th>Version</th>
+              <th>Nodes</th>
+              <th>Failure Policy</th>
+              <th>Timeout</th>
+              <th></th>
+            </tr>
+          </thead>
+          <tbody>
+            {definitions.map((d, i) => {
+              const dynKey = `dyn:${d.name}`;
+              const isOpen = triggerTarget === dynKey;
+              return isOpen ? (
+                <tr key={d.name} className="reveal-item" style={{ animationDelay: `${i * 40}ms` }}>
+                  <td colSpan={6} style={{ padding: 0 }}>
+                    <div style={{ padding: "0.75rem" }}>
+                      <div style={{ display: "flex", alignItems: "center", justifyContent: "space-between", marginBottom: "0.75rem" }}>
+                        <span className="mono" style={{ fontWeight: 600 }}>{d.name}</span>
+                        <span style={{ color: "var(--muted)", fontSize: "0.8125rem" }}>
+                          v{d.version} / {d.nodes.length} nodes / {d.failurePolicy}
+                        </span>
+                      </div>
+                      <SchemaForm schema={null} value={inputJson} onChange={setInputJson} />
+                      <div style={{ marginTop: "0.5rem", display: "flex", gap: "0.5rem" }}>
+                        <button className="btn btn--primary" onClick={() => handleTrigger(d.name, true)} disabled={triggering}>
+                          {triggering ? "Dispatching..." : "Dispatch"}
+                        </button>
+                        <button className="btn" onClick={() => toggleTrigger(dynKey)}>Cancel</button>
+                      </div>
                     </div>
-                  </div>
-                </td>
-              </tr>
-            ) : (
-              <tr
-                key={b.name}
-                className="reveal-item clickable-row"
-                style={{ animationDelay: `${i * 40}ms` }}
-                onClick={() => router.push(`/broadcasts/${encodeURIComponent(b.name)}`)}
-              >
-                <td className="mono">{b.name}</td>
-                <td className="mono">{b.nodes.length}</td>
-                <td className="mono" style={{ color: "var(--muted)" }}>{b.failurePolicy}</td>
-                <td className="mono" style={{ fontSize: "0.8125rem" }}>
-                  {b.timeout !== null ? formatMs(b.timeout) : "\u2014"}
-                </td>
-                <td>
-                  <button
-                    className="btn btn--sm btn--primary"
-                    onClick={(e) => { e.stopPropagation(); toggleTrigger(b.name); }}
-                  >
-                    Trigger
-                  </button>
-                </td>
-              </tr>
-            );
-          })}
-        </tbody>
-      </table>
+                  </td>
+                </tr>
+              ) : (
+                <tr
+                  key={d.name}
+                  className="reveal-item clickable-row"
+                  style={{ animationDelay: `${i * 40}ms` }}
+                  onClick={() => router.push(`/broadcasts/dyn/${encodeURIComponent(d.name)}`)}
+                >
+                  <td className="mono">{d.name}</td>
+                  <td className="mono">v{d.version}</td>
+                  <td className="mono">{d.nodes.length}</td>
+                  <td className="mono" style={{ color: "var(--muted)" }}>{d.failurePolicy}</td>
+                  <td className="mono" style={{ fontSize: "0.8125rem" }}>
+                    {d.timeout ? formatMs(d.timeout) : "—"}
+                  </td>
+                  <td>
+                    <button
+                      className="btn btn--sm btn--primary"
+                      onClick={(e) => { e.stopPropagation(); toggleTrigger(dynKey); }}
+                    >Trigger</button>
+                  </td>
+                </tr>
+              );
+            })}
+          </tbody>
+        </table>
+      )}
+
+      <ApiPanel
+        title="List & trigger broadcasts"
+        snippets={[
+          { label: "List file-defined broadcasts", method: "GET", path: "/api/v1/broadcasts" },
+          { label: "List dynamic broadcasts", method: "GET", path: "/api/v1/broadcast-definitions" },
+          {
+            label: "Trigger a static broadcast",
+            method: "POST",
+            path: "/api/v1/trigger-broadcast",
+            body: { broadcastName: "<name>", input: {} },
+          },
+          {
+            label: "Trigger a dynamic broadcast",
+            method: "POST",
+            path: "/api/v1/trigger-dynamic-broadcast",
+            body: { broadcastName: "<name>", input: {} },
+          },
+        ]}
+      />
     </div>
   );
 }

package/src/app/components/api-panel.tsx

@@ -0,0 +1,151 @@
+"use client";
+
+import { useState } from "react";
+
+export interface ApiSnippet {
+  label: string;
+  method: "GET" | "POST" | "PATCH" | "DELETE" | "PUT";
+  path: string;
+  body?: unknown;
+  query?: Record<string, string | number | boolean | undefined>;
+}
+
+export interface ApiPanelProps {
+  title?: string;
+  snippets: ApiSnippet[];
+}
+
+/**
+ * Collapsible "API panel" that mirrors the actions available on the page as
+ * `curl` commands. Lowers the barrier from "I clicked a button" to "I can
+ * script this." Renders nothing if `snippets` is empty.
+ */
+export function ApiPanel({ title = "API equivalent", snippets }: ApiPanelProps) {
+  const [open, setOpen] = useState(false);
+  const [copiedIdx, setCopiedIdx] = useState<number | null>(null);
+  const [copyFailedIdx, setCopyFailedIdx] = useState<number | null>(null);
+
+  if (snippets.length === 0) return null;
+
+  async function copyText(text: string, idx: number): Promise<void> {
+    try {
+      if (navigator.clipboard?.writeText) {
+        await navigator.clipboard.writeText(text);
+        setCopiedIdx(idx);
+        setTimeout(() => setCopiedIdx((c) => (c === idx ? null : c)), 1500);
+        return;
+      }
+      throw new Error("clipboard API unavailable");
+    } catch {
+      // Fall back to the legacy approach for non-secure-context deploys.
+      try {
+        const ta = document.createElement("textarea");
+        ta.value = text;
+        ta.style.position = "fixed";
+        ta.style.left = "-9999px";
+        document.body.appendChild(ta);
+        ta.select();
+        const ok = document.execCommand("copy");
+        document.body.removeChild(ta);
+        if (ok) {
+          setCopiedIdx(idx);
+          setTimeout(() => setCopiedIdx((c) => (c === idx ? null : c)), 1500);
+        } else {
+          throw new Error("execCommand copy returned false");
+        }
+      } catch {
+        setCopyFailedIdx(idx);
+        setTimeout(() => setCopyFailedIdx((c) => (c === idx ? null : c)), 2000);
+      }
+    }
+  }
+
+  return (
+    <details
+      open={open}
+      onToggle={(e) => setOpen((e.target as HTMLDetailsElement).open)}
+      style={{
+        marginTop: "1.5rem",
+        border: "1px solid var(--border)",
+        borderRadius: "4px",
+        background: "var(--surface)",
+      }}
+    >
+      <summary
+        style={{
+          padding: "0.5rem 0.75rem",
+          fontSize: "0.75rem",
+          fontFamily: "var(--mono-font, monospace)",
+          color: "var(--muted)",
+          textTransform: "uppercase",
+          letterSpacing: "0.05em",
+          cursor: "pointer",
+          listStyle: "none",
+        }}
+      >
+        ▸ {title}
+      </summary>
+      <div style={{ padding: "0.5rem 0.75rem 0.75rem" }}>
+        {snippets.map((s, i) => {
+          const cmd = toCurl(s);
+          return (
+            <div key={i} style={{ marginBottom: i === snippets.length - 1 ? 0 : "0.75rem" }}>
+              <div style={{ display: "flex", alignItems: "center", justifyContent: "space-between", marginBottom: "0.25rem" }}>
+                <div className="mono" style={{ fontSize: "0.75rem", color: "var(--muted)" }}>
+                  {s.label}
+                </div>
+                <button
+                  type="button"
+                  className="btn btn--sm"
+                  onClick={() => copyText(cmd, i)}
+                  title={copyFailedIdx === i ? "Copy failed — select the text manually" : ""}
+                >
+                  {copiedIdx === i ? "Copied" : copyFailedIdx === i ? "Copy failed" : "Copy"}
+                </button>
+              </div>
+              <pre className="mono" style={{
+                margin: 0,
+                padding: "0.5rem 0.75rem",
+                background: "var(--bg, #fff)",
+                border: "1px solid var(--border)",
+                borderRadius: "4px",
+                fontSize: "0.75rem",
+                overflowX: "auto",
+                whiteSpace: "pre",
+              }}>{cmd}</pre>
+            </div>
+          );
+        })}
+      </div>
+    </details>
+  );
+}
+
+function toCurl(snippet: ApiSnippet): string {
+  const queryParts: string[] = [];
+  if (snippet.query) {
+    for (const [k, v] of Object.entries(snippet.query)) {
+      if (v === undefined) continue;
+      queryParts.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+    }
+  }
+  const path = `${snippet.path}${queryParts.length ? `?${queryParts.join("&")}` : ""}`;
+  // Use the dashboard's actual origin so users can copy and run the snippet
+  // against the same server. SSR fall-back uses a placeholder.
+  const origin = typeof window !== "undefined" && window.location?.origin
+    ? window.location.origin
+    : "https://your-station.example.com";
+  const lines: string[] = [];
+  lines.push(`curl -X ${snippet.method} \\`);
+  lines.push(`  ${origin}${path} \\`);
+  lines.push(`  -H 'Authorization: Bearer sk_live_…' \\`);
+  if (snippet.body !== undefined) {
+    lines.push(`  -H 'Content-Type: application/json' \\`);
+    const body = typeof snippet.body === "string" ? snippet.body : JSON.stringify(snippet.body, null, 2);
+    lines.push(`  -d ${JSON.stringify(body)}`);
+  } else {
+    // Trim trailing backslash on the last line if there's no body.
+    lines[lines.length - 1] = lines[lines.length - 1].replace(/ \\$/, "");
+  }
+  return lines.join("\n");
+}

package/src/app/components/shell.tsx

@@ -77,6 +77,26 @@ function IconSettings() {
   );
 }
 
+function IconSchedules() {
+  /* Clock face — recurring schedule */
+  return (
+    <svg width="14" height="14" viewBox="0 0 14 14" fill="none" stroke="currentColor" strokeWidth="1.2" strokeLinecap="round" aria-hidden="true">
+      <circle cx="7" cy="7" r="5.5" />
+      <path d="M7 4v3l2 1.5" />
+    </svg>
+  );
+}
+
+function IconPlayground() {
+  /* Beaker — experiment / playground */
+  return (
+    <svg width="14" height="14" viewBox="0 0 14 14" fill="none" stroke="currentColor" strokeWidth="1.2" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+      <path d="M5 1h4M5.5 1v4L2 11.5a1.5 1.5 0 0 0 1.3 2.3h7.4a1.5 1.5 0 0 0 1.3-2.3L8.5 5V1" />
+      <path d="M3.5 8.5h7" />
+    </svg>
+  );
+}
+
 function NavLink({
   href,
   label,
@@ -135,6 +155,9 @@ export function Shell({ children }: { children: React.ReactNode }) {
           <NavLink href="/" label="Overview" section="overview" icon={<IconOverview />} />
           <NavLink href="/signals" label="Signals" section="signals" icon={<IconSignals />} />
           <NavLink href="/broadcasts" label="Broadcasts" section="broadcasts" icon={<IconBroadcasts />} />
+          <NavLink href="/schedules" label="Schedules" section="schedules" icon={<IconSchedules />} />
+          <div className="station-sidebar-nav-label" style={{ marginTop: "1rem" }}>Tools</div>
+          <NavLink href="/playground/expression" label="Expressions" section="playground" icon={<IconPlayground />} />
           <div className="station-sidebar-nav-label" style={{ marginTop: "1rem" }}>Admin</div>
           <NavLink href="/settings" label="Settings" section="settings" icon={<IconSettings />} />
         </nav>

package/src/app/hooks/use-api.ts

@@ -81,6 +81,51 @@ export interface BroadcastMeta {
   interval: string | null;
 }
 
+// ─── Dynamic broadcasts / schedules / expressions ───────────────────
+
+export type ScheduleKind = "signal" | "broadcast-static" | "broadcast-dynamic";
+
+export interface Schedule {
+  id: string;
+  kind: ScheduleKind;
+  target: string;
+  interval: string;
+  input?: unknown;
+  enabled: boolean;
+  nextRunAt: string;
+  lastRunAt?: string;
+  lastRunStatus?: string;
+  lastRunId?: string;
+  createdAt: string;
+  updatedAt: string;
+  createdBy?: string;
+}
+
+export interface DynamicNodeSpec {
+  name: string;
+  signalName: string;
+  dependsOn: string[];
+  input?: unknown;
+  when?: unknown;
+}
+
+export interface DynamicBroadcastSpec {
+  name: string;
+  version: number;
+  failurePolicy: "fail-fast" | "skip-downstream" | "continue";
+  timeout?: number;
+  nodes: DynamicNodeSpec[];
+  createdAt: string;
+  updatedAt: string;
+  createdBy?: string;
+  deletedAt?: string;
+}
+
+export interface DynamicValidationResult {
+  ok: boolean;
+  errors: Array<{ node: string; field?: string; message: string }>;
+}
+
 export function useApi() {
   return {
     // Health
@@ -129,6 +174,78 @@ export function useApi() {
     cancelBroadcastRun: (id: string) => fetchApi<{ cancelled: boolean }>(`/broadcast-runs/${id}/cancel`, { method: "POST" }),
     rerunBroadcastRun: (id: string) => fetchApi<{ id: string; broadcastName: string; status: string }>(`/broadcast-runs/${id}/rerun`, { method: "POST" }),
 
+    // Dynamic broadcast definitions (v1)
+    getBroadcastDefinitions: () =>
+      fetchApi<DynamicBroadcastSpec[]>("/v1/broadcast-definitions"),
+    getBroadcastDefinition: (name: string) =>
+      fetchApi<DynamicBroadcastSpec>(`/v1/broadcast-definitions/${encodeURIComponent(name)}`),
+    getBroadcastDefinitionVersions: (name: string) =>
+      fetchApi<DynamicBroadcastSpec[]>(`/v1/broadcast-definitions/${encodeURIComponent(name)}/versions`),
+    saveBroadcastDefinition: (spec: Partial<DynamicBroadcastSpec>) =>
+      fetchApi<DynamicBroadcastSpec>("/v1/broadcast-definitions", {
+        method: "POST",
+        body: JSON.stringify(spec),
+      }),
+    validateBroadcastDefinition: (spec: Partial<DynamicBroadcastSpec>) =>
+      fetchApi<DynamicValidationResult>("/v1/broadcast-definitions/validate", {
+        method: "POST",
+        body: JSON.stringify(spec),
+      }),
+    deleteBroadcastDefinition: (name: string) =>
+      fetchApi<{ deleted: boolean }>(`/v1/broadcast-definitions/${encodeURIComponent(name)}`, {
+        method: "DELETE",
+      }),
+    triggerDynamicBroadcast: (broadcastName: string, input?: unknown) =>
+      fetchApi<{ id: string }>("/v1/trigger-dynamic-broadcast", {
+        method: "POST",
+        body: JSON.stringify({ broadcastName, input: input ?? {} }),
+      }),
+
+    // Schedules (v1)
+    getSchedules: (filter?: { kind?: ScheduleKind; enabled?: boolean }) => {
+      const q = new URLSearchParams();
+      if (filter?.kind) q.set("kind", filter.kind);
+      if (filter?.enabled !== undefined) q.set("enabled", String(filter.enabled));
+      const qs = q.toString();
+      return fetchApi<Schedule[]>(`/v1/schedules${qs ? `?${qs}` : ""}`);
+    },
+    getSchedule: (id: string) => fetchApi<Schedule>(`/v1/schedules/${id}`),
+    createSchedule: (input: { kind: ScheduleKind; target: string; interval: string; input?: unknown; enabled?: boolean }) =>
+      fetchApi<Schedule>("/v1/schedules", { method: "POST", body: JSON.stringify(input) }),
+    updateSchedule: (id: string, patch: Partial<{ interval: string; input: unknown; enabled: boolean; nextRunAt: string }>) =>
+      fetchApi<Schedule>(`/v1/schedules/${id}`, { method: "PATCH", body: JSON.stringify(patch) }),
+    deleteSchedule: (id: string) =>
+      fetchApi<{ deleted: boolean }>(`/v1/schedules/${id}`, { method: "DELETE" }),
+    previewSchedule: (id: string, count = 5) =>
+      fetchApi<{ fires: string[] }>(`/v1/schedules/${id}/preview`, {
+        method: "POST",
+        body: JSON.stringify({ count }),
+      }),
+
+    // Expressions (v1)
+    evaluateExpression: (node: unknown, context?: { input?: unknown; upstream?: Record<string, unknown> }) =>
+      fetchApi<{ value: unknown }>("/v1/expressions/evaluate", {
+        method: "POST",
+        body: JSON.stringify({ node, context }),
+      }),
+    validateExpression: (
+      node: unknown,
+      schemaContext?: {
+        inputSchema?: unknown;
+        upstreamSchemas?: Record<string, unknown>;
+        expectedSchema?: unknown;
+      },
+    ) =>
+      fetchApi<{ ok: boolean; errors: Array<{ path: string; message: string }> }>(
+        "/v1/expressions/validate",
+        { method: "POST", body: JSON.stringify({ node, schemaContext }) },
+      ),
+    parseExpression: (source: string) =>
+      fetchApi<{ node: unknown }>("/v1/expressions/parse", {
+        method: "POST",
+        body: JSON.stringify({ source }),
+      }),
+
     // API Keys (v1 admin routes — session cookie provides admin scope)
     getApiKeys: () => fetchApi<Array<{ id: string; name: string; keyPrefix: string; scopes: string[]; createdAt: string; lastUsed: string | null; expiresAt: string | null; revoked: boolean }>>("/v1/keys"),
     createApiKey: (name: string, scopes: string[]) =>