@livon/runtime 0.27.0-rc.3 → 0.27.0-rc.5

package/LICENCE.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,156 @@
 # @livon/runtime
 
-Package docs (GitHub Pages):
-- https://live-input-vector-output-node.github.io/livon-ts/docs/packages/runtime
+## Install
 
-License:
-- MIT
-- Root license text: `../../LIZENZ.md`
+```sh
+pnpm add @livon/runtime
+```
+
+## Purpose
+
+[@livon/runtime](https://live-input-vector-output-node.github.io/livon-ts/docs/packages/runtime) is the event pipeline core. It composes modules and executes hook chains for:
+
+- `onReceive`
+- `onSend`
+- `onError`
+
+## 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://live-input-vector-output-node.github.io/livon-ts/docs/core/validated-by-default)
+- [@livon/schema](https://live-input-vector-output-node.github.io/livon-ts/docs/packages/schema)
+- [Runtime Design](https://live-input-vector-output-node.github.io/livon-ts/docs/technical/runtime-design)
+- [Event Flow](https://live-input-vector-output-node.github.io/livon-ts/docs/technical/event-flow)

package/dist/index.cjs

@@ -1 +1,60 @@
-"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";
+const __rslib_import_meta_url__ = /*#__PURE__*/ (function () {
+  return typeof document === 'undefined'
+    ? new (require('url'.replace('', '')).URL)('file:' + __filename).href
+    : (document.currentScript && document.currentScript.src) ||
+      new URL('main.js', document.baseURI).href;
+})();
+;
+// The require scope
+var __webpack_require__ = {};
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  runtime: () => (/* reexport */ external_runtime_cjs_namespaceObject.runtime)
+});
+
+;// CONCATENATED MODULE: external "./runtime.cjs"
+const external_runtime_cjs_namespaceObject = require("./runtime.cjs");
+;// CONCATENATED MODULE: ./src/index.ts
+/**
+ * Public package entrypoint for `@livon/runtime`.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/packages/runtime
+ */ 
+
+exports.runtime = __webpack_exports__.runtime;
+for(var __rspack_i in __webpack_exports__) {
+  if(["runtime"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/index.js

@@ -1 +1,12 @@
-import{runtime as r}from"./runtime.js";export{r as runtime};
+import { runtime } from "./runtime.js";
+
+;// CONCATENATED MODULE: external "./runtime.js"
+
+;// CONCATENATED MODULE: ./src/index.ts
+/**
+ * Public package entrypoint for `@livon/runtime`.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/docs/packages/runtime
+ */ 
+
+export { runtime };

package/dist/mini/index.cjs

@@ -0,0 +1 @@
+"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});

package/dist/mini/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Public package entrypoint for `@livon/runtime`.
+ *
+ * @see https://live-input-vector-output-node.github.io/livon-ts/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';
+export type { RuntimeStart as RuntimeFactory } from './types.js';

package/dist/mini/index.js

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

package/dist/mini/runtime.cjs

@@ -0,0 +1 @@
+"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});

package/dist/mini/runtime.d.ts

@@ -0,0 +1,13 @@
+import type { RuntimeStart } from './types.js';
+/**
+ * runtime is part of the public LIVON API.
+ *
+ * @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
+ *
+ * @example
+ * const result = runtime(undefined as never);
+ */
+export declare const runtime: RuntimeStart;

package/dist/mini/runtime.js

@@ -0,0 +1 @@
+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};

package/dist/mini/types.cjs

@@ -0,0 +1 @@
+"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});

package/dist/mini/types.d.ts

@@ -0,0 +1,143 @@
+export interface RuntimeEventContext {
+}
+export type EventStatus = 'sending' | 'receiving' | 'failed';
+export interface EventError {
+    message: string;
+    name?: string;
+    stack?: string;
+    context?: Readonly<RuntimeEventContext>;
+}
+export interface EventEnvelopeBase {
+    id: string;
+    event: string;
+    status: EventStatus;
+    metadata?: Readonly<Record<string, unknown>>;
+    context?: RuntimeEventContext;
+}
+export interface EventEnvelopePayload extends EventEnvelopeBase {
+    payload: Uint8Array;
+    error?: EventError;
+}
+export interface EventEnvelopeError extends EventEnvelopeBase {
+    error: EventError;
+    payload?: Uint8Array;
+}
+export type EventEnvelope = EventEnvelopePayload | EventEnvelopeError;
+export interface EmitInputBase {
+    id?: string;
+    event: string;
+    status?: EventStatus;
+    metadata?: Readonly<Record<string, unknown>>;
+    context?: RuntimeEventContext;
+}
+export interface EmitInputPayload extends EmitInputBase {
+    payload: Uint8Array;
+    error?: EventError;
+}
+export interface EmitInputError extends EmitInputBase {
+    error: EventError;
+    payload?: Uint8Array;
+}
+export type EmitInput = EmitInputPayload | EmitInputError;
+export interface EventAck {
+    ok: boolean;
+    error?: string;
+    metadata?: Readonly<Record<string, unknown>>;
+}
+export interface EmitEvent {
+    (input: EmitInput): Promise<EventAck>;
+}
+export interface EmitReceive {
+    (input: EmitInput): Promise<EventAck>;
+}
+export interface EmitSend {
+    (input: EmitInput): Promise<EventAck>;
+}
+export interface EmitError {
+    (input: EmitInput): Promise<EventAck>;
+}
+export interface RoomSelector {
+    (name: string): RuntimeContext;
+}
+export interface StateGet {
+    <T = unknown>(key: string): T | undefined;
+}
+export interface StateSet {
+    <T = unknown>(key: string, value: T): void;
+}
+export interface RuntimeState {
+    get: StateGet;
+    set: StateSet;
+}
+export interface RuntimeContext {
+    emitEvent: EmitEvent;
+    emitReceive: EmitReceive;
+    emitSend: EmitSend;
+    emitError: EmitError;
+    room: RoomSelector;
+    state: RuntimeState;
+}
+export interface RuntimeNext {
+    (update?: PartialEventEnvelope): Promise<EventEnvelope>;
+}
+export interface RuntimeHook {
+    (envelope: EventEnvelope, ctx: RuntimeContext, next: RuntimeNext): Promise<EventEnvelope> | EventEnvelope;
+}
+export interface RuntimeModule {
+    name: string;
+    register: RuntimeModuleRegister;
+}
+export interface RuntimeOnError {
+    (error: unknown, envelope: EventEnvelope, ctx: RuntimeContext): void;
+}
+export interface RuntimeHookSubscription {
+    unsub: RuntimeUnsubscribe;
+}
+export interface RuntimeUnsubscribe {
+    (): void;
+}
+export interface RuntimeInput {
+    modules: readonly RuntimeModule[];
+}
+export interface RuntimeModuleRegister {
+    (registry: RuntimeRegistry): void;
+}
+export interface RuntimeHookRegister {
+    (hook: RuntimeHook): RuntimeHookSubscription;
+}
+export interface RuntimeOnErrorRegister {
+    (hook: RuntimeOnError): RuntimeHookSubscription;
+}
+export interface RuntimeRegistry {
+    emitReceive: EmitReceive;
+    emitSend: EmitSend;
+    emitError: EmitError;
+    onReceive: RuntimeHookRegister;
+    onSend: RuntimeHookRegister;
+    onError: RuntimeOnErrorRegister;
+    state: RuntimeState;
+}
+export interface PartialEventEnvelopeBase {
+    id?: string;
+    event?: string;
+    status?: EventStatus;
+    metadata?: Readonly<Record<string, unknown>>;
+    context?: RuntimeEventContext;
+}
+export interface PartialEventEnvelopePayload extends PartialEventEnvelopeBase {
+    payload?: Uint8Array;
+    error?: EventError;
+}
+export interface PartialEventEnvelopeError extends PartialEventEnvelopeBase {
+    error?: EventError;
+    payload?: Uint8Array;
+}
+export interface PartialEventEnvelopeEmpty extends PartialEventEnvelopeBase {
+    payload?: undefined;
+    error?: undefined;
+}
+export type PartialEventEnvelope = PartialEventEnvelopePayload | PartialEventEnvelopeError | PartialEventEnvelopeEmpty;
+export interface RuntimeStart {
+    (...modules: RuntimeModule[]): void;
+    (input: RuntimeInput): void;
+}