@hotmeshio/long-tail 0.1.0

package/build/services/task/process.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listProcesses = listProcesses;
+exports.getProcessStats = getProcessStats;
+exports.getProcessTasks = getProcessTasks;
+const db_1 = require("../db");
+const types_1 = require("./types");
+const sql_1 = require("./sql");
+async function listProcesses(filters) {
+    const pool = (0, db_1.getPool)();
+    const limit = filters.limit || 50;
+    const offset = filters.offset || 0;
+    // Build WHERE conditions that restrict which origin_ids are included
+    const conditions = ['origin_id IS NOT NULL'];
+    const filterParams = [];
+    let idx = 1;
+    if (filters.workflow_type) {
+        conditions.push(`origin_id IN (
+      SELECT origin_id FROM lt_tasks
+      WHERE origin_id IS NOT NULL AND workflow_type = $${idx++}
+    )`);
+        filterParams.push(filters.workflow_type);
+    }
+    if (filters.search) {
+        const pattern = `%${filters.search}%`;
+        conditions.push(`origin_id IN (
+      SELECT DISTINCT origin_id FROM lt_tasks
+      WHERE origin_id IS NOT NULL
+        AND (origin_id ILIKE $${idx} OR workflow_id ILIKE $${idx} OR trace_id ILIKE $${idx})
+    )`);
+        filterParams.push(pattern);
+        idx++;
+    }
+    const where = `WHERE ${conditions.join(' AND ')}`;
+    // Status filter uses HAVING on aggregated counts
+    let having = '';
+    if (filters.status === 'completed') {
+        having = 'HAVING COUNT(*) = COUNT(*) FILTER (WHERE status = \'completed\')';
+    }
+    else if (filters.status === 'escalated') {
+        having = 'HAVING COUNT(*) FILTER (WHERE status = \'needs_intervention\') > 0';
+    }
+    else if (filters.status === 'active') {
+        having = `HAVING COUNT(*) > COUNT(*) FILTER (WHERE status = 'completed')
+              AND COUNT(*) FILTER (WHERE status = 'needs_intervention') = 0`;
+    }
+    // Count query — wrap in subquery because of HAVING
+    const countSql = having
+        ? `SELECT COUNT(*) FROM (
+         SELECT origin_id FROM lt_tasks ${where}
+         GROUP BY origin_id ${having}
+       ) sub`
+        : `SELECT COUNT(DISTINCT origin_id) FROM lt_tasks ${where}`;
+    const dataSql = `SELECT
+       origin_id,
+       COUNT(*)::int AS task_count,
+       COUNT(*) FILTER (WHERE status = 'completed')::int AS completed,
+       COUNT(*) FILTER (WHERE status = 'needs_intervention')::int AS escalated,
+       array_agg(DISTINCT workflow_type) AS workflow_types,
+       MIN(created_at) AS started_at,
+       MAX(COALESCE(completed_at, created_at)) AS last_activity
+     FROM lt_tasks
+     ${where}
+     GROUP BY origin_id
+     ${having}
+     ORDER BY MAX(created_at) DESC
+     LIMIT $${idx++} OFFSET $${idx++}`;
+    const dataParams = [...filterParams, limit, offset];
+    const [countResult, dataResult] = await Promise.all([
+        pool.query(countSql, filterParams),
+        pool.query(dataSql, dataParams),
+    ]);
+    return {
+        processes: dataResult.rows,
+        total: parseInt(countResult.rows[0].count, 10),
+    };
+}
+async function getProcessStats(period) {
+    const pool = (0, db_1.getPool)();
+    const interval = types_1.VALID_PERIODS[period ?? '24h'] ?? '24 hours';
+    // Aggregate process summaries within the time window
+    const { rows } = await pool.query((0, sql_1.processStatsTotals)(interval));
+    const totals = rows[0];
+    // By workflow type (most active types in the period)
+    const { rows: byType } = await pool.query((0, sql_1.processStatsByType)(interval));
+    return {
+        total: totals.total,
+        active: totals.active,
+        completed: totals.completed,
+        escalated: totals.escalated,
+        by_workflow_type: byType,
+    };
+}
+async function getProcessTasks(originId) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_PROCESS_TASKS, [originId]);
+    return rows;
+}

