xslt: accept text or paths, generate Preserves data

WiP! XSLT actor
2024-02-09 14:50:38 +00:00 · 2024-02-08 18:13:09 +00:00
45 changed files with 1103 additions and 1742 deletions
--- a/README.md
+++ b/README.md
@ -28,7 +28,6 @@ Example configuration:
    $cap <cache { dataspace: $nixspace lifetime: 3600.0 }> ]
 ]
 ```
 ### File System Usage
 Summarize the size of file-system directory. Equivalent to `du -s -b`.
@ -47,46 +46,6 @@ Query the size of a directory in bytes by observing `<file-system-usage "/SOME/P
 ]
 ```
 ### HTTP driver
 Experimental HTTP server that services requests using [some version](https://git.syndicate-lang.org/syndicate-lang/syndicate-protocols/src/commit/9864ce0ec86fb2f916c2aab318a1e6994ab8834c/schemas/http.prs) of the http Syndicate protocol schema.
 ```
 # Configuration example
 let ?not-found = dataspace
 $not-found ? <request _ ?res> [
  $res ! <status 503 "Service unavailable">
  $res ! <done "No binding here.">
 ]
 let ?greeting = dataspace
 $greeting ? <request _ ?res> [
  $res ! <status 200 "ok">
  $res ! <chunk "Hello world">
  $res ! <done "!">
 ]
 let ?http = dataspace
 $http [
  <http-bind #f 80 get [ ] $not-found>
  <http-bind #f 80 get [|...|] $not-found>
  <http-bind #f 80 get ["hello"] $greeting>
 ]
 ? <service-object <daemon http-driver> ?cap> [
  $cap <http-driver { dataspace: $http }>
 ]
 <daemon http-driver {
  argv: [ "/bin/syndesizer" ]
  clearEnv: #t
  protocol: application/syndicate
 }>
 <require-service <daemon http-driver>>
 ```
 ### JSON Socket Translator
 Communicate with sockets that send and receive lines of JSON using `<send …>` and `<recv …>` messages.
@ -116,7 +75,7 @@ let ?mpvSpace = dataspace
  ? <service-object <daemon syndesizer> ?cap> [
    $cap <json-socket-translator {
      dataspace: $mpvSpace
-      socket: <unix "/run/user/1000/mpv.sock">
+      socket: "/run/user/1000/mpv.sock"
    }>
  ]
 ]
@ -164,6 +123,38 @@ let ?ds = dataspace
 ]
 ```
 ### PostgreSQL
 Readonly access to PostgreSQL databases. Asserts rows as records in response to SQL query assertions. Dynamic updates are not implemented.
 Can be disabled by passing `--define:withPostgre=no` to the Nim compiler.
 ```
 # Configuration example
 <require-service <daemon syndesizer>>
 let ?sqlspace = dataspace
 ? <service-object <daemon syndesizer> ?cap> [
  $cap <postgre {
     dataspace: $sqlspace
     connection: [
       ["host" "example.com"]
       ["dbname" "foobar"]
       ["user" "hackme"]
     ]
   }>
 ]
 let ?tuplespace = dataspace
 $sqlspace <query "SELECT id, name FROM stuff" $tuplespace>
 $tuplespace ? [?id ?name] [
  $log ! <log "-" { row: <example-row $id $name> }>
 ]
 ```
 ### Pulse proxy
 A proxy actor that passes assertions and messages to a configured capability but only asserts observations on a a periodic pulse.
@ -208,16 +199,56 @@ let ?tuplespace = dataspace
 $sqlspace <query "SELECT id, name FROM stuff" $tuplespace>
