@diia-inhouse/workflow 2.9.13 → 2.10.0

package/dist/activities/index.d.ts

@@ -1 +1,2 @@
-import { buildActivitiesProxy } from "./proxy.js";
+import { ActivityOptions, LocalActivityOptions, RetryPolicy, buildActivitiesProxy } from "./proxy.js";
+export { ActivityOptions, LocalActivityOptions, RetryPolicy, buildActivitiesProxy };

package/dist/activities/index.js

@@ -1,2 +1,2 @@
-import "./proxy.js";
-export {};
+import { buildActivitiesProxy } from "./proxy.js";
+export { buildActivitiesProxy };

package/dist/activities/proxy.d.ts

@@ -1,10 +1,26 @@
-import { ActivityInterfaceFor, ActivityOptions, proxyLocalActivities } from "@temporalio/workflow";
+import { ActivityInterfaceFor, ActivityOptions, RetryPolicy, proxyLocalActivities } from "@temporalio/workflow";
 
 //#region src/activities/proxy.d.ts
 type ActivityClass<T> = T extends {
   prototype: infer P;
 } ? P : never;
-type LocalActivityOptions = Parameters<typeof proxyLocalActivities>[0];
+type TemporalLocalActivityOptions = Parameters<typeof proxyLocalActivities>[0];
+/**
+* Retry policy exposed by pkg-workflow.
+*
+* `nonRetryableErrorTypes` is intentionally omitted from Temporal's {@link TemporalRetryPolicy}:
+* services must not mark failures as non-retryable by error type through the activity proxy, so
+* removing the field here disables the ability to set it via {@link buildActivitiesProxy}.
+*/
+type RetryPolicy$1 = Omit<RetryPolicy, "nonRetryableErrorTypes">;
+/** Activity options exposed by pkg-workflow, without {@link RetryPolicy.nonRetryableErrorTypes}. */
+type ActivityOptions$1 = Omit<ActivityOptions, "retry"> & {
+  retry?: RetryPolicy$1;
+};
+/** Local activity options exposed by pkg-workflow, without {@link RetryPolicy.nonRetryableErrorTypes}. */
+type LocalActivityOptions = Omit<TemporalLocalActivityOptions, "retry"> & {
+  retry?: RetryPolicy$1;
+};
 /**
 * Enhances Temporal activities by prefixing method names with their class name.
 *
@@ -29,6 +45,6 @@ type LocalActivityOptions = Parameters<typeof proxyLocalActivities>[0];
 * }
 */
 declare function buildActivitiesProxy<TActivity extends Record<string, unknown>>(useLocalActivitiesProxy: true): { [K in keyof TActivity]: (options: LocalActivityOptions) => ActivityInterfaceFor<ActivityClass<TActivity[K]>> };
-declare function buildActivitiesProxy<TActivity extends Record<string, unknown>>(useLocalActivitiesProxy?: false): { [K in keyof TActivity]: (options: ActivityOptions) => ActivityInterfaceFor<ActivityClass<TActivity[K]>> };
+declare function buildActivitiesProxy<TActivity extends Record<string, unknown>>(useLocalActivitiesProxy?: false): { [K in keyof TActivity]: (options: ActivityOptions$1) => ActivityInterfaceFor<ActivityClass<TActivity[K]>> };
 //#endregion
-export { buildActivitiesProxy };
+export { ActivityOptions$1 as ActivityOptions, LocalActivityOptions, RetryPolicy$1 as RetryPolicy, buildActivitiesProxy };

package/dist/activities/proxy.js

@@ -5,10 +5,8 @@ function buildActivitiesProxy(useLocalActivitiesProxy = false) {
 		const activityWrapper = (options) => {
 			const activities = useLocalActivitiesProxy ? proxyLocalActivities(options) : proxyActivities(options);
 			return new Proxy({}, { get: function(_inner, prop) {
-				const activityFn = activities[`${activityType}.${prop}`];
-				return (...args) => {
-					return activityFn(...args);
-				};
+				const activityName = `${activityType}.${prop}`;
+				return activities[activityName];
 			} });
 		};
 		return activityWrapper;

package/dist/activity.d.ts

@@ -1,2 +1,2 @@
-import { ApplicationFailure, CancelledFailure, CompleteAsyncError, Context, Info as ActivityInfo, activityInfo, cancellationSignal, cancelled, heartbeat, log, sleep } from "@temporalio/activity";
-export { type ActivityInfo, ApplicationFailure, CancelledFailure, CompleteAsyncError, Context, activityInfo, cancellationSignal, cancelled, heartbeat, log, sleep };
+import { ApplicationFailure, CancelledFailure, CompleteAsyncError, Context, Info as ActivityInfo, activityInfo, cancellationDetails, cancellationSignal, cancelled, getClient, heartbeat, log, metricMeter, sleep } from "@temporalio/activity";
+export { type ActivityInfo, ApplicationFailure, CancelledFailure, CompleteAsyncError, Context, activityInfo, cancellationDetails, cancellationSignal, cancelled, getClient, heartbeat, log, metricMeter, sleep };

package/dist/activity.js

@@ -1,2 +1,2 @@
-import { ApplicationFailure, CancelledFailure, CompleteAsyncError, Context, activityInfo, cancellationSignal, cancelled, heartbeat, log, sleep } from "@temporalio/activity";
-export { ApplicationFailure, CancelledFailure, CompleteAsyncError, Context, activityInfo, cancellationSignal, cancelled, heartbeat, log, sleep };
+import { ApplicationFailure, CancelledFailure, CompleteAsyncError, Context, activityInfo, cancellationDetails, cancellationSignal, cancelled, getClient, heartbeat, log, metricMeter, sleep } from "@temporalio/activity";
+export { ApplicationFailure, CancelledFailure, CompleteAsyncError, Context, activityInfo, cancellationDetails, cancellationSignal, cancelled, getClient, heartbeat, log, metricMeter, sleep };

package/dist/cli/checkWorkflowDeterminism.js

@@ -116,6 +116,7 @@ var CheckWorkflowDeterminismCommand = class {
 						});
 						this.logger.warn(`⏰ Workflow ${outcome.workflowId} timed out`);
 						break;
+					default: break;
 				}
 				if (processed % 50 === 0) {
 					const report = reportBuilder.build();
@@ -213,6 +214,7 @@ var CheckWorkflowDeterminismCommand = class {
 				});
 				this.logger.warn(`⏰ Workflow ${workflowId} timed out after ${outcome.timeoutMs / 1e3}s — skipping`);
 				break;
+			default: break;
 		}
 	}
 	async fetchWorkflowHistory(client, workflowId) {

package/dist/cli/determinism/historyFiles.js

@@ -13,7 +13,7 @@ function collectHistoryFiles(dir) {
 	}
 	return files;
 }