package/build/services/task/resolve.d.ts

@@ -0,0 +1,12 @@
+import type { ResolvedHandle } from './types';
+/**
+ * Resolve a workflowId to the (taskQueue, workflowName) pair that
+ * HotMesh needs to get a workflow handle.
+ *
+ * 1. Look up lt_tasks by workflow_id — returns workflow_type and task_queue.
+ * 2. If no task record (e.g., orchestrators/containers), fall back to
+ *    durable.jobs (entity) + lt_config_workflows (task_queue).
+ * 3. If task_queue is null (pre-migration record), fall back to lt_config_workflows.
+ * 4. Throws if the workflow cannot be resolved.
+ */
+export declare function resolveWorkflowHandle(workflowId: string): Promise<ResolvedHandle>;

package/build/services/task/resolve.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWorkflowHandle = resolveWorkflowHandle;
+const db_1 = require("../db");
+const registry_1 = require("../workers/registry");
+const sql_1 = require("./sql");
+/**
+ * Resolve a workflowId to the (taskQueue, workflowName) pair that
+ * HotMesh needs to get a workflow handle.
+ *
+ * 1. Look up lt_tasks by workflow_id — returns workflow_type and task_queue.
+ * 2. If no task record (e.g., orchestrators/containers), fall back to
+ *    durable.jobs (entity) + lt_config_workflows (task_queue).
+ * 3. If task_queue is null (pre-migration record), fall back to lt_config_workflows.
+ * 4. Throws if the workflow cannot be resolved.
+ */
+async function resolveWorkflowHandle(workflowId) {
+    const pool = (0, db_1.getPool)();
+    // 1. Try lt_tasks first (leaf workflows)
+    const { rows } = await pool.query(sql_1.RESOLVE_TASK_BY_WORKFLOW_ID, [workflowId]);
+    if (rows.length > 0) {
+        const { workflow_type, task_queue } = rows[0];
+        if (task_queue) {
+            return { taskQueue: task_queue, workflowName: workflow_type };
+        }
+        // Fallback: resolve task_queue from config (pre-migration records)
+        const { rows: configRows } = await pool.query(sql_1.RESOLVE_CONFIG_TASK_QUEUE, [workflow_type]);
+        if (configRows.length > 0 && configRows[0].task_queue) {
+            return { taskQueue: configRows[0].task_queue, workflowName: workflow_type };
+        }
+    }
+    // 2. Fall back to durable.jobs — handles orchestrators/containers that
+    //    have no lt_tasks record but do have a job with an entity tag.
+    const { rows: jobRows } = await pool.query(sql_1.RESOLVE_JOB_ENTITY, [`hmsh:durable:j:${workflowId}`]);
+    if (jobRows.length > 0 && jobRows[0].entity) {
+        const entity = jobRows[0].entity;
+        // 2a. Try lt_config_workflows for task_queue
+        const { rows: configRows } = await pool.query(sql_1.RESOLVE_CONFIG_TASK_QUEUE, [entity]);
+        if (configRows.length > 0 && configRows[0].task_queue) {
+            return { taskQueue: configRows[0].task_queue, workflowName: entity };
+        }
+        // 2b. Fall back to in-memory worker registry (unregistered durable workers)
+        const worker = (0, registry_1.getRegisteredWorkers)().get(entity);
+        if (worker) {
+            return { taskQueue: worker.taskQueue, workflowName: entity };
+        }
+    }
+    throw new Error(`Cannot resolve workflow "${workflowId}" — no task record or job entity found`);
+}

package/build/services/task/sql.d.ts

