@tsonic/frontend 0.0.71 → 0.0.73

package/dist/ir/builder.test.js

@@ -54,6 +54,66 @@ describe("IR Builder", () => {
         const ctx = createProgramContext(testProgram, options);
         return { testProgram, ctx, options };
     };
+    const createFilesystemTestProgram = (files, entryRelativePath) => {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tsonic-builder-filesystem-"));
+        for (const [relativePath, contents] of Object.entries(files)) {
+            const absolutePath = path.join(tempDir, relativePath);
+            fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+            fs.writeFileSync(absolutePath, contents);
+        }
+        const rootNames = Object.keys(files)
+            .filter((relativePath) => /\.(?:ts|mts|cts|d\.ts)$/.test(relativePath))
+            .map((relativePath) => path.join(tempDir, relativePath));
+        const tsProgram = ts.createProgram(rootNames, {
+            target: ts.ScriptTarget.ES2022,
+            module: ts.ModuleKind.NodeNext,
+            moduleResolution: ts.ModuleResolutionKind.NodeNext,
+            strict: true,
+            noEmit: true,
+            skipLibCheck: true,
+        });
+        const checker = tsProgram.getTypeChecker();
+        const entryPath = path.join(tempDir, entryRelativePath);
+        const sourceFile = tsProgram.getSourceFile(entryPath);
+        if (!sourceFile) {
+            throw new Error(`Failed to create source file for ${entryRelativePath}`);
+        }
+        const testProgram = {
+            program: tsProgram,
+            checker,
+            options: {
+                projectRoot: tempDir,
+                sourceRoot: path.join(tempDir, "src"),
+                rootNamespace: "TestApp",
+                strict: true,
+            },
+            sourceFiles: rootNames
+                .filter((filePath) => !filePath.endsWith(".d.ts"))
+                .map((filePath) => tsProgram.getSourceFile(filePath))
+                .filter((candidate) => candidate !== undefined),
+            declarationSourceFiles: rootNames
+                .filter((filePath) => filePath.endsWith(".d.ts"))
+                .map((filePath) => tsProgram.getSourceFile(filePath))
+                .filter((candidate) => candidate !== undefined),
+            metadata: new DotnetMetadataRegistry(),
+            bindings: new BindingRegistry(),
+            clrResolver: createClrBindingsResolver(tempDir),
+            binding: createBinding(checker),
+        };
+        const options = {
+            sourceRoot: path.join(tempDir, "src"),
+            rootNamespace: "TestApp",
+        };
+        const ctx = createProgramContext(testProgram, options);
+        return {
+            tempDir,
+            sourceFile,
+            testProgram,
+            ctx,
+            options,
+            cleanup: () => fs.rmSync(tempDir, { recursive: true, force: true }),
+        };
+    };
     describe("Module Structure", () => {
         it("should create IR module with correct namespace and class name", () => {
             const source = `
@@ -476,6 +536,165 @@ describe("IR Builder", () => {
                 fs.rmSync(tempDir, { recursive: true, force: true });
             }
         });
+        it("preserves canonical CLR identity for array elements from source-binding declarations", function () {
+            this.timeout(30000);
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tsonic-builder-source-array-identity-"));
+            try {
+                fs.writeFileSync(path.join(tempDir, "package.json"), JSON.stringify({ name: "app", version: "1.0.0", type: "module" }, null, 2));
+                const srcDir = path.join(tempDir, "src");
+                fs.mkdirSync(srcDir, { recursive: true });
+                const bindingsRoot = path.join(tempDir, "tsonic", "bindings");
+                fs.mkdirSync(path.join(bindingsRoot, "Acme.Core", "internal"), {
+                    recursive: true,
+                });
+                fs.writeFileSync(path.join(bindingsRoot, "Acme.Core", "internal", "index.d.ts"), [
+                    "export interface Attachment$instance {",
+                    '  readonly "__tsonic_binding_alias_Acme.Core.Attachment"?: never;',
+                    "  readonly __tsonic_type_Acme_Core_Attachment?: never;",
+                    "  Id: string;",
+                    "}",
+                    "export type Attachment = Attachment$instance;",
+                ].join("\n"));
+                fs.writeFileSync(path.join(bindingsRoot, "Acme.Core.d.ts"), [
+                    'import type { Attachment } from "./Acme.Core/internal/index.js";',
+                    "export declare function getAttachments(): Attachment[];",
+                ].join("\n"));
+                const entryPath = path.join(srcDir, "index.ts");
+                fs.writeFileSync(entryPath, [
+                    'import { getAttachments } from "../tsonic/bindings/Acme.Core.js";',
+                    "const attachments = getAttachments();",
+                    "export const attachmentCount = attachments.length;",
+                ].join("\n"));
+                const programResult = createProgram([entryPath], {
+                    projectRoot: tempDir,
+                    sourceRoot: srcDir,
+                    rootNamespace: "TestApp",
+                    useStandardLib: true,
+                });
+                expect(programResult.ok).to.equal(true);
+                if (!programResult.ok)
+                    return;
+                const program = programResult.value;
+                const sourceFile = program.sourceFiles.find((file) => path.resolve(file.fileName) === path.resolve(entryPath));
+                expect(sourceFile).to.not.equal(undefined);
+                if (!sourceFile)
+                    return;
+                const ctx = createProgramContext(program, {
+                    sourceRoot: srcDir,
+                    rootNamespace: "TestApp",
+                });
+                const moduleResult = buildIrModule(sourceFile, program, {
+                    sourceRoot: srcDir,
+                    rootNamespace: "TestApp",
+                }, ctx);
+                expect(moduleResult.ok).to.equal(true);
+                if (!moduleResult.ok)
+                    return;
+                const attachmentsDecl = moduleResult.value.body.find((stmt) => stmt.kind === "variableDeclaration" &&
+                    stmt.declarations[0]?.name.kind === "identifierPattern" &&
+                    stmt.declarations[0]?.name.name === "attachments");
+                expect(attachmentsDecl).to.not.equal(undefined);
+                if (!attachmentsDecl)
+                    return;
+                const attachmentsType = attachmentsDecl.declarations[0]?.type;
+                expect(attachmentsType?.kind).to.equal("arrayType");
+                if (!attachmentsType || attachmentsType.kind !== "arrayType")
+                    return;
+                expect(attachmentsType.elementType.kind).to.equal("referenceType");
+                if (attachmentsType.elementType.kind !== "referenceType")
+                    return;
+                expect(attachmentsType.elementType.name).to.equal("Acme.Core.Attachment");
+                expect(attachmentsType.elementType.resolvedClrType).to.equal("Acme.Core.Attachment");
+            }
+            finally {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            }
+        });
+        it("preserves CLR identity for generic structural aliases from source-binding declarations", function () {
+            this.timeout(30000);
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tsonic-builder-source-generic-alias-"));
+            try {
+                fs.writeFileSync(path.join(tempDir, "package.json"), JSON.stringify({ name: "app", version: "1.0.0", type: "module" }, null, 2));
+                const srcDir = path.join(tempDir, "src");
+                fs.mkdirSync(srcDir, { recursive: true });
+                const bindingsRoot = path.join(tempDir, "tsonic", "bindings");
+                fs.mkdirSync(path.join(bindingsRoot, "Acme.Core", "internal"), {
+                    recursive: true,
+                });
+                fs.writeFileSync(path.join(bindingsRoot, "Acme.Core", "bindings.json"), JSON.stringify({
+                    namespace: "Acme.Core",
+                    types: [
+                        {
+                            clrName: "Acme.Core.Ok__Alias`1",
+                            assemblyName: "Acme.Core",
+                            methods: [],
+                            properties: [],
+                            fields: [],
+                        },
+                    ],
+                }, null, 2));
+                fs.writeFileSync(path.join(bindingsRoot, "Acme.Core", "internal", "index.d.ts"), [
+                    "export interface Ok__Alias_1$instance<T> {",
+                    '  readonly "__tsonic_binding_alias_Acme.Core.Ok__Alias_1"?: never;',
+                    "  readonly value: T;",
+                    "}",
+                    "export type Ok__Alias_1<T> = Ok__Alias_1$instance<T>;",
+                ].join("\n"));
+                fs.writeFileSync(path.join(bindingsRoot, "Acme.Core.d.ts"), [
+                    'import type { Ok__Alias_1 } from "./Acme.Core/internal/index.js";',
+                    "export type Ok<T> = Ok__Alias_1<T>;",
+                ].join("\n"));
+                const entryPath = path.join(srcDir, "index.ts");
+                fs.writeFileSync(entryPath, [
+                    'import type { Ok } from "../tsonic/bindings/Acme.Core.js";',
+                    'export const value: Ok<string> | undefined = undefined;',
+                ].join("\n"));
+                const programResult = createProgram([entryPath], {
+                    projectRoot: tempDir,
+                    sourceRoot: srcDir,
+                    rootNamespace: "TestApp",
+                    useStandardLib: true,
+                });
+                expect(programResult.ok).to.equal(true);
+                if (!programResult.ok)
+                    return;
+                const program = programResult.value;
+                const sourceFile = program.sourceFiles.find((file) => path.resolve(file.fileName) === path.resolve(entryPath));
+                expect(sourceFile).to.not.equal(undefined);
+                if (!sourceFile)
+                    return;
+                const ctx = createProgramContext(program, {
+                    sourceRoot: srcDir,
+                    rootNamespace: "TestApp",
+                });
+                const moduleResult = buildIrModule(sourceFile, program, {
+                    sourceRoot: srcDir,
+                    rootNamespace: "TestApp",
+                }, ctx);
+                expect(moduleResult.ok).to.equal(true);
+                if (!moduleResult.ok)
+                    return;
+                const valueDecl = moduleResult.value.body.find((stmt) => stmt.kind === "variableDeclaration" &&
+                    stmt.declarations[0]?.name.kind === "identifierPattern" &&
+                    stmt.declarations[0]?.name.name === "value");
+                expect(valueDecl).to.not.equal(undefined);
+                if (!valueDecl)
+                    return;
+                const declaredType = valueDecl.declarations[0]?.type;
+                expect(declaredType?.kind).to.equal("unionType");
+                if (!declaredType || declaredType.kind !== "unionType")
+                    return;
+                const okType = declaredType.types.find((type) => type.kind === "referenceType");
+                expect(okType).to.not.equal(undefined);
+                if (!okType || okType.kind !== "referenceType")
+                    return;
+                expect(okType.name).to.equal("Acme.Core.Ok__Alias_1");
+                expect(okType.resolvedClrType).to.equal("Acme.Core.Ok__Alias`1");
+            }
+            finally {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            }
+        });
         it("narrows typeof checks in js-surface branches to the matching primitive type", () => {
             const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tsonic-builder-typeof-narrowing-"));
             try {
@@ -577,6 +796,70 @@ describe("IR Builder", () => {
             }
         });
     });
