@primero.ai/temporal-graph-tools 1.0.0

package/README.md

@@ -0,0 +1,203 @@
+# @primero.ai/temporal-graph-tools
+
+TypeScript utilities for assembling Temporal workflows from plain activity
+functions. Build a workflow plan, capture the generated source code, hydrate
+activity implementations, and bundle everything for a worker without
+hand-writing workflow files.
+
+## Highlights
+
+- Fluent builder for chaining sequential steps and running activity stages in
+  parallel with type-safe input/output propagation.
+- Automatic activity key generation and optional per-activity configuration so
+  the generated workflow source stays deterministic.
+- One-call bundler that validates multiple plans, hydrates activities, and
+  produces bundled workflow code ready for a worker.
+- Emits Temporal workflow source that proxies activities and stitches staged
+  plans together.
+- Low-level helpers remain available if you prefer to collect results, build
+  bundles, or hydrate activities manually.
+
+## Installation
+
+```bash
+npm install @primero.ai/temporal-graph-tools
+# or
+pnpm add @primero.ai/temporal-graph-tools
+# or
+bun add @primero.ai/temporal-graph-tools
+```
+
+The package targets Node.js 18+ and ships ESM builds.
+
+## Quick start
+
+```ts
+import {
+  bundleWorkflows,
+  createActivity,
+  createWorkflowBuilder,
+} from '@primero.ai/temporal-graph-tools'
+
+type FetchUserInput = { userId: string }
+type FetchUserOutput = { profile: { id: string; name: string } }
+
+const fetchUserProfile = createActivity(
+  async ({ userId }: FetchUserInput): Promise<FetchUserOutput> => {
+    return { profile: { id: userId, name: `User ${userId}` } }
+  },
+  { id: 'fetchUserProfile' },
+)
+
+const sendWelcomeEmail = createActivity(
+  async ({ profile }: FetchUserOutput) => {
+    return { sent: true, name: profile.name }
+  },
+  { id: 'sendWelcomeEmail' },
+)
+
+async function compile() {
+  const builder = createWorkflowBuilder<FetchUserInput>({
+    workflowName: 'customerOnboardingWorkflow',
+    proxyOptions: { startToCloseTimeout: '2 minutes' },
+  })
+
+  const plan = builder.then(fetchUserProfile).then(sendWelcomeEmail).commit()
+  const { activities, workflowBundle } = await bundleWorkflows([plan])
+
+  // Use the emitted artifacts with a Temporal worker
+  return { workflowBundle, activities }
+}
+```
+
+See the complete onboarding example in `examples/` for a richer flow that uses a
+parallel stage and hooks a worker up to the generated artifacts.
+
+### Example scripts
+
+After installing dependencies you can explore the sample project:
+
+```bash
+bun install
+bun run worker              # Starts a Temporal worker (needs a Temporal cluster)
+bun run trigger-workflows   # Launches the sample workflows through the client
+```
+
+Set `TEMPORAL_ADDRESS`, `TEMPORAL_NAMESPACE`, and `TEMPORAL_TASK_QUEUE` in
+`.env` to point the worker at your cluster. Use `bun run trigger-workflows` to
+start the compiled workflows through the Temporal client once the worker is
+running.
+
+## Workflow builder API
+
+### `createWorkflowBuilder<TInput>(options)`
+
+Creates a `WorkflowBuilder` instance typed with the initial workflow input.
+`options` must include:
+
+- `workflowName`: Name of the exported workflow function. This value must be a
+  non-empty string and unique across the plans you later bundle.
+
+Optional fields:
+
+- `activitiesImportPath`: Module specifier used in the generated workflow import
+  (`'./activities'` by default).
+- `proxyOptions`: Either a `@temporalio/workflow` `ActivityOptions` object or a
+  string literal dropped into the generated code. If omitted, a one-minute
+  `startToCloseTimeout` is emitted.
+
+### `builder.then(activity, config?)`
+
+Appends a sequential activity. The helper accepts either a bare activity
+function or a value created with `createActivity`. When both inline and
+preconfigured options are provided they are merged; `config.id` determines the
+activity key.
+
+### `builder.parallel([activityA, activityB, ...])`
+
+Executes multiple activities against the current stage output and returns an
+object keyed by each activity's `id`. A parallel stage can only be added after
+at least one `then` call.
+
+### `builder.commit(options?)`
+
+Finalises the plan and returns:
+
+- `workflowName`: The sanitized name of the exported workflow function.
+- `workflowSource`: Generated TypeScript for the Temporal workflow function.
+- `activities`: Map of activity keys to the original implementations and config
+  metadata. Implementations remain live references so any captured helpers stay
+  intact.
+
+Additional `options` override the builder defaults for this invocation.
+
+## Activity helpers
+
+### `createActivity(activityFn, config?)`
+
+Wraps an activity function so it can be reused with the builder. When a config
+object is provided its `id` becomes the activity key; without options the
+function name (or an auto-incremented fallback) is used. The helper is also
+re-exported as `createActivity` for codebases that prefer plural naming.
+
+## Workflow bundler utilities
+
+### `bundleWorkflows(plans, options?)`
+
+High-level helper that accepts one or more `WorkflowBuildResult` instances,
+validates them, hydrates all activities, and bundles the generated workflow
+sources. Returns:
+
+- `activities`: Map of activity keys to runnable implementations.
+- `workflowBundle`: Object containing the bundled JavaScript (in `code`) with an
+  inline source map.
+
+Use this when you want a single call that prepares everything for a Temporal
+worker. Under the hood it relies on the lower-level helpers documented below.
+
+```ts
+const plans = [onboardingPlan, greetingPlan]
+const { activities, workflowBundle } = await bundleWorkflows(plans, {
+  filename: 'team-workflows.js',
+})
+```
+
+### `collectWorkflowBuildResults(results)`
+
+Merges the output of multiple `builder.commit()` calls into a single object.
+Workflow names must be unique (duplicates are rejected), and activity IDs either
+unique or guaranteed to have identical implementation/config pairs. The result
+can feed directly into `instantiateActivities` or `buildWorkflowBundleCode`.
+
+### `instantiateActivities(bundles)`
+
+Accepts the `activities` map returned by `builder.commit()` (or
+`collectWorkflowBuildResults`) and produces actual implementations. Each entry
+is the original function reference supplied to the builder, so any captured
+state remains intact.
+
+### `buildWorkflowBundleCode(source, filename?)`
+
+Runs Temporal's `bundleWorkflowCode` against the generated workflow source(s)
+and returns bundled JavaScript with an inline source map. `source` can be:
+
+- A raw workflow source string (preserved for backward compatibility).
+- A single `WorkflowBuildResult` or `WorkflowSourceArtifact`.
+- An array of `WorkflowSourceArtifact` values (for multiple workflows).
+
+`filename` controls the `file` attribute recorded in the map. When omitted the
+helper generates deterministic filenames per workflow and normalizes the map so
+Temporal tooling can attribute stack traces correctly.
+
+## Development
+
+```bash
+bun install
+bun run type-check
+bun run lint
+bun run build
+```
+
+## License
+
+MIT

