diff --git a/implementations/javascript/src/dictionary.ts b/implementations/javascript/src/dictionary.ts
index 5343c2f..0da35e3 100644
--- a/implementations/javascript/src/dictionary.ts
+++ b/implementations/javascript/src/dictionary.ts
@@ -25,11 +25,10 @@ export class Dictionary<V, T extends object = DefaultPointer> extends FlexMap<Va
         return d;
     }
 
-    constructor(items?: readonly [any, V][]);
-    constructor(items?: Iterable<readonly [any, V]>);
-    constructor(items?: Iterable<readonly [any, V]>) {
-        const iter = items?.[Symbol.iterator]();
-        super(canonicalString, iter === void 0 ? void 0 : _iterMap(iter, ([k,v]) => [fromJS(k), v]));
+    constructor(items?: readonly [Value<T>, V][]);
+    constructor(items?: Iterable<readonly [Value<T>, V]>);
+    constructor(items?: Iterable<readonly [Value<T>, V]>) {
+        super(canonicalString, items);
     }
 
     mapEntries<W, R extends object = DefaultPointer>(f: (entry: [Value<T>, V]) => [Value<R>, W]): Dictionary<W, R> {
@@ -84,9 +83,8 @@ export class Set<T extends object = DefaultPointer> extends FlexSet<Value<T>> {
         return x?.[DictionaryType] === 'Set';
     }
 
-    constructor(items?: Iterable<any>) {
-        const iter = items?.[Symbol.iterator]();
-        super(canonicalString, iter === void 0 ? void 0 : _iterMap<any, Value<T>>(iter, fromJS));
+    constructor(items?: Iterable<Value<T>>) {
+        super(canonicalString, items);
     }
 
     map<R extends object = DefaultPointer>(f: (value: Value<T>) => Value<R>): Set<R> {
diff --git a/implementations/javascript/src/record.ts b/implementations/javascript/src/record.ts
index 2a02039..fc5a350 100644
--- a/implementations/javascript/src/record.ts
+++ b/implementations/javascript/src/record.ts
@@ -1,14 +1,14 @@
 import { Tag } from "./constants";
 import { Encoder } from "./codec";
 import { PreserveOn } from "./symbols";
-import { DefaultPointer, fromJS, is, Value } from "./values";
+import { DefaultPointer, is, Value } from "./values";
 
 export const IsPreservesRecord = Symbol.for('IsPreservesRecord');
 
 export class Record<T extends object = DefaultPointer> extends Array<Value<T>> {
     readonly label: Value<T>;
 
-    constructor(label: Value<T>, fieldsJS: any[]) {
+    constructor(label: Value<T>, fields: Value<T>[]) {
         if (arguments.length === 1) {
             // Using things like someRecord.map() involves the runtime
             // apparently instantiating instances of this.constructor
@@ -20,8 +20,8 @@ export class Record<T extends object = DefaultPointer> extends Array<Value<T>> {
             return;
         }
 
-        super(fieldsJS.length);
-        fieldsJS.forEach((f, i) => this[i] = fromJS(f));
+        super(fields.length);
+        fields.forEach((f, i) => this[i] = f);
         this.label = label;
         Object.freeze(this);
     }
@@ -72,11 +72,10 @@ export class Record<T extends object = DefaultPointer> extends Array<Value<T>> {
     }
 
     static makeConstructor<T extends object = DefaultPointer>(labelSymbolText: string, fieldNames: string[]): RecordConstructor<T> {
-        return Record.makeBasicConstructor(Symbol.for(labelSymbolText), fieldNames);
+        return Record.makeBasicConstructor<T>(Symbol.for(labelSymbolText), fieldNames);
     }
 
-    static makeBasicConstructor<T extends object = DefaultPointer>(label0: any, fieldNames: string[]): RecordConstructor<T> {
-        const label = fromJS<T>(label0);
+    static makeBasicConstructor<T extends object = DefaultPointer>(label: Value<T>, fieldNames: string[]): RecordConstructor<T> {
         const arity = fieldNames.length;
         const ctor: RecordConstructor<T> = (...fields: any[]): Record<T> => {
             if (fields.length !== arity) {