@@ -0,0 +1,19 @@
+export declare const CREATE_TASK = "\n  INSERT INTO lt_tasks\n    (workflow_id, workflow_type, lt_type, task_queue, signal_id,\n     parent_workflow_id, origin_id, parent_id, envelope, metadata, priority,\n     trace_id, span_id, initiated_by, principal_type, executing_as)\n  VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)\n  RETURNING *";
+export declare const APPEND_MILESTONES = "\n  UPDATE lt_tasks\n  SET milestones = milestones || $1::jsonb\n  WHERE id = $2\n  RETURNING *";
+export declare const GET_TASK = "SELECT * FROM lt_tasks WHERE id = $1";
+export declare const GET_TASK_BY_SIGNAL_ID = "SELECT * FROM lt_tasks WHERE signal_id = $1";
+export declare const GET_TASK_BY_WORKFLOW_ID = "SELECT * FROM lt_tasks WHERE workflow_id = $1 ORDER BY created_at DESC LIMIT 1";
+export declare const RESOLVE_TASK_BY_WORKFLOW_ID = "SELECT workflow_type, task_queue FROM lt_tasks WHERE workflow_id = $1 ORDER BY created_at DESC LIMIT 1";
+export declare const RESOLVE_CONFIG_TASK_QUEUE = "SELECT task_queue FROM lt_config_workflows WHERE workflow_type = $1";
+export declare const RESOLVE_JOB_ENTITY = "SELECT entity FROM durable.jobs WHERE key = $1 LIMIT 1";
+export declare const GET_PROCESS_TASKS = "SELECT * FROM lt_tasks WHERE origin_id = $1 ORDER BY created_at ASC";
+/**
+ * Build the process-stats totals CTE query for a given interval.
+ * The interval value MUST come from the VALID_PERIODS whitelist.
+ */
+export declare function processStatsTotals(interval: string): string;
+/**
+ * Build the process-stats-by-type CTE query for a given interval.
+ * The interval value MUST come from the VALID_PERIODS whitelist.
+ */
+export declare function processStatsByType(interval: string): string;

package/build/services/task/sql.js