+    describe("Core intrinsic provenance", () => {
+        const expectVariableInitializerKind = (source, variableName, expectedKind) => {
+            const { testProgram, ctx, options } = createTestProgram(source);
+            const sourceFile = testProgram.sourceFiles[0];
+            if (!sourceFile)
+                throw new Error("Failed to create source file");
+            const result = buildIrModule(sourceFile, testProgram, options, ctx);
+            expect(result.ok).to.equal(true);
+            if (!result.ok)
+                return;
+            const variableStmt = result.value.body.find((stmt) => stmt.kind === "variableDeclaration" &&
+                stmt.declarations.some((decl) => decl.name.kind === "identifierPattern" &&
+                    decl.name.name === variableName));
+            expect(variableStmt).to.not.equal(undefined);
+            if (!variableStmt)
+                return;
+            const declaration = variableStmt.declarations.find((decl) => decl.name.kind === "identifierPattern" && decl.name.name === variableName);
+            expect(declaration?.initializer?.kind).to.equal(expectedKind);
+        };
+        it("does not lower locally declared nameof as the compiler intrinsic", () => {
+            expectVariableInitializerKind(`
+          function nameof(value: string): string {
+            return value + "!";
+          }
+
+          export const label = nameof("x");
+        `, "label", "call");
+        });
+        it("does not lower locally declared sizeof as the compiler intrinsic", () => {
+            expectVariableInitializerKind(`
+          function sizeof<T>(): number {
+            return 4;
+          }
+
+          export const bytes = sizeof<number>();
+        `, "bytes", "call");
+        });
+        it("does not lower locally declared defaultof/trycast/stackalloc/asinterface intrinsics", () => {
+            const source = `
+        function defaultof<T>(): T | undefined {
+          return undefined;
+        }
+        function trycast<T>(value: unknown): T | undefined {
+          return value as T | undefined;
+        }
+        function stackalloc<T>(size: number): T {
+          throw new Error(String(size));
+        }
+        function asinterface<T>(value: unknown): T {
+          return value as T;
+        }
+
+        interface Box { value: number; }
+
+        export const fallback = defaultof<number>();
+        export const maybe = trycast<Box>({ value: 1 });
+        export const mem = stackalloc<number>(16);
+        export const view = asinterface<Box>({ value: 1 });
+      `;
+            for (const variableName of ["fallback", "maybe", "mem", "view"]) {
+                expectVariableInitializerKind(source, variableName, "call");
+            }
+        });
+    });
     describe("Import Extraction", () => {
         it("should extract local imports", () => {
             const source = `
@@ -659,6 +942,57 @@ describe("IR Builder", () => {
                 memberName: "buildSite",
             });
         });
+        it("should attach resolvedClrType for CLR type imports used as values", () => {
+            const source = `
+        import { Task as TaskValue } from "@tsonic/dotnet/System.Threading.Tasks.js";
+      `;
+            const { testProgram, ctx, options } = createTestProgram(source);
+            ctx.clrResolver = {
+                resolve: (s) => s === "@tsonic/dotnet/System.Threading.Tasks.js"
+                    ? {
+                        isClr: true,
+                        packageName: "@tsonic/dotnet",
+                        resolvedNamespace: "System.Threading.Tasks",
+                        bindingsPath: "/x/tasks.bindings.json",
+                        assembly: "System.Runtime",
+                    }
+                    : { isClr: false },
+            };
+            ctx.bindings.addBindings("/x/tasks.bindings.json", {
+                namespace: "System.Threading.Tasks",
+                types: [
+                    {
+                        alias: "Task",
+                        clrName: "System.Threading.Tasks.Task",
+                        assemblyName: "System.Runtime",
+                        kind: "Class",
+                        methods: [],
+                        properties: [],
+                        fields: [],
+                    },
+                ],
+                exports: {},
+            });
+            const sourceFile = testProgram.sourceFiles[0];
+            if (!sourceFile)
+                throw new Error("Failed to create source file");
+            const result = buildIrModule(sourceFile, testProgram, options, ctx);
+            expect(result.ok).to.equal(true);
+            if (!result.ok)
+                return;
+            const imp = result.value.imports[0];
+            if (!imp)
+                throw new Error("Missing imports");
+            const spec = imp.specifiers[0];
+            if (!spec || spec.kind !== "named") {
+                throw new Error("Missing named specifier");
+            }
+            expect(spec.name).to.equal("Task");
+            expect(spec.localName).to.equal("TaskValue");
+            expect(spec.isType).to.not.equal(true);
+            expect(spec.resolvedClrType).to.equal("System.Threading.Tasks.Task");
+            expect(spec.resolvedClrValue).to.equal(undefined);
+        });
         it("should error if a CLR namespace value import lacks tsbindgen exports mapping", () => {
             const source = `
         import { buildSite } from "@demo/pkg/Demo.js";
@@ -1198,14 +1532,16 @@ describe("IR Builder", () => {
             const doubledAccessor = initializer.behaviorMembers?.find((member) => member.kind === "propertyDeclaration" && member.name === "doubled");
             expect(doubledAccessor).to.not.equal(undefined);
         });
-        it("normalizes computed const-literal numeric keys during synthesis", () => {
+        it("infers unannotated object literal getter types from deterministic bodies", () => {
             const source = `
         export function run(): number {
-          const slot = 1;
           const obj = {
-            [slot]: 7,
+            value: 21,
+            get doubled() {
+              return this.value * 2;
+            },
           };
-          return obj["1"];
+          return obj.doubled;
         }
       `;
             const { testProgram, ctx, options } = createTestProgram(source);
@@ -1224,36 +1560,36 @@ describe("IR Builder", () => {
             const decl = run.body.statements.find((stmt) => stmt.kind === "variableDeclaration" &&
                 stmt.declarations.some((declaration) => declaration.name.kind === "identifierPattern" &&
                     declaration.name.name === "obj" &&
-                    declaration.initializer !== undefined));
+                    declaration.initializer?.kind === "object"));
             const initializer = decl?.declarations.find((declaration) => declaration.name.kind === "identifierPattern" &&
                 declaration.name.name === "obj")?.initializer;
             expect(initializer?.kind).to.equal("object");
             if (!initializer || initializer.kind !== "object")
                 return;
-            const slotProp = initializer.properties.find((prop) => prop.kind === "property" && prop.key === "1");
-            expect(slotProp).to.not.equal(undefined);
+            const objectType = initializer.inferredType;
+            expect(objectType?.kind).to.equal("objectType");
+            if (!objectType || objectType.kind !== "objectType")
+                return;
+            const doubledMember = objectType.members.find((member) => member.kind === "propertySignature" && member.name === "doubled");
+            expect(doubledMember?.kind).to.equal("propertySignature");
+            if (!doubledMember || doubledMember.kind !== "propertySignature")
+                return;
+            expect(doubledMember.type.kind).to.equal("primitiveType");
+            if (doubledMember.type.kind !== "primitiveType")
+                return;
+            expect(doubledMember.type.name).to.equal("number");
         });
-        it("threads expected return generic context into call argument typing", () => {
+        it("infers unannotated object literal method return types from deterministic bodies", () => {
             const source = `
-        type Ok<T> = { success: true; data: T };
-        type Err<E> = { success: false; error: E };
-        type Result<T, E> = Ok<T> | Err<E>;
-
-        function ok<T>(data: T): Ok<T> {
-          return { success: true, data };
-        }
-
-        interface Payload {
-          foundAnchor: boolean;
-          foundNewest: boolean;
-          foundOldest: boolean;
-        }
-
-        export function run(anchor: string): Result<Payload, string> {
-          const foundAnchor = anchor !== "newest" && anchor !== "oldest";
-          const foundNewest = anchor === "newest";
-          const foundOldest = anchor === "oldest";
-          return ok({ foundAnchor, foundNewest, foundOldest });
+        export function run(): number {
+          const obj = {
+            value: 21,
+            inc() {
+              this.value += 1;
+              return this.value;
+            },
+          };
+          return obj.inc();
         }
       `;
             const { testProgram, ctx, options } = createTestProgram(source);
@@ -1262,45 +1598,205 @@ describe("IR Builder", () => {
                 throw new Error("Failed to create source file");
             const result = buildIrModule(sourceFile, testProgram, options, ctx);
             expect(result.ok).to.equal(true);
+            expect(ctx.diagnostics.some((d) => d.code === "TSN7403")).to.equal(false);
             if (!result.ok)
                 return;
             const run = result.value.body.find((stmt) => stmt.kind === "functionDeclaration" && stmt.name === "run");
             expect(run).to.not.equal(undefined);
             if (!run)
                 return;
-            const retStmt = run.body.statements.find((stmt) => stmt.kind === "returnStatement");
-            expect(retStmt?.expression?.kind).to.equal("call");
-            if (!retStmt?.expression || retStmt.expression.kind !== "call")
+            const decl = run.body.statements.find((stmt) => stmt.kind === "variableDeclaration" &&
+                stmt.declarations.some((declaration) => declaration.name.kind === "identifierPattern" &&
+                    declaration.name.name === "obj" &&
+                    declaration.initializer?.kind === "object"));
+            const initializer = decl?.declarations.find((declaration) => declaration.name.kind === "identifierPattern" &&
+                declaration.name.name === "obj")?.initializer;
+            expect(initializer?.kind).to.equal("object");
+            if (!initializer || initializer.kind !== "object")
                 return;
-            const arg0 = retStmt.expression.arguments[0];
-            expect(arg0?.kind).to.equal("object");
-            if (!arg0 || arg0.kind !== "object")
+            const objectType = initializer.inferredType;
+            expect(objectType?.kind).to.equal("objectType");
+            if (!objectType || objectType.kind !== "objectType")
                 return;
-            expect(arg0.inferredType?.kind).to.equal("referenceType");
-            if (arg0.inferredType?.kind === "referenceType") {
-                expect(arg0.inferredType.name).to.equal("Payload");
-            }
+            const incMember = objectType.members.find((member) => member.kind === "propertySignature" && member.name === "inc");
+            expect(incMember?.kind).to.equal("propertySignature");
+            if (!incMember || incMember.kind !== "propertySignature")
+                return;
+            expect(incMember.type.kind).to.equal("functionType");
+            if (incMember.type.kind !== "functionType")
+                return;
+            expect(incMember.type.returnType.kind).to.not.equal("voidType");
+            expect(incMember.type.returnType.kind).to.not.equal("unknownType");
+            expect(incMember.type.returnType.kind).to.not.equal("anyType");
+            const returnStmt = run.body.statements.find((stmt) => stmt.kind === "returnStatement");
+            expect(returnStmt).to.not.equal(undefined);
+            if (!returnStmt ||
+                returnStmt.kind !== "returnStatement" ||
+                !returnStmt.expression)
+                return;
+            expect(returnStmt.expression.kind).to.equal("call");
+            if (returnStmt.expression.kind !== "call")
+                return;
+            expect(returnStmt.expression.inferredType?.kind).to.not.equal("voidType");
+            expect(returnStmt.expression.inferredType?.kind).to.not.equal("unknownType");
+            expect(returnStmt.expression.inferredType?.kind).to.not.equal("anyType");
         });
-        it("threads expected return generic context through async Promise wrappers", () => {
+        it("synthesizes exact numeric properties after nullish fallback narrowing", () => {
             const source = `
-        type Ok<T> = { success: true; data: T };
-        type Err<E> = { success: false; error: E };
-        type Result<T, E> = Ok<T> | Err<E>;
+        import type { int } from "@tsonic/core/types.js";
 
-        function ok<T>(data: T): Ok<T> {
-          return { success: true, data };
-        }
+        declare function parseRole(raw: string): int | undefined;
 
-        interface Payload {
-          foundAnchor: boolean;
-          foundNewest: boolean;
-          foundOldest: boolean;
+        export function run(raw: string): int {
+          const parsedInviteAsRole = parseRole(raw);
+          const inviteAsRole = parsedInviteAsRole ?? (400 as int);
+          const input = {
+            inviteAsRole,
+          };
+          return input.inviteAsRole;
         }
-
-        export async function run(anchor: string): Promise<Result<Payload, string>> {
-          const foundAnchor = anchor !== "newest" && anchor !== "oldest";
-          const foundNewest = anchor === "newest";
-          const foundOldest = anchor === "oldest";
+      `;
+            const { testProgram, ctx, options } = createTestProgram(source);
+            const sourceFile = testProgram.sourceFiles[0];
+            if (!sourceFile)
+                throw new Error("Failed to create source file");
+            const result = buildIrModule(sourceFile, testProgram, options, ctx);
+            expect(result.ok).to.equal(true);
+            expect(ctx.diagnostics.some((diagnostic) => diagnostic.code === "TSN5203" &&
+                diagnostic.message.includes("inviteAsRole"))).to.equal(false);
+            if (!result.ok)
+                return;
+            const run = result.value.body.find((stmt) => stmt.kind === "functionDeclaration" && stmt.name === "run");
+            expect(run).to.not.equal(undefined);
+            if (!run)
+                return;
+            const decl = run.body.statements.find((stmt) => stmt.kind === "variableDeclaration" &&
+                stmt.declarations.some((declaration) => declaration.name.kind === "identifierPattern" &&
+                    declaration.name.name === "input" &&
+                    declaration.initializer?.kind === "object"));
+            const initializer = decl?.declarations.find((declaration) => declaration.name.kind === "identifierPattern" &&
+                declaration.name.name === "input")?.initializer;
+            expect(initializer?.kind).to.equal("object");
+            if (!initializer || initializer.kind !== "object")
+                return;
+            const objectType = initializer.inferredType;
+            expect(objectType?.kind).to.equal("objectType");
+            if (!objectType || objectType.kind !== "objectType")
+                return;
+            const inviteAsRoleMember = objectType.members.find((member) => member.kind === "propertySignature" &&
+                member.name === "inviteAsRole");
+            expect(inviteAsRoleMember?.kind).to.equal("propertySignature");
+            if (!inviteAsRoleMember ||
+                inviteAsRoleMember.kind !== "propertySignature")
+                return;
+            expect(inviteAsRoleMember.type.kind).to.equal("primitiveType");
+            if (inviteAsRoleMember.type.kind !== "primitiveType")
+                return;
+            expect(inviteAsRoleMember.type.name).to.equal("int");
+        });
+        it("normalizes computed const-literal numeric keys during synthesis", () => {
+            const source = `
+        export function run(): number {
+          const slot = 1;
+          const obj = {
+            [slot]: 7,
+          };
+          return obj["1"];
+        }
+      `;
+            const { testProgram, ctx, options } = createTestProgram(source);
+            const sourceFile = testProgram.sourceFiles[0];
+            if (!sourceFile)
+                throw new Error("Failed to create source file");
+            const result = buildIrModule(sourceFile, testProgram, options, ctx);
+            expect(result.ok).to.equal(true);
+            expect(ctx.diagnostics.some((d) => d.code === "TSN7403")).to.equal(false);
+            if (!result.ok)
+                return;
+            const run = result.value.body.find((stmt) => stmt.kind === "functionDeclaration" && stmt.name === "run");
+            expect(run).to.not.equal(undefined);
+            if (!run)
+                return;
+            const decl = run.body.statements.find((stmt) => stmt.kind === "variableDeclaration" &&
+                stmt.declarations.some((declaration) => declaration.name.kind === "identifierPattern" &&
+                    declaration.name.name === "obj" &&
+                    declaration.initializer !== undefined));
+            const initializer = decl?.declarations.find((declaration) => declaration.name.kind === "identifierPattern" &&
+                declaration.name.name === "obj")?.initializer;
+            expect(initializer?.kind).to.equal("object");
+            if (!initializer || initializer.kind !== "object")
+                return;
+            const slotProp = initializer.properties.find((prop) => prop.kind === "property" && prop.key === "1");
+            expect(slotProp).to.not.equal(undefined);
+        });
+        it("threads expected return generic context into call argument typing", () => {
+            const source = `
+        type Ok<T> = { success: true; data: T };
+        type Err<E> = { success: false; error: E };
+        type Result<T, E> = Ok<T> | Err<E>;
+
+        function ok<T>(data: T): Ok<T> {
+          return { success: true, data };
+        }
+
+        interface Payload {
+          foundAnchor: boolean;
+          foundNewest: boolean;
+          foundOldest: boolean;
+        }
+
+        export function run(anchor: string): Result<Payload, string> {
+          const foundAnchor = anchor !== "newest" && anchor !== "oldest";
+          const foundNewest = anchor === "newest";
+          const foundOldest = anchor === "oldest";
+          return ok({ foundAnchor, foundNewest, foundOldest });
+        }
+      `;
+            const { testProgram, ctx, options } = createTestProgram(source);
+            const sourceFile = testProgram.sourceFiles[0];
+            if (!sourceFile)
+                throw new Error("Failed to create source file");
+            const result = buildIrModule(sourceFile, testProgram, options, ctx);
+            expect(result.ok).to.equal(true);
+            if (!result.ok)
+                return;
+            const run = result.value.body.find((stmt) => stmt.kind === "functionDeclaration" && stmt.name === "run");
+            expect(run).to.not.equal(undefined);
+            if (!run)
+                return;
+            const retStmt = run.body.statements.find((stmt) => stmt.kind === "returnStatement");
+            expect(retStmt?.expression?.kind).to.equal("call");
+            if (!retStmt?.expression || retStmt.expression.kind !== "call")
+                return;
+            const arg0 = retStmt.expression.arguments[0];
+            expect(arg0?.kind).to.equal("object");
+            if (!arg0 || arg0.kind !== "object")
+                return;
+            expect(arg0.inferredType?.kind).to.equal("referenceType");
+            if (arg0.inferredType?.kind === "referenceType") {
+                expect(arg0.inferredType.name).to.equal("Payload");
+            }
+        });
+        it("threads expected return generic context through async Promise wrappers", () => {
+            const source = `
+        type Ok<T> = { success: true; data: T };
+        type Err<E> = { success: false; error: E };
+        type Result<T, E> = Ok<T> | Err<E>;
+
+        function ok<T>(data: T): Ok<T> {
+          return { success: true, data };
+        }
+
+        interface Payload {
+          foundAnchor: boolean;
+          foundNewest: boolean;
+          foundOldest: boolean;
+        }
+
+        export async function run(anchor: string): Promise<Result<Payload, string>> {
+          const foundAnchor = anchor !== "newest" && anchor !== "oldest";
+          const foundNewest = anchor === "newest";
+          const foundOldest = anchor === "oldest";
           return ok({ foundAnchor, foundNewest, foundOldest });
         }
       `;
@@ -1329,6 +1825,132 @@ describe("IR Builder", () => {
                 expect(arg0.inferredType.name).to.equal("Payload");
             }
         });
+        it("threads expected return generic context through imported declaration aliases", () => {
+            const testFiles = {
+                "package.json": JSON.stringify({ name: "app", version: "1.0.0", type: "module" }, null, 2),
+                "src/index.ts": `
+          import type { Result } from "./core.js";
+          import { ok } from "./core.js";
+
+          interface Payload {
+            foundAnchor: boolean;
+            foundNewest: boolean;
+            foundOldest: boolean;
+          }
+
+          export function run(anchor: string): Result<Payload, string> {
+            const foundAnchor = anchor !== "newest" && anchor !== "oldest";
+            const foundNewest = anchor === "newest";
+            const foundOldest = anchor === "oldest";
+            return ok({ foundAnchor, foundNewest, foundOldest });
+          }
+        `,
+                "src/core.d.ts": `
+          export interface Ok<T> {
+            readonly success: true;
+            readonly data: T;
+          }
+
+          export interface Err<E> {
+            readonly success: false;
+            readonly error: E;
+          }
+
+          export type Result<T, E> = Ok<T> | Err<E>;
+
+          export declare function ok<T>(data: T): Ok<T>;
+        `,
+            };
+            const { sourceFile, testProgram, ctx, options, cleanup } = createFilesystemTestProgram(testFiles, "src/index.ts");
+            try {
+                const result = buildIrModule(sourceFile, testProgram, options, ctx);
+                expect(result.ok).to.equal(true);
+                if (!result.ok)
+                    return;
+                const run = result.value.body.find((stmt) => stmt.kind === "functionDeclaration" && stmt.name === "run");
+                expect(run).to.not.equal(undefined);
+                if (!run)
+                    return;
+                const retStmt = run.body.statements.find((stmt) => stmt.kind === "returnStatement");
+                expect(retStmt?.expression?.kind).to.equal("call");
+                if (!retStmt?.expression || retStmt.expression.kind !== "call")
+                    return;
+                const arg0 = retStmt.expression.arguments[0];
+                expect(arg0?.kind).to.equal("object");
+                if (!arg0 || arg0.kind !== "object")
+                    return;
+                expect(arg0.inferredType?.kind).to.equal("referenceType");
+                if (arg0.inferredType?.kind === "referenceType") {
+                    expect(arg0.inferredType.name).to.equal("Payload");
+                }
+            }
+            finally {
+                cleanup();
+            }
+        });
+        it("threads expected return generic context through imported declaration aliases inside Promise wrappers", () => {
+            const testFiles = {
+                "package.json": JSON.stringify({ name: "app", version: "1.0.0", type: "module" }, null, 2),
+                "src/index.ts": `
+          import type { Result } from "./core.js";
+          import { ok } from "./core.js";
+
+          interface Payload {
+            foundAnchor: boolean;
+            foundNewest: boolean;
+            foundOldest: boolean;
+          }
+
+          export async function run(anchor: string): Promise<Result<Payload, string>> {
+            const foundAnchor = anchor !== "newest" && anchor !== "oldest";
+            const foundNewest = anchor === "newest";
+            const foundOldest = anchor === "oldest";
+            return ok({ foundAnchor, foundNewest, foundOldest });
+          }
+        `,
+                "src/core.d.ts": `
+          export interface Ok<T> {
+            readonly success: true;
+            readonly data: T;
+          }
+
+          export interface Err<E> {
+            readonly success: false;
+            readonly error: E;
+          }
+
+          export type Result<T, E> = Ok<T> | Err<E>;
+
+          export declare function ok<T>(data: T): Ok<T>;
+        `,
+            };
+            const { sourceFile, testProgram, ctx, options, cleanup } = createFilesystemTestProgram(testFiles, "src/index.ts");
+            try {
+                const result = buildIrModule(sourceFile, testProgram, options, ctx);
+                expect(result.ok).to.equal(true);
+                if (!result.ok)
+                    return;
+                const run = result.value.body.find((stmt) => stmt.kind === "functionDeclaration" && stmt.name === "run");
+                expect(run).to.not.equal(undefined);
+                if (!run)
+                    return;
+                const retStmt = run.body.statements.find((stmt) => stmt.kind === "returnStatement");
+                expect(retStmt?.expression?.kind).to.equal("call");
+                if (!retStmt?.expression || retStmt.expression.kind !== "call")
+                    return;
+                const arg0 = retStmt.expression.arguments[0];
+                expect(arg0?.kind).to.equal("object");
+                if (!arg0 || arg0.kind !== "object")
+                    return;
+                expect(arg0.inferredType?.kind).to.equal("referenceType");
+                if (arg0.inferredType?.kind === "referenceType") {
+                    expect(arg0.inferredType.name).to.equal("Payload");
+                }
+            }
+            finally {
+                cleanup();
+            }
+        });
         it("does not leak type-alias cache entries across program contexts", () => {
             const sourceA = `
         export type UserId = string;
@@ -1691,12 +2313,102 @@ describe("IR Builder", () => {
                     return;
                 expect(property.key).to.equal("value");
                 expect(property.value.kind).to.equal("memberAccess");
+                expect(property.value.inferredType?.kind).to.not.equal("voidType");
+                expect(property.value.inferredType?.kind).to.not.equal("unknownType");
+                expect(property.value.inferredType?.kind).to.not.equal("anyType");
                 expect(call.inferredType?.kind).to.equal("referenceType");
             }
             finally {
                 fs.rmSync(tempDir, { recursive: true, force: true });
             }
         });
+        it("should preserve callable exports as function-valued namespace members", () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tsonic-builder-dynamic-import-fn-"));
+            try {
+                fs.writeFileSync(path.join(tempDir, "package.json"), JSON.stringify({ name: "app", version: "1.0.0", type: "module" }, null, 2));
+                const srcDir = path.join(tempDir, "src");
+                fs.mkdirSync(srcDir, { recursive: true });
+                const entryPath = path.join(srcDir, "index.ts");
+                fs.writeFileSync(entryPath, [
+                    "export async function load() {",
+                    '  const module = await import("./module.js");',
+                    "  return module.value;",
+                    "}",
+                ].join("\n"));
+                fs.writeFileSync(path.join(srcDir, "module.ts"), "export function value(): number { return 42; }\n");
+                const tsProgram = ts.createProgram([entryPath, path.join(srcDir, "module.ts")], {
+                    target: ts.ScriptTarget.ES2022,
+                    module: ts.ModuleKind.NodeNext,
+                    moduleResolution: ts.ModuleResolutionKind.NodeNext,
+                    strict: true,
+                    noEmit: true,
+                    skipLibCheck: true,
+                });
+                const checker = tsProgram.getTypeChecker();
+                const sourceFile = tsProgram.getSourceFile(entryPath);
+                expect(sourceFile).to.not.equal(undefined);
+                if (!sourceFile)
+                    return;
+                const program = {
+                    program: tsProgram,
+                    checker,
+                    options: {
+                        projectRoot: tempDir,
+                        sourceRoot: srcDir,
+                        rootNamespace: "TestApp",
+                        strict: true,
+                    },
+                    sourceFiles: [
+                        sourceFile,
+                        tsProgram.getSourceFile(path.join(srcDir, "module.ts")),
+                    ],
+                    declarationSourceFiles: [],
+                    metadata: new DotnetMetadataRegistry(),
+                    bindings: new BindingRegistry(),
+                    clrResolver: createClrBindingsResolver(tempDir),
+                    binding: createBinding(checker),
+                };
+                const options = { sourceRoot: srcDir, rootNamespace: "TestApp" };
+                const ctx = createProgramContext(program, options);
+                const moduleResult = buildIrModule(sourceFile, program, options, ctx);
+                expect(moduleResult.ok).to.equal(true);
+                if (!moduleResult.ok)
+                    return;
+                const loadFn = moduleResult.value.body.find((stmt) => stmt.kind === "functionDeclaration" && stmt.name === "load");
+                expect(loadFn).to.not.equal(undefined);
+                if (!loadFn)
+                    return;
+                const declStmt = loadFn.body.statements[0];
+                expect(declStmt?.kind).to.equal("variableDeclaration");
+                if (!declStmt || declStmt.kind !== "variableDeclaration")
+                    return;
+                const initializer = declStmt.declarations[0]?.initializer;
+                expect(initializer?.kind).to.equal("await");
+                if (!initializer || initializer.kind !== "await")
+                    return;
+                const call = initializer.expression;
+                expect(call.kind).to.equal("call");
+                if (call.kind !== "call" || !call.dynamicImportNamespace)
+                    return;
+                const property = call.dynamicImportNamespace.properties[0];
+                expect(property?.kind).to.equal("property");
+                if (!property || property.kind !== "property")
+                    return;
+                expect(property.value.inferredType?.kind).to.equal("functionType");
+                const namespaceType = call.dynamicImportNamespace.inferredType;
+                expect(namespaceType?.kind).to.equal("objectType");
+                if (!namespaceType || namespaceType.kind !== "objectType")
+                    return;
+                const valueMember = namespaceType.members.find((member) => member.kind === "propertySignature" && member.name === "value");
+                expect(valueMember?.kind).to.equal("propertySignature");
+                if (!valueMember || valueMember.kind !== "propertySignature")
+                    return;
+                expect(valueMember.type.kind).to.equal("functionType");
+            }
+            finally {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            }
+        });
         it("should represent empty closed-world dynamic import namespaces as Promise<object>", () => {
             const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "tsonic-builder-dynamic-import-empty-"));
             try {
@@ -2031,6 +2743,251 @@ describe("IR Builder", () => {
                 elementType: { kind: "unknownType" },
             });
         });
+        it("allows arbitrary property access on Record<string, unknown> without unknown poison", () => {
+            const source = `
+        export function fill(): Record<string, unknown> {
+          const state: Record<string, unknown> = {};
+          state.zulip_version = "1.0";
+          state.realm_users = [];
+          return state;
+        }
+      `;
+            const { testProgram, ctx, options } = createTestProgram(source);
+            const sourceFile = testProgram.sourceFiles[0];
+            if (!sourceFile)
+                throw new Error("Failed to create source file");
+            const result = buildIrModule(sourceFile, testProgram, options, ctx);
+            expect(result.ok).to.equal(true);
+            expect(ctx.diagnostics.some((d) => d.code === "TSN5203")).to.equal(false);
+        });
+        it("allows declared unknown members on structural callback parameters", () => {
+            const source = `
+        export function project(
+          rawUpdates: { stream_id: string; property: string; value: unknown }[]
+        ): string[] {
+          return rawUpdates.map((update) => String(update.value ?? ""));
+        }
+      `;
+            const { testProgram, ctx, options } = createTestProgram(source);
+            const sourceFile = testProgram.sourceFiles[0];
+            if (!sourceFile)
+                throw new Error("Failed to create source file");
+            const result = buildIrModule(sourceFile, testProgram, options, ctx);
+            expect(result.ok).to.equal(true);
+            expect(ctx.diagnostics.some((d) => d.code === "TSN5203")).to.equal(false);
+        });
+        it("supports indexed access on generic discriminated-union payloads after narrowing", () => {
+            const source = `
+        type Ok<T> = { success: true; data: T };
+        type Err<E> = { success: false; error: E };
+        type Result<T, E> = Ok<T> | Err<E>;
+
+        declare function listTenants(): Result<{ Id: string }[], string>;
+
+        export function run(): string {
+          const result = listTenants();
+          if (!result.success) {
+            return result.error;
+          }
+
+          const data = result.data;
+          return data[0]!.Id;
+        }
+      `;
+            const { testProgram, ctx, options } = createTestProgram(source);
+            const sourceFile = testProgram.sourceFiles[0];
+            if (!sourceFile)
+                throw new Error("Failed to create source file");
+            const result = buildIrModule(sourceFile, testProgram, options, ctx);
+            expect(result.ok).to.equal(true);
+            expect(ctx.diagnostics.some((d) => d.code === "TSN5203")).to.equal(false);
+            expect(ctx.diagnostics.some((d) => d.code === "TSN5107")).to.equal(false);
+            if (!result.ok)
+                return;
+            const run = result.value.body.find((stmt) => stmt.kind === "functionDeclaration" && stmt.name === "run");
+            expect(run).to.not.equal(undefined);
+            if (!run)
+                return;
+            const dataDecl = run.body.statements.find((stmt) => stmt.kind === "variableDeclaration" &&
+                stmt.declarations.some((declaration) => declaration.name.kind === "identifierPattern" &&
+                    declaration.name.name === "data"));
+            expect(dataDecl).to.not.equal(undefined);
+            const dataInit = dataDecl?.declarations[0]?.initializer;
+            expect(dataInit?.kind).to.equal("memberAccess");
+            if (!dataInit || dataInit.kind !== "memberAccess")
+                return;
+            expect(dataInit.inferredType?.kind).to.equal("arrayType");
+            if (!dataInit.inferredType || dataInit.inferredType.kind !== "arrayType") {
+                return;
+            }
+            expect(dataInit.inferredType.elementType.kind).to.equal("objectType");
+            if (dataInit.inferredType.elementType.kind !== "objectType")
+                return;
+            expect(dataInit.inferredType.elementType.members).to.have.length(1);
+            const idMember = dataInit.inferredType.elementType.members[0];
+            expect(idMember?.kind).to.equal("propertySignature");
+            if (!idMember || idMember.kind !== "propertySignature")
+                return;
+            expect(idMember.name).to.equal("Id");
+            expect(idMember.type).to.deep.equal({
+                kind: "primitiveType",
+                name: "string",
+            });
+            expect(idMember.isOptional).to.equal(false);
+            expect(idMember.isReadonly).to.equal(false);
+        });
+        it("treats string-literal element access on narrowed unions like property access", () => {
+            const source = `
+        type Err = { error: string; code?: string };
+        type Ok = { events: string[] };
+
+        declare function getEvents(): Err | Ok;
+
+        export function run(): string {
+          const result = getEvents();
+          if ("error" in result) {
+            return result["code"] ?? result["error"];
+          }
+          return result["events"][0] ?? "";
+        }
+      `;
+            const { testProgram, ctx, options } = createTestProgram(source);
+            const sourceFile = testProgram.sourceFiles[0];
+            if (!sourceFile)
+                throw new Error("Failed to create source file");
+            const result = buildIrModule(sourceFile, testProgram, options, ctx);
+            expect(result.ok).to.equal(true);
+            expect(ctx.diagnostics.some((d) => d.code === "TSN5203")).to.equal(false);
+            expect(ctx.diagnostics.some((d) => d.code === "TSN5107")).to.equal(false);
+            if (!result.ok)
+                return;
+            const run = result.value.body.find((stmt) => stmt.kind === "functionDeclaration" && stmt.name === "run");
+            expect(run).to.not.equal(undefined);
+            if (!run)
+                return;
+            const ifStmt = run.body.statements.find((stmt) => stmt.kind === "ifStatement");
+            expect(ifStmt).to.not.equal(undefined);
+            if (!ifStmt || ifStmt.kind !== "ifStatement")
+                return;
+            const thenReturn = ifStmt.thenStatement.kind === "blockStatement"
+                ? ifStmt.thenStatement.statements.find((stmt) => stmt.kind === "returnStatement")
+                : undefined;
+            expect(thenReturn).to.not.equal(undefined);
+            if (!thenReturn ||
+                thenReturn.kind !== "returnStatement" ||
+                !thenReturn.expression ||
+                thenReturn.expression.kind !== "logical") {
+                return;
+            }
+            const codeAccess = thenReturn.expression.left;
+            expect(codeAccess.kind).to.equal("memberAccess");
+            if (codeAccess.kind !== "memberAccess")
+                return;
+            expect(codeAccess.accessKind).to.not.equal("unknown");
+            expect(codeAccess.inferredType).to.deep.equal({
+                kind: "unionType",
+                types: [
+                    { kind: "primitiveType", name: "string" },
+                    { kind: "primitiveType", name: "undefined" },
+                ],
+            });
+            const finalReturn = [...run.body.statements]
+                .reverse()
+                .find((stmt) => stmt.kind === "returnStatement");
+            expect(finalReturn).to.not.equal(undefined);
+            if (!finalReturn ||
+                !finalReturn.expression ||
+                finalReturn.expression.kind !== "logical" ||
+                finalReturn.expression.left.kind !== "memberAccess") {
+                return;
+            }
+            const eventsIndex = finalReturn.expression.left;
+            expect(eventsIndex.accessKind).to.equal("clrIndexer");
+            expect(eventsIndex.inferredType).to.deep.equal({
+                kind: "primitiveType",
+                name: "string",
+            });
+        });
+        it("keeps string-literal element access computed for alias-wrapped string dictionaries", () => {
+            const source = `
+        interface SettingsMap {
+          [key: string]: string;
+        }
+
+        declare function load(): SettingsMap;
+
+        export function run(): string | undefined {
+          const settings = load();
+          return settings["waiting_period_threshold"];
+        }
+      `;
+            const { testProgram, ctx, options } = createTestProgram(source);
+            const sourceFile = testProgram.sourceFiles[0];
+            if (!sourceFile)
+                throw new Error("Failed to create source file");
+            const result = buildIrModule(sourceFile, testProgram, options, ctx);
+            expect(result.ok).to.equal(true);
+            expect(ctx.diagnostics.some((d) => d.code === "TSN5203")).to.equal(false);
+            expect(ctx.diagnostics.some((d) => d.code === "TSN5107")).to.equal(false);
+            if (!result.ok)
+                return;
+            const run = result.value.body.find((stmt) => stmt.kind === "functionDeclaration" && stmt.name === "run");
+            expect(run).to.not.equal(undefined);
+            if (!run)
+                return;
+            const returnStmt = run.body.statements.find((stmt) => stmt.kind === "returnStatement");
+            expect(returnStmt).to.not.equal(undefined);
+            if (!returnStmt?.expression)
+                return;
+            expect(returnStmt.expression.kind).to.equal("memberAccess");
+            if (returnStmt.expression.kind !== "memberAccess")
+                return;
+            expect(returnStmt.expression.isComputed).to.equal(true);
+            expect(returnStmt.expression.accessKind).to.equal("dictionary");
+        });
+        it("keeps string-literal element access computed after generic return narrowing", () => {
+            const source = `
+        type SettingsMap = { [key: string]: string };
+
+        declare const JsonSerializer: {
+          Deserialize<T>(json: string): T | undefined;
+        };
+
+        export function run(json: string): string | undefined {
+          const settingsOrNull = JsonSerializer.Deserialize<SettingsMap>(json);
+          if (settingsOrNull === undefined) {
+            return undefined;
+          }
+          const settings = settingsOrNull;
+          return settings["waiting_period_threshold"];
+        }
+      `;
+            const { testProgram, ctx, options } = createTestProgram(source);
+            const sourceFile = testProgram.sourceFiles[0];
+            if (!sourceFile)
+                throw new Error("Failed to create source file");
+            const result = buildIrModule(sourceFile, testProgram, options, ctx);
+            expect(result.ok).to.equal(true);
+            expect(ctx.diagnostics.some((d) => d.code === "TSN5203")).to.equal(false);
+            expect(ctx.diagnostics.some((d) => d.code === "TSN5107")).to.equal(false);
+            if (!result.ok)
+                return;
+            const run = result.value.body.find((stmt) => stmt.kind === "functionDeclaration" && stmt.name === "run");
+            expect(run).to.not.equal(undefined);
+            if (!run)
+                return;
+            const returnStmt = [...run.body.statements]
+                .reverse()
+                .find((stmt) => stmt.kind === "returnStatement");
+            expect(returnStmt).to.not.equal(undefined);
+            if (!returnStmt?.expression)
+                return;
+            expect(returnStmt.expression.kind).to.equal("memberAccess");
+            if (returnStmt.expression.kind !== "memberAccess")
+                return;
+            expect(returnStmt.expression.isComputed).to.equal(true);
+            expect(returnStmt.expression.accessKind).to.equal("dictionary");
+        });
         it("types inferred array Length access as int without unknown poison", () => {
             const source = `
         export function count(items: string[]): int {