@zenithbuild/cli 0.7.10 → 0.7.12

package/dist/scoped-server-data/static-props.js

@@ -0,0 +1,307 @@
+import { createRequire } from 'node:module';
+import { createScopedServerDiagnostic, SCOPED_SERVER_DIAGNOSTIC } from './diagnostics.js';
+const PACKAGE_REQUIRE = createRequire(import.meta.url);
+let TYPESCRIPT_API;
+export function parseScopedComponentStaticProps(options) {
+    const props = {};
+    const diagnostics = [];
+    const attrs = String(options.attrs || '').trim();
+    if (!attrs) {
+        return { props, diagnostics };
+    }
+    let tokens;
+    try {
+        tokens = tokenizeAttrs(attrs);
+    }
+    catch (error) {
+        diagnostics.push(createUnsupportedPropDiagnostic(options, null, error instanceof Error ? error.message : 'attribute syntax is unsupported'));
+        return { props, diagnostics };
+    }
+    for (const token of tokens) {
+        if (isEventLikeProp(token.name)) {
+            diagnostics.push(createUnsupportedPropDiagnostic(options, token.name, 'event/function props require runtime evaluation'));
+            continue;
+        }
+        if (token.valueKind === 'bare') {
+            props[token.name] = true;
+            continue;
+        }
+        if (token.valueKind === 'quoted') {
+            props[token.name] = parseQuotedAttrValue(token.value || '', token.quote || '"');
+            continue;
+        }
+        const parsed = parseLiteralExpression(token.value || '');
+        if (parsed.ok) {
+            props[token.name] = parsed.value;
+            continue;
+        }
+        diagnostics.push(createUnsupportedPropDiagnostic(options, token.name, parsed.reason));
+    }
+    return { props, diagnostics };
+}
+function tokenizeAttrs(attrs) {
+    const tokens = [];
+    let index = 0;
+    while (index < attrs.length) {
+        index = skipWhitespace(attrs, index);
+        if (index >= attrs.length) {
+            break;
+        }
+        if (attrs[index] === '{' && attrs.slice(index + 1).trimStart().startsWith('...')) {
+            throw new Error('spread props are unsupported');
+        }
+        const nameStart = index;
+        while (index < attrs.length && /[A-Za-z0-9_$:-]/.test(attrs[index])) {
+            index += 1;
+        }
+        const name = attrs.slice(nameStart, index);
+        if (!/^[A-Za-z_$][A-Za-z0-9_$:-]*$/.test(name)) {
+            throw new Error(`unsupported prop name near "${attrs.slice(nameStart, nameStart + 16).trim()}"`);
+        }
+        index = skipWhitespace(attrs, index);
+        if (attrs[index] !== '=') {
+            tokens.push({ name, valueKind: 'bare' });
+            continue;
+        }
+        index += 1;
+        index = skipWhitespace(attrs, index);
+        const quote = attrs[index];
+        if (quote === '"' || quote === "'") {
+            const parsed = readQuoted(attrs, index, quote);
+            tokens.push({ name, valueKind: 'quoted', value: parsed.value, quote });
+            index = parsed.nextIndex;
+            continue;
+        }
+        if (attrs[index] === '{') {
+            const parsed = readBraced(attrs, index);
+            tokens.push({ name, valueKind: 'expression', value: parsed.value });
+            index = parsed.nextIndex;
+            continue;
+        }
+        throw new Error(`unsupported value syntax for prop "${name}"`);
+    }
+    return tokens;
+}
+function readQuoted(source, start, quote) {
+    let index = start + 1;
+    let value = '';
+    while (index < source.length) {
+        const ch = source[index];
+        if (ch === '\\') {
+            const next = source[index + 1];
+            if (next === undefined) {
+                throw new Error('unterminated quoted prop value');
+            }
+            value += ch + next;
+            index += 2;
+            continue;
+        }
+        if (ch === quote) {
+            return { value, nextIndex: index + 1 };
+        }
+        value += ch;
+        index += 1;
+    }
+    throw new Error('unterminated quoted prop value');
+}
+function readBraced(source, start) {
+    let index = start + 1;
+    let depth = 1;
+    let mode = 'code';
+    let escaped = false;
+    while (index < source.length) {
+        const ch = source[index];
+        if (mode !== 'code') {
+            if (escaped) {
+                escaped = false;
+                index += 1;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                index += 1;
+                continue;
+            }
+            if ((mode === 'single' && ch === "'") ||
+                (mode === 'double' && ch === '"') ||
+                (mode === 'template' && ch === '`')) {
+                mode = 'code';
+            }
+            index += 1;
+            continue;
+        }
+        if (ch === "'") {
+            mode = 'single';
+            index += 1;
+            continue;
+        }
+        if (ch === '"') {
+            mode = 'double';
+            index += 1;
+            continue;
+        }
+        if (ch === '`') {
+            mode = 'template';
+            index += 1;
+            continue;
+        }
+        if (ch === '{') {
+            depth += 1;
+        }
+        else if (ch === '}') {
+            depth -= 1;
+            if (depth === 0) {
+                return { value: source.slice(start + 1, index), nextIndex: index + 1 };
+            }
+        }
+        index += 1;
+    }
+    throw new Error('unterminated braced prop expression');
+}
+function parseQuotedAttrValue(value, quote) {
+    let out = '';
+    let index = 0;
+    while (index < value.length) {
+        const ch = value[index];
+        if (ch === '\\' && value[index + 1] === quote) {
+            out += quote;
+            index += 2;
+            continue;
+        }
+        out += ch;
+        index += 1;
+    }
+    return out;
+}
+function parseLiteralExpression(expr) {
+    const ts = loadTypeScriptApi();
+    if (!ts) {
+        return { ok: false, reason: 'TypeScript parser is unavailable' };
+    }
+    const source = `const __zenith_static_prop__ = (${String(expr || '').trim()});`;
+    const sourceFile = ts.createSourceFile('zenith-scoped-static-prop.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const parseDiagnostics = sourceFile.parseDiagnostics || [];
+    if (parseDiagnostics.length > 0) {
+        return { ok: false, reason: 'expression syntax is unsupported' };
+    }
+    const statement = sourceFile.statements[0];
+    if (!statement || !ts.isVariableStatement(statement)) {
+        return { ok: false, reason: 'expression syntax is unsupported' };
+    }
+    const initializer = statement.declarationList.declarations[0]?.initializer;
+    const root = initializer && ts.isParenthesizedExpression(initializer) ? initializer.expression : initializer;
+    if (!root) {
+        return { ok: false, reason: 'expression syntax is unsupported' };
+    }
+    return literalValueFromNode(root, ts);
+}
+function literalValueFromNode(node, ts) {
+    if (ts.isParenthesizedExpression(node)) {
+        return literalValueFromNode(node.expression, ts);
+    }
+    if (ts.isStringLiteral(node)) {
+        return { ok: true, value: node.text };
+    }
+    if (ts.isNumericLiteral(node)) {
+        return { ok: true, value: Number(node.text) };
+    }
+    if (node.kind === ts.SyntaxKind.TrueKeyword) {
+        return { ok: true, value: true };
+    }
+    if (node.kind === ts.SyntaxKind.FalseKeyword) {
+        return { ok: true, value: false };
+    }
+    if (node.kind === ts.SyntaxKind.NullKeyword) {
+        return { ok: true, value: null };
+    }
+    if (ts.isPrefixUnaryExpression(node) &&
+        (node.operator === ts.SyntaxKind.MinusToken || node.operator === ts.SyntaxKind.PlusToken) &&
+        ts.isNumericLiteral(node.operand)) {
+        const value = Number(node.operand.text);
+        return { ok: true, value: node.operator === ts.SyntaxKind.MinusToken ? -value : value };
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        const out = [];
+        for (const element of node.elements) {
+            if (ts.isSpreadElement(element)) {
+                return { ok: false, reason: 'array spreads require runtime evaluation' };
+            }
+            const parsed = literalValueFromNode(element, ts);
+            if (!parsed.ok) {
+                return parsed;
+            }
+            out.push(parsed.value);
+        }
+        return { ok: true, value: out };
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+        const out = {};
+        for (const prop of node.properties) {
+            if (!ts.isPropertyAssignment(prop)) {
+                return { ok: false, reason: 'object shorthand, methods, and spreads require runtime evaluation' };
+            }
+            const key = propertyNameToString(prop.name, ts);
+            if (key == null) {
+                return { ok: false, reason: 'computed object keys require runtime evaluation' };
+            }
+            const parsed = literalValueFromNode(prop.initializer, ts);
+            if (!parsed.ok) {
+                return parsed;
+            }
+            out[key] = parsed.value;
+        }
+        return { ok: true, value: out };
+    }
+    return { ok: false, reason: unsupportedExpressionReason(node, ts) };
+}
+function propertyNameToString(name, ts) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return null;
+}
+function unsupportedExpressionReason(node, ts) {
+    if (ts.isIdentifier(node)) {
+        return 'identifiers require runtime evaluation';
+    }
+    if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {
+        return 'member expressions require runtime evaluation';
+    }
+    if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
+        return 'function calls require runtime evaluation';
+    }
+    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        return 'function values are unsupported';
+    }
+    if (ts.isTemplateExpression(node) || node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral) {
+        return 'template literals are unsupported for scoped component props';
+    }
+    return 'expression requires runtime evaluation';
+}
+function createUnsupportedPropDiagnostic(options, propName, reason) {
+    const occurrence = options.occurrenceId ? ` occurrence "${options.occurrenceId}"` : '';
+    const prop = propName ? ` prop "${propName}"` : ' prop expression';
+    return createScopedServerDiagnostic(SCOPED_SERVER_DIAGNOSTIC.UNSUPPORTED_COMPONENT_PROP, 'error', `Unsupported scoped component prop expression for "${options.ownerKey}"${occurrence}${prop}: ${reason}.`, options.contextFile);
+}
+function isEventLikeProp(name) {
+    return name.startsWith('on:') || /^on[A-Z]/.test(name);
+}
+function skipWhitespace(source, index) {
+    let cursor = index;
+    while (cursor < source.length && /\s/.test(source[cursor])) {
+        cursor += 1;
+    }
+    return cursor;
+}
+function loadTypeScriptApi() {
+    if (TYPESCRIPT_API !== undefined) {
+        return TYPESCRIPT_API;
+    }
+    try {
+        TYPESCRIPT_API = PACKAGE_REQUIRE('typescript');
+    }
+    catch {
+        TYPESCRIPT_API = null;
+    }
+    return TYPESCRIPT_API;
+}

