@diia-inhouse/workflow 1.17.11 → 2.5.0

package/dist/services/schedulesExporter.js

@@ -0,0 +1,456 @@
+import * as promClient from "prom-client";
+//#region src/services/schedulesExporter.ts
+const SCHEDULE_LABELS = [
+	"schedule_id",
+	"workflow_type",
+	"task_queue"
+];
+const SCHEDULE_SLOT_LABELS = [...SCHEDULE_LABELS, "slot"];
+const RUNNING_LABELS = ["workflow_type", "task_queue"];
+/**
+* Periodically polls the Temporal Schedule and Visibility APIs, exposing per-schedule and
+* per-workflow-type business metrics that the SDK does not provide out of the box:
+*
+* - `diia_schedule_paused` (0/1)
+* - `diia_schedule_last_action_age_seconds`
+* - `diia_schedule_last_action_succeeded` (0/1)
+* - `diia_schedule_next_action_at_seconds{slot}` — Unix seconds of upcoming fire
+* - `diia_schedule_next_action_eta_seconds{slot}` — seconds from now until upcoming fire
+
+* - `diia_schedule_cadence_seconds` — approximate gap between fires (slot1 − slot0, falls back to spec)
+* - `diia_schedule_fires_total{result="ok"|"failed"}` — counter of observed schedule fires; pair
+*   with cadence to compute expected/day and detect missed runs
+* - `diia_workflows_running` — count of executions in `Running` state for this task queue
+* - `diia_workflows_oldest_running_age_seconds` — age of the oldest running workflow
+*
+* The `service` label is supplied by the `diia-metrics` default labels at scrape time, so it
+* is intentionally absent from the metric labelNames.
+*
+* Schedules with `action.taskQueue` other than `deps.taskQueue` are ignored, so a service
+* only emits metrics for schedules it actually owns. This avoids fan-out when many services
+* share a Temporal namespace.
+*
+* The exporter does NOT run its own HTTP server. Metrics flow through the existing
+* `diia-metrics` `/metrics` endpoint. If a service needs to expose the calendar event list
+* or recent action feed as JSON (e.g. for a Grafana Infinity datasource), it should call
+* {@link SchedulesExporter.getCalendarEvents} and {@link SchedulesExporter.getRecentActions}
+* from a route on its existing HTTP framework.
+*/
+var SchedulesExporter = class SchedulesExporter {
+	deps;
+	pollIntervalMs;
+	visibilityPollIntervalMs;
+	pollVisibility;
+	nextActionSlots;
+	historySize;
+	logger;
+	calendarEvents = [];
+	recentActionsLog = [];
+	paused;
+	lastActionAge;
+	lastActionSucceeded;
+	nextActionAt;
+	nextActionEta;
+	cadence;
+	running;
+	oldestRunningAge;
+	firesTotal;
+	workflowDuration;
+	seenCompletedRunIds = [];
+	seenCompletedRunIdSet = /* @__PURE__ */ new Set();
+	seenActionKeys = [];
+	seenActionKeySet = /* @__PURE__ */ new Set();
+	static ACTIONS_SEEN_CAPACITY = 2e3;
+	lastSeenScheduleLabels = /* @__PURE__ */ new Map();
+	pollCompletions;
+	completionsPollIntervalMs;
+	completionsLookbackMs;
+	completionsSeenCapacity;
+	completionsLastPollMs;
+	scheduleTimer;
+	visibilityTimer;
+	completionsTimer;
+	schedulesPolling = false;
+	runningPolling = false;
+	completionsPolling = false;
+	activeSchedulesPoll;
+	activeRunningPoll;
+	activeCompletionsPoll;
+	stopped = false;
+	constructor(deps, config = {}) {
+		this.deps = deps;
+		this.pollIntervalMs = config.pollIntervalMs ?? 3e4;
+		this.visibilityPollIntervalMs = config.visibilityPollIntervalMs ?? 1e4;
+		this.pollVisibility = config.pollVisibility ?? true;
+		this.nextActionSlots = config.nextActionSlots ?? 5;
+		this.historySize = config.recentActionsHistorySize ?? 200;
+		this.pollCompletions = config.pollCompletions ?? true;
+		this.completionsPollIntervalMs = config.completionsPollIntervalMs ?? 6e4;
+		this.completionsLookbackMs = config.completionsLookbackMs ?? 3600 * 1e3;
+		this.completionsSeenCapacity = config.completionsSeenCapacity ?? 2e3;
+		this.completionsLastPollMs = Date.now() - this.completionsLookbackMs;
+		this.logger = deps.logger;
+		const scheduleLabels = [...SCHEDULE_LABELS];
+		const scheduleSlotLabels = [...SCHEDULE_SLOT_LABELS];
+		const runningLabels = [...RUNNING_LABELS];
+		this.paused = getOrCreateGauge("diia_schedule_paused", "1 if the schedule is paused", scheduleLabels);
+		this.lastActionAge = getOrCreateGauge("diia_schedule_last_action_age_seconds", "Seconds since the schedule last fired (across all action results)", scheduleLabels);
+		this.lastActionSucceeded = getOrCreateGauge("diia_schedule_last_action_succeeded", "1 if the most recent schedule action started a workflow successfully", scheduleLabels);
+		this.nextActionAt = getOrCreateGauge("diia_schedule_next_action_at_seconds", "Unix seconds of an upcoming scheduled action (slot=0 is the next fire)", scheduleSlotLabels);
+		this.nextActionEta = getOrCreateGauge("diia_schedule_next_action_eta_seconds", "Seconds from now until an upcoming scheduled action (slot=0 is the next fire)", scheduleSlotLabels);
+		this.cadence = getOrCreateGauge("diia_schedule_cadence_seconds", "Approximate cadence between fires, derived from the gap between the next two upcoming actions (falls back to spec for single-slot schedules)", scheduleLabels);
+		this.running = getOrCreateGauge("diia_workflows_running", "Currently running workflow executions for this task queue, by workflow type", runningLabels);
+		this.oldestRunningAge = getOrCreateGauge("diia_workflows_oldest_running_age_seconds", "Age of the oldest running workflow per workflow type", runningLabels);
+		this.firesTotal = getOrCreateCounter("diia_schedule_fires_total", "Total schedule fires observed by the exporter, partitioned by result (ok/failed). Compare with expected fires from `diia_schedule_cadence_seconds` to detect missed runs.", [...scheduleLabels, "result"]);
+		this.workflowDuration = getOrCreateHistogram("diia_workflow_duration_seconds", "End-to-end duration of completed (status=Completed) workflow executions per workflow_type. Sample is taken from Temporal Visibility close_time − start_time. Pair with `diia_schedule_fires_total` to compute per-schedule cost (fires/day × p95 duration).", ["workflow_type", "task_queue"], [
+			1,
+			5,
+			15,
+			60,
+			180,
+			600,
+			1800,
+			3600,
+			7200,
+			21600,
+			43200,
+			86400
+		]);
+	}
+	async onInit() {
+		this.runSchedulesPoll("initial");
+		if (this.pollVisibility) this.runRunningPoll("initial");
+		if (this.pollCompletions) this.runCompletionsPoll("initial");
+		this.armSchedulesTimer();
+		if (this.pollVisibility) this.armVisibilityTimer();
+		if (this.pollCompletions) this.armCompletionsTimer();
+	}
+	async onDestroy() {
+		this.stopped = true;
+		if (this.scheduleTimer) clearTimeout(this.scheduleTimer);
+		if (this.visibilityTimer) clearTimeout(this.visibilityTimer);
+		if (this.completionsTimer) clearTimeout(this.completionsTimer);
+		await Promise.allSettled([
+			this.activeSchedulesPoll,
+			this.activeRunningPoll,
+			this.activeCompletionsPoll
+		]);
+	}
+	armSchedulesTimer() {
+		if (this.stopped) return;
+		this.scheduleTimer = setTimeout(() => {
+			this.runSchedulesPoll("interval").finally(() => this.armSchedulesTimer());
+		}, this.pollIntervalMs);
+		this.scheduleTimer.unref();
+	}
+	armVisibilityTimer() {
+		if (this.stopped) return;
+		this.visibilityTimer = setTimeout(() => {
+			this.runRunningPoll("interval").finally(() => this.armVisibilityTimer());
+		}, this.visibilityPollIntervalMs);
+		this.visibilityTimer.unref();
+	}
+	armCompletionsTimer() {
+		if (this.stopped) return;
+		this.completionsTimer = setTimeout(() => {
+			this.runCompletionsPoll("interval").finally(() => this.armCompletionsTimer());
+		}, this.completionsPollIntervalMs);
+		this.completionsTimer.unref();
+	}
+	runSchedulesPoll(source) {
+		if (this.schedulesPolling) return Promise.resolve();
+		this.schedulesPolling = true;
+		const promise = (async () => {
+			try {
+				await this.pollSchedules();
+			} catch (err) {
+				this.logger?.error(`SchedulesExporter ${source} schedule poll failed`, { err });
+			} finally {
+				this.schedulesPolling = false;
+				this.activeSchedulesPoll = void 0;
+			}
+		})();
+		this.activeSchedulesPoll = promise;
+		return promise;
+	}
+	runRunningPoll(source) {
+		if (this.runningPolling) return Promise.resolve();
+		this.runningPolling = true;
+		const promise = (async () => {
+			try {
+				await this.pollRunning();
+			} catch (err) {
+				this.logger?.error(`SchedulesExporter ${source} visibility poll failed`, { err });
+			} finally {
+				this.runningPolling = false;
+				this.activeRunningPoll = void 0;
+			}
+		})();
+		this.activeRunningPoll = promise;
+		return promise;
+	}
+	runCompletionsPoll(source) {
+		if (this.completionsPolling) return Promise.resolve();
+		this.completionsPolling = true;
+		const promise = (async () => {
+			try {
+				await this.pollCompleted();
+			} catch (err) {
+				this.logger?.error(`SchedulesExporter ${source} completions poll failed`, { err });
+			} finally {
+				this.completionsPolling = false;
+				this.activeCompletionsPoll = void 0;
+			}
+		})();
+		this.activeCompletionsPoll = promise;
+		return promise;
+	}
+	/**
+	* Snapshot of the next-N upcoming fires across all tracked schedules.
+	* Each schedule contributes up to `nextActionSlots` events, ordered by `slot`.
+	* Mount on a service HTTP route to feed the Grafana Business Calendar panel via the
+	* Infinity datasource — the data shape is already calendar-event-shaped.
+	*/
+	getCalendarEvents() {
+		return this.calendarEvents;
+	}
+	/**
+	* Snapshot of the most recent schedule actions across all tracked schedules,
+	* ordered newest first. Capped at `recentActionsHistorySize` entries.
+	*/
+	getRecentActions(limit = 50) {
+		return this.recentActionsLog.slice(0, limit).map(({ key: _key, ...rest }) => rest);
+	}
+	async pollSchedules() {
+		const events = [];
+		const currentSeen = /* @__PURE__ */ new Map();
+		for await (const summary of this.deps.client.schedule.list()) {
+			const description = await this.deps.client.schedule.getHandle(summary.scheduleId).describe();
+			const action = description.action;
+			if (action.type !== "startWorkflow") continue;
+			if (action.taskQueue !== this.deps.taskQueue) continue;
+			const workflowType = action.workflowType;
+			const baseLabels = {
+				schedule_id: summary.scheduleId,
+				workflow_type: workflowType,
+				task_queue: this.deps.taskQueue
+			};
+			currentSeen.set(summary.scheduleId, baseLabels);
+			const info = description.info;
+			const state = description.state;
+			const recentActions = info.recentActions ?? [];
+			const upcoming = info.nextActionTimes ?? info.futureActionTimes ?? [];
+			const pausedFlag = state.paused ? 1 : 0;
+			const cadenceLabel = describeCadence(description.spec);
+			this.paused.set(baseLabels, pausedFlag);
+			const lastAction = recentActions[recentActions.length - 1];
+			const lastSucceeded = lastAction ? lastAction.action ? 1 : 0 : null;
+			if (lastAction) {
+				const at = lastAction.takenAt ?? lastAction.scheduledAt;
+				if (at) this.lastActionAge.set(baseLabels, (Date.now() - new Date(at).getTime()) / 1e3);
+				this.lastActionSucceeded.set(baseLabels, lastAction.action ? 1 : 0);
+			}
+			for (const recent of recentActions) {
+				const at = recent.takenAt ?? recent.scheduledAt;
+				if (!at) continue;
+				const key = `${summary.scheduleId}|${new Date(at).toISOString()}`;
+				if (this.seenActionKeySet.has(key)) continue;
+				this.seenActionKeySet.add(key);
+				this.seenActionKeys.push(key);
+				const succeeded = recent.action ? 1 : 0;
+				this.recentActionsLog.push({
+					key,
+					scheduleId: summary.scheduleId,
+					workflowType,
+					taskQueue: this.deps.taskQueue,
+					firedAt: new Date(at).toISOString(),
+					firedAtMs: new Date(at).getTime(),
+					succeeded
+				});
+				this.firesTotal.inc({
+					...baseLabels,
+					result: succeeded ? "ok" : "failed"
+				});
+			}
+			for (let slot = 0; slot < this.nextActionSlots; slot++) {
+				const at = upcoming[slot];
+				const slotLabels = {
+					...baseLabels,
+					slot: String(slot)
+				};
+				if (!at) {
+					this.nextActionAt.remove(slotLabels);
+					this.nextActionEta.remove(slotLabels);
+					continue;
+				}
+				const ms = new Date(at).getTime();
+				this.nextActionAt.set(slotLabels, ms / 1e3);
+				this.nextActionEta.set(slotLabels, Math.max(0, (ms - Date.now()) / 1e3));
+				events.push({
+					scheduleId: summary.scheduleId,
+					workflowType,
+					taskQueue: this.deps.taskQueue,
+					cadence: cadenceLabel,
+					slot,
+					fireAt: new Date(ms).toISOString(),
+					fireAtMs: ms,
+					paused: pausedFlag,
+					lastSucceeded
+				});
+			}
+			const cadenceSeconds = computeCadenceSeconds(upcoming, description.spec);
+			if (cadenceSeconds !== void 0) this.cadence.set(baseLabels, cadenceSeconds);
+			else this.cadence.remove(baseLabels);
+		}
+		this.calendarEvents.length = 0;
+		this.calendarEvents.push(...events);
+		this.recentActionsLog.sort((a, b) => b.firedAtMs - a.firedAtMs);
+		if (this.recentActionsLog.length > this.historySize) this.recentActionsLog.length = this.historySize;
+		while (this.seenActionKeys.length > SchedulesExporter.ACTIONS_SEEN_CAPACITY) {
+			const evicted = this.seenActionKeys.shift();
+			if (evicted) this.seenActionKeySet.delete(evicted);
+		}
+		for (const [scheduleId, labels] of this.lastSeenScheduleLabels) {
+			if (currentSeen.has(scheduleId)) continue;
+			this.paused.remove(labels);
+			this.lastActionAge.remove(labels);
+			this.lastActionSucceeded.remove(labels);
+			this.cadence.remove(labels);
+			this.firesTotal.remove({
+				...labels,
+				result: "ok"
+			});
+			this.firesTotal.remove({
+				...labels,
+				result: "failed"
+			});
+			for (let slot = 0; slot < this.nextActionSlots; slot++) {
+				const slotLabels = {
+					...labels,
+					slot: String(slot)
+				};
+				this.nextActionAt.remove(slotLabels);
+				this.nextActionEta.remove(slotLabels);
+			}
+		}
+		this.lastSeenScheduleLabels.clear();
+		for (const [scheduleId, labels] of currentSeen) this.lastSeenScheduleLabels.set(scheduleId, labels);
+	}
+	async pollRunning() {
+		const buckets = /* @__PURE__ */ new Map();
+		const query = `TaskQueue="${this.deps.taskQueue}" AND ExecutionStatus="Running"`;
+		for await (const wf of this.deps.client.workflow.list({ query })) {
+			const startMs = wf.startTime ? new Date(wf.startTime).getTime() : Date.now();
+			const existing = buckets.get(wf.type) ?? {
+				count: 0,
+				oldestStartMs: Date.now()
+			};
+			existing.count += 1;
+			if (startMs < existing.oldestStartMs) existing.oldestStartMs = startMs;
+			buckets.set(wf.type, existing);
+		}
+		this.running.reset();
+		this.oldestRunningAge.reset();
+		for (const [workflowType, { count, oldestStartMs }] of buckets) {
+			const labels = {
+				workflow_type: workflowType,
+				task_queue: this.deps.taskQueue
+			};
+			this.running.set(labels, count);
+			this.oldestRunningAge.set(labels, (Date.now() - oldestStartMs) / 1e3);
+		}
+	}
+	async pollCompleted() {
+		const sinceMs = this.completionsLastPollMs;
+		const nowMs = Date.now();
+		const sinceIso = new Date(sinceMs).toISOString();
+		const query = `TaskQueue="${this.deps.taskQueue}" AND ExecutionStatus="Completed" AND CloseTime>="${sinceIso}"`;
+		let observed = 0;
+		for await (const wf of this.deps.client.workflow.list({ query })) {
+			const raw = wf.raw;
+			const rawJson = raw && typeof raw.toJSON === "function" ? raw.toJSON() : raw;
+			const runId = rawJson?.execution?.runId;
+			const workflowType = rawJson?.type?.name;
+			const startTimeRaw = rawJson?.startTime ?? (wf.startTime ? new Date(wf.startTime).toISOString() : void 0);
+			const closeTimeRaw = rawJson?.closeTime ?? (wf.closeTime ? new Date(wf.closeTime).toISOString() : void 0);
+			if (!runId || !workflowType || !startTimeRaw || !closeTimeRaw) continue;
+			if (this.seenCompletedRunIdSet.has(runId)) continue;
+			const durationSec = (new Date(closeTimeRaw).getTime() - new Date(startTimeRaw).getTime()) / 1e3;
+			if (durationSec < 0) continue;
+			this.workflowDuration.observe({
+				workflow_type: workflowType,
+				task_queue: this.deps.taskQueue
+			}, durationSec);
+			this.seenCompletedRunIdSet.add(runId);
+			this.seenCompletedRunIds.push(runId);
+			observed++;
+		}
+		while (this.seenCompletedRunIds.length > this.completionsSeenCapacity) {
+			const evicted = this.seenCompletedRunIds.shift();
+			if (evicted) this.seenCompletedRunIdSet.delete(evicted);
+		}
+		this.completionsLastPollMs = nowMs - this.completionsPollIntervalMs;
+		if (observed > 0) this.logger?.debug("SchedulesExporter pollCompleted observed completions", {
+			taskQueue: this.deps.taskQueue,
+			observed
+		});
+	}
+};
+function getOrCreateGauge(name, help, labelNames) {
+	const existing = promClient.register.getSingleMetric(name);
+	if (existing instanceof promClient.Gauge) return existing;
+	return new promClient.Gauge({
+		name,
+		help,
+		labelNames
+	});
+}
+function getOrCreateCounter(name, help, labelNames) {
+	const existing = promClient.register.getSingleMetric(name);
+	if (existing instanceof promClient.Counter) return existing;
+	return new promClient.Counter({
+		name,
+		help,
+		labelNames
+	});
+}
+function getOrCreateHistogram(name, help, labelNames, buckets) {
+	const existing = promClient.register.getSingleMetric(name);
+	if (existing instanceof promClient.Histogram) return existing;
+	return new promClient.Histogram({
+		name,
+		help,
+		labelNames,
+		buckets
+	});
+}
+function describeCadence(spec) {
+	const s = spec;
+	if (!s) return "unknown";
+	if (s.intervals?.length) {
+		const every = s.intervals[0].every;
+		if (typeof every === "number") return `every ${Math.round(every / 1e3)}s`;
+		return `every ${every.toString()}`;
+	}
+	if (s.cronExpressions?.length) return s.cronExpressions[0];
+	if (s.calendars?.length) {
+		const calendar = s.calendars[0];
+		return `cal ${calendar.hour ?? "*"}:${String(calendar.minute ?? 0).padStart(2, "0")}`;
+	}
+	return "unknown";
+}
+function computeCadenceSeconds(upcoming, spec) {
+	if (upcoming.length >= 2) {
+		const gap = new Date(upcoming[1]).getTime() - new Date(upcoming[0]).getTime();
+		if (gap > 0) return gap / 1e3;
+	}
+	const s = spec;
+	if (!s) return;
+	if (s.intervals?.length) {
+		const every = s.intervals[0].every;
+		if (typeof every === "number") return every / 1e3;
+	}
+	if (s.calendars?.length) return 86400;
+}
+//#endregion
+export { SchedulesExporter };

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

