@hotmeshio/hotmesh 0.0.8 → 0.0.9

package/build/esm/modules/errors.d.ts

@@ -1,28 +0,0 @@
-import { ActivityDuplex } from "../types/activity";
-import { CollationFaultType, CollationStage } from "../types/collator";
-declare class GetStateError extends Error {
-    constructor();
-}
-declare class SetStateError extends Error {
-    constructor();
-}
-declare class MapDataError extends Error {
-    constructor();
-}
-declare class RegisterTimeoutError extends Error {
-    constructor();
-}
-declare class DuplicateJobError extends Error {
-    constructor(jobId: string);
-}
-declare class ExecActivityError extends Error {
-    constructor();
-}
-declare class CollationError extends Error {
-    status: number;
-    leg: ActivityDuplex;
-    stage: CollationStage;
-    fault: CollationFaultType;
-    constructor(status: number, leg: ActivityDuplex, stage: CollationStage, fault?: CollationFaultType);
-}
-export { CollationError, DuplicateJobError, GetStateError, SetStateError, MapDataError, RegisterTimeoutError, ExecActivityError };

package/build/esm/modules/errors.js

@@ -1,41 +0,0 @@
-class GetStateError extends Error {
-    constructor() {
-        super("Error occurred while getting job state");
-    }
-}
-class SetStateError extends Error {
-    constructor() {
-        super("Error occurred while setting job state");
-    }
-}
-class MapDataError extends Error {
-    constructor() {
-        super("Error occurred while mapping data");
-    }
-}
-class RegisterTimeoutError extends Error {
-    constructor() {
-        super("Error occurred while registering activity timeout");
-    }
-}
-class DuplicateJobError extends Error {
-    constructor(jobId) {
-        super("Duplicate job");
-        this.message = `Duplicate job: ${jobId}`;
-    }
-}
-class ExecActivityError extends Error {
-    constructor() {
-        super("Error occurred while executing activity");
-    }
-}
-class CollationError extends Error {
-    constructor(status, leg, stage, fault) {
-        super("collation-error");
-        this.leg = leg;
-        this.status = status;
-        this.stage = stage;
-        this.fault = fault;
-    }
-}
-export { CollationError, DuplicateJobError, GetStateError, SetStateError, MapDataError, RegisterTimeoutError, ExecActivityError };

package/build/esm/modules/key.d.ts

