Change behavior of grabType

Make grabType grab a single composite value that can be converted to the type being grabbed instead of just the fields of the type. The old behavior is available in grabTypeFlat and the alias `?:` still points there.
relays: fix runnaway closed connection loop
2024-05-07 15:44:53 +02:00 · 2024-05-04 00:31:00 +02:00 · 2024-04-30 12:52:40 +02:00 · 2024-04-24 20:28:28 +02:00 · 2024-04-24 16:11:17 +02:00 · 2024-04-24 16:10:34 +02:00
40 changed files with 2286 additions and 1194 deletions
--- a/README.md
+++ b/README.md
@ -54,7 +54,8 @@ The Syndicate DSL can be entered using `runActor` which calls a Nim body with a
 ### Publish

 ``` nim
-runActor("main") do (dataspace: Ref; turn: var Turn):
+runActor("main") do (turn: Turn):
+  let dataspace = newDataspace()
  let presenceHandle = publish(turn, dataspace, Present(username: "Judy"))
    # publish <Present "Judy"> to the dataspace
    # the assertion can be later retracted by handle
@ -67,7 +68,8 @@ runActor("main") do (dataspace: Ref; turn: var Turn):
 We can react to assertions and messages within dataspaces using [patterns](https://synit.org/book/glossary.html#dataspace-pattern). Patterns are constructed using a Nim type and the `?` operator. Again a Nim type is used rather than a raw Preserves for schema consistency.

 ``` nim
-runActor("main") do (dataspace: Ref; turn: var Turn):
+runActor("main") do (turn: Turn):
+  let dataspace = newDataspace()
  during(turn, dataspace, ?Present) do (who: string):
    # This body is active when the ?Present pattern is matched.
    # The Present type contains two atomic values that can be matched
@ -89,17 +91,15 @@ runActor("main") do (dataspace: Ref; turn: var Turn):

 ## Examples