package/dist/examples/bundle/activities.d.ts

@@ -0,0 +1,34 @@
+export type FetchUserInput = {
+    userId: string;
+};
+export declare const fetchUserProfile: import("@primero.ai/temporal-graph-tools").ConfiguredActivityReference<FetchUserInput, FetchUserOutput, "fetchUserProfile">;
+export declare const sendWelcomeEmail: import("@primero.ai/temporal-graph-tools").ConfiguredActivityReference<FetchUserOutput, {
+    sent: boolean;
+    recipientSlug: string;
+}, "sendWelcomeEmail">;
+export type UserProfile = {
+    id: string;
+    name: string;
+    slug: string;
+};
+export type FetchUserOutput = {
+    profile: UserProfile;
+};
+export declare const syncCrmRecord: import("@primero.ai/temporal-graph-tools").ConfiguredActivityReference<FetchUserOutput, {
+    synced: boolean;
+    recordSlug: string;
+}, "syncCrmRecord">;
+export type ParallelResult = {
+    sendWelcomeEmail: {
+        sent: boolean;
+        recipientSlug: string;
+    };
+    syncCrmRecord: {
+        synced: boolean;
+        recordSlug: string;
+    };
+};
+export declare const logCompletion: import("@primero.ai/temporal-graph-tools").ConfiguredActivityReference<ParallelResult, void, "logCompletion">;
+export declare const startGreet: import("@primero.ai/temporal-graph-tools").ConfiguredActivityReference<unknown, void, "startGreet">;
+export declare const endGreet: import("@primero.ai/temporal-graph-tools").ConfiguredActivityReference<unknown, void, "endGreet">;
+//# sourceMappingURL=activities.d.ts.map