@@ -0,0 +1,4 @@
+//#region src/services/worker/identity.d.ts
+declare function buildWorkerIdentity(taskQueue: string, identityOverride?: string): string;
+//#endregion
+export { buildWorkerIdentity };

package/dist/services/worker/identity.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildWorkerIdentity = buildWorkerIdentity;
-const node_os_1 = require("node:os");
+import { hostname } from "node:os";
+//#region src/services/worker/identity.ts
 function buildWorkerIdentity(taskQueue, identityOverride) {
-    if (identityOverride) {
-        return identityOverride;
-    }
-    return `${(0, node_os_1.hostname)()}-${process.pid}-${taskQueue}`;
+	if (identityOverride) return identityOverride;
+	return `${hostname()}-${process.pid}-${taskQueue}`;
 }
-//# sourceMappingURL=identity.js.map
+//#endregion
+export { buildWorkerIdentity };

package/dist/services/worker.d.ts

@@ -0,0 +1,124 @@
+import { AppConfig } from "../interfaces/config.js";
+import { ActivityClass, App, NodeTracerProviderLike, WorkerBootstrapOptions } from "../interfaces/services/worker.js";
+import { WorkerHealthDetails, WorkerHealthService } from "./workerHealth.js";
+import { buildWorkerIdentity } from "./worker/identity.js";
+import { EnvService } from "@diia-inhouse/env";
+import { AlsData, Logger } from "@diia-inhouse/types";
+import { Worker, WorkerOptions } from "@temporalio/worker";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/services/worker.d.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.
+*/
+declare function applyServiceProcessConfig(config: AppConfig): void;
+/**
+* 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.
+*/
+declare function applyWorkerProcessConfig(config: AppConfig): void;
+/**
+* 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.
+*/
+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.
+*
+* 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,
+* })
+* ```
+*/
+declare function initTemporalWorker(app: App, options: {
+  nodeTracerProvider: NodeTracerProviderLike;
+  workflowsPath: string;
+  activities: Record<string, ActivityClass>;
+} & Omit<WorkerOptions, "taskQueue" | "activities" | "workflowsPath">): Promise<void>;
+/**
+* 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,
+* })
+* ```
+*/
+declare function bootstrapWorker(app: App, options: WorkerBootstrapOptions): Promise<void>;
+/**
+* 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
+*/
+declare function initWorker({
+  temporal: temporalConfig,
+  metrics: {
+    custom: metricsConfig
+  }
+}: AppConfig, options: Omit<WorkerOptions, "taskQueue"> & {
+  taskQueue?: string;
+}, envService: EnvService, logger?: Logger, nodeTracerProvider?: NodeTracerProviderLike, asyncLocalStorage?: AsyncLocalStorage<AlsData>): Promise<Worker>;
+//#endregion
+export { applyServiceProcessConfig, applyWorkerProcessConfig, bootstrapWorker, initTemporalWorker, initWorker, instantiateActivities, toWorkflowsPath };