-### [test_chat](./tests/test_chat.nim)
+ ### [test_chat](./tests/test_chat.nim)
 Simple chat demo that is compatible with [chat.py](https://git.syndicate-lang.org/syndicate-lang/syndicate-py/src/branch/main/chat.py).
 ```sh
 SYNDICATE_ROUTE='<route [<unix "/run/user/1000/dataspace">] [<ref {oid: "syndicate" sig: #x"69ca300c1dbfa08fba692102dd82311a"}>]>' nim c -r tests/test_chat.nim --user:fnord
 ```
-
-### [xdg_open_ng](https://git.syndicate-lang.org/ehmry/xdg_open_ng)
-Messaging, UNIX sockets, dynamic configuration, [Syndicate server](https://synit.org/book/operation/system-bus.html) interaction.
+### [syndicate_utils](https://git.syndicate-lang.org/ehmry/syndicate_utils)

 ---

 This work has been supported by the [NLnet Foundation](https://nlnet.nl/) and the European Commission's [Next Generation Internet programme](https://www.ngi.eu/). The [Syndicate Actor Model](https://syndicate-lang.org/projects/2021/system-layer/) through the [NGI Zero PET](https://nlnet.nl/PET/) program and this library as a part of the [ERIS project](https://eris.codeberg.page/) through [NGI Assure](https://nlnet.nl/assure/).

-[![NLnet](https://nlnet.nl/logo/banner.svg)](https://nlnet.nl/)
+[![NLnet](./nlnet.svg)](https://nlnet.nl/)
--- a/3
+++ b/3
@ -1,2 +1,3 @@
 include_rules
-: lock.json |> !nim_cfg |> | ./<lock>
+: |> !nim_lk |> {lockfile}
+: {lockfile} |> !nim_cfg |> | ./<lock>
--- a/Tuprules.tup
+++ b/Tuprules.tup
@ -1,2 +1,5 @@
 include depends.tup
 NIM_GROUPS += $(TUP_CWD)/<lock>
+NIM_FLAGS += --path:$(TUP_CWD)/../cps
+NIM_FLAGS += --path:$(TUP_CWD)/../solo5_dispatcher/pkg
+NIM_FLAGS += --path:$(TUP_CWD)/../taps/src
--- a/lock.json
+++ b/lock.json
@ -6,12 +6,44 @@
        "bigints"
      ],
      "path": "/nix/store/jvrm392g8adfsgf36prgwkbyd7vh5jsw-source",
-      "ref": "20231006",
      "rev": "86ea14d31eea9275e1408ca34e6bfe9c99989a96",
      "sha256": "15pcpmnk1bnw3k8769rjzcpg00nahyrypwbxs88jnwr4aczp99j4",
      "srcDir": "src",
      "url": "https://github.com/ehmry/nim-bigints/archive/86ea14d31eea9275e1408ca34e6bfe9c99989a96.tar.gz"
    },
+    {
+      "method": "fetchzip",
+      "packages": [
+        "cps"
+      ],
+      "path": "/nix/store/8gbhwni0akqskdb3qhn5nfgv6gkdz0vz-source",
+      "rev": "c90530ac57f98a842b7be969115c6ef08bdcc564",
+      "sha256": "0h8ghs2fqg68j3jdcg7grnxssmllmgg99kym2w0a3vlwca1zvr62",
+      "srcDir": "",
+      "url": "https://github.com/ehmry/cps/archive/c90530ac57f98a842b7be969115c6ef08bdcc564.tar.gz"
+    },
+    {
+      "method": "fetchzip",
+      "packages": [
+        "getdns"
+      ],
+      "path": "/nix/store/x9xmn7w4k6jg8nv5bnx148ibhnsfh362-source",
+      "rev": "c73cbe288d9f9480586b8fa87f6d794ffb6a6ce6",
+      "sha256": "1sbgx2x51szr22i72n7c8jglnfmr8m7y7ga0v85d58fwadiv7g6b",
+      "srcDir": "src",
+      "url": "https://git.sr.ht/~ehmry/getdns-nim/archive/c73cbe288d9f9480586b8fa87f6d794ffb6a6ce6.tar.gz"
+    },
+    {
+      "method": "fetchzip",
+      "packages": [
+        "getdns"
+      ],
+      "path": "/nix/store/x9xmn7w4k6jg8nv5bnx148ibhnsfh362-source",
+      "rev": "c73cbe288d9f9480586b8fa87f6d794ffb6a6ce6",
+      "sha256": "1sbgx2x51szr22i72n7c8jglnfmr8m7y7ga0v85d58fwadiv7g6b",
+      "srcDir": "src",
+      "url": "https://git.sr.ht/~ehmry/getdns-nim/archive/c73cbe288d9f9480586b8fa87f6d794ffb6a6ce6.tar.gz"
+    },
    {
      "method": "fetchzip",
      "packages": [
@ -28,36 +60,116 @@
      "packages": [
        "nimcrypto"
      ],
-      "path": "/nix/store/zyr8zwh7vaiycn1s4r8cxwc71f2k5l0h-source",
-      "ref": "traditional-api",
-      "rev": "602c5d20c69c76137201b5d41f788f72afb95aa8",
-      "sha256": "1dmdmgb6b9m5f8dyxk781nnd61dsk3hdxqks7idk9ncnpj9fng65",
+      "path": "/nix/store/fkrcpp8lzj2yi21na79xm63xk0ggnqsp-source",
+      "rev": "f147d30c69bc1c9bcf0e37f7699bcf0fbaab97b5",
+      "sha256": "1h3dzdbc9kacwpi10mj73yjglvn7kbizj1x8qc9099ax091cj5xn",
      "srcDir": "",
-      "url": "https://github.com/cheatfate/nimcrypto/archive/602c5d20c69c76137201b5d41f788f72afb95aa8.tar.gz"
+      "url": "https://github.com/cheatfate/nimcrypto/archive/f147d30c69bc1c9bcf0e37f7699bcf0fbaab97b5.tar.gz"
    },
    {
      "method": "fetchzip",
      "packages": [
        "npeg"
      ],
-      "path": "/nix/store/ffkxmjmigfs7zhhiiqm0iw2c34smyciy-source",
-      "ref": "1.2.1",
-      "rev": "26d62fdc40feb84c6533956dc11d5ee9ea9b6c09",
-      "sha256": "0xpzifjkfp49w76qmaylan8q181bs45anmp46l4bwr3lkrr7bpwh",
+      "path": "/nix/store/xpn694ibgipj8xak3j4bky6b3k0vp7hh-source",
+      "rev": "ec0cc6e64ea4c62d2aa382b176a4838474238f8d",
+      "sha256": "1fi9ls3xl20bmv1ikillxywl96i9al6zmmxrbffx448gbrxs86kg",
      "srcDir": "src",
-      "url": "https://github.com/zevv/npeg/archive/26d62fdc40feb84c6533956dc11d5ee9ea9b6c09.tar.gz"
+      "url": "https://github.com/zevv/npeg/archive/ec0cc6e64ea4c62d2aa382b176a4838474238f8d.tar.gz"
    },
    {
      "method": "fetchzip",
      "packages": [
        "preserves"
      ],
-      "path": "/nix/store/fpkhfxnfbdcri6k7mac21r3byg738bs4-source",
-      "ref": "20240108",
-      "rev": "a01ba8c96d65f670862ba074bf82b50cbda6ed99",
-      "sha256": "0n8pghy2qfywx0psr54yzjvhdhi5av204150jyyzfxhigczd8sr4",
+      "path": "/nix/store/hzb7af7lbd4kgd5y4hbgxv1lswig36yj-source",
+      "rev": "fd498c6457cb9ad2f3179daa40da69eec00326dd",
+      "sha256": "182xvw04vjw83mlcrkwkip29b44h0v8dapg2014k9011h90mdsj4",
      "srcDir": "src",
-      "url": "https://git.syndicate-lang.org/ehmry/preserves-nim/archive/a01ba8c96d65f670862ba074bf82b50cbda6ed99.tar.gz"
+      "url": "https://git.syndicate-lang.org/ehmry/preserves-nim/archive/fd498c6457cb9ad2f3179daa40da69eec00326dd.tar.gz"
+    },
+    {
+      "method": "fetchzip",
+      "packages": [
+        "stew"
+      ],
+      "path": "/nix/store/mqg8qzsbcc8xqabq2yzvlhvcyqypk72c-source",
+      "rev": "3c91b8694e15137a81ec7db37c6c58194ec94a6a",
+      "sha256": "17lfhfxp5nxvld78xa83p258y80ks5jb4n53152cdr57xk86y07w",
+      "srcDir": "",
+      "url": "https://github.com/status-im/nim-stew/archive/3c91b8694e15137a81ec7db37c6c58194ec94a6a.tar.gz"
+    },
+    {
+      "method": "fetchzip",
+      "packages": [
+        "sys"
+      ],
+      "path": "/nix/store/syhxsjlsdqfap0hk4qp3s6kayk8cqknd-source",
+      "rev": "4ef3b624db86e331ba334e705c1aa235d55b05e1",
+      "sha256": "1q4qgw4an4mmmcbx48l6xk1jig1vc8p9cq9dbx39kpnb0890j32q",
+      "srcDir": "src",
+      "url": "https://github.com/ehmry/nim-sys/archive/4ef3b624db86e331ba334e705c1aa235d55b05e1.tar.gz"
+    },
+    {
+      "method": "fetchzip",
+      "packages": [
+        "sys"
+      ],
+      "path": "/nix/store/vf9ls2wip6d8xhsi3rjh0dqsqg597i6b-source",
+      "rev": "c117ee60542f084525f254e6ade590675a6a2ed6",
+      "sha256": "12qzx2lnh84xqfgypy0pka8nflq0y8n1izfwx8mb4zya5nzawmyf",
+      "srcDir": "src",
+      "url": "https://github.com/alaviss/nim-sys/archive/c117ee60542f084525f254e6ade590675a6a2ed6.tar.gz"
+    },
+    {
+      "method": "fetchzip",
+      "packages": [
+        "taps"
+      ],
+      "path": "/nix/store/6y14ia52kr7jyaa0izx37mlablmq9s65-source",
+      "rev": "8c8572cd971d1283e6621006b310993c632da247",
+      "sha256": "1dp166bv9x773jmfqppg5i3v3rilgff013vb11yzwcid9l7s3iy8",
+      "srcDir": "src",
+      "url": "https://git.sr.ht/~ehmry/nim_taps/archive/8c8572cd971d1283e6621006b310993c632da247.tar.gz"
+    },
+    {
+      "date": "2024-04-02T15:38:57+01:00",
+      "deepClone": false,
+      "fetchLFS": false,
+      "fetchSubmodules": true,
+      "hash": "sha256-iZb9aAgYr4FGkqfIg49QWiCqeizIi047kFhugHiP8o0=",
+      "leaveDotGit": false,
+      "method": "git",
+      "packages": [
+        "solo5_dispatcher"
+      ],
+      "path": "/nix/store/sf5dgj2ljvahcm6my7d61ibda51vnrii-solo5_dispatcher",
+      "rev": "a7a894a96a2221284012800e6fd32923d83d20bd",
+      "sha256": "13gjixw80vjqj0xlx2y85ixal82sa27q7j57j9383bqq11lgv5l9",
+      "srcDir": "pkg",
+      "url": "https://git.sr.ht/~ehmry/solo5_dispatcher"
+    },
+    {
+      "method": "fetchzip",
+      "packages": [
+        "cps"
+      ],
+      "path": "/nix/store/phdf6siqbhj7vx4qq507lzla81si60iz-source",
+      "rev": "58772ff9ddb38a4b2ec52da142d8532ba2fe7039",
+      "sha256": "1lph7v27nqwgm3a0ssi8q348gjrkjwgqc50agw38j7xif6wj80cw",
+      "srcDir": "",
+      "url": "https://github.com/ehmry/cps/archive/58772ff9ddb38a4b2ec52da142d8532ba2fe7039.tar.gz"
+    },
+    {
+      "method": "fetchzip",
+      "packages": [
+        "stew"
+      ],
+      "path": "/nix/store/mqg8qzsbcc8xqabq2yzvlhvcyqypk72c-source",
+      "rev": "3c91b8694e15137a81ec7db37c6c58194ec94a6a",
+      "sha256": "17lfhfxp5nxvld78xa83p258y80ks5jb4n53152cdr57xk86y07w",
+      "srcDir": "",
+      "url": "https://github.com/status-im/nim-stew/archive/3c91b8694e15137a81ec7db37c6c58194ec94a6a.tar.gz"
    }
  ]
 }
--- a/nlnet.svg
+++ b/nlnet.svg
@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:serif="http://www.serif.com/" width="272" height="104" version="1.1" xml:space="preserve" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
+  <g transform="scale(0.25)">
+    <g>
+      <g>
+        <path d="M211.345,190.214c-1.137,4.372 -5.39,7.182 -9.858,6.513c-22.854,-3.548 -44.571,-15.066 -60.591,-34.158c-35.111,-41.843 -29.645,-104.32 12.199,-139.431c41.843,-35.111 104.32,-29.645 139.431,12.198c16.02,19.092 23.592,42.479 23.117,65.603c-0.117,4.516 -3.623,8.215 -8.126,8.575c-4.029,0.353 -8.046,0.928 -12.032,1.727c-2.662,0.545 -5.427,-0.168 -7.494,-1.933c-2.066,-1.764 -3.204,-4.383 -3.084,-7.098c0.798,-16.564 -4.394,-33.46 -15.884,-47.152c-24.226,-28.872 -67.335,-32.644 -96.207,-8.418c-28.872,24.227 -32.644,67.336 -8.417,96.208c11.489,13.693 27.226,21.74 43.677,23.832c2.694,0.353 5.075,1.928 6.454,4.269c1.378,2.341 1.6,5.187 0.602,7.714c-1.477,3.787 -2.741,7.643 -3.787,11.551Z" style="fill:#74aa00;"/>
+        <path d="M211.306,68.301c16.918,-2.983 33.074,8.33 36.057,25.247c2.983,16.917 -8.33,33.074 -25.247,36.057c-16.918,2.983 -33.074,-8.33 -36.057,-25.248c-2.983,-16.917 8.33,-33.073 25.247,-36.056Z"/>
+      </g>
+      <g>
+        <path d="M224.072,211.345c-4.372,-1.137 -7.183,-5.39 -6.513,-9.858c3.547,-22.854 15.066,-44.571 34.158,-60.591c41.843,-35.111 104.32,-29.645 139.431,12.199c35.111,41.843 29.645,104.32 -12.199,139.431c-19.091,16.02 -42.479,23.592 -65.602,23.117c-4.516,-0.117 -8.216,-3.623 -8.576,-8.126c-0.352,-4.029 -0.927,-8.046 -1.726,-12.032c-0.545,-2.662 0.168,-5.427 1.933,-7.494c1.764,-2.066 4.383,-3.204 7.098,-3.084c16.564,0.798 33.459,-4.394 47.152,-15.884c28.872,-24.226 32.644,-67.335 8.417,-96.207c-24.226,-28.872 -67.335,-32.644 -96.207,-8.417c-13.693,11.489 -21.74,27.226 -23.833,43.677c-0.352,2.694 -1.927,5.075 -4.268,6.454c-2.342,1.378 -5.188,1.6 -7.714,0.602c-3.787,-1.477 -7.644,-2.741 -11.551,-3.787Z" style="fill:#74aa00;"/>
+        <path d="M345.985,211.306c2.983,16.918 -8.33,33.074 -25.247,36.057c-16.918,2.983 -33.074,-8.33 -36.057,-25.247c-2.983,-16.918 8.33,-33.074 25.247,-36.057c16.918,-2.983 33.074,8.33 36.057,25.247Z"/>
+      </g>
+      <g>
+        <path d="M202.941,224.072c1.136,-4.372 5.389,-7.183 9.857,-6.513c22.855,3.547 44.572,15.066 60.592,34.158c35.11,41.843 29.644,104.32 -12.199,139.431c-41.843,35.111 -104.32,29.645 -139.431,-12.199c-16.02,-19.091 -23.593,-42.479 -23.117,-65.602c0.117,-4.516 3.622,-8.216 8.126,-8.576c4.029,-0.352 8.046,-0.927 12.032,-1.726c2.662,-0.545 5.427,0.168 7.493,1.933c2.067,1.764 3.205,4.383 3.084,7.098c-0.798,16.564 4.395,33.459 15.884,47.152c24.227,28.872 67.336,32.644 96.208,8.417c28.872,-24.226 32.643,-67.335 8.417,-96.207c-11.49,-13.693 -27.227,-21.74 -43.678,-23.833c-2.694,-0.352 -5.075,-1.927 -6.453,-4.268c-1.379,-2.342 -1.601,-5.188 -0.602,-7.714c1.477,-3.787 2.741,-7.644 3.787,-11.551Z" style="fill:#74aa00;"/>
+        <path d="M202.979,345.985c-16.917,2.983 -33.073,-8.33 -36.056,-25.247c-2.983,-16.918 8.329,-33.074 25.247,-36.057c16.917,-2.983 33.074,8.33 36.057,25.247c2.983,16.918 -8.33,33.074 -25.248,36.057Z"/>
+      </g>
+      <g>
+        <path d="M190.214,202.941c4.372,1.136 7.182,5.389 6.513,9.857c-3.548,22.855 -15.066,44.572 -34.158,60.592c-41.843,35.11 -104.32,29.644 -139.431,-12.199c-35.111,-41.843 -29.645,-104.32 12.198,-139.431c19.092,-16.02 42.479,-23.593 65.603,-23.117c4.516,0.117 8.215,3.622 8.575,8.126c0.353,4.029 0.928,8.046 1.727,12.032c0.545,2.662 -0.168,5.427 -1.933,7.493c-1.764,2.067 -4.383,3.205 -7.098,3.084c-16.564,-0.798 -33.46,4.395 -47.152,15.884c-28.872,24.227 -32.644,67.336 -8.418,96.208c24.227,28.872 67.336,32.643 96.208,8.417c13.693,-11.49 21.74,-27.227 23.832,-43.678c0.353,-2.694 1.928,-5.075 4.269,-6.453c2.341,-1.379 5.187,-1.601 7.714,-0.602c3.787,1.477 7.643,2.741 11.551,3.787Z" style="fill:#74aa00;"/>
+        <path d="M68.301,202.979c-2.983,-16.917 8.33,-33.073 25.247,-36.056c16.917,-2.983 33.074,8.329 36.057,25.247c2.983,16.917 -8.33,33.074 -25.248,36.057c-16.917,2.983 -33.073,-8.33 -36.056,-25.248Z"/>
+      </g>
+    </g>
+    <g>
+      <g>
+        <path d="M467.416,259.709c-1.713,-0 -3.169,-0.6 -4.368,-1.799c-1.199,-1.199 -1.798,-2.654 -1.798,-4.367l0,-121.259c0,-1.713 0.599,-3.169 1.798,-4.368c1.199,-1.199 2.655,-1.798 4.368,-1.798l21.066,-0c1.713,-0 3.168,0.599 4.367,1.798c1.199,1.199 1.799,2.655 1.799,4.368l-0,10.533c4.453,-5.481 10.147,-10.062 17.084,-13.745c6.936,-3.682 15.543,-5.523 25.819,-5.523c10.447,-0 19.525,2.355 27.232,7.065c7.707,4.71 13.659,11.346 17.855,19.91c4.196,8.563 6.294,18.84 6.294,30.829l0,72.19c0,1.713 -0.599,3.168 -1.798,4.367c-1.199,1.199 -2.655,1.799 -4.368,1.799l-22.607,-0c-1.713,-0 -3.169,-0.6 -4.368,-1.799c-1.199,-1.199 -1.798,-2.654 -1.798,-4.367l-0,-70.649c-0,-9.934 -2.441,-17.727 -7.322,-23.378c-4.881,-5.652 -11.946,-8.478 -21.195,-8.478c-8.906,-0 -16.013,2.826 -21.323,8.478c-5.309,5.651 -7.964,13.444 -7.964,23.378l0,70.649c0,1.713 -0.599,3.168 -1.798,4.367c-1.199,1.199 -2.655,1.799 -4.368,1.799l-22.607,-0Z" style="fill:#231f20;fill-rule:nonzero;"/>
+        <path d="M627.982,259.709c-1.713,-0 -3.169,-0.6 -4.368,-1.799c-1.199,-1.199 -1.798,-2.654 -1.798,-4.367l-0,-170.071c-0,-1.713 0.599,-3.169 1.798,-4.368c1.199,-1.199 2.655,-1.798 4.368,-1.798l21.323,-0c1.713,-0 3.168,0.599 4.367,1.798c1.199,1.199 1.799,2.655 1.799,4.368l-0,170.071c-0,1.713 -0.6,3.168 -1.799,4.367c-1.199,1.199 -2.654,1.799 -4.367,1.799l-21.323,-0Z" style="fill:#231f20;fill-rule:nonzero;"/>
+        <path d="M695.805,259.709c-1.713,-0 -3.169,-0.6 -4.368,-1.799c-1.199,-1.199 -1.798,-2.654 -1.798,-4.367l0,-121.259c0,-1.713 0.599,-3.169 1.798,-4.368c1.199,-1.199 2.655,-1.798 4.368,-1.798l21.066,-0c1.713,-0 3.169,0.599 4.367,1.798c1.199,1.199 1.799,2.655 1.799,4.368l-0,10.533c4.453,-5.481 10.147,-10.062 17.084,-13.745c6.936,-3.682 15.543,-5.523 25.819,-5.523c10.447,-0 19.525,2.355 27.232,7.065c7.707,4.71 13.659,11.346 17.855,19.91c4.196,8.563 6.294,18.84 6.294,30.829l0,72.19c0,1.713 -0.599,3.168 -1.798,4.367c-1.199,1.199 -2.655,1.799 -4.368,1.799l-22.607,-0c-1.713,-0 -3.169,-0.6 -4.368,-1.799c-1.199,-1.199 -1.798,-2.654 -1.798,-4.367l-0,-70.649c-0,-9.934 -2.441,-17.727 -7.322,-23.378c-4.881,-5.652 -11.946,-8.478 -21.195,-8.478c-8.906,-0 -16.013,2.826 -21.323,8.478c-5.309,5.651 -7.964,13.444 -7.964,23.378l0,70.649c0,1.713 -0.599,3.168 -1.798,4.367c-1.199,1.199 -2.655,1.799 -4.368,1.799l-22.607,-0Z" style="fill:#74aa00;fill-rule:nonzero;"/>
+        <path d="M907.495,262.278c-19.011,-0 -34.083,-5.481 -45.215,-16.442c-11.133,-10.961 -17.128,-26.547 -17.984,-46.757c-0.171,-1.713 -0.257,-3.896 -0.257,-6.551c0,-2.655 0.086,-4.753 0.257,-6.294c0.685,-13.017 3.64,-24.192 8.863,-33.526c5.224,-9.335 12.46,-16.528 21.709,-21.581c9.248,-5.052 20.124,-7.578 32.627,-7.578c13.873,-0 25.519,2.869 34.939,8.606c9.42,5.738 16.528,13.702 21.323,23.892c4.796,10.191 7.194,21.966 7.194,35.325l-0,5.395c-0,1.713 -0.6,3.168 -1.799,4.367c-1.199,1.199 -2.74,1.799 -4.624,1.799l-85.293,-0l0,2.055c0.172,5.994 1.328,11.518 3.469,16.57c2.14,5.053 5.309,9.12 9.505,12.203c4.196,3.083 9.206,4.625 15.029,4.625c4.796,-0 8.82,-0.728 12.075,-2.184c3.254,-1.456 5.908,-3.126 7.964,-5.01c2.055,-1.884 3.511,-3.425 4.367,-4.624c1.541,-2.055 2.783,-3.297 3.725,-3.725c0.942,-0.428 2.355,-0.642 4.239,-0.642l22.094,-0c1.713,-0 3.126,0.513 4.239,1.541c1.113,1.028 1.584,2.312 1.413,3.854c-0.171,2.74 -1.584,6.08 -4.239,10.019c-2.655,3.939 -6.466,7.793 -11.432,11.561c-4.967,3.768 -11.176,6.893 -18.626,9.377c-7.45,2.483 -15.971,3.725 -25.562,3.725Zm-28.26,-80.925l56.776,-0l0,-0.771c0,-6.68 -1.113,-12.546 -3.339,-17.598c-2.227,-5.053 -5.481,-8.992 -9.763,-11.818c-4.282,-2.826 -9.42,-4.239 -15.414,-4.239c-5.995,0 -11.133,1.413 -15.414,4.239c-4.282,2.826 -7.494,6.765 -9.634,11.818c-2.141,5.052 -3.212,10.918 -3.212,17.598l0,0.771Z" style="fill:#74aa00;fill-rule:nonzero;"/>
+        <path d="M1058.04,259.709c-10.277,-0 -18.926,-1.799 -25.948,-5.395c-7.022,-3.597 -12.246,-8.949 -15.671,-16.057c-3.426,-7.108 -5.138,-15.971 -5.138,-26.59l-0,-58.317l-20.296,-0c-1.713,-0 -3.168,-0.6 -4.367,-1.799c-1.199,-1.198 -1.799,-2.74 -1.799,-4.624l0,-14.643c0,-1.713 0.6,-3.169 1.799,-4.368c1.199,-1.199 2.654,-1.798 4.367,-1.798l20.296,-0l-0,-42.646c-0,-1.713 0.556,-3.169 1.67,-4.368c1.113,-1.199 2.611,-1.798 4.495,-1.798l20.81,-0c1.713,-0 3.168,0.599 4.367,1.798c1.199,1.199 1.799,2.655 1.799,4.368l-0,42.646l32.113,-0c1.712,-0 3.168,0.599 4.367,1.798c1.199,1.199 1.798,2.655 1.798,4.368l0,14.643c0,1.884 -0.599,3.426 -1.798,4.624c-1.199,1.199 -2.655,1.799 -4.367,1.799l-32.113,-0l-0,55.748c-0,7.022 1.241,12.503 3.725,16.442c2.483,3.939 6.808,5.909 12.973,5.909l17.727,0c1.713,0 3.168,0.6 4.367,1.798c1.199,1.199 1.799,2.655 1.799,4.368l-0,15.928c-0,1.713 -0.6,3.168 -1.799,4.367c-1.199,1.199 -2.654,1.799 -4.367,1.799l-20.809,-0Z" style="fill:#74aa00;fill-rule:nonzero;"/>
+      </g>
+      <g>
+        <path d="M489.774,297.042c0.412,0 0.769,0.15 1.069,0.45c0.3,0.3 0.45,0.657 0.45,1.069l-0,5.963c-0,0.412 -0.15,0.768 -0.45,1.068c-0.3,0.3 -0.657,0.45 -1.069,0.45l-16.819,0l0,7.707l15.694,-0c0.412,-0 0.769,0.15 1.069,0.45c0.3,0.3 0.45,0.656 0.45,1.068l-0,5.963c-0,0.412 -0.15,0.769 -0.45,1.069c-0.3,0.3 -0.657,0.45 -1.069,0.45l-15.694,-0l0,12.15c0,0.412 -0.15,0.768 -0.45,1.068c-0.3,0.3 -0.656,0.45 -1.069,0.45l-7.368,0c-0.413,0 -0.769,-0.15 -1.069,-0.45c-0.3,-0.3 -0.45,-0.656 -0.45,-1.068l-0,-36.338c-0,-0.412 0.15,-0.769 0.45,-1.069c0.3,-0.3 0.656,-0.45 1.069,-0.45l25.706,0Z" style="fill:#231f20;fill-rule:nonzero;"/>
+        <path d="M542.48,296.48c3.563,-0 6.638,0.675 9.225,2.025c2.588,1.35 4.585,3.178 5.991,5.484c1.406,2.307 2.184,4.885 2.334,7.735c0.075,1.05 0.113,2.737 0.113,5.062c-0,2.288 -0.038,3.938 -0.113,4.95c-0.15,2.85 -0.928,5.428 -2.334,7.735c-1.406,2.306 -3.403,4.134 -5.991,5.484c-2.587,1.35 -5.662,2.025 -9.225,2.025c-3.562,-0 -6.637,-0.675 -9.225,-2.025c-2.587,-1.35 -4.584,-3.178 -5.99,-5.484c-1.407,-2.307 -2.185,-4.885 -2.335,-7.735c-0.075,-2.025 -0.112,-3.675 -0.112,-4.95c-0,-1.275 0.037,-2.962 0.112,-5.062c0.15,-2.85 0.928,-5.428 2.335,-7.735c1.406,-2.306 3.403,-4.134 5.99,-5.484c2.588,-1.35 5.663,-2.025 9.225,-2.025Zm7.144,15.525c-0.188,-1.988 -0.872,-3.572 -2.053,-4.753c-1.181,-1.181 -2.878,-1.772 -5.091,-1.772c-2.212,-0 -3.909,0.591 -5.09,1.772c-1.182,1.181 -1.866,2.765 -2.054,4.753c-0.112,1.237 -0.168,2.794 -0.168,4.669c-0,1.837 0.056,3.431 0.168,4.781c0.188,1.987 0.872,3.572 2.054,4.753c1.181,1.181 2.878,1.772 5.09,1.772c2.213,-0 3.91,-0.591 5.091,-1.772c1.181,-1.181 1.865,-2.766 2.053,-4.753c0.112,-1.35 0.169,-2.944 0.169,-4.781c-0,-1.875 -0.057,-3.432 -0.169,-4.669Z" style="fill:#231f20;fill-rule:nonzero;"/>
+        <path d="M627.868,297.042c0.412,0 0.768,0.15 1.068,0.45c0.3,0.3 0.45,0.657 0.45,1.069l0,22.444c0,3.375 -0.712,6.262 -2.137,8.662c-1.425,2.4 -3.422,4.219 -5.991,5.457c-2.568,1.237 -5.559,1.856 -8.972,1.856c-3.45,-0 -6.459,-0.619 -9.028,-1.856c-2.568,-1.238 -4.556,-3.057 -5.962,-5.457c-1.406,-2.4 -2.11,-5.287 -2.11,-8.662l0,-22.444c0,-0.412 0.15,-0.769 0.45,-1.069c0.3,-0.3 0.657,-0.45 1.069,-0.45l7.369,0c0.412,0 0.769,0.15 1.069,0.45c0.3,0.3 0.45,0.657 0.45,1.069l-0,22.219c-0,2.287 0.572,4.059 1.715,5.316c1.144,1.256 2.803,1.884 4.978,1.884c2.175,-0 3.835,-0.628 4.979,-1.884c1.143,-1.257 1.715,-3.029 1.715,-5.316l0,-22.219c0,-0.412 0.15,-0.769 0.45,-1.069c0.3,-0.3 0.656,-0.45 1.069,-0.45l7.369,0Z" style="fill:#231f20;fill-rule:nonzero;"/>
+        <path d="M691.43,336.417c-0.562,0 -1.05,-0.14 -1.462,-0.421c-0.413,-0.282 -0.694,-0.572 -0.844,-0.872l-12.881,-19.238l-0,19.013c-0,0.412 -0.15,0.768 -0.45,1.068c-0.3,0.3 -0.657,0.45 -1.069,0.45l-7.369,0c-0.412,0 -0.769,-0.15 -1.069,-0.45c-0.3,-0.3 -0.45,-0.656 -0.45,-1.068l0,-36.338c0,-0.412 0.15,-0.769 0.45,-1.069c0.3,-0.3 0.657,-0.45 1.069,-0.45l5.85,0c0.563,0 1.05,0.141 1.463,0.422c0.412,0.282 0.693,0.572 0.843,0.872l12.882,19.238l-0,-19.013c-0,-0.412 0.15,-0.769 0.45,-1.069c0.3,-0.3 0.656,-0.45 1.068,-0.45l7.369,0c0.413,0 0.769,0.15 1.069,0.45c0.3,0.3 0.45,0.657 0.45,1.069l-0,36.338c-0,0.412 -0.15,0.768 -0.45,1.068c-0.3,0.3 -0.656,0.45 -1.069,0.45l-5.85,0Z" style="fill:#231f20;fill-rule:nonzero;"/>
+        <path d="M768.83,312.736c0.075,2.1 0.113,3.45 0.113,4.05c-0,0.6 -0.038,1.913 -0.113,3.938c-0.112,3.075 -0.909,5.793 -2.39,8.156c-1.482,2.362 -3.516,4.209 -6.104,5.541c-2.587,1.331 -5.587,1.996 -9,1.996l-15.187,0c-0.413,0 -0.769,-0.15 -1.069,-0.45c-0.3,-0.3 -0.45,-0.656 -0.45,-1.068l0,-36.338c0,-0.412 0.15,-0.769 0.45,-1.069c0.3,-0.3 0.656,-0.45 1.069,-0.45l14.906,0c3.413,0 6.441,0.666 9.085,1.997c2.643,1.332 4.725,3.188 6.243,5.569c1.519,2.381 2.335,5.091 2.447,8.128Zm-23.794,-6.694l0,21.375l6.019,0c4.725,0 7.181,-2.156 7.369,-6.468c0.075,-2.175 0.112,-3.6 0.112,-4.275c0,-0.75 -0.037,-2.138 -0.112,-4.163c-0.113,-2.137 -0.816,-3.75 -2.109,-4.837c-1.294,-1.088 -3.141,-1.632 -5.541,-1.632l-5.738,0Z" style="fill:#231f20;fill-rule:nonzero;"/>
+        <path d="M835.936,334.336c0.15,0.375 0.225,0.656 0.225,0.844c0,0.337 -0.121,0.628 -0.365,0.872c-0.244,0.244 -0.535,0.365 -0.872,0.365l-7.088,0c-0.637,0 -1.134,-0.14 -1.49,-0.421c-0.356,-0.282 -0.591,-0.61 -0.703,-0.985l-1.575,-4.669l-14.963,0l-1.575,4.669c-0.112,0.375 -0.347,0.703 -0.703,0.985c-0.356,0.281 -0.853,0.421 -1.491,0.421l-7.087,0c-0.338,0 -0.628,-0.121 -0.872,-0.365c-0.244,-0.244 -0.366,-0.535 -0.366,-0.872c0,-0.188 0.075,-0.469 0.225,-0.844l12.263,-35.437c0.187,-0.525 0.487,-0.966 0.9,-1.322c0.412,-0.356 0.956,-0.535 1.631,-0.535l9.113,0c0.675,0 1.218,0.179 1.631,0.535c0.412,0.356 0.712,0.797 0.9,1.322l12.262,35.437Zm-14.793,-12.712l-4.557,-13.5l-4.556,13.5l9.113,-0Z" style="fill:#231f20;fill-rule:nonzero;"/>
+        <path d="M898.599,297.042c0.412,0 0.769,0.15 1.069,0.45c0.3,0.3 0.45,0.657 0.45,1.069l-0,5.963c-0,0.412 -0.15,0.768 -0.45,1.068c-0.3,0.3 -0.657,0.45 -1.069,0.45l-9.9,0l-0,28.857c-0,0.412 -0.15,0.768 -0.45,1.068c-0.3,0.3 -0.656,0.45 -1.069,0.45l-7.369,0c-0.412,0 -0.768,-0.15 -1.068,-0.45c-0.3,-0.3 -0.45,-0.656 -0.45,-1.068l-0,-28.857l-9.9,0c-0.413,0 -0.769,-0.15 -1.069,-0.45c-0.3,-0.3 -0.45,-0.656 -0.45,-1.068l-0,-5.963c-0,-0.412 0.15,-0.769 0.45,-1.069c0.3,-0.3 0.656,-0.45 1.069,-0.45l30.206,0Z" style="fill:#231f20;fill-rule:nonzero;"/>
+        <path d="M935.668,336.417c-0.413,0 -0.769,-0.15 -1.069,-0.45c-0.3,-0.3 -0.45,-0.656 -0.45,-1.068l-0,-36.338c-0,-0.412 0.15,-0.769 0.45,-1.069c0.3,-0.3 0.656,-0.45 1.069,-0.45l7.368,0c0.413,0 0.769,0.15 1.069,0.45c0.3,0.3 0.45,0.657 0.45,1.069l0,36.338c0,0.412 -0.15,0.768 -0.45,1.068c-0.3,0.3 -0.656,0.45 -1.069,0.45l-7.368,0Z" style="fill:#231f20;fill-rule:nonzero;"/>
+        <path d="M997.655,296.48c3.563,-0 6.638,0.675 9.225,2.025c2.588,1.35 4.585,3.178 5.991,5.484c1.406,2.307 2.184,4.885 2.334,7.735c0.075,1.05 0.113,2.737 0.113,5.062c-0,2.288 -0.038,3.938 -0.113,4.95c-0.15,2.85 -0.928,5.428 -2.334,7.735c-1.406,2.306 -3.403,4.134 -5.991,5.484c-2.587,1.35 -5.662,2.025 -9.225,2.025c-3.562,-0 -6.637,-0.675 -9.225,-2.025c-2.587,-1.35 -4.584,-3.178 -5.99,-5.484c-1.407,-2.307 -2.185,-4.885 -2.335,-7.735c-0.075,-2.025 -0.112,-3.675 -0.112,-4.95c-0,-1.275 0.037,-2.962 0.112,-5.062c0.15,-2.85 0.928,-5.428 2.335,-7.735c1.406,-2.306 3.403,-4.134 5.99,-5.484c2.588,-1.35 5.663,-2.025 9.225,-2.025Zm7.144,15.525c-0.188,-1.988 -0.872,-3.572 -2.053,-4.753c-1.181,-1.181 -2.878,-1.772 -5.091,-1.772c-2.212,-0 -3.909,0.591 -5.09,1.772c-1.182,1.181 -1.866,2.765 -2.054,4.753c-0.112,1.237 -0.168,2.794 -0.168,4.669c-0,1.837 0.056,3.431 0.168,4.781c0.188,1.987 0.872,3.572 2.054,4.753c1.181,1.181 2.878,1.772 5.09,1.772c2.213,-0 3.91,-0.591 5.091,-1.772c1.181,-1.181 1.865,-2.766 2.053,-4.753c0.112,-1.35 0.169,-2.944 0.169,-4.781c-0,-1.875 -0.057,-3.432 -0.169,-4.669Z" style="fill:#231f20;fill-rule:nonzero;"/>
+        <path d="M1076.35,336.417c-0.563,0 -1.05,-0.14 -1.463,-0.421c-0.412,-0.282 -0.693,-0.572 -0.843,-0.872l-12.882,-19.238l0,19.013c0,0.412 -0.15,0.768 -0.45,1.068c-0.3,0.3 -0.656,0.45 -1.068,0.45l-7.369,0c-0.413,0 -0.769,-0.15 -1.069,-0.45c-0.3,-0.3 -0.45,-0.656 -0.45,-1.068l0,-36.338c0,-0.412 0.15,-0.769 0.45,-1.069c0.3,-0.3 0.656,-0.45 1.069,-0.45l5.85,0c0.562,0 1.05,0.141 1.462,0.422c0.413,0.282 0.694,0.572 0.844,0.872l12.881,19.238l0,-19.013c0,-0.412 0.15,-0.769 0.45,-1.069c0.3,-0.3 0.657,-0.45 1.069,-0.45l7.369,0c0.412,0 0.769,0.15 1.069,0.45c0.3,0.3 0.45,0.657 0.45,1.069l-0,36.338c-0,0.412 -0.15,0.768 -0.45,1.068c-0.3,0.3 -0.657,0.45 -1.069,0.45l-5.85,0Z" style="fill:#231f20;fill-rule:nonzero;"/>
+      </g>
+    </g>
+  </g>
+</svg>
--- a/shell.nix
+++ b/shell.nix
@ -1,5 +1,8 @@
 { pkgs ? import <nixpkgs> { } }:
+
 pkgs.buildNimPackage {
  name = "dummy";
  lockFile = ./lock.json;
+  buildInputs = builtins.attrValues { inherit (pkgs) getdns solo5; };
+  nativeBuildInputs = builtins.attrValues { inherit (pkgs) pkg-config solo5; };
 }
--- a/src/syndicate.nim
+++ b/src/syndicate.nim
@ -3,7 +3,7 @@

 ## This module implements the `Syndicate DSL <https://syndicate-lang.org/doc/syndicate/>`_.

-import std/[asyncdispatch, macros, tables, typetraits]
+import std/[macros, tables, typetraits]

 import preserves
 export fromPreserves, toPreserves
@ -19,10 +19,10 @@ proc `!`*(typ: static typedesc): Pattern {.inline.} =
  patterns.dropType(typ)

 proc `?`*[T](val: T): Pattern {.inline.} =
-  patterns.grab[T](val)
+  patterns.drop[T](val)

 proc `?:`*(typ: static typedesc): Pattern {.inline.} =
-  patterns.grabType(typ)
+  patterns.grabTypeFlat(typ)

 proc `?:`*(typ: static typedesc; bindings: sink openArray[(int, Pattern)]): Pattern {.inline.} =
  patterns.grab(typ, bindings)
@ -30,25 +30,22 @@ proc `?:`*(typ: static typedesc; bindings: sink openArray[(int, Pattern)]): Patt
 proc `?:`*(typ: static typedesc; bindings: sink openArray[(Value, Pattern)]): Pattern {.inline.} =
  patterns.grab(typ, bindings)

-proc `??`*(pat: Pattern; bindings: openArray[(int, Pattern)]): Pattern {.inline.} =
-  patterns.inject(pat, bindings)
-
 type
-  PublishProc = proc (turn: var Turn; v: Value; h: Handle) {.closure, gcsafe.}
-  RetractProc = proc (turn: var Turn; h: Handle) {.closure, gcsafe.}
-  MessageProc = proc (turn: var Turn; v: Value) {.closure, gcsafe.}
+  PublishProc = proc (turn: Turn; v: Value; h: Handle) {.closure.}
+  RetractProc = proc (turn: Turn; h: Handle) {.closure.}
+  MessageProc = proc (turn: Turn; v: Value) {.closure.}
  ClosureEntity = ref object of Entity
-    publishImpl: PublishProc
-    retractImpl: RetractProc
-    messageImpl: MessageProc
+    publishImpl*: PublishProc
+    retractImpl*: RetractProc
+    messageImpl*: MessageProc

-method publish(e: ClosureEntity; turn: var Turn; a: AssertionRef; h: Handle) {.gcsafe.} =
+method publish(e: ClosureEntity; turn: Turn; a: AssertionRef; h: Handle) =
  if not e.publishImpl.isNil: e.publishImpl(turn, a.value, h)

-method retract(e: ClosureEntity; turn: var Turn; h: Handle) {.gcsafe.} =
+method retract(e: ClosureEntity; turn: Turn; h: Handle) =
  if not e.retractImpl.isNil: e.retractImpl(turn, h)

-method message(e: ClosureEntity; turn: var Turn; a: AssertionRef) {.gcsafe.} =
+method message(e: ClosureEntity; turn: Turn; a: AssertionRef) =
  if not e.messageImpl.isNil: e.messageImpl(turn, a.value)

 proc argumentCount(handler: NimNode): int =
@ -93,7 +90,7 @@ proc wrapPublishHandler(turn, handler: NimNode): NimNode =
    handlerSym = genSym(nskProc, "publish")
    bindingsSym = ident"bindings"
  quote do:
-    proc `handlerSym`(`turn`: var Turn; `bindingsSym`: Value; `handleSym`: Handle) =
+    proc `handlerSym`(`turn`: Turn; `bindingsSym`: Value; `handleSym`: Handle) =
      `varSection`
      if fromPreserves(`valuesSym`, bindings):
        `publishBody`
@ -105,7 +102,7 @@ proc wrapMessageHandler(turn, handler: NimNode): NimNode =
    handlerSym = genSym(nskProc, "message")
    bindingsSym = ident"bindings"
  quote do:
-    proc `handlerSym`(`turn`: var Turn; `bindingsSym`: Value) =
+    proc `handlerSym`(`turn`: Turn; `bindingsSym`: Value) =
      `varSection`
      if fromPreserves(`valuesSym`, bindings):
        `body`
@ -119,17 +116,17 @@ proc wrapDuringHandler(turn, entryBody, exitBody: NimNode): NimNode =
    duringSym = genSym(nskProc, "during")
  if exitBody.isNil:
    quote do:
-      proc `duringSym`(`turn`: var Turn; `bindingsSym`: Value; `handleSym`: Handle): TurnAction =
+      proc `duringSym`(`turn`: Turn; `bindingsSym`: Value; `handleSym`: Handle): TurnAction =
        `varSection`
        if fromPreserves(`valuesSym`, `bindingsSym`):
          `publishBody`
  else:
    quote do:
-      proc `duringSym`(`turn`: var Turn; `bindingsSym`: Value; `handleSym`: Handle): TurnAction =
+      proc `duringSym`(`turn`: Turn; `bindingsSym`: Value; `handleSym`: Handle): TurnAction =
        `varSection`
        if fromPreserves(`valuesSym`, `bindingsSym`):
          `publishBody`
-          proc action(`turn`: var Turn) =
+          proc action(`turn`: Turn) =
            `exitBody`
          result = action

@ -187,16 +184,14 @@ macro during*(turn: untyped; ds: Cap; pattern: Pattern; publishBody: untyped) =
    `callbackProc`
    discard observe(`turn`, `ds`, `pattern`, during(`callbackSym`))

-type BootProc = proc (turn: var Turn; ds: Cap) {.gcsafe.}
-type DeprecatedBootProc = proc (ds: Cap; turn: var Turn) {.gcsafe.}
-
-proc runActor*(name: string; bootProc: BootProc) =
-  ## Run an `Actor` to completion.
-  let actor = bootDataspace(name, bootProc)
-  while actor.running:
-    waitFor sleepAsync(500)
-
-proc runActor*(name: string; bootProc: DeprecatedBootProc) {.deprecated.} =
-  ## Run an `Actor` to completion.
-  runActor(name) do (turn: var Turn, ds: Cap):
-    bootProc(ds, turn)
+when defined(solo5):
+  echo """
+    ______
+   /    \_\
+  /  ,__/  \                          ____           __
+ /\__/  \,  \   _______  ______  ____/ /_/________  / /____
+ \/  \__/   /  / ___/ / / / __ \/ __  / / ___/ __ \/ __/ _ \
+  \  '  \__/  _\_ \/ /_/ / / / / /_/ / / /__/ /_/ / /_/  __/
+   \____/_/  /____/\__, /_/ /_/\____/_/\___/\__/_/\__/\___/
+                 /____/
+"""
--- a/src/syndicate/Tupfile
+++ b/src/syndicate/Tupfile
@ -1,3 +1,4 @@
 include_rules
 NIM_FLAGS += --path:$(TUP_CWD)/..
 : foreach *.nim |> !nim_check |>
+: patterns.nim |> !nim_bin |>
--- a/src/syndicate/actors.nim
+++ b/src/syndicate/actors.nim
@ -1,30 +1,27 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense

-import std/[asyncfutures, hashes, monotimes, options, sets, tables, times]
+import std/[assertions, deques, hashes, monotimes, options, sets, tables, times]
+import cps
+
 import preserves
 import ../syndicate/protocols/[protocol, sturdy]
+import ../syndicate/protocols/trace
+
+when defined(solo5):
+  import solo5_dispatcher
+else:
+  import pkg/sys/ioqueue

 const tracing = defined(traceSyndicate)

 when tracing:
  import std/streams
-  from std/os import getEnv
-  import ./protocols/trace
+  when not defined(solo5):
+    from std/os import getEnv

 export Handle

-template generateIdType(typ: untyped) =
-  type typ* = distinct Natural
-  proc `==`*(x, y: typ): bool {.borrow.}
-  proc `$`*(id: typ): string {.borrow.}
-
-generateIdType(ActorId)
-generateIdType(FacetId)
-generateIdType(EndpointId)
-generateIdType(FieldId)
-generateIdType(TurnId)
-
 type
  Oid = sturdy.Oid
  Caveat = sturdy.Caveat
@ -37,11 +34,13 @@ type
      # C code has "redefinition of struct" problems when orc is enabled

  Entity* = ref object of RootObj
+    facet*: Facet
    oid*: Oid # oid is how Entities are identified over the wire

  Cap* {.preservesEmbedded.} = ref object of EmbeddedObj
-    relay*: Facet
    target*: Entity
+    relay*: Facet
+      # Entity has facet but a Cap is also scoped to a relay Facet
    attenuation*: Attenuation

  Ref* {.deprecated: "Ref was renamed to Cap".} = Cap
@ -53,6 +52,7 @@ type
  OutboundTable = Table[Handle, OutboundAssertion]

  Actor* = ref object
+    next: Actor
    name: string
    handleAllocator: ref Handle
      # a fresh actor gets a new ref Handle and
@ -61,18 +61,16 @@ type
    exitReason: ref Exception
    exitHooks: seq[TurnAction]
    id: ActorId
+    facetIdAllocator: uint
    exiting, exited: bool
-    when tracing:
-      turnIdAllocator: ref TurnId
-      traceStream: FileStream

-  TurnAction* = proc (t: var Turn) {.gcsafe.}
+  TurnAction* = proc (t: Turn) {.closure.}

-  Queues = TableRef[Facet, seq[TurnAction]]
-
-  Turn* = object # an object that should remain on the stack
-    facet: Facet
-    queues: Queues # a ref object that can outlive Turn
+  Turn* = var TurnRef
+  TurnRef* = ref object
+    facet: Facet # active facet that may change during a turn
+    work: Deque[tuple[facet: Facet, act: TurnAction]]
+    effects: Table[Actor, TurnRef]
    when tracing:
      desc: TurnDescription

@ -87,81 +85,171 @@ type
    id: FacetId
    isAlive: bool

+var turnQueue {.threadvar.}: Deque[TurnRef]
+
 when tracing:
-
-  proc nextTurnId(facet: Facet): TurnId =
-    result = succ(facet.actor.turnIdAllocator[])
-    facet.actor.turnIdAllocator[] = result
-
-  proc trace(actor: Actor; act: ActorActivation) =
-    if not actor.traceStream.isNil:
-      var entry = TraceEntry(
+  when defined(solo5):
+    proc traceActivation(actor: Actor; act: ActorActivation) =
+      discard #[
+      echo TraceEntry(
          timestamp: getTime().toUnixFloat(),
          actor: initRecord("named", actor.name.toPreserves),
-          item: act)
-      actor.traceStream.writeText entry.toPreserves
-      actor.traceStream.writeLine()
+          item: act,
+        ).toPreserves
+        ]#
+  else:
+    proc openTraceStream: FileStream =
+      let path = getEnv("SYNDICATE_TRACE_FILE")
+      case path
+      of "": stderr.writeLine "$SYNDICATE_TRACE_FILE unset"
+      of "-": result = newFileStream(stderr)
+      else: result = openFileStream(path, fmWrite)

-  proc path(facet: Facet): seq[trace.FacetId] =
+    let traceStream = openTraceStream()
+
+    proc traceActivation(actor: Actor; act: ActorActivation) =
+      if not traceStream.isNil:
+        var entry = TraceEntry(
+            timestamp: getTime().toUnixFloat(),
+            actor: initRecord("named", actor.name.toPreserves),
+            item: act)
+        traceStream.write(entry.toPreserves)
+        traceStream.flush()
+
+  var turnIdAllocator: uint
+
+  proc nextTurnId(): TurnId =
+    inc(turnIdAllocator)
+    turnIdAllocator.toPreserves
+
+  proc path(facet: Facet): seq[FacetId] =
    var f = facet
    while not f.isNil:
      result.add f.id.toPreserves
      f = f.parent

-method publish*(e: Entity; turn: var Turn; v: AssertionRef; h: Handle) {.base, gcsafe.} = discard
-method retract*(e: Entity; turn: var Turn; h: Handle) {.base, gcsafe.} = discard
-method message*(e: Entity; turn: var Turn; v: AssertionRef) {.base, gcsafe.} = discard
-method sync*(e: Entity; turn: var Turn; peer: Cap) {.base, gcsafe.} = discard
+  proc initEnqueue(turn: Turn; cap: Cap): ActionDescription =
+    result = ActionDescription(orKind: ActionDescriptionKind.enqueue)
+    result.enqueue.event.target.actor = turn.facet.actor.id.toPreserves
+    result.enqueue.event.target.facet = turn.facet.id.toPreserves
+    result.enqueue.event.target.oid = cap.target.oid.toPreserves
+
+  proc toDequeue(act: sink ActionDescription): ActionDescription =
+    result = ActionDescription(orKind: ActionDescriptionKind.dequeue)
+    result.dequeue.event = move act.enqueue.event
+
+  proc toTraceTarget(cap: Cap): Target =
+    assert not cap.target.isNil
+    assert not cap.target.facet.isNil
+    result.actor = cap.target.facet.actor.id
+    result.facet = cap.target.facet.id
+    result.oid = cap.target.oid.toPreserves
+
+converter toActor(f: Facet): Actor = f.actor
+converter toActor(t: Turn): Actor = t.facet.actor
+converter toFacet(a: Actor): Facet = a.root
+converter toFacet(t: Turn): Facet = t.facet

 using
  actor: Actor
  facet: Facet
-  turn: var Turn
+  turn: Turn
  action: TurnAction

 proc labels(f: Facet): string =
+  assert not f.isNil
+  assert not f.actor.isNil
+  result.add f.actor.name
  proc catLabels(f: Facet; labels: var string) =
-    labels.add ':'
    if not f.parent.isNil:
      catLabels(f.parent, labels)
      labels.add ':'
-    when tracing:
      labels.add $f.id
-  result.add f.actor.name
  catLabels(f, result)

 proc `$`*(f: Facet): string =
  "<Facet:" & f.labels & ">"

-proc `$`*(r: Cap): string =
-  "<Ref:" & r.relay.labels & ">"
-
 proc `$`*(actor: Actor): string =
  "<Actor:" & actor.name & ">" # TODO: ambigous

-proc attenuate(r: Cap; a: Attenuation): Cap =
+when tracing:
+
+  proc `$`*(r: Cap): string =
+    "<Ref:" & r.relay.labels & ">"
+
+  proc `$`*(t: Turn): string =
+    "<Turn:" & $t.desc.id & ">"
+
+proc attenuate*(r: Cap; a: Attenuation): Cap =
  if a.len == 0: result = r
  else: result = Cap(
-    relay: r.relay,
    target: r.target,
+    relay: r.relay,
    attenuation: a & r.attenuation)

+proc hash*(actor): Hash =
+  result = actor[].unsafeAddr.hash
+
 proc hash*(facet): Hash =
-  facet.id.hash
+  facet[].unsafeAddr.hash

 proc hash*(r: Cap): Hash = !$(r.relay.hash !& r.target.unsafeAddr.hash)

+proc actor*(turn): Actor = turn.facet.actor
+
 proc nextHandle(facet: Facet): Handle =
  result = succ(facet.actor.handleAllocator[])
  facet.actor.handleAllocator[] = result

-proc facet*(turn: var Turn): Facet = turn.facet
+template recallFacet(turn: Turn; body: untyped): untyped =
+  let facet = turn.facet
+  block:
+    body
+  assert facet.actor == turn.facet.actor
+  turn.facet = facet

-proc enqueue(turn: var Turn; target: Facet; action: TurnAction) =
-  if target in turn.queues:
-    turn.queues[target].add action
+proc queueWork*(turn: Turn; facet: Facet; act: TurnAction) =
+  assert not facet.isNil
+  turn.work.addLast((facet, act,))
+
+proc queueTurn*(facet: Facet; act: TurnAction) =
+  var turn = TurnRef(facet: facet)
+  assert not facet.isNil
+  turn.work.addLast((facet, act,))
+  when tracing:
+    turn.desc.id = nextTurnId()
+  turnQueue.addLast(turn)
+
+proc queueTurn*(prev: Turn; facet: Facet; act: TurnAction) =
+  var next = TurnRef(facet: facet)
+  assert not facet.isNil
+  next.work.addLast((facet, act,))
+  when tracing:
+    next.desc.id = nextTurnId()
+    next.desc.cause = TurnCause(orKind: TurnCauseKind.turn)
+    next.desc.cause.turn.id = prev.desc.id
+  turnQueue.addLast(next)
+
+proc run*(facet: Facet; action: TurnAction) = queueTurn(facet, action)
+  ## Alias to queueTurn_.
+
+proc facet*(turn: Turn): Facet = turn.facet
+
+proc queueEffect*(turn: Turn; target: Facet; act: TurnAction) =
+  let fremd = target.actor
+  if fremd == turn.facet.actor:
+    turn.work.addLast((target, act,))
  else:
-    turn.queues[target] = @[action]
+    var fremdTurn = turn.effects.getOrDefault(fremd)
+    if fremdTurn.isNil:
+      fremdTurn = TurnRef(facet: target)
+      turn.effects[fremd] = fremdTurn
+    when tracing:
+      fremdTurn.desc.id = nextTurnId()
+      fremdTurn.desc.cause = TurnCause(orKind: TurnCauseKind.turn)
+      fremdTurn.desc.cause.turn.id = turn.desc.id
+    fremdTurn.work.addLast((target, act,))

 type Bindings = Table[Value, Value]

@ -171,8 +259,7 @@ proc match(bindings: var Bindings; p: Pattern; v: Value): bool =
  of PatternKind.Patom:
    result = case p.patom
      of PAtom.Boolean: v.isBoolean
-      of PAtom.Float: v.isFloat
-      of PAtom.Double: v.isDouble
+      of PAtom.Double: v.isFloat
      of PAtom.Signedinteger: v.isInteger
      of PAtom.String: v.isString
      of PAtom.Bytestring: v.isByteString
@ -276,79 +363,109 @@ proc runRewrites*(a: Attenuation; v: Value): Value =
    result = examineAlternatives(stage, result)
    if result.isFalse: break

-proc publish(turn: var Turn; r: Cap; v: Value; h: Handle) =
-  var a = runRewrites(r.attenuation, v)
-  if not a.isFalse:
-    let e = OutboundAssertion(
-      handle: h, peer: r, established: false)
-    turn.facet.outbound[h] = e
-    enqueue(turn, r.relay) do (turn: var Turn):
-      e.established = true
-      publish(r.target, turn, AssertionRef(value: a), e.handle)
-  when tracing:
-    var act = ActionDescription(orKind: ActionDescriptionKind.enqueue)
-    act.enqueue.event.target.actor = turn.facet.actor.id.toPreserves
-    act.enqueue.event.target.facet = turn.facet.id.toPreserves
-    act.enqueue.event.target.oid = r.target.oid.toPreserves
-    act.enqueue.event.detail = trace.TurnEvent(orKind: TurnEventKind.assert)
-    act.enqueue.event.detail.assert.assertion.value.value =
-      mapEmbeds(v) do (cap: Value) -> Value: discard
-    act.enqueue.event.detail.assert.handle = h
-    turn.desc.actions.add act
+method publish*(e: Entity; turn: Turn; v: AssertionRef; h: Handle) {.base.} = discard

-proc publish*(turn: var Turn; r: Cap; a: Value): Handle =
+proc publish(turn: Turn; cap: Cap; v: Value; h: Handle) =
+  var a = runRewrites(cap.attenuation, v)
+  if not a.isFalse:
+    let e = OutboundAssertion(handle: h, peer: cap)
+    turn.facet.outbound[h] = e
+    when tracing:
+      var act = ActionDescription(orKind: ActionDescriptionKind.enqueue)
+      act.enqueue.event.target.actor = turn.facet.actor.id.toPreserves
+      act.enqueue.event.target.facet = turn.facet.id.toPreserves
+      act.enqueue.event.target.oid = cap.target.oid.toPreserves
+      act.enqueue.event.detail = trace.TurnEvent(orKind: trace.TurnEventKind.assert)
+      act.enqueue.event.detail.assert.assertion.value.value =
+        mapEmbeds(v) do (cap: Value) -> Value: discard
+      act.enqueue.event.detail.assert.handle = h
+      turn.desc.actions.add act
+    queueEffect(turn, cap.relay) do (turn: Turn):
+      e.established = true
+      when tracing:
+        turn.desc.actions.add act.toDequeue
+      publish(cap.target, turn, AssertionRef(value: a), e.handle)
+
+proc publish*(turn: Turn; r: Cap; a: Value): Handle {.discardable.} =
  result = turn.facet.nextHandle()
  publish(turn, r, a, result)

-proc publish*[T](turn: var Turn; r: Cap; a: T): Handle =
+proc publish*[T](turn: Turn; r: Cap; a: T): Handle {.discardable.} =
  publish(turn, r, a.toPreserves)

-proc retract(turn: var Turn; e: OutboundAssertion) =
-  enqueue(turn, e.peer.relay) do (turn: var Turn):
+method retract*(e: Entity; turn: Turn; h: Handle) {.base.} = discard
+
+proc retract(turn: Turn; e: OutboundAssertion) =
+  when tracing:
+    var act = initEnqueue(turn, e.peer)
+    act.enqueue.event.detail = trace.TurnEvent(orKind: TurnEventKind.retract)
+    act.enqueue.event.detail.retract.handle = e.handle
+    turn.desc.actions.add act
+  queueEffect(turn, e.peer.relay) do (turn: Turn):
+    when tracing:
+      turn.desc.actions.add act.toDequeue
    if e.established:
      e.established = false
      e.peer.target.retract(turn, e.handle)

-proc retract*(turn: var Turn; h: Handle) =
+proc retract*(turn: Turn; h: Handle) =
  var e: OutboundAssertion
  if turn.facet.outbound.pop(h, e):
    turn.retract(e)

-proc message*(turn: var Turn; r: Cap; v: Value) =
+method message*(e: Entity; turn: Turn; v: AssertionRef) {.base.} = discard
+
+proc message*(turn: Turn; r: Cap; v: Value) =
  var a = runRewrites(r.attenuation, v)
  if not a.isFalse:
-    enqueue(turn, r.relay) do (turn: var Turn):
+    when tracing:
+      var act = initEnqueue(turn, r)
+      act.enqueue.event.detail = trace.TurnEvent(orKind: TurnEventKind.message)
+      act.enqueue.event.detail.message.body.value.value =
+        mapEmbeds(a) do (cap: Value) -> Value: discard
+      turn.desc.actions.add act
+    queueEffect(turn, r.relay) do (turn: Turn):
+      when tracing:
+        turn.desc.actions.add act.toDequeue
      r.target.message(turn, AssertionRef(value: a))

-proc message*[T](turn: var Turn; r: Cap; v: T) =
+proc message*[T](turn: Turn; r: Cap; v: T) =
  message(turn, r, v.toPreserves)

-proc sync(turn: var Turn; e: Entity; peer: Cap) =
-  e.sync(turn, peer)
+method sync*(e: Entity; turn: Turn; peer: Cap) {.base.} =
+  queueTurn(e.facet) do (turn: Turn):
+    message(turn, peer, true.toPreserves)
+      # complete sync on a later turn

-proc sync*(turn: var Turn; r, peer: Cap) =
-  enqueue(turn, r.relay) do (turn: var Turn):
-    sync(turn, r.target, peer)
+proc sync*(turn: Turn; r, peer: Cap) =
+  when tracing:
+    var act = initEnqueue(turn, peer)
+    act.enqueue.event.detail = trace.TurnEvent(orKind: TurnEventKind.sync)
+    act.enqueue.event.detail.sync.peer = peer.toTraceTarget
+    turn.desc.actions.add act
+  queueEffect(turn, r.relay) do (turn: Turn):
+    when tracing:
+      turn.desc.actions.add act.toDequeue
+    r.target.sync(turn, peer)

-proc replace*[T](turn: var Turn; cap: Cap; h: Handle; v: T): Handle =
+proc replace*[T](turn: Turn; cap: Cap; h: Handle; v: T): Handle =
  result = publish(turn, cap, v)
  if h != default(Handle):
    retract(turn, h)

-proc replace*[T](turn: var Turn; cap: Cap; h: var Handle; v: T): Handle {.discardable.} =
+proc replace*[T](turn: Turn; cap: Cap; h: var Handle; v: T): Handle {.discardable.} =
  var old = h
  h = publish(turn, cap, v)
  if old != default(Handle):
    retract(turn, old)
  h

-proc stop*(turn: var Turn) {.gcsafe.}
-
-proc run*(facet; action: TurnAction; zombieTurn = false) {.gcsafe.}
+proc stop*(turn: Turn)

 proc newFacet(actor; parent: Facet; initialAssertions: OutboundTable): Facet =
+  inc actor.facetIdAllocator
  result = Facet(
-    id: getMonoTime().ticks.FacetId,
+    id: actor.facetIdAllocator.toPreserves,
    actor: actor,
    parent: parent,
    outbound: initialAssertions,
@ -360,127 +477,147 @@ proc newFacet(actor; parent: Facet): Facet =
  newFacet(actor, parent, initialAssertions)

 proc isInert(facet): bool =
-  result = facet.children.len == 0 and
-    (facet.outbound.len == 0 or facet.parent.isNil) and
-    facet.inertCheckPreventers == 0
+  let
+    noKids = facet.children.len == 0
+    noOutboundHandles = facet.outbound.len == 0
+    isRootFacet = facet.parent.isNil
+    noInertCheckPreventers = facet.inertCheckPreventers == 0
+  result = noKids and (noOutboundHandles or isRootFacet) and noInertCheckPreventers

-proc preventInertCheck*(facet): (proc() {.gcsafe.}) {.discardable.} =
-  var armed = true
-  inc facet.inertCheckPreventers
-  proc disarm() =
-    if armed:
-      armed = false
-      dec facet.inertCheckPreventers
-  result = disarm
+proc preventInertCheck*(turn: Turn) =
+  inc turn.facet.inertCheckPreventers

-proc inFacet(turn: var Turn; facet; act: TurnAction) =
-  ## Call an action with a facet using a temporary `Turn`
-  ## that shares the `Queues` of the calling `Turn`.
-  var t = Turn(facet: facet, queues: turn.queues)
-  act(t)
+proc terminateActor(turn; reason: ref Exception)

-proc terminate(actor; turn; reason: ref Exception) {.gcsafe.}
-
-proc terminate(facet; turn: var Turn; orderly: bool) {.gcsafe.} =
+proc terminateFacetOrderly(turn: Turn) =
+  let facet = turn.facet
  if facet.isAlive:
    facet.isAlive = false
-    let parent = facet.parent
-    if not parent.isNil:
-      parent.children.excl facet
-    block:
-      var turn = Turn(facet: facet, queues: turn.queues)
-      while facet.children.len > 0:
-        facet.children.pop.terminate(turn, orderly)
-      if orderly:
-        for act in facet.shutdownActions:
-          act(turn)
-      for a in facet.outbound.values: turn.retract(a)
-      if orderly:
-        if not parent.isNil:
-          if parent.isInert:
-            parent.terminate(turn, true)
-        else:
-          terminate(facet.actor, turn, nil)
+    var i = 0
+    while i < facet.shutdownActions.len:
+      facet.shutdownActions[i](turn)
+      inc i
+    setLen facet.shutdownActions, 0
+    for e in facet.outbound.values:
+      retract(turn, e)
+    clear facet.outbound
+
+proc inertCheck(turn: Turn) =
+  if (not turn.facet.parent.isNil and
+        (not turn.facet.parent.isAlive)) or
+      turn.facet.isInert:
    when tracing:
      var act = ActionDescription(orKind: ActionDescriptionKind.facetStop)
-      act.facetstop.path = facet.path
+      act.facetstop.path = turn.facet.path
+      act.facetstop.reason = FacetStopReason.inert
      turn.desc.actions.add act
+    stop(turn)
+
+proc terminateFacet(turn: Turn) =
+  let facet = turn.facet
+  for child in facet.children:
+    queueWork(turn, child, terminateFacetOrderly)
+      # terminate all children
+  facet.children.clear()
+    # detach all children
+  queueWork(turn, facet, terminateFacetOrderly)
+    # self-termination

 proc stopIfInertAfter(action: TurnAction): TurnAction =
-  proc wrapper(turn: var Turn) =
+  proc work(turn: Turn) =
+    queueEffect(turn, turn.facet, inertCheck)
    action(turn)
-    enqueue(turn, turn.facet) do (turn: var Turn):
-      if (not turn.facet.parent.isNil and
-            (not turn.facet.parent.isAlive)) or
-          turn.facet.isInert:
-        stop(turn)
-  wrapper
+  work

-proc newFacet*(turn: var Turn): Facet = newFacet(turn.facet.actor, turn.facet)
+proc newFacet(turn: Turn): Facet = newFacet(turn.facet.actor, turn.facet)

-proc inFacet*(turn: var Turn; bootProc: TurnAction): Facet =
+proc inFacet*(turn: Turn; bootProc: TurnAction): Facet {.discardable.} =
  result = newFacet(turn)
-  when tracing:
-    var act = ActionDescription(orKind: ActionDescriptionKind.facetstart)
-    act.facetstart.path.add result.path
-    turn.desc.actions.add act
-  inFacet(turn, result, stopIfInertAfter(bootProc))
+  recallFacet turn:
+    turn.facet = result
+    when tracing:
+      var act = ActionDescription(orKind: ActionDescriptionKind.facetstart)
+      act.facetstart.path.add result.path
+      turn.desc.actions.add act
+    stopIfInertAfter(bootProc)(turn)

-proc facet*(turn: var Turn; bootProc: TurnAction): Facet {.deprecated.} = inFacet(turn, bootProc)
-
-proc newActor(name: string; handleAlloc: ref Handle): Actor =
-  let
-    now = getTime()
-    seed = now.toUnix * 1_000_000_000 + now.nanosecond
+proc newActor(name: string; parent: Facet): Actor =
  result = Actor(
    name: name,
-    id: ActorId(seed),
-    handleAllocator: handleAlloc,
+    id: name.toPreserves,
  )
-  result.root = newFacet(result, nil)
+  if parent.isNil:
+    new result.handleAllocator
+  else:
+    result.handleAllocator = parent.actor.handleAllocator
+  result.root = newFacet(result, parent)
  when tracing:
    var act = ActorActivation(orKind: ActorActivationKind.start)
    act.start.actorName = Name(orKind: NameKind.named)
    act.start.actorName.named.name = name.toPreserves
-    trace(result, act)
+    traceActivation(result, act)

-proc run(actor; bootProc: TurnAction; initialAssertions: OutboundTable) =
-  run(newFacet(actor, actor.root, initialAssertions), stopIfInertAfter(bootProc))
+proc run(actor: Actor; bootProc: TurnAction; initialAssertions: OutboundTable) =
+  queueTurn(newFacet(actor, actor.root, initialAssertions), stopIfInertAfter(bootProc))

-proc bootActor*(name: string; bootProc: TurnAction): Actor =
-  var initialAssertions: OutboundTable
-  result = newActor(name, new(ref Handle))
+proc bootActor*(name: string; bootProc: TurnAction): Actor {.discardable.} =
+  ## Boot a top-level actor.
+  result = newActor(name, nil)
+  new result.handleAllocator
+  var turn = TurnRef(facet: result.root)
+  assert not result.root.isNil
+  turn.work.addLast((result.root, bootProc,))
  when tracing:
-    new result.turnIdAllocator
-    let path = getEnv("SYNDICATE_TRACE_FILE", "/tmp/" & name & ".trace.pr")
-    case path
-    of "": stderr.writeLine "$SYNDICATE_TRACE_FILE unset, not tracing actor ", name
-    of "-": result.traceStream = newFileStream(stderr)
-    else: result.traceStream = openFileStream(path, fmWrite)
-  run(result, bootProc, initialAssertions)
+    turn.desc.id = nextTurnId()
+    turn.desc.cause = TurnCause(orKind: TurnCauseKind.external)
+    turn.desc.cause.external.description = "bootActor".toPreserves
+  turnQueue.addLast turn

-proc spawn*(name: string; turn: var Turn; bootProc: TurnAction; initialAssertions = initHashSet[Handle]()): Actor =
-  let actor = newActor(name, turn.facet.actor.handleAllocator)
-  enqueue(turn, turn.facet) do (turn: var Turn):
+proc spawnActor*(turn: Turn; name: string; bootProc: TurnAction; initialAssertions = initHashSet[Handle]()): Actor {.discardable.} =
+  let actor = newActor(name, turn.facet)
+  queueEffect(turn, actor.root) do (turn: Turn):
    var newOutBound: Table[Handle, OutboundAssertion]
    for key in initialAssertions:
      discard turn.facet.outbound.pop(key, newOutbound[key])
    when tracing:
-      actor.turnIdAllocator = turn.facet.actor.turnIdAllocator
-      actor.traceStream = turn.facet.actor.traceStream
      var act = ActionDescription(orKind: ActionDescriptionKind.spawn)
      act.spawn.id = actor.id.toPreserves
      turn.desc.actions.add act
    run(actor, bootProc, newOutBound)
  actor

+proc spawn*(name: string; turn: Turn; bootProc: TurnAction; initialAssertions = initHashSet[Handle]()): Actor {.discardable.} =
+  spawnActor(turn, name, bootProc, initialAssertions)
+
+type StopOnRetract = ref object of Entity
+
+method retract*(e: StopOnRetract; turn: Turn; h: Handle) =
+  stop(turn)
+
+proc halfLink(facet, other: Facet) =
+  let h = facet.nextHandle()
+  facet.outbound[h] = OutboundAssertion(
+      handle: h,
+      peer: Cap(relay: other, target: StopOnRetract(facet: facet)),
+      established: true,
+    )
+
+proc linkActor*(turn: Turn; name: string; bootProc: TurnAction; initialAssertions = initHashSet[Handle]()): Actor {.discardable.} =
+  result = spawnActor(turn, name, bootProc, initialAssertions)
+  halfLink(turn.facet, result.root)
+  halfLink(result.root, turn.facet)
+
+var inertActor {.threadvar.}: Actor
+
 proc newInertCap*(): Cap =
-  let a = bootActor("inert") do (turn: var Turn): turn.stop()
-  Cap(relay: a.root)
+  if inertActor.isNil:
+    inertActor = bootActor("inert") do (turn: Turn): turn.stop()
+  Cap(relay: inertActor.root)

 proc atExit*(actor; action) = actor.exitHooks.add action

-proc terminate(actor; turn; reason: ref Exception) =
+proc terminateActor(turn; reason: ref Exception) =
+  let actor = turn.actor
  if not actor.exiting:
    actor.exiting = true
    actor.exitReason = reason
@ -489,122 +626,185 @@ proc terminate(actor; turn; reason: ref Exception) =
      if not reason.isNil:
        act.stop.status = ExitStatus(orKind: ExitStatusKind.Error)
        act.stop.status.error.message = reason.msg
-      trace(actor, act)
-    for hook in actor.exitHooks: hook(turn)
-    proc finish(turn: var Turn) =
-      actor.root.terminate(turn, reason.isNil)
+      traceActivation(actor, act)
+    while actor.exitHooks.len > 0:
+      var hook = actor.exitHooks.pop()
+      try: hook(turn)
+      except CatchableError as err:
+        if reason.isNil:
+          terminateActor(turn, err)
+          return
+    proc finish(turn: Turn) =
+      assert not actor.root.isNil, actor.name
+      terminateFacet(turn)
+      actor.root = nil
      actor.exited = true
-    callSoon do ():
-      run(actor.root, finish, true)
+    queueTurn(actor.root, finish)

-proc terminate*(facet; e: ref Exception) =
-  run(facet.actor.root) do (turn: var Turn):
-    facet.actor.terminate(turn, e)
+proc terminateFacet*(facet; e: ref Exception) =
+  run(facet.actor.root) do (turn: Turn):
+    terminateActor(turn, e)

-proc asyncCheck*(facet: Facet; fut: FutureBase) =
-  ## Sets a callback on `fut` which propagates exceptions to `facet`.
-  addCallback(fut) do ():
-    if fut.failed: terminate(facet, fut.error)
+proc terminate*(turn: Turn; e: ref Exception) =
+    terminateActor(turn, e)

-proc asyncCheck*(turn; fut: FutureBase) =
-  ## Sets a callback on `fut` which propagates exceptions to the facet of `turn`.
-  asyncCheck(turn.facet, fut)
+proc stop*(turn: Turn, facet: Facet) =
+  queueEffect(turn, facet) do (turn: Turn):
+    when tracing:
+      var act = ActionDescription(orKind: ActionDescriptionKind.facetStop)
+      act.facetstop.path = facet.path
+      act.facetstop.reason = FacetStopReason.explicitAction
+      turn.desc.actions.add act
+    terminateFacet(turn)

-template tryFacet(facet; body: untyped) =
-  try: body
-  except CatchableError as err: terminate(facet, err)
-
-proc run*(facet; action: TurnAction; zombieTurn = false) =
-  if zombieTurn or (facet.actor.exitReason.isNil and facet.isAlive):
-    tryFacet(facet):
-      var queues = newTable[Facet, seq[TurnAction]]()
-      block:
-        var turn = Turn(facet: facet, queues: queues)
-        action(turn)
-        when tracing:
-          turn.desc.id = facet.nextTurnId.toPreserves
-          facet.actor.trace ActorActivation(
-              orKind: ActorActivationKind.turn, turn: turn.desc)
-      for facet, queue in queues:
-        for action in queue: run(facet, action)
-
-proc run*(cap: Cap; action: TurnAction) =
-  ## Convenience proc to run a `TurnAction` in the scope of a `Cap`.
-  run(cap.relay, action)
-
-proc addCallback*(fut: FutureBase; facet: Facet; act: TurnAction) =
-  ## Add a callback to a `Future` that will be called at a later `Turn`
-  ## within the context of `facet`.
-  addCallback(fut) do ():
-    if fut.failed: terminate(facet, fut.error)
-    else:
-      when tracing:
-        run(facet) do (turn: var Turn):
-          turn.desc.cause = TurnCause(orKind: TurnCauseKind.external)
-          turn.desc.cause.external.description = "Future".toPreserves
-          act(turn)
-      else:
-        run(facet, act)
-
-proc addCallback*(fut: FutureBase; turn: var Turn; act: TurnAction) =
-  ## Add a callback to a `Future` that will be called at a later `Turn`
-  ## with the same context as the current.
-  if fut.failed:
-    terminate(turn.facet, fut.error)
-  elif fut.finished:
-    enqueue(turn, turn.facet, act)
-  else:
-    addCallback(fut, turn.facet, act)
-
-proc addCallback*[T](fut: Future[T]; turn: var Turn; act: proc (t: var Turn, x: T) {.gcsafe.}) =
-  addCallback(fut, turn) do (turn: var Turn):
-    if fut.failed: terminate(turn.facet, fut.error)
-    else:
-      when tracing:
-        turn.desc.cause = TurnCause(orKind: TurnCauseKind.external)
-        turn.desc.cause.external.description = "Future".toPreserves
-      act(turn, read fut)
-
-proc stop*(turn: var Turn, facet: Facet) =
-  if facet.parent.isNil:
-      facet.terminate(turn, true)
-  else:
-    enqueue(turn, facet.parent) do (turn: var Turn):
-      facet.terminate(turn, true)
-
-proc stop*(turn: var Turn) =
+proc stop*(turn: Turn) =
  stop(turn, turn.facet)

+proc stop*(facet: Facet) =
+  run(facet, stop)
+
 proc onStop*(facet: Facet; act: TurnAction) =
-  ## Add a `proc (turn: var Turn)` action to `facet` to be called as it stops.
+  ## Add a `proc (turn: Turn)` action to `facet` to be called as it stops.
  add(facet.shutdownActions, act)

-proc stopActor*(turn: var Turn) =
-  let actor = turn.facet.actor
-  enqueue(turn, actor.root) do (turn: var Turn):
-    terminate(actor, turn, nil)
+proc onStop*(turn: Turn; act: TurnAction) =
+  onStop(turn.facet, act)

-proc freshen*(turn: var Turn, act: TurnAction) =
-  assert(turn.queues.len == 0, "Attempt to freshen a non-stale Turn")
+proc isAlive(actor): bool =
+  not(actor.exited or actor.exiting)
+
+proc stop*(actor: Actor) =
+  if actor.isAlive:
+    queueTurn(actor.root) do (turn: Turn):
+      assert(not turn.facet.isNil)
+      when tracing:
+        var act = ActionDescription(orKind: ActionDescriptionKind.facetStop)
+        act.facetstop.path = turn.facet.path
+        act.facetstop.reason = FacetStopReason.actorStopping
+        turn.desc.actions.add act
+      stop(turn, turn.facet)
+
+proc stopActor*(facet: Facet) =
+  stop(facet.actor)
+
+proc stopActor*(turn: Turn) =
+  stop(turn, turn.facet.actor.root)
+
+proc freshen*(turn: Turn, act: TurnAction) {.deprecated.} =
  run(turn.facet, act)

-proc newCap*(relay: Facet; e: Entity): Cap =
-  Cap(relay: relay, target: e)
+proc newCap*(relay: Facet; entity: Entity): Cap =
+  ## Create a new capability for `entity` via `relay`.
+  # An Entity has an owning facet and a Cap does as well?
+  if entity.facet.isNil: entity.facet = relay
+  Cap(relay: relay, target: entity)

 proc newCap*(turn; e: Entity): Cap =
-  Cap(relay: turn.facet, target: e)
+  newCap(turn.facet, e)
+proc newCap*(e: Entity; turn): Cap =
+  newCap(turn.facet, e)

 type SyncContinuation {.final.} = ref object of Entity
  action: TurnAction

-method message(entity: SyncContinuation; turn: var Turn; v: AssertionRef) =
+method message(entity: SyncContinuation; turn: Turn; v: AssertionRef) =
  entity.action(turn)

-proc sync*(turn: var Turn; refer: Cap; act: TurnAction) =
-  let e = SyncContinuation(action: act)
+proc sync*(turn: Turn; refer: Cap; act: TurnAction) =
  sync(turn, refer, newCap(turn, SyncContinuation(action: act)))

 proc running*(actor): bool =
  result = not actor.exited
  if not (result or actor.exitReason.isNil):
    raise actor.exitReason
+
+proc run(turn: Turn) =
+  while turn.work.len > 0:
+    var (facet, act) = turn.work.popFirst()
+    assert not act.isNil
+    turn.facet = facet
+    act(turn)
+  when tracing:
+    var act = ActorActivation(orKind: ActorActivationKind.turn)
+    act.turn = move turn.desc
+    traceActivation(turn.facet.actor, act)
+  # TODO: catch exceptions here
+  for eff in turn.effects.mvalues:
+    assert not eff.facet.isNil
+    turnQueue.addLast(move eff)
+  turn.facet = nil # invalidate the turn
+
+proc runPendingTurns* =
+  while turnQueue.len > 0:
+    var turn = turnQueue.popFirst()
+    # TODO: check if actor is still valid
+    try: run(turn)
+    except CatchableError as err:
+      terminateActor(turn, err)
+      raise err
+
+proc runOnce*: bool {.discardable.} =
+  ## Run pending turns if there are any, otherwise
+  ## poll for external events and run any resulting turns.
+  ## Return true if any turns have been processed.
+  if turnQueue.len == 0:
+    when defined(solo5):
+      discard solo5_dispatcher.runOnce()
+    else:
+      var ready: seq[Continuation]
+      ioqueue.poll(ready)
+      while ready.len > 0:
+        discard trampoline:
+          ready.pop()
+  result = turnQueue.len > 0
+  runPendingTurns()
+
+proc run* =
+  ## Run actors to completion.
+  when defined(solo5):
+    while turnQueue.len > 0 or solo5_dispatcher.runOnce():
+      runPendingTurns()
+  else:
+    var ready: seq[Continuation]
+    while true:
+      runPendingTurns()
+      ioqueue.poll(ready)
+      if ready.len == 0: break
+      while ready.len > 0:
+        discard trampoline:
+          ready.pop()
+
+proc runActor*(name: string; bootProc: TurnAction) =
+  ## Boot an actor `Actor` and churn ioqueue.
+  let actor = bootActor(name, bootProc)
+  if not actor.exitReason.isNil:
+    raise actor.exitReason
+  when defined(solo5):
+    runPendingTurns()
+    while (actor.isAlive and solo5_dispatcher.runOnce()) or turnQueue.len > 0:
+      runPendingTurns()
+  else:
+    actors.run()
+  if not actor.exitReason.isNil:
+    raise actor.exitReason
+
+type FacetGuard* = object
+  facet: Facet
+
+proc initGuard*(f: Facet): FacetGuard =
+  result.facet = f
+  inc result.facet.inertCheckPreventers
+
+proc disarm*(g: var FacetGuard) =
+  if not g.facet.isNil:
+    assert g.facet.inertCheckPreventers > 0
+    dec g.facet.inertCheckPreventers
+    g.facet = nil
+
+proc `=destroy`*(g: FacetGuard) =
+  if not g.facet.isNil:
+    dec g.facet.inertCheckPreventers
+
+proc `=copy`*(dst: var FacetGuard, src: FacetGuard) =
+  dst.facet = src.facet
+  inc dst.facet.inertCheckPreventers
--- a/src/syndicate/actors/timers.nim
+++ b/src/syndicate/actors/timers.nim
@ -1,35 +0,0 @@
-# SPDX-FileCopyrightText: ☭ Emery Hemingway
-# SPDX-License-Identifier: Unlicense
-
-import std/[asyncdispatch, monotimes, times]
-import preserves
-import syndicate
-
-import ../protocols/timer
-from syndicate/protocols/dataspace import Observe
-
-export timer
-
-type Observe = dataspace.Observe
-
-proc now: float64 = getTime().toUnixFloat()
-
-proc spawnTimers*(turn: var Turn; ds: Cap): Actor {.discardable.} =
-  ## Spawn a timer actor.
-  spawn("timer", turn) do (turn: var Turn):
-
-    during(turn, ds, inject(grab Observe(pattern: dropType LaterThan), {0: grabLit()})) do (seconds: float):
-      let period = seconds - now()
-      if period < 0.001:
-        discard publish(turn, ds, LaterThan(seconds: seconds))
-      else:
-        addCallback(sleepAsync(period * 1_000), turn) do (turn: var Turn):
-          discard publish(turn, ds, LaterThan(seconds: seconds))
-
-proc after*(turn: var Turn; ds: Cap; dur: Duration; act: TurnAction) =
-  ## Execute `act` after some duration of time.
-  let later = now() + dur.inMilliseconds.float64 * 1_000.0
-  onPublish(turn, ds, grab LaterThan(seconds: later)):
-    act(turn)
-
-# TODO: periodic timer
--- a/src/syndicate/bags.nim
+++ b/src/syndicate/bags.nim
@ -4,7 +4,7 @@
 ## An unordered association of items to counts.
 ## An item count may be negative, unlike CountTable.

-import tables
+import std/[assertions, tables]

 type
  ChangeDescription* = enum
@ -46,3 +46,5 @@ proc `$`*(bag: Bag): string =
    if result.len > 1: result.add ' '
    result.add $x
  result.add '}'
+
+export tables.contains, tables.del, tables.len
--- a/src/syndicate/dataflow.nim
+++ b/src/syndicate/dataflow.nim
@ -51,7 +51,7 @@ iterator observersOf[Sid, Oid](g: Graph[Sid, Oid]; oid: Oid): Sid =
  if g.edgesForward.hasKey(oid):
    for sid in g.edgesForward[oid]: yield sid

-proc repairDamage*[Sid, Oid](g: var Graph[Sid, Oid]; repairNode: proc (sid: Sid) {.gcsafe.}) =
+proc repairDamage*[Sid, Oid](g: var Graph[Sid, Oid]; repairNode: proc (sid: Sid) {.closure.}) =
  var repairedThisRound: Set[Oid]
  while true:
    var workSet = move g.damagedNodes
--- a/src/syndicate/dataspaces.nim
+++ b/src/syndicate/dataspaces.nim
@ -16,14 +16,14 @@ type
    index: Index
    handleMap: Table[Handle, Assertion]

-method publish(ds: Dataspace; turn: var Turn; a: AssertionRef; h: Handle) {.gcsafe.} =
+method publish(ds: Dataspace; turn: Turn; a: AssertionRef; h: Handle) =
  if add(ds.index, turn, a.value):
    var obs = a.value.preservesTo(Observe)
    if obs.isSome and obs.get.observer of Cap:
      ds.index.add(turn, obs.get.pattern, Cap(obs.get.observer))
  ds.handleMap[h] = a.value

-method retract(ds: Dataspace; turn: var Turn; h: Handle) {.gcsafe.} =
+method retract(ds: Dataspace; turn: Turn; h: Handle) =
  let v = ds.handleMap[h]
  if remove(ds.index, turn, v):
    ds.handleMap.del h
@ -31,20 +31,20 @@ method retract(ds: Dataspace; turn: var Turn; h: Handle) {.gcsafe.} =
    if obs.isSome and obs.get.observer of Cap:
      ds.index.remove(turn, obs.get.pattern, Cap(obs.get.observer))

-method message(ds: Dataspace; turn: var Turn; a: AssertionRef) {.gcsafe.} =
+method message(ds: Dataspace; turn: Turn; a: AssertionRef) =
  ds.index.deliverMessage(turn, a.value)

-proc newDataspace*(turn: var Turn): Cap =
+proc newDataspace*(turn: Turn): Cap =
  newCap(turn, Dataspace(index: initIndex()))

-type BootProc = proc (turn: var Turn; ds: Cap) {.gcsafe.}
-type DeprecatedBootProc = proc (ds: Cap; turn: var Turn) {.gcsafe.}
+type BootProc = proc (turn: Turn; ds: Cap) {.closure.}
+type DeprecatedBootProc = proc (ds: Cap; turn: Turn) {.closure.}

 proc bootDataspace*(name: string; bootProc: BootProc): Actor =
-  bootActor(name) do (turn: var Turn):
-    discard turn.facet.preventInertCheck()
+  bootActor(name) do (turn: Turn):
+    turn.preventInertCheck()
    bootProc(turn, newDataspace(turn))

 proc bootDataspace*(name: string; bootProc: DeprecatedBootProc): Actor {.deprecated.} =
-  bootDataspace(name) do (turn: var Turn, ds: Cap):
+  bootDataspace(name) do (turn: Turn, ds: Cap):
    bootProc(ds, turn)
--- a/src/syndicate/drivers/Tupfile
+++ b/src/syndicate/drivers/Tupfile
--- a/src/syndicate/drivers/http_driver.nim
+++ b/src/syndicate/drivers/http_driver.nim
@ -0,0 +1,343 @@
+# SPDX-FileCopyrightText: ☭ Emery Hemingway
+# SPDX-License-Identifier: Unlicense
+
+import std/[httpcore, options, parseutils, sets, streams, strutils, tables, times, uri]
+import preserves, ../../syndicate, ../bags, ./timers
+import ../protocols/http
+import taps
+
+const
+  CRLF = "\x0d\x0a"
+  SP = { ' ', '\x09', '\x0b', '\x0c', '\x0d' }
+  SupportedVersion = "HTTP/1.1"
+  IMF = initTimeFormat"ddd, dd MMM yyyy HH:mm:ss"
+
+when defined(posix):
+  proc echo(args: varargs[string, `$`]) {.used.} =
+    stderr.writeLine(args)
+
+proc badRequest(conn: Connection; msg: string) =
+  conn.send(SupportedVersion & " 400 " & msg, endOfMessage = true)
+
+proc extractQuery(s: var string): Table[Symbol, seq[QueryValue]] =
+  let start = succ skipUntil(s, '?')
+  if start < s.len:
+    var query = s[start..s.high]
+    s.setLen(pred start)
+    for key, val in uri.decodeQuery(query):
+      var list = result.getOrDefault(Symbol key)
+      list.add QueryValue(orKind: QueryValueKind.string, string: val)
+      result[Symbol key] = list
+
+proc parseRequest(conn: Connection; text: string): (int, HttpRequest) =
+  ## Parse an `HttpRequest` request out of a `text` from a `Connection`.
+  result[1].host = RequestHost(orKind: RequestHostKind.absent)
+  result[1].body = RequestBody(orKind: RequestBodyKind.absent)
+
+  var
+    token: string
+    off: int
+
+  template advanceSp =
+    let n = skipWhile(text, SP, off)
+    if n < 1:
+      badRequest(conn, "invalid request")
+      return
+    inc(off, n)
+
+  # method
+  off.inc parseUntil(text, token, SP, off)
+  result[1].method = token.toLowerAscii.Symbol
+  advanceSp()
+
+  # target
+  if text[off] == '/': inc(off) #TODO: always a leading slash?
+  off.inc parseUntil(text, token, SP, off)
+  advanceSp()
+
+  block:
+    var version: string
+    off.inc parseUntil(text, version, SP, off)
+    advanceSp()
+    if version != SupportedVersion:
+      badRequest(conn, "version not supported")
+      return
+
+  result[1].query = extractQuery(token)
+
+  if token != "":
+    result[1].path = split(token, '/')
+    for p in result[1].path.mitems:
+      # normalize the path
+      for i, c in p:
+        if c in {'A'..'Z'}:
+          p[i] = char c.ord + 0x20
+
+  template advanceLine =
+    inc off, skipWhile(text, {'\x0d'}, off)
+    if text.high < off or text[off] != '\x0a':
+      badRequest(conn, "invalid request")
+      return
+    inc off, 1
+
+  advanceLine()
+  while off < text.len:
+    off.inc parseUntil(text, token, {'\x0d', '\x0a'}, off)
+    if token == "": break
+    advanceLine()
+    var
+      (key, vals) = httpcore.parseHeader(token)
+      k = key.toLowerAscii.Symbol
+      v = result[1].headers.getOrDefault(k)
+    for e in vals.mitems:
+      e = e.toLowerAscii
+      if k == Symbol"host":
+        result[1].host = RequestHost(orKind: RequestHostKind.`present`, present: e)
+      if v == "": v = move e
+      else:
+        v.add ", "
+        v.add e
+      if k == Symbol"host":
+        result[1].host = RequestHost(orKind: RequestHostKind.`present`, present: v)
+      result[1].headers[k] = v
+
+  result[0] = off
+
+proc len(chunk: Chunk): int =
+  case chunk.orKind
+  of ChunkKind.string: chunk.string.len
+  of ChunkKind.bytes: chunk.bytes.len
+
+proc lenLine(chunk: Chunk): string =
+  result = chunk.len.toHex.strip(true, false, {'0'})
+  result.add CRLF
+
+type
+  Driver = ref object
+    facet: Facet
+    ds, timers: Cap
+    bindings: Bag[Value]
+      # cannot make a bag of HttpBinding, no `==` operator
+    sequenceNumber: BiggestInt
+  Session = ref object
+    facet: Facet
+    driver: Driver
+    conn: Connection
+    port: Port
+  Exchange = ref object of Entity
+    ses: Session
+    req: HttpRequest
+    stream: StringStream
+    mode: HttpResponseKind
+    active: bool
+
+proc send[T: byte|char](ses: Session; data: openarray[T]) =
+  ses.conn.send(addr data[0], data.len, endOfMessage = false)
+
+proc send(ses: Session; chunk: Chunk) =
+  case chunk.orKind
+  of ChunkKind.string:
+    ses.send(chunk.string)
+  of ChunkKind.bytes:
+    ses.send(chunk.bytes)
+
+func `==`(s: string; rh: RequestHost): bool =
+  rh.orKind == RequestHostKind.present and rh.present == s
+
+proc match(b: HttpBinding, r: HttpRequest): bool =
+  ## Check if `HttpBinding` `b` matches `HttpRequest` `r`.
+  result =
+    (b.host.orKind == HostPatternKind.any or
+      b.host.host == r.host) and
+    (b.port == r.port) and
+    (b.method.orKind == MethodPatternKind.any or
+        b.method.specific == r.method)
+  if result:
+    for i, p in b.path:
+      if i > r.path.high: return false
+      case p.orKind
+      of PathPatternElementKind.wildcard: discard
+      of PathPatternElementKind.label:
+        if p.label != r.path[i]: return false
+      of PathPatternElementKind.rest:
+        return i == b.path.high
+          # return false if ... isn't the last element
+
+proc strongerThan(a, b: HttpBinding): bool =
+  ## Check if `a` is a stronger `HttpBinding` than `b`.
+  result =
+    (a.host.orKind != b.host.orKind and
+      a.host.orKind == HostPatternKind.host) or
+    (a.method.orKind != b.method.orKind and
+      a.method.orKind == MethodPatternKind.specific)
+  if not result:
+    if a.path.len > b.path.len: return true
+    for i in b.path.low..a.path.high:
+      if a.path[i].orKind != b.path[i].orKind and
+          a.path[i].orKind == PathPatternElementKind.label:
+        return true
+
+proc match(driver: Driver; req: HttpRequest): Option[HttpBinding] =
+  var b: HttpBinding
+  for p in driver.bindings:
+    if b.fromPreserves(p) and b.match req:
+      if result.isNone or b.strongerThan(result.get):
+        result = some b
+
+method message(e: Exchange; turn: Turn; a: AssertionRef) =
+  # Send responses back into a connection.
+  var res: HttpResponse
+  if e.mode != HttpResponseKind.done and res.fromPreserves a.value:
+    case res.orKind
+
+    of HttpResponseKind.status:
+      if e.mode == res.orKind:
+        e.active = true
+        e.ses.conn.startBatch()
+        e.stream.write(
+            SupportedVersion, " ", res.status.code, " ", res.status.message, CRLF,
+            "date: ", now().format(IMF), CRLF)
+          # add Date header automatically - RFC 9110 Section 6.6.1.
+        e.mode = HttpResponseKind.header
+
+    of HttpResponseKind.header:
+      if e.mode == res.orKind:
+        e.stream.write(res.header.name, ": ", res.header.value, CRLF)
+
+    of HttpResponseKind.chunk:
+      if res.chunk.chunk.len > 0:
+        if e.mode == HttpResponseKind.header:
+          e.stream.write("transfer-encoding: chunked" & CRLF & CRLF)
+          e.ses.send(move e.stream.data)
+          e.mode = res.orKind
+        if e.mode == res.orKind:
+          e.ses.send(res.chunk.chunk.lenLine)
+          e.ses.send(res.chunk.chunk)
+          e.ses.send(CRLF)
+
+    of HttpResponseKind.done:
+      if e.mode in {HttpResponseKind.header, HttpResponseKind.chunk}:
+        if e.mode == HttpResponseKind.header:
+          e.stream.write("content-length: ", $res.done.chunk.len & CRLF & CRLF)
+          e.ses.send(move e.stream.data)
+          if res.done.chunk.len > 0:
+            e.ses.send(res.done.chunk)
+        elif e.mode == HttpResponseKind.chunk:
+          e.ses.send(res.done.chunk.lenLine)
+          if res.done.chunk.len > 0:
+            e.ses.send(res.done.chunk)
+          e.ses.send(CRLF & "0" & CRLF & CRLF)
+        e.mode = res.orKind
+        e.ses.conn.endBatch()
+        if e.req.headers.getOrDefault(Symbol"connection") == "close":
+          e.ses.conn.close()
+        stop(turn)
+          # stop the facet scoped to the exchange
+          # so that the response capability is withdrawn
+
+proc service(turn: Turn; exch: Exchange) =
+  ## Service an HTTP message exchange.
+  var binding = exch.ses.driver.match exch.req
+  if binding.isNone:
+    stop(turn)
+  else:
+    var handler = binding.get.handler.unembed Cap
+    if handler.isNone:
+      stop(turn)
+    else:
+      let cap =  newCap(turn, exch)
+      publish(turn, handler.get, HttpContext(
+          req: exch.req,
+          res: embed cap,
+        ))
+      const timeout = initDuration(seconds = 4)
+      after(turn, exch.ses.driver.timers, timeout) do (turn: Turn):
+        if not exch.active:
+          var res = HttpResponse(orKind: HttpResponseKind.status)
+          res.status.code = 504
+          res.status.message = "Binding timeout"
+          message(turn, cap, res)
+          res = HttpResponse(orKind: HttpResponseKind.done)
+          message(turn, cap, res)
+
+proc service(ses: Session) =
+  ## Service a connection to an HTTP client.
+  ses.facet.onStop do (turn: Turn):
+    close ses.conn
+  ses.conn.onClosed do ():
+    stop ses.facet
+  ses.conn.onReceivedPartial do (data: seq[byte]; ctx: MessageContext; eom: bool):
+    ses.facet.run do (turn: Turn):
+      var (n, req) = parseRequest(ses.conn, cast[string](data))
+      if n > 0:
+        inc(ses.driver.sequenceNumber)
+        req.sequenceNumber = ses.driver.sequenceNumber
+        req.port = BiggestInt ses.port
+        inFacet(turn) do (turn: Turn):
+          preventInertCheck(turn)
+          # start a new facet for this message exchange
+          turn.service Exchange(
+              facet: turn.facet,
+              ses: ses,
+              req: req,
+              stream: newStringStream(),
+              mode: HttpResponseKind.status
+            )
+      ses.conn.receive()
+  ses.conn.receive()
+
+proc newListener(port: Port): Listener =
+  var lp = newLocalEndpoint()
+  lp.with port
+  listen newPreconnection(local=[lp])
+
+proc httpListen(turn: Turn; driver: Driver; port: Port): Listener =
+  let facet = turn.facet
+  var listener = newListener(port)
+  preventInertCheck(turn)
+  listener.onListenError do (err: ref Exception):
+    terminateFacet(facet, err)
+  facet.onStop do (turn: Turn):
+    stop listener
+  listener.onConnectionReceived do (conn: Connection):
+    driver.facet.run do (turn: Turn):
+      # start a new turn
+      linkActor(turn, "http-conn") do (turn: Turn):
+        preventInertCheck(turn)
+        let facet = turn.facet
+        conn.onConnectionError do (err: ref Exception):
+          terminateFacet(facet, err)
+            # terminate this actor on exception
+        # facet is scoped to the lifetime of the connection
+        service Session(
+            facet: turn.facet,
+            driver: driver,
+            conn: conn,
+            port: port,
+          )
+  listener
+
+proc httpDriver(turn: Turn; ds: Cap) =
+  let driver = Driver(facet: turn.facet, ds: ds, timers: turn.newDataspace)
+  spawnTimerDriver(turn, driver.timers)
+
+  during(turn, ds, HttpBinding?:{
+        1: grab(),
+      }) do (port: BiggestInt):
+    publish(turn, ds, HttpListener(port: port))
+
+  during(turn, ds, ?:HttpBinding) do (
+      ho: HostPattern, po: int, me: MethodPattern, pa: PathPattern, e: Value):
+    let b = HttpBinding(host: ho, port: po, `method`: me, path: pa, handler: e)
+    discard driver.bindings.change(b.toPreserves, +1)
+  do:
+    discard driver.bindings.change(b.toPreserves, -1)
+
+  during(turn, ds, ?:HttpListener) do (port: uint16):
+    let l = httpListen(turn, driver, Port port)
+  do:
+    stop(l)
+
+proc spawnHttpDriver*(turn: Turn; ds: Cap): Actor {.discardable.} =
+  spawnActor(turn, "http-driver") do (turn: Turn):
+    httpDriver(turn, ds)
--- a/src/syndicate/drivers/timers.nim
+++ b/src/syndicate/drivers/timers.nim
@ -0,0 +1,148 @@
+# SPDX-FileCopyrightText: ☭ Emery Hemingway
+# SPDX-License-Identifier: Unlicense
+
+import std/[tables, times]
+import preserves
+import ../../syndicate, ../protocols/[timer, dataspace]
+
+when defined(solo5):
+  import solo5_dispatcher
+else:
+  import pkg/sys/[handles, ioqueue]
+
+export timer
+
+type
+  Observe = dataspace.Observe
+
+when defined(solo5):
+  import solo5, solo5_dispatcher
+
+  proc wallFloat: float =
+    solo5_clock_wall().float / 1_000_000_000.0
+
+  type
+    TimerDriver = ref object
+      facet: Facet
+        ## Owning facet of driver.
+      target: Cap
+        ## Destination for LaterThan assertions.
+      deadlines: Table[float, Facet]
+        ## Deadlines that other actors are observing.
+
+  proc spawnTimerDriver(facet: Facet; cap: Cap): TimerDriver =
+    TimerDriver(facet: facet, target: cap)
+
+  proc await(driver: TimerDriver; deadline: float) {.solo5dispatch.} =
+    yieldUntil(deadline)
+    let facet = driver.deadlines.getOrDefault(deadline)
+    if not facet.isNil:
+      # check if the deadline is still observed
+      proc turnWork(turn: Turn) =
+        discard publish(turn, driver.target, LaterThan(seconds: deadline))
+      run(facet, turnWork)
+
+else:
+  import std/[oserrors, posix, sets]
+  type Time = posix.Time
+
+  {.pragma: timerfd, importc, header: "<sys/timerfd.h>".}
+
+  proc timerfd_create(clock_id: ClockId, flags: cint): cint {.timerfd.}
+  proc timerfd_settime(ufd: cint, flags: cint,
+                        utmr: var Itimerspec, otmr: var Itimerspec): cint {.timerfd.}
+  proc timerfd_gettime(ufd: cint, curr: var Itimerspec): cint {.timerfd.}
+
+  var
+    TFD_NONBLOCK {.timerfd.}: cint
+    TFD_CLOEXEC {.timerfd.}: cint
+    TFD_TIMER_ABSTIME {.timerfd.}: cint
+
+  proc `<`(a, b: Timespec): bool =
+    a.tv_sec.clong < b.tv_sec.clong or
+      (a.tv_sec.clong == b.tv_sec.clong and a.tv_nsec < b.tv_nsec)
+
+  proc `+`(a, b: Timespec): Timespec =
+    result.tv_sec = Time a.tv_sec.clong + b.tv_sec.clong
+    result.tv_nsec = a.tv_nsec + b.tv_nsec
+
+  func toFloat(ts: Timespec): float =
+    ts.tv_sec.float + ts.tv_nsec.float / 1_000_000_000
+
+  func toTimespec(f: float): Timespec =
+    result.tv_sec = Time(f)
+    result.tv_nsec = clong(uint64(f * 1_000_000_000) mod 1_000_000_000)
+
+  proc wallFloat: float =
+    var ts: Timespec
+    if clock_gettime(CLOCK_REALTIME, ts) < 0:
+      raiseOSError(osLastError(), "clock_gettime")
+    ts.toFloat
+
+  type
+    TimerDriver = ref object
+      facet: Facet
+        ## Owning facet of driver.
+      target: Cap
+        ## Destination for LaterThan assertions.
+      deadlines: Table[float, Facet]
+        ## Deadlines that other actors are observing.
+      timers: HashSet[cint]
+        # TODO: use a single timer descriptor
+
+  proc spawnTimerDriver(facet: Facet; cap: Cap): TimerDriver =
+    let driver = TimerDriver(facet: facet, target: cap)
+    facet.onStop do (turn: Turn):
+      for fd in driver.timers:
+        unregister(FD fd)
+        discard close(fd)
+    driver
+
+  proc earliestFloat(driver: TimerDriver): float =
+    assert driver.deadlines.len > 0
+    result = high float
+    for deadline in driver.deadlines.keys:
+      if deadline < result:
+        result = deadline
+
+  proc await(driver: TimerDriver; deadline: float) {.asyncio.} =
+    ## Run timer driver concurrently with actor.
+    let fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK or TFD_CLOEXEC)
+    if fd < 0:
+      raiseOSError(osLastError(), "failed to acquire timer descriptor")
+    var
+      old: Itimerspec
+      its = Itimerspec(it_value: deadline.toTimespec)
+    if timerfd_settime(fd, TFD_TIMER_ABSTIME, its, old) < 0:
+      raiseOSError(osLastError(), "failed to set timeout")
+    driver.timers.incl(fd)
+    while wallFloat() < deadline:
+      # Check if the timer is expired which
+      # could happen before waiting.
+      wait(FD fd, Read)
+    let facet = driver.deadlines.getOrDefault(deadline)
+    if not facet.isNil:
+      # Check if the deadline is still observed.
+      proc turnWork(turn: Turn) =
+        discard publish(turn, driver.target, LaterThan(seconds: deadline))
+      run(facet, turnWork)
+    discard close(fd)
+    driver.timers.excl(fd)
+
+proc spawnTimerDriver*(turn: Turn; ds: Cap): Actor {.discardable.} =
+  ## Spawn a timer actor that responds to
+  ## dataspace observations of timeouts on `ds`.
+  linkActor(turn, "timers") do (turn: Turn):
+    let driver = spawnTimerDriver(turn.facet, ds)
+    let pat = observePattern(!LaterThan, {@[0.toPreserves]: grabLit()})
+    during(turn, ds, pat) do (deadline: float):
+      driver.deadlines[deadline] = turn.facet
+      discard trampoline(whelp await(driver, deadline))
+    do:
+      driver.deadlines.del deadline
+
+proc after*(turn: Turn; ds: Cap; dur: Duration; act: TurnAction) =
+  ## Execute `act` after some duration of time.
+  var later = wallFloat() + dur.inMilliseconds.float / 1_000.0
+  onPublish(turn, ds, ?LaterThan(seconds: later)):
+    act(turn)
--- a/src/syndicate/durings.nim
+++ b/src/syndicate/durings.nim
@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: ☭ 2021 Emery Hemingway
+# SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense

 import std/[hashes, tables]
@ -6,7 +6,7 @@ import preserves
 import ./actors, ./patterns, ./protocols/dataspace

 type
-  DuringProc* = proc (turn: var Turn; a: Value; h: Handle): TurnAction {.gcsafe.}
+  DuringProc* = proc (turn: Turn; a: Value; h: Handle): TurnAction
  DuringActionKind = enum null, dead, act
  DuringAction = object
    case kind: DuringActionKind
@ -17,20 +17,21 @@ type
    cb: DuringProc
    assertionMap: Table[Handle, DuringAction]

-method publish(de: DuringEntity; turn: var Turn; a: AssertionRef; h: Handle) =
-  let action =  de.cb(turn, a.value, h)
-  # assert(not action.isNil "should have put in a no-op action")
-  let g = de.assertionMap.getOrDefault h
-  case g.kind
-  of null:
-    de.assertionMap[h] = DuringAction(kind: act, action: action)
-  of dead:
-    de.assertionMap.del h
-    freshen(turn, action)
-  of act:
-    raiseAssert("during: duplicate handle in publish: " & $h)
+method publish(de: DuringEntity; turn: Turn; a: AssertionRef; h: Handle) =
+  discard inFacet(turn) do (turn: Turn):
+    let action =  de.cb(turn, a.value, h)
+    # assert(not action.isNil "should have put in a no-op action")
+    let g = de.assertionMap.getOrDefault h
+    case g.kind
+    of null:
+      de.assertionMap[h] = DuringAction(kind: act, action: action)
+    of dead:
+      de.assertionMap.del h
+      action(turn)
+    of act:
+      raiseAssert("during: duplicate handle in publish: " & $h)

-method retract(de: DuringEntity; turn: var Turn; h: Handle) =
+method retract(de: DuringEntity; turn: Turn; h: Handle) =
  let g = de.assertionMap.getOrDefault h
  case g.kind
  of null:
@ -44,5 +45,5 @@ method retract(de: DuringEntity; turn: var Turn; h: Handle) =

 proc during*(cb: DuringProc): DuringEntity = DuringEntity(cb: cb)

-proc observe*(turn: var Turn; ds: Cap; pat: Pattern; e: Entity): Handle =
+proc observe*(turn: Turn; ds: Cap; pat: Pattern; e: Entity): Handle =
  publish(turn, ds, Observe(pattern: pat, observer: newCap(turn, e)))
--- a/src/syndicate/membranes.nim
+++ b/src/syndicate/membranes.nim
@ -3,7 +3,7 @@

 import std/[hashes, tables]

-from ./actors import Cap, hash
+import ./actors
 from ./protocols/sturdy import Oid

 proc hash(r: Cap): Hash = !$(r.relay.hash !& r.target.unsafeAddr.hash)
--- a/src/syndicate/patterns.nim
+++ b/src/syndicate/patterns.nim
@ -1,147 +1,115 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense

-import std/[algorithm, options, sequtils, tables, typetraits]
+import std/[assertions, options, tables, typetraits]

 import preserves
-import ./protocols/dataspacePatterns
+import ./protocols/[dataspacePatterns, dataspace]
 from ./actors import Cap

-export dataspacePatterns.`$`, PatternKind, DCompoundKind, AnyAtomKind
+export dataspacePatterns.`$`, AnyAtomKind, GroupTypeKind, PatternKind

 type
-  AnyAtom = dataspacePatterns.AnyAtom
-  DBind = dataspacePatterns.DBind
-  DCompound = dataspacePatterns.DCompound
-  DCompoundArr = dataspacePatterns.DCompoundArr
-  DCompoundDict = dataspacePatterns.DCompoundDict
-  DCompoundRec = dataspacePatterns.DCompoundRec
-  DLit = dataspacePatterns.DLit
  Pattern* = dataspacePatterns.Pattern

-iterator orderedEntries*(dict: DCompoundDict): (Value, Pattern) =
-  ## Iterate a `DCompoundDict` in Preserves order.
-  ## Values captured from a dictionary are represented as an
-  ## array of values ordered by their former key, so using an
-  ## ordered iterator is sometimes essential.
-  var keys = dict.entries.keys.toSeq
-  sort(keys, preserves.cmp)
-  for k in keys:
-    yield(k, dict.entries.getOrDefault(k))
-      # getOrDefault doesn't raise and we know the keys will match
+proc toPattern(b: sink PatternBind): Pattern =
+  Pattern(orKind: PatternKind.`bind`, `bind`: b)

-proc toPattern(d: sink DBind): Pattern =
-  Pattern(orKind: PatternKind.DBind, dbind: d)
+proc toPattern(l: sink PatternLit): Pattern =
+  Pattern(orKind: PatternKind.`lit`, lit: l)

-proc toPattern(d: sink DLit): Pattern =
-  Pattern(orKind: PatternKind.DLit, dlit: d)
+proc toPattern(g: sink PatternGroup): Pattern =
+  Pattern(orKind: PatternKind.`group`, group: g)

-proc toPattern(aa: sink AnyAtom): Pattern =
-  DLit(value: aa).toPattern
+proc toPattern(a: sink AnyAtom): Pattern =
+  PatternLit(value: a).toPattern

-proc toPattern(d: sink DCompound): Pattern =
-  Pattern(orKind: PatternKind.DCompound, dcompound: d)
+proc grab*(p: sink Pattern): Pattern =
+  PatternBind(pattern: p).toPattern

-proc toPattern(d: sink DCompoundRec): Pattern =
-  DCompound(orKind: DCompoundKind.rec, rec: d).toPattern
-
-proc toPattern(d: sink DCompoundArr): Pattern =
-  DCompound(orKind: DCompoundKind.arr, arr: d).toPattern
-
-proc toPattern(d: sink DCompoundDict): Pattern =
-  DCompound(orKind: DCompoundKind.dict, dict: d).toPattern
-
-proc drop*(): Pattern {.inline.} = Pattern(orKind: PatternKind.DDiscard)
+proc drop*(): Pattern = Pattern(orKind: PatternKind.`discard`)
  ## Create a pattern to match any value without capture.

-proc grab*(): Pattern {.inline.} = DBind(pattern: drop()).toPattern
+proc grab*(): Pattern = drop().grab()
  ## Create a pattern to capture any value.

-proc grab*(pr: Value): Pattern =
+proc drop*(pr: Value): Pattern =
  ## Convert a `Preserve` value to a `Pattern`.
  runnableExamples:
    from std/unittest import check
    import preserves
    check:
-      $(grab parsePreserves"""<foo "bar" #"00" [0 1 2.0] {maybe: #t} <_>>""") ==
-        """<rec foo [<lit "bar"> <lit #"00"> <arr [<lit 0> <lit 1> <lit 2.0>]> <dict {maybe: <lit #t>}> <_>]>"""
+      $("""<foo "bar" #"00" [0 1 2.0] {maybe: #t} <_>>""".parsePreserves.drop) ==
+        """<group <rec foo> {0: <lit "bar"> 1: <lit #"00"> 2: <group <arr> {0: <lit 0> 1: <lit 1> 2: <lit 2.0>}> 3: <group <dict> {maybe: <lit #t>}> 4: <_>}>"""

-  if pr.embedded: drop()
-  else:
-    case pr.kind
-    of pkBoolean:
-      AnyAtom(orKind: AnyAtomKind.`bool`, bool: pr.bool).toPattern
-    of pkFloat:
-      AnyAtom(orKind: AnyAtomKind.`float`, float: pr.float).toPattern
-    of pkDouble:
-      AnyAtom(orKind: AnyAtomKind.`double`, double: pr.double).toPattern
-    of pkRegister:
-      AnyAtom(orKind: AnyAtomKind.`int`, int: pr.register).toPattern
-    of pkString:
-      AnyAtom(orKind: AnyAtomKind.`string`, string: pr.string).toPattern
-    of pkByteString:
-      AnyAtom(orKind: AnyAtomKind.`bytes`, bytes: pr.bytes).toPattern
-    of pkSymbol:
-      AnyAtom(orKind: AnyAtomKind.`symbol`, symbol: pr.symbol).toPattern
-    of pkRecord:
-      if (pr.isRecord("_") and pr.arity == 0) or (pr.isRecord("bind") and pr.arity == 1):
-        drop()
-      else:
-        DCompoundRec(
-          label: pr.label,
-          fields: map[Value, Pattern](pr.fields, grab)).toPattern
-    of pkSequence:
-      DCompoundArr(items: map(pr.sequence, grab)).toPattern
-    of pkSet:
-      raiseAssert "cannot construct a pattern over a set literal"
-    of pkDictionary:
-      var dict = DCompoundDict()
-      for key, val in pr.pairs: dict.entries[key] = grab val
-      dict.toPattern
-    of pkEmbedded:
-      # TODO: can patterns be constructed over embedded literals?
+  case pr.kind
+  of pkBoolean:
+    AnyAtom(orKind: AnyAtomKind.`bool`, bool: pr.bool).toPattern
+  of pkFloat:
+    AnyAtom(orKind: AnyAtomKind.`double`, double: pr.float).toPattern
+  of pkRegister:
+    AnyAtom(orKind: AnyAtomKind.`int`, int: pr.register).toPattern
+  of pkBigInt:
+    raiseAssert "cannot make a pattern over a big integer"
+  of pkString:
+    AnyAtom(orKind: AnyAtomKind.`string`, string: pr.string).toPattern
+  of pkByteString:
+    AnyAtom(orKind: AnyAtomKind.`bytes`, bytes: pr.bytes).toPattern
+  of pkSymbol:
+    AnyAtom(orKind: AnyAtomKind.`symbol`, symbol: pr.symbol).toPattern
+
+  of pkRecord:
+    if pr.isRecord("_", 0):
      drop()
+    elif pr.isRecord("bind", 1):
+      pr.fields[0].drop
    else:
-      raise newException(ValueError, "cannot generate a pattern for unhandled Value type")
+      var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.rec))
+      group.`type`.rec.label = pr.label
+      var i: int
+      for v in pr.fields:
+        group.entries[toPreserves i] = drop v
+        inc i
+      group.toPattern

