@xdelivered/emberflow 0.2.0

package/dist/src/flows/anomaly-flows.js

@@ -0,0 +1,151 @@
+const FOLDER = 'Anomaly API';
+const CREATED = '2026-07-02T00:00:00Z';
+function makeFlow(id, name, specs, edges, scenarios) {
+    const nodes = specs.map((spec, i) => ({
+        id: spec.id,
+        type: spec.type,
+        label: spec.label,
+        position: spec.position ?? { x: 60 + 250 * i, y: 200 },
+        config: spec.config ?? {},
+        inputMap: spec.inputMap,
+    }));
+    return {
+        id,
+        name,
+        version: 1,
+        folder: FOLDER,
+        nodes,
+        edges,
+        ...(scenarios ? { scenarios } : {}),
+        createdAt: CREATED,
+        updatedAt: CREATED,
+    };
+}
+const from = (sourceNodeId, sourceField) => ({ sourceNodeId, sourceField });
+/**
+ * Live call: whole-series detection, then branch on severity.
+ *   build → detect → summarize → cond(anomalyCount > 0?)
+ *     ├─ anomalous → composeIncident → incidentResult
+ *     └─ clean     → cleanResult
+ *
+ * Deviation from spec: the spec's Conditional has two rules (`gt 3 → P1`,
+ * `gt 0 → P2`) feeding three downstream paths, but this flow only ever had
+ * two downstream branches (anomalous/clean). Kept the original two-branch
+ * shape as a single rule `gt 0 → anomalous`, fallback `clean`, rather than
+ * inventing a third P1/P2 branch nothing here consumes.
+ */
+export function createDetectEntireFlow() {
+    return makeFlow('anomaly-detect-entire', 'Detect · Entire Series', [
+        { id: 'input', type: 'Input', label: 'Series Request', config: { fields: [{ name: 'points', type: 'number', required: true }, { name: 'spikeIndex', type: 'number' }], defaults: { points: 24, spikeIndex: 20 } }, position: { x: -180, y: 240 } },
+        { id: 'build', type: 'BuildSeries', label: 'Build Series', config: { points: 24, baseValue: 100, spikeIndex: 20, spikeFactor: 3 }, inputMap: { points: from('input', 'points'), spikeIndex: from('input', 'spikeIndex') }, position: { x: 60, y: 240 } },
+        { id: 'detect', type: 'DetectEntireSeries', label: 'Detect Entire Series', config: { apiKey: 'dev-emberflow', sensitivity: 80 }, inputMap: { series: from('build', 'series') }, position: { x: 300, y: 240 } },
+        { id: 'summarize', type: 'SummarizeAnomalies', label: 'Summarize Anomalies', inputMap: { isAnomaly: from('detect', 'isAnomaly'), series: from('build', 'series') }, position: { x: 540, y: 240 } },
+        { id: 'cond', type: 'Conditional', label: 'Severity?', config: { branches: [{ name: 'anomalous', op: 'gt', value: 0 }], fallback: 'clean' }, inputMap: { value: from('summarize', 'anomalyCount') }, position: { x: 1020, y: 240 } },
+        { id: 'composeIncident', type: 'ComposeIncident', label: 'Compose Incident', inputMap: { headline: from('summarize', 'headline'), anomalyCount: from('summarize', 'anomalyCount') }, position: { x: 1260, y: 120 } },
+        { id: 'incidentResult', type: 'Result', label: 'Incident', inputMap: { data: from('composeIncident', '$') }, position: { x: 1500, y: 120 } },
+        { id: 'cleanResult', type: 'Result', label: 'All Clear', inputMap: { data: from('summarize', '$') }, position: { x: 1260, y: 360 } },
+    ], [
+        { id: 'e0', source: 'input', target: 'build', targetHandle: 'points' },
+        { id: 'e1', source: 'build', target: 'detect', targetHandle: 'series' },
+        { id: 'e2', source: 'detect', target: 'summarize', targetHandle: 'isAnomaly' },
+        { id: 'e3', source: 'build', target: 'summarize', targetHandle: 'series' },
+        { id: 'e4', source: 'summarize', target: 'cond', targetHandle: 'value' },
+        { id: 'e6', source: 'cond', target: 'composeIncident', sourceHandle: 'anomalous' },
+        { id: 'e7', source: 'cond', target: 'cleanResult', sourceHandle: 'clean' },
+        { id: 'e8', source: 'composeIncident', target: 'incidentResult', targetHandle: 'data' },
+    ], [
+        {
+            id: 'scn-spike',
+            name: 'spike at 20',
+            description: '×3 spike — detector flags it, incident branch fires',
+            input: { points: 24, spikeIndex: 20 },
+        },
+        {
+            id: 'scn-flat',
+            name: 'flat series',
+            description: 'no spike (spikeIndex −1) — clean branch, all clear',
+            input: { points: 24, spikeIndex: -1 },
+        },
+    ]);
+}
+/** Live call: streaming-style last-point verdict. */
+export function createDetectLastFlow() {
+    return makeFlow('anomaly-detect-last', 'Detect · Last Point', [
+        { id: 'build', type: 'BuildSeries', label: 'Build Series (spike at end)', config: { points: 14, baseValue: 50, spikeIndex: 13, spikeFactor: 4 } },
+        { id: 'detect', type: 'DetectLastPoint', label: 'Detect Last Point', config: { apiKey: 'dev-emberflow', sensitivity: 80 }, inputMap: { series: from('build', 'series') } },
+        { id: 'result', type: 'Result', label: 'Verdict', inputMap: { data: from('detect', '$') } },
+    ], [
+        { id: 'e1', source: 'build', target: 'detect', targetHandle: 'series' },
+        { id: 'e2', source: 'detect', target: 'result', targetHandle: 'data' },
+    ]);
+}
+/** Live call: detection + Adtributor root-cause analysis. */
+export function createRootCauseFlow() {
+    return makeFlow('anomaly-root-cause', 'Detect · Root Cause', [
+        { id: 'build', type: 'BuildDimensionalSeries', label: 'Build Dimensional Series', config: { points: 14, baseValue: 100, spikeIndex: 12, culpritSlice: 'paid' } },
+        { id: 'detect', type: 'DetectAttributed', label: 'Detect + Attribute', config: { apiKey: 'dev-emberflow', sensitivity: 80, topK: 3 }, inputMap: { series: from('build', 'series') } },
+        { id: 'extract', type: 'ExtractRootCause', label: 'Extract Root Cause', inputMap: { rca: from('detect', 'rca') } },
+        { id: 'result', type: 'Result', label: 'Root Cause', inputMap: { data: from('extract', '$') } },
+    ], [
+        { id: 'e1', source: 'build', target: 'detect', targetHandle: 'series' },
+        { id: 'e2', source: 'detect', target: 'extract', targetHandle: 'rca' },
+        { id: 'e3', source: 'extract', target: 'result', targetHandle: 'data' },
+    ]);
+}
+/** Replica of today's quota/email business logic (Clerk-gated server-side). */
+export function createQuotaFlow() {
+    return makeFlow('anomaly-quota-emails', 'Quota · Usage & Emails', [
+        { id: 'input', type: 'Input', label: 'Usage Snapshot', config: { fields: [{ name: 'calls', type: 'number', required: true }], defaults: { calls: 850 } } },
+        { id: 'plan', type: 'PlanCatalog', label: 'Plan Catalog', config: { planCode: 'anomaly_free' } },
+        { id: 'usage', type: 'UsageState', label: 'Usage State', config: { calls: 850 }, inputMap: { calls: from('input', 'calls'), quota: from('plan', 'quota') } },
+        { id: 'classify', type: 'ClassifyQuotaEmail', label: 'Classify Quota Email', config: { alreadyWarned: false, alreadyNotifiedExceeded: false }, inputMap: { warn80: from('usage', 'warn80'), overQuota: from('usage', 'overQuota') } },
+        { id: 'result', type: 'Result', label: 'Sweep Decision', inputMap: { data: from('classify', '$') } },
+    ], [
+        { id: 'e0', source: 'input', target: 'usage', targetHandle: 'calls' },
+        { id: 'e1', source: 'plan', target: 'usage', targetHandle: 'quota' },
+        { id: 'e2', source: 'usage', target: 'classify', targetHandle: 'warn80' },
+        { id: 'e3', source: 'classify', target: 'result', targetHandle: 'data' },
+    ], 
+    // Free plan quota is 1,000 calls: the three scenarios straddle the
+    // warn-at-80% and exceeded thresholds in classifyUsageRow().
+    [
+        {
+            id: 'scn-quiet',
+            name: 'quiet month',
+            description: '400/1000 calls — no email',
+            input: { calls: 400 },
+        },
+        {
+            id: 'scn-warn',
+            name: 'approaching limit',
+            description: '850/1000 calls — 80% warning email',
+            input: { calls: 850 },
+        },
+        {
+            id: 'scn-over',
+            name: 'over quota',
+            description: '1200/1000 calls — exceeded email',
+            input: { calls: 1200 },
+        },
+    ]);
+}
+/** Replica of today's key issuance + 5-key limit guard. */
+export function createKeyLifecycleFlow() {
+    return makeFlow('anomaly-key-lifecycle', 'Keys · Issue & Limit', [
+        { id: 'generate', type: 'GenerateApiKey', label: 'Generate API Key', config: { label: 'production' } },
+        { id: 'enforce', type: 'EnforceKeyLimit', label: 'Enforce Key Limit', config: { activeKeyCount: 3 }, inputMap: { keyPrefix: from('generate', 'keyPrefix') } },
+        { id: 'result', type: 'Result', label: 'Issued Key', inputMap: { data: from('enforce', '$') } },
+    ], [
+        { id: 'e1', source: 'generate', target: 'enforce', targetHandle: 'keyPrefix' },
+        { id: 'e2', source: 'enforce', target: 'result', targetHandle: 'data' },
+    ]);
+}
+export function createAnomalyFlows() {
+    return [
+        createDetectEntireFlow(),
+        createDetectLastFlow(),
+        createRootCauseFlow(),
+        createQuotaFlow(),
+        createKeyLifecycleFlow(),
+    ];
+}

