From 7fc6117eded0ee79d959f39be69e863e4adbaf93 Mon Sep 17 00:00:00 2001
From: tjjfvi <t6@t6.fyi>
Date: Sat, 8 Apr 2023 14:59:11 -0400
Subject: [PATCH] separate input and output types

---
 Readme.md                                  |  4 +-
 codecs/array.ts                            | 13 +++---
 codecs/compact.ts                          |  2 +-
 codecs/deferred.ts                         |  4 +-
 codecs/instance.ts                         | 10 ++---
 codecs/int.ts                              |  2 +-
 codecs/iterable.ts                         | 19 ++++----
 codecs/lenPrefixed.ts                      |  2 +-
 codecs/object.ts                           | 32 ++++++++++----
 codecs/option.ts                           | 12 +++---
 codecs/promise.ts                          |  2 +-
 codecs/record.ts                           |  4 +-
 codecs/result.ts                           | 12 +++---
 codecs/test/__snapshots__/str.test.ts.snap | 18 +++++++-
 codecs/transform.ts                        | 14 +++---
 codecs/tuple.ts                            | 11 +++--
 codecs/union.ts                            | 30 ++++++++-----
 common/codec.ts                            | 50 +++++++++-------------
 common/metadata.ts                         | 30 ++++++-------
 examples/collections.eg.ts                 |  2 +-
 examples/recursive.eg.ts                   |  2 +-
 words.txt                                  |  2 +
 22 files changed, 160 insertions(+), 117 deletions(-)

diff --git a/Readme.md b/Readme.md
index 6859d87..8c92899 100644
--- a/Readme.md
+++ b/Readme.md
@@ -51,10 +51,10 @@ const decodedValue: Superhero = $superhero.decode(encodedBytes)
 assertEquals(decodedValue, valueToEncode)
 ```
 
-To extract the JS-native TypeScript type from a given codec, use the `Native` utility type.
+To extract the type from a given codec, you can use the `Output` utility type.
 
 ```ts
-type Superhero = $.Native<typeof $superhero>
+type Superhero = $.Output<typeof $superhero>
 // {
 //   pseudonym: string;
 //   secretIdentity?: string | undefined;
diff --git a/codecs/array.ts b/codecs/array.ts
index 36fd7a3..c531b71 100644
--- a/codecs/array.ts
+++ b/codecs/array.ts
@@ -12,7 +12,10 @@ type ArrayOfLength<
   : L extends A["length"] ? A
   : ArrayOfLength<T, L, [...A, T]>
 
-export function sizedArray<L extends number, T>($el: Codec<T>, length: L): Codec<ArrayOfLength<T, L>> {
+export function sizedArray<L extends number, I, O>($el: Codec<I, O>, length: L): Codec<
+  Readonly<ArrayOfLength<I, L>>,
+  ArrayOfLength<O, L>
+> {
   return createCodec({
     _metadata: metadata("$.sizedArray", sizedArray, $el, length),
     _staticSize: $el._staticSize * length,
@@ -22,11 +25,11 @@ export function sizedArray<L extends number, T>($el: Codec<T>, length: L): Codec
       }
     },
     _decode(buffer) {
-      const value: T[] = Array(length)
+      const value: O[] = Array(length)
       for (let i = 0; i < value.length; i++) {
         value[i] = $el._decode(buffer)
       }
-      return value as ArrayOfLength<T, L>
+      return value as ArrayOfLength<O, L>
     },
     _assert(assert) {
       assert.instanceof(this, Array)
@@ -38,7 +41,7 @@ export function sizedArray<L extends number, T>($el: Codec<T>, length: L): Codec
   })
 }
 
