syndicate_utils: 20240530 -> 20240610

DBus is a mess that we shouldn't get involved in. If you need DBus then use a
tool that can start DBus as it might be expected and then extract the
communication endpoints with the preserve_process_environment utility.

https://git.syndicate-lang.org/ehmry/syndicate_utils#preserve_process_environment

README.md

@@ -1,58 +1,11 @@
 # Syndicate Nix flake
 
+Add as a Nix channel.
+```sh
+$ doas nix-channel --add https://git.syndicate-lang.org/ehmry/syndicate-flake/archive/trunk.tar.gz syndicate
+```
+
 To add to your local flake registry:
 ```sh
-nix registry add syndicate "git+https://git.syndicate-lang.org/ehmry/syndicate-flake?ref=trunk"
-```
-
-## NixOS service
-
-### Importing
-To import the NixOS module:
-```nix
-{
-  # /etc/nixos/flake.nix
-  inputs.syndicate.url = "git+https://git.syndicate-lang.org/ehmry/syndicate-flake?ref=trunk";
-
-  outputs = { self, nixpkgs, syndicate }: {
-
-    nixosConfigurations.myhost = nixpkgs.lib.nixosSystem {
-      system = "x86_64-linux";
-      modules = [
-        ./configuration.nix
-        syndicate.nixosModules.syndicate-server
-      ];
-    };
-
-  };
-
-}
-```
-
-If `/etc/nixos` is not a flake then you may be able to use the `getFlake` builtin
-to retrieve the module.
-```nix
-{ config, lib, pkgs, ... }:
-
-{
-  imports = [ (builtins.getFlake "syndicate").nixosModules.syndicate-server ];
-}
-```
-
-## Configuration
-```nix
-{ config, lib, pkgs, ... }:
-
-{
-  services.syndicate-server = {
-    enable = true;
-    # A socket at /run/syndicate/ds is enable by default.
-    tcpListeners = [{
-      address = "127.0.0.1";
-      port = 3232;
-    }];
-  };
-
-}
-
+$ nix registry add syndicate "git+https://git.syndicate-lang.org/ehmry/syndicate-flake"
 ```

build-nim-sbom.nix

@@ -0,0 +1,196 @@
+{
+  lib,
+  stdenv,
+  fetchgit,
+  fetchzip,
+  runCommand,
+  xorg,
+  nim,
+  nimOverrides,
+}:
+
+let
+  fetchers = {
+    fetchzip =
+      { url, sha256, ... }:
+      fetchzip {
+        name = "source";
+        inherit url sha256;
+      };
+    fetchgit =
+      {
+        fetchSubmodules ? false,
+        leaveDotGit ? false,
+        rev,
+        sha256,
+        url,
+        ...
+      }:
+      fetchgit {
+        inherit
+          fetchSubmodules
+          leaveDotGit
+          rev
+          sha256
+          url
+          ;
+      };
+  };
+
+  filterPropertiesToAttrs =
+    prefix: properties:
+    lib.pipe properties [
+      (builtins.filter ({ name, ... }: (lib.strings.hasPrefix prefix name)))
+      (map (
+        { name, value }:
+        {
+          name = lib.strings.removePrefix prefix name;
+          inherit value;
+        }
+      ))
+      builtins.listToAttrs
+    ];
+
+  buildNimCfg =
+    { backend, components, ... }:
+    let
+      componentSrcDirs = map (
+        { properties, ... }:
+        let
+          fodProps = filterPropertiesToAttrs "nix:fod:" properties;
+          fod = fetchers.${fodProps.method} fodProps;
+          srcDir = fodProps.srcDir or "";
+        in
+        if srcDir == "" then fod else "${fod}/${srcDir}"
+      ) components;
+    in
+    runCommand "nim.cfg"
+      {
+        outputs = [
+          "out"
+          "src"
+        ];
+        nativeBuildInputs = [ xorg.lndir ];
+      }
+      ''
+        pkgDir=$src/pkg
+        cat << EOF >> $out
+        backend:${backend}
+        path:"$src"
+        path:"$pkgDir"
+        EOF
+        mkdir -p "$pkgDir"
+        ${lib.strings.concatMapStrings (d: ''
+          lndir "${d}" "$pkgDir"
+        '') componentSrcDirs}
+      '';
+
+  buildCommands = lib.attrsets.mapAttrsToList (
+    output: input: ''
+      nim compile $nimFlags --out:${output} ${input}
+    ''
+  );
+
+  installCommands = lib.attrsets.mapAttrsToList (
+    output: input: ''
+      install -Dt $out/bin ${output}
+    ''
+  );
+in
+
+callerArg: sbomArg:
+
+let
+  applySbom =
+    {
+      passthru ? { },
+      ...
+    }@prevAttrs:
+    let
+      sbom = lib.attrsets.recursiveUpdate (
+        if builtins.isAttrs sbomArg then sbomArg else builtins.fromJSON (builtins.readFile sbomArg)
+      ) passthru.sbom or { };
+
+      properties = # SBOM metadata.component.properties as an attrset.
+        lib.attrsets.recursiveUpdate (builtins.listToAttrs sbom.metadata.component.properties)
+          passthru.properties or { };
+
+      nimBin = # A mapping of Nim module file paths to names of programs.
+        lib.attrsets.recursiveUpdate (lib.pipe properties [
+          (lib.attrsets.filterAttrs (name: value: lib.strings.hasPrefix "nim:bin:" name))
+          (lib.attrsets.mapAttrs' (
+            name: value: {
+              name = lib.strings.removePrefix "nim:bin:" name;
+              value = "${properties."nim:binDir" or (properties."nim:srcDir" or ".")}/${value}";
+            }
+          ))
+        ]) passthru.nimBin or { };
+    in
+    {
+      strictDeps = true;
+
+      pname = prevAttrs.pname or sbom.metadata.component.name;
+      version = prevAttrs.version or sbom.metadata.component.version or null;
+
+      configurePhase =
+        prevAttrs.configurePhase or ''
+          runHook preConfigure
+          echo "nim.cfg << $nimCfg"
+          cat $nimCfg >> nim.cfg
+          cat << EOF >> nim.cfg
+          nimcache:"$NIX_BUILD_TOP/nimcache"
+          parallelBuild:$NIX_BUILD_CORES
+          EOF
+          runHook postConfigure
+        '';
+
+      buildPhase =
+        prevAttrs.buildPhase or ''
+          runHook preBuild
+          ${lib.strings.concatLines (buildCommands nimBin)}
+          runHook postBuild
+        '';
+
+      installPhase =
+        prevAttrs.installPhase or ''
+          runHook preInstall
+          ${lib.strings.concatLines (installCommands nimBin)}
+          runHook postInstall
+        '';
+
+      nativeBuildInputs = (prevAttrs.nativeBuildInputs or [ ]) ++ [ nim ];
+
+      nimCfg =
+        prevAttrs.nimCfg or (buildNimCfg {
+          backend = prevAttrs.nimBackend or properties."nim:backend" or "c";
+          inherit (sbom) components;
+        });
+
+      passthru = {
+        inherit sbom properties nimBin;
+      };
+    };
+
+  applyOverrides =
+    prevAttrs:
+    builtins.foldl' (
+      prevAttrs:
+      { name, ... }@component:
+      if (builtins.hasAttr name nimOverrides) then
+        prevAttrs // (nimOverrides.${name} component prevAttrs)
+      else
+        prevAttrs
+    ) prevAttrs prevAttrs.passthru.sbom.components;
+
+  composition =
+    finalAttrs:
+    let
+      callerAttrs = if builtins.isAttrs callerArg then callerArg else callerArg finalAttrs;
+      sbomAttrs = callerAttrs // (applySbom callerAttrs);
+      overrideAttrs = sbomAttrs // (applyOverrides sbomAttrs);
+    in
+    overrideAttrs;
+in
+stdenv.mkDerivation composition
+
+# TODO: Add an overrideSbom function into the result..

