diff --git a/packages/core/src/cbor.js b/packages/core/src/cbor.js
index b19d8b4e..99de128d 100644
--- a/packages/core/src/cbor.js
+++ b/packages/core/src/cbor.js
@@ -1,12 +1,16 @@
 import * as API from '@ucanto/interface'
 import * as CBOR from '@ipld/dag-cbor'
-export { code, name, decode } from '@ipld/dag-cbor'
-import { sha256 } from 'multiformats/hashes/sha2'
+export { decode } from '@ipld/dag-cbor'
+import * as sha256 from './sha256.js'
 import { create as createLink, isLink } from 'multiformats/link'
 
 // @see https://www.iana.org/assignments/media-types/application/vnd.ipld.dag-cbor
 export const contentType = 'application/vnd.ipld.dag-cbor'
 
+/** @type {API.MulticodecCode<typeof CBOR.code, typeof CBOR.name>} */
+export const code = CBOR.code
+export const name = CBOR.name
+
 /**
  * @param {unknown} data
  * @param {Set<unknown>} seen
diff --git a/packages/core/src/dag.js b/packages/core/src/dag.js
index 80199a74..87a1e98d 100644
--- a/packages/core/src/dag.js
+++ b/packages/core/src/dag.js
@@ -106,18 +106,18 @@ export const notFound = link => {
 /**
  * @template T
  * @template {T} U
- * @template {API.MulticodecCode} C
- * @template {API.MulticodecCode} A
+ * @template {MF.BlockEncoder<number, U>} [Codec=MF.BlockEncoder<API.MulticodecCode<typeof CBOR.code, typeof CBOR.name>, U>]
+ * @template {MF.MultihashHasher} [Hasher=MF.MultihashHasher<API.MulticodecCode<typeof sha256.code, typeof sha256.name>>]
  * @param {U} source
  * @param {BlockStore<T>} store
  * @param {object} options
- * @param {MF.BlockEncoder<C, unknown>} [options.codec]
- * @param {MF.MultihashHasher<A>} [options.hasher]
- * @returns {Promise<API.Block<U, C, A> & { data: U }>}
+ * @param {Codec} [options.codec]
+ * @param {Hasher} [options.hasher]
+ * @returns {Promise<API.Block<U, Codec['code'], Hasher['code']> & { data: U }>}
  */
 export const writeInto = async (source, store, options = {}) => {
-  const codec = /** @type {MF.BlockEncoder<C, U>} */ (options.codec || CBOR)
-  const hasher = /** @type {MF.MultihashHasher<A>} */ (options.hasher || sha256)
+  const codec = /** @type {Codec} */ (options.codec || CBOR)
+  const hasher = /** @type {Hasher} */ (options.hasher || sha256)
 
   const bytes = codec.encode(source)
   const digest = await hasher.digest(bytes)
diff --git a/packages/core/src/delegation.js b/packages/core/src/delegation.js
index 8f91b62b..9162f136 100644
--- a/packages/core/src/delegation.js
+++ b/packages/core/src/delegation.js
@@ -173,41 +173,6 @@ export class Delegation {
     })
   }
 
-  /**
-   * @returns {API.AttachedLinkSet}
-   */
-  get attachedLinks() {
-    const _attachedLinks = new Set()
-    const ucanView = this.data
-
-    // Get links from capabilities nb
-    for (const capability of ucanView.capabilities) {
-      /** @type {Link[]} */
-      const links = getLinksFromObject(capability)
-
-      for (const link of links) {
-        _attachedLinks.add(`${link}`)
-      }
-    }
-
-    // Get links from facts values
-    for (const fact of ucanView.facts) {
-      if (Link.isLink(fact)) {
-        _attachedLinks.add(`${fact}`)
-      } else {
-        /** @type {Link[]} */
-        // @ts-expect-error isLink does not infer value type
-        const links = Object.values(fact).filter(e => Link.isLink(e))
-
-        for (const link of links) {
-          _attachedLinks.add(`${link}`)
-        }
-      }
-    }
-
-    return _attachedLinks
-  }
-
   get version() {
     return this.data.version
   }
@@ -231,22 +196,8 @@ export class Delegation {
     Object.defineProperties(this, { data: { value: data, enumerable: false } })
     return data
   }
-  /**
-   * Attach a block to the delegation DAG so it would be included in the
-   * block iterator.
-   * ⚠️ You can only attach blocks that are referenced from the `capabilities`
-   * or `facts`.
-   *
-   * @param {API.Block} block
-   */
-  attach(block) {
-    if (!this.attachedLinks.has(`${block.cid.link()}`)) {
-      throw new Error(`given block with ${block.cid} is not an attached link`)
-    }
-    this.blocks.set(`${block.cid}`, block)
-  }
   export() {
-    return exportDAG(this.root, this.blocks, this.attachedLinks)
+    return exportDAG(this)
   }
 
   /**
@@ -257,7 +208,7 @@ export class Delegation {
   }
 
   iterateIPLDBlocks() {
-    return exportDAG(this.root, this.blocks, this.attachedLinks)
+    return exportDAG(this)
   }
 
   /**
@@ -385,7 +336,7 @@ export const archive = async delegation => {
 
 export const ArchiveSchema = Schema.variant({
   'ucan@0.9.1': /** @type {Schema.Schema<API.UCANLink>} */ (
-    Schema.link({ version: 1 })
+    Schema.unknown().link({ version: 1 })
   ),
 })
 
