npm - @lunatest/core - Versions diffs - 0.1.0 - Mend

@lunatest/core 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (32) hide show

package/LICENSE +21 -0
package/dist/config/lua-config.d.ts +4 -0
package/dist/config/lua-config.js +71 -0
package/dist/index.d.ts +6 -0
package/dist/index.js +5 -0
package/dist/mocks/provider.d.ts +56 -0
package/dist/mocks/provider.js +166 -0
package/dist/provider/luna-provider.d.ts +27 -0
package/dist/provider/luna-provider.js +117 -0
package/dist/runner/assert.d.ts +11 -0
package/dist/runner/assert.js +58 -0
package/dist/runner/execute-scenario.d.ts +38 -0
package/dist/runner/execute-scenario.js +70 -0
package/dist/runner/performance.d.ts +14 -0
package/dist/runner/performance.js +31 -0
package/dist/runner/reporter.d.ts +5 -0
package/dist/runner/reporter.js +70 -0
package/dist/runner/runner.d.ts +42 -0
package/dist/runner/runner.js +74 -0
package/dist/runtime/bridge.d.ts +2 -0
package/dist/runtime/bridge.js +48 -0
package/dist/runtime/engine.d.ts +2 -0
package/dist/runtime/engine.js +85 -0
package/dist/runtime/sandbox.d.ts +3 -0
package/dist/runtime/sandbox.js +54 -0
package/dist/runtime/scenario-runtime.d.ts +70 -0
package/dist/runtime/scenario-runtime.js +156 -0
package/dist/runtime/types.d.ts +17 -0
package/dist/runtime/types.js +9 -0
package/dist/scenario/index.d.ts +43 -0
package/dist/scenario/index.js +85 -0
package/package.json +36 -0

package/dist/runner/performance.js ADDED Viewed

@@ -0,0 +1,31 @@
+import { performance } from "node:perf_hooks";
+import { runScenario } from "./runner.js";
+function percentile(values, ratio) {
+    if (values.length === 0) {
+        return 0;
+    }
+    const sorted = [...values].sort((left, right) => left - right);
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * ratio) - 1));
+    return sorted[index] ?? 0;
+}
+export async function measureScenarioPerformance(input) {
+    const samplesMs = [];
+    const iterations = Math.max(0, input.iterations);
+    const totalStart = performance.now();
+    for (let index = 0; index < iterations; index += 1) {
+        const start = performance.now();
+        await runScenario({
+            scenario: input.scenario,
+            resolveUi: input.resolveUi,
+        });
+        samplesMs.push(performance.now() - start);
+    }
+    const totalMs = performance.now() - totalStart;
+    return {
+        iterations,
+        totalMs,
+        averageMs: iterations === 0 ? 0 : totalMs / iterations,
+        p95Ms: percentile(samplesMs, 0.95),
+        samplesMs,
+    };
+}

package/dist/runner/reporter.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import type { RunAllResult } from "./runner.js";
+export declare function toConsoleReport(result: RunAllResult): string;
+export declare function toJsonReport(result: RunAllResult): string;
+export declare function toJunitReport(result: RunAllResult): string;
+export declare function toHtmlReport(result: RunAllResult): string;

package/dist/runner/reporter.js ADDED Viewed

