@livon/client 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,145 @@
+<!-- Generated from website/docs/packages/*.md. Do not edit directly. -->
+
 # @livon/client
 
-Package docs (GitHub Pages):
-- https://live-input-vector-output-node.github.io/livon-ts/docs/packages/client
 
-License:
-- MIT
-- Root license text: `../../LIZENZ.md`
+[![npm](https://img.shields.io/npm/v/%40livon%2Fclient)](https://www.npmjs.com/package/@livon/client)
+[![dependencies](https://img.shields.io/librariesio/release/npm/%40livon%2Fclient?label=dependencies)](https://libraries.io/npm/%40livon%2Fclient)
+[![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%2Fclient?label=package%20size)](https://www.npmjs.com/package/@livon/client)
+[![license](https://img.shields.io/github/license/live-input-vector-output-node/livon-ts)](https://github.com/live-input-vector-output-node/livon-ts)
+
+## Purpose
+
+[@livon/client](https://livon.tech/docs/packages/client) provides deterministic client interface execution and generated-client foundations.
+
+## Best for
+
+Use this package when frontend apps consume generated LIVON APIs and typed subscription handlers.
+
+Exports include:
+
+- `createClient`
+- `createClientModule`
+- `clientModule`
+
+## Generator sync policy
+
+Generated client surfaces and hover docs are built from the client generator.
+When generator output changes, docs must be updated in sync.
+
+- Rule source: `packages/client/PROMPT.md`
+- JSDoc reference: [SchemaDoc & Generated JSDoc](https://livon.tech/docs/core/schema-doc-and-generated-jsdoc)
+
+Current generated typing behavior to keep in sync:
+
+- `and(...)` schema nodes are emitted as TypeScript intersections (`Left & Right`).
+- If schema composition passes an explicit `name`, that name is used as the generated type name.
+
+### Central TypeScript surface template
+
+Generated interface and signature syntax is centralized in:
+
+- `packages/client/src/typeScriptSurfaceTemplate.ts`
+
+Use this file when TypeScript surface style should change globally (for example interface member syntax, callable signatures, or method/property signature formatting).
+This avoids editing many render call sites in `packages/client/src/generate.ts`.
+
+## Install
+
+```sh
+pnpm add @livon/client
+```
+
+## Runtime wiring (generated API path)
+
+```ts
+import {runtime} from '@livon/runtime';
+import {clientWsTransport} from '@livon/client-ws-transport';
+import {api} from './generated/api';
+
+runtime(
+  clientWsTransport({url: 'ws://127.0.0.1:3002/ws'}),
+  api,
+);
+```
+
+### Parameters in this example
+
+`clientWsTransport({...})`:
+
+- `url` (`string`): websocket endpoint used by client transport.
+
+`runtime(transport, api)`:
+
+- `transport` (`RuntimeModule`): client transport module.
+- `api` (`RuntimeModule`): generated client module built from server schema.
+
+## Subscription handling pattern
+
+```ts
+api({
+  onMessage: (payload, ctx) => {
+    payload.text;
+    ctx.state.get('lastMessage');
+  },
+});
+
+api.onMessage.off();
+```
+
+### Parameters in this example
+
+`api({...})`:
+
+- `onMessage` (`(payload, ctx) => void`): typed subscription callback.
+- `payload` (in callback): generated payload type from server schema.
+- `ctx` (in callback): runtime context for state/emit/room access.
+
+`api.onMessage.off()`:
+
+- no parameters; disables one subscription callback stream.
+
+## Room-scoped handlers
+
+```ts
+api.room('global')({
+  onMessage: (payload) => {
+    payload.text;
+  },
+});
+```
+
+### Parameters in this example
+
+`api.room(roomId)`:
+
+- `roomId` (`string`): room selector for scoped schema handling.
+
+`api.room(... )({...})`:
+
+- `onMessage` (`(payload) => void`): room-scoped subscription callback.
+
+## Low-level client module
+
+```ts
+import {createClientModule} from '@livon/client';
+import {runtime} from '@livon/runtime';
+
+const module = createClientModule({ast});
+runtime(transport, module);
+```
+
+### Parameters in this example
+
+`createClientModule({...})`:
+
+- `ast` (`AstNode`): schema AST used to build executable client interface module.
+
+## Related pages
+
+- [@livon/runtime](https://livon.tech/docs/packages/runtime)
+- [@livon/client-ws-transport](https://livon.tech/docs/packages/client-ws-transport)
+- [@livon/schema](https://livon.tech/docs/packages/schema)
+- [SchemaDoc & Generated JSDoc](https://livon.tech/docs/core/schema-doc-and-generated-jsdoc)
+- [Schema APIs](https://livon.tech/docs/schema)

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1 @@
+No third-party notices are required for this package at this time.

package/dist/client.cjs

@@ -1 +1,360 @@
-"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,t)=>{for(var r in t)__webpack_require__.o(t,r)&&!__webpack_require__.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:t[r]})},__webpack_require__.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),__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__,{clientModule:()=>clientModule,createClient:()=>createClient,createClientModule:()=>createClientModule});const DEFAULT_REQUEST_KEY="livon.client.request",setClientRequest=({client:e,registry:t,requestKey:r})=>{"object"==typeof e&&null!==e&&"setRequest"in e&&"function"==typeof e.setRequest&&e.setRequest((e,n)=>{let a=t.state.get(r);if(!a)throw Error("Client request handler is not available.");return a(e,n)})},buildClientEventEnvelope=e=>"payload"in e?{...e,payload:e.payload}:{...e,error:e.error},clientModule=(e,t={})=>({name:t.name??"client-module",register:r=>{setClientRequest({client:e,registry:r,requestKey:t.requestKey??DEFAULT_REQUEST_KEY}),r.onReceive((t,r,n)=>(e.emitEvent(buildClientEventEnvelope(t)),n()))}}),isRecord=e=>"object"==typeof e&&null!==e&&!Array.isArray(e),isArray=e=>Array.isArray(e),capitalize=e=>0===e.length?e:e.slice(0,1).toUpperCase()+e.slice(1),camelCaseName=e=>e?e.replace(/[^a-zA-Z0-9]+(.)/g,(e,t)=>String(t).toUpperCase()).replace(/^./,e=>e.toLowerCase()):e,fieldMethodName=(e,t)=>`$${camelCaseName(e)}${capitalize(t)}`,fieldEventName=(e,t)=>`$${e}.${t}`,walkAst=(e,t)=>{t(e),e.children?.forEach(e=>walkAst(e,t))},collectOperations=e=>{let t=[];return walkAst(e,e=>{if("operation"!==e.type||!e.name)return;let r=e.children?.[0],n=e.children?.[1];t.push({name:e.name,input:r,output:n,event:e.name})}),t},collectFieldOperations=e=>{let t=new Map;return walkAst(e,e=>{if("field"!==e.type)return;let r=e.constraints,n="string"==typeof r?.owner?r.owner:void 0,a="string"==typeof r?.field?r.field:void 0;if(!n||!a)return;let i=e.children??[],l=i[0],o=3===i.length?i[1]:void 0,s=3===i.length?i[2]:i[1];if(!l)return;let c={owner:n,field:a,input:o,output:s,event:fieldEventName(n,a)};t.has(n)||t.set(n,new Map),t.get(n).set(a,c)}),t},hydrateByNode=({value:e,node:t,registry:r,request:n})=>{if(!t)return e;if("array"===t.type&&Array.isArray(e)){let a=t.children?.[0];return e.forEach((t,i)=>{e[i]=hydrateByNode({value:t,node:a,registry:r,request:n})}),e}if("tuple"===t.type&&Array.isArray(e)){let a=t.children??[];return e.forEach((t,i)=>{e[i]=hydrateByNode({value:t,node:a[i],registry:r,request:n})}),e}if("object"===t.type&&isRecord(e)){let a=t.name;return a&&r.has(a)&&attachFieldOperations({target:e,typeName:a,registry:r,request:n}),(t.children??[]).forEach(t=>{if("field"!==t.type||!t.name)return;let a=t.children?.[0];a&&(e[t.name]=hydrateByNode({value:e[t.name],node:a,registry:r,request:n}))}),e}return"field"===t.type?hydrateByNode({value:e,node:t.children?.[0],registry:r,request:n}):e},attachFieldOperations=({target:e,typeName:t,registry:r,request:n})=>{let a=r.get(t);!a||Object.isExtensible(e)&&a.forEach((t,a)=>{a in e||Object.defineProperty(e,a,{enumerable:!1,configurable:!0,value:async a=>hydrateByNode({value:await n(t.event,{dependsOn:e,input:a}),node:t.output,registry:r,request:n})})})},normalizeFieldPayload=e=>{if(isRecord(e)&&"dependsOn"in e){let t=e.dependsOn,r="input"in e?e.input:void 0;return void 0===r?{dependsOn:t}:{dependsOn:t,input:r}}return{dependsOn:e}},createClientCore=({ast:e})=>{let t,r=collectOperations(e),n=collectFieldOperations(e),a={};a.setRequest=e=>{t=e};let i=new Map,l=new Map,o=new Map,s=new Map;return r.forEach(e=>{a[e.name]=async r=>{if(!t)throw Error("Client request handler is not available.");return hydrateByNode({value:await t(e.event,r),node:e.output,registry:n,request:t})}}),n.forEach((e,r)=>{e.forEach((e,i)=>{let l=fieldMethodName(r,i);l in a||(a[l]=async(r,a)=>{let i=normalizeFieldPayload(r);if(!t)throw Error("Client request handler is not available.");return hydrateByNode({value:await t(e.event,{dependsOn:i.dependsOn,input:a??i.input}),node:e.output,registry:n,request:t})})})}),Object.assign(a,{__register:(e,t)=>{let r=Object.entries(e).filter(([,e])=>"function"==typeof e);if(0===r.length)return;if(!t)return void r.forEach(([e,t])=>{i.set(e,t),l.set(e,!0)});let n=o.get(t)??new Map,a=s.get(t)??new Map;r.forEach(([e,t])=>{n.set(e,t),a.set(e,!0)}),o.set(t,n),s.set(t,a)},__toggle:(e,t,r)=>(({enabled:e,event:t,roomId:r})=>{if(!r)return void l.set(t,e);let n=s.get(r)??new Map;n.set(t,e),s.set(r,n)})({event:e,enabled:t,roomId:r}),emitEvent:e=>{let t={eventId:e.id,event:e.event,status:e.status,metadata:e.metadata,context:e.context,room:"string"==typeof e.metadata?.room?String(e.metadata.room):void 0},r=t.room;if(r){let n=s.get(r),a=o.get(r),i=a?.get(e.event),l=n?.get(e.event)??!0;i&&l&&i(e.payload,t)}let n=i.get(e.event),a=l.get(e.event)??!0;n&&a&&n(e.payload,t)}})},createClient=e=>{let t=createClientCore({ast:e.ast});return Object.assign({name:e.name??"client",register:r=>{setClientRequest({client:t,registry:r,requestKey:e.requestKey??DEFAULT_REQUEST_KEY}),r.onReceive((e,r,n)=>(t.emitEvent(buildClientEventEnvelope(e)),n()))}},t)},createClientModule=e=>createClient(e);for(var __rspack_i in exports.clientModule=__webpack_exports__.clientModule,exports.createClient=__webpack_exports__.createClient,exports.createClientModule=__webpack_exports__.createClientModule,__webpack_exports__)-1===["clientModule","createClient","createClientModule"].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__, {
+    clientModule: ()=>clientModule,
+    createClient: ()=>createClient,
+    createClientModule: ()=>createClientModule
+});
+const DEFAULT_REQUEST_KEY = 'livon.client.request';
+const setClientRequest = ({ client, registry, requestKey })=>{
+    if ('object' != typeof client || null === client || !('setRequest' in client)) return;
+    const candidate = client;
+    if ('function' != typeof candidate.setRequest) return;
+    candidate.setRequest((event, payload)=>{
+        const request = registry.state.get(requestKey);
+        if (!request) throw new Error('Client request handler is not available.');
+        return request(event, payload);
+    });
+};
+const buildClientEventEnvelope = (envelope)=>{
+    if ('payload' in envelope) return {
+        ...envelope,
+        payload: envelope.payload
+    };
+    return {
+        ...envelope,
+        error: envelope.error
+    };
+};
+const clientModule = (client, options = {})=>{
+    const register = (registry)=>{
+        const requestKey = options.requestKey ?? DEFAULT_REQUEST_KEY;
+        setClientRequest({
+            client,
+            registry,
+            requestKey
+        });
+        registry.onReceive((envelope, _ctx, next)=>{
+            client.emitEvent(buildClientEventEnvelope(envelope));
+            return next();
+        });
+    };
+    return {
+        name: options.name ?? 'client-module',
+        register
+    };
+};
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const isArray = (value)=>Array.isArray(value);
+const capitalize = (value)=>0 === value.length ? value : value.slice(0, 1).toUpperCase() + value.slice(1);
+const camelCaseName = (value)=>{
+    if (!value) return value;
+    return value.replace(/[^a-zA-Z0-9]+(.)/g, (_, group)=>String(group).toUpperCase()).replace(/^./, (char)=>char.toLowerCase());
+};
+const fieldMethodName = (owner, field)=>`$${camelCaseName(owner)}${capitalize(field)}`;
+const fieldEventName = (owner, field)=>`$${owner}.${field}`;
+const walkAst = (node, visit)=>{
+    visit(node);
+    node.children?.forEach((child)=>walkAst(child, visit));
+};
+const collectOperations = (root)=>{
+    const operations = [];
+    walkAst(root, (node)=>{
+        if ('operation' !== node.type || !node.name) return;
+        const input = node.children?.[0];
+        const output = node.children?.[1];
+        operations.push({
+            name: node.name,
+            input,
+            output,
+            event: node.name
+        });
+    });
+    return operations;
+};
+const collectFieldOperations = (root)=>{
+    const registry = new Map();
+    walkAst(root, (node)=>{
+        if ('field' !== node.type) return;
+        const constraints = node.constraints;
+        const owner = 'string' == typeof constraints?.owner ? constraints.owner : void 0;
+        const field = 'string' == typeof constraints?.field ? constraints.field : void 0;
+        if (!owner || !field) return;
+        const children = node.children ?? [];
+        const dependsOn = children[0];
+        const input = 3 === children.length ? children[1] : void 0;
+        const output = 3 === children.length ? children[2] : children[1];
+        if (!dependsOn) return;
+        const spec = {
+            owner,
+            field,
+            input,
+            output,
+            event: fieldEventName(owner, field)
+        };
+        if (!registry.has(owner)) registry.set(owner, new Map());
+        registry.get(owner).set(field, spec);
+    });
+    return registry;
+};
+const hydrateByNode = ({ value, node, registry, request })=>{
+    if (!node) return value;
+    if ('array' === node.type && isArray(value)) {
+        const child = node.children?.[0];
+        value.forEach((item, index)=>{
+            value[index] = hydrateByNode({
+                value: item,
+                node: child,
+                registry,
+                request
+            });
+        });
+        return value;
+    }
+    if ('tuple' === node.type && isArray(value)) {
+        const children = node.children ?? [];
+        value.forEach((item, index)=>{
+            value[index] = hydrateByNode({
+                value: item,
+                node: children[index],
+                registry,
+                request
+            });
+        });
+        return value;
+    }
+    if ('and' === node.type) return (node.children ?? []).reduce((current, child)=>hydrateByNode({
+            value: current,
+            node: child,
+            registry,
+            request
+        }), value);
+    if ('object' === node.type && isRecord(value)) {
+        const typeName = node.name;
+        if (typeName && registry.has(typeName)) attachFieldOperations({
+            target: value,
+            typeName,
+            registry,
+            request
+        });
+        const fields = node.children ?? [];
+        fields.forEach((fieldNode)=>{
+            if ('field' !== fieldNode.type || !fieldNode.name) return;
+            const child = fieldNode.children?.[0];
+            if (!child) return;
+            value[fieldNode.name] = hydrateByNode({
+                value: value[fieldNode.name],
+                node: child,
+                registry,
+                request
+            });
+        });
+        return value;
+    }
+    if ('field' === node.type) {
+        const child = node.children?.[0];
+        return hydrateByNode({
+            value,
+            node: child,
+            registry,
+            request
+        });
+    }
+    return value;
+};
+const attachFieldOperations = ({ target, typeName, registry, request })=>{
+    const operations = registry.get(typeName);
+    if (!operations) return;
+    if (!Object.isExtensible(target)) return;
+    operations.forEach((spec, fieldName)=>{
+        if (fieldName in target) return;
+        Object.defineProperty(target, fieldName, {
+            enumerable: false,
+            configurable: true,
+            value: async (input)=>{
+                const payload = {
+                    dependsOn: target,
+                    input
+                };
+                const result = await request(spec.event, payload);
+                return hydrateByNode({
+                    value: result,
+                    node: spec.output,
+                    registry,
+                    request
+                });
+            }
+        });
+    });
+};
+const normalizeFieldPayload = (payload)=>{
+    if (isRecord(payload) && 'dependsOn' in payload) {
+        const dependsOn = payload.dependsOn;
+        const input = 'input' in payload ? payload.input : void 0;
+        if (void 0 === input) return {
+            dependsOn
+        };
+        return {
+            dependsOn,
+            input
+        };
+    }
+    return {
+        dependsOn: payload
+    };
+};
+const createClientCore = ({ ast })=>{
+    const operations = collectOperations(ast);
+    const fieldRegistry = collectFieldOperations(ast);
+    let request;
+    const client = {};
+    client.setRequest = (next)=>{
+        request = next;
+    };
+    const globalHandlers = new Map();
+    const globalEnabled = new Map();
+    const roomHandlers = new Map();
+    const roomEnabled = new Map();
+    const registerHandlers = (handlers, roomId)=>{
+        const entries = Object.entries(handlers).filter(([, handler])=>'function' == typeof handler);
+        if (0 === entries.length) return;
+        if (!roomId) return void entries.forEach(([event, handler])=>{
+            globalHandlers.set(event, handler);
+            globalEnabled.set(event, true);
+        });
+        const roomMap = roomHandlers.get(roomId) ?? new Map();
+        const enabledMap = roomEnabled.get(roomId) ?? new Map();
+        entries.forEach(([event, handler])=>{
+            roomMap.set(event, handler);
+            enabledMap.set(event, true);
+        });
+        roomHandlers.set(roomId, roomMap);
+        roomEnabled.set(roomId, enabledMap);
+    };
+    const toggleHandler = ({ enabled, event, roomId })=>{
+        if (!roomId) return void globalEnabled.set(event, enabled);
+        const enabledMap = roomEnabled.get(roomId) ?? new Map();
+        enabledMap.set(event, enabled);
+        roomEnabled.set(roomId, enabledMap);
+    };
+    const dispatch = (envelope)=>{
+        const ctx = {
+            eventId: envelope.id,
+            event: envelope.event,
+            status: envelope.status,
+            metadata: envelope.metadata,
+            context: envelope.context,
+            room: 'string' == typeof envelope.metadata?.room ? String(envelope.metadata.room) : void 0
+        };
+        const roomId = ctx.room;
+        if (roomId) {
+            const enabledMap = roomEnabled.get(roomId);
+            const roomMap = roomHandlers.get(roomId);
+            const handler = roomMap?.get(envelope.event);
+            const isEnabled = enabledMap?.get(envelope.event) ?? true;
+            if (handler && isEnabled) handler(envelope.payload, ctx);
+        }
+        const handler = globalHandlers.get(envelope.event);
+        const isEnabled = globalEnabled.get(envelope.event) ?? true;
+        if (handler && isEnabled) handler(envelope.payload, ctx);
+    };
+    operations.forEach((op)=>{
+        client[op.name] = async (input)=>{
+            if (!request) throw new Error('Client request handler is not available.');
+            const result = await request(op.event, input);
+            return hydrateByNode({
+                value: result,
+                node: op.output,
+                registry: fieldRegistry,
+                request
+            });
+        };
+    });
+    fieldRegistry.forEach((fields, owner)=>{
+        fields.forEach((spec, field)=>{
+            const method = fieldMethodName(owner, field);
+            if (method in client) return;
+            client[method] = async (payload, input)=>{
+                const normalized = normalizeFieldPayload(payload);
+                if (!request) throw new Error('Client request handler is not available.');
+                const result = await request(spec.event, {
+                    dependsOn: normalized.dependsOn,
+                    input: input ?? normalized.input
+                });
+                return hydrateByNode({
+                    value: result,
+                    node: spec.output,
+                    registry: fieldRegistry,
+                    request
+                });
+            };
+        });
+    });
+    return Object.assign(client, {
+        __register: registerHandlers,
+        __toggle: (event, enabled, roomId)=>toggleHandler({
+                event,
+                enabled,
+                roomId
+            }),
+        emitEvent: dispatch
+    });
+};
+const createClient = (input)=>{
+    const client = createClientCore({
+        ast: input.ast
+    });
+    const register = (registry)=>{
+        const requestKey = input.requestKey ?? DEFAULT_REQUEST_KEY;
+        setClientRequest({
+            client,
+            registry,
+            requestKey
+        });
+        registry.onReceive((envelope, _ctx, next)=>{
+            client.emitEvent(buildClientEventEnvelope(envelope));
+            return next();
+        });
+    };
+    const moduleBase = {
+        name: input.name ?? 'client',
+        register
+    };
+    const moduleWithClient = Object.assign(moduleBase, client);
+    return moduleWithClient;
+};
+const createClientModule = (input)=>createClient(input);
+exports.clientModule = __webpack_exports__.clientModule;
+exports.createClient = __webpack_exports__.createClient;
+exports.createClientModule = __webpack_exports__.createClientModule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "clientModule",
+    "createClient",
+    "createClientModule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/client.d.ts

@@ -64,7 +64,7 @@ export interface ClientModuleOptions {
  * @remarks
  * Parameter and return types are defined in the TypeScript signature.
  *
- * @see https://live-input-vector-output-node.github.io/livon-ts/docs/packages/client
+ * @see https://livon.tech/docs/packages/client
  *
  * @example
  * const result = clientModule(undefined as never);
@@ -76,7 +76,7 @@ export declare const clientModule: (client: ClientEventEmitter, options?: Client
  * @remarks
  * Parameter and return types are defined in the TypeScript signature.
  *
- * @see https://live-input-vector-output-node.github.io/livon-ts/docs/packages/client
+ * @see https://livon.tech/docs/packages/client
  *
  * @example
  * const result = createClient(undefined as never);
@@ -92,7 +92,7 @@ export declare const createClient: (input: ClientModuleInput) => ClientModule &
  * @remarks
  * Parameter and return types are defined in the TypeScript signature.
  *
- * @see https://live-input-vector-output-node.github.io/livon-ts/docs/packages/client
+ * @see https://livon.tech/docs/packages/client
  *
  * @example
  * const result = createClientModule(undefined as never);