@hotmeshio/long-tail 0.1.0

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

@@ -0,0 +1,39 @@
+import type { ExecutionExportOptions, WorkflowExecution } from '@hotmeshio/hotmesh/build/types/exporter';
+import type { LTExportOptions, LTWorkflowExport } from '../../types';
+import type { JobListParams, JobListResult } from './types';
+/**
+ * Export the full workflow state for a given workflow (raw HotMesh format).
+ *
+ * Delegates to the HotMesh Durable `handle.export()` method and
+ * normalises the result into an `LTWorkflowExport`.
+ */
+export declare function exportWorkflow(workflowId: string, taskQueue: string, workflowName: string, options?: LTExportOptions): Promise<LTWorkflowExport>;
+/**
+ * Return only the status semaphore for a workflow.
+ * 0 = complete, negative = interrupted.
+ */
+export declare function getWorkflowStatus(workflowId: string, taskQueue: string, workflowName: string): Promise<{
+    workflow_id: string;
+    status: number;
+}>;
+/**
+ * Export workflow state as a structured execution event history.
+ *
+ * Delegates to HotMesh's native `handle.exportExecution()` which produces
+ * typed events with ISO timestamps, durations, event cross-references,
+ * system/user classification, and a summary.
+ */
+export declare function exportWorkflowExecution(workflowId: string, taskQueue: string, workflowName: string, options?: ExecutionExportOptions): Promise<WorkflowExecution>;
+/**
+ * Return the current job state of a workflow.
+ * If the workflow is complete this is also the output.
+ */
+export declare function getWorkflowState(workflowId: string, taskQueue: string, workflowName: string): Promise<{
+    workflow_id: string;
+    state: Record<string, any>;
+}>;
+/**
+ * List workflow jobs from durable.jobs where entity IS NOT NULL.
+ * Returns paginated results sorted by active first, then created_at DESC.
+ */
+export declare function listJobs(params: JobListParams): Promise<JobListResult>;

