diff --git a/src/syndicate/actors.nim b/src/syndicate/actors.nim
index 98efc16..cc42ea3 100644
--- a/src/syndicate/actors.nim
+++ b/src/syndicate/actors.nim
@@ -39,7 +39,7 @@ type
   Entity* = ref object of RootObj
     oid*: Oid # oid is how Entities are identified over the wire
 
-  Cap* {.final.} = ref object of EmbeddedObj
+  Cap* {.preservesEmbedded.} = ref object of EmbeddedObj
     relay*: Facet
     target*: Entity
     attenuation*: Attenuation
@@ -292,7 +292,7 @@ proc publish(turn: var Turn; r: Cap; v: Value; h: Handle) =
     act.enqueue.event.target.oid = r.target.oid.toPreserves
     act.enqueue.event.detail = trace.TurnEvent(orKind: TurnEventKind.assert)
     act.enqueue.event.detail.assert.assertion.value.value =
-      mapEmbeds(v) do (r: Cap) -> Value: discard
+      mapEmbeds(v) do (cap: Value) -> Value: discard
     act.enqueue.event.detail.assert.handle = h
     turn.desc.actions.add act
 
diff --git a/src/syndicate/dataspaces.nim b/src/syndicate/dataspaces.nim
index c813ae0..822c7fc 100644
--- a/src/syndicate/dataspaces.nim
+++ b/src/syndicate/dataspaces.nim
@@ -19,10 +19,8 @@ type
 method publish(ds: Dataspace; turn: var Turn; a: AssertionRef; h: Handle) {.gcsafe.} =
   if add(ds.index, turn, a.value):
     var obs = a.value.preservesTo(Observe)
-    if obs.isSome:
-      var cap = obs.get.observer.unembed(Cap)
-      if cap.isSome:
-        ds.index.add(turn, obs.get.pattern, cap.get)
+    if obs.isSome and obs.get.observer of Cap:
+      ds.index.add(turn, obs.get.pattern, Cap(obs.get.observer))
   ds.handleMap[h] = a.value
 
 method retract(ds: Dataspace; turn: var Turn; h: Handle) {.gcsafe.} =
@@ -30,9 +28,8 @@ method retract(ds: Dataspace; turn: var Turn; h: Handle) {.gcsafe.} =
   if remove(ds.index, turn, v):
     ds.handleMap.del h
     var obs = v.preservesTo(Observe)
-    if obs.isSome:
-      var cap = obs.get.observer.unembed(Cap)
-      ds.index.remove(turn, obs.get.pattern, cap.get)
+    if obs.isSome and obs.get.observer of Cap:
+      ds.index.remove(turn, obs.get.pattern, Cap(obs.get.observer))
 
 method message(ds: Dataspace; turn: var Turn; a: AssertionRef) {.gcsafe.} =
   ds.index.deliverMessage(turn, a.value)
diff --git a/src/syndicate/durings.nim b/src/syndicate/durings.nim
index 577b3df..fc966b2 100644
--- a/src/syndicate/durings.nim
+++ b/src/syndicate/durings.nim
@@ -45,4 +45,4 @@ method retract(de: DuringEntity; turn: var Turn; h: Handle) =
 proc during*(cb: DuringProc): DuringEntity = DuringEntity(cb: cb)
 
 proc observe*(turn: var Turn; ds: Cap; pat: Pattern; e: Entity): Handle =
-  publish(turn, ds, Observe(pattern: pat, observer: newCap(turn, e).embed))
+  publish(turn, ds, Observe(pattern: pat, observer: newCap(turn, e)))
diff --git a/src/syndicate/protocols/dataspace.nim b/src/syndicate/protocols/dataspace.nim
index 6538930..cd7132d 100644
--- a/src/syndicate/protocols/dataspace.nim
+++ b/src/syndicate/protocols/dataspace.nim
@@ -5,7 +5,7 @@ import
 type
   Observe* {.preservesRecord: "Observe".} = object
     `pattern`*: dataspacePatterns.Pattern
-    `observer`* {.preservesEmbedded.}: Value
+    `observer`* {.preservesEmbedded.}: EmbeddedRef
 
 proc `$`*(x: Observe): string =
   `$`(toPreserves(x))
