@livon/runtime 0.27.0-rc.3 → 0.28.0-rc.4

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LIVON contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,8 +1,169 @@
+<!-- Generated from website/docs/packages/*.md. Do not edit directly. -->
+
 # @livon/runtime
 
-Package docs (GitHub Pages):
-- https://live-input-vector-output-node.github.io/livon-ts/docs/packages/runtime
 
-License:
-- MIT
-- Root license text: `../../LIZENZ.md`
+[![npm](https://img.shields.io/npm/v/%40livon%2Fruntime)](https://www.npmjs.com/package/@livon/runtime)
+[![dependencies](https://img.shields.io/librariesio/release/npm/%40livon%2Fruntime?label=dependencies)](https://libraries.io/npm/%40livon%2Fruntime)
+[![code quality](https://img.shields.io/github/actions/workflow/status/live-input-vector-output-node/livon-ts/code-quality.yml?branch=main&label=code%20quality)](https://github.com/live-input-vector-output-node/livon-ts/actions/workflows/code-quality.yml)
+[![package size](https://img.shields.io/npm/unpacked-size/%40livon%2Fruntime?label=package%20size)](https://www.npmjs.com/package/@livon/runtime)
+[![license](https://img.shields.io/github/license/live-input-vector-output-node/livon-ts)](https://github.com/live-input-vector-output-node/livon-ts)
+
+## Install
+
+```sh
+pnpm add @livon/runtime
+```
+
+## Purpose
+
+[@livon/runtime](https://livon.tech/docs/packages/runtime) is the event pipeline core. It composes modules and executes hook chains for:
+
+- `onReceive`
+- `onSend`
+- `onError`
+
+## Best for
+
+Use this package when you need deterministic event flow orchestration across transports and schema execution.
+
+## Basic usage
+
+```ts
+import {runtime} from '@livon/runtime';
+
+runtime(moduleA, moduleB);
+```
+
+## Parameters
+
+`runtime(...modules)`:
+
+- `modules` (`RuntimeModule[]`): ordered module list to register and execute.
+
+`RuntimeModule`:
+
+- `name` (`string`): module identifier for debugging and traceability.
+- `register` (`(registry) => void`): setup callback where hooks are registered.
+
+## Execution order (important)
+
+Runtime module order defines execution order.
+
+```ts
+runtime(moduleA, moduleB, moduleC);
+```
+
+Hook chains run from left to right:
+
+1. `moduleA`
+2. `moduleB`
+3. `moduleC`
+
+This applies to `onReceive`, `onSend`, and `onError` registration order.
+
+## Writing a runtime module
+
+```ts
+import type {RuntimeModule} from '@livon/runtime';
+
+const traceModule: RuntimeModule = {
+  name: 'trace',
+  register: ({onReceive, onSend, onError}) => {
+    onReceive(async (envelope, ctx, next) => {
+      return next();
+    });
+
+    onSend(async (envelope, ctx, next) => {
+      return next();
+    });
+
+    onError((error, envelope, ctx) => {
+      // error handling
+    });
+  },
+};
+```
+
+### Hook callback parameters
+
+`onReceive((envelope, ctx, next) => ...)` and `onSend((envelope, ctx, next) => ...)`:
+
+- `envelope` (`EventEnvelope`): current event envelope flowing through the chain.
+- `ctx` (`RuntimeContext`): emit APIs, room-scoped context, and shared runtime state.
+- `next` (`(update?) => Promise<EventEnvelope>`): continue chain and optionally merge envelope updates.
+
+`onError((error, envelope, ctx) => ...)`:
+
+- `error` (`unknown`): thrown/normalized error from runtime chain.
+- `envelope` (`EventEnvelope`): failed envelope snapshot.
+- `ctx` (`RuntimeContext`): same runtime context for recovery/reporting logic.
+
+## Runtime context model
+
+`RuntimeContext` (`ctx` in hooks) is runtime control surface.  
+It is separate from `envelope.context` (event data flowing through the pipeline).
+
+```mermaid
+flowchart TD
+  Runtime["runtime(...)"] --> Ctx["RuntimeContext"]
+  Ctx --> EmitReceive["emitReceive(input)"]
+  Ctx --> EmitSend["emitSend(input)"]
+  Ctx --> EmitError["emitError(input)"]
+  Ctx --> EmitEvent["emitEvent(input)"]
+  Ctx --> Room["room(name) -> RuntimeContext"]
+  Ctx --> State["state.get/set shared map"]
+  EmitReceive --> Envelope["EventEnvelope"]
+  EmitSend --> Envelope
+  EmitError --> Envelope
+  EmitEvent --> Envelope
+```
+
+```mermaid
+sequenceDiagram
+  participant M1 as moduleA
+  participant R as runtime
+  participant M2 as moduleB
+
+  M1->>R: next({ context: { traceId: "t-1" } })
+  R->>R: mergeContext(base, update)
+  R->>M2: onReceive(... envelope.context includes traceId)
+  M2->>R: throw { message, context: { phase: "auth" } }
+  R->>R: buildFailedEnvelope + mergeContext(error.context)
+```
+
+Rules:
+
+- `ctx.room(name)` creates a room-scoped context that injects `metadata.room`.
+- `ctx.state` is shared across room scopes for one runtime instance.
+- `envelope.context` is immutable hook input; use `next(update)` to merge context changes.
+
+## Emit APIs in runtime context
+
+Inside hooks/modules you can emit:
+
+- `ctx.emitReceive(...)`
+- `ctx.emitSend(...)`
+- `ctx.emitError(...)`
+- `ctx.emitEvent(...)` (alias to send path)
+
+You can also scope to rooms via `ctx.room(roomId)`.
+
+### Emit input parameters
+
+`emitReceive`, `emitSend`, `emitError`, `emitEvent` all accept one `EmitInput`:
+
+- `event` (`string`, required): event name.
+- `payload` (`Uint8Array`, required unless `error` is provided): transport payload.
+- `error` (`EventError`, required unless `payload` is provided): error payload.
+- `id` (`string`, optional): envelope id override.
+- `status` (`'sending' | 'receiving' | 'failed'`, optional): explicit status override.
+- `metadata` (`Record<string, unknown>`, optional): routing/correlation metadata.
+- `context` (`RuntimeEventContext`, optional): module context object merged across pipeline.
+
+## Related pages
+
+- [Validated by Default](https://livon.tech/docs/core/validated-by-default)
+- [@livon/schema](https://livon.tech/docs/packages/schema)
+- [Runtime Design](https://livon.tech/docs/technical/runtime-design)
+- [Event Flow](https://livon.tech/docs/technical/event-flow)

package/THIRD_PARTY_NOTICES.md

@@ -1,28 +1 @@
-Third-Party Notices
-
-This package includes third-party software. The following licenses apply:
-
-------------------------------------------------------------------------------
-msgpackr
-------------------------------------------------------------------------------
-License: MIT
-
-Copyright (c) 2020 Kris Zyp
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+No third-party notices are required for this package at this time.

package/dist/index.cjs

@@ -1 +1,36 @@
-"use strict";const __rslib_import_meta_url__="u"<typeof document?new(require("url".replace("",""))).URL("file:"+__filename).href:document.currentScript&&document.currentScript.src||new URL("main.js",document.baseURI).href;var __webpack_require__={};__webpack_require__.d=(e,_)=>{for(var r in _)__webpack_require__.o(_,r)&&!__webpack_require__.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:_[r]})},__webpack_require__.o=(e,_)=>Object.prototype.hasOwnProperty.call(e,_),__webpack_require__.r=e=>{"u">typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var __webpack_exports__={};__webpack_require__.r(__webpack_exports__),__webpack_require__.d(__webpack_exports__,{runtime:()=>external_runtime_cjs_namespaceObject.runtime});const external_runtime_cjs_namespaceObject=require("./runtime.cjs");for(var __rspack_i in exports.runtime=__webpack_exports__.runtime,__webpack_exports__)-1===["runtime"].indexOf(__rspack_i)&&(exports[__rspack_i]=__webpack_exports__[__rspack_i]);Object.defineProperty(exports,"__esModule",{value:!0});
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    runtime: ()=>external_runtime_cjs_namespaceObject.runtime
+});
+const external_runtime_cjs_namespaceObject = require("./runtime.cjs");
+exports.runtime = __webpack_exports__.runtime;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runtime"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * Public package entrypoint for `@livon/runtime`.
  *
- * @see https://live-input-vector-output-node.github.io/livon-ts/docs/packages/runtime
+ * @see https://livon.tech/docs/packages/runtime
  */
 export { runtime } from './runtime.js';
 export type { RuntimeEventContext, EventStatus, EventError, EventEnvelopeBase, EventEnvelopePayload, EventEnvelopeError, EventEnvelope, EventAck, EmitInputBase, EmitInputPayload, EmitInputError, EmitInput, EmitEvent, EmitReceive, EmitSend, EmitError, RoomSelector, StateGet, StateSet, RuntimeState, RuntimeContext, RuntimeHook, RuntimeModule, RuntimeOnError, RuntimeInput, RuntimeModuleRegister, RuntimeHookRegister, RuntimeOnErrorRegister, RuntimeHookSubscription, RuntimeUnsubscribe, RuntimeRegistry, RuntimeStart, PartialEventEnvelopeBase, PartialEventEnvelopePayload, PartialEventEnvelopeError, PartialEventEnvelopeEmpty, PartialEventEnvelope, } from './types.js';