-proc grab*[T](x: T): Pattern =
+  of pkSequence:
+    var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.arr))
+    for i, v in pr.sequence:
+      group.entries[toPreserves i] = drop v
+    group.toPattern
+
+  of pkSet:
+    raiseAssert "cannot construct a pattern over a set literal"
+
+  of pkDictionary:
+    var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.dict))
+    for key, val in pr.pairs:
+      group.entries[key] = drop val
+    group.toPattern
+
+  of pkEmbedded:
+    if pr.embeddedRef.isNil: drop()
+    else:
+      AnyAtom(orKind: AnyAtomKind.`embedded`, embedded: pr.embeddedRef).toPattern
+  #else:
+  #  raise newException(ValueError, "cannot generate a pattern for unhandled Value type")
+
+proc drop*[T](x: T): Pattern =
  ## Construct a `Pattern` from value of type `T`.
+  ## This proc is called `drop` because the value `x` is matched but discarded.
  runnableExamples:
    from std/unittest import check
    check:
-      $grab(true) == "<lit #t>"
-      $grab(3.14) == "<lit 3.14>"
-      $grab([0, 1, 2, 3]) == "<arr [<lit 0> <lit 1> <lit 2> <lit 3>]>"
-  grab(x.toPreserves)
+      $drop(true) == "<lit #t>"
+      $drop(3.14) == "<lit 3.14>"
+      $drop([0, 1, 2, 3]) == "<group <arr> {0: <lit 0> 1: <lit 1> 2: <lit 2> 3: <lit 3>}>"
+  drop(x.toPreserves)