@@ -0,0 +1,92 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// Task service — externalized SQL
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET_PROCESS_TASKS = exports.RESOLVE_JOB_ENTITY = exports.RESOLVE_CONFIG_TASK_QUEUE = exports.RESOLVE_TASK_BY_WORKFLOW_ID = exports.GET_TASK_BY_WORKFLOW_ID = exports.GET_TASK_BY_SIGNAL_ID = exports.GET_TASK = exports.APPEND_MILESTONES = exports.CREATE_TASK = void 0;
+exports.processStatsTotals = processStatsTotals;
+exports.processStatsByType = processStatsByType;
+// ---- crud.ts queries ------------------------------------------------------
+exports.CREATE_TASK = `
+  INSERT INTO lt_tasks
+    (workflow_id, workflow_type, lt_type, task_queue, signal_id,
+     parent_workflow_id, origin_id, parent_id, envelope, metadata, priority,
+     trace_id, span_id, initiated_by, principal_type, executing_as)
+  VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
+  RETURNING *`;
+exports.APPEND_MILESTONES = `
+  UPDATE lt_tasks
+  SET milestones = milestones || $1::jsonb
+  WHERE id = $2
+  RETURNING *`;
+exports.GET_TASK = `SELECT * FROM lt_tasks WHERE id = $1`;
+exports.GET_TASK_BY_SIGNAL_ID = `SELECT * FROM lt_tasks WHERE signal_id = $1`;
+exports.GET_TASK_BY_WORKFLOW_ID = `SELECT * FROM lt_tasks WHERE workflow_id = $1 ORDER BY created_at DESC LIMIT 1`;
+// ---- resolve.ts queries ---------------------------------------------------
+exports.RESOLVE_TASK_BY_WORKFLOW_ID = `SELECT workflow_type, task_queue FROM lt_tasks WHERE workflow_id = $1 ORDER BY created_at DESC LIMIT 1`;
+exports.RESOLVE_CONFIG_TASK_QUEUE = `SELECT task_queue FROM lt_config_workflows WHERE workflow_type = $1`;
+exports.RESOLVE_JOB_ENTITY = `SELECT entity FROM durable.jobs WHERE key = $1 LIMIT 1`;
+// ---- process.ts queries ---------------------------------------------------
+exports.GET_PROCESS_TASKS = `SELECT * FROM lt_tasks WHERE origin_id = $1 ORDER BY created_at ASC`;
+/**
+ * Build the process-stats totals CTE query for a given interval.
+ * The interval value MUST come from the VALID_PERIODS whitelist.
+ */
+function processStatsTotals(interval) {
+    return `
+    WITH process_stats AS (
+      SELECT
+        origin_id,
+        COUNT(*)::int AS task_count,
+        COUNT(*) FILTER (WHERE status = 'completed')::int AS completed_count,
+        COUNT(*) FILTER (WHERE status = 'needs_intervention')::int AS escalated_count
+      FROM lt_tasks
+      WHERE origin_id IS NOT NULL
+        AND created_at > NOW() - INTERVAL '${interval}'
+      GROUP BY origin_id
+    )
+    SELECT
+      COUNT(*)::int AS total,
+      COUNT(*) FILTER (WHERE completed_count = task_count AND task_count > 0)::int AS completed,
+      COUNT(*) FILTER (WHERE escalated_count > 0)::int AS escalated,
+      COUNT(*) FILTER (
+        WHERE completed_count < task_count
+          AND escalated_count = 0
+      )::int AS active
+    FROM process_stats`;
+}
+/**
+ * Build the process-stats-by-type CTE query for a given interval.
+ * The interval value MUST come from the VALID_PERIODS whitelist.
+ */
+function processStatsByType(interval) {
+    return `
+    WITH task_window AS (
+      SELECT
+        origin_id,
+        workflow_type,
+        status
+      FROM lt_tasks
+      WHERE origin_id IS NOT NULL
+        AND created_at > NOW() - INTERVAL '${interval}'
+    ),
+    per_origin AS (
+      SELECT
+        origin_id,
+        COUNT(*)::int AS task_count,
+        COUNT(*) FILTER (WHERE status = 'completed')::int AS completed_count,
+        COUNT(*) FILTER (WHERE status = 'needs_intervention')::int AS escalated_count,
+        (array_agg(DISTINCT workflow_type))[1] AS primary_workflow_type
+      FROM task_window
+      GROUP BY origin_id
+    )
+    SELECT
+      primary_workflow_type AS workflow_type,
+      COUNT(*)::int AS total,
+      COUNT(*) FILTER (WHERE completed_count < task_count AND escalated_count = 0)::int AS active,
+      COUNT(*) FILTER (WHERE completed_count = task_count AND task_count > 0)::int AS completed,
+      COUNT(*) FILTER (WHERE escalated_count > 0)::int AS escalated
+    FROM per_origin
+    GROUP BY primary_workflow_type
+    ORDER BY COUNT(*) DESC`;
+}

package/build/services/task/types.d.ts

@@ -0,0 +1,56 @@
+import type { LTTaskStatus, LTMilestone } from '../../types';
+export interface ResolvedHandle {
+    taskQueue: string;
+    workflowName: string;
+}
+export interface CreateTaskInput {
+    workflow_id: string;
+    workflow_type: string;
+    lt_type: string;
+    task_queue?: string;
+    signal_id: string;
+    parent_workflow_id: string;
+    origin_id?: string;
+    parent_id?: string;
+    envelope: string;
+    metadata?: Record<string, any>;
+    priority?: number;
+    trace_id?: string;
+    span_id?: string;
+    /** User or bot ID that initiated this task (for audit trail). */
+    initiated_by?: string;
+    /** Principal type: 'user' or 'bot'. */
+    principal_type?: string;
+    /** Executing principal (bot external_id) when proxy invocation is used. */
+    executing_as?: string;
+}
+export interface UpdateTaskInput {
+    status?: LTTaskStatus;
+    completed_at?: Date;
+    error?: string;
+    milestones?: LTMilestone[];
+    data?: string;
+}
+export interface ProcessSummary {
+    origin_id: string;
+    task_count: number;
+    completed: number;
+    escalated: number;
+    workflow_types: string[];
+    started_at: string;
+    last_activity: string;
+}
+export interface ProcessStats {
+    total: number;
+    active: number;
+    completed: number;
+    escalated: number;
+    by_workflow_type: {
+        workflow_type: string;
+        total: number;
+        active: number;
+        completed: number;
+        escalated: number;
+    }[];
+}
+export declare const VALID_PERIODS: Record<string, string>;

