diff --git a/.changeset/afraid-masks-own.md b/.changeset/afraid-masks-own.md
new file mode 100644
index 0000000000..523f43eea0
--- /dev/null
+++ b/.changeset/afraid-masks-own.md
@@ -0,0 +1,5 @@
+---
+"effect": minor
+---
+
+remove ReadonlyRecord.fromIterable (duplicate of fromEntries)
diff --git a/.changeset/four-turtles-suffer.md b/.changeset/four-turtles-suffer.md
new file mode 100644
index 0000000000..e396aeb608
--- /dev/null
+++ b/.changeset/four-turtles-suffer.md
@@ -0,0 +1,7 @@
+---
+"effect": minor
+"@effect/platform": minor
+"@effect/typeclass": minor
+---
+
+add key type to ReadonlyRecord
diff --git a/packages/effect/dtslint/ReadonlyRecord.ts b/packages/effect/dtslint/ReadonlyRecord.ts
index bed8510b6b..1a331a373b 100644
--- a/packages/effect/dtslint/ReadonlyRecord.ts
+++ b/packages/effect/dtslint/ReadonlyRecord.ts
@@ -341,7 +341,7 @@ pipe(numbersOrStrings, ReadonlyRecord.partition(Predicate.isNumber))
 // keys
 // -------------------------------------------------------------------------------------
 
-// $ExpectType string[]
+// $ExpectType ("a" | "b")[]
 ReadonlyRecord.keys(structNumbers)
 
 // -------------------------------------------------------------------------------------
@@ -358,10 +358,24 @@ ReadonlyRecord.values(structNumbers)
 ReadonlyRecord.set(numbers, "a", true)
 
 // -------------------------------------------------------------------------------------
-// replace
+// set
 // -------------------------------------------------------------------------------------
+
 // $ExpectType Record<string, number | boolean>
-ReadonlyRecord.replace(numbers, "a", true)
+ReadonlyRecord.set(numbers, "a", true)
+
+// $ExpectType Record<"a" | "b" | "c", number | boolean>
+ReadonlyRecord.set(structNumbers, "c", true)
+
+// -------------------------------------------------------------------------------------
+// remove
+// -------------------------------------------------------------------------------------
+
+// $ExpectType Record<string, number>
+ReadonlyRecord.remove(numbers, "a")
+
+// $ExpectType Record<"b", number>
+ReadonlyRecord.remove(structNumbers, "a")
 
 // -------------------------------------------------------------------------------------
 // reduce
@@ -374,7 +388,7 @@ ReadonlyRecord.reduce(structNumbers, "", (
   _value,
   // $ExpectType "a" | "b"
   key
-) => key)
+) => typeof key === "string" ? key : _acc)
 
 // -------------------------------------------------------------------------------------
 // some
@@ -432,9 +446,74 @@ ReadonlyRecord.every(structNumbers, (
 ) => false)
 
 if (ReadonlyRecord.every(numbersOrStrings, Predicate.isString)) {
-  numbersOrStrings // $ExpectType Readonly<Record<string, string>>
+  numbersOrStrings // $ExpectType ReadonlyRecord<string, string>
 }
 
