Add esc_printer_actor

This happened because the semantics of bind(Value) changed from a
drop to a bind.

.gitignore

@@ -1 +1,2 @@
 /nim.cfg
+*.check

README.md

@@ -1,8 +1,16 @@
 # Syndicate utils
 
-## cache_actor
+## Syndesizer
 
-An actor that observes patterns and reässerts the values they capture for a given lifetime. Takes the arguments `{ dataspace: #!any lifetime: double }`. The lifetime of a cache counts down from moment a value is asserted.
+A Syndicate multitool that includes a number of different actors that become active via configuration.
+
+Think of it as a Busybox for Syndicate, if Busybox was created before POSIX.
+
+Whether you use a single instance for many protocols or many specialized instances is up to you.
+
+### Cache
+
+Observes patterns and reässert the values captured for a given lifetime. Takes the argument `<cache { dataspace: #!any lifetime: float }>`. The lifetime of a cache counts down from moment a value is asserted.
 
 Example configuration:
 ```
@@ -15,20 +23,313 @@ Example configuration:
 
   ; Cache anything captured by observers in the $nixspace for an hour.
   ; The nix_actor is not required during caching.
-  $config ? <service-object <daemon cache_actor> ?cap> [
+  $config <require-service <daemon syndesizer>>
-    $cap { dataspace: $nixspace lifetime: 3600.0 } ]
+  $config ? <service-object <daemon syndesizer> ?cap> [
+    $cap <cache { dataspace: $nixspace lifetime: 3600.0 }> ]
 ]
 ```
 
-## json_translator
+### File System Usage
 
-Wrapper that executes a command, parses its JSON output, converts to Preserves record `<recv @jsonData any>`, and publishes and messages to its initial dataspace.
+Summarize the size of file-system directory. Equivalent to `du -s -b`.
+Query the size of a directory in bytes by observing `<file-system-usage "/SOME/PATH" ?size>`.
 