@@ -1,75 +0,0 @@
-/**
- * Keys
- *
- * hmsh ->                                            {hash}    hotmesh config {version: "0.0.1", namespace: "hmsh"}
- * hmsh:a:<appid> ->                                  {hash}    app profile { "id": "appid", "version": "2", "versions/1": "GMT", "versions/2": "GMT"}
- * hmsh:<appid>:e:<engineId> ->                       {string}  setnx to ensure only one engine of given id
- * hmsh:<appid>:w: ->                                 {zset}    work items/tasks an engine must do like garbage collect or hook a set of matching records (hookAll)
- * hmsh:<appid>:t: ->                                 {zset}    an ordered set of list (work lists) ids
- * hmsh:<appid>:t:<timeValue?> ->                     {list}    a worklist of `jobId+activityId` items that should be awakened
- * hmsh:<appid>:q: ->                                 {hash}    quorum-wide messages
- * hmsh:<appid>:q:<ngnid> ->                          {hash}    engine-targeted messages (targeted quorum-oriented message)
- * hmsh:<appid>:j:<jobid> ->                          {hash}    job data
- * hmsh:<appid>:j:<jobid>:<activityid>  ->            {hash}    job activity data (a1)
- * hmsh:<appid>:s:<jobkey>:<dateTime> ->              {hash}    job stats (general)
- * hmsh:<appid>:s:<jobkey>:<dateTime>:mdn:<field/path>:<fieldvalue> ->      {zset}    job stats (median)
- * hmsh:<appid>:s:<jobkey>:<dateTime>:index:<field/path>:<fieldvalue> ->    {list}    job stats (index of jobid[])
- * hmsh:<appid>:v:<version>:activities ->             {hash}    schemas [cache]
- * hmsh:<appid>:v:<version>:transitions ->            {hash}    transitions [cache]
- * hmsh:<appid>:v:<version>:subscriptions ->          {hash}    subscriptions [cache]
- * hmsh:<appid>:x: ->                                 {xstream} when an engine is sent or reads a buffered task (engines read from their custom topic)
- * hmsh:<appid>:x:<topic> ->                          {xstream} when a worker is sent or reads a buffered task (workers read from their custom topic)
- * hmsh:<appid>:hooks ->                              {hash}    hook patterns/rules; set at compile time
- * hmsh:<appid>:signals ->                            {hash}    dynamic hook signals (hget/hdel) when resolving (always self-clean); added/removed at runtime
- * hmsh:<appid>:sym:keys: ->                          {hash}    list of symbol ranges and :cursor assigned at version deploy time for job keys
- * hmsh:<appid>:sym:keys:<activityid|$subscribes> ->  {hash}    list of symbols based upon schema enums (initially) and adaptively optimized (later) during runtime; if '$subscribes' is used as the activityid, it is a top-level `job` symbol set (for job keys)
- * hmsh:<appid>:sym:vals: ->                          {hash}    list of symbols for job values across all app versions
- */
-declare const PSNS = "hmsh";
-declare enum KeyType {
-    APP = 0,
-    ENGINE_ID = 1,
-    HOOKS = 2,
-    JOB_STATE = 3,
-    JOB_STATS_GENERAL = 4,
-    JOB_STATS_MEDIAN = 5,
-    JOB_STATS_INDEX = 6,
-    HOTMESH = 7,
-    QUORUM = 8,
-    SCHEMAS = 9,
-    SIGNALS = 10,
-    STREAMS = 11,
-    SUBSCRIPTIONS = 12,
-    SUBSCRIPTION_PATTERNS = 13,
-    SYMKEYS = 14,
-    SYMVALS = 15,
-    TIME_RANGE = 16,
-    WORK_ITEMS = 17
-}
-type KeyStoreParams = {
-    appId?: string;
-    engineId?: string;
-    appVersion?: string;
-    jobId?: string;
-    activityId?: string;
-    jobKey?: string;
-    dateTime?: string;
-    facet?: string;
-    topic?: string;
-    timeValue?: number;
-};
-declare class KeyService {
-    /**
-     * returns a key that can be used to access a value in the key/value store
-     * appropriate for the given key type; the keys have an implicit hierarchy
-     * and are used to organize data in the store in a tree-like structure
-     * via the use of colons as separators. The top-level entity is the hmsh manifest.
-     * This file will reveal the full scope of what is on the server (apps, versions, etc)
-     * @param namespace
-     * @param keyType
-     * @param params
-     * @returns {string}
-     */
-    static mintKey(namespace: string, keyType: KeyType, params: KeyStoreParams): string;
-}
-export { KeyService, KeyType, KeyStoreParams, PSNS };

package/build/esm/modules/key.js

