@diia-inhouse/workflow 1.17.11 → 2.5.1

package/dist/services/worker.js

@@ -1,333 +1,353 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkerHealthService = exports.buildWorkerIdentity = void 0;
-exports.applyServiceProcessConfig = applyServiceProcessConfig;
-exports.applyWorkerProcessConfig = applyWorkerProcessConfig;
-exports.instantiateActivities = instantiateActivities;
-exports.initTemporalWorker = initTemporalWorker;
-exports.bootstrapWorker = bootstrapWorker;
-exports.initWorker = initWorker;
-const node_path_1 = __importDefault(require("node:path"));
-const resources_1 = require("@opentelemetry/resources");
-const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
-const worker_1 = require("@temporalio/interceptors-opentelemetry/lib/worker");
-const worker_2 = require("@temporalio/worker");
-const env_1 = require("@diia-inhouse/env");
-const encryption_1 = require("../encryption");
-const instrumentation_1 = require("../instrumentation");
-const asyncLocalStorageBridge_1 = require("../interceptors/asyncLocalStorageBridge");
-const identity_1 = require("./worker/identity");
-const workerHealth_1 = require("./workerHealth");
-var identity_2 = require("./worker/identity");
-Object.defineProperty(exports, "buildWorkerIdentity", { enumerable: true, get: function () { return identity_2.buildWorkerIdentity; } });
-var workerHealth_2 = require("./workerHealth");
-Object.defineProperty(exports, "WorkerHealthService", { enumerable: true, get: function () { return workerHealth_2.WorkerHealthService; } });
+import { getDataConverter } from "../encryption/dataConverter.js";
+import "../encryption/index.js";
+import { traceExporter } from "../instrumentation.js";
+import { AsyncLocalStorageBridgeInterceptor } from "../interceptors/asyncLocalStorageBridge.js";
+import { SchedulesExporter } from "./schedulesExporter.js";
+import { buildWorkerIdentity } from "./worker/identity.js";
+import { WorkerHealthService } from "./workerHealth.js";
+import { EnvService } from "@diia-inhouse/env";
+import { NativeConnection, Runtime, Worker } from "@temporalio/worker";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Resource } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
+import { OpenTelemetryActivityInboundInterceptor, OpenTelemetryActivityOutboundInterceptor, makeWorkflowExporter } from "@temporalio/interceptors-opentelemetry/lib/worker/index.js";
+import * as promClient from "prom-client";
+//#region src/services/worker.ts
 /**
- * Applies service process configuration overrides when the worker runs separately.
- *
- * When `temporal.workerInProcess` is `false`, disables `temporal` and `temporal-worker` scrapers
- * so the main service does not scrape metrics that the worker process handles.
- *
- * Mutates the config object in place. Safe to call when scrapers are absent.
- */
+* Applies service process configuration overrides when the worker runs separately.
+*
+* When `temporal.workerInProcess` is `false`, disables `temporal` and `temporal-worker` scrapers
+* so the main service does not scrape metrics that the worker process handles.
+*
+* Mutates the config object in place. Safe to call when scrapers are absent.
+*/
 function applyServiceProcessConfig(config) {
-    const { workerInProcess = true } = config.temporal;
-    if (workerInProcess) {
-        return;
-    }
-    for (const scraper of config.metrics.custom.scrapers ?? []) {
-        if (scraper.name === 'temporal' || scraper.name === 'temporal-worker') {
-            scraper.disabled = true;
-        }
-    }
+	const { workerInProcess = true } = config.temporal;
+	if (workerInProcess) return;
+	for (const scraper of config.metrics.custom.scrapers ?? []) if (scraper.name === "temporal" || scraper.name === "temporal-worker") scraper.disabled = true;
 }
 /**
- * Applies worker process configuration overrides.
- *
- * - Disables queue consumers on all rabbit connections (unless `temporal.disableQueueConsumers` is `false`)
- * - Overrides `metrics.custom.port` with the `'temporal-worker'` scraper port and disables that scraper to prevent self-scraping
- *
- * Mutates the config object in place. Safe to call when queue config is absent.
- */
+* Applies worker process configuration overrides.
+*
+* - Disables queue consumers on all rabbit connections (unless `temporal.disableQueueConsumers` is `false`)
+* - Overrides `metrics.custom.port` with the `'temporal-worker'` scraper port and disables that scraper to prevent self-scraping
+*
+* Mutates the config object in place. Safe to call when queue config is absent.
+*/
 function applyWorkerProcessConfig(config) {
-    const { disableQueueConsumers = true } = config.temporal;
-    if (disableQueueConsumers && config.rabbit) {
-        for (const value of Object.values(config.rabbit)) {
-            if (value && typeof value === 'object' && 'consumerEnabled' in value) {
-                value.consumerEnabled = false;
-            }
-        }
-    }
-    const workerScraper = config.metrics.custom.scrapers?.find((s) => s.name === 'temporal-worker');
-    if (workerScraper?.port !== undefined) {
-        config.metrics.custom.port = workerScraper.port;
-        workerScraper.disabled = true;
-    }
+	const { disableQueueConsumers = true } = config.temporal;
+	if (disableQueueConsumers && config.rabbit) {
+		for (const value of Object.values(config.rabbit)) if (value && typeof value === "object" && "consumerEnabled" in value) value.consumerEnabled = false;
+	}
+	const workerScraper = config.metrics.custom.scrapers?.find((s) => s.name === "temporal-worker");
+	if (workerScraper?.port !== void 0) {
+		config.metrics.custom.port = workerScraper.port;
+		workerScraper.disabled = true;
+	}
 }
 /**
- * Builds worker interceptors with OpenTelemetry and AsyncLocalStorage support.
- * OpenTelemetry creates span first, then AsyncLocalStorage bridge extracts traceId.
- */
-const traceLogAttributesModulePath = node_path_1.default.resolve(__dirname, '../interceptors/traceLogAttributes');
+* Accepts either a filesystem path or a `file://` URL (e.g. from `import.meta.resolve`)
+* and returns a filesystem path suitable for Temporal's worker.
+*/
+function toWorkflowsPath(input) {
+	return input.startsWith("file://") ? fileURLToPath(input) : input;
+}
+/**
+* Builds worker interceptors with OpenTelemetry and AsyncLocalStorage support.
+* OpenTelemetry creates span first, then AsyncLocalStorage bridge extracts traceId.
+*/
+const traceLogAttributesModulePath = path.resolve(import.meta.dirname, "../interceptors/traceLogAttributes");
 function buildWorkerInterceptors(tracingEnabled, asyncLocalStorage, logger, workflowsPath) {
-    if (tracingEnabled) {
-        const workflowModules = [traceLogAttributesModulePath];
-        if (workflowsPath) {
-            workflowModules.unshift(workflowsPath);
-        }
-        return {
-            activity: [
-                (ctx) => ({
-                    inbound: new worker_1.OpenTelemetryActivityInboundInterceptor(ctx),
-                    outbound: new worker_1.OpenTelemetryActivityOutboundInterceptor(ctx),
-                }),
-                ...(asyncLocalStorage && logger
-                    ? [
-                        (ctx) => ({
-                            inbound: new asyncLocalStorageBridge_1.AsyncLocalStorageBridgeInterceptor(ctx, asyncLocalStorage, logger),
-                        }),
-                    ]
-                    : []),
-            ],
-            workflowModules,
-        };
-    }
-    if (asyncLocalStorage && logger) {
-        return {
-            activity: [
-                (ctx) => ({
-                    inbound: new asyncLocalStorageBridge_1.AsyncLocalStorageBridgeInterceptor(ctx, asyncLocalStorage, logger),
-                    outbound: new worker_1.OpenTelemetryActivityOutboundInterceptor(ctx),
-                }),
-            ],
-            workflowModules: workflowsPath ? [workflowsPath] : [],
-        };
-    }
-    return undefined;
+	if (tracingEnabled) {
+		const workflowModules = [traceLogAttributesModulePath];
+		if (workflowsPath) workflowModules.unshift(workflowsPath);
+		return {
+			activity: [(ctx) => ({
+				inbound: new OpenTelemetryActivityInboundInterceptor(ctx),
+				outbound: new OpenTelemetryActivityOutboundInterceptor(ctx)
+			}), ...asyncLocalStorage && logger ? [(ctx) => ({ inbound: new AsyncLocalStorageBridgeInterceptor(ctx, asyncLocalStorage, logger) })] : []],
+			workflowModules
+		};
+	}
+	if (asyncLocalStorage && logger) return {
+		activity: [(ctx) => ({
+			inbound: new AsyncLocalStorageBridgeInterceptor(ctx, asyncLocalStorage, logger),
+			outbound: new OpenTelemetryActivityOutboundInterceptor(ctx)
+		})],
+		workflowModules: workflowsPath ? [workflowsPath] : []
+	};
 }
 /**
- * Merges built-in interceptors with custom interceptors from options.
- */
+* Merges built-in interceptors with custom interceptors from options.
+*/
 function mergeInterceptors(builtIn, custom) {
-    if (!builtIn && !custom) {
-        return undefined;
-    }
-    return {
-        activity: [...(builtIn?.activity || []), ...(custom?.activity || [])],
-        workflowModules: [...(builtIn?.workflowModules || []), ...(custom?.workflowModules || [])],
-    };
+	if (!builtIn && !custom) return;
+	return {
+		activity: [...builtIn?.activity || [], ...custom?.activity || []],
+		workflowModules: [...builtIn?.workflowModules || [], ...custom?.workflowModules || []]
+	};
 }
 function buildActivities(app, activities) {
-    const instances = {};
-    for (const [key, value] of Object.entries(activities)) {
-        instances[key] = app.container.build(value);
-    }
-    return instances;
+	const instances = {};
+	for (const [key, value] of Object.entries(activities)) instances[key] = app.container.build(value);
+	return instances;
 }
 function bindActivities(key, instance) {
-    const methods = Object.getOwnPropertyNames(Object.getPrototypeOf(instance)).filter((name) => name !== 'constructor');
-    const boundActivities = {};
-    for (const method of methods) {
-        const fn = instance[method];
-        const token = `${key}.${String(method)}`;
-        boundActivities[token] = fn.bind(instance);
-    }
-    return boundActivities;
+	const methods = Object.getOwnPropertyNames(Object.getPrototypeOf(instance)).filter((name) => name !== "constructor");
+	const boundActivities = {};
+	for (const method of methods) {
+		const fn = instance[method];
+		const token = `${key}.${String(method)}`;
+		boundActivities[token] = fn.bind(instance);
+	}
+	return boundActivities;
 }
 function instantiateActivities(app, workerActivities) {
-    const activitiesInstances = buildActivities(app, workerActivities);
-    const activities = {};
-    for (const [key, value] of Object.entries(activitiesInstances)) {
-        Object.assign(activities, bindActivities(key, value));
-    }
-    return activities;
+	const activitiesInstances = buildActivities(app, workerActivities);
+	const activities = {};
+	for (const [key, value] of Object.entries(activitiesInstances)) Object.assign(activities, bindActivities(key, value));
+	return activities;
 }
 /**
- * Initializes and starts Temporal worker with full dependency injection support.
- *
- * 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
- *
- * @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
- *
- * @example
- * ```typescript
- * // Define your activities
- * const workerActivities = {
- *     userActivity: UserActivity,
- *     notificationActivity: NotificationActivity,
- * }
- *
- * // Initialize and start the worker
- * await initTemporalWorker(app, {
- *     nodeTracerProvider,
- *     workflowsPath: require.resolve('./worker/workflows'),
- *     activities: workerActivities,
- * })
- * ```
- */
+* Initializes and starts Temporal worker with full dependency injection support.
+*
+* 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
+*
+* @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
+*
+* @example
+* ```typescript
+* // Define your activities
+* const workerActivities = {
+*     userActivity: UserActivity,
+*     notificationActivity: NotificationActivity,
+* }
+*
+* // Initialize and start the worker
+* await initTemporalWorker(app, {
+*     nodeTracerProvider,
+*     workflowsPath: import.meta.resolve('./worker/workflows/index.js'),
+*     activities: workerActivities,
+* })
+* ```
+*/
 async function initTemporalWorker(app, options) {
-    const config = app.getConfig?.();
-    const { nodeTracerProvider, workflowsPath, activities, ...workerOptions } = options;
-    const envService = app.container.resolve('envService');
-    const logger = app.container.resolve('logger');
-    const asyncLocalStorage = app.container.resolve('asyncLocalStorage');
-    const instantiatedActivities = instantiateActivities(app, activities);
-    const worker = await initWorker(config, { ...workerOptions, workflowsPath, activities: instantiatedActivities }, envService, logger, nodeTracerProvider, asyncLocalStorage);
-    await worker.run();
+	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);
+	const worker = await initWorker(config, {
+		...workerOptions,
+		workflowsPath,
+		activities: instantiatedActivities
+	}, envService, logger, nodeTracerProvider, asyncLocalStorage);
+	const schedulesExporter = await startSchedulesExporter(app, config, logger);
+	try {
+		await worker.run();
+	} finally {
+		await schedulesExporter?.onDestroy().catch((err) => logger.error("SchedulesExporter shutdown failed", { err }));
+	}
 }
 /**
- * Bootstraps and runs Temporal worker with graceful shutdown.
- *
- * Handles both in-process and separate-process worker topologies:
- *
- * - **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.
- *
- * Automatically integrates worker health with the app's centralized health check
- * system via `HealthCheck.addHealthCheckable()`.
- *
- * @param app - App instance for DI container and config access
- * @param options - Worker bootstrap options
- *
- * @example
- * ```typescript
- * // Separate worker process with full lifecycle management
- * const app = new Application(serviceName, nodeTracerProvider, loggerConfig)
- *
- * await bootstrapWorker(app, {
- *     configFactory,
- *     deps,
- *     workflowsPath: require.resolve('./worker/workflows'),
- *     activities: workerActivities,
- *     nodeTracerProvider,
- * })
- * ```
- */
+* Bootstraps and runs Temporal worker with graceful shutdown.
+*
+* Handles both in-process and separate-process worker topologies:
+*
+* - **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.
+*
+* Automatically integrates worker health with the app's centralized health check
+* system via `HealthCheck.addHealthCheckable()`.
+*
+* @param app - App instance for DI container and config access
+* @param options - Worker bootstrap options
+*
+* @example
+* ```typescript
+* // Separate worker process with full lifecycle management
+* const app = new Application(serviceName, nodeTracerProvider, loggerConfig)
+*
+* await bootstrapWorker(app, {
+*     configFactory,
+*     deps,
+*     workflowsPath: import.meta.resolve('./worker/workflows/index.js'),
+*     activities: workerActivities,
+*     nodeTracerProvider,
+* })
+* ```
+*/
 async function bootstrapWorker(app, options) {
-    const { configFactory, deps, workflowsPath, activities, nodeTracerProvider, shutdownSignals = ['SIGTERM', 'SIGINT'], ...workerOptions } = options;
-    if (configFactory && deps) {
-        await app.setConfig(configFactory);
-        applyWorkerProcessConfig(app.getConfig());
-        await app.setDeps(deps);
-        const appOperator = await app.initialize();
-        await appOperator.start();
-    }
-    const config = app.getConfig?.();
-    if (!configFactory && config.temporal.workerInProcess === false) {
-        applyServiceProcessConfig(config);
-        return;
-    }
-    const envService = app.container.resolve('envService');
-    const logger = app.container.resolve('logger');
-    const asyncLocalStorage = app.container.resolve('asyncLocalStorage');
-    const taskQueue = config.temporal.taskQueue;
-    const identity = (0, identity_1.buildWorkerIdentity)(taskQueue, workerOptions.identity);
-    const instantiatedActivities = instantiateActivities(app, activities);
-    const worker = await initWorker(config, {
-        ...workerOptions,
-        workflowsPath,
-        activities: instantiatedActivities,
-        identity,
-    }, envService, logger, nodeTracerProvider, asyncLocalStorage);
-    logger.info('Starting Temporal worker', { taskQueue, identity });
-    const healthCheck = tryResolve(app.container, 'healthCheck');
-    if (healthCheck) {
-        const workerHealthService = new workerHealth_1.WorkerHealthService();
-        workerHealthService.setStatusProvider(() => worker.getStatus());
-        healthCheck.addHealthCheckable(workerHealthService);
-    }
-    const signalHandler = () => {
-        worker.shutdown();
-    };
-    for (const signal of shutdownSignals) {
-        process.once(signal, signalHandler);
-    }
-    try {
-        await worker.run();
-    }
-    finally {
-        for (const signal of shutdownSignals) {
-            process.off(signal, signalHandler);
-        }
-    }
+	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();
+	}
+	const config = app.getConfig?.();
+	if (!configFactory && config.temporal.workerInProcess === false) {
+		applyServiceProcessConfig(config);
+		return;
+	}
+	const envService = app.container.resolve("envService");
+	const logger = app.container.resolve("logger");
+	const asyncLocalStorage = app.container.resolve("asyncLocalStorage");
+	const taskQueue = config.temporal.taskQueue;
+	const identity = buildWorkerIdentity(taskQueue, workerOptions.identity);
+	const instantiatedActivities = instantiateActivities(app, activities);
+	const worker = await initWorker(config, {
+		...workerOptions,
+		workflowsPath,
+		activities: instantiatedActivities,
+		identity
+	}, envService, logger, nodeTracerProvider, asyncLocalStorage);
+	const schedulesExporter = await startSchedulesExporter(app, config, logger);
+	logger.info("Starting Temporal worker", {
+		taskQueue,
+		identity
+	});
+	const healthCheck = tryResolve(app.container, "healthCheck");
+	if (healthCheck) {
+		const workerHealthService = new WorkerHealthService();
+		workerHealthService.setStatusProvider(() => worker.getStatus());
+		healthCheck.addHealthCheckable(workerHealthService);
+	}
+	const signalHandler = () => {
+		worker.shutdown();
+	};
+	for (const signal of shutdownSignals) process.once(signal, signalHandler);
+	try {
+		await worker.run();
+	} finally {
+		for (const signal of shutdownSignals) process.off(signal, signalHandler);
+		await schedulesExporter?.onDestroy().catch((err) => logger.error("SchedulesExporter shutdown failed", { err }));
+	}
 }
 function tryResolve(container, key) {
-    try {
-        return container.resolve(key);
-    }
-    catch {
-        return undefined;
-    }
+	try {
+		return container.resolve(key);
+	} catch {
+		return;
+	}
+}
+/**
+* Wires the SchedulesExporter to the in-process worker. Auto-enabled; opt out by setting
+* `config.temporal.schedulesExporter` to `false`. Returns the exporter so callers can stop
+* it on shutdown.
+*/
+async function startSchedulesExporter(app, config, logger) {
+	const exporterConfig = config.temporal.schedulesExporter;
+	if (exporterConfig === false) return;
+	const temporalClient = tryResolve(app.container, "temporalClient");
+	if (!temporalClient) {
+		logger.warn("SchedulesExporter not started: temporalClient is not registered in the DI container");
+		return;
+	}
+	const exporter = new SchedulesExporter({
+		client: temporalClient,
+		taskQueue: config.temporal.taskQueue,
+		logger
+	}, exporterConfig ?? {});
+	await exporter.onInit();
+	return exporter;
 }
 /**
- * Initializes Temporal worker.
- *
- * @param config - Application configuration
- * @param options - Worker options including workflows path
- * @param envService - Environment service instance
- * @param logger - Logger instance (optional)
- * @param nodeTracerProvider - OpenTelemetry tracer provider (optional)
- * @param asyncLocalStorage - AsyncLocalStorage instance for tracing context (optional)
- * @returns Configured Temporal worker
- */
+* Initializes Temporal worker.
+*
+* @param config - Application configuration
+* @param options - Worker options including workflows path
+* @param envService - Environment service instance
+* @param logger - Logger instance (optional)
+* @param nodeTracerProvider - OpenTelemetry tracer provider (optional)
+* @param asyncLocalStorage - AsyncLocalStorage instance for tracing context (optional)
+* @returns Configured Temporal worker
+*/
 async function initWorker({ temporal: temporalConfig, metrics: { custom: metricsConfig } }, options, envService, logger, nodeTracerProvider, asyncLocalStorage) {
-    const { encryptionEnabled, encryptionKeyId, encryptionKeyRefreshInterval, namespace = 'default', address, taskQueue } = temporalConfig;
-    const runtimeParams = {};
-    if (logger) {
-        runtimeParams.logger = logger.child({ taskQueue });
-    }
-    const temporalMetrics = metricsConfig.scrapers?.find((s) => s.name === 'temporal');
-    if (temporalMetrics && !temporalMetrics.disabled) {
-        runtimeParams.telemetryOptions = {
-            metrics: {
-                prometheus: {
-                    bindAddress: `0.0.0.0:${temporalMetrics.port}`,
-                    useSecondsForDurations: true,
-                    countersTotalSuffix: true,
-                    unitSuffix: true,
-                },
-            },
-        };
-    }
-    worker_2.Runtime.install(runtimeParams);
-    const resource = new resources_1.Resource({
-        [semantic_conventions_1.ATTR_SERVICE_NAME]: nodeTracerProvider?.resource.attributes[semantic_conventions_1.ATTR_SERVICE_NAME],
-    });
-    const tracingEnabled = env_1.EnvService.getVar('TRACING_ENABLED', 'boolean', false);
-    const builtInInterceptors = buildWorkerInterceptors(tracingEnabled, asyncLocalStorage, logger, options.workflowsPath);
-    const mergedInterceptors = mergeInterceptors(builtInInterceptors, options.interceptors);
-    try {
-        const worker = await worker_2.Worker.create({
-            namespace,
-            taskQueue,
-            connection: await worker_2.NativeConnection.connect({ address }),
-            dataConverter: encryptionEnabled
-                ? await (0, encryption_1.getDataConverter)(encryptionKeyId, envService, encryptionKeyRefreshInterval)
-                : undefined,
-            ...options,
-            sinks: tracingEnabled ? { exporter: (0, worker_1.makeWorkflowExporter)(instrumentation_1.traceExporter, resource) } : undefined,
-            interceptors: mergedInterceptors,
-        });
-        return worker;
-    }
-    catch (err) {
-        logger?.error('Failed to create Temporal worker', { err });
-        throw new Error('Failed to create Temporal worker', { cause: err });
-    }
+	const { encryptionEnabled, encryptionKeyId, encryptionKeyRefreshInterval, namespace = "default", address, taskQueue } = temporalConfig;
+	const runtimeParams = {};
+	if (logger) runtimeParams.logger = logger.child({ taskQueue });
+	const temporalMetrics = metricsConfig.scrapers?.find((s) => s.name === "temporal");
+	if (temporalMetrics && !temporalMetrics.disabled) runtimeParams.telemetryOptions = { metrics: { prometheus: {
+		bindAddress: `0.0.0.0:${temporalMetrics.port}`,
+		useSecondsForDurations: true,
+		countersTotalSuffix: true,
+		unitSuffix: true
+	} } };
+	Runtime.install(runtimeParams);
+	const providerWithPrivateResource = nodeTracerProvider;
+	const tracerResource = nodeTracerProvider?.resource ?? providerWithPrivateResource?.["_resource"];
+	const resource = new Resource({ [ATTR_SERVICE_NAME]: tracerResource?.attributes?.[ATTR_SERVICE_NAME] });
+	const tracingEnabled = EnvService.getVar("TRACING_ENABLED", "boolean", false);
+	const workflowsPath = options.workflowsPath ? toWorkflowsPath(options.workflowsPath) : void 0;
+	const mergedInterceptors = mergeInterceptors(buildWorkerInterceptors(tracingEnabled, asyncLocalStorage, logger, workflowsPath), options.interceptors);
+	try {
+		const worker = await Worker.create({
+			namespace,
+			taskQueue,
+			connection: await NativeConnection.connect({ address }),
+			dataConverter: encryptionEnabled ? await getDataConverter(encryptionKeyId, envService, encryptionKeyRefreshInterval) : void 0,
+			...options,
+			workflowsPath,
+			sinks: tracingEnabled ? { exporter: makeWorkflowExporter(traceExporter, resource) } : void 0,
+			interceptors: mergedInterceptors
+		});
+		if (workflowsPath && taskQueue) await emitRegisteredWorkflowTypes(workflowsPath, taskQueue, logger);
+		return worker;
+	} catch (err) {
+		logger?.error("Failed to create Temporal worker", { err });
+		throw new Error("Failed to create Temporal worker", { cause: err });
+	}
+}
+/**
+* Dynamic-imports the workflows entrypoint module and emits
+* `diia_workflow_registered_type_info{workflow_type, task_queue}=1` for every exported
+* function. Pairs with `diia_schedule_*` series so a dashboard can detect zombie schedules
+* (schedules whose workflow type is no longer registered on the same task queue).
+*
+* Failures are logged and swallowed — this is observability, not load-bearing.
+*/
+async function emitRegisteredWorkflowTypes(workflowsPath, taskQueue, logger) {
+	try {
+		const mod = await (workflowsPath.startsWith("file://") ? import(workflowsPath) : import(`file://${workflowsPath}`));
+		const existing = promClient.register.getSingleMetric("diia_workflow_registered_type_info");
+		const gauge = existing instanceof promClient.Gauge ? existing : new promClient.Gauge({
+			name: "diia_workflow_registered_type_info",
+			help: "1 if the workflow type is registered on this task queue (function exported from the worker entrypoint module)",
+			labelNames: ["workflow_type", "task_queue"]
+		});
+		const registered = [];
+		for (const [name, value] of Object.entries(mod)) if (typeof value === "function") {
+			gauge.set({
+				workflow_type: name,
+				task_queue: taskQueue
+			}, 1);
+			registered.push(name);
+		}
+		logger?.info("Registered workflow types emitted to Prometheus", {
+			taskQueue,
+			count: registered.length,
+			types: registered
+		});
+	} catch (err) {
+		logger?.warn("Failed to enumerate registered workflow types", { err });
+	}
 }
-//# sourceMappingURL=worker.js.map
+//#endregion
+export { applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, initTemporalWorker, initWorker, instantiateActivities, toWorkflowsPath };