@hotmeshio/long-tail 0.1.0

package/build/examples/seed.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seedExamples = seedExamples;
+const hotmesh_1 = require("@hotmeshio/hotmesh");
+const defaults_1 = require("../modules/defaults");
+const logger_1 = require("../services/logger");
+const user_1 = require("../services/user");
+const roles_1 = require("../services/user/roles");
+const role_1 = require("../services/role");
+// ── Seed users ───────────────────────────────────────────────────────────────
+const SEED_USERS = [
+    {
+        external_id: 'superadmin',
+        display_name: 'Super Admin',
+        email: 'admin@longtail.local',
+        password: 'l0ngt@1l',
+        roles: [{ role: 'superadmin', type: 'superadmin' }],
+    },
+    {
+        external_id: 'admin',
+        display_name: 'Admin User',
+        email: 'admin-user@longtail.local',
+        password: 'l0ngt@1l',
+        roles: [{ role: 'admin', type: 'admin' }],
+    },
+    {
+        external_id: 'engineer',
+        display_name: 'Engineer User',
+        email: 'engineer@longtail.local',
+        password: 'l0ngt@1l',
+        roles: [{ role: 'engineer', type: 'member' }],
+    },
+    {
+        external_id: 'reviewer',
+        display_name: 'Reviewer User',
+        email: 'reviewer@longtail.local',
+        password: 'l0ngt@1l',
+        roles: [{ role: 'reviewer', type: 'member' }],
+    },
+    {
+        external_id: 'mock:test-user-1',
+        display_name: 'Alice Test',
+        email: 'alice@test.local',
+        password: 'l0ngt@1l',
+        oauth_provider: 'mock',
+        oauth_provider_id: 'test-user-1',
+        roles: [{ role: 'superadmin', type: 'superadmin' }],
+    },
+];
+const SEED_ROLES = ['reviewer', 'engineer', 'admin', 'superadmin'];
+const SEED_ENVELOPES = [
+    // -- Process 1: Clean Review
+    {
+        label: 'Process 1 — Clean Review',
+        workflowName: 'reviewContent',
+        taskQueue: 'long-tail-examples',
+        envelope: {
+            data: {
+                contentId: 'process-clean-001',
+                content: 'This is a well-researched article about renewable energy solutions for urban environments. It covers solar panels, wind turbines, and energy storage with thorough citations and balanced analysis.',
+                contentType: 'article',
+            },
+            metadata: {
+                source: 'seed',
+                process: 'clean-review',
+                description: 'Happy path — AI auto-approves high-quality content',
+            },
+        },
+    },
+    // -- Process 2: Flagged for Review
+    {
+        label: 'Process 2 — Flagged for Review',
+        workflowName: 'reviewContent',
+        taskQueue: 'long-tail-examples',
+        envelope: {
+            data: {
+                contentId: 'process-flagged-001',
+                content: 'REVIEW_ME This user-submitted blog post discusses alternative medicine claims without citing peer-reviewed sources. The AI flagged it for human review.',
+                contentType: 'blog_post',
+            },
+            metadata: {
+                source: 'seed',
+                process: 'flagged-review',
+                description: 'AI flags content for human review. Log in as reviewer (reviewer/l0ngt@1l) and approve or reject.',
+            },
+        },
+    },
+    // -- Process 3: Wrong Language -> Durable MCP
+    {
+        label: 'Process 3 — Wrong Language',
+        workflowName: 'reviewContent',
+        taskQueue: 'long-tail-examples',
+        envelope: {
+            data: {
+                contentId: 'process-language-001',
+                content: 'WRONG_LANGUAGE La energía renovable es el futuro de las ciudades sostenibles. Los paneles solares y las turbinas eólicas pueden reducir significativamente la huella de carbono urbana cuando se combinan con sistemas modernos de almacenamiento de energía.',
+                contentType: 'article',
+            },
+            metadata: {
+                source: 'seed',
+                process: 'wrong-language',
+                description: 'Content arrived in the wrong language. Walk the escalation chain: reviewer → admin → engineer. As engineer, check "Request AI Triage" and describe: "Content is in Spanish, needs translation to English."',
+            },
+        },
+    },
+    // -- Process 4: Kitchen Sink -> Dynamic Triage
+    {
+        label: 'Process 4 — Dynamic Triage',
+        workflowName: 'kitchenSink',
+        taskQueue: 'long-tail-examples',
+        envelope: {
+            data: {
+                name: 'Triage Demo',
+                mode: 'full',
+            },
+            metadata: {
+                source: 'seed',
+                process: 'dynamic-triage',
+                description: 'As reviewer, check "Request AI Triage" and write: "This looks fine, just approve it."',
+            },
+        },
+    },
+    // -- Process 5: Basic Echo
+    {
+        label: 'Process 5 — Basic Echo',
+        workflowName: 'basicEcho',
+        taskQueue: 'long-tail-examples',
+        envelope: {
+            data: {
+                message: 'Hello from the seed!',
+                sleepSeconds: 2,
+            },
+            metadata: {
+                source: 'seed',
+                process: 'basic-echo',
+                description: 'Minimal durable workflow — echoes a message and reveals IAM context.',
+            },
+        },
+    },
+];
+// Escalation chains: reviewer -> admin -> engineer (and cross-links)
+const SEED_CHAINS = [
+    ['reviewer', 'admin'],
+    ['reviewer', 'engineer'],
+    ['admin', 'engineer'],
+    ['admin', 'superadmin'],
+    ['engineer', 'admin'],
+    ['engineer', 'superadmin'],
+];
+// ── Seed functions ───────────────────────────────────────────────────────────
+async function seedRoles() {
+    for (const role of SEED_ROLES) {
+        try {
+            await (0, role_1.createRole)(role);
+        }
+        catch { /* ON CONFLICT DO NOTHING handles duplicates */ }
+    }
+    logger_1.loggerRegistry.info(`[examples] roles verified (${SEED_ROLES.join(', ')})`);
+}
+async function seedUsers() {
+    for (const userDef of SEED_USERS) {
+        try {
+            const existing = await (0, user_1.getUserByExternalId)(userDef.external_id);
+            if (existing) {
+                // Ensure existing user has the expected roles
+                if (userDef.roles?.length) {
+                    const currentRoles = await (0, roles_1.getUserRoles)(existing.id);
+                    for (const expected of userDef.roles) {
+                        const has = currentRoles.some(r => r.role === expected.role && r.type === expected.type);
+                        if (!has) {
+                            await (0, roles_1.addUserRole)(existing.id, expected.role, expected.type);
+                            logger_1.loggerRegistry.info(`[examples] added role ${expected.role} (${expected.type}) to ${userDef.external_id}`);
+                        }
+                    }
+                }
+                logger_1.loggerRegistry.info(`[examples] ${userDef.external_id} already exists, skipping`);
+                continue;
+            }
+            await (0, user_1.createUser)(userDef);
+            logger_1.loggerRegistry.info(`[examples] seeded user (${userDef.external_id} / ${userDef.password})`);
+        }
+        catch (err) {
+            logger_1.loggerRegistry.warn(`[examples] failed to seed ${userDef.external_id}: ${err.message}`);
+        }
+    }
+}
+async function seedEscalationChains() {
+    for (const [source, target] of SEED_CHAINS) {
+        try {
+            await (0, role_1.addEscalationChain)(source, target);
+        }
+        catch { /* ON CONFLICT DO NOTHING handles duplicates */ }
+    }
+    logger_1.loggerRegistry.info(`[examples] escalation chains verified (${SEED_CHAINS.length} entries)`);
+}
+/**
+ * Seed example workflows so the dashboard tells a story immediately.
+ * Called automatically when `examples: true` is set in the start config.
+ */
+async function seedExamples(client) {
+    await seedRoles();
+    await seedUsers();
+    await seedEscalationChains();
+    for (const { workflowName, taskQueue, envelope, label } of SEED_ENVELOPES) {
+        try {
+            const workflowId = `${workflowName}-seed-${hotmesh_1.Durable.guid().slice(0, 8)}`;
+            await client.workflow.start({
+                args: [envelope],
+                taskQueue,
+                workflowName,
+                workflowId,
+                expire: defaults_1.JOB_EXPIRE_SECS,
+                entity: workflowName,
+            });
+            logger_1.loggerRegistry.info(`[examples] seeded: ${label} (${workflowId})`);
+        }
+        catch (err) {
+            logger_1.loggerRegistry.warn(`[examples] seed failed for ${label}: ${err.message}`);
+        }
+    }
+}