@@ -0,0 +1,70 @@
+function escapeXml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll("\"", "&quot;")
+        .replaceAll("'", "&apos;");
+}
+function scenarioLine(result) {
+    return `${result.pass ? "PASS" : "FAIL"} ${result.scenarioName}`;
+}
+export function toConsoleReport(result) {
+    const lines = [
+        "Scenario Summary",
+        `total=${result.total}`,
+        `passed=${result.passed}`,
+        `failed=${result.failed}`,
+    ];
+    for (const item of result.results) {
+        lines.push(scenarioLine(item));
+        if (!item.pass && item.diff) {
+            lines.push(item.diff);
+        }
+    }
+    return lines.join("\n");
+}
+export function toJsonReport(result) {
+    return JSON.stringify(result, null, 2);
+}
+export function toJunitReport(result) {
+    const testcases = result.results
+        .map((item) => {
+        if (item.pass) {
+            return `<testcase classname="lunatest" name="${escapeXml(item.scenarioName)}" />`;
+        }
+        return [
+            `<testcase classname="lunatest" name="${escapeXml(item.scenarioName)}">`,
+            `<failure message="${escapeXml(item.diff || "assertion failed")}" />`,
+            "</testcase>",
+        ].join("");
+    })
+        .join("");
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        `<testsuite name="lunatest" tests="${result.total}" failures="${result.failed}">`,
+        testcases,
+        "</testsuite>",
+    ].join("");
+}
+export function toHtmlReport(result) {
+    const rows = result.results
+        .map((item) => {
+        const status = item.pass ? "PASS" : "FAIL";
+        const diff = item.diff ? item.diff : "";
+        return `<tr><td>${escapeXml(item.scenarioName)}</td><td>${status}</td><td>${escapeXml(diff)}</td></tr>`;
+    })
+        .join("");
+    return [
+        "<!doctype html>",
+        "<html><head><meta charset=\"utf-8\" /><title>LunaTest Report</title></head>",
+        "<body>",
+        "<h1>LunaTest Report</h1>",
+        `<p>total=${result.total}, passed=${result.passed}, failed=${result.failed}</p>`,
+        "<table border=\"1\" cellspacing=\"0\" cellpadding=\"6\">",
+        "<thead><tr><th>Scenario</th><th>Status</th><th>Diff</th></tr></thead>",
+        `<tbody>${rows}</tbody>`,
+        "</table>",
+        "</body></html>",
+    ].join("");
+}

package/dist/runner/runner.d.ts ADDED Viewed

@@ -0,0 +1,42 @@
+import { type AssertionResult } from "./assert.js";
+type ScenarioLike = {
+    name: string;
+    given?: Record<string, unknown>;
+    when: {
+        action: string;
+        [key: string]: unknown;
+    };
+    then_ui: Record<string, unknown>;
+    then_state?: Record<string, unknown>;
+    stages?: Array<{
+        name: string;
+    }>;
+    not_present?: string[];
+    timing_ms?: number;
+};
+export type RunScenarioInput = {
+    scenario: ScenarioLike;
+    resolveUi: (scenario: ScenarioLike) => Promise<Record<string, unknown>> | Record<string, unknown>;
+    resolveState?: (scenario: ScenarioLike) => Promise<Record<string, unknown>> | Record<string, unknown>;
+    resolveTransitions?: (scenario: ScenarioLike) => Promise<string[]> | string[];
+    resolveElapsedMs?: (scenario: ScenarioLike) => Promise<number> | number;
+};
+export type RunScenarioResult = {
+    scenarioName: string;
+    pass: boolean;
+    diff: string;
+    expectedUi: Record<string, unknown>;
+    actualUi: Record<string, unknown>;
+    expectedState?: Record<string, unknown>;
+    actualState?: Record<string, unknown>;
+    assertions: Record<string, AssertionResult>;
+};
+export type RunAllResult = {
+    total: number;
+    passed: number;
+    failed: number;
+    results: RunScenarioResult[];
+};
+export declare function runScenario(input: RunScenarioInput): Promise<RunScenarioResult>;
+export declare function runAll(items: RunScenarioInput[]): Promise<RunAllResult>;
+export {};

package/dist/runner/runner.js ADDED Viewed