diff --git a/src/syndicate/protocols/dataspacePatterns.nim b/src/syndicate/protocols/dataspacePatterns.nim
index 0c9b859..be01703 100644
--- a/src/syndicate/protocols/dataspacePatterns.nim
+++ b/src/syndicate/protocols/dataspacePatterns.nim
@@ -5,39 +5,31 @@ import
 type
   AnyAtomKind* {.pure.} = enum
     `bool`, `float`, `double`, `int`, `string`, `bytes`, `symbol`, `embedded`
-  AnyAtomBool* = bool
-  AnyAtomFloat* = float32
-  AnyAtomDouble* = float64
-  AnyAtomInt* = BiggestInt
-  AnyAtomString* = string
-  AnyAtomBytes* = seq[byte]
-  AnyAtomSymbol* = Symbol
-  AnyAtomEmbedded* = Value
   `AnyAtom`* {.preservesOr.} = object
     case orKind*: AnyAtomKind
     of AnyAtomKind.`bool`:
-        `bool`*: AnyAtomBool
+        `bool`*: bool
 
     of AnyAtomKind.`float`:
-        `float`*: AnyAtomFloat
+        `float`*: float32
 
     of AnyAtomKind.`double`:
-        `double`*: AnyAtomDouble
+        `double`*: float64
 
     of AnyAtomKind.`int`:
-        `int`*: AnyAtomInt
+        `int`*: BiggestInt
 
     of AnyAtomKind.`string`:
-        `string`*: AnyAtomString
+        `string`*: string
 
     of AnyAtomKind.`bytes`:
-        `bytes`*: AnyAtomBytes
+        `bytes`*: seq[byte]
 
     of AnyAtomKind.`symbol`:
-        `symbol`*: AnyAtomSymbol
+        `symbol`*: Symbol
 
     of AnyAtomKind.`embedded`:
-        `embedded`*: AnyAtomEmbedded
+        `embedded`* {.preservesEmbedded.}: EmbeddedRef
 
   
   DLit* {.preservesRecord: "lit".} = object
@@ -63,13 +55,13 @@ type
   `DCompound`* {.preservesOr.} = object
     case orKind*: DCompoundKind
     of DCompoundKind.`rec`:
-        `rec`*: DCompoundRec
+        `rec`* {.preservesEmbedded.}: DCompoundRec
 
     of DCompoundKind.`arr`:
-        `arr`*: DCompoundArr
+        `arr`* {.preservesEmbedded.}: DCompoundArr
 
     of DCompoundKind.`dict`:
-        `dict`*: DCompoundDict
+        `dict`* {.preservesEmbedded.}: DCompoundDict
 
   
   PatternKind* {.pure.} = enum
@@ -80,13 +72,13 @@ type
         `ddiscard`*: DDiscard
 
     of PatternKind.`DBind`:
-        `dbind`*: DBind
+        `dbind`* {.preservesEmbedded.}: DBind
 
     of PatternKind.`DLit`:
-        `dlit`*: DLit
+        `dlit`* {.preservesEmbedded.}: DLit
 
     of PatternKind.`DCompound`:
-        `dcompound`*: DCompound
+        `dcompound`* {.preservesEmbedded.}: DCompound
 
   
 proc `$`*(x: AnyAtom | DLit | DBind | DDiscard | DCompound | Pattern): string =
diff --git a/src/syndicate/protocols/gatekeeper.nim b/src/syndicate/protocols/gatekeeper.nim
index b8f5d08..1c1e16a 100644
--- a/src/syndicate/protocols/gatekeeper.nim
+++ b/src/syndicate/protocols/gatekeeper.nim
@@ -5,7 +5,7 @@ import
 type
   Bind* {.preservesRecord: "bind".} = object
     `description`*: Description
-    `target`* {.preservesEmbedded.}: Value
+    `target`* {.preservesEmbedded.}: EmbeddedRef
     `observer`*: BindObserver
 
   Route* {.preservesRecord: "route".} = object
@@ -14,11 +14,10 @@ type
 
   BindObserverKind* {.pure.} = enum
     `present`, `absent`