package/build/examples/types/envelopes.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Typed envelope data shapes for each invocable workflow.
+ *
+ * These define the API contract — what the Start Workflow page
+ * and REST callers send as `envelope.data` when invoking a workflow.
+ */
+/** Content to review — article, comment, or other text submission. */
+export interface ReviewContentEnvelopeData {
+    contentId: string;
+    content: string;
+    contentType?: string;
+}
+/** Kitchen sink — showcases every Durable primitive. */
+export interface KitchenSinkEnvelopeData {
+    /** Name used in the greeting activity. */
+    name?: string;
+    /** 'full' pauses for human review; 'quick' auto-completes. */
+    mode?: 'full' | 'quick';
+}
+/** Basic echo — minimal durable workflow with IAM context. */
+export interface BasicEchoEnvelopeData {
+    /** Message to echo back. */
+    message?: string;
+    /** Duration to sleep before echoing (seconds). */
+    sleepSeconds?: number;
+}
+/** Map of invocable workflow type → its typed envelope data shape. */
+export type WorkflowEnvelopeMap = {
+    reviewContent: ReviewContentEnvelopeData;
+    kitchenSink: KitchenSinkEnvelopeData;
+    basicEcho: BasicEchoEnvelopeData;
+};
+/** All invocable workflow type names. */
+export type InvocableWorkflowType = keyof WorkflowEnvelopeMap;

