@primero-ai/temporal-graph-tools 1.0.0 → 1.0.2

package/README.md

@@ -1,4 +1,4 @@
-# @segundoai/temporal-graph-tools
+# @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
@@ -21,11 +21,11 @@ hand-writing workflow files.
 ## Installation
 
 ```bash
-npm install @segundoai/temporal-graph-tools
+npm install @primero-ai/temporal-graph-tools
 # or
-pnpm add @segundoai/temporal-graph-tools
+pnpm add @primero-ai/temporal-graph-tools
 # or
-bun add @segundoai/temporal-graph-tools
+bun add @primero-ai/temporal-graph-tools
 ```
 
 The package targets Node.js 18+ and ships ESM builds.
@@ -37,7 +37,7 @@ import {
   bundleWorkflows,
   createActivity,
   createWorkflowBuilder,
-} from '@segundoai/temporal-graph-tools'
+} from '@primero-ai/temporal-graph-tools'
 
 type FetchUserInput = { userId: string }
 type FetchUserOutput = { profile: { id: string; name: string } }

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":"AACA,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,CA4BlC;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,202 @@
+import { isAbsolute, resolve } from 'node:path';
+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 encoded = Buffer.from(source, 'utf8').toString('base64');
+    const moduleUrl = `data:text/javascript;base64,${encoded}`;
+    const moduleNamespace = (await import(moduleUrl));
+    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.mjs').trim();
+    const externals = new Set(['@primero-ai/temporal-graph-tools']);
+    ((_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: 'esm',
+        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'));
+    const mapFile = (_e = buildResult.outputFiles) === null || _e === void 0 ? void 0 : _e.find((file) => file.path.endsWith('.js.map') || file.path.endsWith('.mjs.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';

package/dist/src/types.d.ts

@@ -0,0 +1,45 @@
+import type { ActivityOptions } from '@temporalio/workflow';
+export type CreateActivity<TInput = unknown, TOutput = unknown> = (input: TInput) => TOutput | Promise<TOutput>;
+export type ActivityConfig<Id extends string = string> = ActivityOptions & {
+    id?: Id;
+};
+export declare const ACTIVITY_SOURCE_SYMBOL: unique symbol;
+export type ConfiguredActivityReference<TInput = unknown, TOutput = unknown, Id extends string = string> = {
+    activity: CreateActivity<TInput, TOutput>;
+    config: ActivityConfig<Id>;
+};
+export type ActivityReference<TInput = unknown, TOutput = unknown, Id extends string = string> = CreateActivity<TInput, TOutput> | ConfiguredActivityReference<TInput, TOutput, Id>;
+export declare function getActivitySourceFile(activity: CreateActivity<unknown, unknown>): string | undefined;
+export type ActivityBundle = {
+    implementation: CreateActivity<unknown, unknown>;
+    config?: ActivityConfig;
+    name?: string;
+    sourceFile?: string;
+};
+export type WorkflowSourceArtifact = {
+    workflowName: string;
+    workflowSource: string;
+};
+export type WorkflowBuildResult = WorkflowSourceArtifact & {
+    activities: Record<string, ActivityBundle>;
+};
+export type TemporalWorkflowBuildOptions = {
+    workflowName: string;
+    activitiesImportPath?: string;
+    proxyOptions?: ActivityOptions | string;
+};
+export declare function createActivity<TInput, TOutput>(activity: CreateActivity<TInput, TOutput>): CreateActivity<TInput, TOutput>;
+export declare function createActivity<TInput, TOutput, Id extends string>(activity: CreateActivity<TInput, TOutput>, config: ActivityConfig<Id>): ConfiguredActivityReference<TInput, TOutput, Id>;
+type TupleToObject<Refs> = Refs extends readonly [infer Head, ...infer Tail] ? (Head extends ConfiguredActivityReference<never, infer Output, infer Id> ? {
+    [K in Id]: Output;
+} : Record<never, never>) & TupleToObject<Tail extends readonly ConfiguredActivityReference<never, unknown, string>[] ? Tail : []> : object;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+};
+export type ParallelOutputs<TInput, Refs extends readonly ConfiguredActivityReference<TInput, unknown, string>[]> = Simplify<TupleToObject<Refs>>;
+export type WorkflowCollectionBuildResult = {
+    workflows: WorkflowSourceArtifact[];
+    activities: Record<string, ActivityBundle>;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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"}

package/dist/src/types.js

@@ -0,0 +1,64 @@
+import { fileURLToPath } from 'node:url';
+const ACTIVITY_SELF_SEGMENT = '/temporal-graph-tools/';
+export const ACTIVITY_SOURCE_SYMBOL = Symbol.for('@primero-ai/temporal-graph-tools/activity-source');
+function captureActivitySource() {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const originalPrepare = Error.prepareStackTrace;
+    try {
+        Error.prepareStackTrace = (_, structuredStackTrace) => structuredStackTrace;
+        const error = new Error();
+        Error.captureStackTrace(error, createActivity);
+        const callsites = error.stack;
+        if (!callsites) {
+            return undefined;
+        }
+        for (const site of callsites) {
+            const fileName = typeof site.getFileName === 'function' ? site.getFileName.call(site) : undefined;
+            const scriptName = typeof site.getScriptNameOrSourceURL === 'function'
+                ? site.getScriptNameOrSourceURL.call(site)
+                : undefined;
+            const resolved = fileName !== null && fileName !== void 0 ? fileName : scriptName;
+            if (!resolved) {
+                continue;
+            }
+            const normalized = resolved.startsWith('file:') ? fileURLToPath(resolved) : resolved;
+            const comparable = normalized.replace(/\\/g, '/').replace(/^file:\/\//, '');
+            if (comparable.includes(ACTIVITY_SELF_SEGMENT)) {
+                continue;
+            }
+            return normalized;
+        }
+        return undefined;
+    }
+    finally {
+        Error.prepareStackTrace = originalPrepare;
+    }
+}
+function recordActivityMetadata(activity) {
+    if (Reflect.get(activity, ACTIVITY_SOURCE_SYMBOL)) {
+        return;
+    }
+    const metadata = {
+        sourceFile: captureActivitySource(),
+    };
+    Reflect.defineProperty(activity, ACTIVITY_SOURCE_SYMBOL, {
+        value: metadata,
+        configurable: false,
+        enumerable: false,
+        writable: false,
+    });
+}
+export function getActivitySourceFile(activity) {
+    const metadata = Reflect.get(activity, ACTIVITY_SOURCE_SYMBOL);
+    return metadata === null || metadata === void 0 ? void 0 : metadata.sourceFile;
+}
+export function createActivity(activity, config) {
+    recordActivityMetadata(activity);
+    if (!config) {
+        return activity;
+    }
+    return {
+        activity,
+        config,
+    };
+}

package/dist/src/utils/deep-equal.d.ts

@@ -0,0 +1,2 @@
+export declare function deepEqual(left: unknown, right: unknown): boolean;
+//# sourceMappingURL=deep-equal.d.ts.map

package/dist/src/utils/deep-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-equal.d.ts","sourceRoot":"","sources":["../../../src/utils/deep-equal.ts"],"names":[],"mappings":"AAWA,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CA2DhE"}

package/dist/src/utils/deep-equal.js

@@ -0,0 +1,54 @@
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+export function deepEqual(left, right) {
+    if (Object.is(left, right)) {
+        return true;
+    }
+    if (left === null || right === null) {
+        return left === right;
+    }
+    if (left instanceof Date && right instanceof Date) {
+        return left.getTime() === right.getTime();
+    }
+    if (left instanceof RegExp && right instanceof RegExp) {
+        return left.source === right.source && left.flags === right.flags;
+    }
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+            return false;
+        }
+        for (let index = 0; index < left.length; index += 1) {
+            if (!deepEqual(left[index], right[index])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (isPlainObject(left) || isPlainObject(right)) {
+        if (!isPlainObject(left) || !isPlainObject(right)) {
+            return false;
+        }
+        const leftEntries = Object.entries(left).filter(([, value]) => value !== undefined);
+        const rightEntries = Object.entries(right).filter(([, value]) => value !== undefined);
+        if (leftEntries.length !== rightEntries.length) {
+            return false;
+        }
+        const sortedLeft = leftEntries.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+        const sortedRight = rightEntries.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+        for (let index = 0; index < sortedLeft.length; index += 1) {
+            const [leftKey, leftValue] = sortedLeft[index];
+            const [rightKey, rightValue] = sortedRight[index];
+            if (leftKey !== rightKey || !deepEqual(leftValue, rightValue)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}

package/dist/src/workflow/builder.d.ts

@@ -0,0 +1,27 @@
+import type { ActivityConfig, ActivityReference, ConfiguredActivityReference, ParallelOutputs, TemporalWorkflowBuildOptions, WorkflowBuildResult } from '../types.js';
+export declare class WorkflowBuilder<TCurrentOutput> {
+    private readonly activityBundles;
+    private readonly plan;
+    private readonly baseOptions;
+    private started;
+    private autoIncrement;
+    constructor(options: TemporalWorkflowBuildOptions);
+    then<TNextOutput>(reference: ActivityReference<TCurrentOutput, TNextOutput>, config?: ActivityConfig): WorkflowBuilder<TNextOutput>;
+    parallel<const References extends readonly ConfiguredActivityReference<TCurrentOutput, unknown, string>[]>(references: References): WorkflowBuilder<ParallelOutputs<TCurrentOutput, References>>;
+    commit(): WorkflowBuildResult;
+    private normalizeActivityReference;
+    private registerActivity;
+    private createActivityBundle;
+    private prepareConfig;
+    private generateTemporalWorkflowSource;
+    private formatProxyOptions;
+    private ensureUniqueIdentifier;
+    private formatPropertyKey;
+    private assignActivityKey;
+    private normalizeActivityKey;
+    private activityBundlesEqual;
+    private deriveActivityKey;
+    private assertStarted;
+}
+export declare const createWorkflowBuilder: <TInitialInput>(options: TemporalWorkflowBuildOptions) => WorkflowBuilder<TInitialInput>;
+//# sourceMappingURL=builder.d.ts.map

package/dist/src/workflow/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../src/workflow/builder.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,cAAc,EACd,iBAAiB,EACjB,2BAA2B,EAE3B,eAAe,EACf,4BAA4B,EAC5B,mBAAmB,EACpB,MAAM,aAAa,CAAA;AAepB,qBAAa,eAAe,CAAC,cAAc;IACzC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAqC;IAErE,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAc;IAEnC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA8B;IAE1D,OAAO,CAAC,OAAO,CAAQ;IAEvB,OAAO,CAAC,aAAa,CAAI;gBAEb,OAAO,EAAE,4BAA4B;IAejD,IAAI,CAAC,WAAW,EACd,SAAS,EAAE,iBAAiB,CAAC,cAAc,EAAE,WAAW,CAAC,EACzD,MAAM,CAAC,EAAE,cAAc,GACtB,eAAe,CAAC,WAAW,CAAC;IAU/B,QAAQ,CACN,KAAK,CAAC,UAAU,SAAS,SAAS,2BAA2B,CAC3D,cAAc,EACd,OAAO,EACP,MAAM,CACP,EAAE,EACH,UAAU,EAAE,UAAU,GAAG,eAAe,CAAC,eAAe,CAAC,cAAc,EAAE,UAAU,CAAC,CAAC;IAiBvF,MAAM,IAAI,mBAAmB;IAgB7B,OAAO,CAAC,0BAA0B;IAiBlC,OAAO,CAAC,gBAAgB;IAOxB,OAAO,CAAC,oBAAoB;IAa5B,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,8BAA8B;IAwFtC,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,sBAAsB;IAqC9B,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,iBAAiB;IAkCzB,OAAO,CAAC,oBAAoB;IAU5B,OAAO,CAAC,oBAAoB;IAO5B,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,aAAa;CAKtB;AAED,eAAO,MAAM,qBAAqB,GAAI,aAAa,EACjD,SAAS,4BAA4B,KACpC,eAAe,CAAC,aAAa,CAE/B,CAAA"}

package/dist/src/workflow/builder.js

@@ -0,0 +1,230 @@
+import { getActivitySourceFile } from '../types.js';
+import { deepEqual } from '../utils/deep-equal.js';
+export class WorkflowBuilder {
+    constructor(options) {
+        this.activityBundles = {};
+        this.plan = [];
+        this.started = false;
+        this.autoIncrement = 0;
+        const workflowName = options === null || options === void 0 ? void 0 : options.workflowName;
+        if (typeof workflowName !== 'string' || workflowName.trim().length === 0) {
+            throw new Error('createWorkflowBuilder requires options.workflowName to be a non-empty string.');
+        }
+        this.baseOptions = {
+            ...options,
+            workflowName: workflowName.trim(),
+        };
+    }
+    then(reference, config) {
+        const entry = this.normalizeActivityReference(reference, config);
+        const normalized = this.registerActivity(entry);
+        this.plan.push({ type: 'step', step: normalized });
+        this.started = true;
+        return this;
+    }
+    parallel(references) {
+        this.assertStarted('parallel');
+        if (!Array.isArray(references) || references.length === 0) {
+            throw new Error('parallel() requires at least one activity reference.');
+        }
+        const normalized = references.map((ref) => this.registerActivity(this.normalizeActivityReference(ref)));
+        this.plan.push({ type: 'parallel', steps: normalized });
+        this.started = true;
+        return this;
+    }
+    commit() {
+        if (!this.started) {
+            throw new Error('Cannot build a workflow without any steps. Call then() before build().');
+        }
+        const { source: workflowSource, workflowName } = this.generateTemporalWorkflowSource({
+            ...this.baseOptions,
+        });
+        return {
+            workflowName,
+            activities: { ...this.activityBundles },
+            workflowSource,
+        };
+    }
+    normalizeActivityReference(reference, inlineConfig) {
+        var _a;
+        if (typeof reference === 'function') {
+            return {
+                activity: reference,
+                config: { ...(inlineConfig !== null && inlineConfig !== void 0 ? inlineConfig : {}) },
+            };
+        }
+        return {
+            activity: reference.activity,
+            config: { ...((_a = reference.config) !== null && _a !== void 0 ? _a : {}), ...(inlineConfig !== null && inlineConfig !== void 0 ? inlineConfig : {}) },
+        };
+    }
+    registerActivity(entry) {
+        var _a;
+        const baseKey = (_a = entry.config.id) !== null && _a !== void 0 ? _a : this.deriveActivityKey(entry.activity);
+        const key = this.assignActivityKey(baseKey, entry);
+        return { key };
+    }
+    createActivityBundle(entry, key) {
+        var _a;
+        const config = this.prepareConfig(entry.config);
+        const name = (_a = entry.activity.name) === null || _a === void 0 ? void 0 : _a.trim();
+        const sourceFile = getActivitySourceFile(entry.activity);
+        return {
+            implementation: entry.activity,
+            ...(name ? { name } : { name: key }),
+            ...(config ? { config } : {}),
+            ...(sourceFile ? { sourceFile } : {}),
+        };
+    }
+    prepareConfig(config) {
+        const entries = Object.entries(config).filter(([, value]) => value !== undefined);
+        if (entries.length === 0) {
+            return undefined;
+        }
+        return Object.fromEntries(entries);
+    }
+    generateTemporalWorkflowSource(options) {
+        var _a;
+        const topLevelIdentifiers = new Set();
+        const workflowName = this.ensureUniqueIdentifier(options.workflowName, options.workflowName, topLevelIdentifiers);
+        const activitiesIdentifier = this.ensureUniqueIdentifier('activities', 'activities', topLevelIdentifiers);
+        const activitiesImportPath = (_a = options.activitiesImportPath) !== null && _a !== void 0 ? _a : './activities';
+        const proxyOptionsLiteral = this.formatProxyOptions(options.proxyOptions);
+        const lines = [];
+        lines.push(`import { proxyActivities } from '@temporalio/workflow'`);
+        lines.push(`import type { Activities } from '${activitiesImportPath}'`);
+        lines.push('');
+        lines.push(`const ${activitiesIdentifier} = proxyActivities<Activities>(${proxyOptionsLiteral})`);
+        lines.push('');
+        lines.push(`export async function ${workflowName}(input: unknown): Promise<unknown> {`);
+        let currentValue = 'input';
+        const localIdentifiers = new Set(['input']);
+        this.plan.forEach((stage, stageIndex) => {
+            if (stage.type === 'step') {
+                const resultVar = this.ensureUniqueIdentifier(undefined, `step${stageIndex}`, localIdentifiers);
+                lines.push(`  const ${resultVar} = await ${activitiesIdentifier}.${stage.step.key}(${currentValue});`);
+                lines.push('');
+                currentValue = resultVar;
+                return;
+            }
+            const individualVars = stage.steps.map((step, index) => this.ensureUniqueIdentifier(undefined, `parallel${stageIndex}_${index}`, localIdentifiers));
+            lines.push(`  const [${individualVars.join(', ')}] = await Promise.all([`);
+            stage.steps.forEach((step, index) => {
+                const suffix = index === stage.steps.length - 1 ? '' : ',';
+                lines.push(`    ${activitiesIdentifier}.${step.key}(${currentValue})${suffix}`);
+            });
+            lines.push('  ])');
+            const aggregateVar = this.ensureUniqueIdentifier(undefined, `parallel${stageIndex}`, localIdentifiers);
+            lines.push(`  const ${aggregateVar} = {`);
+            stage.steps.forEach((step, index) => {
+                const propertyKey = this.formatPropertyKey(step.key);
+                lines.push(`    ${propertyKey}: ${individualVars[index]},`);
+            });
+            lines.push('  }');
+            lines.push('');
+            currentValue = aggregateVar;
+        });
+        lines.push(`  return ${currentValue};`);
+        lines.push('}');
+        return {
+            workflowName,
+            source: lines.join('\n'),
+        };
+    }
+    formatProxyOptions(options) {
+        if (typeof options === 'string' && options.trim().length > 0) {
+            return options.trim();
+        }
+        if (options === undefined) {
+            return `{
+  startToCloseTimeout: '1 minute',
+}`;
+        }
+        return JSON.stringify(options, null, 2);
+    }
+    ensureUniqueIdentifier(raw, fallback, used) {
+        const fallbackValue = fallback || 'value';
+        const base = raw && raw.trim().length > 0 ? raw.trim() : fallbackValue;
+        let sanitized = base.replace(/[^A-Za-z0-9_]/g, '_');
+        if (!/^[A-Za-z_]/.test(sanitized)) {
+            sanitized = `_${sanitized}`;
+        }
+        if (sanitized.length === 0 || /^_+$/.test(sanitized)) {
+            sanitized = fallbackValue.replace(/[^A-Za-z0-9_]/g, '_');
+            if (!/^[A-Za-z_]/.test(sanitized)) {
+                sanitized = `_${sanitized}`;
+            }
+            if (sanitized.length === 0 || /^_+$/.test(sanitized)) {
+                sanitized = 'value';
+            }
+        }
+        let candidate = sanitized;
+        let counter = 1;
+        while (used.has(candidate)) {
+            candidate = `${sanitized}_${counter++}`;
+        }
+        used.add(candidate);
+        return candidate;
+    }
+    formatPropertyKey(key) {
+        if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+            return key;
+        }
+        return `'${key.replace(/'/g, "\\'")}'`;
+    }
+    assignActivityKey(candidate, entry) {
+        const normalized = this.normalizeActivityKey(candidate);
+        const existing = this.activityBundles[normalized];
+        const initialBundle = this.createActivityBundle(entry, normalized);
+        if (!existing) {
+            this.activityBundles[normalized] = initialBundle;
+            return normalized;
+        }
+        if (this.activityBundlesEqual(existing, initialBundle)) {
+            return normalized;
+        }
+        let counter = 1;
+        while (true) {
+            const nextKey = `${normalized}_${counter++}`;
+            const nextBundle = this.createActivityBundle(entry, nextKey);
+            const existingBundle = this.activityBundles[nextKey];
+            if (!existingBundle) {
+                this.activityBundles[nextKey] = nextBundle;
+                return nextKey;
+            }
+            if (this.activityBundlesEqual(existingBundle, nextBundle)) {
+                return nextKey;
+            }
+        }
+    }
+    normalizeActivityKey(candidate) {
+        const key = candidate.trim();
+        if (key.length === 0) {
+            throw new Error('Activity keys must be non-empty strings.');
+        }
+        return key;
+    }
+    activityBundlesEqual(existing, candidate) {
+        var _a, _b, _c, _d;
+        const configsEqual = deepEqual((_a = existing.config) !== null && _a !== void 0 ? _a : undefined, (_b = candidate.config) !== null && _b !== void 0 ? _b : undefined);
+        const namesEqual = ((_c = existing.name) !== null && _c !== void 0 ? _c : null) === ((_d = candidate.name) !== null && _d !== void 0 ? _d : null);
+        return existing.implementation === candidate.implementation && configsEqual && namesEqual;
+    }
+    deriveActivityKey(activity) {
+        var _a;
+        const candidate = (_a = activity.name) === null || _a === void 0 ? void 0 : _a.trim();
+        if (candidate) {
+            return candidate;
+        }
+        this.autoIncrement += 1;
+        return `step_${this.autoIncrement}`;
+    }
+    assertStarted(method) {
+        if (!this.started) {
+            throw new Error(`Cannot call ${method}() before defining the first step.`);
+        }
+    }
+}
+export const createWorkflowBuilder = (options) => {
+    return new WorkflowBuilder(options);
+};

package/dist/src/workflow/collection.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowBuildResult, WorkflowCollectionBuildResult } from '../types.js';
+export declare function collectWorkflowBuildResults(results: readonly WorkflowBuildResult[]): WorkflowCollectionBuildResult;
+//# sourceMappingURL=collection.d.ts.map

package/dist/src/workflow/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../src/workflow/collection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,mBAAmB,EACnB,6BAA6B,EAE9B,MAAM,aAAa,CAAA;AAGpB,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,SAAS,mBAAmB,EAAE,GACtC,6BAA6B,CAmD/B"}

package/dist/src/workflow/collection.js

@@ -0,0 +1,39 @@
+import { deepEqual } from '../utils/deep-equal.js';
+export function collectWorkflowBuildResults(results) {
+    if (results.length === 0) {
+        throw new Error('collectWorkflowBuildResults requires at least one workflow build result.');
+    }
+    const workflows = [];
+    const activities = {};
+    const workflowNames = new Set();
+    results.forEach((result, index) => {
+        if (workflowNames.has(result.workflowName)) {
+            throw new Error(`Duplicate workflow name detected at index ${index}: '${result.workflowName}'. Workflow names must be unique.`);
+        }
+        workflowNames.add(result.workflowName);
+        workflows.push({
+            workflowName: result.workflowName,
+            workflowSource: result.workflowSource,
+        });
+        Object.entries(result.activities).forEach(([key, bundle]) => {
+            var _a, _b, _c, _d, _e, _f;
+            const existing = activities[key];
+            if (!existing) {
+                activities[key] = bundle;
+                return;
+            }
+            const configMatches = deepEqual((_a = existing.config) !== null && _a !== void 0 ? _a : undefined, (_b = bundle.config) !== null && _b !== void 0 ? _b : undefined);
+            const sourceMatches = ((_c = existing.sourceFile) !== null && _c !== void 0 ? _c : null) === ((_d = bundle.sourceFile) !== null && _d !== void 0 ? _d : null);
+            if (existing.implementation !== bundle.implementation ||
+                !configMatches ||
+                ((_e = existing.name) !== null && _e !== void 0 ? _e : null) !== ((_f = bundle.name) !== null && _f !== void 0 ? _f : null) ||
+                !sourceMatches) {
+                throw new Error(`Activity '${key}' is defined multiple times with conflicting implementations.`);
+            }
+        });
+    });
+    return {
+        workflows,
+        activities,
+    };
+}

package/dist/src/workflow-bundler.d.ts

@@ -0,0 +1,6 @@
+import type { WorkflowBuildResult, WorkflowSourceArtifact } from './types.js';
+export type ActivityImplementations = Record<string, (...args: unknown[]) => unknown>;
+export type ActivityBundles = WorkflowBuildResult['activities'];
+export declare function instantiateActivities(bundles: ActivityBundles): Promise<ActivityImplementations>;
+export declare function buildWorkflowBundleCode(workflow: string | WorkflowSourceArtifact | WorkflowSourceArtifact[], filename?: string): Promise<string>;
+//# sourceMappingURL=workflow-bundler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-bundler.d.ts","sourceRoot":"","sources":["../../src/workflow-bundler.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAE7E,MAAM,MAAM,uBAAuB,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,CAAA;AAErF,MAAM,MAAM,eAAe,GAAG,mBAAmB,CAAC,YAAY,CAAC,CAAA;AAE/D,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,uBAAuB,CAAC,CAQlC;AAED,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,GAAG,sBAAsB,GAAG,sBAAsB,EAAE,EACpE,QAAQ,SAAgB,GACvB,OAAO,CAAC,MAAM,CAAC,CAMjB"}

package/dist/src/workflow-bundler.js

@@ -0,0 +1,163 @@
+import * as realFS from 'node:fs';
+import path, { basename } from 'node:path';
+import { WorkflowCodeBundler, } from '@temporalio/worker/lib/workflow/bundler.js';
+import { createFsFromVolume, Volume } from 'memfs';
+import { Union } from 'unionfs';
+export async function instantiateActivities(bundles) {
+    const implementations = {};
+    Object.entries(bundles).forEach(([key, bundle]) => {
+        implementations[key] = bundle.implementation;
+    });
+    return implementations;
+}
+export async function buildWorkflowBundleCode(workflow, filename = 'workflow.js') {
+    const workflows = normalizeWorkflows(workflow);
+    const bundler = new VirtualWorkflowCodeBundler(workflows);
+    const { code } = await bundler.createBundle();
+    return ensureInlineSourceMap(code, filename);
+}
+function normalizeWorkflows(workflow) {
+    if (Array.isArray(workflow)) {
+        if (workflow.length === 0) {
+            throw new Error('buildWorkflowBundleCode requires at least one workflow source.');
+        }
+        return workflow;
+    }
+    if (typeof workflow === 'string') {
+        return [
+            {
+                workflowName: 'workflow',
+                workflowSource: workflow,
+            },
+        ];
+    }
+    return [workflow];
+}
+function sanitizeFileName(candidate) {
+    const base = candidate.trim().replace(/[^A-Za-z0-9_.-]/g, '_');
+    if (base.length > 0 && !/^_+$/.test(base)) {
+        return `${base}.ts`;
+    }
+    return 'workflow.ts';
+}
+function ensureUniqueFileName(baseName, used) {
+    let candidate = baseName;
+    let counter = 1;
+    while (used.has(candidate)) {
+        const dotIndex = baseName.lastIndexOf('.');
+        const prefix = dotIndex > 0 ? baseName.slice(0, dotIndex) : baseName;
+        const extension = dotIndex > 0 ? baseName.slice(dotIndex) : '';
+        candidate = `${prefix}_${counter++}${extension}`;
+    }
+    used.add(candidate);
+    return candidate;
+}
+function stripExtension(fileName) {
+    const parsed = basename(fileName);
+    if (parsed.endsWith('.ts')) {
+        return parsed.slice(0, -3);
+    }
+    return parsed;
+}
+function ensureInlineSourceMap(code, filename) {
+    const marker = '//# sourceMappingURL=data:application/json;base64,';
+    if (!code.includes(marker)) {
+        const stubMap = {
+            version: 3,
+            file: filename,
+            sources: ['workflow.ts'],
+            sourcesContent: [code],
+            names: [],
+            mappings: '',
+        };
+        const base64 = Buffer.from(JSON.stringify(stubMap)).toString('base64');
+        return `${code}\n${marker}${base64}`;
+    }
+    const markerIndex = code.lastIndexOf(marker);
+    const base64 = code.slice(markerIndex + marker.length).trim();
+    const decoded = Buffer.from(base64, 'base64').toString('utf8');
+    const sourceMap = JSON.parse(decoded);
+    if (!sourceMap.file || sourceMap.file.length === 0) {
+        sourceMap.file = filename;
+    }
+    if (!Array.isArray(sourceMap.sources) || sourceMap.sources.length === 0) {
+        sourceMap.sources = [filename];
+    }
+    const updatedBase64 = Buffer.from(JSON.stringify(sourceMap)).toString('base64');
+    return code.slice(0, markerIndex + marker.length) + updatedBase64;
+}
+class VirtualWorkflowCodeBundler extends WorkflowCodeBundler {
+    constructor(workflows) {
+        const entry = path.join(VirtualWorkflowCodeBundler.virtualRoot, 'index.ts');
+        super({ workflowsPath: entry });
+        this.workflows = workflows;
+        this.virtualEntrypoint = entry;
+    }
+    async createBundle() {
+        const volume = new Volume();
+        const unionFs = new Union();
+        this.populateVirtualWorkflows(volume);
+        const readdir = Object.assign((...params) => {
+            const args = [...params];
+            const callbackCandidate = args.pop();
+            if (typeof callbackCandidate !== 'function') {
+                return realFS.readdir(...params);
+            }
+            const callback = callbackCandidate;
+            const wrappedCallback = (err, files) => {
+                if (err !== null) {
+                    callback(err, files);
+                    return;
+                }
+                if (!Array.isArray(files)) {
+                    callback(null, files);
+                    return;
+                }
+                if (!files.every((entry) => typeof entry === 'string')) {
+                    callback(null, files);
+                    return;
+                }
+                const typedFiles = files;
+                const filtered = typedFiles.filter((file) => /\.[jt]s$/.test(path.extname(file)) && !file.endsWith('.d.ts'));
+                callback(null, filtered);
+            };
+            const patchedArgs = [...args, wrappedCallback];
+            return realFS.readdir(...patchedArgs);
+        }, { __promisify__: realFS.readdir.__promisify__ });
+        const memoryFs = createFsFromVolume(volume);
+        const layeredFs = { ...realFS, readdir };
+        unionFs.use(memoryFs);
+        unionFs.use(layeredFs);
+        const distDir = '/dist';
+        const entrypointPath = this.makeEntrypointPath(unionFs, this.virtualEntrypoint);
+        this.genEntrypoint(volume, entrypointPath);
+        const bundleFilePath = await this.bundle(unionFs, memoryFs, entrypointPath, distDir);
+        let code = memoryFs.readFileSync(bundleFilePath, 'utf8');
+        code = code.replace('var __webpack_module_cache__ = {}', 'var __webpack_module_cache__ = globalThis.__webpack_module_cache__');
+        const sizeInMb = `${(code.length / (1024 * 1024)).toFixed(2)}MB`;
+        this.logger.info('Workflow bundle created', { size: sizeInMb });
+        return {
+            sourceMap: 'deprecated: this is no longer in use\n',
+            code,
+        };
+    }
+    populateVirtualWorkflows(volume) {
+        const usedFileNames = new Set();
+        const moduleSpecifiers = [];
+        const baseDir = VirtualWorkflowCodeBundler.virtualRoot;
+        this.workflows.forEach((entry, index) => {
+            var _a;
+            const fileName = this.workflows.length === 1
+                ? 'workflow.ts'
+                : ensureUniqueFileName(sanitizeFileName((_a = entry.workflowName) !== null && _a !== void 0 ? _a : `workflow_${index}`), usedFileNames);
+            const filePath = path.join(baseDir, fileName);
+            volume.mkdirSync(path.dirname(filePath), { recursive: true });
+            volume.writeFileSync(filePath, `${entry.workflowSource}\n`);
+            moduleSpecifiers.push(`./${stripExtension(fileName)}`);
+        });
+        const entrySource = moduleSpecifiers.map((specifier) => `export * from '${specifier}'`).join('\n') + '\n';
+        volume.mkdirSync(path.dirname(this.virtualEntrypoint), { recursive: true });
+        volume.writeFileSync(this.virtualEntrypoint, entrySource);
+    }
+}
+VirtualWorkflowCodeBundler.virtualRoot = path.join(process.cwd(), '__temporal_virtual__', 'workflows');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primero-ai/temporal-graph-tools",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Utilities for working with DAG workflows.",
   "keywords": [],
   "homepage": "https://github.com/primero-ai/temporal-graph-tools#readme",