@chainlink/cre-sdk 0.0.0 → 0.0.2-alpha

package/dist/sdk/utils/values/value.test.js

@@ -0,0 +1,439 @@
+import { describe, expect, test } from 'bun:test';
+import { create } from '@bufbuild/protobuf';
+import { FieldMaskSchema, TimestampSchema, timestampDate } from '@bufbuild/protobuf/wkt';
+import { BigIntSchema, DecimalSchema, ListSchema, MapSchema, ValueSchema, } from '../../../generated/values/v1/values_pb';
+import { Decimal, Int64, UInt64, Value } from './value';
+const bytesToBigIntBE = (bytes) => {
+    let out = 0n;
+    for (const b of bytes)
+        out = (out << 8n) + BigInt(b);
+    return out;
+};
+const expectProto = (actual, expected) => {
+    expect(actual.value).toBeDefined();
+    expect(actual.value).toEqual(expected);
+};
+const expectValue = (actual, expected) => {
+    expectProto(actual.proto(), expected);
+    expect(actual.unwrap()).toEqual(expected.value);
+};
+function expectCase(actual, expectedCase) {
+    expect(actual.value).toBeDefined();
+    expect(actual.value.case).toBe(expectedCase);
+    return actual.value.value;
+}
+describe('val helpers', () => {
+    test('another value', () => {
+        const val = Value.from('10');
+        const val2 = Value.from(val);
+        expect(val).toEqual(val2);
+    });
+    test('nested value', () => {
+        const val = Value.from(10);
+        const val2 = Value.from({ foo: 99, val: val });
+        expectProto(val2.proto(), {
+            case: 'mapValue',
+            value: create(MapSchema, {
+                fields: {
+                    foo: create(ValueSchema, { value: { case: 'float64Value', value: 99 } }),
+                    val: create(ValueSchema, { value: { case: 'float64Value', value: 10 } }),
+                },
+            }),
+        });
+    });
+    describe('protos directly', () => {
+        const allCases = {
+            stringValue: {
+                proto: create(ValueSchema, {
+                    value: { case: 'stringValue', value: 'hello' },
+                }),
+                expected: 'hello',
+            },
+            boolValue: {
+                proto: create(ValueSchema, {
+                    value: { case: 'boolValue', value: true },
+                }),
+                expected: true,
+            },
+            bytesValue: {
+                proto: create(ValueSchema, {
+                    value: { case: 'bytesValue', value: new Uint8Array([1, 2, 3]) },
+                }),
+                expected: new Uint8Array([1, 2, 3]),
+            },
+            float64Value: {
+                proto: create(ValueSchema, {
+                    value: { case: 'float64Value', value: 3.14159 },
+                }),
+                expected: 3.14159,
+            },
+            int64Value: {
+                proto: create(ValueSchema, {
+                    value: { case: 'int64Value', value: 42n },
+                }),
+                expected: new Int64(42n),
+            },
+            uint64Value: {
+                proto: create(ValueSchema, {
+                    value: { case: 'uint64Value', value: 42n },
+                }),
+                expected: new UInt64(42n),
+            },
+            timeValue: {
+                proto: create(ValueSchema, {
+                    value: {
+                        case: 'timeValue',
+                        value: create(TimestampSchema, {
+                            seconds: 1700000123n,
+                            nanos: 456000000,
+                        }),
+                    },
+                }),
+                expected: new Date(1700000123456),
+            },
+            bigintValue: {
+                proto: create(ValueSchema, {
+                    value: {
+                        case: 'bigintValue',
+                        value: create(BigIntSchema, {
+                            absVal: new Uint8Array([0x01, 0x23, 0x45, 0x67, 0x89]),
+                            sign: 1n,
+                        }),
+                    },
+                }),
+                expected: 0x0123456789n,
+            },
+            listValue: {
+                proto: create(ValueSchema, {
+                    value: {
+                        case: 'listValue',
+                        value: create(ListSchema, {
+                            fields: [
+                                create(ValueSchema, { value: { case: 'stringValue', value: 'item1' } }),
+                                create(ValueSchema, { value: { case: 'float64Value', value: 2.5 } }),
+                            ],
+                        }),
+                    },
+                }),
+                expected: ['item1', 2.5],
+            },
+            mapValue: {
+                proto: create(ValueSchema, {
+                    value: {
+                        case: 'mapValue',
+                        value: create(MapSchema, {
+                            fields: {
+                                key1: create(ValueSchema, { value: { case: 'stringValue', value: 'value1' } }),
+                                key2: create(ValueSchema, { value: { case: 'float64Value', value: 2.5 } }),
+                            },
+                        }),
+                    },
+                }),
+                expected: { key1: 'value1', key2: 2.5 },
+            },
+            decimalValue: {
+                proto: create(ValueSchema, {
+                    value: {
+                        case: 'decimalValue',
+                        value: create(DecimalSchema, {
+                            coefficient: create(BigIntSchema, {
+                                absVal: new Uint8Array([0x04, 0xd2]), // 1234 in big-endian
+                                sign: 1n,
+                            }),
+                            exponent: -2,
+                        }),
+                    },
+                }),
+                expected: new Decimal(1234n, -2),
+            },
+        };
+        const possibleCases = Object.keys(allCases);
+        possibleCases.forEach((caseType) => {
+            const testCase = allCases[caseType];
+            test(`handles ${caseType} correctly`, () => {
+                var val = Value.wrap(testCase.proto);
+                expect(val.proto().value).toBeDefined();
+                expect(val.proto().value.case).toBe(caseType);
+                expect(val.unwrap()).toEqual(testCase.expected);
+            });
+        });
+    });
+    test('string', () => {
+        expectValue(Value.from('hello'), { case: 'stringValue', value: 'hello' });
+    });
+    test('bool', () => {
+        const val = Value.from(true);
+        expectValue(Value.from(true), { case: 'boolValue', value: true });
+    });
+    test('bytes Uint8Array', () => {
+        const data = new Uint8Array([1, 2, 3]);
+        const val = Value.from(data);
+        expectValue(val, { case: 'bytesValue', value: new Uint8Array([1, 2, 3]) });
+    });
+    test('bytes ArrayBuffer', () => {
+        const ab = new Uint8Array([1, 2, 3]);
+        const val = Value.from(ab.buffer);
+        expectValue(val, { case: 'bytesValue', value: new Uint8Array([1, 2, 3]) });
+    });
+    // Use expectProto instead and verify against the int64 etc
+    test('int64 from number', () => {
+        const val = Value.from(new Int64(42));
+        const pb = expectCase(val.proto(), 'int64Value');
+        expect(pb).toBe(42n);
+        expect(val.unwrap()).toEqual(new Int64(42));
+    });
+    test('int64 from bigint within range', () => {
+        const val = Value.from(new Int64(123n));
+        const pb = expectCase(val.proto(), 'int64Value');
+        expect(pb).toBe(123n);
+        expect(val.unwrap()).toEqual(new Int64(123n));
+    });
+    test('int64 throws on non-integer number', () => {
+        expect(() => new Int64(1.5)).toThrow();
+    });
+    test('int64 overflow throws (number)', () => {
+        // larger than int64 max
+        const tooBig = Number(2n ** 63n);
+        expect(Number.isFinite(tooBig)).toBe(true);
+        expect(() => new Int64(tooBig)).toThrow();
+    });
+    test('int64 underflow throws (number)', () => {
+        // smaller than int64 min
+        const tooSmall = Number(-(2n ** 64n));
+        expect(Number.isFinite(tooSmall)).toBe(true);
+        expect(() => new Int64(tooSmall)).toThrow();
+    });
+    test('int64 from string ', () => {
+        const val = Value.from(new Int64('-42'));
+        const pb = expectCase(val.proto(), 'int64Value');
+        expect(pb).toBe(-42n);
+        expect(val.unwrap()).toEqual(new Int64(-42));
+    });
+    test('uint64 from number', () => {
+        const val = Value.from(new UInt64(42));
+        const pb = expectCase(val.proto(), 'uint64Value');
+        expect(pb).toBe(42n);
+        expect(val.unwrap()).toEqual(new UInt64(42));
+    });
+    test('uint64 from bigint within range', () => {
+        const val = Value.from(new UInt64(123n));
+        const pb = expectCase(val.proto(), 'uint64Value');
+        expect(pb).toBe(123n);
+        expect(val.unwrap()).toEqual(new UInt64(123n));
+    });
+    test('uint64 throws on non-integer number', () => {
+        expect(() => new UInt64(1.5)).toThrow();
+    });
+    test('uint64 overflow throws (number)', () => {
+        // larger than uint64 max
+        const tooBig = Number(2n ** 64n);
+        expect(Number.isFinite(tooBig)).toBe(true);
+        expect(() => new UInt64(tooBig)).toThrow();
+    });
+    test('uint64 underflow throws (number)', () => {
+        // larger than uint64 min
+        const tooSmall = Number(-1);
+        expect(Number.isFinite(tooSmall)).toBe(true);
+        expect(() => new UInt64(tooSmall)).toThrow();
+    });
+    test('uint64 from string ', () => {
+        const val = Value.from(new UInt64('42'));
+        const pb = expectCase(val.proto(), 'uint64Value');
+        expect(pb).toBe(42n);
+        expect(val.unwrap()).toEqual(new UInt64(42n));
+    });
+    test('float64', () => {
+        // safe, since the any rounding would occur before the nubmer is a float
+        // this does a copy without math
+        expectValue(Value.from(3.14), { case: 'float64Value', value: 3.14 });
+    });
+    test('float64 supports NaN and Infinity', () => {
+        const nan = Value.from(NaN);
+        var value = expectCase(nan.proto(), 'float64Value');
+        expect(Number.isNaN(value)).toBe(true);
+        const unwrappedNaN = nan.unwrap();
+        expect(Number.isNaN(unwrappedNaN)).toBe(true);
+        const inf = Value.from(Infinity);
+        var value = expectCase(inf.proto(), 'float64Value');
+        expect(Number.isFinite(value)).toBe(false);
+        const unwrappedInf = inf.unwrap();
+        expect(Number.isFinite(unwrappedInf)).toBe(false);
+    });
+    test('bigint encodes sign and abs bytes', () => {
+        const big = -123456789012345678901234567890n;
+        const val = Value.from(big);
+        const pb = expectCase(val.proto(), 'bigintValue');
+        expect(pb.sign).toBe(-1n);
+        const abs = bytesToBigIntBE(pb.absVal);
+        expect(abs).toBe(-big);
+        const unwrapped = val.unwrap();
+        expect(unwrapped).toEqual(big);
+    });
+    test('time from Date', () => {
+        const d = new Date(1700000123456);
+        const val = Value.from(d);
+        const ts = expectCase(val.proto(), 'timeValue');
+        expect(timestampDate(ts)).toEqual(d);
+        const unwrapped = val.unwrap();
+        expect(unwrapped).toEqual(d);
+    });
+    test('list', () => {
+        const items = [1, 'x', true];
+        const val = Value.from(items);
+        const protoItems = expectCase(val.proto(), 'listValue').fields;
+        expect(protoItems).toHaveLength(3);
+        expectProto(protoItems[0], { case: 'float64Value', value: 1 });
+        expectProto(protoItems[1], { case: 'stringValue', value: 'x' });
+        expectProto(protoItems[2], { case: 'boolValue', value: true });
+        const unwrapped = val.unwrap();
+        expect(unwrapped).toEqual(items);
+    });
+    test('list empty', () => {
+        const val = Value.from([]);
+        const protoItems = expectCase(val.proto(), 'listValue').fields;
+        expect(protoItems).toHaveLength(0);
+    });
+    test('map', () => {
+        const inputMap = { d: 1.25, s: 'ok' };
+        const val = Value.from(inputMap);
+        const m = expectCase(val.proto(), 'mapValue').fields;
+        expect(Object.keys(m)).toHaveLength(2);
+        expectProto(m['d'], { case: 'float64Value', value: 1.25 });
+        expectProto(m['s'], { case: 'stringValue', value: 'ok' });
+        expect(val.unwrap()).toEqual(inputMap);
+    });
+    test('map empty', () => {
+        const val = Value.from({});
+        const m = expectCase(val.proto(), 'mapValue').fields;
+        expect(Object.keys(m)).toHaveLength(0);
+        const unwrapped = val.unwrap();
+        expect(Object.keys(unwrapped)).toHaveLength(0);
+    });
+    test('from object with schema', () => {
+        var schemaCalled = false;
+        const personSchema = {
+            parse: (value) => {
+                schemaCalled = true;
+                if (typeof value !== 'object' || value === null) {
+                    throw new Error('Expected an object');
+                }
+                const v = value;
+                if (typeof v.name !== 'string' || typeof v.age !== 'number') {
+                    throw new Error('Invalid person schema');
+                }
+                return { name: v.name, age: v.age };
+            },
+        };
+        const person = { name: 'Alice', age: 30 };
+        const val = Value.from(person);
+        // Test unwrapToType with schema
+        const unwrapped = val.unwrapToType({ schema: personSchema });
+        expect(unwrapped).toEqual(person);
+        expect(schemaCalled).toBe(true);
+    });
+    test('unwrapToType primitives values', () => {
+        const val = Value.from(123);
+        const unwrapped = val.unwrapToType({ instance: 0 });
+        expect(unwrapped).toEqual(123);
+    });
+    test('unwrapToType wrong primitive type throws', () => {
+        const val = Value.from(123);
+        expect(() => val.unwrapToType({ instance: 'a' })).toThrow();
+    });
+    test('from object with constructor', () => {
+        class Test {
+            i = 0;
+            s = '';
+            constructor() { }
+            getI() {
+                return this.i;
+            }
+        }
+        const inputObject = new Test();
+        inputObject.i = 123;
+        inputObject.s = 'abc';
+        const val = Value.from(inputObject);
+        const fields = expectCase(val.proto(), 'mapValue').fields;
+        expect(Object.keys(fields)).toHaveLength(2);
+        expectProto(fields['i'], { case: 'float64Value', value: 123 });
+        expectProto(fields['s'], { case: 'stringValue', value: 'abc' });
+        const rawUnwrapped = val.unwrap();
+        expect(rawUnwrapped).toEqual({ i: 123, s: 'abc' });
+        var factoryCalled = false;
+        const unwrappedObject = val.unwrapToType({
+            factory: () => {
+                factoryCalled = true;
+                return new Test();
+            },
+        });
+        expect(unwrappedObject).toEqual(inputObject);
+        expect(unwrappedObject).toBeInstanceOf(Test);
+        expect(unwrappedObject.getI()).toEqual(123);
+        expect(factoryCalled).toBe(true);
+    });
+    test('decimal normalization and structure', () => {
+        const val = Value.from(Decimal.parse('15.2300'));
+        const d = expectCase(val.proto(), 'decimalValue');
+        expect(d.exponent).toBe(-2);
+        // coefficient should be 1523 (sign + digits)
+        const coeffAbs = bytesToBigIntBE(d.coefficient.absVal);
+        expect(d.coefficient.sign).toBe(1n);
+        expect(coeffAbs).toBe(1523n);
+        const unwrapped = val.unwrap();
+        expect(unwrapped).toEqual(new Decimal(1523n, -2));
+    });
+    test('decimal negative and integer only', () => {
+        const val = Value.from(Decimal.parse('-123.4500'));
+        const d = expectCase(val.proto(), 'decimalValue');
+        expect(d.exponent).toBe(-2);
+        expect(d.coefficient.sign).toBe(-1n);
+        const coeffAbs = bytesToBigIntBE(d.coefficient.absVal);
+        expect(coeffAbs).toBe(12345n);
+        const unwrapped = val.unwrap();
+        expect(unwrapped).toEqual(new Decimal(-12345n, -2));
+        const intString = '42';
+        const i = Value.from(Decimal.parse(intString));
+        const id = expectCase(i.proto(), 'decimalValue');
+        expect(id.exponent).toBe(0);
+        expect(bytesToBigIntBE(id.coefficient.absVal)).toBe(42n);
+        const iunwrapped = i.unwrap();
+        expect(iunwrapped).toEqual(new Decimal(42n, 0));
+    });
+    test('decimal invalid strings throw', () => {
+        expect(() => Value.from(Decimal.parse('abc'))).toThrow();
+        expect(() => Value.from(Decimal.parse('1.'))).toThrow();
+        expect(() => Value.from(Decimal.parse('.5'))).toThrow();
+    });
+    test('from throws on null/undefined', () => {
+        expect(() => Value.from(null)).toThrow();
+        expect(() => Value.from(undefined)).toThrow();
+    });
+    test('non value protos', () => {
+        // An proto that isn't related to values
+        const fieldMask = create(FieldMaskSchema, {
+            paths: ['user.displayName', 'user.email', 'posts.*.title'],
+        });
+        const val = Value.from(fieldMask);
+        const mapValue = expectCase(val.proto(), 'mapValue').fields;
+        expect(Object.keys(mapValue)).toContain('$typeName');
+        expect(Object.keys(mapValue)).toContain('paths');
+        // Check that the typeName was preserved
+        expectProto(mapValue['$typeName'], { case: 'stringValue', value: 'google.protobuf.FieldMask' });
+        const pathsList = expectCase(mapValue['paths'], 'listValue').fields;
+        expect(pathsList).toHaveLength(3);
+        expectProto(pathsList[0], { case: 'stringValue', value: 'user.displayName' });
+        expectProto(pathsList[1], { case: 'stringValue', value: 'user.email' });
+        expectProto(pathsList[2], { case: 'stringValue', value: 'posts.*.title' });
+        // Test unwrap to plain object
+        const unwrapped = val.unwrap();
+        expect(unwrapped.$typeName).toBe('google.protobuf.FieldMask');
+        expect(Array.isArray(unwrapped.paths)).toBe(true);
+        expect(unwrapped.paths).toEqual(['user.displayName', 'user.email', 'posts.*.title']);
+        const directProto = val.unwrapToType({
+            factory: () => create(FieldMaskSchema),
+        });
+        // Verify this approach also works
+        expect(directProto.$typeName).toBe('google.protobuf.FieldMask');
+        expect(directProto.paths).toEqual(['user.displayName', 'user.email', 'posts.*.title']);
+    });
+});