@@ -0,0 +1,74 @@
+import { assertNot, assertState, assertTiming, assertTransition, assertUI, } from "./assert.js";
+function missingResolver(label) {
+    return {
+        pass: false,
+        diff: `${label} resolver is required for this scenario`,
+        expected: "resolver",
+        actual: "missing",
+    };
+}
+function collectFailureDiff(assertions) {
+    return Object.entries(assertions)
+        .filter(([, value]) => !value.pass)
+        .map(([name, value]) => `[${name}] ${value.diff}`)
+        .join("\n");
+}
+export async function runScenario(input) {
+    const actualUi = await input.resolveUi(input.scenario);
+    const assertions = {
+        ui: assertUI(input.scenario.then_ui, actualUi),
+    };
+    let actualState;
+    if (input.scenario.then_state) {
+        if (!input.resolveState) {
+            assertions.state = missingResolver("state");
+        }
+        else {
+            actualState = await input.resolveState(input.scenario);
+            assertions.state = assertState(input.scenario.then_state, actualState);
+        }
+    }
+    if (input.scenario.stages && input.scenario.stages.length > 0) {
+        const expectedPath = input.scenario.stages.map((stage) => stage.name);
+        if (!input.resolveTransitions) {
+            assertions.transition = missingResolver("transition");
+        }
+        else {
+            const actualPath = await input.resolveTransitions(input.scenario);
+            assertions.transition = assertTransition(expectedPath, actualPath);
+        }
+    }
+    if (input.scenario.not_present && input.scenario.not_present.length > 0) {
+        assertions.negative = assertNot(input.scenario.not_present, actualUi);
+    }
+    if (input.scenario.timing_ms !== undefined) {
+        if (!input.resolveElapsedMs) {
+            assertions.timing = missingResolver("timing");
+        }
+        else {
+            const elapsedMs = await input.resolveElapsedMs(input.scenario);
+            assertions.timing = assertTiming(input.scenario.timing_ms, elapsedMs);
+        }
+    }
+    const pass = Object.values(assertions).every((result) => result.pass);
+    return {
+        scenarioName: input.scenario.name,
+        pass,
+        diff: collectFailureDiff(assertions),
+        expectedUi: input.scenario.then_ui,
+        actualUi,
+        expectedState: input.scenario.then_state,
+        actualState,
+        assertions,
+    };
+}
+export async function runAll(items) {
+    const results = await Promise.all(items.map((item) => runScenario(item)));
+    const passed = results.filter((result) => result.pass).length;
+    return {
+        total: results.length,
+        passed,
+        failed: results.length - passed,
+        results,
+    };
+}

package/dist/runtime/bridge.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export declare function toLuaArgs<T>(value: T): T;
2	+ export declare function fromLuaValue<T>(value: T): T;

package/dist/runtime/bridge.js ADDED Viewed

@@ -0,0 +1,48 @@
+function typeName(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    return typeof value;
+}
+function isPlainObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.getPrototypeOf(value) === Object.prototype);
+}
+function cloneSupported(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => cloneSupported(item));
+    }
+    if (isPlainObject(value)) {
+        const cloned = {};
+        for (const [key, nested] of Object.entries(value)) {
+            if (nested === undefined) {
+                throw new Error(`Unsupported value type at ${key}: undefined`);
+            }
+            Object.defineProperty(cloned, key, {
+                value: cloneSupported(nested),
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            });
+        }
+        return cloned;
+    }
+    throw new Error(`Unsupported value type: ${typeName(value)}`);
+}
+export function toLuaArgs(value) {
+    return cloneSupported(value);
+}
+export function fromLuaValue(value) {
+    return cloneSupported(value);
+}

package/dist/runtime/engine.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import { type Runtime, type RuntimeOptions } from "./types.js";
2	+ export declare function createRuntime(rawOptions?: RuntimeOptions): Promise<Runtime>;

package/dist/runtime/engine.js ADDED Viewed

