@positronic/core 0.0.1

package/.swcrc

@@ -0,0 +1,31 @@
+{
+  "jsc": {
+    "parser": {
+      "syntax": "typescript"
+    },
+    "target": "es2022",
+    "experimental": {
+      "plugins": [
+        [
+          "@swc/plugin-transform-imports",
+          {
+            "^(\\.{1,2}\\/.*?)$": {
+              "skipDefaultConversion": true,
+              "transform": "{{matches.[1]}}.js"
+            }
+          }
+        ]
+      ]
+    }
+  },
+  "module": {
+    "type": "es6"
+  },
+  "exclude": [
+    ".*\\.test\\.ts$",
+    "node_modules",
+    "dist",
+    "coverage",
+    "jest.config.*"
+  ]
+}

package/dist/src/adapters/types.js

@@ -0,0 +1,16 @@
+import { WORKFLOW_EVENTS } from "../dsl/constants.js";
+export class Adapter {
+    async dispatch(event) {
+        if (event.type === WORKFLOW_EVENTS.START && this.started) {
+            await this.started(event);
+        } else if (event.type === WORKFLOW_EVENTS.STEP_COMPLETE && this.updated) {
+            await this.updated(event);
+        } else if (event.type === WORKFLOW_EVENTS.COMPLETE && this.completed) {
+            await this.completed(event);
+        } else if (event.type === WORKFLOW_EVENTS.ERROR && this.error) {
+            await this.error(event);
+        } else if (event.type === WORKFLOW_EVENTS.RESTART && this.restarted) {
+            await this.restarted(event);
+        }
+    }
+}

package/dist/src/clients/types.js

@@ -0,0 +1 @@
+export { };

package/dist/src/dsl/constants.js

@@ -0,0 +1,15 @@
+export const WORKFLOW_EVENTS = {
+    START: 'workflow:start',
+    RESTART: 'workflow:restart',
+    STEP_START: 'step:start',
+    STEP_COMPLETE: 'step:complete',
+    STEP_STATUS: 'step:status',
+    ERROR: 'workflow:error',
+    COMPLETE: 'workflow:complete'
+};
+export const STATUS = {
+    PENDING: 'pending',
+    RUNNING: 'running',
+    COMPLETE: 'complete',
+    ERROR: 'error'
+};

package/dist/src/dsl/extensions.js

@@ -0,0 +1,19 @@
+import { Workflow } from "./workflow.js";
+export function createExtension(key, extension) {
+    return {
+        install () {
+            Object.defineProperty(Workflow.prototype, key, {
+                get () {
+                    const boundMethods = {};
+                    for (const [methodKey, fn] of Object.entries(extension)){
+                        boundMethods[methodKey] = fn.bind(this);
+                    }
+                    return boundMethods;
+                }
+            });
+        },
+        augment () {
+            return {};
+        }
+    };
+}

package/dist/src/dsl/json-patch.js

@@ -0,0 +1,30 @@
+import pkg from 'fast-json-patch';
+const { compare, applyPatch } = pkg;
+/**
+ * Creates a JSON Patch that describes the changes needed to transform prevState into nextState.
+ */ export function createPatch(prevState, nextState) {
+    // Filter out non-standard operations and ensure type safety
+    return compare(prevState, nextState).filter((op)=>[
+            'add',
+            'remove',
+            'replace',
+            'move',
+            'copy',
+            'test'
+        ].includes(op.op));
+}
+/**
+ * Applies one or more JSON Patches to a state object and returns the resulting state.
+ * If multiple patches are provided, they are applied in sequence.
+ */ export function applyPatches(state, patches) {
+    const patchArray = Array.isArray(patches[0]) ? patches : [
+        patches
+    ];
+    // Apply patches in sequence, creating a new state object each time
+    return patchArray.reduce((currentState, patch)=>{
+        const { newDocument } = applyPatch(currentState, patch, true, false);
+        return newDocument;
+    }, {
+        ...state
+    });
+}

package/dist/src/dsl/types.js

@@ -0,0 +1 @@
+export { };

package/dist/src/dsl/workflow-runner.js