package/dist/sdk/wasm/host-bindings.d.ts

@@ -0,0 +1,13 @@
+import { Mode } from '../../generated/sdk/v1alpha/sdk_pb';
+export declare const hostBindings: {
+    switchModes: (args_0: Mode, ...args: unknown[]) => void;
+    log: (args_0: string, ...args: unknown[]) => void;
+    sendResponse: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
+    versionV2: (...args: unknown[]) => void;
+    callCapability: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, ...args: unknown[]) => number;
+    awaitCapabilities: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>;
+    getSecrets: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => any;
+    awaitSecrets: (args_0: Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>, args_1: number, ...args: unknown[]) => Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBuffer>;
+    getWasiArgs: (...args: unknown[]) => string;
+    now: (...args: unknown[]) => number;
+};

package/dist/sdk/wasm/host-bindings.js

@@ -0,0 +1,52 @@
+import { Mode } from '../../generated/sdk/v1alpha/sdk_pb';
+import { z } from 'zod';
+// Zod schema for validating global host functions
+const globalHostBindingsSchema = z.object({
+    switchModes: z.function().args(z.nativeEnum(Mode)).returns(z.void()),
+    log: z.function().args(z.string()).returns(z.void()),
+    sendResponse: z
+        .function()
+        .args(z.union([z.instanceof(Uint8Array), z.custom()]))
+        .returns(z.number()),
+    versionV2: z.function().args().returns(z.void()),
+    callCapability: z
+        .function()
+        .args(z.union([z.instanceof(Uint8Array), z.custom()]))
+        .returns(z.number()),
+    awaitCapabilities: z
+        .function()
+        .args(z.union([z.instanceof(Uint8Array), z.custom()]), z.number())
+        .returns(z.union([z.instanceof(Uint8Array), z.custom()])),
+    getSecrets: z
+        .function()
+        .args(z.union([z.instanceof(Uint8Array), z.custom()]), z.number())
+        .returns(z.any()),
+    awaitSecrets: z
+        .function()
+        .args(z.union([z.instanceof(Uint8Array), z.custom()]), z.number())
+        .returns(z.union([z.instanceof(Uint8Array), z.custom()])),
+    getWasiArgs: z.function().args().returns(z.string()),
+    now: z.function().args().returns(z.number()),
+});
+// Validate global host functions at runtime
+const validateGlobalHostBindings = () => {
+    const globalFunctions = globalThis;
+    try {
+        return globalHostBindingsSchema.parse(globalFunctions);
+    }
+    catch (error) {
+        const missingFunctions = Object.keys(globalHostBindingsSchema.shape).filter((key) => !(key in globalFunctions));
+        throw new Error(`Missing required global host functions: ${missingFunctions.join(', ')}. ` +
+            `This indicates the runtime environment is not properly configured.`);
+    }
+};
+// Initialize validated global functions (lazy evaluation for testing)
+let _hostBindings = null;
+export const hostBindings = new Proxy({}, {
+    get(target, prop) {
+        if (!_hostBindings) {
+            _hostBindings = validateGlobalHostBindings();
+        }
+        return _hostBindings[prop];
+    },
+});