-  BindObserverPresent* = Bound
   `BindObserver`* {.preservesOr.} = object
     case orKind*: BindObserverKind
     of BindObserverKind.`present`:
-        `present`*: BindObserverPresent
+        `present`* {.preservesEmbedded.}: EmbeddedRef
 
     of BindObserverKind.`absent`:
         `absent`* {.preservesLiteral: "#f".}: bool
@@ -26,12 +25,12 @@ type
   
   TransportConnection* {.preservesRecord: "connect-transport".} = object
     `addr`*: Value
-    `control`* {.preservesEmbedded.}: TransportControl
+    `control`* {.preservesEmbedded.}: EmbeddedRef
     `resolved`*: Resolved
 
   Step* = Value
   ResolvedPathStep* {.preservesRecord: "path-step".} = object
-    `origin`* {.preservesEmbedded.}: Resolve
+    `origin`* {.preservesEmbedded.}: EmbeddedRef
     `pathStep`*: PathStep
     `resolved`*: Resolved
 
@@ -57,17 +56,17 @@ type
 
   Resolve* {.preservesRecord: "resolve".} = object
     `step`*: Step
-    `observer`* {.preservesEmbedded.}: Resolved
+    `observer`* {.preservesEmbedded.}: EmbeddedRef
 
   ResolvedKind* {.pure.} = enum
     `accepted`, `Rejected`
   ResolvedAccepted* {.preservesRecord: "accepted".} = object
-    `responderSession`* {.preservesEmbedded.}: Value
+    `responderSession`* {.preservesEmbedded.}: EmbeddedRef
 
   `Resolved`* {.preservesOr.} = object
     case orKind*: ResolvedKind
     of ResolvedKind.`accepted`:
-        `accepted`*: ResolvedAccepted
+        `accepted`* {.preservesEmbedded.}: ResolvedAccepted
 
     of ResolvedKind.`Rejected`:
         `rejected`*: Rejected
@@ -77,7 +76,7 @@ type
   ResolvePath* {.preservesRecord: "resolve-path".} = object
     `route`*: Route
     `addr`*: Value
-    `control`* {.preservesEmbedded.}: TransportControl
+    `control`* {.preservesEmbedded.}: EmbeddedRef
     `resolved`*: Resolved
 
   PathStep* = Value
diff --git a/src/syndicate/protocols/http.nim b/src/syndicate/protocols/http.nim
index 4f68f73..747282a 100644
--- a/src/syndicate/protocols/http.nim
+++ b/src/syndicate/protocols/http.nim
@@ -5,11 +5,10 @@ import
 type
   HostPatternKind* {.pure.} = enum
     `host`, `any`
-  HostPatternHost* = string
   `HostPattern`* {.preservesOr.} = object
     case orKind*: HostPatternKind
     of HostPatternKind.`host`:
-        `host`*: HostPatternHost
+        `host`*: string
 
     of HostPatternKind.`any`:
         `any`* {.preservesLiteral: "#f".}: bool
@@ -20,20 +19,18 @@ type
 
   MethodPatternKind* {.pure.} = enum
     `any`, `specific`
-  MethodPatternSpecific* = Symbol
   `MethodPattern`* {.preservesOr.} = object
     case orKind*: MethodPatternKind
     of MethodPatternKind.`any`:
         `any`* {.preservesLiteral: "#f".}: bool
 
     of MethodPatternKind.`specific`:
-        `specific`*: MethodPatternSpecific
+        `specific`*: Symbol
 
   
   MimeType* = Symbol
   QueryValueKind* {.pure.} = enum
     `string`, `file`
-  QueryValueString* = string
   QueryValueFile* {.preservesRecord: "file".} = object
     `filename`*: string
     `headers`*: Headers
@@ -42,7 +39,7 @@ type
   `QueryValue`* {.preservesOr.} = object
     case orKind*: QueryValueKind
     of QueryValueKind.`string`:
-        `string`*: QueryValueString
+        `string`*: string
 
     of QueryValueKind.`file`:
         `file`*: QueryValueFile
@@ -60,11 +57,10 @@ type
 
   RequestBodyKind* {.pure.} = enum
     `present`, `absent`
