Bring up to date

git-subtree-dir: protocols
git-subtree-mainline: 381471225b
git-subtree-split: 993cf78a38

Makefile

@@ -0,0 +1,11 @@
+all:
+	yarn run build
+
+clean:
+	yarn run clean
+
+pull-protocols:
+	git subtree pull -P protocols \
+		-m 'Merge latest changes from the syndicate-protocols repository' \
+		git@git.syndicate-lang.org:syndicate-lang/syndicate-protocols \
+		main

package.json

@@ -10,14 +10,13 @@
     "@preserves/schema": "^0.16.0"
   },
   "scripts": {
-    "regenerate": "rm -rf ./src/gen && preserves-schema-ts --module Actor=./src/runtime/actor.ts --output ./src/gen './schemas/**/*.prs'",
+    "regenerate": "rm -rf ./src/gen && preserves-schema-ts --module EntityRef=./src/runtime/actor.ts --output ./src/gen './protocols/schemas/**/*.prs'",
     "regenerate:watch": "yarn regenerate --watch",
-    "regenerate:bundle": "preserves-schemac './schemas/**/*.prs' > novy-syndicate.schema.bundle.bin",
     "compile": "tsc",
     "compile:watch": "tsc -w",
     "rollup": "rollup -c",
     "rollup:watch": "rollup -c -w",
     "clean": "rm -rf lib index.js",
-    "build": "yarn regenerate && yarn regenerate:bundle && yarn compile && yarn rollup"
+    "build": "yarn regenerate && yarn compile && yarn rollup"
   }
 }

protocols/Makefile