package/dist/sdk/wasm/index.d.ts

@@ -0,0 +1 @@
+export { Runner } from './runner';

package/dist/sdk/wasm/index.js

@@ -0,0 +1 @@
+export { Runner } from './runner';

package/dist/sdk/wasm/runner.d.ts

@@ -0,0 +1,14 @@
+import { type ExecuteRequest, type ExecutionResult } from '../../generated/sdk/v1alpha/sdk_pb';
+import { type ConfigHandlerParams } from '../utils/config';
+import type { SecretsProvider, Workflow } from '../workflow';
+import { Runtime } from './runtime';
+export declare class Runner<TConfig> {
+    private readonly config;
+    private readonly request;
+    private constructor();
+    static newRunner<TConfig, TIntermediateConfig = TConfig>(configHandlerParams?: ConfigHandlerParams<TConfig, TIntermediateConfig>): Promise<Runner<TConfig>>;
+    private static getRequest;
+    run(initFn: (config: TConfig, secretsProvider: SecretsProvider) => Promise<Workflow<TConfig>> | Workflow<TConfig>): Promise<void>;
+    handleExecutionPhase<TConfig>(req: ExecuteRequest, workflow: Workflow<TConfig>, runtime: Runtime<TConfig>): Promise<ExecutionResult>;
+    handleSubscribePhase(req: ExecuteRequest, workflow: Workflow<TConfig>): ExecutionResult;
+}