@@ -0,0 +1,85 @@
+import { LuaFactory } from "wasmoon";
+import { fromLuaValue, toLuaArgs } from "./bridge.js";
+import { applySandbox } from "./sandbox.js";
+import { RuntimeOptionsSchema, } from "./types.js";
+const FUNCTION_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const DEFAULT_MEMORY_LIMIT = 16 * 1024 * 1024;
+function normalizeFunctionName(name) {
+    if (!FUNCTION_NAME_RE.test(name)) {
+        throw new Error(`Invalid function name: ${name}`);
+    }
+    return name;
+}
+export async function createRuntime(rawOptions = {}) {
+    const options = RuntimeOptionsSchema.parse(rawOptions);
+    const factory = new LuaFactory();
+    const hostFunctions = new Map();
+    let instructionLimit = options.instructionLimit;
+    let memoryLimit = options.memoryLimit ?? DEFAULT_MEMORY_LIMIT;
+    let engine;
+    const bindHostFunction = (name, hostFn) => {
+        engine.global.set(name, (...values) => {
+            const normalizedValues = fromLuaValue(values);
+            const result = hostFn(...normalizedValues);
+            return toLuaArgs(result);
+        });
+    };
+    const bootstrapEngine = async () => {
+        if (engine) {
+            engine.global.close();
+        }
+        engine = await factory.createEngine({
+            functionTimeout: instructionLimit,
+            traceAllocations: true,
+        });
+        engine.global.setMemoryMax(memoryLimit);
+        await applySandbox(engine, {
+            ...options,
+            instructionLimit,
+            memoryLimit,
+        });
+        for (const [name, hostFn] of hostFunctions.entries()) {
+            bindHostFunction(name, hostFn);
+        }
+    };
+    await bootstrapEngine();
+    return {
+        async eval(code) {
+            await engine.doString(code);
+        },
+        async call(name, args = {}) {
+            const targetName = normalizeFunctionName(name);
+            const target = engine.global.get(targetName);
+            if (typeof target !== "function") {
+                throw new Error(`Function not found: ${targetName}`);
+            }
+            const normalizedArgs = toLuaArgs(args);
+            const orderedArgs = Object.values(normalizedArgs);
+            const result = await Promise.resolve(target(...orderedArgs));
+            return fromLuaValue(result);
+        },
+        register(name, hostFn) {
+            const targetName = normalizeFunctionName(name);
+            hostFunctions.set(targetName, hostFn);
+            bindHostFunction(targetName, hostFn);
+        },
+        async getState(keys = []) {
+            const snapshot = {};
+            for (const key of keys) {
+                snapshot[key] = fromLuaValue(engine.global.get(key));
+            }
+            return snapshot;
+        },
+        setInstructionLimit(n) {
+            instructionLimit = Math.max(1, Math.trunc(n));
+            engine.global.setTimeout(instructionLimit);
+        },
+        setMemoryLimit(bytes) {
+            memoryLimit = Math.max(1, Math.trunc(bytes));
+            engine.global.setMemoryMax(memoryLimit);
+        },
+        async reset() {
+            await bootstrapEngine();
+        },
+    };
+}

package/dist/runtime/sandbox.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import type { LuaEngine } from "wasmoon";
+import type { RuntimeOptions } from "./types.js";
+export declare function applySandbox(engine: LuaEngine, options?: RuntimeOptions): Promise<void>;

package/dist/runtime/sandbox.js ADDED Viewed

@@ -0,0 +1,54 @@
+function createDeterministicRandom(seed) {
+    let cursor = seed;
+    return () => {
+        const nextValue = Math.sin(cursor++) * 10000;
+        const fractional = nextValue - Math.floor(nextValue);
+        return Number(fractional.toFixed(6));
+    };
+}
+function toInteger(value) {
+    return Number.isFinite(value) ? Math.trunc(value) : 0;
+}
+export async function applySandbox(engine, options = {}) {
+    const seed = options.seed ?? 1;
+    const now = toInteger(options.now ?? 0);
+    const instructionLimit = options.instructionLimit;
+    engine.global.set("__lunatest_next_random", createDeterministicRandom(seed));
+    await engine.doString(`
+    math.random = function()
+      return __lunatest_next_random()
+    end
+    os.time = function()
+      return ${now}
+    end
+    os.date = function()
+      return "1970-01-01T00:00:00Z"
+    end
+    io = {
+      open = function()
+        error("io.open is blocked in sandbox")
+      end
+    }
+    os.execute = function()
+      error("os.execute is blocked in sandbox")
+    end
+  `);
+    if (instructionLimit !== undefined) {
+        const normalizedLimit = Math.max(1, toInteger(instructionLimit));
+        await engine.doString(`
+      __lunatest_instruction_count = 0
+      __lunatest_instruction_limit = ${normalizedLimit}
+      debug.sethook(function()
+        __lunatest_instruction_count = __lunatest_instruction_count + 1
+        if __lunatest_instruction_count > __lunatest_instruction_limit then
+          error("instruction limit exceeded")
+        end
+      end, "", 1)
+    `);
+    }
+}