package/build/examples/types/envelopes.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Typed envelope data shapes for each invocable workflow.
+ *
+ * These define the API contract — what the Start Workflow page
+ * and REST callers send as `envelope.data` when invoking a workflow.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/examples/types/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared types for the Long Tail example workflows.
+ *
+ * Envelope types define the API contract for starting workflows.
+ * Resolver types define the payload shape for resolving escalations.
+ * Per-workflow types are re-exported for convenience.
+ */
+export type { ReviewContentEnvelopeData, KitchenSinkEnvelopeData, BasicEchoEnvelopeData, WorkflowEnvelopeMap, InvocableWorkflowType, } from './envelopes';
+export type { ResolverLTBlock, BaseResolverPayload, ReviewContentResolverPayload, } from './resolvers';
+export type { ReviewContentInput, ReviewAnalysis, ReviewContentReturnData, ReviewContentReturn, ReviewContentEscalationData, ReviewContentEscalation, } from '../workflows/review-content/types';

package/build/examples/types/index.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Shared types for the Long Tail example workflows.
+ *
+ * Envelope types define the API contract for starting workflows.
+ * Resolver types define the payload shape for resolving escalations.
+ * Per-workflow types are re-exported for convenience.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/examples/types/resolvers.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Typed resolver payloads — what the operator sends when resolving
+ * an escalation via POST /api/escalations/:id/resolve.
+ *
+ * Every resolver payload may include an `_lt` block for routing
+ * control (e.g., flagging that the escalation needs AI triage).
+ */
+/** Control block available on all resolver payloads. */
+export interface ResolverLTBlock {
+    /** Flag for AI triage — routes to the mcpTriage orchestrator. */
+    needsTriage?: boolean;
+}
+/** Base resolver payload — all resolvers may include _lt and notes. */
+export interface BaseResolverPayload {
+    _lt?: ResolverLTBlock;
+    /** Human description of the problem — the LLM uses this for diagnosis. */
+    notes?: string;
+}
+/** Resolver payload when a reviewer resolves a content escalation. */
+export interface ReviewContentResolverPayload extends BaseResolverPayload {
+    approved: boolean;
+    analysis?: {
+        confidence: number;
+        flags: string[];
+        summary: string;
+    };
+}

package/build/examples/types/resolvers.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Typed resolver payloads — what the operator sends when resolving
+ * an escalation via POST /api/escalations/:id/resolve.
+ *
+ * Every resolver payload may include an `_lt` block for routing
+ * control (e.g., flagging that the escalation needs AI triage).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/examples/workers.d.ts

@@ -0,0 +1,10 @@
+import * as kitchenSinkWorkflow from './workflows/kitchen-sink';
+/**
+ * Example workers that ship with Long Tail.
+ * Pass these to `start({ workers: [...exampleWorkers] })` or enable
+ * via `examples: true` in the start config.
+ */
+export declare const exampleWorkers: {
+    taskQueue: string;
+    workflow: typeof kitchenSinkWorkflow.kitchenSink;
+}[];

