@livon/client 0.27.0-rc.1

package/dist/generate.cjs

@@ -0,0 +1,676 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "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__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    getClientGeneratorFingerprint: ()=>getClientGeneratorFingerprint,
+    generateClientFiles: ()=>generateClientFiles
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_url_namespaceObject = require("node:url");
+const AST_PLACEHOLDER = '${{LIVON_AST}}';
+const CLIENT_IMPORTS_PLACEHOLDER = '${{LIVON_CLIENT_IMPORTS}}';
+const CLIENT_TYPE_DEFS_PLACEHOLDER = '${{LIVON_CLIENT_TYPE_DEFS}}';
+const CLIENT_EVENT_MAP_PLACEHOLDER = '${{LIVON_CLIENT_EVENT_MAP}}';
+const CLIENT_FIELD_OPS_PLACEHOLDER = '${{LIVON_CLIENT_FIELD_OPS}}';
+const CLIENT_OP_DEFS_PLACEHOLDER = '${{LIVON_CLIENT_OP_DEFS}}';
+const CLIENT_OP_LINES_PLACEHOLDER = '${{LIVON_CLIENT_OP_LINES}}';
+const CLIENT_SUB_NAMES_PLACEHOLDER = '${{LIVON_CLIENT_SUB_NAMES}}';
+const CLIENT_EXPORT_NAME_PLACEHOLDER = '${{LIVON_CLIENT_EXPORT_NAME}}';
+const moduleUrl = __rslib_import_meta_url__;
+const templatesDir = external_node_path_default().resolve(external_node_path_default().dirname((0, external_node_url_namespaceObject.fileURLToPath)(moduleUrl)), '../templates');
+const sourceFilePath = (0, external_node_url_namespaceObject.fileURLToPath)(moduleUrl);
+const serializeAst = (ast)=>JSON.stringify(ast, null, 2);
+const hashText = (value)=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(value).digest('hex');
+const isValidIdentifier = (value)=>/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
+const renderPropertyName = (value)=>isValidIdentifier(value) ? value : JSON.stringify(value);
+const pascalCaseName = (value)=>{
+    const normalized = value.replace(/[^a-zA-Z0-9]+(.)/g, (_, group)=>String(group).toUpperCase());
+    return 0 === normalized.length ? 'Type' : normalized.charAt(0).toUpperCase() + normalized.slice(1);
+};
+const sanitizeTypeName = (value)=>{
+    const pascal = pascalCaseName(value);
+    const cleaned = pascal.replace(/[^A-Za-z0-9_$]/g, '');
+    if (0 === cleaned.length) return 'Type';
+    return isValidIdentifier(cleaned) ? cleaned : `Type${cleaned}`;
+};
+const resolveUniqueName = (base, used, index = 0)=>{
+    const suffix = index > 0 ? String(index) : '';
+    const candidate = `${base}${suffix}`;
+    if (!used.has(candidate)) {
+        used.add(candidate);
+        return candidate;
+    }
+    return resolveUniqueName(base, used, index + 1);
+};
+const isTypeDefinitionNode = (node)=>'api' !== node.type && 'api-composed' !== node.type && 'operation' !== node.type && 'field' !== node.type && "subscription" !== node.type;
+const isString = (value)=>'string' == typeof value;
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const extractDocText = (doc)=>{
+    if (!doc) return;
+    if ('string' == typeof doc) return doc;
+    if (!isRecord(doc)) return;
+    const value = 'string' == typeof doc.description && doc.description || 'string' == typeof doc.summary && doc.summary || 'string' == typeof doc.text && doc.text || 'string' == typeof doc.title && doc.title;
+    return value || void 0;
+};
+const renderJSDoc = (lines, indent = '')=>{
+    if (0 === lines.length) return [];
+    return [
+        `${indent}/**`,
+        ...lines.map((line)=>`${indent} * ${line}`),
+        `${indent} */`
+    ];
+};
+const walkAst = (node, visit)=>{
+    visit(node);
+    node.children?.forEach((child)=>walkAst(child, visit));
+};
+const collectNamedNodes = (root)=>{
+    const nodes = new Map();
+    const usedNames = new Set();
+    walkAst(root, (node)=>{
+        if (!node.name || !isTypeDefinitionNode(node)) return;
+        if (nodes.has(node.name)) return;
+        const baseName = sanitizeTypeName(node.name);
+        const typeName = resolveUniqueName(baseName, usedNames);
+        nodes.set(node.name, {
+            name: node.name,
+            typeName,
+            node
+        });
+    });
+    return nodes;
+};
+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];
+        const constraints = node.constraints;
+        const requestType = node.request ?? ('string' == typeof constraints?.request ? constraints.request : void 0);
+        const responseType = node.response ?? ('string' == typeof constraints?.response ? constraints.response : void 0);
+        operations.push({
+            name: node.name,
+            input,
+            output,
+            doc: node.doc,
+            publishTopics: readPublishTopics(node),
+            requestType,
+            responseType,
+            constraints: node.constraints
+        });
+    });
+    return operations;
+};
+const collectFieldOperations = (root)=>{
+    const operations = [];
+    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 input = 3 === children.length ? children[1] : void 0;
+        const output = 3 === children.length ? children[2] : children[1];
+        const requestType = node.request ?? ('string' == typeof constraints?.request ? constraints.request : void 0);
+        const responseType = node.response ?? ('string' == typeof constraints?.response ? constraints.response : void 0);
+        const dependsOnType = node.dependsOn ?? ('string' == typeof constraints?.dependsOn ? constraints.dependsOn : void 0);
+        operations.push({
+            owner,
+            field,
+            input,
+            output,
+            doc: node.doc,
+            requestType,
+            responseType,
+            dependsOnType,
+            constraints: node.constraints
+        });
+    });
+    return operations;
+};
+const readPublishTopics = (node)=>{
+    const constraints = node.constraints;
+    if (!constraints || 'object' != typeof constraints || Array.isArray(constraints)) return [];
+    const raw = constraints.publish;
+    if (!Array.isArray(raw)) return [];
+    return raw.filter(isString);
+};
+const collectPublishEvents = (root, namedNodes)=>{
+    const events = [];
+    walkAst(root, (node)=>{
+        if ('operation' !== node.type) return;
+        const topics = readPublishTopics(node);
+        if (0 === topics.length) return;
+        const output = node.children?.[1];
+        const payloadType = renderType(output, namedNodes);
+        topics.forEach((topic)=>{
+            events.push({
+                topic,
+                payloadType
+            });
+        });
+    });
+    return events;
+};
+const resolveTypeName = (typeName, namedNodes)=>{
+    if (!typeName) return;
+    const named = namedNodes.get(typeName);
+    return named?.typeName;
+};
+const collectSubscriptionEvents = (root, namedNodes)=>{
+    const events = [];
+    walkAst(root, (node)=>{
+        if ("subscription" !== node.type || !node.name) return;
+        const constraints = node.constraints;
+        const responseType = node.response ?? ('string' == typeof constraints?.response ? constraints.response : void 0);
+        const resolvedType = resolveTypeName(responseType, namedNodes);
+        const payload = node.children?.[0];
+        const payloadType = resolvedType ?? renderType(payload, namedNodes, node.name);
+        events.push({
+            topic: node.name,
+            payloadType
+        });
+    });
+    return events;
+};
+const groupFieldOperations = (fieldOperations)=>{
+    const grouped = fieldOperations.reduce((acc, op)=>{
+        const existing = acc.get(op.owner) ?? [];
+        acc.set(op.owner, existing.concat(op));
+        return acc;
+    }, new Map());
+    return Array.from(grouped.entries()).map(([owner, operations])=>({
+            owner,
+            operations
+        }));
+};
+const renderLiteral = (value)=>{
+    if ('string' == typeof value || 'number' == typeof value || 'boolean' == typeof value) return JSON.stringify(value);
+    return 'unknown';
+};
+const resolveDocText = (doc)=>{
+    const text = extractDocText(doc);
+    if (!text) return [];
+    return text.split(/\r?\n/).map((line)=>line.trim()).filter((line)=>line.length > 0);
+};
+const renderConstraints = (constraints)=>{
+    if (!constraints || 'object' != typeof constraints) return [];
+    const entries = Object.entries(constraints).filter(([_, value])=>void 0 !== value);
+    if (0 === entries.length) return [];
+    const parts = entries.map(([key, value])=>{
+        if (Array.isArray(value)) return `${key}=[${value.map((item)=>JSON.stringify(item)).join(', ')}]`;
+        return `${key}=${JSON.stringify(value)}`;
+    });
+    return [
+        `Constraints: ${parts.join(', ')}.`
+    ];
+};
+const buildExample = (node, namedNodes, depth = 0, visited = new Set())=>{
+    if (!node) return 'undefined';
+    if (depth > 2) return '...';
+    if (node.name && namedNodes.has(node.name) && isTypeDefinitionNode(node)) {
+        const named = namedNodes.get(node.name).node;
+        if (named !== node) {
+            if (visited.has(node.name)) return '...';
+            visited.add(node.name);
+            return buildExample(named, namedNodes, depth + 1, visited);
+        }
+        if (visited.has(node.name)) return '...';
+        visited.add(node.name);
+    }
+    switch(node.type){
+        case 'string':
+            return '"string"';
+        case 'number':
+            return '0';
+        case 'boolean':
+            return 'false';
+        case 'date':
+            return 'new Date()';
+        case 'binary':
+            return 'new Uint8Array()';
+        case 'literal':
+            return renderLiteral(node.constraints?.value);
+        case 'enum':
+            {
+                const values = Array.isArray(node.constraints?.values) ? node.constraints?.values ?? [] : [];
+                return values.length > 0 ? renderLiteral(values[0]) : '"value"';
+            }
+        case 'array':
+            {
+                const child = node.children?.[0];
+                return `[${buildExample(child, namedNodes, depth + 1, visited)}]`;
+            }
+        case 'tuple':
+            {
+                const items = (node.children ?? []).map((child)=>buildExample(child, namedNodes, depth + 1, visited));
+                return `[${items.join(', ')}]`;
+            }
+        case 'union':
+            {
+                const first = node.children?.[0];
+                return buildExample(first, namedNodes, depth + 1, visited);
+            }
+        case 'object':
+            {
+                const fields = (node.children ?? []).filter((child)=>'field' === child.type && child.name);
+                const body = fields.slice(0, 3).map((field)=>{
+                    const value = buildExample(field.children?.[0], namedNodes, depth + 1, visited);
+                    return `${renderPropertyName(field.name ?? 'field')}: ${value}`;
+                });
+                const tail = fields.length > 3 ? ', ...' : '';
+                return `{ ${body.join(', ')}${tail} }`;
+            }
+        default:
+            return '...';
+    }
+};
+const renderTypeDoc = (node, namedNodes)=>{
+    const lines = [];
+    lines.push(...resolveDocText(node.doc));
+    lines.push(`Type: ${node.type}${node.name ? ` (${node.name})` : ''}.`);
+    lines.push(...renderConstraints(node.constraints));
+    if ('object' === node.type) {
+        const fields = (node.children ?? []).filter((child)=>'field' === child.type && child.name);
+        if (fields.length > 0) lines.push(`Fields: ${fields.map((field)=>field.name).join(', ')}.`);
+    }
+    lines.push(`@example ${buildExample(node, namedNodes)}`);
+    return lines;
+};
+const renderFieldDoc = (fieldName, fieldNode, fieldType, namedNodes)=>{
+    const doc = fieldNode.doc ?? fieldNode.children?.[0]?.doc;
+    const lines = [];
+    lines.push(...resolveDocText(doc));
+    lines.push(`Field: ${fieldName}.`);
+    lines.push(`Type: ${fieldType}.`);
+    lines.push(...renderConstraints(fieldNode.constraints));
+    lines.push(`@link ${fieldType}`);
+    lines.push(`@example ${buildExample(fieldNode.children?.[0], namedNodes)}`);
+    return lines;
+};
+const renderOperationDoc = (operation, inputType, outputType, namedNodes)=>{
+    const lines = [];
+    lines.push(...resolveDocText(operation.doc));
+    lines.push(`Operation: ${operation.name}.`);
+    lines.push(...renderConstraints(operation.constraints));
+    if (operation.input) {
+        const requestType = operation.requestType ?? inputType;
+        lines.push(`@param input ${requestType}`);
+        lines.push(`@link ${requestType}`);
+    } else lines.push("@param input void");
+    const responseType = operation.responseType ?? outputType;
+    lines.push(`@returns ${responseType}`);
+    lines.push(`@resolve ${responseType}`);
+    lines.push(`@link ${responseType}`);
+    if (operation.publishTopics.length > 0) lines.push(`Publishes events: ${operation.publishTopics.join(', ')}.`);
+    const inputExample = operation.input ? buildExample(operation.input, namedNodes) : '';
+    const call = operation.input ? `(${inputExample})` : '()';
+    lines.push(`@example await client.${renderPropertyName(operation.name)}${call}`);
+    if (operation.input) {
+        const requestType = operation.requestType ?? inputType;
+        const signatureInput = `${inputExample}: ${requestType}`;
+        lines.push(`@example ${operation.name}(${signatureInput}): ${responseType}`);
+    } else lines.push(`@example ${operation.name}(): ${responseType}`);
+    return lines;
+};
+const renderFieldOperationDoc = (owner, field, inputType, outputType, hasInput, operation, namedNodes)=>{
+    const lines = [];
+    lines.push(...resolveDocText(operation.doc));
+    lines.push(`Field operation: ${owner}.${field}.`);
+    lines.push(...renderConstraints(operation.constraints));
+    const dependsOn = operation.dependsOnType ?? owner;
+    lines.push(`Depends on: ${dependsOn}.`);
+    lines.push(`@link ${dependsOn}`);
+    if (hasInput) {
+        const requestType = operation.requestType ?? inputType;
+        lines.push(`@param input ${requestType}`);
+        lines.push(`@link ${requestType}`);
+    } else lines.push("@param input void");
+    const responseType = operation.responseType ?? outputType;
+    lines.push(`@returns ${responseType}`);
+    lines.push(`@resolve ${responseType}`);
+    lines.push(`@link ${responseType}`);
+    const inputExample = hasInput ? buildExample(operation.input, namedNodes) : '';
+    const call = hasInput ? `(${inputExample})` : '()';
+    lines.push(`@example await ${field}${call}`);
+    if (hasInput) {
+        const requestType = operation.requestType ?? inputType;
+        lines.push(`@example ${field}(${inputExample}: ${requestType}): ${responseType}`);
+    } else lines.push(`@example ${field}(): ${responseType}`);
+    return lines;
+};
+const renderType = (node, namedNodes, ignoreName)=>{
+    if (!node) return 'unknown';
+    if (node.name && node.name !== ignoreName && namedNodes.has(node.name) && isTypeDefinitionNode(node)) return namedNodes.get(node.name).typeName;
+    switch(node.type){
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'date':
+            return 'Date';
+        case 'binary':
+            return 'Uint8Array';
+        case 'literal':
+            return renderLiteral(node.constraints?.value);
+        case 'enum':
+            {
+                const values = Array.isArray(node.constraints?.values) ? node.constraints?.values ?? [] : [];
+                const literalValues = values.map((value)=>renderLiteral(value)).filter((value)=>'unknown' !== value);
+                return literalValues.length > 0 ? literalValues.join(' | ') : 'string';
+            }
+        case 'array':
+            {
+                const child = node.children?.[0];
+                return `Array<${renderType(child, namedNodes)}>`;
+            }
+        case 'tuple':
+            {
+                const items = (node.children ?? []).map((child)=>renderType(child, namedNodes));
+                return `[${items.join(', ')}]`;
+            }
+        case 'union':
+            {
+                const options = (node.children ?? []).map((child)=>renderType(child, namedNodes));
+                return options.length > 0 ? options.join(' | ') : 'unknown';
+            }
+        case 'object':
+            return node.name && namedNodes.has(node.name) ? namedNodes.get(node.name).typeName : 'Record<string, unknown>';
+        default:
+            return 'unknown';
+    }
+};
+const renderOperationTypeName = (operation, used)=>resolveUniqueName(`${pascalCaseName(operation.name)}Operation`, used);
+const renderFieldOperationTypeName = (ownerType, field, used)=>resolveUniqueName(`${ownerType}${pascalCaseName(field)}Field`, used);
+const renderTypeDefinitions = (namedNodes, fieldOperations, usedNames)=>{
+    const lines = [];
+    const fieldTypeNames = new Map();
+    const groups = groupFieldOperations(fieldOperations);
+    const groupsByOwner = groups.reduce((acc, group)=>{
+        acc.set(group.owner, group.operations);
+        return acc;
+    }, new Map());
+    const namedEntries = Array.from(namedNodes.values()).sort((a, b)=>a.typeName.localeCompare(b.typeName));
+    namedEntries.forEach((entry)=>{
+        const node = entry.node;
+        lines.push(...renderJSDoc(renderTypeDoc(node, namedNodes)));
+        if ('object' === node.type) {
+            lines.push(`export interface ${entry.typeName} {`);
+            const fields = (node.children ?? []).filter((child)=>'field' === child.type && child.name);
+            fields.forEach((fieldNode)=>{
+                const fieldName = fieldNode.name ?? 'field';
+                const childType = renderType(fieldNode.children?.[0], namedNodes);
+                lines.push(...renderJSDoc(renderFieldDoc(fieldName, fieldNode, childType, namedNodes), '  '));
+                lines.push(`  ${renderPropertyName(fieldName)}: ${childType};`);
+            });
+            const operations = groupsByOwner.get(entry.name) ?? [];
+            operations.forEach((operation)=>{
+                const fieldMap = fieldTypeNames.get(entry.name) ?? new Map();
+                const fieldTypeName = renderFieldOperationTypeName(entry.typeName, operation.field, usedNames);
+                fieldMap.set(operation.field, fieldTypeName);
+                fieldTypeNames.set(entry.name, fieldMap);
+                const inputType = renderType(operation.input, namedNodes);
+                const outputType = renderType(operation.output, namedNodes);
+                const hasInput = Boolean(operation.input);
+                lines.push(...renderJSDoc(renderFieldOperationDoc(entry.typeName, operation.field, inputType, outputType, hasInput, operation, namedNodes), '  '));
+                lines.push(`  ${renderPropertyName(operation.field)}?: ${fieldTypeName};`);
+            });
+            lines.push('}');
+            lines.push('');
+            return;
+        }
+        const typeBody = renderType(node, namedNodes, entry.name);
+        lines.push(`export type ${entry.typeName} = ${typeBody};`);
+        lines.push('');
+    });
+    return {
+        definitions: lines,
+        fieldTypeNames
+    };
+};
+const renderFieldOperationDefinitions = (fieldOperations, namedNodes, usedNames, fieldTypeNames)=>{
+    const lines = [];
+    const operations = fieldOperations.map((operation)=>{
+        const owner = namedNodes.get(operation.owner)?.typeName ?? sanitizeTypeName(operation.owner);
+        const fieldTypeName = fieldTypeNames.get(operation.owner)?.get(operation.field) ?? renderFieldOperationTypeName(owner, operation.field, usedNames);
+        const inputType = renderType(operation.input, namedNodes);
+        const outputType = renderType(operation.output, namedNodes);
+        return {
+            owner,
+            field: operation.field,
+            fieldTypeName,
+            inputType,
+            outputType,
+            hasInput: Boolean(operation.input),
+            doc: operation.doc,
+            inputNode: operation.input,
+            requestType: operation.requestType,
+            responseType: operation.responseType,
+            dependsOnType: operation.dependsOnType
+        };
+    }).sort((a, b)=>a.fieldTypeName.localeCompare(b.fieldTypeName));
+    operations.forEach((operation)=>{
+        lines.push(...renderJSDoc(renderFieldOperationDoc(operation.owner, operation.field, operation.inputType, operation.outputType, operation.hasInput, {
+            owner: operation.owner,
+            field: operation.field,
+            input: operation.inputNode,
+            doc: operation.doc,
+            requestType: operation.requestType,
+            responseType: operation.responseType,
+            dependsOnType: operation.dependsOnType
+        }, namedNodes)));
+        lines.push(`export interface ${operation.fieldTypeName} {`);
+        if (operation.hasInput) lines.push(`  (input: ${operation.inputType}): Promise<${operation.outputType}>;`);
+        else lines.push(`  (): Promise<${operation.outputType}>;`);
+        lines.push('}');
+        lines.push('');
+    });
+    return lines;
+};
+const renderOperationDefinitions = (operations, namedNodes, usedNames)=>{
+    const lines = [];
+    const clientLines = [];
+    const sorted = operations.map((operation)=>({
+            operation,
+            typeName: renderOperationTypeName(operation, usedNames)
+        })).sort((a, b)=>a.typeName.localeCompare(b.typeName));
+    sorted.forEach((entry)=>{
+        const inputType = renderType(entry.operation.input, namedNodes);
+        const outputType = renderType(entry.operation.output, namedNodes);
+        lines.push(...renderJSDoc(renderOperationDoc(entry.operation, inputType, outputType, namedNodes)));
+        lines.push(`export interface ${entry.typeName} {`);
+        if (entry.operation.input) lines.push(`  (input: ${inputType}): Promise<${outputType}>;`);
+        else lines.push(`  (): Promise<${outputType}>;`);
+        lines.push('}');
+        lines.push('');
+        clientLines.push(...renderJSDoc(renderOperationDoc(entry.operation, inputType, outputType, namedNodes), '  '));
+        clientLines.push(`  ${renderPropertyName(entry.operation.name)}: ${entry.typeName};`);
+    });
+    return {
+        lines,
+        clientLines
+    };
+};
+const renderEventMapDefinitions = (events)=>{
+    if (0 === events.length) return [
+        'export type LivonEventMap = Record<string, never>;',
+        ''
+    ];
+    const entries = events.reduce((acc, event)=>{
+        if (!acc.has(event.topic)) acc.set(event.topic, event.payloadType);
+        return acc;
+    }, new Map());
+    const lines = [
+        'export type LivonEventMap = {'
+    ];
+    Array.from(entries.entries()).forEach(([topic, payloadType])=>{
+        lines.push(`  ${JSON.stringify(topic)}: ${payloadType};`);
+    });
+    lines.push('};');
+    lines.push('');
+    return lines;
+};
+const defaultAstTemplate = ()=>`export const ast = ${AST_PLACEHOLDER} as const;\n\nexport default ast;\n`;
+const defaultClientTemplate = ()=>[
+        CLIENT_IMPORTS_PLACEHOLDER,
+        CLIENT_TYPE_DEFS_PLACEHOLDER,
+        CLIENT_EVENT_MAP_PLACEHOLDER,
+        CLIENT_FIELD_OPS_PLACEHOLDER,
+        CLIENT_OP_DEFS_PLACEHOLDER,
+        CLIENT_OP_LINES_PLACEHOLDER,
+        CLIENT_SUB_NAMES_PLACEHOLDER,
+        CLIENT_EXPORT_NAME_PLACEHOLDER
+    ].join('\n');
+const readTemplate = (filename, fallback)=>{
+    const templatePath = external_node_path_default().join(templatesDir, filename);
+    try {
+        return external_node_fs_default().readFileSync(templatePath, 'utf8');
+    } catch  {
+        return fallback();
+    }
+};
+const applyTemplate = (template, placeholder, value, label)=>{
+    if (!template.includes(placeholder)) throw new Error(`Template ${label} is missing placeholder ${placeholder}`);
+    return template.split(placeholder).join(value);
+};
+const applyTemplateMap = (template, placeholders, label)=>placeholders.reduce((next, entry)=>applyTemplate(next, entry.key, entry.value, label), template);
+const getClientGeneratorFingerprint = ()=>{
+    const source = external_node_fs_default().readFileSync(sourceFilePath, 'utf8');
+    const astTemplate = readTemplate('ast.template.ts', defaultAstTemplate);
+    const clientTemplate = readTemplate('client.template.ts', defaultClientTemplate);
+    const parts = [
+        hashText(source),
+        hashText(astTemplate),
+        hashText(clientTemplate)
+    ];
+    return hashText(parts.join(':'));
+};
+const generateClientFiles = ({ ast, exportName = 'api', astModuleName = 'ast', clientModuleName = 'api' })=>{
+    const namedNodes = collectNamedNodes(ast);
+    const operations = collectOperations(ast);
+    const fieldOperations = collectFieldOperations(ast);
+    const usedNames = new Set(Array.from(namedNodes.values()).map((node)=>node.typeName));
+    const publishEvents = collectPublishEvents(ast, namedNodes);
+    const subscriptionEvents = collectSubscriptionEvents(ast, namedNodes);
+    const { definitions: typeDefinitions, fieldTypeNames } = renderTypeDefinitions(namedNodes, fieldOperations, usedNames);
+    const fieldOperationDefinitions = renderFieldOperationDefinitions(fieldOperations, namedNodes, usedNames, fieldTypeNames);
+    const { lines: operationDefinitions, clientLines } = renderOperationDefinitions(operations, namedNodes, usedNames);
+    const eventsByTopic = new Map();
+    subscriptionEvents.forEach((event)=>eventsByTopic.set(event.topic, event));
+    publishEvents.forEach((event)=>{
+        if (!eventsByTopic.has(event.topic)) eventsByTopic.set(event.topic, event);
+    });
+    const events = Array.from(eventsByTopic.values());
+    const eventMapDefinitions = renderEventMapDefinitions(events);
+    const eventTopics = events.map((event)=>event.topic);
+    const subscriptionNamesArray = Array.from(new Set(eventTopics)).map((topic)=>JSON.stringify(topic));
+    const clientImports = [
+        "import { createClient as createRuntimeClient } from '@livon/client';",
+        "import type { ClientHandlerContext, ClientModule } from '@livon/client';",
+        `import { ast } from './${astModuleName}.js';`
+    ].join('\n');
+    const clientTypeDefs = typeDefinitions.join('\n');
+    const clientEventMap = eventMapDefinitions.join('\n');
+    const clientFieldOps = fieldOperationDefinitions.join('\n');
+    const clientOpDefs = operationDefinitions.join('\n');
+    const clientOpLines = clientLines.join('\n');
+    const clientSubscriptionNames = subscriptionNamesArray.join(', ');
+    const astTemplate = readTemplate('ast.template.ts', defaultAstTemplate);
+    const clientTemplate = readTemplate('client.template.ts', defaultClientTemplate);
+    const astSource = applyTemplate(astTemplate, AST_PLACEHOLDER, serializeAst(ast), 'ast');
+    const clientSource = applyTemplateMap(clientTemplate, [
+        {
+            key: CLIENT_IMPORTS_PLACEHOLDER,
+            value: clientImports
+        },
+        {
+            key: CLIENT_TYPE_DEFS_PLACEHOLDER,
+            value: clientTypeDefs
+        },
+        {
+            key: CLIENT_EVENT_MAP_PLACEHOLDER,
+            value: clientEventMap
+        },
+        {
+            key: CLIENT_FIELD_OPS_PLACEHOLDER,
+            value: clientFieldOps
+        },
+        {
+            key: CLIENT_OP_DEFS_PLACEHOLDER,
+            value: clientOpDefs
+        },
+        {
+            key: CLIENT_OP_LINES_PLACEHOLDER,
+            value: clientOpLines
+        },
+        {
+            key: CLIENT_SUB_NAMES_PLACEHOLDER,
+            value: clientSubscriptionNames
+        },
+        {
+            key: CLIENT_EXPORT_NAME_PLACEHOLDER,
+            value: exportName
+        }
+    ], 'client');
+    const astFile = `${astModuleName}.ts`;
+    const clientFile = `${clientModuleName}.ts`;
+    return {
+        astFile,
+        clientFile,
+        files: {
+            [astFile]: astSource,
+            [clientFile]: clientSource
+        }
+    };
+};
+exports.generateClientFiles = __webpack_exports__.generateClientFiles;
+exports.getClientGeneratorFingerprint = __webpack_exports__.getClientGeneratorFingerprint;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "generateClientFiles",
+    "getClientGeneratorFingerprint"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});