@@ -1,111 +0,0 @@
-/**
- * Keys
- *
- * hmsh ->                                            {hash}    hotmesh config {version: "0.0.1", namespace: "hmsh"}
- * hmsh:a:<appid> ->                                  {hash}    app profile { "id": "appid", "version": "2", "versions/1": "GMT", "versions/2": "GMT"}
- * hmsh:<appid>:e:<engineId> ->                       {string}  setnx to ensure only one engine of given id
- * hmsh:<appid>:w: ->                                 {zset}    work items/tasks an engine must do like garbage collect or hook a set of matching records (hookAll)
- * hmsh:<appid>:t: ->                                 {zset}    an ordered set of list (work lists) ids
- * hmsh:<appid>:t:<timeValue?> ->                     {list}    a worklist of `jobId+activityId` items that should be awakened
- * hmsh:<appid>:q: ->                                 {hash}    quorum-wide messages
- * hmsh:<appid>:q:<ngnid> ->                          {hash}    engine-targeted messages (targeted quorum-oriented message)
- * hmsh:<appid>:j:<jobid> ->                          {hash}    job data
- * hmsh:<appid>:j:<jobid>:<activityid>  ->            {hash}    job activity data (a1)
- * hmsh:<appid>:s:<jobkey>:<dateTime> ->              {hash}    job stats (general)
- * hmsh:<appid>:s:<jobkey>:<dateTime>:mdn:<field/path>:<fieldvalue> ->      {zset}    job stats (median)
- * hmsh:<appid>:s:<jobkey>:<dateTime>:index:<field/path>:<fieldvalue> ->    {list}    job stats (index of jobid[])
- * hmsh:<appid>:v:<version>:activities ->             {hash}    schemas [cache]
- * hmsh:<appid>:v:<version>:transitions ->            {hash}    transitions [cache]
- * hmsh:<appid>:v:<version>:subscriptions ->          {hash}    subscriptions [cache]
- * hmsh:<appid>:x: ->                                 {xstream} when an engine is sent or reads a buffered task (engines read from their custom topic)
- * hmsh:<appid>:x:<topic> ->                          {xstream} when a worker is sent or reads a buffered task (workers read from their custom topic)
- * hmsh:<appid>:hooks ->                              {hash}    hook patterns/rules; set at compile time
- * hmsh:<appid>:signals ->                            {hash}    dynamic hook signals (hget/hdel) when resolving (always self-clean); added/removed at runtime
- * hmsh:<appid>:sym:keys: ->                          {hash}    list of symbol ranges and :cursor assigned at version deploy time for job keys
- * hmsh:<appid>:sym:keys:<activityid|$subscribes> ->  {hash}    list of symbols based upon schema enums (initially) and adaptively optimized (later) during runtime; if '$subscribes' is used as the activityid, it is a top-level `job` symbol set (for job keys)
- * hmsh:<appid>:sym:vals: ->                          {hash}    list of symbols for job values across all app versions
- */
-//default namespace for hotmesh
-const PSNS = "hmsh";
-//these are the entity types that are stored in the key/value store
-var KeyType;
-(function (KeyType) {
-    KeyType[KeyType["APP"] = 0] = "APP";
-    KeyType[KeyType["ENGINE_ID"] = 1] = "ENGINE_ID";
-    KeyType[KeyType["HOOKS"] = 2] = "HOOKS";
-    KeyType[KeyType["JOB_STATE"] = 3] = "JOB_STATE";
-    KeyType[KeyType["JOB_STATS_GENERAL"] = 4] = "JOB_STATS_GENERAL";
-    KeyType[KeyType["JOB_STATS_MEDIAN"] = 5] = "JOB_STATS_MEDIAN";
-    KeyType[KeyType["JOB_STATS_INDEX"] = 6] = "JOB_STATS_INDEX";
-    KeyType[KeyType["HOTMESH"] = 7] = "HOTMESH";
-    KeyType[KeyType["QUORUM"] = 8] = "QUORUM";
-    KeyType[KeyType["SCHEMAS"] = 9] = "SCHEMAS";
-    KeyType[KeyType["SIGNALS"] = 10] = "SIGNALS";
-    KeyType[KeyType["STREAMS"] = 11] = "STREAMS";
-    KeyType[KeyType["SUBSCRIPTIONS"] = 12] = "SUBSCRIPTIONS";
-    KeyType[KeyType["SUBSCRIPTION_PATTERNS"] = 13] = "SUBSCRIPTION_PATTERNS";
-    KeyType[KeyType["SYMKEYS"] = 14] = "SYMKEYS";
-    KeyType[KeyType["SYMVALS"] = 15] = "SYMVALS";
-    KeyType[KeyType["TIME_RANGE"] = 16] = "TIME_RANGE";
-    KeyType[KeyType["WORK_ITEMS"] = 17] = "WORK_ITEMS";
-})(KeyType || (KeyType = {}));
-class KeyService {
-    /**
-     * returns a key that can be used to access a value in the key/value store
-     * appropriate for the given key type; the keys have an implicit hierarchy
-     * and are used to organize data in the store in a tree-like structure
-     * via the use of colons as separators. The top-level entity is the hmsh manifest.
-     * This file will reveal the full scope of what is on the server (apps, versions, etc)
-     * @param namespace
-     * @param keyType
-     * @param params
-     * @returns {string}
-     */
-    static mintKey(namespace, keyType, params) {
-        switch (keyType) {
-            case KeyType.HOTMESH:
-                return namespace;
-            case KeyType.ENGINE_ID:
-                return `${namespace}:${params.appId}:e:${params.engineId}`;
-            case KeyType.WORK_ITEMS:
-                return `${namespace}:${params.appId}:w:`;
-            case KeyType.TIME_RANGE:
-                return `${namespace}:${params.appId}:t:${params.timeValue || ''}`;
-            case KeyType.APP:
-                return `${namespace}:a:${params.appId || ''}`;
-            case KeyType.QUORUM:
-                return `${namespace}:${params.appId}:q:${params.engineId || ''}`;
-            case KeyType.JOB_STATE:
-                return `${namespace}:${params.appId}:j:${params.jobId}`;
-            case KeyType.JOB_STATS_GENERAL:
-                return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}`;
-            case KeyType.JOB_STATS_MEDIAN:
-                return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}:${params.facet}`;
-            case KeyType.JOB_STATS_INDEX:
-                return `${namespace}:${params.appId}:s:${params.jobKey}:${params.dateTime}:${params.facet}`;
-            case KeyType.SCHEMAS:
-                return `${namespace}:${params.appId}:v:${params.appVersion}:schemas`;
-            case KeyType.SUBSCRIPTIONS:
-                return `${namespace}:${params.appId}:v:${params.appVersion}:subscriptions`;
-            case KeyType.SUBSCRIPTION_PATTERNS:
-                return `${namespace}:${params.appId}:v:${params.appVersion}:transitions`;
-            case KeyType.HOOKS:
-                //`hooks` provide the pattern to resolve a value
-                return `${namespace}:${params.appId}:hooks`;
-            case KeyType.SIGNALS:
-                //`signals` provide the registry of resolved values that link back to paused jobs
-                return `${namespace}:${params.appId}:signals`;
-            case KeyType.SYMKEYS:
-                //`symbol keys` provide the registry of replacement values for job keys
-                return `${namespace}:${params.appId}:sym:keys:${params.activityId || ''}`;
-            case KeyType.SYMVALS:
-                //`symbol vals` provide the registry of replacement values for job vals
-                return `${namespace}:${params.appId}:sym:vals:`;
-            case KeyType.STREAMS:
-                return `${namespace}:${params.appId || ''}:x:${params.topic || ''}`;
-            default:
-                throw new Error("Invalid key type.");
-        }
-    }
-}
-export { KeyService, KeyType, PSNS };