@@ -0,0 +1,93 @@
+import { WORKFLOW_EVENTS } from "./constants.js";
+import { applyPatches } from "./json-patch.js";
+export class WorkflowRunner {
+    options;
+    constructor(options){
+        this.options = options;
+    }
+    async run(workflow, { initialState = {}, options, initialCompletedSteps, workflowRunId, endAfter } = {}) {
+        const { adapters, logger: { log }, verbose, fileStore, client } = this.options;
+        let currentState = initialState ?? {};
+        let stepNumber = 1;
+        // Apply any patches from completed steps
+        // to the initial state so that the workflow
+        // starts with a state that reflects all of the completed steps.
+        // Need to do this when a workflow is restarted with completed steps.
+        initialCompletedSteps?.forEach((step)=>{
+            if (step.patch) {
+                currentState = applyPatches(currentState, [
+                    step.patch
+                ]);
+                stepNumber++;
+            }
+        });
+        const workflowRun = workflowRunId && initialCompletedSteps ? workflow.run({
+            initialState,
+            initialCompletedSteps,
+            workflowRunId,
+            options,
+            client,
+            fileStore
+        }) : workflow.run({
+            initialState,
+            options,
+            client,
+            fileStore
+        });
+        for await (const event of workflowRun){
+            // Dispatch event to all adapters
+            await Promise.all(adapters.map((adapter)=>adapter.dispatch(event)));
+            // Update current state when steps complete
+            if (event.type === WORKFLOW_EVENTS.STEP_COMPLETE) {
+                if (event.patch) {
+                    currentState = applyPatches(currentState, [
+                        event.patch
+                    ]);
+                }
+                // Check if we should stop after this step
+                if (endAfter && stepNumber >= endAfter) {
+                    // Log final state if verbose
+                    if (verbose) {
+                        log(`\nWorkflow stopped after step ${endAfter} as requested: \n\n ${JSON.stringify(this.truncateDeep(structuredClone(currentState)), null, 2)}`);
+                    }
+                    return;
+                }
+                stepNumber++;
+            }
+            // Log final state on workflow completion/error if verbose
+            if ((event.type === WORKFLOW_EVENTS.COMPLETE || event.type === WORKFLOW_EVENTS.ERROR) && verbose) {
+                log(`\nWorkflow completed: \n\n ${JSON.stringify(this.truncateDeep(structuredClone(currentState)), null, 2)}`);
+            }
+        }
+    }
+    truncateDeep(obj, maxLength = 100) {
+        if (obj === null || obj === undefined) return obj;
+        if (typeof obj === 'string') {
+            return obj.length > maxLength ? obj.slice(0, maxLength) + '...' : obj;
+        }
+        if (Array.isArray(obj)) {
+            if (obj.length === 0) return obj;
+            let truncatedArray = [];
+            let currentLength = 2; // Account for [] brackets
+            for(let i = 0; i < obj.length; i++){
+                const processedItem = this.truncateDeep(obj[i], maxLength);
+                const itemStr = JSON.stringify(processedItem);
+                if (currentLength + itemStr.length + (i > 0 ? 1 : 0) > maxLength) {
+                    truncatedArray.push(`... (${obj.length})`);
+                    break;
+                }
+                truncatedArray.push(processedItem);
+                currentLength += itemStr.length + (i > 0 ? 1 : 0); // Add 1 for comma
+            }
+            return truncatedArray;
+        }
+        if (typeof obj === 'object') {
+            const truncated = {};
+            for (const [key, value] of Object.entries(obj)){
+                truncated[key] = this.truncateDeep(value, maxLength);
+            }
+            return truncated;
+        }
+        return obj;
+    }
+}

package/dist/src/dsl/workflow.js