default.nix

@@ -0,0 +1,8 @@
+{
+  pkgs ? null,
+}:
+let
+  overlay = import ./overlay.nix;
+  pkgs' = if pkgs == null then import <nixpkgs> { overlays = [ overlay ]; } else pkgs.extend overlay;
+in
+builtins.intersectAttrs (overlay { } { }) pkgs'

flake.lock

@@ -1,74 +1,23 @@
 {
   "nodes": {
-    "flake-utils": {
-      "locked": {
-        "lastModified": 1623875721,
-        "narHash": "sha256-A8BU7bjS5GirpAUv4QA+QnJ4CceLHkcXdRp4xITDB0s=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "f7e004a55b120c02ecb6219596820fcd32ca8772",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1636723036,
-        "narHash": "sha256-zFuu3TTj/NLq3NPJ8pprlmkOpjAoW3AWQNac3UFkCG8=",
-        "owner": "nixos",
+        "lastModified": 1717196966,
+        "narHash": "sha256-yZKhxVIKd2lsbOqYd5iDoUIwsRZFqE87smE2Vzf6Ck0=",
+        "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "50a1ef0f59752623af884f5085e3d5e8bd806c77",
+        "rev": "57610d2f8f0937f39dbd72251e9614b1561942d8",
         "type": "github"
       },
       "original": {
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "50a1ef0f59752623af884f5085e3d5e8bd806c77",
-        "type": "github"
-      }
-    },
-    "nixpkgs_2": {
-      "locked": {
-        "lastModified": 1628186154,
-        "narHash": "sha256-r2d0wvywFnL9z4iptztdFMhaUIAaGzrSs7kSok0PgmE=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "06552b72346632b6943c8032e57e702ea12413bf",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "type": "github"
+        "id": "nixpkgs",
+        "ref": "57610d2f8f09",
+        "type": "indirect"
       }
     },
     "root": {
       "inputs": {
-        "nixpkgs": "nixpkgs",
-        "rust": "rust"
-      }
-    },
-    "rust": {
-      "inputs": {
-        "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs_2"
-      },
-      "locked": {
-        "lastModified": 1630548746,
-        "narHash": "sha256-SLzeWhEN0kRDTzL+AHfDxwbYEZm09UEcdIcPDdOIZew=",
-        "owner": "oxalica",
-        "repo": "rust-overlay",
-        "rev": "00f6332f8c690480c7b7137fb8b1f069e7b2e18a",
-        "type": "github"
-      },
-      "original": {
-        "owner": "oxalica",
-        "repo": "rust-overlay",
-        "type": "github"
+        "nixpkgs": "nixpkgs"
       }
     }
   },

flake.nix

@@ -1,38 +1,88 @@
 {
   description = "Syndicate utilities";
 
-  inputs.rust.url = "github:oxalica/rust-overlay";
+  inputs.nixpkgs.url = "nixpkgs/57610d2f8f09";
 
-  inputs.nixpkgs.url = "github:nixos/nixpkgs/50a1ef0f59752623af884f5085e3d5e8bd806c77";
+  outputs =
+    { self, nixpkgs }:
+    {
+      lib = nixpkgs.lib.extend (import ./lib.nix);
 
-  outputs = { self, nixpkgs, rust }:
-    let
-      forEachSystem = nixpkgs.lib.genAttrs [ "aarch64-linux" "x86_64-linux" ];
-      libOverlay = import ./lib.nix;
-    in {
-      lib = nixpkgs.lib.extend libOverlay;
+      overlays.default = import ./overlay.nix;
 
-      overlay = final: prev:
-        let rust' = (prev.extend rust.overlay).rust-bin.nightly.latest.default;
-        in {
-          lib = prev.lib.extend libOverlay;
-          preserves-nim = final.callPackage ./preserves-nim { };
-          preserves-tools =
-            final.callPackage ./preserves-tools { rust = rust'; };
-          syndicate-rs = final.callPackage ./syndicate-rs { rust = rust'; };
-        };
+      legacyPackages = self.lib.mapAttrs (system: pkgs: pkgs.extend self.overlays.default) {
+        inherit (nixpkgs.legacyPackages) aarch64-linux x86_64-linux;
+      };
 
-      packages = forEachSystem (system:
-        let pkgs = nixpkgs.legacyPackages.${system}.extend self.overlay;
-        in with pkgs; { inherit preserves-nim preserves-tools syndicate-rs; });
+      packages = self.lib.mapAttrs (
+        system: pkgs: with pkgs; {
+          inherit
+            # fontconfig_actor
+            libnotify_actor
+            noise-c
+            preserves-tools
+            squeak
+            squeaker
+            syndicate-server
+            syndicated-open
+            syndicate_utils
+            ;
+          preserves-py = python3Packages.preserves;
+          syndicate-py = python3Packages.syndicate-py;
+        }
+      ) self.legacyPackages;
 
+      nixosModules.default = self.nixosModules.syndicate-server;
       nixosModules.syndicate-server =
         # A little hack to apply our overlay to this module only.
-        let f = import ./nixos/syndicate-server.nix;
-        in { config, lib, pkgs, ... }:
-        f {
+        {
+          config,
+          lib,
+          pkgs,
+          ...
+        }:
+        (import ./nixos/syndicate-server.nix) {
           inherit config lib;
-          pkgs = pkgs.extend self.overlay;
+          pkgs = pkgs.extend self.overlays.default;
         };
+
+      devShells = self.lib.mapAttrs (
+        system: pkgs: with pkgs; {
+          default = mkShell { packages = builtins.attrValues self.packages.${system}; };
+        }
+      ) self.legacyPackages;
+
+      checks = self.lib.mapAttrs (
+        system: pkgs':
+        with import (nixpkgs + "/nixos/lib/testing-python.nix") {
+          inherit system;
+          pkgs = pkgs';
+        }; {
+          simple = simpleTest {
+            name = "http";
+            nodes.machine =
+              { config, pkgs, ... }:
+              {
+                imports = [ self.nixosModules.syndicate-server ];
+
+                nixpkgs.pkgs = pkgs';
+
+                services.syndicate.tty1 = {
+                  enable = true;
+                  user = "loser";
+                  config = [ ];
+                };
+                users.users.loser.isNormalUser = true;
+              };
+            testScript = ''
+              machine.wait_for_job("syndicate-tty1")
+            '';
+          };
+        }
+      ) { inherit (self.legacyPackages) x86_64-linux; };
+
+      hydraJobs.packages.aarch64-linux = {
+        inherit (self.packages.aarch64-linux) syndicate_utils;
+      };
     };
 }

lib.nix

@@ -1,39 +1,14 @@
 final: prev:
-let lib = final;
-in with lib; {
+let
+  lib = final;
+in
+with lib;
+{
 
-  generators = with final.generators;
-    prev.generators // {
-
-      # Generates Preserves from an arbitrary value.
-      # Records are generated for functions that take
-      # a single formal argument `toRecord` and return
-      # a list of values.
-      toPreserves = { }@args:
-        let
-          toPreserves' = toPreserves args;
-          concatItems = toString;
-        in v:
-        if isAttrs v then
-          "{ ${
-            concatItems (lib.attrsets.mapAttrsToList
-              (key: val: "${key}: ${toPreserves' val}") v)
-          } }"
-        else if isList v then
-          "[ ${concatItems (map toPreserves' v)} ]"
-        else if isBool v then
-          (if v then "#t" else "#f")
-        else if isFunction v then
-          (if (lib.functionArgs v) == { toRecord = false; } then
-            let items = v { toRecord = null; };
-            in "<${head items} ${toString (map toPreserves' (tail items))}>"
-          else
-            abort
-            "generators.toPreserves: cannot convert a function to Preserves")
-        else if isNull v then
-          "null"
-        else
-          builtins.toJSON v;
+  generators =
+    with final.generators;
+    prev.generators
+    // {
+      toPreserves = throw "moved to https://git.syndicate-lang.org/ehmry/nix-processmgmt/src/branch/synit/nixproc/backends/synit";
     };
-
 }

nixos/syndicate-server.nix

@@ -1,102 +1,129 @@
-{ config, lib, pkgs, ... }:
-with lib;
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
 
 {
-  options.services.syndicate-server = {
-    enable = mkEnableOption "the Syndicate dataspace server";
-
-    group = mkOption {
-      type = types.str;
-      default = "wheel";
-      example = "users";
-      description = "Group account under which the Syndicate server runs.";
+  options.services.syndicate = lib.mkOption {
+    default = { };
+    example = {
+      tty1 = {
+        enable = true;
+        user = "jane";
+        config = [ "/etc/syndicate" ];
+      };
     };
+    description = ''
+      Syndicate dataspace server instances.
+      If the key is in the form of "tty''${N}" it will
+      be attached to the appropriate teletypewriter.
+    '';
+    type = lib.types.attrsOf (
+      lib.types.submodule {
+        options = {
+          enable = lib.mkEnableOption "this Syndicate dataspace server instance";
 
-    package = mkOption {
-      default = pkgs.syndicate-rs;
-      defaultText = "pkgs.syndicate-rs";
-      type = types.package;
-      description = "The package to use for the Syndicate dataspace server.";
-    };
-
-    tcpListeners = mkOption {
-      default = [ ];
-      example = [{
-        address = "0.0.0.0";
-        port = 8001;
-      }];
-      type = with types;
-        listOf (submodule {
-          options = {
-            address = mkOption { type = str; };
-            port = mkOption { type = port; };
+          user = lib.mkOption {
+            type = lib.types.str;
+            example = "jane";
+            description = "User account under which the Syndicate server runs.";
           };
-        });
-      description = "TCP ports to listen for connections on.";
-    };
 
-    unixListeners = mkOption {
-      default = [ "/run/syndicate/ds" ];
-      type = types.listOf types.path;
-      description = "Sockets to listen for connections on.";
-    };
+          package = lib.mkOption {
+            default = pkgs.syndicate-server;
+            defaultText = "pkgs.syndicate-server";
+            type = lib.types.package;
+            description = "The package to use for the Syndicate dataspace server.";
+          };
 
+          config = lib.mkOption {
+            type = lib.types.listOf lib.types.path;
+            description = "Configurations to load.";
+            example = [ "/etc/syndicate" ];
+          };
+        };
+      }
+    );
   };
 
-  config = let
-    cfg = config.services.syndicate-server;
-    configDir = "/run/syndicate/config";
-    requireServiceRelayListener = spec:
-      "<require-service <relay-listener ${spec}>>";
-  in mkIf cfg.enable {
+  config = {
 
-    systemd.services.syndicate-server = {
-      description = "Syndicate dataspace server";
-      wantedBy = [ "multi-user.target" ];
-      serviceConfig = {
-        ExecStartPre = "${pkgs.coreutils}/bin/mkdir -p ${configDir}";
-        ExecStart = "${cfg.package}/bin/syndicate-server --config ${configDir}";
-        Group = cfg.group;
-        AmbientCapabilities = [ "CAP_NET_BIND_SERVICE" ];
-        DynamicUser = true;
-        Restart = "always";
-        RuntimeDirectory = "syndicate";
-      };
-    };
-
-    systemd.services.syndicate-server-unix-listeners = {
-      description = "Configure Syndicate unix listeners";
-      after = [ "syndicate-server.service" ];
-      wantedBy = [ "multi-user.target" ];
-      serviceConfig = {
-        ExecStart = let
-          prsFile = builtins.toFile "unix-listeners.pr"
-            (lib.strings.concatMapStrings
-              (path: requireServiceRelayListener ''<unix "${path}">'')
-              cfg.unixListeners);
-        in "${pkgs.coreutils}/bin/cp ${prsFile} ${configDir}/nixos-unix-listeners.pr";
-        ExecStop =
-          "${pkgs.coreutils}/bin/rm ${configDir}/nixos-unix-listeners.pr";
-        RemainAfterExit = true;
-      };
-    };
-
-    systemd.services.syndicate-server-tcp-listeners = {
-      description = "Configure Syndicate TCP listeners";
-      after = [ "syndicate-server.service" "network.target" ];
-      wantedBy = [ "multi-user.target" ];
-      serviceConfig = {
-        ExecStart = let
-          prsFile = builtins.toFile "tcp-listeners.pr"
-            (lib.strings.concatMapStrings ({ address, port }:
-              requireServiceRelayListener
-              ''<tcp "${address}" ${toString port}>'') cfg.tcpListeners);
-        in "${pkgs.coreutils}/bin/cp ${prsFile} ${configDir}/nixos-tcp-listeners.pr";
-        ExecStop =
-          "${pkgs.coreutils}/bin/rm ${configDir}/nixos-tcp-listeners.pr";
-        RemainAfterExit = true;
-      };
-    };
+    systemd.services =
+      let
+        configure =
+          name: cfg:
+          let
+            configFile = lib.pipe cfg.config [
+              (lib.strings.concatMapStrings (dir: ''
+                <require-service <config-watcher "${dir}" $.>>
+              ''))
+              (pkgs.writeText "syndicate-nixos-config.pr")
+            ];
+          in
+          [
+            {
+              name = "syndicate-${name}";
+              value =
+                let
+                  serviceConfig = {
+                    RuntimeDirectory = name;
+                    ExecStart = "${cfg.package}/bin/syndicate-server --no-banner --config ${configFile}";
+                    User = cfg.user;
+                  };
+                in
+                {
+                  description = "Syndicate dataspace server";
+                  restartIfChanged = false;
+                  reloadIfChanged = false;
+                  wantedBy = [ "multi-user.target" ];
+                }
+                // (
+                  if builtins.match "tty[0-9]" name == null then
+                    { inherit serviceConfig; }
+                  else
+                    {
+                      after = [
+                        "systemd-user-sessions.service"
+                        "systemd-logind.service"
+                        "getty@${name}.service"
+                      ];
+                      wants = [
+                        "dbus.socket"
+                        "systemd-logind.service"
+                      ];
+                      conflicts = [ "getty@${name}.service" ];
+                      unitConfig.ConditionPathExists = "/dev/${name}";
+                      serviceConfig = serviceConfig // {
+                        PAMName = "login";
+                        StandardError = "journal";
+                        StandardInput = "tty-fail";
+                        StandardOutput = "journal";
+                        TTYPath = "/dev/${name}";
+                        TTYReset = "yes";
+                        TTYVHangup = "yes";
+                        TTYVTDisallocate = "yes";
+                        UtmpIdentifier = "%n";
+                        UtmpMode = "user";
+                        WorkingDirectory = "~";
+                      };
+                    }
+                );
+            }
+          ];
+        serverCfgs = lib.attrsets.filterAttrs (_: cfg: cfg.enable) config.services.syndicate;
+      in
+      lib.pipe serverCfgs [
+        (lib.attrsets.mapAttrsToList configure)
+        lib.lists.flatten
+        builtins.listToAttrs
+      ];
 
+    systemd.targets.multi-user.wants = lib.lists.flatten (
+      lib.attrsets.mapAttrsToList (
+        name: cfg: lib.optional cfg.enable "syndicate-${name}.service"
+      ) config.services.syndicate
+    );
   };
 }

overlay.nix

@@ -0,0 +1,59 @@
+final: prev:
+let
+  rustPkgs =
+    let
+      overlay = import (
+        prev.fetchFromGitHub {
+          owner = "oxalica";
+          repo = "rust-overlay";
+          rev = "a2ccfb2134622b28668a274e403ba6f075ae1223";
+          hash = "sha256-9honwiIeMbBKi7FzfEy89f1ShUiXz/gVxZSS048pKyc=";
+        }
+      );
+    in
+    final.extend overlay;
+
+  rust' = rustPkgs.rust-bin.nightly.latest.default;
+in
+{
+  lib = prev.lib.extend (import ./lib.nix);
+
+  acpi_actor = final.callPackage ./packages/acpi_actor { };
+
+  buildNimSbom = prev.buildNimSbom or final.callPackage ./build-nim-sbom.nix { };
+
+  fontconfig_actor = final.callPackage ./packages/fontconfig_actor { };
+
+  libnotify_actor = final.callPackage ./packages/libnotify_actor { };
+
+  nix_actor = final.callPackage ./packages/nix_actor { };
+
+  noiseprotocol = final.callPackage ./packages/nim/noiseprotocol { };
+
+  syndicate_utils = final.callPackage ./packages/syndicate_utils-nim { };
+
+  syndicated-open = final.callPackage ./packages/syndicated-open { };
+
+  noise-c = final.callPackage ./packages/noise-c { };
+
+  preserves-tools = final.callPackage ./packages/preserves-tools { };
+
+  python3Packages = prev.python3Packages.overrideScope (
+    final': prev': {
+      preserves = final'.callPackage ./packages/preserves-py { };
+      syndicate-py = final'.callPackage ./packages/syndicate-py { };
+      synit-daemons = final'.callPackage ./packages/synit-daemons-py { };
+    }
+  );
+
+  sqlite_actor = final.callPackage ./packages/sqlite_actor { };
+
+  squeak = final.callPackage ./packages/squeak { };
+  squeaker = final.python3Packages.callPackage ./packages/squeaker { };
+
+  syndicate-server = final.callPackage ./packages/syndicate-server { rust = rust'; };
+
+  synit-pid1 = final.callPackage ./packages/synit-pid1 { };
+
+  xapian_actor = final.callPackage ./packages/xapian_actor { };
+}

packages/acpi_actor/default.nix

@@ -0,0 +1,25 @@
+{
+  lib,
+  buildNimPackage,
+  fetchFromGitea,
+}:
+
+buildNimPackage (finalAttrs: {
+  pname = "acpi_actor";
+  version = "20231010";
+
+  src = fetchFromGitea {
+    domain = "git.syndicate-lang.org";
+    owner = "ehmry";
+    repo = pname;
+    rev = finalAttrs.version;
+    hash = "sha256-eN3VC2yL6UvjeIGvzx0PAujR/Xd6Rc1e9Ftf6fKKk2E=";
+  };
+
+  lockFile = "${src}/lock.json";
+
+  meta = src.meta // {
+    maintainers = [ lib.maintainers.ehmry ];
+    license = lib.licenses.unlicense;
+  };
+})

packages/fontconfig_actor/default.nix

@@ -0,0 +1,31 @@
+{
+  lib,
+  buildNimPackage,
+  fetchFromGitea,
+  fontconfig,
+  pkg-config,
+}:
+
+buildNimPackage rec {
+  pname = "fontconfig_actor";
+  version = "20231021";
+
+  src = fetchFromGitea {
+    domain = "git.syndicate-lang.org";
+    owner = "ehmry";
+    repo = pname;
+    rev = version;
+    hash = "sha256-3LRIsZ6NA+E799/z6PGb4wH3CgJ6lx2CgKH/CzEuSzQ=";
+  };
+
+  nativeBuildInputs = [ pkg-config ];
+  buildInputs = [ fontconfig ];
+
+  lockFile = "${src}/lock.json";
+
+  meta = src.meta // {
+    description = "Syndicate actor for asserting Fontconfig information";
+    maintainers = [ lib.maintainers.ehmry ];
+    license = lib.licenses.unlicense;
+  };
+}

packages/libnotify_actor/default.nix

@@ -0,0 +1,30 @@
+{
+  lib,
+  buildNimPackage,
+  fetchFromGitea,
+  libnotify,
+  pkg-config,
+}:
+
+buildNimPackage rec {
+  pname = "libnotify_actor";
+  version = "20231130";
+
+  src = fetchFromGitea {
+    domain = "git.syndicate-lang.org";
+    owner = "ehmry";
+    repo = pname;
+    rev = version;
+    hash = "sha256-PNRscNm3axhEr1O2QGLs9JBH35err34y3wc9arPxZ5c=";
+  };
+
+  propagatedNativeBuildInputs = [ pkg-config ];
+  propagatedBuildInputs = [ libnotify ];
+
+  lockFile = "${src}/lock.json";
+
+  meta = src.meta // {
+    maintainers = [ lib.maintainers.ehmry ];
+    license = lib.licenses.unlicense;
+  };
+}

packages/nim/noiseprotocol/default.nix

@@ -0,0 +1,19 @@
+{
+  lib,
+  buildNimPackage,
+  noise-c,
+}:
+
+buildNimPackage rec {
+  pname = "noise";
+  version = "20230509";
+
+  src = null;
+
+  propagatedBuildInputs = [ noise-c ];
+
+  meta = {
+    inherit (noise-c.meta) license;
+    maintainers = [ lib.maintainers.ehmry ];
+  };
+}

packages/nix_actor/default.nix

@@ -0,0 +1,47 @@
+{
+  lib,
+  buildNimPackage,
+  fetchFromGitea,
+  fetchFromGitHub,
+  boost,
+  nix,
+  pkg-config,
+}:
+
+let
+  nix' = nix.overrideAttrs (
+    final: prev: {
+      src = fetchFromGitHub {
+        owner = "NixOS";
+        repo = "nix";
+        rev = "2.13.3";
+        hash = "sha256-jUc2ccTR8f6MGY2pUKgujm+lxSPNGm/ZAP+toX+nMNc=";
+      };
+    }
+  );
+in
+buildNimPackage rec {
+  pname = "nix_actor";
+  version = "20231009";
+
+  src = fetchFromGitea {
+    domain = "git.syndicate-lang.org";
+    owner = "ehmry";
+    repo = pname;
+    rev = version;
+    hash = "sha256-+wMhpmC1233Ze4+xnd5sNnIfsXkGEx67bZN3oMYu2EQ=";
+  };
+
+  lockFile = "${src}/lock.json";
+
+  propagatedNativeBuildInputs = [ pkg-config ];
+  propagatedBuildInputs = [
+    boost
+    nix'
+  ];
+
+  meta = src.meta // {
+    maintainers = [ lib.maintainers.ehmry ];
+    license = lib.licenses.unlicense;
+  };
+}

packages/noise-c/default.nix

@@ -0,0 +1,35 @@
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  autoreconfHook,
+}:
+
+stdenv.mkDerivation rec {
+  pname = "noise-c";
+  version = "20230309";
+  outputs = [
+    "bin"
+    "out"
+  ];
+  src = fetchFromGitHub {
+    owner = "rweather";
+    repo = pname;
+    rev = "ffa626bddd1f8182e47c634af686108ca5049e56";
+    hash = "sha256-HkcyV/WT4UNFWczbZZIDW2fWRliQb8IEykv2d7bZM7w=";
+  };
+
+  nativeBuildInputs = [ autoreconfHook ];
+
+  # excise protobuf bloat
+  prePatch = ''
+    substituteInPlace tools/Makefile.am \
+      --replace 'SUBDIRS = keytool protoc' 'SUBDIRS = keytool'
+  '';
+
+  meta = src.meta // {
+    description = "Plain C implementation of the Noise Protocol";
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ ehmry ];
+  };
+}

