@livon/runtime 0.27.0-rc.1

package/dist/runtime.js

@@ -0,0 +1,338 @@
+const createHookStore = ()=>({
+        onReceive: [],
+        onSend: [],
+        onError: []
+    });
+const createState = ()=>{
+    const store = new Map();
+    const get = (key)=>store.get(key);
+    const set = (key, value)=>{
+        store.set(key, value);
+    };
+    return {
+        get,
+        set
+    };
+};
+const mergeMetadata = (base, extra)=>{
+    if (!base && !extra) return;
+    return {
+        ...base ?? {},
+        ...extra ?? {}
+    };
+};
+let fallbackEventIdCounter = 0;
+const createEventId = ()=>{
+    const cryptoValue = globalThis.crypto;
+    if (cryptoValue?.randomUUID) return cryptoValue.randomUUID();
+    fallbackEventIdCounter += 1;
+    return `evt_${Date.now().toString(36)}_${fallbackEventIdCounter.toString(36)}`;
+};
+const isContextRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const contextRecordFrom = (value)=>{
+    if (!value || !isContextRecord(value)) return;
+    return value;
+};
+const errorFromUnknown = (error)=>{
+    if (error instanceof Error) {
+        const context = isContextRecord(error.context) ? error.context : void 0;
+        return {
+            message: error.message,
+            ...error.name ? {
+                name: error.name
+            } : {},
+            ...error.stack ? {
+                stack: error.stack
+            } : {},
+            ...context ? {
+                context
+            } : {}
+        };
+    }
+    if ('string' == typeof error) return {
+        message: error
+    };
+    if ('object' == typeof error && null !== error) {
+        const value = error;
+        const message = 'string' == typeof value.message ? value.message : 'Unknown error';
+        const name = 'string' == typeof value.name ? value.name : void 0;
+        const stack = 'string' == typeof value.stack ? value.stack : void 0;
+        const context = isContextRecord(value.context) ? value.context : void 0;
+        return {
+            message,
+            ...name ? {
+                name
+            } : {},
+            ...stack ? {
+                stack
+            } : {},
+            ...context ? {
+                context
+            } : {}
+        };
+    }
+    return {
+        message: 'Unknown error'
+    };
+};
+const registerHook = (hooks)=>(hook)=>{
+        hooks.push(hook);
+        const unsub = ()=>{
+            const index = hooks.indexOf(hook);
+            if (index >= 0) hooks.splice(index, 1);
+        };
+        return {
+            unsub
+        };
+    };
+const registerErrorHook = (hooks)=>(hook)=>{
+        hooks.push(hook);
+        const unsub = ()=>{
+            const index = hooks.indexOf(hook);
+            if (index >= 0) hooks.splice(index, 1);
+        };
+        return {
+            unsub
+        };
+    };
+const runtime = (inputOrModule, ...rest)=>{
+    const input = 'modules' in inputOrModule ? inputOrModule : {
+        modules: [
+            inputOrModule,
+            ...rest
+        ]
+    };
+    const modules = input.modules;
+    const state = createState();
+    const hooks = createHookStore();
+    const onReceive = registerHook(hooks.onReceive);
+    const onSend = registerHook(hooks.onSend);
+    const onError = registerErrorHook(hooks.onError);
+    const emitErrorHooks = ({ runtimeError, eventEnvelope, runtimeContext })=>{
+        hooks.onError.forEach((handler)=>{
+            try {
+                handler(runtimeError, eventEnvelope, runtimeContext);
+            } catch  {}
+        });
+    };
+    const mergeContext = (base, update)=>{
+        const left = contextRecordFrom(base);
+        const right = contextRecordFrom(update);
+        if (!left && !right) return;
+        return {
+            ...left ?? {},
+            ...right ?? {}
+        };
+    };
+    const payloadFromEvent = (event)=>event.payload;
+    const errorFromEvent = (event)=>event.error;
+    const mergeEvent = (base, update)=>{
+        if (!update) return base;
+        const nextId = update.id ?? base.id;
+        const nextEvent = update.event ?? base.event;
+        const nextStatus = update.status ?? base.status;
+        const nextMetadata = mergeMetadata(base.metadata, update.metadata);
+        const nextContext = mergeContext(base.context, update.context);
+        const nextPayload = payloadFromEvent(update) ?? payloadFromEvent(base);
+        const nextError = errorFromEvent(update) ?? errorFromEvent(base);
+        if (void 0 === nextPayload && void 0 === nextError) throw new Error('Event envelope must contain payload or error.');
+        const mergedEnvelopeBase = {
+            ...base,
+            id: nextId,
+            event: nextEvent,
+            status: nextStatus,
+            metadata: nextMetadata,
+            context: nextContext
+        };
+        if (void 0 !== nextPayload && void 0 !== nextError) return {
+            ...mergedEnvelopeBase,
+            payload: nextPayload,
+            error: nextError
+        };
+        if (void 0 !== nextPayload) return {
+            ...mergedEnvelopeBase,
+            payload: nextPayload
+        };
+        const definedError = nextError;
+        return {
+            ...mergedEnvelopeBase,
+            error: definedError
+        };
+    };
+    const buildEnvelope = ({ emitInput, fallbackStatus, roomName })=>{
+        const { id: inputId, event, status: inputStatus, metadata: inputMetadata, context, payload, error } = emitInput;
+        const roomMeta = roomName ? {
+            room: roomName
+        } : void 0;
+        const metadata = mergeMetadata(roomMeta, inputMetadata);
+        const id = inputId ?? createEventId();
+        const status = inputStatus ?? fallbackStatus;
+        if (void 0 === payload && void 0 === error) throw new Error('Emit input must contain payload or error.');
+        const envelopeBase = {
+            id,
+            event,
+            status,
+            metadata,
+            context
+        };
+        if (void 0 !== payload && void 0 !== error) return {
+            ...envelopeBase,
+            payload,
+            error
+        };
+        if (void 0 !== payload) return {
+            ...envelopeBase,
+            payload
+        };
+        const definedError = error;
+        return {
+            ...envelopeBase,
+            error: definedError
+        };
+    };
+    const buildFailedEnvelope = ({ runtimeError, eventEnvelope })=>{
+        const normalizedError = errorFromUnknown(runtimeError);
+        const nextContext = mergeContext(eventEnvelope.context, normalizedError.context);
+        return {
+            ...eventEnvelope,
+            error: normalizedError,
+            context: nextContext
+        };
+    };
+    const invokeHook = (input)=>{
+        const hook = input.hookChain[input.hookIndex];
+        if (!hook) return Promise.resolve(input.eventEnvelope);
+        let nextPromise;
+        let nextCalled = false;
+        const next = (update)=>{
+            nextCalled = true;
+            nextPromise = invokeHook({
+                hookChain: input.hookChain,
+                hookIndex: input.hookIndex + 1,
+                eventEnvelope: mergeEvent(input.eventEnvelope, update),
+                runtimeContext: input.runtimeContext
+            });
+            return nextPromise;
+        };
+        const result = hook(input.eventEnvelope, input.runtimeContext, next);
+        if (void 0 === result && nextCalled) return nextPromise ?? Promise.resolve(input.eventEnvelope);
+        return Promise.resolve(result).then((value)=>value ?? nextPromise ?? input.eventEnvelope);
+    };
+    const runReceive = (eventEnvelope, runtimeContext)=>invokeHook({
+            hookChain: hooks.onReceive,
+            hookIndex: 0,
+            eventEnvelope,
+            runtimeContext
+        });
+    const runSend = (eventEnvelope, runtimeContext)=>invokeHook({
+            hookChain: hooks.onSend,
+            hookIndex: 0,
+            eventEnvelope,
+            runtimeContext
+        });
+    const createEmitError = ({ runtimeContext, roomName })=>async (emitInput)=>{
+            const envelope = buildEnvelope({
+                emitInput,
+                fallbackStatus: 'sending',
+                roomName
+            });
+            const fallbackError = envelope.error ?? {
+                message: 'Unknown error'
+            };
+            const failedEnvelope = {
+                ...envelope,
+                error: fallbackError
+            };
+            emitErrorHooks({
+                runtimeError: fallbackError,
+                eventEnvelope: failedEnvelope,
+                runtimeContext
+            });
+            return {
+                ok: true
+            };
+        };
+    const createEmitReceive = ({ runtimeContext, roomName })=>async (emitInput)=>{
+            const envelope = buildEnvelope({
+                emitInput,
+                fallbackStatus: 'receiving',
+                roomName
+            });
+            try {
+                await runReceive(envelope, runtimeContext);
+                return {
+                    ok: true
+                };
+            } catch (error) {
+                const failedEnvelope = buildFailedEnvelope({
+                    runtimeError: error,
+                    eventEnvelope: envelope
+                });
+                emitErrorHooks({
+                    runtimeError: error,
+                    eventEnvelope: failedEnvelope,
+                    runtimeContext
+                });
+                return {
+                    ok: false,
+                    error: failedEnvelope.error.message
+                };
+            }
+        };
+    const createEmitSend = ({ runtimeContext, roomName })=>async (emitInput)=>{
+            const envelope = buildEnvelope({
+                emitInput,
+                fallbackStatus: 'sending',
+                roomName
+            });
+            try {
+                await runSend(envelope, runtimeContext);
+                return {
+                    ok: true
+                };
+            } catch (error) {
+                const failedEnvelope = buildFailedEnvelope({
+                    runtimeError: error,
+                    eventEnvelope: envelope
+                });
+                emitErrorHooks({
+                    runtimeError: error,
+                    eventEnvelope: failedEnvelope,
+                    runtimeContext
+                });
+                return {
+                    ok: false,
+                    error: failedEnvelope.error.message
+                };
+            }
+        };
+    const createEmitEvent = (input)=>async (eventInput)=>createEmitSend(input)(eventInput);
+    const createContext = (roomName)=>{
+        const runtimeContext = {};
+        const createEmitInput = {
+            runtimeContext,
+            roomName
+        };
+        runtimeContext.emitReceive = createEmitReceive(createEmitInput);
+        runtimeContext.emitSend = createEmitSend(createEmitInput);
+        runtimeContext.emitError = createEmitError(createEmitInput);
+        runtimeContext.emitEvent = createEmitEvent(createEmitInput);
+        runtimeContext.room = (nextRoomName)=>createContext(nextRoomName);
+        runtimeContext.state = state;
+        return runtimeContext;
+    };
+    const baseContext = createContext();
+    const registry = {
+        emitReceive: baseContext.emitReceive,
+        emitSend: baseContext.emitSend,
+        emitError: baseContext.emitError,
+        onReceive,
+        onSend,
+        onError,
+        state
+    };
+    modules.forEach((mod)=>{
+        mod.register(registry);
+    });
+};
+export { runtime };