-proc patternOfType(typ: static typedesc; `bind`: static bool): Pattern =
-  when typ is ref:
-    patternOfType(pointerBase(typ), `bind`)
-  elif typ.hasPreservesRecordPragma:
-    var rec = DCompoundRec(label: typ.recordLabel.toSymbol)
-    for _, f in fieldPairs(default typ):
-      add(rec.fields, patternOfType(typeof f, `bind`))
-    result = rec.toPattern
-  elif typ.hasPreservesDictionaryPragma:
-    var dict = DCompoundDict()
-    for key, val in fieldPairs(default typ):
-      dict.entries[key.toSymbol] = patternOfType(typeof val, `bind`)
-    dict.toPattern
-  elif typ is tuple:
-    var arr = DCompoundArr()
-    for _, f in fieldPairs(default typ):
-      add(arr.items, patternOfType(typeof f, `bind`))
-    arr.toPattern
-  elif typ is array:
-    var arr = DCompoundArr()
-    arr.items.setLen(len(typ))
-    for e in arr.items.mitems: e = grab()
-    arr.toPattern
-  else:
-    if `bind`: grab()
-    else: drop()
+proc grab*[T](x: T): Pattern {.
+    deprecated: "use drop unless you wish to capture the provided value".} =
+  PatternBind(pattern: drop x).toPattern

