@tsonic/cli 0.0.72 → 0.0.74

package/dist/commands/library-bindings-firstparty.js

@@ -17,6 +17,82 @@ const ensureUndefinedInType = (typeText) => {
         return trimmed;
     return `${trimmed} | undefined`;
 };
+const textContainsIdentifier = (text, identifier) => {
+    const escaped = identifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(^|[^A-Za-z0-9_$])${escaped}([^A-Za-z0-9_$]|$)`).test(text);
+};
+const toRelativeImportSpecifier = (fromFile, targetFile) => {
+    const relative = posix.relative(posix.dirname(fromFile), targetFile);
+    if (relative.startsWith("."))
+        return relative;
+    return `./${relative}`;
+};
+const namespaceInternalImportSpecifier = (fromNamespace, targetNamespace) => {
+    return toRelativeImportSpecifier(posix.join(moduleNamespacePath(fromNamespace), "internal", "index.js"), posix.join(moduleNamespacePath(targetNamespace), "internal", "index.js"));
+};
+const namespaceFacadeImportSpecifier = (fromNamespace, targetNamespace) => {
+    return toRelativeImportSpecifier(`${moduleNamespacePath(fromNamespace)}.js`, `${moduleNamespacePath(targetNamespace)}.js`);
+};
+const resolveSourceTypeImportBinding = (opts) => {
+    const source = opts.imported.source.trim();
+    if (source === "@tsonic/core/types.js") {
+        return { ok: true, value: undefined };
+    }
+    if (!isRelativeModuleSpecifier(source)) {
+        return {
+            ok: true,
+            value: {
+                source,
+                importedName: opts.imported.importedName,
+                localName: opts.localName,
+            },
+        };
+    }
+    const targetModule = resolveLocalModuleFile(source, opts.currentModuleKey, opts.modulesByFileKey);
+    if (!targetModule) {
+        return {
+            ok: false,
+            error: `Unable to resolve source type import '${opts.localName}' from '${source}' in ${opts.currentModuleKey}.\n` +
+                "First-party bindings generation requires public type dependencies to resolve deterministically.",
+        };
+    }
+    if (targetModule.namespace === opts.currentNamespace) {
+        return { ok: true, value: undefined };
+    }
+    return {
+        ok: true,
+        value: {
+            source: opts.context === "internal"
+                ? namespaceInternalImportSpecifier(opts.currentNamespace, targetModule.namespace)
+                : namespaceFacadeImportSpecifier(opts.currentNamespace, targetModule.namespace),
+            importedName: opts.imported.importedName,
+            localName: opts.localName,
+        },
+    };
+};
+const registerSourceTypeImportBinding = (registry, binding, namespace, moduleFilePath) => {
+    const existing = registry.get(binding.localName);
+    if (existing) {
+        if (existing.source !== binding.source ||
+            existing.importedName !== binding.importedName) {
+            return {
+                ok: false,
+                error: `Conflicting source type import alias '${binding.localName}' while generating namespace ${namespace} from ${moduleFilePath}.\n` +
+                    `- ${existing.importedName} from '${existing.source}'\n` +
+                    `- ${binding.importedName} from '${binding.source}'\n` +
+                    "Disambiguate source type imports so generated bindings remain deterministic.",
+            };
+        }
+        return { ok: true, value: undefined };
+    }
+    registry.set(binding.localName, binding);
+    return { ok: true, value: undefined };
+};
+const selectSourceTypeImportsForRenderedText = (renderedText, candidates) => {
+    return candidates
+        .filter((candidate) => textContainsIdentifier(renderedText, candidate.localName))
+        .sort((left, right) => left.localName.localeCompare(right.localName));
+};
 const applyWrappersToBaseType = (baseType, wrappers) => {
     let expr = baseType.trim();
     for (const w of wrappers.slice().reverse()) {
@@ -35,6 +111,11 @@ const sanitizeForBrand = (value) => {
     const normalized = value.replace(/[^A-Za-z0-9_]/g, "_");
     return normalized.length > 0 ? normalized : "_";
 };
+const renderBindingAliasMarker = (namespace, bindingAlias) => `    readonly ${JSON.stringify(`__tsonic_binding_alias_${namespace}.${bindingAlias}`)}?: never;`;
+const isPortableMarkerMemberName = (name) => name === "__brand" ||
+    name.startsWith("__tsonic_type_") ||
+    name.startsWith("__tsonic_iface_") ||
+    name.startsWith("__tsonic_binding_alias_");
 const printTypeParameters = (typeParameters) => {
     if (!typeParameters || typeParameters.length === 0)
         return "";
@@ -53,7 +134,7 @@ const normalizeTypeReferenceName = (name, arity) => {
     }
     return `${backtickNormalized}_${arity}`;
 };
-const renderReferenceType = (referenceName, typeArguments, typeParametersInScope) => {
+const renderReferenceType = (referenceName, typeArguments, typeParametersInScope, localTypeNameRemaps = new Map()) => {
     if (typeParametersInScope.includes(referenceName))
         return referenceName;
     if (referenceName === "unknown")
@@ -68,7 +149,8 @@ const renderReferenceType = (referenceName, typeArguments, typeParametersInScope
         return "boolean";
     if (referenceName === "number")
         return "number";
-    let normalizedName = normalizeTypeReferenceName(referenceName);
+    const effectiveReferenceName = localTypeNameRemaps.get(referenceName) ?? referenceName;
+    let normalizedName = normalizeTypeReferenceName(effectiveReferenceName);
     if (typeArguments && typeArguments.length > 0) {
         const arityMatch = normalizedName.match(/_(\d+)$/);
         if (arityMatch &&
@@ -86,80 +168,124 @@ const renderReferenceType = (referenceName, typeArguments, typeParametersInScope
     if (!typeArguments || typeArguments.length === 0)
         return normalizedName;
     return `${normalizedName}<${typeArguments
-        .map((arg) => renderPortableType(arg, typeParametersInScope))
+        .map((arg) => renderPortableType(arg, typeParametersInScope, localTypeNameRemaps))
         .join(", ")}>`;
 };
-const renderPortableType = (type, typeParametersInScope = []) => {
+const renderPortableType = (type, typeParametersInScope = [], localTypeNameRemaps = new Map(), anonymousStructuralAliases = new Map()) => {
+    const renderPortableShapeType = (shapeType, shapeTypeParametersInScope = []) => {
+        if (!shapeType)
+            return "object";
+        switch (shapeType.kind) {
+            case "primitiveType":
+                return shapeType.name;
+            case "literalType":
+                return typeof shapeType.value === "string"
+                    ? JSON.stringify(shapeType.value)
+                    : String(shapeType.value);
+            case "voidType":
+                return "void";
+            case "neverType":
+                return "never";
+            case "unknownType":
+            case "anyType":
+                return "unknown";
+            case "typeParameterType":
+                return shapeType.name;
+            case "arrayType":
+                return `${renderPortableShapeType(shapeType.elementType, shapeTypeParametersInScope)}[]`;
+            case "tupleType":
+                return `[${shapeType.elementTypes
+                    .map((item) => renderPortableShapeType(item, shapeTypeParametersInScope))
+                    .join(", ")}]`;
+            case "unionType":
+                return shapeType.types
+                    .map((item) => renderPortableShapeType(item, shapeTypeParametersInScope))
+                    .join(" | ");
+            case "intersectionType":
+                return shapeType.types
+                    .map((item) => renderPortableShapeType(item, shapeTypeParametersInScope))
+                    .join(" & ");
+            case "dictionaryType":
+                return `Record<${renderPortableShapeType(shapeType.keyType, shapeTypeParametersInScope)}, ${renderPortableShapeType(shapeType.valueType, shapeTypeParametersInScope)}>`;
+            case "functionType":
+                return `(${shapeType.parameters
+                    .map((parameter, index) => {
+                    const parameterName = parameter.pattern.kind === "identifierPattern"
+                        ? parameter.pattern.name
+                        : `p${index + 1}`;
+                    return `${parameterName}: ${renderPortableShapeType(parameter.type, shapeTypeParametersInScope)}`;
+                })
+                    .join(", ")}) => ${renderPortableShapeType(shapeType.returnType, shapeTypeParametersInScope)}`;
+            case "objectType":
+                return `{ ${shapeType.members
+                    .filter((member) => !isPortableMarkerMemberName(member.name))
+                    .map((member) => {
+                    if (member.kind === "methodSignature") {
+                        return `${member.name}${printTypeParameters(member.typeParameters)}(${member.parameters
+                            .map((parameter, index) => {
+                            const parameterName = parameter.pattern.kind === "identifierPattern"
+                                ? parameter.pattern.name
+                                : `p${index + 1}`;
+                            const optionalMark = parameter.isOptional ? "?" : "";
+                            return `${parameterName}${optionalMark}: ${renderPortableShapeType(parameter.type, shapeTypeParametersInScope)}`;
+                        })
+                            .join(", ")}): ${renderPortableShapeType(member.returnType, shapeTypeParametersInScope)}`;
+                    }
+                    const optionalMark = member.isOptional ? "?" : "";
+                    const readonlyMark = member.isReadonly ? "readonly " : "";
+                    return `${readonlyMark}${member.name}${optionalMark}: ${renderPortableShapeType(member.type, shapeTypeParametersInScope)}`;
+                })
+                    .join("; ")} }`;
+            case "referenceType":
+                return renderReferenceType(shapeType.name, shapeType.typeArguments, shapeTypeParametersInScope, localTypeNameRemaps);
+            default:
+                return "object";
+        }
+    };
     if (!type)
         return "object";
     switch (type.kind) {
-        case "primitiveType":
-            return type.name;
-        case "literalType":
-            return typeof type.value === "string"
-                ? JSON.stringify(type.value)
-                : String(type.value);
-        case "voidType":
-            return "void";
-        case "neverType":
-            return "never";
-        case "unknownType":
-        case "anyType":
-            return "unknown";
-        case "typeParameterType":
-            return type.name;
+        case "objectType": {
+            const shape = renderPortableShapeType(type, typeParametersInScope);
+            const alias = anonymousStructuralAliases.get(shape);
+            if (alias) {
+                const typeArgs = alias.typeParameters.length > 0
+                    ? `<${alias.typeParameters.join(", ")}>`
+                    : "";
+                return `${alias.name}${typeArgs}`;
+            }
+            return shape;
+        }
         case "arrayType":
-            return `${renderPortableType(type.elementType, typeParametersInScope)}[]`;
+            return `${renderPortableType(type.elementType, typeParametersInScope, localTypeNameRemaps, anonymousStructuralAliases)}[]`;
         case "tupleType":
             return `[${type.elementTypes
-                .map((item) => renderPortableType(item, typeParametersInScope))
+                .map((item) => renderPortableType(item, typeParametersInScope, localTypeNameRemaps, anonymousStructuralAliases))
                 .join(", ")}]`;
         case "unionType":
             return type.types
-                .map((item) => renderPortableType(item, typeParametersInScope))
+                .map((item) => renderPortableType(item, typeParametersInScope, localTypeNameRemaps, anonymousStructuralAliases))
                 .join(" | ");
         case "intersectionType":
             return type.types
-                .map((item) => renderPortableType(item, typeParametersInScope))
+                .map((item) => renderPortableType(item, typeParametersInScope, localTypeNameRemaps, anonymousStructuralAliases))
                 .join(" & ");
         case "dictionaryType":
-            return `Record<${renderPortableType(type.keyType, typeParametersInScope)}, ${renderPortableType(type.valueType, typeParametersInScope)}>`;
+            return `Record<${renderPortableType(type.keyType, typeParametersInScope, localTypeNameRemaps, anonymousStructuralAliases)}, ${renderPortableType(type.valueType, typeParametersInScope, localTypeNameRemaps, anonymousStructuralAliases)}>`;
         case "functionType":
             return `(${type.parameters
                 .map((parameter, index) => {
                 const parameterName = parameter.pattern.kind === "identifierPattern"
                     ? parameter.pattern.name
                     : `p${index + 1}`;
-                return `${parameterName}: ${renderPortableType(parameter.type, typeParametersInScope)}`;
+                return `${parameterName}: ${renderPortableType(parameter.type, typeParametersInScope, localTypeNameRemaps, anonymousStructuralAliases)}`;
             })
-                .join(", ")}) => ${renderPortableType(type.returnType, typeParametersInScope)}`;
-        case "objectType":
-            return `{ ${type.members
-                .map((member) => {
-                if (member.kind === "methodSignature") {
-                    return `${member.name}${printTypeParameters(member.typeParameters)}(${member.parameters
-                        .map((parameter, index) => {
-                        const parameterName = parameter.pattern.kind === "identifierPattern"
-                            ? parameter.pattern.name
-                            : `p${index + 1}`;
-                        const optionalMark = parameter.isOptional ? "?" : "";
-                        return `${parameterName}${optionalMark}: ${renderPortableType(parameter.type, typeParametersInScope)}`;
-                    })
-                        .join(", ")}): ${renderPortableType(member.returnType, typeParametersInScope)}`;
-                }
-                const optionalMark = member.isOptional ? "?" : "";
-                const readonlyMark = member.isReadonly ? "readonly " : "";
-                return `${readonlyMark}${member.name}${optionalMark}: ${renderPortableType(member.type, typeParametersInScope)}`;
-            })
-                .join("; ")} }`;
-        case "referenceType": {
-            return renderReferenceType(type.name, type.typeArguments, typeParametersInScope);
-        }
+                .join(", ")}) => ${renderPortableType(type.returnType, typeParametersInScope, localTypeNameRemaps, anonymousStructuralAliases)}`;
         default:
-            return "object";
+            return renderPortableShapeType(type, typeParametersInScope);
     }
 };