package/dist/src/flows/city-sweep-flow.d.ts

@@ -0,0 +1,10 @@
+import type { WorkflowDefinition } from '../engine/index.js';
+/**
+ * ForEach/Collect loop over a list of cities:
+ *   input(cities) → fe(ForEach) → geocode → forecast → classify → col(Collect) → result
+ *
+ * Each iteration resolves one city, fetches its forecast, and grades it
+ * severe/mild; Collect gathers every iteration's classification into a
+ * single array that the Result node surfaces as the sweep report.
+ */
+export declare function createCitySweepFlow(): WorkflowDefinition;

package/dist/src/flows/city-sweep-flow.js

@@ -0,0 +1,127 @@
+/**
+ * ForEach/Collect loop over a list of cities:
+ *   input(cities) → fe(ForEach) → geocode → forecast → classify → col(Collect) → result
+ *
+ * Each iteration resolves one city, fetches its forecast, and grades it
+ * severe/mild; Collect gathers every iteration's classification into a
+ * single array that the Result node surfaces as the sweep report.
+ */
+export function createCitySweepFlow() {
+    const nodes = [
+        {
+            id: 'input',
+            type: 'Input',
+            label: 'Sweep Request',
+            position: { x: -180, y: 240 },
+            config: {
+                fields: [{ name: 'cities', type: 'array', required: true }],
+                defaults: { cities: ['Belfast', 'Valencia', 'Reykjavik'] },
+            },
+        },
+        {
+            id: 'fe',
+            type: 'ForEach',
+            label: 'Each City',
+            position: { x: 60, y: 240 },
+            config: {},
+            inputMap: {
+                items: { sourceNodeId: 'input', sourceField: 'cities' },
+            },
+        },
+        {
+            id: 'geocode',
+            type: 'GeocodeCity',
+            label: 'Geocode City',
+            position: { x: 300, y: 240 },
+            config: {},
+            inputMap: {
+                city: { sourceNodeId: 'fe', sourceField: 'item' },
+            },
+        },
+        {
+            id: 'forecast',
+            type: 'FetchForecast',
+            label: 'Fetch Forecast',
+            position: { x: 540, y: 240 },
+            config: {},
+            inputMap: {
+                latitude: { sourceNodeId: 'geocode', sourceField: 'latitude' },
+                longitude: { sourceNodeId: 'geocode', sourceField: 'longitude' },
+            },
+        },
+        {
+            id: 'classify',
+            type: 'ClassifyWeather',
+            label: 'Classify Weather',
+            position: { x: 780, y: 240 },
+            config: {},
+            inputMap: {
+                windKmh: { sourceNodeId: 'forecast', sourceField: 'windKmh' },
+                rainChancePct: { sourceNodeId: 'forecast', sourceField: 'rainChancePct' },
+                place: { sourceNodeId: 'geocode', sourceField: 'place' },
+            },
+        },
+        {
+            id: 'col',
+            type: 'Collect',
+            label: 'Verdicts',
+            position: { x: 1020, y: 240 },
+            config: {},
+            inputMap: {
+                value: { sourceNodeId: 'classify', sourceField: '$' },
+            },
+        },
+        {
+            id: 'result',
+            type: 'Result',
+            label: 'Sweep Report',
+            position: { x: 1260, y: 240 },
+            config: {},
+            inputMap: {
+                data: { sourceNodeId: 'col', sourceField: '$' },
+            },
+        },
+    ];
+    const edges = [
+        { id: 'e0', source: 'input', target: 'fe', targetHandle: 'items' },
+        { id: 'e1', source: 'fe', target: 'geocode', targetHandle: 'city' },
+        { id: 'e2', source: 'geocode', target: 'forecast', targetHandle: 'latitude' },
+        { id: 'e3', source: 'geocode', target: 'forecast', targetHandle: 'longitude' },
+        { id: 'e4', source: 'forecast', target: 'classify', targetHandle: 'windKmh' },
+        { id: 'e5', source: 'forecast', target: 'classify', targetHandle: 'rainChancePct' },
+        { id: 'e6', source: 'classify', target: 'col', targetHandle: 'value' },
+        { id: 'e7', source: 'col', target: 'result', targetHandle: 'data' },
+    ];
+    return {
+        id: 'city-sweep',
+        name: 'City Sweep',
+        version: 1,
+        nodes,
+        edges,
+        // Live-weather flow: results depend on real conditions, so scenarios
+        // mainly exercise loop shape (batch count, empty list) rather than a
+        // specific branch outcome.
+        scenarios: [
+            {
+                id: 'scn-two',
+                name: 'two cities',
+                description: 'Two iterations through the loop body',
+                input: { cities: ['Belfast', 'Valencia'] },
+            },
+            {
+                id: 'scn-five',
+                name: 'five cities',
+                description: 'Five iterations — GeocodeCity takes one city at a time, so batchSize stays 1',
+                input: { cities: ['Belfast', 'Valencia', 'Reykjavik', 'Tokyo', 'Nairobi'] },
+            },
+            {
+                id: 'scn-empty',
+                name: 'empty list',
+                description: 'No cities — ForEach/Collect run zero iterations',
+                input: { cities: [] },
+            },
+        ],
+        createdAt: '2026-07-02T00:00:00Z',
+        updatedAt: '2026-07-02T00:00:00Z',
+    };
+}