-export function array<T>($el: Codec<T>): Codec<T[]> {
+export function array<I, O = I>($el: Codec<I, O>): Codec<readonly I[], O[]> {
   return createCodec({
     _metadata: metadata("$.array", array, $el),
     _staticSize: compactU32._staticSize,
@@ -54,7 +57,7 @@ export function array<T>($el: Codec<T>): Codec<T[]> {
     },
     _decode(buffer) {
       const length = compactU32._decode(buffer)
-      const value: T[] = Array(length)
+      const value: O[] = Array(length)
       for (let i = 0; i < value.length; i++) {
         value[i] = $el._decode(buffer)
       }
diff --git a/codecs/compact.ts b/codecs/compact.ts
index e2972c4..3906562 100644
--- a/codecs/compact.ts
+++ b/codecs/compact.ts
@@ -120,7 +120,7 @@ compactVisitor.add(constant<any>, (codec) => codec)
 compactVisitor.add(tuple<any[]>, (codec, ...entries) => {
   if (entries.length === 0) return codec
   if (entries.length > 1) throw new Error("Cannot derive compact codec for tuples with more than one field")
-  return withMetadata(metadata("$.compact", compact, codec), tuple<any[]>(compact(entries[0]!)))
+  return withMetadata(metadata("$.compact", compact<any>, codec), tuple(compact(entries[0]!)))
 })
 
 compactVisitor.add(field<any, any>, (codec, key, value) => {
diff --git a/codecs/deferred.ts b/codecs/deferred.ts
index 08d24e0..0434818 100644
--- a/codecs/deferred.ts
+++ b/codecs/deferred.ts
@@ -1,7 +1,7 @@
 import { Codec, createCodec, metadata } from "../common/mod.ts"
 
-export function deferred<T>(getCodec: () => Codec<T>): Codec<T> {
-  let $codec: Codec<T>
+export function deferred<I, O>(getCodec: () => Codec<I, O>): Codec<I, O> {
+  let $codec: Codec<I, O>
   const codec = createCodec({
     _metadata: metadata("$.deferred", deferred, getCodec),
     _staticSize: 0,
diff --git a/codecs/instance.ts b/codecs/instance.ts
index ef99557..e3b8590 100644
--- a/codecs/instance.ts
+++ b/codecs/instance.ts
@@ -1,11 +1,11 @@
 import { AssertState } from "../common/assert.ts"
 import { Codec, createCodec, metadata } from "../common/mod.ts"
 
-export function instance<A extends unknown[], T>(
-  ctor: new(...args: A) => T,
+export function instance<A extends unknown[], O extends I, I = O>(
+  ctor: new(...args: A) => O,
   $args: Codec<A>,
-  toArgs: (value: T) => [...A],
-): Codec<T> {
+  toArgs: (value: I) => [...A],
+): Codec<I, O> {
   return createCodec({
     _metadata: metadata("$.instance", instance, ctor, $args, toArgs),
     _staticSize: $args._staticSize,
@@ -17,7 +17,7 @@ export function instance<A extends unknown[], T>(
     },
     _assert(assert) {
       assert.instanceof(this, ctor)
-      $args._assert(new AssertState(toArgs(assert.value as T), "#arguments", assert))
+      $args._assert(new AssertState(toArgs(assert.value as O), "#arguments", assert))
     },
   })
 }
diff --git a/codecs/int.ts b/codecs/int.ts
index e42c3e4..d46e289 100644
--- a/codecs/int.ts
+++ b/codecs/int.ts
@@ -96,7 +96,7 @@ export function int(signed: boolean, size: 8 | 16 | 32 | 64 | 128 | 256): Codec<
 }
 
 function intMetadata<T extends number | bigint>(signed: boolean, size: number) {
-  return metadata<T>(
+  return metadata<T, T>(
     metadata(`$.${signed ? "i" : "u"}${size}`),
     metadata("$.int", int as any, signed, size),
   )
diff --git a/codecs/iterable.ts b/codecs/iterable.ts
index 64ad7e0..07280f6 100644
--- a/codecs/iterable.ts
+++ b/codecs/iterable.ts
@@ -14,14 +14,14 @@ import { tuple } from "./tuple.ts"
 
 const compactU32 = compact(u32)
 
-export function iterable<T, I extends Iterable<T>>(
+export function iterable<TI, I extends Iterable<TI>, TO = TI, O = I>(
   props: {
-    $el: Codec<T>
+    $el: Codec<TI, TO>
     calcLength: (iterable: I) => number
-    rehydrate: (iterable: Iterable<T>) => I
-    assert: (this: Codec<I>, assert: AssertState) => void
+    rehydrate: (iterable: Iterable<TO>) => O
+    assert: (this: Codec<I, O>, assert: AssertState) => void
   },
-): Codec<I> {
+): Codec<I, O> {
   return createCodec({
     _metadata: metadata("$.iterable", iterable, props),
     _staticSize: compactU32._staticSize,
@@ -64,7 +64,7 @@ export function iterable<T, I extends Iterable<T>>(
   })
 }
 
-export function set<T>($el: Codec<T>): Codec<Set<T>> {
+export function set<I, O>($el: Codec<I, O>): Codec<ReadonlySet<I>, Set<O>> {
   return withMetadata(
     metadata("$.set", set, $el),
     iterable({
@@ -78,8 +78,11 @@ export function set<T>($el: Codec<T>): Codec<Set<T>> {
   )
 }
 
-export function map<K, V>($key: Codec<K>, $value: Codec<V>): Codec<Map<K, V>> {
-  return withMetadata(
+export function map<KI, KO, VI, VO>(
+  $key: Codec<KI, KO>,
+  $value: Codec<VI, VO>,
+): Codec<ReadonlyMap<KI, VI>, Map<KO, VO>> {
+  return withMetadata<ReadonlyMap<KI, VI>, Map<KO, VO>>(
     metadata("$.map", map, $key, $value),
     iterable({
       $el: tuple($key, $value),
diff --git a/codecs/lenPrefixed.ts b/codecs/lenPrefixed.ts
index f56ba2b..105c8bb 100644
--- a/codecs/lenPrefixed.ts
+++ b/codecs/lenPrefixed.ts
@@ -4,7 +4,7 @@ import { u32 } from "./int.ts"
 
 const compactU32 = compact(u32)
 
-export function lenPrefixed<T>($inner: Codec<T>): Codec<T> {
+export function lenPrefixed<I, O>($inner: Codec<I, O>): Codec<I, O> {
   return createCodec({
     _metadata: metadata("$.lenPrefixed", lenPrefixed, $inner),
     _staticSize: compactU32._staticSize + $inner._staticSize,
diff --git a/codecs/object.ts b/codecs/object.ts
index c1460cc..81b2f7d 100644
--- a/codecs/object.ts
+++ b/codecs/object.ts
@@ -1,8 +1,11 @@
-import { AnyCodec, Codec, CodecVisitor, createCodec, Expand, metadata, Native, U2I } from "../common/mod.ts"
+import { AnyCodec, Codec, CodecVisitor, createCodec, Expand, Input, metadata, Output, U2I } from "../common/mod.ts"
 import { constant } from "./constant.ts"
 import { option } from "./option.ts"
 
-export function field<K extends keyof any, V>(key: K, $value: Codec<V>): Codec<Expand<Record<K, V>>> {
+export function field<K extends keyof any, V>(key: K, $value: Codec<V>): Codec<
+  Expand<Readonly<Record<K, V>>>,
+  Expand<Record<K, V>>
+> {
   return createCodec({
     _metadata: metadata("$.field", field, key, $value),
     _staticSize: $value._staticSize,
@@ -18,7 +21,10 @@ export function field<K extends keyof any, V>(key: K, $value: Codec<V>): Codec<E
   })
 }
 
-export function optionalField<K extends keyof any, V>(key: K, $value: Codec<V>): Codec<Expand<Partial<Record<K, V>>>> {
+export function optionalField<K extends keyof any, V>(key: K, $value: Codec<V>): Codec<
+  Expand<Readonly<Partial<Record<K, V>>>>,
+  Expand<Partial<Record<K, V>>>
+> {
   const $option = option($value)
   return createCodec({
     _metadata: metadata("$.optionalField", optionalField, key, $value),
@@ -43,11 +49,19 @@ export function optionalField<K extends keyof any, V>(key: K, $value: Codec<V>):
   })
 }
 
-export type NativeObject<T extends AnyCodec[]> = Expand<
+export type InputObject<T extends AnyCodec[]> = Expand<
   U2I<
     | { x: {} }
     | {
-      [K in keyof T]: { x: Native<T[K]> }
+      [K in keyof T]: { x: Input<T[K]> }
+    }[number]
+  >["x"]
+>
+export type OutputObject<T extends AnyCodec[]> = Expand<
+  U2I<
+    | { x: {} }
+    | {
+      [K in keyof T]: { x: Output<T[K]> }
     }[number]
   >["x"]
 >
@@ -56,17 +70,17 @@ type UnionKeys<T> = T extends T ? keyof T : never
 export type ObjectMembers<T extends AnyCodec[]> = [
   ...never extends T ? {
       [K in keyof T]:
-        & UnionKeys<Native<T[K]>>
+        & UnionKeys<Input<T[K]>>
         & {
-          [L in keyof T]: K extends L ? never : UnionKeys<Native<T[L]>>
+          [L in keyof T]: K extends L ? never : UnionKeys<Input<T[L]>>
         }[number] extends (infer O extends keyof any)
-        ? [O] extends [never] ? Codec<Native<T[K]> & {}> : Codec<{ [_ in O]?: never }>
+        ? [O] extends [never] ? Codec<Input<T[K]> & {}> : Codec<{ [_ in O]?: never }>
         : never
     }
     : T,
 ]
 
-export function object<T extends AnyCodec[]>(...members: ObjectMembers<T>): Codec<NativeObject<T>> {
+export function object<T extends AnyCodec[]>(...members: ObjectMembers<T>): Codec<InputObject<T>, OutputObject<T>> {
   return createCodec({
     _metadata: metadata("$.object", object<T>, ...members),
     _staticSize: members.map((x) => x._staticSize).reduce((a, b) => a + b, 0),
diff --git a/codecs/option.ts b/codecs/option.ts
index f15e798..ac6b4b0 100644
--- a/codecs/option.ts
+++ b/codecs/option.ts
@@ -1,23 +1,23 @@
 import { Codec, createCodec, metadata, ScaleDecodeError } from "../common/mod.ts"
 
-export function option<T>($some: Codec<T>): Codec<T | undefined>
-export function option<T, U>($some: Codec<T>, none: U): Codec<T | U>
-export function option<T, U>($some: Codec<T>, none?: U): Codec<T | U> {
+export function option<SI, SO>($some: Codec<SI, SO>): Codec<SI | undefined, SO | undefined>
+export function option<SI, SO, N>($some: Codec<SI, SO>, none: N): Codec<SI | N, SO | N>
+export function option<SI, SO, N>($some: Codec<SI, SO>, none?: N): Codec<SI | N, SO | N> {
   if ($some._metadata.some((x) => x.factory === option && x.args[1] === none)) {
     throw new Error("Nested option codec will not roundtrip correctly")
   }
   return createCodec({
-    _metadata: metadata("$.option", option<T, U>, $some, ...(none === undefined ? [] : [none!]) as [U]),
+    _metadata: metadata("$.option", option<SI, SO, N>, $some, ...(none === undefined ? [] : [none!]) as [N]),
     _staticSize: 1 + $some._staticSize,
     _encode(buffer, value) {
       if ((buffer.array[buffer.index++] = +(value !== none))) {
-        $some._encode(buffer, value as T)
+        $some._encode(buffer, value as SI)
       }
     },
     _decode(buffer) {
       switch (buffer.array[buffer.index++]) {
         case 0:
-          return none as U
+          return none as N
         case 1: {
           const value = $some._decode(buffer)
           if (value === none) {
diff --git a/codecs/promise.ts b/codecs/promise.ts
index 661c773..24b7a1e 100644
--- a/codecs/promise.ts
+++ b/codecs/promise.ts
@@ -1,6 +1,6 @@
 import { Codec, createCodec, metadata } from "../common/mod.ts"
 
-export function promise<T>($value: Codec<T>): Codec<Promise<T>> {
+export function promise<I, O>($value: Codec<I, O>): Codec<Promise<I>, Promise<O>> {
   return createCodec({
     _metadata: metadata("$.promise", promise, $value),
     _staticSize: $value._staticSize,
diff --git a/codecs/record.ts b/codecs/record.ts
index cb85aec..44f7fc8 100644
--- a/codecs/record.ts
+++ b/codecs/record.ts
@@ -4,8 +4,8 @@ import { str } from "./str.ts"
 import { transform } from "./transform.ts"
 import { tuple } from "./tuple.ts"
 
-export function record<V>($value: Codec<V>) {
-  return transform<[string, V][], Record<string, V>>({
+export function record<I, O>($value: Codec<I, O>): Codec<Readonly<Record<string, I>>, Record<string, O>> {
+  return transform({
     $base: array(tuple(str, $value)),
     encode: Object.entries,
     decode: Object.fromEntries,
diff --git a/codecs/result.ts b/codecs/result.ts
index 73c622e..cecf580 100644
--- a/codecs/result.ts
+++ b/codecs/result.ts
@@ -1,9 +1,9 @@
 import { Codec, createCodec, metadata, ScaleDecodeError } from "../common/mod.ts"
 
-export function result<Ok, Err extends Error>(
-  $ok: Codec<Ok>,
-  $err: Codec<Err>,
-): Codec<Ok | Err> {
+export function result<TI, TO, UI extends Error, UO extends Error>(
+  $ok: Codec<TI, TO>,
+  $err: Codec<UI, UO>,
+): Codec<TI | UI, TO | UO> {
   if ($ok._metadata.some((x) => x.factory === result)) {
     throw new Error("Nested result codec will not roundtrip correctly")
   }
@@ -12,9 +12,9 @@ export function result<Ok, Err extends Error>(
     _staticSize: 1 + Math.max($ok._staticSize, $err._staticSize),
     _encode(buffer, value) {
       if ((buffer.array[buffer.index++] = +(value instanceof Error))) {
-        $err._encode(buffer, value as Err)
+        $err._encode(buffer, value as UI)
       } else {
-        $ok._encode(buffer, value as Ok)
+        $ok._encode(buffer, value as TI)
       }
     },
     _decode(buffer) {
diff --git a/codecs/test/__snapshots__/str.test.ts.snap b/codecs/test/__snapshots__/str.test.ts.snap
index 9b3966c..a4a3dda 100644
--- a/codecs/test/__snapshots__/str.test.ts.snap
+++ b/codecs/test/__snapshots__/str.test.ts.snap
@@ -501,7 +501,7 @@ f9
 `;
 
 snapshot[`\$.str words 1`] = `
-15
+55
 03
 61
 76
@@ -557,6 +557,14 @@ snapshot[`\$.str words 1`] = `
 6f
 6e
 0a
+44
+65
+63
+6f
+64
+65
+63
+0a
 64
 65
 6e
@@ -578,6 +586,14 @@ snapshot[`\$.str words 1`] = `
 6e
 74
 0a
+45
+6e
+63
+6f
+64
+65
+63
+0a
 68
 79
 64
diff --git a/codecs/transform.ts b/codecs/transform.ts
index 0adadb7..37e9121 100644
--- a/codecs/transform.ts
+++ b/codecs/transform.ts
@@ -1,13 +1,13 @@
 import { AssertState, Codec, createCodec, metadata } from "../common/mod.ts"
 
-export function transform<T, U>(
+export function transform<TI, UI, TO = TI, UO = UI>(
   props: {
-    $base: Codec<T>
-    encode: (value: U) => T
-    decode: (value: T) => U
-    assert?: (this: Codec<U>, assert: AssertState) => void
+    $base: Codec<TI, TO>
+    encode: (value: UI) => TI
+    decode: (value: TO) => UO
+    assert?: (this: Codec<UI, UO>, assert: AssertState) => void
   },
-): Codec<U> {
+): Codec<UI, UO> {
   return createCodec({
     _metadata: metadata("$.transform", transform, props),
     _staticSize: props.$base._staticSize,
@@ -19,7 +19,7 @@ export function transform<T, U>(
     },
     _assert(assert) {
       props.assert?.call(this, assert)
-      props.$base._assert(new AssertState(props.encode(assert.value as U), "#encode", assert))
+      props.$base._assert(new AssertState(props.encode(assert.value as UI), "#encode", assert))
     },
   })
 }
diff --git a/codecs/tuple.ts b/codecs/tuple.ts
index 0c21bab..a70c19a 100644
--- a/codecs/tuple.ts
+++ b/codecs/tuple.ts
@@ -1,10 +1,13 @@
-import { AnyCodec, Codec, createCodec, metadata } from "../common/mod.ts"
+import { AnyCodec, Codec, createCodec, Input, metadata, Output } from "../common/mod.ts"
 
-export type NativeTuple<ElCodecs extends AnyCodec[]> = {
-  [I in keyof ElCodecs]: ElCodecs[I] extends Codec<infer T> ? T : never
+type InputTuple<T extends AnyCodec[]> = {
+  readonly [K in keyof T]: Input<T[K]>
+}
+type OutputTuple<T extends AnyCodec[]> = {
+  [K in keyof T]: Output<T[K]>
 }
 
-export function tuple<T extends AnyCodec[]>(...codecs: [...T]): Codec<NativeTuple<T>> {
+export function tuple<T extends AnyCodec[]>(...codecs: [...T]): Codec<InputTuple<T>, OutputTuple<T>> {
   return createCodec({
     _metadata: metadata("$.tuple", tuple<T>, ...codecs),
     _staticSize: codecs.map((x) => x._staticSize).reduce((a, b) => a + b, 0),
diff --git a/codecs/union.ts b/codecs/union.ts
index 58e0b77..f7e379f 100644
--- a/codecs/union.ts
+++ b/codecs/union.ts
@@ -1,32 +1,42 @@
-import { AnyCodec, Native } from "../common/codec.ts"
+import { AnyCodec, Input, Output } from "../common/codec.ts"
 import { Codec, createCodec, Expand, metadata, Narrow, ScaleAssertError, ScaleDecodeError } from "../common/mod.ts"
 import { constant } from "./constant.ts"
-import { field, NativeObject, object, ObjectMembers } from "./object.ts"
+import { field, InputObject, object, ObjectMembers, OutputObject } from "./object.ts"
 
-export class Variant<T extends string, V> {
-  constructor(readonly tag: T, readonly codec: Codec<V>) {}
+export class Variant<T extends string, I, O> {
+  constructor(readonly tag: T, readonly codec: Codec<I, O>) {}
 }
 
 export function variant<T extends string, E extends AnyCodec[]>(
   tag: T,
   ...members: ObjectMembers<E>
-): Variant<T, NativeObject<E>> {
+): Variant<T, InputObject<E>, OutputObject<E>> {
   return new Variant(tag, object(...members))
 }
 
-export type NativeTaggedUnion<
+export type InputTaggedUnion<
   K extends keyof any,
-  M extends Record<number, Variant<any, any>>,
+  M extends Record<number, Variant<any, any, any>>,
 > = {
   [I in keyof M]: Expand<
-    Record<K, Extract<M[I], Variant<any, any>>["tag"]> & Native<Extract<M[I], Variant<any, any>>["codec"]>
+    & Readonly<Record<K, Extract<M[I], Variant<any, any, any>>["tag"]>>
+    & Input<Extract<M[I], Variant<any, any, any>>["codec"]>
+  >
+}[keyof M & number]
+export type OutputTaggedUnion<
+  K extends keyof any,
+  M extends Record<number, Variant<any, any, any>>,
+> = {
+  [I in keyof M]: Expand<
+    & Record<K, Extract<M[I], Variant<any, any, any>>["tag"]>
+    & Output<Extract<M[I], Variant<any, any, any>>["codec"]>
   >
 }[keyof M & number]
 
 export function taggedUnion<
   K extends keyof any,
-  M extends [] | Record<number, Variant<any, any>>,
->(tagKey: K, members: M): Codec<NativeTaggedUnion<K, M>> {
+  M extends [] | Record<number, Variant<any, any, any>>,
+>(tagKey: K, members: M): Codec<InputTaggedUnion<K, M>, OutputTaggedUnion<K, M>> {
   const tagToDiscriminant: Record<string, number> = Object.create(null)
   const discriminantToMember: Record<number, Codec<any>> = Object.create(null)
   for (const _discriminant in members) {
diff --git a/common/codec.ts b/common/codec.ts
index d3cf0ae..e8c2ac4 100644
--- a/common/codec.ts
+++ b/common/codec.ts
@@ -3,15 +3,16 @@ import { DecodeBuffer, EncodeBuffer } from "./buffer.ts"
 import { Metadata } from "./metadata.ts"
 import { ScaleAssertError, ScaleEncodeError } from "./util.ts"
 
-export type Native<T extends AnyCodec> = T extends Codec<infer U> ? U : never
+export type Input<T extends AnyCodec> = T extends Codec<infer I, unknown> ? I : never
+export type Output<T extends AnyCodec> = T extends Codec<never, infer O> ? O : never
 
-export function createCodec<T>(
+export function createCodec<I, O = I>(
   _codec:
-    & ThisType<Codec<T>>
-    & Pick<Codec<T>, "_encode" | "_decode" | "_assert" | "_staticSize" | "_metadata">,
-): Codec<T> {
+    & ThisType<Codec<I, O>>
+    & Pick<Codec<I, O>, "_encode" | "_decode" | "_assert" | "_staticSize" | "_metadata">,
+): Codec<I, O> {
   const { _staticSize, _encode, _assert, _decode, _metadata } = _codec
-  const codec: Codec<T> = {
+  const codec: Codec<I, O> = {
     // @ts-ignore https://gist.github.com/tjjfvi/ea194c4fce76dacdd60a0943256332aa
     __proto__: Codec.prototype,
     _staticSize,
@@ -24,12 +25,12 @@ export function createCodec<T>(
 }
 
 type NoInfer<T> = T extends infer U ? U : never
-export function withMetadata<T>(metadata: Metadata<NoInfer<T>>, codec: Codec<T>): Codec<T> {
-  const result: Codec<T> = {
+export function withMetadata<I, O>(metadata: Metadata<NoInfer<I>, NoInfer<O>>, codec: Codec<I, O>): Codec<I, O> {
+  const result: Codec<I, O> = {
     // @ts-ignore https://gist.github.com/tjjfvi/ea194c4fce76dacdd60a0943256332aa
     __proto__: Codec.prototype,
     ...codec,
-    _metadata: [...metadata as Metadata<T>, ...codec._metadata],
+    _metadata: [...metadata as Metadata<I, O>, ...codec._metadata],
   }
   return result
 }
@@ -83,33 +84,24 @@ abstract class _Codec {
   }
 }
 
-export interface AnyCodec extends _Codec {
-  _staticSize: number
-  _encode(buffer: EncodeBuffer, value: any): void
-  _decode: (buffer: DecodeBuffer) => any
-  _assert: (state: AssertState) => void
-  _metadata: any
+export type AnyCodec = Codec<never, unknown>
+export type Encodec<I> = Codec<I, unknown>
+export type Decodec<O> = Codec<never, O>
 
-  encode(value: any): Uint8Array
-  encodeAsync(value: any): Promise<Uint8Array>
-  decode(array: Uint8Array): any
-  assert(value: unknown): void
-}
-
-export abstract class Codec<in out T> extends _Codec implements AnyCodec {
+export abstract class Codec<in I, out O = I> extends _Codec implements AnyCodec {
   /** A static estimation of the size, which may be an under- or over-estimate */
   abstract _staticSize: number
   /** Encodes the value into the supplied buffer, which should have at least `_staticSize` free byte. */
-  abstract _encode: (buffer: EncodeBuffer, value: T) => void
+  abstract _encode: (buffer: EncodeBuffer, value: I) => void
   /** Decodes the value from the supplied buffer */
-  abstract _decode: (buffer: DecodeBuffer) => T
+  abstract _decode: (buffer: DecodeBuffer) => O
   /** Asserts that the value is valid for this codec */
   abstract _assert: (state: AssertState) => void
   /** An array with metadata representing the construction of this codec */
-  abstract _metadata: Metadata<T>
+  abstract _metadata: Metadata<I, O>
 
   /** Encodes the value into a new Uint8Array (throws if async) */
-  encode(value: T) {
+  encode(value: I) {
     const buf = new EncodeBuffer(this._staticSize)
     this._encode(buf, value)
     if (buf.asyncCount) throw new ScaleEncodeError(this, value, "Attempted to synchronously encode an async codec")
@@ -117,7 +109,7 @@ export abstract class Codec<in out T> extends _Codec implements AnyCodec {
   }
 
   /** Asynchronously encodes the value into a new Uint8Array */
-  async encodeAsync(value: T) {
+  async encodeAsync(value: I) {
     const buf = new EncodeBuffer(this._staticSize)
     this._encode(buf, value)
     return buf.finishAsync()
@@ -130,13 +122,13 @@ export abstract class Codec<in out T> extends _Codec implements AnyCodec {
   }
 
   /** Requires the codec to have an explicit type annotation; if it doesn't, use `$.assert` instead. */
-  assert(value: unknown): asserts value is T {
+  assert(value: unknown): asserts value is I {
     assert(this, value)
   }
 }
 
 /** Asserts that the value is valid for the specified codec */
-export function assert<T>(codec: Codec<T>, value: unknown): asserts value is T {
+export function assert<I>(codec: Codec<I, unknown>, value: unknown): asserts value is I {
   codec._assert(new AssertState(value))
 }
 
diff --git a/common/metadata.ts b/common/metadata.ts
index 3627ae8..f2bfc92 100644
--- a/common/metadata.ts
+++ b/common/metadata.ts
@@ -1,6 +1,6 @@
 import { Codec } from "./codec.ts"
 
-export type Metadata<T> = Array<
+export type Metadata<I, O> = Array<
   | {
     type: "atomic"
     name: string
@@ -12,7 +12,7 @@ export type Metadata<T> = Array<
     type: "factory"
     name: string
     docs?: never
-    factory: (...args: any) => Codec<T>
+    factory: (...args: any) => Codec<I, O>
     args: any[]
   }
   | {
@@ -24,26 +24,26 @@ export type Metadata<T> = Array<
 >
 
 /** Metadata for an atomic codec */
-export function metadata<T = any>(name: string): Metadata<T>
+export function metadata<I = any, O = any>(name: string): Metadata<I, O>
 /** Metadata for a factory-made codec */
-export function metadata<T, A extends unknown[]>(
+export function metadata<I, O, A extends unknown[]>(
   name: string,
-  factory: (...args: A) => Codec<T>,
+  factory: (...args: A) => Codec<I, O>,
   ...args: A
-): Metadata<T>
+): Metadata<I, O>
 /** Concatenate multiple metadata arrays */
-export function metadata<T>(...metadata: Metadata<T>[]): Metadata<T>
-export function metadata<T>(
+export function metadata<I, O>(...metadata: Metadata<I, O>[]): Metadata<I, O>
+export function metadata<I, O>(
   ...fullArgs:
-    | Metadata<T>[]
+    | Metadata<I, O>[]
     | [
       name: string,
-      factory?: (...args: any) => Codec<T>,
+      factory?: (...args: any) => Codec<[I, O]>,
       ...args: any[],
     ]
-): Metadata<T> {
+): Metadata<I, O> {
   if (typeof fullArgs[0] !== "string") return fullArgs.flat()
-  const [name, factory, ...args] = fullArgs as [name: string, factory?: (...args: any) => Codec<T>, ...args: any[]]
+  const [name, factory, ...args] = fullArgs as [name: string, factory?: (...args: any) => Codec<I, O>, ...args: any[]]
   return [
     factory
       ? {
@@ -59,17 +59,17 @@ export function metadata<T>(
   ]
 }
 
-export function docs<T = any>(docs: string): Metadata<T> {
+export function docs<I = any, O = any>(docs: string): Metadata<I, O> {
   return [{ type: "docs", docs }]
 }
 
 export class CodecVisitor<R> {
   #fallback?: <T>(codec: Codec<T>) => R
-  #visitors = new Map<Metadata<any>[number] | Function, (codec: Codec<any>, ...args: any[]) => R>()
+  #visitors = new Map<Metadata<any, any>[number] | Function, (codec: Codec<any>, ...args: any[]) => R>()
 
   add<T, A extends unknown[]>(codec: (...args: A) => Codec<T>, fn: (codec: Codec<T>, ...args: A) => R): this
   add<T>(codec: Codec<T>, fn: (codec: Codec<T>) => R): this
-  add(codec: Codec<any> | Metadata<any>[number] | Function, fn: (codec: Codec<any>, ...args: any[]) => R): this {
+  add(codec: Codec<any> | Metadata<any, any>[number] | Function, fn: (codec: Codec<any>, ...args: any[]) => R): this {
     if (codec instanceof Codec) {
       codec = codec._metadata[0]!
       if (!codec) throw new Error("Cannot register visitor for metadata-less codec")
diff --git a/examples/collections.eg.ts b/examples/collections.eg.ts
index 38c377b..568d2d0 100644
--- a/examples/collections.eg.ts
+++ b/examples/collections.eg.ts
@@ -5,4 +5,4 @@ $.set($.u32) // Codec<Set<number>>
 
 $.map($.str, $.u32) // Codec<Map<string, number>>
 
-$.record($.u8) // Codec<Partial<Record<string, number>>>
+$.record($.u8) // Codec<Record<string, number>>
diff --git a/examples/recursive.eg.ts b/examples/recursive.eg.ts
index f1f5a84..31a08f5 100644
--- a/examples/recursive.eg.ts
+++ b/examples/recursive.eg.ts
@@ -7,7 +7,7 @@ import { $interestingU8, $pet, InterestingU8 } from "./unions.eg.ts"
 interface Person {
   name: string
   favoriteU8: InterestingU8
-  pets: $.Native<typeof $pet>[]
+  pets: $.Output<typeof $pet>[]
   children: Person[]
 }
 
diff --git a/words.txt b/words.txt
index f88f4f1..e5e1d89 100644
--- a/words.txt
+++ b/words.txt
@@ -4,9 +4,11 @@ bitvec
 combinators
 contravariance
 cummon
+Decodec
 deno
 denoland
 dprint
+Encodec
 hydrokinesis
 jsbin
 Kosmoceratops