package/dist/index.js

@@ -1 +1,2 @@
-import{runtime as r}from"./runtime.js";export{r as runtime};
+import { runtime } from "./runtime.js";
+export { runtime };

package/dist/runtime.cjs

@@ -1 +1,372 @@
-"use strict";const __rslib_import_meta_url__="u"<typeof document?new(require("url".replace("",""))).URL("file:"+__filename).href:document.currentScript&&document.currentScript.src||new URL("main.js",document.baseURI).href;var __webpack_require__={};__webpack_require__.d=(e,r)=>{for(var t in r)__webpack_require__.o(r,t)&&!__webpack_require__.o(e,t)&&Object.defineProperty(e,t,{enumerable:!0,get:r[t]})},__webpack_require__.o=(e,r)=>Object.prototype.hasOwnProperty.call(e,r),__webpack_require__.r=e=>{"u">typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var __webpack_exports__={};__webpack_require__.r(__webpack_exports__),__webpack_require__.d(__webpack_exports__,{runtime:()=>runtime});const createHookStore=()=>({onReceive:[],onSend:[],onError:[]}),createState=()=>{let e=new Map;return{get:r=>e.get(r),set:(r,t)=>{e.set(r,t)}}},mergeMetadata=(e,r)=>{if(e||r)return{...e??{},...r??{}}};let fallbackEventIdCounter=0;const createEventId=()=>{let e=globalThis.crypto;return e?.randomUUID?e.randomUUID():(fallbackEventIdCounter+=1,`evt_${Date.now().toString(36)}_${fallbackEventIdCounter.toString(36)}`)},isContextRecord=e=>"object"==typeof e&&null!==e&&!Array.isArray(e),contextRecordFrom=e=>{if(e&&isContextRecord(e))return e},errorFromUnknown=e=>{if(e instanceof Error){let r=isContextRecord(e.context)?e.context:void 0;return{message:e.message,...e.name?{name:e.name}:{},...e.stack?{stack:e.stack}:{},...r?{context:r}:{}}}if("string"==typeof e)return{message:e};if("object"==typeof e&&null!==e){let r="string"==typeof e.message?e.message:"Unknown error",t="string"==typeof e.name?e.name:void 0,o="string"==typeof e.stack?e.stack:void 0,n=isContextRecord(e.context)?e.context:void 0;return{message:r,...t?{name:t}:{},...o?{stack:o}:{},...n?{context:n}:{}}}return{message:"Unknown error"}},registerHook=e=>r=>(e.push(r),{unsub:()=>{let t=e.indexOf(r);t>=0&&e.splice(t,1)}}),registerErrorHook=e=>r=>(e.push(r),{unsub:()=>{let t=e.indexOf(r);t>=0&&e.splice(t,1)}}),runtime=(e,...r)=>{let t=("modules"in e?e:{modules:[e,...r]}).modules,o=createState(),n=createHookStore(),a=registerHook(n.onReceive),i=registerHook(n.onSend),s=registerErrorHook(n.onError),c=({runtimeError:e,eventEnvelope:r,runtimeContext:t})=>{n.onError.forEach(o=>{try{o(e,r,t)}catch{}})},_=(e,r)=>{let t=contextRecordFrom(e),o=contextRecordFrom(r);if(t||o)return{...t??{},...o??{}}},u=({emitInput:e,fallbackStatus:r,roomName:t})=>{let{id:o,event:n,status:a,metadata:i,context:s,payload:c,error:_}=e,u=mergeMetadata(t?{room:t}:void 0,i),l=o??createEventId();if(void 0===c&&void 0===_)throw Error("Emit input must contain payload or error.");let d={id:l,event:n,status:a??r,metadata:u,context:s};return void 0!==c&&void 0!==_?{...d,payload:c,error:_}:void 0!==c?{...d,payload:c}:{...d,error:_}},l=({runtimeError:e,eventEnvelope:r})=>{let t=errorFromUnknown(e),o=_(r.context,t.context);return{...r,error:t,context:o}},d=e=>{let r,t=e.hookChain[e.hookIndex];if(!t)return Promise.resolve(e.eventEnvelope);let o=!1,n=t(e.eventEnvelope,e.runtimeContext,t=>(o=!0,r=d({hookChain:e.hookChain,hookIndex:e.hookIndex+1,eventEnvelope:((e,r)=>{if(!r)return e;let t=r.id??e.id,o=r.event??e.event,n=r.status??e.status,a=mergeMetadata(e.metadata,r.metadata),i=_(e.context,r.context),s=r.payload??e.payload,c=r.error??e.error;if(void 0===s&&void 0===c)throw Error("Event envelope must contain payload or error.");let u={...e,id:t,event:o,status:n,metadata:a,context:i};return void 0!==s&&void 0!==c?{...u,payload:s,error:c}:void 0!==s?{...u,payload:s}:{...u,error:c}})(e.eventEnvelope,t),runtimeContext:e.runtimeContext})));return void 0===n&&o?r??Promise.resolve(e.eventEnvelope):Promise.resolve(n).then(t=>t??r??e.eventEnvelope)},m=({runtimeContext:e,roomName:r})=>async t=>{let o=u({emitInput:t,fallbackStatus:"sending",roomName:r});try{return await d({hookChain:n.onSend,hookIndex:0,eventEnvelope:o,runtimeContext:e}),{ok:!0}}catch(t){let r=l({runtimeError:t,eventEnvelope:o});return c({runtimeError:t,eventEnvelope:r,runtimeContext:e}),{ok:!1,error:r.error.message}}},p=e=>{let r={},t={runtimeContext:r,roomName:e};return r.emitReceive=(({runtimeContext:e,roomName:r})=>async t=>{let o=u({emitInput:t,fallbackStatus:"receiving",roomName:r});try{return await d({hookChain:n.onReceive,hookIndex:0,eventEnvelope:o,runtimeContext:e}),{ok:!0}}catch(t){let r=l({runtimeError:t,eventEnvelope:o});return c({runtimeError:t,eventEnvelope:r,runtimeContext:e}),{ok:!1,error:r.error.message}}})(t),r.emitSend=m(t),r.emitError=(({runtimeContext:e,roomName:r})=>async t=>{let o=u({emitInput:t,fallbackStatus:"sending",roomName:r}),n=o.error??{message:"Unknown error"},a={...o,error:n};return c({runtimeError:n,eventEnvelope:a,runtimeContext:e}),{ok:!0}})(t),r.emitEvent=async e=>m(t)(e),r.room=e=>p(e),r.state=o,r},v=p(),k={emitReceive:v.emitReceive,emitSend:v.emitSend,emitError:v.emitError,onReceive:a,onSend:i,onError:s,state:o};t.forEach(e=>{e.register(k)})};for(var __rspack_i in exports.runtime=__webpack_exports__.runtime,__webpack_exports__)-1===["runtime"].indexOf(__rspack_i)&&(exports[__rspack_i]=__webpack_exports__[__rspack_i]);Object.defineProperty(exports,"__esModule",{value:!0});
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    runtime: ()=>runtime
+});
+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);
+    });
+};
+exports.runtime = __webpack_exports__.runtime;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runtime"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/runtime.d.ts