-const renderUnknownParameters = (parameters, typeParametersInScope) => {
+const renderUnknownParameters = (parameters, typeParametersInScope, localTypeNameRemaps = new Map(), anonymousStructuralAliases = new Map()) => {
     return parameters
         .map((parameter, index) => {
         const baseName = parameter.pattern.kind === "identifierPattern"
@@ -167,7 +293,7 @@ const renderUnknownParameters = (parameters, typeParametersInScope) => {
             : `p${index + 1}`;
         const restPrefix = parameter.isRest ? "..." : "";
         const optionalMark = parameter.isOptional && !parameter.isRest ? "?" : "";
-        const parameterType = renderPortableType(parameter.type, typeParametersInScope);
+        const parameterType = renderPortableType(parameter.type, typeParametersInScope, localTypeNameRemaps, anonymousStructuralAliases);
         const typeSuffix = parameter.isRest
             ? `${parameterType}[]`
             : parameterType;
@@ -175,13 +301,405 @@ const renderUnknownParameters = (parameters, typeParametersInScope) => {
     })
         .join(", ");
 };
-const renderMethodSignature = (name, typeParameters, parameters, returnType) => {
+const renderMethodSignature = (name, typeParameters, parameters, returnType, localTypeNameRemaps = new Map(), anonymousStructuralAliases = new Map()) => {
     const typeParametersText = printTypeParameters(typeParameters);
     const typeParameterNames = typeParameters?.map((typeParameter) => typeParameter.name) ?? [];
-    const parametersText = renderUnknownParameters(parameters, typeParameterNames);
-    const returnTypeText = renderPortableType(returnType, typeParameterNames);
+    const parametersText = renderUnknownParameters(parameters, typeParameterNames, localTypeNameRemaps, anonymousStructuralAliases);
+    const returnTypeText = renderPortableType(returnType, typeParameterNames, localTypeNameRemaps, anonymousStructuralAliases);
     return `${name}${typeParametersText}(${parametersText}): ${returnTypeText};`;
 };
+const renderSourceTypeNodeForAliasLookup = (node, localTypeNameRemaps) => {
+    switch (node.kind) {
+        case ts.SyntaxKind.StringKeyword:
+            return "string";
+        case ts.SyntaxKind.NumberKeyword:
+            return "number";
+        case ts.SyntaxKind.BooleanKeyword:
+            return "boolean";
+        case ts.SyntaxKind.VoidKeyword:
+            return "void";
+        case ts.SyntaxKind.NeverKeyword:
+            return "never";
+        case ts.SyntaxKind.UnknownKeyword:
+            return "unknown";
+        case ts.SyntaxKind.AnyKeyword:
+            return "unknown";
+        case ts.SyntaxKind.NullKeyword:
+            return "null";
+        case ts.SyntaxKind.UndefinedKeyword:
+            return "undefined";
+    }
+    if (ts.isParenthesizedTypeNode(node)) {
+        return `(${renderSourceTypeNodeForAliasLookup(node.type, localTypeNameRemaps)})`;
+    }
+    if (ts.isArrayTypeNode(node)) {
+        return `${renderSourceTypeNodeForAliasLookup(node.elementType, localTypeNameRemaps)}[]`;
+    }
+    if (ts.isTupleTypeNode(node)) {
+        return `[${node.elements
+            .map((element) => renderSourceTypeNodeForAliasLookup(element, localTypeNameRemaps))
+            .join(", ")}]`;
+    }
+    if (ts.isUnionTypeNode(node)) {
+        return node.types
+            .map((part) => renderSourceTypeNodeForAliasLookup(part, localTypeNameRemaps))
+            .join(" | ");
+    }
+    if (ts.isIntersectionTypeNode(node)) {
+        return node.types
+            .map((part) => renderSourceTypeNodeForAliasLookup(part, localTypeNameRemaps))
+            .join(" & ");
+    }
+    if (ts.isLiteralTypeNode(node)) {
+        return node.getText();
+    }
+    if (ts.isTypeReferenceNode(node)) {
+        const typeNameText = node.typeName.getText();
+        const rewrittenTypeName = rewriteSourceTypeText(typeNameText, localTypeNameRemaps);
+        if (!node.typeArguments || node.typeArguments.length === 0) {
+            return rewrittenTypeName;
+        }
+        return `${rewrittenTypeName}<${node.typeArguments
+            .map((argument) => renderSourceTypeNodeForAliasLookup(argument, localTypeNameRemaps))
+            .join(", ")}>`;
+    }
+    if (ts.isTypeLiteralNode(node)) {
+        return `{ ${node.members
+            .flatMap((member) => {
+            if (ts.isPropertySignature(member)) {
+                const propertyName = ts.isIdentifier(member.name)
+                    ? member.name.text
+                    : ts.isStringLiteral(member.name)
+                        ? member.name.text
+                        : undefined;
+                if (!propertyName || !member.type)
+                    return [];
+                const readonlyMark = (member.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false)
+                    ? "readonly "
+                    : "";
+                const propertyTypeText = member.questionToken
+                    ? ensureUndefinedInType(renderSourceTypeNodeForAliasLookup(member.type, localTypeNameRemaps))
+                    : renderSourceTypeNodeForAliasLookup(member.type, localTypeNameRemaps);
+                return [`${readonlyMark}${propertyName}: ${propertyTypeText}`];
+            }
+            if (ts.isMethodSignature(member)) {
+                const methodName = ts.isIdentifier(member.name)
+                    ? member.name.text
+                    : ts.isStringLiteral(member.name)
+                        ? member.name.text
+                        : undefined;
+                if (!methodName)
+                    return [];
+                const typeParametersText = member.typeParameters
+                    ? `<${member.typeParameters
+                        .map((typeParameter) => typeParameter.name.text)
+                        .join(", ")}>`
+                    : "";
+                const parametersText = member.parameters
+                    .map((parameter, index) => {
+                    const parameterName = ts.isIdentifier(parameter.name)
+                        ? parameter.name.text
+                        : `p${index + 1}`;
+                    const optionalMark = parameter.questionToken ? "?" : "";
+                    const restPrefix = parameter.dotDotDotToken ? "..." : "";
+                    const parameterType = parameter.type
+                        ? renderSourceTypeNodeForAliasLookup(parameter.type, localTypeNameRemaps)
+                        : "unknown";
+                    return `${restPrefix}${parameterName}${optionalMark}: ${parameterType}`;
+                })
+                    .join(", ");
+                const returnType = member.type
+                    ? renderSourceTypeNodeForAliasLookup(member.type, localTypeNameRemaps)
+                    : "void";
+                return [
+                    `${methodName}${typeParametersText}(${parametersText}): ${returnType}`,
+                ];
+            }
+            return [];
+        })
+            .join("; ")} }`;
+    }
+    return node.getText();
+};
+const rewriteSourceTypeText = (typeText, localTypeNameRemaps, anonymousStructuralAliases = new Map()) => {
+    const sourceFile = ts.createSourceFile("__tsonic_source_type__.ts", `type __T = ${typeText};`, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const statement = sourceFile.statements[0];
+    if (!statement || !ts.isTypeAliasDeclaration(statement))
+        return typeText;
+    const transformer = (context) => {
+        const visit = (node) => {
+            if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName)) {
+                const remappedName = localTypeNameRemaps.get(node.typeName.text);
+                if (remappedName) {
+                    return ts.factory.updateTypeReferenceNode(node, ts.factory.createIdentifier(remappedName), node.typeArguments);
+                }
+            }
+            if (anonymousStructuralAliases.size > 0 && ts.isTypeLiteralNode(node)) {
+                const alias = anonymousStructuralAliases.get(renderSourceTypeNodeForAliasLookup(node, localTypeNameRemaps));
+                if (alias) {
+                    return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(alias.name), alias.typeParameters.map((typeParameter) => ts.factory.createTypeReferenceNode(typeParameter)));
+                }
+            }
+            return ts.visitEachChild(node, visit, context);
+        };
+        return (node) => ts.visitNode(node, visit);
+    };
+    const transformed = ts.transform(statement.type, [transformer])
+        .transformed[0];
+    if (!transformed)
+        return typeText;
+    const printer = ts.createPrinter({ removeComments: true });
+    return printer.printNode(ts.EmitHint.Unspecified, transformed, sourceFile);
+};
+const selectPreferredSourceFunctionSignature = (opts) => {
+    const targetTypeParameterCount = opts.declaration.typeParameters?.length ?? 0;
+    const targetParameterCount = opts.declaration.parameters.length;
+    const exact = opts.sourceSignatures.find((signature) => {
+        return (signature.parameters.length === targetParameterCount &&
+            signature.typeParameterCount === targetTypeParameterCount);
+    });
+    return exact ?? opts.sourceSignatures[0];
+};
+const renderSourceFunctionSignature = (opts) => {
+    const sourceSignature = selectPreferredSourceFunctionSignature({
+        declaration: opts.declaration,
+        sourceSignatures: opts.sourceSignatures,
+    });
+    if (!sourceSignature)
+        return undefined;
+    const parametersText = sourceSignature.parameters
+        .map((parameter) => `${parameter.prefixText}${rewriteSourceTypeText(parameter.typeText, opts.localTypeNameRemaps, opts.anonymousStructuralAliases)}`)
+        .join(", ");
+    return {
+        typeParametersText: sourceSignature.typeParametersText,
+        parametersText,
+        returnTypeText: rewriteSourceTypeText(sourceSignature.returnTypeText, opts.localTypeNameRemaps, opts.anonymousStructuralAliases),
+    };
+};
+const renderSourceValueType = (sourceType, localTypeNameRemaps, anonymousStructuralAliases = new Map()) => !sourceType
+    ? undefined
+    : rewriteSourceTypeText(sourceType.typeText, localTypeNameRemaps, anonymousStructuralAliases);
+const renderSourceFunctionType = (opts) => {
+    const sourceSignature = opts.sourceSignatures[0];
+    if (!sourceSignature)
+        return undefined;
+    const parametersText = sourceSignature.parameters
+        .map((parameter) => `${parameter.prefixText}${rewriteSourceTypeText(parameter.typeText, opts.localTypeNameRemaps, opts.anonymousStructuralAliases)}`)
+        .join(", ");
+    return `${sourceSignature.typeParametersText}(${parametersText}) => ${rewriteSourceTypeText(sourceSignature.returnTypeText, opts.localTypeNameRemaps, opts.anonymousStructuralAliases)}`;
+};
+const isGeneratedStructuralHelperName = (name) => name.startsWith("__Anon_") || /__\d+$/.test(name);
+const buildAnonymousStructuralAliasMap = (plan) => {
+    const aliases = new Map();
+    const registerAnonymousClass = (localName, declaration) => {
+        if (!isGeneratedStructuralHelperName(localName))
+            return;
+        const members = [];
+        for (const member of declaration.members) {
+            if (member.kind === "propertyDeclaration") {
+                if (isPortableMarkerMemberName(member.name))
+                    continue;
+                members.push({
+                    kind: "propertySignature",
+                    name: member.name,
+                    type: member.type ?? { kind: "unknownType" },
+                    isOptional: false,
+                    isReadonly: member.isReadonly,
+                });
+                continue;
+            }
+            if (member.kind === "methodDeclaration") {
+                if (isPortableMarkerMemberName(member.name))
+                    continue;
+                members.push({
+                    kind: "methodSignature",
+                    name: member.name,
+                    parameters: member.parameters,
+                    returnType: member.returnType,
+                    typeParameters: member.typeParameters,
+                });
+            }
+        }
+        const shape = renderPortableType({ kind: "objectType", members }, declaration.typeParameters?.map((typeParameter) => typeParameter.name) ??
+            [], new Map(), new Map());
+        const existing = aliases.get(shape) ?? [];
+        existing.push({
+            name: localName,
+            typeParameters: declaration.typeParameters?.map((typeParameter) => typeParameter.name) ?? [],
+        });
+        aliases.set(shape, existing);
+    };
+    for (const symbol of plan.typeDeclarations) {
+        if (symbol.kind !== "class" ||
+            symbol.declaration.kind !== "classDeclaration") {
+            continue;
+        }
+        registerAnonymousClass(symbol.localName, symbol.declaration);
+    }
+    for (const helper of plan.internalHelperTypeDeclarations) {
+        if (helper.kind !== "class")
+            continue;
+        registerAnonymousClass(helper.emittedName, helper.declaration);
+    }
+    const uniqueAliases = new Map();
+    for (const [shape, candidates] of aliases.entries()) {
+        if (candidates.length !== 1)
+            continue;
+        const onlyCandidate = candidates[0];
+        if (!onlyCandidate)
+            continue;
+        uniqueAliases.set(shape, onlyCandidate);
+    }
+    return uniqueAliases;
+};
+const collectReferencedPortableTypeNames = (type, typeParametersInScope, out) => {
+    if (!type)
+        return;
+    switch (type.kind) {
+        case "primitiveType":
+        case "literalType":
+        case "voidType":
+        case "neverType":
+        case "unknownType":
+        case "anyType":
+            return;
+        case "typeParameterType":
+            if (!typeParametersInScope.has(type.name)) {
+                out.add(type.name);
+            }
+            return;
+        case "arrayType":
+            collectReferencedPortableTypeNames(type.elementType, typeParametersInScope, out);
+            return;
+        case "tupleType":
+            for (const element of type.elementTypes) {
+                collectReferencedPortableTypeNames(element, typeParametersInScope, out);
+            }
+            return;
+        case "unionType":
+        case "intersectionType":
+            for (const member of type.types) {
+                collectReferencedPortableTypeNames(member, typeParametersInScope, out);
+            }
+            return;
+        case "dictionaryType":
+            collectReferencedPortableTypeNames(type.keyType, typeParametersInScope, out);
+            collectReferencedPortableTypeNames(type.valueType, typeParametersInScope, out);
+            return;
+        case "functionType":
+            for (const parameter of type.parameters) {
+                collectReferencedPortableTypeNames(parameter.type, typeParametersInScope, out);
+            }
+            collectReferencedPortableTypeNames(type.returnType, typeParametersInScope, out);
+            return;
+        case "objectType":
+            for (const member of type.members) {
+                if (member.kind === "propertySignature") {
+                    collectReferencedPortableTypeNames(member.type, typeParametersInScope, out);
+                    continue;
+                }
+                const nestedTypeParameters = new Set(typeParametersInScope);
+                for (const typeParameter of member.typeParameters ?? []) {
+                    nestedTypeParameters.add(typeParameter.name);
+                }
+                for (const parameter of member.parameters) {
+                    collectReferencedPortableTypeNames(parameter.type, nestedTypeParameters, out);
+                }
+                collectReferencedPortableTypeNames(member.returnType, nestedTypeParameters, out);
+            }
+            return;
+        case "referenceType":
+            {
+                const renderedName = renderReferenceType(type.name, type.typeArguments, []);
+                const baseName = renderedName.split("<")[0];
+                if (!baseName)
+                    return;
+                out.add(baseName);
+            }
+            for (const typeArgument of type.typeArguments ?? []) {
+                collectReferencedPortableTypeNames(typeArgument, typeParametersInScope, out);
+            }
+            return;
+    }
+};
+const collectReferencedPortableTypesFromParameters = (parameters, typeParametersInScope, out) => {
+    for (const parameter of parameters) {
+        collectReferencedPortableTypeNames(parameter.type, typeParametersInScope, out);
+    }
+};
+const collectReferencedPortableTypeNamesFromDeclaration = (declaration, out) => {
+    switch (declaration.kind) {
+        case "enumDeclaration":
+            return;
+        case "typeAliasDeclaration": {
+            const typeParametersInScope = new Set((declaration.typeParameters ?? []).map((typeParameter) => typeParameter.name));
+            collectReferencedPortableTypeNames(declaration.type, typeParametersInScope, out);
+            return;
+        }
+        case "interfaceDeclaration": {
+            const typeParametersInScope = new Set((declaration.typeParameters ?? []).map((typeParameter) => typeParameter.name));
+            for (const baseType of declaration.extends) {
+                collectReferencedPortableTypeNames(baseType, typeParametersInScope, out);
+            }
+            for (const member of declaration.members) {
+                if (member.kind === "propertySignature") {
+                    collectReferencedPortableTypeNames(member.type, typeParametersInScope, out);
+                    continue;
+                }
+                const nestedTypeParameters = new Set(typeParametersInScope);
+                for (const typeParameter of member.typeParameters ?? []) {
+                    nestedTypeParameters.add(typeParameter.name);
+                }
+                collectReferencedPortableTypesFromParameters(member.parameters, nestedTypeParameters, out);
+                collectReferencedPortableTypeNames(member.returnType, nestedTypeParameters, out);
+            }
+            return;
+        }
+        case "classDeclaration": {
+            const typeParametersInScope = new Set((declaration.typeParameters ?? []).map((typeParameter) => typeParameter.name));
+            if (declaration.superClass) {
+                collectReferencedPortableTypeNames(declaration.superClass, typeParametersInScope, out);
+            }
+            for (const implementedType of declaration.implements) {
+                collectReferencedPortableTypeNames(implementedType, typeParametersInScope, out);
+            }
+            for (const member of declaration.members) {
+                switch (member.kind) {
+                    case "constructorDeclaration":
+                        collectReferencedPortableTypesFromParameters(member.parameters, typeParametersInScope, out);
+                        continue;
+                    case "propertyDeclaration":
+                        collectReferencedPortableTypeNames(member.type, typeParametersInScope, out);
+                        continue;
+                    case "methodDeclaration": {
+                        const nestedTypeParameters = new Set(typeParametersInScope);
+                        for (const typeParameter of member.typeParameters ?? []) {
+                            nestedTypeParameters.add(typeParameter.name);
+                        }
+                        collectReferencedPortableTypesFromParameters(member.parameters, nestedTypeParameters, out);
+                        collectReferencedPortableTypeNames(member.returnType, nestedTypeParameters, out);
+                        continue;
+                    }
+                }
+            }
+            return;
+        }
+    }
+};
+const classifyLocalTypeDeclarationKind = (statement) => {
+    switch (statement.kind) {
+        case "classDeclaration":
+            return "class";
+        case "interfaceDeclaration":
+            return "interface";
+        case "enumDeclaration":
+            return "enum";
+        case "typeAliasDeclaration":
+            return "typeAlias";
+        default:
+            return undefined;
+    }
+};
 const declarationNameOf = (statement) => {
     switch (statement.kind) {
         case "functionDeclaration":
@@ -328,6 +846,22 @@ const collectModuleExports = (module, modulesByFileKey) => {
         value: exportedSymbols.sort((left, right) => left.exportName.localeCompare(right.exportName)),
     };
 };
+const finalizeCrossNamespaceReexports = (grouped) => {
+    const dtsStatements = [];
+    const jsValueStatements = [];
+    for (const [key, specs] of Array.from(grouped.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
+        const [moduleSpecifier, kind] = key.split("|");
+        const unique = Array.from(new Set(specs)).sort((a, b) => a.localeCompare(b));
+        if (kind === "type") {
+            dtsStatements.push(`export type { ${unique.join(", ")} } from '${moduleSpecifier}';`);
+            continue;
+        }
+        const statement = `export { ${unique.join(", ")} } from '${moduleSpecifier}';`;
+        dtsStatements.push(statement);
+        jsValueStatements.push(statement);
+    }
+    return { dtsStatements, jsValueStatements };
+};
 const moduleNamespacePath = (namespace) => {
     return namespace.length > 0 ? namespace : "index";
 };
@@ -512,27 +1046,64 @@ const buildModuleSourceIndex = (absoluteFilePath, fileKey) => {
     const wrapperImportsByLocalName = new Map();
     const typeImportsByLocalName = new Map();
     const typeAliasesByName = new Map();
+    const exportedTypeDeclarationNames = new Set();
     const exportedFunctionSignaturesByName = new Map();
+    const exportedValueTypesByName = new Map();
     const memberTypesByClassAndMember = new Map();
+    const anonymousTypeLiteralsByShape = new Map();
     const printTypeParametersText = (typeParameters) => {
         if (!typeParameters || typeParameters.length === 0)
             return "";
         return `<${typeParameters.map((tp) => tp.getText(sourceFile)).join(", ")}>`;
     };
-    const printParameterText = (param) => {
+    const printParameterSignature = (param) => {
         const rest = param.dotDotDotToken ? "..." : "";
         const name = param.name.getText(sourceFile);
         const optional = param.questionToken ? "?" : "";
-        const type = param.type
-            ? printTypeNodeText(param.type, sourceFile)
-            : "unknown";
-        return `${rest}${name}${optional}: ${type}`;
+        return {
+            prefixText: `${rest}${name}${optional}: `,
+            typeText: param.type
+                ? printTypeNodeText(param.type, sourceFile)
+                : "unknown",
+        };
     };
     const addExportedFunctionSignature = (name, signature) => {
         const signatures = exportedFunctionSignaturesByName.get(name) ?? [];
         signatures.push(signature);
         exportedFunctionSignaturesByName.set(name, signatures);
     };
+    const registerAnonymousTypeLiteralsInTypeNode = (typeNode) => {
+        if (!typeNode)
+            return;
+        const visit = (current) => {
+            if (ts.isTypeLiteralNode(current)) {
+                const shape = renderSourceTypeNodeForAliasLookup(current, new Map());
+                if (!anonymousTypeLiteralsByShape.has(shape)) {
+                    const members = new Map();
+                    for (const member of current.members) {
+                        if (!ts.isPropertySignature(member))
+                            continue;
+                        if (!member.name || !member.type)
+                            continue;
+                        const memberName = getPropertyNameText(member.name);
+                        if (!memberName)
+                            continue;
+                        members.set(memberName, {
+                            typeNode: member.type,
+                            typeText: printTypeNodeText(member.type, sourceFile),
+                            isOptional: member.questionToken !== undefined,
+                        });
+                    }
+                    anonymousTypeLiteralsByShape.set(shape, {
+                        typeText: printTypeNodeText(current, sourceFile),
+                        members,
+                    });
+                }
+            }
+            ts.forEachChild(current, visit);
+        };
+        visit(typeNode);
+    };
     for (const stmt of sourceFile.statements) {
         if (ts.isImportDeclaration(stmt)) {
             const moduleSpecifier = ts.isStringLiteral(stmt.moduleSpecifier)
@@ -549,9 +1120,6 @@ const buildModuleSourceIndex = (absoluteFilePath, fileKey) => {
             for (const spec of namedBindings.elements) {
                 const localName = spec.name.text;
                 const importedName = (spec.propertyName ?? spec.name).text;
-                const isTypeOnly = clause.isTypeOnly || spec.isTypeOnly;
-                if (!isTypeOnly)
-                    continue;
                 typeImportsByLocalName.set(localName, {
                     source: moduleSpecifier,
                     importedName,
@@ -567,6 +1135,7 @@ const buildModuleSourceIndex = (absoluteFilePath, fileKey) => {
         }
         if (ts.isTypeAliasDeclaration(stmt)) {
             const aliasName = stmt.name.text;
+            const hasExport = stmt.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
             const typeParameterNames = (stmt.typeParameters ?? []).map((tp) => tp.name.text);
             typeAliasesByName.set(aliasName, {
                 typeParametersText: printTypeParametersText(stmt.typeParameters),
@@ -574,16 +1143,25 @@ const buildModuleSourceIndex = (absoluteFilePath, fileKey) => {
                 type: stmt.type,
                 typeText: printTypeNodeText(stmt.type, sourceFile),
             });
+            registerAnonymousTypeLiteralsInTypeNode(stmt.type);
+            if (hasExport) {
+                exportedTypeDeclarationNames.add(aliasName);
+            }
             continue;
         }
         if (ts.isFunctionDeclaration(stmt)) {
             const hasExport = stmt.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
             if (!hasExport || !stmt.name || !stmt.type)
                 continue;
-            const parametersText = stmt.parameters.map(printParameterText).join(", ");
+            for (const parameter of stmt.parameters) {
+                registerAnonymousTypeLiteralsInTypeNode(parameter.type);
+            }
+            registerAnonymousTypeLiteralsInTypeNode(stmt.type);
+            const parameters = stmt.parameters.map(printParameterSignature);
             addExportedFunctionSignature(stmt.name.text, {
                 typeParametersText: printTypeParametersText(stmt.typeParameters),
-                parametersText,
+                typeParameterCount: stmt.typeParameters?.length ?? 0,
+                parameters,
                 returnTypeText: printTypeNodeText(stmt.type, sourceFile),
             });
             continue;
@@ -601,16 +1179,25 @@ const buildModuleSourceIndex = (absoluteFilePath, fileKey) => {
                     continue;
                 if (!ts.isArrowFunction(initializer) &&
                     !ts.isFunctionExpression(initializer)) {
+                    if (declaration.type) {
+                        registerAnonymousTypeLiteralsInTypeNode(declaration.type);
+                        exportedValueTypesByName.set(exportName, {
+                            typeText: printTypeNodeText(declaration.type, sourceFile),
+                        });
+                    }
                     continue;
                 }
                 if (!initializer.type)
                     continue;
-                const parametersText = initializer.parameters
-                    .map(printParameterText)
-                    .join(", ");
+                for (const parameter of initializer.parameters) {
+                    registerAnonymousTypeLiteralsInTypeNode(parameter.type);
+                }
+                registerAnonymousTypeLiteralsInTypeNode(initializer.type);
+                const parameters = initializer.parameters.map(printParameterSignature);
                 addExportedFunctionSignature(exportName, {
                     typeParametersText: printTypeParametersText(initializer.typeParameters),
-                    parametersText,
+                    typeParameterCount: initializer.typeParameters?.length ?? 0,
+                    parameters,
                     returnTypeText: printTypeNodeText(initializer.type, sourceFile),
                 });
             }
@@ -618,6 +1205,10 @@ const buildModuleSourceIndex = (absoluteFilePath, fileKey) => {
         }
         if (ts.isClassDeclaration(stmt) && stmt.name) {
             const className = stmt.name.text;
+            const hasExport = stmt.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+            if (hasExport) {
+                exportedTypeDeclarationNames.add(className);
+            }
             const members = memberTypesByClassAndMember.get(className) ??
                 new Map();
             for (const member of stmt.members) {
@@ -640,6 +1231,7 @@ const buildModuleSourceIndex = (absoluteFilePath, fileKey) => {
                     const name = getPropertyNameText(member.name);
                     if (!name)
                         continue;
+                    registerAnonymousTypeLiteralsInTypeNode(member.type);
                     members.set(name, {
                         typeNode: member.type,
                         typeText: printTypeNodeText(member.type, sourceFile),
@@ -654,6 +1246,10 @@ const buildModuleSourceIndex = (absoluteFilePath, fileKey) => {
         }
         if (ts.isInterfaceDeclaration(stmt)) {
             const interfaceName = stmt.name.text;
+            const hasExport = stmt.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+            if (hasExport) {
+                exportedTypeDeclarationNames.add(interfaceName);
+            }
             const members = memberTypesByClassAndMember.get(interfaceName) ??
                 new Map();
             for (const member of stmt.members) {
@@ -664,6 +1260,7 @@ const buildModuleSourceIndex = (absoluteFilePath, fileKey) => {
                 const name = getPropertyNameText(member.name);
                 if (!name)
                     continue;
+                registerAnonymousTypeLiteralsInTypeNode(member.type);
                 members.set(name, {
                     typeNode: member.type,
                     typeText: printTypeNodeText(member.type, sourceFile),
@@ -673,6 +1270,13 @@ const buildModuleSourceIndex = (absoluteFilePath, fileKey) => {
             if (members.size > 0) {
                 memberTypesByClassAndMember.set(interfaceName, members);
             }
+            continue;
+        }
+        if (ts.isEnumDeclaration(stmt)) {
+            const hasExport = stmt.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+            if (hasExport) {
+                exportedTypeDeclarationNames.add(stmt.name.text);
+            }
         }
     }
     return {
@@ -682,8 +1286,11 @@ const buildModuleSourceIndex = (absoluteFilePath, fileKey) => {
             wrapperImportsByLocalName,
             typeImportsByLocalName,
             typeAliasesByName,
+            exportedTypeDeclarationNames,
             exportedFunctionSignaturesByName,
+            exportedValueTypesByName,
             memberTypesByClassAndMember,
+            anonymousTypeLiteralsByShape,
         },
     };
 };
@@ -798,42 +1405,6 @@ const collectExtensionWrapperImportsFromSourceType = (opts) => {
     }
     return { ok: true, value: wrappers };
 };
-const classifyExportKind = (module, name) => {
-    const isNamed = (stmt) => typeof stmt.name === "string";
-    const findDecl = () => {
-        for (const stmt of module.body) {
-            if (!("isExported" in stmt) ||
-                stmt.isExported !== true)
-                continue;
-            if (isNamed(stmt) && stmt.name === name)
-                return stmt;
-            if (stmt.kind === "variableDeclaration") {
-                for (const decl of stmt.declarations) {
-                    if (decl.name.kind === "identifierPattern" &&
-                        decl.name.name === name) {
-                        return stmt;
-                    }
-                }
-            }
-        }
-        return undefined;
-    };
-    const decl = findDecl();
-    if (!decl)
-        return "unknown";
-    switch (decl.kind) {
-        case "typeAliasDeclaration":
-        case "interfaceDeclaration":
-            return "type";
-        case "classDeclaration":
-        case "enumDeclaration":
-        case "functionDeclaration":
-        case "variableDeclaration":
-            return "value";
-        default:
-            return "unknown";
-    }
-};
 const moduleNamespaceToInternalSpecifier = (namespace) => {
     const nsPath = moduleNamespacePath(namespace);
     return `./${nsPath}/internal/index.js`;
@@ -842,6 +1413,12 @@ const toClrTypeName = (namespace, typeName, arity) => {
     const suffix = arity && arity > 0 ? `\`${arity}` : "";
     return `${namespace}.${typeName}${suffix}`;
 };
+const toBindingTypeAlias = (namespace, typeName, arity) => {
+    const normalizedName = normalizeTypeReferenceName(typeName, arity);
+    return namespace.length > 0
+        ? `${namespace}.${normalizedName}`
+        : normalizedName;
+};
 const toStableId = (assemblyName, clrName) => {
     return `${assemblyName}:${clrName}`;
 };
@@ -870,7 +1447,111 @@ const isNumericValueType = (name) => {
         name === "System.Byte" ||
         name === "System.SByte");
 };
-const toSignatureType = (type, typeParametersInScope) => {
+const rewriteBindingSemanticParameter = (parameter, localTypeNameRemaps) => ({
+    ...parameter,
+    type: rewriteBindingSemanticType(parameter.type, localTypeNameRemaps),
+});
+const rewriteBindingSemanticMember = (member, localTypeNameRemaps) => {
+    if (member.kind === "propertySignature") {
+        return {
+            ...member,
+            type: rewriteBindingSemanticType(member.type, localTypeNameRemaps) ??
+                member.type,
+        };
+    }
+    return {
+        ...member,
+        parameters: member.parameters.map((parameter) => rewriteBindingSemanticParameter(parameter, localTypeNameRemaps)),
+        returnType: rewriteBindingSemanticType(member.returnType, localTypeNameRemaps) ??
+            member.returnType,
+    };
+};
+const rewriteBindingSemanticType = (type, localTypeNameRemaps) => {
+    if (!type)
+        return undefined;
+    switch (type.kind) {
+        case "referenceType": {
+            const rewrittenName = normalizeTypeReferenceName(localTypeNameRemaps.get(type.name) ?? type.name, type.typeArguments?.length);
+            return {
+                ...type,
+                name: rewrittenName,
+                typeArguments: type.typeArguments?.map((arg) => rewriteBindingSemanticType(arg, localTypeNameRemaps)),
+                structuralMembers: type.structuralMembers?.map((member) => rewriteBindingSemanticMember(member, localTypeNameRemaps)),
+            };
+        }
+        case "arrayType":
+            return {
+                ...type,
+                elementType: rewriteBindingSemanticType(type.elementType, localTypeNameRemaps) ??
+                    type.elementType,
+            };
+        case "tupleType":
+            return {
+                ...type,
+                elementTypes: type.elementTypes.map((elementType) => rewriteBindingSemanticType(elementType, localTypeNameRemaps)),
+            };
+        case "functionType":
+            return {
+                ...type,
+                parameters: type.parameters.map((parameter) => rewriteBindingSemanticParameter(parameter, localTypeNameRemaps)),
+                returnType: rewriteBindingSemanticType(type.returnType, localTypeNameRemaps) ??
+                    type.returnType,
+            };
+        case "objectType":
+            return {
+                ...type,
+                members: type.members.map((member) => rewriteBindingSemanticMember(member, localTypeNameRemaps)),
+            };
+        case "dictionaryType":
+            return {
+                ...type,
+                keyType: rewriteBindingSemanticType(type.keyType, localTypeNameRemaps) ??
+                    type.keyType,
+                valueType: rewriteBindingSemanticType(type.valueType, localTypeNameRemaps) ??
+                    type.valueType,
+            };
+        case "unionType":
+        case "intersectionType":
+            return {
+                ...type,
+                types: type.types.map((candidate) => rewriteBindingSemanticType(candidate, localTypeNameRemaps)),
+            };
+        default:
+            return type;
+    }
+};
+const buildSemanticSignature = (opts) => {
+    return {
+        typeParameters: opts.typeParameters?.map((typeParameter) => typeParameter.name),
+        parameters: opts.parameters.map((parameter) => rewriteBindingSemanticParameter(parameter, opts.localTypeNameRemaps)),
+        returnType: rewriteBindingSemanticType(opts.returnType, opts.localTypeNameRemaps),
+    };
+};
+const buildSemanticSignatureFromFunctionType = (type, localTypeNameRemaps) => ({
+    typeParameters: undefined,
+    parameters: type.parameters.map((parameter) => rewriteBindingSemanticParameter(parameter, localTypeNameRemaps)),
+    returnType: rewriteBindingSemanticType(type.returnType, localTypeNameRemaps),
+});
+const resolveFunctionTypeFromValueDeclarator = (declarator) => {
+    if (declarator?.type?.kind === "functionType") {
+        return declarator.type;
+    }
+    const initializerType = declarator?.initializer?.inferredType;
+    if (initializerType?.kind === "functionType") {
+        return initializerType;
+    }
+    return undefined;
+};
+const areBindingSemanticSignaturesEqual = (left, right) => JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
+const areBindingSemanticsEqual = (left, right) => left.kind === right.kind &&
+    left.clrName === right.clrName &&
+    left.declaringClrType === right.declaringClrType &&
+    left.declaringAssemblyName === right.declaringAssemblyName &&
+    left.semanticOptional === right.semanticOptional &&
+    JSON.stringify(left.semanticType ?? null) ===
+        JSON.stringify(right.semanticType ?? null) &&
+    areBindingSemanticSignaturesEqual(left.semanticSignature, right.semanticSignature);
+const toSignatureType = (type, typeParametersInScope, localTypeNameRemaps = new Map()) => {
     if (!type)
         return "System.Object";
     switch (type.kind) {
@@ -893,20 +1574,20 @@ const toSignatureType = (type, typeParametersInScope) => {
         case "typeParameterType":
             return type.name;
         case "arrayType":
-            return `${toSignatureType(type.elementType, typeParametersInScope)}[]`;
+            return `${toSignatureType(type.elementType, typeParametersInScope, localTypeNameRemaps)}[]`;
         case "tupleType":
         case "objectType":
         case "functionType":
         case "dictionaryType":
             return "System.Object";
         case "intersectionType":
-            return toSignatureType(type.types[0], typeParametersInScope);
+            return toSignatureType(type.types[0], typeParametersInScope, localTypeNameRemaps);
         case "unionType": {
             const nonUndefined = type.types.filter((candidate) => {
                 return !(candidate.kind === "primitiveType" && candidate.name === "undefined");
             });
             if (nonUndefined.length === 1 && nonUndefined[0]) {
-                const single = toSignatureType(nonUndefined[0], typeParametersInScope);
+                const single = toSignatureType(nonUndefined[0], typeParametersInScope, localTypeNameRemaps);
                 if (isNumericValueType(single)) {
                     return `System.Nullable\`1[[${single}]]`;
                 }
@@ -917,12 +1598,12 @@ const toSignatureType = (type, typeParametersInScope) => {
         case "referenceType": {
             if (typeParametersInScope.includes(type.name))
                 return type.name;
-            const normalizedName = normalizeTypeReferenceName(type.name, type.typeArguments?.length);
+            const normalizedName = normalizeTypeReferenceName(localTypeNameRemaps.get(type.name) ?? type.name, type.typeArguments?.length);
             if (!type.typeArguments || type.typeArguments.length === 0) {
                 return normalizedName;
             }
             const args = type.typeArguments
-                .map((arg) => toSignatureType(arg, typeParametersInScope))
+                .map((arg) => toSignatureType(arg, typeParametersInScope, localTypeNameRemaps))
                 .join(",");
             return `${normalizedName}[[${args}]]`;
         }
@@ -947,13 +1628,19 @@ const makeMethodBinding = (opts) => {
         : undefined)
         .filter((name) => name !== undefined)));
     const normalizedSignature = `${opts.methodName}|(${opts.parameters
-        .map((parameter) => toSignatureType(parameter.type, typeParameterScope))
-        .join(",")}):${toSignatureType(opts.returnType, typeParameterScope)}|static=${opts.isStatic ? "true" : "false"}`;
+        .map((parameter) => toSignatureType(parameter.type, typeParameterScope, opts.localTypeNameRemaps))
+        .join(",")}):${toSignatureType(opts.returnType, typeParameterScope, opts.localTypeNameRemaps)}|static=${opts.isStatic ? "true" : "false"}`;
     const stableId = `${toStableId(opts.declaringAssemblyName, opts.declaringClrType)}::method:${opts.methodName}|${normalizedSignature}`;
     return {
         stableId,
         clrName: opts.methodName,
         normalizedSignature,
+        semanticSignature: buildSemanticSignature({
+            typeParameters: opts.typeParameters,
+            parameters: opts.parameters,
+            returnType: opts.returnType,
+            localTypeNameRemaps: opts.localTypeNameRemaps ?? new Map(),
+        }),
         arity: opts.arity,
         parameterCount: opts.parameters.length,
         isStatic: opts.isStatic,
@@ -967,16 +1654,17 @@ const makeMethodBinding = (opts) => {
         isExtensionMethod: false,
     };
 };
-const renderClassInternal = (declaration, namespace, memberOverrides) => {
+const renderClassInternal = (declaration, namespace, memberOverrides, emittedName = declaration.name, localTypeNameRemaps = new Map(), brandName = declaration.name, bindingAlias = declaration.name) => {
     const lines = [];
+    const isSyntheticAnonymousStructuralClass = emittedName.startsWith("__Anon_") || brandName.startsWith("__Anon_");
     const typeParameterScope = (declaration.typeParameters ?? []).map((typeParameter) => typeParameter.name);
     const typeParameters = printTypeParameters(declaration.typeParameters);
-    const markerName = `__tsonic_type_${sanitizeForBrand(namespace)}_${sanitizeForBrand(declaration.name)}`;
+    const markerName = `__tsonic_type_${sanitizeForBrand(namespace)}_${sanitizeForBrand(brandName)}`;
     const heritageNames = [
         declaration.superClass
-            ? renderPortableType(declaration.superClass, typeParameterScope)
+            ? renderPortableType(declaration.superClass, typeParameterScope, localTypeNameRemaps)
             : undefined,
-        ...declaration.implements.map((implementedType) => renderPortableType(implementedType, typeParameterScope)),
+        ...declaration.implements.map((implementedType) => renderPortableType(implementedType, typeParameterScope, localTypeNameRemaps)),
     ]
         .filter((name) => name !== undefined)
         .map((name) => name.trim())
@@ -987,8 +1675,11 @@ const renderClassInternal = (declaration, namespace, memberOverrides) => {
     const extendsClause = heritageNames.length > 0
         ? ` extends ${Array.from(new Set(heritageNames)).join(", ")}`
         : "";
-    lines.push(`export interface ${declaration.name}$instance${typeParameters}${extendsClause} {`);
-    lines.push(`    readonly ${markerName}: never;`);
+    lines.push(`export interface ${emittedName}$instance${typeParameters}${extendsClause} {`);
+    if (!isSyntheticAnonymousStructuralClass) {
+        lines.push(`    readonly ${markerName}: never;`);
+    }
+    lines.push(renderBindingAliasMarker(namespace, bindingAlias));
     const instanceMembers = declaration.members.filter((member) => {
         if (member.kind === "constructorDeclaration")
             return false;
@@ -998,7 +1689,7 @@ const renderClassInternal = (declaration, namespace, memberOverrides) => {
     });
     for (const member of instanceMembers) {
         if (member.kind === "methodDeclaration") {
-            lines.push(`    ${renderMethodSignature(member.name, member.typeParameters, member.parameters, member.returnType)}`);
+            lines.push(`    ${renderMethodSignature(member.name, member.typeParameters, member.parameters, member.returnType, localTypeNameRemaps)}`);
             continue;
         }
         if (member.kind === "propertyDeclaration") {
@@ -1010,24 +1701,33 @@ const renderClassInternal = (declaration, namespace, memberOverrides) => {
             const hasSetter = hasAccessorBody
                 ? member.setterBody !== undefined
                 : !member.isReadonly;
+            const optionalBySource = memberOverride?.emitOptionalPropertySyntax === true &&
+                memberOverride.isOptional === true &&
+                !member.name.startsWith("__tsonic_type_");
+            const optionalMark = optionalBySource ? "?" : "";
             const baseType = (memberOverride?.replaceWithSourceType
                 ? memberOverride.sourceTypeText
-                : undefined) ?? renderPortableType(member.type);
+                : undefined) ??
+                renderPortableType(member.type, typeParameterScope, localTypeNameRemaps);
             const wrappedType = applyWrappersToBaseType(baseType, memberOverride?.wrappers ?? []);
-            const memberType = memberOverride?.isOptional === true
+            const memberType = memberOverride?.isOptional === true && !optionalBySource
                 ? ensureUndefinedInType(wrappedType)
                 : wrappedType;
             if (hasGetter && !hasSetter) {
-                lines.push(`    readonly ${member.name}: ${memberType};`);
+                lines.push(`    readonly ${member.name}${optionalMark}: ${memberType};`);
                 continue;
             }
-            lines.push(`    ${member.name}: ${memberType};`);
+            lines.push(`    ${member.name}${optionalMark}: ${memberType};`);
         }
     }
     lines.push("}");
     lines.push("");
-    lines.push(`export const ${declaration.name}: {`);
-    lines.push(`    new(...args: unknown[]): ${declaration.name}${typeParameters};`);
+    if (isSyntheticAnonymousStructuralClass) {
+        lines.push(`export type ${emittedName}${typeParameters} = ${emittedName}$instance${typeParameters};`);
+        return lines;
+    }
+    lines.push(`export const ${emittedName}: {`);
+    lines.push(`    new(...args: unknown[]): ${emittedName}${typeParameters};`);
     const staticMembers = declaration.members.filter((member) => {
         if (member.kind === "constructorDeclaration")
             return false;
@@ -1035,26 +1735,26 @@ const renderClassInternal = (declaration, namespace, memberOverrides) => {
     });
     for (const member of staticMembers) {
         if (member.kind === "methodDeclaration") {
-            lines.push(`    ${renderMethodSignature(member.name, member.typeParameters, member.parameters, member.returnType)}`);
+            lines.push(`    ${renderMethodSignature(member.name, member.typeParameters, member.parameters, member.returnType, localTypeNameRemaps)}`);
             continue;
         }
         if (member.kind === "propertyDeclaration") {
-            lines.push(`    ${member.name}: ${renderPortableType(member.type)};`);
+            lines.push(`    ${member.name}: ${renderPortableType(member.type, typeParameterScope, localTypeNameRemaps)};`);
         }
     }
     lines.push("};");
     lines.push("");
-    lines.push(`export type ${declaration.name}${typeParameters} = ${declaration.name}$instance${typeParameters};`);
+    lines.push(`export type ${emittedName}${typeParameters} = ${emittedName}$instance${typeParameters};`);
     lines.push("");
     return lines;
 };
-const renderInterfaceInternal = (declaration, namespace, memberOverrides) => {
+const renderInterfaceInternal = (declaration, namespace, memberOverrides, emittedName = declaration.name, localTypeNameRemaps = new Map(), brandName = declaration.name, bindingAlias = declaration.name) => {
     const lines = [];
     const typeParameterScope = (declaration.typeParameters ?? []).map((typeParameter) => typeParameter.name);
     const typeParameters = printTypeParameters(declaration.typeParameters);
-    const markerName = `__tsonic_type_${sanitizeForBrand(namespace)}_${sanitizeForBrand(declaration.name)}`;
+    const markerName = `__tsonic_type_${sanitizeForBrand(namespace)}_${sanitizeForBrand(brandName)}`;
     const extendsNames = declaration.extends
-        .map((baseType) => renderPortableType(baseType, typeParameterScope).trim())
+        .map((baseType) => renderPortableType(baseType, typeParameterScope, localTypeNameRemaps).trim())
         .filter((name) => name.length > 0 &&
         name !== "unknown" &&
         name !== "never" &&
@@ -1062,11 +1762,12 @@ const renderInterfaceInternal = (declaration, namespace, memberOverrides) => {
     const extendsClause = extendsNames.length > 0
         ? ` extends ${Array.from(new Set(extendsNames)).join(", ")}`
         : "";
-    lines.push(`export interface ${declaration.name}$instance${typeParameters}${extendsClause} {`);
+    lines.push(`export interface ${emittedName}$instance${typeParameters}${extendsClause} {`);
     lines.push(`    readonly ${markerName}?: never;`);
+    lines.push(renderBindingAliasMarker(namespace, bindingAlias));
     for (const member of declaration.members) {
         if (member.kind === "methodSignature") {
-            lines.push(`    ${renderMethodSignature(member.name, member.typeParameters, member.parameters, member.returnType)}`);
+            lines.push(`    ${renderMethodSignature(member.name, member.typeParameters, member.parameters, member.returnType, localTypeNameRemaps)}`);
             continue;
         }
         if (member.kind === "propertySignature") {
@@ -1077,7 +1778,8 @@ const renderInterfaceInternal = (declaration, namespace, memberOverrides) => {
             const optionalMark = optionalBySource || member.isOptional ? "?" : "";
             const baseType = (memberOverride?.replaceWithSourceType
                 ? memberOverride.sourceTypeText
-                : undefined) ?? renderPortableType(member.type);
+                : undefined) ??
+                renderPortableType(member.type, typeParameterScope, localTypeNameRemaps);
             const wrappedType = applyWrappersToBaseType(baseType, memberOverride?.wrappers ?? []);
             const memberType = memberOverride?.isOptional && !optionalBySource
                 ? ensureUndefinedInType(wrappedType)
@@ -1087,13 +1789,13 @@ const renderInterfaceInternal = (declaration, namespace, memberOverrides) => {
     }
     lines.push("}");
     lines.push("");
-    lines.push(`export type ${declaration.name}${typeParameters} = ${declaration.name}$instance${typeParameters};`);
+    lines.push(`export type ${emittedName}${typeParameters} = ${emittedName}$instance${typeParameters};`);
     lines.push("");
     return lines;
 };
-const renderEnumInternal = (declaration) => {
+const renderEnumInternal = (declaration, emittedName = declaration.name) => {
     const lines = [];
-    lines.push(`export enum ${declaration.name} {`);
+    lines.push(`export enum ${emittedName} {`);
     declaration.members.forEach((member, index) => {
         lines.push(`    ${member.name} = ${index},`);
     });
@@ -1101,16 +1803,22 @@ const renderEnumInternal = (declaration) => {
     lines.push("");
     return lines;
 };
-const renderStructuralAliasInternal = (declaration, namespace, memberOverrides) => {
+const renderStructuralAliasInternal = (declaration, namespace, memberOverrides, emittedName = declaration.name, localTypeNameRemaps = new Map(), brandAliasName = `${declaration.name}__Alias${(declaration.typeParameters?.length ?? 0) > 0
+    ? `_${declaration.typeParameters?.length ?? 0}`
+    : ""}`, bindingAlias = `${declaration.name}__Alias${(declaration.typeParameters?.length ?? 0) > 0
+    ? `_${declaration.typeParameters?.length ?? 0}`
+    : ""}`) => {
     if (declaration.type.kind !== "objectType")
         return [];
     const lines = [];
     const arity = declaration.typeParameters?.length ?? 0;
     const typeParameters = printTypeParameters(declaration.typeParameters);
-    const internalAliasName = `${declaration.name}__Alias${arity > 0 ? `_${arity}` : ""}`;
-    const markerName = `__tsonic_type_${sanitizeForBrand(namespace)}_${sanitizeForBrand(internalAliasName)}`;
+    const typeParameterScope = (declaration.typeParameters ?? []).map((typeParameter) => typeParameter.name);
+    const internalAliasName = `${emittedName}__Alias${arity > 0 ? `_${arity}` : ""}`;
+    const markerName = `__tsonic_type_${sanitizeForBrand(namespace)}_${sanitizeForBrand(brandAliasName)}`;
     lines.push(`export interface ${internalAliasName}$instance${typeParameters} {`);
     lines.push(`    readonly ${markerName}?: never;`);
+    lines.push(renderBindingAliasMarker(namespace, bindingAlias));
     for (const member of declaration.type.members) {
         if (member.kind === "methodSignature") {
             lines.push(`    ${renderMethodSignature(member.name, member.typeParameters, member.parameters, member.returnType)}`);
@@ -1121,7 +1829,8 @@ const renderStructuralAliasInternal = (declaration, namespace, memberOverrides)
             const optionalMark = member.isOptional ? "?" : "";
             const baseType = (memberOverride?.replaceWithSourceType
                 ? memberOverride.sourceTypeText
-                : undefined) ?? renderPortableType(member.type);
+                : undefined) ??
+                renderPortableType(member.type, typeParameterScope, localTypeNameRemaps);
             const wrappedType = applyWrappersToBaseType(baseType, memberOverride?.wrappers ?? []);
             const memberType = memberOverride?.isOptional === true
                 ? ensureUndefinedInType(wrappedType)
@@ -1129,20 +1838,73 @@ const renderStructuralAliasInternal = (declaration, namespace, memberOverrides)
             lines.push(`    ${member.name}${optionalMark}: ${memberType};`);
         }
     }
-    lines.push("}");
-    lines.push("");
-    lines.push(`export type ${internalAliasName}${typeParameters} = ${internalAliasName}$instance${typeParameters};`);
-    lines.push("");
-    return lines;
+    lines.push("}");
+    lines.push("");
+    lines.push(`export type ${internalAliasName}${typeParameters} = ${internalAliasName}$instance${typeParameters};`);
+    lines.push("");
+    return lines;
+};
+const renderTypeAliasInternal = (declaration, emittedName = declaration.name, localTypeNameRemaps = new Map(), anonymousStructuralAliases = new Map()) => {
+    if (declaration.type.kind === "objectType")
+        return [];
+    const typeParameterScope = (declaration.typeParameters ?? []).map((typeParameter) => typeParameter.name);
+    const typeParameters = printTypeParameters(declaration.typeParameters);
+    return [
+        `export type ${emittedName}${typeParameters} = ${renderPortableType(declaration.type, typeParameterScope, localTypeNameRemaps, anonymousStructuralAliases)};`,
+        "",
+    ];
+};
+const renderSourceAliasPlan = (plan, anonymousStructuralAliases) => {
+    const sourceTypeParams = plan.sourceAlias?.typeParametersText ??
+        printTypeParameters(plan.declaration.typeParameters);
+    if (plan.declaration.type.kind === "objectType") {
+        const arity = plan.declaration.typeParameters?.length ?? 0;
+        const internalName = `${plan.declaration.name}__Alias${arity > 0 ? `_${arity}` : ""}`;
+        const typeArgs = plan.sourceAlias && plan.sourceAlias.typeParameterNames.length > 0
+            ? `<${plan.sourceAlias.typeParameterNames.join(", ")}>`
+            : plan.declaration.typeParameters &&
+                plan.declaration.typeParameters.length > 0
+                ? `<${plan.declaration.typeParameters.map((tp) => tp.name).join(", ")}>`
+                : "";
+        return {
+            line: `export type ${plan.declaration.name}${sourceTypeParams} = ${internalName}${typeArgs};`,
+            internalImport: internalName,
+        };
+    }
+    const rhs = renderPortableType(plan.declaration.type, plan.declaration.typeParameters?.map((tp) => tp.name) ?? [], new Map(), anonymousStructuralAliases);
+    const shouldPreferSourceAliasText = plan.sourceAlias !== undefined &&
+        !typeNodeUsesImportedTypeNames(plan.sourceAlias.type, plan.typeImportsByLocalName) &&
+        /__\d+\b|\$instance\b/.test(rhs);
+    return {
+        line: `export type ${plan.declaration.name}${sourceTypeParams} = ${shouldPreferSourceAliasText
+            ? rewriteSourceTypeText(plan.sourceAlias.typeText, new Map(), anonymousStructuralAliases)
+            : rhs};`,
+    };
 };
-const renderContainerInternal = (entry) => {
+const renderContainerInternal = (entry, anonymousStructuralAliases) => {
     const lines = [];
     lines.push(`export abstract class ${entry.module.className}$instance {`);
     for (const method of entry.methods) {
-        lines.push(`    static ${renderMethodSignature(method.localName, method.declaration.typeParameters, method.declaration.parameters, method.declaration.returnType)}`);
+        const sourceSignature = renderSourceFunctionSignature({
+            declaration: method.declaration,
+            sourceSignatures: method.sourceSignatures,
+            localTypeNameRemaps: method.localTypeNameRemaps,
+            anonymousStructuralAliases,
+        });
+        lines.push(`    static ${sourceSignature
+            ? `${method.localName}${sourceSignature.typeParametersText}(${sourceSignature.parametersText}): ${sourceSignature.returnTypeText};`
+            : renderMethodSignature(method.localName, method.declaration.typeParameters, method.declaration.parameters, method.declaration.returnType, method.localTypeNameRemaps, anonymousStructuralAliases)}`);
     }
     for (const variable of entry.variables) {
-        lines.push(`    static ${variable.localName}: ${renderPortableType(variable.declarator?.type)};`);
+        const sourceFunctionTypeText = renderSourceFunctionType({
+            sourceSignatures: variable.sourceSignatures,
+            localTypeNameRemaps: variable.localTypeNameRemaps,
+            anonymousStructuralAliases,
+        });
+        const sourceTypeText = sourceFunctionTypeText ??
+            renderSourceValueType(variable.sourceType, variable.localTypeNameRemaps, anonymousStructuralAliases);
+        lines.push(`    static ${variable.localName}: ${sourceTypeText ??
+            renderPortableType(variable.declarator?.type, [], variable.localTypeNameRemaps, anonymousStructuralAliases)};`);
     }
     lines.push("}");
     lines.push("");
@@ -1150,7 +1912,7 @@ const renderContainerInternal = (entry) => {
     lines.push("");
     return lines;
 };
-const buildTypeBindingFromClass = (declaration, namespace, assemblyName) => {
+const buildTypeBindingFromClass = (declaration, namespace, assemblyName, localTypeNameRemaps = new Map()) => {
     const declaringClrType = toClrTypeName(namespace, declaration.name, declaration.typeParameters?.length ?? 0);
     const typeStableId = toStableId(assemblyName, declaringClrType);
     const typeParameterScope = declaration.typeParameters?.map((typeParameter) => typeParameter.name) ??
@@ -1162,7 +1924,7 @@ const buildTypeBindingFromClass = (declaration, namespace, assemblyName) => {
         if (member.kind === "constructorDeclaration") {
             constructors.push({
                 normalizedSignature: `.ctor|(${member.parameters
-                    .map((parameter) => toSignatureType(parameter.type, typeParameterScope))
+                    .map((parameter) => toSignatureType(parameter.type, typeParameterScope, localTypeNameRemaps))
                     .join(",")})|static=false`,
                 isStatic: false,
                 parameterCount: member.parameters.length,
@@ -1176,12 +1938,14 @@ const buildTypeBindingFromClass = (declaration, namespace, assemblyName) => {
                 methodName: member.name,
                 parameters: member.parameters,
                 returnType: member.returnType,
+                typeParameters: member.typeParameters,
                 arity: member.typeParameters?.length ?? 0,
                 parameterModifiers: buildParameterModifiers(member.parameters),
                 isStatic: member.isStatic,
                 isAbstract: member.body === undefined,
                 isVirtual: member.isVirtual,
                 isOverride: member.isOverride,
+                localTypeNameRemaps,
             }));
             continue;
         }
@@ -1193,11 +1957,12 @@ const buildTypeBindingFromClass = (declaration, namespace, assemblyName) => {
             const hasSetter = hasAccessorBody
                 ? member.setterBody !== undefined
                 : !member.isReadonly;
-            const propertyType = toSignatureType(member.type, typeParameterScope);
+            const propertyType = toSignatureType(member.type, typeParameterScope, localTypeNameRemaps);
             properties.push({
                 stableId: `${typeStableId}::property:${member.name}`,
                 clrName: member.name,
                 normalizedSignature: `${member.name}|:${propertyType}|static=${member.isStatic ? "true" : "false"}|accessor=${hasGetter && hasSetter ? "getset" : hasSetter ? "set" : "get"}`,
+                semanticType: rewriteBindingSemanticType(member.type, localTypeNameRemaps),
                 isStatic: member.isStatic,
                 isAbstract: member.getterBody === undefined && member.setterBody === undefined
                     ? false
@@ -1215,6 +1980,7 @@ const buildTypeBindingFromClass = (declaration, namespace, assemblyName) => {
     return {
         stableId: typeStableId,
         clrName: declaringClrType,
+        alias: toBindingTypeAlias(namespace, declaration.name, declaration.typeParameters?.length ?? 0),
         assemblyName,
         kind: declaration.isStruct ? "Struct" : "Class",
         accessibility: "Public",
@@ -1239,7 +2005,7 @@ const buildTypeBindingFromClass = (declaration, namespace, assemblyName) => {
             ],
     };
 };
-const buildTypeBindingFromInterface = (declaration, namespace, assemblyName) => {
+const buildTypeBindingFromInterface = (declaration, namespace, assemblyName, localTypeNameRemaps = new Map()) => {
     const declaringClrType = toClrTypeName(namespace, declaration.name, declaration.typeParameters?.length ?? 0);
     const typeStableId = toStableId(assemblyName, declaringClrType);
     const typeParameterScope = declaration.typeParameters?.map((typeParameter) => typeParameter.name) ??
@@ -1254,17 +2020,21 @@ const buildTypeBindingFromInterface = (declaration, namespace, assemblyName) =>
                 methodName: member.name,
                 parameters: member.parameters,
                 returnType: member.returnType,
+                typeParameters: member.typeParameters,
                 arity: member.typeParameters?.length ?? 0,
                 parameterModifiers: buildParameterModifiers(member.parameters),
                 isStatic: false,
                 isAbstract: true,
+                localTypeNameRemaps,
             }));
             continue;
         }
         properties.push({
             stableId: `${typeStableId}::property:${member.name}`,
             clrName: member.name,
-            normalizedSignature: `${member.name}|:${toSignatureType(member.type, typeParameterScope)}|static=false|accessor=${member.isReadonly ? "get" : "getset"}`,
+            normalizedSignature: `${member.name}|:${toSignatureType(member.type, typeParameterScope, localTypeNameRemaps)}|static=false|accessor=${member.isReadonly ? "get" : "getset"}`,
+            semanticType: rewriteBindingSemanticType(member.type, localTypeNameRemaps),
+            semanticOptional: member.isOptional,
             isStatic: false,
             isAbstract: true,
             isVirtual: false,
@@ -1279,6 +2049,7 @@ const buildTypeBindingFromInterface = (declaration, namespace, assemblyName) =>
     return {
         stableId: typeStableId,
         clrName: declaringClrType,
+        alias: toBindingTypeAlias(namespace, declaration.name, declaration.typeParameters?.length ?? 0),
         assemblyName,
         kind: declaration.isStruct ? "Struct" : "Interface",
         accessibility: "Public",
@@ -1311,6 +2082,7 @@ const buildTypeBindingFromEnum = (declaration, namespace, assemblyName) => {
     return {
         stableId: typeStableId,
         clrName: declaringClrType,
+        alias: toBindingTypeAlias(namespace, declaration.name),
         assemblyName,
         kind: "Enum",
         accessibility: "Public",
@@ -1326,7 +2098,7 @@ const buildTypeBindingFromEnum = (declaration, namespace, assemblyName) => {
         constructors: [],
     };
 };
-const buildTypeBindingFromStructuralAlias = (declaration, namespace, assemblyName) => {
+const buildTypeBindingFromStructuralAlias = (declaration, namespace, assemblyName, localTypeNameRemaps = new Map()) => {
     if (declaration.type.kind !== "objectType")
         return undefined;
     const arity = declaration.typeParameters?.length ?? 0;
@@ -1345,17 +2117,21 @@ const buildTypeBindingFromStructuralAlias = (declaration, namespace, assemblyNam
                 methodName: member.name,
                 parameters: member.parameters,
                 returnType: member.returnType,
+                typeParameters: member.typeParameters,
                 arity: member.typeParameters?.length ?? 0,
                 parameterModifiers: buildParameterModifiers(member.parameters),
                 isStatic: false,
                 isAbstract: true,
+                localTypeNameRemaps,
             }));
             continue;
         }
         properties.push({
             stableId: `${typeStableId}::property:${member.name}`,
             clrName: member.name,
-            normalizedSignature: `${member.name}|:${toSignatureType(member.type, typeParameterScope)}|static=false|accessor=${member.isReadonly ? "get" : "getset"}`,
+            normalizedSignature: `${member.name}|:${toSignatureType(member.type, typeParameterScope, localTypeNameRemaps)}|static=false|accessor=${member.isReadonly ? "get" : "getset"}`,
+            semanticType: rewriteBindingSemanticType(member.type, localTypeNameRemaps),
+            semanticOptional: member.isOptional,
             isStatic: false,
             isAbstract: true,
             isVirtual: false,
@@ -1370,6 +2146,7 @@ const buildTypeBindingFromStructuralAlias = (declaration, namespace, assemblyNam
     return {
         stableId: typeStableId,
         clrName: declaringClrType,
+        alias: toBindingTypeAlias(namespace, internalAliasName, arity),
         assemblyName,
         kind: declaration.isStruct ? "Struct" : "Class",
         accessibility: "Public",
@@ -1398,11 +2175,13 @@ const buildTypeBindingFromContainer = (entry, namespace, assemblyName) => {
         arity: method.declaration.typeParameters?.length ?? 0,
         parameterModifiers: buildParameterModifiers(method.declaration.parameters),
         isStatic: true,
+        localTypeNameRemaps: method.localTypeNameRemaps,
     }));
     const properties = entry.variables.map((variable) => ({
         stableId: `${typeStableId}::property:${variable.localName}`,
         clrName: variable.localName,
-        normalizedSignature: `${variable.localName}|:${toSignatureType(variable.declarator?.type, [])}|static=true|accessor=getset`,
+        normalizedSignature: `${variable.localName}|:${toSignatureType(variable.declarator?.type, [], variable.localTypeNameRemaps)}|static=true|accessor=getset`,
+        semanticType: rewriteBindingSemanticType(variable.declarator?.type, variable.localTypeNameRemaps),
         isStatic: true,
         isAbstract: false,
         isVirtual: false,
@@ -1416,6 +2195,7 @@ const buildTypeBindingFromContainer = (entry, namespace, assemblyName) => {
     return {
         stableId: typeStableId,
         clrName: declaringClrType,
+        alias: toBindingTypeAlias(namespace, entry.module.className),
         assemblyName,
         kind: "Class",
         accessibility: "Public",
@@ -1451,37 +2231,112 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
     for (const [namespace, moduleList] of Array.from(modulesByNamespace.entries())) {
         const typeDeclarations = [];
         const moduleContainers = [];
+        const crossNamespaceReexportsGrouped = new Map();
+        const crossNamespaceTypeDeclarations = [];
+        const seenCrossNamespaceTypeDeclarationKeys = new Set();
         const valueExportsMap = new Map();
         const seenTypeDeclarationKeys = new Set();
-        const sourceAliasLines = new Set();
-        const sourceAliasInternalImports = new Set();
+        const sourceAliasPlans = [];
         const memberOverrides = [];
+        const internalTypeImportByAlias = new Map();
+        const facadeTypeImportByAlias = new Map();
         const wrapperImportByAlias = new Map();
+        const internalHelperTypeDeclarationsByKey = new Map();
+        const internalHelperTypeRemapsByModuleKey = new Map();
+        const getInternalHelperTypeName = (moduleFileKey, localName) => {
+            return `__Local_${sanitizeForBrand(moduleFileKey)}_${sanitizeForBrand(localName)}`;
+        };
+        const registerInternalHelperTypeClosure = (opts) => {
+            if (!opts.sourceIndex)
+                return { ok: true, value: new Map() };
+            const moduleFileKey = normalizeModuleFileKey(opts.declarationModule.filePath);
+            const remaps = internalHelperTypeRemapsByModuleKey.get(moduleFileKey) ?? new Map();
+            if (!internalHelperTypeRemapsByModuleKey.has(moduleFileKey)) {
+                internalHelperTypeRemapsByModuleKey.set(moduleFileKey, remaps);
+            }
+            const visiting = new Set();
+            const visitLocalType = (localName) => {
+                if (opts.sourceIndex?.exportedTypeDeclarationNames.has(localName)) {
+                    return { ok: true, value: undefined };
+                }
+                const declaration = resolveModuleLocalDeclaration(opts.declarationModule, localName);
+                if (!declaration)
+                    return { ok: true, value: undefined };
+                const kind = classifyLocalTypeDeclarationKind(declaration);
+                if (!kind)
+                    return { ok: true, value: undefined };
+                const localTypeDeclaration = declaration;
+                const key = `${moduleFileKey}::${localName}`;
+                if (!remaps.has(localName)) {
+                    remaps.set(localName, getInternalHelperTypeName(moduleFileKey, localName));
+                }
+                if (internalHelperTypeDeclarationsByKey.has(key)) {
+                    return { ok: true, value: undefined };
+                }
+                if (visiting.has(key))
+                    return { ok: true, value: undefined };
+                visiting.add(key);
+                const nestedReferencedNames = new Set();
+                collectReferencedPortableTypeNamesFromDeclaration(localTypeDeclaration, nestedReferencedNames);
+                for (const nestedName of nestedReferencedNames) {
+                    const visited = visitLocalType(nestedName);
+                    if (!visited.ok)
+                        return visited;
+                }
+                visiting.delete(key);
+                const emittedName = remaps.get(localName);
+                if (!emittedName) {
+                    return {
+                        ok: false,
+                        error: `Internal error: missing emitted name remap for local helper '${localName}'.`,
+                    };
+                }
+                internalHelperTypeDeclarationsByKey.set(key, {
+                    key,
+                    moduleFileKey,
+                    declaringNamespace: opts.declarationModule.namespace,
+                    emittedName,
+                    originalName: localName,
+                    kind,
+                    declaration: localTypeDeclaration,
+                });
+                return { ok: true, value: undefined };
+            };
+            for (const referencedName of opts.referencedNames) {
+                const visited = visitLocalType(referencedName);
+                if (!visited.ok)
+                    return visited;
+            }
+            return { ok: true, value: new Map(remaps) };
+        };
         const registerValueExport = (valueExport) => {
             const existing = valueExportsMap.get(valueExport.exportName);
             if (!existing) {
                 valueExportsMap.set(valueExport.exportName, valueExport);
                 return { ok: true, value: undefined };
             }
-            const sameBinding = existing.binding.kind === valueExport.binding.kind &&
-                existing.binding.clrName === valueExport.binding.clrName &&
-                existing.binding.declaringClrType ===
-                    valueExport.binding.declaringClrType &&
-                existing.binding.declaringAssemblyName ===
-                    valueExport.binding.declaringAssemblyName;
+            const sameBinding = areBindingSemanticsEqual(existing.binding, valueExport.binding);
             const normalizeFunctionFacade = (facade) => {
                 const declaration = facade.declaration;
                 const typeParametersText = printTypeParameters(declaration.typeParameters);
                 const typeParameterNames = declaration.typeParameters?.map((typeParameter) => typeParameter.name) ?? [];
-                const parametersText = renderUnknownParameters(declaration.parameters, typeParameterNames);
-                const returnTypeText = renderPortableType(declaration.returnType, typeParameterNames);
+                const parametersText = renderUnknownParameters(declaration.parameters, typeParameterNames, facade.localTypeNameRemaps);
+                const returnTypeText = renderPortableType(declaration.returnType, typeParameterNames, facade.localTypeNameRemaps);
                 const sourceSignatures = (facade.sourceSignatures ?? [])
-                    .map((signature) => `${signature.typeParametersText}(${signature.parametersText}):${signature.returnTypeText}`)
+                    .map((signature) => `${signature.typeParametersText}(${signature.parameters
+                    .map((parameter) => `${parameter.prefixText}${parameter.typeText}`)
+                    .join(", ")}):${signature.returnTypeText}`)
                     .sort((left, right) => left.localeCompare(right))
                     .join("||");
                 return `${typeParametersText}(${parametersText}):${returnTypeText}|source=${sourceSignatures}`;
             };
-            const normalizeVariableFacade = (declarator) => renderPortableType(declarator?.type);
+            const normalizeVariableFacade = (declarator, localTypeNameRemaps) => {
+                const functionType = resolveFunctionTypeFromValueDeclarator(declarator);
+                if (functionType) {
+                    return JSON.stringify(buildSemanticSignatureFromFunctionType(functionType, localTypeNameRemaps));
+                }
+                return renderPortableType(declarator?.type, [], localTypeNameRemaps);
+            };
             const sameFacade = (() => {
                 if (existing.facade.kind !== valueExport.facade.kind)
                     return false;
@@ -1492,8 +2347,8 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
                 }
                 if (existing.facade.kind === "variable" &&
                     valueExport.facade.kind === "variable") {
-                    return (normalizeVariableFacade(existing.facade.declarator) ===
-                        normalizeVariableFacade(valueExport.facade.declarator));
+                    return (normalizeVariableFacade(existing.facade.declarator, existing.facade.localTypeNameRemaps) ===
+                        normalizeVariableFacade(valueExport.facade.declarator, valueExport.facade.localTypeNameRemaps));
                 }
                 return false;
             })();
@@ -1526,32 +2381,113 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
             }
             return { ok: true, value: undefined };
         };
+        const registerCrossNamespaceReexport = (opts) => {
+            if (opts.declaringNamespace === namespace)
+                return;
+            const moduleSpecifier = `./${moduleNamespacePath(opts.declaringNamespace)}.js`;
+            const key = `${moduleSpecifier}|${opts.kind}`;
+            const specifier = opts.exportName === opts.localName
+                ? opts.exportName
+                : `${opts.localName} as ${opts.exportName}`;
+            const existing = crossNamespaceReexportsGrouped.get(key) ?? [];
+            existing.push(specifier);
+            crossNamespaceReexportsGrouped.set(key, existing);
+        };
+        const registerCrossNamespaceTypeDeclaration = (symbol) => {
+            if (symbol.declaringNamespace === namespace)
+                return;
+            const key = `${symbol.declaringNamespace}|${symbol.declaringClassName}|${symbol.localName}|${symbol.kind}`;
+            if (seenCrossNamespaceTypeDeclarationKeys.has(key))
+                return;
+            seenCrossNamespaceTypeDeclarationKeys.add(key);
+            crossNamespaceTypeDeclarations.push(symbol);
+        };
+        const registerSourceTypeImportCandidates = (sourceIndex, moduleKey, moduleFilePath) => {
+            for (const [localName, imported] of sourceIndex.typeImportsByLocalName) {
+                if (sourceIndex.wrapperImportsByLocalName.has(localName))
+                    continue;
+                const internalImport = resolveSourceTypeImportBinding({
+                    context: "internal",
+                    currentNamespace: namespace,
+                    currentModuleKey: moduleKey,
+                    localName,
+                    imported,
+                    modulesByFileKey,
+                });
+                if (!internalImport.ok)
+                    return internalImport;
+                if (internalImport.value) {
+                    const registered = registerSourceTypeImportBinding(internalTypeImportByAlias, internalImport.value, namespace, moduleFilePath);
+                    if (!registered.ok)
+                        return registered;
+                }
+                const facadeImport = resolveSourceTypeImportBinding({
+                    context: "facade",
+                    currentNamespace: namespace,
+                    currentModuleKey: moduleKey,
+                    localName,
+                    imported,
+                    modulesByFileKey,
+                });
+                if (!facadeImport.ok)
+                    return facadeImport;
+                if (facadeImport.value) {
+                    const registered = registerSourceTypeImportBinding(facadeTypeImportByAlias, facadeImport.value, namespace, moduleFilePath);
+                    if (!registered.ok)
+                        return registered;
+                }
+            }
+            return { ok: true, value: undefined };
+        };
+        const registerFacadeLocalTypeReferenceImports = (opts) => {
+            const typeParameterNames = new Set((opts.typeParameters ?? []).map((typeParameter) => typeParameter.name));
+            const referencedNames = new Set();
+            for (const parameterType of opts.parameterTypes) {
+                collectReferencedPortableTypeNames(parameterType, typeParameterNames, referencedNames);
+            }
+            collectReferencedPortableTypeNames(opts.returnType, typeParameterNames, referencedNames);
+            const helperTypeRemaps = registerInternalHelperTypeClosure({
+                declarationModule: opts.declarationModule,
+                sourceIndex: opts.sourceIndex,
+                referencedNames,
+            });
+            if (!helperTypeRemaps.ok)
+                return helperTypeRemaps;
+            if (!opts.sourceIndex)
+                return helperTypeRemaps;
+            if (opts.declarationNamespace === namespace) {
+                return helperTypeRemaps;
+            }
+            const moduleSpecifier = `./${moduleNamespacePath(opts.declarationNamespace)}.js`;
+            for (const referencedName of referencedNames) {
+                if (!opts.sourceIndex.exportedTypeDeclarationNames.has(referencedName)) {
+                    continue;
+                }
+                const registered = registerSourceTypeImportBinding(facadeTypeImportByAlias, {
+                    importedName: referencedName,
+                    localName: referencedName,
+                    source: moduleSpecifier,
+                }, namespace, opts.declarationFilePath);
+                if (!registered.ok)
+                    return registered;
+            }
+            return helperTypeRemaps;
+        };
         for (const module of moduleList.sort((left, right) => left.filePath.localeCompare(right.filePath))) {
             const moduleKey = normalizeModuleFileKey(module.filePath);
             const sourceIndex = sourceIndexByFileKey.get(moduleKey);
             if (sourceIndex) {
+                const registered = registerSourceTypeImportCandidates(sourceIndex, moduleKey, module.filePath);
+                if (!registered.ok)
+                    return registered;
                 const exportedAliasDecls = module.body.filter((stmt) => stmt.kind === "typeAliasDeclaration" && stmt.isExported);
                 for (const alias of exportedAliasDecls) {
                     const sourceAlias = sourceIndex.typeAliasesByName.get(alias.name);
-                    const sourceTypeParams = sourceAlias?.typeParametersText ??
-                        printTypeParameters(alias.typeParameters);
-                    if (alias.type.kind === "objectType") {
-                        const arity = alias.typeParameters?.length ?? 0;
-                        const internalName = `${alias.name}__Alias${arity > 0 ? `_${arity}` : ""}`;
-                        const typeArgs = sourceAlias && sourceAlias.typeParameterNames.length > 0
-                            ? `<${sourceAlias.typeParameterNames.join(", ")}>`
-                            : alias.typeParameters && alias.typeParameters.length > 0
-                                ? `<${alias.typeParameters.map((tp) => tp.name).join(", ")}>`
-                                : "";
-                        sourceAliasLines.add(`export type ${alias.name}${sourceTypeParams} = ${internalName}${typeArgs};`);
-                        sourceAliasInternalImports.add(internalName);
-                        continue;
-                    }
-                    const rhs = renderPortableType(alias.type, alias.typeParameters?.map((tp) => tp.name) ?? []);
-                    const shouldPreferSourceAliasText = sourceAlias !== undefined &&
-                        !typeNodeUsesImportedTypeNames(sourceAlias.type, sourceIndex.typeImportsByLocalName) &&
-                        /__\d+\b|\$instance\b/.test(rhs);
-                    sourceAliasLines.add(`export type ${alias.name}${sourceTypeParams} = ${shouldPreferSourceAliasText ? sourceAlias.typeText : rhs};`);
+                    sourceAliasPlans.push({
+                        declaration: alias,
+                        sourceAlias,
+                        typeImportsByLocalName: sourceIndex.typeImportsByLocalName,
+                    });
                 }
                 const exportedClasses = module.body.filter((stmt) => stmt.kind === "classDeclaration" && stmt.isExported);
                 const exportedInterfaces = module.body.filter((stmt) => stmt.kind === "interfaceDeclaration" && stmt.isExported);
@@ -1692,6 +2628,17 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
                 const exportKind = classifyDeclarationKind(declaration, declarationModule.filePath, exportItem.name);
                 if (!exportKind.ok)
                     return exportKind;
+                if (declarationModule.namespace !== namespace) {
+                    registerCrossNamespaceReexport({
+                        declaringNamespace: declarationModule.namespace,
+                        exportName: exportItem.name,
+                        localName: resolved.value.clrName,
+                        kind: exportKind.value === "interface" ||
+                            exportKind.value === "typeAlias"
+                            ? "type"
+                            : "value",
+                    });
+                }
                 if (exportKind.value === "function") {
                     const functionDeclaration = declaration.kind === "functionDeclaration"
                         ? declaration
@@ -1702,6 +2649,24 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
                             error: `Invalid function export '${exportItem.name}' in ${declarationModule.filePath}: expected function declaration.`,
                         };
                     }
+                    const declarationModuleKey = normalizeModuleFileKey(declarationModule.filePath);
+                    const declarationSourceIndex = sourceIndexByFileKey.get(declarationModuleKey);
+                    if (declarationSourceIndex) {
+                        const registered = registerSourceTypeImportCandidates(declarationSourceIndex, declarationModuleKey, declarationModule.filePath);
+                        if (!registered.ok)
+                            return registered;
+                    }
+                    const registeredLocalTypeRefs = registerFacadeLocalTypeReferenceImports({
+                        declarationModule,
+                        declarationNamespace: declarationModule.namespace,
+                        declarationFilePath: declarationModule.filePath,
+                        sourceIndex: declarationSourceIndex,
+                        typeParameters: functionDeclaration.typeParameters,
+                        parameterTypes: functionDeclaration.parameters.map((parameter) => parameter.type),
+                        returnType: functionDeclaration.returnType,
+                    });
+                    if (!registeredLocalTypeRefs.ok)
+                        return registeredLocalTypeRefs;
                     const registered = registerValueExport({
                         exportName: exportItem.name,
                         binding: {
@@ -1713,6 +2678,7 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
                         facade: {
                             kind: "function",
                             declaration: functionDeclaration,
+                            localTypeNameRemaps: registeredLocalTypeRefs.value,
                             sourceSignatures: sourceIndexByFileKey
                                 .get(normalizeModuleFileKey(declarationModule.filePath))
                                 ?.exportedFunctionSignaturesByName.get(resolved.value.clrName) ?? [],
@@ -1732,23 +2698,63 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
                             error: `Invalid variable export '${exportItem.name}' in ${declarationModule.filePath}: expected variable declaration.`,
                         };
                     }
+                    const declarationModuleKey = normalizeModuleFileKey(declarationModule.filePath);
+                    const declarationSourceIndex = sourceIndexByFileKey.get(declarationModuleKey);
+                    if (declarationSourceIndex) {
+                        const registered = registerSourceTypeImportCandidates(declarationSourceIndex, declarationModuleKey, declarationModule.filePath);
+                        if (!registered.ok)
+                            return registered;
+                    }
                     const declarator = declarationStatement.declarations.find((candidate) => candidate.name.kind === "identifierPattern" &&
                         candidate.name.name === resolved.value.clrName);
+                    const exportedFunctionType = resolveFunctionTypeFromValueDeclarator(declarator && declarator.name.kind === "identifierPattern"
+                        ? {
+                            kind: declarator.kind,
+                            name: declarator.name,
+                            type: declarator.type,
+                            initializer: declarator.initializer,
+                        }
+                        : undefined);
+                    const registeredLocalTypeRefs = registerFacadeLocalTypeReferenceImports({
+                        declarationModule,
+                        declarationNamespace: declarationModule.namespace,
+                        declarationFilePath: declarationModule.filePath,
+                        sourceIndex: declarationSourceIndex,
+                        typeParameters: undefined,
+                        parameterTypes: exportedFunctionType
+                            ? [exportedFunctionType]
+                            : declarator?.type
+                                ? [declarator.type]
+                                : [],
+                        returnType: undefined,
+                    });
+                    if (!registeredLocalTypeRefs.ok)
+                        return registeredLocalTypeRefs;
                     const registered = registerValueExport({
                         exportName: exportItem.name,
                         binding: {
-                            kind: "field",
+                            kind: exportedFunctionType ? "functionType" : "field",
                             clrName: resolved.value.clrName,
                             declaringClrType: toClrTypeName(declarationModule.namespace, declarationModule.className),
                             declaringAssemblyName: assemblyName,
+                            semanticType: exportedFunctionType
+                                ? undefined
+                                : rewriteBindingSemanticType(declarator?.type, registeredLocalTypeRefs.value),
+                            semanticSignature: exportedFunctionType
+                                ? buildSemanticSignatureFromFunctionType(exportedFunctionType, registeredLocalTypeRefs.value)
+                                : undefined,
                         },
                         facade: {
                             kind: "variable",
+                            localTypeNameRemaps: registeredLocalTypeRefs.value,
+                            sourceType: declarationSourceIndex?.exportedValueTypesByName.get(resolved.value.clrName),
+                            sourceSignatures: declarationSourceIndex?.exportedFunctionSignaturesByName.get(resolved.value.clrName) ?? [],
                             declarator: declarator && declarator.name.kind === "identifierPattern"
                                 ? {
                                     kind: declarator.kind,
                                     name: declarator.name,
                                     type: declarator.type,
+                                    initializer: declarator.initializer,
                                 }
                                 : undefined,
                         },
@@ -1761,6 +2767,25 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
                     exportKind.value === "interface" ||
                     exportKind.value === "enum" ||
                     exportKind.value === "typeAlias") {
+                    if (declarationModule.namespace !== namespace) {
+                        registerCrossNamespaceTypeDeclaration({
+                            exportName: exportItem.name,
+                            localName: resolved.value.clrName,
+                            kind: exportKind.value,
+                            declaration,
+                            declaringNamespace: declarationModule.namespace,
+                            declaringClassName: declarationModule.className,
+                            declaringFilePath: declarationModule.filePath,
+                        });
+                        continue;
+                    }
+                    const declarationModuleKey = normalizeModuleFileKey(declarationModule.filePath);
+                    const declarationSourceIndex = sourceIndexByFileKey.get(declarationModuleKey);
+                    if (declarationSourceIndex) {
+                        const registered = registerSourceTypeImportCandidates(declarationSourceIndex, declarationModuleKey, declarationModule.filePath);
+                        if (!registered.ok)
+                            return registered;
+                    }
                     if (exportKind.value === "typeAlias" &&
                         declaration.kind === "typeAliasDeclaration" &&
                         declaration.type.kind !== "objectType") {
@@ -1812,6 +2837,18 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
                     symbol.kind === "interface" ||
                     symbol.kind === "enum" ||
                     symbol.kind === "typeAlias") {
+                    if (symbol.declaringNamespace !== namespace) {
+                        registerCrossNamespaceReexport({
+                            declaringNamespace: symbol.declaringNamespace,
+                            exportName: symbol.exportName,
+                            localName: symbol.localName,
+                            kind: symbol.kind === "interface" || symbol.kind === "typeAlias"
+                                ? "type"
+                                : "value",
+                        });
+                        registerCrossNamespaceTypeDeclaration(symbol);
+                        continue;
+                    }
                     if (symbol.kind === "typeAlias" &&
                         symbol.declaration.kind === "typeAliasDeclaration" &&
                         symbol.declaration.type.kind !== "objectType") {
@@ -1824,11 +2861,45 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
                     }
                 }
                 if (symbol.kind === "function") {
+                    if (symbol.declaringNamespace !== namespace) {
+                        registerCrossNamespaceReexport({
+                            declaringNamespace: symbol.declaringNamespace,
+                            exportName: symbol.exportName,
+                            localName: symbol.localName,
+                            kind: "value",
+                        });
+                    }
                     const functionDeclaration = symbol.declaration.kind === "functionDeclaration"
                         ? symbol.declaration
                         : undefined;
                     if (!functionDeclaration)
                         continue;
+                    const symbolModuleKey = normalizeModuleFileKey(symbol.declaringFilePath);
+                    const symbolSourceIndex = sourceIndexByFileKey.get(symbolModuleKey);
+                    const symbolDeclarationModule = modulesByFileKey.get(symbolModuleKey);
+                    if (!symbolDeclarationModule) {
+                        return {
+                            ok: false,
+                            error: `Unable to resolve declaring module for '${symbol.exportName}' while generating ${symbol.declaringFilePath}.\n` +
+                                "First-party bindings generation requires a stable source module for each exported value.",
+                        };
+                    }
+                    if (symbolSourceIndex) {
+                        const registered = registerSourceTypeImportCandidates(symbolSourceIndex, symbolModuleKey, symbol.declaringFilePath);
+                        if (!registered.ok)
+                            return registered;
+                    }
+                    const registeredLocalTypeRefs = registerFacadeLocalTypeReferenceImports({
+                        declarationModule: symbolDeclarationModule,
+                        declarationNamespace: symbol.declaringNamespace,
+                        declarationFilePath: symbol.declaringFilePath,
+                        sourceIndex: symbolSourceIndex,
+                        typeParameters: functionDeclaration.typeParameters,
+                        parameterTypes: functionDeclaration.parameters.map((parameter) => parameter.type),
+                        returnType: functionDeclaration.returnType,
+                    });
+                    if (!registeredLocalTypeRefs.ok)
+                        return registeredLocalTypeRefs;
                     const isLocalContainerMember = symbol.declaringNamespace === module.namespace &&
                         symbol.declaringClassName === module.className;
                     if (isLocalContainerMember) {
@@ -1836,6 +2907,11 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
                             exportName: symbol.exportName,
                             localName: symbol.localName,
                             declaration: functionDeclaration,
+                            localTypeNameRemaps: registeredLocalTypeRefs.value,
+                            sourceSignatures: sourceIndexByFileKey
+                                .get(normalizeModuleFileKey(symbol.declaringFilePath))
+                                ?.exportedFunctionSignaturesByName.get(symbol.localName) ??
+                                [],
                         });
                     }
                     const registered = registerValueExport({
@@ -1849,6 +2925,7 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
                         facade: {
                             kind: "function",
                             declaration: functionDeclaration,
+                            localTypeNameRemaps: registeredLocalTypeRefs.value,
                             sourceSignatures: sourceIndexByFileKey
                                 .get(normalizeModuleFileKey(symbol.declaringFilePath))
                                 ?.exportedFunctionSignaturesByName.get(symbol.localName) ??
@@ -1860,13 +2937,60 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
                     continue;
                 }
                 if (symbol.kind === "variable") {
+                    if (symbol.declaringNamespace !== namespace) {
+                        registerCrossNamespaceReexport({
+                            declaringNamespace: symbol.declaringNamespace,
+                            exportName: symbol.exportName,
+                            localName: symbol.localName,
+                            kind: "value",
+                        });
+                    }
                     const declaration = symbol.declaration.kind === "variableDeclaration"
                         ? symbol.declaration
                         : undefined;
                     if (!declaration)
                         continue;
+                    const symbolModuleKey = normalizeModuleFileKey(symbol.declaringFilePath);
+                    const symbolSourceIndex = sourceIndexByFileKey.get(symbolModuleKey);
+                    const symbolDeclarationModule = modulesByFileKey.get(symbolModuleKey);
+                    if (!symbolDeclarationModule) {
+                        return {
+                            ok: false,
+                            error: `Unable to resolve declaring module for '${symbol.exportName}' while generating ${symbol.declaringFilePath}.\n` +
+                                "First-party bindings generation requires a stable source module for each exported value.",
+                        };
+                    }
+                    if (symbolSourceIndex) {
+                        const registered = registerSourceTypeImportCandidates(symbolSourceIndex, symbolModuleKey, symbol.declaringFilePath);
+                        if (!registered.ok)
+                            return registered;
+                    }
                     const declarator = declaration.declarations.find((candidate) => candidate.name.kind === "identifierPattern" &&
                         candidate.name.name === symbol.localName);
+                    const exportDeclarator = declarator && declarator.name.kind === "identifierPattern"
+                        ? {
+                            kind: declarator.kind,
+                            name: declarator.name,
+                            type: declarator.type,
+                            initializer: declarator.initializer,
+                        }
+                        : undefined;
+                    const exportedFunctionType = resolveFunctionTypeFromValueDeclarator(exportDeclarator);
+                    const registeredLocalTypeRefs = registerFacadeLocalTypeReferenceImports({
+                        declarationModule: symbolDeclarationModule,
+                        declarationNamespace: symbol.declaringNamespace,
+                        declarationFilePath: symbol.declaringFilePath,
+                        sourceIndex: symbolSourceIndex,
+                        typeParameters: undefined,
+                        parameterTypes: exportedFunctionType
+                            ? [exportedFunctionType]
+                            : declarator?.type
+                                ? [declarator.type]
+                                : [],
+                        returnType: undefined,
+                    });
+                    if (!registeredLocalTypeRefs.ok)
+                        return registeredLocalTypeRefs;
                     const isLocalContainerMember = symbol.declaringNamespace === module.namespace &&
                         symbol.declaringClassName === module.className;
                     if (isLocalContainerMember) {
@@ -1874,32 +2998,37 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
                             exportName: symbol.exportName,
                             localName: symbol.localName,
                             declaration,
-                            declarator: declarator && declarator.name.kind === "identifierPattern"
-                                ? {
-                                    kind: declarator.kind,
-                                    name: declarator.name,
-                                    type: declarator.type,
-                                }
-                                : undefined,
+                            declarator: exportDeclarator,
+                            localTypeNameRemaps: registeredLocalTypeRefs.value,
+                            sourceType: sourceIndexByFileKey
+                                .get(normalizeModuleFileKey(symbol.declaringFilePath))
+                                ?.exportedValueTypesByName.get(symbol.localName),
+                            sourceSignatures: sourceIndexByFileKey
+                                .get(normalizeModuleFileKey(symbol.declaringFilePath))
+                                ?.exportedFunctionSignaturesByName.get(symbol.localName) ??
+                                [],
                         });
                     }
                     const registered = registerValueExport({
                         exportName: symbol.exportName,
                         binding: {
-                            kind: "field",
+                            kind: exportedFunctionType ? "functionType" : "field",
                             clrName: symbol.localName,
                             declaringClrType: toClrTypeName(symbol.declaringNamespace, symbol.declaringClassName),
                             declaringAssemblyName: assemblyName,
+                            semanticType: exportedFunctionType
+                                ? undefined
+                                : rewriteBindingSemanticType(exportDeclarator?.type, registeredLocalTypeRefs.value),
+                            semanticSignature: exportedFunctionType
+                                ? buildSemanticSignatureFromFunctionType(exportedFunctionType, registeredLocalTypeRefs.value)
+                                : undefined,
                         },
                         facade: {
                             kind: "variable",
-                            declarator: declarator && declarator.name.kind === "identifierPattern"
-                                ? {
-                                    kind: declarator.kind,
-                                    name: declarator.name,
-                                    type: declarator.type,
-                                }
-                                : undefined,
+                            localTypeNameRemaps: registeredLocalTypeRefs.value,
+                            sourceType: symbolSourceIndex?.exportedValueTypesByName.get(symbol.localName),
+                            sourceSignatures: symbolSourceIndex?.exportedFunctionSignaturesByName.get(symbol.localName) ?? [],
+                            declarator: exportDeclarator,
                         },
                     });
                     if (!registered.ok)
@@ -1914,18 +3043,113 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
                 });
             }
         }
+        const anonymousHelperClassNamesByShape = new Map();
+        const registerAnonymousHelperClass = (emittedName, declaration) => {
+            if (!emittedName.startsWith("__Anon_") &&
+                !declaration.name.startsWith("__Anon_")) {
+                return;
+            }
+            const members = [];
+            for (const member of declaration.members) {
+                if (member.kind === "propertyDeclaration") {
+                    if (isPortableMarkerMemberName(member.name))
+                        continue;
+                    members.push({
+                        kind: "propertySignature",
+                        name: member.name,
+                        type: member.type ?? { kind: "unknownType" },
+                        isOptional: false,
+                        isReadonly: member.isReadonly,
+                    });
+                    continue;
+                }
+                if (member.kind === "methodDeclaration") {
+                    if (isPortableMarkerMemberName(member.name))
+                        continue;
+                    members.push({
+                        kind: "methodSignature",
+                        name: member.name,
+                        parameters: member.parameters,
+                        returnType: member.returnType,
+                        typeParameters: member.typeParameters,
+                    });
+                }
+            }
+            const shape = renderPortableType({ kind: "objectType", members }, declaration.typeParameters?.map((typeParameter) => typeParameter.name) ?? [], new Map(), new Map());
+            anonymousHelperClassNamesByShape.set(shape, emittedName);
+        };
+        for (const symbol of typeDeclarations) {
+            if (symbol.kind === "class" &&
+                symbol.declaration.kind === "classDeclaration") {
+                registerAnonymousHelperClass(symbol.localName, symbol.declaration);
+            }
+        }
+        for (const helper of internalHelperTypeDeclarationsByKey.values()) {
+            if (helper.kind === "class") {
+                registerAnonymousHelperClass(helper.emittedName, helper.declaration);
+            }
+        }
+        for (const [moduleKey, sourceIndex] of sourceIndexByFileKey) {
+            const sourceModule = modulesByFileKey.get(moduleKey);
+            if (!sourceModule)
+                continue;
+            for (const [shape, anonymousType,] of sourceIndex.anonymousTypeLiteralsByShape) {
+                const className = anonymousHelperClassNamesByShape.get(shape);
+                if (!className)
+                    continue;
+                for (const [memberName, sourceMember] of anonymousType.members) {
+                    const wrappersResult = collectExtensionWrapperImportsFromSourceType({
+                        startModuleKey: moduleKey,
+                        typeNode: sourceMember.typeNode,
+                        sourceIndexByFileKey,
+                        modulesByFileKey,
+                    });
+                    if (!wrappersResult.ok)
+                        return wrappersResult;
+                    const wrappers = wrappersResult.value;
+                    const canUseSourceTypeText = !typeNodeUsesImportedTypeNames(sourceMember.typeNode, sourceIndex.typeImportsByLocalName);
+                    if (!canUseSourceTypeText &&
+                        wrappers.length === 0 &&
+                        !sourceMember.isOptional) {
+                        continue;
+                    }
+                    const wrapperRegistered = registerWrapperImports(wrappers, sourceModule.filePath);
+                    if (!wrapperRegistered.ok)
+                        return wrapperRegistered;
+                    memberOverrides.push({
+                        className,
+                        memberName,
+                        sourceTypeText: canUseSourceTypeText
+                            ? sourceMember.typeText
+                            : undefined,
+                        replaceWithSourceType: canUseSourceTypeText,
+                        isOptional: sourceMember.isOptional,
+                        emitOptionalPropertySyntax: true,
+                        wrappers,
+                    });
+                }
+            }
+        }
         plans.push({
             namespace,
             typeDeclarations: typeDeclarations.sort((left, right) => left.exportName.localeCompare(right.exportName)),
+            internalHelperTypeDeclarations: Array.from(internalHelperTypeDeclarationsByKey.values()).sort((left, right) => left.key.localeCompare(right.key)),
             moduleContainers: moduleContainers.sort((left, right) => left.module.className.localeCompare(right.module.className)),
-            sourceAliasLines: Array.from(sourceAliasLines.values()).sort((left, right) => left.localeCompare(right)),
-            sourceAliasInternalImports: Array.from(sourceAliasInternalImports.values()).sort((left, right) => left.localeCompare(right)),
+            crossNamespaceReexports: finalizeCrossNamespaceReexports(crossNamespaceReexportsGrouped),
+            crossNamespaceTypeDeclarations: crossNamespaceTypeDeclarations.sort((left, right) => {
+                const leftKey = `${left.exportName}|${left.declaringNamespace}|${left.localName}|${left.kind}`;
+                const rightKey = `${right.exportName}|${right.declaringNamespace}|${right.localName}|${right.kind}`;
+                return leftKey.localeCompare(rightKey);
+            }),
+            sourceAliases: sourceAliasPlans.sort((left, right) => left.declaration.name.localeCompare(right.declaration.name)),
             memberOverrides: memberOverrides.sort((left, right) => {
                 const classCmp = left.className.localeCompare(right.className);
                 if (classCmp !== 0)
                     return classCmp;
                 return left.memberName.localeCompare(right.memberName);
             }),
+            internalTypeImports: Array.from(internalTypeImportByAlias.values()).sort((left, right) => left.localName.localeCompare(right.localName)),
+            facadeTypeImports: Array.from(facadeTypeImportByAlias.values()).sort((left, right) => left.localName.localeCompare(right.localName)),
             wrapperImports: Array.from(wrapperImportByAlias.values()).sort((left, right) => left.aliasName.localeCompare(right.aliasName)),
             valueExports: Array.from(valueExportsMap.values()).sort((left, right) => left.exportName.localeCompare(right.exportName)),
         });
@@ -1935,55 +3159,7 @@ const collectNamespacePlans = (modules, assemblyName, rootNamespace, sourceIndex
         value: plans.sort((left, right) => left.namespace.localeCompare(right.namespace)),
     };
 };
-const collectEntrypointReexports = (entryModule, modulesByFileKey) => {
-    const grouped = new Map();
-    for (const exported of entryModule.exports) {
-        if (exported.kind !== "reexport")
-            continue;
-        const targetModule = resolveLocalModuleFile(exported.fromModule, entryModule.filePath, modulesByFileKey);
-        if (!targetModule) {
-            return {
-                ok: false,
-                error: `Failed to resolve re-export '${exported.name}' from '${exported.fromModule}' in ${entryModule.filePath}.`,
-            };
-        }
-        if (targetModule.namespace === entryModule.namespace)
-            continue;
-        const kind = classifyExportKind(targetModule, exported.originalName);
-        if (kind === "unknown") {
-            return {
-                ok: false,
-                error: `Failed to classify re-export '${exported.name}' from '${exported.fromModule}' in ${entryModule.filePath}.`,
-            };
-        }
-        const moduleSpecifier = `./${moduleNamespacePath(targetModule.namespace)}.js`;
-        const key = `${moduleSpecifier}|${kind}`;
-        const specifier = exported.name === exported.originalName
-            ? exported.name
-            : `${exported.originalName} as ${exported.name}`;
-        const list = grouped.get(key) ?? [];
-        list.push(specifier);
-        grouped.set(key, list);
-    }
-    const dtsStatements = [];
-    const jsValueStatements = [];
-    for (const [key, specs] of Array.from(grouped.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
-        const [moduleSpecifier, kind] = key.split("|");
-        const unique = Array.from(new Set(specs)).sort((a, b) => a.localeCompare(b));
-        if (kind === "type") {
-            dtsStatements.push(`export type { ${unique.join(", ")} } from '${moduleSpecifier}';`);
-            continue;
-        }
-        const statement = `export { ${unique.join(", ")} } from '${moduleSpecifier}';`;
-        dtsStatements.push(statement);
-        jsValueStatements.push(statement);
-    }
-    return {
-        ok: true,
-        value: { dtsStatements, jsValueStatements },
-    };
-};
-const writeNamespaceArtifacts = (config, outDir, plan, entrypointReexports) => {
+const writeNamespaceArtifacts = (config, outDir, plan) => {
     const namespacePath = moduleNamespacePath(plan.namespace);
     const namespaceDir = join(outDir, namespacePath);
     const internalDir = join(namespaceDir, "internal");
@@ -1992,7 +3168,8 @@ const writeNamespaceArtifacts = (config, outDir, plan, entrypointReexports) => {
     const facadeDtsPath = join(outDir, `${namespacePath}.d.ts`);
     const facadeJsPath = join(outDir, `${namespacePath}.js`);
     const bindingsPath = join(namespaceDir, "bindings.json");
-    const internalLines = [];
+    const anonymousStructuralAliases = buildAnonymousStructuralAliasMap(plan);
+    const internalBodyLines = [];
     const memberOverridesByClass = new Map();
     for (const override of plan.memberOverrides) {
         const byMember = memberOverridesByClass.get(override.className) ??
@@ -2000,47 +3177,29 @@ const writeNamespaceArtifacts = (config, outDir, plan, entrypointReexports) => {
         byMember.set(override.memberName, override);
         memberOverridesByClass.set(override.className, byMember);
     }
-    internalLines.push("// Generated by Tsonic - Source bindings");
-    internalLines.push(`// Namespace: ${plan.namespace}`);
-    internalLines.push(`// Assembly: ${config.outputName}`);
-    internalLines.push("");
-    internalLines.push(primitiveImportLine);
-    if (plan.wrapperImports.length > 0) {
-        internalLines.push("");
-        internalLines.push("// Tsonic source member type imports (generated)");
-        for (const wrapperImport of plan.wrapperImports) {
-            if (wrapperImport.importedName === wrapperImport.aliasName) {
-                internalLines.push(`import type { ${wrapperImport.importedName} } from '${wrapperImport.source}';`);
-                continue;
-            }
-            internalLines.push(`import type { ${wrapperImport.importedName} as ${wrapperImport.aliasName} } from '${wrapperImport.source}';`);
-        }
-        internalLines.push("// End Tsonic source member type imports");
-    }
-    internalLines.push("");
     const typeBindings = [];
     for (const symbol of plan.typeDeclarations) {
         if (symbol.kind === "class" &&
             symbol.declaration.kind === "classDeclaration") {
-            internalLines.push(...renderClassInternal(symbol.declaration, plan.namespace, memberOverridesByClass.get(symbol.declaration.name) ?? new Map()));
+            internalBodyLines.push(...renderClassInternal(symbol.declaration, plan.namespace, memberOverridesByClass.get(symbol.declaration.name) ?? new Map()));
             typeBindings.push(buildTypeBindingFromClass(symbol.declaration, plan.namespace, config.outputName));
             continue;
         }
         if (symbol.kind === "interface" &&
             symbol.declaration.kind === "interfaceDeclaration") {
-            internalLines.push(...renderInterfaceInternal(symbol.declaration, plan.namespace, memberOverridesByClass.get(symbol.declaration.name) ?? new Map()));
+            internalBodyLines.push(...renderInterfaceInternal(symbol.declaration, plan.namespace, memberOverridesByClass.get(symbol.declaration.name) ?? new Map()));
             typeBindings.push(buildTypeBindingFromInterface(symbol.declaration, plan.namespace, config.outputName));
             continue;
         }
         if (symbol.kind === "enum" &&
             symbol.declaration.kind === "enumDeclaration") {
-            internalLines.push(...renderEnumInternal(symbol.declaration));
+            internalBodyLines.push(...renderEnumInternal(symbol.declaration));
             typeBindings.push(buildTypeBindingFromEnum(symbol.declaration, plan.namespace, config.outputName));
             continue;
         }
         if (symbol.kind === "typeAlias" &&
             symbol.declaration.kind === "typeAliasDeclaration") {
-            internalLines.push(...renderStructuralAliasInternal(symbol.declaration, plan.namespace, memberOverridesByClass.get(`${symbol.declaration.name}__Alias${(symbol.declaration.typeParameters?.length ?? 0) > 0
+            internalBodyLines.push(...renderStructuralAliasInternal(symbol.declaration, plan.namespace, memberOverridesByClass.get(`${symbol.declaration.name}__Alias${(symbol.declaration.typeParameters?.length ?? 0) > 0
                 ? `_${symbol.declaration.typeParameters?.length ?? 0}`
                 : ""}`) ?? new Map()));
             const binding = buildTypeBindingFromStructuralAlias(symbol.declaration, plan.namespace, config.outputName);
@@ -2048,10 +3207,137 @@ const writeNamespaceArtifacts = (config, outDir, plan, entrypointReexports) => {
                 typeBindings.push(binding);
         }
     }
+    const helperRemapsByModuleKey = new Map();
+    for (const helper of plan.internalHelperTypeDeclarations) {
+        const current = new Map(helperRemapsByModuleKey.get(helper.moduleFileKey) ?? []);
+        current.set(helper.originalName, helper.emittedName);
+        helperRemapsByModuleKey.set(helper.moduleFileKey, current);
+    }
+    for (const helper of plan.internalHelperTypeDeclarations) {
+        const localTypeNameRemaps = helperRemapsByModuleKey.get(helper.moduleFileKey) ?? new Map();
+        switch (helper.kind) {
+            case "class":
+                internalBodyLines.push(...renderClassInternal(helper.declaration, helper.declaringNamespace, memberOverridesByClass.get(helper.emittedName) ??
+                    memberOverridesByClass.get(helper.declaration.name) ??
+                    new Map(), helper.emittedName, localTypeNameRemaps, helper.declaration.name, helper.declaration.name));
+                typeBindings.push(buildTypeBindingFromClass(helper.declaration, helper.declaringNamespace, config.outputName, localTypeNameRemaps));
+                continue;
+            case "interface":
+                internalBodyLines.push(...renderInterfaceInternal(helper.declaration, helper.declaringNamespace, memberOverridesByClass.get(helper.emittedName) ??
+                    memberOverridesByClass.get(helper.declaration.name) ??
+                    new Map(), helper.emittedName, localTypeNameRemaps, helper.declaration.name, helper.declaration.name));
+                typeBindings.push(buildTypeBindingFromInterface(helper.declaration, helper.declaringNamespace, config.outputName, localTypeNameRemaps));
+                continue;
+            case "enum":
+                internalBodyLines.push(...renderEnumInternal(helper.declaration, helper.emittedName));
+                typeBindings.push(buildTypeBindingFromEnum(helper.declaration, helper.declaringNamespace, config.outputName));
+                continue;
+            case "typeAlias": {
+                const structuralLines = renderStructuralAliasInternal(helper.declaration, helper.declaringNamespace, memberOverridesByClass.get(helper.emittedName) ??
+                    memberOverridesByClass.get(`${helper.declaration.name}__Alias${(helper.declaration.typeParameters
+                        ?.length ?? 0) > 0
+                        ? `_${helper.declaration
+                            .typeParameters?.length ?? 0}`
+                        : ""}`) ??
+                    new Map(), helper.emittedName, localTypeNameRemaps, `${helper.declaration.name}__Alias${(helper.declaration.typeParameters
+                    ?.length ?? 0) > 0
+                    ? `_${helper.declaration.typeParameters
+                        ?.length ?? 0}`
+                    : ""}`, `${helper.declaration.name}__Alias${(helper.declaration.typeParameters
+                    ?.length ?? 0) > 0
+                    ? `_${helper.declaration.typeParameters
+                        ?.length ?? 0}`
+                    : ""}`);
+                if (structuralLines.length > 0) {
+                    internalBodyLines.push(...structuralLines);
+                    const binding = buildTypeBindingFromStructuralAlias(helper.declaration, helper.declaringNamespace, config.outputName, localTypeNameRemaps);
+                    if (binding)
+                        typeBindings.push(binding);
+                    continue;
+                }
+                internalBodyLines.push(...renderTypeAliasInternal(helper.declaration, helper.emittedName, localTypeNameRemaps, anonymousStructuralAliases));
+                continue;
+            }
+        }
+    }
+    const renderedSourceAliases = plan.sourceAliases.map((sourceAliasPlan) => renderSourceAliasPlan(sourceAliasPlan, anonymousStructuralAliases));
+    const sourceAliasLines = renderedSourceAliases.map((entry) => entry.line);
+    const sourceAliasInternalImports = renderedSourceAliases
+        .map((entry) => entry.internalImport)
+        .filter((entry) => entry !== undefined)
+        .sort((left, right) => left.localeCompare(right));
     for (const container of plan.moduleContainers) {
-        internalLines.push(...renderContainerInternal(container));
+        internalBodyLines.push(...renderContainerInternal(container, anonymousStructuralAliases));
         typeBindings.push(buildTypeBindingFromContainer(container, plan.namespace, config.outputName));
     }
+    for (const symbol of plan.crossNamespaceTypeDeclarations) {
+        if (symbol.kind === "class" &&
+            symbol.declaration.kind === "classDeclaration") {
+            typeBindings.push(buildTypeBindingFromClass(symbol.declaration, symbol.declaringNamespace, config.outputName));
+            continue;
+        }
+        if (symbol.kind === "interface" &&
+            symbol.declaration.kind === "interfaceDeclaration") {
+            typeBindings.push(buildTypeBindingFromInterface(symbol.declaration, symbol.declaringNamespace, config.outputName));
+            continue;
+        }
+        if (symbol.kind === "enum" &&
+            symbol.declaration.kind === "enumDeclaration") {
+            typeBindings.push(buildTypeBindingFromEnum(symbol.declaration, symbol.declaringNamespace, config.outputName));
+            continue;
+        }
+        if (symbol.kind === "typeAlias" &&
+            symbol.declaration.kind === "typeAliasDeclaration") {
+            const binding = buildTypeBindingFromStructuralAlias(symbol.declaration, symbol.declaringNamespace, config.outputName);
+            if (binding)
+                typeBindings.push(binding);
+        }
+    }
+    const internalSourceAliasLines = sourceAliasLines.length > 0
+        ? [
+            "",
+            "// Tsonic source type aliases (generated)",
+            ...sourceAliasLines,
+            "// End Tsonic source type aliases",
+        ]
+        : [];
+    const requiredInternalTypeImports = selectSourceTypeImportsForRenderedText([...internalSourceAliasLines, ...internalBodyLines].join("\n"), plan.internalTypeImports);
+    const internalLines = [];
+    internalLines.push("// Generated by Tsonic - Source bindings");
+    internalLines.push(`// Namespace: ${plan.namespace}`);
+    internalLines.push(`// Assembly: ${config.outputName}`);
+    internalLines.push("");
+    internalLines.push(primitiveImportLine);
+    if (requiredInternalTypeImports.length > 0) {
+        internalLines.push("");
+        internalLines.push("// Tsonic source type imports (generated)");
+        for (const typeImport of requiredInternalTypeImports) {
+            if (typeImport.importedName === typeImport.localName) {
+                internalLines.push(`import type { ${typeImport.importedName} } from '${typeImport.source}';`);
+                continue;
+            }
+            internalLines.push(`import type { ${typeImport.importedName} as ${typeImport.localName} } from '${typeImport.source}';`);
+        }
+        internalLines.push("// End Tsonic source type imports");
+    }
+    if (plan.wrapperImports.length > 0) {
+        internalLines.push("");
+        internalLines.push("// Tsonic source member type imports (generated)");
+        for (const wrapperImport of plan.wrapperImports) {
+            if (wrapperImport.importedName === wrapperImport.aliasName) {
+                internalLines.push(`import type { ${wrapperImport.importedName} } from '${wrapperImport.source}';`);
+                continue;
+            }
+            internalLines.push(`import type { ${wrapperImport.importedName} as ${wrapperImport.aliasName} } from '${wrapperImport.source}';`);
+        }
+        internalLines.push("// End Tsonic source member type imports");
+    }
+    internalLines.push("");
+    if (internalSourceAliasLines.length > 0) {
+        internalLines.push(...internalSourceAliasLines);
+        internalLines.push("");
+    }
+    internalLines.push(...internalBodyLines);
     writeFileSync(internalIndexPath, internalLines.join("\n").trimEnd() + "\n", "utf-8");
     const internalSpecifier = moduleNamespaceToInternalSpecifier(plan.namespace);
     const facadeLines = [];
@@ -2100,9 +3386,12 @@ const writeNamespaceArtifacts = (config, outDir, plan, entrypointReexports) => {
             localTypeImports.add(`${symbol.localName}$instance`);
         }
     }
-    for (const internalImport of plan.sourceAliasInternalImports) {
+    for (const internalImport of sourceAliasInternalImports) {
         localTypeImports.add(internalImport);
     }
+    for (const helper of plan.internalHelperTypeDeclarations) {
+        localTypeImports.add(helper.emittedName);
+    }
     if (localTypeImports.size > 0) {
         facadeLines.push("");
         facadeLines.push("// Tsonic source alias imports (generated)");
@@ -2111,35 +3400,53 @@ const writeNamespaceArtifacts = (config, outDir, plan, entrypointReexports) => {
             .join(", ")} } from '${internalSpecifier}';`);
         facadeLines.push("// End Tsonic source alias imports");
     }
-    if (plan.sourceAliasLines.length > 0) {
+    if (sourceAliasLines.length > 0) {
         facadeLines.push("");
         facadeLines.push("// Tsonic source type aliases (generated)");
-        facadeLines.push(...plan.sourceAliasLines);
+        facadeLines.push(...sourceAliasLines);
         facadeLines.push("// End Tsonic source type aliases");
     }
-    if (entrypointReexports && entrypointReexports.dtsStatements.length > 0) {
+    if (plan.crossNamespaceReexports.dtsStatements.length > 0) {
         facadeLines.push("");
-        facadeLines.push("// Tsonic entrypoint re-exports (generated)");
-        facadeLines.push(...entrypointReexports.dtsStatements);
-        facadeLines.push("// End Tsonic entrypoint re-exports");
+        facadeLines.push("// Tsonic cross-namespace re-exports (generated)");
+        facadeLines.push(...plan.crossNamespaceReexports.dtsStatements);
+        facadeLines.push("// End Tsonic cross-namespace re-exports");
     }
     for (const valueExport of plan.valueExports) {
         valueBindings.set(valueExport.exportName, valueExport.binding);
         if (valueExport.facade.kind === "function") {
-            const typeParametersText = printTypeParameters(valueExport.facade.declaration.typeParameters);
-            const typeParameterNames = valueExport.facade.declaration.typeParameters?.map((typeParameter) => typeParameter.name) ?? [];
-            const parametersText = renderUnknownParameters(valueExport.facade.declaration.parameters, typeParameterNames);
-            const returnTypeText = renderPortableType(valueExport.facade.declaration.returnType, typeParameterNames);
-            facadeLines.push(`export declare function ${valueExport.exportName}${typeParametersText}(${parametersText}): ${returnTypeText};`);
+            const sourceSignature = renderSourceFunctionSignature({
+                declaration: valueExport.facade.declaration,
+                sourceSignatures: valueExport.facade.sourceSignatures ?? [],
+                localTypeNameRemaps: valueExport.facade.localTypeNameRemaps,
+                anonymousStructuralAliases,
+            });
+            facadeLines.push(sourceSignature
+                ? `export declare function ${valueExport.exportName}${sourceSignature.typeParametersText}(${sourceSignature.parametersText}): ${sourceSignature.returnTypeText};`
+                : `export declare function ${valueExport.exportName}${printTypeParameters(valueExport.facade.declaration.typeParameters)}(${renderUnknownParameters(valueExport.facade.declaration.parameters, valueExport.facade.declaration.typeParameters?.map((typeParameter) => typeParameter.name) ?? [], valueExport.facade.localTypeNameRemaps, anonymousStructuralAliases)}): ${renderPortableType(valueExport.facade.declaration.returnType, valueExport.facade.declaration.typeParameters?.map((typeParameter) => typeParameter.name) ?? [], valueExport.facade.localTypeNameRemaps, anonymousStructuralAliases)};`);
             continue;
         }
-        facadeLines.push(`export declare const ${valueExport.exportName}: ${renderPortableType(valueExport.facade.declarator?.type)};`);
+        const sourceFunctionTypeText = renderSourceFunctionType({
+            sourceSignatures: valueExport.facade.sourceSignatures ?? [],
+            localTypeNameRemaps: valueExport.facade.localTypeNameRemaps,
+            anonymousStructuralAliases,
+        });
+        const sourceTypeText = sourceFunctionTypeText ??
+            renderSourceValueType(valueExport.facade.sourceType, valueExport.facade.localTypeNameRemaps, anonymousStructuralAliases);
+        facadeLines.push(`export declare const ${valueExport.exportName}: ${sourceTypeText ??
+            renderPortableType(valueExport.facade.declarator?.type, [], valueExport.facade.localTypeNameRemaps, anonymousStructuralAliases)};`);
+    }
+    const requiredFacadeTypeImports = selectSourceTypeImportsForRenderedText(facadeLines.join("\n"), plan.facadeTypeImports);
+    if (requiredFacadeTypeImports.length > 0) {
+        facadeLines.splice(4, 0, "", "// Tsonic source type imports (generated)", ...requiredFacadeTypeImports.map((typeImport) => typeImport.importedName === typeImport.localName
+            ? `import type { ${typeImport.importedName} } from '${typeImport.source}';`
+            : `import type { ${typeImport.importedName} as ${typeImport.localName} } from '${typeImport.source}';`), "// End Tsonic source type imports");
     }
     if (plan.typeDeclarations.length === 0 &&
         plan.moduleContainers.length === 0 &&
         plan.valueExports.length === 0 &&
-        plan.sourceAliasLines.length === 0 &&
-        (!entrypointReexports || entrypointReexports.dtsStatements.length === 0)) {
+        sourceAliasLines.length === 0 &&
+        plan.crossNamespaceReexports.dtsStatements.length === 0) {
         facadeLines.push("export {};");
     }
     writeFileSync(facadeDtsPath, facadeLines.join("\n").trimEnd() + "\n", "utf-8");
@@ -2148,12 +3455,11 @@ const writeNamespaceArtifacts = (config, outDir, plan, entrypointReexports) => {
         "// Generated by Tsonic - Source bindings",
         "// Module Stub - Do Not Execute",
         "",
-        ...(entrypointReexports &&
-            entrypointReexports.jsValueStatements.length > 0
+        ...(plan.crossNamespaceReexports.jsValueStatements.length > 0
             ? [
-                "// Tsonic entrypoint value re-exports (generated)",
-                ...entrypointReexports.jsValueStatements,
-                "// End Tsonic entrypoint value re-exports",
+                "// Tsonic cross-namespace value re-exports (generated)",
+                ...plan.crossNamespaceReexports.jsValueStatements,
+                "// End Tsonic cross-namespace value re-exports",
                 "",
             ]
             : []),
@@ -2216,10 +3522,6 @@ export const generateFirstPartyLibraryBindings = (config, bindingsOutDir) => {
     }
     rmSync(bindingsOutDir, { recursive: true, force: true });
     mkdirSync(bindingsOutDir, { recursive: true });
-    const modulesByFileKey = new Map();
-    for (const module of graphResult.value.modules) {
-        modulesByFileKey.set(normalizeModuleFileKey(module.filePath), module);
-    }
     const sourceIndexByFileKey = new Map();
     for (const module of graphResult.value.modules) {
         if (module.filePath.startsWith("__tsonic/"))
@@ -2234,13 +3536,8 @@ export const generateFirstPartyLibraryBindings = (config, bindingsOutDir) => {
     const plansResult = collectNamespacePlans(graphResult.value.modules, config.outputName, config.rootNamespace, sourceIndexByFileKey);
     if (!plansResult.ok)
         return plansResult;
-    const entrypointReexportsResult = collectEntrypointReexports(graphResult.value.entryModule, modulesByFileKey);
-    if (!entrypointReexportsResult.ok)
-        return entrypointReexportsResult;
     for (const plan of plansResult.value) {
-        const result = writeNamespaceArtifacts(config, bindingsOutDir, plan, plan.namespace === graphResult.value.entryModule.namespace
-            ? entrypointReexportsResult.value
-            : undefined);
+        const result = writeNamespaceArtifacts(config, bindingsOutDir, plan);
         if (!result.ok)
             return result;
     }