package/build/services/task/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALID_PERIODS = void 0;
+exports.VALID_PERIODS = {
+    '1h': '1 hour',
+    '24h': '24 hours',
+    '7d': '7 days',
+    '30d': '30 days',
+};

package/build/services/telemetry/honeycomb.d.ts

@@ -0,0 +1,53 @@
+import type { LTTelemetryAdapter } from '../../types/telemetry';
+export interface HoneycombOptions {
+    /** Honeycomb API key (defaults to HONEYCOMB_API_KEY env var) */
+    apiKey?: string;
+    /** Service name reported to Honeycomb (defaults to 'long-tail') */
+    serviceName?: string;
+    /** Honeycomb OTLP endpoint (defaults to https://api.honeycomb.io) */
+    endpoint?: string;
+    /**
+     * URL template for deep-linking to traces in Honeycomb UI.
+     * Use `{traceId}` as a placeholder, e.g.:
+     * `https://ui.honeycomb.io/my-team/environments/prod/trace?trace_id={traceId}`
+     */
+    traceUrl?: string;
+}
+/**
+ * Honeycomb telemetry adapter.
+ *
+ * Configures the OpenTelemetry Node.js SDK with an OTLP exporter
+ * pointed at Honeycomb. Once connected, all spans created by HotMesh
+ * (workflow executions, activity calls, stream routing) are
+ * automatically exported to Honeycomb.
+ *
+ * HotMesh uses `@opentelemetry/api` internally to create spans. This
+ * adapter provides the TracerProvider + exporter that captures them.
+ *
+ * Usage:
+ * ```typescript
+ * import { telemetryRegistry } from './services/telemetry';
+ * import { HoneycombTelemetryAdapter } from './services/telemetry/honeycomb';
+ *
+ * telemetryRegistry.register(new HoneycombTelemetryAdapter({
+ *   apiKey: process.env.HONEYCOMB_API_KEY,
+ *   serviceName: 'my-app',
+ * }));
+ * await telemetryRegistry.connect(); // before starting workers
+ * ```
+ */
+export declare class HoneycombTelemetryAdapter implements LTTelemetryAdapter {
+    private sdk;
+    private readonly apiKey;
+    private readonly serviceName;
+    private readonly endpoint;
+    readonly traceUrl?: string;
+    constructor(options?: HoneycombOptions);
+    /**
+     * Auto-derive the Honeycomb trace URL from standard env vars.
+     * Returns undefined if HONEYCOMB_TEAM or HONEYCOMB_ENVIRONMENT are not set.
+     */
+    private static deriveTraceUrl;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/build/services/telemetry/honeycomb.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoneycombTelemetryAdapter = void 0;
+const sdk_node_1 = require("@opentelemetry/sdk-node");
+const exporter_trace_otlp_proto_1 = require("@opentelemetry/exporter-trace-otlp-proto");
+const resources_1 = require("@opentelemetry/resources");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const logger_1 = require("../logger");
+/**
+ * Honeycomb telemetry adapter.
+ *
+ * Configures the OpenTelemetry Node.js SDK with an OTLP exporter
+ * pointed at Honeycomb. Once connected, all spans created by HotMesh
+ * (workflow executions, activity calls, stream routing) are
+ * automatically exported to Honeycomb.
+ *
+ * HotMesh uses `@opentelemetry/api` internally to create spans. This
+ * adapter provides the TracerProvider + exporter that captures them.
+ *
+ * Usage:
+ * ```typescript
+ * import { telemetryRegistry } from './services/telemetry';
+ * import { HoneycombTelemetryAdapter } from './services/telemetry/honeycomb';
+ *
+ * telemetryRegistry.register(new HoneycombTelemetryAdapter({
+ *   apiKey: process.env.HONEYCOMB_API_KEY,
+ *   serviceName: 'my-app',
+ * }));
+ * await telemetryRegistry.connect(); // before starting workers
+ * ```
+ */
+class HoneycombTelemetryAdapter {
+    constructor(options) {
+        this.sdk = null;
+        this.apiKey = options?.apiKey || process.env.HONEYCOMB_API_KEY || '';
+        this.serviceName = options?.serviceName || 'long-tail';
+        this.endpoint = options?.endpoint || 'https://api.honeycomb.io';
+        this.traceUrl = options?.traceUrl || HoneycombTelemetryAdapter.deriveTraceUrl(this.serviceName);
+    }
+    /**
+     * Auto-derive the Honeycomb trace URL from standard env vars.
+     * Returns undefined if HONEYCOMB_TEAM or HONEYCOMB_ENVIRONMENT are not set.
+     */
+    static deriveTraceUrl(dataset) {
+        const team = process.env.HONEYCOMB_TEAM;
+        const env = process.env.HONEYCOMB_ENVIRONMENT;
+        if (!team || !env)
+            return undefined;
+        return `https://ui.honeycomb.io/${team}/environments/${env}/datasets/${dataset}/trace?trace_id={traceId}`;
+    }
+    async connect() {
+        if (!this.apiKey) {
+            logger_1.loggerRegistry.warn('[telemetry] HONEYCOMB_API_KEY not set — skipping Honeycomb telemetry');
+            return;
+        }
+        const exporter = new exporter_trace_otlp_proto_1.OTLPTraceExporter({
+            url: `${this.endpoint}/v1/traces`,
+            headers: {
+                'x-honeycomb-team': this.apiKey,
+            },
+        });
+        this.sdk = new sdk_node_1.NodeSDK({
+            resource: (0, resources_1.resourceFromAttributes)({
+                [semantic_conventions_1.ATTR_SERVICE_NAME]: this.serviceName,
+            }),
+            traceExporter: exporter,
+        });
+        this.sdk.start();
+        logger_1.loggerRegistry.info(`[telemetry] Honeycomb connected (service: ${this.serviceName})`);
+    }
+    async disconnect() {
+        if (!this.sdk)
+            return;
+        await this.sdk.shutdown();
+        this.sdk = null;
+        logger_1.loggerRegistry.info('[telemetry] Honeycomb disconnected');
+    }
+}
+exports.HoneycombTelemetryAdapter = HoneycombTelemetryAdapter;

package/build/services/telemetry/index.d.ts

@@ -0,0 +1,46 @@
+import type { LTTelemetryAdapter } from '../../types/telemetry';
+/**
+ * Singleton registry for the telemetry adapter.
+ *
+ * Unlike the event registry (which fans out to multiple adapters),
+ * telemetry uses a single adapter because OTEL only supports one
+ * global TracerProvider at a time.
+ *
+ * The adapter must be registered and connected BEFORE HotMesh
+ * workers start so that spans are captured from the first workflow.
+ */
+declare class LTTelemetryRegistry {
+    private adapter;
+    private connected;
+    /**
+     * Register a telemetry adapter. Call before connect().
+     * Replaces any previously registered adapter.
+     */
+    register(adapter: LTTelemetryAdapter): void;
+    /**
+     * Connect the registered adapter (initializes OTEL SDK).
+     * Must be called before HotMesh workers start.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect the adapter (flush + shutdown OTEL SDK).
+     * Call during graceful shutdown.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Remove the adapter and reset state. Used in tests.
+     */
+    clear(): void;
+    /**
+     * Check if an adapter is registered.
+     */
+    get hasAdapter(): boolean;
+    /**
+     * Trace URL template from the registered adapter (if any).
+     * Contains `{traceId}` placeholder for substitution.
+     */
+    get traceUrl(): string | undefined;
+}
+/** Singleton telemetry registry */
+export declare const telemetryRegistry: LTTelemetryRegistry;
+export {};

package/build/services/telemetry/index.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telemetryRegistry = void 0;
+/**
+ * Singleton registry for the telemetry adapter.
+ *
+ * Unlike the event registry (which fans out to multiple adapters),
+ * telemetry uses a single adapter because OTEL only supports one
+ * global TracerProvider at a time.
+ *
+ * The adapter must be registered and connected BEFORE HotMesh
+ * workers start so that spans are captured from the first workflow.
+ */
+class LTTelemetryRegistry {
+    constructor() {
+        this.adapter = null;
+        this.connected = false;
+    }
+    /**
+     * Register a telemetry adapter. Call before connect().
+     * Replaces any previously registered adapter.
+     */
+    register(adapter) {
+        this.adapter = adapter;
+    }
+    /**
+     * Connect the registered adapter (initializes OTEL SDK).
+     * Must be called before HotMesh workers start.
+     */
+    async connect() {
+        if (this.connected || !this.adapter)
+            return;
+        await this.adapter.connect();
+        this.connected = true;
+    }
+    /**
+     * Disconnect the adapter (flush + shutdown OTEL SDK).
+     * Call during graceful shutdown.
+     */
+    async disconnect() {
+        if (!this.adapter)
+            return;
+        await this.adapter.disconnect();
+        this.connected = false;
+    }
+    /**
+     * Remove the adapter and reset state. Used in tests.
+     */
+    clear() {
+        this.adapter = null;
+        this.connected = false;
+    }
+    /**
+     * Check if an adapter is registered.
+     */
+    get hasAdapter() {
+        return this.adapter !== null;
+    }
+    /**
+     * Trace URL template from the registered adapter (if any).
+     * Contains `{traceId}` placeholder for substitution.
+     */
+    get traceUrl() {
+        return this.adapter?.traceUrl;
+    }
+}
+/** Singleton telemetry registry */
+exports.telemetryRegistry = new LTTelemetryRegistry();

package/build/services/user/auth.d.ts

@@ -0,0 +1,7 @@
+import type { LTUserRecord } from '../../types';
+/**
+ * Verify a user's password. Returns the full user record (with roles)
+ * on success, or null if the external_id doesn't exist, the user has
+ * no password set, or the password doesn't match.
+ */
+export declare function verifyPassword(externalId: string, password: string): Promise<LTUserRecord | null>;

package/build/services/user/auth.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyPassword = verifyPassword;
+const bcryptjs_1 = __importDefault(require("bcryptjs"));
+const db_1 = require("../db");
+const crud_1 = require("./crud");
+const sql_1 = require("./sql");
+// ─── Password authentication ────────────────────────────────────────────────
+/**
+ * Verify a user's password. Returns the full user record (with roles)
+ * on success, or null if the external_id doesn't exist, the user has
+ * no password set, or the password doesn't match.
+ */
+async function verifyPassword(externalId, password) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_USER_BY_EXTERNAL_ID, [externalId]);
+    if (!rows[0] || !rows[0].password_hash)
+        return null;
+    const valid = await bcryptjs_1.default.compare(password, rows[0].password_hash);
+    if (!valid)
+        return null;
+    return (0, crud_1.attachRoles)(rows[0]);
+}

package/build/services/user/crud.d.ts

@@ -0,0 +1,19 @@
+import type { LTUserRecord, LTRoleType, LTUserStatus } from '../../types';
+import type { CreateUserInput, UpdateUserInput } from './types';
+export declare function attachRoles(user: any): Promise<LTUserRecord>;
+export declare function createUser(input: CreateUserInput): Promise<LTUserRecord>;
+export declare function getUser(id: string): Promise<LTUserRecord | null>;
+export declare function getUserByExternalId(externalId: string): Promise<LTUserRecord | null>;
+export declare function getUserByEmail(email: string): Promise<LTUserRecord | null>;
+export declare function updateUser(id: string, input: UpdateUserInput): Promise<LTUserRecord | null>;
+export declare function deleteUser(id: string): Promise<boolean>;
+export declare function listUsers(filters: {
+    role?: string;
+    roleType?: LTRoleType;
+    status?: LTUserStatus;
+    limit?: number;
+    offset?: number;
+}): Promise<{
+    users: LTUserRecord[];
+    total: number;
+}>;