dotdo 0.0.1 → 0.1.0

package/dist/objects/createFunction.js

@@ -0,0 +1,934 @@
+/**
+ * createFunction Factory
+ *
+ * Creates typed function instances for different execution modes:
+ * - CodeFunction: executes TypeScript/JavaScript code
+ * - GenerativeFunction: calls LLM for generation
+ * - AgenticFunction: orchestrates multi-step AI tasks
+ * - HumanFunction: queues tasks for human input
+ */
+// Use Cloudflare's DurableObjectState type from @cloudflare/workers-types
+// No need to redeclare - it's provided by the ambient types
+// ============================================================================
+// ERROR CLASSES
+// ============================================================================
+export class ValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ValidationError';
+    }
+}
+export class RegistrationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RegistrationError';
+    }
+}
+export class ExecutionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ExecutionError';
+    }
+}
+// ============================================================================
+// VALIDATION
+// ============================================================================
+const VALID_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+const VALID_JSON_SCHEMA_TYPES = ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'];
+const VALID_FORM_FIELD_TYPES = ['text', 'number', 'boolean', 'select', 'multiselect'];
+function validateBase(def) {
+    if (!def.name) {
+        throw new ValidationError('Function name is required');
+    }
+    if (def.name === '') {
+        throw new ValidationError('Function name cannot be empty');
+    }
+    if (!VALID_NAME_PATTERN.test(def.name)) {
+        throw new ValidationError(`Invalid function name: ${def.name}. Names must start with a letter and contain only alphanumeric characters and underscores.`);
+    }
+    if (!def.type) {
+        throw new ValidationError('Function type is required');
+    }
+    if (!['code', 'generative', 'agentic', 'human'].includes(def.type)) {
+        throw new ValidationError(`Invalid function type: ${def.type}`);
+    }
+    if (def.timeout !== undefined && def.timeout < 0) {
+        throw new ValidationError('Timeout must be non-negative');
+    }
+    if (def.retries !== undefined && def.retries < 0) {
+        throw new ValidationError('Retries must be non-negative');
+    }
+}
+function validateCodeFunction(def) {
+    if (!def.handler) {
+        throw new ValidationError('CodeFunction requires a handler');
+    }
+    if (typeof def.handler !== 'function') {
+        throw new ValidationError('Handler must be a function');
+    }
+    if (def.runtime !== undefined && !['javascript', 'typescript'].includes(def.runtime)) {
+        throw new ValidationError(`Invalid runtime: ${def.runtime}. Must be 'javascript' or 'typescript'.`);
+    }
+}
+function validateGenerativeFunction(def) {
+    if (!def.model) {
+        throw new ValidationError('GenerativeFunction requires a model');
+    }
+    if (def.model === '') {
+        throw new ValidationError('Model cannot be empty');
+    }
+    if (def.prompt === undefined) {
+        throw new ValidationError('GenerativeFunction requires a prompt');
+    }
+    if (def.temperature !== undefined && (def.temperature < 0 || def.temperature > 2)) {
+        throw new ValidationError('Temperature must be between 0 and 2');
+    }
+    if (def.maxTokens !== undefined && def.maxTokens < 0) {
+        throw new ValidationError('maxTokens must be non-negative');
+    }
+    if (def.schema !== undefined) {
+        const schemaType = def.schema.type;
+        if (schemaType && !VALID_JSON_SCHEMA_TYPES.includes(schemaType)) {
+            throw new ValidationError(`Invalid JSON Schema type: ${schemaType}`);
+        }
+    }
+}
+function validateAgenticFunction(def) {
+    if (!def.agent) {
+        throw new ValidationError('AgenticFunction requires an agent');
+    }
+    if (def.agent === '') {
+        throw new ValidationError('Agent cannot be empty');
+    }
+    if (def.maxIterations !== undefined) {
+        if (def.maxIterations < 1) {
+            throw new ValidationError('maxIterations must be at least 1');
+        }
+        if (def.maxIterations > 1000) {
+            throw new ValidationError('maxIterations cannot exceed 1000');
+        }
+    }
+    if (def.tools !== undefined) {
+        const uniqueTools = new Set(def.tools);
+        if (uniqueTools.size !== def.tools.length) {
+            throw new ValidationError('Tools array contains duplicates');
+        }
+    }
+}
+function validateHumanFunction(def) {
+    if (!def.channel) {
+        throw new ValidationError('HumanFunction requires a channel');
+    }
+    if (def.channel === '') {
+        throw new ValidationError('Channel cannot be empty');
+    }
+    if (def.timeout === undefined) {
+        throw new ValidationError('HumanFunction requires a timeout');
+    }
+    if (def.timeout <= 0) {
+        throw new ValidationError('Timeout must be positive');
+    }
+    if (def.escalation !== undefined && def.escalation.timeout > def.timeout) {
+        throw new ValidationError('Escalation timeout cannot exceed main timeout');
+    }
+    if (def.form !== undefined) {
+        for (const field of def.form.fields) {
+            if (!field.name) {
+                throw new ValidationError('Form field name is required');
+            }
+            if (!VALID_FORM_FIELD_TYPES.includes(field.type)) {
+                throw new ValidationError(`Invalid form field type: ${field.type}`);
+            }
+        }
+    }
+}
+function validate(def) {
+    validateBase(def);
+    switch (def.type) {
+        case 'code':
+            validateCodeFunction(def);
+            break;
+        case 'generative':
+            validateGenerativeFunction(def);
+            break;
+        case 'agentic':
+            validateAgenticFunction(def);
+            break;
+        case 'human':
+            validateHumanFunction(def);
+            break;
+    }
+}
+// ============================================================================
+// TEMPLATE SUBSTITUTION
+// ============================================================================
+function substituteTemplate(template, data) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+        return String(data[key] ?? '');
+    });
+}
+// ============================================================================
+// JSON SCHEMA VALIDATION
+// ============================================================================
+function validateAgainstSchema(data, schema) {
+    const schemaType = schema.type;
+    if (schemaType === 'object') {
+        if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+            return false;
+        }
+        const required = schema.required || [];
+        for (const key of required) {
+            if (!(key in data)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+// ============================================================================
+// FORM VALIDATION
+// ============================================================================
+function validateFormResponse(response, form) {
+    if (typeof response !== 'object' || response === null) {
+        return false;
+    }
+    const data = response;
+    for (const field of form.fields) {
+        const value = data[field.name];
+        if (field.required && value === undefined) {
+            return false;
+        }
+        if (value !== undefined) {
+            switch (field.type) {
+                case 'boolean':
+                    if (typeof value !== 'boolean') {
+                        return false;
+                    }
+                    break;
+                case 'number':
+                    if (typeof value !== 'number') {
+                        return false;
+                    }
+                    break;
+                case 'text':
+                    if (typeof value !== 'string') {
+                        return false;
+                    }
+                    break;
+            }
+        }
+    }
+    return true;
+}
+// ============================================================================
+// EXECUTION HELPERS
+// ============================================================================
+async function withTimeout(promise, ms) {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new ExecutionError('Execution timeout exceeded')), ms);
+    });
+    try {
+        const result = await Promise.race([promise, timeoutPromise]);
+        clearTimeout(timeoutId);
+        return result;
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        throw error;
+    }
+}
+async function withRetries(fn, retries) {
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt === retries) {
+                throw new ExecutionError(`Execution failed after ${retries + 1} attempts: ${lastError.message}`);
+            }
+        }
+    }
+    throw lastError;
+}
+// ============================================================================
+// FUNCTION INSTANCE IMPLEMENTATION
+// ============================================================================
+function createFunctionInstance(def, options) {
+    const id = options.id || crypto.randomUUID();
+    const createdAt = new Date();
+    let invocationCount = 0;
+    const invocationHistory = [];
+    let registeredRegistry = undefined;
+    const createContext = (input) => {
+        return {
+            functionId: id,
+            invocationId: crypto.randomUUID(),
+            input,
+            env: options.env,
+            emit: async (event, data) => {
+                options.onEvent?.(event, data);
+            },
+            log: (message, data) => {
+                console.log(`[${id}] ${message}`, data);
+            },
+        };
+    };
+    const executeCode = async (input) => {
+        const codeDef = def;
+        const ctx = createContext(input);
+        return codeDef.handler(input, ctx);
+    };
+    const executeGenerative = async (input) => {
+        const genDef = def;
+        const inputObj = input;
+        let promptStr;
+        if (typeof genDef.prompt === 'function') {
+            promptStr = genDef.prompt(input);
+        }
+        else {
+            promptStr = substituteTemplate(genDef.prompt, inputObj);
+        }
+        if (genDef.stream) {
+            return options.env.AI.stream({
+                model: genDef.model,
+                prompt: promptStr,
+                temperature: genDef.temperature ?? 1,
+                maxTokens: genDef.maxTokens,
+            });
+        }
+        const response = await options.env.AI.generate({
+            model: genDef.model,
+            prompt: promptStr,
+            temperature: genDef.temperature ?? 1,
+            maxTokens: genDef.maxTokens,
+        });
+        if (genDef.schema) {
+            try {
+                const parsed = JSON.parse(response.text);
+                if (!validateAgainstSchema(parsed, genDef.schema)) {
+                    throw new ExecutionError('AI output does not match schema');
+                }
+                return parsed;
+            }
+            catch (error) {
+                if (error instanceof ExecutionError)
+                    throw error;
+                throw new ExecutionError('Failed to parse AI output as JSON');
+            }
+        }
+        return response;
+    };
+    const executeAgentic = async (input) => {
+        const agentDef = def;
+        try {
+            const result = await options.env.AGENT_RUNNER.run({
+                agent: agentDef.agent,
+                input,
+                tools: agentDef.tools || [],
+                maxIterations: agentDef.maxIterations ?? 10,
+                systemPrompt: agentDef.systemPrompt,
+                onStep: agentDef.onStep,
+            });
+            return result;
+        }
+        catch (error) {
+            throw new ExecutionError(`Agent execution failed: ${error.message}`);
+        }
+    };
+    const executeHuman = async (input) => {
+        const humanDef = def;
+        const inputObj = input;
+        let message;
+        if (typeof humanDef.prompt === 'function') {
+            message = humanDef.prompt(input);
+        }
+        else if (humanDef.prompt) {
+            message = substituteTemplate(humanDef.prompt, inputObj);
+        }
+        else {
+            message = JSON.stringify(input);
+        }
+        await options.env.NOTIFICATIONS.send({
+            channel: humanDef.channel,
+            message,
+        });
+        try {
+            const response = await options.env.NOTIFICATIONS.waitForResponse({
+                timeout: humanDef.timeout,
+            });
+            if (humanDef.form && !validateFormResponse(response, humanDef.form)) {
+                throw new ExecutionError('Human response does not match form schema');
+            }
+            return response;
+        }
+        catch (error) {
+            if (humanDef.escalation) {
+                await options.env.NOTIFICATIONS.send({
+                    channel: humanDef.escalation.to,
+                    message,
+                });
+                return options.env.NOTIFICATIONS.waitForResponse({
+                    timeout: humanDef.escalation.timeout,
+                });
+            }
+            throw new ExecutionError(`Human task timeout: ${error.message}`);
+        }
+    };
+    const execute = async (input) => {
+        const startTime = Date.now();
+        const ctx = createContext(input);
+        options.onEvent?.('function.invoked', {
+            functionId: id,
+            invocationId: ctx.invocationId,
+            input,
+        });
+        const doExecute = async () => {
+            switch (def.type) {
+                case 'code':
+                    return executeCode(input);
+                case 'generative':
+                    return executeGenerative(input);
+                case 'agentic':
+                    return executeAgentic(input);
+                case 'human':
+                    return executeHuman(input);
+            }
+        };
+        try {
+            let result;
+            const retries = def.retries ?? 0;
+            const wrappedExecute = async () => {
+                const exec = doExecute();
+                if (def.timeout) {
+                    return withTimeout(exec, def.timeout);
+                }
+                return exec;
+            };
+            if (retries > 0) {
+                result = await withRetries(wrappedExecute, retries);
+            }
+            else {
+                result = await wrappedExecute();
+            }
+            const duration = Date.now() - startTime;
+            invocationCount++;
+            invocationHistory.push({
+                invocationId: ctx.invocationId,
+                functionId: id,
+                input,
+                output: result,
+                status: 'completed',
+                startedAt: new Date(startTime),
+                completedAt: new Date(),
+                duration,
+            });
+            if (options.state) {
+                await options.state.storage.put(`invocation:${ctx.invocationId}`, invocationHistory[invocationHistory.length - 1]);
+            }
+            options.onEvent?.('function.completed', {
+                functionId: id,
+                invocationId: ctx.invocationId,
+                result,
+                duration,
+            });
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMessage = error.message;
+            invocationHistory.push({
+                invocationId: ctx.invocationId,
+                functionId: id,
+                input,
+                error: errorMessage,
+                status: 'failed',
+                startedAt: new Date(startTime),
+                completedAt: new Date(),
+                duration,
+            });
+            options.onEvent?.('function.failed', {
+                functionId: id,
+                invocationId: ctx.invocationId,
+                error: errorMessage,
+                duration,
+            });
+            if (error instanceof ExecutionError) {
+                throw error;
+            }
+            throw new ExecutionError(errorMessage);
+        }
+    };
+    // Track registry reference (set during auto-register or manual register)
+    registeredRegistry = options.registry;
+    const register = async (registry) => {
+        registeredRegistry = registry;
+        await registry.register(instance);
+    };
+    const unregister = async () => {
+        if (registeredRegistry) {
+            await registeredRegistry.unregister(def.name);
+        }
+        if (options.state) {
+            await options.state.storage.delete(`function:${def.name}`);
+        }
+    };
+    const toJSON = () => {
+        const json = {
+            id,
+            name: def.name,
+            type: def.type,
+            description: def.description,
+            createdAt: createdAt.toISOString(),
+        };
+        if (def.type === 'generative') {
+            const genDef = def;
+            json.model = genDef.model;
+            json.temperature = genDef.temperature;
+            json.maxTokens = genDef.maxTokens;
+        }
+        return json;
+    };
+    const getMetadata = () => ({
+        id,
+        name: def.name,
+        type: def.type,
+        createdAt,
+        invocationCount,
+    });
+    const getInvocationHistory = async () => {
+        return invocationHistory;
+    };
+    // Composition methods
+    const pipe = (next) => {
+        return createComposedFunction([instance, next], options);
+    };
+    const ifMethod = (predicate) => {
+        return createConditionalFunction(instance, predicate, options);
+    };
+    const map = (fn) => {
+        return createMappedFunction(instance, fn, options);
+    };
+    const contramap = (fn) => {
+        return createContramappedFunction(instance, fn, options);
+    };
+    const catchMethod = (handler) => {
+        return createCatchFunction(instance, handler, options);
+    };
+    const finallyMethod = (cleanup) => {
+        return createFinallyFunction(instance, cleanup, options);
+    };
+    const instance = {
+        id,
+        name: def.name,
+        type: def.type,
+        description: def.description,
+        createdAt,
+        timeout: def.timeout,
+        retries: def.retries,
+        requiredPermission: def.requiredPermission,
+        // Type-specific properties
+        ...(def.type === 'code' && {
+            handler: def.handler,
+            runtime: def.runtime ?? 'javascript',
+            sandboxed: def.sandboxed,
+        }),
+        ...(def.type === 'generative' && {
+            model: def.model,
+            prompt: def.prompt,
+            temperature: def.temperature ?? 1,
+            maxTokens: def.maxTokens,
+            stream: def.stream,
+            schema: def.schema,
+        }),
+        ...(def.type === 'agentic' && {
+            agent: def.agent,
+            tools: def.tools,
+            maxIterations: def.maxIterations ?? 10,
+            systemPrompt: def.systemPrompt,
+            onStep: def.onStep,
+        }),
+        ...(def.type === 'human' && {
+            channel: def.channel,
+            timeout: def.timeout,
+            prompt: def.prompt,
+            form: def.form,
+            escalation: def.escalation,
+        }),
+        execute,
+        register,
+        unregister,
+        toJSON,
+        getMetadata,
+        getInvocationHistory,
+        pipe,
+        if: ifMethod,
+        map,
+        contramap,
+        catch: catchMethod,
+        finally: finallyMethod,
+    };
+    return instance;
+}
+// ============================================================================
+// COMPOSED FUNCTION
+// ============================================================================
+function createComposedFunction(functions, options) {
+    const name = functions.map(f => f.name).join(' -> ');
+    const id = crypto.randomUUID();
+    const createdAt = new Date();
+    let invocationCount = 0;
+    const execute = async (input) => {
+        let result = input;
+        for (const fn of functions) {
+            result = await fn.execute(result);
+        }
+        invocationCount++;
+        return result;
+    };
+    const describe = () => ({
+        type: 'pipeline',
+        steps: functions.map(f => ({ name: f.name, type: f.type })),
+    });
+    const pipe = (next) => {
+        return createComposedFunction([...functions, next], options);
+    };
+    const instance = {
+        id,
+        name,
+        type: 'code',
+        createdAt,
+        execute,
+        describe,
+        pipe,
+        if: (predicate) => createConditionalFunction(instance, predicate, options),
+        map: (fn) => createMappedFunction(instance, fn, options),
+        contramap: (fn) => createContramappedFunction(instance, fn, options),
+        catch: (handler) => createCatchFunction(instance, handler, options),
+        finally: (cleanup) => createFinallyFunction(instance, cleanup, options),
+        register: async () => { },
+        unregister: async () => { },
+        toJSON: () => ({ id, name, type: 'composed' }),
+        getMetadata: () => ({ id, name, type: 'composed', createdAt, invocationCount }),
+        getInvocationHistory: async () => [],
+    };
+    return instance;
+}
+// ============================================================================
+// CONDITIONAL FUNCTION
+// ============================================================================
+function createConditionalFunction(fn, predicate, options) {
+    const id = crypto.randomUUID();
+    const createdAt = new Date();
+    let elseFn;
+    const execute = async (input) => {
+        if (predicate(input)) {
+            return fn.execute(input);
+        }
+        if (elseFn) {
+            return elseFn.execute(input);
+        }
+        return null;
+    };
+    const elseMethod = (alternative) => {
+        elseFn = alternative;
+        return instance;
+    };
+    const instance = {
+        id,
+        name: `${fn.name} (conditional)`,
+        type: fn.type,
+        createdAt,
+        execute,
+        else: elseMethod,
+        pipe: (next) => createComposedFunction([instance, next], options),
+        if: (pred) => createConditionalFunction(instance, pred, options),
+        map: (mapper) => createMappedFunction(instance, mapper, options),
+        contramap: (mapper) => createContramappedFunction(instance, mapper, options),
+        catch: (handler) => createCatchFunction(instance, handler, options),
+        finally: (cleanup) => createFinallyFunction(instance, cleanup, options),
+        register: async () => { },
+        unregister: async () => { },
+        toJSON: () => ({ id, name: instance.name, type: 'conditional' }),
+        getMetadata: () => ({ id, name: instance.name, type: 'conditional', createdAt, invocationCount: 0 }),
+        getInvocationHistory: async () => [],
+    };
+    return instance;
+}
+// ============================================================================
+// MAPPED FUNCTION
+// ============================================================================
+function createMappedFunction(fn, mapper, options) {
+    const id = crypto.randomUUID();
+    const createdAt = new Date();
+    const execute = async (input) => {
+        const result = await fn.execute(input);
+        return mapper(result);
+    };
+    const instance = {
+        id,
+        name: `${fn.name} (mapped)`,
+        type: fn.type,
+        createdAt,
+        execute,
+        pipe: (next) => createComposedFunction([instance, next], options),
+        if: (pred) => createConditionalFunction(instance, pred, options),
+        map: (m) => createMappedFunction(instance, m, options),
+        contramap: (m) => createContramappedFunction(instance, m, options),
+        catch: (handler) => createCatchFunction(instance, handler, options),
+        finally: (cleanup) => createFinallyFunction(instance, cleanup, options),
+        register: async () => { },
+        unregister: async () => { },
+        toJSON: () => ({ id, name: instance.name, type: 'mapped' }),
+        getMetadata: () => ({ id, name: instance.name, type: 'mapped', createdAt, invocationCount: 0 }),
+        getInvocationHistory: async () => [],
+    };
+    return instance;
+}
+// ============================================================================
+// CONTRAMAPPED FUNCTION
+// ============================================================================
+function createContramappedFunction(fn, mapper, options) {
+    const id = crypto.randomUUID();
+    const createdAt = new Date();
+    const execute = async (input) => {
+        const mappedInput = mapper(input);
+        return fn.execute(mappedInput);
+    };
+    const instance = {
+        id,
+        name: `${fn.name} (contramapped)`,
+        type: fn.type,
+        createdAt,
+        execute,
+        pipe: (next) => createComposedFunction([instance, next], options),
+        if: (pred) => createConditionalFunction(instance, pred, options),
+        map: (m) => createMappedFunction(instance, m, options),
+        contramap: (m) => createContramappedFunction(instance, m, options),
+        catch: (handler) => createCatchFunction(instance, handler, options),
+        finally: (cleanup) => createFinallyFunction(instance, cleanup, options),
+        register: async () => { },
+        unregister: async () => { },
+        toJSON: () => ({ id, name: instance.name, type: 'contramapped' }),
+        getMetadata: () => ({ id, name: instance.name, type: 'contramapped', createdAt, invocationCount: 0 }),
+        getInvocationHistory: async () => [],
+    };
+    return instance;
+}
+// ============================================================================
+// CATCH FUNCTION
+// ============================================================================
+function createCatchFunction(fn, handler, options) {
+    const id = crypto.randomUUID();
+    const createdAt = new Date();
+    const execute = async (input) => {
+        try {
+            return await fn.execute(input);
+        }
+        catch (error) {
+            return handler(error);
+        }
+    };
+    const instance = {
+        id,
+        name: `${fn.name} (with catch)`,
+        type: fn.type,
+        createdAt,
+        execute,
+        pipe: (next) => createComposedFunction([instance, next], options),
+        if: (pred) => createConditionalFunction(instance, pred, options),
+        map: (m) => createMappedFunction(instance, m, options),
+        contramap: (m) => createContramappedFunction(instance, m, options),
+        catch: (h) => createCatchFunction(instance, h, options),
+        finally: (cleanup) => createFinallyFunction(instance, cleanup, options),
+        register: async () => { },
+        unregister: async () => { },
+        toJSON: () => ({ id, name: instance.name, type: 'catch' }),
+        getMetadata: () => ({ id, name: instance.name, type: 'catch', createdAt, invocationCount: 0 }),
+        getInvocationHistory: async () => [],
+    };
+    return instance;
+}
+// ============================================================================
+// FINALLY FUNCTION
+// ============================================================================
+function createFinallyFunction(fn, cleanup, options) {
+    const id = crypto.randomUUID();
+    const createdAt = new Date();
+    const execute = async (input) => {
+        try {
+            return await fn.execute(input);
+        }
+        finally {
+            await cleanup();
+        }
+    };
+    const instance = {
+        id,
+        name: `${fn.name} (with finally)`,
+        type: fn.type,
+        createdAt,
+        execute,
+        pipe: (next) => createComposedFunction([instance, next], options),
+        if: (pred) => createConditionalFunction(instance, pred, options),
+        map: (m) => createMappedFunction(instance, m, options),
+        contramap: (m) => createContramappedFunction(instance, m, options),
+        catch: (h) => createCatchFunction(instance, h, options),
+        finally: (c) => createFinallyFunction(instance, c, options),
+        register: async () => { },
+        unregister: async () => { },
+        toJSON: () => ({ id, name: instance.name, type: 'finally' }),
+        getMetadata: () => ({ id, name: instance.name, type: 'finally', createdAt, invocationCount: 0 }),
+        getInvocationHistory: async () => [],
+    };
+    return instance;
+}
+// ============================================================================
+// PARALLEL FUNCTIONS
+// ============================================================================
+function createParallelFunction(functions, mode) {
+    const id = crypto.randomUUID();
+    const createdAt = new Date();
+    const name = `parallel(${functions.map(f => f.name).join(', ')})`;
+    const execute = async (input) => {
+        const promises = functions.map(fn => fn.execute(input));
+        if (mode === 'all') {
+            return Promise.all(promises);
+        }
+        else {
+            const results = await Promise.allSettled(promises);
+            return results.map(r => r.status === 'fulfilled'
+                ? { status: 'fulfilled', value: r.value }
+                : { status: 'rejected', reason: r.reason });
+        }
+    };
+    const instance = {
+        id,
+        name,
+        type: 'code',
+        createdAt,
+        execute,
+        pipe: (next) => createComposedFunction([instance, next], {}),
+        if: (pred) => createConditionalFunction(instance, pred, {}),
+        map: (m) => createMappedFunction(instance, m, {}),
+        contramap: (m) => createContramappedFunction(instance, m, {}),
+        catch: (h) => createCatchFunction(instance, h, {}),
+        finally: (c) => createFinallyFunction(instance, c, {}),
+        register: async () => { },
+        unregister: async () => { },
+        toJSON: () => ({ id, name, type: 'parallel' }),
+        getMetadata: () => ({ id, name, type: 'parallel', createdAt, invocationCount: 0 }),
+        getInvocationHistory: async () => [],
+    };
+    return instance;
+}
+// ============================================================================
+// MAIN FACTORY FUNCTION
+// ============================================================================
+// We use a non-async wrapper function to avoid TypeScript's thenable detection issue
+// FunctionInstance has a 'then' method for composition which conflicts with Promise.then
+function createFunctionImpl(def, options) {
+    // Wrap everything to ensure validation errors become Promise rejections
+    try {
+        // Validate definition (sync)
+        validate(def);
+    }
+    catch (e) {
+        return Promise.reject(e);
+    }
+    // Create instance (sync)
+    const instance = createFunctionInstance(def, options);
+    // Register with DO if provided (sync)
+    if (options.durableObject) {
+        options.durableObject.registerFunction(instance);
+    }
+    // Build the promise chain for async operations
+    let promise = Promise.resolve();
+    // Check for duplicate names if registry provided
+    if (options.registry && options.autoRegister !== false) {
+        promise = promise.then(async () => {
+            const existing = await options.registry.has(def.name);
+            if (existing && !options.replace) {
+                throw new RegistrationError(`Function '${def.name}' already exists`);
+            }
+        });
+    }
+    // Store in state if provided
+    if (options.state) {
+        promise = promise.then(() => options.state.storage.put(`function:${def.name}`, {
+            name: def.name,
+            type: def.type,
+            description: def.description,
+            id: instance.id,
+            createdAt: instance.createdAt.toISOString(),
+        }));
+    }
+    // Auto-register with registry
+    if (options.registry && options.autoRegister !== false) {
+        promise = promise.then(async () => {
+            if (options.replace) {
+                await options.registry.unregister(def.name);
+                options.onEvent?.('function.replaced', { name: def.name, id: instance.id });
+            }
+            await options.registry.register(instance);
+            options.onEvent?.('function.registered', { name: def.name, type: def.type, id: instance.id });
+        });
+    }
+    // We need to explicitly resolve with the instance to avoid the thenable issue
+    // where JavaScript would try to call instance.then() since it exists
+    return new Promise((resolve, reject) => {
+        promise.then(() => resolve(instance)).catch(reject);
+    });
+}
+// Note: Using type assertion to avoid the thenable conflict with Promise<FunctionInstance>
+// The FunctionInstance type has a 'then' method for composition which conflicts with Promise.then
+export const createFunction = Object.assign((def, options) => createFunctionImpl(def, options), {
+    all: (functions) => {
+        return createParallelFunction(functions, 'all');
+    },
+    allSettled: (functions) => {
+        return createParallelFunction(functions, 'allSettled');
+    },
+    fromStorage: (name, options) => {
+        if (!options.state) {
+            return Promise.reject(new Error('State is required to restore from storage'));
+        }
+        return new Promise((resolve, reject) => {
+            options.state.storage.get(`function:${name}`).then((stored) => {
+                const storedData = stored;
+                if (!storedData) {
+                    reject(new Error(`Function '${name}' not found in storage`));
+                    return;
+                }
+                // Create a minimal placeholder instance for restoration
+                // In real implementation, would need to store and restore full definition
+                const id = storedData.id;
+                const createdAt = new Date(storedData.createdAt);
+                const instance = {
+                    id,
+                    name: storedData.name,
+                    type: storedData.type,
+                    description: storedData.description,
+                    createdAt,
+                    execute: () => Promise.reject(new Error('Function restored from storage cannot be executed without handler')),
+                    register: (registry) => registry.register(instance),
+                    unregister: () => Promise.resolve(),
+                    toJSON: () => ({ id, name: storedData.name, type: storedData.type }),
+                    getMetadata: () => ({ id, name: storedData.name, type: storedData.type, createdAt, invocationCount: 0 }),
+                    getInvocationHistory: () => Promise.resolve([]),
+                    pipe: () => instance,
+                    if: () => instance,
+                    map: () => instance,
+                    contramap: () => instance,
+                    catch: () => instance,
+                    finally: () => instance,
+                };
+                resolve(instance);
+            }).catch(reject);
+        });
+    },
+});
+export default createFunction;
+//# sourceMappingURL=createFunction.js.map