@livon/client 0.27.0-rc.2 → 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

@@ -0,0 +1,109 @@
+# @livon/client
+
+## Purpose
+
+[@livon/client](https://live-input-vector-output-node.github.io/livon-ts/docs/packages/client) provides deterministic client interface execution and generated-client foundations.
+
+Exports include:
+
+- `createClient`
+- `createClientModule`
+- `clientModule`
+
+## 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://live-input-vector-output-node.github.io/livon-ts/docs/packages/runtime)
+- [@livon/client-ws-transport](https://live-input-vector-output-node.github.io/livon-ts/docs/packages/client-ws-transport)
+- [@livon/schema](https://live-input-vector-output-node.github.io/livon-ts/docs/packages/schema)
+- [Schema APIs](https://live-input-vector-output-node.github.io/livon-ts/docs/schema)

package/dist/client.cjs

@@ -1 +1,455 @@
-"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";
+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__ = {};
+__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 (typeof client !== 'object' || client === null || !('setRequest' in client)) {
+        return;
+    }
+    const candidate = client;
+    if (typeof candidate.setRequest !== 'function') {
+        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
+    };
+};
+/**
+ * clientModule 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/client
+ *
+ * @example
+ * const result = clientModule(undefined as never);
+ */ 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)=>typeof value === 'object' && value !== null && !Array.isArray(value);
+const isArray = (value)=>Array.isArray(value);
+const capitalize = (value)=>value.length === 0 ? 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 (node.type !== 'operation' || !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 (node.type !== 'field') {
+            return;
+        }
+        const constraints = node.constraints;
+        const owner = typeof constraints?.owner === 'string' ? constraints.owner : undefined;
+        const field = typeof constraints?.field === 'string' ? constraints.field : undefined;
+        if (!owner || !field) {
+            return;
+        }
+        const children = node.children ?? [];
+        const dependsOn = children[0];
+        const input = children.length === 3 ? children[1] : undefined;
+        const output = children.length === 3 ? 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 (node.type === 'array' && isArray(value)) {
+        const child = node.children?.[0];
+        value.forEach((item, index)=>{
+            value[index] = hydrateByNode({
+                value: item,
+                node: child,
+                registry,
+                request
+            });
+        });
+        return value;
+    }
+    if (node.type === 'tuple' && isArray(value)) {
+        const children = node.children ?? [];
+        value.forEach((item, index)=>{
+            value[index] = hydrateByNode({
+                value: item,
+                node: children[index],
+                registry,
+                request
+            });
+        });
+        return value;
+    }
+    if (node.type === 'and') {
+        return (node.children ?? []).reduce((current, child)=>hydrateByNode({
+                value: current,
+                node: child,
+                registry,
+                request
+            }), value);
+    }
+    if (node.type === 'object' && 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 (fieldNode.type !== 'field' || !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 (node.type === 'field') {
+        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 : undefined;
+        if (input === undefined) {
+            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])=>typeof handler === 'function');
+        if (entries.length === 0) {
+            return;
+        }
+        if (!roomId) {
+            entries.forEach(([event, handler])=>{
+                globalHandlers.set(event, handler);
+                globalEnabled.set(event, true);
+            });
+            return;
+        }
+        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) {
+            globalEnabled.set(event, enabled);
+            return;
+        }
+        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: typeof envelope.metadata?.room === 'string' ? String(envelope.metadata.room) : undefined
+        };
+        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
+    });
+};
+/**
+ * createClient 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/client
+ *
+ * @example
+ * const result = createClient(undefined as never);
+ */ 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;
+};
+/**
+ * createClientModule 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/client
+ *
+ * @example
+ * const result = createClientModule(undefined as never);
+ */ 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(["clientModule","createClient","createClientModule"].indexOf(__rspack_i) === -1) {
+    exports[__rspack_i] = __webpack_exports__[__rspack_i];
+  }
+}
+Object.defineProperty(exports, '__esModule', { value: true });