package/dist/runtime.spec.cjs

@@ -0,0 +1,280 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const external_runtime_cjs_namespaceObject = require("./runtime.cjs");
+const index_cjs_namespaceObject = require("./testing/mocks/index.cjs");
+const getRegistryFromModule = (moduleMock)=>{
+    const call = moduleMock.register.mock.calls[0];
+    if (!call) throw new Error('runtime module should receive a registry during startup');
+    return call[0];
+};
+(0, external_vitest_namespaceObject.describe)('runtime()', ()=>{
+    (0, external_vitest_namespaceObject.beforeAll)(()=>{
+        external_vitest_namespaceObject.vi.useRealTimers();
+    });
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        external_vitest_namespaceObject.vi.clearAllTimers();
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        external_vitest_namespaceObject.vi.clearAllTimers();
+    });
+    (0, external_vitest_namespaceObject.afterAll)(()=>{
+        external_vitest_namespaceObject.vi.restoreAllMocks();
+    });
+    (0, external_vitest_namespaceObject.describe)('happy', ()=>{
+        (0, external_vitest_namespaceObject.it)('should register runtime registry when runtime starts with module input', ()=>{
+            const moduleMock = (0, index_cjs_namespaceObject.createRuntimeModuleMock)();
+            (0, external_runtime_cjs_namespaceObject.runtime)(moduleMock);
+            (0, external_vitest_namespaceObject.expect)(moduleMock.register).toHaveBeenCalledTimes(1);
+            const registry = getRegistryFromModule(moduleMock);
+            (0, external_vitest_namespaceObject.expect)(typeof registry.emitReceive).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof registry.emitSend).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof registry.emitError).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof registry.onReceive).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof registry.onSend).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof registry.onError).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof registry.state.get).toBe('function');
+            (0, external_vitest_namespaceObject.expect)(typeof registry.state.set).toBe('function');
+        });
+        (0, external_vitest_namespaceObject.it)('should register runtime registry when runtime starts with modules array input', ()=>{
+            const moduleMock = (0, index_cjs_namespaceObject.createRuntimeModuleMock)();
+            (0, external_runtime_cjs_namespaceObject.runtime)({
+                modules: [
+                    moduleMock
+                ]
+            });
+            (0, external_vitest_namespaceObject.expect)(moduleMock.register).toHaveBeenCalledTimes(1);
+            (0, external_vitest_namespaceObject.expect)(getRegistryFromModule(moduleMock)).toBeDefined();
+        });
+        (0, external_vitest_namespaceObject.it)('should execute receive hooks in registration order when emitReceive is called', async ()=>{
+            const hookOrder = [];
+            const firstHook = (0, index_cjs_namespaceObject.createRuntimeHookMock)(async (_envelope, _ctx, next)=>{
+                hookOrder.push('first');
+                return next({
+                    metadata: {
+                        first: true
+                    }
+                });
+            });
+            const secondHook = (0, index_cjs_namespaceObject.createRuntimeHookMock)(async (_envelope, _ctx, next)=>{
+                hookOrder.push('second');
+                return next();
+            });
+            const moduleMock = (0, index_cjs_namespaceObject.createRuntimeModuleMock)({
+                register: (registry)=>{
+                    registry.onReceive(firstHook);
+                    registry.onReceive(secondHook);
+                }
+            });
+            (0, external_runtime_cjs_namespaceObject.runtime)(moduleMock);
+            const registry = getRegistryFromModule(moduleMock);
+            const ack = await registry.emitReceive((0, index_cjs_namespaceObject.createEmitInputMock)({
+                event: 'receive.event'
+            }));
+            (0, external_vitest_namespaceObject.expect)(ack).toEqual({
+                ok: true
+            });
+            (0, external_vitest_namespaceObject.expect)(hookOrder).toEqual([
+                'first',
+                'second'
+            ]);
+            (0, external_vitest_namespaceObject.expect)(firstHook).toHaveBeenCalledTimes(1);
+            const firstEnvelope = firstHook.mock.calls[0]?.[0];
+            (0, external_vitest_namespaceObject.expect)(firstEnvelope.event).toBe('receive.event');
+            (0, external_vitest_namespaceObject.expect)(firstEnvelope.status).toBe('receiving');
+        });
+        (0, external_vitest_namespaceObject.it)('should execute onSend hooks when emitEvent is called from receive context', async ()=>{
+            const sendHook = (0, index_cjs_namespaceObject.createRuntimeHookMock)((envelope, _ctx, next)=>next(envelope));
+            const moduleMock = (0, index_cjs_namespaceObject.createRuntimeModuleMock)({
+                register: (registry)=>{
+                    registry.onReceive(async (_envelope, ctx, next)=>{
+                        await ctx.emitEvent((0, index_cjs_namespaceObject.createEmitInputMock)({
+                            event: 'nested.send'
+                        }));
+                        return next();
+                    });
+                    registry.onSend(sendHook);
+                }
+            });
+            (0, external_runtime_cjs_namespaceObject.runtime)(moduleMock);
+            const registry = getRegistryFromModule(moduleMock);
+            const ack = await registry.emitReceive((0, index_cjs_namespaceObject.createEmitInputMock)({
+                event: 'root.receive'
+            }));
+            (0, external_vitest_namespaceObject.expect)(ack).toEqual({
+                ok: true
+            });
+            (0, external_vitest_namespaceObject.expect)(sendHook).toHaveBeenCalledTimes(1);
+            const sendEnvelope = sendHook.mock.calls[0]?.[0];
+            (0, external_vitest_namespaceObject.expect)(sendEnvelope.event).toBe('nested.send');
+            (0, external_vitest_namespaceObject.expect)(sendEnvelope.status).toBe('sending');
+        });
+        (0, external_vitest_namespaceObject.it)('should include room metadata when room context emits send event', async ()=>{
+            const sendHook = (0, index_cjs_namespaceObject.createRuntimeHookMock)((envelope, _ctx, next)=>next(envelope));
+            const moduleMock = (0, index_cjs_namespaceObject.createRuntimeModuleMock)({
+                register: (registry)=>{
+                    registry.onReceive(async (_envelope, ctx, next)=>{
+                        await ctx.room('team-alpha').emitSend((0, index_cjs_namespaceObject.createEmitInputMock)({
+                            event: 'room.send'
+                        }));
+                        return next();
+                    });
+                    registry.onSend(sendHook);
+                }
+            });
+            (0, external_runtime_cjs_namespaceObject.runtime)(moduleMock);
+            const registry = getRegistryFromModule(moduleMock);
+            const ack = await registry.emitReceive((0, index_cjs_namespaceObject.createEmitInputMock)({
+                event: 'root.receive'
+            }));
+            (0, external_vitest_namespaceObject.expect)(ack).toEqual({
+                ok: true
+            });
+            const sendEnvelope = sendHook.mock.calls[0]?.[0];
+            (0, external_vitest_namespaceObject.expect)(sendEnvelope.metadata).toEqual({
+                room: 'team-alpha'
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should stop calling receive hook when unsubscribe is executed', async ()=>{
+            const receiveHook = (0, index_cjs_namespaceObject.createRuntimeHookMock)((_envelope, _ctx, next)=>next());
+            const moduleMock = (0, index_cjs_namespaceObject.createRuntimeModuleMock)({
+                register: (registry)=>{
+                    const subscription = registry.onReceive(receiveHook);
+                    subscription.unsub();
+                }
+            });
+            (0, external_runtime_cjs_namespaceObject.runtime)(moduleMock);
+            const registry = getRegistryFromModule(moduleMock);
+            const ack = await registry.emitReceive((0, index_cjs_namespaceObject.createEmitInputMock)({
+                event: 'receive.event'
+            }));
+            (0, external_vitest_namespaceObject.expect)(ack).toEqual({
+                ok: true
+            });
+            (0, external_vitest_namespaceObject.expect)(receiveHook).not.toHaveBeenCalled();
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)('sad', ()=>{
+        (0, external_vitest_namespaceObject.it)('should return failed ack and call onError when receive hook throws', async ()=>{
+            const errorHook = external_vitest_namespaceObject.vi.fn();
+            const moduleMock = (0, index_cjs_namespaceObject.createRuntimeModuleMock)({
+                register: (registry)=>{
+                    registry.onReceive(()=>{
+                        throw new Error('receive failed');
+                    });
+                    registry.onError(errorHook);
+                }
+            });
+            (0, external_runtime_cjs_namespaceObject.runtime)(moduleMock);
+            const registry = getRegistryFromModule(moduleMock);
+            const ack = await registry.emitReceive((0, index_cjs_namespaceObject.createEmitInputMock)({
+                event: 'receive.event'
+            }));
+            (0, external_vitest_namespaceObject.expect)(ack).toEqual({
+                ok: false,
+                error: 'receive failed'
+            });
+            (0, external_vitest_namespaceObject.expect)(errorHook).toHaveBeenCalledTimes(1);
+            const errorEnvelope = errorHook.mock.calls[0]?.[1];
+            (0, external_vitest_namespaceObject.expect)(errorEnvelope.status).toBe('receiving');
+            (0, external_vitest_namespaceObject.expect)(errorEnvelope.error?.message).toBe('receive failed');
+        });
+        (0, external_vitest_namespaceObject.it)('should return failed ack and merged context when send hook throws with context payload', async ()=>{
+            const errorHook = external_vitest_namespaceObject.vi.fn();
+            const moduleMock = (0, index_cjs_namespaceObject.createRuntimeModuleMock)({
+                register: (registry)=>{
+                    registry.onSend(()=>{
+                        throw {
+                            message: 'send failed',
+                            context: {
+                                source: 'send-hook'
+                            }
+                        };
+                    });
+                    registry.onError(errorHook);
+                }
+            });
+            (0, external_runtime_cjs_namespaceObject.runtime)(moduleMock);
+            const registry = getRegistryFromModule(moduleMock);
+            const ack = await registry.emitSend((0, index_cjs_namespaceObject.createEmitInputMock)({
+                event: 'send.event',
+                context: {
+                    requestId: 'req-1'
+                }
+            }));
+            (0, external_vitest_namespaceObject.expect)(ack).toEqual({
+                ok: false,
+                error: 'send failed'
+            });
+            (0, external_vitest_namespaceObject.expect)(errorHook).toHaveBeenCalledTimes(1);
+            const errorEnvelope = errorHook.mock.calls[0]?.[1];
+            (0, external_vitest_namespaceObject.expect)(errorEnvelope.context).toEqual({
+                requestId: 'req-1',
+                source: 'send-hook'
+            });
+        });
+        (0, external_vitest_namespaceObject.it)('should call onError with unknown fallback when emitError input has no error', async ()=>{
+            const errorHook = external_vitest_namespaceObject.vi.fn();
+            const moduleMock = (0, index_cjs_namespaceObject.createRuntimeModuleMock)({
+                register: (registry)=>{
+                    registry.onError(errorHook);
+                }
+            });
+            (0, external_runtime_cjs_namespaceObject.runtime)(moduleMock);
+            const registry = getRegistryFromModule(moduleMock);
+            const ack = await registry.emitError((0, index_cjs_namespaceObject.createEmitInputMock)({
+                event: 'error.event',
+                payload: new Uint8Array([
+                    1
+                ])
+            }));
+            (0, external_vitest_namespaceObject.expect)(ack).toEqual({
+                ok: true
+            });
+            (0, external_vitest_namespaceObject.expect)(errorHook).toHaveBeenCalledTimes(1);
+            const runtimeError = errorHook.mock.calls[0]?.[0];
+            const errorEnvelope = errorHook.mock.calls[0]?.[1];
+            (0, external_vitest_namespaceObject.expect)(runtimeError.message).toBe('Unknown error');
+            (0, external_vitest_namespaceObject.expect)(errorEnvelope.error?.message).toBe('Unknown error');
+        });
+        (0, external_vitest_namespaceObject.it)('should throw input error when emit input has neither payload nor error', async ()=>{
+            const moduleMock = (0, index_cjs_namespaceObject.createRuntimeModuleMock)();
+            (0, external_runtime_cjs_namespaceObject.runtime)(moduleMock);
+            const registry = getRegistryFromModule(moduleMock);
+            const invalidInput = {
+                event: 'invalid.event'
+            };
+            await (0, external_vitest_namespaceObject.expect)(registry.emitReceive(invalidInput)).rejects.toThrow('Emit input must contain payload or error.');
+        });
+        (0, external_vitest_namespaceObject.it)('should continue onError chain when one error handler throws', async ()=>{
+            const failingErrorHook = external_vitest_namespaceObject.vi.fn(()=>{
+                throw new Error('secondary error');
+            });
+            const succeedingErrorHook = external_vitest_namespaceObject.vi.fn();
+            const moduleMock = (0, index_cjs_namespaceObject.createRuntimeModuleMock)({
+                register: (registry)=>{
+                    registry.onReceive(()=>{
+                        throw new Error('receive failed');
+                    });
+                    registry.onError(failingErrorHook);
+                    registry.onError(succeedingErrorHook);
+                }
+            });
+            (0, external_runtime_cjs_namespaceObject.runtime)(moduleMock);
+            const registry = getRegistryFromModule(moduleMock);
+            const ack = await registry.emitReceive((0, index_cjs_namespaceObject.createEmitInputMock)({
+                event: 'receive.event'
+            }));
+            (0, external_vitest_namespaceObject.expect)(ack).toEqual({
+                ok: false,
+                error: 'receive failed'
+            });
+            (0, external_vitest_namespaceObject.expect)(failingErrorHook).toHaveBeenCalledTimes(1);
+            (0, external_vitest_namespaceObject.expect)(succeedingErrorHook).toHaveBeenCalledTimes(1);
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/runtime.spec.d.ts

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