package/build/services/export/index.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportWorkflow = exportWorkflow;
+exports.getWorkflowStatus = getWorkflowStatus;
+exports.exportWorkflowExecution = exportWorkflowExecution;
+exports.getWorkflowState = getWorkflowState;
+exports.listJobs = listJobs;
+const db_1 = require("../db");
+const client_1 = require("./client");
+const post_process_1 = require("./post-process");
+/** Error thrown when a workflow job is not found (expired or never existed). */
+class WorkflowNotFoundError extends Error {
+    constructor(workflowId) {
+        super(`${workflowId} Not Found`);
+        this.status = 404;
+        this.name = 'WorkflowNotFoundError';
+    }
+}
+/**
+ * Export the full workflow state for a given workflow (raw HotMesh format).
+ *
+ * Delegates to the HotMesh Durable `handle.export()` method and
+ * normalises the result into an `LTWorkflowExport`.
+ */
+async function exportWorkflow(workflowId, taskQueue, workflowName, options) {
+    try {
+        const handle = await (0, client_1.getHandle)(taskQueue, workflowName, workflowId);
+        const raw = await handle.export({ ...options, enrich_inputs: true });
+        return {
+            workflow_id: workflowId,
+            data: raw.data,
+            state: raw.state,
+            status: raw.status,
+            timeline: raw.timeline,
+            transitions: raw.transitions,
+        };
+    }
+    catch (err) {
+        if (err instanceof WorkflowNotFoundError)
+            throw err;
+        throw new WorkflowNotFoundError(workflowId);
+    }
+}
+/**
+ * Return only the status semaphore for a workflow.
+ * 0 = complete, negative = interrupted.
+ */
+async function getWorkflowStatus(workflowId, taskQueue, workflowName) {
+    try {
+        const handle = await (0, client_1.getHandle)(taskQueue, workflowName, workflowId);
+        const status = await handle.status();
+        return { workflow_id: workflowId, status };
+    }
+    catch {
+        throw new WorkflowNotFoundError(workflowId);
+    }
+}
+/**
+ * Export workflow state as a structured execution event history.
+ *
+ * Delegates to HotMesh's native `handle.exportExecution()` which produces
+ * typed events with ISO timestamps, durations, event cross-references,
+ * system/user classification, and a summary.
+ */
+async function exportWorkflowExecution(workflowId, taskQueue, workflowName, options) {
+    try {
+        const handle = await (0, client_1.getHandle)(taskQueue, workflowName, workflowId);
+        const execution = await handle.exportExecution({ ...options, enrich_inputs: true });
+        return (0, post_process_1.postProcessExecution)(execution);
+    }
+    catch (err) {
+        if (err instanceof WorkflowNotFoundError)
+            throw err;
+        throw new WorkflowNotFoundError(workflowId);
+    }
+}
+/**
+ * Return the current job state of a workflow.
+ * If the workflow is complete this is also the output.
+ */
+async function getWorkflowState(workflowId, taskQueue, workflowName) {
+    try {
+        const handle = await (0, client_1.getHandle)(taskQueue, workflowName, workflowId);
+        const state = await handle.state(true);
+        return { workflow_id: workflowId, state };
+    }
+    catch {
+        throw new WorkflowNotFoundError(workflowId);
+    }
+}
+const JOB_SORTABLE_COLUMNS = new Set(['created_at', 'updated_at', 'entity', 'status']);
+function buildJobOrderBy(sortBy, order) {
+    if (!sortBy || !JOB_SORTABLE_COLUMNS.has(sortBy)) {
+        return '(CASE WHEN j.status > 0 THEN 0 ELSE 1 END), j.created_at DESC';
+    }
+    const dir = order === 'asc' ? 'ASC' : 'DESC';
+    return `j.${sortBy} ${dir}`;
+}
+/**
+ * List workflow jobs from durable.jobs where entity IS NOT NULL.
+ * Returns paginated results sorted by active first, then created_at DESC.
+ */
+async function listJobs(params) {
+    const limit = Math.min(params.limit ?? 20, 100);
+    const offset = params.offset ?? 0;
+    const pool = (0, db_1.getPool)();
+    const conditions = ['j.entity IS NOT NULL'];
+    const values = [];
+    let idx = 1;
+    if (params.registered === 'true') {
+        conditions.push(`EXISTS (SELECT 1 FROM lt_config_workflows c WHERE c.workflow_type = j.entity)`);
+    }
+    else if (params.registered === 'false') {
+        conditions.push(`NOT EXISTS (SELECT 1 FROM lt_config_workflows c WHERE c.workflow_type = j.entity)`);
+    }
+    if (params.entity) {
+        const entities = params.entity.split(',').map((e) => e.trim()).filter(Boolean);
+        if (entities.length === 1) {
+            conditions.push(`j.entity = $${idx++}`);
+            values.push(entities[0]);
+        }
+        else if (entities.length > 1) {
+            conditions.push(`j.entity = ANY($${idx++})`);
+            values.push(entities);
+        }
+    }
+    if (params.search) {
+        conditions.push(`j.key ILIKE $${idx++}`);
+        values.push(`%${params.search}%`);
+    }
+    if (params.status === 'running') {
+        conditions.push('j.status > 0');
+    }
+    else if (params.status === 'completed') {
+        conditions.push('j.status = 0');
+    }
+    else if (params.status === 'failed') {
+        conditions.push('j.status < 0');
+    }
+    const where = conditions.join(' AND ');
+    const [countResult, dataResult] = await Promise.all([
+        pool.query(`SELECT COUNT(*) FROM durable.jobs j WHERE ${where}`, values),
+        pool.query(`SELECT j.key, j.entity, j.status, j.is_live, j.created_at, j.updated_at
+       FROM durable.jobs j
+       WHERE ${where}
+       ORDER BY ${buildJobOrderBy(params.sort_by, params.order)}
+       LIMIT $${idx++} OFFSET $${idx++}`, [...values, limit, offset]),
+    ]);
+    const jobs = dataResult.rows.map((row) => ({
+        workflow_id: row.key.replace('hmsh:durable:j:', ''),
+        entity: row.entity,
+        status: (row.status > 0 ? 'running' : row.status === 0 ? 'completed' : 'failed'),
+        is_live: row.is_live,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    }));
+    return { jobs, total: parseInt(countResult.rows[0].count, 10) };
+}

package/build/services/export/post-process.d.ts

