@solidactions/sdk 0.1.0

package/dist/src/solidactions.js

@@ -0,0 +1,1284 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolidActions = exports.runInternalStep = exports.getExecutor = void 0;
+const context_1 = require("./context");
+const solidactions_executor_1 = require("./solidactions-executor");
+const traces_1 = require("./telemetry/traces");
+const workflow_1 = require("./workflow");
+const logs_1 = require("./telemetry/logs");
+const error_1 = require("./error");
+const config_1 = require("./config");
+const decorators_1 = require("./decorators");
+const utils_1 = require("./utils");
+const serialization_1 = require("./serialization");
+const adminserver_1 = require("./adminserver");
+const node_crypto_1 = require("node:crypto");
+const conductor_1 = require("./conductor/conductor");
+const system_database_1 = require("./system_database");
+const authdecorators_1 = require("./authdecorators");
+const node_assert_1 = __importDefault(require("node:assert"));
+function getExecutor() {
+    if (!solidactions_executor_1.SolidActionsExecutor.globalInstance) {
+        throw new error_1.SolidActionsExecutorNotInitializedError();
+    }
+    return solidactions_executor_1.SolidActionsExecutor.globalInstance;
+}
+exports.getExecutor = getExecutor;
+function runInternalStep(callback, funcName, childWFID, assignedFuncID) {
+    if (SolidActions.isWithinWorkflow()) {
+        if (SolidActions.isInStep()) {
+            // OK to use directly
+            return callback();
+        }
+        else if (SolidActions.isInWorkflow()) {
+            return solidactions_executor_1.SolidActionsExecutor.globalInstance.runInternalStep(callback, funcName, SolidActions.workflowID, assignedFuncID ?? (0, context_1.functionIDGetIncrement)(), childWFID);
+        }
+        else {
+            throw new error_1.SolidActionsInvalidWorkflowTransitionError(`Invalid call to \`${funcName}\` inside a \`transaction\` or \`procedure\``);
+        }
+    }
+    return callback();
+}
+exports.runInternalStep = runInternalStep;
+class SolidActions {
+    ///////
+    // Lifecycle
+    ///////
+    static adminServer = undefined;
+    static conductor = undefined;
+    /**
+     * Set configuration of `SolidActions` prior to `launch`
+     * @param config - configuration of services needed by SolidActions
+     */
+    static setConfig(config) {
+        (0, node_assert_1.default)(!SolidActions.isInitialized(), 'Cannot call SolidActions.setConfig after SolidActions.launch');
+        SolidActions.#solidActionsConfig = config;
+    }
+    /**
+     * Check if SolidActions has been `launch`ed (and not `shutdown`)
+     * @returns `true` if SolidActions has been launched, or `false` otherwise
+     */
+    static isInitialized() {
+        return !!solidactions_executor_1.SolidActionsExecutor.globalInstance?.initialized;
+    }
+    /**
+     * Launch SolidActions, starting recovery and request handling
+     * @param options - Launch options for connecting to SolidActions Conductor
+     */
+    static async launch(options) {
+        const debugMode = options?.debugMode ?? process.env.SOLIDACTIONS_DEBUG_WORKFLOW_ID !== undefined;
+        const configFile = await (0, config_1.readConfigFile)();
+        // If no setConfig() was called, try to auto-configure from solidsteps.yaml + env vars
+        if (!SolidActions.#solidActionsConfig) {
+            const solidStepsConfig = await (0, config_1.readSolidStepsConfig)();
+            if (solidStepsConfig.project || process.env.SOLIDACTIONS_API_URL) {
+                // Auto-configure: use project name from solidsteps.yaml, API config from env vars
+                try {
+                    const httpConfig = (0, config_1.getHttpConfig)(configFile);
+                    SolidActions.#solidActionsConfig = {
+                        name: solidStepsConfig.project || configFile.name,
+                        api: {
+                            url: httpConfig.apiUrl,
+                            key: httpConfig.apiKey,
+                            timeout: httpConfig.timeout,
+                            maxRetries: httpConfig.maxRetries,
+                        },
+                    };
+                }
+                catch {
+                    // If we can't get HTTP config, fall back to normal config file handling
+                }
+            }
+        }
+        let internalConfig = SolidActions.#solidActionsConfig
+            ? (0, config_1.translateSolidActionsConfig)(SolidActions.#solidActionsConfig, debugMode)
+            : (0, config_1.getSolidActionsConfig)(configFile);
+        let runtimeConfig = SolidActions.#solidActionsConfig
+            ? (0, config_1.translateRuntimeConfig)(SolidActions.#solidActionsConfig)
+            : (0, config_1.getRuntimeConfig)(configFile);
+        if (process.env.SOLIDACTIONS__CLOUD === 'true' || process.env.SOLIDACTIONS__CLOUD === 'true') {
+            [internalConfig, runtimeConfig] = (0, config_1.overwriteConfigForCloud)(internalConfig, runtimeConfig, configFile);
+        }
+        utils_1.globalParams.enableOTLP = SolidActions.#solidActionsConfig?.enableOTLP ?? (0, utils_1.defaultEnableOTLP)();
+        if (!(0, traces_1.isTraceContextWorking)())
+            (0, traces_1.installTraceContextManager)(internalConfig.name);
+        // Do nothing if SolidActions is already initialized
+        if (SolidActions.isInitialized()) {
+            return;
+        }
+        (0, decorators_1.finalizeClassRegistrations)();
+        (0, decorators_1.insertAllMiddleware)();
+        // Globally set the application version and executor ID.
+        // In SolidActions Cloud, instead use the value supplied through environment variables.
+        if (process.env.SOLIDACTIONS__CLOUD !== 'true') {
+            if (SolidActions.#solidActionsConfig?.applicationVersion) {
+                utils_1.globalParams.appVersion = SolidActions.#solidActionsConfig.applicationVersion;
+            }
+            else if (SolidActions.#solidActionsConfig?.enablePatching) {
+                utils_1.globalParams.appVersion = 'PATCHING_ENABLED';
+            }
+            if (SolidActions.#solidActionsConfig?.executorID) {
+                utils_1.globalParams.executorID = SolidActions.#solidActionsConfig.executorID;
+            }
+        }
+        if (options?.conductorKey) {
+            // Always use a generated executor ID in Conductor.
+            utils_1.globalParams.executorID = (0, node_crypto_1.randomUUID)();
+        }
+        solidactions_executor_1.SolidActionsExecutor.globalInstance = new solidactions_executor_1.SolidActionsExecutor(internalConfig, { debugMode });
+        (0, decorators_1.recordSolidActionsLaunch)();
+        const executor = solidactions_executor_1.SolidActionsExecutor.globalInstance;
+        await executor.init();
+        const debugWorkflowId = process.env.SOLIDACTIONS_DEBUG_WORKFLOW_ID;
+        if (debugWorkflowId) {
+            SolidActions.logger.info(`Debugging workflow "${debugWorkflowId}"`);
+            const handle = await executor.executeWorkflowId(debugWorkflowId);
+            await handle.getResult();
+            SolidActions.logger.info(`Workflow Debugging complete. Exiting process.`);
+            await executor.destroy();
+            process.exit(0);
+            return; // return for cases where process.exit is mocked
+        }
+        await solidactions_executor_1.SolidActionsExecutor.globalInstance.initEventReceivers();
+        if (options?.conductorKey) {
+            if (!options.conductorURL) {
+                const solidActionsDomain = process.env.SOLIDACTIONS_DOMAIN || 'cloud.dbos.dev';
+                options.conductorURL = `wss://${solidActionsDomain}/conductor/v1alpha1`;
+            }
+            SolidActions.conductor = new conductor_1.Conductor(solidactions_executor_1.SolidActionsExecutor.globalInstance, options.conductorKey, options.conductorURL);
+            SolidActions.conductor.dispatchLoop();
+        }
+        // Start the SolidActions admin server
+        const logger = SolidActions.logger;
+        if (runtimeConfig.runAdminServer) {
+            const adminApp = adminserver_1.SolidActionsAdminServer.setupAdminApp(executor);
+            try {
+                await adminserver_1.SolidActionsAdminServer.checkPortAvailabilityIPv4Ipv6(runtimeConfig.admin_port, logger);
+                // Wrap the listen call in a promise to properly catch errors
+                SolidActions.adminServer = await new Promise((resolve, reject) => {
+                    const server = adminApp.listen(runtimeConfig?.admin_port, () => {
+                        SolidActions.logger.debug(`SolidActions Admin Server is running at http://localhost:${runtimeConfig?.admin_port}`);
+                        resolve(server);
+                    });
+                    server.on('error', (err) => {
+                        reject(err);
+                    });
+                });
+            }
+            catch (e) {
+                logger.warn(`Unable to start SolidActions admin server on port ${runtimeConfig.admin_port}`);
+            }
+        }
+    }
+    /**
+     * Logs all workflows that can be invoked externally.
+     */
+    static logRegisteredEndpoints() {
+        if (!solidactions_executor_1.SolidActionsExecutor.globalInstance)
+            return;
+        for (const lcl of (0, decorators_1.getLifecycleListeners)()) {
+            lcl.logRegisteredEndpoints?.();
+        }
+    }
+    /**
+     * Shut down SolidActions processing:
+     *   Stops receiving external workflow requests
+     *   Disconnects from administration / Conductor
+     *   Stops workflow processing and disconnects from databases
+     */
+    static async shutdown() {
+        // Stop the admin server
+        if (SolidActions.adminServer) {
+            SolidActions.adminServer.close();
+            SolidActions.adminServer = undefined;
+        }
+        // Stop the conductor
+        if (SolidActions.conductor) {
+            SolidActions.conductor.stop();
+            while (!SolidActions.conductor.isClosed) {
+                await (0, utils_1.sleepms)(500);
+            }
+            SolidActions.conductor = undefined;
+        }
+        // Stop the executor
+        if (solidactions_executor_1.SolidActionsExecutor.globalInstance) {
+            await solidactions_executor_1.SolidActionsExecutor.globalInstance.deactivateEventReceivers();
+            await solidactions_executor_1.SolidActionsExecutor.globalInstance.destroy();
+            solidactions_executor_1.SolidActionsExecutor.globalInstance = undefined;
+        }
+        // Reset the global app version and executor ID
+        utils_1.globalParams.appVersion = process.env.SOLIDACTIONS__APPVERSION || '';
+        utils_1.globalParams.wasComputed = false;
+        utils_1.globalParams.appID = process.env.SOLIDACTIONS__APPID || '';
+        utils_1.globalParams.executorID = process.env.SOLIDACTIONS__VMID || 'local';
+        (0, decorators_1.recordSolidActionsShutdown)();
+    }
+    //////
+    // Convenience APIs for SolidSteps workflows
+    //////
+    /**
+     * Get the workflow input from WORKFLOW_INPUT environment variable.
+     * This is set by the SolidSteps runner from the webhook payload.
+     * @returns Parsed input or empty object if not set
+     */
+    static getInput() {
+        const raw = process.env.WORKFLOW_INPUT;
+        if (!raw) {
+            return {};
+        }
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return {};
+        }
+    }
+    /**
+     * Run a workflow with minimal boilerplate.
+     * Handles launch(), startWorkflow(), getResult(), and shutdown().
+     *
+     * @param workflow - The workflow function to run
+     * @param options - Optional settings for input and workflow ID
+     * @returns Promise that resolves when workflow completes (or rejects on error)
+     *
+     * @example
+     * ```typescript
+     * async function myWorkflow(input: MyInput): Promise<MyOutput> {
+     *   // workflow logic
+     * }
+     *
+     * const wf = SolidActions.registerWorkflow(myWorkflow, { name: 'my-workflow' });
+     * await SolidActions.run(wf);
+     * ```
+     */
+    static async run(workflow, options) {
+        try {
+            await SolidActions.launch();
+            const input = options?.input ?? SolidActions.getInput();
+            const handle = await SolidActions.startWorkflow(workflow, {
+                workflowID: options?.workflowID,
+            })(input);
+            await handle.getResult();
+            await SolidActions.shutdown();
+            process.exit(0);
+        }
+        catch (error) {
+            console.error('Workflow failed:', error);
+            try {
+                await SolidActions.shutdown();
+            }
+            catch {
+                // Ignore shutdown errors
+            }
+            process.exit(1);
+        }
+    }
+    /**
+     * Interface for signal URLs returned by getSignalUrls()
+     */
+    static getSignalUrls(topic) {
+        const baseApiUrl = process.env.SOLIDACTIONS_API_URL?.replace('/api/internal', '') ||
+            process.env.SOLIDACTIONS_API_URL?.replace('/api/internal', '') ||
+            process.env.APP_URL ||
+            'http://localhost:8000';
+        const workflowId = SolidActions.workflowID;
+        if (!workflowId) {
+            throw new error_1.SolidActionsError('getSignalUrls() must be called from within a workflow');
+        }
+        const topicParam = topic ? `&topic=${encodeURIComponent(topic)}` : '';
+        const base = `${baseApiUrl}/api/signal/${workflowId}`;
+        return {
+            base,
+            approve: `${base}?choice=approve${topicParam}`,
+            reject: `${base}?choice=reject${topicParam}`,
+            custom: (action) => `${base}?choice=${encodeURIComponent(action)}${topicParam}`,
+        };
+    }
+    /** Stop listening for external events (for testing) */
+    static async deactivateEventReceivers() {
+        return solidactions_executor_1.SolidActionsExecutor.globalInstance?.deactivateEventReceivers();
+    }
+    /** Start listening for external events (for testing) */
+    static async initEventReceivers() {
+        return solidactions_executor_1.SolidActionsExecutor.globalInstance?.initEventReceivers();
+    }
+    // Global SolidActions executor instance
+    static get #executor() {
+        return getExecutor();
+    }
+    //////
+    // Globals
+    //////
+    static #solidActionsConfig;
+    //////
+    // Context
+    //////
+    /** Get the current SolidActions Logger, appropriate to the current context */
+    static get logger() {
+        const lctx = (0, context_1.getCurrentContextStore)();
+        if (lctx?.logger)
+            return lctx.logger;
+        const executor = solidactions_executor_1.SolidActionsExecutor.globalInstance;
+        if (executor)
+            return executor.logger;
+        return new logs_1.GlobalLogger();
+    }
+    /** Get the current SolidActions Tracer, for starting spans */
+    static get tracer() {
+        const executor = solidactions_executor_1.SolidActionsExecutor.globalInstance;
+        if (executor)
+            return executor.tracer;
+    }
+    /** Get the current SolidActions tracing span, appropriate to the current context */
+    static get span() {
+        return (0, traces_1.getActiveSpan)();
+    }
+    /**
+     * Get the current request object (such as an HTTP request)
+     * This is intended for use in event libraries that know the type of the current request,
+     *  and set it using `withTracedContext` or `runWithContext`
+     */
+    static requestObject() {
+        return (0, context_1.getCurrentContextStore)()?.request;
+    }
+    /** Get the current HTTP request (within `@SolidActions.getApi` et al) */
+    static getRequest() {
+        return this.requestObject();
+    }
+    /** Get the current HTTP request (within `@SolidActions.getApi` et al) */
+    static get request() {
+        const r = SolidActions.getRequest();
+        if (!r)
+            throw new error_1.SolidActionsError('`SolidActions.request` accessed from outside of HTTP requests');
+        return r;
+    }
+    /** Get the current application version */
+    static get applicationVersion() {
+        return utils_1.globalParams.appVersion;
+    }
+    /** Get the current workflow ID */
+    static get workflowID() {
+        return (0, context_1.getCurrentContextStore)()?.workflowId;
+    }
+    /**
+     * Get the current run ID (alias for workflowID).
+     * This is the unique identifier assigned by SolidSteps at trigger time.
+     */
+    static get runID() {
+        return SolidActions.workflowID;
+    }
+    /** Get the current step number, within the current workflow */
+    static get stepID() {
+        if (SolidActions.isInStep()) {
+            return (0, context_1.getCurrentContextStore)()?.curStepFunctionId;
+        }
+        else if (SolidActions.isInTransaction()) {
+            return (0, context_1.getCurrentContextStore)()?.curTxFunctionId;
+        }
+        else {
+            return undefined;
+        }
+    }
+    static get stepStatus() {
+        return (0, context_1.getCurrentContextStore)()?.stepStatus;
+    }
+    /** Get the current authenticated user */
+    static get authenticatedUser() {
+        return (0, context_1.getCurrentContextStore)()?.authenticatedUser ?? '';
+    }
+    /** Get the roles granted to the current authenticated user */
+    static get authenticatedRoles() {
+        return (0, context_1.getCurrentContextStore)()?.authenticatedRoles ?? [];
+    }
+    /** Get the role assumed by the current user giving authorization to execute the current function */
+    static get assumedRole() {
+        return (0, context_1.getCurrentContextStore)()?.assumedRole ?? '';
+    }
+    /** @returns true if called from within a transaction, false otherwise */
+    static isInTransaction() {
+        return (0, context_1.getCurrentContextStore)()?.curTxFunctionId !== undefined;
+    }
+    /** @returns true if called from within a step, false otherwise */
+    static isInStep() {
+        return (0, context_1.getCurrentContextStore)()?.curStepFunctionId !== undefined;
+    }
+    /**
+     * @returns true if called from within a workflow
+     *  (regardless of whether the workflow is currently executing a step,
+     *   transaction, or procedure), false otherwise
+     */
+    static isWithinWorkflow() {
+        return (0, context_1.getCurrentContextStore)()?.workflowId !== undefined;
+    }
+    /**
+     * @returns true if called from within a workflow that is not currently executing
+     *  a step, transaction, or procedure, or false otherwise
+     */
+    static isInWorkflow() {
+        return SolidActions.isWithinWorkflow() && !SolidActions.isInTransaction() && !SolidActions.isInStep();
+    }
+    //////
+    // Access to system DB, for event receivers etc.
+    //////
+    /**
+     * Get a state item from the system database, which provides a key/value store interface for event dispatchers.
+     *   The full key for the database state should include the service, function, and item.
+     *   Values are versioned.  A version can either be a sequence number (long integer), or a time (high precision floating point).
+     *       If versions are in use, any upsert is discarded if the version field is less than what is already stored.
+     *
+     * Examples of state that could be kept:
+     *   Offsets into kafka topics, per topic partition
+     *   Last time for which a scheduling service completed schedule dispatch
+     *
+     * @param service - should be unique to the event receiver keeping state, to separate from others
+     * @param workflowFnName - function name; should be the fully qualified / unique function name dispatched
+     * @param key - The subitem kept by event receiver service for the function, allowing multiple values to be stored per function
+     * @returns The latest system database state for the specified service+workflow+item
+     */
+    static async getEventDispatchState(svc, wfn, key) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('getEventDispatchState');
+        return await SolidActions.#executor.getEventDispatchState(svc, wfn, key);
+    }
+    /**
+     * Set a state item into the system database, which provides a key/value store interface for event dispatchers.
+     *   The full key for the database state should include the service, function, and item; these fields are part of `state`.
+     *   Values are versioned.  A version can either be a sequence number (long integer), or a time (high precision floating point).
+     *     If versions are in use, any upsert is discarded if the version field is less than what is already stored.
+     *
+     * @param state - the service, workflow, item, version, and value to write to the database
+     * @returns The upsert returns the current record, which may be useful if it is more recent than the `state` provided.
+     */
+    static async upsertEventDispatchState(state) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('upsertEventDispatchState');
+        return await SolidActions.#executor.upsertEventDispatchState(state);
+    }
+    //////
+    // Workflow and other operations
+    //////
+    /**
+     * Get the workflow status given a workflow ID
+     * @param workflowID - ID of the workflow
+     * @returns status of the workflow as `WorkflowStatus`, or `null` if there is no workflow with `workflowID`
+     */
+    static getWorkflowStatus(workflowID) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('getWorkflowStatus');
+        if (SolidActions.isWithinWorkflow()) {
+            if (SolidActions.isInStep()) {
+                // OK to use directly
+                return SolidActions.#executor.getWorkflowStatus(workflowID);
+            }
+            else if (SolidActions.isInWorkflow()) {
+                return SolidActions.#executor.getWorkflowStatus(workflowID, SolidActions.workflowID, (0, context_1.functionIDGetIncrement)());
+            }
+            else {
+                throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to `getWorkflowStatus` inside a `transaction` or `procedure`');
+            }
+        }
+        return SolidActions.#executor.getWorkflowStatus(workflowID);
+    }
+    /**
+     * Get the workflow result, given a workflow ID
+     * @param workflowID - ID of the workflow
+     * @param timeoutSeconds - Maximum time to wait for result
+     * @returns The return value of the workflow, or throws the exception thrown by the workflow, or `null` if times out
+     */
+    static async getResult(workflowID, timeoutSeconds) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('getResult');
+        let timerFuncID = undefined;
+        if (SolidActions.isWithinWorkflow() && timeoutSeconds !== undefined) {
+            timerFuncID = (0, context_1.functionIDGetIncrement)();
+        }
+        return await SolidActions.getResultInternal(workflowID, timeoutSeconds, timerFuncID, undefined);
+    }
+    static async getResultInternal(workflowID, timeoutSeconds, timerFuncID, assignedFuncID) {
+        return await runInternalStep(async () => {
+            const rres = await solidactions_executor_1.SolidActionsExecutor.globalInstance.systemDatabase.awaitWorkflowResult(workflowID, timeoutSeconds, SolidActions.workflowID, timerFuncID);
+            if (!rres)
+                return null;
+            if (rres?.cancelled) {
+                throw new error_1.SolidActionsAwaitedWorkflowCancelledError(workflowID);
+            }
+            return solidactions_executor_1.SolidActionsExecutor.reviveResultOrError(rres, SolidActions.#executor.serializer);
+        }, 'SolidActions.getResult', workflowID, assignedFuncID);
+    }
+    /**
+     * Create a workflow handle with a given workflow ID.
+     * This call always returns a handle, even if the workflow does not exist.
+     * The resulting handle will check the database to provide any workflow information.
+     * @param workflowID - ID of the workflow
+     * @returns `WorkflowHandle` that can be used to poll for the status or result of any workflow with `workflowID`
+     */
+    static retrieveWorkflow(workflowID) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('retrieveWorkflow');
+        if (SolidActions.isWithinWorkflow()) {
+            if (!SolidActions.isInWorkflow()) {
+                throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to `retrieveWorkflow` inside a `transaction` or `step`');
+            }
+            return new workflow_1.RetrievedHandle(solidactions_executor_1.SolidActionsExecutor.globalInstance.systemDatabase, workflowID);
+        }
+        return SolidActions.#executor.retrieveWorkflow(workflowID);
+    }
+    /**
+     * Query the system database for all workflows matching the provided predicate
+     * @param input - `GetWorkflowsInput` predicate for filtering returned workflows
+     * @returns `WorkflowStatus` array containing details of the matching workflows
+     */
+    static async listWorkflows(input) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('listWorkflows');
+        return await runInternalStep(async () => {
+            return await SolidActions.#executor.listWorkflows(input);
+        }, 'SolidActions.listWorkflows');
+    }
+    /**
+     * Retrieve the steps of a workflow
+     * @param workflowID - ID of the workflow
+     * @returns `StepInfo` array listing the executed steps of the workflow. If the workflow is not found, `undefined` is returned.
+     */
+    static async listWorkflowSteps(workflowID) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('listWorkflowSteps');
+        return await runInternalStep(async () => {
+            return await SolidActions.#executor.listWorkflowSteps(workflowID);
+        }, 'SolidActions.listWorkflowSteps');
+    }
+    /**
+     * Cancel a workflow given its ID.
+     * If the workflow is currently running, `SolidActionsWorkflowCancelledError` will be
+     *   thrown from its next SolidActions call.
+     * @param workflowID - ID of the workflow
+     */
+    static async cancelWorkflow(workflowID) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('cancelWorkflow');
+        return await runInternalStep(async () => {
+            return await SolidActions.#executor.cancelWorkflow(workflowID);
+        }, 'SolidActions.cancelWorkflow');
+    }
+    /**
+     * Resume a workflow given its ID.
+     * @param workflowID - ID of the workflow
+     */
+    static async resumeWorkflow(workflowID) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('resumeWorkflow');
+        await runInternalStep(async () => {
+            return await SolidActions.#executor.resumeWorkflow(workflowID);
+        }, 'SolidActions.resumeWorkflow');
+        return this.retrieveWorkflow(workflowID);
+    }
+    /**
+     * Fork a workflow given its ID.
+     * @param workflowID - ID of the workflow
+     * @param startStep - Step ID to start the forked workflow from
+     * @param applicationVersion - Version of the application to use for the forked workflow
+     * @returns A handle to the forked workflow
+     * @throws SolidActionsInvalidStepIDError if the `startStep` is greater than the maximum step ID of the workflow
+     */
+    static async forkWorkflow(workflowID, startStep, options) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('forkWorkflow');
+        const forkedID = await runInternalStep(async () => {
+            return await SolidActions.#executor.forkWorkflow(workflowID, startStep, options);
+        }, 'SolidActions.forkWorkflow');
+        return this.retrieveWorkflow(forkedID);
+    }
+    /**
+     * Sleep for the specified amount of time.
+     * If called from within a workflow, the sleep is "durable",
+     *   meaning that the workflow will sleep until the wakeup time
+     *   (calculated by adding `durationMS` to the original invocation time),
+     *   regardless of workflow recovery.
+     * @param durationMS - Length of sleep, in milliseconds.
+     */
+    static async sleepms(durationMS) {
+        if (SolidActions.isWithinWorkflow() && !SolidActions.isInStep()) {
+            if (SolidActions.isInTransaction()) {
+                throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to `SolidActions.sleep` inside a `transaction`');
+            }
+            const functionID = (0, context_1.functionIDGetIncrement)();
+            if (durationMS <= 0) {
+                return;
+            }
+            return await solidactions_executor_1.SolidActionsExecutor.globalInstance.systemDatabase.durableSleepms(SolidActions.workflowID, functionID, durationMS);
+        }
+        await (0, utils_1.sleepms)(durationMS);
+    }
+    /** @see sleepms */
+    static async sleepSeconds(durationSec) {
+        return SolidActions.sleepms(durationSec * 1000);
+    }
+    /** @see sleepms */
+    static async sleep(durationMS) {
+        return SolidActions.sleepms(durationMS);
+    }
+    /**
+     * Get the current time in milliseconds, similar to `Date.now()`.
+     * This function is deterministic and can be used within workflows.
+     */
+    static async now() {
+        if (SolidActions.isInWorkflow()) {
+            return runInternalStep(async () => Promise.resolve(Date.now()), 'SolidActions.now');
+        }
+        return Date.now();
+    }
+    /**
+     * Generate a random (v4) UUUID, similar to `node:crypto.randomUUID`.
+     * This function is deterministic and can be used within workflows.
+     */
+    static async randomUUID() {
+        if (SolidActions.isInWorkflow()) {
+            return runInternalStep(async () => Promise.resolve((0, node_crypto_1.randomUUID)()), 'SolidActions.randomUUID');
+        }
+        return (0, node_crypto_1.randomUUID)();
+    }
+    /**
+     * Use the provided `workflowID` as the identifier for first workflow started
+     *   within the `callback` function.
+     * @param workflowID - ID to assign to the first workflow started
+     * @param callback - Function to run, which would start a workflow
+     * @returns - Return value from `callback`
+     */
+    static async withNextWorkflowID(workflowID, callback) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('workflows');
+        return SolidActions.#withTopContext({ idAssignedForNextWorkflow: workflowID }, callback);
+    }
+    /**
+     * Use the provided `authedUser` and `authedRoles` as the authenticated user for
+     *   any security checks or calls to `SolidActions.authenticatedUser`
+     *   or `SolidActions.authenticatedRoles` placed within the `callback` function.
+     * @param authedUser - Authenticated user
+     * @param authedRoles - Authenticated roles
+     * @param callback - Function to run with authentication context in place
+     * @returns - Return value from `callback`
+     */
+    static async withAuthedContext(authedUser, authedRoles, callback) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('auth');
+        return SolidActions.#withTopContext({
+            authenticatedUser: authedUser,
+            authenticatedRoles: authedRoles,
+        }, callback);
+    }
+    /**
+     * This generic setter helps users calling SolidActions operation to pass a name,
+     *   later used in seeding a parent OTel span for the operation.
+     * @param callerName - Tracing caller name
+     * @param callback - Function to run with tracing context in place
+     * @returns - Return value from `callback`
+     */
+    static async withNamedContext(callerName, callback) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('tracing');
+        return SolidActions.#withTopContext({ operationCaller: callerName }, callback);
+    }
+    /**
+     * Specify workflow timeout for any workflows started within the `callback`.
+     * @param timeoutMS - timeout length for all workflows started within `callback` will be run
+     * @param callback - Function to run, which would call or start workflows
+     * @returns - Return value from `callback`
+     */
+    static async withWorkflowTimeout(timeoutMS, callback) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('workflows');
+        return SolidActions.#withTopContext({ workflowTimeoutMS: timeoutMS }, callback);
+    }
+    /**
+     * Run a workflow with the option to set any of the contextual items
+     *
+     * @param options - Overrides for options
+     * @param callback - Function to run, which would call or start workflows
+     * @returns - Return value from `callback`
+     */
+    static async runWithContext(options, callback) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('contexts');
+        return SolidActions.#withTopContext(options, callback);
+    }
+    static async #withTopContext(options, callback) {
+        const pctx = (0, context_1.getCurrentContextStore)();
+        if (pctx) {
+            // Save existing values and overwrite with new; hard to do cleanly but is actually type correct
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const existing = {};
+            for (const k of Object.keys(options)) {
+                if (Object.hasOwn(pctx, k))
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+                    existing[k] = options[k];
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+                pctx[k] = options[k];
+            }
+            try {
+                return await callback();
+            }
+            finally {
+                for (const k of Object.keys(options)) {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                    if (Object.hasOwn(existing, k))
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
+                        pctx[k] = existing[k];
+                    else
+                        delete pctx[k];
+                }
+            }
+        }
+        else {
+            return await (0, context_1.runWithTopContext)(options, callback);
+        }
+    }
+    static startWorkflow(target, params) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('workflows');
+        const instance = typeof target === 'function' ? null : target;
+        if (instance && typeof instance !== 'function' && !(instance instanceof decorators_1.ConfiguredInstance)) {
+            throw new error_1.SolidActionsInvalidWorkflowTransitionError('Attempt to call `startWorkflow` on an object that is not a `ConfiguredInstance`');
+        }
+        const regOps = (0, decorators_1.getRegisteredOperations)(target);
+        const handler = {
+            apply(target, _thisArg, args) {
+                const regOp = (0, decorators_1.getFunctionRegistration)(target);
+                if (!regOp) {
+                    // eslint-disable-next-line @typescript-eslint/no-base-to-string
+                    const name = typeof target === 'function' ? target.name : target.toString();
+                    throw new error_1.SolidActionsNotRegisteredError(name, `${name} is not a registered SolidActions workflow function`);
+                }
+                return SolidActions.#invokeWorkflow(instance, regOp, args, params);
+            },
+            get(target, p, receiver) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                const func = Reflect.get(target, p, receiver);
+                const regOp = (0, decorators_1.getFunctionRegistration)(func) ?? regOps.find((op) => op.name === p);
+                if (regOp) {
+                    return (...args) => SolidActions.#invokeWorkflow(instance, regOp, args, params);
+                }
+                const name = typeof p === 'string' ? p : String(p);
+                throw new error_1.SolidActionsNotRegisteredError(name, `${name} is not a registered SolidActions workflow function`);
+            },
+        };
+        return new Proxy(target, handler);
+    }
+    /**
+     * Send `message` on optional `topic` to the workflow with `destinationID`
+     *  This can be done from inside or outside of SolidActions workflow functions
+     *  Use the optional `idempotencyKey` to guarantee that the message is sent exactly once
+     * @see `SolidActions.recv`
+     *
+     * @param destinationID - ID of the workflow that will `recv` the message
+     * @param message - Message to send, which must be serializable as JSON
+     * @param topic - Optional topic; if specified the `recv` command can specify the same topic to receive selectively
+     * @param idempotencyKey - Optional key for sending the message exactly once
+     */
+    static async send(destinationID, message, topic, idempotencyKey) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('send');
+        if (SolidActions.isWithinWorkflow()) {
+            if (!SolidActions.isInWorkflow()) {
+                throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to `SolidActions.send` inside a `step` or `transaction`');
+            }
+            if (idempotencyKey) {
+                throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to `SolidActions.send` with an idempotency key from within a workflow');
+            }
+            const functionID = (0, context_1.functionIDGetIncrement)();
+            return await solidactions_executor_1.SolidActionsExecutor.globalInstance.systemDatabase.send(SolidActions.workflowID, functionID, destinationID, SolidActions.#executor.serializer.stringify(message), topic);
+        }
+        return SolidActions.#executor.runSendTempWF(destinationID, message, topic, idempotencyKey); // Temp WF variant
+    }
+    /**
+     * Receive a message on optional `topic` from within a workflow.
+     *  This must be called from within a workflow; this workflow's ID is used to check for messages sent by `SolidActions.send`
+     *  This can be configured to time out.
+     *  Messages are received in the order in which they are sent (per-sender / causal order).
+     * @see `SolidActions.send`
+     *
+     * @param topic - Optional topic; if specified the `recv` command can specify the same topic to receive selectively
+     * @param timeoutSeconds - Optional timeout; if no message is received before the timeout, `null` will be returned
+     * @template T - The type of message that is expected to be received
+     * @returns Any message received, or `null` if the timeout expires
+     */
+    static async recv(topic, timeoutSeconds) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('recv');
+        if (SolidActions.isWithinWorkflow()) {
+            if (!SolidActions.isInWorkflow()) {
+                throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to `SolidActions.recv` inside a `step` or `transaction`');
+            }
+            const functionID = (0, context_1.functionIDGetIncrement)();
+            const timeoutFunctionID = (0, context_1.functionIDGetIncrement)();
+            return SolidActions.#executor.serializer.parse(await solidactions_executor_1.SolidActionsExecutor.globalInstance.systemDatabase.recv(SolidActions.workflowID, functionID, timeoutFunctionID, topic, timeoutSeconds));
+        }
+        throw new error_1.SolidActionsInvalidWorkflowTransitionError('Attempt to call `SolidActions.recv` outside of a workflow'); // Only workflows can recv
+    }
+    /**
+     * Set an event, from within a SolidActions workflow.  This value can be retrieved with `SolidActions.getEvent`.
+     * If the event `key` already exists, its `value` is updated.
+     * This function can only be called from within a workflow.
+     * @see `SolidActions.getEvent`
+     *
+     * @param key - The key for the event; at most one value is associated with a key at any given time.
+     * @param value - The value to associate with `key`
+     */
+    static async setEvent(key, value) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('setEvent');
+        if (SolidActions.isWithinWorkflow()) {
+            if (!SolidActions.isInWorkflow()) {
+                throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to `SolidActions.setEvent` inside a `step` or `transaction`');
+            }
+            const functionID = (0, context_1.functionIDGetIncrement)();
+            return solidactions_executor_1.SolidActionsExecutor.globalInstance.systemDatabase.setEvent(SolidActions.workflowID, functionID, key, SolidActions.#executor.serializer.stringify(value));
+        }
+        throw new error_1.SolidActionsInvalidWorkflowTransitionError('Attempt to call `SolidActions.setEvent` outside of a workflow'); // Only workflows can set event
+    }
+    /**
+     * Get the value of a workflow event, or wait for it to be set.
+     * This function can be called inside or outside of SolidActions workflow functions.
+     * If this function is called from within a workflow, its result is durably checkpointed.
+     * @see `SolidActions.setEvent`
+     *
+     * @param workflowID - The ID of the workflow with the corresponding `setEvent`
+     * @param key - The key for the event; at most one value is associated with a key at any given time.
+     * @param timeoutSeconds - Optional timeout; if a value for `key` is not set before the timeout, `null` will be returned
+     * @template T - The expected type for the value assigned to `key`
+     * @returns The value to associate with `key`, or `null` if the timeout is hit
+     */
+    static async getEvent(workflowID, key, timeoutSeconds) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('getEvent');
+        if (SolidActions.isWithinWorkflow()) {
+            if (!SolidActions.isInWorkflow()) {
+                throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to `SolidActions.getEvent` inside a `step` or `transaction`');
+            }
+            const functionID = (0, context_1.functionIDGetIncrement)();
+            const timeoutFunctionID = (0, context_1.functionIDGetIncrement)();
+            const params = {
+                workflowID: SolidActions.workflowID,
+                functionID,
+                timeoutFunctionID,
+            };
+            return SolidActions.#executor.serializer.parse(await solidactions_executor_1.SolidActionsExecutor.globalInstance.systemDatabase.getEvent(workflowID, key, timeoutSeconds ?? solidactions_executor_1.SolidActionsExecutor.defaultNotificationTimeoutSec, params));
+        }
+        return SolidActions.#executor.getEvent(workflowID, key, timeoutSeconds);
+    }
+    /**
+     * Write a value to a stream.
+     * @param key - The stream key/name within the workflow
+     * @param value - A serializable value to write to the stream
+     */
+    static async writeStream(key, value) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('writeStream');
+        if (SolidActions.isWithinWorkflow()) {
+            if (SolidActions.isInWorkflow()) {
+                const functionID = (0, context_1.functionIDGetIncrement)();
+                return await solidactions_executor_1.SolidActionsExecutor.globalInstance.systemDatabase.writeStreamFromWorkflow(SolidActions.workflowID, functionID, key, value);
+            }
+            else if (SolidActions.isInStep()) {
+                return await solidactions_executor_1.SolidActionsExecutor.globalInstance.systemDatabase.writeStreamFromStep(SolidActions.workflowID, key, value);
+            }
+            else {
+                throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to `SolidActions.writeStream` outside of a workflow or step');
+            }
+        }
+        else {
+            throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to `SolidActions.writeStream` outside of a workflow or step');
+        }
+    }
+    /**
+     * Close a stream by writing a sentinel value.
+     * @param key - The stream key/name within the workflow
+     */
+    static async closeStream(key) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('closeStream');
+        if (SolidActions.isWithinWorkflow()) {
+            if (SolidActions.isInWorkflow()) {
+                const functionID = (0, context_1.functionIDGetIncrement)();
+                return await solidactions_executor_1.SolidActionsExecutor.globalInstance.systemDatabase.closeStream(SolidActions.workflowID, functionID, key);
+            }
+            else {
+                throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to `SolidActions.closeStream` outside of a workflow or step');
+            }
+        }
+        else {
+            throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to `SolidActions.closeStream` outside of a workflow');
+        }
+    }
+    /**
+     * Read values from a stream as an async generator.
+     * This function reads values from a stream identified by the workflowID and key,
+     * yielding each value in order until the stream is closed or the workflow terminates.
+     * @param workflowID - The workflow instance ID that owns the stream
+     * @param key - The stream key/name within the workflow
+     * @returns An async generator that yields each value in the stream until the stream is closed
+     */
+    static async *readStream(workflowID, key) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('readStream');
+        let offset = 0;
+        while (true) {
+            try {
+                const value = await solidactions_executor_1.SolidActionsExecutor.globalInstance.systemDatabase.readStream(workflowID, key, offset);
+                if (value === system_database_1.SOLIDACTIONS_STREAM_CLOSED_SENTINEL) {
+                    break;
+                }
+                yield value;
+                offset += 1;
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes('No value found')) {
+                    // Poll the offset until a value arrives or the workflow terminates
+                    const status = await SolidActions.getWorkflowStatus(workflowID);
+                    if (!status || !(0, workflow_1.isWorkflowActive)(status.status)) {
+                        break;
+                    }
+                    await (0, utils_1.sleepms)(1000); // 1 second polling interval
+                    continue;
+                }
+                throw error;
+            }
+        }
+    }
+    //////
+    // Decorators
+    //////
+    /**
+     * Allow a class to be assigned a name
+     */
+    static className(name) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function clsdec(ctor) {
+            const clsreg = (0, decorators_1.getClassRegistration)(ctor, true);
+            if (clsreg.reg?.name && clsreg.reg.name !== name && clsreg.reg.name !== ctor.name) {
+                throw new error_1.SolidActionsConflictingRegistrationError(`Attempt to assign name ${name} to class ${ctor.name}, which has already been aliased to ${clsreg.reg.name}`);
+            }
+            clsreg.reg.name = name;
+        }
+        return clsdec;
+    }
+    /**
+     * Decorator designating a method as a SolidActions workflow
+     *   Durable execution will be applied within calls to the workflow function
+     *   This also registers the function so that it is available during recovery
+     * @param config - Configuration information for the workflow
+     */
+    static workflow(config = {}) {
+        function decorator(target, propertyKey, inDescriptor) {
+            const { descriptor, registration } = (0, decorators_1.wrapSolidActionsFunctionAndRegisterByTarget)(target, propertyKey, config.name ?? propertyKey, inDescriptor);
+            const invoker = SolidActions.#getWorkflowInvoker(registration, config);
+            descriptor.value = invoker;
+            registration.wrappedFunction = invoker;
+            (0, decorators_1.registerFunctionWrapper)(invoker, registration);
+            return descriptor;
+        }
+        return decorator;
+    }
+    /**
+     * Create a SolidActions workflow function from a provided function.
+     *   Similar to the SolidActions.workflow, but without requiring a decorator
+     *   Durable execution will be applied to calls to the function returned by registerWorkflow
+     *   This also registers the function so that it is available during recovery
+     * @param func - The function to register as a workflow
+     * @param name - The name of the registered workflow
+     * @param options - Configuration information for the registered workflow
+     */
+    static registerWorkflow(func, config) {
+        const registration = (0, decorators_1.wrapSolidActionsFunctionAndRegisterByUniqueName)(config?.ctorOrProto, config?.className, config?.name ?? func.name, config?.name ?? func.name, func);
+        return SolidActions.#getWorkflowInvoker(registration, config);
+    }
+    static async #invokeWorkflow($this, regOP, args, params = {}, startWfFuncId) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('workflows');
+        const wfId = (0, context_1.getNextWFID)(params.workflowID);
+        const ppctx = (0, context_1.getCurrentContextStore)();
+        const queueName = params.queueName ?? ppctx?.queueAssignedForWorkflows;
+        const timeoutMS = params.timeoutMS ?? ppctx?.workflowTimeoutMS;
+        const instance = $this === undefined || typeof $this === 'function' ? undefined : $this;
+        if (instance && !(instance instanceof decorators_1.ConfiguredInstance)) {
+            throw new error_1.SolidActionsInvalidWorkflowTransitionError('Attempt to call a `workflow` function on an object that is not a `ConfiguredInstance`');
+        }
+        // If this is called from within a workflow, this is a child workflow,
+        //  For OAOO, we will need a consistent ID formed from the parent WF and call number
+        if (SolidActions.isWithinWorkflow()) {
+            if (!SolidActions.isInWorkflow()) {
+                throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to a `workflow` function from within a `step` or `transaction`');
+            }
+            const funcId = startWfFuncId ?? (0, context_1.functionIDGetIncrement)();
+            const pctx = (0, context_1.getCurrentContextStore)();
+            const pwfid = pctx.workflowId;
+            const wfParams = {
+                workflowUUID: wfId || pwfid + '-' + funcId,
+                configuredInstance: instance,
+                queueName,
+                timeoutMS,
+                // Detach child deadline if a null timeout is configured
+                deadlineEpochMS: params.timeoutMS === null || pctx?.workflowTimeoutMS === null ? undefined : pctx?.deadlineEpochMS,
+                enqueueOptions: params.enqueueOptions,
+            };
+            return await invokeRegOp(wfParams, pwfid, funcId);
+        }
+        else {
+            const wfParams = {
+                workflowUUID: wfId,
+                queueName,
+                enqueueOptions: params.enqueueOptions,
+                configuredInstance: instance,
+                timeoutMS,
+            };
+            return await invokeRegOp(wfParams, undefined, undefined);
+        }
+        function invokeRegOp(wfParams, workflowID, funcNum) {
+            if (regOP.workflowConfig) {
+                const func = regOP.registeredFunction;
+                return solidactions_executor_1.SolidActionsExecutor.globalInstance.internalWorkflow(func, wfParams, workflowID, funcNum, ...args);
+            }
+            if (regOP.stepConfig) {
+                const func = regOP.registeredFunction;
+                return solidactions_executor_1.SolidActionsExecutor.globalInstance.startStepTempWF(func, wfParams, workflowID, funcNum, ...args);
+            }
+            throw new error_1.SolidActionsNotRegisteredError(regOP.name, `${regOP.name} is not a registered SolidActions workflow, step, or transaction function`);
+        }
+    }
+    static #getWorkflowInvoker(registration, config) {
+        registration.setWorkflowConfig(config ?? {});
+        const invoker = async function (...rawArgs) {
+            (0, decorators_1.ensureSolidActionsIsLaunched)('workflows');
+            if (SolidActions.isInWorkflow()) {
+                const startWfFuncId = (0, context_1.functionIDGetIncrement)();
+                const getResFuncID = (0, context_1.functionIDGetIncrement)();
+                const handle = await SolidActions.#invokeWorkflow(this, registration, rawArgs, undefined, startWfFuncId);
+                return await handle.getResult(getResFuncID);
+            }
+            const handle = await SolidActions.#invokeWorkflow(this, registration, rawArgs);
+            return await handle.getResult();
+        };
+        (0, decorators_1.registerFunctionWrapper)(invoker, registration);
+        Object.defineProperty(invoker, 'name', {
+            value: registration.name,
+        });
+        return invoker;
+    }
+    /**
+     * Decorator designating a method as a SolidActions step.
+     *   A durable checkpoint will be made after the step completes
+     *   This ensures "at least once" execution of the step, and that the step will not
+     *    be executed again once the checkpoint is recorded
+     *
+     * @param config - Configuration information for the step, particularly the retry policy
+     */
+    static step(config = {}) {
+        function decorator(target, propertyKey, inDescriptor) {
+            const { descriptor, registration } = (0, decorators_1.wrapSolidActionsFunctionAndRegisterByTarget)(target, propertyKey, config.name, inDescriptor);
+            registration.setStepConfig(config);
+            const invokeWrapper = async function (...rawArgs) {
+                (0, decorators_1.ensureSolidActionsIsLaunched)('steps');
+                let inst = undefined;
+                if (this === undefined || typeof this === 'function') {
+                    // This is static
+                }
+                else {
+                    inst = this;
+                    if (!(inst instanceof decorators_1.ConfiguredInstance)) {
+                        throw new error_1.SolidActionsInvalidWorkflowTransitionError('Attempt to call a `step` function on an object that is not a `ConfiguredInstance`');
+                    }
+                }
+                if (SolidActions.isWithinWorkflow()) {
+                    if (SolidActions.isInTransaction()) {
+                        throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to a `step` function from within a `transaction`');
+                    }
+                    if (SolidActions.isInStep()) {
+                        // There should probably be checks here about the compatibility of the StepConfig...
+                        return registration.registeredFunction.call(this, ...rawArgs);
+                    }
+                    return await solidactions_executor_1.SolidActionsExecutor.globalInstance.callStepFunction(registration.registeredFunction, undefined, undefined, inst ?? null, ...rawArgs);
+                }
+                const wfId = (0, context_1.getNextWFID)(undefined);
+                const wfParams = {
+                    configuredInstance: inst,
+                    workflowUUID: wfId,
+                };
+                return await SolidActions.#executor.runStepTempWF(registration.registeredFunction, wfParams, ...rawArgs);
+            };
+            descriptor.value = invokeWrapper;
+            registration.wrappedFunction = invokeWrapper;
+            (0, decorators_1.registerFunctionWrapper)(invokeWrapper, registration);
+            Object.defineProperty(invokeWrapper, 'name', {
+                value: registration.name,
+            });
+            return descriptor;
+        }
+        return decorator;
+    }
+    /**
+     * Create a check pointed SolidActions step function from  a provided function
+     *   Similar to the SolidActions.step decorator, but without requiring a decorator
+     *   A durable checkpoint will be made after the step completes
+     *   This ensures "at least once" execution of the step, and that the step will not
+     *    be executed again once the checkpoint is recorded
+     * @param func - The function to register as a step
+     * @param config - Configuration information for the step, particularly the retry policy and name
+     */
+    static registerStep(func, config = {}) {
+        const name = config.name ?? func.name;
+        const reg = (0, decorators_1.wrapSolidActionsFunctionAndRegister)(config?.ctorOrProto, config?.className, name, name, func);
+        const invokeWrapper = async function (...rawArgs) {
+            (0, decorators_1.ensureSolidActionsIsLaunched)('steps');
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const inst = this;
+            const callFunc = reg.registeredFunction ?? reg.origFunction;
+            if (SolidActions.isWithinWorkflow()) {
+                if (SolidActions.isInTransaction()) {
+                    throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to a `step` function from within a `transaction`');
+                }
+                if (SolidActions.isInStep()) {
+                    // There should probably be checks here about the compatibility of the StepConfig...
+                    return callFunc.call(this, ...rawArgs);
+                }
+                return await solidactions_executor_1.SolidActionsExecutor.globalInstance.callStepFunction(callFunc, name, config, inst ?? null, ...rawArgs);
+            }
+            if ((0, context_1.getNextWFID)(undefined)) {
+                throw new error_1.SolidActionsInvalidWorkflowTransitionError(`Invalid call to step '${name}' outside of a workflow; with directive to start a workflow.`);
+            }
+            return callFunc.call(this, ...rawArgs);
+        };
+        (0, decorators_1.registerFunctionWrapper)(invokeWrapper, reg);
+        Object.defineProperty(invokeWrapper, 'name', { value: name });
+        return invokeWrapper;
+    }
+    /**
+     * Run the enclosed `callback` as a checkpointed step within a SolidActions workflow
+     * @param callback - function containing code to run
+     * @param config - Configuration information for the step, particularly the retry policy
+     * @param config.name - The name of the step; if not provided, the function name will be used
+     * @returns - result (either obtained from invoking function, or retrieved if run before)
+     */
+    static runStep(func, config = {}) {
+        (0, decorators_1.ensureSolidActionsIsLaunched)('steps');
+        const name = config.name ?? func.name;
+        if (SolidActions.isWithinWorkflow()) {
+            if (SolidActions.isInTransaction()) {
+                throw new error_1.SolidActionsInvalidWorkflowTransitionError('Invalid call to a runStep from within a `transaction`');
+            }
+            if (SolidActions.isInStep()) {
+                // There should probably be checks here about the compatibility of the StepConfig...
+                return func();
+            }
+            return solidactions_executor_1.SolidActionsExecutor.globalInstance.callStepFunction(func, name, config, null);
+        }
+        if ((0, context_1.getNextWFID)(undefined)) {
+            throw new error_1.SolidActionsInvalidWorkflowTransitionError(`Invalid call to step '${name}' outside of a workflow; with directive to start a workflow.`);
+        }
+        return func();
+    }
+    /**
+     * Register serialization recipe; this is used to save/retrieve objects from the SolidActions system
+     *  database.  This includes workflow inputs, function return values, messages, and events.
+     */
+    static registerSerialization(serReg) {
+        if (SolidActions.isInitialized()) {
+            throw new TypeError(`Serializers/deserializers should not be registered after SolidActions.launch()`);
+        }
+        (0, serialization_1.registerSerializationRecipe)(serReg);
+    }
+    /**
+     * Decorate a class with the default list of required roles.
+     *   This class-level default can be overridden on a per-function basis with `requiredRole`.
+     * @param anyOf - The list of roles allowed access; authorization is granted if the authenticated user has any role on the list
+     */
+    static defaultRequiredRole(anyOf) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        function clsdec(ctor) {
+            const clsreg = (0, decorators_1.associateClassWithExternal)(decorators_1.SOLIDACTIONS_AUTH, ctor);
+            clsreg.requiredRole = anyOf;
+            (0, authdecorators_1.registerAuthChecker)();
+        }
+        return clsdec;
+    }
+    /**
+     * Decorate a method with the default list of required roles.
+     * @see `SolidActions.defaultRequiredRole`
+     * @param anyOf - The list of roles allowed access; authorization is granted if the authenticated user has any role on the list
+     */
+    static requiredRole(anyOf) {
+        function apidec(target, propertyKey, inDescriptor) {
+            const rr = (0, decorators_1.associateMethodWithExternal)(decorators_1.SOLIDACTIONS_AUTH, target, undefined, propertyKey.toString(), inDescriptor.value);
+            rr.regInfo.requiredRole = anyOf;
+            (0, authdecorators_1.registerAuthChecker)();
+            inDescriptor.value = rr.registration.wrappedFunction ?? rr.registration.registeredFunction;
+            return inDescriptor;
+        }
+        return apidec;
+    }
+    /////
+    // Patching
+    /////
+    /**
+     * Check if a workflow execution has been patched.
+     *
+     * Patching allows reexecution of workflows to accommate changes to the workflow logic.
+     *
+     * Patches check the system database to see which code branch to take.  As this adds overhead,
+     *  they may eventually be removed; see `deprecatePatch`.
+     *
+     * @param patchName Name of the patch to check.
+     * @returns true if this is the patched(new) workflow variant, or false if the execution predates the patch
+     */
+    static async patch(patchName) {
+        if (!SolidActions.isInWorkflow()) {
+            throw new error_1.SolidActionsInvalidWorkflowTransitionError('`SolidActions.patch` must be called from a workflow, and not within a step');
+        }
+        if (!SolidActions.#solidActionsConfig?.enablePatching) {
+            throw new error_1.SolidActionsInvalidWorkflowTransitionError('Patching is not enabled.  See `enablePatching` in `SolidActionsConfig`');
+        }
+        const patched = await solidactions_executor_1.SolidActionsExecutor.globalInstance.systemDatabase.checkPatch(SolidActions.workflowID, (0, context_1.functionIDGet)(), patchName, false);
+        if (patched.hasEntry) {
+            (0, context_1.functionIDGetIncrement)();
+        }
+        return patched.isPatched;
+    }
+    /**
+     * Check if a workflow execution has been patched, within a plan to eventually remove the unpatched (old) variant.
+     *
+     * `patch` may be changed to `deprecatePatch` after all unpatched workflows have completed and will not be reexecuted.
+     * Once all workflows started with `patch` have completed (in favor of those using `deprecatePatch`), the `deprecatePatch` may then be removed.
+     *
+     * @param patchName Name of the patch to check.
+     * @returns true if this is the patched(new) workflow variant, which it should always be if all unpatched workflows have been retired
+     */
+    static async deprecatePatch(patchName) {
+        if (!SolidActions.isInWorkflow()) {
+            throw new error_1.SolidActionsInvalidWorkflowTransitionError('`SolidActions.deprecatePatch` must be called from a workflow, and not within a step');
+        }
+        if (!SolidActions.#solidActionsConfig?.enablePatching) {
+            throw new error_1.SolidActionsInvalidWorkflowTransitionError('Patching is not enabled.  See `enablePatching` in `SolidActionsConfig`');
+        }
+        const patched = await solidactions_executor_1.SolidActionsExecutor.globalInstance.systemDatabase.checkPatch(SolidActions.workflowID, (0, context_1.functionIDGet)(), patchName, true);
+        if (patched.hasEntry) {
+            (0, context_1.functionIDGetIncrement)();
+        }
+        return patched.isPatched;
+    }
+    /////
+    // Registration, etc
+    /////
+    /**
+     * Register a lifecycle listener
+     */
+    static registerLifecycleCallback(lcl) {
+        (0, decorators_1.registerLifecycleCallback)(lcl);
+    }
+    /**
+     * Register a middleware provider
+     */
+    static registerMiddlewareInstaller(mwp) {
+        (0, decorators_1.registerMiddlewareInstaller)(mwp);
+    }
+    /**
+     * Register information to be associated with a SolidActions class
+     */
+    static associateClassWithInfo(external, cls) {
+        return (0, decorators_1.associateClassWithExternal)(external, cls);
+    }
+    /**
+     * Register information to be associated with a SolidActions function
+     */
+    static associateFunctionWithInfo(external, func, target) {
+        return (0, decorators_1.associateMethodWithExternal)(external, target.ctorOrProto, target.className, target.name ?? func.name, func);
+    }
+    /**
+     * Register information to be associated with a SolidActions function
+     */
+    static associateParamWithInfo(external, func, target) {
+        return (0, decorators_1.associateParameterWithExternal)(external, target.ctorOrProto, target.className, target.name ?? func?.name ?? '<unknown>', func, target.param);
+    }
+    /** Get registrations */
+    static getAssociatedInfo(external, cls, funcName) {
+        return (0, decorators_1.getRegistrationsForExternal)(external, cls, funcName);
+    }
+}
+exports.SolidActions = SolidActions;
+//# sourceMappingURL=solidactions.js.map