package/dist/scoped-server-data/type-declarations.d.ts

@@ -0,0 +1,10 @@
+import type { ManifestScopedServerDataEntry } from './types.js';
+interface RouteManifestEntry {
+    scoped_server_data?: ManifestScopedServerDataEntry[];
+}
+export interface RenderScopedServerDataDtsOptions {
+    manifest: RouteManifestEntry[];
+    srcDir: string;
+}
+export declare function renderScopedServerDataDts(options: RenderScopedServerDataDtsOptions): string;
+export {};

package/dist/scoped-server-data/type-declarations.js

@@ -0,0 +1,368 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { isAbsolute, resolve, sep } from 'node:path';
+import { partitionScriptBlocks } from './parse-owner-server-block.js';
+const PACKAGE_REQUIRE = createRequire(import.meta.url);
+let TYPESCRIPT_API;
+export function renderScopedServerDataDts(options) {
+    const srcDir = resolve(String(options.srcDir || ''));
+    const entries = collectScopedEntries(options.manifest);
+    const owners = new Map();
+    const runtimeKeys = new Map();
+    for (const entry of entries) {
+        if (!entry || typeof entry.ownerKey !== 'string' || entry.ownerKey.length === 0) {
+            continue;
+        }
+        if (!owners.has(entry.ownerKey)) {
+            owners.set(entry.ownerKey, entry);
+        }
+        for (const key of runtimeKeysForEntry(entry)) {
+            if (!runtimeKeys.has(key)) {
+                runtimeKeys.set(key, entry.ownerKey);
+            }
+        }
+    }
+    const ownerDeclarations = [...owners.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, entry]) => ({
+        key,
+        type: inferOwnerType(entry, resolveOwnerFilePath(key, srcDir))
+    }));
+    const runtimeDeclarations = [...runtimeKeys.entries()]
+        .sort(([a], [b]) => a.localeCompare(b));
+    return renderDts(ownerDeclarations, runtimeDeclarations);
+}
+function collectScopedEntries(manifest) {
+    const entries = [];
+    for (const route of Array.isArray(manifest) ? manifest : []) {
+        const scoped = Array.isArray(route?.scoped_server_data) ? route.scoped_server_data : [];
+        for (const entry of scoped) {
+            entries.push(entry);
+        }
+    }
+    return entries;
+}
+function runtimeKeysForEntry(entry) {
+    if (entry.ownerKind === 'layout') {
+        return [`layout:${entry.ownerKey}`];
+    }
+    if (entry.ownerKind === 'component' && entry.instanceStrategy === 'per-instance') {
+        return Array.isArray(entry.instances)
+            ? entry.instances.map((item) => item.key).filter((key) => typeof key === 'string' && key.length > 0)
+            : [];
+    }
+    if (entry.ownerKind === 'component') {
+        return [`component:${entry.ownerKey}`];
+    }
+    return [];
+}
+function resolveOwnerFilePath(ownerKey, srcDir) {
+    const raw = String(ownerKey || '').replace(/\\/g, '/');
+    if (!raw || isAbsolute(raw) || /^[A-Za-z]:[\\/]/.test(raw)) {
+        return null;
+    }
+    const relative = raw.startsWith('src/') ? raw.slice(4) : raw;
+    const parts = relative.split('/');
+    if (parts.some((part) => part.length === 0 || part === '.' || part === '..')) {
+        return null;
+    }
+    const resolved = resolve(srcDir, ...parts);
+    if (resolved !== srcDir && !resolved.startsWith(`${srcDir}${sep}`)) {
+        return null;
+    }
+    return resolved;
+}
+function inferOwnerType(entry, ownerPath) {
+    if (!ownerPath || !existsSync(ownerPath)) {
+        return entry.syntax === 'explicit-data' ? 'Record<string, unknown>' : variablesType(entry, new Map());
+    }
+    const ts = loadTypeScriptApi();
+    if (!ts) {
+        return entry.syntax === 'explicit-data' ? 'Record<string, unknown>' : variablesType(entry, new Map());
+    }
+    const source = readFileSync(ownerPath, 'utf8');
+    const serverBody = readSingleServerBody(source);
+    if (!serverBody) {
+        return entry.syntax === 'explicit-data' ? 'Record<string, unknown>' : variablesType(entry, new Map());
+    }
+    const sourceFile = ts.createSourceFile(ownerPath, serverBody, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    if (entry.syntax === 'explicit-data') {
+        return inferExplicitDataType(sourceFile, ts);
+    }
+    const variableTypes = inferTopLevelVariableTypes(sourceFile, ts, serverBody);
+    return variablesType(entry, variableTypes);
+}
+function readSingleServerBody(source) {
+    const { serverBlocks } = partitionScriptBlocks(source);
+    return serverBlocks.length === 1 ? String(serverBlocks[0]?.body || '').trim() : '';
+}
+function inferTopLevelVariableTypes(sourceFile, ts, source) {
+    const out = new Map();
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement)) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name)) {
+                continue;
+            }
+            const annotated = declaration.type ? safeTypeAnnotation(declaration.type, ts, source) : null;
+            const inferred = annotated || (declaration.initializer ? inferExpressionType(declaration.initializer, ts) : null);
+            out.set(declaration.name.text, inferred || 'unknown');
+        }
+    }
+    return out;
+}
+function inferExplicitDataType(sourceFile, ts) {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement)) {
+            continue;
+        }
+        const hasExport = statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+        if (!hasExport) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name) || declaration.name.text !== 'data') {
+                continue;
+            }
+            const inferred = declaration.initializer ? inferDataInitializerReturn(declaration.initializer, ts) : null;
+            return inferred && inferred.startsWith('{') ? inferred : 'Record<string, unknown>';
+        }
+    }
+    return 'Record<string, unknown>';
+}
+function inferDataInitializerReturn(node, ts) {
+    const target = unwrapExpression(node, ts);
+    if (ts.isArrowFunction(target) || ts.isFunctionExpression(target)) {
+        if (target.type) {
+            const annotated = safeScopedDataReturnAnnotation(target.type, ts, target.getSourceFile().text);
+            if (annotated && annotated.startsWith('{')) {
+                return annotated;
+            }
+        }
+        if (ts.isBlock(target.body)) {
+            const returned = singleReturnExpression(target.body, ts);
+            return returned ? inferExpressionType(returned, ts) : null;
+        }
+        return inferExpressionType(target.body, ts);
+    }
+    return null;
+}
+function singleReturnExpression(block, ts) {
+    const returns = block.statements.filter(ts.isReturnStatement);
+    if (returns.length !== 1) {
+        return null;
+    }
+    return returns[0].expression || null;
+}
+function inferExpressionType(node, ts) {
+    const expr = unwrapExpression(node, ts);
+    if (ts.isStringLiteral(expr) || expr.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral) {
+        return 'string';
+    }
+    if (ts.isNumericLiteral(expr)) {
+        return 'number';
+    }
+    if (expr.kind === ts.SyntaxKind.TrueKeyword || expr.kind === ts.SyntaxKind.FalseKeyword) {
+        return 'boolean';
+    }
+    if (expr.kind === ts.SyntaxKind.NullKeyword) {
+        return 'null';
+    }
+    if (ts.isPrefixUnaryExpression(expr) &&
+        (expr.operator === ts.SyntaxKind.MinusToken || expr.operator === ts.SyntaxKind.PlusToken) &&
+        ts.isNumericLiteral(expr.operand)) {
+        return 'number';
+    }
+    if (ts.isObjectLiteralExpression(expr)) {
+        return inferObjectType(expr, ts);
+    }
+    if (ts.isArrayLiteralExpression(expr)) {
+        return inferArrayType(expr, ts);
+    }
+    return null;
+}
+function inferObjectType(node, ts) {
+    const fields = [];
+    for (const prop of node.properties) {
+        if (!ts.isPropertyAssignment(prop)) {
+            return null;
+        }
+        const name = propertyNameToString(prop.name, ts);
+        if (name == null) {
+            return null;
+        }
+        const valueType = inferExpressionType(prop.initializer, ts);
+        if (!valueType) {
+            return null;
+        }
+        fields.push(`${safePropertyName(name)}: ${valueType};`);
+    }
+    return `{ ${fields.join(' ')} }`;
+}
+function inferArrayType(node, ts) {
+    const elementTypes = [];
+    for (const element of node.elements) {
+        if (ts.isSpreadElement(element)) {
+            return null;
+        }
+        const type = inferExpressionType(element, ts);
+        if (!type) {
+            return null;
+        }
+        if (!elementTypes.includes(type)) {
+            elementTypes.push(type);
+        }
+    }
+    if (elementTypes.length === 0) {
+        return 'unknown[]';
+    }
+    return elementTypes.length === 1 ? `${elementTypes[0]}[]` : `Array<${elementTypes.join(' | ')}>`;
+}
+function safeTypeAnnotation(node, ts, source) {
+    if (node.kind === ts.SyntaxKind.StringKeyword ||
+        node.kind === ts.SyntaxKind.NumberKeyword ||
+        node.kind === ts.SyntaxKind.BooleanKeyword ||
+        node.kind === ts.SyntaxKind.UnknownKeyword) {
+        return node.getText();
+    }
+    if (ts.isLiteralTypeNode(node)) {
+        return literalTypeText(node, ts);
+    }
+    if (ts.isArrayTypeNode(node)) {
+        const item = safeTypeAnnotation(node.elementType, ts, source);
+        return item ? `${item}[]` : null;
+    }
+    if (ts.isTupleTypeNode(node)) {
+        const items = node.elements.map((item) => safeTypeAnnotation(item, ts, source));
+        return items.every(Boolean) ? `[${items.join(', ')}]` : null;
+    }
+    if (ts.isUnionTypeNode(node)) {
+        const items = node.types.map((item) => safeTypeAnnotation(item, ts, source));
+        return items.every(Boolean) ? items.join(' | ') : null;
+    }
+    if (ts.isTypeLiteralNode(node)) {
+        return safeTypeLiteral(node, ts, source);
+    }
+    return null;
+}
+function safeScopedDataReturnAnnotation(node, ts, source) {
+    if (ts.isTypeReferenceNode(node) && isPromiseLikeTypeReference(node, ts)) {
+        const inner = node.typeArguments?.[0];
+        return inner ? safeTypeAnnotation(inner, ts, source) : null;
+    }
+    return safeTypeAnnotation(node, ts, source);
+}
+function isPromiseLikeTypeReference(node, ts) {
+    if (!ts.isIdentifier(node.typeName)) {
+        return false;
+    }
+    return node.typeName.text === 'Promise' || node.typeName.text === 'PromiseLike';
+}
+function safeTypeLiteral(node, ts, source) {
+    const fields = [];
+    for (const member of node.members) {
+        if (!ts.isPropertySignature(member) || !member.type || !member.name) {
+            return null;
+        }
+        const name = propertyNameToString(member.name, ts);
+        const type = safeTypeAnnotation(member.type, ts, source);
+        if (name == null || !type) {
+            return null;
+        }
+        fields.push(`${safePropertyName(name)}${member.questionToken ? '?' : ''}: ${type};`);
+    }
+    return `{ ${fields.join(' ')} }`;
+}
+function literalTypeText(node, ts) {
+    const literal = node.literal;
+    if (ts.isStringLiteral(literal)) {
+        return JSON.stringify(literal.text);
+    }
+    if (ts.isNumericLiteral(literal)) {
+        return literal.text;
+    }
+    if (literal.kind === ts.SyntaxKind.TrueKeyword) {
+        return 'true';
+    }
+    if (literal.kind === ts.SyntaxKind.FalseKeyword) {
+        return 'false';
+    }
+    if (literal.kind === ts.SyntaxKind.NullKeyword) {
+        return 'null';
+    }
+    if (ts.isPrefixUnaryExpression(literal) && ts.isNumericLiteral(literal.operand)) {
+        return literal.getText();
+    }
+    return null;
+}
+function variablesType(entry, variableTypes) {
+    const names = Array.isArray(entry.serializedVariableNames) ? [...entry.serializedVariableNames].sort() : [];
+    if (names.length === 0) {
+        return '{}';
+    }
+    const fields = names.map((name) => `${safePropertyName(name)}: ${variableTypes.get(name) || 'unknown'};`);
+    return `{ ${fields.join(' ')} }`;
+}
+function renderDts(owners, runtimeEntries) {
+    const lines = [
+        '// Auto-generated by Zenith CLI. Do not edit manually.',
+        'export {};',
+        '',
+        'declare global {',
+        '  namespace Zenith {',
+        '    interface ScopedServerDataOwnerMap {'
+    ];
+    for (const owner of owners) {
+        lines.push(`      ${JSON.stringify(owner.key)}: ${owner.type};`);
+    }
+    lines.push('    }');
+    lines.push('');
+    lines.push('    interface ScopedServerDataRuntimeMap {');
+    for (const [runtimeKey, ownerKey] of runtimeEntries) {
+        lines.push(`      ${JSON.stringify(runtimeKey)}: ScopedServerDataOwnerMap[${JSON.stringify(ownerKey)}];`);
+    }
+    lines.push('    }');
+    lines.push('');
+    lines.push('    type ScopedServerDataFor<K extends keyof ScopedServerDataOwnerMap> =');
+    lines.push('      ScopedServerDataOwnerMap[K];');
+    lines.push('');
+    lines.push('    type ScopedServerRuntimeDataFor<K extends keyof ScopedServerDataRuntimeMap> =');
+    lines.push('      ScopedServerDataRuntimeMap[K];');
+    lines.push('  }');
+    lines.push('}');
+    lines.push('');
+    return `${lines.join('\n')}\n`;
+}
+function unwrapExpression(node, ts) {
+    let current = node;
+    while (ts.isParenthesizedExpression(current) ||
+        ts.isAsExpression(current) ||
+        ts.isTypeAssertionExpression(current) ||
+        ts.isSatisfiesExpression(current)) {
+        current = current.expression;
+    }
+    return current;
+}
+function propertyNameToString(name, ts) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        return name.text;
+    }
+    return null;
+}
+function safePropertyName(name) {
+    return /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function loadTypeScriptApi() {
+    if (TYPESCRIPT_API !== undefined) {
+        return TYPESCRIPT_API;
+    }
+    try {
+        TYPESCRIPT_API = PACKAGE_REQUIRE('typescript');
+    }
+    catch {
+        TYPESCRIPT_API = null;
+    }
+    return TYPESCRIPT_API;
+}