@primero.ai/temporal-graph-tools 1.0.0

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');