packages/preserves-py/default.nix

@@ -0,0 +1,26 @@
+{
+  lib,
+  buildPythonPackage,
+  fetchPypi,
+  python,
+  setuptools-scm,
+}:
+
+buildPythonPackage rec {
+  pname = "preserves";
+  version = "0.992.2";
+  pyproject = true;
+
+  src = fetchPypi {
+    inherit pname version;
+    hash = "sha256-VO9kN/nSB5K0LbpY6xjxgIUhZye/rX8gRxlHomUPRRk=";
+  };
+
+  nativeBuildInputs = [ setuptools-scm ];
+
+  meta = src.meta // {
+    description = "Preserves serialization format";
+    homepage = "https://preserves.dev/";
+    maintainers = with lib.maintainers; [ ehmry ];
+  };
+}

packages/preserves-tools/default.nix

@@ -1,22 +1,30 @@
-{ lib, rustPlatform, rust, fetchCrate }:
+{
+  lib,
+  rustPlatform,
+  rustc,
+  fetchCrate,
+}:
 
 rustPlatform.buildRustPackage rec {
   pname = "preserves-tool";
   # use the name of the actual utility so that
   # nix run …#preserves-tools works as expected.
 
-  version = "1.0.0";
+  version = "2.3.0";
   src = fetchCrate {
     pname = "preserves-tools"; # name of the crate
     inherit version;
-    sha256 = "10vy7pmdbxkcwbr1qwqqv1lfi622pk8ncbp1hn5jrddxrv92q4ph";
+    sha256 = "sha256-I9dqY2pej/HRQg2VGkEoWKOlo4c9TYwk/jw23eN1nlU=";
   };
-  cargoHash = "sha256-h6ulvjTDTj8/fmzEn1YgZKmze4jwpmGjcSq78hmq2cU=";
-  nativeBuildInputs = [ rust ];
+  cargoHash = "sha256-0UMGDoyfdEJQQDoUadbU6Ev6yA2k0sQHRvO/Z+4QF5g=";
+  nativeBuildInputs = [ rustc ];
+
+  RUSTC_BOOTSTRAP = true;
 
   meta = {
     description = "Swiss army knife for working with Preserves documents";
     homepage = "https://preserves.gitlab.io/preserves/doc/preserves-tool.html";
     maintainers = with lib.maintainers; [ ehmry ];
+    mainProgram = "preserves-tool";
   };
 }