package/dist/runtime/scenario-runtime.d.ts ADDED Viewed

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { type RouteMock } from "@lunatest/contracts";
+export type { RouteMock } from "@lunatest/contracts";
+export declare const LuaConfigSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        strict: "strict";
+        permissive: "permissive";
+    }>>;
+    given: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    when: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    then_ui: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    then_state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    intercept: z.ZodOptional<z.ZodObject<{
+        routes: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            endpointType: z.ZodLiteral<"ethereum">;
+            method: z.ZodString;
+            responseKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            endpointType: z.ZodLiteral<"rpc">;
+            urlPattern: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>]>;
+            methods: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            responseKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            endpointType: z.ZodLiteral<"http">;
+            urlPattern: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>]>;
+            method: z.ZodOptional<z.ZodString>;
+            responseKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            endpointType: z.ZodLiteral<"ws">;
+            urlPattern: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>]>;
+            responseKey: z.ZodString;
+            match: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<RegExp, RegExp>]>>;
+        }, z.core.$strip>], "endpointType">>>;
+        routing: z.ZodOptional<z.ZodObject<{
+            ethereumMethods: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                method: z.ZodString;
+                responseKey: z.ZodString;
+            }, z.core.$strip>>>>;
+            rpcEndpoints: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                urlPattern: z.ZodString;
+                methods: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                responseKey: z.ZodString;
+            }, z.core.$strip>>>>;
+            httpEndpoints: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                urlPattern: z.ZodString;
+                method: z.ZodOptional<z.ZodString>;
+                responseKey: z.ZodString;
+            }, z.core.$strip>>>>;
+            wsEndpoints: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodObject<{
+                urlPattern: z.ZodString;
+                responseKey: z.ZodString;
+                match: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>>;
+        }, z.core.$strip>>;
+        mockResponses: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+export type LuaConfig = z.infer<typeof LuaConfigSchema>;
+export type ScenarioRuntime = {
+    getConfig: () => LuaConfig;
+    getRouteMocks: () => RouteMock[];
+    setRouteMocks: (routes: RouteMock[]) => RouteMock[];
+    getInterceptState: () => Record<string, unknown>;
+    applyInterceptState: (partialState: Record<string, unknown>) => Record<string, unknown>;
+};
+export declare function createScenarioRuntime(input: LuaConfig): ScenarioRuntime;
+export declare function applyInterceptState(runtime: ScenarioRuntime, partialState: Record<string, unknown>): Record<string, unknown>;
+export declare function setRouteMocks(runtime: ScenarioRuntime, routes: RouteMock[]): RouteMock[];

package/dist/runtime/scenario-runtime.js ADDED Viewed