-  RequestBodyPresent* = seq[byte]
   `RequestBody`* {.preservesOr.} = object
     case orKind*: RequestBodyKind
     of RequestBodyKind.`present`:
-        `present`*: RequestBodyPresent
+        `present`*: seq[byte]
 
     of RequestBodyKind.`absent`:
         `absent`* {.preservesLiteral: "#f".}: bool
@@ -113,19 +109,18 @@ type
     `port`*: BiggestInt
     `method`*: MethodPattern
     `path`*: PathPattern
-    `handler`* {.preservesEmbedded.}: HttpRequest
+    `handler`* {.preservesEmbedded.}: Value
 
   HttpContext* {.preservesRecord: "request".} = object
     `req`*: HttpRequest
-    `res`* {.preservesEmbedded.}: HttpResponse
+    `res`* {.preservesEmbedded.}: Value
 
   PathPatternElementKind* {.pure.} = enum
     `label`, `wildcard`, `rest`
-  PathPatternElementLabel* = string
   `PathPatternElement`* {.preservesOr.} = object
     case orKind*: PathPatternElementKind
     of PathPatternElementKind.`label`:
-        `label`*: PathPatternElementLabel
+        `label`*: string
 
     of PathPatternElementKind.`wildcard`:
         `wildcard`* {.preservesLiteral: "_".}: bool
@@ -136,15 +131,13 @@ type
   
   ChunkKind* {.pure.} = enum
     `string`, `bytes`
-  ChunkString* = string
-  ChunkBytes* = seq[byte]
   `Chunk`* {.preservesOr.} = object
     case orKind*: ChunkKind
     of ChunkKind.`string`:
-        `string`*: ChunkString
+        `string`*: string
 
     of ChunkKind.`bytes`:
-        `bytes`*: ChunkBytes
+        `bytes`*: seq[byte]
 
   
   PathPattern* = seq[PathPatternElement]
diff --git a/src/syndicate/protocols/noise.nim b/src/syndicate/protocols/noise.nim
index b220c1f..ffbdbdf 100644
--- a/src/syndicate/protocols/noise.nim
+++ b/src/syndicate/protocols/noise.nim
@@ -95,15 +95,13 @@ type
 
   PacketKind* {.pure.} = enum
     `complete`, `fragmented`
-  PacketComplete* = seq[byte]
-  PacketFragmented* = seq[seq[byte]]
   `Packet`* {.preservesOr.} = object
     case orKind*: PacketKind
     of PacketKind.`complete`:
-        `complete`*: PacketComplete
+        `complete`*: seq[byte]
 
     of PacketKind.`fragmented`:
