@exaudeus/workrail 0.8.6 → 0.10.0

package/dist/mcp-server.js

@@ -1,429 +1,11 @@
 #!/usr/bin/env node
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-const container_js_1 = require("./container.js");
-const index_js_1 = require("./infrastructure/session/index.js");
-const session_tools_js_1 = require("./tools/session-tools.js");
-class WorkflowOrchestrationServer {
-    constructor(container) {
-        this.sessionManager = null;
-        this.httpServer = null;
-        this.container = container ?? (0, container_js_1.createAppContainer)();
-        this.featureFlags = this.container.featureFlags;
-        if (this.featureFlags.isEnabled('sessionTools')) {
-            this.sessionManager = new index_js_1.SessionManager();
-            this.httpServer = new index_js_1.HttpServer(this.sessionManager, { autoOpen: false });
-            this.sessionTools = (0, session_tools_js_1.createSessionTools)(this.sessionManager, this.httpServer);
-            console.error('[FeatureFlags] Session tools enabled');
-        }
-        else {
-            this.sessionTools = [];
-            console.error('[FeatureFlags] Session tools disabled (enable with WORKRAIL_ENABLE_SESSION_TOOLS=true)');
-        }
-    }
-    async initialize() {
-        if (this.featureFlags.isEnabled('sessionTools') && this.httpServer) {
-            await this.httpServer.start();
-            console.error('[FeatureFlags] Dashboard server started');
-        }
-    }
-    getSessionTools() {
-        return this.sessionTools;
-    }
-    async handleSessionTool(name, args) {
-        if (!this.featureFlags.isEnabled('sessionTools') || !this.sessionManager || !this.httpServer) {
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify({
-                            error: 'Session tools are not enabled. Set WORKRAIL_ENABLE_SESSION_TOOLS=true to enable.',
-                            tool: name
-                        }, null, 2)
-                    }],
-                isError: true
-            };
-        }
-        return (0, session_tools_js_1.handleSessionTool)(name, args, this.sessionManager, this.httpServer);
-    }
-    async callWorkflowMethod(method, params) {
-        try {
-            const { workflowService } = this.container;
-            let result;
-            switch (method) {
-                case 'workflow_list':
-                    const workflows = await workflowService.listWorkflowSummaries();
-                    result = { workflows };
-                    break;
-                case 'workflow_get':
-                    const { createGetWorkflow } = await Promise.resolve().then(() => __importStar(require('./application/use-cases/get-workflow.js')));
-                    const getWorkflowUseCase = createGetWorkflow(workflowService);
-                    result = await getWorkflowUseCase(params.id, params.mode);
-                    break;
-                case 'workflow_next':
-                    result = await workflowService.getNextStep(params.workflowId, params.completedSteps || [], params.context);
-                    break;
-                case 'workflow_validate':
-                    result = await workflowService.validateStepOutput(params.workflowId, params.stepId, params.output);
-                    break;
-                default:
-                    throw new Error(`Unknown method: ${method}`);
-            }
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify(result, null, 2)
-                    }]
-            };
-        }
-        catch (error) {
-            console.error(`Workflow method ${method} failed:`, error);
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify({
-                            error: error instanceof Error ? error.message : String(error),
-                            method,
-                            params
-                        }, null, 2)
-                    }],
-                isError: true
-            };
-        }
-    }
-    async listWorkflows() {
-        return this.callWorkflowMethod('workflow_list', {});
-    }
-    async getWorkflow(workflowId, mode) {
-        return this.callWorkflowMethod('workflow_get', { id: workflowId, mode });
-    }
-    async getNextStep(workflowId, completedSteps = [], context) {
-        return this.callWorkflowMethod('workflow_next', { workflowId, completedSteps, context });
-    }
-    async validateStep(workflowId, stepId, output) {
-        return this.callWorkflowMethod('workflow_validate', { workflowId, stepId, output });
-    }
-    async validateWorkflowJson(workflowJson) {
-        try {
-            const { createValidateWorkflowJson } = await Promise.resolve().then(() => __importStar(require('./application/use-cases/validate-workflow-json.js')));
-            const validateWorkflowJsonUseCase = createValidateWorkflowJson();
-            const result = await validateWorkflowJsonUseCase(workflowJson);
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify(result, null, 2)
-                    }]
-            };
-        }
-        catch (error) {
-            console.error(`Workflow JSON validation failed:`, error);
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify({
-                            error: error instanceof Error ? error.message : String(error),
-                            method: 'workflow_validate_json',
-                            workflowJson: workflowJson.substring(0, 100) + (workflowJson.length > 100 ? '...' : '')
-                        }, null, 2)
-                    }],
-                isError: true
-            };
-        }
-    }
-    async getWorkflowSchema() {
-        try {
-            const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-            const path = await Promise.resolve().then(() => __importStar(require('path')));
-            const schemaPath = path.resolve(__dirname, '../spec/workflow.schema.json');
-            const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
-            const schema = JSON.parse(schemaContent);
-            const result = {
-                schema,
-                metadata: {
-                    version: '1.0.0',
-                    description: 'Complete JSON schema for workflow files',
-                    usage: 'This schema defines the structure, required fields, and validation rules for workflow JSON files',
-                    lastUpdated: new Date().toISOString(),
-                    schemaPath: 'spec/workflow.schema.json'
-                },
-                commonPatterns: {
-                    basicWorkflow: {
-                        id: 'string (required): Unique identifier using lowercase letters, numbers, and hyphens',
-                        name: 'string (required): Human-readable workflow name',
-                        description: 'string (required): Detailed description of the workflow purpose',
-                        version: 'string (required): Semantic version (e.g., "1.0.0")',
-                        steps: 'array (required): List of workflow steps, minimum 1 item'
-                    },
-                    stepStructure: {
-                        id: 'string (required): Unique step identifier',
-                        title: 'string (required): Human-readable step title',
-                        prompt: 'string (required): Instructions for the step',
-                        agentRole: 'string (required): Role description for the agent',
-                        validationCriteria: 'array (optional): Validation rules for step output'
-                    }
-                }
-            };
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify(result, null, 2)
-                    }]
-            };
-        }
-        catch (error) {
-            console.error(`Workflow schema retrieval failed:`, error);
-            return {
-                content: [{
-                        type: "text",
-                        text: JSON.stringify({
-                            error: error instanceof Error ? error.message : String(error),
-                            method: 'workflow_get_schema',
-                            suggestion: 'Ensure the workflow schema file exists at spec/workflow.schema.json'
-                        }, null, 2)
-                    }],
-                isError: true
-            };
-        }
-    }
-}
-const WORKFLOW_LIST_TOOL = {
-    name: "workflow_list",
-    description: `Your primary tool for any complex or multi-step request. Call this FIRST to see if a reliable, pre-defined workflow exists, as this is the preferred method over improvisation.
-
-  Your process:
-  1. Call this tool to get a list of available workflows.
-  2. Analyze the returned descriptions to find a match for the user's goal.
-  3. If a good match is found, suggest it to the user and use \`workflow_get\` to start.
-  4. If NO match is found, inform the user and then attempt to solve the task using your general abilities.`,
-    inputSchema: {
-        type: "object",
-        properties: {},
-        additionalProperties: false
-    }
-};
-const WORKFLOW_GET_TOOL = {
-    name: "workflow_get",
-    description: `Retrieves workflow information with configurable detail level. Supports progressive disclosure to prevent "workflow spoiling" while providing necessary context for workflow selection and initiation.`,
-    inputSchema: {
-        type: "object",
-        properties: {
-            id: {
-                type: "string",
-                description: "The unique identifier of the workflow to retrieve",
-                pattern: "^[A-Za-z0-9_-]+$"
-            },
-            mode: {
-                type: "string",
-                enum: ["metadata", "preview"],
-                description: "The level of detail to return: 'metadata' returns workflow info without steps, 'preview' (default) returns metadata plus the first eligible step",
-                default: "preview"
-            }
-        },
-        required: ["id"],
-        additionalProperties: false
-    }
-};
-const WORKFLOW_NEXT_TOOL = {
-    name: "workflow_next",
-    description: `Executes a workflow by getting the next step. Use this tool in a loop to progress through a workflow. You must provide the \`workflowId\` and a list of \`completedSteps\`. For conditional workflows, provide \`context\` with variables that will be used to evaluate step conditions.`,
-    inputSchema: {
-        type: "object",
-        properties: {
-            workflowId: {
-                type: "string",
-                description: "The unique identifier of the workflow",
-                pattern: "^[A-Za-z0-9_-]+$"
-            },
-            completedSteps: {
-                type: "array",
-                items: {
-                    type: "string",
-                    pattern: "^[A-Za-z0-9_-]+$"
-                },
-                description: "Array of step IDs that have been completed",
-                default: []
-            },
-            context: {
-                type: "object",
-                description: "Optional context variables for conditional step execution",
-                additionalProperties: true
-            }
-        },
-        required: ["workflowId"],
-        additionalProperties: false
-    }
-};
-const WORKFLOW_VALIDATE_JSON_TOOL = {
-    name: "workflow_validate_json",
-    description: `Validates workflow JSON content directly without external tools. Use this tool when you need to verify that a workflow JSON file is syntactically correct and follows the proper schema.
-
-  This tool provides comprehensive validation including:
-  - JSON syntax validation with detailed error messages
-  - Workflow schema compliance checking
-  - User-friendly error reporting with actionable suggestions
-  - Support for all workflow features (steps, conditions, validation criteria, etc.)
-
-  Example usage:
-  - Validate a newly created workflow before saving
-  - Check workflow syntax when editing workflow files
-  - Verify workflow structure when troubleshooting issues
-  - Ensure workflow compliance before deployment`,
-    inputSchema: {
-        type: "object",
-        properties: {
-            workflowJson: {
-                type: "string",
-                description: "The complete workflow JSON content as a string to validate",
-                minLength: 1
-            }
-        },
-        required: ["workflowJson"],
-        additionalProperties: false
-    }
-};
-const WORKFLOW_GET_SCHEMA_TOOL = {
-    name: "workflow_get_schema",
-    description: `Retrieves the complete workflow JSON schema for reference and development purposes. Use this tool when you need to understand the structure, required fields, and validation rules for workflows.
-
-  This tool provides:
-  - Complete JSON schema definition with all properties and constraints
-  - Field descriptions and validation rules
-  - Examples of valid patterns and formats
-  - Schema version and metadata information
-  - Comprehensive reference for workflow structure
-
-  Example usage:
-  - Understanding workflow structure before creating new workflows
-  - Checking required fields and their types
-  - Verifying validation rules and constraints
-  - Reference during workflow development and debugging
-  - Learning about available workflow features and options`,
-    inputSchema: {
-        type: "object",
-        properties: {},
-        additionalProperties: false
-    }
-};
-async function runServer() {
-    const [sdkServer, sdkStdio, sdkTypes] = await Promise.all([
-        Promise.resolve().then(() => __importStar(require("@modelcontextprotocol/sdk/server/index.js"))),
-        Promise.resolve().then(() => __importStar(require("@modelcontextprotocol/sdk/server/stdio.js"))),
-        Promise.resolve().then(() => __importStar(require("@modelcontextprotocol/sdk/types.js"))),
-    ]);
-    const { Server } = sdkServer;
-    const { StdioServerTransport } = sdkStdio;
-    const { CallToolRequestSchema, ListToolsRequestSchema, ListRootsRequestSchema } = sdkTypes;
-    const server = new Server({
-        name: "workrail-server",
-        version: "0.1.0",
-    }, {
-        capabilities: {
-            tools: {},
-        },
-    });
-    const workflowServer = new WorkflowOrchestrationServer();
-    await workflowServer.initialize();
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [
-            WORKFLOW_LIST_TOOL,
-            WORKFLOW_GET_TOOL,
-            WORKFLOW_NEXT_TOOL,
-            WORKFLOW_VALIDATE_JSON_TOOL,
-            WORKFLOW_GET_SCHEMA_TOOL,
-            ...workflowServer.getSessionTools()
-        ],
-    }));
-    server.setRequestHandler(ListRootsRequestSchema, async () => {
-        const path = await Promise.resolve().then(() => __importStar(require('path')));
-        const os = await Promise.resolve().then(() => __importStar(require('os')));
-        const toFileUri = (p) => {
-            const abs = path.resolve(p);
-            return `file://${abs}`;
-        };
-        const roots = [];
-        roots.push({ uri: toFileUri(process.cwd()), name: 'Current Project' });
-        roots.push({ uri: toFileUri(path.resolve(__dirname, '../workflows')), name: 'Bundled Workflows' });
-        roots.push({ uri: toFileUri(path.join(os.homedir(), '.workrail', 'workflows')), name: 'User Workflows' });
-        return { roots };
-    });
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        const { name, arguments: args } = request.params;
-        if (name.startsWith('workrail_')) {
-            return await workflowServer.handleSessionTool(name, args || {});
-        }
-        switch (name) {
-            case "workflow_list":
-                return await workflowServer.listWorkflows();
-            case "workflow_get":
-                if (!args?.['id']) {
-                    return {
-                        content: [{ type: "text", text: "Error: id parameter is required" }],
-                        isError: true
-                    };
-                }
-                return await workflowServer.getWorkflow(args['id'], args['mode']);
-            case "workflow_next":
-                if (!args?.['workflowId']) {
-                    return {
-                        content: [{ type: "text", text: "Error: workflowId parameter is required" }],
-                        isError: true
-                    };
-                }
-                return await workflowServer.getNextStep(args['workflowId'], args['completedSteps'] || [], args['context']);
-            case "workflow_validate_json":
-                if (!args?.['workflowJson']) {
-                    return {
-                        content: [{ type: "text", text: "Error: workflowJson parameter is required" }],
-                        isError: true
-                    };
-                }
-                return await workflowServer.validateWorkflowJson(args['workflowJson']);
-            case "workflow_get_schema":
-                return await workflowServer.getWorkflowSchema();
-            default:
-                return {
-                    content: [{ type: "text", text: `Unknown tool: ${name}` }],
-                    isError: true
-                };
-        }
-    });
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error("Workflow Orchestration MCP Server running on stdio");
-}
-runServer().catch((error) => {
-    console.error("Fatal error running server:", error);
+exports.startServer = void 0;
+var server_js_1 = require("./mcp/server.js");
+Object.defineProperty(exports, "startServer", { enumerable: true, get: function () { return server_js_1.startServer; } });
+const server_js_2 = require("./mcp/server.js");
+(0, server_js_2.startServer)().catch((error) => {
+    console.error('Fatal error running server:', error);
     process.exit(1);
 });

package/dist/runtime/adapters/in-memory-shutdown-events.d.ts

@@ -0,0 +1,6 @@
+import type { ShutdownEvent, ShutdownEvents, Unsubscribe } from '../ports/shutdown-events.js';
+export declare class InMemoryShutdownEvents implements ShutdownEvents {
+    private readonly listeners;
+    onShutdown(listener: (event: ShutdownEvent) => void): Unsubscribe;
+    emit(event: ShutdownEvent): void;
+}

package/dist/runtime/adapters/in-memory-shutdown-events.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryShutdownEvents = void 0;
+class InMemoryShutdownEvents {
+    constructor() {
+        this.listeners = new Set();
+    }
+    onShutdown(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    emit(event) {
+        for (const listener of this.listeners) {
+            listener(event);
+        }
+    }
+}
+exports.InMemoryShutdownEvents = InMemoryShutdownEvents;

package/dist/runtime/adapters/node-process-signals.d.ts

@@ -0,0 +1,4 @@
+import type { ProcessSignal, ProcessSignals } from '../ports/process-signals.js';
+export declare class NodeProcessSignals implements ProcessSignals {
+    on(signal: ProcessSignal, handler: () => void | Promise<void>): void;
+}

package/dist/runtime/adapters/node-process-signals.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeProcessSignals = void 0;
+class NodeProcessSignals {
+    on(signal, handler) {
+        process.on(signal, () => {
+            void handler();
+        });
+    }
+}
+exports.NodeProcessSignals = NodeProcessSignals;

package/dist/runtime/adapters/node-process-terminator.d.ts

@@ -0,0 +1,4 @@
+import type { ExitCode, ProcessTerminator } from '../ports/process-terminator.js';
+export declare class NodeProcessTerminator implements ProcessTerminator {
+    terminate(code: ExitCode): never;
+}

package/dist/runtime/adapters/node-process-terminator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeProcessTerminator = void 0;
+const assert_never_js_1 = require("../assert-never.js");
+class NodeProcessTerminator {
+    terminate(code) {
+        switch (code.kind) {
+            case 'success':
+                process.exit(0);
+            case 'failure':
+                process.exit(1);
+            default:
+                return (0, assert_never_js_1.assertNever)(code);
+        }
+    }
+}
+exports.NodeProcessTerminator = NodeProcessTerminator;

package/dist/runtime/adapters/noop-process-signals.d.ts

@@ -0,0 +1,4 @@
+import type { ProcessSignal, ProcessSignals } from '../ports/process-signals.js';
+export declare class NoopProcessSignals implements ProcessSignals {
+    on(_signal: ProcessSignal, _handler: () => void | Promise<void>): void;
+}

package/dist/runtime/adapters/noop-process-signals.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopProcessSignals = void 0;
+class NoopProcessSignals {
+    on(_signal, _handler) {
+    }
+}
+exports.NoopProcessSignals = NoopProcessSignals;

package/dist/runtime/adapters/throwing-process-terminator.d.ts

@@ -0,0 +1,4 @@
+import type { ExitCode, ProcessTerminator } from '../ports/process-terminator.js';
+export declare class ThrowingProcessTerminator implements ProcessTerminator {
+    terminate(code: ExitCode): never;
+}

package/dist/runtime/adapters/throwing-process-terminator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThrowingProcessTerminator = void 0;
+class ThrowingProcessTerminator {
+    terminate(code) {
+        throw new Error(`[ProcessTerminator] terminate(${code.kind})`);
+    }
+}
+exports.ThrowingProcessTerminator = ThrowingProcessTerminator;

package/dist/runtime/assert-never.d.ts

@@ -0,0 +1 @@
+export declare function assertNever(x: never): never;

package/dist/runtime/assert-never.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNever = assertNever;
+function assertNever(x) {
+    throw new Error(`Unexpected value: ${JSON.stringify(x)}`);
+}

package/dist/runtime/brand.d.ts

@@ -0,0 +1,5 @@
+declare const brand: unique symbol;
+export type Brand<T, B extends string> = T & {
+    readonly [brand]: B;
+};
+export {};

package/dist/runtime/ports/process-signals.d.ts

@@ -0,0 +1,4 @@
+export type ProcessSignal = NodeJS.Signals | 'exit';
+export interface ProcessSignals {
+    on(signal: ProcessSignal, handler: () => void | Promise<void>): void;
+}

package/dist/runtime/ports/process-signals.js

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

package/dist/runtime/ports/process-terminator.d.ts

@@ -0,0 +1,8 @@
+export type ExitCode = {
+    kind: 'success';
+} | {
+    kind: 'failure';
+};
+export interface ProcessTerminator {
+    terminate(code: ExitCode): never;
+}

package/dist/runtime/ports/process-terminator.js

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

package/dist/runtime/ports/shutdown-events.d.ts

@@ -0,0 +1,11 @@
+import type { ProcessSignal } from './process-signals.js';
+export type ShutdownSignal = Exclude<ProcessSignal, 'exit'>;
+export type ShutdownEvent = {
+    kind: 'shutdown_requested';
+    signal: ShutdownSignal;
+};
+export type Unsubscribe = () => void;
+export interface ShutdownEvents {
+    onShutdown(listener: (event: ShutdownEvent) => void): Unsubscribe;
+    emit(event: ShutdownEvent): void;
+}

package/dist/runtime/ports/shutdown-events.js

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

package/dist/runtime/process-lifecycle-policy.d.ts

@@ -0,0 +1,5 @@
+export type ProcessLifecyclePolicy = {
+    kind: 'install_signal_handlers';
+} | {
+    kind: 'no_signal_handlers';
+};

package/dist/runtime/process-lifecycle-policy.js

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

package/dist/runtime/result.d.ts

@@ -0,0 +1,17 @@
+export type Ok<T> = {
+    readonly kind: 'ok';
+    readonly value: T;
+};
+export type Err<E> = {
+    readonly kind: 'err';
+    readonly error: E;
+};
+export type Result<T, E> = Ok<T> | Err<E>;
+export declare const ok: <T>(value: T) => Result<T, never>;
+export declare const err: <E>(error: E) => Result<never, E>;
+export declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
+export declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
+export declare function map<T, E, U>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+export declare function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
+export declare function andThen<T, E, U>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
+export declare function match<T, E, R>(result: Result<T, E>, onOk: (value: T) => R, onErr: (error: E) => R): R;

package/dist/runtime/result.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.err = exports.ok = void 0;
+exports.isOk = isOk;
+exports.isErr = isErr;
+exports.map = map;
+exports.mapErr = mapErr;
+exports.andThen = andThen;
+exports.match = match;
+const ok = (value) => ({ kind: 'ok', value });
+exports.ok = ok;
+const err = (error) => ({ kind: 'err', error });
+exports.err = err;
+function isOk(result) {
+    return result.kind === 'ok';
+}
+function isErr(result) {
+    return result.kind === 'err';
+}
+function map(result, fn) {
+    return result.kind === 'ok' ? (0, exports.ok)(fn(result.value)) : result;
+}
+function mapErr(result, fn) {
+    return result.kind === 'err' ? (0, exports.err)(fn(result.error)) : result;
+}
+function andThen(result, fn) {
+    return result.kind === 'ok' ? fn(result.value) : result;
+}
+function match(result, onOk, onErr) {
+    return result.kind === 'ok' ? onOk(result.value) : onErr(result.error);
+}