@tsonic/emitter 0.0.76 → 0.0.77

package/dist/integration-cases/regression-coverage-c.test.js

@@ -85,26 +85,25 @@ describe("End-to-End Integration", () => {
             expect(csharp).to.match(/updatePresenceDomain\(new global::Fixture\.Presence\.domain\.UpdatePresenceParams\s*\{\s*status = input\.status,\s*client = input\.client,\s*pingOnly = input\.pingOnly,\s*slimPresence = input\.slimPresence,\s*historyLimitDays = input\.historyLimitDays,\s*lastUpdateId = input\.lastUpdateId\s*\}\)/);
             expect(csharp).not.to.include("(global::Fixture.Presence.domain.UpdatePresenceParams)(object)input");
         });
-        it("uses runtime equality for JsValue-vs-boolean strict comparisons", () => {
+        it("uses runtime equality for unknown-vs-boolean strict comparisons", () => {
             const source = `
-        export function hasSubdomain(body: Record<string, JsValue>): boolean {
-          return body.allow_subdomains === true;
+        export function hasSubdomain(body: Record<string, unknown>): boolean {
+          return body["allow_subdomains"] === true;
         }
       `;
             const csharp = compileToCSharp(source);
             expect(csharp).to.include('global::System.Object.Equals(body["allow_subdomains"], true)');
             expect(csharp).not.to.include('body["allow_subdomains"] == true');
         });
-        it("casts JsValue record member reads after typeof guards when assigning to nullable concrete slots", () => {
+        it("casts unknown record member reads after typeof guards when assigning to nullable concrete slots", () => {
             const source = `
-        import type { JsValue } from "@tsonic/core/types.js";
 
         type JwtPayload = {
           email?: string;
           exp?: number;
         };
 
-        export function read(payloadObject: Record<string, JsValue>): JwtPayload {
+        export function read(payloadObject: Record<string, unknown>): JwtPayload {
           let exp: number | undefined = undefined;
           if (typeof payloadObject.exp === "number") {
             exp = payloadObject.exp as number;
@@ -124,16 +123,15 @@ describe("End-to-End Integration", () => {
             const csharp = compileToCSharp(source, "/test/test.ts", {
                 surface: "@tsonic/js",
             });
-            expect(csharp).to.match(/exp\s*=\s*\(double\??\)/);
-            expect(csharp).to.match(/payload\.email\s*=\s*\(string\??\)/);
+            expect(csharp).to.match(/exp\s*=\s*\(\(\(global::System\.Func<object\?>\)[\s\S]*?\)\)\(\) switch \{ int __tsonic_number_int_/);
+            expect(csharp).to.match(/payload\.email\s*=\s*\(string\)\(\(global::System\.Func<object\?>\)[\s\S]*?\)\)\(\);/);
             expect(csharp).not.to.include('exp = payloadObject["exp"];');
             expect(csharp).not.to.include('payload.email = payloadObject["email"];');
         });
-        it("materializes broad JsValue Array.isArray narrows for length and index reads", () => {
+        it("rejects broad unknown Array.isArray narrowing before emission", () => {
             const source = `
-        import type { JsValue } from "@tsonic/core/types.js";
 
-        declare function parseJsonValueText(value: string): JsValue;
+        declare function parseJsonValueText(value: string): unknown;
 
         export function countObjects(value: string): number {
           const parsed = parseJsonValueText(value);
@@ -151,13 +149,9 @@ describe("End-to-End Integration", () => {
           return count;
         }
       `;
-            const csharp = compileToCSharp(source, "/test/test.ts", {
+            expect(() => compileToCSharp(source, "/test/test.ts", {
                 surface: "@tsonic/js",
-            });
-            expect(csharp).to.include("((global::System.Array)parsed).Length");
-            expect(csharp).to.include("((global::System.Array)parsed).GetValue(i)");
-            expect(csharp).not.to.include("((object)parsed).Length");
-            expect(csharp).not.to.include("((object)parsed)[i]");
+            })).to.throw(/Array\.isArray cannot narrow a broad runtime value/);
         });
         it("compares optional runtime-union member reads to literals without Match projections", () => {
             const source = `
@@ -177,7 +171,9 @@ describe("End-to-End Integration", () => {
           return "None";
         }
       `;
-            const csharp = compileToCSharp(source);
+            const csharp = compileToCSharp(source, "/test/test.ts", {
+                surface: "@tsonic/js",
+            });
             expect(csharp).to.include("options?.sameSite is global::Tsonic.Internal.Union<bool, string> __tsonic_union_compare_1");
             expect(csharp).to.include("__tsonic_union_compare_1.Is1()");
             expect(csharp).to.include("__tsonic_union_compare_1.As1() == true");
@@ -200,7 +196,9 @@ describe("End-to-End Integration", () => {
 
           return "other";
         }
-      `);
+      `, "/test/test.ts", {
+                surface: "@tsonic/js",
+            });
             expect(csharp).to.include("__tsonic_union_compare_1");
             expect(csharp).to.include("__tsonic_union_compare_2");
         });
@@ -230,7 +228,9 @@ describe("End-to-End Integration", () => {
             portOrOptionsOrPath.host
           );
         }
-      `);
+      `, "/test/test.ts", {
+                surface: "@tsonic/js",
+            });
             expect(csharp).to.include("portOrOptionsOrPath.Is2()");
             expect(csharp).to.include("portOrOptionsOrPath.Is1()");
             expect(csharp).to.include("return connectPort((portOrOptionsOrPath.As3()).port, (portOrOptionsOrPath.As3()).host);");
@@ -407,7 +407,7 @@ describe("End-to-End Integration", () => {
               );
             }
           `, "/test/test.ts", { surface: "@tsonic/nodejs" }));
-            expect(csharp).to.match(/resp\.end\(global::Tsonic\.Internal\.Union<[^>]+>\.From4\(text\)\);/);
+            expect(csharp).to.match(/resp\.end\(global::Tsonic\.Internal\.Union<[^>]+>\.From3\(text\)\);/);
             expect(csharp).to.include('normalizeHeaderValue(resp.getHeader("x-test") == null ? default(global::Tsonic.Internal.Union<string[], string>?) : global::Tsonic.Internal.Union<string[], string>.From2(resp.getHeader("x-test")));');
             expect(csharp).not.to.include("resp.end(text);");
             expect(csharp).not.to.include('normalizeHeaderValue(resp.getHeader("x-test"));');
@@ -453,13 +453,12 @@ describe("End-to-End Integration", () => {
         });
         it("passes boxed storage values through broad calls after typeof-number narrowing", () => {
             const csharp = compileToCSharp(`
-          import type { JsValue } from "@tsonic/core/types.js";
 
-          const toNumberArg = (value: JsValue): number => {
+          const toNumberArg = (value: unknown): number => {
             return Number(value);
           };
 
-          export function run(args: readonly JsValue[]): number {
+          export function run(args: readonly unknown[]): number {
             const arg0 = args.length > 0 ? args[0] : undefined;
             if (typeof arg0 === "number") {
               return toNumberArg(arg0);
@@ -468,16 +467,27 @@ describe("End-to-End Integration", () => {
             return 0;
           }
         `, "/test/test.ts", { surface: "@tsonic/js" });
-            expect(csharp).to.include('if (global::Tsonic.Runtime.Operators.@typeof(arg0) == "number")');
+            expect(csharp).to.include("if ((arg0 is double || arg0 is int))");
             expect(csharp).to.include("return toNumberArg(arg0);");
             expect(csharp).not.to.include("toNumberArg((object?)(double)arg0)");
         });
-        it("keeps broad JsValue typeof-object guards on the runtime typeof helper instead of union member checks", () => {
+        it("rejects typeof-number narrowing as proof for int storage", () => {
+            expect(() => compileToCSharp(`
+            import type { int } from "@tsonic/core/types.js";
+
+            export function readInt(value: unknown): int {
+              if (typeof value === "number") {
+                return value;
+              }
+              return 0;
+            }
+          `, "/test/test.ts", { surface: "@tsonic/js" })).to.throw("Implicit narrowing not allowed");
+        });
+        it("keeps broad unknown typeof-object guards on the runtime typeof helper instead of union member checks", () => {
             const csharp = compileToCSharp(`
-          import type { JsValue } from "@tsonic/core/types.js";
 
           export class Checker {
-            static isObject(value: JsValue | undefined): boolean {
+            static isObject(value: unknown | undefined): boolean {
               if (value === undefined || value === null) {
                 return false;
               }
@@ -490,7 +500,8 @@ describe("End-to-End Integration", () => {
             }
           }
         `, "/test/test.ts", { surface: "@tsonic/js" });
-            expect(csharp).to.include('if (global::Tsonic.Runtime.Operators.@typeof(value) != "object")');
+            expect(csharp).to.include("value != null");
+            expect(csharp).not.to.include("global::Tsonic.Runtime.Operators.@typeof");
             expect(csharp).not.to.include("if (!(((global::System.Object)(value)) != null && (value.Is1() || value.Is2())))");
         });
         it("calls exact external member overloads instead of wrapping object arguments into implementation unions", () => {
@@ -526,7 +537,7 @@ describe("End-to-End Integration", () => {
                     "  bind(options: BindOptions, callback?: () => void): void;",
                     "}",
                 ].join("\n"),
-            }, "src/index.ts");
+            }, "src/index.ts", { surface: "@tsonic/js" });
             expect(csharp).to.include("socket.bind(options);");
             expect(csharp).not.to.include("global::Tsonic.Internal.Union<global::System.Action, double, BindOptions>.From3(options)");
         });
@@ -824,7 +835,7 @@ describe("End-to-End Integration", () => {
         });
         it("preserves compiler-generated anonymous carriers over unrelated structural globals", () => {
             const csharp = compileToCSharp(`
-        declare function deepEqual(left: JsValue, right: JsValue): void;
+        declare function deepEqual(left: unknown, right: unknown): void;
 
         export function run(): void {
           const first = { user: { name: "Alice" } };
@@ -853,23 +864,22 @@ describe("End-to-End Integration", () => {
         });
         it("resolves emitted structural alias storage names during CLR member materialization", () => {
             const csharp = compileToCSharp(`
-        import type { JsValue } from "@tsonic/core/types.js";
         import { List } from "@tsonic/dotnet/System.Collections.Generic.js";
 
         type NarrowFilter = {
           op: string;
-          value: JsValue | undefined;
+          value: unknown | undefined;
           negated?: boolean;
         };
 
-        declare function getObjectField(value: JsValue, key: string): JsValue | undefined;
+        declare function getObjectField(value: unknown, key: string): unknown | undefined;
 
-        export function parse(entries: JsValue[]): NarrowFilter[] | undefined {
+        export function parse(entries: unknown[]): NarrowFilter[] | undefined {
           const filters = new List<NarrowFilter>();
           for (let i = 0; i < entries.length; i++) {
             const entry = entries[i]!;
             if (Array.isArray(entry)) {
-              const tuple = entry as JsValue[];
+              const tuple = entry as unknown[];
               const filter: NarrowFilter = {
                 op: tuple[0] as string,
                 value: tuple[1],
@@ -887,7 +897,9 @@ describe("End-to-End Integration", () => {
           }
           return filters.ToArray();
         }
-      `);
+      `, "/test/test.ts", {
+                surface: "@tsonic/js",
+            });
             expect(csharp).to.include("class NarrowFilter__Alias");
             expect(csharp).to.include("new global::System.Collections.Generic.List<NarrowFilter__Alias>()");
             expect(csharp).to.include("filters.Add(filter);");
@@ -916,7 +928,7 @@ describe("End-to-End Integration", () => {
         }
       `);
             expect(csharp).to.include("class MkdirOptions__Alias");
-            expect(csharp).to.include("((global::System.Object)(options)) != null");
+            expect(csharp).to.include("((global::System.Object)(options)) == null");
             expect(csharp).to.include("options.Is1()");
             expect(csharp).not.to.include("ICE: Anonymous object type reached emitter");
         });
@@ -924,7 +936,7 @@ describe("End-to-End Integration", () => {
             const csharp = compileToCSharp(`
         import { FileNotFoundException } from "@tsonic/dotnet/System.IO.js";
 
-        export function isMissing(error: JsValue): boolean {
+        export function isMissing(error: unknown): boolean {
           return error instanceof FileNotFoundException;
         }
       `);
@@ -963,6 +975,87 @@ describe("End-to-End Integration", () => {
             expect(csharp).not.to.include("readValue_flag");
             expect(csharp).not.to.include("readValue_encoding");
         });
+        it("preserves override on methods generated from overload family bodies", () => {
+            const source = `
+        import { overloads as O } from "@tsonic/core/lang.js";
+        import type { int } from "@tsonic/core/types.js";
+
+        export class DbContext {
+          SaveChanges(): int {
+            return 0 as int;
+          }
+        }
+
+        export class WorkspaceDbContext extends DbContext {
+          override SaveChanges(): int;
+          SaveChanges(_acceptAllChangesOnSuccess?: boolean): int {
+            throw new Error("stub");
+          }
+
+          SaveChangesDefault(): int {
+            return super.SaveChanges();
+          }
+        }
+
+        O<WorkspaceDbContext>()
+          .method((context) => context.SaveChangesDefault)
+          .family((context) => context.SaveChanges);
+      `;
+            const csharp = compileToCSharp(source);
+            expect(csharp).to.include("public override int SaveChanges()");
+            expect(csharp).not.to.include("public new int SaveChanges()");
+        });
+        it("emits expression-tree object literal bodies as anonymous objects", () => {
+            const source = `
+        interface Expression_1<TDelegate> {}
+
+        export class EntityTypeBuilder<TEntity> {
+          HasKey<TKey>(_keySelector: Expression_1<(row: TEntity) => TKey>): void {}
+          HasIndex<TKey>(_indexSelector: Expression_1<(row: TEntity) => TKey>): void {}
+        }
+
+        export class AuthProvider {
+          WorkspaceId: string = "";
+          Id: string = "";
+          DisplayName: string = "";
+        }
+
+        export function configure(builder: EntityTypeBuilder<AuthProvider>): void {
+          builder.HasKey((row: AuthProvider) => ({
+            WorkspaceId: row.WorkspaceId,
+            Id: row.Id,
+          }));
+
+          builder.HasIndex((row: AuthProvider) => ({
+            WorkspaceId: row.WorkspaceId,
+            DisplayName: row.DisplayName,
+          }));
+        }
+      `;
+            const csharp = compileToCSharp(source);
+            expect(csharp).to.include("builder.HasKey((AuthProvider row) => new { WorkspaceId = row.WorkspaceId, Id = row.Id });");
+            expect(csharp).to.include("builder.HasIndex((AuthProvider row) => new { WorkspaceId = row.WorkspaceId, DisplayName = row.DisplayName });");
+            expect(csharp).not.to.include("Dictionary<string, object?>");
+            expect(csharp).not.to.include("new global::System.Collections.Generic.Dictionary");
+        });
+        it("keeps explicit nominal casts on direct member access", () => {
+            const source = `
+        export class Person {
+          name: string;
+
+          constructor(name: string) {
+            this.name = name;
+          }
+        }
+
+        export function readName(value: object): string {
+          return (value as Person).name;
+        }
+      `;
+            const csharp = compileToCSharp(source);
+            expect(csharp).to.include("return ((Person)value).name;");
+            expect(csharp).not.to.include("Structural.GetProperty");
+        });
         it("directly specializes awaited array-or-string overloads when omitted parameters fold away", () => {
             const csharp = compileToCSharp(`
         import { overloads as O } from "@tsonic/core/lang.js";
@@ -1050,15 +1143,15 @@ describe("End-to-End Integration", () => {
         };
 
         export class ServerLike {
-          private readonly _allowHalfOpen: boolean;
+          #allowHalfOpen: boolean;
 
           constructor(
             optionsOrListener?: ServerOpts | (() => void)
           ) {
             if (typeof optionsOrListener === "function") {
-              this._allowHalfOpen = false;
+              this.#allowHalfOpen = false;
             } else {
-              this._allowHalfOpen = optionsOrListener?.allowHalfOpen ?? false;
+              this.#allowHalfOpen = optionsOrListener?.allowHalfOpen ?? false;
             }
           }
         }
@@ -1100,11 +1193,19 @@ describe("End-to-End Integration", () => {
         it("emits source-owned union aliases with source alias carrier names", () => {
             const csharp = compileToCSharp(`
         class Ok<T> {
-          constructor(public value: T) {}
+          value: T;
+
+          constructor(value: T) {
+            this.value = value;
+          }
         }
 
         class Err<E> {
-          constructor(public error: E) {}
+          error: E;
+
+          constructor(error: E) {
+            this.error = error;
+          }
         }
 
         type Result<T, E> = Ok<T> | Err<E>;
@@ -1118,6 +1219,66 @@ describe("End-to-End Integration", () => {
             expect(csharp).to.include(".From");
             expect(csharp).to.not.include("Tsonic.Internal.Union");
         });
+        it("erases broad object source-owned union aliases in emitted signatures", () => {
+            const csharp = compileToCSharp(`
+        type ConsoleValue = string | number | boolean | object | null | undefined;
+
+        export function log(...data: ConsoleValue[]): void {
+        }
+      `);
+            expect(csharp).to.include("public static void log(params object?[] data)");
+            expect(csharp).to.not.include("ConsoleValue");
+            expect(csharp).to.not.include("Tsonic.Internal.Union");
+        });
+        it("preserves scalar typeof branches for broad-object-erased unions", () => {
+            const csharp = compileToCSharp(`
+        type Value = string | number | boolean | object | null | undefined;
+
+        export function coerce(value?: Value): boolean {
+          if (value === undefined || value === null) {
+            return false;
+          }
+
+          if (typeof value === "boolean") {
+            return value;
+          }
+
+          if (typeof value === "number") {
+            return value !== 0;
+          }
+
+          return true;
+        }
+      `);
+            expect(csharp).to.include("if (value is bool)");
+            expect(csharp).to.include("if ((value is double || value is int))");
+            expect(csharp).to.include("return (value switch { int ");
+            expect(csharp).to.include("=> (double)__tsonic_number_int_");
+            expect(csharp).to.include("double __tsonic_number_double_");
+            expect(csharp).to.include("var __tsonic_number_value_");
+            expect(csharp).to.not.include("return (double)value != 0");
+            expect(csharp).to.not.include("if (false)");
+            expect(csharp).to.not.include("global::System.Object.Equals((double)value, 0)");
+        });
+        it("uses projected runtime-union member types in boolean contexts", () => {
+            const csharp = compileToCSharp(`
+        type NumberValue = string | number | boolean | null | undefined;
+
+        export function coerce(value?: NumberValue): number {
+          if (value === undefined || value === null) {
+            return 0;
+          }
+
+          if (typeof value === "boolean") {
+            return value ? 1 : 0;
+          }
+
+          return 1;
+        }
+      `);
+            expect(csharp).to.include("return (double)((value.As1()) ? 1 : 0);");
+            expect(csharp).to.not.include("value.As1()) is global::Tsonic.Internal.Union");
+        });
         it("directly specializes async void overloads when omitted parameters fold away", () => {
             const csharp = compileToCSharp(`
         import { overloads as O } from "@tsonic/core/lang.js";
@@ -1159,8 +1320,8 @@ describe("End-to-End Integration", () => {
         import type { int } from "@tsonic/core/types.js";
 
         export class MkdirOptions {
-          public recursive?: boolean;
-          public mode?: int;
+          recursive?: boolean;
+          mode?: int;
         }
 
         declare function implDefault(path: string): Promise<void>;
@@ -1203,8 +1364,8 @@ describe("End-to-End Integration", () => {
         import type { int } from "@tsonic/core/types.js";
 
         export class MkdirOptions {
-          public recursive?: boolean;
-          public mode?: int;
+          recursive?: boolean;
+          mode?: int;
         }
 
         declare const fs: {
@@ -1285,7 +1446,7 @@ describe("End-to-End Integration", () => {
         it("emits generic property empty-array initializers using the declared element type", () => {
             const csharp = compileToCSharp(`
         export class Box<T> {
-          public items: Array<T | null> = [] as Array<T | null>;
+          items: Array<T | null> = [] as Array<T | null>;
         }
       `);
             expect(csharp).to.include("public T?[] items { get; set; } = global::System.Array.Empty<T?>();");
@@ -1294,14 +1455,17 @@ describe("End-to-End Integration", () => {
         it("emits generic undefined constructor arguments using the generic default type", () => {
             const csharp = compileToCSharp(`
         export class IntervalIterationResult<T> {
-          public constructor(
-            public readonly done: boolean,
-            public readonly value: T | undefined
-          ) {}
+          done: boolean;
+          value: T | undefined;
+
+          constructor(done: boolean, value: T | undefined) {
+            this.done = done;
+            this.value = value;
+          }
         }
 
         export class IntervalAsyncIterator<T> {
-          public close(): IntervalIterationResult<T> {
+          close(): IntervalIterationResult<T> {
             return new IntervalIterationResult(true, undefined);
           }
         }
@@ -1336,15 +1500,15 @@ describe("End-to-End Integration", () => {
         O(readFile_text).family(readFile);
 
         export class FsPromises {
-          public readFile(path: string): Promise<byte[]>;
-          public readFile(path: string, encoding: string): Promise<string>;
-          public readFile(_path: any, _encoding?: any): any {
+          readFile(path: string): Promise<byte[]>;
+          readFile(path: string, encoding: string): Promise<string>;
+          readFile(_path: any, _encoding?: any): any {
             throw new Error("stub");
           }
-          public readFile_bytes(path: string): Promise<byte[]> {
+          readFile_bytes(path: string): Promise<byte[]> {
             return readFile(path);
           }
-          public readFile_text(path: string, encoding: string): Promise<string> {
+          readFile_text(path: string, encoding: string): Promise<string> {
             return readFile(path, encoding);
           }
         }
@@ -1388,17 +1552,17 @@ describe("End-to-End Integration", () => {
         O(readFileSync_text).family(readFileSync);
 
         export class FsModuleNamespace {
-          public readFileSync(path: string): byte[];
-          public readFileSync(path: string, encoding: string): string;
-          public readFileSync(_path: any, _encoding?: any): any {
+          readFileSync(path: string): byte[];
+          readFileSync(path: string, encoding: string): string;
+          readFileSync(_path: any, _encoding?: any): any {
             throw new Error("stub");
           }
 
-          public readFileSync_bytes(path: string): byte[] {
+          readFileSync_bytes(path: string): byte[] {
             return readFileSync(path);
           }
 
-          public readFileSync_text(path: string, encoding: string): string {
+          readFileSync_text(path: string, encoding: string): string {
             return readFileSync(path, encoding);
           }
         }
@@ -1491,31 +1655,31 @@ describe("End-to-End Integration", () => {
             expect(csharp).not.to.include("return global::System.Convert.ToInt64((byte)holder.TotalMilliseconds);");
             expect(csharp).not.to.include("return global::System.Convert.ToInt32((byte)(month + 1));");
         });
-        it("casts broad JS numbers to imported CLR integral overload parameters", () => {
-            const csharp = compileToCSharp(`
+        it("rejects broad JS numbers flowing to imported CLR integral overload parameters", () => {
+            expect(() => compileToCSharp(`
         import type { int } from "@tsonic/core/types.js";
         import { Process } from "@tsonic/dotnet/System.Diagnostics.js";
 
         declare const process: Process;
 
         class ExecOptions {
-          public timeout: number = 0;
+          timeout: number = 0;
         }
 
         export function run(options?: ExecOptions | null): boolean {
           const timeout = options?.timeout ?? 0;
           return process.WaitForExit(timeout);
         }
-      `);
-            expect(csharp).to.include("return process.WaitForExit((int)timeout);");
-            expect(csharp).not.to.include("return process.WaitForExit(timeout);");
+      `)).to.throw("Implicit narrowing not allowed");
         });
         it("null-checks optional Array.isArray runtime-union guards before member tests", () => {
             const csharp = compileToCSharp(`
         export function hasArray(values?: string[] | number): boolean {
           return Array.isArray(values);
         }
-      `);
+      `, "/test/test.ts", {
+                surface: "@tsonic/js",
+            });
             expect(csharp).to.include("((global::System.Object)(values)) != null");
             expect(csharp).to.include("values.Is1()");
         });
@@ -1635,7 +1799,7 @@ describe("End-to-End Integration", () => {
             requestHeaders: Record<string, string | readonly string[] | undefined>,
           ): Record<string, string> {
             const headers: Record<string, string> = {};
-            for (const key in requestHeaders) {
+            for (const key of Object.keys(requestHeaders)) {
               const headerValue = normalizeHeaderValue(requestHeaders[key]);
               if (headerValue !== undefined) {
                 headers[key] = headerValue;
@@ -1652,7 +1816,6 @@ describe("End-to-End Integration", () => {
         it("prefers contextual union surfaces for local safe dictionary reads", () => {
             const csharp = compileToCSharp(`
           import { asinterface } from "@tsonic/core/lang.js";
-          import type { JsValue } from "@tsonic/core/types.js";
 
           interface RequestWithHeadersLookup {
             headers: Record<string, string | readonly string[] | undefined>;
@@ -1670,10 +1833,10 @@ describe("End-to-End Integration", () => {
             return value.join(", ");
           }
 
-          export function run(request: JsValue): Record<string, string> {
+          export function run(request: unknown): Record<string, string> {
             const headers: Record<string, string> = {};
             const requestHeaders = asinterface<RequestWithHeadersLookup>(request).headers;
-            for (const key in requestHeaders) {
+            for (const key of Object.keys(requestHeaders)) {
               const headerValue = normalizeHeaderValue(requestHeaders[key]);
               if (headerValue !== undefined) {
                 headers[key] = headerValue;
@@ -1714,7 +1877,7 @@ describe("End-to-End Integration", () => {
                     "export function run(request: IncomingMessage): Record<string, string> {",
                     "  const headers: Record<string, string> = {};",
                     "  const requestHeaders = asinterface<RequestWithHeadersLookup>(request).headers;",
-                    "  for (const key in requestHeaders) {",
+                    "  for (const key of Object.keys(requestHeaders)) {",
                     "    const headerValue = normalizeHeaderValue(requestHeaders[key]);",
                     "    if (headerValue !== undefined) {",
                     "      headers[key] = headerValue;",
@@ -1860,19 +2023,19 @@ describe("End-to-End Integration", () => {
             expect(csharp).not.to.include("(object)span");
             expect(csharp).not.to.include("(object)destSpan");
         });
-        it("keeps JsValue spread-array conditionals on object arrays instead of numeric unions", () => {
+        it("keeps unknown spread-array conditionals on object arrays instead of numeric unions", () => {
             const csharp = compileToCSharp(`
-        declare function inspect(value: JsValue): string;
+        declare function inspect(value: unknown): string;
 
         export function format(
-          message?: JsValue,
-          optionalParams: readonly JsValue[] = []
+          message?: unknown,
+          optionalParams: readonly unknown[] = []
         ): string {
           const values =
             message === undefined ? [...optionalParams] : [message, ...optionalParams];
           return values.map((value) => inspect(value)).join(" ");
         }
-      `);
+      `, "/test/test.ts", { surface: "@tsonic/js" });
             expect(csharp).not.to.include("Union<double[], object?[]>");
             expect(csharp).not.to.include("(double)message");
             expect(csharp).not.to.include('.toArray().join(" ")');
@@ -1896,7 +2059,7 @@ describe("End-to-End Integration", () => {
         it("widens narrowed runtime-subset handlers without re-matching extracted members", () => {
             const csharp = compileToCSharp(`
         type RequestHandler = (request: string) => void;
-        type ErrorRequestHandler = (error: JsValue, request: string) => void;
+        type ErrorRequestHandler = (error: unknown, request: string) => void;
 
         class Router {}
 
@@ -2023,13 +2186,13 @@ describe("End-to-End Integration", () => {
         });
         it("packs rest arrays for local function values inferred from call results", () => {
             const csharp = compileToCSharp(`
-        type DebugLogFunction = (message: string, ...args: JsValue[]) => void;
+        type DebugLogFunction = (message: string, ...args: unknown[]) => void;
 
         declare function debuglog(section: string): DebugLogFunction;
         declare function deprecate(
-          fn: (...args: JsValue[]) => JsValue,
+          fn: (...args: unknown[]) => unknown,
           message: string
-        ): (...args: JsValue[]) => JsValue;
+        ): (...args: unknown[]) => unknown;
 
         export function run(): void {
           const debug = debuglog("test");
@@ -2047,12 +2210,12 @@ describe("End-to-End Integration", () => {
         it("invokes narrowed handler assertions without matching extracted delegate members", () => {
             const csharp = compileToCSharp(`
         type RequestHandler = (request: string) => void;
-        type ErrorRequestHandler = (error: JsValue, request: string) => void;
+        type ErrorRequestHandler = (error: unknown, request: string) => void;
         type MiddlewareHandler = RequestHandler | ErrorRequestHandler;
 
         export function run(
           handlers: MiddlewareHandler[],
-          currentError?: JsValue
+          currentError?: unknown
         ): void {
           const entry = handlers[0]!;
           if (currentError === undefined) {
@@ -2079,26 +2242,26 @@ describe("End-to-End Integration", () => {
           request: Request,
           response: Response,
           next: NextFunction
-        ) => JsValue | Promise<JsValue>;
+        ) => unknown | Promise<unknown>;
         type ErrorRequestHandler = (
-          error: JsValue,
+          error: unknown,
           request: Request,
           response: Response,
           next: NextFunction
-        ) => JsValue | Promise<JsValue>;
+        ) => unknown | Promise<unknown>;
         type MiddlewareHandler = RequestHandler | ErrorRequestHandler;
 
-        declare function isMiddlewareHandler(value: JsValue): value is MiddlewareHandler;
+        declare function isMiddlewareHandler(value: unknown): value is MiddlewareHandler;
         declare function isErrorHandler(
           value: MiddlewareHandler,
           treatAsError: boolean
         ): value is ErrorRequestHandler;
 
         export async function run(
-          handlers: JsValue[],
+          handlers: unknown[],
           request: Request,
           response: Response,
-          currentError: JsValue
+          currentError: unknown
         ): Promise<void> {
           let error = currentError;
           const next = async (_value?: NextControl): Promise<void> => {};
@@ -2123,27 +2286,27 @@ describe("End-to-End Integration", () => {
         }
       `);
             expect(csharp).to.include("isErrorHandler(");
-            expect(csharp).to.include("MiddlewareHandler From1(global::System.Func<object?, Request__Alias, Response__Alias");
-            expect(csharp).to.include("MiddlewareHandler From2(global::System.Func<Request__Alias, Response__Alias");
-            expect(csharp).to.match(/\.As2\(\)\)\(request, response, next\)\.Match(?:<[^\n]+>)?\(/);
-            expect(csharp).to.match(/\.As1\(\)\)\(error, request, response, next\)\.Match(?:<[^\n]+>)?\(/);
+            expect(csharp).to.include("MiddlewareHandler From1(global::System.Func<Request__Alias, Response__Alias");
+            expect(csharp).to.include("MiddlewareHandler From2(global::System.Func<object?, Request__Alias, Response__Alias");
+            expect(csharp).to.match(/\.As1\(\)\)\(request, response, next\)\.Match(?:<[^\n]+>)?\(/);
+            expect(csharp).to.match(/\.As2\(\)\)\(error, request, response, next\)\.Match(?:<[^\n]+>)?\(/);
             expect(csharp).not.to.include("handler.Is2()");
         });
-        it("passes callable and nominal source-union members directly into broad JsValue guard predicates", () => {
+        it("passes callable and nominal source-union members directly into broad unknown guard predicates", () => {
             const csharp = compileToCSharp(`
         class Router {}
 
         type PathSpec = string | RegExp | readonly PathSpec[];
         type RequestHandler = (request: string) => void;
 
-        declare function isPathSpec(value: JsValue): value is PathSpec;
+        declare function isPathSpec(value: unknown): value is PathSpec;
 
         export function run(first: PathSpec | RequestHandler | Router): boolean {
           return isPathSpec(first);
         }
       `);
-            expect(csharp).to.include("first.Match<object?>(");
-            expect(csharp.split(".Match<object?>(").length - 1).to.equal(2);
+            expect(csharp).to.include("first.Match<object>(");
+            expect(csharp.split(".Match<object>(").length - 1).to.equal(2);
             expect(csharp).not.to.include("new global::System.InvalidCastException");
         });
         it("narrows predicate-guarded source unions before exact branch-local call arguments", () => {
@@ -2154,7 +2317,7 @@ describe("End-to-End Integration", () => {
         type RequestHandler = (request: string) => void;
         type MiddlewareLike = RequestHandler | Router;
 
-        declare function isPathSpec(value: JsValue): value is PathSpec;
+        declare function isPathSpec(value: unknown): value is PathSpec;
         declare function addMiddlewareLayer(path: PathSpec, handlers: readonly MiddlewareLike[]): void;
         declare function useRootMiddleware(first: MiddlewareLike, rest: readonly MiddlewareLike[]): void;
 
@@ -2167,17 +2330,17 @@ describe("End-to-End Integration", () => {
           useRootMiddleware(first, rest);
         }
       `);
-            expect(csharp).to.include("if (isPathSpec(first.Match<object?>(");
+            expect(csharp).to.include("if (isPathSpec(first.Match<object>(");
             expect(csharp).to.include("addMiddlewareLayer((first.As1()), rest);");
             expect(csharp).to.include("useRootMiddleware((first.As2()), rest);");
             expect(csharp).not.to.include("addMiddlewareLayer(first, rest);");
             expect(csharp).not.to.include("useRootMiddleware(first, rest);");
         });
-        it("keeps broad JsValue call arguments on their storage carrier after typeof narrowing", () => {
+        it("keeps broad unknown call arguments on their storage carrier after typeof narrowing", () => {
             const csharp = compileToCSharp(`
-        declare function toNumericValue(value: JsValue): number;
+        declare function toNumericValue(value: unknown): number;
 
-        export function run(value?: JsValue): number {
+        export function run(value?: unknown): number {
           if (value === undefined || value === null) {
             return 0;
           }
@@ -2192,28 +2355,42 @@ describe("End-to-End Integration", () => {
 
           return toNumericValue(value);
         }
-      `);
+      `, "/test/test.ts", {
+                surface: "@tsonic/js",
+            });
             expect(csharp).to.include("return toNumericValue(value);");
             expect(csharp).not.to.include("toNumericValue(value.Match<object?>");
         });
         it("uses runtime equality for unannotated broad assertion locals", () => {
             const csharp = compileToCSharp(`
-          import type { JsValue } from "@tsonic/core/types.js";
 
           export function run<T>(left: T, right: T): boolean {
-            const leftValue = left as JsValue | undefined;
-            const rightValue = right as JsValue | undefined;
+            const leftValue = left as unknown | undefined;
+            const rightValue = right as unknown | undefined;
             return leftValue === rightValue;
           }
         `, "/test/test.ts", { surface: "@tsonic/js" });
             expect(csharp).to.include("return global::System.Object.Equals(leftValue, rightValue);");
             expect(csharp).not.to.include("return leftValue == rightValue;");
         });
-        it("casts Array.isArray-narrowed broad storage directly for concrete array assertions", () => {
+        it("rejects concrete array assertions after broad Array.isArray guards", () => {
+            expect(() => compileToCSharp(`
+
+            export function run(value: unknown): string[] | undefined {
+              if (Array.isArray(value)) {
+                const list = value as string[];
+                list.push("x");
+                return list;
+              }
+
+              return undefined;
+            }
+          `, "/test/test.ts", { surface: "@tsonic/js" })).to.throw(/Array\.isArray cannot narrow a broad runtime value/);
+        });
+        it("casts concrete union Array.isArray-narrowed storage directly for concrete array assertions", () => {
             const csharp = compileToCSharp(`
-          import type { JsValue } from "@tsonic/core/types.js";
 
-          export function run(value: JsValue): string[] | undefined {
+          export function run(value: string | string[]): string[] | undefined {
             if (Array.isArray(value)) {
               const list = value as string[];
               list.push("x");
@@ -2223,7 +2400,7 @@ describe("End-to-End Integration", () => {
             return undefined;
           }
         `, "/test/test.ts", { surface: "@tsonic/js" });
-            expect(csharp).to.include("string[] list = (string[])value;");
+            expect(csharp).to.include("string[] list = (value.As1());");
             expect(csharp).not.to.include("(global::js.Array)value");
             expect(csharp).not.to.match(/global::System\.Linq\.Enumerable\.Select<object\?, string>\(\(global::js\.Array\)value/);
         });
@@ -2261,7 +2438,9 @@ describe("End-to-End Integration", () => {
 
           return false;
         }
-      `);
+      `, "/test/test.ts", {
+                surface: "@tsonic/js",
+            });
             expect(csharp).to.include("pathSpec.Is1()");
             expect(csharp).not.to.include("(pathSpec.As1()).Is1()");
             expect(csharp).not.to.include("((pathSpec.As1()).As1())[index]");
@@ -2286,20 +2465,20 @@ describe("End-to-End Integration", () => {
             expect(csharp).not.to.include("pathOrName.Is3()");
             expect(csharp).to.include("pathOrName.As1()");
         });
-        it("keeps js Date nullish constructor fallbacks direct in constructor arguments", () => {
+        it("materializes js Date constructor union arguments while preserving nullish selection", () => {
             const csharp = compileToCSharp(`
           class Holder {
-            public date: Date | undefined;
+            date: Date | undefined;
 
-            public constructor(date?: Date) {
+            constructor(date?: Date) {
               this.date = date;
             }
           }
 
           class Box {
-            public readonly value: Date;
+            value: Date;
 
-            public constructor(value: Date) {
+            constructor(value: Date) {
               this.value = value;
             }
           }
@@ -2310,10 +2489,9 @@ describe("End-to-End Integration", () => {
             return new Box(selected);
           }
         `, "/test/src/index.ts", { surface: "@tsonic/js" });
-            expect(csharp).to.include("var fallback = new global::js.Date((object)(double)0);");
+            expect(csharp).to.include("var fallback = new global::js.Date(global::Tsonic.Internal.Union<double, string>.From1(0));");
             expect(csharp).to.include("var selected = holder.date ?? fallback;");
             expect(csharp).to.include("return new Box(selected);");
-            expect(csharp).not.to.include("Union2_");
             expect(csharp).not.to.include(".From1(selected)");
         });
         it("returns narrowed string members from overload implementations with broad return types", () => {
@@ -2332,13 +2510,13 @@ describe("End-to-End Integration", () => {
         type PathSpec = string | FileInfo | readonly PathSpec[];
 
         class Application extends Router {
-          get(name: string): JsValue;
+          get(name: string): unknown;
           override get(path: PathSpec, ...handlers: RouteHandler[]): this;
           override get(_nameOrPath: any, ..._handlers: any[]): any {
             throw new Error("stub");
           }
 
-          get_name(name: string): JsValue {
+          get_name(name: string): unknown {
             return name;
           }
 
@@ -2350,7 +2528,7 @@ describe("End-to-End Integration", () => {
         O<Application>().method(x => x.get_name).family(x => x.get);
         O<Application>().method(x => x.get_path).family(x => x.get);
       `);
-            expect(csharp).to.include("public object? get(string name)");
+            expect(csharp).to.include("public new object? get(string name)");
             expect(csharp).to.include("return name;");
             expect(csharp).to.not.include("name.Is");
             expect(csharp).not.to.include("get_name");
@@ -2410,7 +2588,7 @@ describe("End-to-End Integration", () => {
               | TypedArrayInput<TElement>;
 
             export class Uint16Array {
-              public constructor(lengthOrValues: TypedArrayConstructorInput<number>) {
+              constructor(lengthOrValues: TypedArrayConstructorInput<number>) {
                 void lengthOrValues;
               }
             }
@@ -2446,7 +2624,7 @@ describe("End-to-End Integration", () => {
               | TypedArrayInput<TElement>;
 
             export class Uint8Array {
-              public constructor(lengthOrValues: TypedArrayConstructorInput<number>) {
+              constructor(lengthOrValues: TypedArrayConstructorInput<number>) {
                 void lengthOrValues;
               }
             }
@@ -2456,7 +2634,7 @@ describe("End-to-End Integration", () => {
             import { Uint8Array } from "./typed-array-core.js";
 
             class Parameters {
-              public Modulus: byte[] | null = null;
+              Modulus: byte[] | null = null;
             }
 
             export function run(parameters: Parameters): Uint8Array {
@@ -2484,7 +2662,7 @@ describe("End-to-End Integration", () => {
             import { Uint8Array } from "@tsonic/js/index.js";
 
             class Parameters {
-              public Modulus: byte[] | null = null;
+              Modulus: byte[] | null = null;
             }
 
             export function run(parameters: Parameters): Uint8Array {
@@ -2516,13 +2694,13 @@ describe("End-to-End Integration", () => {
               | TypedArrayInput<TElement>;
 
             export class TypedArrayBase<TElement extends number> {
-              protected constructor(lengthOrValues: int | TypedArrayInput<TElement>) {
+              constructor(lengthOrValues: int | TypedArrayInput<TElement>) {
                 void lengthOrValues;
               }
             }
 
             export class Uint8Array extends TypedArrayBase<number> {
-              public constructor(lengthOrValues: TypedArrayConstructorInput<number>) {
+              constructor(lengthOrValues: TypedArrayConstructorInput<number>) {
                 super(lengthOrValues);
               }
             }
@@ -2560,8 +2738,10 @@ describe("End-to-End Integration", () => {
         });
         it("preserves narrowed runtime-union members when coercing Uint8Array byte elements", () => {
             const csharp = compileToCSharp(`
+          import type { byte } from "@tsonic/core/types.js";
+
           export function create(
-            generatorOrEncoding: number | Uint8Array | string
+            generatorOrEncoding: byte | Uint8Array | string
           ): Uint8Array {
             if (typeof generatorOrEncoding === "number") {
               return new Uint8Array([generatorOrEncoding]);
@@ -2572,7 +2752,7 @@ describe("End-to-End Integration", () => {
         `, "/test/test.ts", {
                 surface: "@tsonic/js",
             });
-            expect(csharp).to.include("new global::js.Uint8Array(global::js.TypedArrayConstructorInput<byte>.From2(global::js.TypedArrayInput<byte>.From1(new byte[] { (byte)(generatorOrEncoding.As2()) })))");
+            expect(csharp).to.include("new global::js.Uint8Array(global::js.TypedArrayConstructorInput<byte>.From2(global::js.TypedArrayInput<byte>.From1(new byte[] { (generatorOrEncoding.As3()) })))");
             expect(csharp).not.to.include("new global::js.Uint8Array(new byte[] { (byte)generatorOrEncoding })");
         });
         it("rewraps plain string call arguments through runtime-union surfaces", () => {
@@ -2640,7 +2820,7 @@ describe("End-to-End Integration", () => {
               export class Uint8Array {}
             `,
             }, "src/index.ts", { surface: "@tsonic/js" }));
-            expect(csharp).to.include("return Buffer.fromNonString((global::Tsonic.Internal.Union<double[], global::Test.Buffer, global::fixturejs.Uint8Array>)value.Match<global::Tsonic.Internal.Union<double[], global::Test.Buffer, global::fixturejs.Uint8Array>>(");
+            expect(csharp).to.include("return Buffer.fromNonString(value.Match<global::Tsonic.Internal.Union<double[], global::fixturejs.Uint8Array, global::Test.Buffer>>(");
             expect(csharp).not.to.include("return Buffer.fromNonString(value);");
             expect(csharp).not.to.include("return Buffer.fromNonString(global::Tsonic.Internal.Union<double[], global::Test.Buffer, global::fixturejs.Uint8Array, string>");
         });
@@ -2651,7 +2831,7 @@ describe("End-to-End Integration", () => {
           declare function takesBytes(values: byte[]): void;
 
           export function create(
-            generatorOrEncoding: number | Uint8Array | string
+            generatorOrEncoding: byte | Uint8Array | string
           ): void {
             if (typeof generatorOrEncoding === "number") {
               takesBytes([generatorOrEncoding]);
@@ -2660,7 +2840,7 @@ describe("End-to-End Integration", () => {
         `, "/test/test.ts", {
                 surface: "@tsonic/js",
             });
-            expect(csharp).to.include("takesBytes(new byte[] { (byte)(generatorOrEncoding.As2()) })");
+            expect(csharp).to.include("takesBytes(new byte[] { (generatorOrEncoding.As3()) })");
             expect(csharp).not.to.include("takesBytes(new byte[] { (byte)generatorOrEncoding })");
         });
         it("preserves explicit numeric assertion targets in arithmetic operands", () => {
@@ -2711,7 +2891,7 @@ describe("End-to-End Integration", () => {
         it("emits shadowed instanceof receivers from actual local storage", () => {
             const csharp = compileToCSharp(`
           class BoolValue {
-            public value: boolean;
+            value: boolean;
 
             constructor(value: boolean) {
               this.value = value;
@@ -2732,15 +2912,17 @@ describe("End-to-End Integration", () => {
             expect(csharp).to.match(/if \(shadow__1 is BoolValue shadow__is_\d+\)/);
             expect(csharp).not.to.include("(int)(object)shadow__1 is BoolValue");
         });
-        it("casts numeric Uint8Array length constructors to int", () => {
+        it("keeps exact-int Uint8Array length constructors on the numeric arm", () => {
             const csharp = compileToCSharp(`
-          export function run(start: number, end: number): Uint8Array {
+          import type { int } from "@tsonic/core/types.js";
+
+          export function run(start: int, end: int): Uint8Array {
             return new Uint8Array(end - start);
           }
         `, "/test/test.ts", {
                 surface: "@tsonic/js",
             });
-            expect(csharp).to.include("new global::js.Uint8Array(global::js.TypedArrayConstructorInput<byte>.From1((int)(end - start)))");
+            expect(csharp).to.include("new global::js.Uint8Array(global::js.TypedArrayConstructorInput<byte>.From1(end - start))");
             expect(csharp).not.to.include("new global::js.Uint8Array((int)global::js.TypedArrayConstructorInput");
         });
         it("does not recast materialized typed-array constructor length unions", () => {
@@ -2770,14 +2952,15 @@ describe("End-to-End Integration", () => {
         });
         it("keeps conditional Uint8Array length constructors on the numeric arm", () => {
             const csharp = compileToCSharp(`
-          export function run(totalLength: number): Uint8Array {
+          import type { int } from "@tsonic/core/types.js";
+
+          export function run(totalLength: int): Uint8Array {
             return new Uint8Array(totalLength === 0 ? 1 : totalLength);
           }
         `, "/test/test.ts", {
                 surface: "@tsonic/js",
             });
-            expect(csharp).to.include("return new global::js.Uint8Array(global::js.TypedArrayConstructorInput<byte>.From1((int)(");
-            expect(csharp).to.include("totalLength == 0 ? 1 :");
+            expect(csharp).to.include("return new global::js.Uint8Array(global::js.TypedArrayConstructorInput<byte>.From1(totalLength == 0 ? 1 : totalLength));");
             expect(csharp).not.to.include("return new global::js.Uint8Array(totalLength == 0 ? global::js.TypedArrayConstructorInput<byte>.From2(");
         });
         it("keeps narrowed Uint8Array length access as a direct member read", () => {
@@ -2838,7 +3021,9 @@ describe("End-to-End Integration", () => {
               }
             }
           `,
-            }, "src/index.ts");
+            }, "src/index.ts", {
+                surface: "@tsonic/js",
+            });
             expect(csharp).to.include("if (nextCount > rule.maxCount.Value)");
             expect(csharp).to.include("String(rule.maxCount.Value)");
             expect(csharp).not.to.include("rule.maxCount.Value.Value");
@@ -2856,9 +3041,12 @@ describe("End-to-End Integration", () => {
             }, "src/index.ts", {
                 surface: "@tsonic/js",
             });
-            expect(csharp).to.include("if (chunk.Is3())");
-            expect(csharp).to.include("chunk__is_1.length");
-            expect(csharp).to.include("chunk__is_1.at(index)");
+            expect(csharp).to.include("if (chunk.Is4())");
+            expect(csharp).to.include("return ServerResponse._copyUint8Array(chunk__is_1.buffer);");
+            expect(csharp).to.include("return ServerResponse._copyUint8Array(chunk__is_2);");
+            expect(csharp).to.include("if (chunk.Is2())");
+            expect(csharp).to.include("for (int index = 0; index < source.length;");
+            expect(csharp).to.include("source.at(index)");
             expect(csharp).not.to.include("new global::js.Array<object>(chunk__is_1).length");
         });
         it("lowers non-byte typed-array array-literal constructors through concrete CLR arrays", () => {
@@ -2877,16 +3065,15 @@ describe("End-to-End Integration", () => {
             expect(csharp).not.to.include("new Int16Array(global::Tsonic.Internal.Union<double[], global::System.Collections.Generic.IEnumerable<double>>");
             expect(csharp).not.to.include("new Float32Array(global::Tsonic.Internal.Union<double[], global::System.Collections.Generic.IEnumerable<double>>");
         });
-        it("casts non-byte typed-array numeric length constructors to int", () => {
-            const csharp = compileToCSharp(`
+        it("rejects broad numeric lengths for non-byte typed-array constructors", () => {
+            expect(() => compileToCSharp(`
           export function run(start: number, end: number): void {
             const view = new Int16Array(end - start);
             void view;
           }
         `, "/test/test.ts", {
                 surface: "@tsonic/js",
-            });
-            expect(csharp).to.include("new global::js.Int16Array(global::js.TypedArrayConstructorInput<short>.From1((int)(end - start)))");
+            })).to.throw("Implicit narrowing not allowed");
         });
         it("casts Uint8Array element assignments to byte", () => {
             const csharp = compileToCSharp(`
@@ -2902,12 +3089,12 @@ describe("End-to-End Integration", () => {
             expect(csharp).to.include("data.set(i, 255);");
             expect(csharp).not.to.include("data[i] = 255;");
         });
-        it("casts JS numeric expressions when assigning into int slots", () => {
-            const csharp = compileToCSharp(`
+        it("rejects JS numeric expressions when assigning into int slots", () => {
+            expect(() => compileToCSharp(`
           import type { int } from "@tsonic/core/types.js";
 
           class CursorPosition {
-            public rows: int = 0;
+            rows: int = 0;
           }
 
           export function run(totalLength: number): CursorPosition {
@@ -2917,19 +3104,36 @@ describe("End-to-End Integration", () => {
           }
         `, "/test/test.ts", {
                 surface: "@tsonic/js",
-            });
-            expect(csharp).to.include("pos.rows = (int)global::js.Math.floor(totalLength / 80);");
+            })).to.throw("Implicit narrowing not allowed");
         });
-        it("casts JS numeric expressions when assigning through exact int property slots", () => {
+        it("emits explicit numeric narrowings when assigning into int slots", () => {
             const csharp = compileToCSharp(`
           import type { int } from "@tsonic/core/types.js";
 
+          class CursorPosition {
+            rows: int = 0;
+          }
+
+          export function run(totalLength: int): CursorPosition {
+            const pos = new CursorPosition();
+            pos.rows = (totalLength + 1) as int;
+            return pos;
+          }
+        `, "/test/test.ts", {
+                surface: "@tsonic/js",
+            });
+            expect(csharp).to.include("pos.rows = (int)(totalLength + 1);");
+        });
+        it("rejects JS numeric expressions when assigning through exact int property slots", () => {
+            expect(() => compileToCSharp(`
+          import type { int } from "@tsonic/core/types.js";
+
           class Counter {
-            private _value: int = 0;
+            #value: int = 0;
 
-            public set value(v: number) {
+            set value(v: number) {
               const offset = 123;
-              this._value = v + offset;
+              this.#value = v + offset;
             }
           }
 
@@ -2937,15 +3141,36 @@ describe("End-to-End Integration", () => {
             const counter = new Counter();
             counter.value = value;
           }
+        `, "/test/test.ts", {
+                surface: "@tsonic/js",
+            })).to.throw("Implicit narrowing not allowed");
+        });
+        it("emits explicit numeric narrowings when assigning through exact int property slots", () => {
+            const csharp = compileToCSharp(`
+          import type { int } from "@tsonic/core/types.js";
+
+          class Counter {
+            #value: int = 0;
+
+            set value(v: int) {
+              const offset: int = 123;
+              this.#value = (v + offset) as int;
+            }
+          }
+
+          export function run(value: int): void {
+            const counter = new Counter();
+            counter.value = value;
+          }
         `, "/test/test.ts", {
                 surface: "@tsonic/js",
             });
-            expect(csharp).to.include("this._value = (int)(v + offset);");
+            expect(csharp).to.include("this.__private_value = (int)(v + offset);");
         });
         it("keeps context-narrowed numeric conditionals on the contextual branch type", () => {
             const csharp = compileToCSharp(`
           export function build(): number[] {
-            const table: number[] = new Array<number>(1);
+            const table: number[] = [0];
             const polynomial = 0xedb88320;
             let crc = 0;
             crc = (crc & 1) === 1 ? (crc >>> 1) ^ polynomial : crc >>> 1;
@@ -2986,7 +3211,7 @@ describe("End-to-End Integration", () => {
 
         export function run(drafts: { type: string; to: string; topic?: string; content: string }[]): void {
           const inputs = new List<{ type: string; to: string; topic?: string; content: string }>();
-          for (let i = 0; i < drafts.length; i++) {
+          for (let i = 0; i < drafts.Length; i++) {
             const d = drafts[i];
             inputs.Add({ type: d.type, to: d.to, topic: d.topic, content: d.content });
           }
@@ -3168,6 +3393,33 @@ describe("End-to-End Integration", () => {
             expect(csharp).not.to.include("return new TLSServer((TlsOptions__Alias)(optionsOrListener.As2()), secureConnectionListener ?? null);");
             expect(csharp).not.to.include("global::Tsonic.Internal.Union<global::System.Action<TLSSocket>, TlsOptions__Alias>.From2");
         });
+        it("keeps nullable projected union members direct when assigning to matching storage", () => {
+            const csharp = compileToCSharp(`
+          export class Options {
+            allowHalfOpen?: boolean;
+          }
+
+          class Socket {}
+
+          export class Server {
+            _allowHalfOpen: boolean;
+
+            constructor(
+              optionsOrListener?: Options | ((socket: Socket) => void) | null,
+            ) {
+              let options: Options | null = null;
+              if (typeof optionsOrListener !== "function") {
+                options = optionsOrListener ?? null;
+              }
+
+              this._allowHalfOpen = options?.allowHalfOpen ?? false;
+            }
+          }
+        `, "/test/test.ts", { surface: "@tsonic/js" });
+            expect(csharp).to.include("options = ((object)optionsOrListener == null ? default(Options) : (optionsOrListener.As2())) ?? null;");
+            expect(csharp).not.to.include(").Match<Options>");
+            expect(csharp).not.to.include("Cannot cast runtime union functionType");
+        });
         it("materializes typeof complements before later local initializers in nested nullish guards", () => {
             const csharp = compileToCSharp(`
           import type { byte } from "@tsonic/core/types.js";
@@ -3199,9 +3451,22 @@ describe("End-to-End Integration", () => {
           }
         `, "/test/test.ts", { surface: "@tsonic/js" });
             expect(csharp).to.include("var value = chunkOrCallback.Match");
-            expect(csharp).to.include("global::Tsonic.Internal.Union<byte[], global::js.Uint8Array, string, global::Test.Buffer>");
+            expect(csharp).to.include("global::Tsonic.Internal.Union<byte[], string, global::js.Uint8Array, global::Test.Buffer>");
             expect(csharp).to.include('__tsonic_union_member_2 => throw new global::System.InvalidCastException("Cannot materialize runtime union functionType to unionType")');
-            expect(csharp).not.to.include("var value = (global::Tsonic.Internal.Union<byte[], global::js.Uint8Array, string, global::Test.Buffer>)chunkOrCallback;");
+            expect(csharp).not.to.include("var value = (global::Tsonic.Internal.Union<byte[], string, global::js.Uint8Array, global::Test.Buffer>)chunkOrCallback;");
+        });
+        it("keeps numeric return context for conditionals with mixed numeric carriers", () => {
+            const csharp = compileToCSharp(`
+          import type { byte, int } from "@tsonic/core/types.js";
+
+          export function read(values: byte[], offset: int): number {
+            const value = values[offset]!;
+            return value >= 0x80 ? value - 0x100 : value;
+          }
+        `);
+            expect(csharp).to.include("return value >= 0x80 ? (double)(value - 0x100) : value;");
+            expect(csharp).not.to.include("Union<int, byte>");
+            expect(csharp).not.to.include(".From1(value - 0x100)");
         });
         it("tightens sequential typeof-plus-undefined ternary locals before storage reuse", () => {
             const csharp = compileToCSharp(`
@@ -3302,11 +3567,11 @@ describe("End-to-End Integration", () => {
         it("preserves generic iterable assertion surfaces after predicate narrowing", () => {
             const csharp = compileToCSharp(`
           declare function isIterableObject(
-            value: JsValue,
-          ): value is Iterable<JsValue>;
+            value: unknown
+          ): value is Iterable<unknown>;
           declare function consume<T>(value: T): void;
 
-          export function run<T>(item: JsValue): void {
+          export function run<T>(item: unknown): void {
             if (isIterableObject(item)) {
               for (const value of item as Iterable<T>) {
                 consume(value);
@@ -3409,12 +3674,16 @@ describe("End-to-End Integration", () => {
         });
         it("materializes narrower function arrays into union-element arrays at call sites", () => {
             const csharp = compileToCSharp(`
-        type RouteHandler = (req: string) => JsValue;
-        type ErrorHandler = (error: JsValue, req: string) => JsValue;
+        type RouteHandler = (req: string) => unknown;
+        type ErrorHandler = (error: unknown, req: string) => unknown;
         type Handler = RouteHandler | ErrorHandler;
 
         class RouteBox {
-          constructor(readonly handlers: Handler[]) {}
+          handlers: Handler[];
+
+          constructor(handlers: Handler[]) {
+            this.handlers = handlers;
+          }
         }
 
         function flatten(handlers: RouteHandler[]): RouteHandler[] {
@@ -3453,14 +3722,14 @@ describe("End-to-End Integration", () => {
         });
         it("treats fixed lambda parameters against rest callbacks as positional values", () => {
             const csharp = compileToCSharp(`
-        type EventListener = (...args: JsValue[]) => void;
+        type EventListener = (...args: unknown[]) => void;
 
         declare function consume(listener: EventListener): void;
 
         export function main(): void {
-          let first: JsValue = undefined;
-          let second: JsValue = undefined;
-          let third: JsValue = undefined;
+          let first: unknown = undefined;
+          let second: unknown = undefined;
+          let third: unknown = undefined;
 
           consume((arg1, arg2, arg3) => {
             first = arg1;
@@ -3473,6 +3742,27 @@ describe("End-to-End Integration", () => {
             expect(csharp).to.include("first = arg1;");
             expect(csharp).to.not.include("first = (object?[])arg1;");
         });
+        it("preserves explicit semantic types for fixed parameters lowered from rest callbacks", () => {
+            const csharp = compileToCSharp(`
+        type RuntimeValue = string | number | boolean | object | null | undefined;
+        type EventListener = (...args: RuntimeValue[]) => void;
+
+        declare function consume(listener: EventListener): void;
+
+        export function main(): void {
+          let received: number = 0;
+          consume((value: RuntimeValue) => {
+            if (typeof value === "number") {
+              received = value;
+            }
+          });
+        }
+      `);
+            expect(csharp).to.include("object? value = __unused_args[0];");
+            expect(csharp).to.include("if ((value is double || value is int))");
+            expect(csharp).to.include("received = (double)(value switch { int ");
+            expect(csharp).to.not.include("if (false)");
+        });
         it("preserves nullable array arguments when forwarding identical signatures", () => {
             const csharp = compileToCSharp(`
         class Child {}
@@ -3495,18 +3785,18 @@ describe("End-to-End Integration", () => {
         it("preserves readable array surfaces after setter writes before length reads", () => {
             const csharp = compileToCSharp(`
           declare class Assert {
-            static Equal(expected: JsValue, actual: JsValue): void;
+            static Equal(expected: unknown, actual: unknown): void;
           }
 
           class Proc {
-            private _argv: string[] = [];
+            #argv: string[] = [];
 
             get argv(): string[] {
-              return this._argv;
+              return this.#argv;
             }
 
             set argv(value: string[] | undefined) {
-              this._argv = value ?? [];
+              this.#argv = value ?? [];
             }
           }
 
@@ -3516,7 +3806,7 @@ describe("End-to-End Integration", () => {
           }
         `, "/test/test.ts", { surface: "@tsonic/js" });
             expect(csharp).to.include("p.argv = default(string[]);");
-            expect(csharp).to.include("Assert.Equal((object)(double)0, (object)(double)p.argv.Length);");
+            expect(csharp).to.include("Assert.Equal((object)(double)0, p.argv.Length);");
             expect(csharp).to.not.include("new global::js.Array<object>((object)p.argv).length");
         });
         it("erases compiler-generated structural assertion casts for nominal receivers", () => {
@@ -3551,28 +3841,26 @@ describe("End-to-End Integration", () => {
             expect(csharp).to.include('server.listen("/tmp/socket"');
             expect(csharp).to.include('request.on("data"');
         });
-        it("prefers inferred conditional array surfaces over broad JsValue sinks", () => {
+        it("prefers inferred conditional array surfaces over broad unknown sinks", () => {
             const csharp = compileToCSharp(`
-          import type { JsValue } from "@tsonic/core/types.js";
 
           declare function readIds(json: string): string[];
 
-          export function run(json: string, useJson: boolean): Record<string, JsValue> {
-            const obj: Record<string, JsValue> = {};
+          export function run(json: string, useJson: boolean): Record<string, unknown> {
+            const obj: Record<string, unknown> = {};
             obj["channel_ids"] = useJson ? readIds(json) : [];
             return obj;
           }
         `, "/test/test.ts", { surface: "@tsonic/js" });
             expect(csharp).to.include('obj["channel_ids"] = useJson ? readIds(json) : global::System.Array.Empty<string>();');
         });
-        it("keeps nullable conditional array call surfaces direct over broad JsValue sinks", () => {
+        it("keeps nullable conditional array call surfaces direct over broad unknown sinks", () => {
             const csharp = compileToCSharp(`
-          import type { JsValue } from "@tsonic/core/types.js";
 
           declare function maybeIds(json: string): string[] | undefined;
 
-          export function run(json: string, useJson: boolean): Record<string, JsValue> {
-            const obj: Record<string, JsValue> = {};
+          export function run(json: string, useJson: boolean): Record<string, unknown> {
+            const obj: Record<string, unknown> = {};
             obj["channel_ids"] = useJson ? maybeIds(json) : [];
             return obj;
           }
@@ -3582,11 +3870,10 @@ describe("End-to-End Integration", () => {
         });
         it("keeps conditional reference-array surfaces direct when one branch is nullish", () => {
             const csharp = compileToCSharp(`
-          import type { JsValue } from "@tsonic/core/types.js";
           import { JsonSerializer } from "@tsonic/dotnet/System.Text.Json.js";
 
-          export function run(json: string, useJson: boolean): Record<string, JsValue> {
-            const obj: Record<string, JsValue> = {};
+          export function run(json: string, useJson: boolean): Record<string, unknown> {
+            const obj: Record<string, unknown> = {};
             obj["channel_ids"] =
               useJson ? JsonSerializer.Deserialize<string[]>(json) : [];
             return obj;
@@ -3922,7 +4209,7 @@ describe("End-to-End Integration", () => {
           `,
             }, "src/test.ts", { surface: "@tsonic/js" });
             expect(csharp).to.include("public static Result<T, E> From1(Err__Alias<E> value)");
-            expect(csharp).to.include("var result = await global::System.Threading.Tasks.Task.FromResult(render());");
+            expect(csharp).to.include("var result = await global::System.Threading.Tasks.Task.FromResult(global::Test.render__Module.render());");
             expect(csharp).to.include("if (!result.Match<bool>(__tsonic_union_member_1 => __tsonic_union_member_1.success, __tsonic_union_member_2 => __tsonic_union_member_2.success))");
             expect(csharp).to.match(/return result__1_\d+\.error;/);
             expect(csharp).not.to.include("if (result.Is2())");
@@ -4013,8 +4300,8 @@ describe("End-to-End Integration", () => {
             return String(actualEnd + start);
           }
         `, "/test/test.ts", { surface: "@tsonic/js" });
-            expect(csharp).to.include("clamp(lengthValue + (int)end.Value, 0, lengthValue)");
-            expect(csharp).to.include("clamp((int)end.Value, 0, lengthValue)");
+            expect(csharp).to.include("clamp(lengthValue + end.Value, 0, lengthValue)");
+            expect(csharp).to.include("clamp(end.Value, 0, lengthValue)");
             expect(csharp).not.to.include("clamp(lengthValue + end, 0, lengthValue)");
         });
         it("wraps nested runtime-union carriers without projecting members", () => {
@@ -4118,7 +4405,7 @@ describe("End-to-End Integration", () => {
         });
         it("materializes union array arms to broad object arrays without throwing", () => {
             const csharp = compileToCSharp(`
-          import type { int, JsValue } from "@tsonic/core/types.js";
+          import type { int } from "@tsonic/core/types.js";
 
           interface RecordWithTtl {
             address: string;
@@ -4126,14 +4413,29 @@ describe("End-to-End Integration", () => {
           }
 
           export function run(result: string[] | RecordWithTtl[]): number {
-            const values = result as Array<JsValue>;
+            const values = result as Array<unknown>;
             return values.length;
           }
         `, "/test/test.ts", { surface: "@tsonic/js" });
             expect(csharp).to.include("result.Match<object?[]>");
-            expect(csharp).to.match(/global::System\.Linq\.Enumerable\.Select<(?:global::Test\.)?RecordWithTtl, object\?>/);
+            expect(csharp).to.include("global::System.Linq.Enumerable.Select");
             expect(csharp).not.to.include("Cannot materialize runtime union arrayType to arrayType");
         });
+        it("emits in-operator checks only for string-key dictionary carriers", () => {
+            const csharp = compileToCSharp(`
+        export function hasKey(values: Record<string, number>): boolean {
+          return "total" in values;
+        }
+      `);
+            expect(csharp).to.include('return values.ContainsKey("total");');
+        });
+        it("rejects in-operator checks over declared object properties", () => {
+            expect(() => compileToCSharp(`
+          export function hasName(value: { name?: string }): boolean {
+            return "name" in value;
+          }
+        `)).to.throw(/'in' operator is only supported/);
+        });
     });
 });
 //# sourceMappingURL=regression-coverage-c.test.js.map