@@ -0,0 +1,308 @@
+import { v4 as uuidv4 } from 'uuid';
+import { STATUS } from "./constants.js";
+import { WORKFLOW_EVENTS } from "./constants.js";
+import { createPatch } from "./json-patch.js";
+import { applyPatches } from "./json-patch.js";
+export class Workflow {
+    title;
+    description;
+    blocks;
+    type;
+    constructor(title, description){
+        this.title = title;
+        this.description = description;
+        this.blocks = [];
+        this.type = 'workflow';
+    }
+    step(title, action) {
+        const stepBlock = {
+            type: 'step',
+            title,
+            action
+        };
+        this.blocks.push(stepBlock);
+        return this.nextWorkflow();
+    }
+    workflow(title, innerWorkflow, action, initialState) {
+        const nestedBlock = {
+            type: 'workflow',
+            title,
+            innerWorkflow,
+            initialState: initialState || (()=>({})),
+            action: (outerState, innerState)=>action({
+                    state: outerState,
+                    workflowState: innerState
+                })
+        };
+        this.blocks.push(nestedBlock);
+        return this.nextWorkflow();
+    }
+    // TResponseKey:
+    // The response key must be a string literal, so if defining a response model
+    // a consumer of this workflow must use "as const" to ensure the key is a string literal
+    // this type makes sure that the will get a ts error if they don't.
+    prompt(title, config, reduce) {
+        const promptBlock = {
+            type: 'step',
+            title,
+            action: async ({ state, client: runClient, options })=>{
+                const { template, responseModel, client: stepClient } = config;
+                const client = stepClient ?? runClient;
+                const promptString = template(state);
+                const response = await client.execute(promptString, responseModel);
+                const stateWithResponse = {
+                    ...state,
+                    [config.responseModel.name]: response
+                };
+                return reduce ? reduce({
+                    state,
+                    response,
+                    options,
+                    prompt: promptString
+                }) : stateWithResponse;
+            }
+        };
+        this.blocks.push(promptBlock);
+        return this.nextWorkflow();
+    }
+    // Implementation signature
+    async *run(params) {
+        const { title, description, blocks } = this;
+        const stream = new WorkflowEventStream({
+            title,
+            description,
+            blocks,
+            ...params
+        });
+        yield* stream.next();
+    }
+    withBlocks(blocks) {
+        this.blocks = blocks;
+        return this;
+    }
+    nextWorkflow() {
+        return new Workflow(this.title, this.description).withBlocks(this.blocks);
+    }
+}
+class Step {
+    block;
+    id;
+    patch;
+    status;
+    constructor(block, id){
+        this.block = block;
+        this.status = STATUS.PENDING;
+        this.id = id || uuidv4();
+    }
+    withPatch(patch) {
+        this.patch = patch;
+        return this;
+    }
+    withStatus(status) {
+        this.status = status;
+        return this;
+    }
+    get serialized() {
+        return {
+            id: this.id,
+            title: this.block.title,
+            status: this.status,
+            patch: typeof this.patch === 'string' ? JSON.parse(this.patch) : this.patch
+        };
+    }
+}
+class WorkflowEventStream {
+    currentState;
+    steps;
+    currentStepIndex = 0;
+    initialState;
+    workflowRunId;
+    title;
+    description;
+    fileStore;
+    client;
+    options;
+    constructor(params){
+        const { initialState = {}, initialCompletedSteps, blocks, title, description, workflowRunId: providedWorkflowRunId, options = {}, fileStore, client } = params;
+        this.initialState = initialState;
+        this.title = title;
+        this.description = description;
+        this.fileStore = fileStore;
+        this.client = client;
+        this.options = options;
+        // Initialize steps array with UUIDs and pending status
+        this.steps = blocks.map((block, index)=>{
+            const completedStep = initialCompletedSteps?.[index];
+            if (completedStep) {
+                return new Step(block, completedStep.id).withStatus(completedStep.status).withPatch(completedStep.patch);
+            }
+            return new Step(block);
+        });
+        this.currentState = clone(this.initialState);
+        for (const step of this.steps){
+            if (step.serialized.status === STATUS.COMPLETE && step.serialized.patch) {
+                this.currentState = applyPatches(this.currentState, [
+                    step.serialized.patch
+                ]);
+            }
+        }
+        this.workflowRunId = providedWorkflowRunId ?? uuidv4();
+    }
+    async *next() {
+        const { steps, title: workflowTitle, description: workflowDescription, currentState, options, workflowRunId } = this;
+        try {
+            const hasCompletedSteps = steps.some((step)=>step.serialized.status !== STATUS.PENDING);
+            yield {
+                type: hasCompletedSteps ? WORKFLOW_EVENTS.RESTART : WORKFLOW_EVENTS.START,
+                status: STATUS.RUNNING,
+                workflowTitle,
+                workflowDescription,
+                initialState: currentState,
+                options,
+                workflowRunId
+            };
+            // Emit initial step status after workflow starts
+            yield {
+                type: WORKFLOW_EVENTS.STEP_STATUS,
+                steps: steps.map((step)=>step.serialized),
+                options,
+                workflowRunId
+            };
+            // Process each step
+            while(this.currentStepIndex < steps.length){
+                const step = steps[this.currentStepIndex];
+                // Skip completed steps
+                if (step.serialized.status === STATUS.COMPLETE) {
+                    this.currentStepIndex++;
+                    continue;
+                }
+                // Step start event
+                yield {
+                    type: WORKFLOW_EVENTS.STEP_START,
+                    status: STATUS.RUNNING,
+                    stepTitle: step.block.title,
+                    stepId: step.id,
+                    options,
+                    workflowRunId
+                };
+                // Execute step and yield the STEP_COMPLETE event and
+                // all events from inner workflows if any
+                yield* this.executeStep(step);
+                // Step Status Event
+                yield {
+                    type: WORKFLOW_EVENTS.STEP_STATUS,
+                    steps: steps.map((step)=>step.serialized),
+                    options,
+                    workflowRunId
+                };
+                this.currentStepIndex++;
+            }
+            yield {
+                type: WORKFLOW_EVENTS.COMPLETE,
+                status: STATUS.COMPLETE,
+                workflowTitle,
+                workflowDescription,
+                workflowRunId,
+                options
+            };
+        } catch (err) {
+            const error = err;
+            const currentStep = steps[this.currentStepIndex];
+            currentStep?.withStatus(STATUS.ERROR);
+            yield {
+                type: WORKFLOW_EVENTS.ERROR,
+                status: STATUS.ERROR,
+                workflowTitle,
+                workflowDescription,
+                workflowRunId,
+                error: {
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack
+                },
+                options
+            };
+            // Step Status Event
+            yield {
+                type: WORKFLOW_EVENTS.STEP_STATUS,
+                steps: steps.map((step)=>step.serialized),
+                options,
+                workflowRunId
+            };
+            throw error;
+        }
+    }
+    async *executeStep(step) {
+        const block = step.block;
+        if (block.type === 'workflow') {
+            const initialState = typeof block.initialState === 'function' ? block.initialState(this.currentState) : block.initialState;
+            // Run inner workflow and yield all its events
+            let patches = [];
+            const innerRun = block.innerWorkflow.run({
+                fileStore: this.fileStore,
+                client: this.client,
+                initialState,
+                options: this.options ?? {}
+            });
+            for await (const event of innerRun){
+                yield event; // Forward all inner workflow events
+                if (event.type === WORKFLOW_EVENTS.STEP_COMPLETE) {
+                    patches.push(event.patch);
+                }
+            }
+            // Apply collected patches to get final inner state
+            const innerState = applyPatches(initialState, patches);
+            // Get previous state before action
+            const prevState = this.currentState;
+            // Update state with inner workflow results
+            this.currentState = await block.action(this.currentState, innerState);
+            yield* this.completeStep(step, prevState);
+        } else {
+            // Get previous state before action
+            const prevState = this.currentState;
+            // Execute regular step
+            this.currentState = await block.action({
+                state: this.currentState,
+                options: this.options ?? {},
+                client: this.client,
+                fileStore: this.fileStore
+            });
+            yield* this.completeStep(step, prevState);
+        }
+    }
+    *completeStep(step, prevState) {
+        step.withStatus(STATUS.COMPLETE);
+        // Create patch for the state change
+        const patch = createPatch(prevState, this.currentState);
+        step.withPatch(patch);
+        yield {
+            type: WORKFLOW_EVENTS.STEP_COMPLETE,
+            status: STATUS.RUNNING,
+            stepTitle: step.block.title,
+            stepId: step.id,
+            patch,
+            options: this.options ?? {},
+            workflowRunId: this.workflowRunId
+        };
+    }
+}
+let workflowNamesAreUnique = true;
+export function disableWorkflowNameUniqueness() {
+    workflowNamesAreUnique = false;
+}
+export function enableWorkflowNameUniqueness() {
+    workflowNamesAreUnique = true;
+}
+const workflowNames = new Set();
+export function workflow(workflowConfig) {
+    const title = typeof workflowConfig === 'string' ? workflowConfig : workflowConfig.title;
+    const description = typeof workflowConfig === 'string' ? undefined : workflowConfig.description;
+    if (workflowNamesAreUnique && workflowNames.has(title)) {
+        throw new Error(`Workflow with name "${title}" already exists. Workflow names must be unique.`);
+    }
+    if (workflowNamesAreUnique) {
+        workflowNames.add(title);
+    }
+    return new Workflow(title, description);
+}
+const clone = (value)=>structuredClone(value);