@@ -0,0 +1,16 @@
+import type { WorkflowExecution } from '@hotmeshio/hotmesh/build/types/exporter';
+/**
+ * Post-process execution events to improve timeline visualization:
+ *
+ * 1. Fire-and-forget child starts (`startChild`): set duration_ms = 0
+ *    so they render as a narrow completed band instead of pending.
+ *
+ * 2. Completed signals (`waitFor` that received a signal): split into
+ *    signal_wait_started + workflow_execution_signaled pair so the
+ *    timeline can show the full wait duration as a band.
+ *
+ * 3. Running workflows: inject a pending signal_wait_started event
+ *    after any fire-and-forget start that lacks a matching signal,
+ *    so the timeline shows a growing orange "pending" band.
+ */
+export declare function postProcessExecution(execution: WorkflowExecution): WorkflowExecution;

package/build/services/export/post-process.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postProcessExecution = postProcessExecution;
+/**
+ * Post-process execution events to improve timeline visualization:
+ *
+ * 1. Fire-and-forget child starts (`startChild`): set duration_ms = 0
+ *    so they render as a narrow completed band instead of pending.
+ *
+ * 2. Completed signals (`waitFor` that received a signal): split into
+ *    signal_wait_started + workflow_execution_signaled pair so the
+ *    timeline can show the full wait duration as a band.
+ *
+ * 3. Running workflows: inject a pending signal_wait_started event
+ *    after any fire-and-forget start that lacks a matching signal,
+ *    so the timeline shows a growing orange "pending" band.
+ */
+function postProcessExecution(execution) {
+    const events = execution.events.map((e) => ({
+        ...e,
+        attributes: { ...e.attributes },
+    }));
+    const isRunning = !events.some((e) => e.event_type === 'workflow_execution_completed' ||
+        e.event_type === 'workflow_execution_failed');
+    let nextId = events.length > 0 ? Math.max(...events.map((e) => e.event_id)) + 1 : 1;
+    const toAdd = [];
+    // Enrich ltSignalParent activities with the workflow result as their payload.
+    // The activity returns void, but it sends execution.result to the parent --
+    // surfacing this makes the signal content visible in the UI.
+    let enriched = false;
+    if (execution.result) {
+        for (const evt of events) {
+            const attrs = evt.attributes;
+            if (evt.event_type === 'activity_task_completed' &&
+                attrs.activity_type === 'ltSignalParent' &&
+                (attrs.result === undefined || attrs.result === null)) {
+                attrs.result = execution.result;
+                enriched = true;
+            }
+        }
+    }
+    // Existing signal completions and wait-start events (keyed by timeline_key)
+    const signalKeys = new Set(events
+        .filter((e) => e.event_type === 'workflow_execution_signaled')
+        .map((e) => e.attributes.timeline_key)
+        .filter(Boolean));
+    const existingWaitStarts = new Set(events
+        .filter((e) => e.event_type === 'signal_wait_started')
+        .map((e) => e.attributes.timeline_key)
+        .filter(Boolean));
+    for (const evt of events) {
+        const attrs = evt.attributes;
+        // 1. Fire-and-forget starts: completed instantly
+        if (evt.event_type === 'child_workflow_execution_started' &&
+            attrs.awaited === false &&
+            evt.duration_ms === null) {
+            evt.duration_ms = 0;
+        }
+        // 2. Completed signals: inject signal_wait_started before completion
+        if (evt.event_type === 'workflow_execution_signaled' &&
+            evt.duration_ms != null &&
+            evt.duration_ms > 0 &&
+            attrs.timeline_key &&
+            !existingWaitStarts.has(attrs.timeline_key)) {
+            const waitStartTime = new Date(new Date(evt.event_time).getTime() - evt.duration_ms).toISOString();
+            toAdd.push({
+                event_id: nextId++,
+                event_type: 'signal_wait_started',
+                category: 'signal',
+                event_time: waitStartTime,
+                duration_ms: null,
+                is_system: false,
+                attributes: {
+                    kind: 'signal_wait_started',
+                    signal_name: attrs.signal_name,
+                    timeline_key: attrs.timeline_key,
+                    execution_index: attrs.execution_index,
+                },
+            });
+        }
+    }
+    // 3. Running workflows: inject pending waits after unmatched fire-and-forget starts
+    if (isRunning) {
+        for (const evt of events) {
+            const attrs = evt.attributes;
+            if (evt.event_type === 'child_workflow_execution_started' &&
+                attrs.awaited === false) {
+                const startIndex = attrs.execution_index;
+                const childId = attrs.child_workflow_id;
+                const waitIndex = startIndex + 1;
+                const waitKey = `-wait-${waitIndex}-`;
+                if (!signalKeys.has(waitKey) && !existingWaitStarts.has(waitKey)) {
+                    toAdd.push({
+                        event_id: nextId++,
+                        event_type: 'signal_wait_started',
+                        category: 'signal',
+                        event_time: evt.event_time,
+                        duration_ms: null,
+                        is_system: false,
+                        attributes: {
+                            kind: 'signal_wait_started',
+                            signal_name: `lt-result-${childId}`,
+                            timeline_key: waitKey,
+                            execution_index: waitIndex,
+                        },
+                    });
+                }
+            }
+        }
+    }
+    if (toAdd.length === 0 && !enriched)
+        return execution;
+    if (toAdd.length === 0) {
+        return { ...execution, events };
+    }
+    events.push(...toAdd);
+    // Re-sort chronologically and re-number
+    events.sort((a, b) => {
+        const cmp = a.event_time.localeCompare(b.event_time);
+        return cmp !== 0 ? cmp : a.event_id - b.event_id;
+    });
+    for (let i = 0; i < events.length; i++) {
+        events[i].event_id = i + 1;
+    }
+    return {
+        ...execution,
+        events,
+        summary: {
+            ...execution.summary,
+            total_events: events.length,
+        },
+    };
+}

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