@@ -0,0 +1,156 @@
+import { z } from "zod";
+import { deepClone, deepMerge } from "@lunatest/contracts";
+const StringRecordSchema = z.record(z.string(), z.unknown());
+const EthereumRouteSchema = z.object({
+    endpointType: z.literal("ethereum"),
+    method: z.string().min(1),
+    responseKey: z.string().min(1),
+});
+const RpcRouteSchema = z.object({
+    endpointType: z.literal("rpc"),
+    urlPattern: z.union([z.string().min(1), z.instanceof(RegExp)]),
+    methods: z.array(z.string().min(1)).optional(),
+    responseKey: z.string().min(1),
+});
+const HttpRouteSchema = z.object({
+    endpointType: z.literal("http"),
+    urlPattern: z.union([z.string().min(1), z.instanceof(RegExp)]),
+    method: z.string().min(1).optional(),
+    responseKey: z.string().min(1),
+});
+const WsRouteSchema = z.object({
+    endpointType: z.literal("ws"),
+    urlPattern: z.union([z.string().min(1), z.instanceof(RegExp)]),
+    responseKey: z.string().min(1),
+    match: z.union([z.string().min(1), z.instanceof(RegExp)]).optional(),
+});
+const RouteMockSchema = z.discriminatedUnion("endpointType", [
+    EthereumRouteSchema,
+    RpcRouteSchema,
+    HttpRouteSchema,
+    WsRouteSchema,
+]);
+const LegacyRoutingSchema = z
+    .object({
+    ethereumMethods: z
+        .array(z.object({
+        method: z.string().min(1),
+        responseKey: z.string().min(1),
+    }))
+        .optional(),
+    rpcEndpoints: z
+        .array(z.object({
+        urlPattern: z.string().min(1),
+        methods: z.array(z.string().min(1)).optional(),
+        responseKey: z.string().min(1),
+    }))
+        .optional(),
+    httpEndpoints: z
+        .array(z.object({
+        urlPattern: z.string().min(1),
+        method: z.string().min(1).optional(),
+        responseKey: z.string().min(1),
+    }))
+        .optional(),
+    wsEndpoints: z
+        .array(z.object({
+        urlPattern: z.string().min(1),
+        responseKey: z.string().min(1),
+        match: z.string().min(1).optional(),
+    }))
+        .optional(),
+})
+    .partial();
+export const LuaConfigSchema = z
+    .object({
+    name: z.string().min(1).optional(),
+    mode: z.enum(["strict", "permissive"]).default("strict"),
+    given: StringRecordSchema.default({}),
+    when: StringRecordSchema.optional(),
+    then_ui: StringRecordSchema.optional(),
+    then_state: StringRecordSchema.optional(),
+    intercept: z
+        .object({
+        routes: z.array(RouteMockSchema).optional(),
+        routing: LegacyRoutingSchema.optional(),
+        mockResponses: StringRecordSchema.optional(),
+        state: StringRecordSchema.optional(),
+    })
+        .optional(),
+})
+    .passthrough();
+function normalizeLegacyRoutes(routing) {
+    if (!routing) {
+        return [];
+    }
+    const routes = [];
+    for (const route of routing.ethereumMethods ?? []) {
+        routes.push({
+            endpointType: "ethereum",
+            method: route.method,
+            responseKey: route.responseKey,
+        });
+    }
+    for (const route of routing.rpcEndpoints ?? []) {
+        routes.push({
+            endpointType: "rpc",
+            urlPattern: route.urlPattern,
+            methods: route.methods,
+            responseKey: route.responseKey,
+        });
+    }
+    for (const route of routing.httpEndpoints ?? []) {
+        routes.push({
+            endpointType: "http",
+            urlPattern: route.urlPattern,
+            method: route.method,
+            responseKey: route.responseKey,
+        });
+    }
+    for (const route of routing.wsEndpoints ?? []) {
+        routes.push({
+            endpointType: "ws",
+            urlPattern: route.urlPattern,
+            responseKey: route.responseKey,
+            match: route.match,
+        });
+    }
+    return routes;
+}
+export function createScenarioRuntime(input) {
+    const parsed = LuaConfigSchema.parse(input);
+    let routeMocks = parsed.intercept?.routes
+        ? parsed.intercept.routes.map((route) => ({ ...route }))
+        : normalizeLegacyRoutes(parsed.intercept?.routing);
+    let interceptState = deepClone(parsed.intercept?.state ?? {});
+    return {
+        getConfig() {
+            const cloned = deepClone(parsed);
+            cloned.intercept = cloned.intercept ?? {};
+            cloned.intercept.routes = routeMocks.map((route) => ({ ...route }));
+            cloned.intercept.state = deepClone(interceptState);
+            return cloned;
+        },
+        getRouteMocks() {
+            return routeMocks.map((route) => ({ ...route }));
+        },
+        setRouteMocks(routes) {
+            routeMocks = z.array(RouteMockSchema).parse(routes).map((route) => ({ ...route }));
+            return routeMocks.map((route) => ({ ...route }));
+        },
+        getInterceptState() {
+            return deepClone(interceptState);
+        },
+        applyInterceptState(partialState) {
+            const normalized = StringRecordSchema.parse(partialState);
+            interceptState = deepMerge(interceptState, normalized);
+            return deepClone(interceptState);
+        },
+    };
+}
+export function applyInterceptState(runtime, partialState) {
+    return runtime.applyInterceptState(partialState);
+}
+export function setRouteMocks(runtime, routes) {
+    return runtime.setRouteMocks(routes);
+}

package/dist/runtime/types.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export declare const RuntimeOptionsSchema: z.ZodObject<{
+    seed: z.ZodOptional<z.ZodNumber>;
+    now: z.ZodOptional<z.ZodNumber>;
+    instructionLimit: z.ZodOptional<z.ZodNumber>;
+    memoryLimit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type RuntimeOptions = z.infer<typeof RuntimeOptionsSchema>;
+export interface Runtime {
+    eval(code: string): Promise<void>;
+    call(name: string, args?: Record<string, unknown>): Promise<unknown>;
+    register(name: string, hostFn: (...args: unknown[]) => unknown): void;
+    getState(keys?: string[]): Promise<Record<string, unknown>>;
+    setInstructionLimit(n: number): void;
+    setMemoryLimit(bytes: number): void;
+    reset(): Promise<void>;
+}

package/dist/runtime/types.js ADDED Viewed

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export const RuntimeOptionsSchema = z
+    .object({
+    seed: z.number().finite().optional(),
+    now: z.number().finite().optional(),
+    instructionLimit: z.number().int().positive().optional(),
+    memoryLimit: z.number().int().positive().optional(),
+})
+    .strict();