package/dist/src/flows/login-flow.d.ts

@@ -0,0 +1,13 @@
+import type { WorkflowDefinition } from '../engine/index.js';
+/**
+ * Branching login flow:
+ *   input → validate → fetch → route(isNew?)
+ *     ├─ new      → welcome ─┐
+ *     └─ existing → checkPlan ┴→ issueToken → result
+ *
+ * Route reads `isNew` off the fetched user: `true` takes the welcome branch,
+ * anything else falls back to `existing` and runs the plan check. Both branches
+ * converge on issueToken; on the new-user path checkPlan is skipped, so its
+ * `plan` input resolves undefined and IssueToken falls back to 'free'.
+ */
+export declare function createLoginFlow(): WorkflowDefinition;

package/dist/src/flows/login-flow.js

@@ -0,0 +1,145 @@
+const from = (sourceNodeId, sourceField) => ({ sourceNodeId, sourceField });
+/**
+ * Branching login flow:
+ *   input → validate → fetch → route(isNew?)
+ *     ├─ new      → welcome ─┐
+ *     └─ existing → checkPlan ┴→ issueToken → result
+ *
+ * Route reads `isNew` off the fetched user: `true` takes the welcome branch,
+ * anything else falls back to `existing` and runs the plan check. Both branches
+ * converge on issueToken; on the new-user path checkPlan is skipped, so its
+ * `plan` input resolves undefined and IssueToken falls back to 'free'.
+ */
+export function createLoginFlow() {
+    const nodes = [
+        {
+            id: 'input',
+            type: 'Input',
+            label: 'Login Request',
+            position: { x: 60, y: 220 },
+            config: {
+                fields: [
+                    { name: 'username', type: 'string', required: true },
+                    { name: 'password', type: 'string', required: true },
+                ],
+                defaults: { username: 'ada', password: 'lovelace' },
+            },
+        },
+        {
+            id: 'validate',
+            type: 'ValidateCredentials',
+            label: 'Validate Credentials',
+            position: { x: 300, y: 220 },
+            config: {},
+            inputMap: {
+                username: from('input', 'username'),
+                password: from('input', 'password'),
+            },
+        },
+        {
+            id: 'fetch',
+            type: 'FetchUser',
+            label: 'Fetch User',
+            position: { x: 540, y: 220 },
+            config: {},
+            inputMap: {
+                userId: { sourceNodeId: 'validate', sourceField: 'userId' },
+            },
+        },
+        {
+            id: 'route',
+            type: 'Route',
+            label: 'New user?',
+            position: { x: 780, y: 220 },
+            config: { field: 'isNew', branches: ['true'], fallback: 'existing' },
+            inputMap: {
+                value: { sourceNodeId: 'fetch', sourceField: '$' },
+            },
+        },
+        {
+            id: 'welcome',
+            type: 'WelcomeUser',
+            label: 'Welcome User',
+            position: { x: 1020, y: 100 },
+            config: {},
+            inputMap: {
+                user: { sourceNodeId: 'fetch', sourceField: '$' },
+            },
+        },
+        {
+            id: 'checkPlan',
+            type: 'CheckPlan',
+            label: 'Check Plan',
+            position: { x: 1020, y: 340 },
+            config: {},
+            inputMap: {
+                user: { sourceNodeId: 'fetch', sourceField: '$' },
+            },
+        },
+        {
+            id: 'issueToken',
+            type: 'IssueToken',
+            label: 'Issue Token',
+            position: { x: 1260, y: 220 },
+            config: {},
+            inputMap: {
+                userId: { sourceNodeId: 'fetch', sourceField: 'id' },
+                plan: { sourceNodeId: 'checkPlan', sourceField: 'plan' },
+            },
+        },
+        {
+            id: 'result',
+            type: 'Result',
+            label: 'Result',
+            position: { x: 1500, y: 220 },
+            config: {},
+            inputMap: {
+                data: { sourceNodeId: 'issueToken', sourceField: '$' },
+            },
+        },
+    ];
+    // Branch handles live on the Route's outgoing edges (sourceHandle = branch
+    // name). welcome→issueToken carries no targetHandle: it is a structural join,
+    // not a data mapping (issueToken's inputs come from fetch and checkPlan).
+    const edges = [
+        { id: 'e0', source: 'input', target: 'validate', targetHandle: 'username' },
+        { id: 'e1', source: 'validate', target: 'fetch', targetHandle: 'userId' },
+        { id: 'e2', source: 'fetch', target: 'route', targetHandle: 'value' },
+        { id: 'e3', source: 'route', target: 'welcome', sourceHandle: 'true' },
+        { id: 'e4', source: 'route', target: 'checkPlan', sourceHandle: 'existing' },
+        { id: 'e5', source: 'welcome', target: 'issueToken' },
+        { id: 'e6', source: 'checkPlan', target: 'issueToken', targetHandle: 'plan' },
+        { id: 'e7', source: 'issueToken', target: 'result', targetHandle: 'data' },
+    ];
+    return {
+        id: 'login-example',
+        name: 'Login Example',
+        version: 1,
+        nodes,
+        edges,
+        // FetchUser derives isNew from a `new` name prefix and plan from a `pro`
+        // substring, so the username alone steers every branch.
+        scenarios: [
+            {
+                id: 'scn-new-user',
+                name: 'new user',
+                description: 'newton is new — welcome branch, checkPlan skipped',
+                input: { username: 'newton', password: 'apple123' },
+            },
+            {
+                id: 'scn-existing-pro',
+                name: 'existing pro',
+                description: 'ada-pro exists on the pro plan — plan-check branch',
+                input: { username: 'ada-pro', password: 'lovelace' },
+            },
+            {
+                id: 'scn-bad-password',
+                name: 'bad password',
+                description: 'password under 4 chars — validation fails the run',
+                input: { username: 'ada', password: 'abc' },
+            },
+        ],
+        createdAt: '2026-07-02T00:00:00Z',
+        updatedAt: '2026-07-02T00:00:00Z',
+    };
+}

package/dist/src/flows/pradar-flows.d.ts

@@ -0,0 +1,5 @@
+import type { WorkflowDefinition } from '../engine/index.js';
+export declare function createEvaluateCycleFlow(): WorkflowDefinition;
+export declare function createThresholdIntelligenceFlow(): WorkflowDefinition;
+export declare function createNightChargeFlow(): WorkflowDefinition;
+export declare function createPradarFlows(): WorkflowDefinition[];