@@ -453,11 +404,34 @@ const decode = ({ bytes }) => {
  */
 
 export const delegate = async (
-  { issuer, audience, proofs = [], attachedBlocks = new Map(), ...input },
+  { issuer, audience, proofs = [], facts = [], ...input },
   options
 ) => {
   const links = []
+  /** @type {Map<string, API.Block>} */
   const blocks = new Map()
+  for (const capability of input.capabilities) {
+    for (const node of [...Object.values(capability.nb || {}), capability.nb]) {
+      for (const block of DAG.iterate(node)) {
+        blocks.set(block.cid.toString(), block)
+      }
+    }
+  }
+
+  for (const fact of facts) {
+    if (fact) {
+      for (const node of [...Object.values(fact), fact]) {
+        for (const block of DAG.iterate(node)) {
+          blocks.set(block.cid.toString(), block)
+        }
+      }
+    }
+  }
+
+  const attachments = [...blocks.values()]
+    .map(block => block.cid)
+    .sort((left, right) => left.toString().localeCompare(right.toString()))
+
   for (const proof of proofs) {
     if (!isDelegation(proof)) {
       links.push(proof)
@@ -469,11 +443,20 @@ export const delegate = async (
     }
   }
 
+  // We may not have codecs to traverse all the blocks on the other side of the
+  // wire, which is why we capture all the links in a flat list which we include
+  // in facts. That way recipient will know all of the blocks without having to
+  // know to know how to traverse the graph.
+  if (attachments.length > 0) {
+    facts.push({ 'ucan/attachments': attachments })
+  }
+
   const data = await UCAN.issue({
     ...input,
     issuer,
     audience,
     proofs: links,
+    facts,
   })
   const { cid, bytes } = await UCAN.write(data, options)
   decodeCache.set(cid, data)
@@ -482,23 +465,20 @@ export const delegate = async (
   const delegation = new Delegation({ cid, bytes }, blocks)
   Object.defineProperties(delegation, { proofs: { value: proofs } })
 
-  for (const block of attachedBlocks.values()) {
-    delegation.attach(block)
-  }
-
   return delegation
 }
 
 /**
  * @template {API.Capabilities} C
- * @param {API.UCANBlock<C>} root
- * @param {DAG.BlockStore} blocks
- * @param {API.AttachedLinkSet} attachedLinks
+ * @param {object} source
+ * @param {API.UCANBlock<C>} source.root
+ * @param {DAG.BlockStore} source.blocks
  * @returns {IterableIterator<API.Block>}
  */
 
-export const exportDAG = function* (root, blocks, attachedLinks) {
-  for (const link of decode(root).proofs) {
+export const exportDAG = function* ({ root, blocks }) {
+  const { proofs, facts, capabilities } = decode(root)
+  for (const link of proofs) {
     // Check if block is included in this delegation
     const root = /** @type {UCAN.Block} */ (blocks.get(`${link}`))
     if (root) {
@@ -506,7 +486,8 @@ export const exportDAG = function* (root, blocks, attachedLinks) {
     }
   }
 
-  for (const link of attachedLinks.values()) {
+  const links = new Set([...iterateLinks({ facts, capabilities }, blocks)])
+  for (const link of links) {
     const block = blocks.get(link)
 
     if (block) {
@@ -609,31 +590,22 @@ const proofs = delegation => {
 }
 
 /**
- * @param {API.Capability<API.Ability, `${string}:${string}`, unknown>} obj
+ * Traverses source and yields all links found.
+ *
+ * @param {unknown} source
+ * @param {Schema.Region} region
+ * @returns {IterableIterator<string>}
  */
-function getLinksFromObject(obj) {
-  /** @type {Link[]} */
-  const links = []
-
-  /**
-   * @param {object} obj
-   */
-  function recurse(obj) {
-    for (const key in obj) {
-      // @ts-expect-error record type not inferred
-      const value = obj[key]
-      if (Link.isLink(value)) {
-        // @ts-expect-error isLink does not infer value type
-        links.push(value)
-      } else if (value && typeof value === 'object') {
-        recurse(value)
+const iterateLinks = function* (source, region) {
+  if (source && typeof source === 'object') {
+    if (Link.isLink(source)) {
+      yield `${source}`
+    } else {
+      for (const member of Object.values(source)) {
+        yield* iterateLinks(member, region)
       }
     }
   }
-
-  recurse(obj)
-
-  return links
 }
 
 export { Delegation as View }
diff --git a/packages/core/src/identity.js b/packages/core/src/identity.js
new file mode 100644
index 00000000..ca21a150
--- /dev/null
+++ b/packages/core/src/identity.js
@@ -0,0 +1,9 @@
+import * as API from '@ucanto/interface'
+
+import { identity } from 'multiformats/hashes/identity'
+
+/** @type {API.MulticodecCode<typeof identity.code, typeof identity.name>} */
+export const code = identity.code
+export const name = identity.name
+export const { encode } = identity
+export const digest = identity.digest.bind(identity)
diff --git a/packages/core/src/invocation.js b/packages/core/src/invocation.js
index 819adafb..b9c7b5a4 100644
--- a/packages/core/src/invocation.js
+++ b/packages/core/src/invocation.js
@@ -81,22 +81,6 @@ class IssuedInvocation {
     this.notBefore = notBefore
     this.nonce = nonce
     this.facts = facts
-
-    /** @type {API.BlockStore<unknown>} */
-    this.attachedBlocks = new Map()
-  }
-
-  /**
-   * Attach a block to the invocation DAG so it would be included in the
-   * block iterator.
-   * ⚠️ You should only attach blocks that are referenced from the `capabilities`
-   * or `facts`, if that is not the case you probably should reconsider.
-   * ⚠️ Once a delegation is de-serialized the attached blocks will not be re-attached.
-   *
-   * @param {API.Block} block
-   */
-  attach(block) {
-    this.attachedBlocks.set(`${block.cid}`, block)
   }
 
   delegate() {
diff --git a/packages/core/src/lib.js b/packages/core/src/lib.js
index 2a299393..805dd40e 100644
--- a/packages/core/src/lib.js
+++ b/packages/core/src/lib.js
@@ -15,7 +15,7 @@ export {
   parse as parseLink,
   decode as decodeLink,
 } from './link.js'
-export { sha256 } from 'multiformats/hashes/sha2'
+export * as sha256 from './sha256.js'
 export * as UCAN from '@ipld/dag-ucan'
 export * as DID from '@ipld/dag-ucan/did'
 export * as Signature from '@ipld/dag-ucan/signature'
diff --git a/packages/core/src/message.js b/packages/core/src/message.js
index 9021ecea..4be20867 100644
--- a/packages/core/src/message.js
+++ b/packages/core/src/message.js
@@ -6,15 +6,13 @@ import * as Schema from './schema.js'
 
 export const MessageSchema = Schema.variant({
   'ucanto/message@7.0.0': Schema.struct({
-    execute: Schema.link().array().optional(),
-    delegate: Schema.dictionary({
+    execute: Schema.unknown().link().array().optional(),
+    report: Schema.dictionary({
       key: Schema.string(),
-      value: /** @type {API.Reader<API.Link<API.ReceiptModel>>} */ (
-        Schema.link()
+      value: /** @type {Schema.Convert<API.Link<API.ReceiptModel>>} */ (
+        Schema.unknown().link()
       ),
-    })
-      .array()
-      .optional(),
+    }).optional(),
   }),
 })
 
@@ -178,6 +176,9 @@ class Message {
     this._invocations = invocations
     this._receipts = receipts
   }
+  link() {
+    return this.root.cid
+  }
   *iterateIPLDBlocks() {
     for (const invocation of this.invocations) {
       yield* invocation.iterateIPLDBlocks()
diff --git a/packages/core/src/receipt.js b/packages/core/src/receipt.js
index e9cd4dbf..90fafefa 100644
--- a/packages/core/src/receipt.js
+++ b/packages/core/src/receipt.js
@@ -61,6 +61,9 @@ class Receipt {
     this._issuer = issuer
   }
 
+  link() {
+    return this.root.cid
+  }
   /**
    * @returns {Ran|ReturnType<Ran['link']>}
    */
diff --git a/packages/core/src/schema.js b/packages/core/src/schema.js
index 0bfecbfe..1daf4762 100644
--- a/packages/core/src/schema.js
+++ b/packages/core/src/schema.js
@@ -1,9 +1,7 @@
 export * as URI from './schema/uri.js'
-export * as Link from './schema/link.js'
 export * as DID from './schema/did.js'
 export * as Text from './schema/text.js'
 export * from './schema/schema.js'
-export { match as link } from './schema/link.js'
 export { match as did } from './schema/did.js'
 export { match as uri } from './schema/uri.js'
 export { match as text } from './schema/text.js'
diff --git a/packages/core/src/schema/link.js b/packages/core/src/schema/link.js
deleted file mode 100644
index 851c42ec..00000000
--- a/packages/core/src/schema/link.js
+++ /dev/null
@@ -1,98 +0,0 @@
-import * as API from '@ucanto/interface'
-import { create, createLegacy, isLink, parse, base32 } from '../link.js'
-import * as Schema from './schema.js'
-
-export { create, createLegacy, isLink, parse }
-
-/**
- * @template {number} [Code=number]
- * @template {number} [Alg=number]
- * @template {1|0} [Version=0|1]
- * @typedef {{
- * code?:Code,
- * version?:Version
- * multihash?: {code?: Alg, digest?: Uint8Array}
- * }} Settings
- */
-
-/**
- * @template {number} Code
- * @template {number} Alg
- * @template {1|0} Version
- * @extends {Schema.API<API.Link<unknown, Code, Alg, Version>, unknown, Settings<Code, Alg, Version>>}
- */
-class LinkSchema extends Schema.API {
-  /**
-   *
-   * @param {unknown} cid
-   * @param {Settings<Code, Alg, Version>} settings
-   * @returns {Schema.ReadResult<API.Link<unknown, Code, Alg, Version>>}
-   */
-  readWith(cid, { code, multihash = {}, version }) {
-    if (cid == null) {
-      return Schema.error(`Expected link but got ${cid} instead`)
-    } else {
-      if (!isLink(cid)) {
-        return Schema.error(`Expected link to be a CID instead of ${cid}`)
-      } else {
-        if (code != null && cid.code !== code) {
-          return Schema.error(
-            `Expected link to be CID with 0x${code.toString(16)} codec`
-          )
-        }
-
-        if (multihash.code != null && cid.multihash.code !== multihash.code)
-          return Schema.error(
-            `Expected link to be CID with 0x${multihash.code.toString(
-              16
-            )} hashing algorithm`
-          )
-
-        if (version != null && cid.version !== version) {
-          return Schema.error(
-            `Expected link to be CID version ${version} instead of ${cid.version}`
-          )
-        }
-
-        const [expectDigest, actualDigest] =
-          multihash.digest != null
-            ? [
-                base32.baseEncode(multihash.digest),
-                base32.baseEncode(cid.multihash.digest),
-              ]
-            : ['', '']
-
-        if (expectDigest !== actualDigest) {
-          return Schema.error(
-            `Expected link with "${expectDigest}" hash digest instead of "${actualDigest}"`
-          )
-        }
-
-        return {
-          ok: /** @type {API.Link<unknown, any, any, any>} */ (cid),
-        }
-      }
-    }
-  }
-}
-
-/** @type {Schema.Schema<API.Link<unknown, number, number, 0|1>, unknown>}  */
-export const schema = new LinkSchema({})
-
-export const link = () => schema
-
-/**
- * @template {number} Code
- * @template {number} Alg
- * @template {1|0} Version
- * @param {Settings<Code, Alg, Version>} options
- * @returns {Schema.Schema<API.Link<unknown, Code, Alg, Version>>}
- */
-export const match = (options = {}) => new LinkSchema(options)
-
-/**
- * @param {unknown} input
- */
-export const read = input => schema.read(input)
-
-export const optional = () => schema.optional()
diff --git a/packages/core/src/schema/schema.js b/packages/core/src/schema/schema.js
index da1affd1..b32128ad 100644
--- a/packages/core/src/schema/schema.js
+++ b/packages/core/src/schema/schema.js
@@ -1,15 +1,26 @@
 import * as Schema from './type.js'
 import { ok, Failure } from '../result.js'
+import {
+  create as createLink,
+  parse as parseLink,
+  createLegacy,
+  isLink,
+  parse,
+  base32,
+} from '../link.js'
 export * from './type.js'
+import * as sha256 from '../sha256.js'
+import * as identity from '../identity.js'
+import * as CBOR from '../cbor.js'
 
 export { ok }
 /**
  * @abstract
- * @template [T=unknown]
- * @template [I=unknown]
+ * @template [Out=unknown]
+ * @template [In=unknown]
  * @template [Settings=void]
- * @extends {Schema.Base<T, I, Settings>}
- * @implements {Schema.Schema<T, I>}
+ * @extends {Schema.Base<Out, In, Settings>}
+ * @implements {Schema.Schema<Out, In>}
  */
 export class API {
   /**
@@ -25,36 +36,65 @@ export class API {
   }
   /**
    * @abstract
-   * @param {I} input
+   * @param {In} input
    * @param {Settings} settings
-   * @returns {Schema.ReadResult<T>}
+   * @param {Schema.Region} [region]
+   * @returns {Schema.ReadResult<Out>}
    */
   /* c8 ignore next 3 */
-  readWith(input, settings) {
+  readWith(input, settings, region) {
     throw new Error(`Abstract method readWith must be implemented by subclass`)
   }
+
+  /**
+   *
+   * @param {Out} output
+   * @param {Settings} settings
+   * @returns {Schema.ReadResult<In>}
+   */
+  writeWith(output, settings) {
+    throw new Error(`Abstract method writeWith must be implemented by subclass`)
+  }
+
   /**
-   * @param {I} input
-   * @returns {Schema.ReadResult<T>}
+   * @param {unknown} input
    */
+
   read(input) {
-    return this.readWith(input, this.settings)
+    return this.tryFrom(/** @type {In} */ (input))
+  }
+
+  /**
+   * @param {In} input
+   * @param {Schema.Region} [region]
+   * @returns {Schema.ReadResult<Out>}
+   */
+  tryFrom(input, region) {
+    return this.readWith(input, this.settings, region)
+  }
+
+  /**
+   * @param {Out} output
+   * @returns {Schema.ReadResult<In>}
+   */
+  tryTo(output) {
+    return this.writeWith(output, this.settings)
   }
 
   /**
    * @param {unknown} value
-   * @returns {value is T}
+   * @returns {value is Out}
    */
   is(value) {
-    return !this.read(/** @type {I} */ (value))?.error
+    return !this.tryFrom(/** @type {In} */ (value))?.error
   }
 
   /**
-   * @param {unknown} value
-   * @return {T}
+   * @param {In} value
+   * @return {Out}
    */
   from(value) {
-    const result = this.read(/** @type {I} */ (value))
+    const result = this.tryFrom(/** @type {In} */ (value))
     if (result.error) {
       throw result.error
     } else {
@@ -63,29 +103,50 @@ export class API {
   }
 
   /**
-   * @returns {Schema.Schema<T|undefined, I>}
+   * @param {Out} value
    */
+  to(value) {
+    const result = this.tryTo(value)
+    if (result.error) {
+      throw result.error
+    } else {
+      return result.ok
+    }
+  }
+
   optional() {
     return optional(this)
   }
 
-  /**
-   * @returns {Schema.Schema<T|null, I>}
-   */
   nullable() {
     return nullable(this)
   }
 
   /**
-   * @returns {Schema.Schema<T[], I>}
+   * @deprecated - use {@link Schema.Schema.implicit} instead
+   * @param {Schema.NotUndefined<Out>} value
+   */
+  default(value) {
+    return this.implicit(value)
+  }
+
+  /**
+   * @param {Schema.NotUndefined<Out>} value
+   */
+  implicit(value) {
+    return implicit(this, value)
+  }
+
+  /**
+   * @returns {Schema.ArraySchema<Schema.Convert<Out, In>>}
    */
   array() {
     return array(this)
   }
   /**
-   * @template U
-   * @param {Schema.Reader<U, I>} schema
-   * @returns {Schema.Schema<T | U, I>}
+   * @template I, O
+   * @param {Schema.Convert<O, I>} schema
+   * @returns {Schema.Schema<Out | O, In | I>}
    */
 
   or(schema) {
@@ -93,70 +154,89 @@ export class API {
   }
 
   /**
-   * @template U
-   * @param {Schema.Reader<U, I>} schema
-   * @returns {Schema.Schema<T & U, I>}
+   * @template I, O
+   * @param {Schema.Convert<O, I>} schema
+   * @returns {Schema.Schema<Out & O, In & I>}
    */
   and(schema) {
     return and(this, schema)
   }
 
   /**
-   * @template {T} U
-   * @param {Schema.Reader<U, T>} schema
-   * @returns {Schema.Schema<U, I>}
+   * @template {Out} O
+   * @template {Out} I
+   * @param {Schema.Convert<O, I>} schema
+   * @returns {Schema.Schema<O, In>}
    */
   refine(schema) {
     return refine(this, schema)
   }
 
+  /**
+   * @template O
+   * @param {Schema.Convert<O, Out>} to
+   * @returns {Schema.Schema<O, In>}
+   */
+  pipe(to) {
+    return pipe(this, to)
+  }
+
   /**
    * @template {string} Kind
    * @param {Kind} [kind]
-   * @returns {Schema.Schema<Schema.Branded<T, Kind>, I>}
+   * @returns {Schema.Schema<Schema.Branded<Out, Kind>, In>}
    */
   brand(kind) {
-    return /** @type {Schema.Schema<Schema.Branded<T, Kind>, I>} */ (this)
+    return /** @type {Schema.Schema<Schema.Branded<Out, Kind>, In>} */ (this)
   }
 
   /**
-   * @param {Schema.NotUndefined<T>} value
-   * @returns {Schema.DefaultSchema<Schema.NotUndefined<T>, I>}
+   * @template {Schema.BlockCodec<Schema.MulticodecCode, In>} Codec
+   * @template {Schema.MultihashHasher<Schema.MulticodecCode>} Hasher
+   * @template {Schema.UnknownLink['version']} Version
+   * @param {{
+   * codec?: Codec
+   * hasher?: Hasher
+   * version?: Version
+   * }} options
+   * @returns {Schema.LinkSchema<Out, Codec['code'], Hasher['code'], Version>}
    */
-  default(value) {
-    // ⚠️ this.from will throw if wrong default is provided
-    const fallback = this.from(value)
-    // we also check that fallback is not undefined because that is the point
-    // of having a fallback
-    if (fallback === undefined) {
-      throw new Error(`Value of type undefined is not a valid default`)
-    }
-
-    const schema = new Default({
-      reader: /** @type {Schema.Reader<T, I>} */ (this),
-      value: /** @type {Schema.NotUndefined<T>} */ (fallback),
+  link({ codec, hasher, version } = {}) {
+    const schema = link({
+      codec,
+      hasher,
+      version,
+      schema: /** @type {Schema.Schema<Out, In>} */ (this),
     })
 
-    return /** @type {Schema.DefaultSchema<Schema.NotUndefined<T>, I>} */ (
-      schema
-    )
+    return schema
+  }
+
+  toSchema() {
+    return this
   }
 }
 
 /**
- * @template [I=unknown]
- * @extends {API<never, I>}
- * @implements {Schema.Schema<never, I>}
+ * @extends {API<never, any>}
+ * @implements {Schema.Schema<never, any>}
  */
 class Never extends API {
   toString() {
     return 'never()'
   }
+
+  /**
+   * @param {never} value
+   */
+  tryTo(value) {
+    return value
+  }
   /**
-   * @param {I} input
+   * @param {any} input
    * @returns {Schema.ReadResult<never>}
    */
-  read(input) {
+  tryFrom(input) {
     return typeError({ expect: 'never', actual: input })
   }
 }
@@ -168,17 +248,22 @@ class Never extends API {
 export const never = () => new Never()
 
 /**
- * @template [I=unknown]
- * @extends API<unknown, I, void>
- * @implements {Schema.Schema<unknown, I>}
+ * @extends API<unknown, unknown, void>
+ * @implements {Schema.Schema<unknown, unknown>}
  */
 class Unknown extends API {
   /**
-   * @param {I} input
+   * @param {unknown} input
    */
-  read(input) {
+  tryFrom(input) {
     return /** @type {Schema.ReadResult<unknown>}*/ ({ ok: input })
   }
+  /**
+   * @param {unknown} output
+   */
+  tryTo(output) {
+    return { ok: output }
+  }
   toString() {
     return 'unknown()'
   }
@@ -186,23 +271,27 @@ class Unknown extends API {
 
 /**
  * @template [I=unknown]
- * @returns {Schema.Schema<unknown, I>}
+ * @returns {Schema.Schema<unknown, unknown>}
  */
 export const unknown = () => new Unknown()
 
 /**
- * @template O
- * @template [I=unknown]
- * @extends {API<null|O, I, Schema.Reader<O, I>>}
- * @implements {Schema.Schema<null|O, I>}
+ * @template I, O
+ * @extends {API<null|O, null|I, Schema.Convert<O, I>>}
+ * @implements {Schema.Schema<null|O, I|null>}
  */
 class Nullable extends API {
   /**
-   * @param {I} input
-   * @param {Schema.Reader<O, I>} reader
+   * @param {I|null} input
+   * @param {Schema.Convert<O, I>} convert
+   * @param {Schema.Region} [region]
    */
-  readWith(input, reader) {
-    const result = reader.read(input)
+  readWith(input, convert, region) {
+    if (input === null) {
+      return { ok: null }
+    }
+
+    const result = convert.tryFrom(input, region)
     if (result.error) {
       return input === null
         ? { ok: null }
@@ -218,6 +307,13 @@ class Nullable extends API {
       return result
     }
   }
+  /**
+   * @param {O|null} output
+   * @param {Schema.Convert<O, I>} writer
+   */
+  writeWith(output, writer) {
+    return output === null ? { ok: null } : writer.tryTo(output)
+  }
   toString() {
     return `${this.settings}.nullable()`
   }
@@ -226,111 +322,179 @@ class Nullable extends API {
 /**
  * @template O
  * @template [I=unknown]
- * @param {Schema.Reader<O, I>} schema
- * @returns {Schema.Schema<O|null, I>}
+ * @param {Schema.Convert<O, I>} schema
+ * @returns {Schema.Schema<O|null, I | null>}
  */
 export const nullable = schema => new Nullable(schema)
 
 /**
  * @template O
- * @template [I=unknown]
- * @extends {API<O|undefined, I, Schema.Reader<O, I>>}
- * @implements {Schema.Schema<O|undefined, I>}
+ * @template I
+ * @extends {API<O|undefined, I|undefined, Schema.Convert<O, I>>}
+ * @implements {Schema.Schema<O|undefined, I|undefined>}
  */
 class Optional extends API {
   optional() {
     return this
   }
   /**
-   * @param {I} input
-   * @param {Schema.Reader<O, I>} reader
+   * @param {I|undefined} input
+   * @param {Schema.Convert<O, I>} convert
+   * @param {Schema.Region} [region]
    * @returns {Schema.ReadResult<O|undefined>}
    */
-  readWith(input, reader) {
-    const result = reader.read(input)
+  readWith(input, convert, region) {
+    if (input === undefined) {
+      return { ok: undefined }
+    }
+    const result = convert.tryFrom(input, region)
     return result.error && input === undefined ? { ok: undefined } : result
   }
+  /**
+   *
+   * @param {O|undefined} output
+   * @param {Schema.Convert} convert
+   */
+  writeWith(output, convert) {
+    return output === undefined ? { ok: undefined } : convert.tryTo(output)
+  }
   toString() {
     return `${this.settings}.optional()`
   }
 }
 
 /**
- * @template {unknown} O
+ * @template O
  * @template [I=unknown]
- * @extends {API<O, I, {reader:Schema.Reader<O, I>, value:O & Schema.NotUndefined<O>}>}
- * @implements {Schema.DefaultSchema<O, I>}
+ * @param {Schema.Convert<O, I>} schema
+ * @returns {Schema.Schema<O|undefined, I|undefined>}
+ */
+export const optional = schema => new Optional(schema)
+
+/**
+ * @template Out
+ * @template In
+ * @extends {API<Exclude<Out, undefined>, In | undefined, {convert:Schema.Convert<Out, In>, value:Exclude<Out, undefined>}>}
+ * @implements {Schema.ImplicitSchema<Out, In>}
  */
-class Default extends API {
+class Implicit extends API {
   /**
-   * @returns {Schema.DefaultSchema<O & Schema.NotUndefined<O>, I>}
+   * @returns {*}
    */
   optional() {
-    // Short circuit here as we there is no point in wrapping this in optional.
-    return /** @type {Schema.DefaultSchema<O & Schema.NotUndefined<O>, I>} */ (
-      this
-    )
+    return /** @type {*} */ (this)
+  }
+
+  /**
+   * @param {Exclude<Out, undefined>} value
+   */
+  implicit(value) {
+    return /** @type {*} */ (implicit(this.settings.convert, value))
   }
+
   /**
-   * @param {I} input
+   * @param {In|undefined} input
    * @param {object} options
-   * @param {Schema.Reader<O|undefined, I>} options.reader
-   * @param {O} options.value
-   * @returns {Schema.ReadResult<O>}
+   * @param {Schema.Convert<Out, In>} options.convert
+   * @param {Exclude<Out, undefined>} options.value
+   * @param {Schema.Region} [region]
+   * @returns {Schema.ReadResult<Exclude<Out, undefined>>}
    */
-  readWith(input, { reader, value }) {
+  readWith(input, { convert, value }, region) {
     if (input === undefined) {
-      return /** @type {Schema.ReadResult<O>} */ ({ ok: value })
+      return { ok: value }
     } else {
-      const result = reader.read(input)
+      const result = convert.tryFrom(input, region)
 
       return result.error
         ? result
-        : result.ok !== undefined
-        ? // We just checked that result.ok is not undefined but still needs
+        : result.ok === undefined
+        ? { ok: value }
+        : // We just checked that result.ok is not undefined but still needs
           // reassurance
-          /** @type {Schema.ReadResult<O>} */ (result)
-        : { ok: value }
+          /** @type {*} */ (result)
     }
   }
+
+  /**
+   *
+   * @param {Exclude<Out, undefined>} output
+   * @param {object} options
+   * @param {Schema.Convert<Out, In>} options.convert
+   */
+  writeWith(output, { convert }) {
+    return convert.tryTo(output)
+  }
   toString() {
-    return `${this.settings.reader}.default(${JSON.stringify(
+    return `${this.settings.convert}.default(${JSON.stringify(
       this.settings.value
     )})`
   }
 
+  /**
+   * @returns {Schema.NotUndefined<Out>}
+   */
   get value() {
-    return this.settings.value
+    return /** @type {Schema.NotUndefined<Out>} */ (this.settings.value)
   }
 }
 
 /**
- * @template O
- * @template [I=unknown]
- * @param {Schema.Reader<O, I>} schema
- * @returns {Schema.Schema<O|undefined, I>}
+ * @template O, I
+ * @template {Exclude<O, undefined>} Q
+ * @param {Schema.Convert<O, I>} schema
+ * @param {Q} value
+ * @returns {Schema.ImplicitSchema<O, I>}
  */
-export const optional = schema => new Optional(schema)
+export const implicit = (schema, value) => {
+  // we also check that fallback is not undefined because that is the point
+  // of having a fallback
+  if (value === undefined) {
+    throw new Error(`Value of type undefined is not a valid default`)
+  }
+
+  const implicit = /** @type {Schema.ImplicitSchema<O, I>} */ (
+    new Implicit({ convert: schema, value })
+  )
+
+  return implicit
+}
 
 /**
- * @template O
- * @template [I=unknown]
- * @extends {API<O[], I, Schema.Reader<O, I>>}
- * @implements {Schema.ArraySchema<O, I>}
+ * @template {Schema.Convert} Convert
+ * @extends {API<Schema.Infer<Convert>[], Schema.InferInput<Convert>[], Convert>}
+ * @implements {Schema.ArraySchema<Convert>}
  */
 class ArrayOf extends API {
   /**
-   * @param {I} input
-   * @param {Schema.Reader<O, I>} schema
+   * @param {Schema.InferInput<Convert>[]} input
+   * @param {Convert} convert
+   * @param {Schema.Region} [context]
    */
-  readWith(input, schema) {
+  readWith(input, convert, context) {
     if (!Array.isArray(input)) {
       return typeError({ expect: 'array', actual: input })
     }
-    /** @type {O[]} */
     const results = []
     for (const [index, value] of input.entries()) {
-      const result = schema.read(value)
+      const result = convert.tryFrom(value, context)
+      if (result.error) {
+        return memberError({ at: index, cause: result.error })
+      } else {
+        results.push(result.ok)
+      }
+    }
+    return { ok: results }
+  }
+  /**
+   *
+   * @param {Schema.Infer<Convert>[]} output
+   * @param {Convert} convert
+   */
+  writeWith(output, convert) {
+    const results = []
+    for (const [index, value] of output.entries()) {
+      const result = convert.tryTo(value)
       if (result.error) {
         return memberError({ at: index, cause: result.error })
       } else {
@@ -339,6 +503,7 @@ class ArrayOf extends API {
     }
     return { ok: results }
   }
+
   get element() {
     return this.settings
   }
@@ -348,27 +513,29 @@ class ArrayOf extends API {
 }
 
 /**
- * @template O
- * @template [I=unknown]
- * @param {Schema.Reader<O, I>} schema
- * @returns {Schema.ArraySchema<O, I>}
+ * @template O, I
+ * @template {Schema.Convert} Schema
+ * @param {Schema} schema
+ * @returns {Schema.ArraySchema<Schema>}
  */
-export const array = schema => new ArrayOf(schema)
+export const array = schema => {
+  const out = new ArrayOf(schema)
+  return out
+}
 
 /**
- * @template {Schema.Reader<unknown, I>} T
- * @template {[T, ...T[]]} U
- * @template [I=unknown]
- * @extends {API<Schema.InferTuple<U>, I, U>}
- * @implements {Schema.Schema<Schema.InferTuple<U>, I>}
+ * @template {[Schema.Convert, ...Schema.Convert[]]} Shape
+ * @extends {API<Schema.InferTuple<Shape>, Schema.InferTupleInput<Shape>, Shape>}
+ * @implements {Schema.Schema<Schema.InferTuple<Shape>, Schema.InferTupleInput<Shape>>}
  */
 class Tuple extends API {
   /**
-   * @param {I} input
-   * @param {U} shape
-   * @returns {Schema.ReadResult<Schema.InferTuple<U>>}
+   * @param {Schema.InferTupleInput<Shape>} input
+   * @param {Shape} shape
+   * @param {Schema.Region} [context]
+   * @returns {Schema.ReadResult<Schema.InferTuple<Shape>>}
    */
-  readWith(input, shape) {
+  readWith(input, shape, context) {
     if (!Array.isArray(input)) {
       return typeError({ expect: 'array', actual: input })
     }
@@ -378,7 +545,34 @@ class Tuple extends API {
 
     const results = []
     for (const [index, reader] of shape.entries()) {
-      const result = reader.read(input[index])
+      const result = reader.tryFrom(input[index], context)
+      if (result.error) {
+        return memberError({ at: index, cause: result.error })
+      } else {
+        results[index] = result.ok
+      }
+    }
+
+    return { ok: /** @type {Schema.InferTuple<Shape>} */ (results) }
+  }
+  /**
+   *
+   * @param {Schema.InferTuple<Shape>} output
+   * @param {Shape} shape
+   * @returns {Schema.ReadResult<Schema.InferTupleInput<Shape>>}
+   */
+  writeWith(output, shape) {
+    if (!Array.isArray(output)) {
+      return typeError({ expect: 'array', actual: output })
+    }
+
+    if (output.length !== this.shape.length) {
+      return error(`Array must contain exactly ${this.shape.length} elements`)
+    }
+
+    const results = []
+    for (const [index, writer] of shape.entries()) {
+      const result = writer.tryTo(output[index])
       if (result.error) {
         return memberError({ at: index, cause: result.error })
       } else {
@@ -386,43 +580,42 @@ class Tuple extends API {
       }
     }
 
-    return { ok: /** @type {Schema.InferTuple<U>} */ (results) }
+    return { ok: /** @type {Schema.InferTupleInput<Shape>} */ (results) }
   }
 
-  /** @type {U} */
+  /** @type {Shape} */
   get shape() {
     return this.settings
   }
 
   toString() {
-    return `tuple([${this.shape.map(reader => reader.toString()).join(', ')}])`
+    return `tuple([${this.shape.map(member => member.toString()).join(', ')}])`
   }
 }
 
 /**
- * @template {Schema.Reader<unknown, I>} T
- * @template {[T, ...T[]]} U
- * @template [I=unknown]
- * @param {U} shape
- * @returns {Schema.Schema<Schema.InferTuple<U>, I>}
+ * @template {[Schema.Convert, ...Schema.Convert[]]} Shape
+ * @param {Shape} shape
+ * @returns {Schema.Schema<Schema.InferTuple<Shape>, Schema.InferTupleInput<Shape>>}
  */
 export const tuple = shape => new Tuple(shape)
 
 /**
  * @template V
  * @template {string} K
- * @template [I=unknown]
- * @extends {API<Schema.Dictionary<K, V>, I, { key: Schema.Reader<K, string>, value: Schema.Reader<V, I> }>}
- * @implements {Schema.DictionarySchema<V, K, I>}
+ * @template U
+ * @extends {API<Schema.Dictionary<K, V>, Schema.Dictionary<K, U>, { key: Schema.From<K, string>, value: Schema.Convert<V, U> }>}
+ * @implements {Schema.DictionarySchema<V, K, U>}
  */
 class Dictionary extends API {
   /**
-   * @param {I} input
+   * @param {Schema.Dictionary<K, U>} input
    * @param {object} schema
-   * @param {Schema.Reader<K, string>} schema.key
-   * @param {Schema.Reader<V, I>} schema.value
+   * @param {Schema.From<K, string>} schema.key
+   * @param {Schema.From<V, U>} schema.value
+   * @param {Schema.Region} [context]
    */
-  readWith(input, { key, value }) {
+  readWith(input, { key, value }, context) {
     if (typeof input != 'object' || input === null || Array.isArray(input)) {
       return typeError({
         expect: 'dictionary',
@@ -433,12 +626,42 @@ class Dictionary extends API {
     const dict = /** @type {Schema.Dictionary<K, V>} */ ({})
 
     for (const [k, v] of Object.entries(input)) {
-      const keyResult = key.read(k)
+      const keyResult = key.tryFrom(k, context)
+      if (keyResult.error) {
+        return memberError({ at: k, cause: keyResult.error })
+      }
+
+      const valueResult = value.tryFrom(v, context)
+      if (valueResult.error) {
+        return memberError({ at: k, cause: valueResult.error })
+      }
+
+      // skip undefined because they mess up CBOR and are generally useless.
+      if (valueResult.ok !== undefined) {
+        dict[keyResult.ok] = valueResult.ok
+      }
+    }
+
+    return { ok: dict }
+  }
+
+  /**
+   *
+   * @param {Schema.Dictionary<K, V>} output
+   * @param {object} schema
+   * @param {Schema.From<K, string>} schema.key
+   * @param {Schema.To<V, U>} schema.value
+   */
+  writeWith(output, { key, value }) {
+    const dict = /** @type {Schema.Dictionary<K, U>} */ ({})
+
+    for (const [k, v] of Object.entries(output)) {
+      const keyResult = key.tryFrom(k)
       if (keyResult.error) {
         return memberError({ at: k, cause: keyResult.error })
       }
 
-      const valueResult = value.read(v)
+      const valueResult = value.tryTo(/** @type {V} */ (v))
       if (valueResult.error) {
         return memberError({ at: k, cause: valueResult.error })
       }
@@ -460,10 +683,11 @@ class Dictionary extends API {
 
   partial() {
     const { key, value } = this.settings
-    return new Dictionary({
+    const partial = new Dictionary({
       key,
       value: optional(value),
     })
+    return /** @type {*} */ (partial)
   }
   toString() {
     return `dictionary(${this.settings})`
@@ -473,37 +697,48 @@ class Dictionary extends API {
 /**
  * @template {string} K
  * @template {unknown} V
- * @template [I=unknown]
+ * @template {unknown} U
  * @param {object} shape
- * @param {Schema.Reader<V, I>} shape.value
- * @param {Schema.Reader<K, string>} [shape.key]
- * @returns {Schema.DictionarySchema<V, K, I>}
+ * @param {Schema.Convert<V, U>} shape.value
+ * @param {Schema.From<K, string>} [shape.key]
+ * @returns {Schema.DictionarySchema<V, K, U>}
  */
 export const dictionary = ({ value, key }) =>
   new Dictionary({
     value,
-    key: key || /** @type {Schema.Reader<K, string>} */ (string()),
+    key: key || /** @type {Schema.From<K, string>} */ (string()),
   })
 
 /**
- * @template {[unknown, ...unknown[]]} T
- * @template [I=unknown]
- * @extends {API<T[number], I, {type: string, variants:Set<T[number]>}>}
- * @implements {Schema.Schema<T[number], I>}
+ * @template {string} T
+ * @template {[T, ...T[]]} U
+ * @extends {API<U[number], string, {type: string, variants:Set<U[number]>}>}
+ * @implements {Schema.Schema<U[number], string>}
  */
 class Enum extends API {
   /**
-   * @param {I} input
-   * @param {{type:string, variants:Set<T[number]>}} settings
-   * @returns {Schema.ReadResult<T[number]>}
+   * @param {string} input
+   * @param {{type:string, variants:Set<U[number]>}} settings
+   * @returns {Schema.ReadResult<U[number]>}
    */
   readWith(input, { variants, type }) {
-    if (variants.has(input)) {
-      return /** @type {Schema.ReadResult<T[number]>} */ ({ ok: input })
+    if (variants.has(/** @type {T} */ (input))) {
+      return /** @type {Schema.ReadResult<U[number]>} */ ({ ok: input })
     } else {
       return typeError({ expect: type, actual: input })
     }
   }
+  /**
+   * @param {U[number]} output
+   * @param {{type:string, variants:Set<T[number]>}} settings
+   */
+  writeWith(output, settings) {
+    if (settings.variants.has(output)) {
+      return { ok: output }
+    } else {
+      return typeError({ expect: settings.type, actual: output })
+    }
+  }
   toString() {
     return this.settings.type
   }
@@ -514,7 +749,7 @@ class Enum extends API {
  * @template {[T, ...T[]]} U
  * @template [I=unknown]
  * @param {U} variants
- * @returns {Schema.Schema<U[number], I>}
+ * @returns {Schema.Schema<U[number], string>}
  */
 const createEnum = variants =>
   new Enum({
@@ -524,73 +759,90 @@ const createEnum = variants =>
 export { createEnum as enum }
 
 /**
- * @template {Schema.Reader<unknown, I>} T
- * @template {[T, ...T[]]} U
- * @template [I=unknown]
- * @extends {API<Schema.InferUnion<U>, I, U>}
- * @implements {Schema.Schema<Schema.InferUnion<U>, I>}
+ * @template {[Schema.Convert, ...Schema.Convert[]]} Members
+ * @extends {API<Schema.InferUnion<Members>, Schema.InferUnionInput<Members>, Members>}
+ * @implements {Schema.Schema<Schema.InferUnion<Members>, Schema.InferUnionInput<Members>>}
  */
 class Union extends API {
   /**
-   * @param {I} input
-   * @param {U} variants
+   * @param {Schema.InferUnionInput<Members>} input
+   * @param {Members} variants
+   * @param {Schema.Region} [context]
    */
-  readWith(input, variants) {
+  readWith(input, variants, context) {
     const causes = []
     for (const reader of variants) {
-      const result = reader.read(input)
+      const result = reader.tryFrom(input, context)
+      if (result.error) {
+        causes.push(result.error)
+      } else {
+        return /** @type {Schema.ReadResult<Schema.InferUnion<Members>>} */ (
+          result
+        )
+      }
+    }
+    return { error: new UnionError({ causes }) }
+  }
+  /**
+   * @param {Schema.InferUnion<Members>} output
+   * @param {Members} variants
+   */
+  writeWith(output, variants) {
+    const causes = []
+    for (const member of variants) {
+      const result = member.tryTo(output)
       if (result.error) {
         causes.push(result.error)
       } else {
-        return /** @type {Schema.ReadResult<Schema.InferUnion<U>>} */ (result)
+        return /** @type {Schema.ReadResult<Schema.InferUnionInput<Members>>} */ (
+          result
+        )
       }
     }
     return { error: new UnionError({ causes }) }
   }
 
-  get variants() {
+  get members() {
     return this.settings
   }
   toString() {
-    return `union([${this.variants.map(type => type.toString()).join(', ')}])`
+    return `union([${this.members
+      .map(member => member.toString())
+      .join(', ')}])`
   }
 }
 
 /**
- * @template {Schema.Reader<unknown, I>} T
- * @template {[T, ...T[]]} U
- * @template [I=unknown]
- * @param {U} variants
- * @returns {Schema.Schema<Schema.InferUnion<U>, I>}
+ * @template {[Schema.Convert, ...Schema.Convert[]]} Members
+ * @param {Members} members
+ * @returns {Schema.Schema<Schema.InferUnion<Members>, Schema.InferUnionInput<Members>>}
  */
-const union = variants => new Union(variants)
+const union = members => new Union(members)
 
 /**
- * @template T, U
- * @template [I=unknown]
- * @param {Schema.Reader<T, I>} left
- * @param {Schema.Reader<U, I>} right
- * @returns {Schema.Schema<T|U, I>}
+ * @template O, Q, I, J
+ * @param {Schema.Convert<O, I>} left
+ * @param {Schema.Convert<Q, J>} right
+ * @returns {Schema.Schema<O|Q, I|J>}
  */
 export const or = (left, right) => union([left, right])
 
 /**
- * @template {Schema.Reader<unknown, I>} T
- * @template {[T, ...T[]]} U
- * @template [I=unknown]
- * @extends {API<Schema.InferIntersection<U>, I, U>}
- * @implements {Schema.Schema<Schema.InferIntersection<U>, I>}
+ * @template {[Schema.Convert, ...Schema.Convert[]]} Members
+ * @extends {API<Schema.InferIntersection<Members>, Schema.InferIntersectionInput<Members>, Members>}
+ * @implements {Schema.Schema<Schema.InferIntersection<Members>, Schema.InferIntersectionInput<Members>>}
  */
 class Intersection extends API {
   /**
-   * @param {I} input
-   * @param {U} schemas
-   * @returns {Schema.ReadResult<Schema.InferIntersection<U>>}
+   * @param {Schema.InferIntersectionInput<Members>} input
+   * @param {Members} schemas
+   * @param {Schema.Region} [context]
+   * @returns {Schema.ReadResult<Schema.InferIntersection<Members>>}
    */
-  readWith(input, schemas) {
+  readWith(input, schemas, context) {
     const causes = []
     for (const schema of schemas) {
-      const result = schema.read(input)
+      const result = schema.tryFrom(input, context)
       if (result.error) {
         causes.push(result.error)
       }
@@ -598,44 +850,86 @@ class Intersection extends API {
 
     return causes.length > 0
       ? { error: new IntersectionError({ causes }) }
-      : /** @type {Schema.ReadResult<Schema.InferIntersection<U>>} */ ({
+      : /** @type {Schema.ReadResult<Schema.InferIntersection<Members>>} */ ({
           ok: input,
         })
   }
+  /**
+   * @param {Schema.InferIntersection<Members>} output
+   * @param {Members} members
+   * @returns {Schema.ReadResult<Schema.InferIntersectionInput<Members>>}
+   */
+  writeWith(output, members) {
+    const causes = []
+    for (const member of members) {
+      const result = member.tryTo(output)
+      if (result.error) {
+        causes.push(result.error)
+      }
+    }
+
+    return causes.length > 0
+      ? { error: new IntersectionError({ causes }) }
+      : /** @type {Schema.ReadResult<Schema.InferIntersectionInput<Members>>} */ ({
+          ok: output,
+        })
+  }
+  get members() {
+    return this.settings
+  }
   toString() {
-    return `intersection([${this.settings
-      .map(type => type.toString())
+    return `intersection([${this.members
+      .map(member => member.toString())
       .join(',')}])`
   }
 }
 
 /**
- * @template {Schema.Reader<unknown, I>} T
- * @template {[T, ...T[]]} U
- * @template [I=unknown]
- * @param {U} variants
- * @returns {Schema.Schema<Schema.InferIntersection<U>, I>}
+ * @template {[Schema.Convert, ...Schema.Convert[]]} Members
+ * @param {Members} members
+ * @returns {Schema.Schema<Schema.InferIntersection<Members>, Schema.InferIntersectionInput<Members>>}
  */
-export const intersection = variants => new Intersection(variants)
+export const intersection = members => new Intersection(members)
 
 /**
- * @template T, U
- * @template [I=unknown]
- * @param {Schema.Reader<T, I>} left
- * @param {Schema.Reader<U, I>} right
- * @returns {Schema.Schema<T & U, I>}
+ * @template O, Q, I, J
+ * @param {Schema.Convert<O, I>} left
+ * @param {Schema.Convert<Q, J>} right
+ * @returns {Schema.Schema<O & Q, I & J>}
  */
 export const and = (left, right) => intersection([left, right])
 
 /**
- * @template [I=unknown]
- * @extends {API<boolean, I>}
+ * @template {string|number|boolean|null} Type
+ * @template {string} Name
+ * @extends {API<Type, Type, {name: Name, cast(input:Type): Schema.ReadResult<Type>}>}
  */
-class Boolean extends API {
+class Scalar extends API {
   /**
-   * @param {I} input
+   * @param {Type} input
+   * @param {typeof this.settings} settings
    */
-  readWith(input) {
+  readWith(input, { cast }) {
+    return cast(input)
+  }
+  /**
+   * @param {Type} output
+   * @param {typeof this.settings} settings
+   */
+  writeWith(output, { cast }) {
+    return cast(output)
+  }
+  toString() {
+    return `${this.settings.name}()`
+  }
+}
+
+export const Boolean = new Scalar({
+  name: 'boolean',
+  /**
+   * @param {boolean} input
+   */
+  cast(input) {
     switch (input) {
       case true:
       case false:
@@ -646,229 +940,290 @@ class Boolean extends API {
           actual: input,
         })
     }
-  }
-
-  toString() {
-    return `boolean()`
-  }
-}
-
-/** @type {Schema.Schema<boolean, unknown>} */
-const anyBoolean = new Boolean()
-
-export const boolean = () => anyBoolean
+  },
+})
+export const boolean = () => Boolean
 
 /**
- * @template {number} [O=number]
- * @template [I=unknown]
+ * @template {number} Out
+ * @template {number} In
  * @template [Settings=void]
- * @extends {API<O, I, Settings>}
- * @implements {Schema.NumberSchema<O, I>}
+ * @extends {API<Out, In, Settings>}
+ * @implements {Schema.NumberSchema<Out, In>}
  */
-class UnknownNumber extends API {
+class NumberSchema extends API {
+  isInteger = globalThis.Number.isInteger
+  isFinite = globalThis.Number.isFinite
+
+  /**
+   * @param {(input: Out) => Schema.ReadResult<Out>} check
+   * @returns {Schema.NumberSchema<Out, In>}
+   */
+  constraint(check) {
+    return this.refine({
+      tryFrom: check,
+      tryTo: check,
+    })
+  }
+
   /**
    * @param {number} n
    */
   greaterThan(n) {
-    return this.refine(greaterThan(n))
+    return this.constraint(number => {
+      if (number > n) {
+        return { ok: number }
+      } else {
+        return error(`Expected ${number} > ${n}`)
+      }
+    })
   }
   /**
    * @param {number} n
    */
   lessThan(n) {
-    return this.refine(lessThan(n))
+    return this.constraint(number => {
+      if (number < n) {
+        return { ok: number }
+      } else {
+        return error(`Expected ${number} < ${n}`)
+      }
+    })
   }
 
   /**
-   * @template {O} U
-   * @param {Schema.Reader<U, O>} schema
-   * @returns {Schema.NumberSchema<U, I>}
+   * @template {Out} O
+   * @template {Out} I
+   * @param {Schema.Convert<O, I>} convert
+   * @returns {Schema.NumberSchema<O, In>}
    */
-  refine(schema) {
-    return new RefinedNumber({ base: this, schema })
+  refine(convert) {
+    return new RefinedNumber({ schema: this, refine: convert })
   }
-}
 
-/**
- * @template [I=unknown]
- * @extends {UnknownNumber<number, I>}
- * @implements {Schema.NumberSchema<number, I>}
- */
-class AnyNumber extends UnknownNumber {
   /**
-   * @param {I} input
-   * @returns {Schema.ReadResult<number>}
+   * @param {In} input
+   * @param {Settings} settings
+   * @returns {Schema.ReadResult<Out>}
    */
-  readWith(input) {
+  readWith(input, settings) {
     return typeof input === 'number'
-      ? { ok: input }
+      ? { ok: /** @type {*} */ (input) }
       : typeError({ expect: 'number', actual: input })
   }
+  /**
+   * @param {Out} output
+   * @param {Settings} settings
+   * @returns {Schema.ReadResult<In>}
+   */
+  writeWith(output, settings) {
+    return typeof output === 'number'
+      ? { ok: /** @type {*} */ (output) }
+      : typeError({ expect: 'number', actual: output })
+  }
   toString() {
     return `number()`
   }
 }
 
-/** @type {Schema.NumberSchema<number, unknown>} */
-const anyNumber = new AnyNumber()
-export const number = () => anyNumber
+/** @type {Schema.NumberSchema<number, number>} */
+export const Number = new NumberSchema(undefined)
+export const number = () => Number
 
 /**
- * @template {number} [T=number]
- * @template {T} [O=T]
- * @template [I=unknown]
- * @extends {UnknownNumber<O, I, {base:Schema.Reader<T, I>, schema:Schema.Reader<O, T>}>}
- * @implements {Schema.NumberSchema<O, I>}
+ * @template {number} Out
+ * @template {number} In
+ * @template {Out} O
+ * @template {Out} I
+ * @extends {NumberSchema<O, In, {schema: Schema.Convert<Out, In>, refine:Schema.From<O, I>}>}
+ * @implements {Schema.NumberSchema<O, In>}
  */
-class RefinedNumber extends UnknownNumber {
+class RefinedNumber extends NumberSchema {
   /**
-   * @param {I} input
-   * @param {{base:Schema.Reader<T, I>, schema:Schema.Reader<O, T>}} settings
+   * @param {In} input
+   * @param {{schema: Schema.Convert<Out, In>, refine: Schema.Convert<O, I> } } settings
    * @returns {Schema.ReadResult<O>}
    */
-  readWith(input, { base, schema }) {
-    const result = base.read(input)
-    return result.error ? result : schema.read(result.ok)
+  readWith(input, { schema, refine }) {
+    const result = schema.tryFrom(input)
+    return result.error ? result : refine.tryFrom(/** @type {I} */ (result.ok))
   }
-  toString() {
-    return `${this.settings.base}.refine(${this.settings.schema})`
-  }
-}
 
-/**
- * @template {number} T
- * @extends {API<T, T, number>}
- */
-class LessThan extends API {
   /**
-   * @param {T} input
-   * @param {number} number
-   * @returns {Schema.ReadResult<T>}
+   * @param {O} output
+   * @param {{schema: Schema.Convert<Out, In>, refine: Schema.Convert<O, I> } } settings
    */
-  readWith(input, number) {
-    if (input < number) {
-      return { ok: input }
-    } else {
-      return error(`Expected ${input} < ${number}`)
-    }
+  writeWith(output, { schema, refine }) {
+    const result = refine.tryTo(output)
+    return result.error ? result : schema.tryTo(result.ok)
   }
-  toString() {
-    return `lessThan(${this.settings})`
-  }
-}
-
-/**
- * @template {number} T
- * @param {number} n
- * @returns {Schema.Schema<T, T>}
- */
-export const lessThan = n => new LessThan(n)
 
-/**
- * @template {number} T
- * @extends {API<T, T, number>}
- */
-class GreaterThan extends API {
-  /**
-   * @param {T} input
-   * @param {number} number
-   * @returns {Schema.ReadResult<T>}
-   */
-  readWith(input, number) {
-    if (input > number) {
-      return { ok: input }
-    } else {
-      return error(`Expected ${input} > ${number}`)
-    }
-  }
   toString() {
-    return `greaterThan(${this.settings})`
+    return `${this.settings.schema}.refine(${this.settings.refine})`
   }
 }
 
 /**
- * @template {number} T
- * @param {number} n
- * @returns {Schema.Schema<T, T>}
+ * @extends {NumberSchema<Schema.Integer, number, void>}
  */
-export const greaterThan = n => new GreaterThan(n)
-
-const Integer = {
+class IntegerSchema extends NumberSchema {
   /**
-   * @param {number} input
+   * @param {number} number
    * @returns {Schema.ReadResult<Schema.Integer>}
    */
-  read(input) {
-    return Number.isInteger(input)
-      ? { ok: /** @type {Schema.Integer} */ (input) }
+  static validate(number) {
+    return Number.isInteger(number)
+      ? { ok: /** @type {Schema.Integer} */ (number) }
       : typeError({
           expect: 'integer',
-          actual: input,
+          actual: number,
         })
-  },
+  }
+  /**
+   * @param {number} number
+   * @returns {Schema.ReadResult<Schema.Integer>}
+   */
+  tryFrom(number) {
+    return IntegerSchema.validate(number)
+  }
+  /**
+   * @param {Schema.Integer} number
+   * @returns {Schema.ReadResult<number>}
+   */
+  tryTo(number) {
+    return IntegerSchema.validate(number)
+  }
   toString() {
     return `Integer`
-  },
+  }
 }
+/** @type {Schema.NumberSchema<Schema.Integer, number>} */
+const Integer = new IntegerSchema()
+export const integer = () => Integer
 
-const anyInteger = anyNumber.refine(Integer)
-export const integer = () => anyInteger
-
-const Float = {
+/**
+ * @extends {NumberSchema<Schema.Float, number, void>}
+ */
+class FloatSchema extends NumberSchema {
   /**
    * @param {number} number
    * @returns {Schema.ReadResult<Schema.Float>}
    */
-  read(number) {
+  static validate(number) {
     return Number.isFinite(number)
       ? { ok: /** @type {Schema.Float} */ (number) }
       : typeError({
           expect: 'Float',
           actual: number,
         })
-  },
+  }
+  /**
+   * @param {number} number
+   * @returns {Schema.ReadResult<Schema.Float>}
+   */
+  tryFrom(number) {
+    return FloatSchema.validate(number)
+  }
+  /**
+   * @param {Schema.Float} number
+   * @returns {Schema.ReadResult<Schema.Float>}
+   */
+  tryTo(number) {
+    return FloatSchema.validate(number)
+  }
   toString() {
     return 'Float'
-  },
+  }
 }
 
-const anyFloat = anyNumber.refine(Float)
-export const float = () => anyFloat
+const Float = new FloatSchema()
+export const float = () => Float
 
 /**
- * @template {string} [O=string]
- * @template [I=unknown]
+ * @template {string} Out
+ * @template {string} In
  * @template [Settings=void]
- * @extends {API<O, I, Settings>}
+ * @extends {API<Out, In, Settings>}
+ * @implements {Schema.StringSchema<Out, In>}
  */
-class UnknownString extends API {
+class StringSchema extends API {
+  /**
+   * @template {string} Source
+   * @param {Source} source
+   * @returns {Schema.ReadResult<Source>}
+   */
+  static validate(source) {
+    return typeof source === 'string'
+      ? { ok: source }
+      : typeError({ expect: 'string', actual: source })
+  }
+  /**
+   * @param {In} input
+   * @param {Settings} settings
+   * @returns {Schema.ReadResult<Out>}
+   */
+  readWith(input, settings) {
+    return StringSchema.validate(/** @type {In & Out} */ (input))
+  }
+
+  /**
+   * @param {Out} input
+   * @param {Settings} settings
+   * @returns {Schema.ReadResult<In>}
+   */
+  writeWith(input, settings) {
+    return StringSchema.validate(/** @type {In & Out} */ (input))
+  }
+
   /**
-   * @template {O|unknown} U
-   * @param {Schema.Reader<U, O>} schema
-   * @returns {Schema.StringSchema<O & U, I>}
+   * @template {Out} O
+   * @template {Out} I
+   * @param {Schema.Convert<O, I>} schema
+   * @returns {Schema.StringSchema<O, In>}
    */
   refine(schema) {
-    const other = /** @type {Schema.Reader<U, O>} */ (schema)
-    const rest = new RefinedString({
+    const refined = new RefinedString({
       base: this,
-      schema: other,
+      schema,
     })
 
-    return /** @type {Schema.StringSchema<O & U, I>} */ (rest)
+    return /** @type {Schema.StringSchema<O, In>} */ (refined)
+  }
+
+  /**
+   * @param {(value: Out) => Schema.ReadResult<Out>} check
+   * @returns {Schema.StringSchema<Out, In>}
+   */
+  constraint(check) {
+    return this.refine({
+      tryFrom: check,
+      tryTo: check,
+    })
   }
   /**
    * @template {string} Prefix
    * @param {Prefix} prefix
    */
   startsWith(prefix) {
-    return this.refine(startsWith(prefix))
+    const constraint =
+      /** @type {Schema.Convert<Out & `${Prefix}${string}`, Out>} */ (
+        startsWith(prefix)
+      )
+
+    return this.refine(constraint)
   }
+
   /**
    * @template {string} Suffix
    * @param {Suffix} suffix
    */
   endsWith(suffix) {
-    return this.refine(endsWith(suffix))
+    const constraint =
+      /** @type {Schema.Convert<Out & `${string}${Suffix}`, Out>} */ (
+        endsWith(suffix)
+      )
+
+    return this.refine(constraint)
   }
   toString() {
     return `string()`
@@ -876,86 +1231,57 @@ class UnknownString extends API {
 }
 
 /**
- * @template O
- * @template {string} [T=string]
- * @template [I=unknown]
- * @extends {UnknownString<T & O, I, {base:Schema.Reader<T, I>, schema:Schema.Reader<O, T>}>}
- * @implements {Schema.StringSchema<O & T, I>}
+ * @template {string} Out
+ * @template {string} In
+ * @template {Out} O
+ * @template {Out} I
+ * @extends {StringSchema<O, In, {base:Schema.Convert<Out, In>, schema:Schema.Convert<O, I>}>}
+ * @implements {Schema.StringSchema<O, In>}
  */
-class RefinedString extends UnknownString {
+class RefinedString extends StringSchema {
   /**
-   * @param {I} input
-   * @param {{base:Schema.Reader<T, I>, schema:Schema.Reader<O, T>}} settings
-   * @returns {Schema.ReadResult<T & O>}
+   * @param {In} input
+   * @param {{base:Schema.From<Out, In>, schema:Schema.From<O, I>}} settings
+   * @returns {Schema.ReadResult<O>}
    */
   readWith(input, { base, schema }) {
-    const result = base.read(input)
-    return result.error
-      ? result
-      : /** @type {Schema.ReadResult<T & O>} */ (schema.read(result.ok))
-  }
-  toString() {
-    return `${this.settings.base}.refine(${this.settings.schema})`
+    const result = base.tryFrom(input)
+    return result.error ? result : schema.tryFrom(/** @type {I} */ (result.ok))
   }
-}
 
-/**
- * @template [I=unknown]
- * @extends {UnknownString<string, I>}
- * @implements {Schema.StringSchema<string, I>}
- */
-class AnyString extends UnknownString {
   /**
-   * @param {I} input
-   * @returns {Schema.ReadResult<string>}
+   * @param {O} output
+   * @param {{base:Schema.To<Out, In>, schema:Schema.To<O, I>}} settings
+   * @returns {Schema.ReadResult<In>}
    */
-  readWith(input) {
-    return typeof input === 'string'
-      ? { ok: input }
-      : typeError({ expect: 'string', actual: input })
+  writeWith(output, { base, schema }) {
+    const result = schema.tryTo(output)
+    return result.error ? result : base.tryTo(result.ok)
   }
-}
 
-/** @type {Schema.StringSchema<string, unknown>} */
-const anyString = new AnyString()
-export const string = () => anyString
-
-/**
- * @template [I=unknown]
- * @extends {API<Uint8Array, I, void>}
- */
-class BytesSchema extends API {
-  /**
-   * @param {I} input
-   * @returns {Schema.ReadResult<Uint8Array>}
-   */
-  readWith(input) {
-    if (input instanceof Uint8Array) {
-      return { ok: input }
-    } else {
-      return typeError({ expect: 'Uint8Array', actual: input })
-    }
+  toString() {
+    return `${this.settings.base}.refine(${this.settings.schema})`
   }
 }
 
-/** @type {Schema.Schema<Uint8Array, unknown>} */
-export const Bytes = new BytesSchema()
-export const bytes = () => Bytes
+/** @type {Schema.StringSchema<string, string>} */
+export const String = new StringSchema(undefined)
+export const string = () => String
 
 /**
  * @template {string} Prefix
- * @template {string} Body
- * @extends {API<Body & `${Prefix}${Body}`, Body, Prefix>}
- * @implements {Schema.Schema<Body & `${Prefix}${Body}`, Body>}
+ * @template {string} In
+ * @extends {API<`${Prefix}${string}` & In, In, Prefix>}
+ * @implements {Schema.Schema<`${Prefix}${string}` & In, In>}
  */
 class StartsWith extends API {
   /**
-   * @param {Body} input
+   * @param {In} input
    * @param {Prefix} prefix
    */
   readWith(input, prefix) {
     const result = input.startsWith(prefix)
-      ? /** @type {Schema.ReadResult<Body & `${Prefix}${Body}`>} */ ({
+      ? /** @type {Schema.ReadResult<`${Prefix}${string}` & In>} */ ({
           ok: input,
         })
       : error(`Expect string to start with "${prefix}" instead got "${input}"`)
@@ -972,16 +1298,16 @@ class StartsWith extends API {
 
 /**
  * @template {string} Prefix
- * @template {string} Body
+ * @template {string} Input
  * @param {Prefix} prefix
- * @returns {Schema.Schema<`${Prefix}${string}`, string>}
+ * @returns {Schema.Schema<Input & `${Prefix}${string}`, Input>}
  */
 export const startsWith = prefix => new StartsWith(prefix)
 
 /**
  * @template {string} Suffix
  * @template {string} Body
- * @extends {API<Body & `${Body}${Suffix}`, Body, Suffix>}
+ * @extends {API<Body & `${string}${Suffix}`, Body, Suffix>}
  */
 class EndsWith extends API {
   /**
@@ -990,7 +1316,7 @@ class EndsWith extends API {
    */
   readWith(input, suffix) {
     return input.endsWith(suffix)
-      ? /** @type {Schema.ReadResult<Body & `${Body}${Suffix}`>} */ ({
+      ? /** @type {Schema.ReadResult<Body & `${string}${Suffix}`>} */ ({
           ok: input,
         })
       : error(`Expect string to end with "${suffix}" instead got "${input}"`)
@@ -1005,27 +1331,40 @@ class EndsWith extends API {
 
 /**
  * @template {string} Suffix
+ * @template {string} Input
  * @param {Suffix} suffix
- * @returns {Schema.Schema<`${string}${Suffix}`, string>}
+ * @returns {Schema.Schema<`${string}${Suffix}` & Input, Input>}
  */
 export const endsWith = suffix => new EndsWith(suffix)
 
 /**
- * @template T
- * @template {T} U
- * @template [I=unknown]
- * @extends {API<U, I, { base: Schema.Reader<T, I>, schema: Schema.Reader<U, T> }>}
- * @implements {Schema.Schema<U, I>}
+ * @template Out
+ * @template {Out} O
+ * @template {Out} I
+ * @template In
+ * @extends {API<O, In, { base: Schema.Convert<Out, In>, schema: Schema.Convert<O, I> }>}
+ * @implements {Schema.Schema<O, In>}
  */
 
 class Refine extends API {
   /**
-   * @param {I} input
-   * @param {{ base: Schema.Reader<T, I>, schema: Schema.Reader<U, T> }} settings
+   * @param {In} input
+   * @param {{ base: Schema.Convert<Out, In>, schema: Schema.Convert<O, I> }} settings
+   * @param {Schema.Region} [context]
    */
-  readWith(input, { base, schema }) {
-    const result = base.read(input)
-    return result.error ? result : schema.read(result.ok)
+  readWith(input, { base, schema }, context) {
+    const result = base.tryFrom(input, context)
+    return result.error
+      ? result
+      : schema.tryFrom(/** @type {I} */ (result.ok), context)
+  }
+  /**
+   * @param {O} output
+   * @param {{ base: Schema.Convert<Out, In>, schema: Schema.Convert<O, I> }} settings
+   */
+  writeWith(output, { base, schema }) {
+    const result = schema.tryTo(output)
+    return result.error ? result : base.tryTo(/** @type {Out} */ (result.ok))
   }
   toString() {
     return `${this.settings.base}.refine(${this.settings.schema})`
@@ -1033,26 +1372,67 @@ class Refine extends API {
 }
 
 /**
- * @template T
- * @template {T} U
- * @template [I=unknown]
- * @param {Schema.Reader<T, I>} base
- * @param {Schema.Reader<U, T>} schema
- * @returns {Schema.Schema<U, I>}
+ * @template {Out} O
+ * @template {Out} I
+ * @template Out
+ * @template In
+ * @param {Schema.Convert<Out, In>} base
+ * @param {Schema.Convert<O, I>} schema
+ * @returns {Schema.Schema<O, In>}
  */
 export const refine = (base, schema) => new Refine({ base, schema })
 
 /**
- * @template {null|boolean|string|number} T
- * @template [I=unknown]
- * @extends {API<T, I, T>}
- * @implements {Schema.LiteralSchema<T, I>}
+ * @template Into
+ * @template Out
+ * @template In
+ * @extends {API<Into, In, { from: Schema.Convert<Out, In>, to: Schema.Convert<Into, Out> }>}
+ * @implements {Schema.Schema<Into, In>}
+ */
+class Pipe extends API {
+  /**
+   * @param {In} input
+   * @param {{ from: Schema.From<Out, In>, to: Schema.From<Into, Out> }} settings
+   * @param {Schema.Region} [context]
+   */
+  readWith(input, { from, to }, context) {
+    const result = from.tryFrom(input, context)
+    return result.error ? result : to.tryFrom(result.ok, context)
+  }
+  /**
+   * @param {Into} output
+   * @param {{ from: Schema.To<Out, In>, to: Schema.To<Into, Out> }} settings
+   */
+  writeWith(output, { from, to }) {
+    const result = to.tryTo(output)
+    return result.error ? result : from.tryTo(result.ok)
+  }
+  toString() {
+    return `${this.settings.from}.pipe(${this.settings.to})`
+  }
+}
+
+/**
+ * @template Into
+ * @template Out
+ * @template In
+ * @param {Schema.Convert<Out, In>} from
+ * @param {Schema.Convert<Into, Out>} to
+ * @returns {Schema.Schema<Into, In>}
+ */
+export const pipe = (from, to) => new Pipe({ from, to })
+
+/**
+ * @template {null|boolean|string|number} Out
+ * @template {null|boolean|string|number} In
+ * @extends {API<Out, In, Out>}
+ * @implements {Schema.LiteralSchema<Out, In>}
  */
 class Literal extends API {
   /**
-   * @param {I} input
-   * @param {T} expect
-   * @returns {Schema.ReadResult<T>}
+   * @param {In} input
+   * @param {Out} expect
+   * @returns {Schema.ReadResult<Out>}
    */
   readWith(input, expect) {
     return input !== /** @type {unknown} */ (expect)
@@ -1060,14 +1440,13 @@ class Literal extends API {
       : { ok: expect }
   }
   get value() {
-    return /** @type {Exclude<T, undefined>} */ (this.settings)
+    return /** @type {Exclude<Out, undefined>} */ (this.settings)
   }
   /**
-   * @template {Schema.NotUndefined<T>} U
-   * @param {U} value
+   * @param {Out} value
    */
-  default(value = /** @type {U} */ (this.value)) {
-    return super.default(value)
+  implicit(value = this.value) {
+    return implicit(this, /** @type {Exclude<Out, undefined>} */ (value))
   }
   toString() {
     return `literal(${displayTypeName(this.value)})`
@@ -1075,25 +1454,26 @@ class Literal extends API {
 }
 
 /**
- * @template {null|boolean|string|number} T
- * @template [I=unknown]
- * @param {T} value
- * @returns {Schema.LiteralSchema<T, I>}
+ * @template {null|boolean|string|number} Out
+ * @template {null|boolean|string|number} In
+ * @param {Out} value
+ * @returns {Schema.LiteralSchema<Out, In>}
  */
 export const literal = value => new Literal(value)
 
 /**
- * @template {{[key:string]: Schema.Reader}} U
- * @template [I=unknown]
- * @extends {API<Schema.InferStruct<U>, I, U>}
+ * @template {Schema.StructMembers} Members
+ * @extends {API<Schema.InferStruct<Members>, Schema.InferStructInput<Members>, {shape: Members}>}
+ * @implements {Schema.StructSchema<Members>}
  */
 class Struct extends API {
   /**
-   * @param {I} input
-   * @param {U} shape
-   * @returns {Schema.ReadResult<Schema.InferStruct<U>>}
+   * @param {Schema.InferStructInput<Members>} input
+   * @param {{shape: Members}} settings
+   * @param {Schema.Region} [context]
+   * @returns {Schema.ReadResult<Schema.InferStruct<Members>>}
    */
-  readWith(input, shape) {
+  readWith(input, { shape }, context) {
     if (typeof input != 'object' || input === null || Array.isArray(input)) {
       return typeError({
         expect: 'object',
@@ -1101,22 +1481,23 @@ class Struct extends API {
       })
     }
 
-    const source = /** @type {{[K in keyof U]: unknown}} */ (input)
+    const source = /** @type {{[K in keyof Members]: unknown}} */ (input)
 
-    const struct = /** @type {{[K in keyof U]: Schema.Infer<U[K]>}} */ ({})
+    const struct =
+      /** @type {{[K in keyof Members]: Schema.Infer<Members[K]>}} */ ({})
     const entries =
-      /** @type {{[K in keyof U]: [K & string, U[K]]}[keyof U][]} */ (
+      /** @type {{[K in keyof Members]: [K & string, Members[K]]}[keyof Members][]} */ (
         Object.entries(shape)
       )
 
     for (const [at, reader] of entries) {
-      const result = reader.read(source[at])
+      const result = reader.tryFrom(source[at], context)
       if (result.error) {
         return memberError({ at, cause: result.error })
       }
       // skip undefined because they mess up CBOR and are generally useless.
       else if (result.ok !== undefined) {
-        struct[at] = /** @type {Schema.Infer<U[typeof at]>} */ (result.ok)
+        struct[at] = /** @type {Schema.Infer<Members[typeof at]>} */ (result.ok)
       }
     }
 
@@ -1124,20 +1505,54 @@ class Struct extends API {
   }
 
   /**
-   * @returns {Schema.MapRepresentation<Partial<Schema.InferStruct<U>>> & Schema.StructSchema}
+   * @param {Schema.InferStruct<Members>} output
+   * @param {{shape: Members}} settings
    */
-  partial() {
-    return new Struct(
-      Object.fromEntries(
-        Object.entries(this.shape).map(([key, value]) => [key, optional(value)])
+
+  writeWith(output, { shape }) {
+    if (typeof output != 'object' || output === null || Array.isArray(output)) {
+      return typeError({
+        expect: 'object',
+        actual: output,
+      })
+    }
+
+    const source = /** @type {{[K in keyof Members]: unknown}} */ (output)
+
+    const input =
+      /** @type {{[K in keyof Members]: Schema.InferInput<Members[K]>}} */ ({})
+    const entries =
+      /** @type {{[K in keyof Members]: [K & string, Members[K]]}[keyof Members][]} */ (
+        Object.entries(shape)
       )
+
+    for (const [at, writer] of entries) {
+      const result = writer.tryTo(source[at])
+      if (result.error) {
+        return memberError({ at, cause: result.error })
+      }
+      // skip undefined because they mess up CBOR and are generally useless.
+      else if (result.ok !== undefined) {
+        input[at] = /** @type {Schema.InferInput<Members[typeof at]>} */ (
+          result.ok
+        )
+      }
+    }
+
+    return { ok: input }
+  }
+
+  partial() {
+    const shape = Object.fromEntries(
+      Object.entries(this.shape).map(([key, value]) => [key, optional(value)])
     )
+
+    return /** @type {*} */ (new Struct({ shape }))
   }
 
-  /** @type {U} */
+  /** @type {Members} */
   get shape() {
-    // @ts-ignore - We declared `settings` private but we access it here
-    return this.settings
+    return this.settings.shape
   }
 
   toString() {
@@ -1151,34 +1566,32 @@ class Struct extends API {
   }
 
   /**
-   * @param {Schema.InferStructSource<U>} data
+   * @param {Schema.InferStructSource<Members>} data
    */
   create(data) {
-    return this.from(data || {})
+    return this.from(/** @type {*} */ (data || {}))
   }
 
   /**
-   * @template {{[key:string]: Schema.Reader}} E
+   * @template {Schema.StructMembers} E
    * @param {E} extension
-   * @returns {Schema.StructSchema<U & E, I>}
+   * @returns {Schema.StructSchema<Members & E>}
    */
   extend(extension) {
-    return new Struct({ ...this.shape, ...extension })
+    return new Struct({ shape: { ...this.shape, ...extension } })
   }
 }
 
 /**
  * @template {null|boolean|string|number} T
- * @template {{[key:string]: T|Schema.Reader}} U
- * @template {{[K in keyof U]: U[K] extends Schema.Reader ? U[K] : Schema.LiteralSchema<U[K] & T>}} V
- * @template [I=unknown]
+ * @template {{[key:string]: T|Schema.Convert}} U
+ * @template {{[K in keyof U]: U[K] extends Schema.Convert ? U[K] : Schema.Convert<U[K] & T>}} Members
  * @param {U} fields
- * @returns {Schema.StructSchema<V, I>}
+ * @returns {Schema.StructSchema<Members>}
  */
 export const struct = fields => {
-  const shape =
-    /** @type {{[K in keyof U]: Schema.Reader<unknown, unknown>}} */ ({})
-  /** @type {[keyof U & string, T|Schema.Reader][]} */
+  const shape = /** @type {{[K in keyof U]: Schema.Convert}} */ ({})
+  /** @type {[keyof U & string, T|Schema.Convert][]} */
   const entries = Object.entries(fields)
 
   for (const [key, field] of entries) {
@@ -1198,22 +1611,761 @@ export const struct = fields => {
     }
   }
 
-  return new Struct(/** @type {V} */ (shape))
+  return /** @type {*} */ (new Struct({ shape: shape }))
 }
 
 /**
- * @template {Schema.VariantChoices} U
- * @template [I=unknown]
- * @extends {API<Schema.InferVariant<U>, I, U>}
- * @implements {Schema.VariantSchema<U, I>}
+ * @extends {API<Uint8Array, Uint8Array, void>}
+ * @implements {Schema.BytesSchema<Uint8Array, Schema.MulticodecCode<0x55, 'raw'>>}
+ */
+class RawBytes extends API {
+  name = 'raw'
+  code = /** @type {const} */ (0x55)
+
+  /**
+   * @param {Uint8Array} input
+   */
+  encode(input) {
+    if (input instanceof Uint8Array) {
+      return input
+    } else {
+      throw typeError({ expect: 'Uint8Array', actual: input }).error
+    }
+  }
+
+  /**
+   * @param {Uint8Array} output
+   */
+  decode(output) {
+    if (output instanceof Uint8Array) {
+      return output
+    } else {
+      throw typeError({ expect: 'Uint8Array', actual: output }).error
+    }
+  }
+  /**
+   * @param {Uint8Array} input
+   * @returns {Schema.ReadResult<Uint8Array>}
+   */
+  readWith(input) {
+    if (input instanceof Uint8Array) {
+      return { ok: input }
+    } else {
+      return typeError({ expect: 'Uint8Array', actual: input })
+    }
+  }
+
+  /**
+   * @template {Uint8Array} O
+   * @template {Uint8Array} I
+   * @param {Schema.Convert<O, I>} into
+   * @returns {Schema.BytesSchema<O, typeof this.code>}
+   */
+  refine(into) {
+    const codec = /** @type {Schema.BlockCodec<0x55, * & I>} */ (this)
+    return new ByteView({ codec, convert: into })
+  }
+}
+
+/** @type {Schema.BytesSchema} */
+export const Bytes = new RawBytes()
+
+/**
+ * @type {Schema.Convert<*>}
+ */
+const direct = {
+  tryFrom: input => ({ ok: input }),
+  tryTo: output => ({ ok: output }),
+}
+
+/**
+ * @template {Schema.BlockCodec<number, any>} [Codec=import('multiformats/codecs/raw')]
+ * @param {Codec} [codec]
+ * @returns {Schema.BytesSchema<ReturnType<Codec['decode']> & ({} | null), Schema.MulticodecCode<Codec['code'], Codec['name']>>}
+ */
+export const bytes = codec =>
+  /** @type {*} */ (codec ? new ByteView({ codec, convert: direct }) : Bytes)
+
+/**
+ * @template {{}|null} Model
+ * @template {Model} Out
+ * @template {Schema.MulticodecCode} Code
+ * @extends {API<Out, Schema.ByteView<Model>, Schema.ByteSchemaSettings<Model, Out, Code>>}
+ * @implements {Schema.BytesSchema<Out, Code>}
+ */
+class ByteView extends API {
+  get codec() {
+    return this.settings.codec
+  }
+  get name() {
+    return this.codec.name
+  }
+  get code() {
+    return this.codec.code
+  }
+  /**
+   * @param {Out} data
+   */
+  encode(data) {
+    const { codec, convert } = this.settings
+    const model = convert.tryFrom(data)
+    if (model.error) {
+      throw model.error
+    } else {
+      return /** @type {Schema.ByteView<Out>} */ (codec.encode(model.ok))
+    }
+  }
+  /**
+   * @param {Schema.ByteView<Out>} bytes
+   */
+  decode(bytes) {
+    const { codec, convert } = this.settings
+    const model = codec.decode(bytes)
+    const result = convert.tryFrom(model)
+    if (result.error) {
+      throw result.error
+    } else {
+      return result.ok
+    }
+  }
+  /**
+   * @param {Uint8Array} input
+   * @param {Schema.ByteSchemaSettings<Model, Out, Code>} settings
+   * @returns {Schema.ReadResult<Out>}
+   */
+  readWith(input, { codec, convert }) {
+    try {
+      const model = codec.decode(input)
+      return convert.tryFrom(model)
+    } catch (cause) {
+      return { error: /** @type {Error} */ (cause) }
+    }
+  }
+  /**
+   *
+   * @param {Out} output
+   * @param {Schema.ByteSchemaSettings<Model, Out, Code>} settings
+   * @returns {Schema.ReadResult<Schema.ByteView<Out>>}
+   */
+  writeWith(output, { codec, convert }) {
+    try {
+      const result = convert.tryTo(output)
+      if (result.error) {
+        throw result.error
+      }
+      return {
+        ok: /** @type {Schema.ByteView<Out>} */ (codec.encode(result.ok)),
+      }
+    } catch (cause) {
+      return { error: /** @type {Error} */ (cause) }
+    }
+  }
+
+  /**
+   * @template {Out} O
+   * @template {Out} I
+   * @param {Schema.Convert<O, I>} into
+   * @returns {Schema.BytesSchema<O, Code>}
+   */
+  refine(into) {
+    const { codec, convert: from } = this.settings
+    const convert =
+      from === direct
+        ? // if convertor is direct, we don't need to compose
+          /** @type {Schema.Convert<O, * & Model>} */ (into)
+        : pipe(/** @type {Schema.Convert<* & I, Model>} */ (from), into)
+
+    return new ByteView({
+      codec,
+      convert,
+    })
+  }
+
+  /**
+   * @template {Schema.BlockCodec<Schema.MulticodecCode, *>} Codec
+   * @template {Schema.MultihashHasher<Schema.MulticodecCode>} Hasher
+   * @template {Schema.UnknownLink['version']} Version
+   * @param {{
+   * codec?: Codec
+   * hasher?: Hasher
+   * version?: Version
+   * }} options
+   * @returns {Schema.LinkSchema<Out, Codec['code'], Hasher['code'], Version>}
+   */
+  link(options) {
+    return link({
+      codec: this.codec,
+      ...options,
+      schema: this.settings.convert,
+    })
+  }
+}
+
+const emptyStore = Object.freeze(new Map())
+/**
+ * @template {{}|null} T
+ * @param {object} options
+ * @param {Schema.BlockCodec<number, any>} options.codec
+ * @returns {Schema.Schema<T, { root: Schema.Link, store: Map<string, Schema.Block>}>}
+ */
+export const dag = options => {
+  throw new Error('Not implemented')
+}
+
+/**
+ * @template {unknown} Out
+ * @template {unknown} In
+ * @template {Schema.MulticodecCode} Code
+ * @template {Schema.MulticodecCode} Alg
+ * @template {Schema.UnknownLink['version']} V
+ * @implements {Schema.LinkOf<Out, Code, Alg, V>}
+ */
+class Link {
+  /**
+   * @param {object} source
+   * @param {Schema.Link<Out, Code, Alg, V>} source.link
+   * @param {Schema.BlockCodec<Code, In>} [source.codec]
+   * @param {Schema.Convert<Out, In>} source.schema
+   * @param {Schema.Region} [source.store]
+   */
+  constructor({ link, codec, schema }) {
+    this.codec = codec
+    this.cid = link
+    this.schema = schema
+
+    this['/'] = link.bytes
+    this.version = link.version
+    this.multihash = link.multihash
+    this.code = link.code
+    this.bytes = link.bytes
+
+    Object.defineProperties(this, {
+      codec: { enumerable: false },
+      cid: { enumerable: false },
+      schema: { enumerable: false },
+    })
+  }
+
+  /**
+   * @param {Schema.Region} region
+   * @returns {Schema.Attachment<Out, Code, Alg, V>}
+   */
+  select(region) {
+    const { cid, codec, schema } = this
+    const block = region.get(`${cid}`)
+    const bytes = block
+      ? block.bytes
+      : cid.multihash.code === identity.code
+      ? cid.multihash.digest
+      : undefined
+
+    if (bytes) {
+      return new Attachment({
+        root: { cid, bytes },
+        codec,
+        schema,
+        store: region,
+      })
+    } else {
+      throw new RangeError(
+        `Block can not be resolved, please provide a store from which to resolve it`
+      )
+    }
+  }
+
+  /**
+   * @param {Schema.Region} region
+   * @returns {Schema.ResolvedLink<Out, Code, Alg, V>}
+   */
+  resolve(region) {
+    return this.select(region).resolve()
+  }
+  // get version() {
+  //   return this.cid.version
+  // }
+  // get code() {
+  //   return this.cid.code
+  // }
+  // get multihash() {
+  //   return this.cid.multihash
+  // }
+  get byteOffset() {
+    return this.cid.byteOffset
+  }
+  get byteLength() {
+    return this.cid.byteLength
+  }
+  // get bytes() {
+  //   return this.cid.bytes
+  // }
+  link() {
+    return this.cid
+  }
+  /**
+   * @param {unknown} other
+   * @returns {other is Schema.Link<Out, Code, Alg, V>}
+   */
+  equals(other) {
+    return this.cid.equals(other)
+  }
+  /**
+   * @template {string} Prefix
+   * @param {Schema.MultibaseEncoder<Prefix>} [base]
+   * @returns
+   */
+  toString(base) {
+    return this.cid.toString(base)
+  }
+  toJSON() {
+    return { '/': this.toString() }
+  }
+  get [Symbol.toStringTag]() {
+    return 'CID'
+  }
+  [Symbol.for('nodejs.util.inspect.custom')]() {
+    return `CID(${this.toString()})`
+  }
+  toV1() {
+    return this.cid.toV1()
+  }
+}
+
+/**
+ * @template {unknown} Out
+ * @template {unknown} In
+ * @template {Schema.MulticodecCode} Code
+ * @template {Schema.MulticodecCode} Alg
+ * @template {Schema.UnknownLink['version']} V
+ * @implements {Schema.Attachment<Out, Code, Alg, V>}
+ */
+class Attachment {
+  /**
+   * @param {object} source
+   * @param {Schema.Block<Out, Code, Alg, V>} source.root
+   * @param {Schema.BlockCodec<Code, In>} [source.codec]
+   * @param {Schema.Convert<Out, In>} source.schema
+   * @param {Schema.Region} [source.store]
+   */
+  constructor({ root, codec, schema, store = emptyStore }) {
+    this.codec = codec
+    this.root = root
+    this.store = store
+    this.schema = schema
+    this['/'] = root.cid.bytes
+
+    /** @type {Schema.ReadResult<Out>|null} */
+    this._resolved = null
+  }
+
+  /**
+   * @returns {Schema.ResolvedLink<Out, Code, Alg, V>}
+   */
+  resolve() {
+    let result = this._resolved
+    if (result == null) {
+      const { schema, codec = CBOR, root } = this
+      const data = codec.decode(/** @type {Uint8Array} */ (root.bytes))
+      result = schema.tryFrom(data, this.store)
+
+      this._resolved = result
+    }
+
+    if (result.error) {
+      throw result.error
+    } else {
+      return /** @type {Schema.ResolvedLink<Out, Code, Alg, V>} */ (result.ok)
+    }
+  }
+  get version() {
+    return this.root.cid.version
+  }
+  get code() {
+    return this.root.cid.code
+  }
+  get multihash() {
+    return this.root.cid.multihash
+  }
+  get byteOffset() {
+    return this.root.cid.byteOffset
+  }
+  get byteLength() {
+    return this.root.cid.byteLength
+  }
+  get bytes() {
+    return this.root.cid.bytes
+  }
+  link() {
+    return this.root.cid
+  }
+  /**
+   * @param {unknown} other
+   * @returns {other is Schema.Link<Out, Code, Alg, V>}
+   */
+  equals(other) {
+    return this.root.cid.equals(other)
+  }
+  /**
+   * @template {string} Prefix
+   * @param {Schema.MultibaseEncoder<Prefix>} [base]
+   * @returns
+   */
+  toString(base) {
+    return this.root.cid.toString(base)
+  }
+  toV1() {
+    return this.root.cid.toV1()
+  }
+  /**
+   * @param {object} context
+   * @param {Schema.Region} [context.store]
+   */
+  with({ store = this.store }) {
+    return new Attachment({
+      root: this.root,
+      codec: this.codec,
+      schema: this.schema,
+      store,
+    })
+  }
+
+  *iterateIPLDBlocks() {
+    const dag = this.resolve()
+    const { store, root } = this
+    for (const link of Attachment.links(dag)) {
+      const block = store.get(`${link}`)
+      if (block) {
+        yield { cid: link, bytes: block.bytes }
+      }
+    }
+
+    yield /** @type {Schema.Block} */ (root)
+  }
+
+  /**
+   * @param {unknown} source
+   * @returns {IterableIterator<Schema.Link>}
+   */
+  static *links(source) {
+    if (isLink(source)) {
+      yield /** @type {Schema.Link} */ (source)
+    } else if (source && typeof source === 'object') {
+      for (const value of Object.values(source)) {
+        yield* this.links(value)
+      }
+    }
+  }
+
+  /**
+   * @param {unknown} source
+   */
+  static *iterateIPLDBlocks(source) {
+    if (source && typeof source === 'object') {
+      for (const value of Object.values(source)) {
+        if (value && typeof value['iterateIPLDBlocks'] === 'function') {
+          yield* value.iterateIPLDBlocks()
+        }
+      }
+    }
+  }
+}
+
+/**
+ * @template {unknown} [Out=unknown]
+ * @template {unknown} [In=number]
+ * @template {number} [Code=number]
+ * @template {number} [Alg=number]
+ * @template {1|0} [Version=0|1]
+ * @typedef {{
+ * codec?: Schema.BlockCodec<Code, In>,
+ * version?: Version
+ * hasher?: {code: Alg}
+ * schema: Schema.Convert<Out, In>
+ * }} LinkSettings
+ */
+
+/**
+ * @template {unknown} Out
+ * @template {unknown} In
+ * @template {Schema.MulticodecCode} Code
+ * @template {Schema.MulticodecCode} Alg
+ * @template {Schema.UnknownLink['version']} V
+ * @extends {API<Schema.LinkOf<Out, Code, Alg, V>, Schema.IntoLink<Out>, LinkSettings<Out, In, Code, Alg, V>>}
+ * @implements {Schema.LinkSchema<Out, Code, Alg, V>}
+ */
+class LinkSchema extends API {
+  /**
+   * @template {unknown} Out
+   * @template {unknown} In
+   * @template {Schema.MulticodecCode} Code
+   * @template {Schema.MulticodecCode} Alg
+   * @template {Schema.UnknownLink['version']} V
+   * @param {Schema.IntoLink<Out>} source
+   * @param {LinkSettings<Out, In, Code, Alg, V>} settings
+   * @returns {Schema.ReadResult<Schema.Link<Out, Code, Alg, V>>}
+   */
+  static validate(source, { codec, hasher, version, schema }) {
+    if (source == null) {
+      return error(`Expected link but got ${source} instead`)
+    } else {
+      if (!isLink(source)) {
+        return error(`Expected link to be a CID instead of ${source}`)
+      } else {
+        if (codec && codec.code !== source.code) {
+          return error(
+            `Expected link to be CID with 0x${codec.code.toString(16)} codec`
+          )
+        }
+
+        if (hasher && hasher.code !== source.multihash.code)
+          return error(
+            `Expected link to be CID with 0x${hasher.code.toString(
+              16
+            )} hashing algorithm`
+          )
+
+        if (version != null && version !== source.version) {
+          return error(
+            `Expected link to be CID version ${version} instead of ${source.version}`
+          )
+        }
+
+        const link = /** @type {Schema.Link<Out, *, *, *>} */ (source)
+        return { ok: link }
+      }
+    }
+  }
+
+  /**
+   * @param {Schema.IntoLink<Out>} cid
+   * @param {LinkSettings<Out, In, Code, Alg, V>} settings
+   * @returns {Schema.ReadResult<Schema.LinkOf<Out, Code, Alg, V>>}
+   */
+  readWith(cid, { codec, hasher, version, schema }) {
+    const result = LinkSchema.validate(cid, {
+      codec,
+      hasher,
+      version,
+      schema,
+    })
+
+    if (result.ok) {
+      const link = result.ok
+      const ok = link instanceof Link ? link : new Link({ link, codec, schema })
+      return { ok }
+    } else {
+      return result
+    }
+  }
+
+  /**
+   *
+   * @param {Schema.LinkOf<Out, Code, Alg, V>} source
+   * @param {LinkSettings<Out, In, Code, Alg, V>} settings
+   * @returns {Schema.ReadResult<Schema.IntoLink<Out>>}
+   */
+  writeWith(source, settings) {
+    return LinkSchema.validate(source.link(), settings)
+  }
+
+  /**
+   * @returns {never}
+   */
+  link() {
+    throw new Error('Can not create link of link')
+  }
+
+  /**
+   * @returns {Schema.AttachmentSchema<Out, Code, Alg, V>}
+   */
+  attached() {
+    let attachment = this._attached
+    if (attachment == null) {
+      const attachment = new AttachmentSchema(this.settings)
+      this._attached = attachment
+      return attachment
+    }
+
+    return attachment
+  }
+
+  /**
+   * @param {Out} target
+   */
+  embed(target) {
+    return this.attached().embed(target)
+  }
+  /**
+   * @param {Out} target
+   */
+  attach(target) {
+    return this.attached().attach(target)
+  }
+
+  /**
+   * @template {string} Prefix
+   * @param {string} input
+   * @param {Schema.MultibaseDecoder<Prefix>} [base]
+   */
+  parse(input, base) {
+    const link = parseLink(input, base)
+    return this.from(/** @type {*} */ (link))
+  }
+}
+
+/**
+ * @template {unknown} Out
+ * @template {unknown} In
+ * @template {Schema.MulticodecCode} Code
+ * @template {Schema.MulticodecCode} Alg
+ * @template {Schema.UnknownLink['version']} V
+ * @extends {API<Schema.Attachment<Out, Code, Alg, V>, Schema.IPLDView<Out, Code, Alg, V>, LinkSettings<Out, In, Code, Alg, V>>}
+ * @implements {Schema.AttachmentSchema<Out, Code, Alg, V>}
+ */
+class AttachmentSchema extends API {
+  /**
+   * @param {Schema.IPLDView<Out, Code, Alg, V>} source
+   * @param {LinkSettings<Out, In, Code, Alg, V>} settings
+   * @param {Schema.Region} [region]
+   */
+  readWith(source, { codec, schema }, region = emptyStore) {
+    const link = /** @type {Schema.Link<Out, Code, Alg, V>} */ (source.link())
+    const block = source.root ? source.root : region.get(`${link}`)
+    /** @type {Uint8Array|undefined} */
+    const bytes = block
+      ? block.bytes
+      : link.multihash.code === identity.code
+      ? link.multihash.digest
+      : undefined
+
+    if (bytes) {
+      const attachment = new Attachment({
+        root: { cid: link, bytes },
+        codec,
+        schema,
+        store: region,
+      })
+      return { ok: attachment }
+    } else {
+      return error(`Could not find block for ${link}`)
+    }
+  }
+  /**
+   * @param {Schema.Attachment<Out, Code, Alg, V>} attachment
+   * @param {LinkSettings<Out, In, Code, Alg, V>} settings
+   * @returns {Schema.ReadResult<Schema.IPLDView<Out, Code, Alg, V>>}
+   */
+  writeWith(attachment, settings) {
+    if (attachment instanceof Attachment) {
+      return { ok: attachment }
+    }
+
+    console.log('!!!!!!!!!')
+    try {
+      const { codec, schema } = settings
+      const link = attachment.link()
+      const out = attachment.resolve()
+      const data = schema.tryTo(out)
+      if (data.error) {
+        return data
+      } else {
+        /** @type {Uint8Array} */
+        const bytes = (codec || CBOR).encode(data.ok)
+        /** @type {Required<Schema.Block<Out, Code, Alg, V>>} */
+        const root = { cid: link, bytes, data: out }
+        const view = new Attachment({ root, codec, schema })
+        return { ok: view }
+      }
+    } catch (cause) {
+      return { error: /** @type {Error} */ (cause) }
+    }
+  }
+
+  /**
+   * @param {Out} target
+   * @param {{hasher?: Schema.MultihashHasher<Alg> }} options
+   */
+  async attach(target, { hasher = /** @type {*} */ (sha256) } = {}) {
+    const { schema, codec = CBOR } = this.settings
+    const result = schema.tryTo(target)
+    if (result.error) {
+      throw result.error
+    }
+    const data = result.ok
+    /** @type {Uint8Array} */
+    const bytes = codec.encode(data)
+    const digest = await hasher.digest(bytes)
+    /** @type {Schema.Link<Out, *, Alg, *>} */
+    const cid = createLink(codec.code, digest)
+
+    const store = new Map()
+    for (const block of Attachment.iterateIPLDBlocks(target)) {
+      store.set(`${block.cid}`, block)
+    }
+    store.set(`${cid}`, { bytes, cid })
+
+    return new Attachment({
+      codec,
+      schema,
+      root: { bytes, cid },
+      store,
+    })
+  }
+
+  /**
+   * @param {Out} target
+   */
+  embed(target) {
+    const { schema, codec = /** @type {*} */ (CBOR) } = this.settings
+    const result = schema.tryTo(target)
+    if (result.error) {
+      throw result.error
+    }
+    const data = result.ok
+    /** @type {Uint8Array} */
+    const bytes = codec.encode(data)
+    const digest = identity.digest(bytes)
+    /** @type {Schema.Link<Out, Code, *>} */
+    const cid = createLink(codec.code, digest)
+
+    return new Attachment({
+      codec,
+      schema,
+      root: { bytes, cid },
+    })
+  }
+
+  /**
+   * @returns {never}
+   */
+  link() {
+    throw new Error('Can not create link of link')
+  }
+}
+
+/**
+ * @template {unknown} Out
+ * @template In
+ * @template {Schema.BlockCodec<Schema.MulticodecCode, In>} Codec
+ * @template {Schema.MultihashHasher<Schema.MulticodecCode>} Hasher
+ * @template {Schema.UnknownLink['version']} Version
+ * @param {LinkSettings<Out, In, Codec['code'], Hasher['code'], Version>} options
+ * @returns {Schema.LinkSchema<Out, Codec['code'], Hasher['code'], Version>}
+ */
+export const link = options => new LinkSchema(options)
+
+/**
+ * @template {Schema.VariantChoices} Choices
+ * @extends {API<Schema.InferVariant<Choices>, Schema.InferVariantInput<Choices>, Choices>}
+ * @implements {Schema.VariantSchema<Choices>}
  */
 class Variant extends API {
   /**
-   * @param {I} input
-   * @param {U} variants
-   * @returns {Schema.ReadResult<Schema.InferVariant<U>>}
+   * @param {Schema.InferVariantInput<Choices>} input
+   * @param {Choices} variants
+   * @param {Schema.Region} [context]
+   * @returns {Schema.ReadResult<Schema.InferVariant<Choices>>}
    */
-  readWith(input, variants) {
+  readWith(input, variants, context) {
     if (typeof input != 'object' || input === null || Array.isArray(input)) {
       return typeError({
         expect: 'object',
@@ -1229,15 +2381,19 @@ class Variant extends API {
     const reader = key ? variants[key] : undefined
 
     if (reader) {
-      const result = reader.read(input[key])
+      const result = reader.tryFrom(input[key], context)
       return result.error
         ? memberError({ at: key, cause: result.error })
-        : { ok: /** @type {Schema.InferVariant<U>} */ ({ [key]: result.ok }) }
+        : {
+            ok: /** @type {Schema.InferVariant<Choices>} */ ({
+              [key]: result.ok,
+            }),
+          }
     } else if (variants._) {
-      const result = variants._.read(input)
+      const result = variants._.tryFrom(input, context)
       return result.error
         ? result
-        : { ok: /** @type {Schema.InferVariant<U>} */ ({ _: result.ok }) }
+        : { ok: /** @type {Schema.InferVariant<Choices>} */ ({ _: result.ok }) }
     } else if (key) {
       return error(
         `Expected an object with one of the these keys: ${Object.keys(variants)
@@ -1254,11 +2410,11 @@ class Variant extends API {
 
   /**
    * @template [E=never]
-   * @param {I} input
+   * @param {unknown} input
    * @param {E} [fallback]
    */
   match(input, fallback) {
-    const result = this.read(input)
+    const result = this.tryFrom(/** @type {*} */ (input))
     if (result.error) {
       if (fallback !== undefined) {
         return [null, fallback]
@@ -1268,17 +2424,17 @@ class Variant extends API {
     } else {
       const [key] = Object.keys(result.ok)
       const value = result.ok[key]
-      return /** @type {any} */ ([key, value])
+      return /** @type {*} */ ([key, value])
     }
   }
 
   /**
-   * @template {Schema.InferVariant<U>} O
-   * @param {O} source
-   * @returns {O}
+   * @template {Schema.InferVariant<Choices>} Choice
+   * @param {Choice} source
+   * @returns {Choice}
    */
   create(source) {
-    return /** @type {O} */ (this.from(source))
+    return /** @type {Choice} */ (this.from(/** @type {*} */ (source)))
   }
 }
 
@@ -1334,9 +2490,8 @@ class Variant extends API {
  * ```
  *
  * @template {Schema.VariantChoices} Choices
- * @template [In=unknown]
  * @param {Choices} variants
- * @returns {Schema.VariantSchema<Choices, In>}
+ * @returns {Schema.VariantSchema<Choices>}
  */
 export const variant = variants => new Variant(variants)
 
@@ -1397,10 +2552,11 @@ const displayTypeName = value => {
     // eg turn NaN and Infinity to null
     case 'bigint':
       return `${value}n`
-    case 'number':
     case 'symbol':
+      return /** @type {symbol} */ (value).toString()
+    case 'number':
     case 'undefined':
-      return String(value)
+      return `${value}`
     case 'object':
       return value === null
         ? 'null'
@@ -1537,3 +2693,12 @@ const indent = (message, indent = '  ') =>
  * @param {string} message
  */
 const li = message => indent(`- ${message}`)
+
+/**
+ * @template In, Out
+ * @param {Schema.Schema<Out, In>} schema
+ * @returns {{in:In, out:Out}}
+ */
+export const debug = schema => {
+  throw new Error('Not implemented')
+}
diff --git a/packages/core/src/schema/tradeoffs.md b/packages/core/src/schema/tradeoffs.md
new file mode 100644
index 00000000..832fbbca
--- /dev/null
+++ b/packages/core/src/schema/tradeoffs.md
@@ -0,0 +1,6 @@
+- we either have:
+  1. Another set of APIs for working with dags alongside of regular APIs
+    that take `BlockStore / BlockLoader` in addition.
+  2. We have set of properties that fail decode when `.link().resolve()` is used.
+  3. We have a modifier that turns regular struct decoder into DAG decoder.
+  4. We have alternative to `struct({})` which takes `.link().resolve()`.
diff --git a/packages/core/src/schema/type.ts b/packages/core/src/schema/type.ts
index 09a27dbe..ff00b458 100644
--- a/packages/core/src/schema/type.ts
+++ b/packages/core/src/schema/type.ts
@@ -1,43 +1,295 @@
-import { Failure as Error, Result, Variant, Phantom } from '@ucanto/interface'
-
-export interface Reader<O = unknown, I = unknown, X extends Error = Error> {
-  read(input: I): Result<O, X>
+import {
+  Failure as Error,
+  Await,
+  Result,
+  Variant,
+  Phantom,
+  Link,
+  BlockStore,
+  Block,
+  BlockCodec,
+  BlockDecoder,
+  BlockEncoder,
+  MultihashHasher,
+  MulticodecCode,
+  MultibaseDecoder,
+  MultibaseEncoder,
+  UnknownLink,
+  IPLDView,
+  IPLDViewBuilder,
+  BuildOptions,
+  ByteView,
+} from '@ucanto/interface'
+import type * as identity from '../identity'
+import type * as sha256 from '../sha256'
+
+export type {
+  Link,
+  UnknownLink,
+  BlockStore,
+  Block,
+  BlockCodec,
+  BlockEncoder,
+  BlockDecoder,
+  MultihashHasher,
+  MulticodecCode,
+  MultibaseDecoder,
+  MultibaseEncoder,
+  ByteView,
+  IPLDView,
+  IPLDViewBuilder,
+  BuildOptions,
+  Phantom,
+  Await,
 }
 
 export type { Error, Result }
 
 export type ReadResult<T, X extends Error = Error> = Result<T, X>
 
+export interface From<Self = unknown, T = unknown> {
+  tryFrom(value: T, context?: Region): ReadResult<Self>
+}
+
+export interface To<Self = unknown, T = unknown> {
+  tryTo(value: Self): ReadResult<T>
+}
+
+export interface Convert<Self = unknown, T = unknown>
+  extends From<Self, T>,
+    To<Self, T> {}
+
+export interface Conform<Self = unknown> {
+  conform(value: unknown): Conformance<Self, Error>
+}
+
+export type Conformance<Self, Reason extends Error = Error> = Result<
+  Self,
+  Reason
+>
+
+export interface BlockLoader extends From<Block, Link> {}
+
+export interface Region {
+  get(id: string): undefined | { bytes: Uint8Array }
+}
+
 export interface Schema<
-  O extends unknown = unknown,
-  I extends unknown = unknown
-> extends Reader<O, I> {
-  optional(): Schema<O | undefined, I>
-  nullable(): Schema<O | null, I>
-  array(): Schema<O[], I>
-  default(value: NotUndefined<O>): DefaultSchema<NotUndefined<O>, I>
-  or<T>(other: Reader<T, I>): Schema<O | T, I>
-  and<T>(other: Reader<T, I>): Schema<O & T, I>
-  refine<T extends O>(schema: Reader<O & T, O>): Schema<T, I>
+  Out extends unknown = unknown,
+  In extends unknown = unknown
+> extends Convert<Out, In> {
+  optional(): Schema<Out | undefined, In | undefined>
+  nullable(): Schema<Out | null, In | null>
+
+  implicit(value: Exclude<Out, undefined>): ImplicitSchema<Out, In>
+
+  array(): ArraySchema<Convert<Out, In>>
+  or<O, I>(other: Convert<O, I>): Schema<Out | O, In | I>
+  and<O, I>(other: Convert<O, I>): Schema<Out & O, In & I>
+  refine<O extends Out, I extends Out>(schema: Convert<O, I>): Schema<O, In>
+
+  // lift: <O extends Out, X extends Out>(from: Convert<O, X>) => Schema<O, In>
+
+  // into<I>(schema: Convert<In, I>): Schema<Out, I>
+  pipe<O>(schema: Convert<O, Out>): Schema<O, In>
+
+  brand<K extends string>(kind?: K): Schema<Branded<Out, K>, In>
 
-  brand<K extends string>(kind?: K): Schema<Branded<O, K>, I>
+  is(value: unknown): value is Out
+
+  read(unknown: unknown): ReadResult<Out>
+  from(value: In): Out
+  to(value: Out): In
+
+  // conforms(value: unknown): value is Out
+
+  link<
+    Codec extends BlockCodec<MulticodecCode, In>,
+    Hasher extends MultihashHasher<MulticodecCode> = MultihashHasher<MulticodecCode>,
+    V extends UnknownLink['version'] = 1
+  >(options?: {
+    codec?: Codec
+    version?: V
+    hasher?: Hasher
+  }): LinkSchema<Out, Codec['code'], Hasher['code'], V>
+
+  // attach<
+  //   Code extends MulticodecCode,
+  //   Alg extends MulticodecCode,
+  //   V extends UnknownLink['version']
+  // >(options?: {
+  //   codec?: BlockCodec<Code, In>
+  //   hasher?: MultihashHasher<Alg>
+  //   version?: V
+  // }): AttachmentSchema<Out, Code, Alg, V>
+
+  // with(context: { store: BlockStore }): Schema<Out, In>
+
+  // resolve(settings: { store: BlockStore }): Schema<Out, In>
+
+  // codec: BlockCodec<number, unknown>
+  // hasher: MultihashHasher<number>
+
+  // toIPLDBuilder(input: I): Result<IPLDViewBuilder<IPLDView<O>>, Error>
+
+  // toIPLDView(source: {
+  //   link: Link
+  //   store: BlockStore
+  // }): ReturnType<this['createIPLDView']>
+
+  // createIPLDView(source: IPLDViewSource): Result<IPLDView<O>, Error>
+
+  // view(value: O): View<O>
+  // attach(value: O): Await<Attachment<O>>
+
+  // compile(value: I): Await<CompiledView<ToBlock<O>>>
+  // attachment(value: I): Await<IPLDView<O>>
+
+  // IN: I
+  // OUT: Out
+}
+
+export interface DAGRoot<T> {
+  link(): Link<T>
+  resolve(link: Link): Uint8Array
+}
+
+export interface ByteSchemaSettings<
+  Model,
+  Out extends Model,
+  Code extends MulticodecCode
+> {
+  codec: BlockCodec<Code, Model>
+  convert: Convert<Out, Model>
+}
 
-  is(value: unknown): value is O
-  from(value: I): O
+export interface BytesSchema<
+  Out = Uint8Array,
+  Code extends MulticodecCode = MulticodecCode<0x55, 'raw'>
+> extends Schema<Out, Uint8Array> {
+  code: Code
+  name: string
+  encode(value: Out): ByteView<Out>
+  decode(value: ByteView<Out>): Out
+
+  refine<O extends Out, I extends Out>(
+    schema: Convert<O, I>
+  ): BytesSchema<O, Code>
 }
 
-export interface DefaultSchema<
-  O extends unknown = unknown,
-  I extends unknown = unknown
-> extends Schema<O, I> {
-  readonly value: O & NotUndefined<O>
-  optional(): DefaultSchema<O & NotUndefined<O>, I>
+export interface LinkOf<
+  T extends unknown = unknown,
+  Code extends MulticodecCode = MulticodecCode,
+  Alg extends MulticodecCode = MulticodecCode,
+  V extends UnknownLink['version'] = 1
+> extends Link<T, Code, Alg, V> {
+  resolve(region: Region): ResolvedLink<T, Code, Alg, V>
+  select(region: Region): Attachment<T, Code, Alg, V>
+}
+
+export interface Attachment<
+  T extends unknown = unknown,
+  Code extends MulticodecCode = MulticodecCode,
+  Alg extends MulticodecCode = MulticodecCode,
+  V extends UnknownLink['version'] = 1
+> extends Link<T, Code, Alg, V>,
+    IPLDView<T, Code, Alg, V> {
+  link(): Link<T, Code, Alg, V>
+  resolve(): ResolvedLink<T, Code, Alg, V>
+
+  with(context: { store?: Region }): Attachment<T, Code, Alg, V>
+}
+
+export interface CompiledView<O> extends IPLDView<O> {
+  root: Required<Block<O>>
+}
+
+export type ResolvedLink<
+  T extends unknown = unknown,
+  Code extends MulticodecCode = MulticodecCode,
+  Alg extends MulticodecCode = MulticodecCode,
+  V extends UnknownLink['version'] = 1
+> = T & Phantom<Link<T, Code, Alg, V>>
+
+// export interface View<O> {
+//   valueOf(): O
+//   attach(): Await<Attachment<O>>
+// }
+
+// export interface Attachment<
+//   T extends unknown = unknown,
+//   Code extends MulticodecCode = MulticodecCode,
+//   Alg extends MulticodecCode = MulticodecCode,
+//   V extends UnknownLink['version'] = 1
+// > extends IPLDView<T> {
+//   load(): T
+//   link(): Link<T, Code, Alg, V>
+// }
+
+export interface LinkSchema<
+  Out extends unknown,
+  Code extends MulticodecCode,
+  Alg extends MulticodecCode,
+  V extends UnknownLink['version']
+> extends Schema<LinkOf<Out, Code, Alg, V>, IntoLink<Out>> {
+  link(): never
+
+  attached(): AttachmentSchema<Out, Code, Alg, V>
+  parse<Prefix extends string>(
+    source: string,
+    base?: MultibaseDecoder<Prefix>
+  ): LinkOf<Out, Code, Alg, V>
+
+  embed(target: Out): Attachment<Out, Code, typeof identity.code>
+  attach(target: Out): Await<Attachment<Out, Code, Alg, V>>
+}
+
+export interface IntoLink<T> {
+  link(): Link<T, MulticodecCode, MulticodecCode, UnknownLink['version']>
+}
+
+export interface AttachmentSchema<
+  Target extends unknown,
+  Code extends MulticodecCode,
+  Alg extends MulticodecCode,
+  V extends UnknownLink['version']
+> extends Schema<
+    Attachment<Target, Code, Alg, V>,
+    IPLDView<Target, Code, Alg, V>
+  > {
+  link(): never
+  attach(
+    target: Target,
+    options?: { hasher?: MultihashHasher<Alg> }
+  ): Await<Attachment<Target, Code, Alg, V>>
+
+  embed(target: Target): Attachment<Target, Code, typeof identity.code>
+}
+
+export interface IPLDViewSource {
+  root: Block
+  store: BlockStore
+}
+
+export interface CreateView<T, V> {
+  create(source: {
+    root: Required<Block>
+    store: BlockStore
+    schema: Schema<T>
+  }): IPLDView<T> & V
+}
+
+export interface ImplicitSchema<O, I>
+  extends Omit<Schema<Exclude<O, undefined>, I | undefined>, 'optional'> {
+  readonly value: Exclude<O, undefined>
+  optional(): ImplicitSchema<O, I>
 }
 
 export type NotUndefined<T extends unknown = unknown> = Exclude<T, undefined>
 
-export interface ArraySchema<T, I = unknown> extends Schema<T[], I> {
-  element: Reader<T, I>
+export interface ArraySchema<C extends Convert>
+  extends Schema<Infer<C>[], InferInput<C>[]> {
+  element: C
 }
 
 /**
@@ -48,20 +300,23 @@ export interface ArraySchema<T, I = unknown> extends Schema<T[], I> {
  */
 export interface MapRepresentation<
   V extends Record<string, unknown>,
-  I = unknown
-> extends Schema<V, I> {
+  U extends Record<string, unknown>
+> extends Schema<V, U> {
   /**
    * Returns equivalent schema in which all of the fields are optional.
    */
-  partial(): MapRepresentation<Partial<V>, I>
+  partial(): MapRepresentation<Partial<V>, Partial<U>>
 }
 
-export interface DictionarySchema<V, K extends string, I = unknown>
-  extends MapRepresentation<Dictionary<K, V>, I> {
-  key: Reader<K, string>
-  value: Reader<V, I>
+export interface DictionarySchema<V, K extends string, U>
+  extends Omit<
+    MapRepresentation<Dictionary<K, V>, Dictionary<K, U>>,
+    'partial'
+  > {
+  key: From<K, string>
+  value: Convert<V, U>
 
-  partial(): DictionarySchema<V | undefined, K, I>
+  partial(): DictionarySchema<V | undefined, K, U | undefined>
 }
 
 export type Dictionary<
@@ -72,35 +327,54 @@ export type Dictionary<
 }
 
 export interface LiteralSchema<
-  T extends string | number | boolean | null,
-  I = unknown
-> extends Schema<T> {
-  default(value?: T): DefaultSchema<T & NotUndefined<T>, I>
-  readonly value: T
+  Out extends string | number | boolean | null,
+  In extends string | number | boolean | null = Out
+> extends Schema<Out, In> {
+  implicit(value?: Out): ImplicitSchema<Out, In>
+  readonly value: Out
 }
 
 export interface NumberSchema<
-  N extends number = number,
-  I extends unknown = unknown
-> extends Schema<N, I> {
-  greaterThan(n: number): NumberSchema<N, I>
-  lessThan(n: number): NumberSchema<N, I>
+  Out extends number = number,
+  In extends number = number
+> extends Schema<Out, In> {
+  isInteger: typeof Number.isInteger
+  isFinite: typeof Number.isFinite
+  greaterThan(n: number): NumberSchema<Out, In>
+  lessThan(n: number): NumberSchema<Out, In>
+
+  optional(): Schema<Out | undefined, In | undefined>
+
+  refine<O extends Out, I extends Out>(
+    convert: Convert<O, I>
+  ): NumberSchema<O, In>
+  constraint(check: (value: Out) => ReadResult<Out>): NumberSchema<Out, In>
+}
 
-  refine<T extends N>(schema: Reader<T, N>): NumberSchema<T & N, I>
+export interface StructMembers {
+  [key: string]: Convert
 }
 
-export interface StructSchema<
-  U extends { [key: string]: Reader } = {},
-  I extends unknown = unknown
-> extends MapRepresentation<InferStruct<U>, I> {
-  shape: U
+export interface StructSchema<Members extends StructMembers = {}>
+  extends MapRepresentation<InferStruct<Members>, InferStructInput<Members>> {
+  shape: Members
+
+  create(
+    input: MarkEmptyOptional<InferStructSource<Members>>
+  ): InferStruct<Members>
+  extend<E extends StructMembers>(extension: E): StructSchema<Members & E>
 
-  create(input: MarkEmptyOptional<InferStructSource<U>>): InferStruct<U>
-  extend<E extends { [key: string]: Reader }>(
-    extension: E
-  ): StructSchema<U & E, I>
+  partial(): MapRepresentation<
+    Partial<InferStruct<Members>>,
+    Partial<InferStructInput<Members>>
+  > &
+    StructSchema
 
-  partial(): MapRepresentation<Partial<InferStruct<U>>, I> & StructSchema
+  // createIPLDView(
+  //   source: IPLDViewSource
+  // ): Result<IPLDView<InferStruct<Members>> & InferStruct<Members>, Error>
+
+  // view(value: InferStruct<U>): InferStruct<U> & IPLDView<InferStruct<U>>
 }
 
 /**
@@ -122,10 +396,8 @@ export interface StructSchema<
  * })
  * ```
  */
-export interface VariantSchema<
-  Choices extends VariantChoices = {},
-  In extends unknown = unknown
-> extends Schema<InferVariant<Choices>, In> {
+export interface VariantSchema<Choices extends VariantChoices = {}>
+  extends Schema<InferVariant<Choices>, InferVariantInput<Choices>> {
   /**
    * Function can be used to match the input against the variant schema to
    * return the matched branch name and corresponding value. It provides
@@ -166,7 +438,7 @@ export interface VariantSchema<
  * their respective schemas.
  */
 export interface VariantChoices {
-  [branch: string]: Reader
+  [branch: string]: Convert
 }
 
 /**
@@ -176,7 +448,15 @@ export type InferVariant<Choices extends VariantChoices> = {
   [Case in keyof Choices]: {
     [Key in Exclude<keyof Choices, Case>]?: never
   } & {
-    [Key in Case]: Choices[Case] extends Reader<infer T> ? T : never
+    [Key in Case]: Choices[Case] extends From<infer T> ? T : never
+  }
+}[keyof Choices]
+
+export type InferVariantInput<Choices extends VariantChoices> = {
+  [Case in keyof Choices]: {
+    [Key in Exclude<keyof Choices, Case>]?: never
+  } & {
+    [Key in Case]: Choices[Case] extends To<any, infer T> ? T : never
   }
 }[keyof Choices]
 
@@ -186,28 +466,29 @@ export type InferVariant<Choices extends VariantChoices> = {
  * use of `switch` statement for type narrowing.
  */
 export type InferVariantMatch<Choices extends VariantChoices> = {
-  [Branch in keyof Choices]: Choices[Branch] extends Reader<infer Value>
+  [Branch in keyof Choices]: Choices[Branch] extends From<infer Value>
     ? [Branch, Value]
     : never
 }[keyof Choices]
 
-export type InferOptionalStructShape<U extends { [key: string]: Reader }> = {
+export type InferOptionalStructShape<U extends { [key: string]: From }> = {
   [K in keyof U]: InferOptionalReader<U[K]>
 }
 
-export type InferOptionalReader<R extends Reader> = R extends Reader<infer T>
-  ? Reader<T | undefined>
+export type InferOptionalReader<R extends From> = R extends From<infer T>
+  ? From<T | undefined>
   : R
 
-export interface StringSchema<O extends string, I = unknown>
-  extends Schema<O, I> {
+export interface StringSchema<Out extends string, In extends string = string>
+  extends Schema<Out, In> {
+  refine<I extends Out, O extends Out>(convert: From<O, I>): StringSchema<O, In>
+  constraint(check: (value: Out) => ReadResult<Out>): StringSchema<Out, In>
   startsWith<Prefix extends string>(
     prefix: Prefix
-  ): StringSchema<O & `${Prefix}${string}`, I>
+  ): StringSchema<Out & `${Prefix}${string}`, In>
   endsWith<Suffix extends string>(
     suffix: Suffix
-  ): StringSchema<O & `${string}${Suffix}`, I>
-  refine<T>(schema: Reader<T, O>): StringSchema<O & T, I>
+  ): StringSchema<Out & `${string}${Suffix}`, In>
 }
 
 declare const Marker: unique symbol
@@ -218,36 +499,52 @@ export type Branded<T, Brand> = T & {
 export type Integer = number & Phantom<{ typeof: 'integer' }>
 export type Float = number & Phantom<{ typeof: 'float' }>
 
-export type Infer<T extends Reader> = T extends Reader<infer T, any> ? T : never
+export type Infer<T extends From> = T extends From<infer T, any> ? T : never
+export type InferInput<T extends To> = T extends To<any, infer T> ? T : never
 
-export type InferIntersection<U extends [Reader, ...Reader[]]> = {
+export type InferIntersection<U extends [From, ...From[]]> = {
   [K in keyof U]: (input: Infer<U[K]>) => void
 }[number] extends (input: infer T) => void
   ? T
   : never
 
-export type InferUnion<U extends [Reader, ...Reader[]]> = Infer<U[number]>
+export type InferIntersectionInput<U extends [To, ...To[]]> = {
+  [K in keyof U]: (input: InferInput<U[K]>) => void
+}[number] extends (input: infer T) => void
+  ? T
+  : never
 
-export type InferTuple<U extends [Reader, ...Reader[]]> = {
+export type InferUnion<U extends [From, ...From[]]> = Infer<U[number]>
+export type InferUnionInput<U extends [To, ...To[]]> = InferInput<U[number]>
+
+export type InferTuple<U extends [From, ...From[]]> = {
   [K in keyof U]: Infer<U[K]>
 }
 
-export type InferStruct<U extends { [key: string]: Reader }> = MarkOptionals<{
-  [K in keyof U]: Infer<U[K]>
+export type InferTupleInput<U extends [To, ...To[]]> = {
+  [K in keyof U]: InferInput<U[K]>
+}
+
+export type InferStruct<Shape extends StructMembers> = MarkOptionals<{
+  [K in keyof Shape]: Infer<Shape[K]>
+}>
+
+export type InferStructInput<Shape extends StructMembers> = MarkOptionals<{
+  [K in keyof Shape]: InferInput<Shape[K]>
 }>
 
-export type InferStructSource<U extends { [key: string]: Reader }> =
+export type InferStructSource<U extends { [key: string]: From }> =
   // MarkEmptyOptional<
   MarkOptionals<{
     [K in keyof U]: InferSource<U[K]>
   }>
 // >
 
-export type InferSource<U extends Reader> = U extends DefaultSchema<infer T>
+export type InferSource<U extends From> = U extends ImplicitSchema<infer T, any>
   ? T | undefined
   : U extends StructSchema
   ? InferStructSource<U['shape']>
-  : U extends Reader<infer T>
+  : U extends From<infer T>
   ? T
   : never
 
diff --git a/packages/core/src/schema/uri.js b/packages/core/src/schema/uri.js
index d2fb1b34..ea3f2752 100644
--- a/packages/core/src/schema/uri.js
+++ b/packages/core/src/schema/uri.js
@@ -46,7 +46,7 @@ export const uri = () => schema
 /**
  * @param {unknown} input
  */
-export const read = input => schema.read(input)
+export const read = input => schema.tryFrom(input)
 
 /**
  * @template {API.Protocol} P
diff --git a/packages/core/src/sha256.js b/packages/core/src/sha256.js
new file mode 100644
index 00000000..015df075
--- /dev/null
+++ b/packages/core/src/sha256.js
@@ -0,0 +1,9 @@
+import * as API from '@ucanto/interface'
+
+import { sha256 } from 'multiformats/hashes/sha2'
+
+/** @type {API.MulticodecCode<typeof sha256.code, typeof sha256.name>} */
+export const code = sha256.code
+export const name = sha256.name
+export const { encode } = sha256
+export const digest = sha256.digest.bind(sha256)
diff --git a/packages/core/test/delegation.spec.js b/packages/core/test/delegation.spec.js
index 84576149..f5580013 100644
--- a/packages/core/test/delegation.spec.js
+++ b/packages/core/test/delegation.spec.js
@@ -1,8 +1,16 @@
 import { assert, test } from './test.js'
-import { CAR, CBOR, delegate, Delegation, parseLink, UCAN } from '../src/lib.js'
+import {
+  CAR,
+  CBOR,
+  delegate,
+  Delegation,
+  parseLink,
+  Schema,
+  UCAN,
+} from '../src/lib.js'
 import { alice, bob, mallory, service as w3 } from './fixtures.js'
 import { base64 } from 'multiformats/bases/base64'
-import { getBlock } from './utils.js'
+import { sha256 } from '../src/dag.js'
 
 const utf8 = new TextEncoder()
 
@@ -427,8 +435,10 @@ test('archive delegation chain', async () => {
   assert.deepEqual(extract.ok.proofs[0], proof)
 })
 
-test('delegation.attach block in capabiliy', async () => {
-  const block = await getBlock({ test: 'inlineBlock' })
+test('includes attachment in capability.nb', async () => {
+  const Block = Schema.bytes(CBOR).link({ hasher: sha256 })
+  const block = await Block.attach({ test: 'inlineBlock' })
+
   const ucan = await Delegation.delegate({
     issuer: alice,
     audience: bob,
@@ -437,24 +447,26 @@ test('delegation.attach block in capabiliy', async () => {
         can: 'store/add',
         with: alice.did(),
         nb: {
-          inlineBlock: block.cid.link()
-        }
+          inlineBlock: block,
+        },
       },
     ],
   })
 
-  ucan.attach(block)
+  const delegationBlocks = [...ucan.iterateIPLDBlocks()]
+  const attachment = delegationBlocks.find(b => b.cid.equals(block.link()))
 
-  const delegationBlocks = []
-  for (const b of ucan.iterateIPLDBlocks()) {
-    delegationBlocks.push(b)
+  if (!attachment) {
+    return assert.fail('attachment not found')
   }
 
-  assert.ok(delegationBlocks.find(b => b.cid.equals(block.cid)))
+  assert.deepEqual(CBOR.decode(attachment.bytes), { test: 'inlineBlock' })
 })
 
-test('delegation.attach block in facts', async () => {
-  const block = await getBlock({ test: 'inlineBlock' })
+test('includes attachment if it is capability.nb', async () => {
+  const Block = Schema.bytes(CBOR).link({ hasher: sha256 })
+  const block = await Block.attach({ test: 'inlineBlock' })
+
   const ucan = await Delegation.delegate({
     issuer: alice,
     audience: bob,
@@ -462,37 +474,68 @@ test('delegation.attach block in facts', async () => {
       {
         can: 'store/add',
         with: alice.did(),
+        nb: block,
       },
     ],
-    facts: [
-      { [`${block.cid.link()}`]: block.cid.link() },
-      // @ts-expect-error Link has fact entry
-      block.cid.link()
-    ]
   })
 
-  ucan.attach(block)
+  const delegationBlocks = [...ucan.iterateIPLDBlocks()]
+  const attachment = delegationBlocks.find(b => b.cid.equals(block.link()))
 
-  const delegationBlocks = []
-  for (const b of ucan.iterateIPLDBlocks()) {
-    delegationBlocks.push(b)
+  if (!attachment) {
+    return assert.fail('attachment not found')
   }
 
-  assert.ok(delegationBlocks.find(b => b.cid.equals(block.cid)))
+  assert.deepEqual(CBOR.decode(attachment.bytes), { test: 'inlineBlock' })
 })
 
-test('delegation.attach fails to attach block with not attached link', async () => {
+test('includes attachment in facts', async () => {
+  const Block = Schema.unknown().link({
+    codec: CBOR,
+    hasher: sha256,
+  })
+
+  const block = await Block.attach({ test: 'inlineBlock' })
   const ucan = await Delegation.delegate({
     issuer: alice,
     audience: bob,
     capabilities: [
       {
         can: 'store/add',
-        with: alice.did()
+        with: alice.did(),
       },
     ],
+    facts: [{ [`${block.link()}`]: block }],
   })
 
-  const block = await getBlock({ test: 'inlineBlock' })
-  assert.throws(() => ucan.attach(block))
-})
\ No newline at end of file
+  const delegationBlocks = [...ucan.iterateIPLDBlocks()]
+
+  assert.ok(delegationBlocks.find(b => b.cid.equals(block.link())))
+})
+
+test('includes unboxed attachment in facts', async () => {
+  const Block = Schema.unknown().link({
+    codec: CBOR,
+    hasher: sha256,
+  })
+
+  const block = await Block.attach({ test: 'inlineBlock' })
+  const ucan = await Delegation.delegate({
+    issuer: alice,
+    audience: bob,
+    capabilities: [
+      {
+        can: 'store/add',
+        with: alice.did(),
+      },
+    ],
+    facts: [
+      // @ts-expect-error - expects dict
+      block,
+    ],
+  })
+
+  const delegationBlocks = [...ucan.iterateIPLDBlocks()]
+
+  assert.ok(delegationBlocks.find(b => b.cid.equals(block.link())))
+})
diff --git a/packages/core/test/extra-schema.spec.js b/packages/core/test/extra-schema.spec.js
index be4447b5..14e7576e 100644
--- a/packages/core/test/extra-schema.spec.js
+++ b/packages/core/test/extra-schema.spec.js
@@ -1,6 +1,9 @@
-import { URI, Link, Text, DID } from '../src/schema.js'
+import { URI, Text, DID } from '../src/schema.js'
+import { parseLink } from '../src/lib.js'
+import * as Schema from '../src/schema.js'
 import { test, assert, matchResult } from './test.js'
 import * as API from '@ucanto/interface'
+import { sha256 } from '../src/dag.js'
 
 {
   /** @type {[string, API.Result|RegExp][]} */
@@ -13,7 +16,7 @@ import * as API from '@ucanto/interface'
   for (const [input, expect] of dataset) {
     test(`URI.read(${JSON.stringify(input)}}`, () => {
       matchResult(URI.read(input), expect)
-      matchResult(URI.uri().read(input), expect)
+      matchResult(URI.uri().tryFrom(input), expect)
     })
   }
 }
@@ -53,7 +56,7 @@ test('URI.from', () => {
     test(`URI.match(${JSON.stringify({
       protocol,
     })}).read(${JSON.stringify(input)})}}`, () => {
-      matchResult(URI.match({ protocol }).read(input), expect)
+      matchResult(URI.match({ protocol }).tryFrom(input), expect)
     })
   }
 }
@@ -82,7 +85,7 @@ test('URI.from', () => {
     test(`URI.match(${JSON.stringify({
       protocol,
     })}).optional().read(${JSON.stringify(input)})}}`, () => {
-      matchResult(URI.match({ protocol }).optional().read(input), expect)
+      matchResult(URI.match({ protocol }).optional().tryFrom(input), expect)
     })
   }
 }
@@ -91,7 +94,7 @@ test('URI.from', () => {
   /** @type {any[][]} */
   const dataset = [
     [
-      Link.parse('bafkqaaa'),
+      parseLink('bafkqaaa'),
       null,
       /Expected link to be CID with 0x70 codec/,
       /Expected link to be CID with 0x12 hashing algorithm/,
@@ -99,7 +102,7 @@ test('URI.from', () => {
       null,
     ],
     [
-      Link.parse('QmdpiaQ9q7n4E224syBJz4peZpAFLArwJgSXHZWH5F6DxB'),
+      parseLink('QmdpiaQ9q7n4E224syBJz4peZpAFLArwJgSXHZWH5F6DxB'),
       null,
       null,
       null,
@@ -107,7 +110,7 @@ test('URI.from', () => {
       null,
     ],
     [
-      Link.parse('bafybeiepa5hmd3vg2i2unyzrhnxnthwi2aksunykhmcaykbl2jx2u77cny'),
+      parseLink('bafybeiepa5hmd3vg2i2unyzrhnxnthwi2aksunykhmcaykbl2jx2u77cny'),
       null,
       null,
       null,
@@ -135,33 +138,33 @@ test('URI.from', () => {
   ]
 
   for (const [input, out1, out2, out3, out4, out5] of dataset) {
-    test(`Link.read(${input})`, () => {
-      matchResult(Link.read(input), out1 || { ok: input })
+    test(`unknown().link().tryFrom(${input})`, () => {
+      matchResult(Schema.unknown().link().tryFrom(input), out1 || { ok: input })
     })
 
-    test('Link.link()', () => {
-      const schema = Link.link()
-      matchResult(schema.read(input), out1 || { ok: input })
+    test('Schema.link()', () => {
+      const schema = Schema.unknown().link()
+      matchResult(schema.tryFrom(input), out1 || { ok: input })
     })
 
-    test(`Link.match({ code: 0x70 }).read(${input})`, () => {
-      const link = Link.match({ code: 0x70 })
-      matchResult(link.read(input), out2 || { ok: input })
+    test(`Schema.link({ code: 0x70 }).read(${input})`, () => {
+      const link = Schema.unknown().link({ codec: { code: 0x70 } })
+      matchResult(link.tryFrom(input), out2 || { ok: input })
     })
 
-    test(`Link.match({ algorithm: 0x12 }).read(${input})`, () => {
-      const link = Link.match({ multihash: { code: 0x12 } })
-      matchResult(link.read(input), out3 || { ok: input })
+    test(`Schema.link({ algorithm: 0x12 }).read(${input})`, () => {
+      const link = Schema.unknown().link({ hasher: sha256 })
+      matchResult(link.tryFrom(input), out3 || { ok: input })
     })
 
-    test(`Link.match({ version: 1 }).read(${input})`, () => {
-      const link = Link.match({ version: 1 })
-      matchResult(link.read(input), out4 || { ok: input })
+    test(`Schema.link({ version: 1 }).read(${input})`, () => {
+      const link = Schema.unknown().link({ version: 1 })
+      matchResult(link.tryFrom(input), out4 || { ok: input })
     })
 
     test(`Link.optional().read(${input})`, () => {
-      const link = Link.optional()
-      matchResult(link.read(input), out5 || { ok: input })
+      const link = Schema.unknown().link().optional()
+      matchResult(link.tryFrom(input), out5 || { ok: input })
     })
   }
 }
@@ -306,7 +309,7 @@ test('URI.from', () => {
 
   for (const [options, input, out] of dataset) {
     test(`DID.match({ method: ${options.method} }).read(${input})`, () => {
-      matchResult(DID.match(options).read(input), out)
+      matchResult(DID.match(options).tryFrom(input), out)
     })
   }
 }
@@ -349,7 +352,7 @@ test('URI.from', () => {
   for (const [options, input, out] of dataset) {
     test(`DID.match({ method: "${options.method}" }).optional().read(${input})`, () => {
       const schema = options.method ? DID.match(options) : DID.did()
-      matchResult(schema.optional().read(input), out)
+      matchResult(schema.optional().tryFrom(input), out)
     })
   }
 }
diff --git a/packages/core/test/invocation.spec.js b/packages/core/test/invocation.spec.js
index e209a849..89c0e33e 100644
--- a/packages/core/test/invocation.spec.js
+++ b/packages/core/test/invocation.spec.js
@@ -1,7 +1,7 @@
-import { invoke, UCAN, Invocation } from '../src/lib.js'
+import { invoke, UCAN, Invocation, Schema, CBOR } from '../src/lib.js'
 import { alice, service as w3 } from './fixtures.js'
-import { getBlock } from './utils.js'
 import { assert, test } from './test.js'
+import { sha256 } from '../src/dag.js'
 
 test('encode invocation', async () => {
   const add = invoke({
@@ -33,49 +33,51 @@ test('encode invocation', async () => {
 })
 
 test('encode invocation with attached block in capability nb', async () => {
-  const block = await getBlock({ test: 'inlineBlock' })
+  const Block = Schema.unknown().link({
+    codec: CBOR,
+    hasher: sha256,
+  })
+
+  const block = await Block.attach({ test: 'inlineBlock' })
   const add = invoke({
     issuer: alice,
     audience: w3,
     capability: {
       can: 'store/add',
       with: alice.did(),
-      link: 'bafy...stuff',
       nb: {
-        inlineBlock: block.cid.link()
-      }
+        link: 'bafy...stuff',
+        inlineBlock: block,
+      },
     },
     proofs: [],
   })
-  add.attach(block)
 
-  /** @type {import('@ucanto/interface').BlockStore<unknown>} */
-  const blockStore = new Map()
   const view = await add.buildIPLDView()
-  for (const b of view.iterateIPLDBlocks()) {
-    blockStore.set(`${b.cid}`, b)
-  }
+
+  const blocks = new Map(
+    [...view.iterateIPLDBlocks()].map(block => [`${block.cid}`, block])
+  )
 
   // blockstore has attached block
-  assert.ok(blockStore.get(`${block.cid}`))
+  assert.ok(blocks.get(`${block.link()}`))
 
   const reassembledInvocation = Invocation.view({
     root: view.root.cid.link(),
-    blocks: blockStore
+    blocks,
   })
 
-  /** @type {import('@ucanto/interface').BlockStore<unknown>} */
-  const reassembledBlockstore = new Map()
-  
-  for (const b of reassembledInvocation.iterateIPLDBlocks()) {
-    reassembledBlockstore.set(`${b.cid}`, b)
-  }
+  const reassembledBlockstore = new Map(
+    [...reassembledInvocation.iterateIPLDBlocks()].map(block => [
+      `${block.cid}`,
+      block,
+    ])
+  )
 
   // reassembledBlockstore has attached block
-  assert.ok(reassembledBlockstore.get(`${block.cid}`))
+  assert.ok(reassembledBlockstore.get(`${block.link()}`))
 })
 
-
 test('expired invocation', async () => {
   const expiration = UCAN.now() - 5
   const invocation = invoke({
diff --git a/packages/core/test/ipld-schema.spec.js b/packages/core/test/ipld-schema.spec.js
new file mode 100644
index 00000000..a822dff2
--- /dev/null
+++ b/packages/core/test/ipld-schema.spec.js
@@ -0,0 +1,398 @@
+import * as Schema from '../src/schema.js'
+import { isLink, parseLink, delegate, Delegation, CAR } from '../src/lib.js'
+import { alice, service as w3 } from './fixtures.js'
+import { CBOR, identity, sha256, createStore, writeInto } from '../src/dag.js'
+import { test, assert } from './test.js'
+import { archive } from '../src/delegation.js'
+
+describe('IPLD Schema', () => {
+  test('link schema', async () => {
+    const Point = Schema.struct({
+      x: Schema.integer(),
+      y: Schema.integer(),
+    })
+
+    const PointLink = Point.link({ codec: CBOR })
+
+    assert.equal(
+      PointLink.tryFrom(parseLink('bafkqaaa')).error?.message,
+      'Expected link to be CID with 0x71 codec'
+    )
+
+    const onlyX = await CBOR.write({ x: 1 })
+    const onlyXLink = await PointLink.from(
+      // @ts-expect-error - does not have y
+      onlyX.cid
+    )
+    assert.ok(onlyX)
+
+    assert.deepEqual(
+      onlyX.cid.toString(),
+      onlyXLink.link().toString(),
+      'links match'
+    )
+
+    assert.throws(
+      () => onlyXLink.resolve(new Map()),
+      'Block can not be resolved, please provide a store from which to resolve it'
+    )
+
+    assert.throws(
+      () => onlyXLink.resolve(new Map([[onlyX.cid.toString(), onlyX]])),
+      /invalid field "y"/
+    )
+
+    const point = await CBOR.write({ x: 1, y: 2 })
+    const pointLink = await PointLink.from(point.cid)
+
+    equalLink(point.cid, pointLink)
+
+    assert.throws(
+      () => pointLink.resolve(new Map()),
+      'Block can not be resolved, please provide a store from which to resolve it'
+    )
+
+    assert.deepEqual(
+      pointLink.resolve(new Map([[point.cid.toString(), point]])),
+      {
+        x: 1,
+        y: 2,
+      }
+    )
+
+    const view = pointLink.select(new Map([[point.cid.toString(), point]]))
+    equalLink(view, point.cid)
+
+    assert.deepEqual(view.resolve(), { x: 1, y: 2 })
+
+    assert.equal(isLink(PointLink.from(view)), true)
+    equalLink(PointLink.from(view), point.cid)
+
+    const p2 = await PointLink.attach({
+      x: 1,
+      y: 2,
+    })
+
+    assert.deepEqual(p2.link(), point.cid)
+    assert.deepEqual(p2.root.bytes, point.bytes)
+  })
+
+  test('embed links', async () => {
+    const Point = Schema.struct({
+      x: Schema.integer(),
+      y: Schema.integer(),
+    })
+
+    const Line = Schema.struct({
+      start: Point.link({ codec: CBOR }),
+      end: Point.link({ codec: CBOR }).attached(),
+    })
+
+    const PointLink = Point.link({ codec: CBOR })
+
+    const line = Line.from({
+      start: PointLink.embed({
+        x: 1,
+        y: 2,
+      }),
+      end: PointLink.embed({
+        x: 0,
+        y: 0,
+      }),
+    })
+
+    assert.ok(isLink(line.start), 'is a link')
+    assert.ok(isLink(line.end), 'is a link')
+    assert.equal(line.start.code, CBOR.code, 'is a CBOR link')
+    assert.equal(line.start.multihash.code, identity.code, 'is a CBOR link')
+
+    assert.deepEqual(line.start.resolve(new Map()), { x: 1, y: 2 })
+    assert.deepEqual(line.end.resolve(), { x: 0, y: 0 })
+  })
+
+  test('attached links', async () => {
+    const Point = Schema.struct({
+      x: Schema.integer(),
+      y: Schema.integer(),
+    })
+
+    const Line = Schema.struct({
+      start: Point.link({ codec: CBOR }).attached(),
+      end: Point.link({ codec: CBOR }).attached(),
+    })
+
+    const int = Schema.integer()
+    const store = createStore()
+    const start = await writeInto({ x: int.from(0), y: int.from(0) }, store)
+    const end = await writeInto({ x: int.from(7), y: int.from(8) }, store)
+    const line = await writeInto({ start: start.cid, end: end.cid }, store)
+
+    const Root = Line.link({ codec: CBOR })
+
+    const root = Root.parse(line.cid.toString())
+
+    {
+      const line = root.resolve(store)
+
+      assert.equal(line.start.resolve().x, 0)
+      assert.equal(line.start.resolve().y, 0)
+      assert.equal(line.end.resolve().x, 7)
+      assert.equal(line.end.resolve().y, 8)
+    }
+
+    const PointLink = Point.link({ codec: CBOR })
+
+    {
+      const line = Line.from({
+        start: PointLink.embed({ x: 0, y: 0 }),
+        end: await PointLink.attach({
+          x: 1,
+          y: 2,
+        }),
+      })
+
+      assert.equal(line.start.code, CBOR.code)
+      assert.equal(line.start.multihash.code, identity.code)
+      assert.equal(line.end.code, CBOR.code)
+      assert.equal(line.end.multihash.code, sha256.code)
+    }
+  })
+
+  test('read from archive', async () => {
+    const Point = Schema.struct({
+      x: Schema.integer(),
+      y: Schema.integer(),
+    })
+
+    const Line = Schema.struct({
+      start: Point.link({ codec: CBOR }).attached(),
+      end: Point.link({ codec: CBOR }).attached(),
+    })
+
+    const int = Schema.integer()
+    const archive = createStore()
+    const start = await writeInto({ x: int.from(0), y: int.from(0) }, archive)
+    const end = await writeInto({ x: int.from(7), y: int.from(8) }, archive)
+    const root = await writeInto({ start: start.cid, end: end.cid }, archive)
+
+    const Root = Line.link({ codec: CBOR })
+
+    const line = Root.parse(root.cid.toString()).resolve(archive)
+    assert.deepEqual(line.start.resolve(), { x: 0, y: 0 })
+    assert.deepEqual(line.end.resolve(), { x: 7, y: 8 })
+  })
+
+  test('build dag', async () => {
+    const Point = Schema.struct({
+      x: Schema.integer(),
+      y: Schema.integer(),
+    })
+
+    const Line = Schema.struct({
+      start: Point.link({ codec: CBOR }).attached(),
+      end: Point.link({ codec: CBOR }).attached(),
+    })
+
+    const start = await Point.link({ codec: CBOR }).attach({
+      x: 1,
+      y: 2,
+    })
+
+    const CBORPoint = Point.link({ codec: CBOR })
+    const end = await Point.link({ codec: CBOR }).attach({
+      x: 3,
+      y: 4,
+    })
+
+    const PointLink = Point.link({ codec: CBOR })
+    const PointAttachment = PointLink.attached()
+
+    const BoxedPoint = Schema.struct({
+      point: Point.link({ codec: CBOR }).attached(),
+    })
+
+    BoxedPoint.from({ point: await PointLink.attach({ x: 1, y: 2 }) })
+    const BoxedPointLink = BoxedPoint.link({ codec: CBOR })
+
+    BoxedPointLink.embed({
+      point: PointLink.embed({ x: 1, y: 2 }),
+    })
+
+    PointAttachment.from
+
+    const point = await PointLink.attach({
+      x: 1,
+      y: 2,
+    })
+
+    assert.deepEqual(point.resolve(), { x: 1, y: 2 })
+
+    const lineEmbed = await Line.link({ codec: CBOR }).attach({
+      start: point,
+      end: point,
+    })
+
+    const embed = lineEmbed.resolve()
+    assert.deepEqual(embed.start.link(), point.link())
+    assert.deepEqual(embed.start.resolve(), { x: 1, y: 2 })
+    assert.deepEqual(embed.end.link(), point.link())
+    assert.deepEqual(embed.end.resolve(), { x: 1, y: 2 })
+
+    const blocks = Object.fromEntries(
+      [...lineEmbed.iterateIPLDBlocks()].map(block => [`${block.cid}`, block])
+    )
+
+    assert.ok(blocks[lineEmbed.link().toString()])
+    assert.ok(blocks[point.link().toString()])
+  })
+
+  test('array of dags', async () => {
+    const Point = Schema.struct({
+      x: Schema.integer(),
+      y: Schema.integer(),
+    })
+
+    const Polygon = Schema.array(Point.link({ codec: CBOR }).attached())
+
+    const polygon = await Polygon.link({ codec: CBOR }).attach([
+      await Polygon.element.attach({ x: 1, y: 2 }),
+      await Polygon.element.attach({ x: 3, y: 4 }),
+      await Polygon.element.attach({ x: 5, y: 6 }),
+    ])
+
+    const compile = async (data = {}) => {
+      const { bytes, cid } = await CBOR.write(data)
+      return { bytes, cid }
+    }
+
+    const link = async (data = {}) => {
+      const { cid } = await CBOR.write(data)
+      return cid
+    }
+
+    assert.deepEqual(
+      [...polygon.iterateIPLDBlocks()].map(({ cid, bytes }) => ({
+        bytes,
+        cid: cid.link(),
+      })),
+      [
+        await compile({ x: 1, y: 2 }),
+        await compile({ x: 3, y: 4 }),
+        await compile({ x: 5, y: 6 }),
+        { cid: polygon.link(), bytes: polygon.root.bytes },
+      ]
+    )
+
+    assert.deepEqual(
+      polygon.link(),
+      await link([
+        await link({ x: 1, y: 2 }),
+        await link({ x: 3, y: 4 }),
+        await link({ x: 5, y: 6 }),
+      ])
+    )
+
+    const region = new Map(
+      [...polygon.iterateIPLDBlocks()].map(block => [`${block.cid}`, block])
+    )
+
+    const root = Polygon.link({ codec: CBOR })
+      .parse(polygon.link().toString())
+      .select(region)
+
+    const replica = root.resolve()
+
+    assert.deepEqual(
+      replica.map(point => point.link()),
+      [
+        await link({ x: 1, y: 2 }),
+        await link({ x: 3, y: 4 }),
+        await link({ x: 5, y: 6 }),
+      ]
+    )
+
+    assert.deepEqual(
+      replica.map(point => point.resolve()),
+      [
+        { x: 1, y: 2 },
+        { x: 3, y: 4 },
+        { x: 5, y: 6 },
+      ]
+    )
+  })
+
+  test('inline into delegation', async () => {
+    const Detail = Schema.struct({
+      link: Schema.unknown().link(),
+      size: Schema.integer(),
+      src: Schema.string().array(),
+    })
+    const Offer = Schema.array(Detail)
+    const Capability = Schema.struct({
+      with: Schema.did(),
+      can: Schema.literal('aggregate/offer'),
+      nb: Schema.struct({
+        offer: Offer.link({ codec: CBOR }).attached(),
+      }),
+    })
+
+    const userData = await CBOR.write({ hello: 'world' })
+
+    const car = await CAR.write({
+      roots: [userData],
+    })
+
+    const offer = await delegate({
+      issuer: alice,
+      audience: w3,
+      capabilities: [
+        Capability.from({
+          can: 'aggregate/offer',
+          with: alice.did(),
+          nb: {
+            offer: await Offer.link({ codec: CBOR, hasher: sha256 }).attach([
+              Detail.from({
+                link: car.cid,
+                size: car.bytes.length,
+                src: [`ipfs://${car.cid}`],
+              }),
+            ]),
+          },
+        }),
+      ],
+    })
+
+    const nodes = [...offer.export()]
+
+    assert.deepEqual(nodes.length, 2, 'links to the attached block')
+    const [node, root] = nodes
+    assert.deepEqual(root.cid, offer.link())
+    assert.deepEqual(CBOR.decode(node.bytes), [
+      {
+        link: car.cid,
+        size: car.bytes.length,
+        src: [`ipfs://${car.cid}`],
+      },
+    ])
+
+    const archive = await offer.archive()
+    if (archive.error) {
+      throw archive.error
+    }
+
+    const replica = await Delegation.extract(archive.ok)
+    if (replica.error) {
+      throw replica.error
+    }
+
+    assert.equal([...replica.ok.export()].length, 2)
+  })
+})
+
+/**
+ *
+ * @param {Schema.UnknownLink} actual
+ * @param {Schema.UnknownLink} expected
+ */
+const equalLink = (actual, expected) =>
+  assert.deepEqual(CBOR.encode(actual), CBOR.encode(expected))
diff --git a/packages/core/test/link-schema.spec.js b/packages/core/test/link-schema.spec.js
index 67a66c53..1a16e715 100644
--- a/packages/core/test/link-schema.spec.js
+++ b/packages/core/test/link-schema.spec.js
@@ -1,80 +1,134 @@
 import * as Schema from '../src/schema.js'
 import { base36 } from 'multiformats/bases/base36'
 import { test, assert, matchError } from './test.js'
+import { CBOR, sha256 } from '../src/dag.js'
 
 const fixtures = {
-  pb: Schema.Link.parse('QmTgnQBKj7eTV7ohraBCmh1DLwerUd2X9Rxzgf3gyMJbC8'),
-  cbor: Schema.Link.parse(
-    'bafyreieuo63r3y2nuycaq4b3q2xvco3nprlxiwzcfp4cuupgaywat3z6mq'
-  ),
-  rawIdentity: Schema.Link.parse('bafkqaaa'),
-  ipns: Schema.Link.parse(
-    'k2k4r8kuj2bs2l996lhjx8rc727xlvthtak8o6eia3qm5adxvs5k84gf',
-    base36
-  ),
-  sha512: Schema.Link.parse(
-    'kgbuwaen1jrbjip6iwe9mqg54spvuucyz7f5jho2tkc2o0c7xzqwpxtogbyrwck57s9is6zqlwt9rsxbuvszym10nbaxt9jn7sf4eksqd',
-    base36
-  ),
+  pb: Schema.unknown()
+    .link()
+    .parse('QmTgnQBKj7eTV7ohraBCmh1DLwerUd2X9Rxzgf3gyMJbC8'),
+  cbor: Schema.unknown()
+    .link()
+    .parse('bafyreieuo63r3y2nuycaq4b3q2xvco3nprlxiwzcfp4cuupgaywat3z6mq'),
+  rawIdentity: Schema.unknown().link().parse('bafkqaaa'),
+  ipns: Schema.unknown()
+    .link()
+    .parse('k2k4r8kuj2bs2l996lhjx8rc727xlvthtak8o6eia3qm5adxvs5k84gf', base36),
+  sha512: Schema.unknown()
+    .link()
+    .parse(
+      'kgbuwaen1jrbjip6iwe9mqg54spvuucyz7f5jho2tkc2o0c7xzqwpxtogbyrwck57s9is6zqlwt9rsxbuvszym10nbaxt9jn7sf4eksqd',
+      base36
+    ),
 }
 
 const links = Object.values(fixtures)
 const versions = new Set(links.map(link => link.version))
 const codes = new Set(links.map(link => link.code))
 const algs = new Set(links.map(link => link.multihash.code))
-const digests = new Set(links.map(link => link.multihash.digest))
 
 for (const link of links) {
   test(`${link} ➡ Schema.link()`, () => {
-    assert.deepEqual(Schema.link().read(link), { ok: link }, `${link}`)
+    assert.deepEqual(
+      Schema.unknown().link().tryFrom(link),
+      { ok: link },
+      `${link}`
+    )
   })
 
   for (const version of versions) {
-    test(`${link} ➡ Schema.link({ version: ${version}})`, () => {
-      const schema = Schema.link({ version })
+    test(`${link} ➡ Schema.unknown().link({ version: ${version}})`, () => {
+      const schema = Schema.unknown().link({ version })
       if (link.version === version) {
-        assert.deepEqual(schema.read(link), { ok: link })
+        assert.deepEqual(schema.tryFrom(link), { ok: link })
       } else {
-        matchError(schema.read(link), /Expected link to be CID version/)
+        matchError(schema.tryFrom(link), /Expected link to be CID version/)
       }
     })
   }
 
   for (const code of codes) {
     test(`${link} ➡ Schema.link({ code: ${code}})`, () => {
-      const schema = Schema.link({ code })
+      const schema = Schema.unknown().link({ codec: { code } })
       if (link.code === code) {
-        assert.deepEqual(schema.read(link), { ok: link })
+        assert.deepEqual(schema.tryFrom(link), { ok: link })
       } else {
-        matchError(schema.read(link), /Expected link to be CID with .* codec/)
+        matchError(
+          schema.tryFrom(link),
+          /Expected link to be CID with .* codec/
+        )
       }
     })
   }
 
   for (const code of algs) {
-    test(`${link} ➡ Schema.link({ multihash: {code: ${code}} })`, () => {
-      const schema = Schema.link({ multihash: { code } })
+    test(`${link} ➡ Schema.unknown().link({ hasher: {code: ${code}} })`, () => {
+      const schema = Schema.unknown().link({ hasher: { code } })
       if (link.multihash.code === code) {
-        assert.deepEqual(schema.read(link), { ok: link })
+        assert.deepEqual(schema.tryFrom(link), { ok: link })
       } else {
         matchError(
-          schema.read(link),
+          schema.tryFrom(link),
           /Expected link to be CID with .* hashing algorithm/
         )
       }
     })
   }
-
-  for (const digest of digests) {
-    test(`${link} ➡ Schema.link({ multihash: {digest} })`, () => {
-      const schema = Schema.link({
-        multihash: { digest: new Uint8Array(digest) },
-      })
-      if (link.multihash.digest === digest) {
-        assert.deepEqual(schema.read(link), { ok: link })
-      } else {
-        matchError(schema.read(link), /Expected link with .* hash digest/)
-      }
-    })
-  }
 }
+
+test('struct().link()', () => {
+  const Point = Schema.struct({
+    x: Schema.integer(),
+    y: Schema.integer(),
+  })
+  const PointLink = Point.link()
+
+  assert.equal(PointLink.read(fixtures.pb).ok, fixtures.pb)
+
+  assert.throws(() => PointLink.link(), /link of link/)
+})
+
+test('struct().link({ codec })', () => {
+  const Point = Schema.struct({
+    x: Schema.integer(),
+    y: Schema.integer(),
+  })
+  const PointLink = Point.link({
+    codec: CBOR,
+  })
+
+  assert.match(PointLink.read(fixtures.pb).error?.message || '', /0x71 code/)
+  assert.equal(PointLink.read(fixtures.cbor).ok, fixtures.cbor)
+})
+
+test('struct().link({ hasher })', () => {
+  const Point = Schema.struct({
+    x: Schema.integer(),
+    y: Schema.integer(),
+  })
+  const PointLink = Point.link({
+    hasher: sha256,
+  })
+
+  assert.match(
+    PointLink.read(fixtures.sha512).error?.message || '',
+    /0x12 hashing/
+  )
+  assert.equal(
+    PointLink.read(fixtures.cbor).ok,
+    /** @type {*} */ (fixtures.cbor)
+  )
+})
+
+test('struct().link({ hasher })', () => {
+  const Point = Schema.struct({
+    x: Schema.integer(),
+    y: Schema.integer(),
+  })
+  const PointLink = Point.link({
+    version: 1,
+  })
+
+  assert.match(PointLink.read(fixtures.pb).error?.message || '', /version 1/)
+  assert.equal(PointLink.read(fixtures.cbor).ok, fixtures.cbor)
+})
diff --git a/packages/core/test/map-schema.spec.js b/packages/core/test/map-schema.spec.js
index 00aa8b80..eef0de4f 100644
--- a/packages/core/test/map-schema.spec.js
+++ b/packages/core/test/map-schema.spec.js
@@ -1,4 +1,5 @@
 import * as Schema from '../src/schema.js'
+import { CBOR } from '../src/dag.js'
 import { test, assert } from './test.js'
 
 test('.partial on structs', () => {
diff --git a/packages/core/test/message.spec.js b/packages/core/test/message.spec.js
index dcbd21c1..462cf54d 100644
--- a/packages/core/test/message.spec.js
+++ b/packages/core/test/message.spec.js
@@ -72,6 +72,8 @@ test('Message.view', async () => {
     invocations: [hi.invocation],
   })
 
+  assert.equal(buildHi.link(), buildHi.root.cid)
+
   assert.throws(
     () =>
       Message.view({
diff --git a/packages/core/test/receipt.spec.js b/packages/core/test/receipt.spec.js
index 854cdbe7..22542281 100644
--- a/packages/core/test/receipt.spec.js
+++ b/packages/core/test/receipt.spec.js
@@ -273,6 +273,8 @@ test('receipt view fallback', async () => {
  * @param {Partial<Receipt> & { verifier?: API.Verifier }} expect
  */
 const assertReceipt = async (receipt, expect) => {
+  assert.equal(receipt.link(), receipt.root.cid, 'root cid is correct')
+
   if (expect.out) {
     assert.deepEqual(receipt.out, expect.out, 'out is correct')
   }
diff --git a/packages/core/test/schema.spec.js b/packages/core/test/schema.spec.js
index 9f75276f..8ca072f2 100644
--- a/packages/core/test/schema.spec.js
+++ b/packages/core/test/schema.spec.js
@@ -5,10 +5,11 @@ import fixtures from './schema/fixtures.js'
 for (const { input, schema, expect, inputLabel, skip, only } of fixtures()) {
   const unit = skip ? test.skip : only ? test.only : test
 
-  unit(`${schema}.read(${inputLabel})`, () => {
-    const result = schema.read(input)
+  unit(`${schema}.tryFrom(${inputLabel})`, () => {
+    const result = schema.tryFrom(input)
 
     if (expect.error) {
+      // console.log(`${schema}.tryFrom(${inputLabel})`, result, expect.error)
       matchError(result, expect.error)
     } else {
       assert.deepEqual(
@@ -46,12 +47,12 @@ test('string startsWith & endsWith', () => {
     'string().refine(startsWith("hello")).refine(startsWith("hi"))'
   )
 
-  assert.deepInclude(impossible.read('hello world').error, {
+  assert.deepInclude(impossible.tryFrom('hello world').error, {
     name: 'SchemaError',
     message: `Expect string to start with "hi" instead got "hello world"`,
   })
 
-  assert.deepInclude(impossible.read('hello world').error, {
+  assert.deepInclude(impossible.tryFrom('hello world').error, {
     name: 'SchemaError',
     message: `Expect string to start with "hi" instead got "hello world"`,
   })
@@ -60,7 +61,7 @@ test('string startsWith & endsWith', () => {
   /** @type {Schema.StringSchema<`hello${string}` & `hello ${string}`>} */
   const typeofHello = hello
 
-  assert.deepEqual(hello.read('hello world'), { ok: 'hello world' })
+  assert.deepEqual(hello.tryFrom('hello world'), { ok: 'hello world' })
 })
 
 test('string startsWith', () => {
@@ -71,8 +72,8 @@ test('string startsWith', () => {
   /** @type {Schema.StringSchema<`hello${string}`>} */
   const hello = Schema.string().startsWith('hello')
 
-  assert.deepEqual(hello.read('hello world!'), { ok: 'hello world!' })
-  assert.deepInclude(hello.read('hi world').error, {
+  assert.deepEqual(hello.tryFrom('hello world!'), { ok: 'hello world!' })
+  assert.deepInclude(hello.tryFrom('hi world').error, {
     name: 'SchemaError',
     message: `Expect string to start with "hello" instead got "hi world"`,
   })
@@ -86,9 +87,9 @@ test('string endsWith', () => {
   /** @type {Schema.StringSchema<`${string} world`>} */
   const greet = Schema.string().endsWith(' world')
 
-  assert.deepEqual(greet.read('hello world'), { ok: 'hello world' })
-  assert.deepEqual(greet.read('hi world'), { ok: 'hi world' })
-  assert.deepInclude(greet.read('hello world!').error, {
+  assert.deepEqual(greet.tryFrom('hello world'), { ok: 'hello world' })
+  assert.deepEqual(greet.tryFrom('hi world'), { ok: 'hi world' })
+  assert.deepInclude(greet.tryFrom('hello world!').error, {
     name: 'SchemaError',
     message: `Expect string to end with " world" instead got "hello world!"`,
   })
@@ -113,24 +114,24 @@ test('string startsWith/endsWith', () => {
     `string().refine(endsWith("!")).refine(startsWith("hello"))`
   )
 
-  assert.deepEqual(hello1.read('hello world!'), { ok: 'hello world!' })
-  assert.deepEqual(hello2.read('hello world!'), { ok: 'hello world!' })
-  assert.deepInclude(hello1.read('hello world').error, {
+  assert.deepEqual(hello1.tryFrom('hello world!'), { ok: 'hello world!' })
+  assert.deepEqual(hello2.tryFrom('hello world!'), { ok: 'hello world!' })
+  assert.deepInclude(hello1.tryFrom('hello world').error, {
     name: 'SchemaError',
     message: `Expect string to end with "!" instead got "hello world"`,
   })
 
-  assert.deepInclude(hello2.read('hello world').error, {
+  assert.deepInclude(hello2.tryFrom('hello world').error, {
     name: 'SchemaError',
     message: `Expect string to end with "!" instead got "hello world"`,
   })
 
-  assert.deepInclude(hello1.read('hi world!').error, {
+  assert.deepInclude(hello1.tryFrom('hi world!').error, {
     name: 'SchemaError',
     message: `Expect string to start with "hello" instead got "hi world!"`,
   })
 
-  assert.deepInclude(hello2.read('hi world!').error, {
+  assert.deepInclude(hello2.tryFrom('hi world!').error, {
     name: 'SchemaError',
     message: `Expect string to start with "hello" instead got "hi world!"`,
   })
@@ -141,12 +142,12 @@ test('string startsWith & endsWith', () => {
   /** @type {Schema.StringSchema<`hello${string}` & `hi${string}`>} */
   const typeofImpossible = impossible
 
-  assert.deepInclude(impossible.read('hello world').error, {
+  assert.deepInclude(impossible.tryFrom('hello world').error, {
     name: 'SchemaError',
     message: `Expect string to start with "hi" instead got "hello world"`,
   })
 
-  assert.deepInclude(impossible.read('hello world').error, {
+  assert.deepInclude(impossible.tryFrom('hello world').error, {
     name: 'SchemaError',
     message: `Expect string to start with "hi" instead got "hello world"`,
   })
@@ -155,23 +156,23 @@ test('string startsWith & endsWith', () => {
   /** @type {Schema.StringSchema<`hello${string}` & `hello ${string}`>} */
   const typeofHello = hello
 
-  assert.deepEqual(hello.read('hello world'), { ok: 'hello world' })
+  assert.deepEqual(hello.tryFrom('hello world'), { ok: 'hello world' })
 })
 
 test('string().refine', () => {
   const impossible = Schema.string()
     .refine(Schema.startsWith('hello'))
+    // @ts-expect-error - catches invalid type
     .refine(Schema.startsWith('hi'))
 
-  /** @type {Schema.StringSchema<`hello${string}` & `hi${string}`>} */
   const typeofImpossible = impossible
 
-  assert.deepInclude(impossible.read('hello world').error, {
+  assert.deepInclude(impossible.tryFrom('hello world').error, {
     name: 'SchemaError',
     message: `Expect string to start with "hi" instead got "hello world"`,
   })
 
-  assert.deepInclude(impossible.read('hello world').error, {
+  assert.deepInclude(impossible.tryFrom('hello world').error, {
     name: 'SchemaError',
     message: `Expect string to start with "hi" instead got "hello world"`,
   })
@@ -183,14 +184,15 @@ test('string().refine', () => {
   /** @type {Schema.StringSchema<`hello${string}` & `hello ${string}`>} */
   const typeofHello = hello
 
-  assert.deepEqual(hello.read('hello world'), { ok: 'hello world' })
+  assert.deepEqual(hello.tryFrom('hello world'), { ok: 'hello world' })
 
   const greet = hello.refine({
     /**
      * @template {string} In
      * @param {In} hello
+     * @returns {Schema.ReadResult<In & { length: 11 }>}
      */
-    read(hello) {
+    tryFrom(hello) {
       if (hello.length === 11) {
         return Schema.ok(/** @type {In & {length: 11}} */ (hello))
       } else {
@@ -198,35 +200,35 @@ test('string().refine', () => {
       }
     },
   })
-  /** @type {Schema.StringSchema<`hello${string}` & `hello ${string}` & { length: 11 }>} */
+  /** @type {Schema.StringSchema<`hello ${string}` & { length: 11 }>} */
   const typeofGreet = greet
 
   assert.equal(
-    greet.read('hello world').ok,
+    greet.tryFrom('hello world').ok,
     /** @type {unknown} */ ('hello world')
   )
   assert.equal(
-    greet.read('hello Julia').ok,
+    greet.tryFrom('hello Julia').ok,
     /** @type {unknown} */ ('hello Julia')
   )
 
-  assert.deepInclude(greet.read('hello Jack').error, {
+  assert.deepInclude(greet.tryFrom('hello Jack').error, {
     name: 'SchemaError',
     message: 'Expected string with 11 chars',
   })
 })
 
-test('never().default()', () => {
+test.skip('never().default()', () => {
   assert.throws(
     () =>
       Schema.never()
         // @ts-expect-error - no value satisfies default
-        .default('hello'),
+        .implicit('hello'),
     /Expected value of type never instead got "hello"/
   )
 })
 
-test('literal("foo").default("bar") throws', () => {
+test.skip('literal("foo").default("bar") throws', () => {
   assert.throws(
     () =>
       Schema.literal('foo')
@@ -237,9 +239,9 @@ test('literal("foo").default("bar") throws', () => {
 })
 
 test('default on literal has default', () => {
-  const schema = Schema.literal('foo').default()
+  const schema = Schema.literal('foo').implicit()
 
-  assert.deepEqual(schema.read(undefined), Schema.ok('foo'))
+  assert.deepEqual(schema.tryFrom(undefined), Schema.ok('foo'))
 })
 
 test('literal has value field', () => {
@@ -247,7 +249,7 @@ test('literal has value field', () => {
 })
 
 test('.default().optional() is noop', () => {
-  const schema = Schema.string().default('hello')
+  const schema = Schema.string().implicit('hello')
   assert.equal(schema.optional(), schema)
 })
 
@@ -279,7 +281,7 @@ test('struct', () => {
     y: Schema.integer(),
   })
 
-  const p1 = Point.read({
+  const p1 = Point.tryFrom({
     x: 1,
     y: 2,
   })
@@ -287,7 +289,7 @@ test('struct', () => {
 
   matchError(p1, /field "type".*expect.*"Point".*got undefined/is)
 
-  const p2 = Point.read({
+  const p2 = Point.tryFrom({
     type: 'Point',
     x: 1,
     y: 1,
@@ -300,7 +302,7 @@ test('struct', () => {
     },
   })
 
-  const p3 = Point.read({
+  const p3 = Point.tryFrom({
     type: 'Point',
     x: 1,
     y: 1.1,
@@ -310,21 +312,22 @@ test('struct', () => {
   matchError(p3, /field "y".*expect.*integer.*got 1.1/is)
 
   matchError(
-    Point.read(['h', 'e', 'l', null, 'l', 'o']),
+    // @ts-expect-error - bad input
+    Point.tryFrom(['h', 'e', 'l', null, 'l', 'o']),
     /Expected value of type object instead got array/
   )
 })
 
 test('struct with defaults', () => {
   const Point = Schema.struct({
-    x: Schema.number().default(0),
-    y: Schema.number().default(0),
+    x: Schema.number().implicit(0),
+    y: Schema.number().implicit(0),
   })
 
-  assert.deepEqual(Point.read({}), { ok: { x: 0, y: 0 } })
-  assert.deepEqual(Point.read({ x: 2 }), { ok: { x: 2, y: 0 } })
-  assert.deepEqual(Point.read({ x: 2, y: 7 }), { ok: { x: 2, y: 7 } })
-  assert.deepEqual(Point.read({ y: 7 }), { ok: { x: 0, y: 7 } })
+  assert.deepEqual(Point.tryFrom({}), { ok: { x: 0, y: 0 } })
+  assert.deepEqual(Point.tryFrom({ x: 2 }), { ok: { x: 2, y: 0 } })
+  assert.deepEqual(Point.tryFrom({ x: 2, y: 7 }), { ok: { x: 2, y: 7 } })
+  assert.deepEqual(Point.tryFrom({ y: 7 }), { ok: { x: 0, y: 7 } })
 })
 
 test('struct with literals', () => {
@@ -334,10 +337,10 @@ test('struct with literals', () => {
     y: Schema.number(),
   })
 
-  assert.deepEqual(Point.read({ x: 0, y: 0, z: 0 }), {
+  assert.deepEqual(Point.tryFrom({ x: 0, y: 0, z: 0 }), {
     ok: { x: 0, y: 0, z: 0 },
   })
-  matchError(Point.read({ x: 1, y: 1, z: 1 }), /"z".*expect.* 0 .* got 1/is)
+  matchError(Point.tryFrom({ x: 1, y: 1, z: 1 }), /"z".*expect.* 0 .* got 1/is)
 })
 
 test('bad struct def', () => {
@@ -355,7 +358,7 @@ test('bad struct def', () => {
 test('struct with null literal', () => {
   const schema = Schema.struct({ a: null, b: true, c: Schema.string() })
 
-  assert.deepEqual(schema.read({ a: null, b: true, c: 'hi' }), {
+  assert.deepEqual(schema.tryFrom({ a: null, b: true, c: 'hi' }), {
     ok: {
       a: null,
       b: true,
@@ -364,12 +367,12 @@ test('struct with null literal', () => {
   })
 
   matchError(
-    schema.read({ a: null, b: false, c: '' }),
+    schema.tryFrom({ a: null, b: false, c: '' }),
     /"b".*expect.* true .* got false/is
   )
 
   matchError(
-    schema.read({ b: true, c: '' }),
+    schema.tryFrom({ b: true, c: '' }),
     /"a".*expect.* null .* got undefined/is
   )
 })
@@ -377,73 +380,89 @@ test('struct with null literal', () => {
 test('lessThan', () => {
   const schema = Schema.number().lessThan(100)
 
-  assert.deepEqual(schema.read(10), { ok: 10 })
-  matchError(schema.read(127), /127 < 100/)
-  matchError(schema.read(Infinity), /Infinity < 100/)
-  matchError(schema.read(NaN), /NaN < 100/)
+  assert.deepEqual(schema.tryFrom(10), { ok: 10 })
+  matchError(schema.tryFrom(127), /127 < 100/)
+  matchError(schema.tryFrom(Infinity), /Infinity < 100/)
+  matchError(schema.tryFrom(NaN), /NaN < 100/)
 })
 
 test('greaterThan', () => {
   const schema = Schema.number().greaterThan(100)
 
-  assert.deepEqual(schema.read(127), { ok: 127 })
-  matchError(schema.read(12), /12 > 100/)
-  assert.deepEqual(schema.read(Infinity), { ok: Infinity })
-  matchError(schema.read(NaN), /NaN > 100/)
+  assert.deepEqual(schema.tryFrom(127), { ok: 127 })
+  matchError(schema.tryFrom(12), /12 > 100/)
+  assert.deepEqual(schema.tryFrom(Infinity), { ok: Infinity })
+  matchError(schema.tryFrom(NaN), /NaN > 100/)
 })
 
 test('number().greaterThan().lessThan()', () => {
   const schema = Schema.number().greaterThan(3).lessThan(117)
 
-  assert.deepEqual(schema.read(4), { ok: 4 })
-  assert.deepEqual(schema.read(116), { ok: 116 })
-  matchError(schema.read(117), /117 < 117/)
-  matchError(schema.read(3), /3 > 3/)
-  matchError(schema.read(127), /127 < 117/)
-  matchError(schema.read(0), /0 > 3/)
-  matchError(schema.read(Infinity), /Infinity < 117/)
-  matchError(schema.read(NaN), /NaN > 3/)
+  assert.deepEqual(schema.tryFrom(4), { ok: 4 })
+  assert.deepEqual(schema.tryFrom(116), { ok: 116 })
+  matchError(schema.tryFrom(117), /117 < 117/)
+  matchError(schema.tryFrom(3), /3 > 3/)
+  matchError(schema.tryFrom(127), /127 < 117/)
+  matchError(schema.tryFrom(0), /0 > 3/)
+  matchError(schema.tryFrom(Infinity), /Infinity < 117/)
+  matchError(schema.tryFrom(NaN), /NaN > 3/)
 })
 
 test('enum', () => {
   const schema = Schema.enum(['Red', 'Green', 'Blue'])
   assert.equal(schema.toString(), 'Red|Green|Blue')
-  assert.deepEqual(schema.read('Red'), { ok: 'Red' })
-  assert.deepEqual(schema.read('Blue'), { ok: 'Blue' })
-  assert.deepEqual(schema.read('Green'), { ok: 'Green' })
+  assert.deepEqual(schema.tryFrom('Red'), { ok: 'Red' })
+  assert.deepEqual(schema.tryFrom('Blue'), { ok: 'Blue' })
+  assert.deepEqual(schema.tryFrom('Green'), { ok: 'Green' })
 
-  matchError(schema.read('red'), /expect.* Red\|Green\|Blue .* got "red"/is)
-  matchError(schema.read(5), /expect.* Red\|Green\|Blue .* got 5/is)
+  matchError(schema.tryFrom('red'), /expect.* Red\|Green\|Blue .* got "red"/is)
+  matchError(
+    schema.tryFrom(
+      // @ts-expect-error - invalid arg
+      5
+    ),
+    /expect.* Red\|Green\|Blue .* got 5/is
+  )
 })
 
 test('tuple', () => {
   const schema = Schema.tuple([Schema.string(), Schema.integer()])
   matchError(
-    schema.read([, undefined]),
+    schema.tryFrom([
+      ,
+      // @ts-expect-error - not an int
+      undefined,
+    ]),
     /invalid element at 0.*expect.*string.*got undefined/is
   )
   matchError(
-    schema.read([0, 'hello']),
+    schema.tryFrom(
+      // @ts-expect-error - invalid arg
+      [0, 'hello']
+    ),
     /invalid element at 0.*expect.*string.*got 0/is
   )
   matchError(
-    schema.read(['0', '1']),
-    /invalid element at 1.*expect.*number.*got "1"/is
+    schema.tryFrom(
+      // @ts-expect-error - invalid arg
+      ['0', '1']
+    ),
+    /invalid element at 1.*expect.*integer.*got "1"/is
   )
   matchError(
-    schema.read(['0', Infinity]),
+    schema.tryFrom(['0', Infinity]),
     /invalid element at 1.*expect.*integer.*got Infinity/is
   )
   matchError(
-    schema.read(['0', NaN]),
+    schema.tryFrom(['0', NaN]),
     /invalid element at 1.*expect.*integer.*got NaN/is
   )
   matchError(
-    schema.read(['0', 0.2]),
+    schema.tryFrom(['0', 0.2]),
     /invalid element at 1.*expect.*integer.*got 0.2/is
   )
 
-  assert.deepEqual(schema.read(['x', 0]), { ok: ['x', 0] })
+  assert.deepEqual(schema.tryFrom(['x', 0]), { ok: ['x', 0] })
 })
 
 test('extend API', () => {
@@ -473,7 +492,7 @@ test('extend API', () => {
     const schema = new DIDString('key')
     assert.equal(schema.toString(), 'new DIDString()')
     matchError(
-      schema.read(
+      schema.tryFrom(
         // @ts-expect-error
         54
       ),
@@ -481,12 +500,18 @@ test('extend API', () => {
     )
 
     matchError(
-      schema.read('did:echo:foo'),
+      schema.tryFrom('did:echo:foo'),
       /Expected did:key URI instead got did:echo:foo/
     )
 
     const didKey = Schema.string().refine(new DIDString('key'))
-    matchError(didKey.read(54), /Expect.* string instead got 54/is)
+    matchError(
+      didKey.tryFrom(
+        // @ts-expect-error - invalid arg
+        54
+      ),
+      /Expect.* string instead got 54/is
+    )
   }
 })
 
@@ -510,7 +535,7 @@ test('refine', () => {
     /**
      * @param {T[]} array
      */
-    read(array) {
+    tryFrom(array) {
       return array.length > 0
         ? Schema.ok(array)
         : Schema.error('Array expected to have elements')
@@ -520,24 +545,35 @@ test('refine', () => {
   const schema = Schema.array(Schema.string()).refine(new NonEmpty())
 
   assert.equal(schema.toString(), 'array(string()).refine(new NonEmpty())')
-  matchError(schema.read([]), /Array expected to have elements/)
-  assert.deepEqual(schema.read(['hello', 'world']), { ok: ['hello', 'world'] })
-  matchError(schema.read(null), /expect.* array .*got null/is)
+  matchError(schema.tryFrom([]), /Array expected to have elements/)
+  assert.deepEqual(schema.tryFrom(['hello', 'world']), {
+    ok: ['hello', 'world'],
+  })
+  matchError(
+    schema.tryFrom(
+      // @ts-expect-error - invalid arg
+      null
+    ),
+    /expect.* array .*got null/is
+  )
 })
 
 test('brand', () => {
   const digit = Schema.integer()
     .refine({
-      read(n) {
+      tryFrom(n) {
         return n >= 0 && n <= 9
           ? Schema.ok(n)
           : Schema.error(`Expected digit but got ${n}`)
       },
+      tryTo(n) {
+        return { ok: n }
+      },
     })
     .brand('digit')
 
-  matchError(digit.read(10), /Expected digit but got 10/)
-  matchError(digit.read(2.7), /Expected value of type integer/)
+  matchError(digit.tryFrom(10), /Expected digit but got 10/)
+  matchError(digit.tryFrom(2.7), /Expected value of type integer/)
   assert.equal(digit.from(2), 2)
 
   /** @param {Schema.Infer<typeof digit>} n */
@@ -564,26 +600,26 @@ test('optional.default removes undefined from type', () => {
   // @ts-expect-error - Schema<string | undefined> is not assignable
   const castError = schema1
 
-  const schema2 = schema1.default('')
+  const schema2 = schema1.implicit('')
   /** @type {Schema.Schema<string>} */
   const castOk = schema2
 
-  assert.deepEqual(schema1.read(undefined), { ok: undefined })
-  assert.deepEqual(schema2.read(undefined), { ok: '' })
+  assert.deepEqual(schema1.tryFrom(undefined), { ok: undefined })
+  assert.deepEqual(schema2.tryFrom(undefined), { ok: '' })
 })
 
 test('.default("one").default("two")', () => {
-  const schema = Schema.string().default('one').default('two')
+  const schema = Schema.string().implicit('one').implicit('two')
 
   assert.equal(schema.value, 'two')
-  assert.deepEqual(schema.read(undefined), { ok: 'two' })
-  assert.deepEqual(schema.read('three'), { ok: 'three' })
+  assert.deepEqual(schema.tryFrom(undefined), { ok: 'two' })
+  assert.deepEqual(schema.tryFrom('three'), { ok: 'three' })
 })
 
-test('default throws on invalid default', () => {
+test.skip('default throws on invalid default', () => {
   assert.throws(
     () =>
-      Schema.string().default(
+      Schema.string().implicit(
         // @ts-expect-error - number is not assignable to string
         101
       ),
@@ -593,7 +629,7 @@ test('default throws on invalid default', () => {
 
 test('unknown with default', () => {
   assert.throws(
-    () => Schema.unknown().default(undefined),
+    () => Schema.unknown().implicit(undefined),
     /undefined is not a valid default/
   )
 })
@@ -601,17 +637,20 @@ test('unknown with default', () => {
 test('default swaps undefined even if decodes to undefined', () => {
   /** @type {Schema.Schema} */
   const schema = Schema.unknown().refine({
-    read(value) {
+    tryFrom(value) {
+      return { ok: value === null ? undefined : value }
+    },
+    tryTo(value) {
       return { ok: value === null ? undefined : value }
     },
   })
 
-  assert.deepEqual(schema.default('X').read(null), { ok: 'X' })
+  assert.deepEqual(schema.implicit('X').tryFrom(null), { ok: 'X' })
 })
 
 test('record defaults', () => {
   const Point = Schema.struct({
-    x: Schema.integer().default(1),
+    x: Schema.integer().implicit(1),
     y: Schema.integer().optional(),
   })
 
@@ -619,7 +658,13 @@ test('record defaults', () => {
     z: Schema.integer(),
   })
 
-  matchError(Point.read(undefined), /expect.* object .* got undefined/is)
+  matchError(
+    Point.tryFrom(
+      // @ts-expect-error - bad input
+      undefined
+    ),
+    /expect.* object .* got undefined/is
+  )
   assert.deepEqual(Point.create(), {
     x: 1,
   })
@@ -627,20 +672,20 @@ test('record defaults', () => {
     x: 1,
   })
 
-  assert.deepEqual(Point.read({}), {
+  assert.deepEqual(Point.tryFrom({}), {
     ok: {
       x: 1,
     },
   })
 
-  assert.deepEqual(Point.read({ y: 2 }), {
+  assert.deepEqual(Point.tryFrom({ y: 2 }), {
     ok: {
       x: 1,
       y: 2,
     },
   })
 
-  assert.deepEqual(Point.read({ x: 2, y: 2 }), {
+  assert.deepEqual(Point.tryFrom({ x: 2, y: 2 }), {
     ok: {
       x: 2,
       y: 2,
@@ -648,8 +693,8 @@ test('record defaults', () => {
   })
 
   const Line = Schema.struct({
-    start: Point.default({ x: 0 }),
-    end: Point.default({ x: 1, y: 3 }),
+    start: Point.implicit({ x: 0 }),
+    end: Point.implicit({ x: 1, y: 3 }),
   })
 
   assert.deepEqual(Line.create(), {
@@ -660,21 +705,39 @@ test('record defaults', () => {
 
 test('bytes schema', () => {
   const schema = Schema.bytes()
-  matchError(schema.read(undefined), /expect.* Uint8Array .* got undefined/is)
+  matchError(
+    schema.tryFrom(
+      // @ts-expect-error - expects Uint8Array
+      undefined
+    ),
+    /expect.* Uint8Array .* got undefined/is
+  )
 
   const bytes = new Uint8Array([1, 2, 3])
 
-  assert.equal(schema.read(bytes).ok, bytes, 'returns same bytes back')
+  assert.equal(schema.tryFrom(bytes).ok, bytes, 'returns same bytes back')
 
   matchError(
-    schema.read(bytes.buffer),
+    schema.tryFrom(
+      // @ts-expect-error - expects Uint8Array
+      bytes.buffer
+    ),
     /expect.* Uint8Array .* got ArrayBuffer/is
   )
 
   matchError(
-    schema.read(new Int8Array(bytes.buffer)),
+    schema.tryFrom(
+      // @ts-expect-error - expects Uint8Array
+      new Int8Array(bytes.buffer)
+    ),
     /expect.* Uint8Array .* got Int8Array/is
   )
 
-  matchError(schema.read([...bytes]), /expect.* Uint8Array .* got array/is)
+  matchError(
+    schema.tryFrom(
+      // @ts-expect-error
+      [...bytes]
+    ),
+    /expect.* Uint8Array .* got array/is
+  )
 })
diff --git a/packages/core/test/schema/fixtures.js b/packages/core/test/schema/fixtures.js
index 2c8aa303..2b2b2ef9 100644
--- a/packages/core/test/schema/fixtures.js
+++ b/packages/core/test/schema/fixtures.js
@@ -84,8 +84,8 @@ export const fixture = ({ in: input, got = input, array, ...expect }) => ({
     ...expect.startsWithHelloEndsWithWorld,
   },
   number: { any: fail({ expect: 'number', got }), ...expect.number },
-  integer: { any: fail({ expect: 'number', got }), ...expect.integer },
-  float: { any: fail({ expect: 'number', got }), ...expect.float },
+  integer: { any: fail({ expect: 'integer', got }), ...expect.integer },
+  float: { any: fail({ expect: 'float', got }), ...expect.float },
   literal: {
     any: { any: fail({ expect: 'literal', got }) },
     ...Object.fromEntries(
@@ -188,10 +188,10 @@ export const source = [
       any: fail.at('"name"', { expect: '"Point2d"', got: 'undefined' }),
     },
     xyz: {
-      any: fail.at('"x"', { expect: 'number', got: 'undefined' }),
+      any: fail.at('"x"', { expect: 'integer', got: 'undefined' }),
     },
     intDict: {
-      any: fail.at('"0"', { expect: 'number', got: '"h"' }),
+      any: fail.at('"0"', { expect: 'integer', got: '"h"' }),
     },
     pointDict: {
       any: fail.at('0', { expect: 'name|x|y', got: '"0"' }),
@@ -344,7 +344,7 @@ export const source = [
       any: fail.at('"name"', { expect: '"Point2d"', got: 'undefined' }),
     },
     xyz: {
-      any: fail.at('"x"', { expect: 'number', got: 'undefined' }),
+      any: fail.at('"x"', { expect: 'integer', got: 'undefined' }),
     },
     dict: {
       any: pass(),
@@ -428,7 +428,7 @@ export const source = [
     unknown: { any: pass() },
     tuple: {
       strNfloat: {
-        any: fail.at(1, { expect: 'number', got: '"world"' }),
+        any: fail.at(1, { expect: 'float', got: '"world"' }),
       },
       strNstr: {
         any: pass(),
@@ -465,7 +465,7 @@ export const source = [
         any: fail.at(1, { got: 'object' }),
       },
       strNfloat: {
-        any: fail.at(1, { got: 'object', expect: 'number' }),
+        any: fail.at(1, { got: 'object', expect: 'float' }),
       },
     },
   },
@@ -552,10 +552,10 @@ export const source = [
       any: pass(),
     },
     xyz: {
-      any: fail.at('"z"', { expect: 'number', got: 'undefined' }),
+      any: fail.at('"z"', { expect: 'integer', got: 'undefined' }),
     },
     intDict: {
-      any: fail.at('"name"', { expect: 'number', got: '"Point2d"' }),
+      any: fail.at('"name"', { expect: 'integer', got: '"Point2d"' }),
     },
     dict: {
       any: pass(),
@@ -565,16 +565,16 @@ export const source = [
     in: { name: 'Point2d', x: 0, z: 0 },
     got: 'object',
     point2d: {
-      any: fail.at('"y"', { expect: 'number', got: 'undefined' }),
+      any: fail.at('"y"', { expect: 'integer', got: 'undefined' }),
     },
     unknown: {
       any: pass(),
     },
     xyz: {
-      any: fail.at('"y"', { expect: 'number', got: 'undefined' }),
+      any: fail.at('"y"', { expect: 'integer', got: 'undefined' }),
     },
     intDict: {
-      any: fail.at('"name"', { expect: 'number', got: '"Point2d"' }),
+      any: fail.at('"name"', { expect: 'integer', got: '"Point2d"' }),
     },
     pointDict: {
       any: fail.at('z', { expect: 'name|x|y', got: '"z"' }),
@@ -596,7 +596,7 @@ export const source = [
       any: pass(),
     },
     intDict: {
-      any: fail.at('"name"', { expect: 'number', got: '"Point2d"' }),
+      any: fail.at('"name"', { expect: 'integer', got: '"Point2d"' }),
     },
     dict: {
       any: pass(),
@@ -635,7 +635,7 @@ export const scenarios = fixture => [
     expect: fixture.unknown.any || fixture.any,
   },
   {
-    schema: Schema.unknown().default('DEFAULT'),
+    schema: Schema.unknown().implicit('DEFAULT'),
     expect:
       (fixture.unknown.default && fixture.unknown.default('DEFAULT')) ||
       fixture.unknown.any ||
@@ -654,7 +654,7 @@ export const scenarios = fixture => [
     expect: fixture.string.nullable || fixture.string.any || fixture.any,
   },
   {
-    schema: Schema.string().default('DEFAULT'),
+    schema: Schema.string().implicit('DEFAULT'),
     expect:
       (fixture.string.default && fixture.string.default('DEFAULT')) ||
       fixture.string.any ||
@@ -692,7 +692,7 @@ export const scenarios = fixture => [
     expect: fixture.number.nullable || fixture.number.any || fixture.any,
   },
   {
-    schema: Schema.number().default(17),
+    schema: Schema.number().implicit(17),
     expect:
       (fixture.number.default && fixture.number.default(17)) ||
       fixture.number.any ||
@@ -711,7 +711,7 @@ export const scenarios = fixture => [
     expect: fixture.integer.nullable || fixture.integer.any || fixture.any,
   },
   {
-    schema: Schema.integer().default(17),
+    schema: Schema.integer().implicit(17),
     expect:
       (fixture.integer.default && fixture.integer.default(17)) ||
       fixture.integer.any ||
@@ -761,7 +761,7 @@ export const scenarios = fixture => [
       fixture.any,
   },
   {
-    schema: Schema.array(Schema.string().default('DEFAULT')),
+    schema: Schema.array(Schema.string().implicit('DEFAULT')),
     expect:
       (fixture.array.string?.default &&
         fixture.array.string?.default('DEFAULT')) ||
@@ -796,7 +796,7 @@ export const scenarios = fixture => [
       fixture.any,
   },
   {
-    schema: Schema.literal('hello').default('hello'),
+    schema: Schema.literal('hello').implicit('hello'),
     expect:
       (fixture.literal?.hello?.default &&
         fixture.literal?.hello?.default('hello')) ||
@@ -837,7 +837,7 @@ export const scenarios = fixture => [
       fixture.any,
   },
   {
-    schema: Schema.string().or(Schema.number()).default(10),
+    schema: Schema.string().or(Schema.number()).implicit(10),
     expect:
       (fixture.stringOrNumber?.default &&
         fixture.stringOrNumber?.default(10)) ||
@@ -846,7 +846,7 @@ export const scenarios = fixture => [
       fixture.any,
   },
   {
-    schema: Schema.string().or(Schema.number()).default('test'),
+    schema: Schema.string().or(Schema.number()).implicit('test'),
     expect:
       (fixture.stringOrNumber?.default &&
         fixture.stringOrNumber?.default('test')) ||
diff --git a/packages/core/test/utils.js b/packages/core/test/utils.js
deleted file mode 100644
index e0d105ba..00000000
--- a/packages/core/test/utils.js
+++ /dev/null
@@ -1,14 +0,0 @@
-import * as Block from 'multiformats/block'
-import * as codec from '@ipld/dag-cbor'
-import { sha256 as hasher } from 'multiformats/hashes/sha2'
-
-/**
- * @param {any} value
- */
-export async function getBlock(value) {
-  return await Block.encode({
-    value,
-    codec,
-    hasher
-  })
-}
diff --git a/packages/core/test/variant-schema.spec.js b/packages/core/test/variant-schema.spec.js
index c8e76046..7b515dc5 100644
--- a/packages/core/test/variant-schema.spec.js
+++ b/packages/core/test/variant-schema.spec.js
@@ -10,13 +10,13 @@ const Shape = Schema.variant({
 })
 
 test('variant', () => {
-  assert.deepEqual(Shape.read({ circle: { radius: 1 } }), {
+  assert.deepEqual(Shape.tryFrom({ circle: { radius: 1 } }), {
     ok: {
       circle: { radius: 1 },
     },
   })
 
-  assert.deepEqual(Shape.read({ rectangle: { width: 1, height: 2 } }), {
+  assert.deepEqual(Shape.tryFrom({ rectangle: { width: 1, height: 2 } }), {
     ok: {
       rectangle: { width: 1, height: 2 },
     },
@@ -37,7 +37,10 @@ test('variant', () => {
 
 test('variant can not have extra fields', () => {
   matchError(
-    Shape.read({ rectangle: { width: 1, height: 2 }, circle: { radius: 3 } }),
+    Shape.read({
+      rectangle: { width: 1, height: 2 },
+      circle: { radius: 3 },
+    }),
     /Expected an object with a single key instead got object with keys circle, rectangle/
   )
 })
@@ -81,11 +84,11 @@ test('variant with default', () => {
     }),
   })
 
-  assert.deepEqual(Shapes.read({ circle: { radius: 1 } }), {
+  assert.deepEqual(Shapes.tryFrom({ circle: { radius: 1 } }), {
     ok: { circle: { radius: 1 } },
   })
 
-  assert.deepEqual(Shapes.read({ rectangle: { width: 10, height: 7 } }), {
+  assert.deepEqual(Shapes.tryFrom({ rectangle: { width: 10, height: 7 } }), {
     ok: {
       rectangle: { width: 10, height: 7 },
     },
diff --git a/packages/interface/src/lib.ts b/packages/interface/src/lib.ts
index 12c840e6..6f9b4db8 100644
--- a/packages/interface/src/lib.ts
+++ b/packages/interface/src/lib.ts
@@ -31,6 +31,10 @@ import {
   Block as IPLDBlock,
   ToString,
   BlockEncoder,
+  BlockDecoder,
+  BlockCodec,
+  BaseDecoder,
+  MultibaseCodec,
 } from 'multiformats'
 import * as UCAN from '@ipld/dag-ucan'
 import {
@@ -46,6 +50,7 @@ import {
 } from './capability.js'
 import type * as Transport from './transport.js'
 import type { Tuple, Block } from './transport.js'
+import { LegacyLink } from 'multiformats'
 export * from './capability.js'
 export * from './transport.js'
 export type {
@@ -73,6 +78,10 @@ export type {
   MultibaseDecoder,
   MultibaseEncoder,
   MulticodecCode,
+  BaseDecoder,
+  BlockDecoder,
+  BlockEncoder,
+  BlockCodec,
   Principal,
   ToJSON,
   ToString,
@@ -82,7 +91,10 @@ export type {
 }
 export * as UCAN from '@ipld/dag-ucan'
 
-export type BlockStore <T> = Map<ToString<Link>, Block<T, number, number, 1>>
+export type BlockStore<T = unknown> = Map<
+  ToString<Link>,
+  Block<T, number, number, 1>
+>
 export type AttachedLinkSet = Set<ToString<Link>>
 
 /**
@@ -109,7 +121,6 @@ export interface UCANOptions {
 
   facts?: Fact[]
   proofs?: Proof[]
-  attachedBlocks?: BlockStore<unknown>
 }
 
 /**
@@ -175,12 +186,19 @@ export interface IPLDViewBuilder<View extends IPLDView = IPLDView> {
  * a generic traversal API. It is useful for encoding (potentially partial) IPLD
  * DAGs into content archives (e.g. CARs).
  */
-export interface IPLDView<T extends unknown = unknown> {
+export interface IPLDView<
+  T extends unknown = unknown,
+  Code extends MulticodecCode = MulticodecCode,
+  Alg extends MulticodecCode = MulticodecCode,
+  V extends UnknownLink['version'] = 1
+> {
   /**
    * The root block of the IPLD DAG this is the view of. This is the the block
    * from which all other blocks are linked directly or transitively.
    */
-  root: Block<T>
+  root: Block<T, Code, Alg, V>
+
+  link(): Link<T, Code, Alg, V>
 
   /**
    * Returns an iterable of all the IPLD blocks that are included in this view.
@@ -247,8 +265,6 @@ export interface Delegation<C extends Capabilities = Capabilities>
   delegate(): Await<Delegation<C>>
 
   archive(): Await<Result<Uint8Array, Error>>
-
-  attach(block: Block): void
 }
 
 /**
@@ -551,7 +567,6 @@ export interface IssuedInvocation<C extends Capability = Capability>
   readonly proofs: Proof[]
 
   delegate(): Await<Delegation<[C]>>
-  attach(block: Block): void
 }
 
 export type ServiceInvocation<
diff --git a/packages/server/test/server.spec.js b/packages/server/test/server.spec.js
index 8451d356..28fb3c48 100644
--- a/packages/server/test/server.spec.js
+++ b/packages/server/test/server.spec.js
@@ -12,7 +12,7 @@ const storeAdd = Server.capability({
   can: 'store/add',
   with: Server.URI.match({ protocol: 'did:' }),
   nb: Schema.struct({
-    link: Server.Link.match().optional(),
+    link: Server.Link.optional(),
   }),
   derives: (claimed, delegated) => {
     if (claimed.with !== delegated.with) {
@@ -38,7 +38,7 @@ const storeRemove = Server.capability({
   can: 'store/remove',
   with: Server.URI.match({ protocol: 'did:' }),
   nb: Schema.struct({
-    link: Server.Link.match().optional(),
+    link: Server.Link.optional(),
   }),
   derives: (claimed, delegated) => {
     if (claimed.with !== delegated.with) {
diff --git a/packages/server/test/service/store.js b/packages/server/test/service/store.js
index 01e5ebd0..15cf0b54 100644
--- a/packages/server/test/service/store.js
+++ b/packages/server/test/service/store.js
@@ -10,7 +10,7 @@ const addCapability = Server.capability({
   can: 'store/add',
   with: Server.URI.match({ protocol: 'did:' }),
   nb: Schema.struct({
-    link: Server.Link.match().optional(),
+    link: Server.Link.optional(),
   }),
   derives: (claimed, delegated) => {
     if (claimed.with !== delegated.with) {
@@ -36,7 +36,7 @@ const removeCapability = Server.capability({
   can: 'store/remove',
   with: Server.URI.match({ protocol: 'did:' }),
   nb: Schema.struct({
-    link: Server.Link.match().optional(),
+    link: Server.Link.optional(),
   }),
   derives: (claimed, delegated) => {
     if (claimed.with !== delegated.with) {
diff --git a/packages/validator/test/capability.spec.js b/packages/validator/test/capability.spec.js
index 9e86f6fa..b40c030c 100644
--- a/packages/validator/test/capability.spec.js
+++ b/packages/validator/test/capability.spec.js
@@ -790,7 +790,7 @@ test('parse with nb', () => {
     can: 'store/add',
     with: URI.match({ protocol: 'did:' }),
     nb: Schema.struct({
-      link: Link.match().optional(),
+      link: Link.optional(),
     }),
     derives: (claimed, delegated) => {
       if (claimed.with !== delegated.with) {
@@ -1499,7 +1499,7 @@ test('capability with optional caveats', async () => {
     with: URI.match({ protocol: 'did:' }),
     nb: Schema.struct({
       message: URI.match({ protocol: 'data:' }),
-      meta: Link.match().optional(),
+      meta: Link.optional(),
     }),
   })
 
diff --git a/packages/validator/test/delegate.spec.js b/packages/validator/test/delegate.spec.js
index 8ff926c8..4c9615e6 100644
--- a/packages/validator/test/delegate.spec.js
+++ b/packages/validator/test/delegate.spec.js
@@ -187,7 +187,7 @@ test('capability with optional caveats', async () => {
     with: URI.match({ protocol: 'did:' }),
     nb: Schema.struct({
       message: URI.match({ protocol: 'data:' }),
-      meta: Link.match().optional(),
+      meta: Link.optional(),
     }),
   })
 
diff --git a/packages/validator/test/inference.spec.js b/packages/validator/test/inference.spec.js
index 793faca2..b6905a6e 100644
--- a/packages/validator/test/inference.spec.js
+++ b/packages/validator/test/inference.spec.js
@@ -262,7 +262,7 @@ test('can create derived capability with dict schema in nb', () => {
       with: URI,
       nb: Schema.struct({
         delegations: Schema.dictionary({
-          value: Schema.Link.match(),
+          value: Schema.Link,
         }),
       }),
       derives: (claim, proof) => {