-if (ReadonlyRecord.every(Predicate.isString)(numbersOrStrings)) {
-  numbersOrStrings // $ExpectType Readonly<Record<string, string>>
+if (ReadonlyRecord.every(numbersOrStrings, Predicate.isString)) {
+  numbersOrStrings // $ExpectType ReadonlyRecord<string, string>
+}
+
+// -------------------------------------------------------------------------------------
+// intersection
+// -------------------------------------------------------------------------------------
+
+// $ExpectType Record<string, number>
+ReadonlyRecord.intersection(numbers, numbersOrStrings, (a, _) => a)
+
+// $ExpectType Record<string, string | number>
+ReadonlyRecord.intersection(numbers, numbersOrStrings, (_, b) => b)
+
+// $ExpectType Record<never, string>
+ReadonlyRecord.intersection(structNumbers, structStrings, (_, b) => b)
+
+// $ExpectType Record<never, number>
+ReadonlyRecord.intersection(structNumbers, structStrings, (a, _) => a)
+
+// $ExpectType Record<string, number>
+ReadonlyRecord.intersection(numbers, numbers, (a, _) => a)
+
+// $ExpectType Record<string, number>
+ReadonlyRecord.intersection(numbers, structStrings, (a, _) => a)
+
+// $ExpectType Record<never, number>
+ReadonlyRecord.intersection(structNumbers, {
+  c: 2
+}, (a, _) => a)
+
+// $ExpectType Record<"b", number>
+ReadonlyRecord.intersection(structNumbers, {
+  b: 2
+}, (a, _) => a)
+
+// -------------------------------------------------------------------------------------
+// has
+// -------------------------------------------------------------------------------------
+
+if (ReadonlyRecord.has(numbers, "a")) {
+  // $ExpectType Record<string, number>
+  numbers
 }
+
+// @ts-expect-error
+ReadonlyRecord.has(structNumbers, "c")
+
+// -------------------------------------------------------------------------------------
+// empty
+// -------------------------------------------------------------------------------------
+
+export const empty1: Record<string, number> = ReadonlyRecord.empty()
+export const empty2: Record<symbol, number> = ReadonlyRecord.empty()
+// @ts-expect-error
+export const empty3: Record<"a", number> = ReadonlyRecord.empty<never>()
+
+// $ExpectType Record<never, never>
+ReadonlyRecord.empty()
+
+// $ExpectType Record<string, never>
+ReadonlyRecord.empty<"a">()
+
+// $ExpectType Record<`a${string}bc`, never>
+ReadonlyRecord.empty<`a${string}bc`>()
+
+// $ExpectType Record<string, never>
+ReadonlyRecord.empty<string>()
diff --git a/packages/effect/src/ReadonlyRecord.ts b/packages/effect/src/ReadonlyRecord.ts
index b06ec776a7..a581ec8e9c 100644
--- a/packages/effect/src/ReadonlyRecord.ts
+++ b/packages/effect/src/ReadonlyRecord.ts
@@ -17,16 +17,39 @@ import type { NoInfer } from "./Types.js"
  * @category models
  * @since 2.0.0
  */
-export interface ReadonlyRecord<out A> {
-  readonly [x: string]: A
+export type ReadonlyRecord<in out K extends string, out A> = {
+  readonly [P in K]: A
+}
+
+/**
+ * @since 2.0.0
+ */
+export declare namespace ReadonlyRecord {
+  type IsFiniteString<T extends string> = [T] extends [`${infer Head}${infer Rest}`]
+    ? string extends Head ? false : Rest extends "" ? true : IsFiniteString<Rest> :
+    false
+
+  /**
+   * @since 2.0.0
+   */
+  export type NonLiteralKey<K extends string> = K extends never ? never
+    : IsFiniteString<K> extends true ? string
+    : K
+
+  /**
+   * @since 2.0.0
+   */
+  export type IntersectKeys<K1 extends string, K2 extends string> = [string] extends [K1 | K2] ?
+    NonLiteralKey<K1> & NonLiteralKey<K2>
+    : K1 & K2
 }
 
 /**
  * @category type lambdas
  * @since 2.0.0
  */
-export interface ReadonlyRecordTypeLambda extends TypeLambda {
-  readonly type: ReadonlyRecord<this["Target"]>
+export interface ReadonlyRecordTypeLambda<K extends string = string> extends TypeLambda {
+  readonly type: ReadonlyRecord<K, this["Target"]>
 }
 
 /**
@@ -35,7 +58,10 @@ export interface ReadonlyRecordTypeLambda extends TypeLambda {
  * @category constructors
  * @since 2.0.0
  */
-export const empty = <A>(): Record<string, A> => ({})
+export const empty = <K extends string = never, V = never>(): Record<
+  ReadonlyRecord.NonLiteralKey<K>,
+  V
+> => ({} as any)
 
 /**
  * Determine if a record is empty.
@@ -51,13 +77,8 @@ export const empty = <A>(): Record<string, A> => ({})
  * @category guards
  * @since 2.0.0
  */
-export const isEmptyRecord = <A>(self: Record<string, A>): self is Record<string, never> => {
-  for (const k in self) {
-    if (has(self, k)) {
-      return false
-    }
-  }
-  return true
+export const isEmptyRecord = <K extends string, A>(self: Record<K, A>): self is Record<K, never> => {
+  return keys(self).length === 0
 }
 
 /**
@@ -74,7 +95,9 @@ export const isEmptyRecord = <A>(self: Record<string, A>): self is Record<string
  * @category guards
  * @since 2.0.0
  */
-export const isEmptyReadonlyRecord: <A>(self: ReadonlyRecord<A>) => self is ReadonlyRecord<never> = isEmptyRecord
+export const isEmptyReadonlyRecord: <K extends string, A>(
+  self: ReadonlyRecord<K, A>
+) => self is ReadonlyRecord<K, never> = isEmptyRecord
 
 /**
  * Takes an iterable and a projection function and returns a record.
@@ -97,26 +120,49 @@ export const isEmptyReadonlyRecord: <A>(self: ReadonlyRecord<A>) => self is Read
  * @since 2.0.0
  */
 export const fromIterableWith: {
-  <A, B>(f: (a: A) => readonly [string, B]): (self: Iterable<A>) => Record<string, B>
-  <A, B>(self: Iterable<A>, f: (a: A) => readonly [string, B]): Record<string, B>
-} = dual(2, <A, B>(self: Iterable<A>, f: (a: A) => readonly [string, B]): Record<string, B> => {
-  const out: Record<string, B> = {}
-  for (const a of self) {
-    const [k, b] = f(a)
-    out[k] = b
+  <A, K extends string, B>(
+    f: (a: A) => readonly [K, B]
+  ): (self: Iterable<A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <A, K extends string, B>(
+    self: Iterable<A>,
+    f: (a: A) => readonly [K, B]
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, B>
+} = dual(
+  2,
+  <A, K extends string, B>(
+    self: Iterable<A>,
+    f: (a: A) => readonly [K, B]
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, B> => {
+    const out: Record<string, B> = empty()
+    for (const a of self) {
+      const [k, b] = f(a)
+      out[k] = b
+    }
+    return out
   }
-  return out
-})
+)
 
 /**
- * Creates a new record from an iterable collection of key/value pairs.
+ * Builds a record from an iterable of key-value pairs.
+ *
+ * If there are conflicting keys when using `fromEntries`, the last occurrence of the key/value pair will overwrite the
+ * previous ones. So the resulting record will only have the value of the last occurrence of each key.
+ *
+ * @param self - The iterable of key-value pairs.
+ *
+ * @example
+ * import { fromEntries } from "effect/ReadonlyRecord"
+ *
+ * const input: Array<[string, number]> = [["a", 1], ["b", 2]]
+ *
+ * assert.deepStrictEqual(fromEntries(input), { a: 1, b: 2 })
  *
  * @since 2.0.0
  * @category constructors
  */
-export const fromIterable: <V>(entries: Iterable<readonly [string, V]>) => Record<string, V> = fromIterableWith(
-  identity
-)
+export const fromEntries: <Entry extends readonly [string, any]>(
+  entries: Iterable<Entry>
+) => Record<ReadonlyRecord.NonLiteralKey<Entry[0]>, Entry[1]> = Object.fromEntries
 
 /**
  * Creates a new record from an iterable, utilizing the provided function to determine the key for each element.
@@ -143,28 +189,10 @@ export const fromIterable: <V>(entries: Iterable<readonly [string, V]>) => Recor
  * @category constructors
  * @since 2.0.0
  */
-export const fromIterableBy = <A>(items: Iterable<A>, f: (a: A) => string): Record<string, A> =>
-  fromIterableWith(items, (a) => [f(a), a])
-
-/**
- * Builds a record from an iterable of key-value pairs.
- *
- * If there are conflicting keys when using `fromEntries`, the last occurrence of the key/value pair will overwrite the
- * previous ones. So the resulting record will only have the value of the last occurrence of each key.
- *
- * @param self - The iterable of key-value pairs.
- *
- * @example
- * import { fromEntries } from "effect/ReadonlyRecord"
- *
- * const input: Array<[string, number]> = [["a", 1], ["b", 2]]
- *
- * assert.deepStrictEqual(fromEntries(input), { a: 1, b: 2 })
- *
- * @category conversions
- * @since 2.0.0
- */
-export const fromEntries: <A>(self: Iterable<readonly [string, A]>) => Record<string, A> = fromIterableWith(identity)
+export const fromIterableBy = <A, K extends string>(
+  items: Iterable<A>,
+  f: (a: A) => K
+): Record<ReadonlyRecord.NonLiteralKey<K>, A> => fromIterableWith(items, (a) => [f(a), a])
 
 /**
  * Transforms the values of a record into an `Array` with a custom mapping function.
@@ -182,13 +210,13 @@ export const fromEntries: <A>(self: Iterable<readonly [string, A]>) => Record<st
  * @since 2.0.0
  */
 export const collect: {
-  <K extends string, A, B>(f: (key: K, a: A) => B): (self: Record<K, A>) => Array<B>
-  <K extends string, A, B>(self: Record<K, A>, f: (key: K, a: A) => B): Array<B>
+  <K extends string, A, B>(f: (key: K, a: A) => B): (self: ReadonlyRecord<K, A>) => Array<B>
+  <K extends string, A, B>(self: ReadonlyRecord<K, A>, f: (key: K, a: A) => B): Array<B>
 } = dual(
   2,
-  <A, B>(self: ReadonlyRecord<A>, f: (key: string, a: A) => B): Array<B> => {
+  <K extends string, A, B>(self: ReadonlyRecord<K, A>, f: (key: K, a: A) => B): Array<B> => {
     const out: Array<B> = []
-    for (const key of Object.keys(self)) {
+    for (const key of keys(self)) {
       out.push(f(key, self[key]))
     }
     return out
@@ -209,7 +237,7 @@ export const collect: {
  * @category conversions
  * @since 2.0.0
  */
-export const toEntries: <K extends string, A>(self: Record<K, A>) => Array<[K, A]> = collect((
+export const toEntries: <K extends string, A>(self: ReadonlyRecord<K, A>) => Array<[K, A]> = collect((
   key,
   value
 ) => [key, value])
@@ -226,7 +254,7 @@ export const toEntries: <K extends string, A>(self: Record<K, A>) => Array<[K, A
  *
  * @since 2.0.0
  */
-export const size = <A>(self: ReadonlyRecord<A>): number => Object.keys(self).length
+export const size = <K extends string, A>(self: ReadonlyRecord<K, A>): number => keys(self).length
 
 /**
  * Check if a given `key` exists in a record.
@@ -235,19 +263,27 @@ export const size = <A>(self: ReadonlyRecord<A>): number => Object.keys(self).le
  * @param key - the key to look for in the record.
  *
  * @example
- * import { has } from "effect/ReadonlyRecord"
+ * import { empty, has } from "effect/ReadonlyRecord"
  *
  * assert.deepStrictEqual(has({ a: 1, b: 2 }, "a"), true);
- * assert.deepStrictEqual(has({ a: 1, b: 2 }, "c"), false);
+ * assert.deepStrictEqual(has(empty<string>(), "c"), false);
  *
  * @since 2.0.0
  */
 export const has: {
-  (key: string): <A>(self: ReadonlyRecord<A>) => boolean
-  <A>(self: ReadonlyRecord<A>, key: string): boolean
+  <K extends string>(
+    key: NoInfer<K>
+  ): <A>(self: ReadonlyRecord<K, A>) => boolean
+  <K extends string, A>(
+    self: ReadonlyRecord<K, A>,
+    key: NoInfer<K>
+  ): boolean
 } = dual(
   2,
-  <A>(self: ReadonlyRecord<A>, key: string): boolean => Object.prototype.hasOwnProperty.call(self, key)
+  <K extends string, A>(
+    self: ReadonlyRecord<K, A>,
+    key: NoInfer<K>
+  ): boolean => Object.prototype.hasOwnProperty.call(self, key)
 )
 
 /**
@@ -260,7 +296,7 @@ export const has: {
  * import { get } from "effect/ReadonlyRecord"
  * import { some, none } from "effect/Option"
  *
- * const person = { name: "John Doe", age: 35 }
+ * const person: Record<string, unknown> = { name: "John Doe", age: 35 }
  *
  * assert.deepStrictEqual(get(person, "name"), some("John Doe"))
  * assert.deepStrictEqual(get(person, "email"), none())
@@ -268,11 +304,12 @@ export const has: {
  * @since 2.0.0
  */
 export const get: {
-  (key: string): <A>(self: ReadonlyRecord<A>) => Option.Option<A>
-  <A>(self: ReadonlyRecord<A>, key: string): Option.Option<A>
+  <K extends string>(key: NoInfer<K>): <A>(self: ReadonlyRecord<K, A>) => Option.Option<A>
+  <K extends string, A>(self: ReadonlyRecord<K, A>, key: NoInfer<K>): Option.Option<A>
 } = dual(
   2,
-  <A>(self: ReadonlyRecord<A>, key: string): Option.Option<A> => has(self, key) ? Option.some(self[key]) : Option.none()
+  <K extends string, A>(self: ReadonlyRecord<K, A>, key: NoInfer<K>): Option.Option<A> =>
+    has(self, key) ? Option.some(self[key]) : Option.none()
 )
 
 /**
@@ -294,21 +331,21 @@ export const get: {
  *  { a: 6 }
  * )
  * assert.deepStrictEqual(
- *  modify({ a: 3 }, 'b', f),
+ *  modify({ a: 3 } as Record<string, number>, 'b', f),
  *  { a: 3 }
  * )
  *
  * @since 2.0.0
  */
 export const modify: {
-  <A, B>(
-    key: string,
+  <K extends string, A, B>(
+    key: NoInfer<K>,
     f: (a: A) => B
-  ): (self: ReadonlyRecord<A>) => Record<string, A | B>
-  <A, B>(self: ReadonlyRecord<A>, key: string, f: (a: A) => B): Record<string, A | B>
+  ): (self: ReadonlyRecord<K, A>) => Record<K, A | B>
+  <K extends string, A, B>(self: ReadonlyRecord<K, A>, key: NoInfer<K>, f: (a: A) => B): Record<K, A | B>
 } = dual(
   3,
-  <A, B>(self: ReadonlyRecord<A>, key: string, f: (a: A) => B): Record<string, A | B> => {
+  <K extends string, A, B>(self: ReadonlyRecord<K, A>, key: NoInfer<K>, f: (a: A) => B): Record<K, A | B> => {
     if (!has(self, key)) {
       return { ...self }
     }
@@ -335,24 +372,33 @@ export const modify: {
  *  some({ a: 6 })
  * )
  * assert.deepStrictEqual(
- *  modifyOption({ a: 3 }, 'b', f),
+ *  modifyOption({ a: 3 } as Record<string, number>, 'b', f),
  *  none()
  * )
  *
  * @since 2.0.0
  */
 export const modifyOption: {
-  <A, B>(key: string, f: (a: A) => B): (self: ReadonlyRecord<A>) => Option.Option<Record<string, A | B>>
-  <A, B>(self: ReadonlyRecord<A>, key: string, f: (a: A) => B): Option.Option<Record<string, A | B>>
+  <K extends string, A, B>(
+    key: NoInfer<K>,
+    f: (a: A) => B
+  ): (self: ReadonlyRecord<K, A>) => Option.Option<Record<K, A | B>>
+  <K extends string, A, B>(
+    self: ReadonlyRecord<K, A>,
+    key: NoInfer<K>,
+    f: (a: A) => B
+  ): Option.Option<Record<K, A | B>>
 } = dual(
   3,
-  <A, B>(self: ReadonlyRecord<A>, key: string, f: (a: A) => B): Option.Option<Record<string, A | B>> => {
+  <K extends string, A, B>(
+    self: ReadonlyRecord<K, A>,
+    key: NoInfer<K>,
+    f: (a: A) => B
+  ): Option.Option<Record<K, A | B>> => {
     if (!has(self, key)) {
       return Option.none()
     }
-    const out: Record<string, A | B> = { ...self }
-    out[key] = f(self[key])
-    return Option.some(out)
+    return Option.some({ ...self, [key]: f(self[key]) })
   }
 )
 
@@ -364,28 +410,39 @@ export const modifyOption: {
  * @param b - The new value to replace the existing value with.
  *
  * @example
- * import { replaceOption } from "effect/ReadonlyRecord"
+ * import { empty, replaceOption } from "effect/ReadonlyRecord"
  * import { some, none } from "effect/Option"
  *
  * assert.deepStrictEqual(
  *   replaceOption({ a: 1, b: 2, c: 3 }, 'a', 10),
  *   some({ a: 10, b: 2, c: 3 })
  * )
- * assert.deepStrictEqual(replaceOption({}, 'a', 10), none())
+ * assert.deepStrictEqual(replaceOption(empty<string>(), 'a', 10), none())
  *
  * @since 2.0.0
  */
 export const replaceOption: {
-  <B>(key: string, b: B): <A>(self: ReadonlyRecord<A>) => Option.Option<Record<string, A | B>>
-  <A, B>(self: ReadonlyRecord<A>, key: string, b: B): Option.Option<Record<string, A | B>>
+  <K extends string, B>(
+    key: NoInfer<K>,
+    b: B
+  ): <A>(self: ReadonlyRecord<K, A>) => Option.Option<Record<K, A | B>>
+  <K extends string, A, B>(
+    self: ReadonlyRecord<K, A>,
+    key: NoInfer<K>,
+    b: B
+  ): Option.Option<Record<K, A | B>>
 } = dual(
   3,
-  <A, B>(self: ReadonlyRecord<A>, key: string, b: B): Option.Option<Record<string, A | B>> =>
-    modifyOption(self, key, () => b)
+  <K extends string, A, B>(
+    self: ReadonlyRecord<K, A>,
+    key: NoInfer<K>,
+    b: B
+  ): Option.Option<Record<K, A | B>> => modifyOption(self, key, () => b)
 )
 
 /**
- * Removes a key from a record and returns a new record
+ * If the given key exists in the record, returns a new record with the key removed,
+ * otherwise returns the original record.
  *
  * @param self - the record to remove the key from.
  * @param key - the key to remove from the record.
@@ -398,13 +455,19 @@ export const replaceOption: {
  * @since 2.0.0
  */
 export const remove: {
-  (key: string): <A>(self: ReadonlyRecord<A>) => Record<string, A>
-  <A>(self: ReadonlyRecord<A>, key: string): Record<string, A>
-} = dual(2, <A>(self: ReadonlyRecord<A>, key: string): Record<string, A> => {
-  const out = { ...self }
-  delete out[key]
-  return out
-})
+  <K extends string, X extends K>(key: X): <A>(self: ReadonlyRecord<K, A>) => Record<Exclude<K, X>, A>
+  <K extends string, A, X extends K>(self: ReadonlyRecord<K, A>, key: X): Record<Exclude<K, X>, A>
+} = dual(
+  2,
+  <K extends string, A, X extends K>(self: ReadonlyRecord<K, A>, key: X): Record<Exclude<K, X>, A> => {
+    if (!has(self, key)) {
+      return { ...self }
+    }
+    const out = { ...self }
+    delete out[key]
+    return out
+  }
+)
 
 /**
  * Retrieves the value of the property with the given `key` from a record and returns an `Option`
@@ -419,19 +482,24 @@ export const remove: {
  * import { some, none } from 'effect/Option'
  *
  * assert.deepStrictEqual(pop({ a: 1, b: 2 }, "a"), some([1, { b: 2 }]))
- * assert.deepStrictEqual(pop({ a: 1, b: 2 }, "c"), none())
+ * assert.deepStrictEqual(pop({ a: 1, b: 2 } as Record<string, number>, "c"), none())
  *
  * @category record
  * @since 2.0.0
  */
 export const pop: {
-  (key: string): <A>(self: ReadonlyRecord<A>) => Option.Option<[A, Record<string, A>]>
-  <A>(self: ReadonlyRecord<A>, key: string): Option.Option<[A, Record<string, A>]>
-} = dual(2, <A>(
-  self: ReadonlyRecord<A>,
-  key: string
-): Option.Option<[A, Record<string, A>]> =>
-  has(self, key) ? Option.some([self[key], remove(self, key)]) : Option.none())
+  <K extends string, X extends K>(
+    key: X
+  ): <A>(self: ReadonlyRecord<K, A>) => Option.Option<[A, Record<Exclude<K, X>, A>]>
+  <K extends string, A, X extends K>(
+    self: ReadonlyRecord<K, A>,
+    key: X
+  ): Option.Option<[A, Record<Exclude<K, X>, A>]>
+} = dual(2, <K extends string, A, X extends K>(
+  self: ReadonlyRecord<K, A>,
+  key: X
+): Option.Option<[A, Record<Exclude<K, X>, A>]> =>
+  has(self, key) ? Option.some([self[key], remove(self as any, key)]) : Option.none())
 
 /**
  * Maps a record into another record by applying a transformation function to each of its values.
@@ -454,13 +522,13 @@ export const pop: {
  * @since 2.0.0
  */
 export const map: {
-  <K extends string, A, B>(f: (a: A, key: K) => B): (self: Record<K, A>) => Record<K, B>
-  <K extends string, A, B>(self: Record<K, A>, f: (a: A, key: K) => B): Record<K, B>
+  <K extends string, A, B>(f: (a: A, key: NoInfer<K>) => B): (self: ReadonlyRecord<K, A>) => Record<K, B>
+  <K extends string, A, B>(self: ReadonlyRecord<K, A>, f: (a: A, key: NoInfer<K>) => B): Record<K, B>
 } = dual(
   2,
-  <A, B>(self: ReadonlyRecord<A>, f: (a: A, key: string) => B): Record<string, B> => {
-    const out: Record<string, B> = {}
-    for (const key of Object.keys(self)) {
+  <K extends string, A, B>(self: ReadonlyRecord<K, A>, f: (a: A, key: NoInfer<K>) => B): Record<K, B> => {
+    const out: Record<K, B> = { ...self } as any
+    for (const key of keys(self)) {
       out[key] = f(self[key], key)
     }
     return out
@@ -479,13 +547,21 @@ export const map: {
  * @since 2.0.0
  */
 export const mapKeys: {
-  <A>(f: (key: string, a: A) => string): (self: ReadonlyRecord<A>) => Record<string, A>
-  <A>(self: ReadonlyRecord<A>, f: (key: string, a: A) => string): Record<string, A>
+  <K extends string, A, K2 extends string>(
+    f: (key: K, a: A) => K2
+  ): (self: ReadonlyRecord<K, A>) => Record<K2, A>
+  <K extends string, A, K2 extends string>(
+    self: ReadonlyRecord<K, A>,
+    f: (key: K, a: A) => K2
+  ): Record<K2, A>
 } = dual(
   2,
-  <A>(self: ReadonlyRecord<A>, f: (key: string, a: A) => string): Record<string, A> => {
-    const out: Record<string, A> = {}
-    for (const key of Object.keys(self)) {
+  <K extends string, A, K2 extends string>(
+    self: ReadonlyRecord<K, A>,
+    f: (key: K, a: A) => K2
+  ): Record<K2, A> => {
+    const out: Record<K2, A> = {} as any
+    for (const key of keys(self)) {
       const a = self[key]
       out[f(key, a)] = a
     }
@@ -505,15 +581,23 @@ export const mapKeys: {
  * @since 2.0.0
  */
 export const mapEntries: {
-  <A>(f: (a: A, key: string) => [string, A]): (self: ReadonlyRecord<A>) => Record<string, A>
-  <A>(self: ReadonlyRecord<A>, f: (a: A, key: string) => [string, A]): Record<string, A>
+  <K extends string, A, K2 extends string, B>(
+    f: (a: A, key: K) => readonly [K2, B]
+  ): (self: ReadonlyRecord<K, A>) => Record<K2, B>
+  <K extends string, A, K2 extends string, B>(
+    self: ReadonlyRecord<K, A>,
+    f: (a: A, key: K) => [K2, B]
+  ): Record<K2, B>
 } = dual(
   2,
-  <A>(self: ReadonlyRecord<A>, f: (a: A, key: string) => [string, A]): Record<string, A> => {
-    const out: Record<string, A> = {}
-    for (const key of Object.keys(self)) {
-      const [k, a] = f(self[key], key)
-      out[k] = a
+  <K extends string, A, K2 extends string, B>(
+    self: ReadonlyRecord<K, A>,
+    f: (a: A, key: K) => [K2, B]
+  ): Record<K2, B> => {
+    const out = <Record<K2, B>> {}
+    for (const key of keys(self)) {
+      const [k, b] = f(self[key], key)
+      out[k] = b
     }
     return out
   }
@@ -537,21 +621,29 @@ export const mapEntries: {
  * @since 2.0.0
  */
 export const filterMap: {
-  <K extends string, A, B>(f: (a: A, key: K) => Option.Option<B>): (self: Record<K, A>) => Record<string, B>
-  <K extends string, A, B>(self: Record<K, A>, f: (a: A, key: K) => Option.Option<B>): Record<string, B>
-} = dual(2, <A, B>(
-  self: Record<string, A>,
-  f: (a: A, key: string) => Option.Option<B>
-): Record<string, B> => {
-  const out: Record<string, B> = {}
-  for (const key of Object.keys(self)) {
-    const o = f(self[key], key)
-    if (Option.isSome(o)) {
-      out[key] = o.value
+  <K extends string, A, B>(
+    f: (a: A, key: K) => Option.Option<B>
+  ): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <K extends string, A, B>(
+    self: ReadonlyRecord<K, A>,
+    f: (a: A, key: K) => Option.Option<B>
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, B>
+} = dual(
+  2,
+  <K extends string, A, B>(
+    self: ReadonlyRecord<K, A>,
+    f: (a: A, key: K) => Option.Option<B>
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, B> => {
+    const out: Record<string, B> = empty()
+    for (const key of keys(self)) {
+      const o = f(self[key], key)
+      if (Option.isSome(o)) {
+        out[key] = o.value
+      }
     }
+    return out
   }
-  return out
-})
+)
 
 /**
  * Selects properties from a record whose values match the given predicate.
@@ -571,20 +663,26 @@ export const filterMap: {
 export const filter: {
   <K extends string, A, B extends A>(
     refinement: (a: NoInfer<A>, key: K) => a is B
-  ): (self: Record<K, A>) => Record<string, B>
+  ): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, B>
   <K extends string, A>(
     predicate: (A: NoInfer<A>, key: K) => boolean
-  ): (self: Record<K, A>) => Record<string, A>
-  <K extends string, A, B extends A>(self: Record<K, A>, refinement: (a: A, key: K) => a is B): Record<string, B>
-  <K extends string, A>(self: Record<K, A>, predicate: (a: A, key: K) => boolean): Record<string, A>
+  ): (self: ReadonlyRecord<K, A>) => Record<ReadonlyRecord.NonLiteralKey<K>, A>
+  <K extends string, A, B extends A>(
+    self: ReadonlyRecord<K, A>,
+    refinement: (a: A, key: K) => a is B
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  <K extends string, A>(
+    self: ReadonlyRecord<K, A>,
+    predicate: (a: A, key: K) => boolean
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, A>
 } = dual(
   2,
-  <A>(
-    self: Record<string, A>,
-    predicate: (a: A, key: string) => boolean
-  ): Record<string, A> => {
-    const out: Record<string, A> = {}
-    for (const key of Object.keys(self)) {
+  <K extends string, A>(
+    self: ReadonlyRecord<K, A>,
+    predicate: (a: A, key: K) => boolean
+  ): Record<ReadonlyRecord.NonLiteralKey<K>, A> => {
+    const out: Record<string, A> = empty()
+    for (const key of keys(self)) {
       if (predicate(self[key], key)) {
         out[key] = self[key]
       }
@@ -610,7 +708,9 @@ export const filter: {
  * @category filtering
  * @since 2.0.0
  */
-export const getSomes: <A>(self: ReadonlyRecord<Option.Option<A>>) => Record<string, A> = filterMap(
+export const getSomes: <K extends string, A>(
+  self: ReadonlyRecord<K, Option.Option<A>>
+) => Record<ReadonlyRecord.NonLiteralKey<K>, A> = filterMap(
   identity
 )
 
@@ -629,9 +729,11 @@ export const getSomes: <A>(self: ReadonlyRecord<Option.Option<A>>) => Record<str
  * @category filtering
  * @since 2.0.0
  */
-export const getLefts = <E, A>(self: ReadonlyRecord<Either<A, E>>): Record<string, E> => {
-  const out: Record<string, E> = {}
-  for (const key of Object.keys(self)) {
+export const getLefts = <K extends string, E, A>(
+  self: ReadonlyRecord<K, Either<A, E>>
+): Record<ReadonlyRecord.NonLiteralKey<K>, E> => {
+  const out: Record<string, E> = empty()
+  for (const key of keys(self)) {
     const value = self[key]
     if (E.isLeft(value)) {
       out[key] = value.left
@@ -656,9 +758,11 @@ export const getLefts = <E, A>(self: ReadonlyRecord<Either<A, E>>): Record<strin
  * @category filtering
  * @since 2.0.0
  */
-export const getRights = <E, A>(self: ReadonlyRecord<Either<A, E>>): Record<string, A> => {
-  const out: Record<string, A> = {}
-  for (const key of Object.keys(self)) {
+export const getRights = <K extends string, E, A>(
+  self: ReadonlyRecord<K, Either<A, E>>
+): Record<string, A> => {
+  const out: Record<string, A> = empty()
+  for (const key of keys(self)) {
     const value = self[key]
     if (E.isRight(value)) {
       out[key] = value.right
@@ -688,20 +792,22 @@ export const getRights = <E, A>(self: ReadonlyRecord<Either<A, E>>): Record<stri
 export const partitionMap: {
   <K extends string, A, B, C>(
     f: (a: A, key: K) => Either<C, B>
-  ): (self: Record<K, A>) => [left: Record<string, B>, right: Record<string, C>]
+  ): (
+    self: ReadonlyRecord<K, A>
+  ) => [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
   <K extends string, A, B, C>(
-    self: Record<K, A>,
+    self: ReadonlyRecord<K, A>,
     f: (a: A, key: K) => Either<C, B>
-  ): [left: Record<string, B>, right: Record<string, C>]
+  ): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>]
 } = dual(
   2,
-  <A, B, C>(
-    self: Record<string, A>,
-    f: (a: A, key: string) => Either<C, B>
-  ): [left: Record<string, B>, right: Record<string, C>] => {
-    const left: Record<string, B> = {}
-    const right: Record<string, C> = {}
-    for (const key of Object.keys(self)) {
+  <K extends string, A, B, C>(
+    self: ReadonlyRecord<K, A>,
+    f: (a: A, key: K) => Either<C, B>
+  ): [left: Record<ReadonlyRecord.NonLiteralKey<K>, B>, right: Record<ReadonlyRecord.NonLiteralKey<K>, C>] => {
+    const left: Record<string, B> = empty()
+    const right: Record<string, C> = empty()
+    for (const key of keys(self)) {
       const e = f(self[key], key)
       if (E.isLeft(e)) {
         left[key] = e.left
@@ -731,9 +837,9 @@ export const partitionMap: {
  * @category filtering
  * @since 2.0.0
  */
-export const separate: <A, B>(
-  self: ReadonlyRecord<Either<B, A>>
-) => [Record<string, A>, Record<string, B>] = partitionMap(identity)
+export const separate: <K extends string, A, B>(
+  self: ReadonlyRecord<K, Either<B, A>>
+) => [Record<ReadonlyRecord.NonLiteralKey<K>, A>, Record<ReadonlyRecord.NonLiteralKey<K>, B>] = partitionMap(identity)
 
 /**
  * Partitions a record into two separate records based on the result of a predicate function.
@@ -754,28 +860,36 @@ export const separate: <A, B>(
  */
 export const partition: {
   <K extends string, A, B extends A>(refinement: (a: NoInfer<A>, key: K) => a is B): (
-    self: Record<K, A>
-  ) => [excluded: Record<string, Exclude<A, B>>, satisfying: Record<string, B>]
+    self: ReadonlyRecord<K, A>
+  ) => [
+    excluded: Record<ReadonlyRecord.NonLiteralKey<K>, Exclude<A, B>>,
+    satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  ]
   <K extends string, A>(
     predicate: (a: NoInfer<A>, key: K) => boolean
-  ): (self: Record<K, A>) => [excluded: Record<string, A>, satisfying: Record<string, A>]
+  ): (
+    self: ReadonlyRecord<K, A>
+  ) => [excluded: Record<ReadonlyRecord.NonLiteralKey<K>, A>, satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, A>]
   <K extends string, A, B extends A>(
-    self: Record<K, A>,
+    self: ReadonlyRecord<K, A>,
     refinement: (a: A, key: K) => a is B
-  ): [excluded: Record<string, Exclude<A, B>>, satisfying: Record<string, B>]
+  ): [
+    excluded: Record<ReadonlyRecord.NonLiteralKey<K>, Exclude<A, B>>,
+    satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, B>
+  ]
   <K extends string, A>(
-    self: Record<K, A>,
+    self: ReadonlyRecord<K, A>,
     predicate: (a: A, key: K) => boolean
-  ): [excluded: Record<string, A>, satisfying: Record<string, A>]
+  ): [excluded: Record<ReadonlyRecord.NonLiteralKey<K>, A>, satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, A>]
 } = dual(
   2,
-  <A>(
-    self: Record<string, A>,
-    predicate: (a: A, key: string) => boolean
-  ): [excluded: Record<string, A>, satisfying: Record<string, A>] => {
-    const left: Record<string, A> = {}
-    const right: Record<string, A> = {}
-    for (const key of Object.keys(self)) {
+  <K extends string, A>(
+    self: ReadonlyRecord<K, A>,
+    predicate: (a: A, key: K) => boolean
+  ): [excluded: Record<ReadonlyRecord.NonLiteralKey<K>, A>, satisfying: Record<ReadonlyRecord.NonLiteralKey<K>, A>] => {
+    const left: Record<string, A> = empty()
+    const right: Record<string, A> = empty()
+    for (const key of keys(self)) {
       if (predicate(self[key], key)) {
         right[key] = self[key]
       } else {
@@ -793,7 +907,7 @@ export const partition: {
  *
  * @since 2.0.0
  */
-export const keys = <A>(self: ReadonlyRecord<A>): Array<string> => Object.keys(self)
+export const keys = <K extends string, A>(self: ReadonlyRecord<K, A>): Array<K> => Object.keys(self) as Array<K>
 
 /**
  * Retrieve the values of a given record as an array.
@@ -802,7 +916,7 @@ export const keys = <A>(self: ReadonlyRecord<A>): Array<string> => Object.keys(s
  *
  * @since 2.0.0
  */
-export const values = <A>(self: ReadonlyRecord<A>): Array<A> => collect(self, (_, a) => a)
+export const values = <K extends string, A>(self: ReadonlyRecord<K, A>): Array<A> => collect(self, (_, a) => a)
 
 /**
  * Add a new key-value pair or update an existing key's value in a record.
@@ -820,16 +934,29 @@ export const values = <A>(self: ReadonlyRecord<A>): Array<A> => collect(self, (_
  * @since 2.0.0
  */
 export const set: {
-  <B>(key: string, value: B): <A>(self: ReadonlyRecord<A>) => Record<string, A | B>
-  <A, B>(self: ReadonlyRecord<A>, key: string, value: B): Record<string, A | B>
-} = dual(3, <A, B>(self: ReadonlyRecord<A>, key: string, value: B): Record<string, A | B> => {
-  const out: Record<string, A | B> = { ...self }
-  out[key] = value
-  return out
-})
+  <K extends string, K1 extends K | ((string) & {}), B>(
+    key: K1,
+    value: B
+  ): <A>(self: ReadonlyRecord<K, A>) => Record<K | K1, A | B>
+  <K extends string, A, K1 extends K | ((string) & {}), B>(
+    self: ReadonlyRecord<K, A>,
+    key: K1,
+    value: B
+  ): Record<K | K1, A | B>
+} = dual(
+  3,
+  <K extends string, A, K1 extends K | ((string) & {}), B>(
+    self: ReadonlyRecord<K, A>,
+    key: K1,
+    value: B
+  ): Record<K | K1, A | B> => {
+    return { ...self, [key]: value } as any
+  }
+)
 
 /**
  * Replace a key's value in a record and return the updated record.
+ * If the key does not exist in the record, the original record is returned.
  *
  * @param self - The original record.
  * @param key - The key to replace.
@@ -845,15 +972,17 @@ export const set: {
  * @since 2.0.0
  */
 export const replace: {
-  <B>(key: string, value: B): <A>(self: ReadonlyRecord<A>) => Record<string, A | B>
-  <A, B>(self: ReadonlyRecord<A>, key: string, value: B): Record<string, A | B>
-} = dual(3, <A, B>(self: ReadonlyRecord<A>, key: string, value: B): Record<string, A | B> => {
-  const out: Record<string, A | B> = { ...self }
-  if (has(self, key)) {
-    out[key] = value
+  <K extends string, B>(key: NoInfer<K>, value: B): <A>(self: ReadonlyRecord<K, A>) => Record<K, A | B>
+  <K extends string, A, B>(self: ReadonlyRecord<K, A>, key: NoInfer<K>, value: B): Record<K, A | B>
+} = dual(
+  3,
+  <K extends string, A, B>(self: ReadonlyRecord<K, A>, key: NoInfer<K>, value: B): Record<K, A | B> => {
+    if (has(self, key)) {
+      return { ...self, [key]: value }
+    }
+    return { ...self }
   }
-  return out
-})
+)
 
 /**
  * Check if all the keys and values in one record are also found in another record.
@@ -865,11 +994,11 @@ export const replace: {
  * @since 2.0.0
  */
 export const isSubrecordBy = <A>(equivalence: Equivalence<A>): {
-  (that: ReadonlyRecord<A>): (self: ReadonlyRecord<A>) => boolean
-  (self: ReadonlyRecord<A>, that: ReadonlyRecord<A>): boolean
+  <K extends string>(that: ReadonlyRecord<K, A>): (self: ReadonlyRecord<K, A>) => boolean
+  <K extends string>(self: ReadonlyRecord<K, A>, that: ReadonlyRecord<K, A>): boolean
 } =>
-  dual(2, (self: ReadonlyRecord<A>, that: ReadonlyRecord<A>): boolean => {
-    for (const key in self) {
+  dual(2, <K extends string>(self: ReadonlyRecord<K, A>, that: ReadonlyRecord<K, A>): boolean => {
+    for (const key of keys(self)) {
       if (!has(that, key) || !equivalence(self[key], that[key])) {
         return false
       }
@@ -887,8 +1016,8 @@ export const isSubrecordBy = <A>(equivalence: Equivalence<A>): {
  * @since 2.0.0
  */
 export const isSubrecord: {
-  <A>(that: ReadonlyRecord<A>): (self: ReadonlyRecord<A>) => boolean
-  <A>(self: ReadonlyRecord<A>, that: ReadonlyRecord<A>): boolean
+  <K extends string, A>(that: ReadonlyRecord<K, A>): (self: ReadonlyRecord<K, A>) => boolean
+  <K extends string, A>(self: ReadonlyRecord<K, A>, that: ReadonlyRecord<K, A>): boolean
 } = isSubrecordBy(Equal.equivalence())
 
 /**
@@ -902,15 +1031,25 @@ export const isSubrecord: {
  * @since 2.0.0
  */
 export const reduce: {
-  <Z, V, K extends string>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: Record<K, V>) => Z
-  <K extends string, V, Z>(self: Record<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z
-} = dual(3, <V, Z>(self: Record<string, V>, zero: Z, f: (accumulator: Z, value: V, key: string) => Z): Z => {
-  let out: Z = zero
-  for (const key in self) {
-    out = f(out, self[key], key)
+  <Z, V, K extends string>(
+    zero: Z,
+    f: (accumulator: Z, value: V, key: K) => Z
+  ): (self: ReadonlyRecord<K, V>) => Z
+  <K extends string, V, Z>(self: ReadonlyRecord<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z
+} = dual(
+  3,
+  <K extends string, V, Z>(
+    self: ReadonlyRecord<K, V>,
+    zero: Z,
+    f: (accumulator: Z, value: V, key: K) => Z
+  ): Z => {
+    let out: Z = zero
+    for (const key of keys(self)) {
+      out = f(out, self[key], key)
+    }
+    return out
   }
-  return out
-})
+)
 
 /**
  * Check if all entries in a record meet a specific condition.
@@ -923,24 +1062,27 @@ export const reduce: {
 export const every: {
   <A, K extends string, B extends A>(
     refinement: (value: A, key: K) => value is B
-  ): (self: Record<K, A>) => self is Readonly<Record<K, B>>
-  <A, K extends string>(predicate: (value: A, key: K) => boolean): (self: Record<K, A>) => boolean
+  ): (self: ReadonlyRecord<K, A>) => self is ReadonlyRecord<K, B>
+  <A, K extends string>(predicate: (value: A, key: K) => boolean): (self: ReadonlyRecord<K, A>) => boolean
+  <A, K extends string, B extends A>(
+    self: ReadonlyRecord<K, A>,
+    refinement: (value: A, key: K) => value is B
+  ): self is ReadonlyRecord<K, B>
+  <K extends string, A>(self: ReadonlyRecord<K, A>, predicate: (value: A, key: K) => boolean): boolean
+} = dual(
+  2,
   <A, K extends string, B extends A>(
-    self: Record<K, A>,
+    self: ReadonlyRecord<K, A>,
     refinement: (value: A, key: K) => value is B
-  ): self is Readonly<Record<K, B>>
-  <K extends string, A>(self: Record<K, A>, predicate: (value: A, key: K) => boolean): boolean
-} = dual(2, <A, K extends string, B extends A>(
-  self: Record<K, A>,
-  refinement: (value: A, key: K) => value is B
-): self is Readonly<Record<K, A>> => {
-  for (const key in self) {
-    if (!refinement(self[key], key)) {
-      return false
+  ): self is ReadonlyRecord<K, B> => {
+    for (const key of keys(self)) {
+      if (!refinement(self[key], key)) {
+        return false
+      }
     }
+    return true
   }
-  return true
-})
+)
 
 /**
  * Check if any entry in a record meets a specific condition.
@@ -951,16 +1093,19 @@ export const every: {
  * @since 2.0.0
  */
 export const some: {
-  <A, K extends string>(predicate: (value: A, key: K) => boolean): (self: Record<K, A>) => boolean
-  <K extends string, A>(self: Record<K, A>, predicate: (value: A, key: K) => boolean): boolean
-} = dual(2, <K extends string, A>(self: Record<K, A>, predicate: (value: A, key: K) => boolean): boolean => {
-  for (const key in self) {
-    if (predicate(self[key], key)) {
-      return true
+  <A, K extends string>(predicate: (value: A, key: K) => boolean): (self: ReadonlyRecord<K, A>) => boolean
+  <K extends string, A>(self: ReadonlyRecord<K, A>, predicate: (value: A, key: K) => boolean): boolean
+} = dual(
+  2,
+  <K extends string, A>(self: ReadonlyRecord<K, A>, predicate: (value: A, key: K) => boolean): boolean => {
+    for (const key of keys(self)) {
+      if (predicate(self[key], key)) {
+        return true
+      }
     }
+    return false
   }
-  return false
-})
+)
 
 /**
  * Merge two records, preserving entries that exist in either of the records.
@@ -972,37 +1117,37 @@ export const some: {
  * @since 2.0.0
  */
 export const union: {
-  <K1 extends string, V0, V1>(
-    that: Record<K1, V1>,
-    combine: (selfValue: V0, thatValue: V1) => V0 | V1
-  ): <K0 extends string>(self: Record<K0, V0>) => Record<K0 | K1, V0 | V1>
-  <K0 extends string, V0, K1 extends string, V1>(
-    self: Record<K0, V0>,
-    that: Record<K1, V1>,
-    combine: (selfValue: V0, thatValue: V1) => V0 | V1
-  ): Record<K0 | K1, V0 | V1>
+  <K1 extends string, A, B, C>(
+    that: ReadonlyRecord<K1, B>,
+    combine: (selfValue: A, thatValue: B) => C
+  ): <K0 extends string>(self: ReadonlyRecord<K0, A>) => Record<K0 | K1, A | B | C>
+  <K0 extends string, A, K1 extends string, B, C>(
+    self: ReadonlyRecord<K0, A>,
+    that: ReadonlyRecord<K1, B>,
+    combine: (selfValue: A, thatValue: B) => C
+  ): Record<K0 | K1, A | B | C>
 } = dual(
   3,
-  <A>(
-    self: Record<string, A>,
-    that: Record<string, A>,
-    combine: (selfValue: A, thatValue: A) => A
-  ): Record<string, A> => {
+  <K0 extends string, A, K1 extends string, B, C>(
+    self: ReadonlyRecord<K0, A>,
+    that: ReadonlyRecord<K1, B>,
+    combine: (selfValue: A, thatValue: B) => C
+  ): Record<K0 | K1, A | B | C> => {
     if (isEmptyRecord(self)) {
-      return { ...that }
+      return { ...that } as any
     }
     if (isEmptyRecord(that)) {
-      return { ...self }
+      return { ...self } as any
     }
-    const out: Record<string, A> = {}
-    for (const key in self) {
-      if (has(that, key)) {
-        out[key] = combine(self[key], that[key])
+    const out: Record<string, A | B | C> = empty()
+    for (const key of keys(self)) {
+      if (has(that, key as any)) {
+        out[key] = combine(self[key], that[key as unknown as K1])
       } else {
         out[key] = self[key]
       }
     }
-    for (const key in that) {
+    for (const key of keys(that)) {
       if (!has(out, key)) {
         out[key] = that[key]
       }
@@ -1021,25 +1166,29 @@ export const union: {
  * @since 2.0.0
  */
 export const intersection: {
-  <A>(
-    that: ReadonlyRecord<A>,
-    combine: (selfValue: A, thatValue: A) => A
-  ): (self: ReadonlyRecord<A>) => Record<string, A>
-  <A>(self: ReadonlyRecord<A>, that: ReadonlyRecord<A>, combine: (selfValue: A, thatValue: A) => A): Record<string, A>
+  <K1 extends string, A, B, C>(
+    that: ReadonlyRecord<K1, B>,
+    combine: (selfValue: A, thatValue: B) => C
+  ): <K0 extends string>(self: ReadonlyRecord<K0, A>) => Record<ReadonlyRecord.IntersectKeys<K0, K1>, C>
+  <K0 extends string, A, K1 extends string, B, C>(
+    self: ReadonlyRecord<K0, A>,
+    that: ReadonlyRecord<K1, B>,
+    combine: (selfValue: A, thatValue: B) => C
+  ): Record<ReadonlyRecord.IntersectKeys<K0, K1>, C>
 } = dual(
   3,
-  <A>(
-    self: ReadonlyRecord<A>,
-    that: ReadonlyRecord<A>,
-    combine: (selfValue: A, thatValue: A) => A
-  ): Record<string, A> => {
+  <K0 extends string, A, K1 extends string, B, C>(
+    self: ReadonlyRecord<K0, A>,
+    that: ReadonlyRecord<K1, B>,
+    combine: (selfValue: A, thatValue: B) => C
+  ): Record<ReadonlyRecord.IntersectKeys<K0, K1>, C> => {
+    const out: Record<string, C> = empty()
     if (isEmptyRecord(self) || isEmptyRecord(that)) {
-      return empty()
+      return out
     }
-    const out: Record<string, A> = {}
-    for (const key in self) {
-      if (has(that, key)) {
-        out[key] = combine(self[key], that[key])
+    for (const key of keys(self)) {
+      if (has(that, key as any)) {
+        out[key] = combine(self[key], that[key as unknown as K1])
       }
     }
     return out
@@ -1055,25 +1204,31 @@ export const intersection: {
  * @since 2.0.0
  */
 export const difference: {
-  <A>(
-    that: ReadonlyRecord<A>
-  ): (self: ReadonlyRecord<A>) => Record<string, A>
-  <A>(self: ReadonlyRecord<A>, that: ReadonlyRecord<A>): Record<string, A>
-} = dual(2, <A>(self: ReadonlyRecord<A>, that: ReadonlyRecord<A>): Record<string, A> => {
+  <K1 extends string, B>(
+    that: ReadonlyRecord<K1, B>
+  ): <K0 extends string, A>(self: ReadonlyRecord<K0, A>) => Record<K0 | K1, A | B>
+  <K0 extends string, A, K1 extends string, B>(
+    self: ReadonlyRecord<K0, A>,
+    that: ReadonlyRecord<K1, B>
+  ): Record<K0 | K1, A | B>
+} = dual(2, <K0 extends string, A, K1 extends string, B>(
+  self: ReadonlyRecord<K0, A>,
+  that: ReadonlyRecord<K1, B>
+): Record<K0 | K1, A | B> => {
   if (isEmptyRecord(self)) {
-    return { ...that }
+    return { ...that } as any
   }
   if (isEmptyRecord(that)) {
-    return { ...self }
+    return { ...self } as any
   }
-  const out: Record<string, A> = {}
-  for (const key in self) {
-    if (!has(that, key)) {
+  const out = <Record<K0 | K1, A | B>> {}
+  for (const key of keys(self)) {
+    if (!has(that, key as any)) {
       out[key] = self[key]
     }
   }
-  for (const key in that) {
-    if (!has(self, key)) {
+  for (const key of keys(that)) {
+    if (!has(self, key as any)) {
       out[key] = that[key]
     }
   }
@@ -1088,7 +1243,9 @@ export const difference: {
  * @category instances
  * @since 2.0.0
  */
-export const getEquivalence = <A>(equivalence: Equivalence<A>): Equivalence<ReadonlyRecord<A>> => {
+export const getEquivalence = <K extends string, A>(
+  equivalence: Equivalence<A>
+): Equivalence<ReadonlyRecord<K, A>> => {
   const is = isSubrecordBy(equivalence)
   return (self, that) => is(self, that) && is(that, self)
 }
@@ -1102,6 +1259,6 @@ export const getEquivalence = <A>(equivalence: Equivalence<A>): Equivalence<Read
  * @category constructors
  * @since 2.0.0
  */
-export const singleton = <K extends string, A>(key: K, value: A): Record<K, A> => (({
+export const singleton = <K extends string, A>(key: K, value: A): Record<K, A> => ({
   [key]: value
-}) as Record<K, A>)
+} as any)
diff --git a/packages/effect/test/ReadonlyRecord.test.ts b/packages/effect/test/ReadonlyRecord.test.ts
index 6997c0c33a..4489700bd7 100644
--- a/packages/effect/test/ReadonlyRecord.test.ts
+++ b/packages/effect/test/ReadonlyRecord.test.ts
@@ -5,58 +5,65 @@ import * as Option from "effect/Option"
 import * as RR from "effect/ReadonlyRecord"
 import { assert, describe, expect, it } from "vitest"
 
+const symA = Symbol.for("a")
+const symB = Symbol.for("b")
+
 describe("ReadonlyRecord", () => {
   it("get", () => {
-    expect(pipe({}, RR.get("a"))).toEqual(Option.none())
+    expect(pipe(RR.empty<string>(), RR.get("a"))).toEqual(Option.none())
     expect(pipe({ a: 1 }, RR.get("a"))).toEqual(Option.some(1))
   })
 
+  it("replaceOption", () => {
+    expect(pipe(RR.empty<string>(), RR.replaceOption("a", 2))).toEqual(Option.none())
+    expect(pipe({ a: 1, [symA]: null }, RR.replaceOption("a", 2))).toEqual(Option.some({ a: 2, [symA]: null }))
+    expect(pipe({ a: 1, [symA]: null }, RR.replaceOption("a", true))).toEqual(Option.some({ a: true, [symA]: null }))
+  })
+
   it("modify", () => {
-    expect(pipe({}, RR.modify("a", (n: number) => n + 1))).toEqual({})
-    expect(pipe({ a: 1 }, RR.modify("a", (n: number) => n + 1))).toEqual({ a: 2 })
-    expect(pipe({ a: 1 }, RR.modify("a", (n: number) => String(n)))).toEqual(
-      { a: "1" }
+    expect(pipe(RR.empty<string>(), RR.modify("a", (n: number) => n + 1))).toEqual({})
+    expect(pipe({ a: 1, [symA]: null }, RR.modify("a", (n: number) => n + 1))).toEqual({ a: 2, [symA]: null })
+    expect(pipe({ a: 1, [symA]: null }, RR.modify("a", (n: number) => String(n)))).toEqual(
+      { a: "1", [symA]: null }
     )
   })
 
   it("modifyOption", () => {
-    expect(pipe({}, RR.modifyOption("a", (n: number) => n + 1))).toEqual(Option.none())
-    expect(pipe({ a: 1 }, RR.modifyOption("a", (n: number) => n + 1))).toEqual(Option.some({ a: 2 }))
-    expect(pipe({ a: 1 }, RR.modifyOption("a", (n: number) => String(n)))).toEqual(
-      Option.some({ a: "1" })
+    expect(pipe(RR.empty<string>(), RR.modifyOption("a", (n) => n + 1))).toEqual(Option.none())
+    expect(pipe({ a: 1, [symA]: null }, RR.modifyOption("a", (n: number) => n + 1))).toEqual(
+      Option.some({ a: 2, [symA]: null })
+    )
+    expect(pipe({ a: 1, [symA]: null }, RR.modifyOption("a", (n: number) => String(n)))).toEqual(
+      Option.some({ a: "1", [symA]: null })
     )
   })
 
   it("replaceOption", () => {
-    expect(pipe({}, RR.replaceOption("a", 2))).toEqual(Option.none())
-    expect(pipe({ a: 1 }, RR.replaceOption("a", 2))).toEqual(Option.some({ a: 2 }))
-    expect(pipe({ a: 1 }, RR.replaceOption("a", true))).toEqual(Option.some({ a: true }))
+    expect(pipe(RR.empty<string>(), RR.replaceOption("a", 2))).toEqual(Option.none())
+    expect(pipe({ a: 1, [symA]: null }, RR.replaceOption("a", 2))).toEqual(Option.some({ a: 2, [symA]: null }))
+    expect(pipe({ a: 1, [symA]: null }, RR.replaceOption("a", true))).toEqual(Option.some({ a: true, [symA]: null }))
   })
 
   it("map", () => {
-    expect(pipe({ a: 1, b: 2 }, RR.map((n) => n * 2))).toEqual({ a: 2, b: 4 })
-    expect(pipe({ a: 1, b: 2 }, RR.map((n, k) => `${k}-${n}`))).toEqual({
-      a: "a-1",
-      b: "b-2"
+    expect(pipe({ a: 1, b: 2, [symA]: null } as Record<string, number>, RR.map((n) => n * 2))).toEqual({
+      a: 2,
+      b: 4,
+      [symA]: null
     })
-  })
-
-  it("fromIterable", () => {
-    const input = [["1", 2], ["2", 4], ["3", 6], ["4", 8]] as const
-    expect(RR.fromIterable(input)).toEqual({
-      "1": 2,
-      "2": 4,
-      "3": 6,
-      "4": 8
+    expect(pipe({ a: 1, b: 2, [symA]: null }, RR.map((n, k) => `${k}-${n}`))).toEqual({
+      a: "a-1",
+      b: "b-2",
+      [symA]: null
     })
+    expect(pipe({ [symA]: 1, [symB]: 2 }, RR.map((n) => n * 2))).toEqual({ [symA]: 1, [symB]: 2 })
   })
 
   it("fromIterableWith", () => {
     const input = [1, 2, 3, 4]
-    expect(RR.fromIterableWith(input, (a) => [String(a), a * 2])).toEqual({
+    expect(RR.fromIterableWith(input, (a) => [a === 3 ? "a" : String(a), a * 2])).toEqual({
       "1": 2,
       "2": 4,
-      "3": 6,
+      a: 6,
       "4": 8
     })
   })
@@ -73,35 +80,44 @@ describe("ReadonlyRecord", () => {
   })
 
   it("fromEntries", () => {
-    const input: Array<[string, number]> = [["a", 1], ["b", 2]]
-    expect(RR.fromEntries(input)).toEqual({ a: 1, b: 2 })
+    const input = [["1", 2], ["2", 4], ["3", 6], ["4", 8]] as const
+    expect(RR.fromEntries(input)).toEqual({
+      "1": 2,
+      "2": 4,
+      "3": 6,
+      "4": 8
+    })
   })
 
   it("collect", () => {
-    const x = { a: 1, b: 2, c: 3 }
+    const x = { a: 1, b: 2, c: 3, [symA]: null }
     assert.deepStrictEqual(RR.collect(x, (key, n) => [key, n]), [["a", 1], ["b", 2], ["c", 3]])
   })
 
   it("toEntries", () => {
-    const x = { a: 1, b: 2, c: 3 }
+    const x = { a: 1, b: 2, c: 3, [symA]: null }
     assert.deepStrictEqual(RR.toEntries(x), [["a", 1], ["b", 2], ["c", 3]])
   })
 
   it("remove", () => {
-    assert.deepStrictEqual(RR.remove({ a: 1, b: 2 }, "a"), { b: 2 })
-    assert.deepStrictEqual(RR.remove({ a: 1, b: 2 }, "c"), { a: 1, b: 2 })
+    assert.deepStrictEqual(RR.remove({ a: 1, b: 2, [symA]: null }, "a"), { b: 2, [symA]: null })
+    assert.deepStrictEqual(RR.remove({ a: 1, b: 2, [symA]: null } as Record<string, number>, "c"), {
+      a: 1,
+      b: 2,
+      [symA]: null
+    })
   })
 
   describe("pop", () => {
     it("should return the value associated with the given key, if the key is present in the record", () => {
-      const record = { a: 1, b: 2 }
-      const result = RR.pop("a")(record)
+      const record = { a: 1, b: 2, [symA]: null }
+      const result = RR.pop(record, "a")
 
-      assert.deepStrictEqual(result, Option.some([1, { b: 2 }] as [number, Record<string, number>]))
+      assert.deepStrictEqual(result, Option.some([1, { b: 2, [symA]: null }] as [number, Record<string, number>]))
     })
 
     it("should return none if the key is not present in the record", () => {
-      const record = { a: 1, b: 2 }
+      const record = { a: 1, b: 2, [symA]: null }
       const result = RR.pop("c")(record)
 
       assert.deepStrictEqual(result, Option.none())
@@ -110,41 +126,41 @@ describe("ReadonlyRecord", () => {
 
   describe("filterMap", () => {
     it("should filter the properties of an object", () => {
-      const obj = { a: 1, b: 2, c: 3 }
-      const filtered = RR.filterMap(obj, (value, key) => (value > 2 ? Option.some(key) : Option.none()))
+      const x: Record<string, number> = { a: 1, b: 2, c: 3, [symA]: null }
+      const filtered = RR.filterMap(x, (value, key) => (value > 2 ? Option.some(key) : Option.none()))
       expect(filtered).toEqual({ c: "c" })
     })
   })
 
-  it("compact", () => {
-    const x = { a: Option.some(1), b: Option.none(), c: Option.some(2) }
+  it("getSomes", () => {
+    const x = { a: Option.some(1), b: Option.none(), c: Option.some(2), [symA]: null }
     assert.deepStrictEqual(RR.getSomes(x), { a: 1, c: 2 })
   })
 
   it("filter", () => {
-    const x = { a: 1, b: 2, c: 3, d: 4 }
+    const x: Record<string, number> = { a: 1, b: 2, c: 3, d: 4, [symA]: null }
     assert.deepStrictEqual(RR.filter(x, (value) => value > 2), { c: 3, d: 4 })
   })
 
   it("partitionMap", () => {
     const f = (n: number) => (n > 2 ? Either.right(n + 1) : Either.left(n - 1))
     assert.deepStrictEqual(RR.partitionMap({}, f), [{}, {}])
-    assert.deepStrictEqual(RR.partitionMap({ a: 1, b: 3 }, f), [{ a: 0 }, { b: 4 }])
+    assert.deepStrictEqual(RR.partitionMap({ a: 1, b: 3, [symA]: null }, f), [{ a: 0 }, { b: 4 }])
   })
 
   it("partition", () => {
     const f = (n: number) => n > 2
     assert.deepStrictEqual(RR.partition({}, f), [{}, {}])
-    assert.deepStrictEqual(RR.partition({ a: 1, b: 3 }, f), [{ a: 1 }, { b: 3 }])
+    assert.deepStrictEqual(RR.partition({ a: 1, b: 3, [symA]: null }, f), [{ a: 1 }, { b: 3 }])
   })
 
   it("separate", () => {
     assert.deepStrictEqual(
-      RR.separate({ a: Either.left("e"), b: Either.right(1) }),
+      RR.separate({ a: Either.left("e"), b: Either.right(1), [symA]: null }),
       [{ a: "e" }, { b: 1 }]
     )
     // should ignore non own properties
-    const o: RR.ReadonlyRecord<Either.Either<number, string>> = Object.create({ a: 1 })
+    const o: RR.ReadonlyRecord<"a", Either.Either<number, string>> = Object.create({ a: 1 })
     assert.deepStrictEqual(pipe(o, RR.separate), [{}, {}])
   })
 
@@ -154,85 +170,95 @@ describe("ReadonlyRecord", () => {
 
   it("isEmptyRecord", () => {
     assert.deepStrictEqual(RR.isEmptyRecord({}), true)
+    assert.deepStrictEqual(RR.isEmptyRecord({ [symA]: null }), true)
     assert.deepStrictEqual(RR.isEmptyRecord({ a: 3 }), false)
   })
 
   it("isEmptyReadonlyRecord", () => {
     assert.deepStrictEqual(RR.isEmptyReadonlyRecord({}), true)
+    assert.deepStrictEqual(RR.isEmptyReadonlyRecord({ [symA]: null }), true)
     assert.deepStrictEqual(RR.isEmptyReadonlyRecord({ a: 3 }), false)
   })
 
   it("size", () => {
-    assert.deepStrictEqual(RR.size({ a: "a", b: 1, c: true }), 3)
+    assert.deepStrictEqual(RR.size({ a: "a", b: 1, c: true, [symA]: null }), 3)
   })
 
   it("has", () => {
-    assert.deepStrictEqual(RR.has({ a: 1, b: 2 }, "a"), true)
-    assert.deepStrictEqual(RR.has({ a: 1, b: 2 }, "c"), false)
+    assert.deepStrictEqual(RR.has({ a: 1, b: 2, [symA]: null }, "a"), true)
+    assert.deepStrictEqual(RR.has({ a: 1, b: 2, [symA]: null } as Record<string, number>, "c"), false)
   })
 
   it("keys", () => {
-    assert.deepStrictEqual(RR.keys({ a: 1, b: 2 }), ["a", "b"])
+    assert.deepStrictEqual(RR.keys({ a: 1, b: 2, [symA]: null }), ["a", "b"])
   })
 
   it("values", () => {
-    assert.deepStrictEqual(RR.values({ a: 1, b: 2 }), [1, 2])
+    assert.deepStrictEqual(RR.values({ a: 1, b: 2, [symA]: null }), [1, 2])
   })
 
   it("set", () => {
-    assert.deepStrictEqual(RR.set({ a: 1, b: 2 }, "c", 3), { a: 1, b: 2, c: 3 })
-    assert.deepStrictEqual(RR.set({ a: 1, b: 2 }, "a", 3), { a: 3, b: 2 })
+    assert.deepStrictEqual(RR.set({ a: 1, b: 2, [symA]: null }, "c", 3), { a: 1, b: 2, c: 3, [symA]: null })
+    assert.deepStrictEqual(RR.set({ a: 1, b: 2, [symA]: null }, "a", 3), { a: 3, b: 2, [symA]: null })
   })
 
   it("replace", () => {
-    expect(RR.replace({ a: 1, b: 2 }, "c", 3)).toStrictEqual({ a: 1, b: 2 })
-    expect(RR.replace({ a: 1, b: 2 }, "a", 3)).toStrictEqual({ a: 3, b: 2 })
+    expect(RR.replace({ a: 1, b: 2, [symA]: null } as Record<string, number>, "c", 3)).toStrictEqual({
+      a: 1,
+      b: 2,
+      [symA]: null
+    })
+    expect(RR.replace({ a: 1, b: 2, [symA]: null }, "a", 3)).toStrictEqual({ a: 3, b: 2, [symA]: null })
   })
 
   it("isSubrecord", () => {
-    expect(RR.isSubrecord({}, {})).toBe(true)
-    expect(RR.isSubrecord({}, { a: 1 })).toBe(true)
+    expect(RR.isSubrecord(RR.empty(), {})).toBe(true)
+    expect(RR.isSubrecord(RR.empty<string>(), { a: 1 })).toBe(true)
     expect(RR.isSubrecord({ a: 1 }, { a: 1 })).toBe(true)
-    expect(RR.isSubrecord({ a: 1 }, { a: 1, b: 2 })).toBe(true)
+    expect(RR.isSubrecord({ a: 1, [symA]: null }, { a: 1 })).toBe(true)
+    expect(RR.isSubrecord({ a: 1 }, { a: 1, [symA]: null })).toBe(true)
+    expect(RR.isSubrecord({ a: 1 } as Record<string, number>, { a: 1, b: 2 })).toBe(true)
     expect(RR.isSubrecord({ b: 2, a: 1 }, { a: 1, b: 2 })).toBe(true)
     expect(RR.isSubrecord({ a: 1 }, { a: 2 })).toBe(false)
-    expect(RR.isSubrecord({ b: 2 }, { a: 1 })).toBe(false)
+    expect(RR.isSubrecord({ b: 2 } as Record<string, number>, { a: 1 })).toBe(false)
   })
 
   it("reduce", () => {
     // data-first
     assert.deepStrictEqual(
-      RR.reduce({ k1: "a", k2: "b" }, "-", (accumulator, value, key) => accumulator + key + value),
+      RR.reduce({ k1: "a", k2: "b", [symA]: null }, "-", (accumulator, value, key) => accumulator + key + value),
       "-k1ak2b"
     )
     // data-last
     assert.deepStrictEqual(
-      pipe({ k1: "a", k2: "b" }, RR.reduce("-", (accumulator, value, key) => accumulator + key + value)),
+      pipe({ k1: "a", k2: "b", [symA]: null }, RR.reduce("-", (accumulator, value, key) => accumulator + key + value)),
       "-k1ak2b"
     )
   })
 
   it("every", () => {
-    assert.deepStrictEqual(RR.every((n: number) => n <= 2)({ a: 1, b: 2 }), true)
-    assert.deepStrictEqual(RR.every((n: number) => n <= 1)({ a: 1, b: 2 }), false)
+    assert.deepStrictEqual(RR.every((n: number) => n <= 2)({ a: 1, b: 2, [symA]: null }), true)
+    assert.deepStrictEqual(RR.every((n: number) => n <= 1)({ a: 1, b: 2, [symA]: null }), false)
   })
 
   it("some", () => {
-    assert.deepStrictEqual(RR.some((n: number) => n <= 1)({ a: 1, b: 2 }), true)
-    assert.deepStrictEqual(RR.some((n: number) => n <= 0)({ a: 1, b: 2 }), false)
+    assert.deepStrictEqual(RR.some((n: number) => n <= 1)({ a: 1, b: 2, [symA]: null }), true)
+    assert.deepStrictEqual(RR.some((n: number) => n <= 0)({ a: 1, b: 2, [symA]: null }), false)
   })
 
   it("union", () => {
     const combine = (s1: string, s2: string) => s1 + s2
-    const x: RR.ReadonlyRecord<string> = {
+    const x: RR.ReadonlyRecord<string, string> = {
       a: "a1",
       b: "b1",
-      c: "c1"
+      c: "c1",
+      [symA]: null
     }
-    const y: RR.ReadonlyRecord<string> = {
+    const y: RR.ReadonlyRecord<string, string> = {
       b: "b2",
       c: "c2",
-      d: "d2"
+      d: "d2",
+      [symA]: null
     }
     assert.deepStrictEqual(RR.union(x, {}, combine), x)
     assert.deepStrictEqual(RR.union({}, x, combine), x)
@@ -248,15 +274,17 @@ describe("ReadonlyRecord", () => {
 
   it("intersection", () => {
     const combine = (s1: string, s2: string) => s1 + s2
-    const x: RR.ReadonlyRecord<string> = {
+    const x: RR.ReadonlyRecord<string, string> = {
       a: "a1",
       b: "b1",
-      c: "c1"
+      c: "c1",
+      [symA]: null
     }
-    const y: RR.ReadonlyRecord<string> = {
+    const y: RR.ReadonlyRecord<string, string> = {
       b: "b2",
       c: "c2",
-      d: "d2"
+      d: "d2",
+      [symA]: null
     }
     assert.deepStrictEqual(RR.intersection(x, {}, combine), {})
     assert.deepStrictEqual(RR.intersection({}, y, combine), {})
@@ -267,15 +295,17 @@ describe("ReadonlyRecord", () => {
   })
 
   it("difference", () => {
-    const x: RR.ReadonlyRecord<string> = {
+    const x: RR.ReadonlyRecord<string, string> = {
       a: "a1",
       b: "b1",
-      c: "c1"
+      c: "c1",
+      [symA]: null
     }
-    const y: RR.ReadonlyRecord<string> = {
+    const y: RR.ReadonlyRecord<string, string> = {
       b: "b2",
       c: "c2",
-      d: "d2"
+      d: "d2",
+      [symA]: null
     }
     assert.deepStrictEqual(RR.difference({}, x), x)
     assert.deepStrictEqual(RR.difference(x, {}), x)
@@ -289,6 +319,7 @@ describe("ReadonlyRecord", () => {
 
   it("getEquivalence", () => {
     assert.deepStrictEqual(RR.getEquivalence(N.Equivalence)({ a: 1 }, { a: 1 }), true)
+    assert.deepStrictEqual(RR.getEquivalence(N.Equivalence)({ a: 1 }, { a: 1, [symA]: null }), true)
     assert.deepStrictEqual(RR.getEquivalence(N.Equivalence)({ a: 1 }, { a: 2 }), false)
     assert.deepStrictEqual(RR.getEquivalence(N.Equivalence)({ a: 1 }, { b: 1 }), false)
     const noPrototype = Object.create(null)
@@ -300,12 +331,21 @@ describe("ReadonlyRecord", () => {
   })
 
   it("mapKeys", () => {
-    expect(pipe({ a: 1, b: 2 }, RR.mapKeys((key) => key.toUpperCase()))).toStrictEqual({ A: 1, B: 2 })
-    expect(RR.mapKeys({ a: 1, b: 2 }, (k) => k.toUpperCase())).toStrictEqual({ A: 1, B: 2 })
+    expect(pipe({ a: 1, b: 2, [symA]: null }, RR.mapKeys((key) => key.toUpperCase()))).toStrictEqual({
+      A: 1,
+      B: 2
+    })
   })
 
   it("mapEntries", () => {
-    expect(pipe({ a: 1, b: 2 }, RR.mapEntries((a, key) => [key.toUpperCase(), a + 1]))).toStrictEqual({ A: 2, B: 3 })
-    expect(RR.mapEntries({ a: 1, b: 2 }, (a, k) => [k.toUpperCase(), a + 1])).toStrictEqual({ A: 2, B: 3 })
+    expect(
+      pipe(
+        { a: 1, b: 2, [symA]: null } as Record<string, number>,
+        RR.mapEntries((a, key) => [key.toUpperCase(), a + 1])
+      )
+    ).toStrictEqual({
+      A: 2,
+      B: 3
+    })
   })
 })
diff --git a/packages/platform/src/Http/Headers.ts b/packages/platform/src/Http/Headers.ts
index c819302b4f..bb2cd6f700 100644
--- a/packages/platform/src/Http/Headers.ts
+++ b/packages/platform/src/Http/Headers.ts
@@ -1,7 +1,6 @@
 /**
  * @since 1.0.0
  */
-import type * as Brand from "effect/Brand"
 import { dual } from "effect/Function"
 import type * as Option from "effect/Option"
 import * as ReadonlyArray from "effect/ReadonlyArray"
@@ -24,13 +23,16 @@ export type HeadersTypeId = typeof HeadersTypeId
  * @since 1.0.0
  * @category models
  */
-export type Headers = Brand.Branded<ReadonlyRecord.ReadonlyRecord<string>, HeadersTypeId>
+export interface Headers {
+  readonly [HeadersTypeId]: HeadersTypeId
+  readonly [key: string]: string
+}
 
 /**
  * @since 1.0.0
  * @category models
  */
-export type Input = ReadonlyRecord.ReadonlyRecord<string> | Iterable<readonly [string, string]>
+export type Input = ReadonlyRecord.ReadonlyRecord<string, string> | Iterable<readonly [string, string]>
 
 /**
  * @since 1.0.0
@@ -60,7 +62,7 @@ export const fromInput: (input?: Input) => Headers = (input) => {
  * @since 1.0.0
  * @category constructors
  */
-export const unsafeFromRecord = (input: ReadonlyRecord.ReadonlyRecord<string>): Headers => input as Headers
+export const unsafeFromRecord = (input: ReadonlyRecord.ReadonlyRecord<string, string>): Headers => input as Headers
 
 /**
  * @since 1.0.0
@@ -72,7 +74,7 @@ export const has: {
 } = dual<
   (key: string) => (self: Headers) => boolean,
   (self: Headers, key: string) => boolean
->(2, (self, key) => ReadonlyRecord.has(self, key.toLowerCase()))
+>(2, (self, key) => ReadonlyRecord.has(self as Record<string, string>, key.toLowerCase()))
 
 /**
  * @since 1.0.0
@@ -84,7 +86,7 @@ export const get: {
 } = dual<
   (key: string) => (self: Headers) => Option.Option<string>,
   (self: Headers, key: string) => Option.Option<string>
->(2, (self, key) => ReadonlyRecord.get(self, key.toLowerCase()))
+>(2, (self, key) => ReadonlyRecord.get(self as Record<string, string>, key.toLowerCase()))
 
 /**
  * @since 1.0.0
diff --git a/packages/rpc/src/Rpc.ts b/packages/rpc/src/Rpc.ts
index 32cd73c100..17b4b4aad8 100644
--- a/packages/rpc/src/Rpc.ts
+++ b/packages/rpc/src/Rpc.ts
@@ -309,7 +309,7 @@ export const annotateHeaders: {
  * @since 1.0.0
  * @category headers
  */
-export const schemaHeaders = <R, I extends ReadonlyRecord.ReadonlyRecord<string | undefined>, A>(
+export const schemaHeaders = <R, I extends ReadonlyRecord.ReadonlyRecord<string, string | undefined>, A>(
   schema: Schema.Schema<R, I, A>
 ): Effect.Effect<R, ParseResult.ParseError, A> => {
   const decode = Schema.decodeUnknown(schema)
diff --git a/packages/typeclass/src/data/ReadonlyRecord.ts b/packages/typeclass/src/data/ReadonlyRecord.ts
index 4be5c16ca1..be3f8ad8bf 100644
--- a/packages/typeclass/src/data/ReadonlyRecord.ts
+++ b/packages/typeclass/src/data/ReadonlyRecord.ts
@@ -13,27 +13,20 @@ import type * as invariant from "../Invariant.js"
 import type * as traversable from "../Traversable.js"
 import type * as traversableFilterable from "../TraversableFilterable.js"
 
-const map = ReadonlyRecord.map
-
-const imap = covariant.imap<ReadonlyRecord.ReadonlyRecordTypeLambda>(map)
-
-const partitionMap = ReadonlyRecord.partitionMap
-
-const filterMap = ReadonlyRecord.filterMap
-
-const traverse = <F extends TypeLambda>(F: applicative.Applicative<F>): {
+/** @internal */
+export const traverse = <F extends TypeLambda>(F: applicative.Applicative<F>): {
   <K extends string, A, R, O, E, B>(
     f: (a: A, key: K) => Kind<F, R, O, E, B>
-  ): (self: Record<K, A>) => Kind<F, R, O, E, Record<string, B>>
+  ): (self: Record<K, A>) => Kind<F, R, O, E, Record<K, B>>
   <K extends string, A, R, O, E, B>(
     self: Record<K, A>,
     f: (a: A, key: K) => Kind<F, R, O, E, B>
-  ): Kind<F, R, O, E, Record<string, B>>
+  ): Kind<F, R, O, E, Record<K, B>>
 } =>
-  dual(2, <A, R, O, E, B>(
+  dual(2, <K extends string, A, R, O, E, B>(
     self: Record<string, A>,
     f: (a: A, key: string) => Kind<F, R, O, E, B>
-  ): Kind<F, R, O, E, Record<string, B>> =>
+  ): Kind<F, R, O, E, Record<K, B>> =>
     F.map(
       F.productAll(
         Object.entries(self).map(([key, a]) => F.map(f(a, key), (b) => [key, b] as const))
@@ -46,18 +39,45 @@ const traversePartitionMap = <F extends TypeLambda>(
 ): {
   <A, R, O, E, B, C>(
     f: (a: A) => Kind<F, R, O, E, Either<C, B>>
-  ): (
-    self: ReadonlyRecord.ReadonlyRecord<A>
-  ) => Kind<F, R, O, E, [Record<string, B>, Record<string, C>]>
-  <A, R, O, E, B, C>(
-    self: ReadonlyRecord.ReadonlyRecord<A>,
+  ): <K extends string>(
+    self: ReadonlyRecord.ReadonlyRecord<K, A>
+  ) => Kind<
+    F,
+    R,
+    O,
+    E,
+    [
+      Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, B>,
+      Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, C>
+    ]
+  >
+  <K extends string, A, R, O, E, B, C>(
+    self: ReadonlyRecord.ReadonlyRecord<K, A>,
     f: (a: A) => Kind<F, R, O, E, Either<C, B>>
-  ): Kind<F, R, O, E, [Record<string, B>, Record<string, C>]>
+  ): Kind<
+    F,
+    R,
+    O,
+    E,
+    [
+      Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, B>,
+      Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, C>
+    ]
+  >
 } =>
-  dual(2, <A, R, O, E, B, C>(
-    self: ReadonlyRecord.ReadonlyRecord<A>,
+  dual(2, <K extends string, A, R, O, E, B, C>(
+    self: ReadonlyRecord.ReadonlyRecord<K, A>,
     f: (a: A) => Kind<F, R, O, E, Either<C, B>>
-  ): Kind<F, R, O, E, [Record<string, B>, Record<string, C>]> => {
+  ): Kind<
+    F,
+    R,
+    O,
+    E,
+    [
+      Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, B>,
+      Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, C>
+    ]
+  > => {
     return F.map(traverse(F)(self, f), ReadonlyRecord.separate)
   })
 
@@ -66,60 +86,120 @@ const traverseFilterMap = <F extends TypeLambda>(
 ): {
   <A, R, O, E, B>(
     f: (a: A) => Kind<F, R, O, E, Option<B>>
-  ): (self: ReadonlyRecord.ReadonlyRecord<A>) => Kind<F, R, O, E, Record<string, B>>
-  <A, R, O, E, B>(
-    self: ReadonlyRecord.ReadonlyRecord<A>,
+  ): <K extends string>(
+    self: ReadonlyRecord.ReadonlyRecord<K, A>
+  ) => Kind<F, R, O, E, Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, B>>
+  <K extends string, A, R, O, E, B>(
+    self: ReadonlyRecord.ReadonlyRecord<K, A>,
     f: (a: A) => Kind<F, R, O, E, Option<B>>
-  ): Kind<F, R, O, E, Record<string, B>>
+  ): Kind<F, R, O, E, Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, B>>
 } =>
-  dual(2, <A, R, O, E, B>(
-    self: ReadonlyRecord.ReadonlyRecord<A>,
+  dual(2, <K extends string, A, R, O, E, B>(
+    self: ReadonlyRecord.ReadonlyRecord<K, A>,
     f: (a: A) => Kind<F, R, O, E, Option<B>>
-  ): Kind<F, R, O, E, Record<string, B>> => {
+  ): Kind<F, R, O, E, Record<ReadonlyRecord.ReadonlyRecord.NonLiteralKey<K>, B>> => {
     return F.map(traverse(F)(self, f), ReadonlyRecord.getSomes)
   })
 
+const _map: covariant.Covariant<ReadonlyRecord.ReadonlyRecordTypeLambda<any>>["map"] = ReadonlyRecord.map
+
+const _imap = covariant.imap<ReadonlyRecord.ReadonlyRecordTypeLambda<any>>(_map)
+
+const _partitionMap: filterable.Filterable<ReadonlyRecord.ReadonlyRecordTypeLambda<any>>["partitionMap"] =
+  ReadonlyRecord.partitionMap
+
+const _filterMap: filterable.Filterable<ReadonlyRecord.ReadonlyRecordTypeLambda<any>>["filterMap"] =
+  ReadonlyRecord.filterMap
+
+const _traverse: traversable.Traversable<ReadonlyRecord.ReadonlyRecordTypeLambda<any>>["traverse"] = traverse
+
+const _traversePartitionMap: traversableFilterable.TraversableFilterable<
+  ReadonlyRecord.ReadonlyRecordTypeLambda<any>
+>["traversePartitionMap"] = traversePartitionMap
+
+const _traverseFilterMap: traversableFilterable.TraversableFilterable<
+  ReadonlyRecord.ReadonlyRecordTypeLambda<any>
+>["traverseFilterMap"] = traverseFilterMap
+
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export const getCovariant = <K extends string>(): covariant.Covariant<
+  ReadonlyRecord.ReadonlyRecordTypeLambda<K>
+> => ({
+  imap: _imap,
+  map: _map
+})
+
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export const Covariant = getCovariant()
+
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export const getInvariant = <K extends string>(): invariant.Invariant<
+  ReadonlyRecord.ReadonlyRecordTypeLambda<K>
+> => ({
+  imap: _imap
+})
+
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export const Invariant = getInvariant()
+
+/**
+ * @category instances
+ * @since 1.0.0
+ */
+export const getFilterable = <K extends string>(): filterable.Filterable<
+  ReadonlyRecord.ReadonlyRecordTypeLambda<K>
+> => ({
+  partitionMap: _partitionMap,
+  filterMap: _filterMap
+})
+
 /**
  * @category instances
  * @since 1.0.0
  */
-export const Covariant: covariant.Covariant<ReadonlyRecord.ReadonlyRecordTypeLambda> = {
-  imap,
-  map
-}
+export const Filterable = getFilterable()
 
 /**
  * @category instances
  * @since 1.0.0
  */
-export const Invariant: invariant.Invariant<ReadonlyRecord.ReadonlyRecordTypeLambda> = {
-  imap
-}
+export const getTraversable = <K extends string>(): traversable.Traversable<
+  ReadonlyRecord.ReadonlyRecordTypeLambda<K>
+> => ({
+  traverse: _traverse
+})
 
 /**
  * @category instances
  * @since 1.0.0
  */
-export const Filterable: filterable.Filterable<ReadonlyRecord.ReadonlyRecordTypeLambda> = {
-  partitionMap,
-  filterMap
-}
+export const Traversable = getTraversable()
 
 /**
  * @category instances
  * @since 1.0.0
  */
-export const Traversable: traversable.Traversable<ReadonlyRecord.ReadonlyRecordTypeLambda> = {
-  traverse
-}
+export const getTraversableFilterable = <K extends string>(): traversableFilterable.TraversableFilterable<
+  ReadonlyRecord.ReadonlyRecordTypeLambda<K>
+> => ({
+  traversePartitionMap: _traversePartitionMap,
+  traverseFilterMap: _traverseFilterMap
+})
 
 /**
  * @category instances
  * @since 1.0.0
  */
-export const TraversableFilterable: traversableFilterable.TraversableFilterable<
-  ReadonlyRecord.ReadonlyRecordTypeLambda
-> = {
-  traversePartitionMap,
-  traverseFilterMap
-}
+export const TraversableFilterable = getTraversableFilterable()
diff --git a/packages/typeclass/test/data/ReadonlyRecord.test.ts b/packages/typeclass/test/data/ReadonlyRecord.test.ts
new file mode 100644
index 0000000000..4d9a091c39
--- /dev/null
+++ b/packages/typeclass/test/data/ReadonlyRecord.test.ts
@@ -0,0 +1,43 @@
+import * as OptionInstances from "@effect/typeclass/data/Option"
+import * as ReadonlyRecordInstances from "@effect/typeclass/data/ReadonlyRecord"
+import * as Option from "effect/Option"
+import { describe, expect, it } from "vitest"
+
+describe.concurrent("ReadonlyRecord", () => {
+  it("traverse (string)", () => {
+    const traverse = ReadonlyRecordInstances.traverse(OptionInstances.Applicative)
+    const stringRecord: Record<string, number> = {
+      a: 1,
+      b: 2
+    }
+    expect(traverse(stringRecord, (a, k) => Option.some(a + k))).toStrictEqual(Option.some({
+      a: "1a",
+      b: "2b"
+    }))
+    expect(traverse(stringRecord, (a) => a < 1 ? Option.some(a) : Option.none())).toStrictEqual(Option.none())
+  })
+
+  it("traverse (template literal)", () => {
+    const traverse = ReadonlyRecordInstances.getTraversable<`a${string}`>().traverse(OptionInstances.Applicative)
+    const templateLiteralRecord: Record<`a${string}`, number> = {
+      a: 1,
+      ab: 2
+    }
+    expect(traverse(templateLiteralRecord, (a) => Option.some(a))).toStrictEqual(Option.some({
+      a: 1,
+      ab: 2
+    }))
+    expect(traverse(templateLiteralRecord, (a) => a < 1 ? Option.some(a) : Option.none())).toStrictEqual(Option.none())
+  })
+
+  it("traverse (symbol)", () => {
+    const traverse = ReadonlyRecordInstances.traverse(OptionInstances.Applicative)
+    const a = Symbol.for("a")
+    const b = Symbol.for("b")
+    const symbolRecord: Record<symbol, number> = {
+      [a]: 1,
+      [b]: 2
+    }
+    expect(traverse(symbolRecord, (a) => Option.some(a))).toStrictEqual(Option.some({}))
+  })
+})