package/dist/sdk/wasm/runner.js

@@ -0,0 +1,114 @@
+import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
+import { ExecuteRequestSchema, ExecutionResultSchema, TriggerSubscriptionRequestSchema, } from '../../generated/sdk/v1alpha/sdk_pb';
+import { configHandler } from '../utils/config';
+import { Value } from '../utils';
+import { hostBindings } from './host-bindings';
+import { Runtime } from './runtime';
+export class Runner {
+    config;
+    request;
+    constructor(config, request) {
+        this.config = config;
+        this.request = request;
+    }
+    static async newRunner(configHandlerParams) {
+        hostBindings.versionV2();
+        const request = Runner.getRequest();
+        const config = await configHandler(request, configHandlerParams);
+        return new Runner(config, request);
+    }
+    static getRequest() {
+        const argsString = hostBindings.getWasiArgs();
+        const args = JSON.parse(argsString);
+        // SDK expects exactly 2 args:
+        // 1st is the script name
+        // 2nd is the base64 encoded request
+        if (args.length !== 2) {
+            throw new Error('Invalid request: must contain payload');
+        }
+        const base64Request = args[1];
+        const bytes = Buffer.from(base64Request, 'base64');
+        return fromBinary(ExecuteRequestSchema, bytes);
+    }
+    async run(initFn) {
+        const runtime = new Runtime(this.config, 0, this.request.maxResponseSize);
+        var result;
+        try {
+            const workflow = await initFn(this.config, {
+                getSecret: runtime.getSecret.bind(runtime),
+            });
+            switch (this.request.request.case) {
+                case 'subscribe':
+                    result = this.handleSubscribePhase(this.request, workflow);
+                    break;
+                case 'trigger':
+                    result = this.handleExecutionPhase(this.request, workflow, runtime);
+                    break;
+            }
+        }
+        catch (e) {
+            const err = e instanceof Error ? e.message : String(e);
+            result = create(ExecutionResultSchema, {
+                result: { case: 'error', value: err },
+            });
+        }
+        const awaitedResult = await result;
+        hostBindings.sendResponse(toBinary(ExecutionResultSchema, awaitedResult));
+    }
+    async handleExecutionPhase(req, workflow, runtime) {
+        if (req.request.case !== 'trigger') {
+            throw new Error('cannot handle non-trigger request as a trigger');
+        }
+        const triggerMsg = req.request.value;
+        const index = Number(triggerMsg.id);
+        if (Number.isFinite(index) && index >= 0 && index < workflow.length) {
+            const entry = workflow[index];
+            const schema = entry.trigger.outputSchema();
+            const payloadAny = triggerMsg.payload;
+            /**
+             * Note: do not hardcode method name; routing by id is authoritative.
+             *
+             * This matches the GO SDK behavior, which also just checks for the id.
+             *
+             * @see https://github.com/smartcontractkit/cre-sdk-go/blob/5a41d81e3e072008484e85dc96d746401aafcba2/cre/wasm/runner.go#L81
+             * */
+            const decoded = fromBinary(schema, payloadAny.value);
+            const adapted = await entry.trigger.adapt(decoded);
+            try {
+                const result = await entry.fn(runtime, adapted);
+                const wrapped = Value.wrap(result);
+                return create(ExecutionResultSchema, {
+                    result: { case: 'value', value: wrapped.proto() },
+                });
+            }
+            catch (e) {
+                const err = e instanceof Error ? e.message : String(e);
+                return create(ExecutionResultSchema, {
+                    result: { case: 'error', value: err },
+                });
+            }
+        }
+        return create(ExecutionResultSchema, {
+            result: { case: 'error', value: 'trigger not found' },
+        });
+    }
+    handleSubscribePhase(req, workflow) {
+        if (req.request.case !== 'subscribe') {
+            return create(ExecutionResultSchema, {
+                result: { case: 'error', value: 'subscribe request expected' },
+            });
+        }
+        // Build TriggerSubscriptionRequest from the workflow entries
+        const subscriptions = workflow.map((entry) => ({
+            id: entry.trigger.capabilityId(),
+            method: entry.trigger.method(),
+            payload: entry.trigger.configAsAny(),
+        }));
+        const subscriptionRequest = create(TriggerSubscriptionRequestSchema, {
+            subscriptions,
+        });
+        return create(ExecutionResultSchema, {
+            result: { case: 'triggerSubscriptions', value: subscriptionRequest },
+        });
+    }
+}

package/dist/sdk/wasm/runner.test.d.ts

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