package/dist/examples/bundle/activities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activities.d.ts","sourceRoot":"","sources":["../../../examples/bundle/activities.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,cAAc,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAE/C,eAAO,MAAM,gBAAgB,6HAiB5B,CAAA;AAED,eAAO,MAAM,gBAAgB;UAC2B,OAAO;mBAAiB,MAAM;sBAOrF,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AACpE,MAAM,MAAM,eAAe,GAAG;IAAE,OAAO,EAAE,WAAW,CAAA;CAAE,CAAA;AAEtD,eAAO,MAAM,aAAa;YACgC,OAAO;gBAAc,MAAM;mBAOpF,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,gBAAgB,EAAE;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAA;IAC1D,aAAa,EAAE;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAA;CACvD,CAAA;AAED,eAAO,MAAM,aAAa,+GASzB,CAAA;AACD,eAAO,MAAM,UAAU,qGAA0E,CAAA;AACjG,eAAO,MAAM,QAAQ,mGAAuE,CAAA"}

package/dist/examples/bundle/activities.js

@@ -0,0 +1,35 @@
+import kebabCase from 'lodash/kebabCase.js';
+import { createActivity, } from '@primero.ai/temporal-graph-tools';
+export const fetchUserProfile = createActivity(async (input) => {
+    const profileName = `User ${input.userId.slice(0, 6)}`;
+    const slug = kebabCase(profileName);
+    console.log(`[fetchUserProfile] fetching ${input.userId} as ${slug}`);
+    return {
+        profile: {
+            id: input.userId,
+            name: profileName,
+            slug,
+        },
+    };
+}, {
+    id: 'fetchUserProfile',
+});
+export const sendWelcomeEmail = createActivity(async ({ profile }) => {
+    console.log(`[sendWelcomeEmail] sent email to ${profile.name} (${profile.slug})`);
+    return { sent: true, recipientSlug: profile.slug };
+}, {
+    id: 'sendWelcomeEmail',
+});
+export const syncCrmRecord = createActivity(async ({ profile }) => {
+    console.log(`[syncCrmRecord] synced record ${profile.id} (${profile.slug})`);
+    return { synced: true, recordSlug: profile.slug };
+}, {
+    id: 'syncCrmRecord',
+});
+export const logCompletion = createActivity(async (result) => {
+    console.log(`[logCompletion] email sent=${result.sendWelcomeEmail.sent} (slug=${result.sendWelcomeEmail.recipientSlug}), crm synced=${result.syncCrmRecord.synced}`);
+}, {
+    id: 'logCompletion',
+});
+export const startGreet = createActivity(async () => console.log('Hello '), { id: 'startGreet' });
+export const endGreet = createActivity(async () => console.log('World'), { id: 'endGreet' });

package/dist/examples/bundle/workflows.d.ts

@@ -0,0 +1,3 @@
+export declare const builderOnboarding: import("@primero.ai/temporal-graph-tools").WorkflowBuildResult;
+export declare const builderHelloWorld: import("@primero.ai/temporal-graph-tools").WorkflowBuildResult;
+//# sourceMappingURL=workflows.d.ts.map

package/dist/examples/bundle/workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../../examples/bundle/workflows.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,iBAAiB,gEAOnB,CAAA;AAEX,eAAO,MAAM,iBAAiB,gEAGnB,CAAA"}

package/dist/examples/bundle/workflows.js