@@ -0,0 +1,25 @@
+/** Filters accepted by the job listing service function. */
+export interface JobListParams {
+    limit?: number;
+    offset?: number;
+    entity?: string;
+    search?: string;
+    status?: string;
+    sort_by?: string;
+    order?: string;
+    registered?: string;
+}
+/** A single job row returned by listJobs(). */
+export interface JobRow {
+    workflow_id: string;
+    entity: string;
+    status: 'running' | 'completed' | 'failed';
+    is_live: boolean;
+    created_at: string;
+    updated_at: string;
+}
+/** Paginated result from listJobs(). */
+export interface JobListResult {
+    jobs: JobRow[];
+    total: number;
+}

package/build/services/export/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/services/hotmesh-utils.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Convert HotMesh's compact timestamp (YYYYMMDDHHmmss.SSS) to ISO 8601.
+ */
+export declare function hmshTimestampToISO(ts: string): string;
+/**
+ * Compute duration in milliseconds between two HotMesh compact timestamps.
+ */
+export declare function computeDuration(ac?: string, au?: string): number | null;
+/**
+ * Deserialize a HotMesh serialized value.
+ * Prefix conventions: /s = JSON, /d = number, /t = true, /f = false, /n = null.
+ */
+export declare function fromString(value: string): unknown;
+/**
+ * Validate and sanitize an app_id for use as a Postgres schema name.
+ */
+export declare function sanitizeAppId(appId: string): string;
+/**
+ * Quote a schema name for safe use in SQL queries (Postgres identifier quoting).
+ */
+export declare function quoteSchema(schema: string): string;
+/** Schema-qualified symbol lookup — schema is injected as an identifier, not a parameter. */
+export declare const LOAD_SYMBOL_MAP: (schema: string) => string;
+/**
+ * Load all symbol key mappings from {schema}.symbols for the given appId.
+ * Returns a reverse map: abbreviated 3-char key → human-readable path.
+ */
+export declare function loadSymbolMap(schema: string, appId: string): Promise<Record<string, string>>;
+/**
+ * Inflate raw HotMesh job attributes using the symbol map.
+ * Converts abbreviated 3-char keys + dimensional indices into
+ * human-readable "dimensions/path" entries with deserialized values.
+ *
+ * Key patterns:
+ *   "abc"          → 3-char job-level key (metadata/jc, data/summary, etc.)
+ *   "abc,N,M,..."  → activity/transition key with dimensional index
+ *   ":"            → status semaphore
+ */
+export declare function inflateAttributes(attrs: Record<string, string>, symbolMap: Record<string, string>): Record<string, unknown>;
+/**
+ * Rebuild a nested object from a flat "dim1/dim2/.../path" → value map.
+ */
+export declare function restoreHierarchy(flat: Record<string, unknown>): Record<string, unknown>;
+export interface ActivityInfo {
+    name: string;
+    type: string;
+    step: string;
+    ac: string | null;
+    au: string | null;
+    traceId: string | null;
+    spanId: string | null;
+    error: string | null;
+    data: Record<string, unknown> | null;
+    dimensions: string;
+}
+/**
+ * Walk an inflated HotMesh hierarchy to extract all activities/transitions.
+ * Recurses through numeric dimension keys, collecting activity nodes that
+ * have an `output.metadata` subtree.
+ */
+export declare function extractActivities(hierarchy: Record<string, unknown>): ActivityInfo[];