-proc grabType*(typ: static typedesc): Pattern =
+proc grabTypeFlat*(typ: static typedesc): Pattern =
  ## Derive a `Pattern` from type `typ`.
  ## This works for `tuple` and `object` types but in the
  ## general case will return a wildcard binding.
@ -149,61 +117,98 @@ proc grabType*(typ: static typedesc): Pattern =
    import preserves
    from std/unittest import check
    check:
-      $grabType(array[3, int]) ==
-        """<arr [<bind <_>> <bind <_>> <bind <_>>]>"""
+      $grabTypeFlat(array[3, int]) ==
+        """<group <arr> {0: <bind <_>> 1: <bind <_>> 2: <bind <_>> 3: <bind <_>>}>"""
    type
      Point = tuple[x: int; y: int]
      Rect {.preservesRecord: "rect".} = tuple[a: Point; B: Point]
      ColoredRect {.preservesDictionary.} = tuple[color: string; rect: Rect]
    check:
-      $(grabType Point) ==
-        "<arr [<bind <_>> <bind <_>>]>"
-      $(grabType Rect) ==
-        "<rec rect [<arr [<bind <_>> <bind <_>>]> <arr [<bind <_>> <bind <_>>]>]>"
-      $(grabType ColoredRect) ==
-        "<dict {color: <bind <_>> rect: <rec rect [<arr [<bind <_>> <bind <_>>]> <arr [<bind <_>> <bind <_>>]>]>}>"
-  patternOfType(typ, true)
-
-proc dropType*(typ: static typedesc): Pattern =
-  ## Derive a `Pattern` from type `typ` without any bindings.
-  patternOfType(typ, false)
+      $(grabTypeFlat Point) ==
+        "<group <arr> {0: <bind <_>> 1: <bind <_>>}>"
+      $(grabTypeFlat Rect) ==
+        "<group <rec rect> {0: <group <arr> {0: <bind <_>> 1: <bind <_>>}> 1: <group <arr> {0: <bind <_>> 1: <bind <_>>}>}>"
+      $(grabTypeFlat ColoredRect) ==
+        "<group <dict> {color: <bind <_>> rect: <group <rec rect> {0: <group <arr> {0: <bind <_>> 1: <bind <_>>}> 1: <group <arr> {0: <bind <_>> 1: <bind <_>>}>}>}>"
+  when typ is ref:
+    grabTypeFlat(pointerBase(typ))
+  elif typ.hasPreservesRecordPragma:
+    var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`rec`))
+    group.`type`.rec.label = typ.recordLabel.toSymbol
+    for _, f in fieldPairs(default typ):
+      group.entries[group.entries.len.toPreserves] = grabTypeFlat(typeof f)
+    group.toPattern
+  elif typ.hasPreservesDictionaryPragma:
+    var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`dict`))
+    for key, val in fieldPairs(default typ):
+      group.entries[key.toSymbol] = grabTypeFlat(typeof val)
+    group.toPattern
+  elif typ is tuple:
+    var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`arr`))
+    for _, f in fieldPairs(default typ):
+      group.entries[group.entries.len.toPreserves] = grabTypeFlat(typeof f)
+    group.toPattern
+  elif typ is array:
+    var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`arr`))
+    for i in 0..len(typ):
+      group.entries[toPreserves i] = grab()
+    group.toPattern
+  else:
+    grab()

 proc fieldCount(T: typedesc): int =
  for _, _ in fieldPairs(default T):
    inc result

-proc lookup(bindings: openArray[(int, Pattern)]; i: int): Pattern =
-  for (j, b) in bindings:
-    if i == j: return b
-  return drop()
+proc dropType*(typ: static typedesc): Pattern =
+  ## Derive a `Pattern` from type `typ` without any bindings.
+  when typ is ref:
+    dropType(pointerBase(typ))
+  elif typ.hasPreservesRecordPragma:
+    var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`rec`))
+    group.`type`.rec.label = typ.recordLabel.toSymbol
+    let high = typ.fieldCount.pred
+    if high >= 0: group.entries[high.toPreserves] = drop()
+    group.toPattern
+  elif typ.hasPreservesDictionaryPragma:
+    PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`dict`)).toPattern
+  elif typ is tuple or typ is array:
+    var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`arr`))
+    let high = typ.fieldCount.pred
+    if high >= 0: group.entries[high.toPreserves] = drop()
+    group.toPattern
+  else:
+    drop()
+
+proc grabType*(typ: static typedesc): Pattern =
+  PatternBind(pattern: typ.dropType).toPattern
+
+proc bindEntries(group: var PatternGroup; bindings: openArray[(int, Pattern)]) =
+  ## Set `bindings` for a `group`.
+  for (i, pat) in bindings: group.entries[toPreserves i] = pat

 proc grab*(typ: static typedesc; bindings: sink openArray[(int, Pattern)]): Pattern =
  ## Construct a `Pattern` from type `typ` with pattern `bindings` by integer offset.
  when typ is ptr | ref:
    grab(pointerBase(typ), bindings)
  elif typ.hasPreservesRecordPragma:
-    var rec = DCompoundRec(label: typ.recordLabel.toSymbol)
-    rec.fields.setLen(fieldCount typ)
-    var i: int
-    for _, f in fieldPairs(default typ):
-      rec.fields[i] = lookup(bindings, i)
-      inc i
-    result = rec.toPattern
+    var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`rec`))
+    group.`type`.rec.label = typ.recordLabel.toSymbol
+    bindEntries(group, bindings)
+    group.toPattern
  elif typ is tuple:
-    var arr = DCompoundArr()
-    arr.items.setLen(fieldCount typ)
-    var i: int
-    for _, f in fieldPairs(default typ):
-      arr.items[i] = lookup(bindings, i)
-      inc i
-    result = arr.toPattern
+    var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`arr`))
+    bindEntries(group, bindings)
+    group.toPattern
  else:
    {.error: "grab with indexed bindings not implemented for " & $typ.}

 proc grab*(typ: static typedesc; bindings: sink openArray[(Value, Pattern)]): Pattern =
  ## Construct a `Pattern` from type `typ` with dictionary field `bindings`.
  when typ.hasPreservesDictionaryPragma:
-    DCompoundDict(entries: bindings.toTable).toPattern
+    var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`dict`))
+    for key, val in bindinds: group.entries[key] = val
+    group.toPattern
  else:
    {.error: "grab with dictionary bindings not implemented for " & $typ.}

@ -211,11 +216,11 @@ proc grabLit*(): Pattern =
  runnableExamples:
    from std/unittest import check
    check:
-      $grabLit() == """<rec lit [<bind <_>>]>"""
-  grabType(dataspacePatterns.DLit)
+      $grabLit() == """<group <rec lit> {0: <bind <_>>}>"""
+  grabTypeFlat(dataspacePatterns.PatternLit)

 proc grabDict*(): Pattern =
-  grabType(dataspacePatterns.DCompoundDict)
+  grabTypeFlat(dataspacePatterns.GroupTypeDict)

 proc unpackLiterals*(pr: Value): Value =
  result = pr
@ -223,64 +228,42 @@ proc unpackLiterals*(pr: Value): Value =
    if pr.isRecord("lit", 1) or pr.isRecord("dict", 1) or pr.isRecord("arr", 1) or pr.isRecord("set", 1):
      pr = pr.record[0]

-proc inject*(pat: Pattern; bindings: openArray[(int, Pattern)]): Pattern =
-  ## Construct a `Pattern` from `pat` with injected overrides from `bindings`.
+proc inject*(pattern: sink Pattern; p: Pattern; path: varargs[Value, toPreserves]): Pattern =
+  ## Inject `p` inside `pattern` at `path`.
  ## Injects are made at offsets indexed by the discard (`<_>`) patterns in `pat`.
-  proc inject(pat: Pattern; bindings: openArray[(int, Pattern)]; offset: var int): Pattern =
-    case pat.orKind
-    of PatternKind.DDiscard:
-      result = pat
-      for (off, injection) in bindings:
-        if off == offset:
-          result = injection
-          break
-      inc offset
-    of PatternKind.DBind:
-      let bindOff = offset
-      result = pat
-      result.dbind.pattern = inject(pat.dbind.pattern, bindings, offset)
-      if result.orKind == PatternKind.DBind:
-        for (off, injection) in bindings:
-          if (off == bindOff) and (result.dbind.pattern == injection):
-            result = result.dbind.pattern
-            break # promote the injected pattern over the bind
-    of PatternKind.DLit:
-      result = pat
-    of PatternKind.DCompound:
-      result = pat
-      case pat.dcompound.orKind
-      of DCompoundKind.rec:
-        var fields = mapIt(pat.dcompound.rec.fields):
-          inject(it, bindings, offset)
-        result = DCompoundRec(label: result.dcompound.rec.label, fields: fields).toPattern
-      of DCompoundKind.arr:
-        var items = mapIt(pat.dcompound.arr.items):
-          inject(it, bindings, offset)
-        result = DCompoundArr(items: items).toPattern
-      of DCompoundKind.dict:
-        var dict = DCompoundDict()
-        for key, val in pat.dcompound.dict.entries:
-          dict.entries[key] = inject(val, bindings, offset)
-        result = toPattern(dict)
-  var offset = 0
-  inject(pat, bindings, offset)
-
-proc inject*(pat: Pattern; bindings: openArray[(Value, Pattern)]): Pattern =
-  ## Inject `bindings` into a dictionary pattern.
-  assert pat.orKind == PatternKind.DCompound
-  assert pat.dcompound.orKind == DCompoundKind.dict
-  result = pat
-  for (key, val) in bindings:
-    result.dcompound.dict.entries[key] = val
+  proc inject(pat: var Pattern; path: openarray[Value]) =
+    if len(path) == 0:
+      pat = p
+    elif pat.orKind != PatternKind.`group`:
+      raise newException(ValueError, "cannot inject along specified path")
+    else:
+      inject(pat.group.entries[path[0]], path[1..path.high])
+  result = pattern
+  inject(result, path)

 proc grabRecord*(label: Value, fields: varargs[Pattern]): Pattern =
  runnableExamples:
    from std/unittest import check
-    import syndicate/actors, preserves
+    import preserves
    check:
      $grabRecord("Says".toSymbol, grab(), grab()) ==
-        """<rec Says [<bind <_>> <bind <_>>]>"""
-  DCompoundRec(label: label, fields: fields.toSeq).toPattern
+        """<group <rec Says> {0: <bind <_>> 1: <bind <_>>}>"""
+  var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`rec`))
+  group.`type`.rec.label = label
+  for i, f in fields: group.entries[toPreserves i] = f
+  group.toPattern
+
+proc grabRecord*(label: Value, fields: sink openArray[(int, Pattern)]): Pattern =
+  runnableExamples:
+    from std/unittest import check
+    import preserves
+    check:
+      $grabRecord("Says".toSymbol, {3: grab(), 4: grab()}) ==
+        """<group <rec Says> {3: <bind <_>> 4: <bind <_>>}>"""
+  var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`rec`))
+  group.`type`.rec.label = label
+  for (i, p) in fields: group.entries[toPreserves i] = p
+  group.toPattern

 proc grabRecord*(label: string, fields: varargs[Pattern]): Pattern =
  ## Sugar for creating record patterns.
@ -289,47 +272,61 @@ proc grabRecord*(label: string, fields: varargs[Pattern]): Pattern =

 proc grabDictionary*(bindings: sink openArray[(Value, Pattern)]): Pattern =
  ## Construct a pattern that grabs some dictionary pairs.
-  DCompoundDict(entries: bindings.toTable).toPattern
+  var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`dict`))
+  for (key, val) in bindings: group.entries[key] = val
+  group.toPattern

 proc grabDictionary*(bindings: sink openArray[(string, Pattern)]): Pattern =
  ## Construct a pattern that grabs some dictionary pairs.
  ## Keys are converted from strings to symbols.
-  result = DCompoundDict().toPattern
-  for (key, val) in bindings.items:
-    result.dcompound.dict.entries[key.toSymbol] = val
+  var group = PatternGroup(`type`: GroupType(orKind: GroupTypeKind.`dict`))
+  for (key, val) in bindings: group.entries[toSymbol key] = val
+  group.toPattern

-proc depattern(comp: DCompound; values: var seq[Value]; index: var int): Value {.gcsafe.}
+proc depattern(group: PatternGroup; values: var seq[Value]; index: var int): Value

 proc depattern(pat: Pattern; values: var seq[Value]; index: var int): Value =
  case pat.orKind
-  of PatternKind.DDiscard:
+  of PatternKind.`discard`:
    discard
-  of PatternKind.DBind:
+  of PatternKind.`bind`:
    if index < values.len:
      result = move values[index]
      inc index
-  of PatternKind.DLit:
-    result = pat.dlit.value.toPreserves
-  of PatternKind.DCompound:
-    result = depattern(pat.dcompound, values, index)
+  of PatternKind.`lit`:
+    result = pat.`lit`.value.toPreserves
+  of PatternKind.`group`:
+    result = depattern(pat.group, values, index)

-proc depattern(comp: DCompound; values: var seq[Value]; index: var int): Value {.gcsafe.} =
-  case comp.orKind
-  of DCompoundKind.rec:
-    result = initRecord(comp.rec.label, comp.rec.fields.len)
-    for i, f in comp.rec.fields:
-      result[i] = depattern(f, values, index)
-  of DCompoundKind.arr:
-    result = initSequence(comp.arr.items.len)
-    for i, e in comp.arr.items:
-      result[i] = depattern(e, values, index)
-  of DCompoundKind.dict:
+proc depattern(group: PatternGroup; values: var seq[Value]; index: var int): Value =
+  case group.`type`.orKind
+  of GroupTypeKind.rec:
+    result = initRecord(group.`type`.rec.label, group.entries.len)
+    var i: int
+    for key, val in group.entries:
+      if i.fromPreserves key:
+        result[i] = depattern(val, values, index)
+  of GroupTypeKind.arr:
+    result = initSequence(group.entries.len)
+    var i: int
+    for key, val in group.entries:
+      if i.fromPreserves key:
+        result[i] = depattern(val, values, index)
+  of GroupTypeKind.dict:
    result = initDictionary(Cap)
-    for key, val in comp.dict.entries:
+    for key, val in group.entries:
      result[key] = depattern(val, values, index)

 proc depattern*(pat: Pattern; values: sink seq[Value]): Value =
  ## Convert a `Pattern` to a `Value` while replacing binds with `values`.
+  runnableExamples:
+    from std/unittest import check
+    import preserves
+    type Foo {.preservesRecord: "foo".} = object
+      a, b: int
+    let pat = grabTypeFlat Foo
+    let val = depattern(pat, @[1.toPreserves, 5.toPreserves])
+    check $val == "<foo 1 5>"
  var index: int
  depattern(pat, values, index)

@ -344,44 +341,73 @@ proc fromPreservesHook*[T](lit: var Literal[T]; pr: Value): bool =
 proc toPreservesHook*[T](lit: Literal[T]): Value =
  lit.value.grab.toPreserves

+func isGroup(pat: Pattern): bool =
+  pat.orKind == PatternKind.`group`
+
+func isMetaDict(pat: Pattern): bool =
+  pat.orKind == PatternKind.`group` and
+    pat.group.type.orKind == GroupTypeKind.dict
+
+proc metaApply(result: var Pattern; pat: Pattern; path: openarray[Value], offset: int) =
+  if offset == path.len:
+    result = pat
+  elif result.isGroup and result.group.entries[1.toPreserves].isMetaDict:
+    if offset == path.high:
+      result.group.entries[1.toPreserves].group.entries[path[offset]] = pat
+    else:
+      metaApply(result.group.entries[1.toPreserves].group.entries[path[offset]], pat, path, succ offset)
+  else:
+    assert result.isGroup, "non-group: " & $result
+    assert result.group.entries[1.toPreserves].isMetaDict, "non-meta-dict: " & $result.group.entries[1.toPreserves]
+    raise newException(ValueError, "cannot inject into non-group pattern " & $result)
+
+proc observePattern*(pat: Pattern; injects: openarray[(seq[Value], Pattern)]): Pattern =
+  result = dropType Observe
+  var meta = pat.toPreserves.drop
+  for (path, pat) in injects:
+    metaApply(meta, pat, path, 0)
+  result.group.entries[0.toPreserves] = meta
+
 type
  Path* = seq[Value]
  Paths* = seq[Path]
  Captures* = seq[Value]
  Analysis* = tuple
+    presentPaths: Paths
    constPaths: Paths
    constValues: seq[Value]
    capturePaths: Paths

 func walk(result: var Analysis; path: var Path; p: Pattern)

-func walk(result: var Analysis; path: var Path; key: int|Value; pat: Pattern) =
-  path.add(key.toPreserves)
+func walk(result: var Analysis; path: var Path; key: Value; pat: Pattern) =
+  path.add(key)
  walk(result, path, pat)
  discard path.pop

 func walk(result: var Analysis; path: var Path; p: Pattern) =
  case p.orKind
-  of PatternKind.DCompound:
-    case p.dcompound.orKind
-    of DCompoundKind.rec:
-      for k, e in p.dcompound.rec.fields: walk(result, path, k, e)
-    of DCompoundKind.arr:
-       for k, e in p.dcompound.arr.items: walk(result, path, k, e)
-    of DCompoundKind.dict:
-      for k, e in p.dcompound.dict.orderedEntries: walk(result, path, k, e)
-  of PatternKind.DBind:
+  of PatternKind.group:
+    for k, v in p.group.entries: walk(result, path, k, v)
+  of PatternKind.`bind`:
    result.capturePaths.add(path)
-    walk(result, path, p.dbind.pattern)
-  of PatternKind.DDiscard: discard
-  of PatternKind.DLit:
+    walk(result, path, p.`bind`.pattern)
+  of PatternKind.`discard`:
+    result.presentPaths.add(path)
+  of PatternKind.`lit`:
    result.constPaths.add(path)
-    result.constValues.add(p.dlit.value.toPreserves)
+    result.constValues.add(p.`lit`.value.toPreserves)

 func analyse*(p: Pattern): Analysis =
  var path: Path
  walk(result, path, p)

+func checkPresence*(v: Value; present: Paths): bool =
+  result = true
+  for path in present:
+    if not result: break
+    result = step(v, path).isSome
+
 func projectPaths*(v: Value; paths: Paths): Option[Captures] =
  var res = newSeq[Value](paths.len)
  for i, path in paths:
@ -393,30 +419,27 @@ func projectPaths*(v: Value; paths: Paths): Option[Captures] =
 proc matches*(pat: Pattern; pr: Value): bool =
  let analysis = analyse(pat)
  assert analysis.constPaths.len == analysis.constValues.len