-const TERMINAL_EVENT_TYPES = new Set([
+const TERMINAL_EVENT_TYPES = /* @__PURE__ */ new Set([
 	"EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED",
 	"EVENT_TYPE_WORKFLOW_EXECUTION_FAILED",
 	"EVENT_TYPE_WORKFLOW_EXECUTION_TIMED_OUT",
@@ -75,4 +75,4 @@ function loadHistoryEntries(historyDir, workflows, options = {}) {
 	};
 }
 //#endregion
-export { loadHistoryEntries };
+export { collectHistoryFiles, loadHistoryEntries, parseHistoryFile };

package/dist/cli/determinism/index.js

@@ -1,7 +1,7 @@
-import "./errorClassifier.js";
-import "./historyFiles.js";
-import "./report.js";
-import "./replayOptions.js";
-import "./replayExecutor.js";
-import "./reportPrinter.js";
-export {};
+import { isNewStepsAdded, isWorkflowNotFoundError } from "./errorClassifier.js";
+import { loadHistoryEntries } from "./historyFiles.js";
+import { DeterminismReportBuilder } from "./report.js";
+import { buildReplayOptions, resolveWorkflowsPath } from "./replayOptions.js";
+import { replayBatch, replaySingle } from "./replayExecutor.js";
+import { printReport } from "./reportPrinter.js";
+export { DeterminismReportBuilder, buildReplayOptions, isNewStepsAdded, isWorkflowNotFoundError, loadHistoryEntries, printReport, replayBatch, replaySingle, resolveWorkflowsPath };

package/dist/client.d.ts

@@ -1,3 +1,3 @@
 import { TemporalClient } from "./services/client.js";
-import { ActivityFailure, ApplicationFailure, CancelledFailure, ChildWorkflowFailure, Client, DAYS_OF_WEEK, DayOfWeek, MONTHS, Month, ProtoFailure, ScheduleOptions, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, WorkflowClient, WorkflowHandleWithFirstExecutionRunId } from "@temporalio/client";
-export { ActivityFailure, ApplicationFailure, CancelledFailure, ChildWorkflowFailure, Client, DAYS_OF_WEEK, type DayOfWeek, MONTHS, type Month, type ProtoFailure, type ScheduleOptions, ServerFailure, TemporalClient, TemporalFailure, TerminatedFailure, TimeoutFailure, WorkflowClient, type WorkflowHandleWithFirstExecutionRunId };
+import { ActivityClient, ActivityExecutionDescription, ActivityExecutionInfo, ActivityFailure, ActivityHandle, ActivityIdConflictPolicy, ActivityIdReusePolicy, ApplicationFailure, CancelledFailure, ChildWorkflowFailure, Client, ClientPlugin, ConnectionPlugin, CountActivityExecutions, DAYS_OF_WEEK, DayOfWeek, MONTHS, Month, ProtoFailure, ScheduleOptions, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, TypedActivityClient, WithStartWorkflowOperation, WorkflowClient, WorkflowHandleWithFirstExecutionRunId, WorkflowUpdateStage } from "@temporalio/client";
+export { ActivityClient, type ActivityExecutionDescription, type ActivityExecutionInfo, ActivityFailure, type ActivityHandle, ActivityIdConflictPolicy, ActivityIdReusePolicy, ApplicationFailure, CancelledFailure, ChildWorkflowFailure, Client, type ClientPlugin, type ConnectionPlugin, type CountActivityExecutions, DAYS_OF_WEEK, type DayOfWeek, MONTHS, type Month, type ProtoFailure, type ScheduleOptions, ServerFailure, TemporalClient, TemporalFailure, TerminatedFailure, TimeoutFailure, type TypedActivityClient, WithStartWorkflowOperation, WorkflowClient, type WorkflowHandleWithFirstExecutionRunId, WorkflowUpdateStage };

package/dist/client.js

@@ -1,3 +1,3 @@
 import { TemporalClient } from "./services/client.js";
-import { ActivityFailure, ApplicationFailure, CancelledFailure, ChildWorkflowFailure, Client, DAYS_OF_WEEK, MONTHS, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, WorkflowClient } from "@temporalio/client";
-export { ActivityFailure, ApplicationFailure, CancelledFailure, ChildWorkflowFailure, Client, DAYS_OF_WEEK, MONTHS, ServerFailure, TemporalClient, TemporalFailure, TerminatedFailure, TimeoutFailure, WorkflowClient };
+import { ActivityClient, ActivityFailure, ActivityIdConflictPolicy, ActivityIdReusePolicy, ApplicationFailure, CancelledFailure, ChildWorkflowFailure, Client, DAYS_OF_WEEK, MONTHS, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, WithStartWorkflowOperation, WorkflowClient, WorkflowUpdateStage } from "@temporalio/client";
+export { ActivityClient, ActivityFailure, ActivityIdConflictPolicy, ActivityIdReusePolicy, ApplicationFailure, CancelledFailure, ChildWorkflowFailure, Client, DAYS_OF_WEEK, MONTHS, ServerFailure, TemporalClient, TemporalFailure, TerminatedFailure, TimeoutFailure, WithStartWorkflowOperation, WorkflowClient, WorkflowUpdateStage };

package/dist/common.d.ts

@@ -1,2 +1,2 @@
-import { DataConverter, WorkflowExecutionAlreadyStartedError, arrayFromPayloads, cutoffStackTrace, defaultFailureConverter, ensureApplicationFailure, ensureTemporalFailure, extractWorkflowType, rootCause } from "@temporalio/common";
-export { type DataConverter, WorkflowExecutionAlreadyStartedError, arrayFromPayloads, cutoffStackTrace, defaultFailureConverter, ensureApplicationFailure, ensureTemporalFailure, extractWorkflowType, rootCause };
+import { ActivityCancellationDetails, ActivityCancellationDetailsOptions, ActivitySerializationContext, AutoUpgradeVersioningOverride, DataConverter, InitialVersioningBehavior, PinnedVersioningOverride, Priority, SearchAttributePair, SearchAttributeType, SearchAttributeUpdatePair, SerializationContext, SuggestContinueAsNewReason, TypedSearchAttributes, VersioningBehavior, VersioningOverride, WorkerDeploymentVersion, WorkflowDefinitionOptions, WorkflowDefinitionOptionsOrGetter, WorkflowExecutionAlreadyStartedError, WorkflowSerializationContext, arrayFromPayloads, cutoffStackTrace, defaultFailureConverter, defineSearchAttributeKey, ensureApplicationFailure, ensureTemporalFailure, extractWorkflowType, rootCause, toCanonicalString } from "@temporalio/common";
+export { ActivityCancellationDetails, type ActivityCancellationDetailsOptions, type ActivitySerializationContext, type AutoUpgradeVersioningOverride, type DataConverter, InitialVersioningBehavior, type PinnedVersioningOverride, type Priority, type SearchAttributePair, SearchAttributeType, type SearchAttributeUpdatePair, type SerializationContext, SuggestContinueAsNewReason, TypedSearchAttributes, VersioningBehavior, type VersioningOverride, type WorkerDeploymentVersion, type WorkflowDefinitionOptions, type WorkflowDefinitionOptionsOrGetter, WorkflowExecutionAlreadyStartedError, type WorkflowSerializationContext, arrayFromPayloads, cutoffStackTrace, defaultFailureConverter, defineSearchAttributeKey, ensureApplicationFailure, ensureTemporalFailure, extractWorkflowType, rootCause, toCanonicalString };

package/dist/common.js

@@ -1,2 +1,2 @@
-import { WorkflowExecutionAlreadyStartedError, arrayFromPayloads, cutoffStackTrace, defaultFailureConverter, ensureApplicationFailure, ensureTemporalFailure, extractWorkflowType, rootCause } from "@temporalio/common";
-export { WorkflowExecutionAlreadyStartedError, arrayFromPayloads, cutoffStackTrace, defaultFailureConverter, ensureApplicationFailure, ensureTemporalFailure, extractWorkflowType, rootCause };
+import { ActivityCancellationDetails, InitialVersioningBehavior, SearchAttributeType, SuggestContinueAsNewReason, TypedSearchAttributes, VersioningBehavior, WorkflowExecutionAlreadyStartedError, arrayFromPayloads, cutoffStackTrace, defaultFailureConverter, defineSearchAttributeKey, ensureApplicationFailure, ensureTemporalFailure, extractWorkflowType, rootCause, toCanonicalString } from "@temporalio/common";
+export { ActivityCancellationDetails, InitialVersioningBehavior, SearchAttributeType, SuggestContinueAsNewReason, TypedSearchAttributes, VersioningBehavior, WorkflowExecutionAlreadyStartedError, arrayFromPayloads, cutoffStackTrace, defaultFailureConverter, defineSearchAttributeKey, ensureApplicationFailure, ensureTemporalFailure, extractWorkflowType, rootCause, toCanonicalString };

package/dist/encryption/index.d.ts

@@ -1,3 +1,4 @@
 import { getDataConverter } from "./dataConverter.js";
 import { EncryptionCodec } from "./encryptionCodec.js";
-import { decrypt, encrypt } from "./crypto.js";
+import { decrypt, encrypt } from "./crypto.js";
+export { EncryptionCodec, decrypt, encrypt, getDataConverter };

package/dist/encryption/index.js

@@ -1,4 +1,4 @@
-import "./crypto.js";
-import "./encryptionCodec.js";
-import "./dataConverter.js";
-export {};
+import { decrypt, encrypt } from "./crypto.js";
+import { EncryptionCodec } from "./encryptionCodec.js";
+import { getDataConverter } from "./dataConverter.js";
+export { EncryptionCodec, decrypt, encrypt, getDataConverter };

package/dist/interfaces/config.d.ts

@@ -20,8 +20,8 @@ interface TemporalConfig extends Omit<ClientOptions, "dataConverter"> {
   * Controls whether the Temporal worker runs in the same process as the service.
   *
   * - `true` (default): Worker is bootstrapped together with the service in the same process.
-  * - `false`: Service starts without bootstrapping the worker. The worker should be run
-  *   as a separate process using `bootstrapWorker()`.
+  * - `false`: Service starts without running the worker in-process. The worker should be run
+  *   as a separate process using `runStandaloneWorker()`.
   *
   * This is configured at the service level to enable flexible deployment topologies
   * where workers can be scaled independently from the main service.
@@ -31,8 +31,8 @@ interface TemporalConfig extends Omit<ClientOptions, "dataConverter"> {
   * Whether to disable message queue consumers when running as a separate worker process.
   * Applies to all queue connection types (internal, external, etc.).
   *
-  * Defaults to `true` when `bootstrapWorker` manages the full application lifecycle
-  * (i.e. when `configFactory` and `deps` are provided).
+  * Defaults to `true`. Applied by `runStandaloneWorker` (the dedicated worker process)
+  * when it shapes config before starting the app.
   */
   disableQueueConsumers?: boolean;
 }

package/dist/interfaces/index.d.ts

@@ -1 +1,2 @@
-import { AppConfig, TemporalConfig } from "./config.js";
+import { AppConfig, TemporalConfig } from "./config.js";
+export { AppConfig, TemporalConfig };

package/dist/interfaces/services/worker.d.ts

@@ -24,7 +24,10 @@ interface NodeTracerProviderLike {
 }
 type WorkerStatusProvider = () => WorkerStatus;
 type ActivityClass = new (...args: any[]) => any;
-interface WorkerBootstrapOptions extends Omit<WorkerOptions, "taskQueue" | "activities" | "workflowsPath"> {
+/**
+* Options shared by both worker entry points (`runStandaloneWorker` and `runInProcessWorker`).
+*/
+interface WorkerRunOptions extends Omit<WorkerOptions, "taskQueue" | "activities" | "workflowsPath"> {
   /**
   * Path to the workflows module. Accepts either an absolute filesystem path
   * or a `file://` URL (e.g. from `import.meta.resolve('./worker/workflows/index.js')`).
@@ -42,14 +45,35 @@ interface WorkerBootstrapOptions extends Omit<WorkerOptions, "taskQueue" | "acti
   workflowTypes?: string[];
   /** Service name for the metric. Defaults to the name derived from the task queue. */
   service?: string;
+}
+/**
+* Options for `runInProcessWorker` — attaches the worker to an already-started service
+* process. The service owns the application lifecycle; this only runs the worker (and
+* only when `temporal.workerInProcess` is not `false`).
+*/
+type RunInProcessWorkerOptions = WorkerRunOptions;
+/**
+* Options for `runStandaloneWorker` — the dedicated worker process. It owns the full
+* application lifecycle, so `configFactory` and `deps` are required.
+*/
+interface RunStandaloneWorkerOptions extends WorkerRunOptions {
   /**
-  * When provided together with `deps`, `bootstrapWorker` manages the full application
-  * lifecycle: setConfig → apply worker overrides → setDeps → initialize → start → run worker.
+  * Config factory passed to `app.setConfig()`. `runStandaloneWorker` manages the full
+  * application lifecycle: setConfig → apply worker overrides → setDeps → initialize → start → run worker.
   */
+  configFactory: (...args: any[]) => Promise<any>;
+  /** Dependency factory passed to `app.setDeps()`. */
+  deps: (...args: any[]) => Promise<any>;
+}
+/**
+* @deprecated Use {@link RunStandaloneWorkerOptions} (dedicated worker process) or
+* {@link RunInProcessWorkerOptions} (in-process, main service). Options for the deprecated
+* {@link WorkerBootstrapOptions | bootstrapWorker} — `configFactory`/`deps` are optional here
+* only to preserve its legacy behaviour of switching roles by which options are present.
+*/
+interface WorkerBootstrapOptions extends WorkerRunOptions {
+  /** When provided together with `deps`, behaves like `runStandaloneWorker`; otherwise like `runInProcessWorker`. */
   configFactory?: (...args: any[]) => Promise<any>;
-  /**
-  * Dependency factory passed to `app.setDeps()`. Required when `configFactory` is provided.
-  */
   deps?: (...args: any[]) => Promise<any>;
 }
 interface Container {
@@ -66,4 +90,4 @@ interface App {
   }>;
 }
 //#endregion
-export { ActivityClass, App, NodeTracerProviderLike, WorkerBootstrapOptions, WorkerStatusProvider };
+export { ActivityClass, App, NodeTracerProviderLike, RunInProcessWorkerOptions, RunStandaloneWorkerOptions, WorkerBootstrapOptions, WorkerRunOptions, WorkerStatusProvider };

package/dist/nexus.d.ts

@@ -0,0 +1,2 @@
+export * from "@temporalio/nexus";
+export * from "nexus-rpc";

package/dist/nexus.js

@@ -0,0 +1,3 @@
+export * from "@temporalio/nexus";
+export * from "nexus-rpc";
+export {};

package/dist/operations.d.ts

@@ -1,9 +1,9 @@
 import { buildActivitiesProxy } from "./activities/proxy.js";
 import { workflowInterceptors } from "./interceptors.js";
 import { ActivityFailure as ActivityFailure$1 } from "@temporalio/common";
-import { ActivityFailure, ApplicationFailure, CancellationScope, CancellationScopeOptions, CancelledFailure, ChildWorkflowFailure, ChildWorkflowHandle, ChildWorkflowOptions, CommonWorkflowOptions, ContinueAsNew, ContinueAsNewOptions, DeterminismViolationError, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, Trigger, WorkflowError, WorkflowInfo, WorkflowInterceptorsFactory, addDefaultWorkflowOptions, allHandlersFinished, condition, continueAsNew, currentUpdateInfo, defineQuery, defineSignal, defineUpdate, deprecatePatch, executeChild, extractWorkflowType, getExternalWorkflowHandle, inWorkflowContext, isCancellation, log, makeContinueAsNewFunc, patched, proxyActivities, proxyLocalActivities, proxySinks, scheduleActivity, scheduleLocalActivity, setDefaultSignalHandler, setHandler, sleep, startChild, upsertMemo, upsertSearchAttributes, uuid4, workflowInfo, workflowMetadataQuery } from "@temporalio/workflow";
+import { ActivityFailure, ApplicationFailure, CancellationScope, CancellationScopeOptions, CancelledFailure, ChildWorkflowFailure, ChildWorkflowHandle, ChildWorkflowOptions, CommonWorkflowOptions, ContinueAsNew, ContinueAsNewOptions, DeterminismViolationError, NexusOperationCancellationType, NexusOperationHandle, NexusServiceClient, NexusServiceClientOptions, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, TimerOptions, Trigger, UnsafeRandomSource, WorkflowError, WorkflowInfo, WorkflowInterceptorsFactory, WorkflowRandomStream, addDefaultWorkflowOptions, allHandlersFinished, condition, continueAsNew, createNexusServiceClient, currentUpdateInfo, defineQuery, defineSignal, defineUpdate, deprecatePatch, executeChild, extractWorkflowType, getCurrentDetails, getExternalWorkflowHandle, getRandomStream, inWorkflowContext, isCancellation, log, makeContinueAsNewFunc, patched, proxyActivities, proxyLocalActivities, proxySinks, scheduleActivity, scheduleLocalActivity, setCurrentDetails, setDefaultQueryHandler, setDefaultSignalHandler, setDefaultUpdateHandler, setHandler, setWorkflowOptions, sleep, startChild, upsertMemo, upsertSearchAttributes, uuid4, workflowInfo, workflowMetadataQuery, workflowRandom } from "@temporalio/workflow";
 
 //#region src/operations.d.ts
 declare function isNonRetryableFailure(err: unknown): err is ActivityFailure$1;
 //#endregion
-export { ActivityFailure, ApplicationFailure, CancellationScope, type CancellationScopeOptions, CancelledFailure, ChildWorkflowFailure, type ChildWorkflowHandle, type ChildWorkflowOptions, type CommonWorkflowOptions, ContinueAsNew, type ContinueAsNewOptions, DeterminismViolationError, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, Trigger, WorkflowError, type WorkflowInfo, type WorkflowInterceptorsFactory, addDefaultWorkflowOptions, allHandlersFinished, buildActivitiesProxy, condition, continueAsNew, currentUpdateInfo, defineQuery, defineSignal, defineUpdate, deprecatePatch, executeChild, extractWorkflowType, getExternalWorkflowHandle, inWorkflowContext, isCancellation, isNonRetryableFailure, log, makeContinueAsNewFunc, patched, proxyActivities, proxyLocalActivities, proxySinks, scheduleActivity, scheduleLocalActivity, setDefaultSignalHandler, setHandler, sleep, startChild, upsertMemo, upsertSearchAttributes, uuid4, workflowInfo, workflowInterceptors, workflowMetadataQuery };
+export { ActivityFailure, ApplicationFailure, CancellationScope, type CancellationScopeOptions, CancelledFailure, ChildWorkflowFailure, type ChildWorkflowHandle, type ChildWorkflowOptions, type CommonWorkflowOptions, ContinueAsNew, type ContinueAsNewOptions, DeterminismViolationError, NexusOperationCancellationType, type NexusOperationHandle, type NexusServiceClient, type NexusServiceClientOptions, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, type TimerOptions, Trigger, type UnsafeRandomSource, WorkflowError, type WorkflowInfo, type WorkflowInterceptorsFactory, type WorkflowRandomStream, addDefaultWorkflowOptions, allHandlersFinished, buildActivitiesProxy, condition, continueAsNew, createNexusServiceClient, currentUpdateInfo, defineQuery, defineSignal, defineUpdate, deprecatePatch, executeChild, extractWorkflowType, getCurrentDetails, getExternalWorkflowHandle, getRandomStream, inWorkflowContext, isCancellation, isNonRetryableFailure, log, makeContinueAsNewFunc, patched, proxyActivities, proxyLocalActivities, proxySinks, scheduleActivity, scheduleLocalActivity, setCurrentDetails, setDefaultQueryHandler, setDefaultSignalHandler, setDefaultUpdateHandler, setHandler, setWorkflowOptions, sleep, startChild, upsertMemo, upsertSearchAttributes, uuid4, workflowInfo, workflowInterceptors, workflowMetadataQuery, workflowRandom };

package/dist/operations.js

@@ -2,7 +2,7 @@ import { buildActivitiesProxy } from "./activities/proxy.js";
 import "./activities/index.js";
 import { workflowInterceptors } from "./interceptors.js";
 import { ActivityFailure as ActivityFailure$1, ApplicationFailure as ApplicationFailure$1, RetryState } from "@temporalio/common";
-import { ActivityFailure, ApplicationFailure, CancellationScope, CancelledFailure, ChildWorkflowFailure, ContinueAsNew, DeterminismViolationError, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, Trigger, WorkflowError, addDefaultWorkflowOptions, allHandlersFinished, condition, continueAsNew, currentUpdateInfo, defineQuery, defineSignal, defineUpdate, deprecatePatch, executeChild, extractWorkflowType, getExternalWorkflowHandle, inWorkflowContext, isCancellation, log, makeContinueAsNewFunc, patched, proxyActivities, proxyLocalActivities, proxySinks, scheduleActivity, scheduleLocalActivity, setDefaultSignalHandler, setHandler, sleep, startChild, upsertMemo, upsertSearchAttributes, uuid4, workflowInfo, workflowMetadataQuery } from "@temporalio/workflow";
+import { ActivityFailure, ApplicationFailure, CancellationScope, CancelledFailure, ChildWorkflowFailure, ContinueAsNew, DeterminismViolationError, NexusOperationCancellationType, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, Trigger, WorkflowError, addDefaultWorkflowOptions, allHandlersFinished, condition, continueAsNew, createNexusServiceClient, currentUpdateInfo, defineQuery, defineSignal, defineUpdate, deprecatePatch, executeChild, extractWorkflowType, getCurrentDetails, getExternalWorkflowHandle, getRandomStream, inWorkflowContext, isCancellation, log, makeContinueAsNewFunc, patched, proxyActivities, proxyLocalActivities, proxySinks, scheduleActivity, scheduleLocalActivity, setCurrentDetails, setDefaultQueryHandler, setDefaultSignalHandler, setDefaultUpdateHandler, setHandler, setWorkflowOptions, sleep, startChild, upsertMemo, upsertSearchAttributes, uuid4, workflowInfo, workflowMetadataQuery, workflowRandom } from "@temporalio/workflow";
 //#region src/operations.ts
 function isNonRetryableFailure(err) {
 	if (!(err instanceof ActivityFailure$1)) return false;
@@ -10,4 +10,4 @@ function isNonRetryableFailure(err) {
 	return err.cause instanceof ApplicationFailure$1 && Boolean(err.cause.nonRetryable);
 }
 //#endregion
-export { ActivityFailure, ApplicationFailure, CancellationScope, CancelledFailure, ChildWorkflowFailure, ContinueAsNew, DeterminismViolationError, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, Trigger, WorkflowError, addDefaultWorkflowOptions, allHandlersFinished, buildActivitiesProxy, condition, continueAsNew, currentUpdateInfo, defineQuery, defineSignal, defineUpdate, deprecatePatch, executeChild, extractWorkflowType, getExternalWorkflowHandle, inWorkflowContext, isCancellation, isNonRetryableFailure, log, makeContinueAsNewFunc, patched, proxyActivities, proxyLocalActivities, proxySinks, scheduleActivity, scheduleLocalActivity, setDefaultSignalHandler, setHandler, sleep, startChild, upsertMemo, upsertSearchAttributes, uuid4, workflowInfo, workflowInterceptors, workflowMetadataQuery };
+export { ActivityFailure, ApplicationFailure, CancellationScope, CancelledFailure, ChildWorkflowFailure, ContinueAsNew, DeterminismViolationError, NexusOperationCancellationType, ServerFailure, TemporalFailure, TerminatedFailure, TimeoutFailure, Trigger, WorkflowError, addDefaultWorkflowOptions, allHandlersFinished, buildActivitiesProxy, condition, continueAsNew, createNexusServiceClient, currentUpdateInfo, defineQuery, defineSignal, defineUpdate, deprecatePatch, executeChild, extractWorkflowType, getCurrentDetails, getExternalWorkflowHandle, getRandomStream, inWorkflowContext, isCancellation, isNonRetryableFailure, log, makeContinueAsNewFunc, patched, proxyActivities, proxyLocalActivities, proxySinks, scheduleActivity, scheduleLocalActivity, setCurrentDetails, setDefaultQueryHandler, setDefaultSignalHandler, setDefaultUpdateHandler, setHandler, setWorkflowOptions, sleep, startChild, upsertMemo, upsertSearchAttributes, uuid4, workflowInfo, workflowInterceptors, workflowMetadataQuery, workflowRandom };

package/dist/services/client.d.ts

@@ -8,7 +8,7 @@ declare class TemporalClient implements OnInit {
   private readonly config;
   private readonly envService;
   private readonly logger;
-  nativeClient!: Client;
+  nativeClient: Client;
   private readonly defaultTimezone;
   /** Default maximum gRPC message size (in bytes) the client may receive. */
   private readonly defaultMaxReceiveMessageLength;
@@ -18,6 +18,11 @@ declare class TemporalClient implements OnInit {
   get workflowService(): Client["workflowService"];
   get schedule(): Client["schedule"];
   get taskQueue(): Client["taskQueue"];
+  /**
+  * Client for starting and managing Standalone Activities (run directly from a client,
+  * without a workflow). Mirrors `nativeClient.activity`.
+  */
+  get activity(): Client["activity"];
   onInit(): Promise<void>;
   syncSchedules(schedules: Record<string, ((config: TemporalConfig) => ScheduleOptions) | ScheduleOptions>): Promise<void>;
   updateSchedule(scheduleId: string, updateData: ScheduleUpdateOptions): Promise<void>;

package/dist/services/client.js

@@ -33,6 +33,13 @@ var TemporalClient = class {
 	get taskQueue() {
 		return this.nativeClient.taskQueue;
 	}
+	/**
+	* Client for starting and managing Standalone Activities (run directly from a client,
+	* without a workflow). Mirrors `nativeClient.activity`.
+	*/
+	get activity() {
+		return this.nativeClient.activity;
+	}
 	async onInit() {
 		const { address, tls, connectTimeout, channelArgs, encryptionEnabled, encryptionKeyId, encryptionKeyRefreshInterval, ...clientConfig } = this.config;
 		const connection = await Connection.connect({

package/dist/services/worker.d.ts

@@ -1,5 +1,5 @@
 import { AppConfig } from "../interfaces/config.js";
-import { ActivityClass, App, NodeTracerProviderLike, WorkerBootstrapOptions } from "../interfaces/services/worker.js";
+import { ActivityClass, App, NodeTracerProviderLike, RunInProcessWorkerOptions, RunStandaloneWorkerOptions, WorkerBootstrapOptions, WorkerRunOptions } from "../interfaces/services/worker.js";
 import { WorkerHealthDetails, WorkerHealthService } from "./workerHealth.js";
 import { buildWorkerIdentity } from "./worker/identity.js";
 import { EnvService } from "@diia-inhouse/env";
@@ -33,75 +33,81 @@ declare function applyWorkerProcessConfig(config: AppConfig): void;
 declare function toWorkflowsPath(input: string): string;
 declare function instantiateActivities(app: App, workerActivities: Record<string, ActivityClass>): Record<string, (...args: unknown[]) => Promise<unknown>>;
 /**
-* Initializes and starts Temporal worker with full dependency injection support.
+* Runs the Temporal worker in the **dedicated worker process**.
 *
-* This is the recommended way to initialize Temporal workers. It handles:
-* - Automatic dependency injection for activities
-* - AsyncLocalStorage setup for distributed tracing
-* - OpenTelemetry integration
-* - Activity instantiation and binding
+* This entry point owns the full application lifecycle — it is meant to be the only
+* call in a standalone worker entry file (e.g. `workerEntry.ts`):
 *
-* @param app - App instance for DI container and config access
-* @param options - Worker configuration options
-* @param options.nodeTracerProvider - OpenTelemetry tracer provider
-* @param options.workflowsPath - Path to workflows module
-* @param options.activities - Activity classes to instantiate
+*   setConfig → apply worker overrides → setDeps → initialize → start → run worker
+*
+* A worker process always runs a worker, so `workerInProcess` is not consulted here.
+* Applies the worker-process config overrides (disables queue consumers, moves metrics
+* to the `temporal-worker` scraper port) before the app starts, and integrates worker
+* health with the app's centralized health check.
+*
+* @param app - App instance (config is set here, so it must be un-initialized)
+* @param options - Worker process options; `configFactory` and `deps` are required
 *
 * @example
 * ```typescript
-* // Define your activities
-* const workerActivities = {
-*     userActivity: UserActivity,
-*     notificationActivity: NotificationActivity,
-* }
-*
-* // Initialize and start the worker
-* await initTemporalWorker(app, {
-*     nodeTracerProvider,
+* // workerEntry.ts — the standalone worker process
+* const app = new Application(serviceName, nodeTracerProvider, loggerConfig)
+*
+* await runStandaloneWorker(app, {
+*     configFactory,
+*     deps,
 *     workflowsPath: import.meta.resolve('./worker/workflows/index.js'),
 *     activities: workerActivities,
+*     nodeTracerProvider,
 * })
 * ```
 */
-declare function initTemporalWorker(app: App, options: {
-  nodeTracerProvider: NodeTracerProviderLike;
-  workflowsPath: string;
-  activities: Record<string, ActivityClass>; /** The workflows this worker runs. Auto-detected from the workflows folder when left empty. */
-  workflowTypes?: string[]; /** Service name. Defaults to the name derived from the task queue. */
-  service?: string;
-} & Omit<WorkerOptions, "taskQueue" | "activities" | "workflowsPath">): Promise<void>;
+declare function runStandaloneWorker(app: App, options: RunStandaloneWorkerOptions): Promise<void>;
 /**
-* Bootstraps and runs Temporal worker with graceful shutdown.
+* Runs the Temporal worker **in the main service process**, alongside an app that the
+* caller has already initialized and started.
 *
-* Handles both in-process and separate-process worker topologies:
+* Behaviour is driven solely by `temporal.workerInProcess`:
 *
-* - **In-process** (`workerInProcess` is `true` or unset): initializes and runs the worker.
-* - **Separate process** (called from a dedicated worker entry with `configFactory`/`deps`):
-*   manages the full application lifecycle: setConfig → apply worker overrides → setDeps →
-*   initialize → start → run worker.
-* - **Service-only** (`workerInProcess` is `false`, no `configFactory`): disables temporal
-*   scrapers on the main service (worker handles them separately) and returns immediately.
+* - not `false` (default): builds and runs the worker in this process (blocks until shutdown).
+* - `false`: the worker runs elsewhere (see {@link runStandaloneWorker}); disables the temporal
+*   scrapers on this service and returns immediately.
 *
-* Automatically integrates worker health with the app's centralized health check
-* system via `HealthCheck.addHealthCheckable()`.
+* Call it after `initialized.start()`.
 *
 * @param app - App instance for DI container and config access
-* @param options - Worker bootstrap options
+* @param options - In-process worker options
 *
 * @example
 * ```typescript
-* // Separate worker process with full lifecycle management
-* const app = new Application(serviceName, nodeTracerProvider, loggerConfig)
+* // bootstrap.ts — the main service process
+* await app.setConfig(configFactory)
+* await app.setDeps(deps)
+* const initialized = await app.initialize()
+* await initialized.start()
 *
-* await bootstrapWorker(app, {
-*     configFactory,
-*     deps,
+* await runInProcessWorker(app, {
 *     workflowsPath: import.meta.resolve('./worker/workflows/index.js'),
 *     activities: workerActivities,
 *     nodeTracerProvider,
 * })
 * ```
 */
+declare function runInProcessWorker(app: App, options: RunInProcessWorkerOptions): Promise<void>;
+/**
+* @deprecated Split into two role-specific entry points — migrate to one of:
+*
+* - {@link runStandaloneWorker} — the dedicated worker process (was `bootstrapWorker(app, { configFactory, deps, ... })`).
+* - {@link runInProcessWorker} — the worker running inside the already-started main service
+*   (was `bootstrapWorker(app, { ... })` without `configFactory`/`deps`).
+*
+* This shim just forwards to those based on whether `configFactory` and `deps` are present, so
+* existing call sites keep working. It multiplexes both roles by inspecting which options were
+* passed — the exact ambiguity the split removes — and will be dropped in a future major.
+*
+* @param app - App instance for DI container and config access
+* @param options - Legacy worker bootstrap options
+*/
 declare function bootstrapWorker(app: App, options: WorkerBootstrapOptions): Promise<void>;
 /**
 * Initializes Temporal worker.
@@ -125,4 +131,4 @@ declare function initWorker({
   service?: string;
 }, envService: EnvService, logger?: Logger, nodeTracerProvider?: NodeTracerProviderLike, asyncLocalStorage?: AsyncLocalStorage<AlsData>): Promise<Worker>;
 //#endregion
-export { applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, initTemporalWorker, initWorker, instantiateActivities, toWorkflowsPath };
+export { type ActivityClass, type App, type RunInProcessWorkerOptions, type RunStandaloneWorkerOptions, type WorkerBootstrapOptions, type WorkerHealthDetails, WorkerHealthService, type WorkerRunOptions, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, initWorker, instantiateActivities, runInProcessWorker, runStandaloneWorker, toWorkflowsPath };

package/dist/services/worker.js

@@ -111,96 +111,118 @@ function instantiateActivities(app, workerActivities) {
 	return activities;
 }
 /**
-* Initializes and starts Temporal worker with full dependency injection support.
+* Runs the Temporal worker in the **dedicated worker process**.
 *
-* This is the recommended way to initialize Temporal workers. It handles:
-* - Automatic dependency injection for activities
-* - AsyncLocalStorage setup for distributed tracing
-* - OpenTelemetry integration
-* - Activity instantiation and binding
+* This entry point owns the full application lifecycle — it is meant to be the only
+* call in a standalone worker entry file (e.g. `workerEntry.ts`):
 *
-* @param app - App instance for DI container and config access
-* @param options - Worker configuration options
-* @param options.nodeTracerProvider - OpenTelemetry tracer provider
-* @param options.workflowsPath - Path to workflows module
-* @param options.activities - Activity classes to instantiate
+*   setConfig → apply worker overrides → setDeps → initialize → start → run worker
+*
+* A worker process always runs a worker, so `workerInProcess` is not consulted here.
+* Applies the worker-process config overrides (disables queue consumers, moves metrics
+* to the `temporal-worker` scraper port) before the app starts, and integrates worker
+* health with the app's centralized health check.
+*
+* @param app - App instance (config is set here, so it must be un-initialized)
+* @param options - Worker process options; `configFactory` and `deps` are required
 *
 * @example
 * ```typescript
-* // Define your activities
-* const workerActivities = {
-*     userActivity: UserActivity,
-*     notificationActivity: NotificationActivity,
-* }
+* // workerEntry.ts — the standalone worker process
+* const app = new Application(serviceName, nodeTracerProvider, loggerConfig)
 *
-* // Initialize and start the worker
-* await initTemporalWorker(app, {
-*     nodeTracerProvider,
+* await runStandaloneWorker(app, {
+*     configFactory,
+*     deps,
 *     workflowsPath: import.meta.resolve('./worker/workflows/index.js'),
 *     activities: workerActivities,
+*     nodeTracerProvider,
 * })
 * ```
 */
-async function initTemporalWorker(app, options) {
-	const config = app.getConfig?.();
-	const { nodeTracerProvider, workflowsPath: workflowsPathInput, activities, ...workerOptions } = options;
-	const workflowsPath = toWorkflowsPath(workflowsPathInput);
-	const envService = app.container.resolve("envService");
-	const logger = app.container.resolve("logger");
-	const asyncLocalStorage = app.container.resolve("asyncLocalStorage");
-	const instantiatedActivities = instantiateActivities(app, activities);
-	await (await initWorker(config, {
-		...workerOptions,
-		workflowsPath,
-		activities: instantiatedActivities
-	}, envService, logger, nodeTracerProvider, asyncLocalStorage)).run();
+async function runStandaloneWorker(app, options) {
+	const { configFactory, deps, ...runOptions } = options;
+	await app.setConfig(configFactory);
+	applyWorkerProcessConfig(app.getConfig());
+	await app.setDeps(deps);
+	await (await app.initialize()).start();
+	await runWorker(app, runOptions);
 }
 /**
-* Bootstraps and runs Temporal worker with graceful shutdown.
+* Runs the Temporal worker **in the main service process**, alongside an app that the
+* caller has already initialized and started.
 *
-* Handles both in-process and separate-process worker topologies:
+* Behaviour is driven solely by `temporal.workerInProcess`:
 *
-* - **In-process** (`workerInProcess` is `true` or unset): initializes and runs the worker.
-* - **Separate process** (called from a dedicated worker entry with `configFactory`/`deps`):
-*   manages the full application lifecycle: setConfig → apply worker overrides → setDeps →
-*   initialize → start → run worker.
-* - **Service-only** (`workerInProcess` is `false`, no `configFactory`): disables temporal
-*   scrapers on the main service (worker handles them separately) and returns immediately.
+* - not `false` (default): builds and runs the worker in this process (blocks until shutdown).
+* - `false`: the worker runs elsewhere (see {@link runStandaloneWorker}); disables the temporal
+*   scrapers on this service and returns immediately.
 *
-* Automatically integrates worker health with the app's centralized health check
-* system via `HealthCheck.addHealthCheckable()`.
+* Call it after `initialized.start()`.
 *
 * @param app - App instance for DI container and config access
-* @param options - Worker bootstrap options
+* @param options - In-process worker options
 *
 * @example
 * ```typescript
-* // Separate worker process with full lifecycle management
-* const app = new Application(serviceName, nodeTracerProvider, loggerConfig)
+* // bootstrap.ts — the main service process
+* await app.setConfig(configFactory)
+* await app.setDeps(deps)
+* const initialized = await app.initialize()
+* await initialized.start()
 *
-* await bootstrapWorker(app, {
-*     configFactory,
-*     deps,
+* await runInProcessWorker(app, {
 *     workflowsPath: import.meta.resolve('./worker/workflows/index.js'),
 *     activities: workerActivities,
 *     nodeTracerProvider,
 * })
 * ```
 */
-async function bootstrapWorker(app, options) {
-	const { configFactory, deps, workflowsPath: workflowsPathInput, activities, nodeTracerProvider, shutdownSignals = ["SIGTERM", "SIGINT"], ...workerOptions } = options;
-	const workflowsPath = toWorkflowsPath(workflowsPathInput);
-	if (configFactory && deps) {
-		await app.setConfig(configFactory);
-		applyWorkerProcessConfig(app.getConfig());
-		await app.setDeps(deps);
-		await (await app.initialize()).start();
-	}
+async function runInProcessWorker(app, options) {
 	const config = app.getConfig?.();
-	if (!configFactory && config.temporal.workerInProcess === false) {
+	if (config.temporal.workerInProcess === false) {
 		applyServiceProcessConfig(config);
 		return;
 	}
+	await runWorker(app, options);
+}
+/**
+* @deprecated Split into two role-specific entry points — migrate to one of:
+*
+* - {@link runStandaloneWorker} — the dedicated worker process (was `bootstrapWorker(app, { configFactory, deps, ... })`).
+* - {@link runInProcessWorker} — the worker running inside the already-started main service
+*   (was `bootstrapWorker(app, { ... })` without `configFactory`/`deps`).
+*
+* This shim just forwards to those based on whether `configFactory` and `deps` are present, so
+* existing call sites keep working. It multiplexes both roles by inspecting which options were
+* passed — the exact ambiguity the split removes — and will be dropped in a future major.
+*
+* @param app - App instance for DI container and config access
+* @param options - Legacy worker bootstrap options
+*/
+async function bootstrapWorker(app, options) {
+	const { configFactory, deps, ...runOptions } = options;
+	if (configFactory && deps) {
+		await runStandaloneWorker(app, {
+			...runOptions,
+			configFactory,
+			deps
+		});
+		return;
+	}
+	await runInProcessWorker(app, runOptions);
+}
+/**
+* Shared worker startup used by both {@link runStandaloneWorker} and {@link runInProcessWorker}.
+*
+* Assumes the app is already initialized and started. Instantiates activities from the DI
+* container, creates the worker, registers its health check, installs graceful-shutdown
+* signal handlers, and runs it until shutdown.
+*/
+async function runWorker(app, options) {
+	const { workflowsPath: workflowsPathInput, activities, nodeTracerProvider, shutdownSignals = ["SIGTERM", "SIGINT"], ...workerOptions } = options;
+	const workflowsPath = toWorkflowsPath(workflowsPathInput);
+	const config = app.getConfig?.();
 	const envService = app.container.resolve("envService");
 	const logger = app.container.resolve("logger");
 	const asyncLocalStorage = app.container.resolve("asyncLocalStorage");
@@ -298,4 +320,4 @@ async function initWorker({ temporal: temporalConfig, metrics: { custom: metrics
 	}
 }
 //#endregion
-export { applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, initTemporalWorker, initWorker, instantiateActivities, toWorkflowsPath };
+export { WorkerHealthService, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, initWorker, instantiateActivities, runInProcessWorker, runStandaloneWorker, toWorkflowsPath };

package/dist/worker.d.ts

@@ -1,8 +1,8 @@
 import { workflowInterceptors } from "./interceptors.js";
-import { ActivityClass, App, WorkerBootstrapOptions } from "./interfaces/services/worker.js";
+import { ActivityClass, App, RunInProcessWorkerOptions, RunStandaloneWorkerOptions, WorkerBootstrapOptions, WorkerRunOptions } from "./interfaces/services/worker.js";
 import { WorkerHealthDetails, WorkerHealthService } from "./services/workerHealth.js";
 import { buildWorkerIdentity } from "./services/worker/identity.js";
-import { applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, initTemporalWorker, initWorker, instantiateActivities, toWorkflowsPath } from "./services/worker.js";
+import { applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, initWorker, instantiateActivities, runInProcessWorker, runStandaloneWorker, toWorkflowsPath } from "./services/worker.js";
 import { RegisterWorkerInfoParams, WORKER_INFO_METRIC, WorkerInfoLabels, deriveWorkflowTypes, registerWorkerInfo, taskQueueToService } from "./services/worker/info.js";
-import { NativeConnection, Runtime, State, Worker, WorkerInterceptors, WorkerOptions, WorkerStatus, bundleWorkflowCode } from "@temporalio/worker";
-export { ActivityClass, App, NativeConnection, RegisterWorkerInfoParams, Runtime, type State, WORKER_INFO_METRIC, Worker, WorkerBootstrapOptions, WorkerHealthDetails, WorkerHealthService, WorkerInfoLabels, type WorkerInterceptors, type WorkerOptions, type WorkerStatus, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, bundleWorkflowCode, deriveWorkflowTypes, initTemporalWorker, initWorker, instantiateActivities, registerWorkerInfo, taskQueueToService, toWorkflowsPath, workflowInterceptors };
+import { NativeConnection, NativeConnectionPlugin, Runtime, State, Worker, WorkerDeploymentOptions, WorkerInterceptors, WorkerOptions, WorkerPlugin, WorkerStatus, bundleWorkflowCode } from "@temporalio/worker";
+export { type ActivityClass, type App, NativeConnection, type NativeConnectionPlugin, RegisterWorkerInfoParams, type RunInProcessWorkerOptions, type RunStandaloneWorkerOptions, Runtime, type State, WORKER_INFO_METRIC, Worker, type WorkerBootstrapOptions, type WorkerDeploymentOptions, type WorkerHealthDetails, WorkerHealthService, WorkerInfoLabels, type WorkerInterceptors, type WorkerOptions, type WorkerPlugin, type WorkerRunOptions, type WorkerStatus, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, bundleWorkflowCode, deriveWorkflowTypes, initWorker, instantiateActivities, registerWorkerInfo, runInProcessWorker, runStandaloneWorker, taskQueueToService, toWorkflowsPath, workflowInterceptors };

package/dist/worker.js

@@ -2,6 +2,6 @@ import { workflowInterceptors } from "./interceptors.js";
 import { buildWorkerIdentity } from "./services/worker/identity.js";
 import { WORKER_INFO_METRIC, deriveWorkflowTypes, registerWorkerInfo, taskQueueToService } from "./services/worker/info.js";
 import { WorkerHealthService } from "./services/workerHealth.js";
-import { applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, initTemporalWorker, initWorker, instantiateActivities, toWorkflowsPath } from "./services/worker.js";
+import { applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, initWorker, instantiateActivities, runInProcessWorker, runStandaloneWorker, toWorkflowsPath } from "./services/worker.js";
 import { NativeConnection, Runtime, Worker, bundleWorkflowCode } from "@temporalio/worker";
-export { NativeConnection, Runtime, WORKER_INFO_METRIC, Worker, WorkerHealthService, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, bundleWorkflowCode, deriveWorkflowTypes, initTemporalWorker, initWorker, instantiateActivities, registerWorkerInfo, taskQueueToService, toWorkflowsPath, workflowInterceptors };
+export { NativeConnection, Runtime, WORKER_INFO_METRIC, Worker, WorkerHealthService, applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, buildWorkerIdentity, bundleWorkflowCode, deriveWorkflowTypes, initWorker, instantiateActivities, registerWorkerInfo, runInProcessWorker, runStandaloneWorker, taskQueueToService, toWorkflowsPath, workflowInterceptors };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@diia-inhouse/workflow",
-    "version": "2.9.13",
+    "version": "2.10.0",
     "description": "Workflow",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -17,37 +17,42 @@
     },
     "exports": {
         ".": {
-            "types": "./dist/types/index.d.ts",
+            "types": "./dist/index.d.ts",
             "import": "./dist/index.js",
             "require": "./dist/index.js"
         },
         "./activity": {
-            "types": "./dist/types/activity.d.ts",
+            "types": "./dist/activity.d.ts",
             "import": "./dist/activity.js",
             "require": "./dist/activity.js"
         },
         "./client": {
-            "types": "./dist/types/client.d.ts",
+            "types": "./dist/client.d.ts",
             "import": "./dist/client.js",
             "require": "./dist/client.js"
         },
         "./common": {
-            "types": "./dist/types/common.d.ts",
+            "types": "./dist/common.d.ts",
             "import": "./dist/common.js",
             "require": "./dist/common.js"
         },
         "./operations": {
-            "types": "./dist/types/operations.d.ts",
+            "types": "./dist/operations.d.ts",
             "import": "./dist/operations.js",
             "require": "./dist/operations.js"
         },
         "./worker": {
-            "types": "./dist/types/worker.d.ts",
+            "types": "./dist/worker.d.ts",
             "import": "./dist/worker.js",
             "require": "./dist/worker.js"
         },
+        "./nexus": {
+            "types": "./dist/nexus.d.ts",
+            "import": "./dist/nexus.js",
+            "require": "./dist/nexus.js"
+        },
         "./testing": {
-            "types": "./dist/types/testing.d.ts",
+            "types": "./dist/testing.d.ts",
             "import": "./dist/testing.js",
             "require": "./dist/testing.js"
         }
@@ -70,15 +75,17 @@
         "@opentelemetry/resources": "1.30.1",
         "@opentelemetry/sdk-trace-node": "1.30.1",
         "@opentelemetry/semantic-conventions": "1.40.0",
-        "@temporalio/activity": "1.12.1",
-        "@temporalio/client": "1.12.1",
-        "@temporalio/common": "1.12.1",
-        "@temporalio/interceptors-opentelemetry": "1.12.1",
-        "@temporalio/proto": "1.12.1",
-        "@temporalio/testing": "1.12.1",
-        "@temporalio/worker": "1.12.1",
-        "@temporalio/workflow": "1.12.1",
+        "@temporalio/activity": "1.20.2",
+        "@temporalio/client": "1.20.2",
+        "@temporalio/common": "1.20.2",
+        "@temporalio/interceptors-opentelemetry": "1.20.2",
+        "@temporalio/nexus": "1.20.2",
+        "@temporalio/proto": "1.20.2",
+        "@temporalio/testing": "1.20.2",
+        "@temporalio/worker": "1.20.2",
+        "@temporalio/workflow": "1.20.2",
         "lodash": "4.18.1",
+        "nexus-rpc": "0.0.2",
         "yargs": "18.0.0"
     },
     "peerDependencies": {
@@ -100,31 +107,31 @@
     },
     "devDependencies": {
         "@diia-inhouse/configs": "7.0.1",
-        "@diia-inhouse/diia-logger": "4.4.8",
-        "@diia-inhouse/diia-metrics": "7.1.46",
-        "@diia-inhouse/diia-queue": "14.1.3",
-        "@diia-inhouse/env": "3.3.29",
-        "@diia-inhouse/healthcheck": "2.1.53",
-        "@diia-inhouse/oxc-config": "1.11.0",
-        "@diia-inhouse/test": "8.2.17",
-        "@diia-inhouse/types": "14.1.1",
-        "@diia-inhouse/utils": "6.0.43",
+        "@diia-inhouse/diia-logger": "4.4.14",
+        "@diia-inhouse/diia-metrics": "7.1.53",
+        "@diia-inhouse/diia-queue": "14.1.4",
+        "@diia-inhouse/env": "3.3.31",
+        "@diia-inhouse/healthcheck": "2.1.60",
+        "@diia-inhouse/oxc-config": "2.0.0",
+        "@diia-inhouse/test": "8.2.19",
+        "@diia-inhouse/types": "14.2.0",
+        "@diia-inhouse/utils": "6.0.49",
         "@types/lodash": "4.17.24",
-        "@types/node": "25.6.2",
+        "@types/node": "26.1.0",
         "@types/yargs": "17.0.35",
-        "@vitest/coverage-v8": "4.1.5",
-        "@vitest/ui": "4.1.5",
+        "@vitest/coverage-v8": "4.1.9",
+        "@vitest/ui": "4.1.9",
         "glob": "13.0.6",
         "lockfile-lint": "5.0.0",
         "madge": "8.0.0",
-        "oxfmt": "0.48.0",
-        "oxlint": "1.63.0",
-        "oxlint-tsgolint": "0.22.1",
+        "oxfmt": "0.57.0",
+        "oxlint": "1.72.0",
+        "oxlint-tsgolint": "0.24.0",
         "rimraf": "6.1.3",
-        "semantic-release": "25.0.3",
-        "tsdown": "0.22.0",
+        "semantic-release": "25.0.5",
+        "tsdown": "0.22.3",
         "vite-tsconfig-paths": "6.1.1",
-        "vitest": "4.1.5",
+        "vitest": "4.1.9",
         "vitest-mock-extended": "4.0.0"
     },
     "release": {