@@ -0,0 +1,14 @@
+import { createWorkflowBuilder } from '@primero.ai/temporal-graph-tools';
+import { endGreet, fetchUserProfile, logCompletion, sendWelcomeEmail, startGreet, syncCrmRecord, } from './activities';
+export const builderOnboarding = createWorkflowBuilder({
+    workflowName: 'customerOnboardingWorkflow',
+    proxyOptions: { startToCloseTimeout: '2 minutes' },
+})
+    .then(fetchUserProfile)
+    .parallel([sendWelcomeEmail, syncCrmRecord])
+    .then(logCompletion)
+    .commit();
+export const builderHelloWorld = createWorkflowBuilder({ workflowName: 'greetWorkflow' })
+    .then(startGreet)
+    .then(endGreet)
+    .commit();

package/dist/examples/trigger-workflows.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=trigger-workflows.d.ts.map

package/dist/examples/trigger-workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger-workflows.d.ts","sourceRoot":"","sources":["../../examples/trigger-workflows.ts"],"names":[],"mappings":""}

package/dist/examples/trigger-workflows.js

@@ -0,0 +1,43 @@
+import { Connection, WorkflowClient } from '@temporalio/client';
+import { builderHelloWorld, builderOnboarding } from './bundle/workflows';
+const DEFAULT_NAMESPACE = 'default';
+const DEFAULT_TASK_QUEUE = 'default';
+async function run() {
+    var _a, _b, _c, _d;
+    const connection = await Connection.connect({
+        address: (_a = process.env.TEMPORAL_ADDRESS) !== null && _a !== void 0 ? _a : 'localhost:7233',
+        tls: process.env.TEMPORAL_API_KEY ? {} : undefined,
+        apiKey: process.env.TEMPORAL_API_KEY,
+    });
+    const client = new WorkflowClient({
+        connection,
+        namespace: (_b = process.env.TEMPORAL_NAMESPACE) !== null && _b !== void 0 ? _b : DEFAULT_NAMESPACE,
+    });
+    const [onboardingHandle, greetHandle] = await Promise.all([
+        client.start(builderOnboarding.workflowName, {
+            taskQueue: (_c = process.env.TEMPORAL_TASK_QUEUE) !== null && _c !== void 0 ? _c : DEFAULT_TASK_QUEUE,
+            workflowId: `customer-onboarding-${Date.now()}`,
+            args: [{ userId: 'user-123' }],
+        }),
+        client.start(builderHelloWorld.workflowName, {
+            taskQueue: (_d = process.env.TEMPORAL_TASK_QUEUE) !== null && _d !== void 0 ? _d : DEFAULT_TASK_QUEUE,
+            workflowId: `greet-${Date.now()}`,
+            args: [{ userId: 'user-123' }],
+        }),
+    ]);
+    console.log('Onboarding Workflow started:', {
+        workflowId: onboardingHandle.workflowId,
+        runId: onboardingHandle.firstExecutionRunId,
+    });
+    console.log('Greet Workflow started:', {
+        workflowId: greetHandle.workflowId,
+        runId: greetHandle.firstExecutionRunId,
+    });
+    const result = await Promise.all([onboardingHandle.result(), greetHandle.result()]);
+    console.log('Workflows completed with result:', result);
+    await connection.close();
+}
+run().catch((error) => {
+    console.error('Failed to run workflow example:', error);
+    process.exitCode = 1;
+});

package/dist/examples/worker.d.ts

@@ -0,0 +1,3 @@
+import { NativeConnectionOptions } from '@temporalio/worker';
+export declare function getConnectionOptions(): NativeConnectionOptions;
+//# sourceMappingURL=worker.d.ts.map

package/dist/examples/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../examples/worker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,uBAAuB,EAAU,MAAM,oBAAoB,CAAA;AAItF,wBAAgB,oBAAoB,IAAI,uBAAuB,CAM9D"}

package/dist/examples/worker.js