-  for i, path in analysis.constPaths:
-    let v = step(pr, path)
-    if v.isNone: return false
-    if analysis.constValues[i] != v.get: return false
-  for path in analysis.capturePaths:
-    if isNone step(pr, path): return false
-  true
+  result = checkPresence(pr, analysis.presentPaths)
+  if result:
+    for i, path in analysis.constPaths:
+      let v = step(pr, path)
+      if v.isNone: return false
+      if analysis.constValues[i] != v.get: return false
+    for path in analysis.capturePaths:
+      if step(pr, path).isNone: return false

-func capture*(pat: Pattern; pr: Value): seq[Value] =
+proc capture*(pat: Pattern; pr: Value): seq[Value] =
  let analysis = analyse(pat)
  assert analysis.constPaths.len == analysis.constValues.len
-  for i, path in analysis.constPaths:
-    let v = step(pr, path)
-    if v.isNone : return @[]
-    if analysis.constValues[i] != v.get: return @[]
-  for path in analysis.capturePaths:
-    let v = step(pr, path)
-    if v.isNone: return @[]
-    result.add(get v)
+  if checkPresence(pr, analysis.presentPaths):
+    for i, path in analysis.constPaths:
+      let v = step(pr, path)
+      if v.isNone : return @[]
+      if analysis.constValues[i] != v.get: return @[]
+    for path in analysis.capturePaths:
+      let v = step(pr, path)
+      if v.isNone: return @[]
+      result.add(get v)

 when isMainModule:
-  let txt = readAll stdin
-  if txt != "":
-    let
-      v = parsePreserves(txt)
-      pat = grab v
-    stdout.writeLine(pat)
+  stdout.writeLine stdin.readAll.parsePreserves.grab
--- a/src/syndicate/protocols/Tupfile
+++ b/src/syndicate/protocols/Tupfile
@ -6,6 +6,7 @@ modules += http.nim
 modules += noise.nim
 modules += protocol.nim
 modules += service.nim
+modules += stdenv.nim
 modules += stream.nim
 modules += sturdy.nim
 modules += tcp.nim
--- a/src/syndicate/protocols/dataspacePatterns.nim
+++ b/src/syndicate/protocols/dataspacePatterns.nim
@ -4,17 +4,14 @@ import

 type
  AnyAtomKind* {.pure.} = enum
-    `bool`, `float`, `double`, `int`, `string`, `bytes`, `symbol`, `embedded`
+    `bool`, `double`, `int`, `string`, `bytes`, `symbol`, `embedded`
  `AnyAtom`* {.preservesOr.} = object
    case orKind*: AnyAtomKind
    of AnyAtomKind.`bool`:
        `bool`*: bool

-    of AnyAtomKind.`float`:
-        `float`*: float32
-
    of AnyAtomKind.`double`:
-        `double`*: float64
+        `double`*: float

    of AnyAtomKind.`int`:
        `int`*: BiggestInt
@ -32,58 +29,58 @@ type
        `embedded`* {.preservesEmbedded.}: EmbeddedRef

  
-  DLit* {.preservesRecord: "lit".} = object
-    `value`*: AnyAtom
-
-  DBind* {.preservesRecord: "bind".} = object
-    `pattern`*: Pattern
-
-  DDiscard* {.preservesRecord: "_".} = object
-  
-  DCompoundKind* {.pure.} = enum
+  GroupTypeKind* {.pure.} = enum
    `rec`, `arr`, `dict`
-  DCompoundRec* {.preservesRecord: "rec".} = object
+  GroupTypeRec* {.preservesRecord: "rec".} = object
    `label`*: Value
-    `fields`*: seq[Pattern]

-  DCompoundArr* {.preservesRecord: "arr".} = object
-    `items`*: seq[Pattern]
+  GroupTypeArr* {.preservesRecord: "arr".} = object
+  
+  GroupTypeDict* {.preservesRecord: "dict".} = object
+  
+  `GroupType`* {.preservesOr.} = object
+    case orKind*: GroupTypeKind
+    of GroupTypeKind.`rec`:
+        `rec`*: GroupTypeRec

-  DCompoundDict* {.preservesRecord: "dict".} = object
-    `entries`*: Table[Value, Pattern]
+    of GroupTypeKind.`arr`:
+        `arr`*: GroupTypeArr

-  `DCompound`* {.preservesOr.} = object
-    case orKind*: DCompoundKind
-    of DCompoundKind.`rec`:
-        `rec`* {.preservesEmbedded.}: DCompoundRec
-
-    of DCompoundKind.`arr`:
-        `arr`* {.preservesEmbedded.}: DCompoundArr
-
-    of DCompoundKind.`dict`:
-        `dict`* {.preservesEmbedded.}: DCompoundDict
+    of GroupTypeKind.`dict`:
+        `dict`*: GroupTypeDict

  
  PatternKind* {.pure.} = enum
-    `DDiscard`, `DBind`, `DLit`, `DCompound`
+    `discard`, `bind`, `lit`, `group`
+  PatternDiscard* {.preservesRecord: "_".} = object
+  
+  PatternBind* {.preservesRecord: "bind".} = object
+    `pattern`*: Pattern
+
+  PatternLit* {.preservesRecord: "lit".} = object
+    `value`*: AnyAtom
+
+  PatternGroup* {.preservesRecord: "group".} = object
+    `type`*: GroupType
+    `entries`*: Table[Value, Pattern]
+
  `Pattern`* {.acyclic, preservesOr.} = ref object
    case orKind*: PatternKind
-    of PatternKind.`DDiscard`:
-        `ddiscard`*: DDiscard
+    of PatternKind.`discard`:
+        `discard`*: PatternDiscard

-    of PatternKind.`DBind`:
-        `dbind`* {.preservesEmbedded.}: DBind
+    of PatternKind.`bind`:
+        `bind`* {.preservesEmbedded.}: PatternBind

-    of PatternKind.`DLit`:
-        `dlit`* {.preservesEmbedded.}: DLit
+    of PatternKind.`lit`:
+        `lit`* {.preservesEmbedded.}: PatternLit

-    of PatternKind.`DCompound`:
-        `dcompound`* {.preservesEmbedded.}: DCompound
+    of PatternKind.`group`:
+        `group`* {.preservesEmbedded.}: PatternGroup

  
-proc `$`*(x: AnyAtom | DLit | DBind | DDiscard | DCompound | Pattern): string =
+proc `$`*(x: AnyAtom | GroupType | Pattern): string =
  `$`(toPreserves(x))

-proc encode*(x: AnyAtom | DLit | DBind | DDiscard | DCompound | Pattern): seq[
-    byte] =
+proc encode*(x: AnyAtom | GroupType | Pattern): seq[byte] =
  encode(toPreserves(x))
--- a/src/syndicate/protocols/http.nim
+++ b/src/syndicate/protocols/http.nim
@ -47,7 +47,7 @@ type
  
  HttpRequest* {.preservesRecord: "http-request".} = object
    `sequenceNumber`*: BiggestInt
-    `host`*: string
+    `host`*: RequestHost
    `port`*: BiggestInt
    `method`*: Symbol
    `path`*: seq[string]
@ -115,6 +115,17 @@ type
    `req`*: HttpRequest
    `res`* {.preservesEmbedded.}: Value

+  RequestHostKind* {.pure.} = enum
+    `present`, `absent`
+  `RequestHost`* {.preservesOr.} = object
+    case orKind*: RequestHostKind
+    of RequestHostKind.`present`:
+        `present`*: string
+
+    of RequestHostKind.`absent`:
+        `absent`* {.preservesLiteral: "#f".}: bool
+
+  
  PathPatternElementKind* {.pure.} = enum
    `label`, `wildcard`, `rest`
  `PathPatternElement`* {.preservesOr.} = object
@ -149,6 +160,7 @@ proc `$`*(x: HostPattern | HttpListener | MethodPattern | MimeType | QueryValue
    HttpService |
    HttpBinding |
    HttpContext |
+    RequestHost |
    PathPatternElement |
    Chunk |
    PathPattern): string =
@ -163,6 +175,7 @@ proc encode*(x: HostPattern | HttpListener | MethodPattern | MimeType |
    HttpService |
    HttpBinding |
    HttpContext |
+    RequestHost |
    PathPatternElement |
    Chunk |
    PathPattern): seq[byte] =
--- a/src/syndicate/protocols/noise.nim
+++ b/src/syndicate/protocols/noise.nim
@ -48,6 +48,17 @@ type
        `absent`*: SecretKeyFieldAbsent

  
+  SessionItemKind* {.pure.} = enum
+    `Initiator`, `Packet`
+  `SessionItem`* {.preservesOr.} = object
+    case orKind*: SessionItemKind
+    of SessionItemKind.`Initiator`:
+        `initiator`* {.preservesEmbedded.}: Initiator
+
+    of SessionItemKind.`Packet`:
+        `packet`*: Packet
+
+  
  NoiseProtocolKind* {.pure.} = enum
    `present`, `invalid`, `absent`
  NoiseProtocolPresent* {.preservesDictionary.} = object
@ -83,6 +94,9 @@ type
    `service`*: ServiceSelector

  ServiceSelector* = Value
+  Initiator* {.preservesRecord: "initiator".} = object
+    `initiatorSession`* {.preservesEmbedded.}: EmbeddedRef
+
  NoiseStepDetail* = ServiceSelector
  NoiseSpecKey* = seq[byte]
  NoiseSpecPreSharedKeys* = Option[Value]
@ -105,17 +119,21 @@ type

  
 proc `$`*(x: NoiseDescriptionDetail | NoisePreSharedKeys | SecretKeyField |
+    SessionItem |
    NoiseProtocol |
    NoisePathStepDetail |
    NoiseServiceSpec |
+    Initiator |
    NoiseSpec |
    Packet): string =
  `$`(toPreserves(x))

 proc encode*(x: NoiseDescriptionDetail | NoisePreSharedKeys | SecretKeyField |
+    SessionItem |
    NoiseProtocol |
    NoisePathStepDetail |
    NoiseServiceSpec |
+    Initiator |
    NoiseSpec |
    Packet): seq[byte] =
  encode(toPreserves(x))
--- a/src/syndicate/protocols/protocol.nim
+++ b/src/syndicate/protocols/protocol.nim
@ -8,18 +8,18 @@ type
    `detail`*: Value

  Turn* = seq[TurnEvent]
-  Message* {.preservesRecord: "message".} = object
+  Message* {.preservesRecord: "M".} = object
    `body`*: Assertion

-  Retract* {.preservesRecord: "retract".} = object
+  Retract* {.preservesRecord: "R".} = object
    `handle`*: Handle

-  Assert* {.preservesRecord: "assert".} = object
+  Assert* {.preservesRecord: "A".} = object
    `assertion`*: Assertion
    `handle`*: Handle

  Extension* = Value
-  Sync* {.preservesRecord: "sync".} = object
+  Sync* {.preservesRecord: "S".} = object
    `peer`* {.preservesEmbedded.}: Value

  TurnEvent* {.preservesTuple.} = object
--- a/src/syndicate/protocols/stdenv.nim
+++ b/src/syndicate/protocols/stdenv.nim
@ -0,0 +1,40 @@
+
+import
+  preserves, sturdy, gatekeeper
+
+type
+  StandardTransportKind* {.pure.} = enum
+    `wsUrl`, `other`
+  `StandardTransport`* {.preservesOr.} = object
+    case orKind*: StandardTransportKind
+    of StandardTransportKind.`wsUrl`:
+        `wsurl`*: string
+
+    of StandardTransportKind.`other`:
+        `other`*: Value
+
+  
+  StandardRouteKind* {.pure.} = enum
+    `standard`, `general`
+  StandardRouteStandard* {.preservesTuple.} = object
+    `transports`*: seq[StandardTransport]
+    `key`*: seq[byte]
+    `service`*: Value
+    `sig`*: seq[byte]
+    `oid`*: Value
+    `caveats`* {.preservesTupleTail.}: seq[sturdy.Caveat]
+
+  `StandardRoute`* {.preservesOr.} = object
+    case orKind*: StandardRouteKind
+    of StandardRouteKind.`standard`:
+        `standard`*: StandardRouteStandard
+
+    of StandardRouteKind.`general`:
+        `general`*: gatekeeper.Route
+
+  
+proc `$`*(x: StandardTransport | StandardRoute): string =
+  `$`(toPreserves(x))
+
+proc encode*(x: StandardTransport | StandardRoute): seq[byte] =
+  encode(toPreserves(x))
--- a/src/syndicate/protocols/sturdy.nim
+++ b/src/syndicate/protocols/sturdy.nim
@ -107,8 +107,7 @@ type
  
  SturdyPathStepDetail* = Parameters
  `PAtom`* {.preservesOr, pure.} = enum
-    `Boolean`, `Float`, `Double`, `SignedInteger`, `String`, `ByteString`,
-    `Symbol`
+    `Boolean`, `Double`, `SignedInteger`, `String`, `ByteString`, `Symbol`
  PDiscard* {.preservesRecord: "_".} = object
  
  TemplateKind* {.pure.} = enum
--- a/src/syndicate/protocols/timer.nim
+++ b/src/syndicate/protocols/timer.nim
@ -5,17 +5,17 @@ import
 type
  TimerExpired* {.preservesRecord: "timer-expired".} = object
    `label`*: Value
-    `seconds`*: float64
+    `seconds`*: float

  SetTimer* {.preservesRecord: "set-timer".} = object
    `label`*: Value
-    `seconds`*: float64
+    `seconds`*: float
    `kind`*: TimerKind

  `TimerKind`* {.preservesOr, pure.} = enum
    `relative`, `absolute`, `clear`
  LaterThan* {.preservesRecord: "later-than".} = object
-    `seconds`*: float64
+    `seconds`*: float

 proc `$`*(x: TimerExpired | SetTimer | LaterThan): string =
  `$`(toPreserves(x))
--- a/src/syndicate/protocols/trace.nim
+++ b/src/syndicate/protocols/trace.nim
@ -86,11 +86,11 @@ type
    `reason`*: LinkedTaskReleaseReason

  TurnCausePeriodicActivation* {.preservesRecord: "periodic-activation".} = object
-    `period`*: float64
+    `period`*: float

  TurnCauseDelay* {.preservesRecord: "delay".} = object
    `causingTurn`*: TurnId
-    `amount`*: float64
+    `amount`*: float

  TurnCauseExternal* {.preservesRecord: "external".} = object
    `description`*: Value
@ -170,7 +170,7 @@ type

  
  TraceEntry* {.preservesRecord: "trace".} = object
-    `timestamp`*: float64
+    `timestamp`*: float
    `actor`*: ActorId
    `item`*: ActorActivation

--- a/src/syndicate/relays.nim
+++ b/src/syndicate/relays.nim
@ -1,10 +1,13 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense

-import std/[asyncdispatch, options, tables]
-from std/os import getEnv, `/`
+import std/[options, tables]
 import preserves
-import ../syndicate, /capabilities, ./durings, ./membranes, ./protocols/[gatekeeper, protocol, sturdy, transportAddress]
+import ../syndicate, ./durings, ./membranes, ./protocols/[gatekeeper, protocol, sturdy, transportAddress]
+
+when defined(posix):
+  import ./capabilities
+  from std/os import getEnv, `/`

 when defined(traceSyndicate):
  when defined(posix):
@ -16,32 +19,31 @@ else:

 export `$`

-type
-  Oid = sturdy.Oid
-
-export Stdio, Tcp, WebSocket, Unix
+export Route, Stdio, Tcp, WebSocket, Unix

 type
  Assertion = Value
-  WireRef = sturdy.WireRef
-  Turn = syndicate.Turn
+  Event = protocol.Event
  Handle = actors.Handle
+  Oid = sturdy.Oid
+  Turn = syndicate.Turn
+  WireRef = sturdy.WireRef

-type
-  PacketWriter = proc (pkt: sink Packet): Future[void] {.gcsafe.}
-  RelaySetup = proc (turn: var Turn; relay: Relay) {.gcsafe.}
+  PacketWriter = proc (turn: Turn; buf: seq[byte]) {.closure.}
+  RelaySetup = proc (turn: Turn; relay: Relay) {.closure.}

-  Relay* = ref object of RootObj
+  Relay* = ref object
    facet: Facet
    inboundAssertions: Table[Handle,
      tuple[localHandle: Handle, imported: seq[WireSymbol]]]
    outboundAssertions: Table[Handle, seq[WireSymbol]]
+    pendingTurn: protocol.Turn
    exported: Membrane
    imported: Membrane
    nextLocalOid: Oid
-    pendingTurn: protocol.Turn
+    wireBuf: BufferedDecoder
    packetWriter: PacketWriter
-    untrusted: bool
+    peer: Cap

  SyncPeerEntity = ref object of Entity
    relay: Relay
@ -57,20 +59,20 @@ type
 proc releaseCapOut(r: Relay; e: WireSymbol) =
  r.exported.drop e

-method publish(spe: SyncPeerEntity; t: var Turn; a: AssertionRef; h: Handle) =
+method publish(spe: SyncPeerEntity; t: Turn; a: AssertionRef; h: Handle) =
  spe.handleMap[h] = publish(t, spe.peer, a.value)

-method retract(se: SyncPeerEntity; t: var Turn; h: Handle) =
+method retract(se: SyncPeerEntity; t: Turn; h: Handle) =
  var other: Handle
  if se.handleMap.pop(h, other):
    retract(t, other)

-method message(se: SyncPeerEntity; t: var Turn; a: AssertionRef) =
+method message(se: SyncPeerEntity; t: Turn; a: AssertionRef) =
  if not se.e.isNil:
    se.relay.releaseCapOut(se.e)
  message(t, se.peer, a.value)

-method sync(se: SyncPeerEntity; t: var Turn; peer: Cap) =
+method sync(se: SyncPeerEntity; t: Turn; peer: Cap) =
  sync(t, se.peer, peer)

 proc newSyncPeerEntity(r: Relay; p: Cap): SyncPeerEntity =
@ -90,7 +92,7 @@ proc rewriteCapOut(relay: Relay; cap: Cap; exported: var seq[WireSymbol]): WireR
        mine: WireRefMine(oid: ws.oid))

 proc rewriteOut(relay: Relay; v: Assertion):
-    tuple[rewritten: Value, exported: seq[WireSymbol]] {.gcsafe.} =
+    tuple[rewritten: Value, exported: seq[WireSymbol]] =
  var exported: seq[WireSymbol]
  result.rewritten = mapEmbeds(v) do (pr: Value) -> Value:
    let o = pr.unembed(Cap); if o.isSome:
@ -107,43 +109,40 @@ proc deregister(relay: Relay; h: Handle) =
  if relay.outboundAssertions.pop(h, outbound):
    for e in outbound: releaseCapOut(relay, e)

-proc send(r: Relay; turn: var Turn; rOid: protocol.Oid; m: Event) =
-  if r.pendingTurn.len == 0:
-    # If the pending queue is empty then schedule a packet
-    # to be sent after pending I/O is processed.
-    callSoon do ():
-      r.facet.run do (turn: var Turn):
-        var pkt = Packet(
-          orKind: PacketKind.Turn,
-          turn: move r.pendingTurn)
-        trace "C: ", pkt
-        assert(not r.packetWriter.isNil, "missing packetWriter proc")
-        asyncCheck(turn, r.packetWriter(pkt))
-  r.pendingTurn.add TurnEvent(oid: rOid, event: m)
+proc send(relay: Relay; turn: Turn; rOid: protocol.Oid; m: Event) =
+  # TODO: don't send right away.
+  relay.pendingTurn.add TurnEvent(oid: rOid, event: m)
+  queueEffect(turn, relay.facet) do (turn: Turn):
+    if relay.pendingTurn.len > 0:
+      var pkt = Packet(
+        orKind: PacketKind.Turn,
+        turn: move relay.pendingTurn)
+      trace "C: ", pkt
+      relay.packetWriter(turn, encode pkt)

-proc send(re: RelayEntity; turn: var Turn; ev: Event) =
+proc send(re: RelayEntity; turn: Turn; ev: Event) =
  send(re.relay, turn, protocol.Oid re.oid, ev)

-method publish(re: RelayEntity; t: var Turn; a: AssertionRef; h: Handle) {.gcsafe.} =
+method publish(re: RelayEntity; t: Turn; a: AssertionRef; h: Handle) =
  re.send(t, Event(
      orKind: EventKind.Assert,
      `assert`: protocol.Assert(
        assertion: re.relay.register(a.value, h).rewritten,
        handle: h)))

-method retract(re: RelayEntity; t: var Turn; h: Handle) {.gcsafe.} =
+method retract(re: RelayEntity; t: Turn; h: Handle) =
  re.relay.deregister h
  re.send(t, Event(
    orKind: EventKind.Retract,
    retract: Retract(handle: h)))

-method message(re: RelayEntity; turn: var Turn; msg: AssertionRef) {.gcsafe.} =
+method message(re: RelayEntity; turn: Turn; msg: AssertionRef) =
  var (value, exported) = rewriteOut(re.relay, msg.value)
  assert(len(exported) == 0, "cannot send a reference in a message")
  if len(exported) == 0:
    re.send(turn, Event(orKind: EventKind.Message, message: Message(body: value)))

-method sync(re: RelayEntity; turn: var Turn; peer: Cap) {.gcsafe.} =
+method sync(re: RelayEntity; turn: Turn; peer: Cap) =
  var
    peerEntity = newSyncPeerEntity(re.relay, peer)
    exported: seq[WireSymbol]
@ -162,11 +161,8 @@ using

 proc lookupLocal(relay; oid: Oid): Cap =
  let sym = relay.exported.grab oid
-  if sym.isNil: newInertCap()
-  else: sym.cap
-
-proc isInert(r: Cap): bool =
-  r.target.isNil
+  if not sym.isNil:
+    result = sym.cap

 proc rewriteCapIn(relay; facet; n: WireRef, imported: var seq[WireSymbol]): Cap =
  case n.orKind
@ -181,12 +177,14 @@ proc rewriteCapIn(relay; facet; n: WireRef, imported: var seq[WireSymbol]): Cap
    imported.add e
    result = e.cap
  of WireRefKind.yours:
-    let r = relay.lookupLocal(n.yours.oid)
-    if n.yours.attenuation.len == 0 or r.isInert: result = r
-    else: raiseAssert "attenuation not implemented"
+    result = relay.lookupLocal(n.yours.oid)
+    if result.isNil:
+      result = newInertCap()
+    elif n.yours.attenuation.len > 0:
+      result = attenuate(result, n.yours.attenuation)

 proc rewriteIn(relay; facet; v: Value):
-    tuple[rewritten: Assertion; imported: seq[WireSymbol]] {.gcsafe.} =
+    tuple[rewritten: Assertion; imported: seq[WireSymbol]] =
  var imported: seq[WireSymbol]
  result.rewritten = mapEmbeds(v) do (pr: Value) -> Value:
    let wr = pr.preservesTo WireRef; if wr.isSome:
@ -197,7 +195,7 @@ proc rewriteIn(relay; facet; v: Value):

 proc close(r: Relay) = discard

-proc dispatch*(relay: Relay; turn: var Turn; cap: Cap; event: Event) {.gcsafe.} =
+proc dispatch(relay: Relay; turn: Turn; cap: Cap; event: Event) =
  case event.orKind
  of EventKind.Assert:
    let (a, imported) = rewriteIn(relay, turn.facet, event.assert.assertion)
@ -216,18 +214,17 @@ proc dispatch*(relay: Relay; turn: var Turn; cap: Cap; event: Event) {.gcsafe.}
    turn.message(cap, a)

  of EventKind.Sync:
-    discard # TODO
-    #[
-    var imported: seq[WireSymbol]
-    let k = relay.rewriteCapIn(turn, evenr.sync.peer, imported)
-    turn.sync(cap) do (turn: var Turn):
-      turn.message(k, true)
-      for e in imported: relay.imported.del e
-      ]#
+    turn.sync(cap) do (turn: Turn):
+      var
+        (v, imported) = rewriteIn(relay, turn.facet, event.sync.peer)
+        peer = unembed(v, Cap)
+      if peer.isSome:
+        turn.message(get peer, true)
+      for e in imported: relay.imported.drop e

-proc dispatch*(relay: Relay; v: Value) {.gcsafe.} =
+proc dispatch(relay: Relay; v: Value) =
  trace "S: ", v
-  run(relay.facet) do (t: var Turn):
+  run(relay.facet) do (t: Turn):
    var pkt: Packet
    if pkt.fromPreserves(v):
      case pkt.orKind
@ -235,10 +232,8 @@ proc dispatch*(relay: Relay; v: Value) {.gcsafe.} =
        # https://synit.org/book/protocol.html#turn-packets
        for te in pkt.turn:
          let r = lookupLocal(relay, te.oid.Oid)
-          if not r.isInert:
+          if not r.isNil:
            dispatch(relay, t, r, te.event)
-          else:
-            stderr.writeLine("discarding event for unknown Cap; ", te.event)
      of PacketKind.Error:
        # https://synit.org/book/protocol.html#error-packets
        when defined(posix):
@ -251,31 +246,33 @@ proc dispatch*(relay: Relay; v: Value) {.gcsafe.} =
      when defined(posix):
        stderr.writeLine("discarding undecoded packet ", v)

+proc recv(relay: Relay; buf: openarray[byte]; slice: Slice[int]) =
+  feed(relay.wireBuf, buf, slice)
+  var pr = decode(relay.wireBuf)
+  if pr.isSome: dispatch(relay, pr.get)
+
+proc recv(relay: Relay; buf: openarray[byte]) {.used.} =
+  feed(relay.wireBuf, buf)
+  var pr = decode(relay.wireBuf)
+  if pr.isSome: dispatch(relay, pr.get)
+
 type
  RelayOptions* = object of RootObj
    packetWriter*: PacketWriter
-    untrusted*: bool
+
  RelayActorOptions* = object of RelayOptions
    initialOid*: Option[Oid]
    initialCap*: Cap
    nextLocalOid*: Option[Oid]

-proc newRelay(turn: var Turn; opts: RelayOptions; setup: RelaySetup): Relay =
-  result = Relay(
-    facet: turn.facet,
-    packetWriter: opts.packetWriter,
-    untrusted: opts.untrusted)
-  discard result.facet.preventInertCheck()
-  setup(turn, result)
-
-proc transportConnectionResolve(addrAss: Assertion; ds: Cap): gatekeeper.TransportConnection =
-  result.`addr` = addrAss
-  result.resolved = Resolved(orKind: ResolvedKind.accepted)
-  result.resolved.accepted.responderSession = ds
-
-proc spawnRelay*(name: string; turn: var Turn; ds: Cap; addrAss: Assertion; opts: RelayActorOptions; setup: RelaySetup) =
-  discard spawn(name, turn) do (turn: var Turn):
-    let relay = newRelay(turn, opts, setup)
+proc spawnRelay(name: string; turn: Turn; opts: RelayActorOptions; setup: RelaySetup) =
+  linkActor(turn, name) do (turn: Turn):
+    turn.preventInertCheck()
+    let relay = Relay(
+        facet: turn.facet,
+        packetWriter: opts.packetWriter,
+        wireBuf: newBufferedDecoder(0),
+      )
    if not opts.initialCap.isNil:
      var exported: seq[WireSymbol]
      discard rewriteCapOut(relay, opts.initialCap, exported)