@@ -5,7 +5,7 @@ import type { RuntimeStart } from './types.js';
  * @remarks
  * Parameter and return types are defined in the TypeScript signature.
  *
- * @see https://live-input-vector-output-node.github.io/livon-ts/docs/packages/runtime
+ * @see https://livon.tech/docs/packages/runtime
  *
  * @example
  * const result = runtime(undefined as never);

package/dist/runtime.js

@@ -1 +1,338 @@
-let e=(e,t)=>{if(e||t)return{...e??{},...t??{}}},t=0,r=e=>"object"==typeof e&&null!==e&&!Array.isArray(e),o=e=>{if(e&&r(e))return e},n=e=>t=>(e.push(t),{unsub:()=>{let r=e.indexOf(t);r>=0&&e.splice(r,1)}}),i=(i,...a)=>{let s,l,v=("modules"in i?i:{modules:[i,...a]}).modules,m=(s=new Map,{get:e=>s.get(e),set:(e,t)=>{s.set(e,t)}}),u=[],d=[],c=[],p=n(u),E=n(d),h=(l=c,e=>(l.push(e),{unsub:()=>{let t=l.indexOf(e);t>=0&&l.splice(t,1)}})),k=({runtimeError:e,eventEnvelope:t,runtimeContext:r})=>{c.forEach(o=>{try{o(e,t,r)}catch{}})},f=(e,t)=>{let r=o(e),n=o(t);if(r||n)return{...r??{},...n??{}}},x=({emitInput:r,fallbackStatus:o,roomName:n})=>{let i,{id:a,event:s,status:l,metadata:v,context:m,payload:u,error:d}=r,c=e(n?{room:n}:void 0,v),p=a??(i=globalThis.crypto,i?.randomUUID?i.randomUUID():(t+=1,`evt_${Date.now().toString(36)}_${t.toString(36)}`));if(void 0===u&&void 0===d)throw Error("Emit input must contain payload or error.");let E={id:p,event:s,status:l??o,metadata:c,context:m};return void 0!==u&&void 0!==d?{...E,payload:u,error:d}:void 0!==u?{...E,payload:u}:{...E,error:d}},g=({runtimeError:e,eventEnvelope:t})=>{let o=(e=>{if(e instanceof Error){let t=r(e.context)?e.context:void 0;return{message:e.message,...e.name?{name:e.name}:{},...e.stack?{stack:e.stack}:{},...t?{context:t}:{}}}if("string"==typeof e)return{message:e};if("object"==typeof e&&null!==e){let t="string"==typeof e.message?e.message:"Unknown error",o="string"==typeof e.name?e.name:void 0,n="string"==typeof e.stack?e.stack:void 0,i=r(e.context)?e.context:void 0;return{message:t,...o?{name:o}:{},...n?{stack:n}:{},...i?{context:i}:{}}}return{message:"Unknown error"}})(e),n=f(t.context,o.context);return{...t,error:o,context:n}},y=t=>{let r,o=t.hookChain[t.hookIndex];if(!o)return Promise.resolve(t.eventEnvelope);let n=!1,i=o(t.eventEnvelope,t.runtimeContext,o=>(n=!0,r=y({hookChain:t.hookChain,hookIndex:t.hookIndex+1,eventEnvelope:((t,r)=>{if(!r)return t;let o=r.id??t.id,n=r.event??t.event,i=r.status??t.status,a=e(t.metadata,r.metadata),s=f(t.context,r.context),l=r.payload??t.payload,v=r.error??t.error;if(void 0===l&&void 0===v)throw Error("Event envelope must contain payload or error.");let m={...t,id:o,event:n,status:i,metadata:a,context:s};return void 0!==l&&void 0!==v?{...m,payload:l,error:v}:void 0!==l?{...m,payload:l}:{...m,error:v}})(t.eventEnvelope,o),runtimeContext:t.runtimeContext})));return void 0===i&&n?r??Promise.resolve(t.eventEnvelope):Promise.resolve(i).then(e=>e??r??t.eventEnvelope)},C=({runtimeContext:e,roomName:t})=>async r=>{let o=x({emitInput:r,fallbackStatus:"sending",roomName:t});try{return await y({hookChain:d,hookIndex:0,eventEnvelope:o,runtimeContext:e}),{ok:!0}}catch(r){let t=g({runtimeError:r,eventEnvelope:o});return k({runtimeError:r,eventEnvelope:t,runtimeContext:e}),{ok:!1,error:t.error.message}}},w=e=>{let t={},r={runtimeContext:t,roomName:e};return t.emitReceive=(({runtimeContext:e,roomName:t})=>async r=>{let o=x({emitInput:r,fallbackStatus:"receiving",roomName:t});try{return await y({hookChain:u,hookIndex:0,eventEnvelope:o,runtimeContext:e}),{ok:!0}}catch(r){let t=g({runtimeError:r,eventEnvelope:o});return k({runtimeError:r,eventEnvelope:t,runtimeContext:e}),{ok:!1,error:t.error.message}}})(r),t.emitSend=C(r),t.emitError=(({runtimeContext:e,roomName:t})=>async r=>{let o=x({emitInput:r,fallbackStatus:"sending",roomName:t}),n=o.error??{message:"Unknown error"},i={...o,error:n};return k({runtimeError:n,eventEnvelope:i,runtimeContext:e}),{ok:!0}})(r),t.emitEvent=async e=>C(r)(e),t.room=e=>w(e),t.state=m,t},b=w(),S={emitReceive:b.emitReceive,emitSend:b.emitSend,emitError:b.emitError,onReceive:p,onSend:E,onError:h,state:m};v.forEach(e=>{e.register(S)})};export{i as runtime};
+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/types.cjs