@@ -0,0 +1,8 @@
+all: schema-bundle.bin
+
+clean:
+	rm -f schema-bundle.bin
+
+schema-bundle.bin: schemas/*.prs
+	preserves-schemac schemas/*.prs > $@.tmp
+	mv $@.tmp $@

protocols/schema-bundle.bin

@@ -0,0 +1,16 @@
+´³bundle·µ³tcp„´³schema·³version‘³definitions·³TcpLocal´³rec´³lit³	tcp-local„´³tupleµ´³named³host´³atom³String„„´³named³port´³atom³
SignedInteger„„„„„³	TcpRemote´³rec´³lit³
+tcp-remote„´³tupleµ´³named³host´³atom³String„„´³named³port´³atom³
SignedInteger„„„„„³TcpPeerInfo´³rec´³lit³tcp-peer„´³tupleµ´³named³handle´³embedded³any„„´³named³local´³refµ„³TcpLocal„„´³named³remote´³refµ„³	TcpRemote„„„„„„³embeddedType´³refµ³	EntityRef„³Cap„„„µ³timer„´³schema·³version‘³definitions·³SetTimer´³rec´³lit³	set-timer„´³tupleµ´³named³label³any„´³named³msecs´³atom³Double„„´³named³kind´³refµ„³	TimerKind„„„„„³	LaterThan´³rec´³lit³
+later-than„´³tupleµ´³named³msecs´³atom³Double„„„„„³	TimerKind´³orµµ±relative´³lit³relative„„µ±absolute´³lit³absolute„„µ±clear´³lit³clear„„„„³TimerExpired´³rec´³lit³
timer-expired„´³tupleµ´³named³label³any„´³named³msecs´³atom³Double„„„„„„³embeddedType€„„µ³stream„´³schema·³version‘³definitions·³Mode´³orµµ±bytes´³lit³bytes„„µ±lines´³refµ„³LineMode„„µ±packet´³rec´³lit³packet„´³tupleµ´³named³size´³atom³
SignedInteger„„„„„„µ±object´³rec´³lit³object„´³tupleµ´³named³description³any„„„„„„„³Sink´³orµµ±source´³rec´³lit³source„´³tupleµ´³named³
+controller´³embedded´³refµ„³Source„„„„„„„µ±StreamError´³refµ„³StreamError„„µ±data´³rec´³lit³data„´³tupleµ´³named³payload³any„´³named³mode´³refµ„³Mode„„„„„„µ±eof´³rec´³lit³eof„´³tupleµ„„„„„„³Source´³orµµ±sink´³rec´³lit³sink„´³tupleµ´³named³
+controller´³embedded´³refµ„³Sink„„„„„„„µ±StreamError´³refµ„³StreamError„„µ±credit´³rec´³lit³credit„´³tupleµ´³named³amount´³refµ„³CreditAmount„„´³named³mode´³refµ„³Mode„„„„„„„„³LineMode´³orµµ±lf´³lit³lf„„µ±crlf´³lit³crlf„„„„³StreamError´³rec´³lit³error„´³tupleµ´³named³message´³atom³String„„„„„³CreditAmount´³orµµ±count´³atom³
SignedInteger„„µ±	unbounded´³lit³	unbounded„„„„³StreamConnection´³rec´³lit³stream-connection„´³tupleµ´³named³source´³embedded´³refµ„³Source„„„´³named³sink´³embedded´³refµ„³Sink„„„´³named³spec³any„„„„³StreamListenerError´³rec´³lit³stream-listener-error„´³tupleµ´³named³spec³any„´³named³message´³atom³String„„„„„³StreamListenerReady´³rec´³lit³stream-listener-ready„´³tupleµ´³named³spec³any„„„„„³embeddedType´³refµ³	EntityRef„³Cap„„„µ³sturdy„´³schema·³version‘³definitions·³Lit´³rec´³lit³lit„´³tupleµ´³named³value³any„„„„³Oid´³atom³
SignedInteger„³Alts´³rec´³lit³or„´³tupleµ´³named³alternatives´³seqof´³refµ„³Rewrite„„„„„„³CArr´³rec´³lit³arr„´³tupleµ´³named³arity´³atom³
SignedInteger„„„„„³CRec´³rec´³lit³rec„´³tupleµ´³named³label³any„´³named³arity´³atom³
SignedInteger„„„„„³PAnd´³rec´³lit³and„´³tupleµ´³named³patterns´³seqof´³refµ„³Pattern„„„„„„³PNot´³rec´³lit³not„´³tupleµ´³named³pattern´³refµ„³Pattern„„„„„³TRef´³rec´³lit³ref„´³tupleµ´³named³binding´³atom³
SignedInteger„„„„„³CDict´³rec´³lit³dict„´³tupleµ„„„³PAtom´³orµµ±Boolean´³lit³Boolean„„µ±Float´³lit³Float„„µ±Double´³lit³Double„„µ±
SignedInteger´³lit³
SignedInteger„„µ±String´³lit³String„„µ±
+ByteString´³lit³
+ByteString„„µ±Symbol´³lit³Symbol„„„„³PBind´³rec´³lit³bind„´³tupleµ´³named³pattern´³refµ„³Pattern„„„„„³Caveat´³orµµ±Rewrite´³refµ„³Rewrite„„µ±Alts´³refµ„³Alts„„„„³Pattern´³orµµ±PDiscard´³refµ„³PDiscard„„µ±PAtom´³refµ„³PAtom„„µ±	PEmbedded´³refµ„³	PEmbedded„„µ±PBind´³refµ„³PBind„„µ±PAnd´³refµ„³PAnd„„µ±PNot´³refµ„³PNot„„µ±Lit´³refµ„³Lit„„µ±	PCompound´³refµ„³	PCompound„„„„³Rewrite´³rec´³lit³rewrite„´³tupleµ´³named³pattern´³refµ„³Pattern„„´³named³template´³refµ„³Template„„„„„³WireRef´³orµµ±mine´³tupleµ´³lit<69>„´³named³oid´³refµ„³Oid„„„„„µ±yours´³tuplePrefixµ´³lit‘„´³named³oid´³refµ„³Oid„„„´³named³attenuation´³seqof´³refµ„³Caveat„„„„„„„³PDiscard´³rec´³lit³
_„´³tupleµ„„„³Template´³orµµ±
+TAttenuate´³refµ„³
+TAttenuate„„µ±TRef´³refµ„³TRef„„µ±Lit´³refµ„³Lit„„µ±	TCompound´³refµ„³	TCompound„„„„³	PCompound´³rec´³lit³compound„´³tupleµ´³named³ctor´³refµ„³ConstructorSpec„„´³named³members´³refµ„³PCompoundMembers„„„„„³	PEmbedded´³lit³Embedded„³	SturdyRef´³rec´³lit³ref„´³tupleµ´³named³oid³any„´³named³caveatChain´³seqof´³refµ„³Attenuation„„„´³named³sig´³atom³
+ByteString„„„„„³	TCompound´³rec´³lit³compound„´³tupleµ´³named³ctor´³refµ„³ConstructorSpec„„´³named³members´³refµ„³TCompoundMembers„„„„„³
+TAttenuate´³rec´³lit³	attenuate„´³tupleµ´³named³template´³refµ„³Template„„´³named³attenuation´³refµ„³Attenuation„„„„„³Attenuation´³seqof´³refµ„³Caveat„„³ConstructorSpec´³orµµ±CRec´³refµ„³CRec„„µ±CArr´³refµ„³CArr„„µ±CDict´³refµ„³CDict„„„„³PCompoundMembers´³dictof³any´³refµ„³Pattern„„³TCompoundMembers´³dictof³any´³refµ„³Template„„„³embeddedType´³refµ³	EntityRef„³Cap„„„µ³worker„´³schema·³version‘³definitions·³Instance´³rec´³lit³Instance„´³tupleµ´³named³name´³atom³String„„´³named³argument³any„„„„„³embeddedType´³refµ³	EntityRef„³Cap„„„µ³service„´³schema·³version‘³definitions·³State´³orµµ±started´³lit³started„„µ±ready´³lit³ready„„µ±failed´³lit³failed„„µ±complete´³lit³complete„„„„³
+RunService´³rec´³lit³run-service„´³tupleµ´³named³serviceName³any„„„„³CoreService´³rec´³lit³core-service„´³tupleµ´³named³serviceName³any„„„„³ServiceState´³rec´³lit³
service-state„´³tupleµ´³named³serviceName³any„´³named³state´³refµ„³State„„„„„³
ServiceObject´³rec´³lit³service-object„´³tupleµ´³named³serviceName³any„´³named³object³any„„„„³RequireService´³rec´³lit³require-service„´³tupleµ´³named³serviceName³any„„„„³ServiceDependency´³rec´³lit³
+depends-on„´³tupleµ´³named³depender³any„´³named³dependee´³refµ„³ServiceState„„„„„„³embeddedType´³refµ³	EntityRef„³Cap„„„µ³protocol„´³schema·³version‘³definitions·³Oid´³atom³
SignedInteger„³Sync´³rec´³lit³sync„´³tupleµ´³named³peer´³embedded´³lit<69>„„„„„„³Turn´³seqof´³refµ„³	TurnEvent„„³Error´³rec´³lit³error„´³tupleµ´³named³message´³atom³String„„´³named³detail³any„„„„³Event´³orµµ±Assert´³refµ„³Assert„„µ±Retract´³refµ„³Retract„„µ±Message´³refµ„³Message„„µ±Sync´³refµ„³Sync„„„„³Assert´³rec´³lit³assert„´³tupleµ´³named³	assertion´³refµ„³	Assertion„„´³named³handle´³refµ„³Handle„„„„„³Handle´³atom³
SignedInteger„³Packet´³orµµ±Turn´³refµ„³Turn„„µ±Error´³refµ„³Error„„„„³Message´³rec´³lit³message„´³tupleµ´³named³body´³refµ„³	Assertion„„„„„³Retract´³rec´³lit³retract„´³tupleµ´³named³handle´³refµ„³Handle„„„„„³	Assertion³any³	TurnEvent´³tupleµ´³named³oid´³refµ„³Oid„„´³named³event´³refµ„³Event„„„„„³embeddedType€„„µ³	dataspace„´³schema·³version‘³definitions·³Observe´³rec´³lit³Observe„´³tupleµ´³named³pattern´³refµ³dataspacePatterns„³Pattern„„´³named³observer´³embedded³any„„„„„„³embeddedType´³refµ³	EntityRef„³Cap„„„µ³
+gatekeeper„´³schema·³version‘³definitions·³Bind´³rec´³lit³bind„´³tupleµ´³named³oid³any„´³named³key´³atom³
+ByteString„„´³named³target´³embedded³any„„„„„³Resolve´³rec´³lit³resolve„´³tupleµ´³named³	sturdyref´³refµ³sturdy„³	SturdyRef„„´³named³observer´³embedded´³embedded³any„„„„„„„³embeddedType´³refµ³	EntityRef„³Cap„„„µ³racketEvent„´³schema·³version‘³definitions·³RacketEvent´³rec´³lit³racket-event„´³tupleµ´³named³source´³embedded³any„„´³named³event´³embedded³any„„„„„„³embeddedType€„„µ³transportAddress„´³schema·³version‘³definitions·³Tcp´³rec´³lit³tcp„´³tupleµ´³named³host´³atom³String„„´³named³port´³atom³
SignedInteger„„„„„³Unix´³rec´³lit³unix„´³tupleµ´³named³path´³atom³String„„„„„³Stdio´³rec´³lit³stdio„´³tupleµ„„„³	WebSocket´³rec´³lit³ws„´³tupleµ´³named³url´³atom³String„„„„„„³embeddedType€„„µ³dataspacePatterns„´³schema·³version‘³definitions·³CArr´³rec´³lit³arr„´³tupleµ´³named³arity´³atom³
SignedInteger„„„„„³CRec´³rec´³lit³rec„´³tupleµ´³named³label³any„´³named³arity´³atom³
SignedInteger„„„„„³DLit´³rec´³lit³lit„´³tupleµ´³named³value³any„„„„³CDict´³rec´³lit³dict„´³tupleµ„„„³DBind´³rec´³lit³bind„´³tupleµ´³named³pattern´³refµ„³Pattern„„„„„³Pattern´³orµµ±DDiscard´³refµ„³DDiscard„„µ±DBind´³refµ„³DBind„„µ±DLit´³refµ„³DLit„„µ±	DCompound´³refµ„³	DCompound„„„„³DDiscard´³rec´³lit³
_„´³tupleµ„„„³	DCompound´³orµµ±rec´³rec´³lit³compound„´³tupleµ´³named³ctor´³refµ„³CRec„„´³named³members´³dictof´³atom³
SignedInteger„´³refµ„³Pattern„„„„„„„µ±arr´³rec´³lit³compound„´³tupleµ´³named³ctor´³refµ„³CArr„„´³named³members´³dictof´³atom³
SignedInteger„´³refµ„³Pattern„„„„„„„µ±dict´³rec´³lit³compound„´³tupleµ´³named³ctor´³refµ„³CDict„„´³named³members´³dictof³any´³refµ„³Pattern„„„„„„„„„„³embeddedType´³refµ³	EntityRef„³Cap„„„µ³secureChatProtocol„´³schema·³version‘³definitions·³Join´³rec´³lit³
+joinedUser„´³tupleµ´³named³uid´³refµ„³UserId„„´³named³handle´³embedded´³refµ„³Session„„„„„„³Says´³rec´³lit³says„´³tupleµ´³named³who´³refµ„³UserId„„´³named³what´³atom³String„„„„„³UserId´³atom³
SignedInteger„³Session´³orµµ±observeUsers´³rec´³lit³Observe„´³tupleµ´³lit³user„´³named³observer´³embedded´³refµ„³UserInfo„„„„„„„µ±
observeSpeech´³rec´³lit³Observe„´³tupleµ´³lit³says„´³named³observer´³embedded´³refµ„³Says„„„„„„„µ±	NickClaim´³refµ„³	NickClaim„„µ±Says´³refµ„³Says„„„„³UserInfo´³rec´³lit³user„´³tupleµ´³named³uid´³refµ„³UserId„„´³named³name´³atom³String„„„„„³	NickClaim´³rec´³lit³	claimNick„´³tupleµ´³named³uid´³refµ„³UserId„„´³named³name´³atom³String„„´³named³
k´³embedded´³refµ„³NickClaimResponse„„„„„„³NickConflict´³rec´³lit³nickConflict„´³tupleµ„„„³NickClaimResponse´³orµµ±true´³lit<69>„„µ±NickConflict´³refµ„³NickConflict„„„„„³embeddedType´³refµ³	EntityRef„³Cap„„„µ³simpleChatProtocol„´³schema·³version‘³definitions·³Says´³rec´³lit³Says„´³tupleµ´³named³who´³atom³String„„´³named³what´³atom³String„„„„„³Present´³rec´³lit³Present„´³tupleµ´³named³username´³atom³String„„„„„„³embeddedType´³refµ³	EntityRef„³Cap„„„„„

protocols/schemas/dataspace.prs

@@ -0,0 +1,4 @@
+version 1 .
+embeddedType EntityRef.Cap .
+
+Observe = <Observe @pattern dataspacePatterns.Pattern @observer #!any>.

protocols/schemas/dataspacePatterns.prs

@@ -0,0 +1,16 @@
+version 1 .
+embeddedType EntityRef.Cap .
+
+; Dataspace patterns: a sublanguage of attenuation patterns.
+Pattern = DDiscard / DBind / DLit / DCompound .
+
+DDiscard = <_>.
+DBind = <bind @pattern Pattern>.
+DLit = <lit @value any>.
+DCompound = @rec  <compound @ctor CRec  @members { int: Pattern ...:... }>
+          / @arr  <compound @ctor CArr  @members { int: Pattern ...:... }>
+          / @dict <compound @ctor CDict @members { any: Pattern ...:... }> .
+
+CRec = <rec @label any @arity int>.
+CArr = <arr @arity int>.
+CDict = <dict>.

protocols/schemas/examples/boxProtocol.prs

@@ -1,5 +1,5 @@
 version 1 .
-embeddedType Actor.Ref .
+embeddedType EntityRef.Ref .
 
 BoxState = <BoxState @value int>.
 SetBox = <SetBox @value int>.

protocols/schemas/gatekeeper.prs

@@ -1,5 +1,5 @@
 version 1 .
-embeddedType Actor.Ref .
+embeddedType EntityRef.Cap .
 
 Resolve = <resolve @sturdyref sturdy.SturdyRef @observer #!#!any>.
 Bind = <bind @oid any @key bytes @target #!any>.

protocols/schemas/protocol.prs

@@ -1,5 +1,8 @@
 version 1 .
-embeddedType sturdy.WireRef .
+
+Packet = Turn / Error .
+
+Error = <error @message string @detail any>.
 
 Assertion = any .
 Handle    = int .

protocols/schemas/racketEvent.prs

@@ -0,0 +1,3 @@
+version 1 .
+
+RacketEvent = <racket-event @source #!any @event #!any>.

protocols/schemas/secureChatProtocol.prs

@@ -1,5 +1,5 @@
 version 1 .
-embeddedType Actor.Ref .
+embeddedType EntityRef.Cap .
 
 UserId = int .
 

protocols/schemas/service.prs

@@ -0,0 +1,51 @@
+version 1 .
+embeddedType EntityRef.Cap .
+
+; Asserts that a service should begin (and stay) running after waiting
+; for its dependencies and considering reverse-dependencies, blocks,
+; and so on.
+RequireService = <require-service @serviceName any>.
+
+; Asserts that a service should begin (and stay) running RIGHT NOW,
+; without considering its dependencies.
+RunService = <run-service @serviceName any>.
+
+; Asserts one or more current states of service `serviceName`. The
+; overall state of the service is the union of asserted `state`s.
+;
+; Only a few combinations make sense:
+;  - `started`
+;  - `started` + `ready`
+;  - `failed`
+;  - `complete`
+;
+ServiceState = <service-state @serviceName any @state State>.
+
+; A running service publishes zero or more of these. The details of
+; the object vary by service.
+;
+ServiceObject = <service-object @serviceName any @object any>.
+
+; Possible service states.
+State =
+/ ; The service has begun its startup routine, and may or may not be
+  ; ready to take requests from other parties.
+  =started
+/ ; The service is ready to take requests from other parties.
+  ; (This state is special in that it is asserted *in addition* to `started`.)
+  =ready
+/ ; The service has failed.
+  =failed
+/ ; The service has completed execution.
+  =complete
+.
+
+; Asserts that, when `depender` is `require-service`d, it should not
+; be started until `dependee` has been asserted.
+ServiceDependency = <depends-on @depender any @dependee ServiceState>.
+
+; Asserts that the service is a "core" service. If *not* specified for
+; a service X, where X is not `<milestone Y>` for some Y, the system
+; acts as if `<depends-on X <service-state <milestone core> ready>>`
+; were asserted.
+CoreService = <core-service @serviceName any>.

protocols/schemas/simpleChatProtocol.prs

@@ -1,5 +1,5 @@
 version 1 .
-embeddedType Actor.Ref .
+embeddedType EntityRef.Cap .
 
 Present = <Present @username string>.
 Says = <Says @who string @what string>.

protocols/schemas/stream.prs

@@ -0,0 +1,38 @@
+version 1 .
+embeddedType EntityRef.Cap .
+
+; Assertion:
+StreamConnection = <stream-connection @source #!Source @sink #!Sink @spec any>.
+
+; Assertions:
+StreamListenerReady = <stream-listener-ready @spec any>.
+StreamListenerError = <stream-listener-error @spec any @message string>.
+
+; Assertion:
+StreamError = <error @message string>.
+
+Source =
+  ; Assertions:
+  / <sink @controller #!Sink>
+  / StreamError
+
+  ; Messages:
+  / <credit @amount CreditAmount @mode Mode>
+.
+
+Sink =
+  ; Assertions:
+  / <source @controller #!Source>
+  / StreamError
+
+  ; Messages:
+  / <data @payload any @mode Mode>
+  / <eof>
+.
+
+; Value:
+CreditAmount = @count int / @unbounded =unbounded .
+
+; Value:
+Mode = =bytes / @lines LineMode / <packet @size int> / <object @description any>.
+LineMode = =lf / =crlf .

protocols/schemas/sturdy.prs

@@ -1,4 +1,5 @@
 version 1 .
+embeddedType EntityRef.Cap .
 
 ; Each Attenuation is a stage. The sequence of Attenuations is run RIGHT-TO-LEFT.
 ; That is, the newest Attenuations are at the right.
@@ -30,7 +31,7 @@ Pattern = PDiscard / PAtom / PEmbedded / PBind / PAnd / PNot / Lit / PCompound .
 PDiscard = <_>.
 PAtom = =Boolean / =Float / =Double / =SignedInteger / =String / =ByteString / =Symbol .
 PEmbedded = =Embedded .
-PBind = <bind @name symbol @pattern Pattern>.
+PBind = <bind @pattern Pattern>.
 PAnd = <and @patterns [Pattern ...]>.
 PNot = <not @pattern Pattern>.
 PCompound = <compound @ctor ConstructorSpec @members PCompoundMembers>.
@@ -38,7 +39,6 @@ PCompoundMembers = { any: Pattern ...:... }.
 
 Template = TAttenuate / TRef / Lit / TCompound .
 TAttenuate = <attenuate @template Template @attenuation Attenuation>.
-TRef = <ref @name symbol>.
+TRef = <ref @binding int>.
 TCompound = <compound @ctor ConstructorSpec @members TCompoundMembers>.
 TCompoundMembers = { any: Template ...:... }.
-

protocols/schemas/tcp.prs

@@ -0,0 +1,7 @@
+version 1 .
+embeddedType EntityRef.Cap .
+
+TcpRemote = <tcp-remote @host string @port int>.
+TcpLocal = <tcp-local @host string @port int>.
+
+TcpPeerInfo = <tcp-peer @handle #!any @local TcpLocal @remote TcpRemote>.

protocols/schemas/timer.prs

@@ -0,0 +1,7 @@
+version 1 .
+
+SetTimer = <set-timer @label any @msecs double @kind TimerKind>.
+TimerExpired = <timer-expired @label any @msecs double>.
+TimerKind = =relative / =absolute / =clear .
+
+LaterThan = <later-than @msecs double>.

protocols/schemas/transportAddress.prs

@@ -0,0 +1,6 @@
+version 1 .
+
+Tcp = <tcp @host string @port int>.
+Unix = <unix @path string>.
+WebSocket = <ws @url string>.
+Stdio = <stdio>.

protocols/schemas/worker.prs

@@ -1,4 +1,4 @@
 version 1 .
-embeddedType Actor.Ref .
+embeddedType EntityRef.Cap .
 
 Instance = <Instance @name string @argument any>.

schemas/dataspace.prs

@@ -1,9 +0,0 @@
-version 1 .
-embeddedType Actor.Ref .
-
-;As implemented
-Observe = <Observe @label symbol @observer #!any>.
-
-; ;As will be implemented soon
-; Observe = <Observe @pattern Pattern @observer #!any>.
-.

src/distributed/server.ts

@@ -1,14 +1,14 @@
-import { Actor, Handle, Turn } from '../runtime/actor.js';
-import { Dataspace, during, observe } from '../runtime/dataspace.js';
+import { Actor, Handle, Ref, Turn } from '../runtime/actor.js';
+import { Dataspace, during, observe, P } from '../runtime/dataspace.js';
 import { Relay, spawnRelay } from '../transport/relay.js';
 import * as net from 'net';
 
 import { mint, sturdyEncode, validate } from '../transport/sturdy.js';
 import { KEY_LENGTH } from '../transport/cryptography.js';
 import { attenuate } from '../runtime/rewrite.js';
-import { Bytes, embed, is } from '@preserves/core';
-import { Attenuation, fromSturdyRef, _val } from '../gen/sturdy.js';
-import { $bind, Bind, fromBind, toBind, toResolve } from '../gen/gatekeeper.js';
+import { Bytes, embed, Embedded } from '@preserves/core';
+import { Attenuation, fromSturdyRef } from '../gen/sturdy.js';
+import { $bind, Bind, fromBind, toResolve } from '../gen/gatekeeper.js';
 
 new Actor(t => {
     t.activeFacet.preventInertCheck();
@@ -44,18 +44,18 @@ new Actor(t => {
                 if (a === void 0) return null;
                 const r = a.sturdyref;
                 let facet = t.facet(t => {
-                    observe(t, ds, $bind, during(async (t, b0) => {
-                        const b = toBind(b0);
-                        if (b === void 0) return null;
-                        if (!is(r.oid, b.oid)) return null;
-                        if (!await validate(r, b.key)) return null;
-                        const cavs: Attenuation = [];
-                        r.caveatChain.forEach(cs => cavs.push(... cs));
-                        const attenuated_ds = attenuate(b.target, ... cavs);
-                        let replyHandle: Handle | undefined;
-                        t.freshen(t => replyHandle = t.assert(a.observer, embed(attenuated_ds)));
-                        return t => t.retract(replyHandle);
-                    }));
+                    observe(t, ds, P.rec($bind, P.lit(r.oid), P.bind(), P.bind()),
+                            during(async (t, bindings) => {
+                                const [key, embeddedTarget] = bindings as [Bytes, Embedded<Ref>];
+                                const target = embeddedTarget.embeddedValue;
+                                if (!await validate(r, key)) return null;
+                                const cavs: Attenuation = [];
+                                r.caveatChain.forEach(cs => cavs.push(... cs));
+                                const attenuated_ds = attenuate(target, ... cavs);
+                                let replyHandle: Handle | undefined;
+                                t.freshen(t => replyHandle = t.assert(a.observer, embed(attenuated_ds)));
+                                return t => t.retract(replyHandle);
+                            }));
                 });
                 return t => t.stop(facet);
             })),

src/examples/box.ts

@@ -1,6 +1,6 @@
 import { Embedded } from "@preserves/core";
-import { BoxState, $SetBox, fromBoxState } from "../gen/box-protocol.js";
-import { fromObserve, Observe } from "../gen/dataspace.js";
+import { BoxState, $SetBox, fromBoxState } from "../gen/examples/boxProtocol.js";
+import { fromObserve, Observe, P } from "../runtime/dataspace.js";
 import { Assertion, Handle, Ref, Turn } from "../runtime/actor.js";
 
 let startTime = Date.now();
@@ -18,7 +18,7 @@ export default function (t: Turn, arg: Assertion) {
     }
     setValue(t, 0);
     t.assert(ds, fromObserve(Observe({
-        label: $SetBox,
+        pattern: P.rec($SetBox, P.bind()),
         observer: t.ref({
             message(t: Turn, [newValue]: [number]): void {
                 // console.log(`Box ${t.actor.id}: got ${newValue}`);

src/examples/client.ts

@@ -1,6 +1,6 @@
 import { Embedded } from "@preserves/core";
-import { $BoxState, fromSetBox, SetBox } from "../gen/box-protocol.js";
-import { fromObserve, Observe } from "../gen/dataspace.js";
+import { $BoxState, fromSetBox, SetBox } from "../gen/examples/boxProtocol.js";
+import { fromObserve, Observe, P } from "../runtime/dataspace.js";
 import { Assertion, Ref, Turn } from "../runtime/actor.js";
 
 export default function (t: Turn, ds_p: Embedded<Ref>) {
@@ -8,7 +8,7 @@ export default function (t: Turn, ds_p: Embedded<Ref>) {
     console.log('Spawning Client');
     let count = 0;
     t.assert(ds, fromObserve(Observe({
-        label: $BoxState,
+        pattern: P.rec($BoxState, P.bind()),
         observer: t.ref({
             assert(t: Turn, [currentValue]: [number]): void {
                 // console.log(`Client ${t.actor.id}: got ${currentValue}`);
@@ -17,7 +17,7 @@ export default function (t: Turn, ds_p: Embedded<Ref>) {
         })
     })));
     t.assert(ds, fromObserve(Observe({
-        label: $BoxState,
+        pattern: P.rec($BoxState, P.discard()),
         observer: t.ref({
             assert(_t: Turn, _assertion: Assertion): void {
                 count++;

src/examples/main.ts

@@ -2,7 +2,7 @@ import { Actor, Assertion, Turn } from '../runtime/actor.js';
 import { Dictionary, embed } from '@preserves/core';
 import { Dataspace } from '../runtime/dataspace.js';
 import { _embedded, attenuate, CRec, Lit, Pattern, PCompound, rfilter, ConstructorSpec } from '../runtime/rewrite.js';
-import { $BoxState, $SetBox } from '../gen/box-protocol.js';
+import { $BoxState, $SetBox } from '../gen/examples/boxProtocol.js';
 import { $Observe } from '../gen/dataspace.js';
 import { spawnWorker } from '../worker/index.js';
 import path from 'path';

src/examples/secure-chat-client.ts

@@ -1,16 +1,17 @@
-import { $joinedUser, $says, $user, asJoin, asSays, asUserInfo, fromNickClaim, fromSays, NickClaim, Says, UserId } from "../gen/secure-chat-protocol.js";
-import { during, observe } from "../runtime/dataspace.js";
+import { $joinedUser, $says, $user, fromNickClaim, fromSays, NickClaim, Says, UserId } from "../gen/secureChatProtocol.js";
+import { during, observe, P } from "../runtime/dataspace.js";
 import { Assertion, Ref, Turn } from "../runtime/actor.js";
 import { attachReadline } from './readline.js';
 import { Embedded } from "@preserves/core";
 
 export default function (t: Turn, ds_ptr: Embedded<Ref>) {
     const ds = ds_ptr.embeddedValue;
-    observe(t, ds, $joinedUser, during(async (t, j0) => {
-        const j = asJoin(j0);
-        const facet = t.facet(t => runSession(t, j.uid, j.handle));
-        return t => t.stop(facet);
-    }));
+    observe(t, ds, P.rec($joinedUser, P.bind(), P.bind()),
+            during(async (t, bindings) => {
+                let [uid, handle] = bindings as [UserId, Ref];
+                const facet = t.facet(t => runSession(t, uid, handle));
+                return t => t.stop(facet);
+            }));
 }
 
 function runSession(t: Turn, uid: UserId, session: Ref) {
@@ -39,25 +40,26 @@ function runSession(t: Turn, uid: UserId, session: Ref) {
     updateUsername(t, 'user' + process.pid);
 
     const users = new Map<UserId, string>();
-    observe(t, session, $user, during(async (_t, ui0) => {
-        const ui = asUserInfo(ui0);
-        const oldName = users.get(ui.uid);
-        console.log(oldName === void 0
-            ? `${ui.name} arrived`
-            : `${oldName} changed name to ${ui.name}`);
-        users.set(ui.uid, ui.name);
-        return (_t) => {
-            if (users.get(ui.uid) === ui.name) {
-                console.log(`${ui.name} departed`);
-                users.delete(ui.uid);
-            }
-        };
-    }));
+    observe(t, session, P.rec($user, P.bind(), P.bind()),
+            during(async (_t, bindings) => {
+                let [uid, name] = bindings as [UserId, string];
+                const oldName = users.get(uid);
+                console.log(oldName === void 0
+                    ? `${name} arrived`
+                    : `${oldName} changed name to ${name}`);
+                users.set(uid, name);
+                return (_t) => {
+                    if (users.get(uid) === name) {
+                        console.log(`${name} departed`);
+                        users.delete(uid);
+                    }
+                };
+            }));
 
-    observe(t, session, $says, {
-        message(_t: Turn, u0: Assertion): void {
-            const u = asSays(u0);
-            console.log(`${users.get(u.who) ?? `<unknown ${u.who}>`}: ${u.what}`);
+    observe(t, session, P.rec($says, P.bind(), P.bind()), {
+        message(_t: Turn, bindings: Assertion): void {
+            let [who, what] = bindings as [UserId, string];
+            console.log(`${users.get(who) ?? `<unknown ${who}>`}: ${what}`);
         },
     });
 

src/examples/secure-chat-moderator.ts

@@ -7,14 +7,13 @@ import {
     NickConflict,
     UserId,
     UserInfo,
-    asNickClaim,
     fromJoin,
     fromNickConflict,
     fromUserInfo,
-} from "../gen/secure-chat-protocol.js";
+} from "../gen/secureChatProtocol.js";
 import { Assertion, Handle, Ref, Turn } from "../runtime/actor.js";
-import { observe, during, $Observe, asObserve, Dataspace } from "../runtime/dataspace.js";
-import { attenuate, rfilter, pRec, pEmbedded, pString, pLit } from "../runtime/rewrite.js";
+import { observe, during, $Observe, Dataspace, P, $rec, $compound } from "../runtime/dataspace.js";
+import { attenuate, rfilter, pRec, pEmbedded, pString, pLit, pDiscard } from "../runtime/rewrite.js";
 import { attenuate as sturdyAttenuate, KEY_LENGTH, sturdyEncode, fromSturdyRef, mint } from "../transport/sturdy.js";
 import { Bind, fromBind } from "../gen/gatekeeper.js";
 import { Bytes, Embedded } from "@preserves/core";
@@ -28,7 +27,11 @@ export default function (t: Turn, gatekeeperDs_ptr: Embedded<Ref>) {
     const chatKey = new Bytes(KEY_LENGTH);
     t.assert(gatekeeperDs, fromBind(Bind({ oid: chatOid, key: chatKey, target: ds })));
     mint(chatOid, chatKey).then(async r => {
-        r = await sturdyAttenuate(r, rfilter(pRec($Observe, pLit($joinedUser), pEmbedded())));
+        r = await sturdyAttenuate(r, rfilter(pRec($Observe,
+                                                  pRec($compound,
+                                                       pRec($rec, pLit($joinedUser), pLit(2)),
+                                                       pDiscard()),
+                                                  pEmbedded())));
         console.log(fromSturdyRef(r).asPreservesText());
         console.log(sturdyEncode(fromSturdyRef(r)).toHex());
     });
@@ -36,39 +39,45 @@ export default function (t: Turn, gatekeeperDs_ptr: Embedded<Ref>) {
     const nicks = new Map<string, UserId>();
 
     let nextUserId: UserId = 0;
-    observe(t, ds, $Observe, during(async (t, o0) => {
-        const o = asObserve(o0);
-        if (o.label !== $joinedUser) return null;
+    observe(t, ds, P.rec($Observe,
+                         P.rec($compound,
+                               P.rec($rec, P.lit($joinedUser), P.lit(2)),
+                               P.discard()),
+                         P.bind()),
+            during(async (t, bindings) => {
+                const [embeddedObserver] = bindings as [Embedded<Ref>];
+                const observer = embeddedObserver.embeddedValue;
 
-        const uid: UserId = nextUserId++;
-        const f = t.facet(t => {
-            t.assert(o.observer, fromJoin(Join({
-                uid,
-                handle: attenuate(ds, rfilter(
-                    pRec($Observe, pLit($user), pEmbedded()),
-                    pRec($Observe, pLit($says), pEmbedded()),
-                    pRec($claimNick, pLit(uid), pString(), pEmbedded()),
-                    pRec($says, pLit(uid), pString()))),
-            })));
-            let infoHandle: Handle | undefined;
-            let nick: string | undefined;
-            observe(t, ds, $claimNick, {
-                assert(t: Turn, c0: Assertion): void {
-                    const c = asNickClaim(c0);
-                    if (c.uid !== uid) return;
-                    if (nicks.has(c.name)) {
-                        t.message(c.k, fromNickConflict(NickConflict()));
-                    } else {
-                        t.message(c.k, true);
-                        if (nick !== void 0) nicks.delete(nick);
-                        infoHandle = t.replace(ds, infoHandle, fromUserInfo(UserInfo(c)));
-                        nick = c.name;
-                        nicks.set(nick, uid);
-                    }
-                }
-            });
-        });
+                const uid: UserId = nextUserId++;
+                const f = t.facet(t => {
+                    t.assert(observer, fromJoin(Join({
+                        uid,
+                        handle: attenuate(ds, rfilter(
+                            pRec($Observe, pLit($user), pEmbedded()),
+                            pRec($Observe, pLit($says), pEmbedded()),
+                            pRec($claimNick, pLit(uid), pString(), pEmbedded()),
+                            pRec($says, pLit(uid), pString()))),
+                    })));
+                    let infoHandle: Handle | undefined;
+                    let nick: string | undefined;
+                    observe(t, ds, P.rec($claimNick, P.lit(uid), P.bind(), P.bind()), {
+                        assert(t: Turn, bindings: Assertion): void {
+                            const [name, embeddedK] = bindings as [string, Embedded<Ref>];
+                            const k = embeddedK.embeddedValue;
+                            if (nicks.has(name)) {
+                                t.message(k, fromNickConflict(NickConflict()));
+                            } else {
+                                t.message(k, true);
+                                if (nick !== void 0) nicks.delete(nick);
+                                infoHandle = t.replace(ds, infoHandle,
+                                                       fromUserInfo(UserInfo({ uid, name })));
+                                nick = name;
+                                nicks.set(nick, uid);
+                            }
+                        }
+                    });
+                });
 
-        return t => t.stop(f);
-    }));
+                return t => t.stop(f);
+            }));
 }

src/examples/simple-chat.ts

@@ -1,5 +1,5 @@
-import { $Present, $Says, asPresent, asSays, fromPresent, fromSays, Present, Says } from "../gen/simple-chat-protocol.js";
-import { during, observe } from "../runtime/dataspace.js";
+import { $Present, $Says, fromPresent, fromSays, Present, Says } from "../gen/simpleChatProtocol.js";
+import { during, observe, P } from "../runtime/dataspace.js";
 import { Assertion, Handle, Ref, Turn } from "../runtime/actor.js";
 import { attachReadline } from './readline.js';
 import { Embedded } from "@preserves/core";
@@ -16,16 +16,16 @@ export default function (t: Turn, ds_ptr: Embedded<Ref>) {
     }
     updateUsername(t, 'user' + process.pid);
 
-    observe(t, ds, $Present, during(async (_t, e0) => {
-        const e = asPresent(e0);
-        console.log(`${e.username} arrived`);
-        return (_t) => console.log(`${e.username} departed`);
+    observe(t, ds, P.rec($Present, P.bind()), during(async (_t, bindings) => {
+        const [username] = bindings as [string];
+        console.log(`${username} arrived`);
+        return (_t) => console.log(`${username} departed`);
     }));
 
-    observe(t, ds, $Says, {
-        message(_t: Turn, u0: Assertion): void {
-            const u = asSays(u0);
-            console.log(`${u.who}: ${u.what}`);
+    observe(t, ds, P.rec($Says, P.bind(), P.bind()), {
+        message(_t: Turn, bindings: Assertion): void {
+            const [who, what] = bindings as [string, string];
+            console.log(`${who}: ${what}`);
         },
     });
 

src/examples/sturdy-demo.ts

@@ -7,18 +7,15 @@ async function main() {
     const m1 = await mint('hello world', new Bytes(KEY_LENGTH));
     console.log(m1);
     const m2 = await attenuate(m1, Caveat.Rewrite(Rewrite({
-        pattern: RW.Pattern.PBind(RW.PBind({
-            name: Symbol.for('a'),
-            pattern: RW.Pattern.PCompound(RW.PCompound({
-                ctor: RW.ConstructorSpec.CRec(RW.CRec({
-                    label: Symbol.for('says'),
-                    arity: 2
-                })),
-                members: new Dictionary<RW._embedded, RW.Pattern>([
-                    [0, RW.Pattern.Lit(RW.Lit('Tony'))]])
-            }))
-        })),
-        template: RW.Template.TRef(RW.TRef(Symbol.for('a')))
+        pattern: RW.Pattern.PBind(RW.PBind(RW.Pattern.PCompound(RW.PCompound({
+            ctor: RW.ConstructorSpec.CRec(RW.CRec({
+                label: Symbol.for('says'),
+                arity: 2
+            })),
+            members: new Dictionary<RW._embedded, RW.Pattern>([
+                [0, RW.Pattern.Lit(RW.Lit('Tony'))]])
+        })))),
+        template: RW.Template.TRef(RW.TRef(0))
     })));
     console.log(m2);
     console.log('should be true:', await validate(m1, new Bytes(KEY_LENGTH)));

src/gen/dataspace.ts

@@ -1,40 +1,49 @@
 import * as _ from "@preserves/core";
-import * as _i_Actor from "../runtime/actor";
+import * as _i_EntityRef from "../runtime/actor";
+import * as _i_dataspacePatterns from "./dataspacePatterns";
 
 export const $Observe = Symbol.for("Observe");
 
-export type _embedded = _i_Actor.Ref;
+export type _embedded = _i_EntityRef.Cap;
 
-export type _val = _.Value<_embedded>;
-
-export type Observe = {"label": symbol, "observer": _embedded};
+export type Observe<_embedded = _i_EntityRef.Cap> = {"pattern": _i_dataspacePatterns.Pattern<_embedded>, "observer": _embedded};
 
 
-export function Observe({label, observer}: {label: symbol, observer: _embedded}): Observe {return {"label": label, "observer": observer};}
+export function Observe<_embedded = _i_EntityRef.Cap>(
+    {pattern, observer}: {pattern: _i_dataspacePatterns.Pattern<_embedded>, observer: _embedded}
+): Observe<_embedded> {return {"pattern": pattern, "observer": observer};}
 
-export function asObserve(v: _val): Observe {
+export function asObserve<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): Observe<_embedded> {
     let result = toObserve(v);
     if (result === void 0) throw new TypeError(`Invalid Observe: ${_.stringify(v)}`);
     return result;
 }
 
-export function toObserve(v: _val): undefined | Observe {
-    let result: undefined | Observe;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
+export function toObserve<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | Observe<_embedded> {
+    let result: undefined | Observe<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
         let _tmp0: (null) | undefined;
         _tmp0 = _.is(v.label, $Observe) ? null : void 0;
         if (_tmp0 !== void 0) {
-            let _tmp1: (symbol) | undefined;
-            _tmp1 = typeof v[0] === 'symbol' ? v[0] : void 0;
+            let _tmp1: (_i_dataspacePatterns.Pattern<_embedded>) | undefined;
+            _tmp1 = _i_dataspacePatterns.toPattern(v[0]);
             if (_tmp1 !== void 0) {
                 let _tmp2: (_embedded) | undefined;
                 _tmp2 = _.isEmbedded<_embedded>(v[1]) ? v[1].embeddedValue : void 0;
-                if (_tmp2 !== void 0) {result = {"label": _tmp1, "observer": _tmp2};};
+                if (_tmp2 !== void 0) {result = {"pattern": _tmp1, "observer": _tmp2};};
             };
         };
     };
     return result;
 }
 
-export function fromObserve(_v: Observe): _val {return _.Record($Observe, [_v["label"], _.embed(_v["observer"])]);}
+export function fromObserve<_embedded = _i_EntityRef.Cap>(_v: Observe<_embedded>): _.Value<_embedded> {
+    return _.Record(
+        $Observe,
+        [
+            _i_dataspacePatterns.fromPattern<_embedded>(_v["pattern"]),
+            _.embed(_v["observer"])
+        ]
+    );
+}
 

src/gen/dataspacePatterns.ts

@@ -0,0 +1,388 @@
+import * as _ from "@preserves/core";
+import * as _i_EntityRef from "../runtime/actor";
+
+export const $_ = Symbol.for("_");
+export const $arr = Symbol.for("arr");
+export const $bind = Symbol.for("bind");
+export const $compound = Symbol.for("compound");
+export const $dict = Symbol.for("dict");
+export const $lit = Symbol.for("lit");
+export const $rec = Symbol.for("rec");
+
+export type _embedded = _i_EntityRef.Cap;
+
+export type Pattern<_embedded = _i_EntityRef.Cap> = (
+    {"_variant": "DDiscard", "value": DDiscard} |
+    {"_variant": "DBind", "value": DBind<_embedded>} |
+    {"_variant": "DLit", "value": DLit<_embedded>} |
+    {"_variant": "DCompound", "value": DCompound<_embedded>}
+);
+
+export type DDiscard = null;
+
+export type DBind<_embedded = _i_EntityRef.Cap> = {"pattern": Pattern<_embedded>};
+
+export type DLit<_embedded = _i_EntityRef.Cap> = {"value": _.Value<_embedded>};
+
+export type DCompound<_embedded = _i_EntityRef.Cap> = (
+    {
+        "_variant": "rec",
+        "ctor": CRec<_embedded>,
+        "members": _.KeyedDictionary<number, Pattern<_embedded>, _embedded>
+    } |
+    {
+        "_variant": "arr",
+        "ctor": CArr,
+        "members": _.KeyedDictionary<number, Pattern<_embedded>, _embedded>
+    } |
+    {
+        "_variant": "dict",
+        "ctor": CDict,
+        "members": _.KeyedDictionary<_.Value<_embedded>, Pattern<_embedded>, _embedded>
+    }
+);
+
+export type CRec<_embedded = _i_EntityRef.Cap> = {"label": _.Value<_embedded>, "arity": number};
+
+export type CArr = {"arity": number};
+
+export type CDict = null;
+
+
+export namespace Pattern {
+    export function DDiscard<_embedded = _i_EntityRef.Cap>(value: DDiscard): Pattern<_embedded> {return {"_variant": "DDiscard", "value": value};};
+    export function DBind<_embedded = _i_EntityRef.Cap>(value: DBind<_embedded>): Pattern<_embedded> {return {"_variant": "DBind", "value": value};};
+    export function DLit<_embedded = _i_EntityRef.Cap>(value: DLit<_embedded>): Pattern<_embedded> {return {"_variant": "DLit", "value": value};};
+    export function DCompound<_embedded = _i_EntityRef.Cap>(value: DCompound<_embedded>): Pattern<_embedded> {return {"_variant": "DCompound", "value": value};};
+}
+
+export function DDiscard(): DDiscard {return null;}
+
+export function DBind<_embedded = _i_EntityRef.Cap>(pattern: Pattern<_embedded>): DBind<_embedded> {return {"pattern": pattern};}
+
+export function DLit<_embedded = _i_EntityRef.Cap>(value: _.Value<_embedded>): DLit<_embedded> {return {"value": value};}
+
+export namespace DCompound {
+    export function rec<_embedded = _i_EntityRef.Cap>(
+        {ctor, members}: {
+            ctor: CRec<_embedded>,
+            members: _.KeyedDictionary<number, Pattern<_embedded>, _embedded>
+        }
+    ): DCompound<_embedded> {return {"_variant": "rec", "ctor": ctor, "members": members};};
+    export function arr<_embedded = _i_EntityRef.Cap>(
+        {ctor, members}: {ctor: CArr, members: _.KeyedDictionary<number, Pattern<_embedded>, _embedded>}
+    ): DCompound<_embedded> {return {"_variant": "arr", "ctor": ctor, "members": members};};
+    export function dict<_embedded = _i_EntityRef.Cap>(
+        {ctor, members}: {
+            ctor: CDict,
+            members: _.KeyedDictionary<_.Value<_embedded>, Pattern<_embedded>, _embedded>
+        }
+    ): DCompound<_embedded> {return {"_variant": "dict", "ctor": ctor, "members": members};};
+}
+
+export function CRec<_embedded = _i_EntityRef.Cap>({label, arity}: {label: _.Value<_embedded>, arity: number}): CRec<_embedded> {return {"label": label, "arity": arity};}
+
+export function CArr(arity: number): CArr {return {"arity": arity};}
+
+export function CDict(): CDict {return null;}
+
+export function asPattern<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): Pattern<_embedded> {
+    let result = toPattern(v);
+    if (result === void 0) throw new TypeError(`Invalid Pattern: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toPattern<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | Pattern<_embedded> {
+    let _tmp0: (DDiscard) | undefined;
+    let result: undefined | Pattern<_embedded>;
+    _tmp0 = toDDiscard(v);
+    if (_tmp0 !== void 0) {result = {"_variant": "DDiscard", "value": _tmp0};};
+    if (result === void 0) {
+        let _tmp1: (DBind<_embedded>) | undefined;
+        _tmp1 = toDBind(v);
+        if (_tmp1 !== void 0) {result = {"_variant": "DBind", "value": _tmp1};};
+        if (result === void 0) {
+            let _tmp2: (DLit<_embedded>) | undefined;
+            _tmp2 = toDLit(v);
+            if (_tmp2 !== void 0) {result = {"_variant": "DLit", "value": _tmp2};};
+            if (result === void 0) {
+                let _tmp3: (DCompound<_embedded>) | undefined;
+                _tmp3 = toDCompound(v);
+                if (_tmp3 !== void 0) {result = {"_variant": "DCompound", "value": _tmp3};};
+            };
+        };
+    };
+    return result;
+}
+
+export function fromPattern<_embedded = _i_EntityRef.Cap>(_v: Pattern<_embedded>): _.Value<_embedded> {
+    switch (_v._variant) {
+        case "DDiscard": {return fromDDiscard<_embedded>(_v.value);};
+        case "DBind": {return fromDBind<_embedded>(_v.value);};
+        case "DLit": {return fromDLit<_embedded>(_v.value);};
+        case "DCompound": {return fromDCompound<_embedded>(_v.value);};
+    };
+}
+
+export function asDDiscard<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): DDiscard {
+    let result = toDDiscard(v);
+    if (result === void 0) throw new TypeError(`Invalid DDiscard: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toDDiscard<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | DDiscard {
+    let result: undefined | DDiscard;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, $_) ? null : void 0;
+        if (_tmp0 !== void 0) {result = null;};
+    };
+    return result;
+}
+
+export function fromDDiscard<_embedded = _i_EntityRef.Cap>(_v: DDiscard): _.Value<_embedded> {return _.Record($_, []);}
+
+export function asDBind<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): DBind<_embedded> {
+    let result = toDBind(v);
+    if (result === void 0) throw new TypeError(`Invalid DBind: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toDBind<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | DBind<_embedded> {
+    let result: undefined | DBind<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, $bind) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (Pattern<_embedded>) | undefined;
+            _tmp1 = toPattern(v[0]);
+            if (_tmp1 !== void 0) {result = {"pattern": _tmp1};};
+        };
+    };
+    return result;
+}
+
+export function fromDBind<_embedded = _i_EntityRef.Cap>(_v: DBind<_embedded>): _.Value<_embedded> {return _.Record($bind, [fromPattern<_embedded>(_v["pattern"])]);}
+
+export function asDLit<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): DLit<_embedded> {
+    let result = toDLit(v);
+    if (result === void 0) throw new TypeError(`Invalid DLit: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toDLit<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | DLit<_embedded> {
+    let result: undefined | DLit<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, $lit) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_.Value<_embedded>) | undefined;
+            _tmp1 = v[0];
+            if (_tmp1 !== void 0) {result = {"value": _tmp1};};
+        };
+    };
+    return result;
+}
+
+export function fromDLit<_embedded = _i_EntityRef.Cap>(_v: DLit<_embedded>): _.Value<_embedded> {return _.Record($lit, [_v["value"]]);}
+
+export function asDCompound<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): DCompound<_embedded> {
+    let result = toDCompound(v);
+    if (result === void 0) throw new TypeError(`Invalid DCompound: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toDCompound<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | DCompound<_embedded> {
+    let result: undefined | DCompound<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, $compound) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (CRec<_embedded>) | undefined;
+            _tmp1 = toCRec(v[0]);
+            if (_tmp1 !== void 0) {
+                let _tmp2: (_.KeyedDictionary<number, Pattern<_embedded>, _embedded>) | undefined;
+                _tmp2 = void 0;
+                if (_.Dictionary.isDictionary<_embedded>(v[1])) {
+                    _tmp2 = new _.KeyedDictionary();
+                    for (const [_tmp4, _tmp3] of v[1]) {
+                        let _tmp5: (number) | undefined;
+                        _tmp5 = typeof _tmp4 === 'number' ? _tmp4 : void 0;
+                        if (_tmp5 !== void 0) {
+                            let _tmp6: (Pattern<_embedded>) | undefined;
+                            _tmp6 = toPattern(_tmp3);
+                            if (_tmp6 !== void 0) {_tmp2.set(_tmp5, _tmp6); continue;};
+                        };
+                        _tmp2 = void 0;
+                        break;
+                    };
+                };
+                if (_tmp2 !== void 0) {result = {"_variant": "rec", "ctor": _tmp1, "members": _tmp2};};
+            };
+        };
+    };
+    if (result === void 0) {
+        if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+            let _tmp7: (null) | undefined;
+            _tmp7 = _.is(v.label, $compound) ? null : void 0;
+            if (_tmp7 !== void 0) {
+                let _tmp8: (CArr) | undefined;
+                _tmp8 = toCArr(v[0]);
+                if (_tmp8 !== void 0) {
+                    let _tmp9: (_.KeyedDictionary<number, Pattern<_embedded>, _embedded>) | undefined;
+                    _tmp9 = void 0;
+                    if (_.Dictionary.isDictionary<_embedded>(v[1])) {
+                        _tmp9 = new _.KeyedDictionary();
+                        for (const [_tmp11, _tmp10] of v[1]) {
+                            let _tmp12: (number) | undefined;
+                            _tmp12 = typeof _tmp11 === 'number' ? _tmp11 : void 0;
+                            if (_tmp12 !== void 0) {
+                                let _tmp13: (Pattern<_embedded>) | undefined;
+                                _tmp13 = toPattern(_tmp10);
+                                if (_tmp13 !== void 0) {_tmp9.set(_tmp12, _tmp13); continue;};
+                            };
+                            _tmp9 = void 0;
+                            break;
+                        };
+                    };
+                    if (_tmp9 !== void 0) {result = {"_variant": "arr", "ctor": _tmp8, "members": _tmp9};};
+                };
+            };
+        };
+        if (result === void 0) {
+            if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+                let _tmp14: (null) | undefined;
+                _tmp14 = _.is(v.label, $compound) ? null : void 0;
+                if (_tmp14 !== void 0) {
+                    let _tmp15: (CDict) | undefined;
+                    _tmp15 = toCDict(v[0]);
+                    if (_tmp15 !== void 0) {
+                        let _tmp16: (_.KeyedDictionary<_.Value<_embedded>, Pattern<_embedded>, _embedded>) | undefined;
+                        _tmp16 = void 0;
+                        if (_.Dictionary.isDictionary<_embedded>(v[1])) {
+                            _tmp16 = new _.KeyedDictionary();
+                            for (const [_tmp18, _tmp17] of v[1]) {
+                                let _tmp19: (_.Value<_embedded>) | undefined;
+                                _tmp19 = _tmp18;
+                                if (_tmp19 !== void 0) {
+                                    let _tmp20: (Pattern<_embedded>) | undefined;
+                                    _tmp20 = toPattern(_tmp17);
+                                    if (_tmp20 !== void 0) {_tmp16.set(_tmp19, _tmp20); continue;};
+                                };
+                                _tmp16 = void 0;
+                                break;
+                            };
+                        };
+                        if (_tmp16 !== void 0) {result = {"_variant": "dict", "ctor": _tmp15, "members": _tmp16};};
+                    };
+                };
+            };
+        };
+    };
+    return result;
+}
+
+export function fromDCompound<_embedded = _i_EntityRef.Cap>(_v: DCompound<_embedded>): _.Value<_embedded> {
+    switch (_v._variant) {
+        case "rec": {
+            return _.Record(
+                $compound,
+                [
+                    fromCRec<_embedded>(_v["ctor"]),
+                    new _.Dictionary<_embedded>(
+                        _.Array.from(_v["members"].entries()).map(([k, v]) => [k, fromPattern<_embedded>(v)])
+                    )
+                ]
+            );
+        };
+        case "arr": {
+            return _.Record(
+                $compound,
+                [
+                    fromCArr<_embedded>(_v["ctor"]),
+                    new _.Dictionary<_embedded>(
+                        _.Array.from(_v["members"].entries()).map(([k, v]) => [k, fromPattern<_embedded>(v)])
+                    )
+                ]
+            );
+        };
+        case "dict": {
+            return _.Record(
+                $compound,
+                [
+                    fromCDict<_embedded>(_v["ctor"]),
+                    new _.Dictionary<_embedded>(
+                        _.Array.from(_v["members"].entries()).map(([k, v]) => [k, fromPattern<_embedded>(v)])
+                    )
+                ]
+            );
+        };
+    };
+}
+
+export function asCRec<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): CRec<_embedded> {
+    let result = toCRec(v);
+    if (result === void 0) throw new TypeError(`Invalid CRec: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toCRec<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | CRec<_embedded> {
+    let result: undefined | CRec<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, $rec) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_.Value<_embedded>) | undefined;
+            _tmp1 = v[0];
+            if (_tmp1 !== void 0) {
+                let _tmp2: (number) | undefined;
+                _tmp2 = typeof v[1] === 'number' ? v[1] : void 0;
+                if (_tmp2 !== void 0) {result = {"label": _tmp1, "arity": _tmp2};};
+            };
+        };
+    };
+    return result;
+}
+
+export function fromCRec<_embedded = _i_EntityRef.Cap>(_v: CRec<_embedded>): _.Value<_embedded> {return _.Record($rec, [_v["label"], _v["arity"]]);}
+
+export function asCArr<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): CArr {
+    let result = toCArr(v);
+    if (result === void 0) throw new TypeError(`Invalid CArr: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toCArr<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | CArr {
+    let result: undefined | CArr;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, $arr) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (number) | undefined;
+            _tmp1 = typeof v[0] === 'number' ? v[0] : void 0;
+            if (_tmp1 !== void 0) {result = {"arity": _tmp1};};
+        };
+    };
+    return result;
+}
+
+export function fromCArr<_embedded = _i_EntityRef.Cap>(_v: CArr): _.Value<_embedded> {return _.Record($arr, [_v["arity"]]);}
+
+export function asCDict<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): CDict {
+    let result = toCDict(v);
+    if (result === void 0) throw new TypeError(`Invalid CDict: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toCDict<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | CDict {
+    let result: undefined | CDict;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, $dict) ? null : void 0;
+        if (_tmp0 !== void 0) {result = null;};
+    };
+    return result;
+}
+
+export function fromCDict<_embedded = _i_EntityRef.Cap>(_v: CDict): _.Value<_embedded> {return _.Record($dict, []);}
+

src/gen/examples/boxProtocol.ts

@@ -1,12 +1,10 @@
 import * as _ from "@preserves/core";
-import * as _i_Actor from "../runtime/actor";
+import * as _i_EntityRef from "../../runtime/actor";
 
 export const $BoxState = Symbol.for("BoxState");
 export const $SetBox = Symbol.for("SetBox");
 
-export type _embedded = _i_Actor.Ref;
-
-export type _val = _.Value<_embedded>;
+export type _embedded = _i_EntityRef.Ref;
 
 export type BoxState = {"value": number};
 
@@ -17,15 +15,15 @@ export function BoxState(value: number): BoxState {return {"value": value};}
 
 export function SetBox(value: number): SetBox {return {"value": value};}
 
-export function asBoxState(v: _val): BoxState {
+export function asBoxState<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): BoxState {
     let result = toBoxState(v);
     if (result === void 0) throw new TypeError(`Invalid BoxState: ${_.stringify(v)}`);
     return result;
 }
 
-export function toBoxState(v: _val): undefined | BoxState {
+export function toBoxState<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | BoxState {
     let result: undefined | BoxState;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
         let _tmp0: (null) | undefined;
         _tmp0 = _.is(v.label, $BoxState) ? null : void 0;
         if (_tmp0 !== void 0) {
@@ -37,17 +35,17 @@ export function toBoxState(v: _val): undefined | BoxState {
     return result;
 }
 
-export function fromBoxState(_v: BoxState): _val {return _.Record($BoxState, [_v["value"]]);}
+export function fromBoxState<_embedded = _i_EntityRef.Ref>(_v: BoxState): _.Value<_embedded> {return _.Record($BoxState, [_v["value"]]);}
 
-export function asSetBox(v: _val): SetBox {
+export function asSetBox<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): SetBox {
     let result = toSetBox(v);
     if (result === void 0) throw new TypeError(`Invalid SetBox: ${_.stringify(v)}`);
     return result;
 }
 
-export function toSetBox(v: _val): undefined | SetBox {
+export function toSetBox<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | SetBox {
     let result: undefined | SetBox;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
         let _tmp0: (null) | undefined;
         _tmp0 = _.is(v.label, $SetBox) ? null : void 0;
         if (_tmp0 !== void 0) {
@@ -59,5 +57,5 @@ export function toSetBox(v: _val): undefined | SetBox {
     return result;
 }
 
-export function fromSetBox(_v: SetBox): _val {return _.Record($SetBox, [_v["value"]]);}
+export function fromSetBox<_embedded = _i_EntityRef.Ref>(_v: SetBox): _.Value<_embedded> {return _.Record($SetBox, [_v["value"]]);}
 

src/gen/gatekeeper.ts

@@ -1,36 +1,36 @@
 import * as _ from "@preserves/core";
-import * as _i_Actor from "../runtime/actor";
+import * as _i_EntityRef from "../runtime/actor";
 import * as _i_sturdy from "./sturdy";
 
 export const $bind = Symbol.for("bind");
 export const $resolve = Symbol.for("resolve");
 
-export type _embedded = _i_Actor.Ref;
+export type _embedded = _i_EntityRef.Cap;
 
-export type _val = _.Value<_embedded>;
+export type Resolve<_embedded = _i_EntityRef.Cap> = {"sturdyref": _i_sturdy.SturdyRef<_embedded>, "observer": _embedded};
 
-export type Resolve = {"sturdyref": _i_sturdy.SturdyRef, "observer": _embedded};
-
-export type Bind = {"oid": _val, "key": _.Bytes, "target": _embedded};
+export type Bind<_embedded = _i_EntityRef.Cap> = {"oid": _.Value<_embedded>, "key": _.Bytes, "target": _embedded};
 
 
-export function Resolve({sturdyref, observer}: {sturdyref: _i_sturdy.SturdyRef, observer: _embedded}): Resolve {return {"sturdyref": sturdyref, "observer": observer};}
+export function Resolve<_embedded = _i_EntityRef.Cap>(
+    {sturdyref, observer}: {sturdyref: _i_sturdy.SturdyRef<_embedded>, observer: _embedded}
+): Resolve<_embedded> {return {"sturdyref": sturdyref, "observer": observer};}
 
-export function Bind({oid, key, target}: {oid: _val, key: _.Bytes, target: _embedded}): Bind {return {"oid": oid, "key": key, "target": target};}
+export function Bind<_embedded = _i_EntityRef.Cap>({oid, key, target}: {oid: _.Value<_embedded>, key: _.Bytes, target: _embedded}): Bind<_embedded> {return {"oid": oid, "key": key, "target": target};}
 
-export function asResolve(v: _val): Resolve {
+export function asResolve<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): Resolve<_embedded> {
     let result = toResolve(v);
     if (result === void 0) throw new TypeError(`Invalid Resolve: ${_.stringify(v)}`);
     return result;
 }
 
-export function toResolve(v: _val): undefined | Resolve {
-    let result: undefined | Resolve;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
+export function toResolve<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | Resolve<_embedded> {
+    let result: undefined | Resolve<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
         let _tmp0: (null) | undefined;
         _tmp0 = _.is(v.label, $resolve) ? null : void 0;
         if (_tmp0 !== void 0) {
-            let _tmp1: (_i_sturdy.SturdyRef) | undefined;
+            let _tmp1: (_i_sturdy.SturdyRef<_embedded>) | undefined;
             _tmp1 = _i_sturdy.toSturdyRef(v[0]);
             if (_tmp1 !== void 0) {
                 let _tmp2: (_embedded) | undefined;
@@ -42,23 +42,26 @@ export function toResolve(v: _val): undefined | Resolve {
     return result;
 }
 
-export function fromResolve(_v: Resolve): _val {
-    return _.Record($resolve, [_i_sturdy.fromSturdyRef(_v["sturdyref"]), _.embed(_v["observer"])]);
+export function fromResolve<_embedded = _i_EntityRef.Cap>(_v: Resolve<_embedded>): _.Value<_embedded> {
+    return _.Record(
+        $resolve,
+        [_i_sturdy.fromSturdyRef<_embedded>(_v["sturdyref"]), _.embed(_v["observer"])]
+    );
 }
 
-export function asBind(v: _val): Bind {
+export function asBind<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): Bind<_embedded> {
     let result = toBind(v);
     if (result === void 0) throw new TypeError(`Invalid Bind: ${_.stringify(v)}`);
     return result;
 }
 
-export function toBind(v: _val): undefined | Bind {
-    let result: undefined | Bind;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
+export function toBind<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | Bind<_embedded> {
+    let result: undefined | Bind<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
         let _tmp0: (null) | undefined;
         _tmp0 = _.is(v.label, $bind) ? null : void 0;
         if (_tmp0 !== void 0) {
-            let _tmp1: (_val) | undefined;
+            let _tmp1: (_.Value<_embedded>) | undefined;
             _tmp1 = v[0];
             if (_tmp1 !== void 0) {
                 let _tmp2: (_.Bytes) | undefined;
@@ -74,5 +77,5 @@ export function toBind(v: _val): undefined | Bind {
     return result;
 }
 
-export function fromBind(_v: Bind): _val {return _.Record($bind, [_v["oid"], _v["key"], _.embed(_v["target"])]);}
+export function fromBind<_embedded = _i_EntityRef.Cap>(_v: Bind<_embedded>): _.Value<_embedded> {return _.Record($bind, [_v["oid"], _v["key"], _.embed(_v["target"])]);}
 

src/gen/protocol.ts

@@ -1,291 +0,0 @@
-import * as _ from "@preserves/core";
-import * as _i_sturdy from "./sturdy";
-
-export const $assert = Symbol.for("assert");
-export const $message = Symbol.for("message");
-export const $retract = Symbol.for("retract");
-export const $sync = Symbol.for("sync");
-
-export type _embedded = _i_sturdy.WireRef;
-
-export type _val = _.Value<_embedded>;
-
-export type Assertion = _val;
-
-export type Handle = number;
-
-export type Event = (
-    {"_variant": "Assert", "value": Assert} |
-    {"_variant": "Retract", "value": Retract} |
-    {"_variant": "Message", "value": Message} |
-    {"_variant": "Sync", "value": Sync}
-);
-
-export type Oid = number;
-
-export type Turn = Array<TurnEvent>;
-
-export type TurnEvent = {"oid": Oid, "event": Event};
-
-export type Assert = {"assertion": Assertion, "handle": Handle};
-
-export type Retract = {"handle": Handle};
-
-export type Message = {"body": Assertion};
-
-export type Sync = {"peer": _embedded};
-
-
-export function Assertion(value: _val): Assertion {return value;}
-
-export function Handle(value: number): Handle {return value;}
-
-export namespace Event {
-    export function Assert(value: Assert): Event {return {"_variant": "Assert", "value": value};};
-    export function Retract(value: Retract): Event {return {"_variant": "Retract", "value": value};};
-    export function Message(value: Message): Event {return {"_variant": "Message", "value": value};};
-    export function Sync(value: Sync): Event {return {"_variant": "Sync", "value": value};};
-}
-
-export function Oid(value: number): Oid {return value;}
-
-export function Turn(value: Array<TurnEvent>): Turn {return value;}
-
-export function TurnEvent({oid, event}: {oid: Oid, event: Event}): TurnEvent {return {"oid": oid, "event": event};}
-
-export function Assert({assertion, handle}: {assertion: Assertion, handle: Handle}): Assert {return {"assertion": assertion, "handle": handle};}
-
-export function Retract(handle: Handle): Retract {return {"handle": handle};}
-
-export function Message(body: Assertion): Message {return {"body": body};}
-
-export function Sync(peer: _embedded): Sync {return {"peer": peer};}
-
-export function asAssertion(v: _val): Assertion {
-    let result = toAssertion(v);
-    if (result === void 0) throw new TypeError(`Invalid Assertion: ${_.stringify(v)}`);
-    return result;
-}
-
-export function toAssertion(v: _val): undefined | Assertion {
-    let _tmp0: (_val) | undefined;
-    let result: undefined | Assertion;
-    _tmp0 = v;
-    if (_tmp0 !== void 0) {result = _tmp0;};
-    return result;
-}
-
-export function fromAssertion(_v: Assertion): _val {return _v;}
-
-export function asHandle(v: _val): Handle {
-    let result = toHandle(v);
-    if (result === void 0) throw new TypeError(`Invalid Handle: ${_.stringify(v)}`);
-    return result;
-}
-
-export function toHandle(v: _val): undefined | Handle {
-    let _tmp0: (number) | undefined;
-    let result: undefined | Handle;
-    _tmp0 = typeof v === 'number' ? v : void 0;
-    if (_tmp0 !== void 0) {result = _tmp0;};
-    return result;
-}
-
-export function fromHandle(_v: Handle): _val {return _v;}
-
-export function asEvent(v: _val): Event {
-    let result = toEvent(v);
-    if (result === void 0) throw new TypeError(`Invalid Event: ${_.stringify(v)}`);
-    return result;
-}
-
-export function toEvent(v: _val): undefined | Event {
-    let _tmp0: (Assert) | undefined;
-    let result: undefined | Event;
-    _tmp0 = toAssert(v);
-    if (_tmp0 !== void 0) {result = {"_variant": "Assert", "value": _tmp0};};
-    if (result === void 0) {
-        let _tmp1: (Retract) | undefined;
-        _tmp1 = toRetract(v);
-        if (_tmp1 !== void 0) {result = {"_variant": "Retract", "value": _tmp1};};
-        if (result === void 0) {
-            let _tmp2: (Message) | undefined;
-            _tmp2 = toMessage(v);
-            if (_tmp2 !== void 0) {result = {"_variant": "Message", "value": _tmp2};};
-            if (result === void 0) {
-                let _tmp3: (Sync) | undefined;
-                _tmp3 = toSync(v);
-                if (_tmp3 !== void 0) {result = {"_variant": "Sync", "value": _tmp3};};
-            };
-        };
-    };
-    return result;
-}
-
-export function fromEvent(_v: Event): _val {
-    switch (_v._variant) {
-        case "Assert": {return fromAssert(_v.value);};
-        case "Retract": {return fromRetract(_v.value);};
-        case "Message": {return fromMessage(_v.value);};
-        case "Sync": {return fromSync(_v.value);};
-    };
-}
-
-export function asOid(v: _val): Oid {
-    let result = toOid(v);
-    if (result === void 0) throw new TypeError(`Invalid Oid: ${_.stringify(v)}`);
-    return result;
-}
-
-export function toOid(v: _val): undefined | Oid {
-    let _tmp0: (number) | undefined;
-    let result: undefined | Oid;
-    _tmp0 = typeof v === 'number' ? v : void 0;
-    if (_tmp0 !== void 0) {result = _tmp0;};
-    return result;
-}
-
-export function fromOid(_v: Oid): _val {return _v;}
-
-export function asTurn(v: _val): Turn {
-    let result = toTurn(v);
-    if (result === void 0) throw new TypeError(`Invalid Turn: ${_.stringify(v)}`);
-    return result;
-}
-
-export function toTurn(v: _val): undefined | Turn {
-    let _tmp0: (Array<TurnEvent>) | undefined;
-    let result: undefined | Turn;
-    _tmp0 = void 0;
-    if (_.Array.isArray(v)) {
-        _tmp0 = [];
-        for (const _tmp1 of v) {
-            let _tmp2: (TurnEvent) | undefined;
-            _tmp2 = toTurnEvent(_tmp1);
-            if (_tmp2 !== void 0) {_tmp0.push(_tmp2); continue;};
-            _tmp0 = void 0;
-            break;
-        };
-    };
-    if (_tmp0 !== void 0) {result = _tmp0;};
-    return result;
-}
-
-export function fromTurn(_v: Turn): _val {return _v.map(v => fromTurnEvent(v));}
-
-export function asTurnEvent(v: _val): TurnEvent {
-    let result = toTurnEvent(v);
-    if (result === void 0) throw new TypeError(`Invalid TurnEvent: ${_.stringify(v)}`);
-    return result;
-}
-
-export function toTurnEvent(v: _val): undefined | TurnEvent {
-    let result: undefined | TurnEvent;
-    if (_.Array.isArray(v) && v.length === 2) {
-        let _tmp0: (Oid) | undefined;
-        _tmp0 = toOid(v[0]);
-        if (_tmp0 !== void 0) {
-            let _tmp1: (Event) | undefined;
-            _tmp1 = toEvent(v[1]);
-            if (_tmp1 !== void 0) {result = {"oid": _tmp0, "event": _tmp1};};
-        };
-    };
-    return result;
-}
-
-export function fromTurnEvent(_v: TurnEvent): _val {return [fromOid(_v["oid"]), fromEvent(_v["event"])];}
-
-export function asAssert(v: _val): Assert {
-    let result = toAssert(v);
-    if (result === void 0) throw new TypeError(`Invalid Assert: ${_.stringify(v)}`);
-    return result;
-}
-
-export function toAssert(v: _val): undefined | Assert {
-    let result: undefined | Assert;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
-        let _tmp0: (null) | undefined;
-        _tmp0 = _.is(v.label, $assert) ? null : void 0;
-        if (_tmp0 !== void 0) {
-            let _tmp1: (Assertion) | undefined;
-            _tmp1 = toAssertion(v[0]);
-            if (_tmp1 !== void 0) {
-                let _tmp2: (Handle) | undefined;
-                _tmp2 = toHandle(v[1]);
-                if (_tmp2 !== void 0) {result = {"assertion": _tmp1, "handle": _tmp2};};
-            };
-        };
-    };
-    return result;
-}
-
-export function fromAssert(_v: Assert): _val {
-    return _.Record($assert, [fromAssertion(_v["assertion"]), fromHandle(_v["handle"])]);
-}
-
-export function asRetract(v: _val): Retract {
-    let result = toRetract(v);
-    if (result === void 0) throw new TypeError(`Invalid Retract: ${_.stringify(v)}`);
-    return result;
-}
-
-export function toRetract(v: _val): undefined | Retract {
-    let result: undefined | Retract;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
-        let _tmp0: (null) | undefined;
-        _tmp0 = _.is(v.label, $retract) ? null : void 0;
-        if (_tmp0 !== void 0) {
-            let _tmp1: (Handle) | undefined;
-            _tmp1 = toHandle(v[0]);
-            if (_tmp1 !== void 0) {result = {"handle": _tmp1};};
-        };
-    };
-    return result;
-}
-
-export function fromRetract(_v: Retract): _val {return _.Record($retract, [fromHandle(_v["handle"])]);}
-
-export function asMessage(v: _val): Message {
-    let result = toMessage(v);
-    if (result === void 0) throw new TypeError(`Invalid Message: ${_.stringify(v)}`);
-    return result;
-}
-
-export function toMessage(v: _val): undefined | Message {
-    let result: undefined | Message;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
-        let _tmp0: (null) | undefined;
-        _tmp0 = _.is(v.label, $message) ? null : void 0;
-        if (_tmp0 !== void 0) {
-            let _tmp1: (Assertion) | undefined;
-            _tmp1 = toAssertion(v[0]);
-            if (_tmp1 !== void 0) {result = {"body": _tmp1};};
-        };
-    };
-    return result;
-}
-
-export function fromMessage(_v: Message): _val {return _.Record($message, [fromAssertion(_v["body"])]);}
-
-export function asSync(v: _val): Sync {
-    let result = toSync(v);
-    if (result === void 0) throw new TypeError(`Invalid Sync: ${_.stringify(v)}`);
-    return result;
-}
-
-export function toSync(v: _val): undefined | Sync {
-    let result: undefined | Sync;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
-        let _tmp0: (null) | undefined;
-        _tmp0 = _.is(v.label, $sync) ? null : void 0;
-        if (_tmp0 !== void 0) {
-            let _tmp1: (_embedded) | undefined;
-            _tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0;
-            if (_tmp1 !== void 0) {result = {"peer": _tmp1};};
-        };
-    };
-    return result;
-}
-
-export function fromSync(_v: Sync): _val {return _.Record($sync, [_.embed(_v["peer"])]);}
-

src/gen/racketEvent.ts

@@ -0,0 +1,35 @@
+import * as _ from "@preserves/core";
+
+export const __lit0 = Symbol.for("racket-event");
+
+export type RacketEvent<_embedded = _.GenericEmbedded> = {"source": _embedded, "event": _embedded};
+
+
+export function RacketEvent<_embedded = _.GenericEmbedded>({source, event}: {source: _embedded, event: _embedded}): RacketEvent<_embedded> {return {"source": source, "event": event};}
+
+export function asRacketEvent<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): RacketEvent<_embedded> {
+    let result = toRacketEvent(v);
+    if (result === void 0) throw new TypeError(`Invalid RacketEvent: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toRacketEvent<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | RacketEvent<_embedded> {
+    let result: undefined | RacketEvent<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit0) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_embedded) | undefined;
+            _tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0;
+            if (_tmp1 !== void 0) {
+                let _tmp2: (_embedded) | undefined;
+                _tmp2 = _.isEmbedded<_embedded>(v[1]) ? v[1].embeddedValue : void 0;
+                if (_tmp2 !== void 0) {result = {"source": _tmp1, "event": _tmp2};};
+            };
+        };
+    };
+    return result;
+}
+
+export function fromRacketEvent<_embedded = _.GenericEmbedded>(_v: RacketEvent<_embedded>): _.Value<_embedded> {return _.Record(__lit0, [_.embed(_v["source"]), _.embed(_v["event"])]);}
+

src/gen/secureChatProtocol.ts

@@ -1,5 +1,5 @@
 import * as _ from "@preserves/core";
-import * as _i_Actor from "../runtime/actor";
+import * as _i_EntityRef from "../runtime/actor";
 
 export const $Observe = Symbol.for("Observe");
 export const $claimNick = Symbol.for("claimNick");
@@ -9,22 +9,20 @@ export const $says = Symbol.for("says");
 export const $user = Symbol.for("user");
 export const __lit5 = true;
 
-export type _embedded = _i_Actor.Ref;
-
-export type _val = _.Value<_embedded>;
+export type _embedded = _i_EntityRef.Cap;
 
 export type UserId = number;
 
-export type Join = {"uid": UserId, "handle": _embedded};
+export type Join<_embedded = _i_EntityRef.Cap> = {"uid": UserId, "handle": _embedded};
 
-export type Session = (
+export type Session<_embedded = _i_EntityRef.Cap> = (
     {"_variant": "observeUsers", "observer": _embedded} |
     {"_variant": "observeSpeech", "observer": _embedded} |
-    {"_variant": "NickClaim", "value": NickClaim} |
+    {"_variant": "NickClaim", "value": NickClaim<_embedded>} |
     {"_variant": "Says", "value": Says}
 );
 
-export type NickClaim = {"uid": UserId, "name": string, "k": _embedded};
+export type NickClaim<_embedded = _i_EntityRef.Cap> = {"uid": UserId, "name": string, "k": _embedded};
 
 export type NickClaimResponse = ({"_variant": "true"} | {"_variant": "NickConflict", "value": NickConflict});
 
@@ -37,16 +35,16 @@ export type NickConflict = null;
 
 export function UserId(value: number): UserId {return value;}
 
-export function Join({uid, handle}: {uid: UserId, handle: _embedded}): Join {return {"uid": uid, "handle": handle};}
+export function Join<_embedded = _i_EntityRef.Cap>({uid, handle}: {uid: UserId, handle: _embedded}): Join<_embedded> {return {"uid": uid, "handle": handle};}
 
 export namespace Session {
-    export function observeUsers(observer: _embedded): Session {return {"_variant": "observeUsers", "observer": observer};};
-    export function observeSpeech(observer: _embedded): Session {return {"_variant": "observeSpeech", "observer": observer};};
-    export function NickClaim(value: NickClaim): Session {return {"_variant": "NickClaim", "value": value};};
-    export function Says(value: Says): Session {return {"_variant": "Says", "value": value};};
+    export function observeUsers<_embedded = _i_EntityRef.Cap>(observer: _embedded): Session<_embedded> {return {"_variant": "observeUsers", "observer": observer};};
+    export function observeSpeech<_embedded = _i_EntityRef.Cap>(observer: _embedded): Session<_embedded> {return {"_variant": "observeSpeech", "observer": observer};};
+    export function NickClaim<_embedded = _i_EntityRef.Cap>(value: NickClaim<_embedded>): Session<_embedded> {return {"_variant": "NickClaim", "value": value};};
+    export function Says<_embedded = _i_EntityRef.Cap>(value: Says): Session<_embedded> {return {"_variant": "Says", "value": value};};
 }
 
-export function NickClaim({uid, name, k}: {uid: UserId, name: string, k: _embedded}): NickClaim {return {"uid": uid, "name": name, "k": k};}
+export function NickClaim<_embedded = _i_EntityRef.Cap>({uid, name, k}: {uid: UserId, name: string, k: _embedded}): NickClaim<_embedded> {return {"uid": uid, "name": name, "k": k};}
 
 export namespace NickClaimResponse {
     export function $true(): NickClaimResponse {return {"_variant": "true"};};
@@ -59,13 +57,13 @@ export function Says({who, what}: {who: UserId, what: string}): Says {return {"w
 
 export function NickConflict(): NickConflict {return null;}
 
-export function asUserId(v: _val): UserId {
+export function asUserId<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): UserId {
     let result = toUserId(v);
     if (result === void 0) throw new TypeError(`Invalid UserId: ${_.stringify(v)}`);
     return result;
 }
 
-export function toUserId(v: _val): undefined | UserId {
+export function toUserId<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | UserId {
     let _tmp0: (number) | undefined;
     let result: undefined | UserId;
     _tmp0 = typeof v === 'number' ? v : void 0;
@@ -73,17 +71,17 @@ export function toUserId(v: _val): undefined | UserId {
     return result;
 }
 
-export function fromUserId(_v: UserId): _val {return _v;}
+export function fromUserId<_embedded = _i_EntityRef.Cap>(_v: UserId): _.Value<_embedded> {return _v;}
 
-export function asJoin(v: _val): Join {
+export function asJoin<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): Join<_embedded> {
     let result = toJoin(v);
     if (result === void 0) throw new TypeError(`Invalid Join: ${_.stringify(v)}`);
     return result;
 }
 
-export function toJoin(v: _val): undefined | Join {
-    let result: undefined | Join;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
+export function toJoin<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | Join<_embedded> {
+    let result: undefined | Join<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
         let _tmp0: (null) | undefined;
         _tmp0 = _.is(v.label, $joinedUser) ? null : void 0;
         if (_tmp0 !== void 0) {
@@ -99,17 +97,19 @@ export function toJoin(v: _val): undefined | Join {
     return result;
 }
 
-export function fromJoin(_v: Join): _val {return _.Record($joinedUser, [fromUserId(_v["uid"]), _.embed(_v["handle"])]);}
+export function fromJoin<_embedded = _i_EntityRef.Cap>(_v: Join<_embedded>): _.Value<_embedded> {
+    return _.Record($joinedUser, [fromUserId<_embedded>(_v["uid"]), _.embed(_v["handle"])]);
+}
 
-export function asSession(v: _val): Session {
+export function asSession<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): Session<_embedded> {
     let result = toSession(v);
     if (result === void 0) throw new TypeError(`Invalid Session: ${_.stringify(v)}`);
     return result;
 }
 
-export function toSession(v: _val): undefined | Session {
-    let result: undefined | Session;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
+export function toSession<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | Session<_embedded> {
+    let result: undefined | Session<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
         let _tmp0: (null) | undefined;
         _tmp0 = _.is(v.label, $Observe) ? null : void 0;
         if (_tmp0 !== void 0) {
@@ -123,7 +123,7 @@ export function toSession(v: _val): undefined | Session {
         };
     };
     if (result === void 0) {
-        if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
+        if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
             let _tmp3: (null) | undefined;
             _tmp3 = _.is(v.label, $Observe) ? null : void 0;
             if (_tmp3 !== void 0) {
@@ -137,7 +137,7 @@ export function toSession(v: _val): undefined | Session {
             };
         };
         if (result === void 0) {
-            let _tmp6: (NickClaim) | undefined;
+            let _tmp6: (NickClaim<_embedded>) | undefined;
             _tmp6 = toNickClaim(v);
             if (_tmp6 !== void 0) {result = {"_variant": "NickClaim", "value": _tmp6};};
             if (result === void 0) {
@@ -150,24 +150,24 @@ export function toSession(v: _val): undefined | Session {
     return result;
 }
 
-export function fromSession(_v: Session): _val {
+export function fromSession<_embedded = _i_EntityRef.Cap>(_v: Session<_embedded>): _.Value<_embedded> {
     switch (_v._variant) {
         case "observeUsers": {return _.Record($Observe, [$user, _.embed(_v["observer"])]);};
         case "observeSpeech": {return _.Record($Observe, [$says, _.embed(_v["observer"])]);};
-        case "NickClaim": {return fromNickClaim(_v.value);};
-        case "Says": {return fromSays(_v.value);};
+        case "NickClaim": {return fromNickClaim<_embedded>(_v.value);};
+        case "Says": {return fromSays<_embedded>(_v.value);};
     };
 }
 
-export function asNickClaim(v: _val): NickClaim {
+export function asNickClaim<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): NickClaim<_embedded> {
     let result = toNickClaim(v);
     if (result === void 0) throw new TypeError(`Invalid NickClaim: ${_.stringify(v)}`);
     return result;
 }
 
-export function toNickClaim(v: _val): undefined | NickClaim {
-    let result: undefined | NickClaim;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
+export function toNickClaim<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | NickClaim<_embedded> {
+    let result: undefined | NickClaim<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
         let _tmp0: (null) | undefined;
         _tmp0 = _.is(v.label, $claimNick) ? null : void 0;
         if (_tmp0 !== void 0) {
@@ -187,17 +187,17 @@ export function toNickClaim(v: _val): undefined | NickClaim {
     return result;
 }
 
-export function fromNickClaim(_v: NickClaim): _val {
-    return _.Record($claimNick, [fromUserId(_v["uid"]), _v["name"], _.embed(_v["k"])]);
+export function fromNickClaim<_embedded = _i_EntityRef.Cap>(_v: NickClaim<_embedded>): _.Value<_embedded> {
+    return _.Record($claimNick, [fromUserId<_embedded>(_v["uid"]), _v["name"], _.embed(_v["k"])]);
 }
 
-export function asNickClaimResponse(v: _val): NickClaimResponse {
+export function asNickClaimResponse<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): NickClaimResponse {
     let result = toNickClaimResponse(v);
     if (result === void 0) throw new TypeError(`Invalid NickClaimResponse: ${_.stringify(v)}`);
     return result;
 }
 
-export function toNickClaimResponse(v: _val): undefined | NickClaimResponse {
+export function toNickClaimResponse<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | NickClaimResponse {
     let _tmp0: (null) | undefined;
     let result: undefined | NickClaimResponse;
     _tmp0 = _.is(v, __lit5) ? null : void 0;
@@ -210,22 +210,22 @@ export function toNickClaimResponse(v: _val): undefined | NickClaimResponse {
     return result;
 }
 
-export function fromNickClaimResponse(_v: NickClaimResponse): _val {
+export function fromNickClaimResponse<_embedded = _i_EntityRef.Cap>(_v: NickClaimResponse): _.Value<_embedded> {
     switch (_v._variant) {
         case "true": {return __lit5;};
-        case "NickConflict": {return fromNickConflict(_v.value);};
+        case "NickConflict": {return fromNickConflict<_embedded>(_v.value);};
     };
 }
 
-export function asUserInfo(v: _val): UserInfo {
+export function asUserInfo<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): UserInfo {
     let result = toUserInfo(v);
     if (result === void 0) throw new TypeError(`Invalid UserInfo: ${_.stringify(v)}`);
     return result;
 }
 
-export function toUserInfo(v: _val): undefined | UserInfo {
+export function toUserInfo<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | UserInfo {
     let result: undefined | UserInfo;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
         let _tmp0: (null) | undefined;
         _tmp0 = _.is(v.label, $user) ? null : void 0;
         if (_tmp0 !== void 0) {
@@ -241,17 +241,17 @@ export function toUserInfo(v: _val): undefined | UserInfo {
     return result;
 }
 
-export function fromUserInfo(_v: UserInfo): _val {return _.Record($user, [fromUserId(_v["uid"]), _v["name"]]);}
+export function fromUserInfo<_embedded = _i_EntityRef.Cap>(_v: UserInfo): _.Value<_embedded> {return _.Record($user, [fromUserId<_embedded>(_v["uid"]), _v["name"]]);}
 
-export function asSays(v: _val): Says {
+export function asSays<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): Says {
     let result = toSays(v);
     if (result === void 0) throw new TypeError(`Invalid Says: ${_.stringify(v)}`);
     return result;
 }
 
-export function toSays(v: _val): undefined | Says {
+export function toSays<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | Says {
     let result: undefined | Says;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
         let _tmp0: (null) | undefined;
         _tmp0 = _.is(v.label, $says) ? null : void 0;
         if (_tmp0 !== void 0) {
@@ -267,17 +267,17 @@ export function toSays(v: _val): undefined | Says {
     return result;
 }
 
-export function fromSays(_v: Says): _val {return _.Record($says, [fromUserId(_v["who"]), _v["what"]]);}
+export function fromSays<_embedded = _i_EntityRef.Cap>(_v: Says): _.Value<_embedded> {return _.Record($says, [fromUserId<_embedded>(_v["who"]), _v["what"]]);}
 
-export function asNickConflict(v: _val): NickConflict {
+export function asNickConflict<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): NickConflict {
     let result = toNickConflict(v);
     if (result === void 0) throw new TypeError(`Invalid NickConflict: ${_.stringify(v)}`);
     return result;
 }
 
-export function toNickConflict(v: _val): undefined | NickConflict {
+export function toNickConflict<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | NickConflict {
     let result: undefined | NickConflict;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
         let _tmp0: (null) | undefined;
         _tmp0 = _.is(v.label, $nickConflict) ? null : void 0;
         if (_tmp0 !== void 0) {result = null;};
@@ -285,5 +285,5 @@ export function toNickConflict(v: _val): undefined | NickConflict {
     return result;
 }
 
-export function fromNickConflict(_v: NickConflict): _val {return _.Record($nickConflict, []);}
+export function fromNickConflict<_embedded = _i_EntityRef.Cap>(_v: NickConflict): _.Value<_embedded> {return _.Record($nickConflict, []);}
 

src/gen/service.ts

@@ -0,0 +1,245 @@
+import * as _ from "@preserves/core";
+import * as _i_EntityRef from "../runtime/actor";
+
+export const $complete = Symbol.for("complete");
+export const $failed = Symbol.for("failed");
+export const $ready = Symbol.for("ready");
+export const $started = Symbol.for("started");
+export const __lit0 = Symbol.for("require-service");
+export const __lit1 = Symbol.for("run-service");
+export const __lit2 = Symbol.for("service-state");
+export const __lit3 = Symbol.for("service-object");
+export const __lit8 = Symbol.for("depends-on");
+export const __lit9 = Symbol.for("core-service");
+
+export type _embedded = _i_EntityRef.Cap;
+
+export type RequireService<_embedded = _i_EntityRef.Cap> = {"serviceName": _.Value<_embedded>};
+
+export type RunService<_embedded = _i_EntityRef.Cap> = {"serviceName": _.Value<_embedded>};
+
+export type ServiceState<_embedded = _i_EntityRef.Cap> = {"serviceName": _.Value<_embedded>, "state": State};
+
+export type ServiceObject<_embedded = _i_EntityRef.Cap> = {"serviceName": _.Value<_embedded>, "object": _.Value<_embedded>};
+
+export type State = (
+    {"_variant": "started"} |
+    {"_variant": "ready"} |
+    {"_variant": "failed"} |
+    {"_variant": "complete"}
+);
+
+export type ServiceDependency<_embedded = _i_EntityRef.Cap> = {"depender": _.Value<_embedded>, "dependee": ServiceState<_embedded>};
+
+export type CoreService<_embedded = _i_EntityRef.Cap> = {"serviceName": _.Value<_embedded>};
+
+
+export function RequireService<_embedded = _i_EntityRef.Cap>(serviceName: _.Value<_embedded>): RequireService<_embedded> {return {"serviceName": serviceName};}
+
+export function RunService<_embedded = _i_EntityRef.Cap>(serviceName: _.Value<_embedded>): RunService<_embedded> {return {"serviceName": serviceName};}
+
+export function ServiceState<_embedded = _i_EntityRef.Cap>({serviceName, state}: {serviceName: _.Value<_embedded>, state: State}): ServiceState<_embedded> {return {"serviceName": serviceName, "state": state};}
+
+export function ServiceObject<_embedded = _i_EntityRef.Cap>(
+    {serviceName, object}: {serviceName: _.Value<_embedded>, object: _.Value<_embedded>}
+): ServiceObject<_embedded> {return {"serviceName": serviceName, "object": object};}
+
+export namespace State {
+    export function started(): State {return {"_variant": "started"};};
+    export function ready(): State {return {"_variant": "ready"};};
+    export function failed(): State {return {"_variant": "failed"};};
+    export function complete(): State {return {"_variant": "complete"};};
+}
+
+export function ServiceDependency<_embedded = _i_EntityRef.Cap>(
+    {depender, dependee}: {depender: _.Value<_embedded>, dependee: ServiceState<_embedded>}
+): ServiceDependency<_embedded> {return {"depender": depender, "dependee": dependee};}
+
+export function CoreService<_embedded = _i_EntityRef.Cap>(serviceName: _.Value<_embedded>): CoreService<_embedded> {return {"serviceName": serviceName};}
+
+export function asRequireService<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): RequireService<_embedded> {
+    let result = toRequireService(v);
+    if (result === void 0) throw new TypeError(`Invalid RequireService: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toRequireService<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | RequireService<_embedded> {
+    let result: undefined | RequireService<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit0) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_.Value<_embedded>) | undefined;
+            _tmp1 = v[0];
+            if (_tmp1 !== void 0) {result = {"serviceName": _tmp1};};
+        };
+    };
+    return result;
+}
+
+export function fromRequireService<_embedded = _i_EntityRef.Cap>(_v: RequireService<_embedded>): _.Value<_embedded> {return _.Record(__lit0, [_v["serviceName"]]);}
+
+export function asRunService<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): RunService<_embedded> {
+    let result = toRunService(v);
+    if (result === void 0) throw new TypeError(`Invalid RunService: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toRunService<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | RunService<_embedded> {
+    let result: undefined | RunService<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit1) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_.Value<_embedded>) | undefined;
+            _tmp1 = v[0];
+            if (_tmp1 !== void 0) {result = {"serviceName": _tmp1};};
+        };
+    };
+    return result;
+}
+
+export function fromRunService<_embedded = _i_EntityRef.Cap>(_v: RunService<_embedded>): _.Value<_embedded> {return _.Record(__lit1, [_v["serviceName"]]);}
+
+export function asServiceState<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): ServiceState<_embedded> {
+    let result = toServiceState(v);
+    if (result === void 0) throw new TypeError(`Invalid ServiceState: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toServiceState<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | ServiceState<_embedded> {
+    let result: undefined | ServiceState<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit2) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_.Value<_embedded>) | undefined;
+            _tmp1 = v[0];
+            if (_tmp1 !== void 0) {
+                let _tmp2: (State) | undefined;
+                _tmp2 = toState(v[1]);
+                if (_tmp2 !== void 0) {result = {"serviceName": _tmp1, "state": _tmp2};};
+            };
+        };
+    };
+    return result;
+}
+
+export function fromServiceState<_embedded = _i_EntityRef.Cap>(_v: ServiceState<_embedded>): _.Value<_embedded> {
+    return _.Record(__lit2, [_v["serviceName"], fromState<_embedded>(_v["state"])]);
+}
+
+export function asServiceObject<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): ServiceObject<_embedded> {
+    let result = toServiceObject(v);
+    if (result === void 0) throw new TypeError(`Invalid ServiceObject: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toServiceObject<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | ServiceObject<_embedded> {
+    let result: undefined | ServiceObject<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit3) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_.Value<_embedded>) | undefined;
+            _tmp1 = v[0];
+            if (_tmp1 !== void 0) {
+                let _tmp2: (_.Value<_embedded>) | undefined;
+                _tmp2 = v[1];
+                if (_tmp2 !== void 0) {result = {"serviceName": _tmp1, "object": _tmp2};};
+            };
+        };
+    };
+    return result;
+}
+
+export function fromServiceObject<_embedded = _i_EntityRef.Cap>(_v: ServiceObject<_embedded>): _.Value<_embedded> {return _.Record(__lit3, [_v["serviceName"], _v["object"]]);}
+
+export function asState<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): State {
+    let result = toState(v);
+    if (result === void 0) throw new TypeError(`Invalid State: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toState<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | State {
+    let _tmp0: (null) | undefined;
+    let result: undefined | State;
+    _tmp0 = _.is(v, $started) ? null : void 0;
+    if (_tmp0 !== void 0) {result = {"_variant": "started"};};
+    if (result === void 0) {
+        let _tmp1: (null) | undefined;
+        _tmp1 = _.is(v, $ready) ? null : void 0;
+        if (_tmp1 !== void 0) {result = {"_variant": "ready"};};
+        if (result === void 0) {
+            let _tmp2: (null) | undefined;
+            _tmp2 = _.is(v, $failed) ? null : void 0;
+            if (_tmp2 !== void 0) {result = {"_variant": "failed"};};
+            if (result === void 0) {
+                let _tmp3: (null) | undefined;
+                _tmp3 = _.is(v, $complete) ? null : void 0;
+                if (_tmp3 !== void 0) {result = {"_variant": "complete"};};
+            };
+        };
+    };
+    return result;
+}
+
+export function fromState<_embedded = _i_EntityRef.Cap>(_v: State): _.Value<_embedded> {
+    switch (_v._variant) {
+        case "started": {return $started;};
+        case "ready": {return $ready;};
+        case "failed": {return $failed;};
+        case "complete": {return $complete;};
+    };
+}
+
+export function asServiceDependency<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): ServiceDependency<_embedded> {
+    let result = toServiceDependency(v);
+    if (result === void 0) throw new TypeError(`Invalid ServiceDependency: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toServiceDependency<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | ServiceDependency<_embedded> {
+    let result: undefined | ServiceDependency<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit8) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_.Value<_embedded>) | undefined;
+            _tmp1 = v[0];
+            if (_tmp1 !== void 0) {
+                let _tmp2: (ServiceState<_embedded>) | undefined;
+                _tmp2 = toServiceState(v[1]);
+                if (_tmp2 !== void 0) {result = {"depender": _tmp1, "dependee": _tmp2};};
+            };
+        };
+    };
+    return result;
+}
+
+export function fromServiceDependency<_embedded = _i_EntityRef.Cap>(_v: ServiceDependency<_embedded>): _.Value<_embedded> {
+    return _.Record(__lit8, [_v["depender"], fromServiceState<_embedded>(_v["dependee"])]);
+}
+
+export function asCoreService<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): CoreService<_embedded> {
+    let result = toCoreService(v);
+    if (result === void 0) throw new TypeError(`Invalid CoreService: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toCoreService<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | CoreService<_embedded> {
+    let result: undefined | CoreService<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit9) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_.Value<_embedded>) | undefined;
+            _tmp1 = v[0];
+            if (_tmp1 !== void 0) {result = {"serviceName": _tmp1};};
+        };
+    };
+    return result;
+}
+
+export function fromCoreService<_embedded = _i_EntityRef.Cap>(_v: CoreService<_embedded>): _.Value<_embedded> {return _.Record(__lit9, [_v["serviceName"]]);}
+

src/gen/simpleChatProtocol.ts

@@ -1,12 +1,10 @@
 import * as _ from "@preserves/core";
-import * as _i_Actor from "../runtime/actor";
+import * as _i_EntityRef from "../runtime/actor";
 
 export const $Present = Symbol.for("Present");
 export const $Says = Symbol.for("Says");
 
-export type _embedded = _i_Actor.Ref;
-
-export type _val = _.Value<_embedded>;
+export type _embedded = _i_EntityRef.Cap;
 
 export type Present = {"username": string};
 
@@ -17,15 +15,15 @@ export function Present(username: string): Present {return {"username": username
 
 export function Says({who, what}: {who: string, what: string}): Says {return {"who": who, "what": what};}
 
-export function asPresent(v: _val): Present {
+export function asPresent<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): Present {
     let result = toPresent(v);
     if (result === void 0) throw new TypeError(`Invalid Present: ${_.stringify(v)}`);
     return result;
 }
 
-export function toPresent(v: _val): undefined | Present {
+export function toPresent<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | Present {
     let result: undefined | Present;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
         let _tmp0: (null) | undefined;
         _tmp0 = _.is(v.label, $Present) ? null : void 0;
         if (_tmp0 !== void 0) {
@@ -37,17 +35,17 @@ export function toPresent(v: _val): undefined | Present {
     return result;
 }
 
-export function fromPresent(_v: Present): _val {return _.Record($Present, [_v["username"]]);}
+export function fromPresent<_embedded = _i_EntityRef.Cap>(_v: Present): _.Value<_embedded> {return _.Record($Present, [_v["username"]]);}
 
-export function asSays(v: _val): Says {
+export function asSays<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): Says {
     let result = toSays(v);
     if (result === void 0) throw new TypeError(`Invalid Says: ${_.stringify(v)}`);
     return result;
 }
 
-export function toSays(v: _val): undefined | Says {
+export function toSays<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | Says {
     let result: undefined | Says;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
         let _tmp0: (null) | undefined;
         _tmp0 = _.is(v.label, $Says) ? null : void 0;
         if (_tmp0 !== void 0) {
@@ -63,5 +61,5 @@ export function toSays(v: _val): undefined | Says {
     return result;
 }
 
-export function fromSays(_v: Says): _val {return _.Record($Says, [_v["who"], _v["what"]]);}
+export function fromSays<_embedded = _i_EntityRef.Cap>(_v: Says): _.Value<_embedded> {return _.Record($Says, [_v["who"], _v["what"]]);}
 

src/gen/stream.ts

@@ -0,0 +1,401 @@
+import * as _ from "@preserves/core";
+import * as _i_EntityRef from "../runtime/actor";
+
+export const $bytes = Symbol.for("bytes");
+export const $credit = Symbol.for("credit");
+export const $crlf = Symbol.for("crlf");
+export const $data = Symbol.for("data");
+export const $eof = Symbol.for("eof");
+export const $error = Symbol.for("error");
+export const $lf = Symbol.for("lf");
+export const $object = Symbol.for("object");
+export const $packet = Symbol.for("packet");
+export const $sink = Symbol.for("sink");
+export const $source = Symbol.for("source");
+export const $unbounded = Symbol.for("unbounded");
+export const __lit0 = Symbol.for("stream-connection");
+export const __lit1 = Symbol.for("stream-listener-ready");
+export const __lit2 = Symbol.for("stream-listener-error");
+
+export type _embedded = _i_EntityRef.Cap;
+
+export type StreamConnection<_embedded = _i_EntityRef.Cap> = {"source": _embedded, "sink": _embedded, "spec": _.Value<_embedded>};
+
+export type StreamListenerReady<_embedded = _i_EntityRef.Cap> = {"spec": _.Value<_embedded>};
+
+export type StreamListenerError<_embedded = _i_EntityRef.Cap> = {"spec": _.Value<_embedded>, "message": string};
+
+export type StreamError = {"message": string};
+
+export type Source<_embedded = _i_EntityRef.Cap> = (
+    {"_variant": "sink", "controller": _embedded} |
+    {"_variant": "StreamError", "value": StreamError} |
+    {"_variant": "credit", "amount": CreditAmount, "mode": Mode<_embedded>}
+);
+
+export type Sink<_embedded = _i_EntityRef.Cap> = (
+    {"_variant": "source", "controller": _embedded} |
+    {"_variant": "StreamError", "value": StreamError} |
+    {"_variant": "data", "payload": _.Value<_embedded>, "mode": Mode<_embedded>} |
+    {"_variant": "eof"}
+);
+
+export type CreditAmount = ({"_variant": "count", "value": number} | {"_variant": "unbounded"});
+
+export type Mode<_embedded = _i_EntityRef.Cap> = (
+    {"_variant": "bytes"} |
+    {"_variant": "lines", "value": LineMode} |
+    {"_variant": "packet", "size": number} |
+    {"_variant": "object", "description": _.Value<_embedded>}
+);
+
+export type LineMode = ({"_variant": "lf"} | {"_variant": "crlf"});
+
+
+export function StreamConnection<_embedded = _i_EntityRef.Cap>(
+    {source, sink, spec}: {source: _embedded, sink: _embedded, spec: _.Value<_embedded>}
+): StreamConnection<_embedded> {return {"source": source, "sink": sink, "spec": spec};}
+
+export function StreamListenerReady<_embedded = _i_EntityRef.Cap>(spec: _.Value<_embedded>): StreamListenerReady<_embedded> {return {"spec": spec};}
+
+export function StreamListenerError<_embedded = _i_EntityRef.Cap>({spec, message}: {spec: _.Value<_embedded>, message: string}): StreamListenerError<_embedded> {return {"spec": spec, "message": message};}
+
+export function StreamError(message: string): StreamError {return {"message": message};}
+
+export namespace Source {
+    export function sink<_embedded = _i_EntityRef.Cap>(controller: _embedded): Source<_embedded> {return {"_variant": "sink", "controller": controller};};
+    export function StreamError<_embedded = _i_EntityRef.Cap>(value: StreamError): Source<_embedded> {return {"_variant": "StreamError", "value": value};};
+    export function credit<_embedded = _i_EntityRef.Cap>({amount, mode}: {amount: CreditAmount, mode: Mode<_embedded>}): Source<_embedded> {return {"_variant": "credit", "amount": amount, "mode": mode};};
+}
+
+export namespace Sink {
+    export function source<_embedded = _i_EntityRef.Cap>(controller: _embedded): Sink<_embedded> {return {"_variant": "source", "controller": controller};};
+    export function StreamError<_embedded = _i_EntityRef.Cap>(value: StreamError): Sink<_embedded> {return {"_variant": "StreamError", "value": value};};
+    export function data<_embedded = _i_EntityRef.Cap>({payload, mode}: {payload: _.Value<_embedded>, mode: Mode<_embedded>}): Sink<_embedded> {return {"_variant": "data", "payload": payload, "mode": mode};};
+    export function eof<_embedded = _i_EntityRef.Cap>(): Sink<_embedded> {return {"_variant": "eof"};};
+}
+
+export namespace CreditAmount {
+    export function count(value: number): CreditAmount {return {"_variant": "count", "value": value};};
+    export function unbounded(): CreditAmount {return {"_variant": "unbounded"};};
+}
+
+export namespace Mode {
+    export function bytes<_embedded = _i_EntityRef.Cap>(): Mode<_embedded> {return {"_variant": "bytes"};};
+    export function lines<_embedded = _i_EntityRef.Cap>(value: LineMode): Mode<_embedded> {return {"_variant": "lines", "value": value};};
+    export function packet<_embedded = _i_EntityRef.Cap>(size: number): Mode<_embedded> {return {"_variant": "packet", "size": size};};
+    export function object<_embedded = _i_EntityRef.Cap>(description: _.Value<_embedded>): Mode<_embedded> {return {"_variant": "object", "description": description};};
+}
+
+export namespace LineMode {
+    export function lf(): LineMode {return {"_variant": "lf"};};
+    export function crlf(): LineMode {return {"_variant": "crlf"};};
+}
+
+export function asStreamConnection<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): StreamConnection<_embedded> {
+    let result = toStreamConnection(v);
+    if (result === void 0) throw new TypeError(`Invalid StreamConnection: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toStreamConnection<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | StreamConnection<_embedded> {
+    let result: undefined | StreamConnection<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit0) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_embedded) | undefined;
+            _tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0;
+            if (_tmp1 !== void 0) {
+                let _tmp2: (_embedded) | undefined;
+                _tmp2 = _.isEmbedded<_embedded>(v[1]) ? v[1].embeddedValue : void 0;
+                if (_tmp2 !== void 0) {
+                    let _tmp3: (_.Value<_embedded>) | undefined;
+                    _tmp3 = v[2];
+                    if (_tmp3 !== void 0) {result = {"source": _tmp1, "sink": _tmp2, "spec": _tmp3};};
+                };
+            };
+        };
+    };
+    return result;
+}
+
+export function fromStreamConnection<_embedded = _i_EntityRef.Cap>(_v: StreamConnection<_embedded>): _.Value<_embedded> {
+    return _.Record(__lit0, [_.embed(_v["source"]), _.embed(_v["sink"]), _v["spec"]]);
+}
+
+export function asStreamListenerReady<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): StreamListenerReady<_embedded> {
+    let result = toStreamListenerReady(v);
+    if (result === void 0) throw new TypeError(`Invalid StreamListenerReady: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toStreamListenerReady<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | StreamListenerReady<_embedded> {
+    let result: undefined | StreamListenerReady<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit1) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_.Value<_embedded>) | undefined;
+            _tmp1 = v[0];
+            if (_tmp1 !== void 0) {result = {"spec": _tmp1};};
+        };
+    };
+    return result;
+}
+
+export function fromStreamListenerReady<_embedded = _i_EntityRef.Cap>(_v: StreamListenerReady<_embedded>): _.Value<_embedded> {return _.Record(__lit1, [_v["spec"]]);}
+
+export function asStreamListenerError<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): StreamListenerError<_embedded> {
+    let result = toStreamListenerError(v);
+    if (result === void 0) throw new TypeError(`Invalid StreamListenerError: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toStreamListenerError<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | StreamListenerError<_embedded> {
+    let result: undefined | StreamListenerError<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit2) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_.Value<_embedded>) | undefined;
+            _tmp1 = v[0];
+            if (_tmp1 !== void 0) {
+                let _tmp2: (string) | undefined;
+                _tmp2 = typeof v[1] === 'string' ? v[1] : void 0;
+                if (_tmp2 !== void 0) {result = {"spec": _tmp1, "message": _tmp2};};
+            };
+        };
+    };
+    return result;
+}
+
+export function fromStreamListenerError<_embedded = _i_EntityRef.Cap>(_v: StreamListenerError<_embedded>): _.Value<_embedded> {return _.Record(__lit2, [_v["spec"], _v["message"]]);}
+
+export function asStreamError<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): StreamError {
+    let result = toStreamError(v);
+    if (result === void 0) throw new TypeError(`Invalid StreamError: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toStreamError<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | StreamError {
+    let result: undefined | StreamError;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, $error) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (string) | undefined;
+            _tmp1 = typeof v[0] === 'string' ? v[0] : void 0;
+            if (_tmp1 !== void 0) {result = {"message": _tmp1};};
+        };
+    };
+    return result;
+}
+
+export function fromStreamError<_embedded = _i_EntityRef.Cap>(_v: StreamError): _.Value<_embedded> {return _.Record($error, [_v["message"]]);}
+
+export function asSource<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): Source<_embedded> {
+    let result = toSource(v);
+    if (result === void 0) throw new TypeError(`Invalid Source: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toSource<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | Source<_embedded> {
+    let result: undefined | Source<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, $sink) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_embedded) | undefined;
+            _tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0;
+            if (_tmp1 !== void 0) {result = {"_variant": "sink", "controller": _tmp1};};
+        };
+    };
+    if (result === void 0) {
+        let _tmp2: (StreamError) | undefined;
+        _tmp2 = toStreamError(v);
+        if (_tmp2 !== void 0) {result = {"_variant": "StreamError", "value": _tmp2};};
+        if (result === void 0) {
+            if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+                let _tmp3: (null) | undefined;
+                _tmp3 = _.is(v.label, $credit) ? null : void 0;
+                if (_tmp3 !== void 0) {
+                    let _tmp4: (CreditAmount) | undefined;
+                    _tmp4 = toCreditAmount(v[0]);
+                    if (_tmp4 !== void 0) {
+                        let _tmp5: (Mode<_embedded>) | undefined;
+                        _tmp5 = toMode(v[1]);
+                        if (_tmp5 !== void 0) {result = {"_variant": "credit", "amount": _tmp4, "mode": _tmp5};};
+                    };
+                };
+            };
+        };
+    };
+    return result;
+}
+
+export function fromSource<_embedded = _i_EntityRef.Cap>(_v: Source<_embedded>): _.Value<_embedded> {
+    switch (_v._variant) {
+        case "sink": {return _.Record($sink, [_.embed(_v["controller"])]);};
+        case "StreamError": {return fromStreamError<_embedded>(_v.value);};
+        case "credit": {
+            return _.Record(
+                $credit,
+                [fromCreditAmount<_embedded>(_v["amount"]), fromMode<_embedded>(_v["mode"])]
+            );
+        };
+    };
+}
+
+export function asSink<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): Sink<_embedded> {
+    let result = toSink(v);
+    if (result === void 0) throw new TypeError(`Invalid Sink: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toSink<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | Sink<_embedded> {
+    let result: undefined | Sink<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, $source) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_embedded) | undefined;
+            _tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0;
+            if (_tmp1 !== void 0) {result = {"_variant": "source", "controller": _tmp1};};
+        };
+    };
+    if (result === void 0) {
+        let _tmp2: (StreamError) | undefined;
+        _tmp2 = toStreamError(v);
+        if (_tmp2 !== void 0) {result = {"_variant": "StreamError", "value": _tmp2};};
+        if (result === void 0) {
+            if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+                let _tmp3: (null) | undefined;
+                _tmp3 = _.is(v.label, $data) ? null : void 0;
+                if (_tmp3 !== void 0) {
+                    let _tmp4: (_.Value<_embedded>) | undefined;
+                    _tmp4 = v[0];
+                    if (_tmp4 !== void 0) {
+                        let _tmp5: (Mode<_embedded>) | undefined;
+                        _tmp5 = toMode(v[1]);
+                        if (_tmp5 !== void 0) {result = {"_variant": "data", "payload": _tmp4, "mode": _tmp5};};
+                    };
+                };
+            };
+            if (result === void 0) {
+                if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+                    let _tmp6: (null) | undefined;
+                    _tmp6 = _.is(v.label, $eof) ? null : void 0;
+                    if (_tmp6 !== void 0) {result = {"_variant": "eof"};};
+                };
+            };
+        };
+    };
+    return result;
+}
+
+export function fromSink<_embedded = _i_EntityRef.Cap>(_v: Sink<_embedded>): _.Value<_embedded> {
+    switch (_v._variant) {
+        case "source": {return _.Record($source, [_.embed(_v["controller"])]);};
+        case "StreamError": {return fromStreamError<_embedded>(_v.value);};
+        case "data": {return _.Record($data, [_v["payload"], fromMode<_embedded>(_v["mode"])]);};
+        case "eof": {return _.Record($eof, []);};
+    };
+}
+
+export function asCreditAmount<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): CreditAmount {
+    let result = toCreditAmount(v);
+    if (result === void 0) throw new TypeError(`Invalid CreditAmount: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toCreditAmount<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | CreditAmount {
+    let _tmp0: (number) | undefined;
+    let result: undefined | CreditAmount;
+    _tmp0 = typeof v === 'number' ? v : void 0;
+    if (_tmp0 !== void 0) {result = {"_variant": "count", "value": _tmp0};};
+    if (result === void 0) {
+        let _tmp1: (null) | undefined;
+        _tmp1 = _.is(v, $unbounded) ? null : void 0;
+        if (_tmp1 !== void 0) {result = {"_variant": "unbounded"};};
+    };
+    return result;
+}
+
+export function fromCreditAmount<_embedded = _i_EntityRef.Cap>(_v: CreditAmount): _.Value<_embedded> {
+    switch (_v._variant) {case "count": {return _v.value;}; case "unbounded": {return $unbounded;};};
+}
+
+export function asMode<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): Mode<_embedded> {
+    let result = toMode(v);
+    if (result === void 0) throw new TypeError(`Invalid Mode: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toMode<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | Mode<_embedded> {
+    let _tmp0: (null) | undefined;
+    let result: undefined | Mode<_embedded>;
+    _tmp0 = _.is(v, $bytes) ? null : void 0;
+    if (_tmp0 !== void 0) {result = {"_variant": "bytes"};};
+    if (result === void 0) {
+        let _tmp1: (LineMode) | undefined;
+        _tmp1 = toLineMode(v);
+        if (_tmp1 !== void 0) {result = {"_variant": "lines", "value": _tmp1};};
+        if (result === void 0) {
+            if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+                let _tmp2: (null) | undefined;
+                _tmp2 = _.is(v.label, $packet) ? null : void 0;
+                if (_tmp2 !== void 0) {
+                    let _tmp3: (number) | undefined;
+                    _tmp3 = typeof v[0] === 'number' ? v[0] : void 0;
+                    if (_tmp3 !== void 0) {result = {"_variant": "packet", "size": _tmp3};};
+                };
+            };
+            if (result === void 0) {
+                if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+                    let _tmp4: (null) | undefined;
+                    _tmp4 = _.is(v.label, $object) ? null : void 0;
+                    if (_tmp4 !== void 0) {
+                        let _tmp5: (_.Value<_embedded>) | undefined;
+                        _tmp5 = v[0];
+                        if (_tmp5 !== void 0) {result = {"_variant": "object", "description": _tmp5};};
+                    };
+                };
+            };
+        };
+    };
+    return result;
+}
+
+export function fromMode<_embedded = _i_EntityRef.Cap>(_v: Mode<_embedded>): _.Value<_embedded> {
+    switch (_v._variant) {
+        case "bytes": {return $bytes;};
+        case "lines": {return fromLineMode<_embedded>(_v.value);};
+        case "packet": {return _.Record($packet, [_v["size"]]);};
+        case "object": {return _.Record($object, [_v["description"]]);};
+    };
+}
+
+export function asLineMode<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): LineMode {
+    let result = toLineMode(v);
+    if (result === void 0) throw new TypeError(`Invalid LineMode: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toLineMode<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | LineMode {
+    let _tmp0: (null) | undefined;
+    let result: undefined | LineMode;
+    _tmp0 = _.is(v, $lf) ? null : void 0;
+    if (_tmp0 !== void 0) {result = {"_variant": "lf"};};
+    if (result === void 0) {
+        let _tmp1: (null) | undefined;
+        _tmp1 = _.is(v, $crlf) ? null : void 0;
+        if (_tmp1 !== void 0) {result = {"_variant": "crlf"};};
+    };
+    return result;
+}
+
+export function fromLineMode<_embedded = _i_EntityRef.Cap>(_v: LineMode): _.Value<_embedded> {
+    switch (_v._variant) {case "lf": {return $lf;}; case "crlf": {return $crlf;};};
+}
+

src/gen/tcp.ts

@@ -0,0 +1,115 @@
+import * as _ from "@preserves/core";
+import * as _i_EntityRef from "../runtime/actor";
+
+export const __lit0 = Symbol.for("tcp-remote");
+export const __lit1 = Symbol.for("tcp-local");
+export const __lit2 = Symbol.for("tcp-peer");
+
+export type _embedded = _i_EntityRef.Cap;
+
+export type TcpRemote = {"host": string, "port": number};
+
+export type TcpLocal = {"host": string, "port": number};
+
+export type TcpPeerInfo<_embedded = _i_EntityRef.Cap> = {"handle": _embedded, "local": TcpLocal, "remote": TcpRemote};
+
+
+export function TcpRemote({host, port}: {host: string, port: number}): TcpRemote {return {"host": host, "port": port};}
+
+export function TcpLocal({host, port}: {host: string, port: number}): TcpLocal {return {"host": host, "port": port};}
+
+export function TcpPeerInfo<_embedded = _i_EntityRef.Cap>(
+    {handle, local, remote}: {handle: _embedded, local: TcpLocal, remote: TcpRemote}
+): TcpPeerInfo<_embedded> {return {"handle": handle, "local": local, "remote": remote};}
+
+export function asTcpRemote<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): TcpRemote {
+    let result = toTcpRemote(v);
+    if (result === void 0) throw new TypeError(`Invalid TcpRemote: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toTcpRemote<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | TcpRemote {
+    let result: undefined | TcpRemote;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit0) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (string) | undefined;
+            _tmp1 = typeof v[0] === 'string' ? v[0] : void 0;
+            if (_tmp1 !== void 0) {
+                let _tmp2: (number) | undefined;
+                _tmp2 = typeof v[1] === 'number' ? v[1] : void 0;
+                if (_tmp2 !== void 0) {result = {"host": _tmp1, "port": _tmp2};};
+            };
+        };
+    };
+    return result;
+}
+
+export function fromTcpRemote<_embedded = _i_EntityRef.Cap>(_v: TcpRemote): _.Value<_embedded> {return _.Record(__lit0, [_v["host"], _v["port"]]);}
+
+export function asTcpLocal<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): TcpLocal {
+    let result = toTcpLocal(v);
+    if (result === void 0) throw new TypeError(`Invalid TcpLocal: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toTcpLocal<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | TcpLocal {
+    let result: undefined | TcpLocal;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit1) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (string) | undefined;
+            _tmp1 = typeof v[0] === 'string' ? v[0] : void 0;
+            if (_tmp1 !== void 0) {
+                let _tmp2: (number) | undefined;
+                _tmp2 = typeof v[1] === 'number' ? v[1] : void 0;
+                if (_tmp2 !== void 0) {result = {"host": _tmp1, "port": _tmp2};};
+            };
+        };
+    };
+    return result;
+}
+
+export function fromTcpLocal<_embedded = _i_EntityRef.Cap>(_v: TcpLocal): _.Value<_embedded> {return _.Record(__lit1, [_v["host"], _v["port"]]);}
+
+export function asTcpPeerInfo<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): TcpPeerInfo<_embedded> {
+    let result = toTcpPeerInfo(v);
+    if (result === void 0) throw new TypeError(`Invalid TcpPeerInfo: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toTcpPeerInfo<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | TcpPeerInfo<_embedded> {
+    let result: undefined | TcpPeerInfo<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit2) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_embedded) | undefined;
+            _tmp1 = _.isEmbedded<_embedded>(v[0]) ? v[0].embeddedValue : void 0;
+            if (_tmp1 !== void 0) {
+                let _tmp2: (TcpLocal) | undefined;
+                _tmp2 = toTcpLocal(v[1]);
+                if (_tmp2 !== void 0) {
+                    let _tmp3: (TcpRemote) | undefined;
+                    _tmp3 = toTcpRemote(v[2]);
+                    if (_tmp3 !== void 0) {result = {"handle": _tmp1, "local": _tmp2, "remote": _tmp3};};
+                };
+            };
+        };
+    };
+    return result;
+}
+
+export function fromTcpPeerInfo<_embedded = _i_EntityRef.Cap>(_v: TcpPeerInfo<_embedded>): _.Value<_embedded> {
+    return _.Record(
+        __lit2,
+        [
+            _.embed(_v["handle"]),
+            fromTcpLocal<_embedded>(_v["local"]),
+            fromTcpRemote<_embedded>(_v["remote"])
+        ]
+    );
+}
+

src/gen/timer.ts

@@ -0,0 +1,147 @@
+import * as _ from "@preserves/core";
+
+export const $absolute = Symbol.for("absolute");
+export const $clear = Symbol.for("clear");
+export const $relative = Symbol.for("relative");
+export const __lit0 = Symbol.for("set-timer");
+export const __lit1 = Symbol.for("timer-expired");
+export const __lit5 = Symbol.for("later-than");
+
+export type SetTimer<_embedded = _.GenericEmbedded> = {"label": _.Value<_embedded>, "msecs": number, "kind": TimerKind};
+
+export type TimerExpired<_embedded = _.GenericEmbedded> = {"label": _.Value<_embedded>, "msecs": number};
+
+export type TimerKind = ({"_variant": "relative"} | {"_variant": "absolute"} | {"_variant": "clear"});
+
+export type LaterThan = {"msecs": number};
+
+
+export function SetTimer<_embedded = _.GenericEmbedded>(
+    {label, msecs, kind}: {label: _.Value<_embedded>, msecs: number, kind: TimerKind}
+): SetTimer<_embedded> {return {"label": label, "msecs": msecs, "kind": kind};}
+
+export function TimerExpired<_embedded = _.GenericEmbedded>({label, msecs}: {label: _.Value<_embedded>, msecs: number}): TimerExpired<_embedded> {return {"label": label, "msecs": msecs};}
+
+export namespace TimerKind {
+    export function relative(): TimerKind {return {"_variant": "relative"};};
+    export function absolute(): TimerKind {return {"_variant": "absolute"};};
+    export function clear(): TimerKind {return {"_variant": "clear"};};
+}
+
+export function LaterThan(msecs: number): LaterThan {return {"msecs": msecs};}
+
+export function asSetTimer<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): SetTimer<_embedded> {
+    let result = toSetTimer(v);
+    if (result === void 0) throw new TypeError(`Invalid SetTimer: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toSetTimer<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | SetTimer<_embedded> {
+    let result: undefined | SetTimer<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit0) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_.Value<_embedded>) | undefined;
+            _tmp1 = v[0];
+            if (_tmp1 !== void 0) {
+                let _tmp2: (number) | undefined;
+                _tmp2 = _.Float.isDouble(v[1]) ? v[1].value : void 0;
+                if (_tmp2 !== void 0) {
+                    let _tmp3: (TimerKind) | undefined;
+                    _tmp3 = toTimerKind(v[2]);
+                    if (_tmp3 !== void 0) {result = {"label": _tmp1, "msecs": _tmp2, "kind": _tmp3};};
+                };
+            };
+        };
+    };
+    return result;
+}
+
+export function fromSetTimer<_embedded = _.GenericEmbedded>(_v: SetTimer<_embedded>): _.Value<_embedded> {
+    return _.Record(
+        __lit0,
+        [_v["label"], _.Double(_v["msecs"]), fromTimerKind<_embedded>(_v["kind"])]
+    );
+}
+
+export function asTimerExpired<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): TimerExpired<_embedded> {
+    let result = toTimerExpired(v);
+    if (result === void 0) throw new TypeError(`Invalid TimerExpired: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toTimerExpired<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | TimerExpired<_embedded> {
+    let result: undefined | TimerExpired<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit1) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (_.Value<_embedded>) | undefined;
+            _tmp1 = v[0];
+            if (_tmp1 !== void 0) {
+                let _tmp2: (number) | undefined;
+                _tmp2 = _.Float.isDouble(v[1]) ? v[1].value : void 0;
+                if (_tmp2 !== void 0) {result = {"label": _tmp1, "msecs": _tmp2};};
+            };
+        };
+    };
+    return result;
+}
+
+export function fromTimerExpired<_embedded = _.GenericEmbedded>(_v: TimerExpired<_embedded>): _.Value<_embedded> {return _.Record(__lit1, [_v["label"], _.Double(_v["msecs"])]);}
+
+export function asTimerKind<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): TimerKind {
+    let result = toTimerKind(v);
+    if (result === void 0) throw new TypeError(`Invalid TimerKind: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toTimerKind<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | TimerKind {
+    let _tmp0: (null) | undefined;
+    let result: undefined | TimerKind;
+    _tmp0 = _.is(v, $relative) ? null : void 0;
+    if (_tmp0 !== void 0) {result = {"_variant": "relative"};};
+    if (result === void 0) {
+        let _tmp1: (null) | undefined;
+        _tmp1 = _.is(v, $absolute) ? null : void 0;
+        if (_tmp1 !== void 0) {result = {"_variant": "absolute"};};
+        if (result === void 0) {
+            let _tmp2: (null) | undefined;
+            _tmp2 = _.is(v, $clear) ? null : void 0;
+            if (_tmp2 !== void 0) {result = {"_variant": "clear"};};
+        };
+    };
+    return result;
+}
+
+export function fromTimerKind<_embedded = _.GenericEmbedded>(_v: TimerKind): _.Value<_embedded> {
+    switch (_v._variant) {
+        case "relative": {return $relative;};
+        case "absolute": {return $absolute;};
+        case "clear": {return $clear;};
+    };
+}
+
+export function asLaterThan<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): LaterThan {
+    let result = toLaterThan(v);
+    if (result === void 0) throw new TypeError(`Invalid LaterThan: ${_.stringify(v)}`);
+    return result;
+}
+
+export function toLaterThan<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | LaterThan {
+    let result: undefined | LaterThan;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: (null) | undefined;
+        _tmp0 = _.is(v.label, __lit5) ? null : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (number) | undefined;
+            _tmp1 = _.Float.isDouble(v[0]) ? v[0].value : void 0;
+            if (_tmp1 !== void 0) {result = {"msecs": _tmp1};};
+        };
+    };
+    return result;
+}
+
+export function fromLaterThan<_embedded = _.GenericEmbedded>(_v: LaterThan): _.Value<_embedded> {return _.Record(__lit5, [_.Double(_v["msecs"])]);}
+

src/gen/worker.ts

@@ -1,33 +1,31 @@
 import * as _ from "@preserves/core";
-import * as _i_Actor from "../runtime/actor";
+import * as _i_EntityRef from "../runtime/actor";
 
 export const $Instance = Symbol.for("Instance");
 
-export type _embedded = _i_Actor.Ref;
+export type _embedded = _i_EntityRef.Cap;
 
-export type _val = _.Value<_embedded>;
-
-export type Instance = {"name": string, "argument": _val};
+export type Instance<_embedded = _i_EntityRef.Cap> = {"name": string, "argument": _.Value<_embedded>};
 
 
-export function Instance({name, argument}: {name: string, argument: _val}): Instance {return {"name": name, "argument": argument};}
+export function Instance<_embedded = _i_EntityRef.Cap>({name, argument}: {name: string, argument: _.Value<_embedded>}): Instance<_embedded> {return {"name": name, "argument": argument};}
 
-export function asInstance(v: _val): Instance {
+export function asInstance<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): Instance<_embedded> {
     let result = toInstance(v);
     if (result === void 0) throw new TypeError(`Invalid Instance: ${_.stringify(v)}`);
     return result;
 }
 
-export function toInstance(v: _val): undefined | Instance {
-    let result: undefined | Instance;
-    if (_.Record.isRecord<_val, _.Tuple<_val>, _embedded>(v)) {
+export function toInstance<_embedded = _i_EntityRef.Cap>(v: _.Value<_embedded>): undefined | Instance<_embedded> {
+    let result: undefined | Instance<_embedded>;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
         let _tmp0: (null) | undefined;
         _tmp0 = _.is(v.label, $Instance) ? null : void 0;
         if (_tmp0 !== void 0) {
             let _tmp1: (string) | undefined;
             _tmp1 = typeof v[0] === 'string' ? v[0] : void 0;
             if (_tmp1 !== void 0) {
-                let _tmp2: (_val) | undefined;
+                let _tmp2: (_.Value<_embedded>) | undefined;
                 _tmp2 = v[1];
                 if (_tmp2 !== void 0) {result = {"name": _tmp1, "argument": _tmp2};};
             };
@@ -36,5 +34,5 @@ export function toInstance(v: _val): undefined | Instance {
     return result;
 }
 
-export function fromInstance(_v: Instance): _val {return _.Record($Instance, [_v["name"], _v["argument"]]);}
+export function fromInstance<_embedded = _i_EntityRef.Cap>(_v: Instance<_embedded>): _.Value<_embedded> {return _.Record($Instance, [_v["name"], _v["argument"]]);}
 

src/runtime/actor.ts

@@ -2,6 +2,8 @@ import { IdentitySet, Value } from '@preserves/core';
 import { Attenuation, runRewrites } from './rewrite.js';
 import { queueTask } from './task.js';
 
+export type AnyValue = Value<Ref>;
+
 //---------------------------------------------------------------------------
 
 if ('stackTraceLimit' in Error) {
@@ -20,6 +22,8 @@ export interface Entity {
     sync(turn: Turn, peer: Ref): void;
 }
 
+export type Cap = Ref;
+
 export interface Ref {
     readonly relay: Facet;
     readonly target: Partial<Entity>;

src/runtime/dataspace.ts

@@ -1,9 +1,11 @@
-import { Assertion, Entity, Handle, LocalAction, Ref, Turn } from 'runtime/actor';
-import { Dictionary, IdentityMap, is, Record, Tuple } from '@preserves/core';
-import { Bag, ChangeDescription } from './bag';
+import { KeyedDictionary, preserves } from '@preserves/core';
+import { AnyValue, Assertion, Entity, Handle, LocalAction, Ref, Turn } from 'runtime/actor';
 
-import { fromObserve, toObserve, Observe } from '../gen/dataspace';
-export * from '../gen/dataspace';
+import { fromObserve, Observe } from '../gen/dataspace';
+import { DBind, DDiscard, DLit, Pattern, DCompound, CArr, CDict, CRec } from '../gen/dataspacePatterns';
+
+export { asObserve, fromObserve, toObserve, Observe, $Observe } from '../gen/dataspace';
+export * from '../gen/dataspacePatterns';
 
 // Q. Why keep "Observe"? Why not do the clever trick of asserting the
 // observer, and having the dataspace read the implicit pattern it's
@@ -36,54 +38,19 @@ export * from '../gen/dataspace';
 // spurious variation.
 
 export class Dataspace implements Partial<Entity> {
-    readonly handleMap: IdentityMap<Handle, Record<Assertion, any, Ref>> = new IdentityMap();
-    readonly assertions = new Bag<Ref>();
-    readonly subscriptions = new Dictionary<Ref, Map<Ref, Dictionary<Ref, Handle>>>();
-
     assert(turn: Turn, rec: Assertion, handle: Handle): void {
-        // console.log(preserves`ds ${turn.activeFacet.id} assert ${rec} ${handle}`);
-        if (!Record.isRecord<Assertion, Tuple<Assertion>, Ref>(rec)) return;
-        this.handleMap.set(handle, rec);
-        if (this.assertions.change(rec, +1) !== ChangeDescription.ABSENT_TO_PRESENT) return;
-        {
-            const o = toObserve(rec);
-            if (o !== void 0) {
-                const seen = new Dictionary<Ref, Handle>();
-                if (!this.subscriptions.has(o.label)) this.subscriptions.set(o.label, new Map());
-                this.subscriptions.get(o.label)!.set(o.observer, seen);
-                this.assertions.forEach((_count, prev) =>
-                    is((prev as Record<Assertion, any, Ref>).label, o.label)
-                    && seen.set(prev, turn.assert(o.observer, prev)));
-            }
-        }
-        this.subscriptions.get(rec.label)?.forEach((seen, peer) =>
-            seen.has(rec) || seen.set(rec, turn.assert(peer, rec)));
+        console.log(preserves`ds ${turn.activeFacet.id} assert ${rec} ${handle}`);
+        throw new Error("Full dataspaces not implemented");
     }
 
     retract(turn: Turn, upstreamHandle: Handle): void {
-        const rec = this.handleMap.get(upstreamHandle);
-        // console.log(preserves`ds ${turn.activeFacet.id} retract ${rec} ${upstreamHandle}`);
-        if (rec === void 0) return;
-        this.handleMap.delete(upstreamHandle);
-        if (this.assertions.change(rec, -1) !== ChangeDescription.PRESENT_TO_ABSENT) return;
-        this.subscriptions.get(rec.label)?.forEach((seen, _peer) => {
-            turn.retract(seen.get(rec));
-            seen.delete(rec);
-        });
-        {
-            const o = toObserve(rec);
-            if (o !== void 0) {
-                let peerMap = this.subscriptions.get(o.label)!;
-                peerMap.delete(o.observer);
-                if (peerMap.size === 0) this.subscriptions.delete(o.label);
-            }
-        }
+        console.log(preserves`ds ${turn.activeFacet.id} retract ${upstreamHandle}`);
+        throw new Error("Full dataspaces not implemented");
     }
 
     message(turn: Turn, rec: Assertion): void {
-        // console.log(preserves`ds ${turn.activeFacet.id} message ${rec}`);
-        if (!Record.isRecord<Assertion, Tuple<Assertion>, Ref>(rec)) return;
-        this.subscriptions.get(rec.label)?.forEach((_seen, peer) => turn.message(peer, rec));
+        console.log(preserves`ds ${turn.activeFacet.id} message ${rec}`);
+        throw new Error("Full dataspaces not implemented");
     }
 }
 
@@ -124,6 +91,46 @@ export function during(f: (t: Turn, a: Assertion) => Promise<LocalAction | null>
     };
 }
 
-export function observe(t: Turn, ds: Ref, label: symbol, e: Partial<Entity>): Handle {
-    return t.assert(ds, fromObserve(Observe({ label, observer: t.ref(e) })));
+export function observe(t: Turn, ds: Ref, pattern: Pattern, e: Partial<Entity>): Handle {
+    return t.assert(ds, fromObserve(Observe({ pattern, observer: t.ref(e) })));
+}
+
+export namespace P {
+    export function discard(): Pattern {
+        return Pattern.DDiscard(DDiscard());
+    }
+    export function bind(pattern: Pattern = discard()): Pattern {
+        return Pattern.DBind(DBind(pattern));
+    }
+    export function lit(value: AnyValue): Pattern {
+        return Pattern.DLit(DLit(value));
+    }
+    export function rec(label: AnyValue, ...fields: Pattern[]): Pattern {
+        const members = new KeyedDictionary<number, Pattern, Ref>();
+        fields.forEach((f, i) => {
+            if (f._variant !== 'DDiscard') members.set(i, f);
+        });
+        return Pattern.DCompound(DCompound.rec({
+            ctor: CRec({ label, arity: fields.length }),
+            members,
+        }));
+    }
+    export function arr(...entries: Pattern[]): Pattern {
+        const members = new KeyedDictionary<number, Pattern, Ref>();
+        entries.forEach((f, i) => {
+            if (f._variant !== 'DDiscard') members.set(i, f);
+        });
+        return Pattern.DCompound(DCompound.arr({
+            ctor: CArr(entries.length),
+            members,
+        }));
+    }
+    export function dict(...entries: [AnyValue, Pattern][]): Pattern {
+        const members = new KeyedDictionary<AnyValue, Pattern, Ref>();
+        entries.forEach(([k, p]) => members.set(k, p));
+        return Pattern.DCompound(DCompound.dict({
+            ctor: CDict(),
+            members,
+        }));
+    }
 }

src/runtime/rewrite.ts

@@ -1,5 +1,6 @@
 import type { Assertion, Handle, Ref, Turn } from "./actor.js";
 import { Bytes, Dictionary, DoubleFloat, embed, IdentityMap, is, isEmbedded, Record, SingleFloat, Tuple } from "@preserves/core";
+import { SturdyValue } from "../transport/sturdy.js";
 
 import {
     Alts,
@@ -22,15 +23,14 @@ import {
     Rewrite,
     TRef,
     Template,
-    _val,
     _embedded,
 } from '../gen/sturdy.js';
 export * from '../gen/sturdy.js';
 
-export type Bindings = { [name: string]: Assertion };
+export type Bindings = Array<Assertion>;
 
 export function match(p: Pattern, v: Assertion): Bindings | null {
-    let bindings: Bindings = {};
+    let bindings: Bindings = [];
 
     function walk(p: Pattern, v: Assertion): boolean {
         switch (p._variant) {
@@ -50,7 +50,7 @@ export function match(p: Pattern, v: Assertion): Bindings | null {
                 return isEmbedded(v);
             case 'PBind':
                 if (walk(p.value.pattern, v)) {
-                    bindings[p.value.name.asPreservesText()] = v;
+                    bindings.push(v);
                     return true;
                 }
                 return false;
@@ -61,7 +61,7 @@ export function match(p: Pattern, v: Assertion): Bindings | null {
                 return true;
             case 'PNot': {
                 const savedBindings = bindings;
-                bindings = {};
+                bindings = [];
                 const result = !walk(p.value.pattern, v)
                 bindings = savedBindings;
                 return result;
@@ -121,7 +121,7 @@ export function instantiate(t: Template, b: Bindings): Assertion {
                 return embed(attenuate(r, ... t.value.attenuation));
             }
             case 'TRef': {
-                const n = t.value.name.asPreservesText()
+                const n = t.value.binding;
                 const v = b[n];
                 if (v === void 0) throw new Error(`Unbound reference: ${n}`);
                 return v;
@@ -193,12 +193,10 @@ export function runRewrites(a: Attenuation | undefined, v: Assertion): Assertion
     return v;
 }
 
-const _a = Symbol.for('a');
-
 export function rfilter(... patterns: Pattern[]): Caveat {
     const ps = patterns.map(p => Rewrite({
-        pattern: Pattern.PBind(PBind({ name: _a, pattern: p })),
-        template: Template.TRef(TRef(_a))
+        pattern: Pattern.PBind(PBind(p)),
+        template: Template.TRef(TRef(0))
     }));
     return ps.length === 1 ? Caveat.Rewrite(ps[0]) : Caveat.Alts(Alts(ps));
 }
@@ -239,7 +237,7 @@ export function forwarder(t: Turn, ref: Ref): { proxy: Ref, revoker: Ref } {
     return { proxy, revoker };
 }
 
-export function pRec(label: _val, ... members: Array<Pattern>): Pattern {
+export function pRec(label: SturdyValue, ... members: Array<Pattern>): Pattern {
     return Pattern.PCompound(PCompound({
         ctor: ConstructorSpec.CRec(CRec({ label: label, arity: members.length })),
         members: PCompoundMembers(new Dictionary<_embedded, Pattern>(
@@ -253,13 +251,13 @@ export function pArr(... members: Array<Pattern>): Pattern {
             members.map((p, i) => [i, p] as const).filter(e => e[1]._variant !== 'PDiscard')))}));
 }
 
-export function pDict(... entries: [_val, Pattern][]): Pattern {
+export function pDict(... entries: [SturdyValue, Pattern][]): Pattern {
     return Pattern.PCompound(PCompound({
         ctor: ConstructorSpec.CDict(CDict()),
         members: PCompoundMembers(new Dictionary<_embedded, Pattern>(entries))}));
 }
 
-export function pLit(value: _val): Pattern {
+export function pLit(value: SturdyValue): Pattern {
     return Pattern.Lit(Lit(value));
 }
 
@@ -271,8 +269,8 @@ export function pAnd(... ps: Pattern[]): Pattern {
     return Pattern.PAnd(PAnd(ps));
 }
 
-export function pBind(name: symbol, pattern: Pattern): Pattern {
-    return Pattern.PBind(PBind({ name, pattern }));
+export function pBind(pattern: Pattern): Pattern {
+    return Pattern.PBind(PBind(pattern));
 }
 
 export function pEmbedded(): Pattern {

src/transport/protocol.ts

@@ -1,9 +1,9 @@
 import * as S from '../gen/sturdy.js';
-import * as IO from '../gen/protocol.js';
+import { Oid } from '../gen/protocol.js';
 import { Ref } from '../runtime/actor.js';
 import { Decoder, DecoderState, Encoder, EncoderState, GenericEmbedded, neverEmbeddedType, EmbeddedType, Value } from '@preserves/core';
 
-export type WireSymbol = { oid: IO.Oid, ref: Ref, count: number };
+export type WireSymbol = { oid: Oid, ref: Ref, count: number };
 
 export const wireRefEmbeddedType: EmbeddedType<S.WireRef> = {
     decode(s: DecoderState): S.WireRef {
@@ -15,7 +15,7 @@ export const wireRefEmbeddedType: EmbeddedType<S.WireRef> = {
     },
 
     fromValue(v: Value<GenericEmbedded>): S.WireRef {
-        return S.asWireRef(v as S._val);
+        return S.asWireRef(v as Value<S._embedded>);
     },
 
     toValue(v: S.WireRef): Value<GenericEmbedded> {

src/transport/relay.ts

@@ -46,7 +46,7 @@ export class RelayEntity implements Entity {
         this.oid = oid;
     }
 
-    send(m: IO.Event): void {
+    send(m: IO.Event<WireRef>): void {
         this.relay.send(this.oid, m);
     }
 
@@ -131,7 +131,7 @@ export class Relay {
     readonly exported = new Membrane();
     readonly imported = new Membrane();
     nextLocalOid: IO.Oid = 0;
-    pendingTurn: IO.Turn = [];
+    pendingTurn: IO.Turn<WireRef> = [];
     debug: boolean;
     trustPeer: boolean;
 
@@ -229,7 +229,7 @@ export class Relay {
         }
     }
 
-    send(remoteOid: IO.Oid, m: IO.Event): void {
+    send(remoteOid: IO.Oid, m: IO.Event<WireRef>): void {
         if (this.pendingTurn.length === 0) {
             queueTask(() => {
                 if (this.debug) console.log('OUT', IO.fromTurn(this.pendingTurn).asPreservesText());
@@ -264,7 +264,7 @@ export class Relay {
         });
     }
 
-    handle(t: Turn, r: Ref, m: IO.Event) {
+    handle(t: Turn, r: Ref, m: IO.Event<WireRef>) {
         switch (m._variant) {
             case 'Assert': {
                 const [a, imported] = this.rewriteIn(t, m.value.assertion);

src/transport/sturdy.ts

@@ -7,11 +7,11 @@
 // California: Internet Society, 2014.
 
 import { mac } from './cryptography.js';
-import { Bytes, decode, encode, is, neverEmbeddedType } from '@preserves/core';
+import { Bytes, decode, encode, is, neverEmbeddedType, Value } from '@preserves/core';
 import * as S from '../gen/sturdy.js';
 export * from '../gen/sturdy.js';
 
-export type SturdyValue = S._val;
+export type SturdyValue = Value<S._embedded>;
 
 export const KEY_LENGTH = 16; // 128 bits