package/build/esm/modules/utils.d.ts

@@ -1,34 +0,0 @@
-/// <reference types="node" />
-import { StoreService } from "../services/store";
-import { AppSubscriptions, AppTransitions, AppVID } from "../types/app";
-import { RedisClient, RedisMulti } from "../types/redis";
-import { StringAnyType } from "../types/serializer";
-import { StreamCode, StreamStatus } from "../types/stream";
-export declare function sleepFor(ms: number): Promise<unknown>;
-export declare function identifyRedisType(redisInstance: any): 'redis' | 'ioredis' | null;
-export declare function identifyRedisTypeFromClass(redisClass: any): 'redis' | 'ioredis' | null;
-export declare function matchesStatusCode(code: StreamCode, pattern: string | RegExp): boolean;
-export declare function matchesStatus(status: StreamStatus, targetStatus: StreamStatus): boolean;
-export declare function XSleepFor(ms: number): {
-    promise: Promise<unknown>;
-    timerId: NodeJS.Timeout;
-};
-export declare function findTopKey(obj: AppTransitions, input: string): string | null;
-export declare function findSubscriptionForTrigger(obj: AppSubscriptions, value: string): string | null;
-/**
- * Get the subscription topic for the flow to which @activityId belongs.
- * TODO: resolve this value in the compiler...do not call this at runtime
- */
-export declare function getSubscriptionTopic(activityId: string, store: StoreService<RedisClient, RedisMulti>, appVID: AppVID): Promise<string | undefined>;
-/**
- * returns the 12-digit format of the iso timestamp (e.g, 202101010000)
- */
-export declare function getTimeSeries(granularity: string): string;
-export declare function formatISODate(input: Date | string): string;
-export declare function getSymKey(number: number): string;
-export declare function getSymVal(number: number): string;
-export declare function getIndexedHash<T>(hash: T, target: string): [number, T];
-export declare function getValueByPath(obj: {
-    [key: string]: any;
-}, path: string): any;
-export declare function restoreHierarchy(obj: StringAnyType): StringAnyType;

package/build/esm/modules/utils.js

