[V0_FILE]typescriptreact:file="app/components/demo.tsx" "use client"; import { useCallback, useEffect, useMemo, useRef, useState } from "react"; import { FanOutCodeWorkbench } from "./fanout-code-workbench"; type ChannelId = "slack" | "email" | "sms" | "pagerduty"; type RunStatus = "fan_out" | "aggregating" | "done"; type ChannelStatus = "pending" | "sending" | "sent" | "failed"; type HighlightTone = "amber" | "cyan" | "green" | "red"; type GutterMarkKind = "success" | "fail"; type ChannelSnapshot = { id: ChannelId; label: string; durationMs: number; status: Exclude; error?: string; }; type DisplayChannelSnapshot = { id: ChannelId; label: string; durationMs: number; status: ChannelStatus; error?: string; }; type FanOutSnapshot = { runId: string; incidentId: string; message: string; status: RunStatus; elapsedMs: number; channels: ChannelSnapshot[]; summary?: { ok: number; failed: number; }; }; type StartResponse = { runId: string; incidentId: string; message: string; failChannels: ChannelId[]; status: "fan_out"; }; type WorkflowLineMap = { allSettled: number[]; deliveries: number[]; summary: number[]; returnResult: number[]; }; type StepLineMap = Record; type DemoProps = { workflowCode: string; workflowLinesHtml: string[]; stepCode: string; stepLinesHtml: string[]; workflowLineMap: WorkflowLineMap; stepLineMap: StepLineMap; }; type HighlightState = { workflowActiveLines: number[]; stepActiveLines: number[]; workflowGutterMarks: Record; stepGutterMarks: Record; activeChannel: ChannelId | null; }; const POLL_INTERVAL_MS = 150; const MIN_MOCK_CHANNEL_DURATION_MS = 500; export const FAN_OUT_DEMO_DEFAULTS = { incidentId: "INC-2041", message: "Database latency exceeded 1.5s threshold in us-east-1", failChannels: [] as ChannelId[], }; const CHANNEL_OPTIONS: Array<{ id: ChannelId; label: string; compactLabel: string; durationMs: number; }> = [ { id: "slack", label: "Slack", compactLabel: "SL", durationMs: Math.max(MIN_MOCK_CHANNEL_DURATION_MS, 650), }, { id: "email", label: "Email", compactLabel: "EM", durationMs: Math.max(MIN_MOCK_CHANNEL_DURATION_MS, 900), }, { id: "sms", label: "SMS", compactLabel: "SMS", durationMs: Math.max(MIN_MOCK_CHANNEL_DURATION_MS, 1150), }, { id: "pagerduty", label: "PagerDuty", compactLabel: "PD", durationMs: Math.max(MIN_MOCK_CHANNEL_DURATION_MS, 750), }, ]; const DEFAULT_CHANNEL_SNAPSHOT: DisplayChannelSnapshot[] = CHANNEL_OPTIONS.map( (channel) => ({ id: channel.id, label: channel.label, durationMs: channel.durationMs, status: "pending", }) ); const EMPTY_HIGHLIGHT_STATE: HighlightState = { workflowActiveLines: [], stepActiveLines: [], workflowGutterMarks: {}, stepGutterMarks: {}, activeChannel: null, }; export function ensureActiveAbortController( existing: AbortController | null ): AbortController { if (!existing || existing.signal.aborted) { return new AbortController(); } return existing; } function formatElapsedMs(ms: number): string { return `${(ms / 1000).toFixed(2)}s`; } function channelColor(status: ChannelStatus): string { if (status === "sent") return "var(--color-green-700)"; if (status === "failed") return "var(--color-red-700)"; if (status === "sending") return "var(--color-amber-700)"; return "var(--color-gray-500)"; } function mergeUniqueLines(...lineGroups: number[][]): number[] { return [...new Set(lineGroups.flat())].sort((a, b) => a - b); } function addGutterMarks( target: Record, lines: number[], kind: GutterMarkKind = "success" ) { for (const lineNumber of lines) { target[lineNumber] = kind; } } function highlightToneForSnapshot(snapshot: FanOutSnapshot | null): HighlightTone { if (!snapshot || snapshot.status === "fan_out") { return "amber"; } if (snapshot.status === "aggregating") { return "cyan"; } return snapshot.summary?.failed ? "red" : "green"; } function pickActiveChannel(snapshot: FanOutSnapshot): ChannelId | null { if (snapshot.status !== "fan_out") { return null; } const sending = snapshot.channels.filter((channel) => channel.status === "sending"); if (sending.length === 0) { return null; } return sending.reduce((current, channel) => { if (channel.durationMs < current.durationMs) { return channel; } return current; }).id; } function buildHighlightState( snapshot: FanOutSnapshot | null, workflowLineMap: WorkflowLineMap, stepLineMap: StepLineMap ): HighlightState { if (!snapshot) { return EMPTY_HIGHLIGHT_STATE; } const workflowGutterMarks: Record = {}; const stepGutterMarks: Record = {}; if (snapshot.status === "fan_out") { const activeChannel = pickActiveChannel(snapshot); for (const channel of snapshot.channels) { if (channel.status !== "sending") { addGutterMarks( stepGutterMarks, stepLineMap[channel.id] ?? [], channel.status === "failed" ? "fail" : "success" ); } } return { workflowActiveLines: workflowLineMap.allSettled, stepActiveLines: activeChannel ? stepLineMap[activeChannel] ?? [] : [], workflowGutterMarks, stepGutterMarks, activeChannel, }; } const snapshotChannelById = new Map( snapshot.channels.map((channel) => [channel.id, channel] as const) ); for (const channel of CHANNEL_OPTIONS) { const markKind = snapshotChannelById.get(channel.id)?.status === "failed" ? "fail" : "success"; addGutterMarks(stepGutterMarks, stepLineMap[channel.id] ?? [], markKind); } if (snapshot.status === "aggregating") { addGutterMarks(workflowGutterMarks, workflowLineMap.allSettled); return { workflowActiveLines: mergeUniqueLines( workflowLineMap.deliveries, workflowLineMap.summary ), stepActiveLines: [], workflowGutterMarks, stepGutterMarks, activeChannel: null, }; } addGutterMarks( workflowGutterMarks, mergeUniqueLines( workflowLineMap.allSettled, workflowLineMap.deliveries, workflowLineMap.summary, workflowLineMap.returnResult ) ); return { workflowActiveLines: [], stepActiveLines: [], workflowGutterMarks, stepGutterMarks, activeChannel: null, }; } function buildExecutionLog( snapshot: FanOutSnapshot | null, incidentId: string, message: string ): string[] { if (!snapshot) { return [ "Idle: click Dispatch Alert to start the run.", "Promise.allSettled() will fan out to all channels in parallel.", ]; } const entries: string[] = [ `[0.00s] incident ${incidentId} queued`, "[0.00s] Promise.allSettled() launched 4 channel sends", ]; for (const channel of snapshot.channels) { if (channel.status === "sending") { entries.push( `[${formatElapsedMs(Math.min(snapshot.elapsedMs, channel.durationMs))}] ${channel.id} sending...` ); continue; } if (channel.status === "failed") { entries.push( `[${formatElapsedMs(channel.durationMs)}] ${channel.id} failed: ${channel.error}` ); continue; } entries.push(`[${formatElapsedMs(channel.durationMs)}] ${channel.id} sent`); } if (snapshot.status === "aggregating") { entries.push( `[${formatElapsedMs(snapshot.elapsedMs)}] aggregating deliveries and summary` ); } if (snapshot.status === "done" && snapshot.summary) { entries.push( `[${formatElapsedMs(snapshot.elapsedMs)}] summary recorded: ok=${snapshot.summary.ok}, failed=${snapshot.summary.failed}` ); } entries.push(`[${formatElapsedMs(snapshot.elapsedMs)}] message: ${message}`); return entries; } function statusExplanation( status: RunStatus | "idle", activeChannel: ChannelId | null ): string { if (status === "idle") { return "Waiting to start. Click Dispatch Alert to run the workflow."; } if (status === "fan_out") { if (!activeChannel) { return "Fan-out active: Promise.allSettled() is waiting for every channel to settle."; } return `Fan-out active: tracing ${activeChannel} while every channel continues in parallel.`; } if (status === "aggregating") { return "Aggregation active: mapping settled deliveries and computing summary."; } return "Completed: all channels settled and the summary checkpoint is persisted."; } async function postJson( url: string, body: unknown, signal?: AbortSignal ): Promise { const response = await fetch(url, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body), signal, }); const payload = (await response.json().catch(() => null)) as | { error?: string } | null; if (!response.ok) { throw new Error(payload?.error ?? `Request failed: ${response.status}`); } return payload as TResponse; } async function getStatus( runId: string, signal?: AbortSignal ): Promise { const response = await fetch( `/api/mock/status?runId=${encodeURIComponent(runId)}`, { cache: "no-store", signal, } ); const payload = (await response.json().catch(() => null)) as | FanOutSnapshot | { error?: string } | null; if (!response.ok) { throw new Error( (payload as { error?: string } | null)?.error ?? `Request failed: ${response.status}` ); } return payload as FanOutSnapshot; } export function toggleFailChannel( previous: ChannelId[], channelId: ChannelId, shouldFail: boolean ): ChannelId[] { if (shouldFail) { if (previous.includes(channelId)) { return previous; } return [...previous, channelId]; } return previous.filter((value) => value !== channelId); } export function FanOutDemo({ workflowCode, workflowLinesHtml, stepCode, stepLinesHtml, workflowLineMap, stepLineMap, }: DemoProps) { const [failChannels, setFailChannels] = useState( FAN_OUT_DEMO_DEFAULTS.failChannels ); const [runId, setRunId] = useState(null); const [snapshot, setSnapshot] = useState(null); const [error, setError] = useState(null); const pollingRef = useRef | null>(null); const abortRef = useRef(null); const startButtonRef = useRef(null); const hasScrolledRef = useRef(false); useEffect(() => { if (runId && !hasScrolledRef.current) { hasScrolledRef.current = true; const heading = document.getElementById("try-it-heading"); if (heading) { const top = heading.getBoundingClientRect().top + window.scrollY; window.scrollTo({ top, behavior: "smooth" }); } } if (!runId) { hasScrolledRef.current = false; } }, [runId]); const stopPolling = useCallback(() => { if (!pollingRef.current) { return; } clearInterval(pollingRef.current); pollingRef.current = null; }, []); const ensureAbortController = useCallback((): AbortController => { const nextController = ensureActiveAbortController(abortRef.current); abortRef.current = nextController; return nextController; }, []); useEffect(() => { return () => { stopPolling(); abortRef.current?.abort(); abortRef.current = null; }; }, [stopPolling]); const pollStatus = useCallback( (targetRunId: string) => { stopPolling(); let inFlight = false; const readSnapshot = async () => { if (inFlight) { return; } inFlight = true; try { const controller = ensureAbortController(); const next = await getStatus(targetRunId, controller.signal); if (controller.signal.aborted) { return; } setSnapshot(next); if (next.status === "done") { stopPolling(); } } catch (cause: unknown) { if (cause instanceof Error && cause.name === "AbortError") { return; } const detail = cause instanceof Error ? cause.message : "Unknown polling error"; setError(detail); stopPolling(); } finally { inFlight = false; } }; void readSnapshot(); pollingRef.current = setInterval(() => { void readSnapshot(); }, POLL_INTERVAL_MS); }, [ensureAbortController, stopPolling] ); const handleStart = async () => { setError(null); setSnapshot(null); setRunId(null); stopPolling(); abortRef.current?.abort(); abortRef.current = null; try { const controller = ensureAbortController(); const payload = await postJson( "/api/mock/start", { incidentId: FAN_OUT_DEMO_DEFAULTS.incidentId, message: FAN_OUT_DEMO_DEFAULTS.message, failChannels, }, controller.signal ); if (controller.signal.aborted) { return; } setRunId(payload.runId); if (controller.signal.aborted) { return; } pollStatus(payload.runId); } catch (cause: unknown) { if (cause instanceof Error && cause.name === "AbortError") { return; } const detail = cause instanceof Error ? cause.message : "Unknown error"; setError(detail); } }; const handleReset = () => { stopPolling(); abortRef.current?.abort(); abortRef.current = null; setRunId(null); setSnapshot(null); setError(null); setTimeout(() => { startButtonRef.current?.focus(); }, 0); }; const effectiveStatus: RunStatus | "idle" = snapshot?.status ?? (runId ? "fan_out" : "idle"); const channels: DisplayChannelSnapshot[] = snapshot?.channels ?? DEFAULT_CHANNEL_SNAPSHOT; const isRunning = runId !== null && snapshot?.status !== "done"; const canSelectFailChannels = !isRunning; const executionLog = useMemo( () => buildExecutionLog( snapshot, FAN_OUT_DEMO_DEFAULTS.incidentId, FAN_OUT_DEMO_DEFAULTS.message ), [snapshot] ); const highlights = useMemo( () => buildHighlightState(snapshot, workflowLineMap, stepLineMap), [snapshot, workflowLineMap, stepLineMap] ); const highlightTone = useMemo( () => highlightToneForSnapshot(snapshot), [snapshot] ); const captionText = useMemo(() => { if (effectiveStatus === "fan_out" && highlights.activeChannel) { return `Promise.allSettled() -> every channel completes, no short-circuit. Active branch: ${highlights.activeChannel}.`; } if (effectiveStatus === "aggregating") { return "Promise.allSettled() -> every channel completes, no short-circuit. Aggregating deliveries + summary."; } return "Promise.allSettled() -> every channel completes, no short-circuit."; }, [effectiveStatus, highlights.activeChannel]); return (

{error && (

{error}

)}

Fail {CHANNEL_OPTIONS.map((channel) => { const checked = failChannels.includes(channel.id); return ( { setFailChannels((previous) => toggleFailChannel(previous, channel.id, event.target.checked) ); }} className="h-3.5 w-3.5 rounded border-gray-400 bg-background-100 text-blue-700 focus:ring-2 focus:ring-blue-700 focus:ring-offset-0 disabled:cursor-not-allowed" /> {channel.compactLabel} ); })}

{runId && ( )}

{statusExplanation(effectiveStatus, highlights.activeChannel)}

Workflow Phase

runId


                {runId ?? "not started"}

Completed Channels {channels.filter((channel) => channel.status !== "sending" && channel.status !== "pending").length} /{channels.length}

Tracing Step


                {highlights.activeChannel ?? (effectiveStatus === "aggregating" ? "aggregateResults" : "-")}

{snapshot?.summary && (

Summary: ok={snapshot.summary.ok}, failed={snapshot.summary.failed}

)}

Execution Log

{entry}

{captionText}

); } function FanOutGraph({ channels }: { channels: DisplayChannelSnapshot[] }) { const byId = new Map(channels.map((channel) => [channel.id, channel])); const nodes: Array<{ id: ChannelId; x: number; y: number; short: string; label: string; }> = [ { id: "slack", x: 50, y: 44, short: "SL", label: "Slack" }, { id: "email", x: 270, y: 44, short: "EM", label: "Email" }, { id: "sms", x: 50, y: 212, short: "SM", label: "SMS" }, { id: "pagerduty", x: 270, y: 212, short: "PD", label: "PagerDuty" }, ]; return (

Parallel Fan-Out Graph

); } function ChannelStatusList({ channels }: { channels: DisplayChannelSnapshot[] }) { return (

Channel Results

{channel.label}
{channel.status === "failed" && channel.error ? (
{channel.error}
) : null}

); } function RunStatusBadge({ status }: { status: RunStatus | "idle" }) { if (status === "done") { return ( done ); } if (status === "aggregating") { return ( aggregating ); } if (status === "fan_out") { return ( fan_out ); } return ( idle ); } function StatusBadge({ status }: { status: ChannelStatus }) { if (status === "sent") { return ( sent ); } if (status === "failed") { return ( failed ); } if (status === "sending") { return ( sending ); } return ( pending ); } [V0_FILE]typescriptreact:file="app/components/fanout-code-workbench.tsx" "use client"; import { useEffect, useMemo, useRef, useState } from "react"; type HighlightTone = "amber" | "cyan" | "green" | "red"; type GutterMarkKind = "success" | "fail"; type CopyState = "idle" | "copied" | "failed"; type HighlightStyle = { border: string; bg: string; text: string; }; const HIGHLIGHT_STYLES: Record = { amber: { border: "border-amber-700", bg: "bg-amber-700/15", text: "text-amber-700", }, cyan: { border: "border-cyan-700", bg: "bg-cyan-700/15", text: "text-cyan-700", }, green: { border: "border-green-700", bg: "bg-green-700/15", text: "text-green-700", }, red: { border: "border-red-700", bg: "bg-red-700/15", text: "text-red-700", }, }; type CodePaneProps = { code: string; filename: string; subtitle: string; linesHtml: string[]; activeLines: number[]; gutterMarks: Record; tone: HighlightTone; }; type FanOutCodeWorkbenchProps = { workflowCode: string; workflowLinesHtml: string[]; workflowActiveLines: number[]; workflowGutterMarks: Record; stepCode: string; stepLinesHtml: string[]; stepActiveLines: number[]; stepGutterMarks: Record; tone: HighlightTone; }; type SyncPreviousFanOutGutterMarksInput = { previousMarks: Map; gutterMarkMap: Map; gutterMarkCount: number; activeLineCount: number; }; const CHECK_ICON_POINTS = "3,8.5 7,12.5 14,4.5"; export function syncPreviousFanOutGutterMarks({ previousMarks, gutterMarkMap, gutterMarkCount, activeLineCount, }: SyncPreviousFanOutGutterMarksInput): void { if (gutterMarkCount === 0 && activeLineCount === 0) { previousMarks.clear(); return; } gutterMarkMap.forEach((kind, line) => { previousMarks.set(line, kind); }); } function CodePane({ code, filename, subtitle, linesHtml, activeLines, gutterMarks, tone, }: CodePaneProps) { const [copyState, setCopyState] = useState("idle"); const activeLineSet = useMemo(() => new Set(activeLines), [activeLines]); const gutterMarkMap = useMemo( () => new Map(Object.entries(gutterMarks).map(([k, v]) => [Number(k), v])), [gutterMarks] ); const activeLineCount = activeLines.length; const prevMarkRef = useRef>(new Map()); useEffect(() => { if (gutterMarkMap.size === 0 && activeLineCount === 0) { prevMarkRef.current.clear(); return; } syncPreviousFanOutGutterMarks({ previousMarks: prevMarkRef.current, gutterMarkMap, gutterMarkCount: gutterMarkMap.size, activeLineCount, }); }, [activeLineCount, gutterMarkMap]); const highlightStyle = HIGHLIGHT_STYLES[tone]; const handleCopy = async () => { try { await navigator.clipboard.writeText(code); setCopyState("copied"); window.setTimeout(() => setCopyState("idle"), 1200); } catch { setCopyState("failed"); window.setTimeout(() => setCopyState("idle"), 1200); } }; return (

{filename}

{subtitle}

          
            {linesHtml.map((lineHtml, index) => {
              const lineNumber = index + 1;
              const isActive = activeLineSet.has(lineNumber);
              const markKind = gutterMarkMap.get(lineNumber);
              const displayKind = markKind ?? prevMarkRef.current.get(lineNumber);

              return (
                
                  
                    
                  
                  
                    {lineNumber}
                  
                   0 ? lineHtml : " ",
                    }}
                  />
                
              );
            })}

); } export function FanOutCodeWorkbench({ workflowCode, workflowLinesHtml, workflowActiveLines, workflowGutterMarks, stepCode, stepLinesHtml, stepActiveLines, stepGutterMarks, tone, }: FanOutCodeWorkbenchProps) { return (

); } [V0_FILE]typescript:file="app/components/code-highlight-server.ts" import { highlight } from "sugar-high"; export function highlightCodeToHtmlLines(code: string): string[] { return highlight(code).split("\n"); } [V0_FILE]typescriptreact:file="app/layout.tsx" import type { Metadata } from "next"; import { Geist, Geist_Mono } from "next/font/google"; import "./globals.css"; const geistSans = Geist({ variable: "--font-geist-sans", subsets: ["latin"], }); const geistMono = Geist_Mono({ variable: "--font-geist-mono", subsets: ["latin"], }); export const metadata: Metadata = { title: "Fan-Out Notifications - Workflow DevKit Example", description: "Demonstrates Promise.allSettled() fan-out notifications with complete delivery reporting.", }; export default function RootLayout({ children, }: Readonly<{ children: React.ReactNode; }>) { return ( Skip to main content {children} ); } [V0_FILE]typescript:file="app/api/mock/start/route.ts" import { createApiErrorResponse, createApiSuccessResponse } from "../api"; import { createMockFanOutRun, parseMockFailChannels } from "../store"; export async function POST(request: Request) { let body: Record = {}; try { const parsed = await request.json(); if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) { body = parsed as Record; } else { return createApiErrorResponse( { code: "INVALID_REQUEST", message: "Request body must be a JSON object", }, { status: 400 } ); } } catch { return createApiErrorResponse( { code: "INVALID_REQUEST", message: "Invalid JSON body", }, { status: 400 } ); } const incidentId = typeof body.incidentId === "string" ? body.incidentId.trim() : ""; const message = typeof body.message === "string" ? body.message.trim() : ""; if (!incidentId) { return createApiErrorResponse( { code: "INVALID_REQUEST", message: "incidentId is required", }, { status: 400 } ); } if (!message) { return createApiErrorResponse( { code: "INVALID_REQUEST", message: "message is required", }, { status: 400 } ); } const parsedFailChannels = parseMockFailChannels(body.failChannels); if (parsedFailChannels.failChannels === null) { return createApiErrorResponse( { code: "INVALID_REQUEST", message: parsedFailChannels.error ?? "Invalid failChannels", }, { status: 400 } ); } const runId = `mock-${crypto.randomUUID().slice(0, 8)}`; createMockFanOutRun({ runId, incidentId, message, failChannels: parsedFailChannels.failChannels, }); return createApiSuccessResponse({ runId, incidentId, message, failChannels: parsedFailChannels.failChannels, status: "fan_out", }); } [V0_FILE]typescript:file="app/api/mock/api.ts" import { NextResponse } from "next/server"; type ApiError = { code: string; message: string; }; export function createApiSuccessResponse>( fields: T, init?: ResponseInit ) { return NextResponse.json( { ok: true, ...fields, }, init ); } export function createApiErrorResponse(error: ApiError, init?: ResponseInit) { return NextResponse.json( { ok: false, error, }, init ); } [V0_FILE]typescript:file="app/api/mock/status/route.ts" import { createApiErrorResponse, createApiSuccessResponse } from "../api"; import { buildMockFanOutSnapshot, getMockFanOutRun } from "../store"; export async function GET(request: Request) { const { searchParams } = new URL(request.url); const runId = searchParams.get("runId")?.trim() ?? ""; if (!runId) { return createApiErrorResponse( { code: "INVALID_REQUEST", message: "runId query parameter is required", }, { status: 400 } ); } const run = getMockFanOutRun(runId); if (!run) { return createApiErrorResponse( { code: "NOT_FOUND", message: "Run not found", }, { status: 404 } ); } return createApiSuccessResponse(buildMockFanOutSnapshot(run)); } [V0_FILE]typescript:file="app/api/mock/store.ts" export type MockChannelId = "slack" | "email" | "sms" | "pagerduty"; export type MockRunStatus = "fan_out" | "aggregating" | "done"; export type MockChannelStatus = "sending" | "sent" | "failed"; export type MockChannelConfig = { id: MockChannelId; label: string; durationMs: number; failError: string; }; export type MockFanOutRun = { runId: string; incidentId: string; message: string; failChannels: MockChannelId[]; startedAtMs: number; startedAt: string; }; export type MockChannelSnapshot = { id: MockChannelId; label: string; durationMs: number; status: MockChannelStatus; error?: string; }; export type MockFanOutSnapshot = { runId: string; incidentId: string; message: string; status: MockRunStatus; elapsedMs: number; channels: MockChannelSnapshot[]; summary?: { ok: number; failed: number; }; }; export const MOCK_MIN_CHANNEL_DURATION_MS = 500; export const MOCK_MIN_AGGREGATE_DELAY_MS = 500; export const MOCK_CHANNELS: MockChannelConfig[] = [ { id: "slack", label: "Slack", durationMs: Math.max(MOCK_MIN_CHANNEL_DURATION_MS, 650), failError: "Slack API rate limit exceeded", }, { id: "email", label: "Email", durationMs: Math.max(MOCK_MIN_CHANNEL_DURATION_MS, 900), failError: "Email provider returned 503", }, { id: "sms", label: "SMS", durationMs: Math.max(MOCK_MIN_CHANNEL_DURATION_MS, 1150), failError: "SMS delivery failed: invalid number", }, { id: "pagerduty", label: "PagerDuty", durationMs: Math.max(MOCK_MIN_CHANNEL_DURATION_MS, 750), failError: "PagerDuty integration is not configured", }, ]; export const MOCK_AGGREGATE_DELAY_MS = Math.max(MOCK_MIN_AGGREGATE_DELAY_MS, 500); const MOCK_CHANNEL_IDS = new Set( MOCK_CHANNELS.map((channel) => channel.id) ); const MOCK_FANOUT_DURATION_MS = Math.max( ...MOCK_CHANNELS.map((channel) => channel.durationMs) ); declare global { // eslint-disable-next-line no-var var __mockFanOutRuns: Map | undefined; } export const mockFanOutRuns: Map = globalThis.__mockFanOutRuns ?? (globalThis.__mockFanOutRuns = new Map()); function toIso(timestampMs: number): string { return new Date(timestampMs).toISOString(); } export function isMockChannelId(value: string): value is MockChannelId { return MOCK_CHANNEL_IDS.has(value as MockChannelId); } export function parseMockFailChannels(input: unknown): { failChannels: MockChannelId[] | null; error?: string; } { if (input === undefined) { return { failChannels: [] }; } if (!Array.isArray(input)) { return { failChannels: null, error: "failChannels must be an array" }; } const deduped: MockChannelId[] = []; for (const value of input) { if (typeof value !== "string") { return { failChannels: null, error: "failChannels can only include channel names", }; } if (!isMockChannelId(value)) { return { failChannels: null, error: `Unknown channel in failChannels: ${value}`, }; } if (!deduped.includes(value)) { deduped.push(value); } } return { failChannels: deduped }; } export function createMockFanOutRun(input: { runId: string; incidentId: string; message: string; failChannels: MockChannelId[]; nowMs?: number; }): MockFanOutRun { const nowMs = input.nowMs ?? Date.now(); const run: MockFanOutRun = { runId: input.runId, incidentId: input.incidentId, message: input.message, failChannels: [...input.failChannels], startedAtMs: nowMs, startedAt: toIso(nowMs), }; mockFanOutRuns.set(run.runId, run); return run; } export function getMockFanOutRun(runId: string): MockFanOutRun | undefined { return mockFanOutRuns.get(runId); } export function buildMockFanOutSnapshot( run: MockFanOutRun, nowMs: number = Date.now() ): MockFanOutSnapshot { const elapsedMs = Math.max(0, nowMs - run.startedAtMs); const failSet = new Set(run.failChannels); const channels: MockChannelSnapshot[] = MOCK_CHANNELS.map((channel) => { if (elapsedMs < channel.durationMs) { return { id: channel.id, label: channel.label, durationMs: channel.durationMs, status: "sending", }; } if (failSet.has(channel.id)) { return { id: channel.id, label: channel.label, durationMs: channel.durationMs, status: "failed", error: channel.failError, }; } return { id: channel.id, label: channel.label, durationMs: channel.durationMs, status: "sent", }; }); const aggregateEndsAtMs = MOCK_FANOUT_DURATION_MS + MOCK_AGGREGATE_DELAY_MS; let status: MockRunStatus = "fan_out"; if (elapsedMs >= MOCK_FANOUT_DURATION_MS && elapsedMs < aggregateEndsAtMs) { status = "aggregating"; } else if (elapsedMs >= aggregateEndsAtMs) { status = "done"; } if (status !== "done") { return { runId: run.runId, incidentId: run.incidentId, message: run.message, status, elapsedMs, channels, }; } const ok = channels.filter((channel) => channel.status === "sent").length; const failed = channels.length - ok; return { runId: run.runId, incidentId: run.incidentId, message: run.message, status, elapsedMs, channels, summary: { ok, failed }, }; } [V0_FILE]typescriptreact:file="app/page.tsx" import { highlightCodeToHtmlLines } from "./components/code-highlight-server"; import { FanOutDemo } from "./components/demo"; const directiveUseWorkflow = `"use ${"workflow"}"`; const directiveUseStep = `"use ${"step"}"`; type ChannelId = "slack" | "email" | "sms" | "pagerduty"; type WorkflowLineMap = { allSettled: number[]; deliveries: number[]; summary: number[]; returnResult: number[]; }; type StepLineMap = Record; const workflowCode = `type NotificationChannel = "slack" | "email" | "sms" | "pagerduty"; type ChannelResult = { channel: NotificationChannel; status: "sent" | "failed"; providerId?: string; error?: string; }; type IncidentReport = { incidentId: string; message: string; status: "done"; deliveries: ChannelResult[]; summary: { ok: number; failed: number; }; }; export async function incidentFanOut( incidentId: string, message: string, failChannels: NotificationChannel[] = [] ): Promise { ${directiveUseWorkflow}; const fanOutTargets = [ { channel: "slack", send: () => sendSlackAlert(incidentId, message, failChannels) }, { channel: "email", send: () => sendEmailAlert(incidentId, message, failChannels) }, { channel: "sms", send: () => sendSmsAlert(incidentId, message, failChannels) }, { channel: "pagerduty", send: () => sendPagerDutyAlert(incidentId, message, failChannels) }, ]; const settled = await Promise.allSettled( fanOutTargets.map((target) => target.send()) ); const deliveries: ChannelResult[] = settled.map((result, index) => { const channel = fanOutTargets[index].channel; if (result.status === "fulfilled") { return { channel, status: "sent", providerId: result.value.providerId }; } return { channel, status: "failed", error: formatChannelError(channel, result.reason), }; }); return aggregateResults(incidentId, message, deliveries); } function formatChannelError( channel: NotificationChannel, reason: unknown ): string { const message = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Unknown delivery failure"; return \`\${channel}: \${message}\`; }`; const stepCode = `type NotificationChannel = "slack" | "email" | "sms" | "pagerduty"; type ChannelResult = { channel: NotificationChannel; status: "sent" | "failed"; providerId?: string; error?: string; }; type IncidentReport = { incidentId: string; message: string; status: "done"; deliveries: ChannelResult[]; summary: { ok: number; failed: number; }; }; const CHANNEL_ERROR_MESSAGES: Record = { slack: "Slack API rate limit exceeded", email: "Email provider returned 503", sms: "SMS delivery failed: invalid number", pagerduty: "PagerDuty integration is not configured", }; async function sendSlackAlert( incidentId: string, message: string, failChannels: NotificationChannel[] ): Promise<{ providerId: string }> { ${directiveUseStep}; if (failChannels.includes("slack")) throw new Error(CHANNEL_ERROR_MESSAGES.slack); return { providerId: \`slack_\${incidentId}_\${message.length}\` }; } async function sendEmailAlert( incidentId: string, message: string, failChannels: NotificationChannel[] ): Promise<{ providerId: string }> { ${directiveUseStep}; if (failChannels.includes("email")) throw new Error(CHANNEL_ERROR_MESSAGES.email); return { providerId: \`email_\${incidentId}_\${message.length}\` }; } async function sendSmsAlert( incidentId: string, message: string, failChannels: NotificationChannel[] ): Promise<{ providerId: string }> { ${directiveUseStep}; if (failChannels.includes("sms")) throw new Error(CHANNEL_ERROR_MESSAGES.sms); return { providerId: \`sms_\${incidentId}_\${message.length}\` }; } async function sendPagerDutyAlert( incidentId: string, message: string, failChannels: NotificationChannel[] ): Promise<{ providerId: string }> { ${directiveUseStep}; if (failChannels.includes("pagerduty")) throw new Error(CHANNEL_ERROR_MESSAGES.pagerduty); return { providerId: \`pagerduty_\${incidentId}_\${message.length}\` }; } async function aggregateResults( incidentId: string, message: string, deliveries: ChannelResult[] ): Promise { ${directiveUseStep}; const ok = deliveries.filter((delivery) => delivery.status === "sent").length; const failed = deliveries.length - ok; return { incidentId, message, status: "done", deliveries, summary: { ok, failed }, }; }`; function collectFunctionBlock(lines: string[], marker: string): number[] { const start = lines.findIndex((line) => line.includes(marker)); if (start === -1) { return []; } const output: number[] = []; let depth = 0; let sawOpeningBrace = false; for (let index = start; index < lines.length; index += 1) { const line = lines[index]; output.push(index + 1); const opens = (line.match(/{/g) ?? []).length; const closes = (line.match(/}/g) ?? []).length; depth += opens - closes; if (opens > 0) { sawOpeningBrace = true; } if (sawOpeningBrace && depth === 0) { break; } } return output; } function collectUntil( lines: string[], marker: string, isTerminalLine: (line: string) => boolean ): number[] { const start = lines.findIndex((line) => line.includes(marker)); if (start === -1) { return []; } const output: number[] = []; for (let index = start; index < lines.length; index += 1) { output.push(index + 1); if (isTerminalLine(lines[index])) { break; } } return output; } function buildWorkflowLineMap(code: string): WorkflowLineMap { const lines = code.split("\n"); return { allSettled: collectUntil( lines, "const settled = await Promise.allSettled(", (line) => line.trim() === ");" ), deliveries: collectUntil( lines, "const deliveries: ChannelResult[] = settled.map((result, index) => {", (line) => line.trim() === "});" ), summary: collectUntil( lines, "return aggregateResults(incidentId, message, deliveries);", (line) => line.includes("return aggregateResults(incidentId, message, deliveries);") ), returnResult: collectUntil( lines, "return aggregateResults(incidentId, message, deliveries);", (line) => line.includes("return aggregateResults(incidentId, message, deliveries);") ), }; } function buildStepLineMap(code: string): StepLineMap { const lines = code.split("\n"); return { slack: collectFunctionBlock(lines, "async function sendSlackAlert("), email: collectFunctionBlock(lines, "async function sendEmailAlert("), sms: collectFunctionBlock(lines, "async function sendSmsAlert("), pagerduty: collectFunctionBlock(lines, "async function sendPagerDutyAlert("), }; } const workflowLinesHtml = highlightCodeToHtmlLines(workflowCode); const stepLinesHtml = highlightCodeToHtmlLines(stepCode); const workflowLineMap = buildWorkflowLineMap(workflowCode); const stepLineMap = buildStepLineMap(stepCode); export default function Home() { return (

Workflow DevKit Example

Fan-Out Notifications

Broadcast an incident alert to Slack, Email, SMS, and PagerDuty in parallel. Promise.allSettled(){" "} ensures every channel completes and returns a full delivery report, even when one branch fails.

Try It

); } [V0_FILE]css:file="app/globals.css" @import "tailwindcss"; @theme { --color-background-100: #0a0a0a; --color-background-200: #171717; --color-gray-100: #1a1a1a; --color-gray-200: #1f1f1f; --color-gray-300: #292929; --color-gray-400: #737373; --color-gray-500: #525252; --color-gray-600: #404040; --color-gray-700: #262626; --color-gray-800: #171717; --color-gray-900: #a1a1a1; --color-gray-1000: #ededed; --color-blue-700: #0070F3; --color-red-700: #E5484D; --color-amber-700: #FFB224; --color-green-700: #46A758; --color-violet-700: #8B5CF6; --color-cyan-700: #06B6D4; --font-sans: var(--font-geist-sans); --font-mono: var(--font-geist-mono); } body { background: #0a0a0a; color: #ededed; font-family: var(--font-sans), -apple-system, BlinkMacSystemFont, sans-serif; } /* Prism token colors — Geist dark-mode palette Extracted from vercel.com/geist/code-block (dark theme) */ .token.keyword, .token.keyword.control-flow { color: #f75f8f; } /* pink — keywords */ .token.plain, .token.parameter, .token.punctuation, .token.plain-text, .token.property-access, .token.operator, .token.tag.punctuation { color: #ededed; } /* gray-1000 — plain text */ .token.function, .token.function.maybe-class-name { color: #bf7af0; } /* purple — functions */ .token.tag { color: #62c073; } /* green — JSX/HTML tags */ .token.literal-property.property { color: #ff6166; } /* red — properties */ .token.string, .token.boolean { color: #62c073; } /* green — strings, booleans */ .token.comment { color: #a1a1a1; } /* gray-900 — comments */ .token.class-name { color: #52a8ff; } /* blue — types */ .token.number { color: #62c073; } /* green — numbers */ .token.attr-name { color: #ff6166; } /* red — attribute names */ .token.attr-value { color: #62c073; } /* green — attribute values */ .token.builtin { color: #52a8ff; } /* blue — builtins */ .token.template-string { color: #62c073; } /* green — template literals */ .token.interpolation { color: #ededed; } /* gray-1000 — interpolation */ [V0_FILE]javascript:file="postcss.config.mjs" export default { plugins: { "@tailwindcss/postcss": {}, }, }; [V0_FILE]typescript:file="workflows/incident-fanout.ts" export type NotificationChannel = "slack" | "email" | "sms" | "pagerduty"; type ChannelResult = { channel: NotificationChannel; status: "sent" | "failed"; providerId?: string; error?: string; }; type IncidentReport = { incidentId: string; message: string; status: "done"; deliveries: ChannelResult[]; summary: { ok: number; failed: number; }; }; const CHANNEL_ERROR_MESSAGES: Record = { slack: "Slack API rate limit exceeded", email: "Email provider returned 503", sms: "SMS delivery failed: invalid number", pagerduty: "PagerDuty integration is not configured", }; export async function incidentFanOut( incidentId: string, message: string, failChannels: NotificationChannel[] = [] ): Promise { "use workflow"; const fanOutTargets = [ { channel: "slack" as const, send: () => sendSlackAlert(incidentId, message, failChannels), }, { channel: "email" as const, send: () => sendEmailAlert(incidentId, message, failChannels), }, { channel: "sms" as const, send: () => sendSmsAlert(incidentId, message, failChannels), }, { channel: "pagerduty" as const, send: () => sendPagerDutyAlert(incidentId, message, failChannels), }, ]; const settled = await Promise.allSettled( fanOutTargets.map((target) => target.send()) ); const deliveries: ChannelResult[] = settled.map((result, index) => { const channel = fanOutTargets[index].channel; if (result.status === "fulfilled") { return { channel, status: "sent", providerId: result.value.providerId, }; } return { channel, status: "failed", error: formatChannelError(channel, result.reason), }; }); return aggregateResults(incidentId, message, deliveries); } function formatChannelError( channel: NotificationChannel, reason: unknown ): string { let message = "Unknown delivery failure"; if (reason instanceof Error) { message = reason.message; } else if (typeof reason === "string") { message = reason; } return `${channel}: ${message}`; } async function sendSlackAlert( incidentId: string, message: string, failChannels: NotificationChannel[] ): Promise<{ providerId: string }> { "use step"; if (failChannels.includes("slack")) { throw new Error(CHANNEL_ERROR_MESSAGES.slack); } return { providerId: `slack_${incidentId}_${message.length}`, }; } async function sendEmailAlert( incidentId: string, message: string, failChannels: NotificationChannel[] ): Promise<{ providerId: string }> { "use step"; if (failChannels.includes("email")) { throw new Error(CHANNEL_ERROR_MESSAGES.email); } return { providerId: `email_${incidentId}_${message.length}`, }; } async function sendSmsAlert( incidentId: string, message: string, failChannels: NotificationChannel[] ): Promise<{ providerId: string }> { "use step"; if (failChannels.includes("sms")) { throw new Error(CHANNEL_ERROR_MESSAGES.sms); } return { providerId: `sms_${incidentId}_${message.length}`, }; } async function sendPagerDutyAlert( incidentId: string, message: string, failChannels: NotificationChannel[] ): Promise<{ providerId: string }> { "use step"; if (failChannels.includes("pagerduty")) { throw new Error(CHANNEL_ERROR_MESSAGES.pagerduty); } return { providerId: `pagerduty_${incidentId}_${message.length}`, }; } async function aggregateResults( incidentId: string, message: string, deliveries: ChannelResult[] ): Promise { "use step"; const ok = deliveries.filter((delivery) => delivery.status === "sent").length; const failed = deliveries.length - ok; return { incidentId, message, status: "done", deliveries, summary: { ok, failed }, }; } [V0_FILE]json:file="package.json" { "name": "fan-out", "version": "0.1.0", "private": true, "scripts": { "dev": "next dev", "build": "next build", "start": "next start", "lint": "next lint" }, "dependencies": { "next": "16.0.10", "react": "19.2.3", "react-dom": "19.2.3", "sugar-high": "^0.9.5", "workflow": "4.1.0-beta.54" }, "devDependencies": { "@tailwindcss/postcss": "^4", "@types/node": "^20", "@types/react": "^19", "@types/react-dom": "^19", "tailwindcss": "^4", "typescript": "^5" } } [V0_FILE]json:file="tsconfig.json" { "compilerOptions": { "target": "ES2017", "lib": ["dom", "dom.iterable", "esnext"], "allowJs": true, "skipLibCheck": true, "strict": true, "noEmit": true, "esModuleInterop": true, "module": "esnext", "moduleResolution": "bundler", "resolveJsonModule": true, "isolatedModules": true, "jsx": "react-jsx", "incremental": true, "plugins": [ { "name": "next" }, { "name": "workflow" } ], "paths": { "@/*": ["./*"] } }, "include": [ "next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts", ".next/dev/types/**/*.ts", "**/*.mts" ], "exclude": ["node_modules"] } [V0_FILE]typescript:file="next.config.ts" import { withWorkflow } from "workflow/next"; import type { NextConfig } from "next"; const nextConfig: NextConfig = {}; export default withWorkflow(nextConfig);