packages/sqlite_actor/default.nix

@@ -0,0 +1,30 @@
+{
+  lib,
+  buildNimPackage,
+  fetchFromGitea,
+  pkg-config,
+  sqlcipher,
+}:
+
+buildNimPackage rec {
+  pname = "sqlite_actor";
+  version = "20231010";
+
+  src = fetchFromGitea {
+    domain = "git.syndicate-lang.org";
+    owner = "ehmry";
+    repo = pname;
+    rev = version;
+    hash = "sha256-oKw5GUsK1F2RegOFiNYkLXT5CvtWcF/8H6QdE4DXa1A=";
+  };
+
+  propagatedNativeBuildInputs = [ pkg-config ];
+  propagatedBuildInputs = [ sqlcipher ];
+
+  lockFile = "${src}/lock.json";
+
+  meta = src.meta // {
+    maintainers = [ lib.maintainers.ehmry ];
+    license = lib.licenses.unlicense;
+  };
+}

packages/squeak/default.nix

@@ -0,0 +1,94 @@
+{
+  lib,
+  stdenv,
+  fetchurl,
+  autoPatchelfHook,
+  makeWrapper,
+  unzip,
+  alsa-lib,
+  libGL,
+  libpulseaudio,
+  libuuid,
+  nas,
+  openssl,
+  pango,
+  sndio,
+  xorg,
+}:
+
+let
+  versionA = "6.0";
+  versionB = "22104";
+  versionC = "202206021410";
+  bits =
+    with stdenv.hostPlatform;
+    if is32bit then
+      "32"
+    else if is64bit then
+      "64"
+    else
+      throw "too many addressing bits";
+  sources = {
+    i686-linux = fetchurl {
+      url = "http://files.squeak.org/${versionA}/Squeak${versionA}-${versionB}-${bits}bit/Squeak${versionA}-${versionB}-${bits}bit-${versionC}-Linux-x86.tar.gz";
+      sha256 = "sha256-6o9GCeNsHV+OhHBUCqBmslgUEBrS3XPwsl/p8zgfJQs=";
+    };
+    x86_64-linux = fetchurl {
+      url = "http://files.squeak.org/${versionA}/Squeak${versionA}-${versionB}-${bits}bit/Squeak${versionA}-${versionB}-${bits}bit-${versionC}-Linux-x64.tar.gz";
+      sha256 = "sha256-pgTdFyqAQo3K6Th2FXL8Op1hakjcL4rJ6wnKuIlFZ9g=";
+    };
+  };
+in
+stdenv.mkDerivation rec {
+  pname = "squeak";
+  version = "${versionA}-${versionB}-${versionC}";
+
+  src = sources.${stdenv.system};
+
+  nativeBuildInputs = [
+    autoPatchelfHook
+    makeWrapper
+    unzip
+  ];
+
+  buildInputs = with xorg; [
+    alsa-lib
+    libGL
+    libICE
+    libSM
+    libX11
+    libXext
+    libXrender
+    libpulseaudio
+    libuuid
+    nas
+    pango
+    sndio
+  ];
+
+  dontBuild = true;
+
+  installPhase = ''
+    mkdir -p $out/bin
+    cp -a bin $out/lib
+    cp -a shared/* $out/lib
+    makeWrapper $out/lib/squeak $out/bin/squeak \
+      --prefix LD_LIBRARY_PATH ":" "$out/lib:${lib.makeLibraryPath [ openssl ]}" \
+      --set SQUEAK_IMAGE $out/lib/Squeak${versionA}-${versionB}-${bits}bit.image
+  '';
+
+  preFixup = ''
+    patchelf $out/lib/vm-sound-sndio.so \
+      --replace-needed libsndio.so.6.1 libsndio.so
+  '';
+  meta = {
+    description = "Squeak virtual machine and image";
+    homepage = "https://squeak.org/";
+    license = with lib.licenses; [
+      asl20
+      mit
+    ];
+    maintainers = with lib.maintainers; [ ehmry ];
+    platforms = builtins.attrNames sources;
+  };
+}

packages/squeaker/default.nix

@@ -0,0 +1,36 @@
+{
+  lib,
+  buildPythonApplication,
+  fetchFromGitHub,
+}:
+
+buildPythonApplication rec {
+  pname = "squeaker";
+  version = "unstable-2022-03-04";
+
+  src = fetchFromGitHub {
+    owner = "tonyg";
+    repo = pname;
+    rev = "caf2ef0b6d5c3cd211b966d3933d4baa885676b5";
+    hash = "sha256-DXYKT3buaQ0WfebNwdGT3s2eAAKpndmZ3TczCD/alH0=";
+  };
+
+  # TODO: could inject squeak into the wrapper,
+  # but for now let the environment pick the VM
+  # propagatedBuildInputs = [ squeak ];
+
+  dontBuild = true;
+  doCheck = false;
+
+  installPhase = ''
+    runHook preInstall
+    install -Dt $out/bin squeaker
+    runHook postInstall
+  '';
+
+  meta = src.meta // {
+    description = "Like Docker, but for Squeak";
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ ehmry ];
+  };
+}

packages/syndicate-py/default.nix

@@ -0,0 +1,30 @@
+{
+  lib,
+  buildPythonPackage,
+  fetchPypi,
+  setuptools-scm,
+  preserves,
+  websockets,
+}:
+
+buildPythonPackage rec {
+  pname = "syndicate-py";
+  version = "0.15.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    hash = "sha256-ePCjzy5ros4H3rp0EszjUiUMCbPmNLWlXCaYcqSui0k=";
+  };
+
+  buildInputs = [ setuptools-scm ];
+  propagatedBuildInputs = [
+    preserves
+    websockets
+  ];
+
+  meta = src.meta // {
+    description = "Syndicated Actor model for Python";
+    homepage = "https://syndicate-lang.org";
+    maintainers = with lib.maintainers; [ ehmry ];
+  };
+}

packages/syndicate-server/default.nix

@@ -0,0 +1,35 @@
+# https://git.syndicate-lang.org/synit/synit/src/branch/main/packaging/packages/syndicate-server/APKBUILD
+
+{
+  lib,
+  rustPlatform,
+  rust,
+  fetchFromGitea,
+  pkg-config,
+  openssl,
+}:
+
+rustPlatform.buildRustPackage rec {
+  pname = "syndicate-server";
+  version = "0.45.0";
+  src = fetchFromGitea {
+    domain = "git.syndicate-lang.org";
+    owner = "syndicate-lang";
+    repo = "syndicate-rs";
+    rev = "${pname}-v${version}";
+    sha256 = "sha256-jyZlio+wo9YiaiIKCl6YC9Bym89fqUkJOqhBb0Nu/zQ=";
+  };
+  cargoHash = "sha256-WMX1GPU9GyXNP5qng6PGX++5PLvdViECTr8KPNkF4ps=";
+  nativeBuildInputs = [
+    rust
+    pkg-config
+  ];
+  buildInputs = [ openssl ];
+
+  meta = {
+    description = "Syndicate broker server";
+    homepage = "https://git.syndicate-lang.org/syndicate-lang/syndicate-rs/";
+    mainProgram = "syndicate-server";
+    maintainers = with lib.maintainers; [ ehmry ];
+  };
+}

packages/syndicate_utils-nim/default.nix

@@ -0,0 +1,35 @@
+{
+  lib,
+  buildNimSbom,
+  fetchFromGitea,
+  postgresql,
+  sqlite,
+  libxml2,
+  libxslt,
+  openssl,
+}:
+
+buildNimSbom (finalAttrs: {
+  pname = "syndicate_utils";
+  version = "20240610";
+  src = fetchFromGitea {
+    domain = "git.syndicate-lang.org";
+    owner = "ehmry";
+    repo = "syndicate_utils";
+    rev = finalAttrs.version;
+    hash = "sha256-qDbPjwq5ECJ5wGRCofVnDkE8NuvchtzYbbzgQShysYs=";
+  };
+  buildInputs = [
+    postgresql.out
+    sqlite
+    libxml2
+    libxslt
+    openssl
+  ];
+  meta = finalAttrs.src.meta // {
+    description = "Utilities for the Syndicated Actor Model";
+    homepage = "https://git.syndicate-lang.org/ehmry/syndicate_utils";
+    maintainers = [ lib.maintainers.ehmry ];
+    license = lib.licenses.unlicense;
+  };
+}) ./sbom.json

packages/syndicate_utils-nim/sbom.json

@@ -0,0 +1,653 @@
+{
+  "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": "20240610",
+      "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-driver",
+          "value": "esc_printer_driver"
+        },
+        {
+          "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:bin:sqlite-actor",
+          "value": "sqlite_actor"
+        },
+        {
+          "name": "nim:srcDir",
+          "value": "src"
+        },
+        {
+          "name": "nim:backend",
+          "value": "c"
+        }
+      ]
+    }
+  },
+  "components": [
+    {
+      "type": "library",
+      "bom-ref": "pkg:nim/syndicate",
+      "name": "syndicate",
+      "version": "20240610",
+      "externalReferences": [
+        {
+          "url": "https://git.syndicate-lang.org/ehmry/syndicate-nim/archive/7bbcdb7e7705c2ab54ba0165565813d67aea48b0.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/mldff990wpr0v9v5qh6ggqjmc2mn3n8g-source"
+        },
+        {
+          "name": "nix:fod:rev",
+          "value": "7bbcdb7e7705c2ab54ba0165565813d67aea48b0"
+        },
+        {
+          "name": "nix:fod:sha256",
+          "value": "0mb3mrj5dkkqm0xp5hg84c5naaci4mi6mv2jjznfi6i7swp3f7vs"
+        },
+        {
+          "name": "nix:fod:url",
+          "value": "https://git.syndicate-lang.org/ehmry/syndicate-nim/archive/7bbcdb7e7705c2ab54ba0165565813d67aea48b0.tar.gz"
+        },
+        {
+          "name": "nix:fod:ref",
+          "value": "20240610"
+        },
+        {
+          "name": "nix:fod:srcDir",
+          "value": "src"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "pkg:nim/preserves",
+      "name": "preserves",
+      "version": "20240610",
+      "externalReferences": [
+        {
+          "url": "https://git.syndicate-lang.org/ehmry/preserves-nim/archive/560a6417a30a2dff63f24b62498e9fcac2de8354.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/0sszsmz84ppwqsgda8cmli4lfh2mjmin-source"
+        },
+        {
+          "name": "nix:fod:rev",
+          "value": "560a6417a30a2dff63f24b62498e9fcac2de8354"
+        },
+        {
+          "name": "nix:fod:sha256",
+          "value": "19r983fy7m54mlaj0adxdp8pxi1x8dp6phkcnr8rz5y5cwndfjx2"
+        },
+        {
+          "name": "nix:fod:url",
+          "value": "https://git.syndicate-lang.org/ehmry/preserves-nim/archive/560a6417a30a2dff63f24b62498e9fcac2de8354.tar.gz"
+        },
+        {
+          "name": "nix:fod:ref",
+          "value": "20240610"
+        },
+        {
+          "name": "nix:fod:srcDir",
+          "value": "src"
+        },
+        {
+          "name": "nix:fod:date",
+          "value": "2024-05-23T15:58:40+03:00"
+        },
+        {
+          "name": "nix:fod:hash",
+          "value": "sha256-JvdvLdPajDgIPbLblO0LbOm0wEp530fs8LYmgH885sk="
+        }
+      ]
+    },
+    {
+      "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"
+      ]
+    }
+  ]
+}

packages/syndicated-open/default.nix

@@ -0,0 +1,51 @@
+{
+  lib,
+  buildNimPackage,
+  fetchFromGitea,
+  makeDesktopItem,
+  pkg-config,
+  pcre,
+}:
+
+buildNimPackage rec {
+  pname = "syndicated-open";
+  version = "20231010";
+
+  src = fetchFromGitea {
+    domain = "git.syndicate-lang.org";
+    owner = "ehmry";
+    repo = pname;
+    rev = version;
+    hash = "sha256-DVBSsnN59XKV7Pc1spBxcLwyOIif3xMHXHID9khVJck=";
+  };
+
+  nativeBuildInputs = [ pkg-config ];
+  propagatedBuildInputs = [ pcre ];
+
+  lockFile = "${src}/lock.json";
+
+  desktopItem = makeDesktopItem rec {
+    name = "open";
+    desktopName = "Syndicated URI open";
+    exec = "${name} %U";
+    mimeTypes = [
+      "application/vnd.mozilla.xul+xml"
+      "application/xhtml+xml"
+      "text/html"
+      "text/xml"
+      "x-scheme-handler/http"
+      "x-scheme-handler/https"
+    ];
+  };
+
+  postInstall = ''
+    ln -s open $out/bin/xdg-open
+    cp -a $desktopItem/* $out/
+  '';
+
+  meta = src.meta // {
+    description = "Syndicated open command";
+    maintainers = [ lib.maintainers.ehmry ];
+    license = lib.licenses.unlicense;
+  };
+}

packages/synit-daemons-py/default.nix

@@ -0,0 +1,54 @@
+{
+  lib,
+  python3Packages,
+  fetchFromGitea,
+}:
+
+python3Packages.buildPythonApplication rec {
+  pname = "synit-python-daemons";
+  version = "2023-11-01";
+  format = "other";
+
+  src = fetchFromGitea {
+    domain = "git.syndicate-lang.org";
+    owner = "synit";
+    repo = "synit";
+    rev = "a2ecd8a4e441f8622a57a99987cb0aa5be9e1dcd";
+    hash = "sha256-M79AJ8/Synzm4CYkt3+GYViJLJcuYBW+x32Vfy+oFUM=";
+  };
+
+  sourceRoot = "${src.name}/packaging/packages/synit-config/files/usr/lib/synit/python/synit/daemon";
+
+  propagatedBuildInputs = with python3Packages; [
+    pyroute2
+    syndicate-py
+  ];
+
+  postPatch = ''
+    for f in *.py; do
+      substituteInPlace $f --replace \
+        "/home/tonyg/src/synit/protocols" \
+        "$out/share/syndicate-protocols"
+    done
+  '';
+
+  buildPhase = ''
+    runHook preBuild
+    for f in *.py; do
+      sed -i '1i #!/bin/python' $f
+    done
+    runHook postBuild
+  '';
+
+  installPhase = ''
+    runHook preInstall
+    for f in *.py; do
+      bin_name=$f
+      bin_name=''${bin_name/.py}
+      bin_name=''${bin_name//_/-}
+      install --mode 0555 -D $f $out/bin/$bin_name
+    done
+    install -D -t $out/share/syndicate-protocols $src/protocols/schema-bundle.bin
+    runHook postInstall
+  '';
+}

packages/synit-pid1/default.nix

@@ -0,0 +1,44 @@
+# https://git.syndicate-lang.org/synit/synit/src/branch/main/packaging/packages/synit-pid1/APKBUILD
+
+{
+  lib,
+  rustPlatform,
+  rustc,
+  fetchFromGitea,
+}:
+
+rustPlatform.buildRustPackage rec {
+  pname = "synit-pid1";
+  version = "unstable-2023-11-01";
+  src = fetchFromGitea {
+    domain = "git.syndicate-lang.org";
+    owner = "synit";
+    repo = "synit";
+    rev = "a2ecd8a4e441f8622a57a99987cb0aa5be9e1dcd";
+    hash = "sha256-M79AJ8/Synzm4CYkt3+GYViJLJcuYBW+x32Vfy+oFUM=";
+  };
+
+  patchPhase =
+    # Patch to take children and configuration from /run/booted-system.
+    ''
+      runHook prePatch
+      substituteInPlace src/main.rs \
+        --replace '"/usr/bin/syndicate-server"' '"/run/booted-system/sw/bin/syndicate-server"' \
+        --replace '"/sbin/synit-log"' '"/run/booted-system/sw/bin/synit-log"' \
+        --replace '"/etc/syndicate/boot"' '"/run/booted-system/etc/syndicate/boot"' \
+
+      runHook postPatch
+    '';
+
+  sourceRoot = "source/${pname}";
+  cargoHash = "sha256-mO1gMtXEc34v9zBst1by1Ed8l/kvuJ9n4/6vJ1LhijM=";
+  nativeBuildInputs = [ rustc ];
+
+  RUSTC_BOOTSTRAP = true;
+
+  meta = src.meta // {
+    description = "Synit pid 1 program (patched for NixOS)";
+    homepage = "https://synit.org/";
+    maintainers = with lib.maintainers; [ ehmry ];
+  };
+}

packages/xapian_actor/default.nix

@@ -0,0 +1,32 @@
+{
+  lib,
+  buildNimPackage,
+  fetchFromGitea,
+  pkg-config,
+  syndicate,
+  xapian,
+}:
+
+buildNimPackage rec {
+  pname = "xapian_actor";
+  version = "20230610";
+
+  src = fetchFromGitea {
+    domain = "git.syndicate-lang.org";
+    owner = "ehmry";
+    repo = pname;
+    rev = version;
+    hash = "sha256-f/+l+c6SCvHH8zDz3/9ndrT77ck5gfk5zESKL74IfNg=";
+  };
+
+  propagatedNativeBuildInputs = [ pkg-config ];
+  propagatedBuildInputs = [
+    syndicate
+    xapian
+  ];
+
+  meta = src.meta // {
+    maintainers = [ lib.maintainers.ehmry ];
+    license = lib.licenses.unlicense;
+  };
+}

preserves-nim/default.nix

@@ -1,40 +0,0 @@
-{ lib, nimPackages, fetchFromGitea, fetchFromGitHub }:
-with nimPackages;
-
-let
-  compiler = fetchFromGitHub {
-    owner = "nim-lang";
-    repo = "nim";
-    rev = "v1.6.0";
-    hash = "sha256-C9oveXIufv0HqMQw6eNmLbku4Sd7r28PKcRILvKYzn0=";
-  };
-
-  npeg = fetchFromGitHub {
-    owner = "zevv";
-    repo = "npeg";
-    rev = "0.25.0";
-    hash = "sha256-E/0hCz0XsoAb/bAksqrKTyi8/FwBdP8kT6uUUAdru68=";
-  };
-
-in buildNimPackage rec {
-  outputs = [ "out" "dev" ];
-
-  pname = "preserves";
-  version = "3.0.0";
-  src = fetchFromGitea {
-    domain = "git.syndicate-lang.org";
-    owner = "ehmry";
-    repo = "preserves-nim";
-    rev = "v${version}";
-    sha256 = "sha256-YcWJkDJIo1UcXyqQTv82ebDeT03f5LqnuIKVtkvBClA=";
-  };
-  buildInputs = [ compiler npeg ];
-  postInstall = ''
-    pushd $out/bin
-    for link in preserves_decode preserves_from_json preserves_to_json;
-    do ln -s  preserves_encode $link
-    done
-    popd
-  '';
-  doCheck = true;
-}

syndicate-rs/default.nix

@@ -1,21 +0,0 @@
-{ lib, rustPlatform, rust, fetchgit, pkg-config, openssl }:
-
-rustPlatform.buildRustPackage rec {
-  pname = "syndicate-rs";
-  version = "2021-09-01";
-  src = fetchgit {
-    url = "https://git.syndicate-lang.org/syndicate-lang/syndicate-rs.git";
-    rev = "622115e13c69397dfa0beb433fdaf382949252b3";
-    sha256 = "sha256-7XcCiDlUntLRB0MLYk+57RSe4f6NyqRa/Jc42xrPOnQ=";
-  };
-  cargoHash = "sha256-sagyE3yCmSNwqgZrgnw1ar7S37iZhVYYpn3WtIoBIU8=";
-  nativeBuildInputs = [ rust pkg-config ];
-  buildInputs = [ openssl ];
-
-  meta = {
-    description =
-      "Rust implementation of Dataspaces, Syndicate, and a high-speed networked dataspace broker.";
-    homepage = "https://git.syndicate-lang.org/syndicate-lang/syndicate-rs/";
-    maintainers = with lib.maintainers; [ ehmry ];
-  };
-}