@@ -1,154 +0,0 @@
-export async function sleepFor(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-export function identifyRedisType(redisInstance) {
-    if (redisInstance.constructor) {
-        if (redisInstance.constructor.name === 'Redis' || redisInstance.constructor.name === 'EventEmitter') {
-            if ('hset' in redisInstance) {
-                return 'ioredis';
-            }
-        }
-        else if (redisInstance.constructor.name === 'RedisClient' || redisInstance.constructor.name === 'Commander') {
-            if ('HSET' in redisInstance) {
-                return 'redis';
-            }
-        }
-    }
-    return null;
-}
-export function identifyRedisTypeFromClass(redisClass) {
-    if (redisClass && redisClass.name === 'Redis' || redisClass.name === 'EventEmitter') {
-        return 'ioredis';
-    }
-    else if (redisClass && 'createClient' in redisClass) {
-        return 'redis';
-    }
-    return null;
-}
-export function matchesStatusCode(code, pattern) {
-    if (typeof pattern === 'string') {
-        // Convert '*' wildcard to its regex equivalent (\d)
-        const regexPattern = `^${pattern.replace(/\*/g, "\\d")}$`;
-        return new RegExp(regexPattern).test(code.toString());
-    }
-    return pattern.test(code.toString());
-}
-export function matchesStatus(status, targetStatus) {
-    return status === targetStatus;
-}
-export function XSleepFor(ms) {
-    //can be interrupted with `clearTimeout`
-    let timerId;
-    let promise = new Promise((resolve) => {
-        timerId = setTimeout(resolve, ms);
-    });
-    return { promise, timerId };
-}
-export function findTopKey(obj, input) {
-    for (const [key, value] of Object.entries(obj)) {
-        if (value.hasOwnProperty(input)) {
-            const parentKey = findTopKey(obj, key.replace(/^\./, ''));
-            return (parentKey || key).replace(/^\./, '');
-        }
-    }
-    return null;
-}
-export function findSubscriptionForTrigger(obj, value) {
-    for (const [key, itemValue] of Object.entries(obj)) {
-        if (itemValue === value) {
-            return key;
-        }
-    }
-    return null;
-}
-/**
- * Get the subscription topic for the flow to which @activityId belongs.
- * TODO: resolve this value in the compiler...do not call this at runtime
- */
-export async function getSubscriptionTopic(activityId, store, appVID) {
-    const appTransitions = await store.getTransitions(appVID);
-    const appSubscriptions = await store.getSubscriptions(appVID);
-    const triggerId = findTopKey(appTransitions, activityId);
-    const topic = findSubscriptionForTrigger(appSubscriptions, triggerId);
-    return topic;
-}
-/**
- * returns the 12-digit format of the iso timestamp (e.g, 202101010000)
- */
-export function getTimeSeries(granularity) {
-    const now = new Date();
-    const granularityUnit = granularity.slice(-1);
-    const granularityValue = parseInt(granularity.slice(0, -1), 10);
-    if (granularityUnit === 'm') {
-        const minute = Math.floor(now.getMinutes() / granularityValue) * granularityValue;
-        now.setUTCMinutes(minute, 0, 0);
-    }
-    else if (granularityUnit === 'h') {
-        now.setUTCMinutes(0, 0, 0);
-    }
-    return now.toISOString().replace(/:\d\d\..+|-|T/g, '').replace(':', '');
-}
-export function formatISODate(input) {
-    const date = input instanceof Date ? input : new Date(input);
-    return date.toISOString().replace(/[:TZ-]/g, '');
-}
-export function getSymKey(number) {
-    const alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-    const base = alphabet.length;
-    if (number < 0 || number >= Math.pow(base, 3)) {
-        throw new Error('Number out of range');
-    }
-    let [q1, r1] = divmod(number, base);
-    let [q2, r2] = divmod(q1, base);
-    return alphabet[q2] + alphabet[r1] + alphabet[r2];
-}
-export function getSymVal(number) {
-    const alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-    const base = alphabet.length;
-    if (number < 0 || number >= Math.pow(base, 2)) {
-        throw new Error('Number out of range');
-    }
-    let [q, r] = divmod(number, base);
-    return alphabet[q] + alphabet[r];
-}
-function divmod(m, n) {
-    return [Math.floor(m / n), m % n];
-}
-export function getIndexedHash(hash, target) {
-    const index = hash[target] || 0;
-    const newHash = { ...hash };
-    delete newHash[target];
-    return [index, newHash];
-}
-export function getValueByPath(obj, path) {
-    const pathParts = path.split('/');
-    let currentValue = obj;
-    for (const part of pathParts) {
-        if (currentValue[part] !== undefined) {
-            currentValue = currentValue[part];
-        }
-        else {
-            return undefined;
-        }
-    }
-    return currentValue;
-}
-export function restoreHierarchy(obj) {
-    const result = {};
-    for (const key in obj) {
-        if (obj[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]] = obj[key];
-            }
-            else {
-                current[keys[i]] = current[keys[i]] || {};
-                current = current[keys[i]];
-            }
-        }
-    }
-    return result;
-}