package/build/examples/workers.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exampleWorkers = void 0;
+const reviewContentWorkflow = __importStar(require("./workflows/review-content"));
+const kitchenSinkWorkflow = __importStar(require("./workflows/kitchen-sink"));
+const basicEchoWorkflow = __importStar(require("./workflows/basic-echo"));
+/**
+ * Example workers that ship with Long Tail.
+ * Pass these to `start({ workers: [...exampleWorkers] })` or enable
+ * via `examples: true` in the start config.
+ */
+exports.exampleWorkers = [
+    { taskQueue: 'long-tail-examples', workflow: reviewContentWorkflow.reviewContent },
+    { taskQueue: 'long-tail-examples', workflow: kitchenSinkWorkflow.kitchenSink },
+    { taskQueue: 'long-tail-examples', workflow: basicEchoWorkflow.basicEcho },
+];

package/build/examples/workflows/basic-echo/activities.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Basic Echo Activities
+ *
+ * Single activity that echoes a message back with IAM context.
+ * Demonstrates three ways to access identity inside a proxy activity:
+ *
+ * 1. `getActivityIdentity()` — recommended: one-call access to principal + credential exchange
+ * 2. `getToolContext()` — lower-level access to ToolContext (principal, scopes, trace)
+ * 3. `Durable.activity.getContext()` — raw HotMesh API for argumentMetadata
+ *
+ * All work across process boundaries because argumentMetadata travels
+ * with the activity call via HotMesh's schema pipeline.
+ */
+export declare function echo(input: {
+    message: string;
+}): Promise<{
+    message: string;
+    echoedAt: string;
+    identity: Record<string, unknown>;
+}>;

package/build/examples/workflows/basic-echo/activities.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Basic Echo Activities
+ *
+ * Single activity that echoes a message back with IAM context.
+ * Demonstrates three ways to access identity inside a proxy activity:
+ *
+ * 1. `getActivityIdentity()` — recommended: one-call access to principal + credential exchange
+ * 2. `getToolContext()` — lower-level access to ToolContext (principal, scopes, trace)
+ * 3. `Durable.activity.getContext()` — raw HotMesh API for argumentMetadata
+ *
+ * All work across process boundaries because argumentMetadata travels
+ * with the activity call via HotMesh's schema pipeline.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.echo = echo;
+const hotmesh_1 = require("@hotmeshio/hotmesh");
+const context_1 = require("../../../services/iam/context");
+async function echo(input) {
+    // Recommended: getActivityIdentity() — principal + getCredential() in one call
+    // const identity = getActivityIdentity();
+    // const token = await identity.getCredential('anthropic'); // credential exchange
+    // Primary: getToolContext() reads from argumentMetadata (injected by activity interceptor)
+    const ctx = (0, context_1.getToolContext)();
+    // Direct access: Durable.activity.getContext() shows the raw argumentMetadata
+    const activityCtx = hotmesh_1.Durable.activity.getContext();
+    const rawPrincipal = activityCtx?.argumentMetadata?.principal;
+    const identity = ctx
+        ? {
+            source: 'getActivityIdentity',
+            principal: {
+                id: ctx.principal.id,
+                type: ctx.principal.type,
+                displayName: ctx.principal.displayName,
+                roles: ctx.principal.roles,
+                roleType: ctx.principal.roleType,
+            },
+            scopes: ctx.credentials.scopes,
+            note: 'Also available via getActivityIdentity().getCredential(provider) for token exchange',
+        }
+        : rawPrincipal
+            ? {
+                source: 'argumentMetadata',
+                principal: rawPrincipal,
+            }
+            : {
+                source: 'unavailable',
+                note: 'no principal in envelope or argumentMetadata',
+            };
+    return {
+        message: input.message,
+        echoedAt: new Date().toISOString(),
+        identity,
+    };
+}

package/build/examples/workflows/basic-echo/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Basic Echo Workflow
+ *
+ * Minimal durable workflow that:
+ *   1. Sleeps for a configurable duration (durable timer)
+ *   2. Echoes the input message back with IAM identity context
+ *
+ * Use this to verify:
+ *   - Durable workflow invocation from the dashboard
+ *   - IAM context availability (registered vs unregistered)
+ *   - Cron scheduling for plain durable workers
+ */
+import type { LTEnvelope } from '../../../types';
+export declare function basicEcho(envelope: LTEnvelope): Promise<any>;