package/dist/src/file-stores/local-file-store.js

@@ -0,0 +1,12 @@
+import { join } from 'path';
+import * as fs from 'fs/promises';
+export class LocalFileStore {
+    baseDir;
+    constructor(baseDir){
+        this.baseDir = baseDir;
+    }
+    async readFile(path) {
+        const filePath = join(this.baseDir, path);
+        return fs.readFile(filePath, 'utf-8');
+    }
+}

package/dist/src/file-stores/types.js

@@ -0,0 +1 @@
+export { };

package/dist/src/index.js

@@ -0,0 +1,10 @@
+export { Workflow } from "./dsl/workflow.js";
+export { workflow } from "./dsl/workflow.js";
+export { WorkflowRunner } from "./dsl/workflow-runner.js";
+export { createExtension } from "./dsl/extensions.js";
+export { STATUS } from "./dsl/constants.js";
+export { WORKFLOW_EVENTS } from "./dsl/constants.js";
+export { Adapter } from "./adapters/types.js";
+export { createPatch } from "./dsl/json-patch.js";
+export { applyPatches } from "./dsl/json-patch.js";
+export { LocalFileStore } from "./file-stores/local-file-store.js";

package/dist/src/utils/temp-files.js

@@ -0,0 +1,27 @@
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs/promises';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+/**
+ * Writes content to a temporary file and opens it in cursor
+ */ export async function writeAndOpenTemp(content, prefix, extension = 'txt') {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'positronic-'));
+    const filename = `${prefix}-${Date.now()}.${extension}`;
+    const filepath = path.join(tempDir, filename);
+    await fs.writeFile(filepath, content, 'utf8');
+    // Open in cursor using the cursor command
+    await execAsync(`cursor ${filepath}`);
+    return filepath;
+}
+/**
+ * Writes both prompt and response to temp files and opens them in cursor
+ */ export async function writePromptAndResponse(prompt, response, prefix = 'debug') {
+    const promptPath = await writeAndOpenTemp(prompt, `${prefix}-prompt`, 'md');
+    const responsePath = await writeAndOpenTemp(typeof response === 'string' ? response : JSON.stringify(response, null, 2), `${prefix}-response`, 'tsx');
+    return {
+        promptPath,
+        responsePath
+    };
+}