-        `fragmented`*: PacketFragmented
+        `fragmented`*: seq[seq[byte]]
 
   
 proc `$`*(x: NoiseDescriptionDetail | NoisePreSharedKeys | SecretKeyField |
diff --git a/src/syndicate/protocols/protocol.nim b/src/syndicate/protocols/protocol.nim
index d24f04f..b9daadb 100644
--- a/src/syndicate/protocols/protocol.nim
+++ b/src/syndicate/protocols/protocol.nim
@@ -34,7 +34,7 @@ type
   `Packet`* {.preservesOr.} = object
     case orKind*: PacketKind
     of PacketKind.`Turn`:
-        `turn`*: Turn
+        `turn`* {.preservesEmbedded.}: Turn
 
     of PacketKind.`Error`:
         `error`*: Error
@@ -57,7 +57,7 @@ type
         `message`*: Message
 
     of EventKind.`Sync`:
-        `sync`*: Sync
+        `sync`* {.preservesEmbedded.}: Sync
 
   
 proc `$`*(x: Error | Turn | Message | Retract | Assert | Sync | TurnEvent | Oid |
diff --git a/src/syndicate/protocols/service.nim b/src/syndicate/protocols/service.nim
index f889792..ed74977 100644
--- a/src/syndicate/protocols/service.nim
+++ b/src/syndicate/protocols/service.nim
@@ -5,7 +5,6 @@ import
 type
   StateKind* {.pure.} = enum
     `started`, `ready`, `failed`, `complete`, `userDefined`
-  StateUserDefined* = Value
   `State`* {.preservesOr.} = object
     case orKind*: StateKind
     of StateKind.`started`:
@@ -21,7 +20,7 @@ type
         `complete`* {.preservesLiteral: "complete".}: bool
 
     of StateKind.`userDefined`:
-        `userdefined`*: StateUserDefined
+        `userdefined`*: Value
 
   
   ServiceObject* {.preservesRecord: "service-object".} = object
diff --git a/src/syndicate/protocols/stream.nim b/src/syndicate/protocols/stream.nim
index 01a16af..f456494 100644
--- a/src/syndicate/protocols/stream.nim
+++ b/src/syndicate/protocols/stream.nim
@@ -5,11 +5,10 @@ import
 type
   CreditAmountKind* {.pure.} = enum
     `count`, `unbounded`
-  CreditAmountCount* = BiggestInt
   `CreditAmount`* {.preservesOr.} = object
     case orKind*: CreditAmountKind
     of CreditAmountKind.`count`:
-        `count`*: CreditAmountCount
+        `count`*: BiggestInt
 
     of CreditAmountKind.`unbounded`:
         `unbounded`* {.preservesLiteral: "unbounded".}: bool
@@ -23,8 +22,8 @@ type
     `message`*: string
 
   StreamConnection* {.preservesRecord: "stream-connection".} = object
-    `source`* {.preservesEmbedded.}: Source
-    `sink`* {.preservesEmbedded.}: Sink
+    `source`* {.preservesEmbedded.}: EmbeddedRef
+    `sink`* {.preservesEmbedded.}: EmbeddedRef
     `spec`*: Value
 
   `LineMode`* {.preservesOr, pure.} = enum
@@ -32,7 +31,7 @@ type
   SourceKind* {.pure.} = enum
     `sink`, `StreamError`, `credit`
   SourceSink* {.preservesRecord: "sink".} = object
-    `controller`* {.preservesEmbedded.}: Sink
+    `controller`* {.preservesEmbedded.}: EmbeddedRef
 
   SourceCredit* {.preservesRecord: "credit".} = object
     `amount`*: CreditAmount
@@ -41,7 +40,7 @@ type
   `Source`* {.acyclic, preservesOr.} = ref object
     case orKind*: SourceKind
     of SourceKind.`sink`:
-        `sink`*: SourceSink
+        `sink`* {.preservesEmbedded.}: SourceSink
 
     of SourceKind.`StreamError`:
         `streamerror`*: StreamError
@@ -53,7 +52,7 @@ type
   SinkKind* {.pure.} = enum
     `source`, `StreamError`, `data`, `eof`
   SinkSource* {.preservesRecord: "source".} = object
-    `controller`* {.preservesEmbedded.}: Source
+    `controller`* {.preservesEmbedded.}: EmbeddedRef
 
   SinkData* {.preservesRecord: "data".} = object
     `payload`*: Value
@@ -64,7 +63,7 @@ type
   `Sink`* {.acyclic, preservesOr.} = ref object
     case orKind*: SinkKind
     of SinkKind.`source`:
-        `source`*: SinkSource
+        `source`* {.preservesEmbedded.}: SinkSource
 
     of SinkKind.`StreamError`:
         `streamerror`*: StreamError
diff --git a/src/syndicate/protocols/sturdy.nim b/src/syndicate/protocols/sturdy.nim
index 752e481..f9934fa 100644
--- a/src/syndicate/protocols/sturdy.nim
+++ b/src/syndicate/protocols/sturdy.nim
@@ -130,7 +130,6 @@ type
   
   CaveatKind* {.pure.} = enum
     `Rewrite`, `Alts`, `Reject`, `unknown`
-  CaveatUnknown* = Value
   `Caveat`* {.preservesOr.} = object
     case orKind*: CaveatKind
     of CaveatKind.`Rewrite`:
@@ -143,7 +142,7 @@ type
         `reject`*: Reject
 
     of CaveatKind.`unknown`:
-        `unknown`*: CaveatUnknown
+        `unknown`*: Value
 
   
   PNot* {.preservesRecord: "not".} = object
diff --git a/src/syndicate/protocols/tcp.nim b/src/syndicate/protocols/tcp.nim
index 494500b..7b449b4 100644
--- a/src/syndicate/protocols/tcp.nim
+++ b/src/syndicate/protocols/tcp.nim
@@ -8,7 +8,7 @@ type
     `port`*: BiggestInt
 
   TcpPeerInfo* {.preservesRecord: "tcp-peer".} = object
-    `handle`* {.preservesEmbedded.}: Value
+    `handle`* {.preservesEmbedded.}: EmbeddedRef
     `local`*: TcpLocal
     `remote`*: TcpRemote
 
diff --git a/src/syndicate/relays.nim b/src/syndicate/relays.nim
index 81953c5..c325f9a 100644
--- a/src/syndicate/relays.nim
+++ b/src/syndicate/relays.nim
@@ -91,8 +91,10 @@ proc rewriteCapOut(relay: Relay; cap: Cap; exported: var seq[WireSymbol]): WireR
 proc rewriteOut(relay: Relay; v: Assertion):
     tuple[rewritten: Value, exported: seq[WireSymbol]] {.gcsafe.} =
   var exported: seq[WireSymbol]
-  result.rewritten = mapEmbeds(v) do (cap: Cap) -> Value:
-    rewriteCapOut(relay, cap, exported).toPreserves
+  result.rewritten = mapEmbeds(v) do (pr: Value) -> Value:
+    let o = pr.unembed(Cap); if o.isSome:
+      rewriteCapOut(relay, o.get, exported).toPreserves
+    else: pr
   result.exported = exported
 
 proc register(relay: Relay; v: Assertion; h: Handle): tuple[rewritten: Value, exported: seq[WireSymbol]] =
@@ -183,10 +185,10 @@ proc rewriteIn(relay; facet; v: Value):
     tuple[rewritten: Assertion; imported: seq[WireSymbol]] {.gcsafe.} =
   var imported: seq[WireSymbol]
   result.rewritten = mapEmbeds(v) do (pr: Value) -> Value:
-    var wr: WireRef
-    if wr.fromPreserves(pr):
-      rewriteCapIn(relay, facet, wr, imported).embed
-    else: pr
+    let wr = pr.preservesTo WireRef; if wr.isSome:
+      result = rewriteCapIn(relay, facet, wr.get, imported).embed
+    else:
+      result = pr
   result.imported = imported
 
 proc close(r: Relay) = discard
@@ -265,7 +267,7 @@ proc newRelay(turn: var Turn; opts: RelayOptions; setup: RelaySetup): Relay =
 proc transportConnectionResolve(addrAss: Assertion; ds: Cap): gatekeeper.TransportConnection =
   result.`addr` = addrAss
   result.resolved = Resolved(orKind: ResolvedKind.accepted)
-  result.resolved.accepted.responderSession = ds.embed
+  result.resolved.accepted.responderSession = ds
 
 proc spawnRelay*(name: string; turn: var Turn; ds: Cap; addrAss: Assertion; opts: RelayActorOptions; setup: RelaySetup) =
   discard spawn(name, turn) do (turn: var Turn):
@@ -346,20 +348,16 @@ when defined(posix):
           discard publish(turn, shutdownCap, true)
           proc duringCallback(turn: var Turn; ass: Assertion; h: Handle): TurnAction =
             let facet = inFacet(turn) do (turn: var Turn):
-              var resolvePath = ResolvePath(route: route, `addr`: addrAss)
-              if resolvePath.resolved.fromPreserves(ass):
-                discard publish(turn, ds, resolvePath)
-              else:
-                raise newException(CatchableError, "unhandled gatekeeper response " & $ass)
+              let o = ass.preservesTo Resolved; if o.isSome:
+                discard publish(turn, ds, ResolvePath(
+                  route: route, `addr`: addrAss, resolved: o.get))
             proc action(turn: var Turn) =
               stop(turn, facet)
             result = action
           var resolve = Resolve(
               step: step,
-              observer: Resolved(orKind: ResolvedKind.accepted),
+              observer: newCap(turn, during(duringCallback)),
             )
-          resolve.observer.accepted.responderSession =
-            embed newCap(turn, during(duringCallback))
           discard publish(turn, gatekeeper, resolve)
 
   proc connect*(turn: var Turn; ds: Cap; route: Route; transport: Tcp; step: Value) =