package/build/examples/workflows/basic-echo/index.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Basic Echo Workflow
+ *
+ * Minimal durable workflow that:
+ *   1. Sleeps for a configurable duration (durable timer)
+ *   2. Echoes the input message back with IAM identity context
+ *
+ * Use this to verify:
+ *   - Durable workflow invocation from the dashboard
+ *   - IAM context availability (registered vs unregistered)
+ *   - Cron scheduling for plain durable workers
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicEcho = basicEcho;
+const hotmesh_1 = require("@hotmeshio/hotmesh");
+const activities = __importStar(require("./activities"));
+const { echo } = hotmesh_1.Durable.workflow.proxyActivities({
+    activities,
+});
+async function basicEcho(envelope) {
+    const { message = 'Hello, Long Tail!', sleepSeconds = 1 } = envelope.data;
+    await hotmesh_1.Durable.workflow.sleepFor(`${sleepSeconds} seconds`);
+    const echoResult = await echo({ message });
+    return {
+        type: 'return',
+        data: {
+            ...echoResult,
+            sleepSeconds,
+            userId: envelope.lt?.userId,
+        },
+    };
+}

package/build/examples/workflows/kitchen-sink/activities.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Kitchen Sink Activities
+ *
+ * Each function is a side effect wrapped as a durable activity.
+ * When proxied via Durable.workflow.proxyActivities(), each call
+ * becomes a checkpointed step — cached on replay, retried on failure.
+ *
+ * Use these as a starting point for your own activities.
+ */
+/** Simple greeting — the most basic activity possible. */
+export declare function greet(name: string): Promise<string>;
+/** Simulate an API call that fetches data from an external source. */
+export declare function fetchData(key: string): Promise<{
+    key: string;
+    value: string;
+    fetchedAt: string;
+}>;
+/** Transform and merge data from multiple sources. */
+export declare function transformData(input: {
+    greeting: string;
+    dataA: {
+        key: string;
+        value: string;
+    };
+    dataB: {
+        key: string;
+        value: string;
+    };
+}): Promise<{
+    summary: string;
+    merged: Record<string, string>;
+}>;
+/** Simulate sending a notification (email, Slack, webhook, etc). */
+export declare function notifyComplete(summary: {
+    status: string;
+    result: any;
+}): Promise<{
+    notified: boolean;
+    timestamp: string;
+}>;

package/build/examples/workflows/kitchen-sink/activities.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Kitchen Sink Activities
+ *
+ * Each function is a side effect wrapped as a durable activity.
+ * When proxied via Durable.workflow.proxyActivities(), each call
+ * becomes a checkpointed step — cached on replay, retried on failure.
+ *
+ * Use these as a starting point for your own activities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.greet = greet;
+exports.fetchData = fetchData;
+exports.transformData = transformData;
+exports.notifyComplete = notifyComplete;
+/** Simple greeting — the most basic activity possible. */
+async function greet(name) {
+    return `Hello, ${name}!`;
+}
+/** Simulate an API call that fetches data from an external source. */
+async function fetchData(key) {
+    // In production, this would call a real API.
+    return {
+        key,
+        value: `data-for-${key}`,
+        fetchedAt: new Date().toISOString(),
+    };
+}
+/** Transform and merge data from multiple sources. */
+async function transformData(input) {
+    return {
+        summary: `${input.greeting} Merged ${input.dataA.key} + ${input.dataB.key}.`,
+        merged: {
+            [input.dataA.key]: input.dataA.value,
+            [input.dataB.key]: input.dataB.value,
+        },
+    };
+}
+/** Simulate sending a notification (email, Slack, webhook, etc). */
+async function notifyComplete(summary) {
+    // In production, this would call a notification service.
+    return {
+        notified: true,
+        timestamp: new Date().toISOString(),
+    };
+}

package/build/examples/workflows/kitchen-sink/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Kitchen Sink Workflow
+ *
+ * Demonstrates every Durable primitive in one workflow:
+ *
+ *   1. proxyActivities  — turn functions into durable, checkpointed steps
+ *   2. Activity calls   — each call is cached on replay (deterministic)
+ *   3. Sleep            — durable timer that survives process crashes
+ *   4. Parallel calls   — Promise.all with multiple activities
+ *   5. waitFor          — pause until an external signal arrives
+ *   6. Conditional flow — branch based on signal data
+ *
+ * Use this as a copy-paste starting point for your own workflows.
+ *
+ * Structure:
+ *   examples/workflows/kitchen-sink/
+ *   ├── activities.ts     ← side-effect functions (API calls, DB writes, etc.)
+ *   ├── index.ts          ← this file (the workflow — must be deterministic)
+ *   └── orchestrator.ts   ← entry point wrapper using executeLT
+ */
+import type { LTEnvelope } from '../../../types';
+export declare function kitchenSink(envelope: LTEnvelope): Promise<any>;