-$tuplespace [
+$tuplespace ? [?id ?name] [
-  ? [?id ?name] [
+  $log ! <log "-" { row: <example-row $id $name> }>
    $log ! <log "-" { row: <example-row $id $name> }>
  ]
  ? <sqlite-error ?msg ?ctx> [
    $log ! <log "-" { msg: $msg ctx: $ctx }>
  ]
 ]
 ```
 ### Webooks
 Listens for webhook requests and sends request data to a dataspace as messages.
 Request data is formated according to the http schema [defined in syndicate-protocols](https://git.syndicate-lang.org/syndicate-lang/syndicate-protocols/src/branch/main/schemas/http.prs), with the exception that messages bodies may be **bytes**, **string**, or **any** for the `content-type`s of `application/octet-stream`, `text/*`, and `application/json` respectively.
 ```
 # Configuration example
 <require-service <daemon syndesizer>>
 ? <service-object <daemon syndesizer> ?cap> [
  $cap <webhooks {
    listen: <tcp "0.0.0.0" 1048>
    endpoints: {
      # http://0.0.0.0:1048/my-endpoint
      ["my-endpoint"]: $target-dataspace
      # http://0.0.0.0:1048/some/multi-element/path
      ["some", "multi-element", "path"]: $target-dataspace
    }
  }>
 ]
 ```
 ### Websockets
 connects to a websocket endpoint. During the lifetime of the connection a `<connected $URL>` assertion is made. Messages received from the server are sent to the dataspace wrapped in `<recv …>` records and messages observed as `<send …>` are sent to the server.
 ```
 # Configuration example
 <require-service <daemon syndesizer>>
 let ?websocketspace = dataspace
 ? <service-object <daemon syndesizer> ?cap> [
  $cap <websocket {
    dataspace: $websocketspace
    url: "ws://127.0.0.1:5225/"
  }>
 ]
 $websocketspace ? <connected $websocketUrl> [
  <bind <ref { oid: "websocket" key: #x"" }> $websocketspace #f>
 ]
 ```
 ### XML translator
 Translates between Preserves and XML according to the [Conventions for Common Data Types](https://preserves.dev/conventions.html).
@ -241,96 +272,6 @@ Examples:
 ---
 ## esc_printer_actor
 A basic [ESC/P](https://en.wikipedia.org/wiki/ESC/P) printer controller.
 Takes a path to a printer device file as a command line argument and publishes a `<printer @cap #:any @device-path string>` to its environment.
 The capability in this assertion is an entity that prints the strings it receives as messages.
 While the `<bold>` or `<italic>` is asserted to this entity the printer will go into the corresponding font mode (if the printer supports it).
 Sample Syndicate server script:
 ```
 <require-service <daemon printer>>
 ? <printer ?printer> [
  $log ?? <log "-" { line: ?line }> [
    $printer ! $text
    $printer ! "\r\n"
      # Print log messages.
  ]
 ]
 ? <service-object <daemon printer> ?cap> [
  $cap ? <printer ?printer ?device> [
    $config <printer $printer>
  ]
 ]
 <daemon printer {
  argv: [ "/bin/esc_printer_actor" "/dev/usb/lp0"]
  protocol: application/syndicate
 }>
 ```
 ## http_client
 The inverse of `http-driver`.
 ### Caveats
 - HTTPS is assumed unless the request is to port 80.
 - If the request or response sets `Content-Type` to `application/json` or `…/preserves`
  the body will be a parsed Preserves value.
 - No cache support.
 - Internal errors propagate using a `400 Internal client error` response.
 Sample Syndicate server script:
 ```
 # A top-level dataspace
 let ?ds = dataspace
 # A dataspace for handling the HTTP response.
 let ?response = dataspace
 $response [
  ?? <done { "code": "EUR" "exchange_middle": ?middle } > [
    $ds <exchange EUR RSD $middle>
  ]
 ]
 $ds [
  <request
      # Request Euro to Dinar exchange rate.
      <http-request 0 "kurs.resenje.org" 443
        get ["api" "v1" "currencies" "eur" "rates" "today"]
        {Content-Type: "application/json"} {} #f
      >
    $response
  >
  # Log all assertions.
  ? ?any [
    $log ! <log "-" { assertion: $any }>
  ]
 ]
 ? <service-object <daemon http-client> ?cap> [
  $cap <http-client {
    dataspace: $ds
  }>
 ]
 <require-service <daemon http-client>>
 ? <built http-client ?path ?sum> [
  <daemon http-client {
    argv: [ "/bin/http_client" ]
    clearEnv: #t
    protocol: application/syndicate
  }>
 ]
 ```
 ## mintsturdyref
 A utility for minting [Sturdyrefs](https://synit.org/book/operation/builtin/gatekeeper.html#sturdyrefs).
@ -380,38 +321,30 @@ Sample Syndicate server script:
 ## msg
-A utility that parses its command-line arguments as Preserves and send them as messages to `$SYNDICATE_ROUTE`.
+A utility that sends messages to `$SYNDICATE_ROUTE`.
 When called as `assert` (by a symlink or a rename) it will make assertions instead.
 ## PostgreSQL
-Readonly access to PostgreSQL databases. Asserts rows as records in response to SQL query assertions. Dynamic updates are not implemented.
+## net_mapper
-Can be disabled by passing `--define:withPostgre=no` to the Nim compiler.
+Publishes ICMP packet round-trip-times. See [net_mapper.prs](./net_mapper.prs) for a protocol description. [Source](./src/net_mapper.nim).
 Example script:
 ```
-# Configuration example
+? <machine-dataspace ?machine> [
-<require-service <daemon postgre_actor>>
+  $machine ? <rtt "10.0.33.136" ?min ?avg ?max> [
    $log ! <log "-" { ping: { min: $min avg: $avg max: $max } }>
  ]
-let ?sqlspace = dataspace
+  $config [
-
+    <require-service <daemon net_mapper>>
-? <service-object <daemon postgre_actor> ?cap> [
+    <daemon net_mapper {
-  $cap <postgre {
+      argv: ["/bin/net_mapper"]
-     dataspace: $sqlspace
+      protocol: application/syndicate
-     connection: [
+    }>
-       ["host" "example.com"]
+    ? <service-object <daemon net_mapper> ?cap> [
-       ["dbname" "foobar"]
+      $cap { dataspace: $machine }
-       ["user" "hackme"]
+    ]
-     ]
+  ]
   }>
 ]
 let ?tuplespace = dataspace
 $sqlspace <query "SELECT id, name FROM stuff" $tuplespace>
 $tuplespace ? [?id ?name] [
  $log ! <log "-" { row: <example-row $id $name> }>
 ]
 ```
@ -420,33 +353,6 @@ $tuplespace ? [?id ?name] [
 This utility serializes it's process environment to Preserves and prints it to stdout.
 It can be used to feed the environment variables of a nested child of the Syndicate server back to the server. For example, to retreive the environmental variables that a desktop manager passed on to its children.
 ## SQLite
 Readonly access to SQLite databases. Asserts rows as records in response to SQL query assertions. Dynamic updates are not implemented.
 Can be disabled by passing `--define:withSqlite=no` to the Nim compiler.
 ```
 # Configuration example
 <require-service <daemon sqlite_actor>>
 let ?sqlspace = dataspace
 ? <service-object <daemon sqlite_actor> ?cap> [
  $cap <sqlite {
    dataspace: $sqlspace
    database: "/var/db/example.db"
  }>
 ]
 let ?tuplespace = dataspace
 $sqlspace <query "SELECT id, name FROM stuff" $tuplespace>
 $tuplespace ? [?id ?name] [
  $log ! <log "-" { row: <example-row $id $name> }>
 ]
 ```
 ## syndump
@ -457,25 +363,3 @@ Example
 # Print patterns in use, filter down with AWK to only the published patterns.
 $ FS=':' syndump '<Observe ? _>' | awk -F : '/^+/ { print $2 }'
 ```
 ## XSLT processor
 Perform XML stylesheet transformations. For a given textual XSLT stylesheet and a textual XML document generate an abstract XML document in Preserves form. Inputs may be XML text or paths to XML files.
 ```
 # Configuration example
 let ?ds = dataspace
 $ds [
  ? <xslt-transform "/stylesheet.xls" "/doc.xml" ?output> [
    ? <xml-translation ?text $output> [
      $log ! <log "-" { xslt-output: $text }>
    ]
  ]
 ]
 <require-service <daemon xslt_actor>>
 ? <service-object <daemon xslt_actor> ?cap> $cap [
  <xml-translator { dataspace: $ds }>
  <xslt { dataspace: $ds }>
 ]
 ```
--- a/2
+++ b/2
@ -1,2 +1,2 @@
 include_rules
-: sbom.json |> !sbom-to-nix |> | ./<lock>
+: lock.json |> !nim_cfg |> | ./<lock>
--- a/base64.prs
+++ b/base64.prs
@ -1,4 +0,0 @@
 version 1.
 Base64Text = <base64 @txt string @bin bytes> .
 Base64File = <base64-file @txt string @path string @size int> .
--- a/config.prs
+++ b/config.prs
@ -1,10 +1,6 @@
 version 1 .
 embeddedType EntityRef.Cap .
 Base64DecoderArguments = <base64-decoder {
  dataspace: #:any
 }>.
 CacheArguments = <cache {
  dataspace: #:any
  lifetime: float
@ -19,24 +15,11 @@ JsonTranslatorArguments = <json-stdio-translator {
  dataspace: #:any
 }>.
-JsonTranslatorConnected = <connected @address SocketAddress>.
+JsonTranslatorConnected = <connected @path string>.
 TcpAddress = <tcp @host string @port int>.
 UnixAddress = <unix @path string>.
 SocketAddress = TcpAddress / UnixAddress .
 HttpClientArguments = <http-client {
  dataspace: #:any
 }>.
 HttpDriverArguments = <http-driver {
  dataspace: #:any
 }>.
 JsonSocketTranslatorArguments = <json-socket-translator {
  dataspace: #:any
-  socket: SocketAddress
+  socket: string
 }>.
 PostgreArguments = <postgre {
--- a/default.nix
+++ b/default.nix
@ -1,19 +0,0 @@
 {
  pkgs ? import <nixpkgs> { },
 }:
 with pkgs;
 let
  buildNimSbom = pkgs.callPackage (import <build-nim-sbom.nix>) { };
 in
 buildNimSbom ./sbom.json (
  final: prev: {
    src = if lib.inNixShell then null else lib.cleanSource ./.;
    buildInputs = [
      postgresql.out
      sqlite
      libxml2
      libxslt
      openssl
    ];
  }
 )
--- a/lock.json
+++ b/lock.json
@ -1,28 +1,12 @@
 {
  "depends": [
    {
      "date": "2024-05-23T17:44:14+03:00",
      "deepClone": false,
      "fetchLFS": false,
      "fetchSubmodules": true,
      "hash": "sha256-qTRhHsOPNov1BQcm3P7NEkEPW6uh80XFfQRBdMp4o0Q=",
      "leaveDotGit": false,
      "method": "git",
      "packages": [
        "syndicate"
      ],
      "path": "/nix/store/1lcxrap5n80hy1z4bcmsmdx83n4b9wjf-syndicate-nim",
      "rev": "7ab4611824b676157523f2618e7893d5ac99e4f2",
      "sha256": "0i53g3578h84gp2lbwx1mddhyh8jrpzdq9h70psqndlgqcg62d59",
      "srcDir": "src",
      "url": "https://git.syndicate-lang.org/ehmry/syndicate-nim.git"
    },
    {
      "method": "fetchzip",
      "packages": [
        "bigints"
      ],
      "path": "/nix/store/jvrm392g8adfsgf36prgwkbyd7vh5jsw-source",
      "ref": "20231006",
      "rev": "86ea14d31eea9275e1408ca34e6bfe9c99989a96",
      "sha256": "15pcpmnk1bnw3k8769rjzcpg00nahyrypwbxs88jnwr4aczp99j4",
      "srcDir": "src",
@ -31,107 +15,85 @@
    {
      "method": "fetchzip",
      "packages": [
-        "cps"
+        "hashlib"
      ],
-      "path": "/nix/store/8gbhwni0akqskdb3qhn5nfgv6gkdz0vz-source",
+      "path": "/nix/store/fav82xdbicvlk34nmcbl89zx99lr3mbs-source",
-      "rev": "c90530ac57f98a842b7be969115c6ef08bdcc564",
+      "rev": "f9455d4be988e14e3dc7933eb7cc7d7c4820b7ac",
-      "sha256": "0h8ghs2fqg68j3jdcg7grnxssmllmgg99kym2w0a3vlwca1zvr62",
+      "sha256": "1sx6j952lj98629qfgr7ds5aipyw9d6lldcnnqs205wpj4pkcjb3",
      "srcDir": "",
-      "url": "https://github.com/ehmry/cps/archive/c90530ac57f98a842b7be969115c6ef08bdcc564.tar.gz"
+      "url": "https://github.com/ehmry/hashlib/archive/f9455d4be988e14e3dc7933eb7cc7d7c4820b7ac.tar.gz"
    },
    {
      "method": "fetchzip",
      "packages": [
-        "getdns"
+        "illwill"
      ],
-      "path": "/nix/store/x9xmn7w4k6jg8nv5bnx148ibhnsfh362-source",
+      "path": "/nix/store/3lmm3z36qn4gz7bfa209zv0pqrpm3di9-source",
-      "rev": "c73cbe288d9f9480586b8fa87f6d794ffb6a6ce6",
+      "ref": "v0.3.2",
-      "sha256": "1sbgx2x51szr22i72n7c8jglnfmr8m7y7ga0v85d58fwadiv7g6b",
+      "rev": "1d12cb36ab7b76c31d2d25fa421013ecb382e625",
-      "srcDir": "src",
+      "sha256": "0f9yncl5gbdja18mrqf5ixrdgrh95k0khda923dm1jd1x1b7ar8z",
-      "url": "https://git.sr.ht/~ehmry/getdns-nim/archive/c73cbe288d9f9480586b8fa87f6d794ffb6a6ce6.tar.gz"
+      "srcDir": "",
      "url": "https://github.com/johnnovak/illwill/archive/1d12cb36ab7b76c31d2d25fa421013ecb382e625.tar.gz"
    },
    {
      "method": "fetchzip",
      "packages": [
        "nimcrypto"
      ],
-      "path": "/nix/store/fkrcpp8lzj2yi21na79xm63xk0ggnqsp-source",
+      "path": "/nix/store/zyr8zwh7vaiycn1s4r8cxwc71f2k5l0h-source",
-      "rev": "485f7b3cfa83c1beecc0e31be0e964d697aa74d7",
+      "ref": "traditional-api",
-      "sha256": "1h3dzdbc9kacwpi10mj73yjglvn7kbizj1x8qc9099ax091cj5xn",
+      "rev": "602c5d20c69c76137201b5d41f788f72afb95aa8",
      "sha256": "1dmdmgb6b9m5f8dyxk781nnd61dsk3hdxqks7idk9ncnpj9fng65",
      "srcDir": "",
-      "url": "https://github.com/cheatfate/nimcrypto/archive/485f7b3cfa83c1beecc0e31be0e964d697aa74d7.tar.gz"
+      "url": "https://github.com/cheatfate/nimcrypto/archive/602c5d20c69c76137201b5d41f788f72afb95aa8.tar.gz"
    },
    {
      "method": "fetchzip",
      "packages": [
        "npeg"
      ],
-      "path": "/nix/store/xpn694ibgipj8xak3j4bky6b3k0vp7hh-source",
+      "path": "/nix/store/ffkxmjmigfs7zhhiiqm0iw2c34smyciy-source",
-      "rev": "ec0cc6e64ea4c62d2aa382b176a4838474238f8d",
+      "ref": "1.2.1",
-      "sha256": "1fi9ls3xl20bmv1ikillxywl96i9al6zmmxrbffx448gbrxs86kg",
+      "rev": "26d62fdc40feb84c6533956dc11d5ee9ea9b6c09",
      "sha256": "0xpzifjkfp49w76qmaylan8q181bs45anmp46l4bwr3lkrr7bpwh",
      "srcDir": "src",
-      "url": "https://github.com/zevv/npeg/archive/ec0cc6e64ea4c62d2aa382b176a4838474238f8d.tar.gz"
+      "url": "https://github.com/zevv/npeg/archive/26d62fdc40feb84c6533956dc11d5ee9ea9b6c09.tar.gz"
    },
    {
      "method": "fetchzip",
      "packages": [
        "preserves"
      ],
-      "path": "/nix/store/9zl4s2did00725n8ygbp37agvkskdhcx-source",
+      "path": "/nix/store/fpkhfxnfbdcri6k7mac21r3byg738bs4-source",
-      "rev": "1fee87590940761e288cf9ab3c7270832403b719",
+      "ref": "20240108",
-      "sha256": "1ny42rwr3yx52zwvkdg4lh54nxaxrmxdj9dlw3qarvvp2grfq4j2",
+      "rev": "a01ba8c96d65f670862ba074bf82b50cbda6ed99",
      "sha256": "0n8pghy2qfywx0psr54yzjvhdhi5av204150jyyzfxhigczd8sr4",
      "srcDir": "src",
-      "url": "https://git.syndicate-lang.org/ehmry/preserves-nim/archive/1fee87590940761e288cf9ab3c7270832403b719.tar.gz"
+      "url": "https://git.syndicate-lang.org/ehmry/preserves-nim/archive/a01ba8c96d65f670862ba074bf82b50cbda6ed99.tar.gz"
    },
    {
      "method": "fetchzip",
      "packages": [
-        "stew"
+        "syndicate"
      ],
-      "path": "/nix/store/mqg8qzsbcc8xqabq2yzvlhvcyqypk72c-source",
+      "path": "/nix/store/43gx5b3y9s9c8cfa1nmhz5dz5z3jsw0a-source",
-      "rev": "3c91b8694e15137a81ec7db37c6c58194ec94a6a",
+      "ref": "20240114",
-      "sha256": "17lfhfxp5nxvld78xa83p258y80ks5jb4n53152cdr57xk86y07w",
+      "rev": "75d1e33bff21f1da511ca0ea7def4bb492fd96fd",
-      "srcDir": "",
+      "sha256": "0b51bj3xpw2jbpxh0ry3d7iqbw6ks2wfnc3jpra6rj3ss4hj749n",
-      "url": "https://github.com/status-im/nim-stew/archive/3c91b8694e15137a81ec7db37c6c58194ec94a6a.tar.gz"
+      "srcDir": "src",
      "url": "https://git.syndicate-lang.org/ehmry/syndicate-nim/archive/75d1e33bff21f1da511ca0ea7def4bb492fd96fd.tar.gz"
    },
    {
      "method": "fetchzip",
      "packages": [
-        "sys"
+        "ws"
      ],
-      "path": "/nix/store/syhxsjlsdqfap0hk4qp3s6kayk8cqknd-source",
+      "path": "/nix/store/zd51j4dphs6h1hyhdbzdv840c8813ai8-source",
-      "rev": "4ef3b624db86e331ba334e705c1aa235d55b05e1",
+      "ref": "0.5.0",
-      "sha256": "1q4qgw4an4mmmcbx48l6xk1jig1vc8p9cq9dbx39kpnb0890j32q",
+      "rev": "9536bf99ddf5948db221ccb7bb3663aa238a8e21",
      "sha256": "0j8z9jlvzb1h60v7rryvh2wx6vg99lra6i62whf3fknc53l641fz",
      "srcDir": "src",
-      "url": "https://github.com/ehmry/nim-sys/archive/4ef3b624db86e331ba334e705c1aa235d55b05e1.tar.gz"
+      "url": "https://github.com/treeform/ws/archive/9536bf99ddf5948db221ccb7bb3663aa238a8e21.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-05-22T06:09:38+02:00",
      "deepClone": false,
      "fetchLFS": false,
      "fetchSubmodules": true,
      "hash": "sha256-B3fMwgBpO2Ty8143k9V1cnHXa5K8i1+zN+eF/rBLMe0=",
      "leaveDotGit": false,
      "method": "git",
      "packages": [
        "solo5_dispatcher"
      ],
      "path": "/nix/store/xqj48v4rqlffl1l94hi02szazj5gla8g-solo5_dispatcher",
      "rev": "cc64ef99416b22b12e4a076d33de9e25a163e57d",
      "sha256": "1v9i9fqgx1g76yrmz2xwj9mxfwbjfpar6dsyygr68fv9031cqxq7",
      "srcDir": "pkg",
      "url": "https://git.sr.ht/~ehmry/solo5_dispatcher"
    }
  ]
 }
--- a/sbom.json
+++ b/sbom.json
@ -1,641 +0,0 @@
 {
  "bomFormat": "CycloneDX",
  "specVersion": "1.6",
  "metadata": {
    "component": {
      "type": "application",
      "bom-ref": "pkg:nim/syndicate_utils",
      "name": "syndicate_utils",
      "description": "Utilites for Syndicated Actors and Synit",
      "version": "20240530",
      "authors": [
        {
          "name": "Emery Hemingway"
        }
      ],
      "licenses": [
        {
          "license": {
            "id": "Unlicense"
          }
        }
      ],
      "properties": [
        {
          "name": "nim:skipExt",
          "value": "nim"
        },
        {
          "name": "nim:bin:postgre-actor",
          "value": "postgre_actor"
        },
        {
          "name": "nim:bin:xslt-actor",
          "value": "xslt_actor"
        },
        {
          "name": "nim:bin:preserve-process-environment",
          "value": "preserve_process_environment"
        },
        {
          "name": "nim:bin:mintsturdyref",
          "value": "mintsturdyref"
        },
        {
          "name": "nim:bin:esc-printer-actor",
          "value": "esc_printer_actor"
        },
        {
          "name": "nim:bin:msg",
          "value": "msg"
        },
        {
          "name": "nim:bin:rofi-script-actor",
          "value": "rofi_script_actor"
        },
        {
          "name": "nim:bin:syndesizer",
          "value": "syndesizer"
        },
        {
          "name": "nim:bin:http-client",
          "value": "http_client"
        },
        {
          "name": "nim:bin:mount-actor",
          "value": "mount_actor"
        },
        {
          "name": "nim:bin:syndump",
          "value": "syndump"
        },
        {
          "name": "nim:srcDir",
          "value": "src"
        },
        {
          "name": "nim:backend",
          "value": "c"
        }
      ]
    }
  },
  "components": [
    {
      "type": "library",
      "bom-ref": "pkg:nim/syndicate",
      "name": "syndicate",
      "version": "20240522",
      "externalReferences": [
        {
          "url": "https://git.syndicate-lang.org/ehmry/syndicate-nim/archive/3a4dc1f13392830b587138199643d30fdbec8541.tar.gz",
          "type": "source-distribution"
        },
        {
          "url": "https://git.syndicate-lang.org/ehmry/syndicate-nim.git",
          "type": "vcs"
        }
      ],
      "properties": [
        {
          "name": "nix:fod:method",
          "value": "fetchzip"
        },
        {
          "name": "nix:fod:path",
          "value": "/nix/store/aixbd9di4671hm3bg92xsxwhqp4mbs1g-source"
        },
        {
          "name": "nix:fod:rev",
          "value": "7ab4611824b676157523f2618e7893d5ac99e4f2"
        },
        {
          "name": "nix:fod:sha256",
          "value": "0i53g3578h84gp2lbwx1mddhyh8jrpzdq9h70psqndlgqcg62d59"
        },
        {
          "name": "nix:fod:url",
          "value": "https://git.syndicate-lang.org/ehmry/syndicate-nim/archive/7ab4611824b676157523f2618e7893d5ac99e4f2.tar.gz"
        },
        {
          "name": "nix:fod:ref",
          "value": "20240522"
        },
        {
          "name": "nix:fod:srcDir",
          "value": "src"
        }
      ]
    },
    {
      "type": "library",
      "bom-ref": "pkg:nim/preserves",
      "name": "preserves",
      "version": "20240523",
      "externalReferences": [
        {
          "url": "https://git.syndicate-lang.org/ehmry/preserves-nim/archive/1fee87590940761e288cf9ab3c7270832403b719.tar.gz",
          "type": "source-distribution"
        },
        {
          "url": "https://git.syndicate-lang.org/ehmry/preserves-nim.git",
          "type": "vcs"
        }
      ],
      "properties": [
        {
          "name": "nix:fod:method",
          "value": "fetchzip"
        },
        {
          "name": "nix:fod:path",
          "value": "/nix/store/mcwpm48hwm9fwdc0v84cjj773gjzjc0a-source"
        },
        {
          "name": "nix:fod:rev",
          "value": "ed065fcc2da71c20a0d5f9972cef2b3261c04727"
        },
        {
          "name": "nix:fod:sha256",
          "value": "1jg67izq09mny3n4gpvr9b0b9sbc1gnr9nxj7l43i36sscnnzxr6"
        },
        {
          "name": "nix:fod:url",
          "value": "https://git.syndicate-lang.org/ehmry/preserves-nim/archive/ed065fcc2da71c20a0d5f9972cef2b3261c04727.tar.gz"
        },
        {
          "name": "nix:fod:ref",
          "value": "20240523"
        },
        {
          "name": "nix:fod:srcDir",
          "value": "src"
        }
      ]
    },
    {
      "type": "library",
      "bom-ref": "pkg:nim/sys",
      "name": "sys",
      "version": "4ef3b624db86e331ba334e705c1aa235d55b05e1",
      "externalReferences": [
        {
          "url": "https://github.com/ehmry/nim-sys/archive/4ef3b624db86e331ba334e705c1aa235d55b05e1.tar.gz",
          "type": "source-distribution"
        },
        {
          "url": "https://github.com/ehmry/nim-sys.git",
          "type": "vcs"
        }
      ],
      "properties": [
        {
          "name": "nix:fod:method",
          "value": "fetchzip"
        },
        {
          "name": "nix:fod:path",
          "value": "/nix/store/syhxsjlsdqfap0hk4qp3s6kayk8cqknd-source"
        },
        {
          "name": "nix:fod:rev",
          "value": "4ef3b624db86e331ba334e705c1aa235d55b05e1"
        },
        {
          "name": "nix:fod:sha256",
          "value": "1q4qgw4an4mmmcbx48l6xk1jig1vc8p9cq9dbx39kpnb0890j32q"
        },
        {
          "name": "nix:fod:url",
          "value": "https://github.com/ehmry/nim-sys/archive/4ef3b624db86e331ba334e705c1aa235d55b05e1.tar.gz"
        },
        {
          "name": "nix:fod:srcDir",
          "value": "src"
        }
      ]
    },
    {
      "type": "library",
      "bom-ref": "pkg:nim/taps",
      "name": "taps",
      "version": "20240405",
      "externalReferences": [
        {
          "url": "https://git.sr.ht/~ehmry/nim_taps/archive/8c8572cd971d1283e6621006b310993c632da247.tar.gz",
          "type": "source-distribution"
        },
        {
          "url": "https://git.sr.ht/~ehmry/nim_taps",
          "type": "vcs"
        }
      ],
      "properties": [
        {
          "name": "nix:fod:method",
          "value": "fetchzip"
        },
        {
          "name": "nix:fod:path",
          "value": "/nix/store/6y14ia52kr7jyaa0izx37mlablmq9s65-source"
        },
        {
          "name": "nix:fod:rev",
          "value": "8c8572cd971d1283e6621006b310993c632da247"
        },
        {
          "name": "nix:fod:sha256",
          "value": "1dp166bv9x773jmfqppg5i3v3rilgff013vb11yzwcid9l7s3iy8"
        },
        {
          "name": "nix:fod:url",
          "value": "https://git.sr.ht/~ehmry/nim_taps/archive/8c8572cd971d1283e6621006b310993c632da247.tar.gz"
        },
        {
          "name": "nix:fod:ref",
          "value": "20240405"
        },
        {
          "name": "nix:fod:srcDir",
          "value": "src"
        }
      ]
    },
    {
      "type": "library",
      "bom-ref": "pkg:nim/nimcrypto",
      "name": "nimcrypto",
      "version": "traditional-api",
      "externalReferences": [
        {
          "url": "https://github.com/cheatfate/nimcrypto/archive/602c5d20c69c76137201b5d41f788f72afb95aa8.tar.gz",
          "type": "source-distribution"
        },
        {
          "url": "https://github.com/cheatfate/nimcrypto",
          "type": "vcs"
        }
      ],
      "properties": [
        {
          "name": "nix:fod:method",
          "value": "fetchzip"
        },
        {
          "name": "nix:fod:path",
          "value": "/nix/store/zyr8zwh7vaiycn1s4r8cxwc71f2k5l0h-source"
        },
        {
          "name": "nix:fod:rev",
          "value": "602c5d20c69c76137201b5d41f788f72afb95aa8"
        },
        {
          "name": "nix:fod:sha256",
          "value": "1dmdmgb6b9m5f8dyxk781nnd61dsk3hdxqks7idk9ncnpj9fng65"
        },
        {
          "name": "nix:fod:url",
          "value": "https://github.com/cheatfate/nimcrypto/archive/602c5d20c69c76137201b5d41f788f72afb95aa8.tar.gz"
        },
        {
          "name": "nix:fod:ref",
          "value": "traditional-api"
        }
      ]
    },
    {
      "type": "library",
      "bom-ref": "pkg:nim/npeg",
      "name": "npeg",
      "version": "1.2.2",
      "externalReferences": [
        {
          "url": "https://github.com/zevv/npeg/archive/ec0cc6e64ea4c62d2aa382b176a4838474238f8d.tar.gz",
          "type": "source-distribution"
        },
        {
          "url": "https://github.com/zevv/npeg.git",
          "type": "vcs"
        }
      ],
      "properties": [
        {
          "name": "nix:fod:method",
          "value": "fetchzip"
        },
        {
          "name": "nix:fod:path",
          "value": "/nix/store/xpn694ibgipj8xak3j4bky6b3k0vp7hh-source"
        },
        {
          "name": "nix:fod:rev",
          "value": "ec0cc6e64ea4c62d2aa382b176a4838474238f8d"
        },
        {
          "name": "nix:fod:sha256",
          "value": "1fi9ls3xl20bmv1ikillxywl96i9al6zmmxrbffx448gbrxs86kg"
        },
        {
          "name": "nix:fod:url",
          "value": "https://github.com/zevv/npeg/archive/ec0cc6e64ea4c62d2aa382b176a4838474238f8d.tar.gz"
        },
        {
          "name": "nix:fod:ref",
          "value": "1.2.2"
        },
        {
          "name": "nix:fod:srcDir",
          "value": "src"
        }
      ]
    },
    {
      "type": "library",
      "bom-ref": "pkg:nim/bigints",
      "name": "bigints",
      "version": "20231006",
      "externalReferences": [
        {
          "url": "https://github.com/ehmry/nim-bigints/archive/86ea14d31eea9275e1408ca34e6bfe9c99989a96.tar.gz",
          "type": "source-distribution"
        },
        {
          "url": "https://github.com/ehmry/nim-bigints.git",
          "type": "vcs"
        }
      ],
      "properties": [
        {
          "name": "nix:fod:method",
          "value": "fetchzip"
        },
        {
          "name": "nix:fod:path",
          "value": "/nix/store/jvrm392g8adfsgf36prgwkbyd7vh5jsw-source"
        },
        {
          "name": "nix:fod:rev",
          "value": "86ea14d31eea9275e1408ca34e6bfe9c99989a96"
        },
        {
          "name": "nix:fod:sha256",
          "value": "15pcpmnk1bnw3k8769rjzcpg00nahyrypwbxs88jnwr4aczp99j4"
        },
        {
          "name": "nix:fod:url",
          "value": "https://github.com/ehmry/nim-bigints/archive/86ea14d31eea9275e1408ca34e6bfe9c99989a96.tar.gz"
        },
        {
          "name": "nix:fod:ref",
          "value": "20231006"
        },
        {
          "name": "nix:fod:srcDir",
          "value": "src"
        }
      ]
    },
    {
      "type": "library",
      "bom-ref": "pkg:nim/cps",
      "name": "cps",
      "version": "0.10.4",
      "externalReferences": [
        {
          "url": "https://github.com/nim-works/cps/archive/2a4d771a715ba45cfba3a82fa625ae7ad6591c8b.tar.gz",
          "type": "source-distribution"
        },
        {
          "url": "https://github.com/nim-works/cps",
          "type": "vcs"
        }
      ],
      "properties": [
        {
          "name": "nix:fod:method",
          "value": "fetchzip"
        },
        {
          "name": "nix:fod:path",
          "value": "/nix/store/m9vpcf3dq6z2h1xpi1vlw0ycxp91s5p7-source"
        },
        {
          "name": "nix:fod:rev",
          "value": "2a4d771a715ba45cfba3a82fa625ae7ad6591c8b"
        },
        {
          "name": "nix:fod:sha256",
          "value": "0c62k5wpq9z9mn8cd4rm8jjc4z0xmnak4piyj5dsfbyj6sbdw2bf"
        },
        {
          "name": "nix:fod:url",
          "value": "https://github.com/nim-works/cps/archive/2a4d771a715ba45cfba3a82fa625ae7ad6591c8b.tar.gz"
        },
        {
          "name": "nix:fod:ref",
          "value": "0.10.4"
        }
      ]
    },
    {
      "type": "library",
      "bom-ref": "pkg:nim/stew",
      "name": "stew",
      "version": "3c91b8694e15137a81ec7db37c6c58194ec94a6a",
      "externalReferences": [
        {
          "url": "https://github.com/status-im/nim-stew/archive/3c91b8694e15137a81ec7db37c6c58194ec94a6a.tar.gz",
          "type": "source-distribution"
        },
        {
          "url": "https://github.com/status-im/nim-stew",
          "type": "vcs"
        }
      ],
      "properties": [
        {
          "name": "nix:fod:method",
          "value": "fetchzip"
        },
        {
          "name": "nix:fod:path",
          "value": "/nix/store/mqg8qzsbcc8xqabq2yzvlhvcyqypk72c-source"
        },
        {
          "name": "nix:fod:rev",
          "value": "3c91b8694e15137a81ec7db37c6c58194ec94a6a"
        },
        {
          "name": "nix:fod:sha256",
          "value": "17lfhfxp5nxvld78xa83p258y80ks5jb4n53152cdr57xk86y07w"
        },
        {
          "name": "nix:fod:url",
          "value": "https://github.com/status-im/nim-stew/archive/3c91b8694e15137a81ec7db37c6c58194ec94a6a.tar.gz"
        }
      ]
    },
    {
      "type": "library",
      "bom-ref": "pkg:nim/getdns",
      "name": "getdns",
      "version": "20230806",
      "externalReferences": [
        {
          "url": "https://git.sr.ht/~ehmry/getdns-nim/archive/e4ae0992ed7c5540e6d498f3074d06c8f454a0b6.tar.gz",
          "type": "source-distribution"
        },
        {
          "url": "https://git.sr.ht/~ehmry/getdns-nim",
          "type": "vcs"
        }
      ],
      "properties": [
        {
          "name": "nix:fod:method",
          "value": "fetchzip"
        },
        {
          "name": "nix:fod:path",
          "value": "/nix/store/j8i20k9aarzppg4p234449140nnnaycq-source"
        },
        {
          "name": "nix:fod:rev",
          "value": "e4ae0992ed7c5540e6d498f3074d06c8f454a0b6"
        },
        {
          "name": "nix:fod:sha256",
          "value": "1dp53gndr6d9s9601dd5ipkiq94j53hlx46mxv8gpr8nd98bqysg"
        },
        {
          "name": "nix:fod:url",
          "value": "https://git.sr.ht/~ehmry/getdns-nim/archive/e4ae0992ed7c5540e6d498f3074d06c8f454a0b6.tar.gz"
        },
        {
          "name": "nix:fod:ref",
          "value": "20230806"
        },
        {
          "name": "nix:fod:srcDir",
          "value": "src"
        }
      ]
    },
    {
      "type": "library",
      "bom-ref": "pkg:nim/solo5_dispatcher",
      "name": "solo5_dispatcher",
      "version": "20240522",
      "externalReferences": [
        {
          "url": "https://git.sr.ht/~ehmry/solo5_dispatcher/archive/cc64ef99416b22b12e4a076d33de9e25a163e57d.tar.gz",
          "type": "source-distribution"
        },
        {
          "url": "https://git.sr.ht/~ehmry/solo5_dispatcher",
          "type": "vcs"
        }
      ],
      "properties": [
        {
          "name": "nix:fod:method",
          "value": "fetchzip"
        },
        {
          "name": "nix:fod:path",
          "value": "/nix/store/4jj467pg4hs6warhksb8nsxn9ykz8c7c-source"
        },
        {
          "name": "nix:fod:rev",
          "value": "cc64ef99416b22b12e4a076d33de9e25a163e57d"
        },
        {
          "name": "nix:fod:sha256",
          "value": "1v9i9fqgx1g76yrmz2xwj9mxfwbjfpar6dsyygr68fv9031cqxq7"
        },
        {
          "name": "nix:fod:url",
          "value": "https://git.sr.ht/~ehmry/solo5_dispatcher/archive/cc64ef99416b22b12e4a076d33de9e25a163e57d.tar.gz"
        },
        {
          "name": "nix:fod:ref",
          "value": "20240522"
        },
        {
          "name": "nix:fod:srcDir",
          "value": "pkg"
        }
      ]
    }
  ],
  "dependencies": [
    {
      "ref": "pkg:nim/syndicate_utils",
      "dependsOn": [
        "pkg:nim/syndicate"
      ]
    },
    {
      "ref": "pkg:nim/syndicate",
      "dependsOn": [
        "pkg:nim/nimcrypto",
        "pkg:nim/preserves",
        "pkg:nim/sys",
        "pkg:nim/taps"
      ]
    },
    {
      "ref": "pkg:nim/preserves",
      "dependsOn": [
        "pkg:nim/npeg",
        "pkg:nim/bigints"
      ]
    },
    {
      "ref": "pkg:nim/sys",
      "dependsOn": [
        "pkg:nim/cps",
        "pkg:nim/stew"
      ]
    },
    {
      "ref": "pkg:nim/taps",
      "dependsOn": [
        "pkg:nim/getdns",
        "pkg:nim/sys",
        "pkg:nim/cps",
        "pkg:nim/solo5_dispatcher"
      ]
    },
    {
      "ref": "pkg:nim/nimcrypto",
      "dependsOn": []
    },
    {
      "ref": "pkg:nim/npeg",
      "dependsOn": []
    },
    {
      "ref": "pkg:nim/bigints",
      "dependsOn": []
    },
    {
      "ref": "pkg:nim/cps",
      "dependsOn": []
    },
    {
      "ref": "pkg:nim/stew",
      "dependsOn": []
    },
    {
      "ref": "pkg:nim/getdns",
      "dependsOn": []
    },
    {
      "ref": "pkg:nim/solo5_dispatcher",
      "dependsOn": [
        "pkg:nim/cps"
      ]
    }
  ]
 }
--- a/shell.nix
+++ b/shell.nix
@ -0,0 +1,8 @@
 { pkgs ? import <nixpkgs> { } }:
 pkgs.buildNimPackage {
  name = "syndicate_utils";
  propagatedNativeBuildInputs = [ pkgs.pkg-config ];
  propagatedBuildInputs = [ pkgs.postgresql pkgs.sqlite pkgs.libxml2 pkgs.libxslt ];
  lockFile = ./lock.json;
 }
--- a/sql.prs
+++ b/sql.prs
@ -2,7 +2,4 @@ version 1 .
 # When asserted the actor reponds to @target rows as records
 # of the given label and row columns as record fields.
-Query = <query @statement [any ...] @target #:any> .
+Query = <query @statement string @target #:any> .
 # When a query fails this is asserted instead.
 SqlError = <sql-error @msg string @context string>.
--- a/src/Tupfile
+++ b/src/Tupfile
@ -1,5 +1,4 @@
 include_rules
-: foreach *.nim | $(SYNDICATE_PROTOCOL) ./<schema> |> !nim_bin |> {bin}
+: foreach *.nim | $(SYNDICATE_PROTOCOL) ./<schema> ./syndesizer/<checks> |> !nim_bin |> {bin}
 : foreach {bin} |> !assert_built |>
-: $(BIN_DIR)/msg |> !symlink |> $(BIN_DIR)/beep
+: $(BIN_DIR)/msg |> cp %f %o |> $(BIN_DIR)/beep
 : $(BIN_DIR)/msg |> !symlink |> $(BIN_DIR)/assert
--- a/src/esc_printer_actor.nim
+++ b/src/esc_printer_actor.nim
@ -1,84 +0,0 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
 ## ESC/P printer control actor.
 import
  std/[cmdline, oserrors, posix, sets],
  preserves, preserves/sugar,
  syndicate, syndicate/relays,
  ./private/esc_p
 proc echo(args: varargs[string, `$`]) {.used.} =
  stderr.writeLine(args)
 type
  HandleSet = HashSet[Handle]
  Printer = ref object of Entity
    device: cint
    boldHandles, italicHandles, superscriptHandles, subscriptHandles: HandleSet
 proc write(printer: Printer; s: string) {.inline.} =
  if posix.write(printer.device, s[0].addr, s.len) < 0:
    osLastError().osErrorMsg().quit()
 proc writeLine(printer: Printer; s: string) {.inline.} =
  printer.write(s)
  printer.write("\r\n")
 method message(printer: Printer; t: Turn; a: AssertionRef) =
  if a.value.isString:
    printer.write(a.value.string)
      # TODO: unicode?
      # TODO: line breaks?
 proc assert(printer: Printer; handles: var HandleSet; ctrl: string; h: Handle) =
  if handles.len == 0: printer.write(ctrl)
  handles.incl h
 proc retract(printer: Printer; handles: var HandleSet; ctrl: string; h: Handle) =
  handles.excl h
  if handles.len == 0: printer.write(ctrl)
 method publish(printer: Printer; t: Turn; a: AssertionRef; h: Handle) =
  if a.value.isRecord("bold"):
    printer.assert(printer.boldHandles, SelectBoldFont, h)
  elif a.value.isRecord("italic"):
    printer.assert(printer.italicHandles, SelectItalicFont, h)
  elif a.value.isRecord("superscript"):
    printer.assert(printer.superscriptHandles, SelectSuperScript, h)
  elif a.value.isRecord("subscript"):
    printer.assert(printer.subscriptHandles, SelectSubScript, h)
 method retract(printer: Printer; t: Turn; h: Handle) =
  if printer.boldHandles.contains h:
    printer.retract(printer.boldHandles, CancelBoldFont, h)
  elif printer.italicHandles.contains h:
    printer.retract(printer.italicHandles, CanceItalicFont, h)
  elif printer.superscriptHandles.contains h:
    printer.retract(printer.superscriptHandles, CancelAltScript, h)
  elif printer.subscriptHandles.contains h:
    printer.retract(printer.subscriptHandles, CancelAltScript, h)
 proc openPrinter(turn: Turn; devicePath: string): Printer =
  new result
  result.facet = turn.facet
  result.device = posix.open(devicePath, O_WRONLY, 0)
  result.write(InitializePrinter)
 proc main =
  let devicePath = paramStr(1)
  runActor(devicePath) do (turn: Turn):
    let printer = turn.newCap openPrinter(turn, devicePath)
    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
      publish(turn, ds, initRecord(
        toSymbol"printer", printer.embed, %devicePath))
 main()
--- a/src/http_client.nim
+++ b/src/http_client.nim
@ -1,91 +0,0 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
 # TODO: write a TAPS HTTP client. Figure out how to externalise TLS.
 import
  std/[httpclient, options, streams, strutils, tables, uri],
  pkg/taps,
  pkg/preserves,
  pkg/syndicate, pkg/syndicate/protocols/http,
  ./schema/config
 proc url(req: HttpRequest): Uri =
  result.scheme = if req.port == 80: "http" else: "https"
  result.hostname = req.host.present
  result.port = $req.port
  for i, p in req.path:
    if 0 < i: result.path.add '/'
    result.path.add p.encodeUrl
  for key, vals in req.query:
    if result.query.len > 0:
      result.query.add '&'
    result.query.add key.string.encodeUrl
    for i, val in vals:
      if i == 0: result.query.add '='
      elif i < vals.high: result.query.add ','
      result.query.add val.string.encodeUrl
 proc bodyString(req: HttpRequest): string =
  if req.body.orKind == RequestBodyKind.present:
    return cast[string](req.body.present)
 proc spawnHttpClient*(turn: Turn; root: Cap): Actor {.discardable.} =
  during(turn, root, ?:HttpClientArguments) do (ds: Cap):
    spawn("http-client", turn) do (turn: Turn):
      during(turn, ds, HttpContext.grabType) do (ctx: HttpContext):
        let peer = ctx.res.unembed(Cap).get
        var client = newHttpClient()
        try:
          var
            headers = newHttpHeaders()
            contentType = ""
          for key, val in ctx.req.headers:
            if key == Symbol"Content-Type":
              contentType = val
            client.headers[key.string] = val
          let stdRes = client.request(
              ctx.req.url,
              ctx.req.method.string.toUpper,
              ctx.req.bodyString, headers
            )
          var resp = HttpResponse(orKind: HttpResponseKind.status)
          resp.status.code = stdRes.status[0 .. 2].parseInt
          resp.status.message = stdRes.status[3 .. ^1]
          message(turn, peer, resp)
          resp = HttpResponse(orKind: HttpResponseKind.header)
          for key, val in stdRes.headers:
            if key == "Content-Type":
              contentType = val
            resp.header.name = key.Symbol
            resp.header.value = val
          message(turn, peer, resp)
          case contentType
          of "application/json", "text/preserves":
            message(turn, peer,
                initRecord("done", stdRes.bodyStream.readAll.parsePreserves))
          of "application/preserves":
            message(turn, peer,
                initRecord("done", stdRes.bodyStream.decodePreserves))
          else:
            resp = HttpResponse(orKind: HttpResponseKind.done)
            resp.done.chunk.string = stdRes.bodyStream.readAll()
            message(turn, peer, resp)
        except CatchableError as err:
          var resp = HttpResponse(orKind: HttpResponseKind.status)
          resp.status.code = 400
          resp.status.message = "Internal client error"
          message(turn, peer, resp)
          resp = HttpResponse(orKind: HttpResponseKind.done)
          resp.done.chunk.string = err.msg
          message(turn, peer, resp)
        client.close()
      do:
        client.close()
 when isMainModule:
  import syndicate/relays
  runActor("main") do (turn: Turn):
    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
      spawnHttpClient(turn, ds)
--- a/src/http_client.nim.cfg
+++ b/src/http_client.nim.cfg
@ -1 +0,0 @@
 define:ssl
--- a/src/inotify_actor.nim
+++ b/src/inotify_actor.nim
@ -0,0 +1,114 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
 ## An actor for filesystem monitoring.
 import std/[asyncdispatch, asyncfile, tables]
 import posix, posix/inotify
 import preserves
 import syndicate, syndicate/[bags, relays]
 import ./schema/inotify_actor
 var IN_NONBLOCK {.importc, nodecl.}: cint
 type
  BootArgs {.preservesDictionary.} = object
    dataspace: Cap
 proc toMask(sym: Symbol): uint32 =
  case sym.string
  of "IN_ACCESS": IN_ACCESS
  of "IN_MODIFY": IN_MODIFY
  of "IN_ATTRIB": IN_ATTRIB
  of "IN_CLOSE_WRITE": IN_CLOSE_WRITE
  of "IN_CLOSE_NOWRITE": IN_CLOSE_NOWRITE
  of "IN_CLOSE": IN_CLOSE
  of "IN_OPEN": IN_OPEN
  of "IN_MOVED_FROM": IN_MOVED_FROM
  of "IN_MOVED_TO": IN_MOVED_TO
  of "IN_MOVE": IN_MOVE
  of "IN_CREATE": IN_CREATE
  of "IN_DELETE": IN_DELETE
  of "IN_DELETE_SELF": IN_DELETE_SELF
  of "IN_MOVE_SELF": IN_MOVE_SELF
  else: 0
 func contains(event, bit: uint32): bool = (event and bit) != 0
 iterator symbols(event: uint32): Symbol =
  if event.contains IN_ACCESS:
    yield Symbol"IN_ACCESS"
  if event.contains IN_MODIFY:
    yield Symbol"IN_MODIFY"
  if event.contains IN_ATTRIB:
    yield Symbol"IN_ATTRIB"
  if event.contains IN_CLOSE_WRITE:
    yield Symbol"IN_CLOSE_WRITE"
  if event.contains IN_CLOSE_NOWRITE:
    yield Symbol"IN_CLOSE_NOWRITE"
  if event.contains IN_OPEN:
    yield Symbol"IN_OPEN"
  if event.contains IN_MOVED_FROM:
    yield Symbol"IN_MOVED_FROM"
  if event.contains IN_MOVED_TO:
    yield Symbol"IN_MOVED_TO"
  if event.contains IN_CREATE:
    yield Symbol"IN_CREATE"
  if event.contains IN_DELETE:
    yield Symbol"IN_DELETE"
  if event.contains IN_DELETE_SELF:
    yield Symbol"IN_DELETE_SELF"
  if event.contains IN_MOVE_SELF:
    yield Symbol"IN_MOVE_SELF"
  if event.contains (IN_CLOSE_WRITE or IN_CLOSE_NOWRITE):
    yield Symbol"IN_CLOSE"
  if event.contains (IN_MOVED_FROM or IN_MOVED_TO):
    yield Symbol"IN_MOVE"
 runActor("inotify_actor") do (root: Cap; turn: var Turn):
  let buf = newSeq[byte](8192)
  let eventPattern = ?Observe(pattern: !InotifyMessage) ?? { 0: grabLit(), 1: grabLit() }
  connectStdio(turn, root)
  during(turn, root, ?:BootArgs) do (ds: Cap):
    let inf = inotify_init1(IN_NONBLOCK)
    doAssert inf != -1, $inf & " - " & $strerror(errno)
    var
      registry = initTable[cint, string]()
      watchBag: Bag[cint]
    let
      anf = newAsyncFile(AsyncFD inf)
      facet = turn.facet
    var fut: Future[int]
    proc readEvents() {.gcsafe.} =
      fut = readBuffer(anf, buf[0].addr, buf.len)
      addCallback(fut, facet) do (turn: var Turn):
        let n = read(fut)
        doAssert n > 0
        for event in inotify_events(buf[0].addr, n):
          var msg = InotifyMessage(path: registry[event.wd], cookie: event.cookie.BiggestInt)
          if event.len > 0:
            let n = event.len
            msg.name.setLen(n)
            copyMem(msg.name[0].addr, event.name.addr, n)
            for i, c in msg.name:
              if c == '\0':
                msg.name.setLen(i)
                break
          for sym in event.mask.symbols:
            msg.event = sym
            message(turn, ds, msg)
        readEvents()
    readEvents()
    during(turn, ds, eventPattern) do (path: string, kind: Symbol):
      let wd = inotify_add_watch(inf, path, kind.toMask or IN_MASK_ADD)
      doAssert wd > 0, $strerror(errno)
      registry[wd] = path
      discard watchBag.change(wd, 1)
    do:
      if watchBag.change(wd, -1, clamp = true) == cdPresentToAbsent:
        discard close(wd)
        registry.del(wd)
  do:
    close(anf)
--- a/src/schema/json_messages.nim
+++ b/src/schema/json_messages.nim
--- a/src/mount_actor.nim
+++ b/src/mount_actor.nim
@ -7,8 +7,8 @@ when not defined(linux):
  {.error: "this component only tested for Linux".}
 import std/oserrors
-import preserves, preserves/sugar
+import preserves
-import syndicate
+import syndicate, syndicate/relays
 import ./schema/mountpoints
 type BootArgs {.preservesDictionary.} = object
@ -20,34 +20,25 @@ proc mount(source, target, fsType: cstring; flags: culong; data: pointer): cint
 proc umount(target: cstring): cint {.importc, header: "<sys/mount.h>".}
  ## `umount(2)`
-proc spawnMountActor*(turn: Turn; ds: Cap): Actor {.discardable.} =
+runActor("mount_actor") do (turn: var Turn; root: Cap):
-  spawnActor(turn, "mount_actor") do (turn: Turn):
+  let
-    let
+    targetPat = ?Observe(pattern: !Mountpoint) ?? { 1: grabLit() }
-      targetPat = observePattern(!Mountpoint, { @[%1]: grabLit() })
+    sourcePat = ?Observe(pattern: !Mountpoint) ?? { 0: grabLit(), 2: grabLit() }
-      sourcePat = observePattern(!Mountpoint, {
+  connectStdio(turn, root)
-          @[%0]: grabLit(),
+  during(turn, root, ?:BootArgs) do (ds: Cap):
-          @[%2]: grabLit(),
+    during(turn, ds, targetPat) do (target: string):
-        })
+      during(turn, ds, sourcePat) do (source: string, fsType: string):
-    during(turn, ds, ?:BootArgs) do (ds: Cap):
+        var mountpoint = Mountpoint(
-      during(turn, ds, targetPat) do (target: string):
+              source: source,
-        during(turn, ds, sourcePat) do (source: string, fsType: string):
+              target: target,
-          var mountpoint = Mountpoint(
+              `type`: fsType,
-                source: source,
+            )
-                target: target,
+        var rc = mount(source, target, fsType, 0, nil)
-                `type`: fsType,
+        if rc == 0:
-              )
+          mountpoint.status = Status(orKind: StatusKind.success)
-          var rc = mount(source, target, fsType, 0, nil)
+        else:
-          if rc == 0:
+          mountpoint.status = Status(orKind: StatusKind.Failure)
-            mountpoint.status = Status(orKind: StatusKind.success)
+          mountpoint.status.failure.msg = osErrorMsg(osLastError())
-          else:
+        discard publish(turn, ds, mountpoint)
-            mountpoint.status = Status(orKind: StatusKind.Failure)
+    do:
-            mountpoint.status.failure.msg = osErrorMsg(osLastError())
+      discard umount(target)
          discard publish(turn, ds, mountpoint)
      do:
        discard umount(target)
 when isMainModule:
  import syndicate/relays
  runActor("main") do (turn: Turn):
    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
      discard spawnMountActor(turn, ds)
--- a/src/msg.nim
+++ b/src/msg.nim
@ -1,22 +1,20 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
-import std/[sequtils, os, strutils]
+import std/[asyncdispatch, sequtils, os]
 import preserves, syndicate, syndicate/relays
-setControlCHook(proc () {.noconv.} = quit())
+proc main =
 runActor("msg") do (turn: Turn):
  let
    route = envRoute()
    data = map(commandLineParams(), parsePreserves)
-    cmd = paramStr(0).extractFilename.normalize
+
-  resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+  discard bootDataspace("msg") do (turn: var Turn; root: Cap):
-    case cmd
+    spawnRelays(turn, root)
-    of "assert":
+    resolve(turn, root, route) do (turn: var Turn; ds: Cap):
      for e in data:
        publish(turn, ds, e)
    else: # "msg"
      for e in data:
        message(turn, ds, e)
-      sync(turn, ds) do (turn: Turn):
+
-        stopActor(turn)
+  for _ in 1..2: poll()
 main()
--- a/src/net_mapper.nim
+++ b/src/net_mapper.nim
@ -0,0 +1,167 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
 ## A ping utility for Syndicate.
 import std/[asyncdispatch, asyncnet, monotimes, nativesockets, net, os, strutils, tables, times]
 import preserves
 import syndicate, syndicate/relays
 import ./schema/net_mapper
 #[
 var
  SOL_IP {.importc, nodecl, header: "<sys/socket.h>".}: int
  IP_TTL {.importc, nodecl, header: "<netinet/in.h>".}: int
 ]#
 proc toPreservesHook(address: IpAddress): Value = toPreserves($address)
 proc fromPreservesHook(address: var IpAddress; pr: Value): bool =
  try:
    if pr.isString:
      address = parseIpAddress(pr.string)
      result = true
  except ValueError: discard
 when isMainModule:
  # verify that the hook catches
  var ip: IpAddress
  assert fromPreservesHook(ip, toPreservesHook(ip))
 type
  IcmpHeader {.packed.} = object
    `type`: uint8
    code: uint8
    checksum: uint16
  IcmpEchoFields {.packed.} = object
    header: IcmpHeader
    identifier: array[2, byte]
    sequenceNumber: uint16
  IcmpEcho {.union.} = object
    fields: IcmpEchoFields
    buffer: array[8, uint8]
  IcmpTypes = enum
    icmpEchoReply = 0,
    icmpEcho = 8,
 proc initIcmpEcho(): IcmpEcho =
  result.fields.header.`type` = uint8 icmpEcho
  # doAssert urandom(result.fields.identifier) # Linux does this?
 proc updateChecksum(msg: var IcmpEcho) =
  var sum: uint32
  msg.fields.header.checksum = 0
  for n in cast[array[4, uint16]](msg.buffer): sum = sum + uint32(n)
  while (sum and 0xffff0000'u32) != 0:
    sum = (sum and 0xffff) + (sum shr 16)
  msg.fields.header.checksum = not uint16(sum)
 proc match(a, b: IcmpEchoFields): bool =
  ({a.header.type, b.header.type} == {uint8 icmpEcho, uint8 icmpEchoReply}) and
    (a.header.code == b.header.code) and
      (a.sequenceNumber == b.sequenceNumber)
 type
  Pinger = ref object
    facet: Facet
    ds: Cap
    rtt: RoundTripTime
    rttHandle: Handle
    sum: Duration
    count: int64
    msg: IcmpEcho
    socket: AsyncSocket
    sad: Sockaddr_storage
    sadLen: SockLen
    interval: Duration
 proc newPinger(address: IpAddress; facet: Facet; ds: Cap): Pinger =
  result = Pinger(
    facet: facet,
    ds: ds,
    rtt: RoundTripTime(address: $address),
    msg: initIcmpEcho(),
    socket: newAsyncSocket(AF_INET, SOCK_DGRAM, IPPROTO_ICMP, false, true),
    interval: initDuration(milliseconds = 500))
  toSockAddr(address, Port 0, result.sad, result.sadLen)
  # setSockOptInt(getFd socket, SOL_IP, IP_TTL, _)
 proc close(ping: Pinger) = close(ping.socket)
 proc sqr(dur: Duration): Duration =
  let us = dur.inMicroseconds
  initDuration(microseconds = us * us)
 proc update(ping: Pinger; dur: Duration) {.inline.} =
  let secs = dur.inMicroseconds.float / 1_000_000.0
  if ping.count == 0: (ping.rtt.minimum, ping.rtt.maximum) = (secs, secs)
  elif secs < ping.rtt.minimum: ping.rtt.minimum = secs
  elif secs > ping.rtt.maximum: ping.rtt.maximum = secs
  ping.sum = ping.sum + dur
  inc ping.count
  ping.rtt.average = inMicroseconds(ping.sum div ping.count).float / 1_000_000.0
 proc exchangeEcho(ping: Pinger) {.async.} =
  inc ping.msg.fields.sequenceNumber
  # updateChecksum(ping.msg) # Linux does this?
  let
    a = getMonoTime()
    r = sendto(ping.socket.getFd,
      unsafeAddr ping.msg.buffer[0], ping.msg.buffer.len, 0,
      cast[ptr SockAddr](unsafeAddr ping.sad), # neckbeard loser API
    ping.sadLen)
  if r == -1'i32:
    let osError = osLastError()
    raiseOSError(osError)
  while true:
    var
      (data, address, _) = await recvFrom(ping.socket, 128)
      b = getMonoTime()
    if address != $ping.rtt.address:
      stderr.writeLine "want ICMP from ", ping.rtt.address, " but received from ", address, " instead"
    elif data.len >= ping.msg.buffer.len:
      let
        period = b - a
        resp = cast[ptr IcmpEcho](unsafeAddr data[0])
      if match(ping.msg.fields, resp.fields):
        update(ping, period)
        return
      else:
        stderr.writeLine "ICMP mismatch"
    else:
      stderr.writeLine "reply data has a bad length ", data.len
 proc kick(ping: Pinger) {.gcsafe.} =
  if not ping.socket.isClosed:
    addTimer(ping.interval.inMilliseconds.int, oneshot = true) do (fd: AsyncFD) -> bool:
      let fut = exchangeEcho(ping)
      fut.addCallback do ():
        if fut.failed and ping.rttHandle != Handle(0):
          ping.facet.run do (turn: var Turn):
            retract(turn, ping.rttHandle)
            reset ping.rttHandle
        else:
          ping.facet.run do (turn: var Turn):
            replace(turn, ping.ds, ping.rttHandle, ping.rtt)
        if ping.interval < initDuration(seconds = 20):
          ping.interval = ping.interval * 2
        kick(ping)
 type Args {.preservesDictionary.} = object
  dataspace: Cap
 runActor("net_mapper") do (root: Cap; turn: var Turn):
  connectStdio(turn, root)
  let rttObserver = ?Observe(pattern: !RoundTripTime) ?? {0: grabLit()}
  during(turn, root, ?:Args) do (ds: Cap):
    during(turn, ds, rttObserver) do (address: IpAddress):
      var ping: Pinger
      if address.family == IpAddressFamily.IPv4:
        ping = newPinger(address, turn.facet, ds)
        kick(ping)
    do:
      if not ping.isNil: close(ping)
--- a/src/private/esc_p.nim
+++ b/src/private/esc_p.nim
@ -1,11 +0,0 @@
 const
  ESC* = "\x1b"
  InitializePrinter* = ESC & "@"
  CancelLine* = ESC & "\x18"
  SelectBoldFont* = ESC & "E"
  CancelBoldFont* = ESC & "F"
  SelectItalicFont* = ESC & "4"
  CanceItalicFont* = ESC & "5"
  SelectSuperScript* = ESC & "S0"
  SelectSubScript* = ESC & "S1"
  CancelAltScript* = ESC & "T"
--- a/src/rofi_script_actor.nim
+++ b/src/rofi_script_actor.nim
@ -3,29 +3,40 @@
 ## See the rofi-script(5) manpage for documentation.
-import std/[cmdline, envvars, strutils, tables]
+import std/[asyncdispatch, cmdline, envvars, strutils, tables]
 import preserves, syndicate, syndicate/relays
 import ./schema/rofi
-if getEnv("ROFI_OUTSIDE") == "":
+proc main =
-  quit("run this program in rofi")
+  let
    route = envRoute()
    rofiPid = getEnv("ROFI_OUTSIDE")
  if rofiPid == "":
    quit("run this program in rofi")
-runActor("rofi_script_actor") do (turn: Turn):
+  runActor("rofi_script_actor") do (turn: var Turn; root: Cap):
-  resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+    let rootFacet = turn.facet
-    case paramCount()
+    resolve(turn, root, route) do (turn: var Turn; ds: Cap):
-    of 0:
+      case paramCount()
-      let pat = ?:Options
+      of 0:
-      onPublish(turn, ds, pat) do (options: seq[string]):
+        let pat = ?:Options
-        stdout.writeLine options.join("\n")
+        onPublish(turn, ds, pat) do (options: seq[string]):
-        quit()
+          stdout.writeLine options.join("\n")
          quit()
-    of 1:
+      of 1:
-      var select = Select(option: commandLineParams()[0])
+        var select = Select(option: commandLineParams()[0])
-      for (key, val) in envPairs():
+        for (key, val) in envPairs():
-        if key.startsWith "ROFI_":
+          if key.startsWith "ROFI_":
-          select.environment[Symbol key] = val
+            select.environment[Symbol key] = val
-      message(turn, ds, select)
+        message(turn, ds, select)
-      sync(turn, ds, stopActor)
+        # TODO: sync not implemented correctly
        # sync(turn, ds, stopActor)
        callSoon do ():
          waitFor sleepAsync(1)
          quit()
-    else:
+      else:
-      quit("rofi passed an unexpected number of arguments")
+        quit("rofi passed an unexpected number of arguments")
 main()
--- a/src/schema/base64.nim
+++ b/src/schema/base64.nim
@ -1,19 +0,0 @@
 import
  preserves
 type
  Base64File* {.preservesRecord: "base64-file".} = object
    `txt`*: string
    `path`*: string
    `size`*: BiggestInt
  Base64Text* {.preservesRecord: "base64".} = object
    `txt`*: string
    `bin`*: seq[byte]
 proc `$`*(x: Base64File | Base64Text): string =
  `$`(toPreserves(x))
 proc encode*(x: Base64File | Base64Text): seq[byte] =
  encode(toPreserves(x))
--- a/src/schema/config.nim
+++ b/src/schema/config.nim
@ -10,12 +10,6 @@ type
  WebsocketArguments* {.preservesRecord: "websocket".} = object
    `field0`*: WebsocketArgumentsField0
  HttpClientArgumentsField0* {.preservesDictionary.} = object
    `dataspace`* {.preservesEmbedded.}: EmbeddedRef
  HttpClientArguments* {.preservesRecord: "http-client".} = object
    `field0`*: HttpClientArgumentsField0
  JsonTranslatorArgumentsField0* {.preservesDictionary.} = object
    `argv`*: seq[string]
    `dataspace`* {.preservesEmbedded.}: EmbeddedRef
@ -23,29 +17,12 @@ type
  JsonTranslatorArguments* {.preservesRecord: "json-stdio-translator".} = object
    `field0`*: JsonTranslatorArgumentsField0
  SocketAddressKind* {.pure.} = enum
    `TcpAddress`, `UnixAddress`
  `SocketAddress`* {.preservesOr.} = object
    case orKind*: SocketAddressKind
    of SocketAddressKind.`TcpAddress`:
        `tcpaddress`*: TcpAddress
    of SocketAddressKind.`UnixAddress`:
        `unixaddress`*: UnixAddress
  Base64DecoderArgumentsField0* {.preservesDictionary.} = object
    `dataspace`* {.preservesEmbedded.}: EmbeddedRef
  Base64DecoderArguments* {.preservesRecord: "base64-decoder".} = object
    `field0`*: Base64DecoderArgumentsField0
  JsonTranslatorConnected* {.preservesRecord: "connected".} = object
-    `address`*: SocketAddress
+    `path`*: string
  JsonSocketTranslatorArgumentsField0* {.preservesDictionary.} = object
    `dataspace`* {.preservesEmbedded.}: EmbeddedRef
-    `socket`*: SocketAddress
+    `socket`*: string
  JsonSocketTranslatorArguments* {.preservesRecord: "json-socket-translator".} = object
    `field0`*: JsonSocketTranslatorArgumentsField0
@ -56,12 +33,6 @@ type
  XsltArguments* {.preservesRecord: "xslt".} = object
    `field0`*: XsltArgumentsField0
  HttpDriverArgumentsField0* {.preservesDictionary.} = object
    `dataspace`* {.preservesEmbedded.}: EmbeddedRef
  HttpDriverArguments* {.preservesRecord: "http-driver".} = object
    `field0`*: HttpDriverArgumentsField0
  WebhooksArgumentsField0* {.preservesDictionary.} = object
    `endpoints`*: Table[seq[string], EmbeddedRef]
    `listen`*: Tcp
@ -82,10 +53,6 @@ type
  SqliteArguments* {.preservesRecord: "sqlite".} = object
    `field0`*: SqliteArgumentsField0
  TcpAddress* {.preservesRecord: "tcp".} = object
    `host`*: string
    `port`*: BiggestInt
  CacheArgumentsField0* {.preservesDictionary.} = object
    `dataspace`* {.preservesEmbedded.}: EmbeddedRef
    `lifetime`*: float
@ -116,50 +83,36 @@ type
  PulseArguments* {.preservesRecord: "pulse".} = object
    `field0`*: PulseArgumentsField0
  UnixAddress* {.preservesRecord: "unix".} = object
    `path`*: string
  Tcp* {.preservesRecord: "tcp".} = object
    `host`*: string
    `port`*: BiggestInt
-proc `$`*(x: WebsocketArguments | HttpClientArguments | JsonTranslatorArguments |
+proc `$`*(x: WebsocketArguments | JsonTranslatorArguments |
    SocketAddress |
    Base64DecoderArguments |
    JsonTranslatorConnected |
    JsonSocketTranslatorArguments |
    XsltArguments |
    HttpDriverArguments |
    WebhooksArguments |
    FileSystemUsageArguments |
    SqliteArguments |
    TcpAddress |
    CacheArguments |
    XmlTranslatorArguments |
    PostgreConnectionParameter |
    PostgreArguments |
    PulseArguments |
    UnixAddress |
    Tcp): string =
  `$`(toPreserves(x))
-proc encode*(x: WebsocketArguments | HttpClientArguments |
+proc encode*(x: WebsocketArguments | JsonTranslatorArguments |
    JsonTranslatorArguments |
    SocketAddress |
    Base64DecoderArguments |
    JsonTranslatorConnected |
    JsonSocketTranslatorArguments |
    XsltArguments |
    HttpDriverArguments |
    WebhooksArguments |
    FileSystemUsageArguments |
    SqliteArguments |
    TcpAddress |
    CacheArguments |
    XmlTranslatorArguments |
    PostgreConnectionParameter |
    PostgreArguments |
    PulseArguments |
    UnixAddress |
    Tcp): seq[byte] =
  encode(toPreserves(x))
--- a/src/schema/sql.nim
+++ b/src/schema/sql.nim
@ -4,15 +4,11 @@ import
 type
  Query* {.preservesRecord: "query".} = object
-    `statement`*: seq[Value]
+    `statement`*: string
    `target`* {.preservesEmbedded.}: Value
-  SqlError* {.preservesRecord: "sql-error".} = object
+proc `$`*(x: Query): string =
    `msg`*: string
    `context`*: string
 proc `$`*(x: Query | SqlError): string =
  `$`(toPreserves(x))
-proc encode*(x: Query | SqlError): seq[byte] =
+proc encode*(x: Query): seq[byte] =
  encode(toPreserves(x))
--- a/src/syndesizer.nim
+++ b/src/syndesizer.nim
@ -3,26 +3,42 @@
 ## Syndicate multitool.
-import syndicate, syndicate/relays, syndicate/drivers/timers
+import syndicate, syndicate/relays, syndicate/actors/timers
 const
  withPostgre* {.booldefine.}: bool = true
  withSqlite* {.booldefine.}: bool = true
 import ./syndesizer/[
  base64_decoder,
  cache_actor,
  file_system_usage,
  http_driver,
  json_socket_translator,
  json_translator,
  pulses,
-  xml_translator]
+  webhooks,
  websockets,
  xml_translator,
  xslt_actor]
-runActor("syndesizer") do (turn: Turn):
+when withPostgre:
-  resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+  import ./syndesizer/postgre_actor
-    discard spawnTimerDriver(turn, ds)
+
-    discard spawnBase64Decoder(turn, ds)
+when withSqlite:
-    discard spawnCacheActor(turn, ds)
+  import ./syndesizer/sqlite_actor
-    discard spawnFileSystemUsageActor(turn, ds)
+
-    discard spawnHttpDriver(turn, ds)
+runActor("syndesizer") do (turn: var Turn; root: Cap):
-    discard spawnJsonSocketTranslator(turn, ds)
+  connectStdio(turn, root)
-    discard spawnJsonStdioTranslator(turn, ds)
+  discard spawnTimers(turn, root)
-    discard spawnPulseActor(turn, ds)
+  discard spawnCacheActor(turn, root)
-    discard spawnXmlTranslator(turn, ds)
+  discard spawnFileSystemUsageActor(turn, root)
  discard spawnJsonSocketTranslator(turn, root)
  discard spawnJsonStdioTranslator(turn, root)
  discard spawnPulseActor(turn, root)
  discard spawnWebhookActor(turn, root)
  discard spawnWebsocketActor(turn, root)
  discard spawnXmlTranslator(turn, root)
  discard spawnXsltActor(turn, root)
  when withPostgre:
    discard spawnPostgreActor(turn, root)
  when withSqlite:
    discard spawnSqliteActor(turn, root)
--- a/src/syndesizer/Tupfile
+++ b/src/syndesizer/Tupfile
@ -1,3 +1,4 @@
 include_rules
-: foreach *.nim | $(SYNDICATE_PROTOCOL) ../<schema> |> !nim_bin |> {bin}
+: foreach *.nim | $(SYNDICATE_PROTOCOL) ../<schema> |> !nim_check |> | ./<checks>
-: foreach {bin} |> !assert_built |>
+: xslt_actor.nim | $(SYNDICATE_PROTOCOL) ../<schema> |> !nim |> {bin}
 : foreach {bin} |> !assert_built |> ../../tests/built-%b.pr
--- a/src/syndesizer/base64_decoder.nim
+++ b/src/syndesizer/base64_decoder.nim
@ -1,50 +0,0 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
 import
  std/[base64, os],
  pkg/nimcrypto/blake2,
  preserves, preserves/sugar, syndicate,
  ../schema/config,
  ../schema/base64 as schema
 export Base64DecoderArguments
 export schema
 proc spawnBase64Decoder*(turn: Turn; root: Cap): Actor {.discardable.} =
  spawnActor(turn, "base64-decoder") do (turn: Turn):
    let tmpDir = getTempDir()
    during(turn, root, ?:Base64DecoderArguments) do (ds: Cap):
      let decTextPat = observePattern(!Base64Text, { @[%0]: grabLit() })
      during(turn, ds, decTextPat) do (txt: string):
        discard publish(turn, ds, Base64Text(
            txt: txt,
            bin: cast[seq[byte]](decode(txt)),
          ))
      let encTextPat = observePattern(!Base64Text, { @[%1]: grabLit() })
      during(turn, ds, encTextPat) do (bin: seq[byte]):
        discard publish(turn, ds, Base64Text(
            txt: encode(bin),
            bin: bin,
          ))
      let decFilePat = observePattern( !Base64File, { @[%0]: grabLit() })
      during(turn, ds, decFilePat) do (txt: string):
        var
          bin = decode(txt)
          digest = $blake2_256.digest(bin)
          path = tmpDir / digest
        writeFile(path, bin)
        discard publish(turn, ds, Base64File(
            txt: txt,
            path: path,
            size: bin.len,
          ))
 when isMainModule:
  import syndicate/relays
  runActor("main") do (turn: Turn):
    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
      spawnBase64Decoder(turn, ds)
--- a/src/syndesizer/cache_actor.nim
+++ b/src/syndesizer/cache_actor.nim
@ -3,8 +3,8 @@
 import std/times
 import preserves, syndicate,
-  syndicate/durings,
+  syndicate/[durings, relays],
-  syndicate/drivers/timers
+  syndicate/actors/timers
 import ../schema/config
@ -18,9 +18,9 @@ type CacheEntity {.final.} = ref object of Entity
  pattern: Pattern
  lifetime: float64
-method publish(cache: CacheEntity; turn: Turn; ass: AssertionRef; h: Handle) =
+method publish(cache: CacheEntity; turn: var Turn; ass: AssertionRef; h: Handle) =
  ## Re-assert pattern captures in a sub-facet.
-  discard inFacet(turn) do (turn: Turn):
+  discard inFacet(turn) do (turn: var Turn):
    # TODO: a seperate facet for every assertion, too much?
    var ass = depattern(cache.pattern, ass.value.sequence)
      # Build an assertion with what he have of the pattern and capture.
@ -30,12 +30,12 @@ method publish(cache: CacheEntity; turn: Turn; ass: AssertionRef; h: Handle) =
      stop(turn) # end this facet
 proc isObserve(pat: Pattern): bool =
-  pat.orKind == PatternKind.group and
+  pat.orKind == PatternKind.DCompound and
-    pat.group.type.orKind == GroupTypeKind.rec and
+    pat.dcompound.orKind == DCompoundKind.rec and
-      pat.group.type.rec.label.isSymbol"Observe"
+      pat.dcompound.rec.label.isSymbol"Observe"
-proc spawnCacheActor*(turn: Turn; root: Cap): Actor =
+proc spawnCacheActor*(turn: var Turn; root: Cap): Actor =
-  spawnActor(turn, "cache_actor") do (turn: Turn):
+  spawn("cache_actor", turn) do (turn: var Turn):
    during(turn, root, ?:CacheArguments) do (ds: Cap, lifetime: float64):
      onPublish(turn, ds, ?:Observe) do (pat: Pattern, obs: Cap):
        var cache: CacheEntity
@ -51,8 +51,7 @@ proc spawnCacheActor*(turn: Turn; root: Cap): Actor =
          discard observe(turn, ds, pat, cache)
 when isMainModule:
-  import syndicate/relays
+  runActor("cache_actor") do (turn: var Turn; root: Cap):
-  runActor("main") do (turn: Turn):
+    spawnTimers(turn, root)
-    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+    connectStdio(turn, root)
-      discard spawnTimerDriver(turn, ds)
+    discard spawnCacheActor(turn, root)
      discard spawnCacheActor(turn, ds)
--- a/src/syndesizer/file_system_usage.nim
+++ b/src/syndesizer/file_system_usage.nim
@ -2,15 +2,15 @@
 # SPDX-License-Identifier: Unlicense
 import std/[dirs, os, paths]
-import preserves, preserves/sugar
+import preserves
-import syndicate
+import syndicate, syndicate/relays
 import ../schema/[assertions, config]
-proc spawnFileSystemUsageActor*(turn: Turn; root: Cap): Actor {.discardable.} =
+proc spawnFileSystemUsageActor*(turn: var Turn; root: Cap): Actor {.discardable.} =
-  spawn("file-system-usage", turn) do (turn: Turn):
+  spawn("file-system-usage", turn) do (turn: var Turn):
    during(turn, root, ?:FileSystemUsageArguments) do (ds: Cap):
-      let pat = observePattern(!FileSystemUsage, { @[%0]: grab() })
+      var pat = ?Observe(pattern: !FileSystemUsage) ?? { 0: grab() }
      during(turn, ds, pat) do (lit: Literal[string]):
        var ass = FileSystemUsage(path: lit.value)
        if fileExists(ass.path): ass.size = getFileSize(ass.path)
@ -22,7 +22,6 @@ proc spawnFileSystemUsageActor*(turn: Turn; root: Cap): Actor {.discardable.} =
          # TODO: updates?
 when isMainModule:
-  import syndicate/relays
+  runActor("main") do (turn: var Turn; root: Cap):
-  runActor("main") do (turn: Turn):
+    connectStdio(turn, root)
-    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+    discard spawnFileSystemUsageActor(turn, root)
      discard spawnFileSystemUsageActor(turn, ds)
--- a/src/syndesizer/http_driver.nim
+++ b/src/syndesizer/http_driver.nim
@ -1,42 +0,0 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
 ## Thin wrapper over `syndicate/drivers/http_driver`.
 import pkg/preserves, pkg/syndicate
 import pkg/syndicate/drivers/http_driver
 import pkg/taps
 import ../schema/config
 proc spawnHttpDriver*(turn: Turn; ds: Cap): Actor {.discardable.}=
  http_driver.spawnHttpDriver(turn, ds)
  during(turn, ds, ?:HttpDriverArguments) do (ds: Cap):
    http_driver.spawnHttpDriver(turn, ds)
 when isMainModule:
  import syndicate/relays
  when defined(solo5):
    import solo5
    acquireDevices([("eth0", netBasic)], netAcquireHook)
    proc envRoute: Route =
      var pr = parsePreserves $solo5_start_info.cmdline
      if result.fromPreserves pr:
        return
      elif pr.isSequence:
        for e in pr:
          if result.fromPreserves e:
            return
      quit("failed to parse command line for route to Syndicate gatekeeper")
    runActor("main") do (turn: Turn):
      let ds = newDataspace(turn)
      spawnRelays(turn, ds)
      resolve(turn, ds, envRoute(), spawnHttpDriver)
  else:
    runActor("main") do (turn: Turn):
      resolveEnvironment(turn) do (turn: Turn; ds: Cap):
        spawnHttpDriver(turn, ds)
--- a/src/syndesizer/http_driver.nim.cfg
+++ b/src/syndesizer/http_driver.nim.cfg
@ -1,2 +0,0 @@
 define:ipv6Enabled
 include:"std/assertions"
--- a/src/syndesizer/json_socket_translator.nim
+++ b/src/syndesizer/json_socket_translator.nim
@ -1,77 +1,39 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
-import std/[json, options]
+import std/[asyncdispatch, asyncnet, json]
-import pkg/sys/[ioqueue, sockets]
+from std/nativesockets import AF_UNIX, SOCK_STREAM, Protocol
-import preserves, preserves/jsonhooks, syndicate
+import preserves, preserves/jsonhooks, syndicate, syndicate/relays
-import ../schema/[config, json_messages]
+import ../schema/config, ../json_messages
-template translateSocketBody {.dirty.} =
+proc spawnJsonSocketTranslator*(turn: var Turn; root: Cap): Actor =
-  # Template workaround for CPS and parameterized types.
+  spawn("json-socket-translator", turn) do (turn: var Turn):
-  var
+    during(turn, root, ?:JsonSocketTranslatorArguments) do (ds: Cap, socketPath: string):
-    guard = initGuard(facet)
+      let socket = newAsyncSocket(
-    dec = newBufferedDecoder(0)
+          domain = AF_UNIX,
-    buf = new string #TODO: get a pointer into the decoder
+          sockType = SOCK_STREAM,
-    alive = true
+          protocol = cast[Protocol](0),
-  proc kill(turn: Turn) =
+          buffered = false,
-    alive = false
+        )
-  proc setup(turn: Turn) =
+      addCallback(connectUnix(socket, socketPath), turn) do (turn: var Turn):
-    # Closure, not CPS.
+        let a = JsonTranslatorConnected(path: socketPath)
-    onMessage(turn, ds, ?:SendJson) do (data: JsonNode):
+        discard publish(turn, ds, a)
      if alive:
        discard trampoline:
          whelp write(socket[], $data & "\n")
      else:
        stderr.writeLine "dropped send of ", data
    discard publish(turn, ds, initRecord("connected", sa.toPreserves))
  onStop(facet, kill)
  run(facet, setup)
  while alive:
    # TODO: parse buffer
    buf[].setLen(0x4000)
    let n = read(socket[], buf)
    if n < 1:
      stderr.writeLine "socket read returned ", n
    else:
      buf[].setLen(n)
      dec.feed(buf[])
      var data = dec.parse()
      if data.isSome:
        proc send(turn: Turn) =
          # Closure, not CPS.
          message(turn, ds, initRecord("recv", data.get))
        run(facet, send)
  stderr.writeLine "close socket ", sa
  close(socket[])
-proc translateSocket(facet: Facet; ds: Cap; sa: TcpAddress) {.asyncio.} =
+        let socketFacet = turn.facet
-  var
+        proc processOutput(fut: Future[string]) {.gcsafe.} =
-    socket = new AsyncConn[Protocol.Tcp]
+          run(socketFacet) do (turn: var Turn):
-    conn = connectTcpAsync(sa.host, Port sa.port)
+            var data = fut.read.parseJson
-  socket[] = conn
+            message(turn, ds, RecvJson(data: data))
-  translateSocketBody()
+          socket.recvLine.addCallback(processOutput)
        socket.recvLine.addCallback(processOutput)
-proc translateSocket(facet: Facet; ds: Cap; sa: UnixAddress) {.asyncio.} =
+        onMessage(turn, ds, ?:SendJson) do (data: JsonNode):
-  var
+          asyncCheck(turn, send(socket, $data & "\n"))
-    socket = new AsyncConn[Protocol.Unix]
+    do:
-    conn = connectUnixAsync(sa.path)
+      close(socket)
  socket[] = conn
  translateSocketBody()
 proc spawnJsonSocketTranslator*(turn: Turn; root: Cap): Actor {.discardable.} =
  spawnActor(turn, "json-socket-translator") do (turn: Turn):
    during(turn, root, ?:JsonSocketTranslatorArguments) do (ds: Cap, sa: TcpAddress):
      linkActor(turn, "json-socket-translator") do (turn: Turn):
        discard trampoline:
          whelp translateSocket(turn.facet, ds, sa)
    during(turn, root, ?:JsonSocketTranslatorArguments) do (ds: Cap, sa: UnixAddress):
      linkActor(turn, "json-socket-translator") do (turn: Turn):
        discard trampoline:
          whelp translateSocket(turn.facet, ds, sa)
 when isMainModule:
-  import syndicate/relays
+  runActor("json_socket_translator") do (turn: var Turn; root: Cap):
-  runActor("main") do (turn: Turn):
+    connectStdio(turn, root)
-    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+    discard spawnJsonSocketTranslator(turn, root)
      spawnJsonSocketTranslator(turn, ds)
--- a/src/syndesizer/json_translator.nim
+++ b/src/syndesizer/json_translator.nim
@ -3,9 +3,10 @@
 import std/[json, osproc]
 import preserves
-import syndicate
+import syndicate, syndicate/relays
-import ../schema/[config, json_messages]
+import ../schema/config
 import ../json_messages
 proc runChild(params: seq[string]): string =
  if params.len < 1:
@ -19,15 +20,14 @@ proc runChild(params: seq[string]): string =
  if result == "":
    stderr.writeLine "no ouput"
-proc spawnJsonStdioTranslator*(turn: Turn; root: Cap): Actor {.discardable.} =
+proc spawnJsonStdioTranslator*(turn: var Turn; root: Cap): Actor {.discardable.} =
-  spawnActor(turn, "json-stdio-translator") do (turn: Turn):
+  spawn("json-stdio-translator", turn) do (turn: var Turn):
    during(turn, root, ?:JsonTranslatorArguments) do (argv: seq[string], ds: Cap):
      var js = parseJson(runChild(argv))
      message(turn, ds,  RecvJson(data: js))
      discard publish(turn, ds,  RecvJson(data: js))
 when isMainModule:
-  import syndicate/relays
+  runActor("main") do (turn: var Turn; root: Cap):
-  runActor("main") do (turn: Turn):
+    connectStdio(turn, root)
-    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+    spawnJsonStdioTranslator(turn, root)
      spawnJsonStdioTranslator(turn, ds)
--- a/src/syndesizer/postgre_actor.nim
+++ b/src/syndesizer/postgre_actor.nim
@ -1,8 +1,9 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
-import preserves, syndicate
+
-import ./schema/[config, sql]
+import preserves, syndicate, syndicate/relays
 import ../schema/[config, sql]
 {.passL: "-lpq".}
@ -87,26 +88,8 @@ proc splitParams(params: StringPairs): (cstringArray, cstringArray) =
  for i, _ in params: strings[i] = params[i][1]
  result[1] = allocCStringArray(strings)
-proc renderSql(tokens: openarray[Value]): string =
+proc spawnPostgreActor*(turn: var Turn; root: Cap): Actor {.discardable.} =
-  for token in tokens:
+  spawn("postgre", turn) do (turn: var Turn):
    if result.len > 0: result.add ' '
    case token.kind
    of pkSymbol:
      result.add token.symbol.string
    of pkString:
      result.add '\''
      result.add token.string
      result.add '\''
    of pkFloat, pkRegister, pkBigInt:
      result.add $token
    of pkBoolean:
      if token.bool: result.add '1'
      else: result.add '0'
    else:
      return ""
 proc spawnPostgreActor*(turn: Turn; root: Cap): Actor {.discardable.} =
  spawn("postgre", turn) do (turn: Turn):
    during(turn, root, ?:PostgreArguments) do (params: StringPairs, ds: Cap):
      var
        conn: PGconn
@ -120,29 +103,21 @@ proc spawnPostgreActor*(turn: Turn; root: Cap): Actor {.discardable.} =
      statusHandle = publish(turn, ds,
          initRecord("status", toSymbol($status), msg.toPreserves))
      if status == CONNECTION_OK:
-        during(turn, ds, ?:Query) do (statement: seq[Value], target: Cap):
+        during(turn, ds, ?:Query) do (statement: string, target: Cap):
-          var text = renderSql statement
+          var res = PQexec(conn, statement)
-          if text == "":
+          var st = PQresultStatus(res)
-            discard publish(turn, ds, SqlError(msg: "invalid statement", context: $statement))
+          discard publish(turn, ds, toRecord(
-          else:
+            "error", statement, toSymbol($PQresStatus(st)), $PQresultErrorMessage(res)))
-            var
+          if st == PGRES_TUPLES_OK or st == PGRES_SINGLE_TUPLE:
-              res = PQexec(conn, text)
+            let tuples = PQntuples(res)
-              st = PQresultStatus(res)
+            let fields = PQnfields(res)
-            if st == PGRES_TUPLES_OK or st == PGRES_SINGLE_TUPLE:
+            if tuples > 0 and fields > 0:
-              let tuples = PQntuples(res)
+              for r in 0..<tuples:
-              let fields = PQnfields(res)
+                var tupl = initSequence(fields)
-              if tuples > 0 and fields > 0:
+                for f in 0..<fields:
-                for r in 0..<tuples:
+                  tupl[f] = toPreserves($PQgetvalue(res, r, f))
-                  var tupl = initSequence(fields)
+                discard publish(turn, target, tupl)
-                  for f in 0..<fields:
+          PQclear(res)
                    tupl[f] = toPreserves($PQgetvalue(res, r, f))
                  discard publish(turn, target, tupl)
            else:
              discard publish(turn, ds, SqlError(
                  msg: $PQresStatus(st),
                  context: $PQresultErrorMessage(res),
                ))
            PQclear(res)
      else:
        stderr.writeLine "refusing to do anything when status is ", status
    do:
@ -151,8 +126,6 @@ proc spawnPostgreActor*(turn: Turn; root: Cap): Actor {.discardable.} =
      PQfinish(conn)
 when isMainModule:
-  import syndicate/relays
+  runActor("main") do (turn: var Turn; root: Cap):
-
+    connectStdio(turn, root)
-  runActor("main") do (turn: Turn):
+    spawnPostgreActor(turn, root)
    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
      spawnPostgreActor(turn, ds)
--- a/src/syndesizer/pulses.nim
+++ b/src/syndesizer/pulses.nim
@ -2,8 +2,9 @@
 # SPDX-License-Identifier: Unlicense
 import std/[options, tables, times]
-import preserves, preserves/sugar
+import preserves, syndicate,
-import syndicate, syndicate/drivers/timers
+  syndicate/relays,
  syndicate/actors/timers
 import ../schema/[assertions, config]
@ -17,7 +18,7 @@ type PulseEntity {.final.} = ref object of Entity
  observePattern: Pattern
  observing: bool
-proc schedule(turn: Turn; pulse: PulseEntity) =
+proc schedule(turn: var Turn; pulse: PulseEntity) =
  ## Schedule the next pulse.
  ## The next pulse will be schedule using the current time as
  ## reference point and not the moment of the previous pulse.
@ -27,7 +28,7 @@ proc schedule(turn: Turn; pulse: PulseEntity) =
      observer: pulse.self,
    ))
-method publish(pulse: PulseEntity; turn: Turn; ass: AssertionRef; h: Handle) =
+method publish(pulse: PulseEntity; turn: var Turn; ass: AssertionRef; h: Handle) =
  ## Publish observers in reponse to <later-than …> assertions.
  pulse.timers.target.retract(turn, pulse.timerHandle)
  schedule(turn, pulse)
@ -36,7 +37,7 @@ method publish(pulse: PulseEntity; turn: Turn; ass: AssertionRef; h: Handle) =
    pulse.target.publish(turn, a, h)
  pulse.target.sync(turn, pulse.self)
-method message(pulse: PulseEntity; turn: Turn; v: AssertionRef) =
+method message(pulse: PulseEntity; turn: var Turn; v: AssertionRef) =
  ## Retract observers in response to a sync message.
  pulse.observing = false
  for h in pulse.observers.keys:
@ -46,7 +47,7 @@ type ProxyEntity {.final.} = ref object of Entity
  ## A proxy `Entity` that diverts observers to a `PulseEntity`.
  pulse: PulseEntity
-method publish(proxy: ProxyEntity; turn: Turn; ass: AssertionRef; h: Handle) =
+method publish(proxy: ProxyEntity; turn: var Turn; ass: AssertionRef; h: Handle) =
  ## Proxy assertions that are not observations.
  if proxy.pulse.observePattern.matches ass.value:
    if proxy.pulse.observers.len == 0:
@ -55,7 +56,7 @@ method publish(proxy: ProxyEntity; turn: Turn; ass: AssertionRef; h: Handle) =
  else:
    proxy.pulse.target.publish(turn, ass, h)
-method retract(proxy: ProxyEntity; turn: Turn; h: Handle) =
+method retract(proxy: ProxyEntity; turn: var Turn; h: Handle) =
  ## Retract proxied assertions.
  var obs: AssertionRef
  if proxy.pulse.observers.pop(h, obs):
@ -66,15 +67,15 @@ method retract(proxy: ProxyEntity; turn: Turn; h: Handle) =
  else:
    proxy.pulse.target.retract(turn, h)
-method message(proxy: ProxyEntity; turn: Turn; v: AssertionRef) =
+method message(proxy: ProxyEntity; turn: var Turn; v: AssertionRef) =
  ## Proxy mesages.
  proxy.pulse.target.message(turn, v)
-method sync(proxy: ProxyEntity; turn: Turn; peer: Cap) =
+method sync(proxy: ProxyEntity; turn: var Turn; peer: Cap) =
  ## Proxy sync.
  proxy.pulse.target.sync(turn, peer)
-proc newProxyEntity(turn: Turn; timers, ds: Cap; period: float): ProxyEntity =
+proc newProxyEntity(turn: var Turn; timers, ds: Cap; period: float): ProxyEntity =
  new result
  result.pulse = PulseEntity(
      target: ds.target,
@ -84,11 +85,11 @@ proc newProxyEntity(turn: Turn; timers, ds: Cap; period: float): ProxyEntity =
    )
  result.pulse.self = newCap(turn, result.pulse)
-proc spawnPulseActor*(turn: Turn; root: Cap): Actor =
+proc spawnPulseActor*(turn: var Turn; root: Cap): Actor =
  ## Spawn an actor that retracts and re-asserts observers on
  ## a timed pulse. Requires a timer service on the `root` capability.
-  spawnActor(turn, "pulse") do (turn: Turn):
+  spawn("pulse", turn) do (turn: var Turn):
-    let grabPeriod = observePattern(!Pulse, { @[%0]: grab() })
+    let grabPeriod = ?Observe(pattern: !Pulse) ?? { 0: grab() }
    during(turn, root, ?:PulseArguments) do (ds: Cap):
      during(turn, ds, grabPeriod) do (lit: Literal[float]):
        if lit.value < 0.000_1:
@ -99,7 +100,7 @@ proc spawnPulseActor*(turn: Turn; root: Cap): Actor =
         discard publish(turn, ds, pulse)
 when isMainModule:
-  import syndicate/relays
+  runActor("main") do (turn: var Turn; root: Cap):
-  runActor("main") do (turn: Turn):
+    spawnTimers(turn, root)
-    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+    connectStdio(turn, root)
-      discard spawnPulseActor(turn, ds)
+    discard spawnPulseActor(turn, root)
--- a/src/syndesizer/sqlite_actor.nim
+++ b/src/syndesizer/sqlite_actor.nim
@ -1,8 +1,8 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
-import preserves, syndicate
+import preserves, syndicate, syndicate/relays
-import ./schema/[config, sql]
+import ../schema/[config, sql]
 # Avoid Sqlite3 from the standard library because it is
 # only held together by wishful thinking and dlload.
@ -54,19 +54,8 @@ proc finalize(stmt: Stmt): cint {.importSqlite3.}
 doAssert libversion_number() == SQLITE_VERSION_NUMBER
-proc assertError(facet: Facet; cap: Cap; db: Sqlite3; context: string) =
+proc logError(db: Sqlite3; context: string) =
-  run(facet) do (turn: Turn):
+  writeLine(stderr, errmsg(db), ": ", context)
    publish(turn, cap, SqlError(
      msg: $errmsg(db),
      context: context,
    ))
 proc assertError(facet: Facet; cap: Cap; msg, context: string) =
  run(facet) do (turn: Turn):
    publish(turn, cap, SqlError(
      msg: msg,
      context: context,
    ))
 proc extractValue(stmt: Stmt; col: cint): Value =
  case column_type(stmt, col)
@ -89,61 +78,36 @@ proc extractTuple(stmt: Stmt; arity: cint): Value =
  result = initSequence(arity)
  for col in 0..<arity: result[col] = extractValue(stmt, col)
-proc renderSql(tokens: openarray[Value]): string =
+proc spawnSqliteActor*(turn: var Turn; root: Cap): Actor {.discardable.} =
-  for token in tokens:
+  spawn("sqlite-actor", turn) do (turn: var Turn):
    if result.len > 0: result.add ' '
    case token.kind
    of pkSymbol:
      result.add token.symbol.string
    of pkString:
      result.add '\''
      result.add token.string
      result.add '\''
    of pkFloat, pkRegister, pkBigInt:
      result.add $token
    of pkBoolean:
      if token.bool: result.add '1'
      else: result.add '0'
    else:
      return ""
 proc spawnSqliteActor*(turn: Turn; root: Cap): Actor {.discardable.} =
  spawn("sqlite-actor", turn) do (turn: Turn):
    during(turn, root, ?:SqliteArguments) do (path: string, ds: Cap):
-      linkActor(turn, path) do (turn: Turn):
+      stderr.writeLine("opening SQLite database ", path)
-        let facet = turn.facet
+      var db: Sqlite3
-        stderr.writeLine("opening SQLite database ", path)
+      if open_v2(path, addr db, SQLITE_OPEN_READONLY, nil) != SQLITE_OK:
-        var db: Sqlite3
+        logError(db, path)
-        if open_v2(path, addr db, SQLITE_OPEN_READONLY, nil) != SQLITE_OK:
+      else:
-          assertError(facet, ds, db, path)
+        during(turn, ds, ?:Query) do (statement: string, target: Cap):
-        else:
+          var stmt: Stmt
-          turn.onStop do (turn: Turn):
+          if prepare_v2(db, statement, statement.len.cint, addr stmt, nil) != SQLITE_OK:
-            close(db)
+            logError(db, statement)
-            stderr.writeLine("closed SQLite database ", path)
+          else:
-          during(turn, ds, ?:Query) do (statement: seq[Value], target: Cap):
+            try:
-            var
+              let arity = column_count(stmt)
-              stmt: Stmt
+              var res = step(stmt)
-              text = renderSql statement
+              while res == SQLITE_ROW:
-            if text == "":
+                var rec = extractTuple(stmt, arity)
-              assertError(facet, target, "invalid statement", $statement)
+                discard publish(turn, target, rec)
-            elif prepare_v2(db, text, text.len.cint, addr stmt, nil) != SQLITE_OK:
+                res = step(stmt)
-              assertError(facet, target, db, text)
+              assert res != 100
-            else:
+              if res != SQLITE_DONE:
-              try:
+                logError(db, statement)
-                let arity = column_count(stmt)
+            finally:
-                var res = step(stmt)
+              if finalize(stmt) != SQLITE_OK: logError(db, statement)
-                while res == SQLITE_ROW:
+    do:
-                  var rec = extractTuple(stmt, arity)
+      close(db)
-                  discard publish(turn, target, rec)
+      stderr.writeLine("closed SQLite database ", path)
                  res = step(stmt)
                assert res != 100
                if res != SQLITE_DONE:
                  assertError(facet, target, db, text)
              finally:
                if finalize(stmt) != SQLITE_OK: assertError(facet, target, db, text)
 when isMainModule:
-  import syndicate/relays
+  runActor("main") do (turn: var Turn; root: Cap):
-  runActor("main") do (turn: Turn):
+    connectStdio(turn, root)
-    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+    spawnSqliteActor(turn, root)
      spawnSqliteActor(turn, ds)
--- a/src/syndesizer/webhooks.nim
+++ b/src/syndesizer/webhooks.nim
@ -0,0 +1,105 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
 ## An actor for relaying Webhooks.
 import std/[asyncdispatch, asynchttpserver, net, strutils, tables, uri]
 import preserves, preserves/jsonhooks
 import syndicate, syndicate/[bags, relays]
 import syndicate/protocols/http
 import ../schema/config
 type
  CapBag = Bag[Cap]
  Endpoints = Table[seq[string], Cap]
 func splitPath(s: string): seq[string] = s.strip(chars={'/'}).split('/')
 proc toRecord(req: Request; seqnum: BiggestInt; path: seq[string]): Value =
  ## Convert a request value from the std/asynchttpserver module
  ## to a request type from syndicate/protocols/http.
  var record: HttpRequest
  record.sequenceNumber = seqnum
  record.host = req.hostname
  record.`method` = Symbol($req.reqMethod)
  record.path = path
  for key, val in req.headers.pairs:
    record.headers[Symbol key] = val
  for key, val in decodeQuery(req.url.query):
    record.query[Symbol key] =
      @[QueryValue(orKind: QueryValueKind.string, string: val)]
  let contentType = req.headers.getOrDefault("content-type")
  result = toPreserves record
  if req.body.len > 0:
    result[7] =
      case contentType.toString
      of "application/json":
        req.body.parsePreserves
      of "application/octet-stream":
        cast[seq[byte]](req.body).toPreserves
      else:
        req.body.toPreserves
 proc spawnWebhookActor*(turn: var Turn; root: Cap): Actor =
  spawn("webhooks", turn) do (turn: var Turn):
    let pat = grabRecord("webhooks", grabDictionary({ "listen": ?:config.Tcp }))
      # Grab the details on listening for requests.
      # Disregard endpoints so the server doesn't restart as those change.
    during(turn, root, pat) do (host: string; port: Port):
      let endpointsPat = grabRecord("webhooks", grabDictionary({
          "listen": ?config.Tcp(host: host, port: BiggestInt port),
          "endpoints": grab(),
        }))
          # construct a pattern for grabbing endpoints when the server is ready
      var seqNum: BiggestInt
      let facet = turn.facet
      let endpoints = newTable[seq[string], CapBag]()
        # use a bag so the same capability registered multiple
        # times with the same path does not get duplicate messages
      proc cb(req: Request): Future[void] =
        inc(seqNum)
        let path = req.url.path.splitPath
        if not endpoints.hasKey path:
          result = respond(req, Http404,
              "no capabilities registered at $1\n" % [req.url.path])
        else:
          result = respond(req, Http200, "")
          proc act(turn: var Turn) {.gcsafe.} =
            let rec = req.toRecord(seqNum, path)
            for cap in endpoints[path]:
              message(turn, cap, rec)
          run(facet, act)
      let server = newAsyncHttpServer()
      stderr.writeLine("listening for webhooks at ", host, ":", port)
      if host.isIpAddress:
        var ip = parseIpAddress host
        case ip.family
        of IPv6:
          asyncCheck(turn, server.serve(port, cb, host, domain = AF_INET6))
        of IPv4:
          asyncCheck(turn, server.serve(port, cb, host, domain = AF_INET))
      else:
        asyncCheck(turn, server.serve(port, cb, host, domain = AF_INET6))
        asyncCheck(turn, server.serve(port, cb, host, domain = AF_INET))
      during(turn, root, endpointsPat) do (eps: Endpoints):
        for path, cap in eps:
          if not endpoints.hasKey path:
            endpoints[path] = CapBag()
          discard endpoints[path].change(cap, +1)
      do:
        for path, cap in eps:
          discard endpoints[path].change(cap, -1)
    do:
      stderr.writeLine("closing for webhook server at ", host, ":", port)
      close(server)
 when isMainModule:
  runActor("webhooks") do (turn: var Turn; root: Cap):
    connectStdio(turn, root)
    discard spawnWebhookActor(turn, root)
--- a/src/syndesizer/websockets.nim
+++ b/src/syndesizer/websockets.nim
@ -0,0 +1,55 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
 import std/[asyncdispatch, json]
 import preserves
 import syndicate, syndicate/relays
 import ws
 import ../schema/config, ../json_messages
 type WebSocket = ws.WebSocket
  # not the object from the transportAddress schema
 proc spawnWebsocketActor*(turn: var Turn; root: Cap): Actor =
  spawn("websocket-actor", turn) do (turn: var Turn):
    during(turn, root, ?:WebsocketArguments) do (ds: Cap, url: string):
      let facet = turn.facet
      var
        ws: WebSocket
        connectedHandle: Handle
      newWebSocket(url).addCallback(turn) do (turn: var Turn; sock: WebSocket):
        ws = sock
        connectedHandle = publish(turn, ds, initRecord("connected", url.toPreserves))
        var fut: Future[(Opcode, string)]
        proc recvMessage() {.gcsafe.} =
          fut = receivePacket ws
          addCallback(fut, facet) do (turn: var Turn):
            let (opcode, data) = read fut
            case opcode
            of Text:
              message(turn, ds,
                  RecvJson(data: data.parseJson))
            of Binary:
              message(turn, ds,
                  initRecord("recv", cast[seq[byte]](data).toPreserves))
            of Ping:
              asyncCheck(turn, ws.send(data, Pong))
            of Pong, Cont:
              discard
            of Close:
              retract(turn, connectedHandle)
              stderr.writeLine "closed connection with ", url
              stop(turn)
              return
            recvMessage()
        recvMessage()
        onMessage(turn, ds, ?:SendJson) do (data: JsonNode):
          asyncCheck(turn, ws.send($data, Text))
    do:
      close(ws)
 when isMainModule:
  runActor("main") do (turn: var Turn; root: Cap):
    connectStdio(turn, root)
    discard spawnWebsocketActor(turn, root)
--- a/src/syndesizer/xml_translator.nim
+++ b/src/syndesizer/xml_translator.nim
@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Unlicense
 import std/[options, parsexml, xmlparser, xmltree]
-import preserves, preserves/sugar, preserves/xmlhooks
+import preserves, preserves/xmlhooks
 import syndicate
 import ../schema/[assertions, config]
@ -17,18 +17,17 @@ proc translatePreserves(pr: Value): XmlTranslation {.gcsafe.} =
  var xn = result.pr.preservesTo(XmlNode)
  if xn.isSome: result.xml = $get(xn)
-proc spawnXmlTranslator*(turn: Turn; root: Cap): Actor {.discardable.} =
+proc spawnXmlTranslator*(turn: var Turn; root: Cap): Actor {.discardable.} =
-  spawnActor(turn, "xml-translator") do (turn: Turn):
+  spawn("xml-translator", turn) do (turn: var Turn):
    during(turn, root, ?:XmlTranslatorArguments) do (ds: Cap):
-      let xmlPat = observePattern(!XmlTranslation, {@[%0]:grab()})
+      let obsPat = ?Observe(pattern: !XmlTranslation)
-      during(turn, ds, xmlPat) do (xs: Literal[string]):
+      during(turn, ds, obsPat ?? {0: grab()}) do (xs: Literal[string]):
        publish(turn, ds, translateXml(xs.value))
-      let prPat = observePattern(!XmlTranslation, {@[%1]:grab()})
+      during(turn, ds, obsPat ?? {1: grab()}) do (pr: Literal[Value]):
      during(turn, ds, prPat) do (pr: Literal[Value]):
        publish(turn, ds, translatePreserves(pr.value))
 when isMainModule:
  import syndicate/relays
-  runActor("main") do (turn: Turn):
+  runActor("main") do (turn: var Turn; root: Cap):
-    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+    connectStdio(turn, root)
-      spawnXmlTranslator(turn, ds)
+    spawnXmlTranslator(turn, root)
--- a/src/syndesizer/xslt_actor.nim
+++ b/src/syndesizer/xslt_actor.nim
@ -2,8 +2,8 @@
 # SPDX-License-Identifier: Unlicense
 import std/[os, strutils]
-import preserves, preserves/sugar, syndicate
+import preserves, syndicate
-import ./schema/[assertions, config]
+import ../schema/[assertions, config]
 {.passC: staticExec("pkg-config --cflags libxslt").}
 {.passL: staticExec("pkg-config --libs libxslt").}
@ -173,11 +173,11 @@ proc toPreservesHook*(xn: xmlNodePtr): Value =
  preserveSiblings(items, xn)
  items[0]
-proc spawnXsltActor*(turn: Turn; root: Cap): Actor {.discardable.} =
+proc spawnXsltActor*(turn: var Turn; root: Cap): Actor {.discardable.} =
-  spawnActor(turn, "xslt") do (turn: Turn):
+  spawn("xslt", turn) do (turn: var Turn):
    initLibXml()
    during(turn, root, ?:XsltArguments) do (ds: Cap):
-      let sheetsPat = observePattern(!XsltTransform, {@[%0]: grab(), @[%1]: grab()})
+      let sheetsPat = ?Observe(pattern: !XsltTransform) ?? {0: grab(), 1: grab()}
      during(turn, ds, sheetsPat) do (stylesheet: Literal[string], input: Literal[string]):
        let cur = loadStylesheet(stylesheet.value)
        if cur.isNil:
@ -206,6 +206,6 @@ proc spawnXsltActor*(turn: Turn; root: Cap): Actor {.discardable.} =
 when isMainModule:
  import syndicate/relays
-  runActor("main") do (turn: Turn):
+  runActor("main") do (turn: var Turn; root: Cap):
-    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+    connectStdio(turn, root)
-      spawnXsltActor(turn, ds)
+    spawnXsltActor(turn, root)
--- a/src/syndex_card.nim
+++ b/src/syndex_card.nim
@ -0,0 +1,133 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
 ## This was all Tony's idea, except for the silly name.
 import std/[asyncdispatch, os, terminal]
 import preserves
 import syndicate, syndicate/[durings, relays]
 import illwill
 proc exitProc() {.noconv.} =
  illwillDeinit()
  showCursor()
  quit QuitSuccess
 setControlCHook(exitProc)
 proc parsePattern(pr: Value): Pattern =
  let
    dropSigil = initRecord("lit", "_".toSymbol)
    grabSigil = initRecord("lit", "?".toSymbol)
  var pr = grab(pr).toPreserves
  apply(pr) do (pr: var Value):
    if pr == dropSigil:
      pr = initRecord("_")
    elif pr == grabSigil:
      pr = initRecord("bind", initRecord("_"))
  doAssert result.fromPreserves(pr)
 proc inputPattern: Pattern =
  var args = commandLineParams()
  if args.len != 1:
    quit "expected a single pattern argument"
  else:
    var input = pop args
    if input == "":
      quit "expected Preserves Pattern on stdin"
    else:
      var pr: Value
      try: pr = decodePreserves(input)
      except ValueError: discard
      try: pr = parsePreserves(input)
      except ValueError: discard
      if pr.isFalse:
        quit "failed to parse Preserves argument"
      result = parsePattern(pr)
 type TermEntity {.final.} = ref object of Entity
  pattern: Pattern
  value: Value
 method publish(te: TermEntity; turn: var Turn; v: AssertionRef; h: Handle) =
  te.value = v.value
  var termBuf = newTerminalBuffer(terminalWidth(), terminalHeight())
  var y = 1
  termBuf.write(1, y, $te.pattern, styleBright)
  inc(y)
  termBuf.drawHorizLine(0, termBuf.width(), y)
  inc(y)
  termBuf.write(0, y, $h, styleBright)
  for i, e in te.value.sequence:
    inc(y)
    termBuf.write(1, y, $e)
  termBuf.display()
 method retract(te: TermEntity; turn: var Turn; h: Handle) =
  var termBuf = newTerminalBuffer(terminalWidth(), terminalHeight())
  var y = 1
  termBuf.write(1, y, $te.pattern, styleDim)
  inc y
  termBuf.drawHorizLine(0, termBuf.width(), y, true)
  inc(y)
  termBuf.write(0, y, $h, styleBright)
  if te.value.isSequence:
    for i, e in te.value.sequence:
      inc(y)
      termBuf.write(1, y, $e)
  else:
    inc(y)
    termBuf.write(1, y, $te.value)
  termBuf.display()
 type DumpEntity {.final.} = ref object of Entity
  discard
 method publish(dump: DumpEntity; turn: var Turn; ass: AssertionRef; h: Handle) =
  stdout.writeLine($ass.value)
  stdout.flushFile()
 method message*(dump: DumpEntity; turn: var Turn; ass: AssertionRef) =
  stdout.writeLine($ass.value)
  stdout.flushFile()
 proc exit {.noconv.} =
  illwillDeinit()
  showCursor()
  quit()
 setControlCHook(exit)
 proc main =
  let
    route = envRoute()
    pat = inputPattern()
  if stdout.is_a_TTY:
    illwillInit()
    hideCursor()
    discard bootDataspace("syndex_card") do (turn: var Turn; root: Cap):
      resolve(turn, root, route) do (turn: var Turn; ds: Cap):
        var termBuf = newTerminalBuffer(terminalWidth(), terminalHeight())
        termBuf.write(1, 1, $pat, styleBright)
        termBuf.drawHorizLine(1, termBuf.width(), 2)
        termBuf.display()
        discard observe(turn, ds, pat, TermEntity(pattern: pat))
    while true:
      try: poll()
      except CatchableError:
        illwillDeinit()
        showCursor()
        quit getCurrentExceptionMsg()
  else:
    let entity = DumpEntity()
    runActor("syndex_card") do (root: Cap; turn: var Turn):
      spawnRelays(turn, root)
      resolve(turn, root, route) do (turn: var Turn; ds: Cap):
        discard observe(turn, ds, pat, entity)
 main()
--- a/src/syndump.nim
+++ b/src/syndump.nim
@ -8,7 +8,7 @@ proc parsePattern(pr: Value): Pattern =
  let
    dropSigil = initRecord("lit", "_".toSymbol)
    grabSigil = initRecord("lit", "?".toSymbol)
-  var pr = drop(pr).toPreserves
+  var pr = grab(pr).toPreserves
  apply(pr) do (pr: var Value):
    if pr == dropSigil:
      pr = initRecord("_")
@ -36,19 +36,19 @@ proc toLine(values: seq[Value]; prefix: char): string =
    add(result, $v)
  add(result, '\n')
-method publish(dump: DumpEntity; turn: Turn; ass: AssertionRef; h: Handle) =
+method publish(dump: DumpEntity; turn: var Turn; ass: AssertionRef; h: Handle) =
  var values = ass.value.sequence
  stdout.write(values.toLine('+'))
  stdout.flushFile()
  dump.assertions[h] = values
-method retract(dump: DumpEntity; turn: Turn; h: Handle) =
+method retract(dump: DumpEntity; turn: var Turn; h: Handle) =
  var values: seq[Value]
  if dump.assertions.pop(h, values):
    stdout.write(values.toLine('-'))
    stdout.flushFile()
-method message*(dump: DumpEntity; turn: Turn; ass: AssertionRef) =
+method message*(dump: DumpEntity; turn: var Turn; ass: AssertionRef) =
  stdout.write(ass.value.sequence.toLine('!'))
  stdout.flushFile()
@ -58,10 +58,14 @@ proc exitProc() {.noconv.} =
 proc main =
  let
    route = envRoute()
    patterns = inputPatterns()
    entity = DumpEntity()
-  runActor("syndex_card") do (turn: Turn):
+  runActor("syndex_card") do (root: Cap; turn: var Turn):
-    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+    for pat in patterns:
      discard observe(turn, root, pat, entity)
    spawnRelays(turn, root)
    resolve(turn, root, route) do (turn: var Turn; ds: Cap):
      for pat in patterns:
        discard observe(turn, ds, pat, entity)
--- a/syndicate_utils.nimble
+++ b/syndicate_utils.nimble
@ -1,61 +1,13 @@
-# Emulate Nimble from CycloneDX data at sbom.json.
+# Package
-import std/json
+version = "20240209"
 author        = "Emery Hemingway"
 description   = "Utilites for Syndicated Actors and Synit"
 license       = "unlicense"
 srcDir        = "src"
 bin           = @["mintsturdyref", "mount_actor", "msg", "net_mapper", "preserve_process_environment", "syndesizer", "syndex_card", "syndump"]
 proc lookupComponent(sbom: JsonNode; bomRef: string): JsonNode =
  for c in sbom{"components"}.getElems.items:
    if c{"bom-ref"}.getStr == bomRef:
      return c
  result = newJNull()
-let
+# Dependencies
  sbom = "sbom.json".readFile.parseJson
  comp = sbom{"metadata", "component"}
  bomRef = comp{"bom-ref"}.getStr
-version = comp{"version"}.getStr
+requires "nim >= 2.0.0", "illwill", "syndicate >= 20240208", "ws"
 author = comp{"authors"}[0]{"name"}.getStr
 description = comp{"description"}.getStr
 license = comp{"licenses"}[0]{"license", "id"}.getStr
 for prop in comp{"properties"}.getElems.items:
  let (key, val) = (prop{"name"}.getStr, prop{"value"}.getStr)
  case key
  of "nim:skipDirs:":
    add(skipDirs, val)
  of "nim:skipFiles:":
    add(skipFiles, val)
  of "nim:skipExt":
    add(skipExt, val)
  of "nim:installDirs":
    add(installDirs, val)
  of "nim:installFiles":
    add(installFiles, val)
  of "nim:installExt":
    add(installExt, val)
  of "nim:binDir":
    add(binDir, val)
  of "nim:srcDir":
    add(srcDir, val)
  of "nim:backend":
    add(backend, val)
  else:
    if key.startsWith "nim:bin:":
      namedBin[key[9..key.high]] = val
 for depend in sbom{"dependencies"}.items:
  if depend{"ref"}.getStr == bomRef:
    for depRef in depend{"dependsOn"}.items:
      let dep = sbom.lookupComponent(depRef.getStr)
      var spec = dep{"name"}.getStr
      for extRef in dep{"externalReferences"}.elems:
        if extRef{"type"}.getStr == "vcs":
          spec = extRef{"url"}.getStr
          break
      let ver = dep{"version"}.getStr
      if ver != "":
        if ver.allCharsInSet {'0'..'9', '.'}: spec.add " == "
        else: spec.add '#'
        spec.add ver
      requires spec
    break
--- a/tests/input.xml
+++ b/tests/input.xml
@ -0,0 +1,11 @@
 <?xml version="1.0"?>
 <persons>
  <person username="JS1">
    <name>John</name>
    <family-name>Smith</family-name>
  </person>
  <person username="MI1">
    <name>Morka</name>
    <family-name>Ismincius</family-name>
  </person>
 </persons>
--- a/tests/stylesheet.xslt
+++ b/tests/stylesheet.xslt
@ -0,0 +1,26 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns="http://www.w3.org/1999/xhtml" version="1.0">
  <xsl:output method="xml" indent="yes" encoding="UTF-8"/>
  <xsl:template match="/persons">
    <html>
      <head>
        <title>Testing XML Example</title>
      </head>
      <body>
        <h1>Persons</h1>
        <ul>
          <xsl:apply-templates select="person">
            <xsl:sort select="family-name"/>
          </xsl:apply-templates>
        </ul>
      </body>
    </html>
  </xsl:template>
  <xsl:template match="person">
    <li>
      <xsl:value-of select="family-name"/>
      <xsl:text>, </xsl:text>
      <xsl:value-of select="name"/>
    </li>
  </xsl:template>
 </xsl:stylesheet>
--- a/tests/xslt.pr
+++ b/tests/xslt.pr
@ -0,0 +1,62 @@
 <require-service <daemon xslt_actor>>
 ? <built xslt_actor ?path ?sum> [
  <daemon xslt_actor {
    argv: [$path]
    protocol: application/syndicate
    env: { BUILD_SUM: $sum }
  }>
 ]
 let ?ds = dataspace
 ? <service-object <daemon xslt_actor> ?cap> $cap [
  <xslt { dataspace: $ds }>
 ]
 let ?stylesheet = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>
 <xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\" xmlns=\"http://www.w3.org/1999/xhtml\" version=\"1.0\">
  <xsl:output method=\"xml\" indent=\"yes\" encoding=\"UTF-8\"/>
  <xsl:template match=\"/persons\">
    <html>
      <head>
        <title>Testing XML Example</title>
      </head>
      <body>
        <h1>Persons</h1>
        <ul>
          <xsl:apply-templates select=\"person\">
            <xsl:sort select=\"family-name\"/>
          </xsl:apply-templates>
        </ul>
      </body>
    </html>
  </xsl:template>
  <xsl:template match=\"person\">
    <li>
      <xsl:value-of select=\"family-name\"/>
      <xsl:text>, </xsl:text>
      <xsl:value-of select=\"name\"/>
    </li>
  </xsl:template>
 </xsl:stylesheet>
 "
 let ?input = "<?xml version=\"1.0\"?>
 <persons>
  <person username=\"JS1\">
    <name>John</name>
    <family-name>Smith</family-name>
  </person>
  <person username=\"MI1\">
    <name>Morka</name>
    <family-name>Minicus</family-name>
  </person>
 </persons>
 "
 $ds [
  ? <xslt-transform $stylesheet $input ?outputs> [
    $log ! <log "-" { xslt-outputs: $outputs }>
  ]
 ]
Author	SHA1	Message	Date
Emery Hemingway	c8e8197ff7	xslt: accept text or paths, generate Preserves data	2024-02-09 14:50:38 +00:00
Emery Hemingway	2c61d144d0	WiP! XSLT actor	2024-02-08 18:13:09 +00:00
`@ -1,2 +1,2 @@`
	`include_rules`	`include_rules`
	`: sbom.json \|> !sbom-to-nix \|> \| ./<lock>`	`: lock.json \|> !nim_cfg \|> \| ./<lock>`
		`@ -1,2 +0,0 @@`
			`define:ipv6Enabled`
			`include:"std/assertions"`