-## json_socket_translator
+```
+# Configuration example
 
-Utility to communicate with sockets that send and receive lines of JSON using `<send …>` and `<recv …>` messages. Compatible with [mpv](https://mpv.io/), see [mpv.config-example.pr](./mpv.config-example.pr).
+? <exposed-dataspace ?ds> [
 
-Do not send messages immediately to the dataspace passed `json_socket_translator`, wait until it asserts `<connected @socketPath string>`.
+  <require-service <daemon syndesizer>>
+  ? <service-object <daemon syndesizer> ?cap> [
+    $cap <file-system-usage { dataspace: $ds }>
+  ]
+
+]
+```
+
+### 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.
+
+Do not send messages into the dataspace configure with `<json-socket-translator …>` until `<connected @socketPath string>` is asserted.
+
+```
+# MPV configuration example
+<require-service <daemon mpv-server>>
+
+<daemon mpv-server {
+  argv: [
+    "/run/current-system/sw/bin/mpv"
+    "--really-quiet"
+    "--idle=yes"
+    "--no-audio-display"
+    "--input-ipc-server=/run/user/1000/mpv.sock"
+    "--volume=75"
+  ]
+  protocol: none
+}>
+
+let ?mpvSpace = dataspace
+
+? <service-state <daemon mpv-server> ready> [
+  <require-service <daemon syndesizer>>
+  ? <service-object <daemon syndesizer> ?cap> [
+    $cap <json-socket-translator {
+      dataspace: $mpvSpace
+      socket: <unix "/run/user/1000/mpv.sock">
+    }>
+  ]
+]
+
+$mpvSpace [
+
+  # announce the dataspace when the translator is connected
+  ? <connected $socketPath> [
+    $config <mpv $mpvSpace>
+    $config <bind <ref { oid: "mpv" key: #x"" }> $mpvSpace #f>
+  ]
+
+  # translate <play-file …> to an MPV command
+  ?? <play-file ?file> [
+    ! <send { "command": ["loadfile" $file "append-play"] }>
+  ]
+
+  # clear the playlist on idle so it doesn't grow indefinitely
+  ?? <recv {"event": "idle"}> [
+    ! <send { "command": ["playlist-clear"] }>
+  ]
+]
+```
+
+### JSON Stdio Translator
+
+Executes a command, parses its JSON output, converts to record `<recv @jsonData any>`, and publishes and messages it to a dataspace.
+
+```
+# Configuration example
+<require-service <daemon syndesizer>>
+
+let ?ds = dataspace
+<bind <ref {oid: "syndicate" key: #x""}> $ds #f>
+
+? <service-object <daemon syndesizer> ?cap> [
+  $cap <json-stdio-translator {
+    argv: [
+      "yt-dlp"
+      "--dump-json"
+      "https://youtu.be/RR9GkEXDvog"
+    ]
+    dataspace: $ds
+  }>
+]
+```
+
+### Pulse proxy
+
+A proxy actor that passes assertions and messages to a configured capability but only asserts observations on a a periodic pulse.
+This can be used to implement polling behavior.
+
+```
+# Example config
+let ?ds = dataspace
+
+<require-service <daemon syndesizer>>
+? <service-object <daemon syndesizer> ?cap> [
+  $cap <pulse {dataspace: $ds}>
+]
+
+$ds ? <pulse 3600.0 ?proxy> [
+  $proxy ? <assertion-updated-hourly ?value> [
+    $log ! <log "-" {assertion-updated-hourly: $value}>
+  ]
+]
+```
+
+### 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 syndesizer>>
+
+let ?sqlspace = dataspace
+
+? <service-object <daemon syndesizer> ?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> }>
+  ]
+  ? <sqlite-error ?msg ?ctx> [
+    $log ! <log "-" { msg: $msg ctx: $ctx }>
+  ]
+]
+```
+
+### XML translator
+
+Translates between Preserves and XML according to the [Conventions for Common Data Types](https://preserves.dev/conventions.html).
+
+Examples:
+- `<xml-translation "<foo a=\"1\"> <bar>hello world!</bar></foo>" <foo {"a": 1}<bar "hello world!">>>`
+- `<xml-translation "" [#t #f]>`
+- `<xml-translation "<<</>>" #f>`
+
+```
+# Configuration example
+? <sharedspace ?ds> [
+  $ds ? <Observe <rec xml-translation _> _> $config [
+    $config <require-service <daemon syndesizer>>
+    $config ? <service-object <daemon syndesizer> ?cap> [
+      $cap <xml-translator { dataspace: $ds }>
+    ]
+  ]
+]
+```
+
+---
+
+## 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
 
@@ -79,30 +380,38 @@ Sample Syndicate server script:
 
 ## msg
 
-A utility that sends messages to `$SYNDICATE_ROUTE`.
+A utility that parses its command-line arguments as Preserves and send them as messages to `$SYNDICATE_ROUTE`.
+When called as `assert` (by a symlink or a rename) it will make assertions instead.
 
+## PostgreSQL
 
-## net_mapper
+Readonly access to PostgreSQL databases. Asserts rows as records in response to SQL query assertions. Dynamic updates are not implemented.
 
-Publishes ICMP packet round-trip-times. See [net_mapper.prs](./net_mapper.prs) for a protocol description. [Source](./src/net_mapper.nim).
+Can be disabled by passing `--define:withPostgre=no` to the Nim compiler.
 
-Example script:
 ```
-? <machine-dataspace ?machine> [
+# Configuration example
-  $machine ? <rtt "10.0.33.136" ?min ?avg ?max> [
+<require-service <daemon postgre_actor>>
-    $log ! <log "-" { ping: { min: $min avg: $avg max: $max } }>
-  ]
 
-  $config [
+let ?sqlspace = dataspace
-    <require-service <daemon net_mapper>>
+
-    <daemon net_mapper {
+? <service-object <daemon postgre_actor> ?cap> [
-      argv: ["/bin/net_mapper"]
+  $cap <postgre {
-      protocol: application/syndicate
+     dataspace: $sqlspace
-    }>
+     connection: [
-    ? <service-object <daemon net_mapper> ?cap> [
+       ["host" "example.com"]
-      $cap { dataspace: $machine }
+       ["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> }>
 ]
 ```
 
@@ -111,6 +420,33 @@ Example script:
 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
 
@@ -121,3 +457,25 @@ 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 }>
+]
+```

Tupfile

@@ -1,2 +1,2 @@
 include_rules
-: lock.json |> !nim_cfg |> | ./<lock>
+: sbom.json |> !sbom-to-nix |> | ./<lock>

Tuprules.tup

@@ -1,3 +1,4 @@
 include ../syndicate-nim/depends.tup
+NIM = $(DIRENV) $(NIM)
 NIM_FLAGS += --path:$(TUP_CWD)/../syndicate-nim/src
 NIM_GROUPS += $(TUP_CWD)/<lock>

assertions.prs

@@ -0,0 +1,14 @@
+version 1.
+
+FileSystemUsage = <file-system-usage @path string @size int>.
+
+# This assertion publishes a dataspace that proxies assertions with
+# an exception for <Observe …> which is pulsed every periodSec.
+# The pulse resolution is no more than one millisecond.
+Pulse = <pulse @periodSec float @proxy #:any>.
+
+XmlTranslation = <xml-translation @xml string @pr any>.
+
+XsltTransform = <xslt-transform @stylesheet string @input string @output any>.
+XsltItems = [XsltItem ...].
+XsltItem = string.

base64.prs

@@ -0,0 +1,4 @@
+version 1.
+
+Base64Text = <base64 @txt string @bin bytes> .
+Base64File = <base64-file @txt string @path string @size int> .

config.prs

@@ -1,8 +1,76 @@
 version 1 .
+embeddedType EntityRef.Cap .
 
-JsonTranslatorConnected = <connected @path string>.
+Base64DecoderArguments = <base64-decoder {
+  dataspace: #:any
+}>.
 
-JsonSocketTranslatorArguments = {
+CacheArguments = <cache {
-  dataspace: #!any
+  dataspace: #:any
-  socket: string
+  lifetime: float
-}.
+}>.
+
+FileSystemUsageArguments = <file-system-usage {
+  dataspace: #:any
+}>.
+
+JsonTranslatorArguments = <json-stdio-translator {
+  argv: [string ...]
+  dataspace: #:any
+}>.
+
+JsonTranslatorConnected = <connected @address SocketAddress>.
+
+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
+}>.
+
+PostgreArguments = <postgre {
+  connection: [PostgreConnectionParameter ...]
+  dataspace: #:any
+}>.
+PostgreConnectionParameter = [@key string @val string].
+
+PulseArguments = <pulse {
+  dataspace: #:any
+}>.
+
+SqliteArguments = <sqlite {
+  database: string
+  dataspace: #:any
+}>.
+
+WebhooksArguments = <webhooks {
+  endpoints: {[string ...]: #:any ...:...}
+  listen: Tcp
+}>.
+
+WebsocketArguments = <websocket {
+  dataspace: #:any
+  url: string
+}>.
+
+XmlTranslatorArguments = <xml-translator {
+  dataspace: #:any
+}>.
+
+XsltArguments = <xslt {
+  dataspace: #:any
+}>.
+
+# Reused from syndicate-protocols/transportAddress
+Tcp = <tcp @host string @port int>.

default.nix

@@ -0,0 +1,19 @@
+{
+  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
+    ];
+  }
+)

lock.json

@@ -1,75 +1,137 @@
 {
   "depends": [
     {
-      "method": "fetchzip",
+      "date": "2024-05-23T17:44:14+03:00",
+      "deepClone": false,
+      "fetchLFS": false,
+      "fetchSubmodules": true,
+      "hash": "sha256-qTRhHsOPNov1BQcm3P7NEkEPW6uh80XFfQRBdMp4o0Q=",
+      "leaveDotGit": false,
+      "method": "git",
       "packages": [
-        "hashlib"
+        "syndicate"
       ],
-      "path": "/nix/store/fav82xdbicvlk34nmcbl89zx99lr3mbs-source",
+      "path": "/nix/store/1lcxrap5n80hy1z4bcmsmdx83n4b9wjf-syndicate-nim",
-      "rev": "f9455d4be988e14e3dc7933eb7cc7d7c4820b7ac",
+      "rev": "7ab4611824b676157523f2618e7893d5ac99e4f2",
-      "sha256": "1sx6j952lj98629qfgr7ds5aipyw9d6lldcnnqs205wpj4pkcjb3",
+      "sha256": "0i53g3578h84gp2lbwx1mddhyh8jrpzdq9h70psqndlgqcg62d59",
-      "srcDir": "",
+      "srcDir": "src",
-      "url": "https://github.com/ehmry/hashlib/archive/f9455d4be988e14e3dc7933eb7cc7d7c4820b7ac.tar.gz"
+      "url": "https://git.syndicate-lang.org/ehmry/syndicate-nim.git"
     },
     {
       "method": "fetchzip",
       "packages": [
-        "illwill"
+        "bigints"
       ],
-      "path": "/nix/store/3lmm3z36qn4gz7bfa209zv0pqrpm3di9-source",
+      "path": "/nix/store/jvrm392g8adfsgf36prgwkbyd7vh5jsw-source",
-      "ref": "v0.3.2",
+      "rev": "86ea14d31eea9275e1408ca34e6bfe9c99989a96",
-      "rev": "1d12cb36ab7b76c31d2d25fa421013ecb382e625",
+      "sha256": "15pcpmnk1bnw3k8769rjzcpg00nahyrypwbxs88jnwr4aczp99j4",
-      "sha256": "0f9yncl5gbdja18mrqf5ixrdgrh95k0khda923dm1jd1x1b7ar8z",
+      "srcDir": "src",
+      "url": "https://github.com/ehmry/nim-bigints/archive/86ea14d31eea9275e1408ca34e6bfe9c99989a96.tar.gz"
+    },
+    {
+      "method": "fetchzip",
+      "packages": [
+        "cps"
+      ],
+      "path": "/nix/store/8gbhwni0akqskdb3qhn5nfgv6gkdz0vz-source",
+      "rev": "c90530ac57f98a842b7be969115c6ef08bdcc564",
+      "sha256": "0h8ghs2fqg68j3jdcg7grnxssmllmgg99kym2w0a3vlwca1zvr62",
       "srcDir": "",
-      "url": "https://github.com/johnnovak/illwill/archive/1d12cb36ab7b76c31d2d25fa421013ecb382e625.tar.gz"
+      "url": "https://github.com/ehmry/cps/archive/c90530ac57f98a842b7be969115c6ef08bdcc564.tar.gz"
+    },
+    {
+      "method": "fetchzip",
+      "packages": [
+        "getdns"
+      ],
+      "path": "/nix/store/x9xmn7w4k6jg8nv5bnx148ibhnsfh362-source",
+      "rev": "c73cbe288d9f9480586b8fa87f6d794ffb6a6ce6",
+      "sha256": "1sbgx2x51szr22i72n7c8jglnfmr8m7y7ga0v85d58fwadiv7g6b",
+      "srcDir": "src",
+      "url": "https://git.sr.ht/~ehmry/getdns-nim/archive/c73cbe288d9f9480586b8fa87f6d794ffb6a6ce6.tar.gz"
     },
     {
       "method": "fetchzip",
       "packages": [
         "nimcrypto"
       ],
-      "path": "/nix/store/zyr8zwh7vaiycn1s4r8cxwc71f2k5l0h-source",
+      "path": "/nix/store/fkrcpp8lzj2yi21na79xm63xk0ggnqsp-source",
-      "ref": "traditional-api",
+      "rev": "485f7b3cfa83c1beecc0e31be0e964d697aa74d7",
-      "rev": "602c5d20c69c76137201b5d41f788f72afb95aa8",
+      "sha256": "1h3dzdbc9kacwpi10mj73yjglvn7kbizj1x8qc9099ax091cj5xn",
-      "sha256": "1dmdmgb6b9m5f8dyxk781nnd61dsk3hdxqks7idk9ncnpj9fng65",
       "srcDir": "",
-      "url": "https://github.com/cheatfate/nimcrypto/archive/602c5d20c69c76137201b5d41f788f72afb95aa8.tar.gz"
+      "url": "https://github.com/cheatfate/nimcrypto/archive/485f7b3cfa83c1beecc0e31be0e964d697aa74d7.tar.gz"
     },
     {
       "method": "fetchzip",
       "packages": [
         "npeg"
       ],
-      "path": "/nix/store/ffkxmjmigfs7zhhiiqm0iw2c34smyciy-source",
+      "path": "/nix/store/xpn694ibgipj8xak3j4bky6b3k0vp7hh-source",
-      "ref": "1.2.1",
+      "rev": "ec0cc6e64ea4c62d2aa382b176a4838474238f8d",
-      "rev": "26d62fdc40feb84c6533956dc11d5ee9ea9b6c09",
+      "sha256": "1fi9ls3xl20bmv1ikillxywl96i9al6zmmxrbffx448gbrxs86kg",
-      "sha256": "0xpzifjkfp49w76qmaylan8q181bs45anmp46l4bwr3lkrr7bpwh",
       "srcDir": "src",
-      "url": "https://github.com/zevv/npeg/archive/26d62fdc40feb84c6533956dc11d5ee9ea9b6c09.tar.gz"
+      "url": "https://github.com/zevv/npeg/archive/ec0cc6e64ea4c62d2aa382b176a4838474238f8d.tar.gz"
     },
     {
       "method": "fetchzip",
       "packages": [
         "preserves"
       ],
-      "path": "/nix/store/fmb2yckksz7iv3qdkk5gk1j060kppkq9-source",
+      "path": "/nix/store/9zl4s2did00725n8ygbp37agvkskdhcx-source",
-      "ref": "20231102",
+      "rev": "1fee87590940761e288cf9ab3c7270832403b719",
-      "rev": "4faeb766dc3945bcfacaa1a836ef6ab29b20ceb0",
+      "sha256": "1ny42rwr3yx52zwvkdg4lh54nxaxrmxdj9dlw3qarvvp2grfq4j2",
-      "sha256": "1a3g5bk1l1h250q3p6sqv6r1lpsplp330qqyp48r0i4a5r0jksq3",
       "srcDir": "src",
-      "url": "https://git.syndicate-lang.org/ehmry/preserves-nim/archive/4faeb766dc3945bcfacaa1a836ef6ab29b20ceb0.tar.gz"
+      "url": "https://git.syndicate-lang.org/ehmry/preserves-nim/archive/1fee87590940761e288cf9ab3c7270832403b719.tar.gz"
     },
     {
       "method": "fetchzip",
       "packages": [
-        "syndicate"
+        "stew"
       ],
-      "path": "/nix/store/nhpvl223vbzdrlzikw7pgyfxs344w7ma-source",
+      "path": "/nix/store/mqg8qzsbcc8xqabq2yzvlhvcyqypk72c-source",
-      "ref": "20231108",
+      "rev": "3c91b8694e15137a81ec7db37c6c58194ec94a6a",
-      "rev": "095418032180e360ea27ec7fcd63193944b68e2c",
+      "sha256": "17lfhfxp5nxvld78xa83p258y80ks5jb4n53152cdr57xk86y07w",
-      "sha256": "09pbml2chzz0v5zpz67fs7raj0mfmg8qrih2vz85xxc51h7ncqvw",
+      "srcDir": "",
+      "url": "https://github.com/status-im/nim-stew/archive/3c91b8694e15137a81ec7db37c6c58194ec94a6a.tar.gz"
+    },
+    {
+      "method": "fetchzip",
+      "packages": [
+        "sys"
+      ],
+      "path": "/nix/store/syhxsjlsdqfap0hk4qp3s6kayk8cqknd-source",
+      "rev": "4ef3b624db86e331ba334e705c1aa235d55b05e1",
+      "sha256": "1q4qgw4an4mmmcbx48l6xk1jig1vc8p9cq9dbx39kpnb0890j32q",
       "srcDir": "src",
-      "url": "https://git.syndicate-lang.org/ehmry/syndicate-nim/archive/095418032180e360ea27ec7fcd63193944b68e2c.tar.gz"
+      "url": "https://github.com/ehmry/nim-sys/archive/4ef3b624db86e331ba334e705c1aa235d55b05e1.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"
     }
   ]
 }

mountpoints.prs

@@ -1,5 +1,5 @@
 version 1.
 
 Mountpoint = <mount @source string @target string @type string @status Status> .
-Status = Failure / #t.
+Status = Failure / @success #t .
 Failure = <failure @msg string> .

sbom.json

@@ -0,0 +1,641 @@
+{
+  "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"
+      ]
+    }
+  ]
+}

shell.nix

@@ -1,5 +0,0 @@
-{ pkgs ? import <nixpkgs> { } }:
-pkgs.buildNimPackage {
-  name = "dummy";
-  lockFile = ./lock.json;
-}

sql.prs

@@ -0,0 +1,8 @@
+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> .
+
+# When a query fails this is asserted instead.
+SqlError = <sql-error @msg string @context string>.

src/Tupfile

@@ -1,4 +1,5 @@
 include_rules
 : foreach *.nim | $(SYNDICATE_PROTOCOL) ./<schema> |> !nim_bin |> {bin}
 : foreach {bin} |> !assert_built |>
-: $(BIN_DIR)/msg |> cp %f %o |> $(BIN_DIR)/beep
+: $(BIN_DIR)/msg |> !symlink |> $(BIN_DIR)/beep
+: $(BIN_DIR)/msg |> !symlink |> $(BIN_DIR)/assert

src/cache_actor.nim

@@ -1,55 +0,0 @@
-# SPDX-FileCopyrightText: ☭ Emery Hemingway
-# SPDX-License-Identifier: Unlicense
-
-import std/times
-import preserves, syndicate,
-  syndicate/relays,
-  syndicate/durings,
-  syndicate/actors/timers
-
-type BootArgs {.preservesDictionary.} = object
-  dataspace: Cap
-  lifetime: float64
-
-proc afterTimeout(n: float64): LaterThan =
-  ## Get a `LaterThan` record for `n` seconds in the future.
-  result.seconds = getTime().toUnixFloat() + n
-
-type CacheEntity {.final.} = ref object of Entity
-  timeouts, target: Cap
-    # dataspaces for observing timeouts and publishing values
-  pattern: Pattern
-  lifetime: float64
-
-method publish(cache: CacheEntity; turn: var Turn; ass: AssertionRef; h: Handle) =
-  ## Re-assert pattern captures in a sub-facet.
-  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.
-    discard publish(turn, cache.target, ass)
-    let timeout = afterTimeout(cache.lifetime)
-    onPublish(turn, cache.timeouts, ?timeout) do:
-      stop(turn) # end this facet
-
-proc isObserve(pat: Pattern): bool =
-  pat.orKind == PatternKind.DCompound and
-    pat.dcompound.orKind == DCompoundKind.rec and
-      pat.dcompound.rec.label.isSymbol"Observe"
-
-runActor("cache_actor") do (turn: var Turn; root: Cap):
-  spawnTimers(turn, root)
-  connectStdio(turn, root)
-  during(turn, root, ?BootArgs) do (ds: Cap, lifetime: float64):
-    onPublish(turn, ds, ?Observe) do (pat: Pattern, obs: Cap):
-      var cache: CacheEntity
-      if obs.relay != turn.facet and not(pat.isObserve):
-        # Watch pattern if the observer is not us
-        # and if the pattern isn't a recursive observe
-        cache = CacheEntity(
-            timeouts: root,
-            target: ds,
-            pattern: pat,
-            lifetime: lifetime,
-          )
-        discard observe(turn, ds, pat, cache)

src/esc_printer_actor.nim

@@ -0,0 +1,84 @@
+# 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()

src/http_client.nim

@@ -0,0 +1,91 @@
+# 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)

src/http_client.nim.cfg

@@ -0,0 +1 @@
+define:ssl

src/inotify_actor.nim

@@ -1,117 +0,0 @@
-# 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]
-from syndicate/protocols/dataspace import Observe
-import ./schema/inotify_actor
-
-var IN_NONBLOCK {.importc, nodecl.}: cint
-
-type
-  Observe = dataspace.Observe[Cap]
-  # Registry = TableRef[cint, TableRef[Cap, HashSet[string]]]
-  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)

src/json_socket_translator.nim

@@ -1,34 +0,0 @@
-# SPDX-FileCopyrightText: ☭ Emery Hemingway
-# SPDX-License-Identifier: Unlicense
-
-import std/[asyncdispatch, asyncnet, json]
-from std/nativesockets import AF_UNIX, SOCK_STREAM, Protocol
-import preserves, preserves/jsonhooks, syndicate, syndicate/relays
-
-import ./schema/config, ./json_messages
-
-runActor("main") do (root: Cap; turn: var Turn):
-  connectStdio(turn, root)
-  during(turn, root, ?JsonSocketTranslatorArguments) do (ds: Cap, socketPath: string):
-    let socket = newAsyncSocket(
-        domain = AF_UNIX,
-        sockType = SOCK_STREAM,
-        protocol = cast[Protocol](0),
-        buffered = false,
-      )
-    addCallback(connectUnix(socket, socketPath), turn) do (turn: var Turn):
-      let a = JsonTranslatorConnected(path: socketPath)
-      discard publish(turn, ds, a)
-
-      let socketFacet = turn.facet
-      proc processOutput(fut: Future[string]) {.gcsafe.} =
-        run(socketFacet) do (turn: var Turn):
-          var data = fut.read.parseJson
-          message(turn, ds, RecvJson(data: data))
-        socket.recvLine.addCallback(processOutput)
-      socket.recvLine.addCallback(processOutput)
-
-      onMessage(turn, ds, ?SendJson) do (data: JsonNode):
-        asyncCheck(turn, send(socket, $data & "\n"))
-  do:
-    close(socket)

src/json_translator.nim

@@ -1,31 +0,0 @@
-# SPDX-FileCopyrightText: ☭ Emery Hemingway
-# SPDX-License-Identifier: Unlicense
-
-import std/[json, os, osproc]
-import preserves
-import syndicate, syndicate/relays
-
-from preserves/jsonhooks import toPreserveHook
-
-import ./json_messages
-
-proc runChild: string =
-  let params = commandLineParams()
-  if params.len < 1:
-    stderr.writeLine "not enough parameters"
-    quit 1
-  let
-    cmd = params[0]
-    args = params[1..params.high]
-  try: result = execProcess(command=cmd, args=args, options={poUsePath})
-  except CatchableError as err:
-    quit("execProcess failed: " & err.msg)
-  if result == "":
-    stderr.writeLine "no ouput"
-    quit 1
-
-runActor("main") do (ds: Cap; turn: var Turn):
-  connectStdio(turn, ds)
-  let js = runChild().parseJson()
-  message(turn, ds,  RecvJson(data: js))
-  discard publish(turn, ds,  RecvJson(data: js))

src/mintsturdyref.nim

@@ -2,7 +2,7 @@
 # SPDX-License-Identifier: Unlicense
 
 from os import commandLineParams
-import preserves, syndicate/capabilities
+import preserves, syndicate/capabilities, syndicate/protocols/sturdy
 
 const usage = """
 mintsturdyref OID < SECRET_KEY
@@ -19,7 +19,7 @@ See:
 """
 
 proc main =
-  var oids: seq[Preserve[void]]
+  var oids: seq[Value]
   for p in commandLineParams():
     case p
     of "-h", "--help", "?":
@@ -28,7 +28,7 @@ proc main =
       add(oids, parsePreserves p)
   if oids.len == 0:
     stderr.writeLine """using the "syndicate" OID"""
-    oids.add(toPreserve "syndicate")
+    oids.add(toPreserves "syndicate")
 
   var key: array[16, byte]
   case readBytes(stdin, key, 0, 16)

src/mount_actor.nim

@@ -7,8 +7,8 @@ when not defined(linux):
   {.error: "this component only tested for Linux".}
 
 import std/oserrors
-import preserves
+import preserves, preserves/sugar
-import syndicate, syndicate/relays
+import syndicate
 import ./schema/mountpoints
 
 type BootArgs {.preservesDictionary.} = object
@@ -20,25 +20,34 @@ proc mount(source, target, fsType: cstring; flags: culong; data: pointer): cint
 proc umount(target: cstring): cint {.importc, header: "<sys/mount.h>".}
   ## `umount(2)`
 
-runActor("mount_actor") do (turn: var Turn; root: Cap):
+proc spawnMountActor*(turn: Turn; ds: Cap): Actor {.discardable.} =
-  let
+  spawnActor(turn, "mount_actor") do (turn: Turn):
-    targetPat = ?Observe(pattern: !Mountpoint) ?? { 1: grabLit() }
+    let
-    sourcePat = ?Observe(pattern: !Mountpoint) ?? { 0: grabLit(), 2: grabLit() }
+      targetPat = observePattern(!Mountpoint, { @[%1]: grabLit() })
-  connectStdio(turn, root)
+      sourcePat = observePattern(!Mountpoint, {
-  during(turn, root, ?BootArgs) do (ds: Cap):
+          @[%0]: grabLit(),
-    during(turn, ds, targetPat) do (target: string):
+          @[%2]: grabLit(),
-      during(turn, ds, sourcePat) do (source: string, fsType: string):
+        })
-        var mountpoint = Mountpoint(
+    during(turn, ds, ?:BootArgs) do (ds: Cap):
-              source: source,
+      during(turn, ds, targetPat) do (target: string):
-              target: target,
+        during(turn, ds, sourcePat) do (source: string, fsType: string):
-              `type`: fsType,
+          var mountpoint = Mountpoint(
-            )
+                source: source,
-        var rc = mount(source, target, fsType, 0, nil)
+                target: target,
-        if rc == 0:
+                `type`: fsType,
-          mountpoint.status = Status(orKind: StatusKind.true)
+              )
-        else:
+          var rc = mount(source, target, fsType, 0, nil)
-          mountpoint.status = Status(orKind: StatusKind.Failure)
+          if rc == 0:
-          mountpoint.status.failure.msg = osErrorMsg(osLastError())
+            mountpoint.status = Status(orKind: StatusKind.success)
-        discard publish(turn, ds, mountpoint)
+          else:
-    do:
+            mountpoint.status = Status(orKind: StatusKind.Failure)
-      discard umount(target)
+            mountpoint.status.failure.msg = osErrorMsg(osLastError())
+          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)

src/msg.nim

@@ -1,19 +1,22 @@
 # SPDX-FileCopyrightText: ☭ Emery Hemingway
 # SPDX-License-Identifier: Unlicense
 
-import std/[asyncdispatch, sequtils, os]
+import std/[sequtils, os, strutils]
 import preserves, syndicate, syndicate/relays
 
-proc main =
+setControlCHook(proc () {.noconv.} = quit())
-  let
-    route = envRoute()
-    data = map(commandLineParams(), parsePreserves)
 
-  discard bootDataspace("msg") do (turn: var Turn; root: Cap):
+runActor("msg") do (turn: Turn):
-    resolve(turn, root, route) do (turn: var Turn; ds: Cap):
+  let
+    data = map(commandLineParams(), parsePreserves)
+    cmd = paramStr(0).extractFilename.normalize
+  resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+    case cmd
+    of "assert":
+      for e in data:
+        publish(turn, ds, e)
+    else: # "msg"
       for e in data:
         message(turn, ds, e)
-
+      sync(turn, ds) do (turn: Turn):
-  for _ in 1..4: poll()
+        stopActor(turn)
-
-main()

src/net_mapper.nim

@@ -1,167 +0,0 @@
-# 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 toPreserveHook(address: IpAddress; E: typedesc): Preserve[E] = toPreserve($address, E)
-
-proc fromPreserveHook[E](address: var IpAddress; pr: Preserve[E]): 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 fromPreserveHook(ip, toPreserveHook(ip, void))
-
-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)

src/postgre_actor.nim

@@ -0,0 +1,158 @@
+# SPDX-FileCopyrightText: ☭ Emery Hemingway
+# SPDX-License-Identifier: Unlicense
+
+import preserves, syndicate
+import ./schema/[config, sql]
+
+{.passL: "-lpq".}
+
+{.pragma: libpq, header: "libpq-fe.h", importc.}
+
+type
+  Oid = cuint
+  PGconn {.libpq.} = ptr object
+  PGresult {.libpq.} = ptr object
+  ConnStatusType {.libpq.} = enum
+    CONNECTION_OK, CONNECTION_BAD, ##  Non-blocking mode only below here
+                                 ##
+                                 ##  The existence of these should never be relied upon - they should only
+                                 ##  be used for user feedback or similar purposes.
+                                 ##
+    CONNECTION_STARTED,       ##  Waiting for connection to be made.
+    CONNECTION_MADE,          ##  Connection OK; waiting to send.
+    CONNECTION_AWAITING_RESPONSE, ##  Waiting for a response from the
+                                 ##  postmaster.
+    CONNECTION_AUTH_OK,       ##  Received authentication; waiting for
+                       ##  backend startup.
+    CONNECTION_SETENV,        ##  This state is no longer used.
+    CONNECTION_SSL_STARTUP,   ##  Negotiating SSL.
+    CONNECTION_NEEDED,        ##  Internal state: connect() needed
+    CONNECTION_CHECK_WRITABLE, ##  Checking if session is read-write.
+    CONNECTION_CONSUME,       ##  Consuming any extra messages.
+    CONNECTION_GSS_STARTUP,   ##  Negotiating GSSAPI.
+    CONNECTION_CHECK_TARGET,  ##  Checking target server properties.
+    CONNECTION_CHECK_STANDBY  ##  Checking if server is in standby mode.
+
+  ExecStatusType = enum
+    PGRES_EMPTY_QUERY = 0,      ##  empty query string was executed
+    PGRES_COMMAND_OK,         ##  a query command that doesn't return
+                     ##  anything was executed properly by the
+                     ##  backend
+    PGRES_TUPLES_OK,          ##  a query command that returns tuples was
+                    ##  executed properly by the backend, PGresult
+                    ##  contains the result tuples
+    PGRES_COPY_OUT,           ##  Copy Out data transfer in progress
+    PGRES_COPY_IN,            ##  Copy In data transfer in progress
+    PGRES_BAD_RESPONSE,       ##  an unexpected response was recv'd from the
+                       ##  backend
+    PGRES_NONFATAL_ERROR,     ##  notice or warning message
+    PGRES_FATAL_ERROR,        ##  query failed
+    PGRES_COPY_BOTH,          ##  Copy In/Out data transfer in progress
+    PGRES_SINGLE_TUPLE,       ##  single tuple from larger resultset
+    PGRES_PIPELINE_SYNC,      ##  pipeline synchronization point
+    PGRES_PIPELINE_ABORTED    ##  Command didn't run because of an abort
+                          ##  earlier in a pipeline
+
+proc PQconnectdbParams(
+    keywords: cstringArray; values: cstringArray; expand_dbname: cint): PGconn {.libpq.}
+
+proc PQerrorMessage(conn: PGconn): cstring {.libpq.}
+proc PQfinish(conn: PGconn) {.libpq.}
+proc PQstatus(conn: PGconn): ConnStatusType {.libpq.}
+proc PQexec(conn: PGconn; query: cstring): PGresult {.libpq.}
+proc PQresultStatus(res: PGresult): ExecStatusType {.libpq.}
+proc PQresStatus (status: ExecStatusType): cstring {.libpq.}
+proc PQresultErrorMessage(res: PGresult): cstring {.libpq.}
+proc PQclear(res: PGresult) {.libpq.}
+proc PQntuples(res: PGresult): cint {.libpq.}
+proc PQnfields(res: PGresult): cint {.libpq.}
+proc PQgetvalue(res: PGresult; tup_num: cint; field_num: cint): cstring {.libpq.}
+proc PQftype(res: PGresult; field_num: cint): Oid {.libpq.}
+proc PQfsize(res: PGresult; field_num: cint): cint {.libpq.}
+
+# proc PQsocket(conn: PGconn): cint
+# proc PQconnectStartParams(
+#     keywords: cstringArray; values: cstringArray; expand_dbname: cint): PGconn
+# TODO: async
+
+proc checkPointer(p: pointer) =
+  if p.isNil: raise newException(OutOfMemDefect, "Postgres returned nil")
+
+type StringPairs = seq[tuple[key: string, val: string]]
+
+proc splitParams(params: StringPairs): (cstringArray, cstringArray) =
+  var strings = newSeq[string](params.len)
+  for i, _ in params: strings[i] = params[i][0]
+  result[0] = allocCStringArray(strings)
+  for i, _ in params: strings[i] = params[i][1]
+  result[1] = allocCStringArray(strings)
+
+proc renderSql(tokens: openarray[Value]): string =
+  for token in tokens:
+    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
+        statusHandle: Handle
+        (keys, vals) = splitParams(params)
+      conn = PQconnectdbParams(keys, vals, 0)
+      checkPointer(conn)
+      let
+        status = PQstatus(conn)
+        msg = $PQerrorMessage(conn)
+      statusHandle = publish(turn, ds,
+          initRecord("status", toSymbol($status), msg.toPreserves))
+      if status == CONNECTION_OK:
+        during(turn, ds, ?:Query) do (statement: seq[Value], target: Cap):
+          var text = renderSql statement
+          if text == "":
+            discard publish(turn, ds, SqlError(msg: "invalid statement", context: $statement))
+          else:
+            var
+              res = PQexec(conn, text)
+              st = PQresultStatus(res)
+            if st == PGRES_TUPLES_OK or st == PGRES_SINGLE_TUPLE:
+              let tuples = PQntuples(res)
+              let fields = PQnfields(res)
+              if tuples > 0 and fields > 0:
+                for r in 0..<tuples:
+                  var tupl = initSequence(fields)
+                  for f in 0..<fields:
+                    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:
+      deallocCStringArray(keys)
+      deallocCStringArray(vals)
+      PQfinish(conn)
+
+when isMainModule:
+  import syndicate/relays
+
+  runActor("main") do (turn: Turn):
+    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+      spawnPostgreActor(turn, ds)

src/preserve_process_environment.nim

@@ -16,6 +16,6 @@ proc main =
   info.argv = commandLineParams()
   for key, val in envPairs(): info.env[key] = val
   info.dir = getCurrentDir()
-  writeLine(stdout, info.toPreserve)
+  writeLine(stdout, info.toPreserves)
 
 main()

src/private/esc_p.nim

@@ -0,0 +1,11 @@
+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"

src/rofi_script_actor.nim

@@ -3,40 +3,29 @@
 
 ## See the rofi-script(5) manpage for documentation.
 
-import std/[asyncdispatch, cmdline, envvars, strutils, tables]
+import std/[cmdline, envvars, strutils, tables]
 import preserves, syndicate, syndicate/relays
 import ./schema/rofi
 
-proc main =
+if getEnv("ROFI_OUTSIDE") == "":
-  let
+  quit("run this program in rofi")
-    route = envRoute()
-    rofiPid = getEnv("ROFI_OUTSIDE")
-  if rofiPid == "":
-    quit("run this program in rofi")
 
-  runActor("rofi_script_actor") do (turn: var Turn; root: Cap):
+runActor("rofi_script_actor") do (turn: Turn):
-    let rootFacet = turn.facet
+  resolveEnvironment(turn) do (turn: Turn; ds: Cap):
-    resolve(turn, root, route) do (turn: var Turn; ds: Cap):
+    case paramCount()
-      case paramCount()
+    of 0:
-      of 0:
+      let pat = ?:Options
-        let pat = ?Options
+      onPublish(turn, ds, pat) do (options: seq[string]):
-        onPublish(turn, ds, pat) do (options: seq[string]):
+        stdout.writeLine options.join("\n")
-          stdout.writeLine options.join("\n")
+        quit()
-          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)
-        # TODO: sync not implemented correctly
+      sync(turn, ds, stopActor)
-        # 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()

src/schema/assertions.nim

@@ -0,0 +1,31 @@
+
+import
+  preserves
+
+type
+  XsltItems* = seq[XsltItem]
+  Pulse* {.preservesRecord: "pulse".} = object
+    `periodSec`*: float
+    `proxy`* {.preservesEmbedded.}: Value
+
+  XsltItem* = string
+  XmlTranslation* {.preservesRecord: "xml-translation".} = object
+    `xml`*: string
+    `pr`*: Value
+
+  FileSystemUsage* {.preservesRecord: "file-system-usage".} = object
+    `path`*: string
+    `size`*: BiggestInt
+
+  XsltTransform* {.preservesRecord: "xslt-transform".} = object
+    `stylesheet`*: string
+    `input`*: string
+    `output`*: Value
+
+proc `$`*(x: XsltItems | Pulse | XsltItem | XmlTranslation | FileSystemUsage |
+    XsltTransform): string =
+  `$`(toPreserves(x))
+
+proc encode*(x: XsltItems | Pulse | XsltItem | XmlTranslation | FileSystemUsage |
+    XsltTransform): seq[byte] =
+  encode(toPreserves(x))

src/schema/base64.nim

@@ -0,0 +1,19 @@
+
+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))

src/schema/config.nim

@@ -1,18 +1,165 @@
 
 import
-  preserves
+  preserves, std/tables
 
 type
+  WebsocketArgumentsField0* {.preservesDictionary.} = object
+    `dataspace`* {.preservesEmbedded.}: EmbeddedRef
+    `url`*: string
+
+  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
+
+  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
+
+  JsonSocketTranslatorArgumentsField0* {.preservesDictionary.} = object
+    `dataspace`* {.preservesEmbedded.}: EmbeddedRef
+    `socket`*: SocketAddress
+
+  JsonSocketTranslatorArguments* {.preservesRecord: "json-socket-translator".} = object
+    `field0`*: JsonSocketTranslatorArgumentsField0
+
+  XsltArgumentsField0* {.preservesDictionary.} = object
+    `dataspace`* {.preservesEmbedded.}: EmbeddedRef
+
+  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
+
+  WebhooksArguments* {.preservesRecord: "webhooks".} = object
+    `field0`*: WebhooksArgumentsField0
+
+  FileSystemUsageArgumentsField0* {.preservesDictionary.} = object
+    `dataspace`* {.preservesEmbedded.}: EmbeddedRef
+
+  FileSystemUsageArguments* {.preservesRecord: "file-system-usage".} = object
+    `field0`*: FileSystemUsageArgumentsField0
+
+  SqliteArgumentsField0* {.preservesDictionary.} = object
+    `database`*: string
+    `dataspace`* {.preservesEmbedded.}: EmbeddedRef
+
+  SqliteArguments* {.preservesRecord: "sqlite".} = object
+    `field0`*: SqliteArgumentsField0
+
+  TcpAddress* {.preservesRecord: "tcp".} = object
+    `host`*: string
+    `port`*: BiggestInt
+
+  CacheArgumentsField0* {.preservesDictionary.} = object
+    `dataspace`* {.preservesEmbedded.}: EmbeddedRef
+    `lifetime`*: float
+
+  CacheArguments* {.preservesRecord: "cache".} = object
+    `field0`*: CacheArgumentsField0
+
+  XmlTranslatorArgumentsField0* {.preservesDictionary.} = object
+    `dataspace`* {.preservesEmbedded.}: EmbeddedRef
+
+  XmlTranslatorArguments* {.preservesRecord: "xml-translator".} = object
+    `field0`*: XmlTranslatorArgumentsField0
+
+  PostgreConnectionParameter* {.preservesTuple.} = object
+    `key`*: string
+    `val`*: string
+
+  PostgreArgumentsField0* {.preservesDictionary.} = object
+    `connection`*: seq[PostgreConnectionParameter]
+    `dataspace`* {.preservesEmbedded.}: EmbeddedRef
+
+  PostgreArguments* {.preservesRecord: "postgre".} = object
+    `field0`*: PostgreArgumentsField0
+
+  PulseArgumentsField0* {.preservesDictionary.} = object
+    `dataspace`* {.preservesEmbedded.}: EmbeddedRef
+
+  PulseArguments* {.preservesRecord: "pulse".} = object
+    `field0`*: PulseArgumentsField0
+
+  UnixAddress* {.preservesRecord: "unix".} = object
     `path`*: string
 
-  JsonSocketTranslatorArguments* {.preservesDictionary.} = object
+  Tcp* {.preservesRecord: "tcp".} = object
-    `dataspace`* {.preservesEmbedded.}: Preserve[void]
+    `host`*: string
-    `socket`*: string
+    `port`*: BiggestInt
 
-proc `$`*(x: JsonTranslatorConnected | JsonSocketTranslatorArguments): string =
+proc `$`*(x: WebsocketArguments | HttpClientArguments | JsonTranslatorArguments |
-  `$`(toPreserve(x))
+    SocketAddress |
+    Base64DecoderArguments |
+    JsonTranslatorConnected |
+    JsonSocketTranslatorArguments |
+    XsltArguments |
+    HttpDriverArguments |
+    WebhooksArguments |
+    FileSystemUsageArguments |
+    SqliteArguments |
+    TcpAddress |
+    CacheArguments |
+    XmlTranslatorArguments |
+    PostgreConnectionParameter |
+    PostgreArguments |
+    PulseArguments |
+    UnixAddress |
+    Tcp): string =
+  `$`(toPreserves(x))
 
-proc encode*(x: JsonTranslatorConnected | JsonSocketTranslatorArguments): seq[
+proc encode*(x: WebsocketArguments | HttpClientArguments |
-    byte] =
+    JsonTranslatorArguments |
-  encode(toPreserve(x))
+    SocketAddress |
+    Base64DecoderArguments |
+    JsonTranslatorConnected |
+    JsonSocketTranslatorArguments |
+    XsltArguments |
+    HttpDriverArguments |
+    WebhooksArguments |
+    FileSystemUsageArguments |
+    SqliteArguments |
+    TcpAddress |
+    CacheArguments |
+    XmlTranslatorArguments |
+    PostgreConnectionParameter |
+    PostgreArguments |
+    PulseArguments |
+    UnixAddress |
+    Tcp): seq[byte] =
+  encode(toPreserves(x))

src/schema/inotify_actor.nim

@@ -10,7 +10,7 @@ type
     `name`*: string
 
 proc `$`*(x: InotifyMessage): string =
-  `$`(toPreserve(x))
+  `$`(toPreserves(x))
 
 proc encode*(x: InotifyMessage): seq[byte] =
-  encode(toPreserve(x))
+  encode(toPreserves(x))

src/schema/json_messages.nim

@@ -4,7 +4,7 @@
 import std/json
 import preserves, preserves/jsonhooks
 
-export fromPreserveHook, toPreserveHook
+export fromPreservesHook, toPreservesHook
   # re-export the hooks so that conversion "just works"
 
 type

src/schema/mountpoints.nim

@@ -13,18 +13,18 @@ type
     `status`*: Status
 
   StatusKind* {.pure.} = enum
-    `Failure`, `true`
+    `Failure`, `success`
   `Status`* {.preservesOr.} = object
     case orKind*: StatusKind
     of StatusKind.`Failure`:
         `failure`*: Failure
 
-    of StatusKind.`true`:
+    of StatusKind.`success`:
-        `true`* {.preservesLiteral: "#t".}: bool
+        `success`* {.preservesLiteral: "#t".}: bool
 
   
 proc `$`*(x: Failure | Mountpoint | Status): string =
-  `$`(toPreserve(x))
+  `$`(toPreserves(x))
 
 proc encode*(x: Failure | Mountpoint | Status): seq[byte] =
-  encode(toPreserve(x))
+  encode(toPreserves(x))

src/schema/net_mapper.nim

@@ -5,12 +5,12 @@ import
 type
   RoundTripTime* {.preservesRecord: "rtt".} = object
     `address`*: string
-    `minimum`*: float32
+    `minimum`*: float
-    `average`*: float32
+    `average`*: float
-    `maximum`*: float32
+    `maximum`*: float
 
 proc `$`*(x: RoundTripTime): string =
-  `$`(toPreserve(x))
+  `$`(toPreserves(x))
 
 proc encode*(x: RoundTripTime): seq[byte] =
-  encode(toPreserve(x))
+  encode(toPreserves(x))

src/schema/rofi.nim

@@ -12,7 +12,7 @@ type
     `options`*: seq[string]
 
 proc `$`*(x: Environment | Select | Options): string =
-  `$`(toPreserve(x))
+  `$`(toPreserves(x))
 
 proc encode*(x: Environment | Select | Options): seq[byte] =
-  encode(toPreserve(x))
+  encode(toPreserves(x))

src/schema/sql.nim

@@ -0,0 +1,18 @@
+
+import
+  preserves
+
+type
+  Query* {.preservesRecord: "query".} = object
+    `statement`*: seq[Value]
+    `target`* {.preservesEmbedded.}: Value
+
+  SqlError* {.preservesRecord: "sql-error".} = object
+    `msg`*: string
+    `context`*: string
+
+proc `$`*(x: Query | SqlError): string =
+  `$`(toPreserves(x))
+
+proc encode*(x: Query | SqlError): seq[byte] =
+  encode(toPreserves(x))

src/sqlite_actor.nim

@@ -0,0 +1,149 @@
+# SPDX-FileCopyrightText: ☭ Emery Hemingway
+# SPDX-License-Identifier: Unlicense
+
+import preserves, syndicate
+import ./schema/[config, sql]
+
+# Avoid Sqlite3 from the standard library because it is
+# only held together by wishful thinking and dlload.
+
+{.passC: staticExec("pkg-config --cflags sqlite3").}
+{.passL: staticExec("pkg-config --libs sqlite3").}
+
+{.pragma: sqlite3h, header: "sqlite3.h".}
+
+var
+  SQLITE_VERSION_NUMBER {.importc, sqlite3h.}: cint
+  SQLITE_OK {.importc, sqlite3h.}: cint
+  SQLITE_ROW {.importc, sqlite3h.}: cint
+  SQLITE_DONE {.importc, sqlite3h.}: cint
+  SQLITE_OPEN_READONLY {.importc, sqlite3h.}: cint
+
+const
+  SQLITE_INTEGER = 1
+  SQLITE_FLOAT = 2
+  SQLITE_TEXT = 3
+  SQLITE_BLOB = 4
+  # SQLITE_NULL = 5
+
+type
+  Sqlite3 {.importc: "sqlite3", sqlite3h.} = distinct pointer
+  Stmt {.importc: "sqlite3_stmt", sqlite3h.} = distinct pointer
+
+{.pragma: importSqlite3, importc: "sqlite3_$1", sqlite3h.}
+
+proc libversion_number: cint {.importSqlite3.}
+
+proc open_v2(filename: cstring; ppDb: ptr Sqlite3; flags: cint; zVfs: cstring): cint {.importSqlite3.}
+proc close(ds: Sqlite3): int32 {.discardable, importSqlite3.}
+
+proc errmsg(db: Sqlite3): cstring {.importSqlite3.}
+
+proc prepare_v2(db: Sqlite3; zSql: cstring, nByte: cint; ppStmt: ptr Stmt; pzTail: ptr cstring): cint {.importSqlite3.}
+
+proc step(para1: Stmt): cint {.importSqlite3.}
+
+proc column_count(stmt: Stmt): int32 {.importSqlite3.}
+proc column_blob(stmt: Stmt; col: cint): pointer {.importSqlite3.}
+proc column_bytes(stmt: Stmt; col: cint): cint {.importSqlite3.}
+proc column_double(stmt: Stmt; col: cint): float64 {.importSqlite3.}
+proc column_int64(stmt: Stmt; col: cint): int64 {.importSqlite3.}
+proc column_text(stmt: Stmt; col: cint): cstring {.importSqlite3.}
+proc column_type(stmt: Stmt; col: cint): cint {.importSqlite3.}
+proc finalize(stmt: Stmt): cint {.importSqlite3.}
+
+doAssert libversion_number() == SQLITE_VERSION_NUMBER
+
+proc assertError(facet: Facet; cap: Cap; db: Sqlite3; context: string) =
+  run(facet) do (turn: Turn):
+    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)
+  of SQLITE_INTEGER:
+    result = toPreserves(column_int64(stmt, col))
+  of SQLITE_FLOAT:
+    result = toPreserves(column_double(stmt, col))
+  of SQLITE_TEXT:
+    result = Value(kind: pkString, string: newString(column_bytes(stmt, col)))
+    if result.string.len > 0:
+      copyMem(addr result.string[0], column_text(stmt, col), result.string.len)
+  of SQLITE_BLOB:
+    result = Value(kind: pkByteString, bytes: newSeq[byte](column_bytes(stmt, col)))
+    if result.bytes.len > 0:
+      copyMem(addr result.bytes[0], column_blob(stmt, col), result.bytes.len)
+  else:
+    result = initRecord("null")
+
+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 =
+  for token in tokens:
+    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):
+        let facet = turn.facet
+        stderr.writeLine("opening SQLite database ", path)
+        var db: Sqlite3
+        if open_v2(path, addr db, SQLITE_OPEN_READONLY, nil) != SQLITE_OK:
+          assertError(facet, ds, db, path)
+        else:
+          turn.onStop do (turn: Turn):
+            close(db)
+            stderr.writeLine("closed SQLite database ", path)
+          during(turn, ds, ?:Query) do (statement: seq[Value], target: Cap):
+            var
+              stmt: Stmt
+              text = renderSql statement
+            if text == "":
+              assertError(facet, target, "invalid statement", $statement)
+            elif prepare_v2(db, text, text.len.cint, addr stmt, nil) != SQLITE_OK:
+              assertError(facet, target, db, text)
+            else:
+              try:
+                let arity = column_count(stmt)
+                var res = step(stmt)
+                while res == SQLITE_ROW:
+                  var rec = extractTuple(stmt, arity)
+                  discard publish(turn, target, rec)
+                  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: Turn):
+    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+      spawnSqliteActor(turn, ds)

src/syndesizer.nim

@@ -0,0 +1,28 @@
+# SPDX-FileCopyrightText: ☭ Emery Hemingway
+# SPDX-License-Identifier: Unlicense
+
+## Syndicate multitool.
+
+import syndicate, syndicate/relays, syndicate/drivers/timers
+
+import ./syndesizer/[
+  base64_decoder,
+  cache_actor,
+  file_system_usage,
+  http_driver,
+  json_socket_translator,
+  json_translator,
+  pulses,
+  xml_translator]
+
+runActor("syndesizer") do (turn: Turn):
+  resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+    discard spawnTimerDriver(turn, ds)
+    discard spawnBase64Decoder(turn, ds)
+    discard spawnCacheActor(turn, ds)
+    discard spawnFileSystemUsageActor(turn, ds)
+    discard spawnHttpDriver(turn, ds)
+    discard spawnJsonSocketTranslator(turn, ds)
+    discard spawnJsonStdioTranslator(turn, ds)
+    discard spawnPulseActor(turn, ds)
+    discard spawnXmlTranslator(turn, ds)

src/syndesizer/Tupfile

@@ -0,0 +1,3 @@
+include_rules
+: foreach *.nim | $(SYNDICATE_PROTOCOL) ../<schema> |> !nim_bin |> {bin}
+: foreach {bin} |> !assert_built |>

src/syndesizer/base64_decoder.nim

@@ -0,0 +1,50 @@
+# 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)

src/syndesizer/cache_actor.nim

@@ -0,0 +1,58 @@
+# SPDX-FileCopyrightText: ☭ Emery Hemingway
+# SPDX-License-Identifier: Unlicense
+
+import std/times
+import preserves, syndicate,
+  syndicate/durings,
+  syndicate/drivers/timers
+
+import ../schema/config
+
+proc afterTimeout(n: float64): LaterThan =
+  ## Get a `LaterThan` record for `n` seconds in the future.
+  result.seconds = getTime().toUnixFloat() + n
+
+type CacheEntity {.final.} = ref object of Entity
+  timeouts, target: Cap
+    # dataspaces for observing timeouts and publishing values
+  pattern: Pattern
+  lifetime: float64
+
+method publish(cache: CacheEntity; turn: Turn; ass: AssertionRef; h: Handle) =
+  ## Re-assert pattern captures in a sub-facet.
+  discard inFacet(turn) do (turn: 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.
+    discard publish(turn, cache.target, ass)
+    let timeout = afterTimeout(cache.lifetime)
+    onPublish(turn, cache.timeouts, ?timeout) do:
+      stop(turn) # end this facet
+
+proc isObserve(pat: Pattern): bool =
+  pat.orKind == PatternKind.group and
+    pat.group.type.orKind == GroupTypeKind.rec and
+      pat.group.type.rec.label.isSymbol"Observe"
+
+proc spawnCacheActor*(turn: Turn; root: Cap): Actor =
+  spawnActor(turn, "cache_actor") do (turn: Turn):
+    during(turn, root, ?:CacheArguments) do (ds: Cap, lifetime: float64):
+      onPublish(turn, ds, ?:Observe) do (pat: Pattern, obs: Cap):
+        var cache: CacheEntity
+        if obs.relay != turn.facet and not(pat.isObserve):
+          # Watch pattern if the observer is not us
+          # and if the pattern isn't a recursive observe
+          cache = CacheEntity(
+              timeouts: root,
+              target: ds,
+              pattern: pat,
+              lifetime: lifetime,
+            )
+          discard observe(turn, ds, pat, cache)
+
+when isMainModule:
+  import syndicate/relays
+  runActor("main") do (turn: Turn):
+    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+      discard spawnTimerDriver(turn, ds)
+      discard spawnCacheActor(turn, ds)

src/syndesizer/file_system_usage.nim

@@ -0,0 +1,28 @@
+# SPDX-FileCopyrightText: ☭ Emery Hemingway
+# SPDX-License-Identifier: Unlicense
+
+import std/[dirs, os, paths]
+import preserves, preserves/sugar
+import syndicate
+
+import ../schema/[assertions, config]
+
+proc spawnFileSystemUsageActor*(turn: Turn; root: Cap): Actor {.discardable.} =
+  spawn("file-system-usage", turn) do (turn: Turn):
+    during(turn, root, ?:FileSystemUsageArguments) do (ds: Cap):
+      let pat = observePattern(!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)
+        else:
+          for fp in walkDirRec(paths.Path(lit.value), yieldFilter={pcFile}):
+            var fs = getFileSize(string fp)
+            inc(ass.size, fs)
+        discard publish(turn, ds, ass)
+          # TODO: updates?
+
+when isMainModule:
+  import syndicate/relays
+  runActor("main") do (turn: Turn):
+    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+      discard spawnFileSystemUsageActor(turn, ds)

src/syndesizer/http_driver.nim

@@ -0,0 +1,42 @@
+# 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)

src/syndesizer/http_driver.nim.cfg

@@ -0,0 +1,2 @@
+define:ipv6Enabled
+include:"std/assertions"

src/syndesizer/json_socket_translator.nim

@@ -0,0 +1,77 @@
+# SPDX-FileCopyrightText: ☭ Emery Hemingway
+# SPDX-License-Identifier: Unlicense
+
+import std/[json, options]
+import pkg/sys/[ioqueue, sockets]
+import preserves, preserves/jsonhooks, syndicate
+
+import ../schema/[config, json_messages]
+
+template translateSocketBody {.dirty.} =
+  # Template workaround for CPS and parameterized types.
+  var
+    guard = initGuard(facet)
+    dec = newBufferedDecoder(0)
+    buf = new string #TODO: get a pointer into the decoder
+    alive = true
+  proc kill(turn: Turn) =
+    alive = false
+  proc setup(turn: Turn) =
+    # Closure, not CPS.
+    onMessage(turn, ds, ?:SendJson) do (data: JsonNode):
+      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.} =
+  var
+    socket = new AsyncConn[Protocol.Tcp]
+    conn = connectTcpAsync(sa.host, Port sa.port)
+  socket[] = conn
+  translateSocketBody()
+
+proc translateSocket(facet: Facet; ds: Cap; sa: UnixAddress) {.asyncio.} =
+  var
+    socket = new AsyncConn[Protocol.Unix]
+    conn = connectUnixAsync(sa.path)
+  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("main") do (turn: Turn):
+    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+      spawnJsonSocketTranslator(turn, ds)

src/syndesizer/json_translator.nim

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: ☭ Emery Hemingway
+# SPDX-License-Identifier: Unlicense
+
+import std/[json, osproc]
+import preserves
+import syndicate
+
+import ../schema/[config, json_messages]
+
+proc runChild(params: seq[string]): string =
+  if params.len < 1:
+    stderr.writeLine "not enough parameters"
+  let
+    cmd = params[0]
+    args = params[1..params.high]
+  try: result = execProcess(command=cmd, args=args, options={poUsePath})
+  except CatchableError as err:
+    quit("execProcess failed: " & err.msg)
+  if result == "":
+    stderr.writeLine "no ouput"
+
+proc spawnJsonStdioTranslator*(turn: Turn; root: Cap): Actor {.discardable.} =
+  spawnActor(turn, "json-stdio-translator") do (turn: 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: Turn):
+    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+      spawnJsonStdioTranslator(turn, ds)

src/syndesizer/pulses.nim

@@ -0,0 +1,105 @@
+# SPDX-FileCopyrightText: ☭ Emery Hemingway
+# SPDX-License-Identifier: Unlicense
+
+import std/[options, tables, times]
+import preserves, preserves/sugar
+import syndicate, syndicate/drivers/timers
+
+import ../schema/[assertions, config]
+
+type PulseEntity {.final.} = ref object of Entity
+  ## An entity that asserts and retracts observers on a pulse.
+  self, timers: Cap
+  target: Entity
+  period: float
+  timerHandle: Handle
+  observers: Table[Handle, AssertionRef]
+  observePattern: Pattern
+  observing: bool
+
+proc schedule(turn: 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.
+  let then = getTime().toUnixFloat()+pulse.period
+  pulse.timerHandle = publish(turn, pulse.timers, Observe(
+      pattern: LaterThan ?: { 0: ?then },
+      observer: pulse.self,
+    ))
+
+method publish(pulse: PulseEntity; turn: Turn; ass: AssertionRef; h: Handle) =
+  ## Publish observers in reponse to <later-than …> assertions.
+  pulse.timers.target.retract(turn, pulse.timerHandle)
+  schedule(turn, pulse)
+  pulse.observing = true
+  for h, a in pulse.observers.pairs:
+    pulse.target.publish(turn, a, h)
+  pulse.target.sync(turn, pulse.self)
+
+method message(pulse: PulseEntity; turn: Turn; v: AssertionRef) =
+  ## Retract observers in response to a sync message.
+  pulse.observing = false
+  for h in pulse.observers.keys:
+    pulse.target.retract(turn, h)
+
+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) =
+  ## Proxy assertions that are not observations.
+  if proxy.pulse.observePattern.matches ass.value:
+    if proxy.pulse.observers.len == 0:
+      schedule(turn, proxy.pulse)
+    proxy.pulse.observers[h] = ass
+  else:
+    proxy.pulse.target.publish(turn, ass, h)
+
+method retract(proxy: ProxyEntity; turn: Turn; h: Handle) =
+  ## Retract proxied assertions.
+  var obs: AssertionRef
+  if proxy.pulse.observers.pop(h, obs):
+    if proxy.pulse.observing:
+      proxy.pulse.target.retract(turn, h)
+    if proxy.pulse.observers.len == 0:
+      proxy.pulse.timers.target.retract(turn, proxy.pulse.timerHandle)
+  else:
+    proxy.pulse.target.retract(turn, h)
+
+method message(proxy: ProxyEntity; turn: Turn; v: AssertionRef) =
+  ## Proxy mesages.
+  proxy.pulse.target.message(turn, v)
+
+method sync(proxy: ProxyEntity; turn: Turn; peer: Cap) =
+  ## Proxy sync.
+  proxy.pulse.target.sync(turn, peer)
+
+proc newProxyEntity(turn: Turn; timers, ds: Cap; period: float): ProxyEntity =
+  new result
+  result.pulse = PulseEntity(
+      target: ds.target,
+      timers: timers,
+      observePattern: ?:Observe,
+      period: period,
+    )
+  result.pulse.self = newCap(turn, result.pulse)
+
+proc spawnPulseActor*(turn: 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):
+    let grabPeriod = observePattern(!Pulse, { @[%0]: grab() })
+    during(turn, root, ?:PulseArguments) do (ds: Cap):
+      during(turn, ds, grabPeriod) do (lit: Literal[float]):
+        if lit.value < 0.000_1:
+          stderr.writeLine("pulse period is too small: ", lit.value, "s")
+        else:
+         let proxyCap = newCap(turn, newProxyEntity(turn, root, ds, lit.value))
+         var pulse = Pulse(periodSec: lit.value, proxy: embed proxyCap)
+         discard publish(turn, ds, pulse)
+
+when isMainModule:
+  import syndicate/relays
+  runActor("main") do (turn: Turn):
+    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+      discard spawnPulseActor(turn, ds)

src/syndesizer/xml_translator.nim

@@ -0,0 +1,34 @@
+# SPDX-FileCopyrightText: ☭ Emery Hemingway
+# SPDX-License-Identifier: Unlicense
+
+import std/[options, parsexml, xmlparser, xmltree]
+import preserves, preserves/sugar, preserves/xmlhooks
+import syndicate
+
+import ../schema/[assertions, config]
+
+proc translateXml(s: string): XmlTranslation =
+  result.xml = s
+  try: result.pr = result.xml.parseXml({allowUnquotedAttribs}).toPreservesHook
+  except XmlError: discard
+
+proc translatePreserves(pr: Value): XmlTranslation {.gcsafe.} =
+  result.pr = pr
+  var xn = result.pr.preservesTo(XmlNode)
+  if xn.isSome: result.xml = $get(xn)
+
+proc spawnXmlTranslator*(turn: Turn; root: Cap): Actor {.discardable.} =
+  spawnActor(turn, "xml-translator") do (turn: Turn):
+    during(turn, root, ?:XmlTranslatorArguments) do (ds: Cap):
+      let xmlPat = observePattern(!XmlTranslation, {@[%0]:grab()})
+      during(turn, ds, xmlPat) do (xs: Literal[string]):
+        publish(turn, ds, translateXml(xs.value))
+      let prPat = observePattern(!XmlTranslation, {@[%1]:grab()})
+      during(turn, ds, prPat) do (pr: Literal[Value]):
+        publish(turn, ds, translatePreserves(pr.value))
+
+when isMainModule:
+  import syndicate/relays
+  runActor("main") do (turn: Turn):
+    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+      spawnXmlTranslator(turn, ds)

src/syndex_card.nim

@@ -1,132 +0,0 @@
-# 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: Assertion): Pattern =
-  let
-    dropSigil = initRecord("lit", "_".toSymbol(Cap))
-    grabSigil = initRecord("lit", "?".toSymbol(Cap))
-  var pr = grab(pr).toPreserve(Cap)
-  apply(pr) do (pr: var Assertion):
-    if pr == dropSigil:
-      pr = initRecord[Cap]("_")
-    elif pr == grabSigil:
-      pr = initRecord("bind", initRecord[Cap]("_"))
-  doAssert result.fromPreserve(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: Assertion
-      try: pr = decodePreserves(input, Cap)
-      except ValueError: discard
-      try: pr = parsePreserves(input, Cap)
-      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: Assertion
-
-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):
-      resolve(turn, root, route) do (turn: var Turn; ds: Cap):
-        discard observe(turn, ds, pat, entity)
-
-main()

src/syndump.nim

@@ -2,34 +2,32 @@
 # SPDX-License-Identifier: Unlicense
 
 import std/[os, tables]
-import preserves
+import preserves, syndicate, syndicate/[durings, relays]
-import syndicate,
-  syndicate/[durings, relays]
 
-proc parsePattern(pr: Assertion): Pattern =
+proc parsePattern(pr: Value): Pattern =
   let
-    dropSigil = initRecord("lit", "_".toSymbol(Cap))
+    dropSigil = initRecord("lit", "_".toSymbol)
-    grabSigil = initRecord("lit", "?".toSymbol(Cap))
+    grabSigil = initRecord("lit", "?".toSymbol)
-  var pr = grab(pr).toPreserve(Cap)
+  var pr = drop(pr).toPreserves
-  apply(pr) do (pr: var Assertion):
+  apply(pr) do (pr: var Value):
     if pr == dropSigil:
-      pr = initRecord[Cap]("_")
+      pr = initRecord("_")
     elif pr == grabSigil:
-      pr = initRecord("bind", initRecord[Cap]("_"))
+      pr = initRecord("bind", initRecord("_"))
-  doAssert result.fromPreserve(pr)
+  doAssert result.fromPreserves(pr)
 
 proc inputPatterns: seq[Pattern] =
   var args = commandLineParams()
   result.setLen(args.len)
   for i, input in args:
-    try: result[i] = input.parsePreserves(Cap).parsePattern
+    try: result[i] = input.parsePreserves.parsePattern
     except ValueError:
       quit "failed to parse Preserves argument"
 
 type DumpEntity {.final.} = ref object of Entity
-  assertions: Table[Handle, seq[Assertion]]
+  assertions: Table[Handle, seq[Value]]
 
-proc toLine(values: seq[Assertion]; prefix: char): string =
+proc toLine(values: seq[Value]; prefix: char): string =
   result = newStringOfCap(1024)
   let sep = getEnv("FS", " ")
   result.add(prefix)
@@ -38,19 +36,19 @@ proc toLine(values: seq[Assertion]; prefix: char): string =
     add(result, $v)
   add(result, '\n')
 
-method publish(dump: DumpEntity; turn: var Turn; ass: AssertionRef; h: Handle) =
+method publish(dump: DumpEntity; turn: 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: var Turn; h: Handle) =
+method retract(dump: DumpEntity; turn: Turn; h: Handle) =
-  var values: seq[Assertion]
+  var values: seq[Value]
   if dump.assertions.pop(h, values):
     stdout.write(values.toLine('-'))
     stdout.flushFile()
 
-method message*(dump: DumpEntity; turn: var Turn; ass: AssertionRef) =
+method message*(dump: DumpEntity; turn: Turn; ass: AssertionRef) =
   stdout.write(ass.value.sequence.toLine('!'))
   stdout.flushFile()
 
@@ -60,13 +58,10 @@ proc exitProc() {.noconv.} =
 
 proc main =
   let
-    route = envRoute()
     patterns = inputPatterns()
     entity = DumpEntity()
-  runActor("syndex_card") do (root: Cap; turn: var Turn):
+  runActor("syndex_card") do (turn: Turn):
-    for pat in patterns:
+    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
-      discard observe(turn, root, pat, entity)
-    resolve(turn, root, route) do (turn: var Turn; ds: Cap):
       for pat in patterns:
         discard observe(turn, ds, pat, entity)
 

src/xslt_actor.nim

@@ -0,0 +1,211 @@
+# SPDX-FileCopyrightText: ☭ Emery Hemingway
+# SPDX-License-Identifier: Unlicense
+
+import std/[os, strutils]
+import preserves, preserves/sugar, syndicate
+import ./schema/[assertions, config]
+
+{.passC: staticExec("pkg-config --cflags libxslt").}
+{.passL: staticExec("pkg-config --libs libxslt").}
+
+{.pragma: libxslt, header: "libxslt/xslt.h", importc.}
+
+type
+  xmlElementType {.libxslt.} = enum
+    XML_ELEMENT_NODE = 1,
+    XML_ATTRIBUTE_NODE = 2,
+    XML_TEXT_NODE = 3,
+    XML_CDATA_SECTION_NODE = 4,
+    XML_ENTITY_REF_NODE = 5,
+    XML_ENTITY_NODE = 6,
+    XML_PI_NODE = 7,
+    XML_COMMENT_NODE = 8,
+    XML_DOCUMENT_NODE = 9,
+    XML_DOCUMENT_TYPE_NODE = 10,
+    XML_DOCUMENT_FRAG_NODE = 11,
+    XML_NOTATION_NODE = 12,
+    XML_HTML_DOCUMENT_NODE = 13,
+    XML_DTD_NODE = 14,
+    XML_ELEMENT_DECL = 15,
+    XML_ATTRIBUTE_DECL = 16,
+    XML_ENTITY_DECL = 17,
+    XML_NAMESPACE_DECL = 18,
+    XML_XINCLUDE_START = 19,
+    XML_XINCLUDE_END = 20
+
+  xmlNsPtr = ptr xmlNs
+  xmlNs {.libxslt.} = object
+    next: xmlNsPtr
+    href, prefix: cstring
+
+  xmlAttrPtr = ptr xmlAttr
+  xmlAttr {.libxslt.} = object
+    name: cstring
+    next: xmlAttrPtr
+    children: xmlNodePtr
+
+  xmlElementContentPtr = ptr xmlElementContent
+  xmlElementContent {.libxslt.} = object
+    encoding: cstring
+
+  xmlNodePtr = ptr xmlNode
+  xmlNode {.libxslt.} = object
+    `type`: xmlElementType
+    name: cstring
+    children, next: xmlNodePtr
+    content: cstring
+    properties: xmlAttrPtr
+    nsDef: xmlNsPtr
+
+  xmlDocPtr {.libxslt.} = distinct pointer
+  xsltStylesheetPtr {.libxslt.} = distinct pointer
+
+proc isNil(x: xmlDocPtr): bool {.borrow.}
+proc isNil(x: xsltStylesheetPtr): bool {.borrow.}
+
+proc xmlReadMemory(buf: pointer; len: cint; url, enc: cstring; opts: cint): xmlDocPtr {.libxslt.}
+
+proc xmlReadMemory(buf: string; uri = "noname.xml"): xmlDocPtr =
+  xmlReadMemory(buf[0].addr, buf.len.cint, uri, "UTF-8", 0)
+
+proc xmlParseFile(filename: cstring): xmlDocPtr {.libxslt.}
+
+proc xmlFreeDoc(p: xmlDocPtr) {.libxslt.}
+
+proc xmlDocGetRootElement(doc: xmlDocPtr): xmlNodePtr {.libxslt.}
+
+proc loadXmlDoc(text: string): xmlDocPtr =
+  if text.startsWith("/") and fileExists(text):
+    xmlParseFile(text)
+  else:
+    xmlReadMemory(text, "noname.xml")
+
+proc xsltParseStylesheetFile(filename: cstring): xsltStylesheetPtr {.libxslt.}
+
+proc xsltParseStylesheetDoc(doc: xmlDocPtr): xsltStylesheetPtr {.libxslt.}
+
+proc xsltParseStylesheetDoc(text: string; uri = "noname.xml"): xsltStylesheetPtr =
+  var doc = xmlReadMemory(text, uri)
+  result = xsltParseStylesheetDoc(doc)
+    # implicit free of doc
+
+proc loadStylesheet(text: string): xsltStylesheetPtr =
+  if text.startsWith("/") and fileExists(text):
+    xsltParseStylesheetFile(text)
+  else:
+    xsltParseStylesheetDoc(text, "noname.xsl")
+
+proc xsltApplyStylesheet(
+    style: xsltStylesheetPtr, doc: xmlDocPtr,  params: cstringArray): xmlDocPtr {.libxslt.}
+
+proc xsltFreeStylesheet(style: xsltStylesheetPtr) {.libxslt.}
+
+proc xsltSaveResultToString(txt: ptr pointer; len: ptr cint; res: xmlDocPtr; style: xsltStylesheetPtr): cint {.libxslt.}
+
+proc c_free*(p: pointer) {.importc: "free", header: "<stdlib.h>".}
+
+proc xsltSaveResultToString(res: xmlDocPtr; style: xsltStylesheetPtr): string =
+  var
+    txt: pointer
+    len: cint
+  if xsltSaveResultToString(addr txt, addr len, res, style) < 0:
+    raise newException(CatchableError, "xsltSaveResultToString failed")
+  if len > 0:
+    result = newString(int len)
+    copyMem(result[0].addr, txt, len)
+    c_free(txt)
+
+proc initLibXml =
+  discard
+
+proc XML_GET_CONTENT(xn: xmlNodePtr): xmlElementContentPtr {.libxslt.}
+
+proc textContent(xn: xmlNodePtr): string =
+  if xn.content != nil: result = $xn.content
+
+proc content(attr: xmlAttrPtr): string =
+  var child = attr.children
+  while not child.isNil:
+    result.add child.content
+    child = child.next
+
+proc preserveSiblings(result: var seq[Value]; first: xmlNodePtr) =
+  var xn = first
+  while not xn.isNil:
+    case xn.type
+    of XML_ELEMENT_NODE:
+      var child = Value(kind: pkRecord)
+      if not xn.nsDef.isNil:
+        child.record.add initDictionary()
+        var ns = xn.nsDef
+        while not ns.isNil:
+          if not ns.href.isNil:
+            var key = Value(kind: pkString)
+            if ns.prefix.isNil:
+              key.string = "xmlns"
+            else:
+              key.string = "xmlns:" & $ns.prefix
+            child.record[0][key] = toPreserves($ns.href)
+          ns = ns.next
+
+      if not xn.properties.isNil:
+        if child.record.len < 1:
+          child.record.add initDictionary()
+        var attr = xn.properties
+        while not attr.isNil:
+          var
+            key = toPreserves($attr.name)
+            val = toPreserves(attr.content)
+          child.record[0][key] = val
+          attr = attr.next
+      if not xn.children.isNil:
+        preserveSiblings(child.record, xn.children)
+      child.record.add tosymbol($xn.name)
+      result.add child
+    of XML_TEXT_NODE:
+      result.add textContent(xn).toPreserves
+    else:
+      stderr.writeLine "not an XML_ELEMENT_NODE - ", $xn.type
+    xn = xn.next
+
+proc toPreservesHook*(xn: xmlNodePtr): Value =
+  var items = newSeqofCap[Value](1)
+  preserveSiblings(items, xn)
+  items[0]
+
+proc spawnXsltActor*(turn: Turn; root: Cap): Actor {.discardable.} =
+  spawnActor(turn, "xslt") do (turn: Turn):
+    initLibXml()
+    during(turn, root, ?:XsltArguments) do (ds: Cap):
+      let sheetsPat = observePattern(!XsltTransform, {@[%0]: grab(), @[%1]: grab()})
+      during(turn, ds, sheetsPat) do (stylesheet: Literal[string], input: Literal[string]):
+        let cur = loadStylesheet(stylesheet.value)
+        if cur.isNil:
+          stderr.writeLine "failed to parse stylesheet"
+        else:
+          let doc = loadXmlDoc(input.value)
+          if doc.isNil:
+            stderr.writeLine "failed to parse input document"
+          else:
+            let
+              params = allocCStringArray([])
+              res = xsltApplyStylesheet(cur, doc, params)
+            if res.isNil:
+              stderr.writeLine "failed to apply stylesheet transformation"
+            else:
+              let output = xsltSaveResultToString(res, cur)
+              deallocCStringArray(params)
+              publish(turn, ds, XsltTransform(
+                  stylesheet: stylesheet.value,
+                  input: input.value,
+                  output: xmlDocGetRootElement(res).toPreservesHook,
+                ))
+              xmlFreeDoc(res)
+            xmlFreeDoc(doc)
+          xsltFreeStylesheet(cur)
+
+when isMainModule:
+  import syndicate/relays
+  runActor("main") do (turn: Turn):
+    resolveEnvironment(turn) do (turn: Turn; ds: Cap):
+      spawnXsltActor(turn, ds)

syndicate_utils.nimble

@@ -1,13 +1,61 @@
-# Package
+# Emulate Nimble from CycloneDX data at sbom.json.
 
-version = "20231130"
+import std/json
-author        = "Emery Hemingway"
-description   = "Utilites for Syndicated Actors and Synit"
-license       = "unlicense"
-srcDir        = "src"
-bin           = @["cache_actor", "json_socket_translator", "json_translator", "mintsturdyref", "mount_actor", "msg", "net_mapper", "preserve_process_environment", "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()
 
-# Dependencies
+let
+  sbom = "sbom.json".readFile.parseJson
+  comp = sbom{"metadata", "component"}
+  bomRef = comp{"bom-ref"}.getStr
 
-requires "nim >= 1.6.6", "illwill", "syndicate >= 20231108"
+version = comp{"version"}.getStr
+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