@ -283,175 +280,379 @@ proc spawnRelay*(name: string; turn: var Turn; ds: Cap; addrAss: Assertion; opts
      relay.nextLocalOid =
        if oid == 0.Oid: 1.Oid
        else: oid
+    assert opts.initialOid.isSome
    if opts.initialOid.isSome:
      var
        imported: seq[WireSymbol]
        wr = WireRef(
          orKind: WireRefKind.mine,
          mine: WireRefMine(oid: opts.initialOid.get))
-        res = rewriteCapIn(relay, turn.facet, wr, imported)
-      discard publish(turn, ds, transportConnectionResolve(addrAss, res))
-    else:
-      discard publish(turn, ds, transportConnectionResolve(addrAss, ds))
+      relay.peer = rewriteCapIn(relay, turn.facet, wr, imported)
+      assert not relay.peer.isNil
+    setup(turn, relay)
+
+proc rejected(detail: Value): Resolved =
+  result = Resolved(orKind: ResolvedKind.Rejected)
+  result.rejected.detail = detail
+
+proc accepted(cap: Cap): Resolved =
+  result = Resolved(orKind: ResolvedKind.accepted)
+  result.accepted.responderSession = cap
+
+type ShutdownEntity = ref object of Entity
+method retract(e: ShutdownEntity; turn: Turn; h: Handle) =
+  stopActor(e.facet)

 when defined(posix):
-  import std/asyncnet
-  from std/nativesockets import AF_INET, AF_UNIX, IPPROTO_TCP, SOCK_STREAM, Protocol

-type ShutdownEntity* = ref object of Entity
+  import std/[oserrors, posix]
+  import pkg/sys/[files, handles, ioqueue, sockets]
+  export transportAddress.Unix

-method retract(e: ShutdownEntity; turn: var Turn; h: Handle) =
-  stopActor(turn)
+  type StdioEntity = ref object of Entity
+    relay: Relay
+    stdin: AsyncFile
+    alive: bool

-type ConnectProc* = proc (turn: var Turn; ds: Cap) {.gcsafe.}
+  method message(entity: StdioEntity; turn: Turn; ass: AssertionRef) =
+    if ass.value.preservesTo(ForceDisconnect).isSome:
+      entity.alive = false

-export Tcp
+  proc loop(entity: StdioEntity) {.asyncio.} =
+    let buf = new seq[byte]
+    entity.alive = true
+    while entity.alive:
+      buf[].setLen(0x1000)
+      let n = read(entity.stdin, buf)
+      if n > 0:
+        entity.relay.recv(buf[], 0..<n)
+      else:
+        entity.alive = false
+        if n < 0: raiseOSError(osLastError())
+    stopActor(entity.facet)

-when defined(posix):
-  export Unix
-
-  proc connect*(turn: var Turn; ds: Cap; route: Route; addrAss: Assertion; socket: AsyncSocket; step: Value) =
-    ## Relay a dataspace over an open `AsyncSocket`.
-    proc socketWriter(packet: sink Packet): Future[void] =
-      socket.send(cast[string](encode(packet)))
-    const recvSize = 0x2000
-    var shutdownCap: Cap
-    let
-      reenable = turn.facet.preventInertCheck()
-      connectionClosedCap = newCap(turn, ShutdownEntity())
-    discard bootActor("socket") do (turn: var Turn):
-      var ops = RelayActorOptions(
-        packetWriter: socketWriter,
-        initialOid: 0.Oid.some)
-      spawnRelay("socket", turn, ds, addrAss, ops) do (turn: var Turn; relay: Relay):
-        let facet = turn.facet
-        var wireBuf = newBufferedDecoder(0)
-        proc recvCb(pktFut: Future[string]) {.gcsafe.} =
-          if pktFut.failed:
-            run(facet) do (turn: var Turn): stopActor(turn)
-          else:
-            var buf = pktFut.read
-            if buf.len == 0:
-              run(facet) do (turn: var Turn): stopActor(turn)
-            else:
-              feed(wireBuf, buf)
-              var (success, pr) = decode(wireBuf)
-              if success:
-                dispatch(relay, pr)
-              if not socket.isClosed:
-                socket.recv(recvSize).addCallback(recvCb)
-        socket.recv(recvSize).addCallback(recvCb)
-        turn.facet.actor.atExit do (turn: var Turn): close(socket)
-        discard publish(turn, connectionClosedCap, true)
-        shutdownCap = newCap(turn, ShutdownEntity())
-      onPublish(turn, ds, TransportConnection ?: {0: ?addrAss, 2: ?:Rejected}) do (detail: Value):
-        raise newException(IOError, $detail)
-      onPublish(turn, ds, TransportConnection ?: {0: ?addrAss, 2: ?:ResolvedAccepted}) do (gatekeeper: Cap):
-        run(gatekeeper.relay) do (turn: var Turn):
-          reenable()
-          discard publish(turn, shutdownCap, true)
-          proc duringCallback(turn: var Turn; ass: Assertion; h: Handle): TurnAction =
-            let facet = inFacet(turn) do (turn: var Turn):
-              let o = ass.preservesTo Resolved; if o.isSome:
-                discard publish(turn, ds, ResolvePath(
-                  route: route, `addr`: addrAss, resolved: o.get))
-            proc action(turn: var Turn) =
-              stop(turn, facet)
-            result = action
-          var resolve = Resolve(
-              step: step,
-              observer: newCap(turn, during(duringCallback)),
-            )
-          discard publish(turn, gatekeeper, resolve)
-
-  proc connect*(turn: var Turn; ds: Cap; route: Route; transport: Tcp; step: Value) =
-    ## Relay a dataspace over TCP.
-    let socket = newAsyncSocket(
-      domain = AF_INET,
-      sockType = SOCK_STREAM,
-      protocol = IPPROTO_TCP,
-      buffered = false)
-    let fut = connect(socket, transport.host, Port transport.port)
-    addCallback(fut, turn) do (turn: var Turn):
-      connect(turn, ds, route, transport.toPreserves, socket, step)
-
-  proc connect*(turn: var Turn; ds: Cap; route: Route; transport: Unix; step: Value) =
-    ## Relay a dataspace over a UNIX socket.
-    let socket = newAsyncSocket(
-      domain = AF_UNIX,
-      sockType = SOCK_STREAM,
-      protocol = cast[Protocol](0),
-      buffered = false)
-    let fut = connectUnix(socket, transport.path)
-    addCallback(fut, turn) do (turn: var Turn):
-      connect(turn, ds, route, transport.toPreserves, socket, step)
-
-  import std/asyncfile
-
-  const stdinReadSize = 128
-
-  proc connectStdio*(turn: var Turn; ds: Cap) =
-    ## Connect to an external dataspace over stdin and stdout.
-    proc stdoutWriter(packet: sink Packet): Future[void] =
-      result = newFuture[void]()
-      var buf = encode(packet)
-      doAssert writeBytes(stdout, buf, 0, buf.len) == buf.len
+  proc connectTransport(turn: Turn; ds: Cap; ta: transportAddress.Stdio) =
+    ## Connect to an external dataspace over stdio.
+    let localDataspace = newDataspace(turn)
+    proc stdoutWriter(turn: Turn; buf: seq[byte]) =
+      ## Blocking write to stdout.
+      let n = writeBytes(stdout, buf, 0, buf.len)
      flushFile(stdout)
-      complete result
+      if n != buf.len:
+        stopActor(turn)
    var opts = RelayActorOptions(
-      packetWriter: stdoutWriter,
-      initialCap: ds,
-      initialOid: 0.Oid.some)
-    spawnRelay("stdio", turn, ds, Stdio().toPreserves, opts) do (turn: var Turn; relay: Relay):
+        packetWriter: stdoutWriter,
+        initialCap: localDataspace,
+        initialOid: 0.Oid.some,
+      )
+    spawnRelay("stdio", turn, opts) do (turn: Turn; relay: Relay):
      let
        facet = turn.facet
-        asyncStdin = openAsync("/dev/stdin") # this is universal now?
-      close(stdin)
-      facet.actor.atExit do (turn: var Turn):
-        close(asyncStdin)
-      var wireBuf = newBufferedDecoder(0)
-      proc readCb(pktFut: Future[string]) {.gcsafe.} =
-        if not pktFut.failed:
-          var buf = pktFut.read
-          if buf.len == 0:
-            run(facet) do (turn: var Turn): stopActor(turn)
-          else:
-            feed(wireBuf, buf)
-            var (success, pr) = decode(wireBuf)
-            if success:
-              dispatch(relay, pr)
-            asyncStdin.read(stdinReadSize).addCallback(readCb)
-      asyncStdin.read(stdinReadSize).addCallback(readCb)
+        fd = stdin.getOsFileHandle()
+        flags =  fcntl(fd.cint, F_GETFL, 0)
+      if flags < 0: raiseOSError(osLastError())
+      if fcntl(fd.cint, F_SETFL, flags or O_NONBLOCK) < 0:
+        raiseOSError(osLastError())
+      let entity = StdioEntity(
+          facet: turn.facet, relay: relay, stdin: newAsyncFile(FD fd))
+      onStop(entity.facet) do (turn: Turn):
+        entity.alive = false
+        close(entity.stdin)
+          # Close stdin to remove it from the ioqueue
+      discard trampoline:
+        whelp loop(entity)
+      publish(turn, ds, TransportConnection(
+          `addr`: ta.toPreserves,
+          control: newCap(entity, turn),
+          resolved: localDataspace.accepted,
+        ))

-type BootProc* = proc (turn: var Turn; ds: Cap) {.gcsafe.}
+  proc connectStdio*(turn: Turn; ds: Cap) =
+    ## Connect to an external dataspace over stdin and stdout.
+    connectTransport(turn, ds, transportAddress.Stdio())

-proc envRoute*: Route =
-  var text = getEnv("SYNDICATE_ROUTE")
-  if text == "":
-    var tx = (getEnv("XDG_RUNTIME_DIR", "/run/user/1000") / "dataspace").toPreserves
-    result.transports = @[initRecord("unix", tx)]
-    result.pathSteps = @[capabilities.mint().toPreserves]
+  type
+    TcpEntity = ref object of Entity
+      relay: Relay
+      sock: AsyncConn[sockets.Protocol.TCP]
+      alive: bool
+
+    UnixEntity = ref object of Entity
+      relay: Relay
+      sock: AsyncConn[sockets.Protocol.Unix]
+      alive: bool
+
+    SocketEntity = TcpEntity | UnixEntity
+
+  method message(entity: SocketEntity; turn: Turn; ass: AssertionRef) =
+    if ass.value.preservesTo(ForceDisconnect).isSome:
+      entity.alive = false
+
+  template bootSocketEntity() {.dirty.} =
+    proc setup(turn: Turn) {.closure.} =
+      proc kill(turn: Turn) =
+        if entity.alive:
+          entity.alive = false
+          close(entity.sock)
+      onStop(turn, kill)
+      var ass = TransportConnection(
+          `addr`: ta.toPreserves,
+          control: newCap(entity, turn),
+          resolved: entity.relay.peer.accepted,
+        )
+      publish(turn, ds, ass)
+    run(entity.relay.facet, setup)
+    let buf = new seq[byte]
+    entity.alive = true
+    while entity.alive:
+      buf[].setLen(0x1000)
+      let n = read(entity.sock, buf)
+      if n > 0:
+        entity.relay.recv(buf[], 0..<n)
+      else:
+        entity.alive = false
+        if n < 0: raiseOSError(osLastError())
+    stopActor(entity.facet)
+    # the socket closes when the actor is stopped
+
+  proc boot(entity: TcpEntity; ta: transportAddress.Tcp; ds: Cap) {.asyncio.} =
+    entity.sock = connectTcpAsync(ta.host, Port ta.port)
+    bootSocketEntity()
+
+  proc boot(entity: UnixEntity; ta: transportAddress.Unix; ds: Cap) {.asyncio.} =
+    entity.sock = connectUnixAsync(ta.path)
+    bootSocketEntity()
+
+  template spawnSocketRelay() {.dirty.} =
+    proc writeConn(turn: Turn; buf: seq[byte]) =
+      if entity.alive:
+        discard trampoline:
+          whelp write(entity.sock, buf)
+    var ops = RelayActorOptions(
+        packetWriter: writeConn,
+        initialOid: 0.Oid.some,
+      )
+    spawnRelay("socket", turn, ops) do (turn: Turn; relay: Relay):
+      entity.facet = turn.facet
+      entity.relay = relay
+      discard trampoline:
+        whelp boot(entity, ta, ds)
+
+  proc connectTransport(turn: Turn; ds: Cap; ta: transportAddress.Tcp) =
+    let entity =  TcpEntity()
+    spawnSocketRelay()
+
+  proc connectTransport(turn: Turn; ds: Cap; ta: transportAddress.Unix) =
+    let entity =  UnixEntity()
+    spawnSocketRelay()
+
+elif defined(solo5):
+
+  import solo5_dispatcher
+  import taps
+
+  type
+    TcpEntity = ref object of Entity
+      relay: Relay
+      conn: Connection
+      decoder: BufferedDecoder
+
+  method message(entity: TcpEntity; turn: Turn; ass: AssertionRef) =
+    if ass.value.preservesTo(ForceDisconnect).isSome:
+      entity.conn.abort()
+
+  proc connectTransport(turn: Turn; ds: Cap; ta: transportAddress.Tcp) =
+    let entity =  TcpEntity(facet: turn.facet)
+
+    proc writeConn(turn: Turn; buf: seq[byte]) =
+      assert not entity.conn.isNil
+      entity.conn.batch:
+        entity.conn.send(buf)
+    var ops = RelayActorOptions(
+        packetWriter: writeConn,
+        initialOid: 0.Oid.some,
+      )
+    spawnRelay("socket", turn, ops) do (turn: Turn; relay: Relay):
+      entity.facet = turn.facet
+      entity.relay = relay
+
+      var ep = newRemoteEndpoint()
+      if ta.host.isIpAddress:
+        ep.with ta.host.parseIpAddress
+      else:
+        ep.withHostname ta.host
+      ep.with ta.port.Port
+
+      var tp = newTransportProperties()
+      tp.require "reliability"
+      tp.ignore "congestion-control"
+      tp.ignore "preserve-order"
+
+      var preconn = newPreconnection(
+        remote=[ep], transport=tp.some)
+      entity.conn = preconn.initiate()
+      entity.facet.onStop do (turn: Turn):
+        entity.conn.close()
+      entity.conn.onConnectionError do (err: ref Exception):
+        run(entity.facet) do (turn: Turn):
+          terminate(turn, err)
+      entity.conn.onClosed():
+        stop(entity.facet)
+      entity.conn.onReceivedPartial do (data: seq[byte]; ctx: MessageContext; eom: bool):
+        entity.relay.recv(data)
+        if eom:
+          stop(entity.facet)
+        else:
+          entity.conn.receive()
+      entity.conn.onReady do ():
+        entity.facet.run do (turn: Turn):
+          publish(turn, ds, TransportConnection(
+              `addr`: ta.toPreserves,
+              control: newCap(entity, turn),
+              resolved: entity.relay.peer.accepted,
+            ))
+          entity.conn.receive()
+
+proc walk(turn: Turn; ds, origin: Cap; route: Route; transOff, stepOff: int) =
+  if stepOff < route.pathSteps.len:
+    let
+      step = route.pathSteps[stepOff]
+      rejectPat = ResolvedPathStep?:{
+          0: ?(origin.embed), 1: ?step, 2: ?:Rejected}
+      acceptPat = ResolvedPathStep?:{
+          0: ?(origin.embed), 1: ?step, 2: ?:ResolvedAccepted}
+    onPublish(turn, ds, rejectPat) do (detail: Value):
+      publish(turn, ds, ResolvePath(
+          route: route,
+          `addr`: route.transports[transOff],
+          resolved: detail.rejected,
+        ))
+    during(turn, ds, acceptPat) do (next: Cap):
+      walk(turn, ds, next, route, transOff, stepOff.succ)
  else:
-    var pr = parsePreserves(text)
-    if not result.fromPreserves(pr):
-      raise newException(ValueError, "failed to parse $SYNDICATE_ROUTE " & $pr)
+    publish(turn, ds, ResolvePath(
+        route: route,
+        `addr`: route.transports[transOff],
+        resolved: origin.accepted,
+      ))

-proc resolve*(turn: var Turn; ds: Cap; route: Route; bootProc: BootProc) =
-  var
-    unix: Unix
-    tcp: Tcp
-    stdio: Stdio
-  doAssert(route.transports.len == 1, "only a single transport supported for routes")
-  doAssert(route.pathSteps.len < 2, "multiple path steps not supported for routes")
-  if unix.fromPreserves route.transports[0]:
-    connect(turn, ds, route, unix, route.pathSteps[0])
-  elif tcp.fromPreserves route.transports[0]:
-    connect(turn, ds, route, tcp, route.pathSteps[0])
-  elif stdio.fromPreserves route.transports[0]:
-    connectStdio(turn, ds)
-    bootProc(turn, ds)
-  else:
-    raise newException(ValueError, "unsupported route")
+proc connectRoute(turn: Turn; ds: Cap; route: Route; transOff: int) =
+  let rejectPat = TransportConnection ?: {
+      0: ?route.transports[transOff],
+      2: ?:Rejected,
+    }
+  during(turn, ds, rejectPat) do (detail: Value):
+    publish(turn, ds, ResolvePath(
+        route: route,
+        `addr`: route.transports[transOff],
+        resolved: detail.rejected,
+      ))
+  let acceptPat = TransportConnection?:{
+      0: ?route.transports[transOff],
+      2: ?:ResolvedAccepted,
+    }
+  onPublish(turn, ds, acceptPat) do (origin: Cap):
+    origin.relay.run do (turn: Turn):
+      # walk using the facet that manages the transport connection
+      walk(turn, ds, origin, route, transOff, 0)

-  during(turn, ds, ResolvePath ?: { 0: ?route, 3: ?:ResolvedAccepted}) do (dest: Cap):
-    bootProc(turn, dest)
+type StepCallback = proc (turn: Turn; step: Value; origin: Cap; res: Resolved) {.closure.}
+
+proc spawnStepResolver(turn: Turn; ds: Cap; stepType: Value; cb: StepCallback) =
+  let pat = observePattern(
+      ResolvedPathStep?:{1: grabRecord(stepType)},
+      { @[0.toPreserve]: grabLit(), @[1.toPreserve]: grab() },
+    )
+  during(turn, ds, pat) do (origin: Cap; stepDetail: Literal[Value]):
+    proc duringCallback(turn: Turn; ass: Value; h: Handle): TurnAction =
+      var res: Resolved
+      if res.fromPreserves ass:
+        cb(turn, stepDetail.value, origin, res)
+      proc action(turn: Turn) =
+        stop(turn)
+      result = action
+    publish(turn, origin, Resolve(
+        step: stepDetail.value, observer: newCap(turn, during(duringCallback))))
+
+proc spawnRelays*(turn: Turn; ds: Cap) =
+  ## Spawn actors that manage routes and appease gatekeepers.
+
+  let transPat = observePattern(!TransportConnection, { @[0.toPreserves]: grab() })
+    # Use a generic pattern and type matching
+    # in the during handler because it is easy.
+
+  when defined(posix):
+    let stdioPat = ?Observe(pattern: TransportConnection?:{0: ?:Stdio})
+    during(turn, ds, stdioPat) do:
+      connectTransport(turn, ds, Stdio())
+
+    # TODO: unix pattern
+    during(turn, ds, transPat) do (ta: Literal[transportAddress.Unix]):
+      try: connectTransport(turn, ds, ta.value)
+      except exceptions.IOError as e:
+        publish(turn, ds, TransportConnection(
+            `addr`: ta.toPreserve,
+            resolved: rejected(embed e),
+          ))
+
+  # TODO: tcp pattern
+  during(turn, ds, transPat) do (ta: Literal[transportAddress.Tcp]):
+    try: connectTransport(turn, ds, ta.value)
+    except exceptions.IOError as e:
+      publish(turn, ds, TransportConnection(
+          `addr`: ta.toPreserve,
+          resolved: rejected(embed e),
+        ))
+
+  let resolvePat = observePattern(!ResolvePath, {@[0.toPreserves]: grab()})
+  during(turn, ds, resolvePat) do (route: Literal[Route]):
+    for i, transAddr in route.value.transports:
+      connectRoute(turn, ds, route.value, i)
+
+  spawnStepResolver(turn, ds, "ref".toSymbol) do (
+      turn: Turn, step: Value, origin: Cap, res: Resolved):
+    publish(turn, ds, ResolvedPathStep(
+        origin: origin, pathStep: step, resolved: res))
+
+type BootProc* = proc (turn: Turn; ds: Cap) {.closure.}
+
+proc resolve*(turn: Turn; ds: Cap; route: Route; bootProc: BootProc) =
+  ## Resolve `route` within `ds` and call `bootProc` with resolved capabilities.
+  let pat = ResolvePath ?: {0: ?route, 3: ?:ResolvedAccepted}
+  during(turn, ds, ResolvePath ?: {0: ?route, 3: ?:ResolvedAccepted}) do (dst: Cap):
+    bootProc(turn, dst)
+
+when defined(posix):
+  const defaultRoute* = "<route [<stdio>]>"
+
+  proc envRoute*: Route =
+    ## Get an route to a Syndicate capability from the calling environment.
+    ## On UNIX this is the SYNDICATE_ROUTE environmental variable with a
+    ## fallack to a defaultRoute_.
+    ## See https://git.syndicate-lang.org/syndicate-lang/syndicate-protocols/raw/branch/main/schemas/gatekeeper.prs.
+    var text = getEnv("SYNDICATE_ROUTE", defaultRoute)
+    if text == "":
+      var tx = (getEnv("XDG_RUNTIME_DIR", "/run/user/1000") / "dataspace").toPreserves
+      result.transports = @[initRecord("unix", tx)]
+      result.pathSteps = @[capabilities.mint().toPreserves]
+    else:
+      var pr = parsePreserves(text)
+      if not result.fromPreserves(pr):
+        raise newException(ValueError, "failed to parse $SYNDICATE_ROUTE " & $pr)
+
+  proc resolveEnvironment*(turn: Turn; bootProc: BootProc) =
+    ## Resolve a capability from the calling environment
+    ## and call `bootProc`. See envRoute_.
+    var resolved = false
+    let
+      ds = newDataspace(turn)
+      pat = ResolvePath ?: {0: ?envRoute(), 3: ?:ResolvedAccepted}
+    during(turn, ds, pat) do (dst: Cap):
+      if not resolved:
+        resolved = true
+        bootProc(turn, dst)
+    do:
+      resolved = false
+    spawnRelays(turn, ds)
+
+# TODO: define a runActor that comes preloaded with relaying
--- a/src/syndicate/skeletons.nim
+++ b/src/syndicate/skeletons.nim
@ -3,38 +3,34 @@

 ## https://git.syndicate-lang.org/syndicate-lang/syndicate-rkt/src/commit/90c4c60699069b496491b81ee63b5a45ffd638cb/syndicate/HOWITWORKS.md

-import std/[hashes, options, sets, tables]
+import std/[assertions, hashes, options, sets, tables]
 import preserves
 import ./actors, ./bags, ./patterns
 import ./protocols/dataspacePatterns

 type
-  DCompound = dataspacePatterns.DCompound
  Pattern = dataspacePatterns.Pattern
  Path = seq[Value]
  ClassKind = enum classNone, classRecord, classSequence, classDictionary
  Class = object
    kind: ClassKind
    label: Value
-    arity: int

 func classOf(v: Value): Class =
  case v.kind
-  of pkRecord: Class(kind: classRecord, label: v.label, arity: v.arity)
-  of pkSequence: Class(kind: classSequence, arity: v.len)
+  of pkRecord: Class(kind: classRecord, label: v.label)
+  of pkSequence: Class(kind: classSequence)
  of pkDictionary: Class(kind: classDictionary)
  else: Class(kind: classNone)

 proc classOf(p: Pattern): Class =
-  if p.orKind == PatternKind.DCompound:
-    case p.dcompound.orKind
-    of DCompoundKind.rec:
-      Class(kind: classRecord,
-        label: p.dcompound.rec.label,
-        arity: p.dcompound.rec.fields.len)
-    of DCompoundKind.arr:
-      Class(kind: classSequence, arity: p.dcompound.arr.items.len)
-    of DCompoundKind.dict:
+  if p.orKind == PatternKind.group:
+    case p.group.type.orKind
+    of GroupTypeKind.rec:
+      Class(kind: classRecord, label: p.group.`type`.rec.label)
+    of GroupTypeKind.arr:
+      Class(kind: classSequence)
+    of GroupTypeKind.dict:
      Class(kind: classDictionary)
  else:
    Class(kind: classNone)
@ -65,17 +61,18 @@ func isEmpty(cont: Continuation): bool =
  cont.cache.len == 0 and cont.leafMap.len == 0

 type
-  ContinuationProc = proc (c: Continuation; v: Value) {.gcsafe.}
-  LeafProc = proc (l: Leaf; v: Value) {.gcsafe.}
-  ObserverProc = proc (turn: var Turn; group: ObserverGroup; vs: seq[Value]) {.gcsafe.}
+  ContinuationProc = proc (c: Continuation; v: Value) {.closure.}
+  LeafProc = proc (l: Leaf; v: Value) {.closure.}
+  ObserverProc = proc (turn: Turn; group: ObserverGroup; vs: seq[Value]) {.closure.}

-proc getLeaves(cont: Continuation; constPaths: Paths): LeafMap =
+proc getLeaves(cont: Continuation; presentPaths, constPaths: Paths): LeafMap =
  result = cont.leafMap.getOrDefault(constPaths)
  if result.isNil:
    new result
    cont.leafMap[constPaths] = result
    assert not cont.isEmpty
    for ass in cont.cache:
+      # TODO: check presence
      let key = projectPaths(ass, constPaths)
      if key.isSome:
        var leaf = result.getOrDefault(get key)
@ -114,10 +111,10 @@ proc top(stack: TermStack): Value =
  assert stack.len > 0
  stack[stack.high]