package/build/services/hotmesh-utils.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOAD_SYMBOL_MAP = void 0;
+exports.hmshTimestampToISO = hmshTimestampToISO;
+exports.computeDuration = computeDuration;
+exports.fromString = fromString;
+exports.sanitizeAppId = sanitizeAppId;
+exports.quoteSchema = quoteSchema;
+exports.loadSymbolMap = loadSymbolMap;
+exports.inflateAttributes = inflateAttributes;
+exports.restoreHierarchy = restoreHierarchy;
+exports.extractActivities = extractActivities;
+const db_1 = require("./db");
+// ── HotMesh timestamp helpers ───────────────────────────────────────────────
+/**
+ * Convert HotMesh's compact timestamp (YYYYMMDDHHmmss.SSS) to ISO 8601.
+ */
+function hmshTimestampToISO(ts) {
+    if (!ts || ts.length < 14)
+        return ts;
+    const y = ts.slice(0, 4);
+    const mo = ts.slice(4, 6);
+    const d = ts.slice(6, 8);
+    const h = ts.slice(8, 10);
+    const mi = ts.slice(10, 12);
+    const rest = ts.slice(12); // ss.SSS
+    return `${y}-${mo}-${d}T${h}:${mi}:${rest}Z`;
+}
+/**
+ * Compute duration in milliseconds between two HotMesh compact timestamps.
+ */
+function computeDuration(ac, au) {
+    if (!ac || !au)
+        return null;
+    const s = new Date(hmshTimestampToISO(ac)).getTime();
+    const e = new Date(hmshTimestampToISO(au)).getTime();
+    return e >= s ? e - s : null;
+}
+// ── HotMesh serialization ───────────────────────────────────────────────────
+/**
+ * Deserialize a HotMesh serialized value.
+ * Prefix conventions: /s = JSON, /d = number, /t = true, /f = false, /n = null.
+ */
+function fromString(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const prefix = value.slice(0, 2);
+    const rest = value.slice(2);
+    switch (prefix) {
+        case '/t': return true;
+        case '/f': return false;
+        case '/d': return Number(rest);
+        case '/n': return null;
+        case '/s': return JSON.parse(rest);
+        default: return value;
+    }
+}
+// ── Schema helpers ──────────────────────────────────────────────────────────
+/**
+ * Validate and sanitize an app_id for use as a Postgres schema name.
+ */
+function sanitizeAppId(appId) {
+    if (!/^[a-zA-Z0-9_.-]+$/.test(appId)) {
+        throw new Error('Invalid app_id: must contain only alphanumeric characters, underscores, hyphens, and dots');
+    }
+    return appId;
+}
+/**
+ * Quote a schema name for safe use in SQL queries (Postgres identifier quoting).
+ */
+function quoteSchema(schema) {
+    return `"${schema.replace(/"/g, '""')}"`;
+}
+// ── Symbol inflation ────────────────────────────────────────────────────────
+/** Schema-qualified symbol lookup — schema is injected as an identifier, not a parameter. */
+const LOAD_SYMBOL_MAP = (schema) => `SELECT key, field, value FROM ${schema}.symbols WHERE key LIKE $1`;
+exports.LOAD_SYMBOL_MAP = LOAD_SYMBOL_MAP;
+/**
+ * Load all symbol key mappings from {schema}.symbols for the given appId.
+ * Returns a reverse map: abbreviated 3-char key → human-readable path.
+ */
+async function loadSymbolMap(schema, appId) {
+    const pool = (0, db_1.getPool)();
+    const symKeyPrefix = `hmsh:${appId}:sym:keys:`;
+    try {
+        const result = await pool.query((0, exports.LOAD_SYMBOL_MAP)(schema), [`${symKeyPrefix}%`]);
+        const reverseMap = {};
+        for (const row of result.rows) {
+            const symbolName = row.key.slice(symKeyPrefix.length);
+            if (row.field && row.value && symbolName !== '') {
+                reverseMap[row.value] = row.field;
+            }
+        }
+        return reverseMap;
+    }
+    catch (err) {
+        // Schema or symbols table may not exist yet — return empty map
+        // so attribute inflation falls back to raw abbreviated keys.
+        if (err.code === '42P01')
+            return {}; // undefined_table
+        throw err;
+    }
+}
+/**
+ * Inflate raw HotMesh job attributes using the symbol map.
+ * Converts abbreviated 3-char keys + dimensional indices into
+ * human-readable "dimensions/path" entries with deserialized values.
+ *
+ * Key patterns:
+ *   "abc"          → 3-char job-level key (metadata/jc, data/summary, etc.)
+ *   "abc,N,M,..."  → activity/transition key with dimensional index
+ *   ":"            → status semaphore
+ */
+function inflateAttributes(attrs, symbolMap) {
+    const flat = {};
+    const symKeyRegex = /^([a-zA-Z]{2,3})(,\d+(?:,\d+)*)?$/;
+    for (const [key, rawValue] of Object.entries(attrs)) {
+        if (key === ':') {
+            flat[':'] = rawValue;
+            continue;
+        }
+        const match = key.match(symKeyRegex);
+        if (match) {
+            const letters = match[1];
+            const dimSuffix = match[2] || '';
+            const inflatedPath = symbolMap[letters] || letters;
+            const dimensions = dimSuffix ? dimSuffix.slice(1).replace(/,/g, '/') + '/' : '';
+            flat[`${dimensions}${inflatedPath}`] = fromString(rawValue);
+        }
+        else {
+            flat[key] = fromString(rawValue);
+        }
+    }
+    return flat;
+}
+/**
+ * Rebuild a nested object from a flat "dim1/dim2/.../path" → value map.
+ */
+function restoreHierarchy(flat) {
+    const result = {};
+    for (const key in flat) {
+        if (flat[key] === undefined)
+            continue;
+        const keys = key.split('/');
+        let current = result;
+        for (let i = 0; i < keys.length; i++) {
+            if (i === keys.length - 1) {
+                current[keys[i]] = flat[key];
+            }
+            else {
+                current[keys[i]] = current[keys[i]] || {};
+                current = current[keys[i]];
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Walk an inflated HotMesh hierarchy to extract all activities/transitions.
+ * Recurses through numeric dimension keys, collecting activity nodes that
+ * have an `output.metadata` subtree.
+ */
+function extractActivities(hierarchy) {
+    const activities = [];
+    function walk(node, dims) {
+        for (const key of Object.keys(node)) {
+            if (/^\d+$/.test(key)) {
+                walk(node[key], [...dims, key]);
+                continue;
+            }
+            const actNode = node[key];
+            if (!actNode || typeof actNode !== 'object')
+                continue;
+            const output = actNode['output'];
+            if (!output)
+                continue;
+            const meta = output['metadata'];
+            const data = output['data'];
+            if (!meta)
+                continue;
+            activities.push({
+                name: key,
+                type: meta['atp'] || 'worker',
+                step: meta['stp'] || key,
+                ac: meta['ac'] || null,
+                au: meta['au'] || null,
+                traceId: meta['l1s'] || null,
+                spanId: meta['l2s'] || null,
+                error: meta['err'] || null,
+                data: data || null,
+                dimensions: dims.join('/'),
+            });
+        }
+    }
+    walk(hierarchy, []);
+    activities.sort((a, b) => {
+        if (!a.ac)
+            return 1;
+        if (!b.ac)
+            return -1;
+        return a.ac.localeCompare(b.ac);
+    });
+    return activities;
+}