@@ -1 +1,18 @@
-"use strict";const __rslib_import_meta_url__="u"<typeof document?new(require("url".replace("",""))).URL("file:"+__filename).href:document.currentScript&&document.currentScript.src||new URL("main.js",document.baseURI).href;var __webpack_require__={};__webpack_require__.r=e=>{"u">typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var __webpack_exports__={};for(var __rspack_i in __webpack_require__.r(__webpack_exports__),__webpack_exports__)exports[__rspack_i]=__webpack_exports__[__rspack_i];Object.defineProperty(exports,"__esModule",{value:!0});
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/package.json

@@ -1,42 +1,43 @@
 {
   "name": "@livon/runtime",
-  "version": "0.27.0-rc.3",
+  "version": "0.28.0-rc.4",
   "private": false,
   "type": "module",
+  "description": "Deterministic event pipeline runtime for LIVON.",
   "publishConfig": {
     "access": "public"
   },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist",
     "README.md",
+    "LICENSE.md",
     "THIRD_PARTY_NOTICES.md"
   ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/live-input-vector-output-node/livon-ts.git",
+    "directory": "packages/runtime"
+  },
+  "homepage": "https://livon.tech/docs/packages/runtime",
+  "bugs": {
+    "url": "https://github.com/live-input-vector-output-node/livon-ts/issues"
+  },
+  "keywords": [
+    "livon",
+    "runtime",
+    "api",
+    "events",
+    "typescript"
+  ],
   "exports": {
     ".": {
-      "development": "./src/index.ts",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.cjs"
     }
-  },
-  "dependencies": {},
-  "devDependencies": {
-    "@rslib/core": "latest",
-    "@typescript-eslint/eslint-plugin": "8.54.0",
-    "@typescript-eslint/parser": "8.54.0",
-    "eslint": "9.0.0",
-    "typescript": "latest",
-    "vitest": "latest",
-    "@livon/config": "0.27.0-rc.3"
-  },
-  "scripts": {
-    "build": "rslib build",
-    "build:watch": "rslib dev",
-    "dev": "true",
-    "lint": "eslint .",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run -c vitest.unit.config.ts",
-    "test:unit": "vitest run -c vitest.unit.config.ts",
-    "test:integration": "vitest run -c vitest.integration.config.ts"
   }
 }