@@ -0,0 +1,29 @@
+import { NativeConnection, Worker } from '@temporalio/worker';
+import { bundleWorkflows, loadActivitiesFromBundle } from '@primero.ai/temporal-graph-tools';
+import { builderHelloWorld, builderOnboarding } from './bundle/workflows';
+export function getConnectionOptions() {
+    return {
+        address: process.env.TEMPORAL_ADDRESS,
+        apiKey: process.env.TEMPORAL_API_KEY,
+        tls: {},
+    };
+}
+async function run() {
+    const { workflowBundle, activityBundle } = await bundleWorkflows([builderHelloWorld, builderOnboarding], {
+        activityBundle: {},
+    });
+    const activities = await loadActivitiesFromBundle(activityBundle);
+    const connection = await NativeConnection.connect(getConnectionOptions());
+    const worker = await Worker.create({
+        connection,
+        namespace: process.env.TEMPORAL_NAMESPACE,
+        taskQueue: process.env.TEMPORAL_TASK_QUEUE || 'default',
+        activities,
+        workflowBundle,
+    });
+    await worker.run();
+}
+run().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/src/bundler.d.ts

@@ -0,0 +1,25 @@
+import type { WorkflowBuildResult } from './types.js';
+import type { ActivityImplementations } from './workflow-bundler.js';
+export type BundleWorkflowsOptions = {
+    filename?: string;
+    activityBundle?: BundleActivitiesOptions;
+};
+export type BundleWorkflowsResult = {
+    activityBundle: BundledActivitiesArtifact;
+    workflowBundle: {
+        code: string;
+    };
+};
+export type BundleActivitiesOptions = {
+    entrypoints?: readonly string[];
+    filename?: string;
+    externals?: readonly string[];
+};
+export type BundledActivitiesArtifact = {
+    filename: string;
+    code: string;
+    map?: string;
+};
+export declare function loadActivitiesFromBundle(bundle: BundledActivitiesArtifact): Promise<ActivityImplementations>;
+export declare function bundleWorkflows(plans: readonly WorkflowBuildResult[], options?: BundleWorkflowsOptions): Promise<BundleWorkflowsResult>;
+//# sourceMappingURL=bundler.d.ts.map

package/dist/src/bundler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundler.d.ts","sourceRoot":"","sources":["../../src/bundler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAkB,mBAAmB,EAA0B,MAAM,YAAY,CAAA;AAC7F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AAIpE,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,cAAc,CAAC,EAAE,uBAAuB,CAAA;CACzC,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,cAAc,EAAE,yBAAyB,CAAA;IACzC,cAAc,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;CACjC,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;CACb,CAAA;AAoCD,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAAC,uBAAuB,CAAC,CAkClC;AAED,wBAAsB,eAAe,CACnC,KAAK,EAAE,SAAS,mBAAmB,EAAE,EACrC,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,qBAAqB,CAAC,CAqChC"}

package/dist/src/bundler.js