package/build/esm/services/activities/activity.d.ts

@@ -1,67 +0,0 @@
-import { EngineService } from '../engine';
-import { ILogger } from '../logger';
-import { StoreService } from '../store';
-import { TelemetryService } from '../telemetry';
-import { ActivityData, ActivityLeg, ActivityMetadata, ActivityType } from '../../types/activity';
-import { JobState, JobStatus } from '../../types/job';
-import { MultiResponseFlags, RedisClient, RedisMulti } from '../../types/redis';
-import { StringAnyType } from '../../types/serializer';
-import { StreamCode, StreamData, StreamStatus } from '../../types/stream';
-/**
- * The base class for all activities
- */
-declare class Activity {
-    config: ActivityType;
-    data: ActivityData;
-    hook: ActivityData;
-    metadata: ActivityMetadata;
-    store: StoreService<RedisClient, RedisMulti>;
-    context: JobState;
-    engine: EngineService;
-    logger: ILogger;
-    status: StreamStatus;
-    code: StreamCode;
-    leg: ActivityLeg;
-    adjacencyList: StreamData[];
-    adjacentIndex: number;
-    constructor(config: ActivityType, data: ActivityData, metadata: ActivityMetadata, hook: ActivityData | null, engine: EngineService, context?: JobState);
-    process(): Promise<string>;
-    setLeg(leg: ActivityLeg): void;
-    doesHook(): boolean;
-    registerHook(multi?: RedisMulti): Promise<string | void>;
-    processWebHookEvent(): Promise<JobStatus | void>;
-    processTimeHookEvent(jobId: string): Promise<JobStatus | void>;
-    processHookEvent(jobId: string): Promise<JobStatus | void>;
-    processEvent(status?: StreamStatus, code?: StreamCode): Promise<void>;
-    processPending(telemetry: TelemetryService): Promise<MultiResponseFlags>;
-    processSuccess(telemetry: TelemetryService): Promise<MultiResponseFlags>;
-    processError(telemetry: TelemetryService): Promise<MultiResponseFlags>;
-    transitionAdjacent(multiResponse: MultiResponseFlags, telemetry: TelemetryService): Promise<void>;
-    resolveStatus(multiResponse: MultiResponseFlags): number;
-    mapJobData(): void;
-    mapInputData(): void;
-    registerTimeout(): Promise<void>;
-    bindActivityError(data: Record<string, unknown>): void;
-    getTriggerConfig(): Promise<ActivityType>;
-    getJobStatus(): null | number;
-    setStatus(amount: number, multi?: RedisMulti): Promise<void>;
-    authorizeEntry(state: StringAnyType): string[];
-    bindDimensionalAddress(state: StringAnyType): void;
-    setState(multi?: RedisMulti): Promise<string>;
-    bindJobMetadata(): void;
-    bindActivityMetadata(): void;
-    bindJobState(state: StringAnyType): Promise<void>;
-    bindActivityState(state: StringAnyType): void;
-    bindJobMetadataPaths(): string[];
-    bindActivityMetadataPaths(): string[];
-    getState(jobId?: string): Promise<void>;
-    initDimensionalAddress(dad: string): void;
-    initSelf(context: StringAnyType): JobState;
-    initPolicies(context: JobState): void;
-    bindActivityData(type: 'output' | 'hook'): void;
-    resolveDad(): string;
-    resolveAdjacentDad(): string;
-    filterAdjacent(): Promise<StreamData[]>;
-    transition(adjacencyList: StreamData[], jobStatus: JobStatus): Promise<string[]>;
-}
-export { Activity, ActivityType };