-proc modify(node: Node; turn: var Turn; outerValue: Value; event: EventKind;
+proc modify(node: Node; turn: Turn; outerValue: Value; event: EventKind;
    modCont: ContinuationProc; modLeaf: LeafProc; modObs: ObserverProc) =

-  proc walk(cont: Continuation; turn: var Turn) =
+  proc walk(cont: Continuation; turn: Turn) =
    modCont(cont, outerValue)
    for constPaths, constValMap in cont.leafMap.pairs:
      let constVals = projectPaths(outerValue, constPaths)
@ -142,7 +139,7 @@ proc modify(node: Node; turn: var Turn; outerValue: Value; event: EventKind;
              constValMap.del(get constVals)


-  proc walk(node: Node; turn: var Turn; termStack: TermStack) =
+  proc walk(node: Node; turn: Turn; termStack: TermStack) =
    walk(node.continuation, turn)
    for selector, table in node.edges:
      let
@ -165,25 +162,13 @@ proc getOrNew[A, B, C](t: var Table[A, TableRef[B, C]], k: A): TableRef[B, C] =
    result = newTable[B, C]()
    t[k] = result

-iterator pairs(dc: DCompound): (Value, Pattern) =
-  case dc.orKind
-  of DCompoundKind.rec:
-    for i, p in dc.rec.fields:
-      yield (i.toPreserves, p,)
-  of DCompoundKind.arr:
-    for i, p in dc.arr.items:
-      yield (i.toPreserves, p,)
-  of DCompoundKind.dict:
-    for pair in dc.dict.entries.pairs:
-      yield pair
-
 proc extendWalk(node: Node; popCount: Natural; stepIndex: Value; pat: Pattern; path: var Path): tuple[popCount: Natural, nextNode: Node] =
  case pat.orKind
-  of PatternKind.DDiscard, PatternKind.DLit:
+  of PatternKind.`discard`, PatternKind.lit:
    result = (popCount, node)
-  of PatternKind.DBind:
-    result = extendWalk(node, popCount, stepIndex, pat.dbind.pattern, path)
-  of PatternKind.DCompound:
+  of PatternKind.`bind`:
+    result = extendWalk(node, popCount, stepIndex, pat.`bind`.pattern, path)
+  of PatternKind.`group`:
    let
      selector: Selector = (popCount, stepIndex,)
      table = node.edges.getOrNew(selector)
@ -198,7 +183,7 @@ proc extendWalk(node: Node; popCount: Natural; stepIndex: Value; pat: Pattern; p
        if v.isSome and class == classOf(get v):
          result.nextNode.continuation.cache.incl a
    result.popCount = 0
-    for step, p in pat.dcompound.pairs:
+    for step, p in pat.group.entries:
      add(path, step)
      result = extendWalk(result.nextNode, result.popCount, step, p, path)
      discard pop(path)
@ -227,11 +212,11 @@ proc getEndpoints(leaf: Leaf; capturePaths: Paths): ObserverGroup =
      if captures.isSome:
        discard result.cachedCaptures.change(get captures, +1)

-proc add*(index: var Index; turn: var Turn; pattern: Pattern; observer: Cap) =
+proc add*(index: var Index; turn: Turn; pattern: Pattern; observer: Cap) =
  let
    cont = index.root.extend(pattern)
    analysis = analyse pattern
-    constValMap = cont.getLeaves(analysis.constPaths)
+    constValMap = cont.getLeaves(analysis.presentPaths, analysis.constPaths)
    leaf = constValMap.getLeaf(analysis.constValues)
    endpoints = leaf.getEndpoints(analysis.capturePaths)
  # TODO if endpoints.cachedCaptures.len > 0:
@ -240,7 +225,7 @@ proc add*(index: var Index; turn: var Turn; pattern: Pattern; observer: Cap) =
    captureMap[capture] = publish(turn, observer, capture)
  endpoints.observers[observer] = captureMap

-proc remove*(index: var Index; turn: var Turn; pattern: Pattern; observer: Cap) =
+proc remove*(index: var Index; turn: Turn; pattern: Pattern; observer: Cap) =
  let
    cont = index.root.extend(pattern)
    analysis = analyse pattern
@ -260,7 +245,7 @@ proc remove*(index: var Index; turn: var Turn; pattern: Pattern; observer: Cap)
    if constValMap.len == 0:
      cont.leafMap.del(analysis.constPaths)

-proc adjustAssertion(index: var Index; turn: var Turn; outerValue: Value; delta: int): bool =
+proc adjustAssertion(index: var Index; turn: Turn; outerValue: Value; delta: int): bool =
  case index.allAssertions.change(outerValue, delta)
  of cdAbsentToPresent:
    result = true
@ -268,7 +253,7 @@ proc adjustAssertion(index: var Index; turn: var Turn; outerValue: Value; delta:
      c.cache.incl(v)
    proc modLeaf(l: Leaf; v: Value) =
      l.cache.incl(v)
-    proc modObserver(turn: var Turn; group: ObserverGroup; vs: seq[Value]) =
+    proc modObserver(turn: Turn; group: ObserverGroup; vs: seq[Value]) =
      let change = group.cachedCaptures.change(vs, +1)
      if change == cdAbsentToPresent:
        for (observer, captureMap) in group.observers.pairs:
@ -281,7 +266,7 @@ proc adjustAssertion(index: var Index; turn: var Turn; outerValue: Value; delta:
      c.cache.excl(v)
    proc modLeaf(l: Leaf; v: Value) =
      l.cache.excl(v)
-    proc modObserver(turn: var Turn; group: ObserverGroup; vs: seq[Value]) =
+    proc modObserver(turn: Turn; group: ObserverGroup; vs: seq[Value]) =
      if group.cachedCaptures.change(vs, -1) == cdPresentToAbsent:
        for (observer, captureMap) in group.observers.pairs:
          var h: Handle
@ -293,12 +278,12 @@ proc adjustAssertion(index: var Index; turn: var Turn; outerValue: Value; delta:
 proc continuationNoop(c: Continuation; v: Value) = discard
 proc leafNoop(l: Leaf; v: Value) = discard

-proc add*(index: var Index; turn: var Turn; v: Value): bool =
+proc add*(index: var Index; turn: Turn; v: Value): bool =
  adjustAssertion(index, turn, v, +1)
-proc remove*(index: var Index; turn: var Turn; v: Value): bool =
+proc remove*(index: var Index; turn: Turn; v: Value): bool =
  adjustAssertion(index, turn, v, -1)

-proc deliverMessage*(index: var Index; turn: var Turn; v: Value) =
-  proc observersCb(turn: var Turn; group: ObserverGroup; vs: seq[Value]) =
+proc deliverMessage*(index: var Index; turn: Turn; v: Value) =
+  proc observersCb(turn: Turn; group: ObserverGroup; vs: seq[Value]) =
    for observer in group.observers.keys: message(turn, observer, vs)
  index.root.modify(turn, v, messageEvent, continuationNoop, leafNoop, observersCb)
--- a/syndicate.nimble
+++ b/syndicate.nimble
@ -1,6 +1,6 @@
 # Package

-version = "20240114"
+version = "20240507"
 author        = "Emery Hemingway"
 description   = "Syndicated actors for conversational concurrency"
 license       = "Unlicense"
@ -9,4 +9,4 @@ srcDir        = "src"

 # Dependencies

-requires "https://github.com/ehmry/hashlib.git#f9455d4be988e14e3dc7933eb7cc7d7c4820b7ac", "nim >= 2.0.0", "https://git.syndicate-lang.org/ehmry/preserves-nim.git >= 20240108"
+requires "https://github.com/ehmry/hashlib.git >= 20231130", "nim >= 2.0.0", "https://git.syndicate-lang.org/ehmry/preserves-nim.git >= 20240422", "https://github.com/ehmry/nim-sys.git#4ef3b624db86e331ba334e705c1aa235d55b05e1", "https://git.sr.ht/~ehmry/nim_taps >= 20240405"
--- a/tests/Tupfile
+++ b/tests/Tupfile
@ -1,3 +1,4 @@
 include_rules
 : foreach *.prs |> !preserves_schema_nim |> | {schema}
 : foreach t*.nim | ../../preserves-nim/<tests> {schema} $(SYNDICATE_PROTOCOL) |> !nim_run |> | ../<test>
+: foreach solo5*.nim | ../../taps/<sources> ../../preserves-nim/<tests> {schema} $(SYNDICATE_PROTOCOL) |> !nim_solo5_spt |> | ../<test>
--- a/tests/simple_chat.sy
+++ b/tests/simple_chat.sy
@ -1,92 +0,0 @@
-#!/usr/bin/env spry
-
-title = "Simple Chat Demo"
-
-# Initialize libui
-uiInit
-
-username = "user"
-
-menu = newMenu "Menu"
-
-# menu addItem: "Username" onClicked: [
-#   dialog = newWindow: "Username" width: 200 height: 40 hasBar: false
-#   entry = newEntryText: username onChanged: []
-#   quitit = newButton: "Quit" onClicked: [
-#     destroy dialog
-#     true
-#   ]
-#   layout = newHorizontalBox
-#   #layout add: entry stretch: true
-#   layout.add: quitit stretch: false
-#   group = newGroup "Username"
-#   group setChild: layout
-#   dialog setChild: quitit
-#   dialog show
-# ]
-
-menu menuAppendAboutItem
-
-menu addQuitItemShouldClose: [
-  win destroy
-  uiQuit
-  true
-]
-
-# Create a new Window
-win = newWindow: title width: 640 height: 400 hasBar: true
-win margined: true
-
-# create text boxes
-scrollback = newMultilineEntryText
-scrollback readonly: true
-
-sendEntry = newMultilineEntryText
-
-# create layouts
-layout = newVerticalBox
-sendBox = newHorizontalBox
-
-# Some buttons and their handlers
-sendButton = newButton: "Send" onClicked: [
-  msg = (sendEntry text)
-  msg != "" then: [
-    scrollback addText: (msg, "\x0a")
-    sendEntry text: ""
-  ]
-]
-
-# Group
-group = newGroup "Workspace"
-group margined: false
-group setChild: layout
-
-sendBox add: sendEntry stretch: true
-sendBox add: sendButton stretch: false
-
-# Put things in the boxes
-layout padded: true
-layout add: scrollback stretch: true
-layout add: sendBox stretch: false
-
-# Add box to window
-win setChild: group
-
-# Set initial text
-sendEntry text: "compose a message here"
-
-# Close handler
-closeHandler = [
-  win destroy
-  uiQuit
-  true
-]
-
-# Set a handler on closing window
-win onClosingShouldClose: [ true ]
-
-# Show the window
-win show
-
-# Enter libui's event loop
-uiMain
--- a/tests/solo5_relays_test.nim
+++ b/tests/solo5_relays_test.nim
@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: ☭ Emery Hemingway
+# SPDX-License-Identifier: Unlicense
+
+import taps
+import solo5
+import syndicate, syndicate/relays
+import preserves
+
+acquireDevices([("relay", netBasic)], netAcquireHook)
+
+type Netif {.preservesRecord: "netif"} = object
+  device, ipAddr: string
+
+proc spawnNetifActor(turn: Turn; ds: Cap) =
+  spawnActor(turn, "netif") do (turn: Turn):
+    let facet = turn.facet
+    onInterfaceUp do (device: string; ip: IpAddress):
+      run(facet) do (turn: Turn):
+        if not ip.isLinkLocal:
+          discard publish(turn, ds, Netif(device: device, ipAddr: $ip))
+
+runActor("relay-test") do (turn: Turn):
+  let root = turn.facet
+  onStop(turn) do (turn: Turn):
+    quit()
+  let ds = newDataspace(turn)
+  spawnNetifActor(turn, ds)
+  spawnRelays(turn, ds)
+  var
+    route: Route
+    pr = parsePreserves $solo5_start_info.cmdline
+  if route.fromPreserves pr:
+    echo "parsed route ", route.toPreserves
+    during(turn, ds, Netif?:{1: grab()}) do (ip: string):
+      echo "Acquired address ", ip
+      resolve(turn, ds, route) do (turn: Turn; ds: Cap):
+        echo "route resolved!"
+        echo "stopping root facet"
+        stop(turn, root)
--- a/tests/solo5_relays_test.nim.cfg
+++ b/tests/solo5_relays_test.nim.cfg
@ -0,0 +1,3 @@
+define:ipv6Enabled
+define:traceSyndicate
+import:"std/assertions"
--- a/tests/solo5_test.nim
+++ b/tests/solo5_test.nim
@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: ☭ Emery Hemingway
+# SPDX-License-Identifier: Unlicense
+
+import std/times
+import solo5
+import syndicate, syndicate/drivers/timers
+
+acquireDevices()
+
+runActor("timer-test") do (turn: Turn):
+  let timers = newDataspace(turn)
+  spawnTimerDriver(turn, timers)
+
+  onPublish(turn, timers, ?LaterThan(seconds: 1356100000)):
+    echo "now in 13th bʼakʼtun"
+
+  after(turn, timers, initDuration(seconds = 3)) do (turn: Turn):
+    echo "third timer expired"
+    stopActor(turn)
+
+  after(turn, timers, initDuration(seconds = 1)) do (turn: Turn):
+    echo "first timer expired"
+
+  after(turn, timers, initDuration(seconds = 2)) do (turn: Turn):
+    echo "second timer expired"
--- a/tests/solo5_test.nim.cfg
+++ b/tests/solo5_test.nim.cfg
@ -0,0 +1,2 @@
+define:ipv6Enabled
+import:"std/assertions"
--- a/tests/test_chat.nim
+++ b/tests/test_chat.nim
@ -1,7 +1,8 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense

-import std/[asyncdispatch, asyncfile, os, parseopt]
+import std/[oserrors, parseopt, posix, strutils]
+import pkg/sys/[files, handles, ioqueue]
 import preserves, syndicate, syndicate/relays

 type
@ -10,33 +11,51 @@ type
  Says {.preservesRecord: "Says".} = object
    who, what: string

-proc readStdin(facet: Facet; ds: Cap; username: string) =
-  let file = openAsync("/dev/stdin")
-  onStop(facet) do (turn: var Turn): close(file)
-  close(stdin)
-  proc readLine() {.gcsafe.} =
-    let future = readLine(file)
-    addCallback(future, facet) do (turn: var Turn):
-      var msg = read(future)
-      if msg == "": quit()
-      message(turn, ds, Says(who: username, what: msg))
-      readLine()
-  readLine()
+proc syncAndStop(facet: Facet; cap: Cap) =
+  ## Stop the actor responsible for `facet` after
+  ## synchronizing with `cap`.
+  run(facet) do (turn: Turn):
+    sync(turn, cap, stopActor)

-proc chat(turn: var Turn; ds: Cap; username: string) =
-    during(turn, ds, ?:Present) do (who: string):
-      echo who, " joined"
-    do:
-      echo who, " left"
+proc readStdin(facet: Facet; ds: Cap; username: string) {.asyncio.} =
+  let
+    fd = stdin.getOsFileHandle()
+    flags =  fcntl(fd.cint, F_GETFL, 0)
+  if flags < 0:
+    raiseOSError(osLastError())
+  if fcntl(fd.cint, F_SETFL, flags or O_NONBLOCK) < 0:
+    raiseOSError(osLastError())
+  let
+    file = newAsyncFile(FD fd)
+    buf = new string
+  buf[].setLen(0x1000)
+  while true:
+    let n = read(file, buf)
+    if n < 1:
+      stderr.writeLine "test_chat calls stopsActor ", facet.actor
+      syncAndStop(facet, ds)
+      return
+    else:
+      var msg = buf[][0..<n].strip
+      proc send(turn: Turn) =
+        message(turn, ds, Says(who: username, what: msg))
+      run(facet, send)

-    onMessage(turn, ds, ?:Says) do (who: string, what: string):
-      echo who, ": ", what
+proc chat(turn: Turn; ds: Cap; username: string) =
+  during(turn, ds, ?:Present) do (who: string):
+    echo who, " joined"
+  do:
+    echo who, " left"

-    discard publish(turn, ds, Present(username: username))
-    readStdin(turn.facet, ds, username)
+  onMessage(turn, ds, ?:Says) do (who: string, what: string):
+    echo who, ": ", what
+
+  discard publish(turn, ds, Present(username: username))
+
+  discard trampoline:
+    whelp readStdin(turn.facet, ds, username)

 proc main =
-  let route = envRoute()
  var username = ""

  for kind, key, val in getopt():
@ -48,8 +67,8 @@ proc main =
  if username == "":
      stderr.writeLine "--user: unspecified"
  else:
-    runActor("chat") do (turn: var Turn; root: Cap):
-      resolve(turn, root, route) do (turn: var Turn; ds: Cap):
+    runActor("chat") do (turn: Turn):
+      resolveEnvironment(turn) do (turn: Turn; ds: Cap):
        chat(turn, ds, username)

 main()
--- a/tests/test_patterns.nim
+++ b/tests/test_patterns.nim
@ -1,103 +1,87 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense

-import std/[options, tables, unittest]
+import std/[options, sequtils, tables, unittest]

-import preserves, syndicate, syndicate/protocols/gatekeeper
+import preserves, syndicate, syndicate/protocols/[gatekeeper, timer]

 import ./test_schema

-test "patterns":
-  let
-    pat = ?Observe(pattern: !Foo) ?? {0: grab()}
-    text = """<rec Observe [<rec rec [<lit foo> <arr [<bind <_>> <_> <_>]>]> <_>]>"""
-  check($pat == text)
+suite "example":
+  var pat: Pattern
+  check pat.fromPreserves parsePreserves"""
+      <group <arr> {
+        0: <lit 1>
+        1: <bind <group <arr> {
+          0: <bind <_>>
+          1: <_>
+        }>>
+        2: <_>
+      }>
+    """

-  let
-    worte = @["alles", "in", "ordnung"]
-    observer = Observe(pattern: inject(?:Foo, { 0: ?worte })).toPreserves
-    have = capture(pat, observer).toPreserves.unpackLiterals
-    want = [worte.toPreserves].toPreserves
-  check(have ==  want)
+  const A = "[1 2 3]"
+  test A:
+    let v = parsePreserves A
+    check:
+      not pat.matches(v)

-type Obj {.preservesDictionary.} = object
-  a, b, c: int
-
-test "dictionaries":
-  let pat = ?:Obj
-  var source = initDictionary(Cap)
-  source["b".toSymbol] = 2.toPreserves
-  source["c".toSymbol] = 3.toPreserves
-  source["a".toSymbol] = 1.toPreserves
-
-  let values = capture(pat, source)
-  check values.len == 3
-  check values[0] == 1.toPreserves
-  check values[1] == 2.toPreserves
-  check values[2] == 3.toPreserves
-
-type
-  File {.preservesDictionary.} = object
-    name: string
-    path: string
-    size: BiggestInt
-    `type`: string
-  Files = Table[Symbol, File]
-  Fields = Table[Symbol, string]
-
-  Request {.preservesRecord: "request".} = object
-    seq: BiggestInt
-    fields: Fields
-    files: Files
-
-test "literals":
-  const txt = """<rec request [<lit 3> <dict {artists: <lit "kyyyyym"> date: <lit "2023-10-14"> notes: <lit "Lots of stuff"> title: <lit "Domes show">}> <dict {front-cover: <dict {name: <lit "ADULT_TIME_Glielmi.jpg"> path: <lit "/tmp/652adad1b3d2b666dcc8d857.jpg"> size: <lit 255614> type: <lit "image/jpeg">}>}>]>"""
-  var pr = parsePreserves(txt)
-
-  var capture: Literal[Request]
-  check capture.fromPreserves(pr)
-
-suite "captures":
-  for txt in [
-      "#f",
-      "#t",
-      "0",
-      "-1",
-      "foo",
-      "<foo>",
-      "[0, 1, 2]",
-      ]:
-    test txt:
-      let
-        pr = parsePreserves txt
-        pat = grab pr
-      checkpoint $pat
-      check pat.matches pr
-
-suite "protocol":
-  test "Observe":
-    let pat = ?:Observe
-    const text = """<rec Observe [<bind <_>> <bind <_>>]>"""
-    check $pat == text
-
-  test "later-than":
+  const B = "[1 [2 3] 4]"
+  test B:
    let
-      obsA = parsePreserves"""<Observe <rec later-than [<lit 1704113731.419243>]> #!#f>"""
-      obsB = parsePreserves"""<Observe <rec Observe [<rec rec [<lit later-than> <arr [<rec lit [<bind <_>>]>]>]> <_>]> #!#f>"""
-      patA = """<rec later-than [<lit 1704113731.419243>]>""".parsePreserves.preservesTo(Pattern).get
-      patB = """<rec Observe [<rec rec [<lit later-than> <arr [<rec lit [<bind <_>>]>]>]> <_>]>""".parsePreserves.preservesTo(Pattern).get
+      v = parsePreserves B
+      c = parsePreserves "[[2 3] 2]"
+    check pat.matches(v)
+    check pat.capture(v).toPreserves == c

-      patC = grab obsA
+  const C = "[1 [2] 5]"
+  test C:
+    let v = parsePreserves C
+    check:
+      not pat.matches(v)

-    test $patC:
-      check patC.matches obsA
-
-    test $patB:
-      checkpoint $obsA
-      check patB.matches obsA
-
-  test "TransportConnection":
+  const D = "[1 [2 3 4] 5]"
+  test D:
    let
-      pat = TransportConnection ?: { 2: ?:Rejected}
-      text = """<rec connect-transport [<_> <_> <rec rejected [<bind <_>>]>]>"""
-    check $pat == text
+      v = parsePreserves D
+      c = parsePreserves "[[2 3 4] 2]"
+    check pat.matches(v)
+    check pat.capture(v).toPreserves == c
+
+  const E = "[1 [<x> <y>] []]"
+  test E:
+    let
+      v = parsePreserves E
+      c = parsePreserves "[[<x> <y>] <x>]"
+    check pat.matches(v)
+    check pat.capture(v).toPreserves == c
+
+suite "meta":
+
+  test "pattern-of-pattern":
+    let
+      pat = grabRecord("foo".toSymbol, {666: drop()})
+      meta = pat.toPreserves.drop()
+    check $meta == "<group <rec group> {0: <group <rec rec> {0: <lit foo>}> 1: <group <dict> {666: <_>}>}>"
+
+  test "observe":
+    let
+      val = Observe(pattern: LaterThan ?: {0: drop 12.24}).toPreserves
+      pat = grab(val)
+    check pat.matches(val)
+    check pat.capture(val) == @[val]
+    let
+      meta = observePattern(!LaterThan, {@[0.toPreserves]: grabLit()})
+      res = parsePreserves "[12.24]"
+    check meta.matches(val)
+    check meta.capture(val).toPreserves == res
+
+  test "connect-transport":
+    let pat = parsePreserves"""
+        <group <rec connect-transport> {0: <group <rec unix> {0: <lit "/run/user/1000/dataspace">}> 2: <group <rec accepted> {0: <bind <_>>}>}>
+      """.preservesTo(Pattern).get
+    let val = parsePreserves"""
+        <connect-transport <unix "/run/user/1000/dataspace"> #:#f <accepted #:#f>>
+      """
+    check pat.matches(val)
+    check pat.capture(val).toPreserves == parsePreserves "[#:#f]"
--- a/tests/test_timers.nim
+++ b/tests/test_timers.nim
@ -2,16 +2,31 @@
 # SPDX-License-Identifier: Unlicense

 import std/times
-import syndicate, syndicate/actors/timers
+import syndicate, syndicate/drivers/timers, preserves

-proc now: float64 = getTime().toUnixFloat()
+var passCount = 0

-runActor("test_timers") do (ds: Cap; turn: var Turn):
-  onPublish(turn, ds, grab(LaterThan(seconds: now()+1.0))) do:
-    stderr.writeLine "slept one second once"
-    onPublish(turn, ds, grab(LaterThan(seconds: now()+1.0))) do:
-      stderr.writeLine "slept one second twice"
-      onPublish(turn, ds, grab(LaterThan(seconds: now()+1.0))) do:
-        stderr.writeLine "slept one second thrice"
-        quit()
-  spawnTimers(turn, ds)
+runActor("timer-test") do (turn: Turn):
+  let timers = newDataspace(turn)
+  spawnTimerDriver(turn, timers)
+
+  onPublish(turn, timers, ?LaterThan(seconds: 1356100000)):
+    echo "now in 13th bʼakʼtun"
+    inc passCount
+
+  after(turn, timers, initDuration(seconds = 3)) do (turn: Turn):
+    echo "third timer expired"
+    assert passCount == 3
+    inc passCount
+
+  after(turn, timers, initDuration(seconds = 1)) do (turn: Turn):
+    echo "first timer expired"
+    assert passCount == 1
+    inc passCount
+
+  after(turn, timers, initDuration(seconds = 2)) do (turn: Turn):
+    echo "second timer expired"
+    assert passCount == 2
+    inc passCount
+
+doAssert passCount == 4, $passCount
Author	SHA1	Message	Date
Emery Hemingway	3a4dc1f133	Change behavior of grabType Make grabType grab a single composite value that can be converted to the type being grabbed instead of just the fields of the type. The old behavior is available in grabTypeFlat and the alias `?:` still points there.	2024-05-07 15:44:53 +02:00
Emery Hemingway	4fb0285190	relays: fix runnaway closed connection loop	2024-05-04 00:31:00 +02:00
Emery Hemingway	81792ac4ce	Replace "var Turn" with "Turn"	2024-04-30 12:52:40 +02:00
Emery Hemingway	7e15b37f44	Implement base method of sync	2024-04-24 20:28:28 +02:00
Emery Hemingway	c99f0a60ab	Add runOnce proc This is useful for forcing progress when embedding Syndicate in contexts that don't expose turn semantics.	2024-04-24 16:11:17 +02:00
Emery Hemingway	5fc371d187	Require newer Preserves	2024-04-24 16:10:34 +02:00
Emery Hemingway	06898e4ec1	Update dataspace patterns protocol Skeletons do not check for the presence of ignored entries in pattern matches, this will cause bugs!	2024-04-22 10:54:44 +02:00
Emery Hemingway	2aaa588f6a	drivers/timers: map deadlines to facets	2024-04-19 17:36:07 +02:00
Emery Hemingway	e0b569e465	Update noise schema	2024-04-19 17:36:07 +02:00
Emery Hemingway	13d3995507	Update http driver to latest schema	2024-04-19 17:36:07 +02:00
Emery Hemingway	6487ef65d0	http_driver: add 504 binding timeouts	2024-04-08 20:44:23 +01:00
Emery Hemingway	6a4854110c	http_driver: don't send empty chunks	2024-04-08 20:37:17 +01:00
Emery Hemingway	464043c8bf	http_driver: set sequenceNumber	2024-04-08 17:01:35 +01:00
Emery Hemingway	15637620f0	http_driver: strip query ? from URL path	2024-04-08 16:59:32 +01:00
Emery Hemingway	c2dce8a274	Update README	2024-04-08 14:50:36 +01:00
Emery Hemingway	1a3fdf2a5a	Update Taps dependency	2024-04-08 14:43:37 +01:00
Emery Hemingway	c2e1e2e0fa	drivers/http_driver: new http server	2024-04-05 13:36:52 +01:00
Emery Hemingway	5f45f76452	Add solo5 tests	2024-04-03 11:01:17 +01:00
Emery Hemingway	403e54878c	Rename syndicate/actors to syndicate/drivers	2024-04-03 11:01:02 +01:00
Emery Hemingway	7c72ea5732	Solo5 support	2024-04-02 16:34:33 +01:00
Emery Hemingway	2aee79662e	Add terminate(Turn, Exception)	2024-04-02 14:50:09 +01:00
Emery Hemingway	8b79dce5ba	Invert spawnActors arguments	2024-04-02 14:50:09 +01:00
Emery Hemingway	6bcf039dc2	stopIfInertAfter: call action immediately	2024-04-02 14:50:09 +01:00
Emery Hemingway	217a6aacf3	relays: catch only IOError during resolution	2024-04-02 14:50:09 +01:00
Emery Hemingway	aea9a2e4e6	relays: send events from a single turn in a single packet	2024-04-02 14:50:09 +01:00
Emery Hemingway	78d7efc712	Fix tracing of turns from turns	2024-04-02 14:50:09 +01:00
Emery Hemingway	289754499c	Fix hashing of Actor and Facet	2024-04-02 14:50:09 +01:00
Emery Hemingway	4fe2173d81	Flush trace stream after every event	2024-04-02 14:50:09 +01:00
Emery Hemingway	87e730bc5b	Add stop(Facet)	2024-04-02 14:50:09 +01:00
Emery Hemingway	399fd4a30c	Replace spawnLink with linkActor	2024-04-02 14:50:09 +01:00
Emery Hemingway	bf8f7e9aaa	Move durings into new facets	2024-04-02 14:50:09 +01:00
Emery Hemingway	d654195fb8	Cleanup test_chat	2024-04-02 14:50:09 +01:00
Emery Hemingway	76acf2cb67	relays: resolve environment once	2024-04-02 14:50:09 +01:00
Emery Hemingway	50b00827ce	Adjust actor API	2024-04-02 14:50:09 +01:00
Emery Hemingway	81ce71d495	Put during clauses in new facets	2024-04-02 14:50:09 +01:00
Emery Hemingway	a3146f88a5	Fix runaway shutdown loop	2024-04-02 14:50:09 +01:00
Emery Hemingway	9ca073d433	Update Preserves dependency	2024-04-02 14:50:09 +01:00
Emery Hemingway	cd846d0d46	Add FacetGuard	2024-04-02 14:50:09 +01:00
Emery Hemingway	82f2e8ee98	actors: better facet stop tracing	2024-04-02 14:50:09 +01:00
Emery Hemingway	1592fac3b1	Build without tracing	2024-04-02 14:50:09 +01:00
Emery Hemingway	8ef95c0e1d	relays: create fresh dataspace at stdin relay	2024-04-02 14:50:09 +01:00
Emery Hemingway	a014362292	Attenuate and sync	2024-04-02 14:50:09 +01:00
Emery Hemingway	b8c1bec9cf	Queue effects to the local actor to the local turn	2024-04-02 14:50:09 +01:00
Emery Hemingway	cf395dbfa4	Revert to var Turn	2024-04-02 14:50:09 +01:00
Emery Hemingway	9d975bab56	Use global turn queue	2024-04-02 14:50:09 +01:00
Emery Hemingway	15d2e8bfb4	Replace actor and relay API	2024-03-04 18:20:59 +00:00
Emery Hemingway	eb5d4d9a57	Port relays to nim-sys	2024-03-04 18:20:29 +00:00
Emery Hemingway	01f26caf7b	New timers actor	2024-03-01 14:26:36 +00:00
Emery Hemingway	e31069e41a	API renaming	2024-03-01 14:10:20 +00:00
Emery Hemingway	fdf2994ec4	bags: export some table procs	2024-03-01 14:05:03 +00:00
Emery Hemingway	0cee6670c9	De-async actors	2024-03-01 14:04:47 +00:00
Emery Hemingway	1ce96560f4	Cleanup actors	2024-03-01 14:01:42 +00:00
Emery Hemingway	d365a1e6e5	Remove gcsafe declarations CPS doesn't give gcsafe assurances.	2024-03-01 14:00:31 +00:00
Emery Hemingway	3e5d910d1a	Depend on cps and nim-sys	2024-03-01 13:57:48 +00:00
Emery Hemingway	50a77995bc	Update lock.json	2024-02-09 15:41:25 +00:00
Emery Hemingway	3e324e2de4	Remove stale Spry script	2024-02-08 15:29:10 +00:00
Emery Hemingway	aadf7a3dc7	Update syndicate-protocols	2024-02-08 15:28:37 +00:00
Emery Hemingway	a2849b18c9	Preserves: floats merged into doubles	2024-02-08 15:28:37 +00:00
Emery Hemingway	f3d6e578cb	Single IEEE754 type	2024-02-08 15:28:37 +00:00
Emery Hemingway	39cb3790df	relays: generalize gatekeeper resolution	2024-02-08 15:28:37 +00:00
Emery Hemingway	46dca031fa	relays: split connecting and resolving	2024-02-08 15:28:37 +00:00
Emery Hemingway	79c621e979	patterns: support embedded literals	2024-02-08 15:28:37 +00:00
Emery Hemingway	a05cfa37eb	Make publish and spawn discardable	2024-02-08 15:28:37 +00:00
Emery Hemingway	d6a8b31812	patterns: do not match inner types at dropType	2024-02-08 15:28:36 +00:00
Emery Hemingway	a4ba81a481	Cleanup relays	2024-01-16 19:59:34 +02:00