@@ -0,0 +1,208 @@
+import { isAbsolute, resolve, join } from 'node:path';
+import { mkdtemp, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { buildWorkflowBundleCode } from './workflow-bundler.js';
+import { collectWorkflowBuildResults } from './workflow/collection.js';
+let cachedEsbuild;
+async function loadEsbuild() {
+    if (cachedEsbuild) {
+        return cachedEsbuild;
+    }
+    const createLoadError = (error) => {
+        if (error instanceof Error) {
+            error.message = `Failed to load esbuild. Install it as a dependency before calling bundleWorkflows(). Original error: ${error.message}`;
+            return error;
+        }
+        return new Error(`Failed to load esbuild. Install it as a dependency before calling bundleWorkflows(). Original error: ${String(error)}`);
+    };
+    try {
+        const esbuildModule = await import('esbuild');
+        cachedEsbuild = esbuildModule;
+        return esbuildModule;
+    }
+    catch (error) {
+        throw createLoadError(error);
+    }
+}
+export async function loadActivitiesFromBundle(bundle) {
+    if (!bundle || typeof bundle.code !== 'string' || bundle.code.trim().length === 0) {
+        throw new Error('Activity bundle code must be a non-empty string.');
+    }
+    const source = ensureActivityInlineSourceMap(bundle.code, bundle.map);
+    const tempDir = await mkdtemp(join(process.cwd(), '.temporal-graph-tools-'));
+    const tempFile = join(tempDir, `activities-${Date.now()}-${Math.random().toString(16).slice(2)}.cjs`);
+    await writeFile(tempFile, source, 'utf8');
+    const require = createRequire(import.meta.url);
+    const moduleNamespace = require(tempFile);
+    const activitiesExport = moduleNamespace.activities;
+    if (isActivityImplementations(activitiesExport)) {
+        return activitiesExport;
+    }
+    const collected = {};
+    Object.entries(moduleNamespace).forEach(([key, value]) => {
+        if (typeof value === 'function') {
+            collected[key] = value;
+        }
+    });
+    if (Object.keys(collected).length > 0) {
+        return collected;
+    }
+    throw new Error('Activity bundle did not expose an activities object or callable exports.');
+}
+export async function bundleWorkflows(plans, options) {
+    var _a;
+    if (plans.length === 0) {
+        throw new Error('bundleWorkflows requires at least one workflow plan.');
+    }
+    const seenWorkflowNames = new Set();
+    plans.forEach((plan, index) => {
+        const workflowName = typeof plan.workflowName === 'string' ? plan.workflowName.trim() : '';
+        if (workflowName.length === 0) {
+            throw new Error(`Workflow plan at index ${index} is missing a valid workflowName. Provide workflowName when building workflows.`);
+        }
+        if (seenWorkflowNames.has(workflowName)) {
+            throw new Error(`Duplicate workflow name detected in bundle: '${workflowName}' at index ${index}. Workflow names must be unique.`);
+        }
+        seenWorkflowNames.add(workflowName);
+    });
+    const collection = collectWorkflowBuildResults(plans);
+    const activityBundle = await bundleActivitiesWithEsbuild(collection.activities, options === null || options === void 0 ? void 0 : options.activityBundle);
+    const filename = (_a = options === null || options === void 0 ? void 0 : options.filename) !== null && _a !== void 0 ? _a : createBundleFilename(collection.workflows);
+    const code = await buildWorkflowBundleCode(collection.workflows, filename);
+    return {
+        activityBundle,
+        workflowBundle: { code },
+    };
+}
+function createBundleFilename(workflows) {
+    const baseName = workflows
+        .map((workflow) => workflow.workflowName)
+        .filter((name) => typeof name === 'string' && name.trim().length > 0)
+        .join('-')
+        .trim();
+    const sanitizedBase = sanitizeFilenameBase(baseName.length > 0 ? baseName : 'workflow');
+    const randomSuffix = Math.random().toString(36).slice(2, 8);
+    return `${sanitizedBase}-${randomSuffix}.workflow.js`;
+}
+function sanitizeFilenameBase(candidate) {
+    const sanitized = candidate.replace(/[^A-Za-z0-9_.-]/g, '_');
+    if (sanitized.length === 0 || /^_+$/.test(sanitized)) {
+        return 'workflow';
+    }
+    return sanitized;
+}
+async function bundleActivitiesWithEsbuild(bundles, options = {}) {
+    var _a, _b, _c, _d, _e;
+    const entrypoints = normalizeActivityEntrypoints((_a = options.entrypoints) !== null && _a !== void 0 ? _a : deriveActivityEntrypoints(bundles));
+    if (entrypoints.length === 0) {
+        throw new Error('bundleActivities requires at least one entrypoint.');
+    }
+    const filename = ((_b = options.filename) !== null && _b !== void 0 ? _b : 'activities.bundle.cjs').trim();
+    const externals = new Set(['@primero.ai/temporal-graph-tools', '@swc/*']);
+    ((_c = options.externals) !== null && _c !== void 0 ? _c : []).forEach((name) => {
+        if (typeof name === 'string' && name.trim().length > 0) {
+            externals.add(name.trim());
+        }
+    });
+    const entrySource = createActivitiesEntrySource(entrypoints);
+    const esbuild = await loadEsbuild();
+    const buildResult = await esbuild.build({
+        stdin: {
+            contents: entrySource,
+            resolveDir: process.cwd(),
+            sourcefile: filename,
+            loader: 'ts',
+        },
+        bundle: true,
+        platform: 'node',
+        format: 'cjs',
+        target: ['node18'],
+        absWorkingDir: process.cwd(),
+        outfile: filename,
+        write: false,
+        sourcemap: 'inline',
+        external: Array.from(externals),
+    });
+    const jsFile = (_d = buildResult.outputFiles) === null || _d === void 0 ? void 0 : _d.find((file) => file.path.endsWith('.js') || file.path.endsWith('.mjs') || file.path.endsWith('.cjs'));
+    const mapFile = (_e = buildResult.outputFiles) === null || _e === void 0 ? void 0 : _e.find((file) => file.path.endsWith('.js.map') ||
+        file.path.endsWith('.mjs.map') ||
+        file.path.endsWith('.cjs.map'));
+    if (!jsFile) {
+        throw new Error('Failed to generate activities bundle.');
+    }
+    return {
+        filename,
+        code: jsFile.text,
+        ...(mapFile ? { map: mapFile.text } : {}),
+    };
+}
+function normalizeActivityEntrypoints(entrypoints) {
+    return entrypoints
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0)
+        .map((entry) => (isAbsolute(entry) ? entry : resolve(process.cwd(), entry)));
+}
+function deriveActivityEntrypoints(bundles) {
+    const paths = new Set();
+    Object.values(bundles).forEach((bundle) => {
+        if (bundle === null || bundle === void 0 ? void 0 : bundle.sourceFile) {
+            paths.add(bundle.sourceFile);
+        }
+    });
+    if (paths.size === 0) {
+        throw new Error('Unable to derive activity sources automatically. Provide activityBundle.entrypoints.');
+    }
+    return Array.from(paths);
+}
+function createActivitiesEntrySource(entrypoints) {
+    const imports = entrypoints
+        .map((entry, index) => `import * as module${index} from ${JSON.stringify(entry)};`)
+        .join('\n');
+    const moduleRefs = entrypoints.map((_, index) => `module${index}`).join(', ');
+    return `
+${imports}
+
+const merged = {} as Record<string, unknown>;
+for (const mod of [${moduleRefs}]) {
+  if (!mod || typeof mod !== 'object') {
+    continue;
+  }
+  const candidate = (mod as { activities?: unknown }).activities;
+  if (candidate && typeof candidate === 'object') {
+    Object.assign(merged, candidate as Record<string, unknown>);
+    continue;
+  }
+  for (const [key, value] of Object.entries(mod)) {
+    if (key === 'default' || key === '__esModule') {
+      continue;
+    }
+    if (value && typeof value === 'object' && 'activity' in (value as { activity?: unknown })) {
+      const activity = (value as { activity?: unknown }).activity;
+      if (typeof activity === 'function') {
+        merged[key] = activity;
+        continue;
+      }
+    }
+    if (typeof value === 'function') {
+      merged[key] = value;
+    }
+  }
+}
+
+export const activities = merged;
+`.trimStart();
+}
+function ensureActivityInlineSourceMap(code, map) {
+    const marker = '//# sourceMappingURL=data:application/json;base64,';
+    if (!map || code.includes(marker)) {
+        return code;
+    }
+    const base64 = Buffer.from(map, 'utf8').toString('base64');
+    return `${code}\n${marker}${base64}`;
+}
+function isActivityImplementations(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    return Object.values(value).every((entry) => typeof entry === 'function');
+}

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types.js';
+export { WorkflowBuilder, createWorkflowBuilder } from './workflow/builder.js';
+export * from './workflow-bundler.js';
+export { collectWorkflowBuildResults } from './workflow/collection.js';
+export * from './bundler.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AAC9E,cAAc,uBAAuB,CAAA;AACrC,OAAO,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAA;AACtE,cAAc,cAAc,CAAA"}

package/dist/src/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export { WorkflowBuilder, createWorkflowBuilder } from './workflow/builder.js';
+export * from './workflow-bundler.js';
+export { collectWorkflowBuildResults } from './workflow/collection.js';
+export * from './bundler.js';