package/dist/types/adapters/types.d.ts

@@ -0,0 +1,10 @@
+import type { WorkflowEvent } from '../dsl/workflow';
+export declare abstract class Adapter<Options extends object = any> {
+    started?(event: WorkflowEvent<Options>): Promise<void>;
+    updated?(event: WorkflowEvent<Options>): Promise<void>;
+    completed?(event: WorkflowEvent<Options>): Promise<void>;
+    error?(event: WorkflowEvent<Options>): Promise<void>;
+    restarted?(event: WorkflowEvent<Options>): Promise<void>;
+    dispatch(event: WorkflowEvent<Options>): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/adapters/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/adapters/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,8BAAsB,OAAO,CAAC,OAAO,SAAS,MAAM,GAAG,GAAG;IAClD,OAAO,CAAC,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IACtD,OAAO,CAAC,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IACtD,SAAS,CAAC,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IACxD,KAAK,CAAC,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IACpD,SAAS,CAAC,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAExD,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC;CAa7C"}

package/dist/types/clients/types.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export type ResponseModel<T extends z.AnyZodObject> = {
+    schema: T;
+    name: string;
+    description?: string;
+};
+export interface PromptClient {
+    execute<T extends z.AnyZodObject>(prompt: string, responseModel: ResponseModel<T>): Promise<z.infer<T>>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/clients/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/clients/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,CAAC,CAAC,YAAY,IAAI;IAClD,MAAM,EAAE,CAAC,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB,CAAA;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,CAAC,SAAS,CAAC,CAAC,YAAY,EAC9B,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,aAAa,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;CACxB"}

package/dist/types/dsl/constants.d.ts

@@ -0,0 +1,16 @@
+export declare const WORKFLOW_EVENTS: {
+    readonly START: "workflow:start";
+    readonly RESTART: "workflow:restart";
+    readonly STEP_START: "step:start";
+    readonly STEP_COMPLETE: "step:complete";
+    readonly STEP_STATUS: "step:status";
+    readonly ERROR: "workflow:error";
+    readonly COMPLETE: "workflow:complete";
+};
+export declare const STATUS: {
+    readonly PENDING: "pending";
+    readonly RUNNING: "running";
+    readonly COMPLETE: "complete";
+    readonly ERROR: "error";
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/types/dsl/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/dsl/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe;;;;;;;;CAQlB,CAAC;AAEX,eAAO,MAAM,MAAM;;;;;CAKT,CAAC"}

package/dist/types/dsl/extensions.d.ts

@@ -0,0 +1,18 @@
+import { Workflow } from "./workflow";
+import type { State } from "./types";
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+type ExtensionMethods<TExtension extends Record<string, any>, TOptions extends object, TState extends State> = TExtension extends ((...args: any[]) => any) ? TExtension extends ((this: any, title: string, config: infer TConfig) => Workflow<any, infer TReturnState>) ? (title: string, config: TConfig extends ((ctx: any) => any) ? {
+    [P in keyof TConfig]: TConfig[P] extends Function ? ((ctx: TState) => any) : TConfig[P];
+} : TConfig) => Workflow<TOptions, Expand<TState & TReturnState>> : never : {
+    [K in keyof TExtension]: TExtension[K] extends (this: any, title: string, config: infer TConfig) => Workflow<any, infer TReturnState> ? (title: string, config: TConfig extends ((ctx: any) => any) ? {
+        [P in keyof TConfig]: TConfig[P] extends Function ? ((ctx: TState) => any) : TConfig[P];
+    } : TConfig) => Workflow<TOptions, Expand<TState & TReturnState>> : never;
+};
+export declare function createExtension<TExtensionKey extends string, TExtension extends Record<string, any>>(key: TExtensionKey, extension: TExtension): {
+    install(): void;
+    augment<TOptions extends object, TState extends State>(): ExtensionMethods<TExtension, TOptions, TState>;
+};
+export {};
+//# sourceMappingURL=extensions.d.ts.map

package/dist/types/dsl/extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../../../src/dsl/extensions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,KAAK,MAAM,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,GAAG,KAAK,CAAC;AAEtE,KAAK,gBAAgB,CACnB,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACtC,QAAQ,SAAS,MAAM,EACvB,MAAM,SAAS,KAAK,IAClB,UAAU,SAAS,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,GAC5C,UAAU,SAAS,CAAC,CAClB,IAAI,EAAE,GAAG,EACT,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,OAAO,KAClB,QAAQ,CAAC,GAAG,EAAE,MAAM,YAAY,CAAC,CAAC,GACrC,CACE,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,OAAO,SAAS,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,CAAC,GACvC;KAAG,CAAC,IAAI,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,SAAS,QAAQ,GAAG,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAAE,GAC3F,OAAO,KACR,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,GAAG,YAAY,CAAC,CAAC,GACtD,KAAK,GACP;KACG,CAAC,IAAI,MAAM,UAAU,GAAG,UAAU,CAAC,CAAC,CAAC,SAAS,CAC7C,IAAI,EAAE,GAAG,EACT,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,OAAO,KAClB,QAAQ,CAAC,GAAG,EAAE,MAAM,YAAY,CAAC,GAClC,CACE,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,OAAO,SAAS,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,CAAC,GACvC;SAAG,CAAC,IAAI,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,SAAS,QAAQ,GAAG,CAAC,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;KAAE,GAC3F,OAAO,KACR,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,GAAG,YAAY,CAAC,CAAC,GACtD,KAAK;CACV,CAAC;AAEN,wBAAgB,eAAe,CAC7B,aAAa,SAAS,MAAM,EAC5B,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACtC,GAAG,EAAE,aAAa,EAAE,SAAS,EAAE,UAAU;;YAa/B,QAAQ,SAAS,MAAM,EAAE,MAAM,SAAS,KAAK,KAAK,gBAAgB,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,CAAC;EAI3G"}

package/dist/types/dsl/json-patch.d.ts

@@ -0,0 +1,11 @@
+import { JsonPatch, State } from './types';
+/**
+ * Creates a JSON Patch that describes the changes needed to transform prevState into nextState.
+ */
+export declare function createPatch(prevState: State, nextState: State): JsonPatch;
+/**
+ * Applies one or more JSON Patches to a state object and returns the resulting state.
+ * If multiple patches are provided, they are applied in sequence.
+ */
+export declare function applyPatches(state: State, patches: JsonPatch | JsonPatch[]): State;
+//# sourceMappingURL=json-patch.d.ts.map