@almadar/std 17.0.2 → 17.1.0

package/behaviors/lolo/cli/atoms/std-orb-packages.lolo

@@ -6,7 +6,7 @@ app std-orb-packages [
   sys: [identity],
   fs: { cwd: "**": [read, write, create, remove], "/**": [read], "~/.orb/**": [read, write, create, remove], "~/.orb": [create] },
   net: { "registry.npmjs.org:443": [tcp] },
-  description: "std-orb-packages — the `orb list|add|update|remove [--global]` client of the npm registry (spec/cli/orb-packages.lolo; golden: orbital-cli packages.rs), bun-free. Packages live in <dir>/node_modules (dir = the working directory, or ~/.orb with --global) and the lockfile <dir>/<lockfile> holds { packages: [{ name, version, url, integrity }] }. Every command first reads the lockfile (absent = empty) and scans node_modules (scoped names included; the entry kind symlink is the workspace link), reading each package.json: a package is an orb package when it declares orbLanguage, orb, orbVocabulary or orbProgram.kind shell|desktop, and its kinds are those. list prints one row per orb package sorted by name (package 34, version 12, kinds 26, `ok`, ` (linked)`, ` [<prefix>/]`) or --json rows. remove refuses a behavior package whose prefix a .lolo or .orb file under the working directory still imports, deletes the package (a link is unlinked, never its target) and drops its lock entry. add parses name@exact-version (a range is refused ORB_PACKAGE_RANGE; a workspace-linked package is refused ORB_PACKAGE_LINKED) or a direct tarball URL (refused: it carries no integrity), and resolves name@version through GET <registry>/<name>/<version> (the npm version manifest: dist.tarball and dist.integrity). update reads the npm packument GET <registry>/<name> of every non-linked orb package and of every missing baseline package (an upgrade from nothing), and moves each to the newest stable, non-deprecated version above the installed one whose language is compatible: the running orb answers `orb --version` as `orb X.Y.Z (language R)` (any other form is refused) and keeps R; @almadar/core resolves first, and its candidate is compatible when its orbLanguage.version satisfies R; every other package is compatible when its language range (orb.language, orbLanguage.language, orbVocabulary.language or orbProgram.language, the first present) is satisfied by the target core language, the orbLanguage.version of the core version this update installs, else of the installed core; a version with no language is skipped ORB_PACKAGE_NO_LANGUAGE (compatibility is declared by the version itself, so one that declares nothing is never assumed compatible). The release version of orb is never compared with a package range. The tarball is downloaded from the registry knob (RegistryHttp) or the sourceOrigin knob (SourceHttp, one client per origin; any other host is refused ORB_PACKAGE_SOURCE), and its sha512 digest must equal the registry dist.integrity (sha512- plus base64, hash/sha): a different digest is refused `integrity-mismatch`, an unhashable one `integrity-unavailable`, and nothing is written or recorded. A verified tarball is gunzipped (maxUnpackedBytes) and read as a ustar archive (maxEntries) by the kernel; a codec refusal is ORB_PACKAGE_ARCHIVE (<code>), an entry outside package/ ORB_PACKAGE_LAYOUT. The files are written into node_modules/.orb-staging/<name>@<version> (mode 755 for executables, else 644), the old node_modules/<name> is renamed to node_modules/.orb-staging/<name>@<version>.old, the staging directory is renamed into place and only then is the backup removed (a failed rename into place renames the backup back and refuses the package ORB_PACKAGE_INSTALL, saying the previous version was restored; a failed restore names where the backup is kept; a leftover backup from an earlier crashed swap is never overwritten, it refuses the package); only then is the package's lock entry replaced and the lockfile written last. Every version may carry a top-level orbRelease block { severity security|critical|normal, advisory (one line), fixes (a semver range of the earlier versions it fixes) } in its registry manifest; no block is normal, and any other severity word is read as normal. update names, after the list rows, one `<severity> update: <name> <from> → <to>: <advisory>` line for each applied version whose own severity is security or critical. `orb update --urgent` (update only; with any other command it is refused with the usage line) installs only urgent updates: a package is urgent when some stable, non-deprecated version newer than the installed one is security or critical, declares a fixes range, the installed version satisfies that range (std-semver) and the version passes the language check above; the newest such version is installed through the same integrity check, staging swap and lockfile write, a baseline package that is not installed is never urgent, and stdout carries only the applied `<severity> update:` lines. An urgent version that fails the language check (ORB_PACKAGE_INCOMPATIBLE or ORB_PACKAGE_NO_LANGUAGE), whose fixes range std-semver refuses (ORB_PACKAGE_RELEASE), or that fails its download, integrity or install, is not applied: the installed version stays, the call answers 500, and stderr names the refusals and each confirmed-urgent advisory (a failed install leaves the old package in place, never half-installed). `orb update --global` also keeps this host's orb binary package (the orbPlatforms knob, matched on os/uname sysname and machine: @almadar/orb-darwin-arm64, -darwin-x64, -linux-x64, -linux-arm64, -windows-x64) installed like a baseline package, in the registry knob, with its own compatibility rule: it has no language range, so its newest stable, non-deprecated version is taken whose package.json declares orbReads, a range the target core language satisfies (a version without orbReads is skipped ORB_PACKAGE_NO_LANGUAGE; its orb and orbProgram blocks are not read); a package that declares orbReads is listed with kind `orb`; --urgent never installs it from nothing. A host that matches no entry, or whose os/uname fails (the Windows host does not implement it), prints one ORB_PACKAGE_PLATFORM line on stderr and no orb package is considered. Not yet ported: the kind-loads-for-this-orb problem column, the behaviors count, the update-check record and the engines subcommands; add does not remove a package that declares no orb kind."
+  description: "std-orb-packages — the `orb list|add|update|remove [--global]` client of the npm registry (spec/cli/orb-packages.lolo; golden: orbital-cli packages.rs), bun-free. Packages live in <dir>/node_modules (dir = the working directory, or ~/.orb with --global) and the lockfile <dir>/<lockfile> holds { packages: [{ name, version, url, integrity }] }. Every command first reads the lockfile (absent = empty) and scans node_modules (scoped names included; the entry kind symlink is the workspace link), reading each package.json: a package is an orb package when it declares orbLanguage, orb, orbVocabulary or orbProgram.kind shell|desktop, and its kinds are those. list prints one row per orb package sorted by name (package 34, version 12, kinds 26, `ok`, ` (linked)`, ` [<prefix>/]`) or --json rows. remove refuses a behavior package whose prefix a .lolo or .orb file under the working directory still imports, deletes the package (a link is unlinked, never its target) and drops its lock entry. add parses name@exact-version (a range is refused ORB_PACKAGE_RANGE; a workspace-linked package is refused ORB_PACKAGE_LINKED) or a direct tarball URL (refused: it carries no integrity), and resolves name@version through GET <registry>/<name>/<version> (the npm version manifest: dist.tarball and dist.integrity). update reads the npm packument GET <registry>/<name> of every non-linked orb package and of every missing baseline package (an upgrade from nothing), and moves each to the newest stable, non-deprecated version above the installed one whose language is compatible: the running orb answers `orb --version` as `orb X.Y.Z (language R)` (any other form is refused) and keeps R; @almadar/core resolves first, and its candidate is compatible when its orbLanguage.version satisfies R; every other package is compatible when its language range (orb.language, orbLanguage.language, orbVocabulary.language or orbProgram.language, the first present) is satisfied by the target core language, the orbLanguage.version of the core version this update installs, else of the installed core; a version with no language is skipped ORB_PACKAGE_NO_LANGUAGE (compatibility is declared by the version itself, so one that declares nothing is never assumed compatible). The release version of orb is never compared with a package range. The tarball is downloaded from the registry knob (RegistryHttp) or the sourceOrigin knob (SourceHttp, one client per origin; any other host is refused ORB_PACKAGE_SOURCE), and its sha512 digest must equal the registry dist.integrity (sha512- plus base64, hash/sha): a different digest is refused `integrity-mismatch`, an unhashable one `integrity-unavailable`, and nothing is written or recorded. A verified tarball is gunzipped (maxUnpackedBytes) and read as a ustar archive (maxEntries) by the kernel; a codec refusal is ORB_PACKAGE_ARCHIVE (<code>), an entry outside package/ ORB_PACKAGE_LAYOUT. The files are written into node_modules/.orb-staging/<name>@<version> (mode 755 for executables, else 644), the old node_modules/<name> is renamed to node_modules/.orb-staging/<name>@<version>.old, the staging directory is renamed into place and only then is the backup removed (a failed rename into place renames the backup back and refuses the package ORB_PACKAGE_INSTALL, saying the previous version was restored; a failed restore names where the backup is kept; a leftover backup from an earlier crashed swap is never overwritten, it refuses the package); only then is the package's lock entry replaced and the lockfile written last. Every version may carry a top-level orbRelease block { severity security|critical|normal, advisory (one line), fixes (a semver range of the earlier versions it fixes) } in its registry manifest; no block is normal, and any other severity word is read as normal. update names, after the list rows, one `<severity> update: <name> <from> → <to>: <advisory>` line for each applied version whose own severity is security or critical. `orb update --urgent` (update only; with any other command it is refused with the usage line) installs only urgent updates: a package is urgent when some stable, non-deprecated version newer than the installed one is security or critical, declares a fixes range, the installed version satisfies that range (std-semver) and the version passes the language check above; the newest such version is installed through the same integrity check, staging swap and lockfile write, a baseline package that is not installed is never urgent, and stdout carries only the applied `<severity> update:` lines. An urgent version that fails the language check (ORB_PACKAGE_INCOMPATIBLE or ORB_PACKAGE_NO_LANGUAGE), whose fixes range std-semver refuses (ORB_PACKAGE_RELEASE), or that fails its download, integrity or install, is not applied: the installed version stays, the call answers 500, and stderr names the refusals and each confirmed-urgent advisory (a failed install leaves the old package in place, never half-installed). `orb update --global` also keeps this host's orb binary package (the orbPlatforms knob, matched on os/uname sysname and machine: @almadar/orb-darwin-arm64, -darwin-x64, -linux-x64, -linux-arm64, -windows-x64) installed like a baseline package, in the registry knob, with its own compatibility rule: it has no language range, so its newest stable, non-deprecated version is taken whose package.json declares orbReads, a range the target core language satisfies (a version without orbReads is skipped ORB_PACKAGE_NO_LANGUAGE; its orb and orbProgram blocks are not read); a package that declares orbReads is listed with kind `orb`; --urgent never installs it from nothing. A host that matches no entry, or whose os/uname fails (the Windows host does not implement it), prints one ORB_PACKAGE_PLATFORM line on stderr and no orb package is considered. A package whose package.json declares orbProgram also installs each of its optionalDependencies at its exact version whose registry manifest os and cpu include this host's (the os and cpu of the orbPlatforms entry os/uname matched, the npm platform rule; every add and update asks os/uname); a host os/uname cannot place installs none of them. Every file the package.json bin map names is written executable. Not yet ported: the kind-loads-for-this-orb problem column, the behaviors count, the update-check record and the engines subcommands; add does not remove a package that declares no orb kind."
 ]
 uses Spec from "almadar-std/orb-packages"
 uses Http from "std/behaviors/std-http-client"
@@ -17,18 +17,18 @@ type PackageKind = "language" | "behaviors" | "language pack" | "shell" | "deskt
 type PackageRow = { package : string!, kinds : [PackageKind]!, version : string!, path : string!, link : boolean!, prefix : string?, behaviors : number?, problem : string? }
 type LockEntry = { name : string!, version : string!, url : string!, integrity : string! }
 type BaselineEntry = { name : string!, registry : string! }
-type OrbPlatform = { sysname : string!, machine : string!, package : string! }
+type OrbPlatform = { sysname : string!, machine : string!, package : string!, os : string!, cpu : string! }
 type LockFile = { packages : [LockEntry]! }
-type PackageTarget = { name : string!, version : string!, url : string!, integrity : string!, severity : string?, advisory : string?, installedVersion : string? }
+type PackageTarget = { name : string!, version : string!, url : string!, integrity : string!, severity : string?, advisory : string?, installedVersion : string?, platform : boolean? }
 type Marker = { x : string? }
 type LanguageBlock = { version : string? }
 type OrbPackagesBlock = { prefix : string? }
 type ProgramBlock = { kind : string?, name : string? }
-type OrbPackagesManifest = { name : string?, version : string?, orbLanguage : LanguageBlock?, orb : OrbPackagesBlock?, orbVocabulary : Marker?, orbProgram : ProgramBlock?, orbReads : string? }
+type OrbPackagesManifest = { name : string?, version : string?, orbLanguage : LanguageBlock?, orb : OrbPackagesBlock?, orbVocabulary : Marker?, orbProgram : ProgramBlock?, orbReads : string?, optionalDependencies : Map string string?, bin : Map string string? }
 type NpmDist = { tarball : string!, integrity : string? }
 type NpmLanguage = { language : string?, version : string? }
 type NpmRelease = { severity : string?, advisory : string?, fixes : string? }
-type NpmManifest = { version : string!, deprecated : string?, dist : NpmDist?, orb : NpmLanguage?, orbLanguage : NpmLanguage?, orbVocabulary : NpmLanguage?, orbProgram : NpmLanguage?, orbRelease : NpmRelease?, orbReads : string? }
+type NpmManifest = { version : string!, deprecated : string?, dist : NpmDist?, orb : NpmLanguage?, orbLanguage : NpmLanguage?, orbVocabulary : NpmLanguage?, orbProgram : NpmLanguage?, orbRelease : NpmRelease?, orbReads : string?, os : [string]?, cpu : [string]? }
 type Packument = { name : string!, versions : Map string NpmManifest! }
 type Candidate = { version : string!, key : number!, language : string!, provides : string!, url : string!, integrity : string!, severity : string?, advisory : string?, fixes : string? }
 type Subject = { package : string!, version : string!, missing : boolean! }
@@ -107,6 +107,8 @@ orbital OrbPackagesOrbital {
     orbPackage : string = ""
     unamed : boolean = false
     platformNote : string = ""
+    hostOs : string = ""
+    hostCpu : string = ""
     placeError : string = ""
   }
 
@@ -176,6 +178,8 @@ orbital OrbPackagesOrbital {
         (set @entity.orbPackage "")
         (set @entity.unamed false)
         (set @entity.platformNote "")
+        (set @entity.hostOs "")
+        (set @entity.hostCpu "")
         (set @entity.lock [])
         (set @entity.pkgs [])
         (set @entity.rows [])
@@ -281,14 +285,14 @@ orbital OrbPackagesOrbital {
         (emit PKG_RM_NEXT { })
       PKG_DISPATCH -> ready when (and (not @entity.installed) (= @entity.cmd "add") (= (array/len @entity.args) 0))
         (emit PACKAGES_ANSWERED { status: 400, body: "", stderr: "usage: orb add <package, an at sign and an exact version | tarball url> [--global]" })
-      PKG_DISPATCH -> resolving when (and (not @entity.installed) (= @entity.cmd "add") (> (array/len @entity.args) 0))
+      PKG_DISPATCH -> resolving when (and (not @entity.installed) (= @entity.cmd "add") (> (array/len @entity.args) 0) @entity.unamed)
         (set @entity.targets [])
         (set @entity.cursor 0)
         (emit PKG_PLAN_ADD { })
-      PKG_DISPATCH -> resolving when (and (not @entity.installed) (= @entity.cmd "update") (and @entity.global (not @entity.urgent) (not @entity.unamed)))
+      PKG_DISPATCH -> resolving when (and (not @entity.installed) (or (= @entity.cmd "update") (and (= @entity.cmd "add") (> (array/len @entity.args) 0))) (not @entity.unamed))
         (set @entity.targets [])
         (os/uname { key: "uname" emit: { success: PKG_UNAME, failure: PKG_UNAME_FAILED } })
-      PKG_DISPATCH -> resolving when (and (not @entity.installed) (= @entity.cmd "update") (not (and @entity.global (not @entity.urgent) (not @entity.unamed))))
+      PKG_DISPATCH -> resolving when (and (not @entity.installed) (= @entity.cmd "update") @entity.unamed)
         (set @entity.targets [])
         (set @entity.subjects (let ((all (array/concat (array/map (array/filter @entity.rows (fn r (not (object/get @r "link")))) (fn r { package: (object/get @r "package"), version: (object/get @r "version"), missing: false })) (if @entity.urgent [] (array/map (array/filter (array/concat @config.baseline (if (!= @entity.orbPackage "") [{ name: @entity.orbPackage, registry: @config.registry }] [])) (fn b (and (= (array/len (array/filter @entity.rows (fn r (= (object/get @r "package") (object/get @b "name"))))) 0) (= (object/get @b "registry") @config.registry)))) (fn b { package: (object/get @b "name"), version: "0.0.0", missing: true })))))) (array/concat (array/filter @all (fn s (= (object/get @s "package") @config.corePackage))) (array/filter @all (fn s (!= (object/get @s "package") @config.corePackage))))))
         (set @entity.refused (if @entity.urgent [] (array/map (array/filter (array/concat @config.baseline (if (!= @entity.orbPackage "") [{ name: @entity.orbPackage, registry: @config.registry }] [])) (fn b (and (= (array/len (array/filter @entity.rows (fn r (= (object/get @r "package") (object/get @b "name"))))) 0) (!= (object/get @b "registry") @config.registry)))) (fn b (str/concat (object/get @b "name") ": ORB_PACKAGE_SOURCE (baseline registry " (object/get @b "registry") " is not the registry knob)")))))
@@ -486,13 +490,15 @@ orbital OrbPackagesOrbital {
       INIT -> resolving
       PKG_UNAME -> dispatching
         (set @entity.unamed true)
-        (set @entity.orbPackage (object/get (default (array/find @config.orbPlatforms (fn x (and (= (object/get @x "sysname") @payload.sysname) (= (object/get @x "machine") @payload.machine)))) { sysname: "", machine: "", package: "" }) "package"))
-        (set @entity.platformNote (if (= (object/get (default (array/find @config.orbPlatforms (fn x (and (= (object/get @x "sysname") @payload.sysname) (= (object/get @x "machine") @payload.machine)))) { sysname: "", machine: "", package: "" }) "package") "") (str/concat "orb: ORB_PACKAGE_PLATFORM (" @payload.sysname " " @payload.machine " has no orb platform package in the orbPlatforms knob; the orb binary was not considered)") ""))
+        (set @entity.hostOs (object/get (default (array/find @config.orbPlatforms (fn x (and (= (object/get @x "sysname") @payload.sysname) (= (object/get @x "machine") @payload.machine)))) { sysname: "", machine: "", package: "", os: "", cpu: "" }) "os"))
+        (set @entity.hostCpu (object/get (default (array/find @config.orbPlatforms (fn x (and (= (object/get @x "sysname") @payload.sysname) (= (object/get @x "machine") @payload.machine)))) { sysname: "", machine: "", package: "", os: "", cpu: "" }) "cpu"))
+        (set @entity.orbPackage (if (and @entity.global (= @entity.cmd "update") (not @entity.urgent)) (object/get (default (array/find @config.orbPlatforms (fn x (and (= (object/get @x "sysname") @payload.sysname) (= (object/get @x "machine") @payload.machine)))) { sysname: "", machine: "", package: "", os: "", cpu: "" }) "package") ""))
+        (set @entity.platformNote (if (or (not (and @entity.global (= @entity.cmd "update") (not @entity.urgent))) (!= (object/get (default (array/find @config.orbPlatforms (fn x (and (= (object/get @x "sysname") @payload.sysname) (= (object/get @x "machine") @payload.machine)))) { sysname: "", machine: "", package: "", os: "", cpu: "" }) "package") "")) "" (str/concat "orb: ORB_PACKAGE_PLATFORM (" @payload.sysname " " @payload.machine " has no orb platform package in the orbPlatforms knob; the orb binary was not considered)")))
         (emit PKG_DISPATCH { })
       PKG_UNAME_FAILED -> dispatching
         (set @entity.unamed true)
         (set @entity.orbPackage "")
-        (set @entity.platformNote (str/concat "orb: ORB_PACKAGE_PLATFORM (the platform could not be determined: " (default @payload.error "") "; the orb binary was not considered)"))
+        (set @entity.platformNote (if (and @entity.global (= @entity.cmd "update") (not @entity.urgent)) (str/concat "orb: ORB_PACKAGE_PLATFORM (the platform could not be determined: " (default @payload.error "") "; the orb binary was not considered)") ""))
         (emit PKG_DISPATCH { })
       PKG_BACKUP_NEXT -> resolving when (and @entity.hadOld @entity.global)
         (os/rmdir (str/concat "~/.orb/node_modules/" (str/concat @entity.stage ".old")) true { key: "backupclear" emit: { success: PKG_BACKUP_GONE, failure: PKG_BACKUP_GONE } })
@@ -609,8 +615,11 @@ orbital OrbPackagesOrbital {
         (emit PKG_DOWNLOAD { url: (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "url") })
       PKG_TARGET_NEXT -> resolving when (and (< @entity.cursor (array/len @entity.targets)) (= (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "url") ""))
         (emit PK_GET { key: "resolve", method: "GET", target: (str/concat "/" (str/join (str/split (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "name") "/") "%2f") "/" (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "version")), headers: [{ name: "accept", value: "application/json" }], body: (bytes/from-string ""), stream: "none" })
-      PKG_RESOLVED -> downloading when (and (!= @entity.mf null) (!= (object/get @entity.mf "dist") null))
-        (set @entity.targets (array/map (array/range 0 (array/len @entity.targets)) (fn i (if (= @i @entity.cursor) { name: (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "name"), version: (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "version"), url: (default (object/get (default (object/get @entity.mf "dist") { tarball: "" }) "tarball") ""), integrity: (default (object/get (default (object/get @entity.mf "dist") { tarball: "" }) "integrity") "") } (default (array/nth @entity.targets @i) { name: "", version: "", url: "", integrity: "" })))))
+      PKG_RESOLVED -> resolving when (and (default (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "platform") false) (!= @entity.mf null) (not (and (array/includes (default (object/get @entity.mf "os") []) @entity.hostOs) (array/includes (default (object/get @entity.mf "cpu") []) @entity.hostCpu))))
+        (set @entity.cursor (+ @entity.cursor 1))
+        (emit PKG_TARGET_NEXT { })
+      PKG_RESOLVED -> downloading when (and (!= @entity.mf null) (!= (object/get @entity.mf "dist") null) (not (and (default (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "platform") false) (not (and (array/includes (default (object/get @entity.mf "os") []) @entity.hostOs) (array/includes (default (object/get @entity.mf "cpu") []) @entity.hostCpu))))))
+        (set @entity.targets (array/map (array/range 0 (array/len @entity.targets)) (fn i (if (= @i @entity.cursor) { name: (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "name"), version: (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "version"), url: (default (object/get (default (object/get @entity.mf "dist") { tarball: "" }) "tarball") ""), integrity: (default (object/get (default (object/get @entity.mf "dist") { tarball: "" }) "integrity") ""), platform: (default (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "platform") false) } (default (array/nth @entity.targets @i) { name: "", version: "", url: "", integrity: "" })))))
         (emit PKG_DOWNLOAD { url: (default (object/get (default (object/get @entity.mf "dist") { tarball: "" }) "tarball") "") })
       PKG_RESOLVED -> resolving when (or (= @entity.mf null) (= (object/get @entity.mf "dist") null))
         (set @entity.refused (array/append @entity.refused (str/concat (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "name") " version " (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "version") ": ORB_PACKAGE_NOT_FOUND (registry answered " @payload.status ")")))
@@ -684,7 +693,7 @@ orbital OrbPackagesOrbital {
         (set @entity.cursor (+ @entity.cursor 1))
         (emit PKG_TARGET_NEXT { })
       PKG_UNTARRED -> installing when (and (!= @entity.tar null) (default (object/get @entity.tar "ok") false))
-        (set @entity.files (default (object/get @entity.tar "entries") []))
+        (set @entity.files (let ((es (default (object/get @entity.tar "entries") []))) (let ((pj (array/find @es (fn e (= (object/get @e "path") "package/package.json"))))) (let ((bins (if (= @pj null) [] (let ((m (json/parse (default (bytes/to-string (object/get @pj "data")) "") OrbPackagesManifest))) (if (= @m null) [] (array/map (object/entries (default (object/get @m "bin") {})) (fn b (str/concat "package/" (str/replace-pattern (default (array/nth @b 1) "") "^\\./" ""))))))))) (array/map @es (fn e { path: (object/get @e "path"), data: (object/get @e "data"), executable: (or (object/get @e "executable") (array/includes @bins (object/get @e "path"))) }))))))
         (set @entity.tar null)
         (emit PKG_LAYOUT { })
       PKG_LAYOUT -> resolving when (or (= (array/len @entity.files) 0) (> (array/len (array/filter @entity.files (fn e (not (str/startsWith (object/get @e "path") "package/"))))) 0))
@@ -761,7 +770,8 @@ orbital OrbPackagesOrbital {
         (set @entity.lock (array/append (array/filter @entity.lock (fn l (!= (object/get @l "name") (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "name")))) { name: (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "name"), version: (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "version"), url: (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "url"), integrity: (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "integrity") }))
         (set @entity.lockDirty true)
         (set @entity.applied (if (array/includes ["security", "critical"] (default (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "severity") "normal")) (array/append @entity.applied (str/concat (default (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "severity") "") " update: " (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "name") " " (default (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "installedVersion") "") " → " (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "version") ": " (default (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "advisory") ""))) @entity.applied))
-        (set @entity.done (array/append @entity.done (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "name")))
+        (set @entity.done (if (default (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "platform") false) @entity.done (array/append @entity.done (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "name"))))
+        (set @entity.targets (let ((pj (array/find @entity.files (fn e (= (object/get @e "path") "package/package.json"))))) (let ((m (if (= @pj null) null (json/parse (default (bytes/to-string (object/get @pj "data")) "") OrbPackagesManifest)))) (if (or (= @m null) (= (object/get @m "orbProgram") null) (= @entity.hostOs "")) @entity.targets (array/concat @entity.targets (array/map (object/entries (default (object/get @m "optionalDependencies") {})) (fn d { name: (array/nth @d 0), version: (array/nth @d 1), url: "", integrity: "", platform: true })))))))
         (set @entity.files [])
         (set @entity.tarball (bytes/from-string ""))
         (emit PACKAGE_INSTALLED { name: (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "name"), version: (object/get (default (array/nth @entity.targets @entity.cursor) { name: "", version: "", url: "", integrity: "" }) "version"), kinds: [] })
@@ -1076,7 +1086,7 @@ orbital OrbPackagesOrbital {
       baseline : [BaselineEntry] = [{ name: (quote "@almadar/core"), registry: "https://registry.npmjs.org" }, { name: (quote "@almadar/std"), registry: "https://registry.npmjs.org" }, { name: (quote "@almadar/lolo-ar"), registry: "https://registry.npmjs.org" }, { name: (quote "@almadar/lolo-sl"), registry: "https://registry.npmjs.org" }, { name: (quote "@almadar/orb-shell-typescript"), registry: "https://registry.npmjs.org" }]
         @label "Baseline"
         @description "The packages `orb update` installs when missing, each resolved like an upgrade from nothing: the newest stable, non-deprecated version whose language is compatible (core: its orbLanguage.version is in the range this orb reads; any other package: its language range accepts the core language this update installs, else the installed one), read from its registry."
-      orbPlatforms : [OrbPlatform] = [{ sysname: "Darwin", machine: "arm64", package: (quote "@almadar/orb-darwin-arm64") }, { sysname: "Darwin", machine: "x86_64", package: (quote "@almadar/orb-darwin-x64") }, { sysname: "Linux", machine: "x86_64", package: (quote "@almadar/orb-linux-x64") }, { sysname: "Linux", machine: "aarch64", package: (quote "@almadar/orb-linux-arm64") }, { sysname: "Linux", machine: "arm64", package: (quote "@almadar/orb-linux-arm64") }, { sysname: "Windows_NT", machine: "AMD64", package: (quote "@almadar/orb-windows-x64") }]
+      orbPlatforms : [OrbPlatform] = [{ sysname: "Darwin", machine: "arm64", package: (quote "@almadar/orb-darwin-arm64"), os: "darwin", cpu: "arm64" }, { sysname: "Darwin", machine: "x86_64", package: (quote "@almadar/orb-darwin-x64"), os: "darwin", cpu: "x64" }, { sysname: "Linux", machine: "x86_64", package: (quote "@almadar/orb-linux-x64"), os: "linux", cpu: "x64" }, { sysname: "Linux", machine: "aarch64", package: (quote "@almadar/orb-linux-arm64"), os: "linux", cpu: "arm64" }, { sysname: "Linux", machine: "arm64", package: (quote "@almadar/orb-linux-arm64"), os: "linux", cpu: "arm64" }, { sysname: "Windows_NT", machine: "AMD64", package: (quote "@almadar/orb-windows-x64"), os: "win32", cpu: "x64" }]
         @label "Orb platform packages"
         @description "The orb binary's own package per platform, keyed by the sysname and machine os/uname answers. `orb update --global` (not --urgent) asks os/uname and resolves the entry that matches this host like a baseline package, in the registry knob, but on its own compatibility rule: an orb platform package has no language range, so a version is compatible when its package.json declares orbReads, a range of core languages, and the target core language satisfies it (a version with no orbReads is skipped ORB_PACKAGE_NO_LANGUAGE). A host that matches no entry, or whose os/uname fails, gets one loud ORB_PACKAGE_PLATFORM line on stderr and no orb package is considered."
       maxUnpackedBytes : number = 536870912

package/behaviors/lolo/cli/atoms/std-orb-serve.lolo

@@ -3,10 +3,11 @@ app std-orb-serve [
   inbound: ["cli-serve"],
   env: ["HOME", "FIREBASE_AUTH_EMULATOR_HOST", "FIREBASE_PROJECT_ID"],
   fs: { "~/.almadar/serve": [create], "~/.almadar/serve/**": [write, create, read], cwd: ".orbital": [create], cwd: ".orbital/serve": [create], cwd: ".orbital/serve/**": [write, create] },
-  description: "std-orb-serve — the `orb serve <file> [--port N] [--host H] [--no-mock] [--client-dir DIR] [--open] [--no-emulators]` command (spec/cli/orb-serve.lolo; port of orbital-cli program_command.rs serve_program and server_overrides). It resolves the app with program/read { resolve: true, path }. An app that declares its own http endpoint is composed alone, and --port, --host or --client-dir is refused (status 400): its server's options are set in the program. Without --client-dir the app gets a browser client prepared first: program/eval generate { mode: client, webClient: true } compiles it client-mode into <cwd>/.orbital/serve/<app> and lays the typescript shell's prebuilt web client, with the app's runtime files over it, out in .orbital/serve/<app>/web-client, which becomes the clientDir; when FIREBASE_AUTH_EMULATOR_HOST and FIREBASE_PROJECT_ID are both set, that folder's __/firebase/init.json names the Auth emulator for the page. Otherwise it writes ~/.almadar/serve/<app path with / as _>.server.lolo, which imports std-http-server's HttpServerOrbital with the serve options as its call-site config (host, port, portFromEnv false and, with --client-dir made absolute against the working directory and required to lie under it, clientDir relative to the working directory), resolves it with program/read so each knob reaches the trait bodies, and composes the app with std-http-server's resolved program (behavior/resolve, for its header grants) carrying that configured orbital, adding the listen grant for host:port and the anchored cwd read grant of the client dir. The compose, prepare-client and answer half is std-orb-serve-handoff's ServeHandoff, which std-orb-launchpad composes as well. The command never runs the program: it answers a hand-off the bootloader acts on, status 200 with headers orb-run: server, orb-app: the absolute app path, and the composed program's JSON as the body. --open and --no-emulators answer status 500 on stderr with the texts the Rust command bailed with; a port that is not an integer in 0..65535 answers status 400 on stderr; a client dir outside the working directory, an app that names no app or a program that does not resolve or compose answers status 500 on stderr `Error: <reason>`; a missing or second file or an unknown flag answers the usage (status 400, exit 2). Defaults: port 3030, host 127.0.0.1. The resolved app is written (with its catalogs and lazy behaviors) to ~/.almadar/serve/<app path with / as _>.orb, the directory read from the HOME env grant and written under the fs grant ~/.almadar/serve/**; orb-app names that file, so the bootloader finds the catalogs."
+  description: "std-orb-serve — the `orb serve <file> [--port N] [--host H] [--no-mock] [--client-dir DIR] [--open] [--no-emulators]` command (spec/cli/orb-serve.lolo; port of orbital-cli program_command.rs serve_program and server_overrides). It resolves the app with program/read { resolve: true, path }. An app that declares its own http endpoint is composed alone, and --port, --host or --client-dir is refused (status 400): its server's options are set in the program. Without --client-dir the app gets a browser client prepared first: program/eval generate { mode: client, webClient: true } compiles it client-mode into <cwd>/.orbital/serve/<app> and lays the typescript shell's prebuilt web client, with the app's runtime files over it, out in .orbital/serve/<app>/web-client, which becomes the clientDir; when FIREBASE_AUTH_EMULATOR_HOST and FIREBASE_PROJECT_ID are both set, that folder's __/firebase/init.json names the Auth emulator for the page. Otherwise it writes ~/.almadar/serve/<app path with / as _>.server.lolo, which imports std-http-server's HttpServerOrbital with the serve options as its call-site config (host, port, portFromEnv false and, with --client-dir made absolute against the working directory and required to lie under it, clientDir relative to the working directory), resolves it with program/read so each knob reaches the trait bodies, and composes the app with std-http-server's resolved program (behavior/resolve, for its header grants) carrying that configured orbital, adding the listen grant for host:port and the anchored cwd read grant of the client dir. The compose, prepare-client and answer half is std-orb-serve-handoff's ServeHandoff, which std-orb-launchpad composes as well. The command never runs the program: it answers a hand-off the bootloader acts on, status 200 with headers orb-run: server, orb-app: the absolute app path, and the composed program's JSON as the body. --open and --no-emulators answer status 500 on stderr with the texts the Rust command bailed with; a port that is not an integer in 0..65535 answers status 400 on stderr; a client dir outside the working directory, an app that names no app or a program that does not resolve or compose answers status 500 on stderr `Error: <reason>`; a missing or second file or an unknown flag answers the usage (status 400, exit 2). Defaults: port 3030, host 127.0.0.1. The resolved app is written (with its catalogs and lazy behaviors) to ~/.almadar/serve/<app path with / as _>.orb, the directory read from the HOME env grant and written under the fs grant ~/.almadar/serve/**; orb-app names that file, so the bootloader finds the catalogs. Unless --no-mock, and when the app does not already seed itself, the server program also composes std-mock-page-seed, and, when the app declares an [identity] entity no trait of it signs in, std-dev-personas over that entity (std-mock-seed-marks answers both texts), so the seeder can sign each owner in and the session starts as the first declared role."
 ]
 uses Spec from "almadar-std/orb-serve"
 uses Args from "std/behaviors/std-args"
+uses Marks from "std/behaviors/std-mock-seed-marks"
 uses Handoff from "std/behaviors/std-orb-serve-handoff"
 type OrbCommandArgs = { argv : [string]!, cwd : string! }
 type ArgFlag = { name : string!, aliases : [string]!, takesValue : boolean!, repeatable : boolean! }
@@ -47,6 +48,12 @@ orbital OrbServeOrbital {
     }
   }
 
+  trait MarksCli = Marks.traits.MarksCheck {
+    listens {
+      ServeEngine.SERVE_SEED_ASK -> MARKS_CHECK
+    }
+  }
+
   trait OrbServe -> ServeRun [optimistic] {
     initial: ready
 
@@ -222,8 +229,12 @@ orbital OrbServeOrbital {
 
     state writing {
       INIT -> writing
-      SERVE_WRITE_SERVER -> writing
-        (emit SERVE_SEED_DECIDED { seed: (if (and @entity.mock (not (array/some (object/get @entity.app "orbitals" []) (fn o (array/some (object/get @o "auxiliaryEntities" []) (fn e (= (object/get @e "collection" "") "mock_seed_marks"))))))) "uses Seed from \"std/behaviors/std-mock-page-seed\"\norbital MockData = Seed.orbitals.MockData {}\n" "") })
+      SERVE_WRITE_SERVER -> writing when (not @entity.mock)
+        (emit SERVE_SEED_DECIDED { seed: "" })
+      SERVE_WRITE_SERVER -> writing when @entity.mock
+        (emit SERVE_SEED_ASK { program: @entity.app })
+      SERVE_SEED_MARKED -> writing
+        (emit SERVE_SEED_DECIDED { seed: (if @payload.marked "" (str/concat "uses Seed from \"std/behaviors/std-mock-page-seed\"\norbital MockData = Seed.orbitals.MockData {}\n" @payload.personas)) })
       SERVE_SEED_DECIDED -> resolving
         (os/write-file (str/concat "~/.almadar/serve/" @entity.serverName) (bytes/from-string (str/concat
           "app orb-served-server [version: \"1.0.0\"]\n"
@@ -286,6 +297,11 @@ orbital OrbServeOrbital {
       SERVE_WRITE_SERVER { }
         @description "Write the server program, std-http-server imported with the serve options as its call-site config."
         @tier "internal"
+      SERVE_SEED_ASK {
+        program : ServeProgram!
+      }
+        @description "Ask std-mock-seed-marks whether the resolved app already declares the MockSeedMark store."
+        @tier "internal"
       SERVE_SEED_DECIDED {
         seed : string!
       }
@@ -350,6 +366,10 @@ orbital OrbServeOrbital {
       }
         @description "Compose the app with std-http-server."
       OrbServe.SERVE_START -> SERVE_START
+      MarksCli.MARKS_CHECKED -> SERVE_SEED_MARKED
+      SERVE_SEED_MARKED { marked : boolean!  personas : string! }
+        @description "std-mock-seed-marks's MARKS_CHECKED: whether the app already declares the marks store, and the personas text that composes std-dev-personas onto the app's identity entity (empty when there is none)."
+        @tier "internal"
       SERVE_SEED_DECIDED { seed : string! }
         @description "The seed decision, which the server program write reads."
         @tier "internal"
@@ -363,5 +383,5 @@ orbital OrbServeOrbital {
     }
   }
 
-  page boot as OrbServePage -> OrbServe, ArgsCli, ServeEngine, ServeHandoff
+  page boot as OrbServePage -> OrbServe, ArgsCli, MarksCli, ServeEngine, ServeHandoff
 }

package/behaviors/lolo/codec/atoms/std-lolo-kotlin.lolo

@@ -19,7 +19,7 @@ orbital LoloKotlinOrbital {
     config {
       language: "Kotlin"
       requiresTypes: false
-      operators: { "/": "_div({{0}}, {{1}})", "%": "_mod({{0}}, {{1}})", "math/mod": "_mod({{0}}, {{1}})", "=": "_eq({{0}}, {{1}})", "==": "_eq({{0}}, {{1}})", "!=": "(!_eq({{0}}, {{1}}))", "default": "_default({{0}}, {{1}})", "as": "{{0}}", "list": "listOf({{*}})", "str/len": "_strLen({{0}}).toDouble()", "str/upper": "{{0}}.uppercase()", "str/lower": "{{0}}.lowercase()", "str/trim": "{{0}}.trim()", "str/trimStart": "{{0}}.trimStart()", "str/trimEnd": "{{0}}.trimEnd()", "str/capitalize": "_capitalize({{0}})", "str/split": "_split({{0}}, {{1}})", "str/join": "_join({{0}}, {{1}})", "str/concat": "_concat({{*}})", "str/includes": "{{0}}.contains({{1}})", "str/startsWith": "{{0}}.startsWith({{1}})", "str/endsWith": "{{0}}.endsWith({{1}})", "str/replace": "{{0}}.replaceFirst({{1}}, {{2}})", "str/replaceAll": "{{0}}.replace({{1}}, {{2}})", "str/repeat": "{{0}}.repeat(_count({{1}}))", "str/reverse": "StringBuilder({{0}}).reverse().toString()", "str/slice#2": "_strSlice({{0}}, {{1}})", "str/slice#3": "_strSlice({{0}}, {{1}}, {{2}})", "str/padStart#2": "_padStart({{0}}, {{1}})", "str/padStart#3": "_padStart({{0}}, {{1}}, {{2}})", "str/padEnd#2": "_padEnd({{0}}, {{1}})", "str/padEnd#3": "_padEnd({{0}}, {{1}}, {{2}})", "str/truncate#2": "_truncate({{0}}, {{1}})", "str/truncate#3": "_truncate({{0}}, {{1}}, {{2}})", "str/to-int": "_toInt({{0}})", "array/len": "{{0}}.size.toDouble()", "array/avg#1": "_avg({{0}})", "array/max#1": "_amax({{0}})", "array/min#1": "_amin({{0}})", "array/first": "_first({{0}})", "array/last": "_last({{0}})", "array/nth": "_nth({{0}}, {{1}})", "array/range#2": "_range({{0}}, {{1}})", "array/range#3": "_range({{0}}, {{1}}, {{2}})", "array/slice#2": "_slice({{0}}, {{1}})", "array/slice#3": "_slice({{0}}, {{1}}, {{2}})", "array/take": "{{0}}.take(_count({{1}}))", "array/drop": "{{0}}.drop(_count({{1}}))", "array/takeLast": "{{0}}.takeLast(_count({{1}}))", "array/dropLast": "{{0}}.dropLast(_count({{1}}))", "array/append": "_append({{0}}, {{1}})", "array/prepend": "_prepend({{0}}, {{1}})", "array/includes": "{{0}}.contains({{1}})", "array/indexOf": "_indexOf({{0}}, {{1}})", "array/reverse": "{{0}}.reversed()", "array/unique": "{{0}}.distinct()", "array/flatten": "{{0}}.flatten()", "array/zip": "{{0}}.zip({{1}}).map { listOf(it.first, it.second) }", "array/sort#1": "_sort({{0}})", "array/reduce": "{{0}}.fold({{1}}, {{2}})", "array/filter": "{{0}}.filter({{1}})", "array/reject": "{{0}}.filterNot({{1}})", "array/find": "{{0}}.firstOrNull({{1}})", "array/findIndex": "{{0}}.indexOfFirst({{1}}).toDouble()", "math/abs": "Math.abs(({{0}}).toDouble())", "math/max": "maxOf({{*}})", "math/min": "minOf({{*}})", "math/round#1": "_round({{0}})", "math/round#2": "_round({{0}}, {{1}})", "math/sqrt": "_sqrt({{0}})", "math/ln": "_ln({{0}})", "math/log10": "_log10({{0}})", "math/pow": "_pow({{0}}, {{1}})", "math/sign": "Math.signum(({{0}}).toDouble())", "math/clamp": "Math.min(Math.max(({{0}}).toDouble(), ({{1}}).toDouble()), ({{2}}).toDouble())", "math/ceil": "Math.ceil(({{0}}).toDouble())", "math/floor": "Math.floor(({{0}}).toDouble())", "math/sin": "Math.sin(({{0}}).toDouble())", "math/cos": "Math.cos(({{0}}).toDouble())", "math/tan": "Math.tan(({{0}}).toDouble())", "math/atan": "Math.atan(({{0}}).toDouble())", "math/atan2": "Math.atan2(({{0}}).toDouble(), ({{1}}).toDouble())", "math/hypot": "Math.hypot(({{0}}).toDouble(), ({{1}}).toDouble())", "validate/required": "_required({{0}})", "validate/length": "(_strLen({{0}}).toDouble() == ({{1}}).toDouble())", "validate/minLength": "(_strLen({{0}}).toDouble() >= ({{1}}).toDouble())", "validate/maxLength": "(_strLen({{0}}).toDouble() <= ({{1}}).toDouble())", "validate/min": "(({{0}}).toDouble() >= ({{1}}).toDouble())", "validate/max": "(({{0}}).toDouble() <= ({{1}}).toDouble())", "validate/range": "(({{0}}).toDouble() in ({{1}}).toDouble()..({{2}}).toDouble())", "validate/oneOf": "{{1}}.contains({{0}})", "validate/equals": "_eq({{0}}, {{1}})" }
+      operators: { "object/get#2": "_get({{0}}, {{1}})", "/": "_div({{0}}, {{1}})", "%": "_mod({{0}}, {{1}})", "math/mod": "_mod({{0}}, {{1}})", "=": "_eq({{0}}, {{1}})", "==": "_eq({{0}}, {{1}})", "!=": "(!_eq({{0}}, {{1}}))", "default": "_default({{0}}, {{1}})", "as": "{{0}}", "list": "listOf({{*}})", "str/len": "_strLen({{0}}).toDouble()", "str/upper": "{{0}}.uppercase()", "str/lower": "{{0}}.lowercase()", "str/trim": "{{0}}.trim()", "str/trimStart": "{{0}}.trimStart()", "str/trimEnd": "{{0}}.trimEnd()", "str/capitalize": "_capitalize({{0}})", "str/split": "_split({{0}}, {{1}})", "str/join": "_join({{0}}, {{1}})", "str/concat": "_concat({{*}})", "str/includes": "{{0}}.contains({{1}})", "str/startsWith": "{{0}}.startsWith({{1}})", "str/endsWith": "{{0}}.endsWith({{1}})", "str/replace": "{{0}}.replaceFirst({{1}}, {{2}})", "str/replaceAll": "{{0}}.replace({{1}}, {{2}})", "str/repeat": "{{0}}.repeat(_count({{1}}))", "str/reverse": "StringBuilder({{0}}).reverse().toString()", "str/slice#2": "_strSlice({{0}}, {{1}})", "str/slice#3": "_strSlice({{0}}, {{1}}, {{2}})", "str/padStart#2": "_padStart({{0}}, {{1}})", "str/padStart#3": "_padStart({{0}}, {{1}}, {{2}})", "str/padEnd#2": "_padEnd({{0}}, {{1}})", "str/padEnd#3": "_padEnd({{0}}, {{1}}, {{2}})", "str/truncate#2": "_truncate({{0}}, {{1}})", "str/truncate#3": "_truncate({{0}}, {{1}}, {{2}})", "str/to-int": "_toInt({{0}})", "array/len": "{{0}}.size.toDouble()", "array/avg#1": "_avg({{0}})", "array/max#1": "_amax({{0}})", "array/min#1": "_amin({{0}})", "array/first": "_first({{0}})", "array/last": "_last({{0}})", "array/nth": "_nth({{0}}, {{1}})", "array/range#2": "_range({{0}}, {{1}})", "array/range#3": "_range({{0}}, {{1}}, {{2}})", "array/slice#2": "_slice({{0}}, {{1}})", "array/slice#3": "_slice({{0}}, {{1}}, {{2}})", "array/take": "{{0}}.take(_count({{1}}))", "array/drop": "{{0}}.drop(_count({{1}}))", "array/takeLast": "{{0}}.takeLast(_count({{1}}))", "array/dropLast": "{{0}}.dropLast(_count({{1}}))", "array/append": "_append({{0}}, {{1}})", "array/prepend": "_prepend({{0}}, {{1}})", "array/includes": "{{0}}.contains({{1}})", "array/indexOf": "_indexOf({{0}}, {{1}})", "array/reverse": "{{0}}.reversed()", "array/unique": "{{0}}.distinct()", "array/flatten": "{{0}}.flatten()", "array/zip": "{{0}}.zip({{1}}).map { listOf(it.first, it.second) }", "array/sort#1": "_sort({{0}})", "array/reduce": "{{0}}.fold({{1}}, {{2}})", "array/filter": "{{0}}.filter({{1}})", "array/reject": "{{0}}.filterNot({{1}})", "array/find": "{{0}}.firstOrNull({{1}})", "array/findIndex": "{{0}}.indexOfFirst({{1}}).toDouble()", "math/abs": "Math.abs(({{0}}).toDouble())", "math/max": "maxOf({{*}})", "math/min": "minOf({{*}})", "math/round#1": "_round({{0}})", "math/round#2": "_round({{0}}, {{1}})", "math/sqrt": "_sqrt({{0}})", "math/ln": "_ln({{0}})", "math/log10": "_log10({{0}})", "math/pow": "_pow({{0}}, {{1}})", "math/sign": "Math.signum(({{0}}).toDouble())", "math/clamp": "Math.min(Math.max(({{0}}).toDouble(), ({{1}}).toDouble()), ({{2}}).toDouble())", "math/ceil": "Math.ceil(({{0}}).toDouble())", "math/floor": "Math.floor(({{0}}).toDouble())", "math/sin": "Math.sin(({{0}}).toDouble())", "math/cos": "Math.cos(({{0}}).toDouble())", "math/tan": "Math.tan(({{0}}).toDouble())", "math/atan": "Math.atan(({{0}}).toDouble())", "math/atan2": "Math.atan2(({{0}}).toDouble(), ({{1}}).toDouble())", "math/hypot": "Math.hypot(({{0}}).toDouble(), ({{1}}).toDouble())", "validate/required": "_required({{0}})", "validate/length": "(_strLen({{0}}).toDouble() == ({{1}}).toDouble())", "validate/minLength": "(_strLen({{0}}).toDouble() >= ({{1}}).toDouble())", "validate/maxLength": "(_strLen({{0}}).toDouble() <= ({{1}}).toDouble())", "validate/min": "(({{0}}).toDouble() >= ({{1}}).toDouble())", "validate/max": "(({{0}}).toDouble() <= ({{1}}).toDouble())", "validate/range": "(({{0}}).toDouble() in ({{1}}).toDouble()..({{2}}).toDouble())", "validate/oneOf": "{{1}}.contains({{0}})", "validate/equals": "_eq({{0}}, {{1}})" }
       unary: { "-": "(-{{0}})", "not": "(!{{0}})", "array/range": "_range({{0}})", "array/sum": "_sum({{0}})", "array/count": "{{0}}.size.toDouble()", "array/sort": "_sort({{0}})", "math/round": "_round({{0}})", "array/concat": "{{0}}" }
       infix: { "+": "+", "-": "-", "*": "*", "<": "<", "<=": "<=", ">": ">", ">=": ">=", "and": "&&", "or": "||", "array/concat": "+" }
       infixForm: "({{*}})"
@@ -28,7 +28,7 @@ orbital LoloKotlinOrbital {
       indexedSource: "{{src}}.mapIndexed { i_, x_ -> Pair(i_.toDouble(), x_) }"
       indexedVars: "({{index}}, {{item}})"
       unsupportedForm: "_unsupported({{op}})"
-      helpers: { "/": ["private fun _div(a: Number, b: Number): Double? = if (b.toDouble() == 0.0) null else a.toDouble() / b.toDouble()"], "%": ["private fun _mod(a: Number, b: Number): Double? = if (b.toDouble() == 0.0) null else a.toDouble() % b.toDouble()"], "math/mod": ["private fun _mod(a: Number, b: Number): Double? = if (b.toDouble() == 0.0) null else a.toDouble() % b.toDouble()"], "=": ["private fun _eq(a: Any?, b: Any?): Boolean = if (a is Number && b is Number) a.toDouble() == b.toDouble() else a == b"], "==": ["private fun _eq(a: Any?, b: Any?): Boolean = if (a is Number && b is Number) a.toDouble() == b.toDouble() else a == b"], "!=": ["private fun _eq(a: Any?, b: Any?): Boolean = if (a is Number && b is Number) a.toDouble() == b.toDouble() else a == b"], "default": ["private fun <T : Any> _default(v: T?, d: T): T = v ?: d"], "str/len": ["private fun _strLen(s: String): Int = s.codePointCount(0, s.length)"], "str/capitalize": ["private fun _capitalize(s: String): String {\n    if (s.isEmpty()) return s\n    val n = s.offsetByCodePoints(0, 1)\n    return s.substring(0, n).uppercase() + s.substring(n).lowercase()\n}"], "str/split": ["private fun _split(s: String, d: String): List<String> =\n    if (d == \"\") s.codePoints().toArray().map { String(Character.toChars(it)) } else s.split(d)"], "str/join": ["private fun _join(a: List<Any?>, d: String): String = a.joinToString(d) { _text(it) }", "private fun _text(v: Any?): String = when (v) {\n    is String -> v\n    is Boolean -> v.toString()\n    is Long -> v.toString()\n    is Int -> v.toString()\n    is Double -> if (v.isFinite() && v == Math.floor(v)) java.math.BigDecimal(v).toBigInteger().toString() else v.toString()\n    else -> throw IllegalArgumentException(\"expected string, number or boolean\")\n}"], "str/concat": ["private fun _concat(vararg v: Any?): String = v.joinToString(\"\") { _text(it) }", "private fun _text(v: Any?): String = when (v) {\n    is String -> v\n    is Boolean -> v.toString()\n    is Long -> v.toString()\n    is Int -> v.toString()\n    is Double -> if (v.isFinite() && v == Math.floor(v)) java.math.BigDecimal(v).toBigInteger().toString() else v.toString()\n    else -> throw IllegalArgumentException(\"expected string, number or boolean\")\n}"], "str/repeat": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}"], "str/slice": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _strSlice(s: String, a: Number, b: Number? = null): String {\n    val n = s.codePointCount(0, s.length)\n    val x = _whole(a)\n    val y = if (b == null) n else _whole(b)\n    val from = if (x < 0) maxOf(n + x, 0) else minOf(x, n)\n    val to = if (y < 0) maxOf(n + y, 0) else minOf(y, n)\n    if (to <= from) return \"\"\n    return s.substring(s.offsetByCodePoints(0, from), s.offsetByCodePoints(0, to))\n}"], "str/padStart": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}", "private fun _strLen(s: String): Int = s.codePointCount(0, s.length)", "private fun _padUnit(p: String): String {\n    if (p.codePointCount(0, p.length) != 1) throw IllegalArgumentException(\"expected a single padding character, got \" + p)\n    return p\n}", "private fun _padStart(s: String, n: Number, p: String = \" \"): String {\n    val k = _count(n) - _strLen(s)\n    return if (k <= 0) s else _padUnit(p).repeat(k) + s\n}"], "str/padEnd": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}", "private fun _strLen(s: String): Int = s.codePointCount(0, s.length)", "private fun _padUnit(p: String): String {\n    if (p.codePointCount(0, p.length) != 1) throw IllegalArgumentException(\"expected a single padding character, got \" + p)\n    return p\n}", "private fun _padEnd(s: String, n: Number, p: String = \" \"): String {\n    val k = _count(n) - _strLen(s)\n    return if (k <= 0) s else s + _padUnit(p).repeat(k)\n}"], "str/truncate": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}", "private fun _strLen(s: String): Int = s.codePointCount(0, s.length)", "private fun _strSlice(s: String, a: Number, b: Number? = null): String {\n    val n = s.codePointCount(0, s.length)\n    val x = _whole(a)\n    val y = if (b == null) n else _whole(b)\n    val from = if (x < 0) maxOf(n + x, 0) else minOf(x, n)\n    val to = if (y < 0) maxOf(n + y, 0) else minOf(y, n)\n    if (to <= from) return \"\"\n    return s.substring(s.offsetByCodePoints(0, from), s.offsetByCodePoints(0, to))\n}", "private fun _truncate(s: String, n: Number, suffix: String = \"...\"): String =\n    if (_strLen(s) <= _count(n)) s else _strSlice(s, 0.0, n) + suffix"], "str/to-int": ["private fun _toInt(s: String): Double? =\n    if (Regex(\"[+-]?[0-9]+\").matches(s)) s.toLongOrNull()?.toDouble() else null"], "array/avg": ["private fun _avg(a: List<Number>): Double? = if (a.isEmpty()) null else a.sumOf { it.toDouble() } / a.size"], "array/max": ["private fun _amax(a: List<Number>): Double? = a.maxOfOrNull { it.toDouble() }"], "array/min": ["private fun _amin(a: List<Number>): Double? = a.minOfOrNull { it.toDouble() }"], "array/first": ["private fun <T> _first(a: List<T>): T? = a.firstOrNull()"], "array/last": ["private fun <T> _last(a: List<T>): T? = a.lastOrNull()"], "array/nth": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun <T> _nth(a: List<T>, i: Number): T? {\n    val k = _whole(i)\n    if (k < 0) throw IllegalArgumentException(\"nth: index \" + k + \" is not a whole number from 0\")\n    return a.getOrNull(k)\n}"], "array/range": ["private fun _range(a: Number, b: Number? = null, step: Number = 1.0): List<Double> {\n    val from = if (b == null) 0.0 else a.toDouble()\n    val to = if (b == null) a.toDouble() else b.toDouble()\n    val st = step.toDouble()\n    if (st == 0.0 || st.isNaN() || st.isInfinite()) throw IllegalArgumentException(\"range: step 0 must be a non-zero finite number\")\n    val out = mutableListOf<Double>()\n    var x = from\n    while (if (st > 0) x < to else x > to) {\n        out.add(x)\n        x += st\n    }\n    return out\n}"], "array/slice": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun <T> _slice(a: List<T>, s: Number, e: Number? = null): List<T> {\n    val from = _whole(s)\n    val to = if (e == null) a.size else _whole(e)\n    if (from < 0 || to < 0) throw IllegalArgumentException(\"slice: not a whole number from 0\")\n    val end = minOf(to, a.size)\n    return if (from >= end) listOf() else a.subList(from, end).toList()\n}"], "array/take": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}"], "array/drop": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}"], "array/takeLast": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}"], "array/dropLast": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}"], "array/append": ["private fun <T> _append(a: List<T>, x: T): List<T> = a + listOf(x)"], "array/prepend": ["private fun <T> _prepend(a: List<T>, x: T): List<T> = listOf(x) + a"], "array/indexOf": ["private fun <T> _indexOf(a: List<T>, x: T): Double = a.indexOf(x).toDouble()"], "array/sort": ["private fun <T : Comparable<T>> _sort(a: List<T>): List<T> = a.sorted()"], "math/round": ["private fun _round(x: Number, d: Number = 0.0): Double {\n    val m = Math.pow(10.0, d.toDouble())\n    return Math.copySign(Math.floor(Math.abs(x.toDouble()) * m + 0.5) / m, x.toDouble())\n}"], "math/sqrt": ["private fun _sqrt(x: Number): Double? = if (x.toDouble() < 0.0) null else Math.sqrt(x.toDouble())"], "math/ln": ["private fun _ln(x: Number): Double? = if (x.toDouble() <= 0.0) null else Math.log(x.toDouble())"], "math/log10": ["private fun _log10(x: Number): Double? = if (x.toDouble() <= 0.0) null else Math.log10(x.toDouble())"], "math/pow": ["private fun _pow(a: Number, b: Number): Double? {\n    val r = Math.pow(a.toDouble(), b.toDouble())\n    return if (r.isNaN() || r.isInfinite()) null else r\n}"], "validate/required": ["private fun _required(v: Any?): Boolean = v != null && v != \"\""], "validate/length": ["private fun _strLen(s: String): Int = s.codePointCount(0, s.length)"], "validate/minLength": ["private fun _strLen(s: String): Int = s.codePointCount(0, s.length)"], "validate/maxLength": ["private fun _strLen(s: String): Int = s.codePointCount(0, s.length)"], "validate/equals": ["private fun _eq(a: Any?, b: Any?): Boolean = if (a is Number && b is Number) a.toDouble() == b.toDouble() else a == b"], "array/sum": ["private fun _sum(a: List<Number>): Double = a.sumOf { it.toDouble() }"], "unsupported": ["private fun _unsupported(name: String): Nothing = throw UnsupportedOperationException(\"no native template for operator \" + name)"] }
+      helpers: { "object/get": ["private fun <V> _get(o: Map<String, V>, p: String): V? {\n    if (p.contains(\".\")) error(\"object/get: a dotted path is not supported on a typed map\")\n    return o[p]\n}"], "store": ["class Answer(val ok: Boolean, val payload: Map<String, Any?>)\n\ninterface Store {\n    fun persist(op: String, entity: String, data: Any?): Answer\n    fun fetch(entity: String, keep: ((Map<String, Any?>) -> Boolean)?): Answer\n}\n\nprivate fun _codePoints(a: String, b: String): Int {\n    val x = a.codePoints().toArray()\n    val y = b.codePoints().toArray()\n    for (i in 0 until minOf(x.size, y.size)) if (x[i] != y[i]) return x[i].compareTo(y[i])\n    return x.size.compareTo(y.size)\n}\n\nprivate fun _stampOrder(a: Map<String, Any?>, b: Map<String, Any?>): Int {\n    val sa = a[\"createdAt\"]\n    val sb = b[\"createdAt\"]\n    if ((sa == null) != (sb == null)) return if (sa != null) -1 else 1\n    if (sa is Number && sb is Number && sa.toDouble() != sb.toDouble()) return sa.toDouble().compareTo(sb.toDouble())\n    if (sa is String && sb is String && sa != sb) return _codePoints(sa, sb)\n    return _codePoints(a[\"id\"].toString(), b[\"id\"].toString())\n}\n\nclass MemoryStore : Store {\n    private val tables = mutableMapOf<String, MutableList<Pair<String, MutableMap<String, Any?>>>>()\n    private var minted = 0\n\n    override fun persist(op: String, entity: String, data: Any?): Answer {\n        val rows = tables.getOrPut(entity) { mutableListOf() }\n        if (op == \"create\" && data is Map<*, *>) {\n            val row = data.entries.associate { (k, v) -> k.toString() to v }.toMutableMap()\n            val given = row[\"id\"]\n            val id = if (given is String && given.isNotEmpty()) given else {\n                minted += 1\n                entity + \"-\" + minted\n            }\n            row[\"id\"] = id\n            rows.add(id to row)\n            return Answer(true, row.toMap())\n        }\n        val key = when (data) {\n            is String -> data\n            is Map<*, *> -> data[\"id\"]?.toString() ?: \"\"\n            else -> \"\"\n        }\n        val pos = rows.indexOfFirst { it.first == key }\n        if (pos < 0) return Answer(false, mapOf(\"error\" to entity + \" \" + key + \" not found\", \"code\" to \"not-found\"))\n        if (op == \"delete\") {\n            rows.removeAt(pos)\n            return Answer(true, mapOf(\"id\" to key, \"deleted\" to true))\n        }\n        if (data is Map<*, *>) for ((k, v) in data) rows[pos].second[k.toString()] = v\n        return Answer(true, rows[pos].second.toMap())\n    }\n\n    override fun fetch(entity: String, keep: ((Map<String, Any?>) -> Boolean)?): Answer {\n        val rows = (tables[entity] ?: mutableListOf()).map { it.second.toMap() }.filter { keep?.invoke(it) ?: true }.sortedWith(::_stampOrder)\n        return Answer(true, mapOf(\"data\" to rows, \"totalCount\" to rows.size))\n    }\n}"], "router": ["private val _routerJson = kotlinx.serialization.json.Json { encodeDefaults = true; ignoreUnknownKeys = true }\n\nprivate fun _json(value: Any?): kotlinx.serialization.json.JsonElement = when (value) {\n    null -> kotlinx.serialization.json.JsonNull\n    Unit -> kotlinx.serialization.json.JsonObject(emptyMap())\n    is kotlinx.serialization.json.JsonElement -> value\n    is String -> kotlinx.serialization.json.JsonPrimitive(value)\n    is Number -> kotlinx.serialization.json.JsonPrimitive(value)\n    is Boolean -> kotlinx.serialization.json.JsonPrimitive(value)\n    is Map<*, *> -> kotlinx.serialization.json.JsonObject(value.entries.associate { (k, v) -> k.toString() to _json(v) })\n    is List<*> -> kotlinx.serialization.json.JsonArray(value.map { _json(it) })\n    else -> _routerJson.encodeToJsonElement(kotlinx.serialization.serializer(value.javaClass), value)\n}\n\nprivate inline fun <reified T> _decode(value: kotlinx.serialization.json.JsonElement): T =\n    _routerJson.decodeFromJsonElement(kotlinx.serialization.serializer<T>(), value)\n\nclass _RouterEntry(\n    val key: String,\n    val trait: Any,\n    val state: () -> String,\n    val entity: () -> kotlinx.serialization.json.JsonElement,\n    val count: () -> Int,\n    val from: (Int) -> List<Triple<String, kotlinx.serialization.json.JsonElement, Boolean>>,\n)\n\nclass _RouterItem(\n    val target: String,\n    val event: String,\n    val payload: kotlinx.serialization.json.JsonElement,\n    val source: kotlinx.serialization.json.JsonElement,\n    val guard: ((kotlinx.serialization.json.JsonElement) -> Boolean)?,\n    val fans: Boolean,\n    val completion: Boolean,\n)\n\nclass _RouterRow(\n    val source: String,\n    val event: String,\n    val target: String,\n    val trigger: String,\n    val guard: ((kotlinx.serialization.json.JsonElement) -> Boolean)?,\n    val mapping: ((kotlinx.serialization.json.JsonElement) -> kotlinx.serialization.json.JsonElement)?,\n)\n\nopen class _Router {\n    val entries = mutableListOf<_RouterEntry>()\n    val handles = mutableMapOf<String, Map<String, List<String>>>()\n    val rows = mutableListOf<_RouterRow>()\n    val log = mutableListOf<Triple<String, String, kotlinx.serialization.json.JsonElement>>()\n\n    fun add(\n        key: String,\n        trait: Any,\n        state: () -> String,\n        entity: () -> kotlinx.serialization.json.JsonElement,\n        count: () -> Int,\n        from: (Int) -> List<Triple<String, kotlinx.serialization.json.JsonElement, Boolean>>,\n    ) {\n        entries.add(_RouterEntry(key, trait, state, entity, count, from))\n    }\n\n    fun row(\n        source: String,\n        event: String,\n        target: String,\n        trigger: String,\n        guard: ((kotlinx.serialization.json.JsonElement) -> Boolean)?,\n        mapping: ((kotlinx.serialization.json.JsonElement) -> kotlinx.serialization.json.JsonElement)?,\n    ) {\n        rows.add(_RouterRow(source, event, target, trigger, guard, mapping))\n    }\n\n    fun entry(key: String): _RouterEntry? = entries.firstOrNull { it.key == key }\n\n    fun trait(key: String): Any? = entry(key)?.trait\n\n    open fun deliver(target: String, event: String, payload: kotlinx.serialization.json.JsonElement) {}\n\n    private fun targets(source: String, event: String, payload: kotlinx.serialization.json.JsonElement, completion: Boolean): List<_RouterItem> =\n        rows.filter { it.source == source && it.event == event }.map {\n            _RouterItem(it.target, it.trigger, it.mapping?.invoke(payload) ?: payload, payload, it.guard, false, completion)\n        }\n\n    fun dispatch(trait: String, event: String, payload: kotlinx.serialization.json.JsonElement) {\n        val queue = ArrayDeque(listOf(_RouterItem(trait, event, payload, payload, null, true, false)))\n        val seen = mutableSetOf<String>()\n        var steps = 0\n        while (queue.isNotEmpty()) {\n            val item = queue.removeFirst()\n            val e = entry(item.target) ?: continue\n            val key = listOf(item.target, item.event, e.state(), item.payload.toString(), e.entity().toString()).joinToString(\"\\u001f\")\n            if (!item.completion && key in seen) continue\n            val g = item.guard\n            if (g != null && !g(item.source)) continue\n            if (steps >= 2000) break\n            steps += 1\n            seen.add(key)\n            val n = e.count()\n            deliver(item.target, item.event, item.payload)\n            val fanned = if (item.fans) targets(item.target, item.event, item.payload, false).toMutableList() else mutableListOf()\n            val own = mutableListOf<_RouterItem>()\n            val newState = e.state()\n            for ((ev, out, completion) in e.from(n)) {\n                log.add(Triple(item.target, ev, out))\n                if (handles[item.target]?.get(newState)?.contains(ev) == true) {\n                    own.add(_RouterItem(item.target, ev, out, out, null, false, completion))\n                }\n                fanned.addAll(targets(item.target, ev, out, completion))\n            }\n            queue.addAll(0, own)\n            queue.addAll(fanned)\n        }\n    }\n}"], "/": ["private fun _div(a: Number, b: Number): Double? = if (b.toDouble() == 0.0) null else a.toDouble() / b.toDouble()"], "%": ["private fun _mod(a: Number, b: Number): Double? = if (b.toDouble() == 0.0) null else a.toDouble() % b.toDouble()"], "math/mod": ["private fun _mod(a: Number, b: Number): Double? = if (b.toDouble() == 0.0) null else a.toDouble() % b.toDouble()"], "=": ["private fun _eq(a: Any?, b: Any?): Boolean = if (a is Number && b is Number) a.toDouble() == b.toDouble() else a == b"], "==": ["private fun _eq(a: Any?, b: Any?): Boolean = if (a is Number && b is Number) a.toDouble() == b.toDouble() else a == b"], "!=": ["private fun _eq(a: Any?, b: Any?): Boolean = if (a is Number && b is Number) a.toDouble() == b.toDouble() else a == b"], "default": ["private fun <T : Any> _default(v: T?, d: T): T = v ?: d"], "str/len": ["private fun _strLen(s: String): Int = s.codePointCount(0, s.length)"], "str/capitalize": ["private fun _capitalize(s: String): String {\n    if (s.isEmpty()) return s\n    val n = s.offsetByCodePoints(0, 1)\n    return s.substring(0, n).uppercase() + s.substring(n).lowercase()\n}"], "str/split": ["private fun _split(s: String, d: String): List<String> =\n    if (d == \"\") s.codePoints().toArray().map { String(Character.toChars(it)) } else s.split(d)"], "str/join": ["private fun _join(a: List<Any?>, d: String): String = a.joinToString(d) { _text(it) }", "private fun _text(v: Any?): String = when (v) {\n    is String -> v\n    is Boolean -> v.toString()\n    is Long -> v.toString()\n    is Int -> v.toString()\n    is Double -> if (v.isFinite() && v == Math.floor(v)) java.math.BigDecimal(v).toBigInteger().toString() else v.toString()\n    else -> throw IllegalArgumentException(\"expected string, number or boolean\")\n}"], "str/concat": ["private fun _concat(vararg v: Any?): String = v.joinToString(\"\") { _text(it) }", "private fun _text(v: Any?): String = when (v) {\n    is String -> v\n    is Boolean -> v.toString()\n    is Long -> v.toString()\n    is Int -> v.toString()\n    is Double -> if (v.isFinite() && v == Math.floor(v)) java.math.BigDecimal(v).toBigInteger().toString() else v.toString()\n    else -> throw IllegalArgumentException(\"expected string, number or boolean\")\n}"], "str/repeat": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}"], "str/slice": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _strSlice(s: String, a: Number, b: Number? = null): String {\n    val n = s.codePointCount(0, s.length)\n    val x = _whole(a)\n    val y = if (b == null) n else _whole(b)\n    val from = if (x < 0) maxOf(n + x, 0) else minOf(x, n)\n    val to = if (y < 0) maxOf(n + y, 0) else minOf(y, n)\n    if (to <= from) return \"\"\n    return s.substring(s.offsetByCodePoints(0, from), s.offsetByCodePoints(0, to))\n}"], "str/padStart": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}", "private fun _strLen(s: String): Int = s.codePointCount(0, s.length)", "private fun _padUnit(p: String): String {\n    if (p.codePointCount(0, p.length) != 1) throw IllegalArgumentException(\"expected a single padding character, got \" + p)\n    return p\n}", "private fun _padStart(s: String, n: Number, p: String = \" \"): String {\n    val k = _count(n) - _strLen(s)\n    return if (k <= 0) s else _padUnit(p).repeat(k) + s\n}"], "str/padEnd": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}", "private fun _strLen(s: String): Int = s.codePointCount(0, s.length)", "private fun _padUnit(p: String): String {\n    if (p.codePointCount(0, p.length) != 1) throw IllegalArgumentException(\"expected a single padding character, got \" + p)\n    return p\n}", "private fun _padEnd(s: String, n: Number, p: String = \" \"): String {\n    val k = _count(n) - _strLen(s)\n    return if (k <= 0) s else s + _padUnit(p).repeat(k)\n}"], "str/truncate": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}", "private fun _strLen(s: String): Int = s.codePointCount(0, s.length)", "private fun _strSlice(s: String, a: Number, b: Number? = null): String {\n    val n = s.codePointCount(0, s.length)\n    val x = _whole(a)\n    val y = if (b == null) n else _whole(b)\n    val from = if (x < 0) maxOf(n + x, 0) else minOf(x, n)\n    val to = if (y < 0) maxOf(n + y, 0) else minOf(y, n)\n    if (to <= from) return \"\"\n    return s.substring(s.offsetByCodePoints(0, from), s.offsetByCodePoints(0, to))\n}", "private fun _truncate(s: String, n: Number, suffix: String = \"...\"): String =\n    if (_strLen(s) <= _count(n)) s else _strSlice(s, 0.0, n) + suffix"], "str/to-int": ["private fun _toInt(s: String): Double? =\n    if (Regex(\"[+-]?[0-9]+\").matches(s)) s.toLongOrNull()?.toDouble() else null"], "array/avg": ["private fun _avg(a: List<Number>): Double? = if (a.isEmpty()) null else a.sumOf { it.toDouble() } / a.size"], "array/max": ["private fun _amax(a: List<Number>): Double? = a.maxOfOrNull { it.toDouble() }"], "array/min": ["private fun _amin(a: List<Number>): Double? = a.minOfOrNull { it.toDouble() }"], "array/first": ["private fun <T> _first(a: List<T>): T? = a.firstOrNull()"], "array/last": ["private fun <T> _last(a: List<T>): T? = a.lastOrNull()"], "array/nth": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun <T> _nth(a: List<T>, i: Number): T? {\n    val k = _whole(i)\n    if (k < 0) throw IllegalArgumentException(\"nth: index \" + k + \" is not a whole number from 0\")\n    return a.getOrNull(k)\n}"], "array/range": ["private fun _range(a: Number, b: Number? = null, step: Number = 1.0): List<Double> {\n    val from = if (b == null) 0.0 else a.toDouble()\n    val to = if (b == null) a.toDouble() else b.toDouble()\n    val st = step.toDouble()\n    if (st == 0.0 || st.isNaN() || st.isInfinite()) throw IllegalArgumentException(\"range: step 0 must be a non-zero finite number\")\n    val out = mutableListOf<Double>()\n    var x = from\n    while (if (st > 0) x < to else x > to) {\n        out.add(x)\n        x += st\n    }\n    return out\n}"], "array/slice": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun <T> _slice(a: List<T>, s: Number, e: Number? = null): List<T> {\n    val from = _whole(s)\n    val to = if (e == null) a.size else _whole(e)\n    if (from < 0 || to < 0) throw IllegalArgumentException(\"slice: not a whole number from 0\")\n    val end = minOf(to, a.size)\n    return if (from >= end) listOf() else a.subList(from, end).toList()\n}"], "array/take": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}"], "array/drop": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}"], "array/takeLast": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}"], "array/dropLast": ["private fun _whole(n: Number): Int {\n    val d = n.toDouble()\n    if (d != Math.floor(d) || d.isInfinite() || d < -2147483648.0 || d > 2147483647.0) throw IllegalArgumentException(\"expected a whole number, got \" + d)\n    return d.toInt()\n}", "private fun _count(n: Number): Int {\n    val k = _whole(n)\n    if (k < 0) throw IllegalArgumentException(\"expected a whole number from 0, got \" + k)\n    return k\n}"], "array/append": ["private fun <T> _append(a: List<T>, x: T): List<T> = a + listOf(x)"], "array/prepend": ["private fun <T> _prepend(a: List<T>, x: T): List<T> = listOf(x) + a"], "array/indexOf": ["private fun <T> _indexOf(a: List<T>, x: T): Double = a.indexOf(x).toDouble()"], "array/sort": ["private fun <T : Comparable<T>> _sort(a: List<T>): List<T> = a.sorted()"], "math/round": ["private fun _round(x: Number, d: Number = 0.0): Double {\n    val m = Math.pow(10.0, d.toDouble())\n    return Math.copySign(Math.floor(Math.abs(x.toDouble()) * m + 0.5) / m, x.toDouble())\n}"], "math/sqrt": ["private fun _sqrt(x: Number): Double? = if (x.toDouble() < 0.0) null else Math.sqrt(x.toDouble())"], "math/ln": ["private fun _ln(x: Number): Double? = if (x.toDouble() <= 0.0) null else Math.log(x.toDouble())"], "math/log10": ["private fun _log10(x: Number): Double? = if (x.toDouble() <= 0.0) null else Math.log10(x.toDouble())"], "math/pow": ["private fun _pow(a: Number, b: Number): Double? {\n    val r = Math.pow(a.toDouble(), b.toDouble())\n    return if (r.isNaN() || r.isInfinite()) null else r\n}"], "validate/required": ["private fun _required(v: Any?): Boolean = v != null && v != \"\""], "validate/length": ["private fun _strLen(s: String): Int = s.codePointCount(0, s.length)"], "validate/minLength": ["private fun _strLen(s: String): Int = s.codePointCount(0, s.length)"], "validate/maxLength": ["private fun _strLen(s: String): Int = s.codePointCount(0, s.length)"], "validate/equals": ["private fun _eq(a: Any?, b: Any?): Boolean = if (a is Number && b is Number) a.toDouble() == b.toDouble() else a == b"], "array/sum": ["private fun _sum(a: List<Number>): Double = a.sumOf { it.toDouble() }"], "unsupported": ["private fun _unsupported(name: String): Nothing = throw UnsupportedOperationException(\"no native template for operator \" + name)"] }
       helperGap: "\n\n"
       portEffects: ["persist", "fetch", "fetch-stream", "notify", "navigate", "navigate-back", "call-service", "cancel-call", "send-server", "spawn", "despawn", "log"]
       portCall: "ports?.invoke(\"{{name}}\", listOf({{*}}))"
@@ -51,6 +51,24 @@ orbital LoloKotlinOrbital {
       setStyle: "copy"
       fieldCase: "split-camel"
       voidPayload: "Unit"
+      programOpen: ["class Program({{entities}}{{store}}) : _Router() {", "{{i}}init {"]
+      programEntity: "e{{n}}: {{entity}}"
+      programEntitySep: ", "
+      programTrait: "{{i}}{{i}}val t{{n}} = {{class}}(e{{n}}); add({{key}}, t{{n}}, { t{{n}}.state }, { _json(t{{n}}.entity) }, { t{{n}}.emitted.size }, { n -> t{{n}}.emitted.drop(n).map { Triple(it.event, _json(it.payload), false) } })"
+      programHandles: "{{i}}{{i}}handles[{{key}}] = {{table}}"
+      programRow: "{{i}}{{i}}row({{source}}, {{event}}, {{target}}, {{trigger}}, {{guard}}, {{map}})"
+      deliverOpen: ["{{i}}}", "", "{{i}}override fun deliver(target: String, event: String, payload: kotlinx.serialization.json.JsonElement) {"]
+      deliverCase: "{{i}}{{i}}if (target == {{target}} && event == {{event}}) { (trait(target) as? {{class}})?.{{method}}({{arg}}); return }"
+      deliverCasePlain: "{{i}}{{i}}if (target == {{target}} && event == {{event}}) { (trait(target) as? {{class}})?.{{method}}(); return }"
+      deliverClose: ["{{i}}}"]
+      programClose: ["}"]
+      payloadDecode: "_decode<{{type}}>({{value}})"
+      guardForm: ["", "private fun {{name}}(payload_json: kotlinx.serialization.json.JsonElement): Boolean {", "{{i}}val payload = {{decode}}", "{{i}}return {{expr}}", "}"]
+      mapForm: ["", "private fun {{name}}(payload_json: kotlinx.serialization.json.JsonElement): kotlinx.serialization.json.JsonElement {", "{{i}}val payload = {{decode}}", "{{i}}return _json({{expr}})", "}"]
+      guardName: "_guard{{n}}"
+      mapName: "_map{{n}}"
+      guardRef: "::{{name}}"
+      mapRef: "::{{name}}"
       recordForm: "{{type}}({{fields}})"
       recordField: "{{name}} = {{value}}"
       unionArmForm: "{{union}}.{{union}}{{arm}}({{inner}})"
@@ -59,9 +77,14 @@ orbital LoloKotlinOrbital {
       methodCase: "pascal"
       classOpen: "class {{class}}("
       classEmpty: ""
-      constructor: ["{{i}}var entity: {{entity}},", "{{i}}val ports: ((String, List<Any?>) -> Unit)? = null,", "{{i}}val config: {{configType}} = {{configType}}(),", ") {", "{{i}}var state: String = {{initial}}", "{{i}}val emitted = mutableListOf<Emitted>()", "", "{{i}}data class Emitted(val event: String, val payload: Any)"]
+      constructor: ["{{i}}var entity: {{entity}},", "{{i}}val ports: ((String, List<Any?>) -> Unit)? = null,", "{{i}}val config: {{configType}} = {{configType}}(),", ") {", "{{i}}var state: String = {{initial}}", "{{i}}val emitted = mutableListOf<Emitted>()", "{{withStore}}{{i}}var store: Store? = null", "{{withStore}}{{i}}val completed = mutableSetOf<Int>()", "", "{{i}}data class Emitted(val event: String, val payload: Any)"]
       configType: "{{trait}}Config"
       emitMethod: ["{{i}}fun emit(event: String, payload: Any) {", "{{i}}{{i}}emitted.add(Emitted(event, payload))", "{{i}}}"]
+      completeMethod: ["", "{{i}}fun complete(answer: Answer, success: String?, failure: String?) {", "{{i}}{{i}}val route = (if (answer.ok) success else failure) ?: return", "{{i}}{{i}}completed.add(emitted.size)", "{{i}}{{i}}emitted.add(Emitted(route, answer.payload))", "{{i}}}", "", "{{i}}fun useStore(): Store = store ?: error(\"no store\")"]
+      routedEffects: {"persist": "complete(useStore().persist({{0}}, {{1}}, {{2}}), {{success}}, {{failure}})", "fetch": "complete(useStore().fetch({{entity}}, {{filter}}), {{success}}, {{failure}})"}
+      fetchAll: "null"
+      programStoreParam: ", store: Store"
+      programTraitStore: "{{i}}{{i}}val t{{n}} = {{class}}(e{{n}}); t{{n}}.store = store; add({{key}}, t{{n}}, { t{{n}}.state }, { _json(t{{n}}.entity) }, { t{{n}}.emitted.size }, { n -> t{{n}}.emitted.drop(n).mapIndexed { j, it -> Triple(it.event, _json(it.payload), (n + j) in t{{n}}.completed) } })"
       entityNames: { "Any": "AnyEntity", "Array": "ArrayEntity", "Boolean": "BooleanEntity", "Box": "BoxEntity", "Button": "ButtonEntity", "Card": "CardEntity", "Char": "CharEntity", "Color": "ColorEntity", "Column": "ColumnEntity", "Double": "DoubleEntity", "Enum": "EnumEntity", "Exception": "ExceptionEntity", "Float": "FloatEntity", "Image": "ImageEntity", "Int": "IntEntity", "List": "ListEntity", "Long": "LongEntity", "Map": "MapEntity", "Modifier": "ModifierEntity", "Nothing": "NothingEntity", "Number": "NumberEntity", "Pair": "PairEntity", "Result": "ResultEntity", "Row": "RowEntity", "Set": "SetEntity", "Short": "ShortEntity", "State": "StateEntity", "String": "StringEntity", "Surface": "SurfaceEntity", "Text": "TextEntity", "Throwable": "ThrowableEntity", "Triple": "TripleEntity", "Unit": "UnitEntity" }
       typeMap: {  }
       indent: "    "

package/behaviors/lolo/codec/atoms/std-lolo-python.lolo

@@ -31,9 +31,9 @@ orbital LoloPythonOrbital {
       calleeForm: "{{callee}}({{*}})"
       unsupportedForm: "_unsupported({{op}})"
       unsupportedWarn: "no {{language}} template for operator {{op}}"
-      helpers: { "/": ["def _div(a, b): return None if b == 0 else a / b"], "%": ["def _mod(a, b): return None if b == 0 else math.fmod(a, b)"], "math/mod": ["def _mod(a, b): return None if b == 0 else math.fmod(a, b)"], "default": ["def _default(v, d): return d if v is None else v"], "str/split": ["def _split(s, d): return list(s) if d == '' else s.split(d)"], "str/join": ["def _join(a, d): return d.join(_text(v) for v in a)", "def _text(v):\n    if isinstance(v, bool): return 'true' if v else 'false'\n    if isinstance(v, float) and v - v == 0 and v == int(v): return str(int(v))\n    if isinstance(v, (int, float, str)): return str(v)\n    raise TypeError('expected string, number or boolean')"], "str/concat": ["def _text(v):\n    if isinstance(v, bool): return 'true' if v else 'false'\n    if isinstance(v, float) and v - v == 0 and v == int(v): return str(int(v))\n    if isinstance(v, (int, float, str)): return str(v)\n    raise TypeError('expected string, number or boolean')"], "str/slice": ["def _str_slice(s, a, b=None):\n    if a != int(a) or (b is not None and b != int(b)): raise ValueError('slice: not a whole number')\n    return s[int(a):None if b is None else int(b)]"], "str/padStart": ["def _pad_start(s, n, p=' '):\n    if len(p) != 1: raise ValueError('expected a single padding character')\n    return s.rjust(int(n), p)"], "str/padEnd": ["def _pad_end(s, n, p=' '):\n    if len(p) != 1: raise ValueError('expected a single padding character')\n    return s.ljust(int(n), p)"], "str/truncate": ["def _truncate(s, n, suffix='...'): return s if len(s) <= n else s[:int(n)] + suffix"], "str/to-int": ["def _to_int(s):\n    t = s[1:] if s[:1] in ('+', '-') else s\n    return int(s) if t.isascii() and t.isdigit() and -2 ** 63 <= int(s) < 2 ** 63 else None"], "array/sum": ["def _sum(a, k=None): return sum(a) if k is None else sum(x[k] for x in a)"], "array/avg": ["def _avg(a, k=None):\n    v = a if k is None else [x[k] for x in a]\n    return sum(v) / len(v) if v else None"], "array/max": ["def _amax(a, k=None):\n    v = a if k is None else [x[k] for x in a]\n    return max(v) if v else None"], "array/min": ["def _amin(a, k=None):\n    v = a if k is None else [x[k] for x in a]\n    return min(v) if v else None"], "array/first": ["def _first(a): return a[0] if a else None"], "array/last": ["def _last(a): return a[-1] if a else None"], "array/nth": ["def _nth(a, i):\n    if i != int(i) or i < 0: raise ValueError('nth: index is not a whole number from 0')\n    return a[int(i)] if i < len(a) else None"], "array/range": ["def _range(a, b=None, step=1):\n    start, end = (0, a) if b is None else (a, b)\n    if step == 0: raise ValueError('range: step 0 must be a non-zero finite number')\n    out = []\n    x = start\n    while (x < end) if step > 0 else (x > end):\n        out.append(x)\n        x += step\n    return out"], "array/slice": ["def _slice(a, s, e=None):\n    if s != int(s) or s < 0 or (e is not None and (e != int(e) or e < 0)): raise ValueError('slice: not a whole number from 0')\n    return a[int(s):None if e is None else int(e)]"], "array/take": ["def _take(a, n):\n    if n != int(n) or n < 0: raise ValueError('count is not a whole number from 0')\n    return a[:int(n)]"], "array/drop": ["def _drop(a, n):\n    if n != int(n) or n < 0: raise ValueError('count is not a whole number from 0')\n    return a[int(n):]"], "array/takeLast": ["def _take_last(a, n):\n    if n != int(n) or n < 0: raise ValueError('count is not a whole number from 0')\n    return a[len(a) - int(n):] if n < len(a) else a[:]"], "array/dropLast": ["def _drop_last(a, n):\n    if n != int(n) or n < 0: raise ValueError('count is not a whole number from 0')\n    return a[:len(a) - int(n)] if n < len(a) else []"], "array/indexOf": ["def _index_of(a, x): return a.index(x) if x in a else -1"], "array/unique": ["def _unique(a):\n    out = []\n    for x in a:\n        if x not in out: out.append(x)\n    return out"], "array/sort": ["def _sort(a, k=None, o='asc'): return sorted(a, key=None if k is None else (lambda x: x[k]), reverse=(o == 'desc'))"], "object/get": ["def _get(o, p, d=None):\n    for s in p.replace(chr(92) + '.', chr(0)).split('.'):\n        s = s.replace(chr(0), '.')\n        if isinstance(o, dict) and s in o: o = o[s]\n        elif isinstance(o, list) and s.isdigit() and int(s) < len(o): o = o[int(s)]\n        else: return d\n    return o"], "object/has": ["def _has(o, p):\n    for s in p.replace(chr(92) + '.', chr(0)).split('.'):\n        s = s.replace(chr(0), '.')\n        if isinstance(o, dict) and s in o: o = o[s]\n        elif isinstance(o, list) and s.isdigit() and int(s) < len(o): o = o[int(s)]\n        else: return False\n    return True"], "object/set": ["def _set(o, p, v):\n    out = dict(o)\n    cur = out\n    parts = [s.replace(chr(0), '.') for s in p.replace(chr(92) + '.', chr(0)).split('.')]\n    for s in parts[:-1]:\n        cur[s] = dict(cur[s]) if isinstance(cur.get(s), dict) else {}\n        cur = cur[s]\n    cur[parts[-1]] = v\n    return out"], "object/pick": ["def _pick(o, ks): return {k: o[k] for k in ks if k in o}"], "object/omit": ["def _omit(o, ks): return {k: v for k, v in o.items() if k not in ks}"], "json/parse": ["def _json_parse(t):\n    try: return json.loads(t)\n    except ValueError: return None"], "json/stringify": ["def _json_dumps(v):\n    def n(x):\n        if isinstance(x, float) and x - x == 0 and x == int(x): return int(x)\n        if isinstance(x, list): return [n(y) for y in x]\n        if isinstance(x, dict): return {k: n(y) for k, y in x.items()}\n        return x\n    return json.dumps(n(v), separators=(',', ':'), ensure_ascii=False)"], "math/round": ["def _round(x, d=0):\n    m = 10 ** d\n    return math.copysign(math.floor(abs(x) * m + 0.5) / m, x)"], "math/sqrt": ["def _sqrt(x): return None if x < 0 else math.sqrt(x)"], "math/ln": ["def _ln(x): return None if x <= 0 else math.log(x)"], "math/log10": ["def _log10(x): return None if x <= 0 else math.log10(x)"], "math/pow": ["def _pow(a, b):\n    try: return math.pow(a, b)\n    except (ValueError, OverflowError, ZeroDivisionError): return None"], "math/sign": ["def _sign(x): return (x > 0) - (x < 0)"], "math/clamp": ["def _clamp(v, lo, hi): return min(max(v, lo), hi)"], "validate/required": ["def _required(v): return v is not None and v != ''"], "validate/number": ["def _is_number(v): return isinstance(v, (int, float)) and not isinstance(v, bool)"], "unsupported": ["def _unsupported(name): raise NotImplementedError('no native template for operator ' + name)"] }
+      helpers: { "store": ["class MemoryStore:\n    def __init__(self):\n        self.tables = {}\n        self.minted = 0\n\n    def persist(self, op, entity, data):\n        rows = self.tables.setdefault(entity, {})\n        if op == \"create\":\n            row = dict(_plain(data))\n            if not row.get(\"id\"):\n                self.minted += 1\n                row[\"id\"] = entity + \"-\" + str(self.minted)\n            rows[row[\"id\"]] = row\n            return True, dict(row)\n        key = data if isinstance(data, str) else _plain(data).get(\"id\")\n        if key not in rows:\n            return False, {\"error\": entity + \" \" + str(key) + \" not found\", \"code\": \"not-found\"}\n        if op == \"delete\":\n            del rows[key]\n            return True, {\"id\": key, \"deleted\": True}\n        rows[key].update(_plain(data))\n        return True, dict(rows[key])\n\n    def fetch(self, entity, keep):\n        rows = [dict(r) for r in self.tables.get(entity, {}).values() if keep is None or keep(dict(r))]\n        rows.sort(key=lambda r: (0, r[\"createdAt\"], r[\"id\"]) if \"createdAt\" in r else (1, 0, r[\"id\"]))\n        return True, {\"data\": rows, \"totalCount\": len(rows)}"], "router": ["def _plain(v):\n    if dataclasses.is_dataclass(v):\n        return dataclasses.asdict(v)\n    return {} if v is None else v", "def _decode(cls, payload):\n    names = {f.name for f in dataclasses.fields(cls)}\n    return cls(**{k: v for k, v in (payload or {}).items() if k in names})", "class _Router:\n    def __init__(self):\n        self.traits = {}\n        self.handles = {}\n        self.rows = []\n        self.log = []\n\n    def add(self, key, trait):\n        self.traits[key] = trait\n\n    def row(self, source, event, target, trigger, guard, mapping):\n        self.rows.append((source, event, target, trigger, guard, mapping))\n\n    def targets(self, source, event, payload, completion):\n        return [{\"trait\": target, \"event\": trigger, \"payload\": mapping(payload) if mapping else payload, \"source\": payload,\n                 \"guard\": guard, \"fans\": False, \"completion\": completion}\n                for (s, e, target, trigger, guard, mapping) in self.rows if s == source and e == event]\n\n    def dispatch(self, trait, event, payload):\n        queue = deque([{\"trait\": trait, \"event\": event, \"payload\": payload, \"source\": payload, \"guard\": None, \"fans\": True, \"completion\": False}])\n        seen = set()\n        steps = 0\n        while queue:\n            item = queue.popleft()\n            t = self.traits[item[\"trait\"]]\n            key = json.dumps([item[\"trait\"], item[\"event\"], t.state, item[\"payload\"], _plain(t.entity)], sort_keys=True, default=str)\n            if not item[\"completion\"] and key in seen:\n                continue\n            if item[\"guard\"] is not None and not item[\"guard\"](item[\"source\"]):\n                continue\n            if steps >= 2000:\n                break\n            steps += 1\n            seen.add(key)\n            n = len(t.emitted)\n            self.deliver(item[\"trait\"], item[\"event\"], item[\"payload\"])\n            own, fanned = [], []\n            if item[\"fans\"]:\n                fanned += self.targets(item[\"trait\"], item[\"event\"], item[\"payload\"], False)\n            for emitted in t.emitted[n:]:\n                ev, out = emitted[0], _plain(emitted[1])\n                completion = len(emitted) > 2 and emitted[2]\n                self.log.append((item[\"trait\"], ev, out))\n                if ev in self.handles[item[\"trait\"]].get(t.state, ()):\n                    own.append({\"trait\": item[\"trait\"], \"event\": ev, \"payload\": out, \"source\": out, \"guard\": None, \"fans\": False, \"completion\": completion})\n                fanned += self.targets(item[\"trait\"], ev, out, completion)\n            queue.extendleft(reversed(own))\n            queue.extend(fanned)"], "/": ["def _div(a, b): return None if b == 0 else a / b"], "%": ["def _mod(a, b): return None if b == 0 else math.fmod(a, b)"], "math/mod": ["def _mod(a, b): return None if b == 0 else math.fmod(a, b)"], "default": ["def _default(v, d): return d if v is None else v"], "str/split": ["def _split(s, d): return list(s) if d == '' else s.split(d)"], "str/join": ["def _join(a, d): return d.join(_text(v) for v in a)", "def _text(v):\n    if isinstance(v, bool): return 'true' if v else 'false'\n    if isinstance(v, float) and v - v == 0 and v == int(v): return str(int(v))\n    if isinstance(v, (int, float, str)): return str(v)\n    raise TypeError('expected string, number or boolean')"], "str/concat": ["def _text(v):\n    if isinstance(v, bool): return 'true' if v else 'false'\n    if isinstance(v, float) and v - v == 0 and v == int(v): return str(int(v))\n    if isinstance(v, (int, float, str)): return str(v)\n    raise TypeError('expected string, number or boolean')"], "str/slice": ["def _str_slice(s, a, b=None):\n    if a != int(a) or (b is not None and b != int(b)): raise ValueError('slice: not a whole number')\n    return s[int(a):None if b is None else int(b)]"], "str/padStart": ["def _pad_start(s, n, p=' '):\n    if len(p) != 1: raise ValueError('expected a single padding character')\n    return s.rjust(int(n), p)"], "str/padEnd": ["def _pad_end(s, n, p=' '):\n    if len(p) != 1: raise ValueError('expected a single padding character')\n    return s.ljust(int(n), p)"], "str/truncate": ["def _truncate(s, n, suffix='...'): return s if len(s) <= n else s[:int(n)] + suffix"], "str/to-int": ["def _to_int(s):\n    t = s[1:] if s[:1] in ('+', '-') else s\n    return int(s) if t.isascii() and t.isdigit() and -2 ** 63 <= int(s) < 2 ** 63 else None"], "array/sum": ["def _sum(a, k=None): return sum(a) if k is None else sum(x[k] for x in a)"], "array/avg": ["def _avg(a, k=None):\n    v = a if k is None else [x[k] for x in a]\n    return sum(v) / len(v) if v else None"], "array/max": ["def _amax(a, k=None):\n    v = a if k is None else [x[k] for x in a]\n    return max(v) if v else None"], "array/min": ["def _amin(a, k=None):\n    v = a if k is None else [x[k] for x in a]\n    return min(v) if v else None"], "array/first": ["def _first(a): return a[0] if a else None"], "array/last": ["def _last(a): return a[-1] if a else None"], "array/nth": ["def _nth(a, i):\n    if i != int(i) or i < 0: raise ValueError('nth: index is not a whole number from 0')\n    return a[int(i)] if i < len(a) else None"], "array/range": ["def _range(a, b=None, step=1):\n    start, end = (0, a) if b is None else (a, b)\n    if step == 0: raise ValueError('range: step 0 must be a non-zero finite number')\n    out = []\n    x = start\n    while (x < end) if step > 0 else (x > end):\n        out.append(x)\n        x += step\n    return out"], "array/slice": ["def _slice(a, s, e=None):\n    if s != int(s) or s < 0 or (e is not None and (e != int(e) or e < 0)): raise ValueError('slice: not a whole number from 0')\n    return a[int(s):None if e is None else int(e)]"], "array/take": ["def _take(a, n):\n    if n != int(n) or n < 0: raise ValueError('count is not a whole number from 0')\n    return a[:int(n)]"], "array/drop": ["def _drop(a, n):\n    if n != int(n) or n < 0: raise ValueError('count is not a whole number from 0')\n    return a[int(n):]"], "array/takeLast": ["def _take_last(a, n):\n    if n != int(n) or n < 0: raise ValueError('count is not a whole number from 0')\n    return a[len(a) - int(n):] if n < len(a) else a[:]"], "array/dropLast": ["def _drop_last(a, n):\n    if n != int(n) or n < 0: raise ValueError('count is not a whole number from 0')\n    return a[:len(a) - int(n)] if n < len(a) else []"], "array/indexOf": ["def _index_of(a, x): return a.index(x) if x in a else -1"], "array/unique": ["def _unique(a):\n    out = []\n    for x in a:\n        if x not in out: out.append(x)\n    return out"], "array/sort": ["def _sort(a, k=None, o='asc'): return sorted(a, key=None if k is None else (lambda x: x[k]), reverse=(o == 'desc'))"], "object/get": ["def _get(o, p, d=None):\n    for s in p.replace(chr(92) + '.', chr(0)).split('.'):\n        s = s.replace(chr(0), '.')\n        if isinstance(o, dict) and s in o: o = o[s]\n        elif isinstance(o, list) and s.isdigit() and int(s) < len(o): o = o[int(s)]\n        else: return d\n    return o"], "object/has": ["def _has(o, p):\n    for s in p.replace(chr(92) + '.', chr(0)).split('.'):\n        s = s.replace(chr(0), '.')\n        if isinstance(o, dict) and s in o: o = o[s]\n        elif isinstance(o, list) and s.isdigit() and int(s) < len(o): o = o[int(s)]\n        else: return False\n    return True"], "object/set": ["def _set(o, p, v):\n    out = dict(o)\n    cur = out\n    parts = [s.replace(chr(0), '.') for s in p.replace(chr(92) + '.', chr(0)).split('.')]\n    for s in parts[:-1]:\n        cur[s] = dict(cur[s]) if isinstance(cur.get(s), dict) else {}\n        cur = cur[s]\n    cur[parts[-1]] = v\n    return out"], "object/pick": ["def _pick(o, ks): return {k: o[k] for k in ks if k in o}"], "object/omit": ["def _omit(o, ks): return {k: v for k, v in o.items() if k not in ks}"], "json/parse": ["def _json_parse(t):\n    try: return json.loads(t)\n    except ValueError: return None"], "json/stringify": ["def _json_dumps(v):\n    def n(x):\n        if isinstance(x, float) and x - x == 0 and x == int(x): return int(x)\n        if isinstance(x, list): return [n(y) for y in x]\n        if isinstance(x, dict): return {k: n(y) for k, y in x.items()}\n        return x\n    return json.dumps(n(v), separators=(',', ':'), ensure_ascii=False)"], "math/round": ["def _round(x, d=0):\n    m = 10 ** d\n    return math.copysign(math.floor(abs(x) * m + 0.5) / m, x)"], "math/sqrt": ["def _sqrt(x): return None if x < 0 else math.sqrt(x)"], "math/ln": ["def _ln(x): return None if x <= 0 else math.log(x)"], "math/log10": ["def _log10(x): return None if x <= 0 else math.log10(x)"], "math/pow": ["def _pow(a, b):\n    try: return math.pow(a, b)\n    except (ValueError, OverflowError, ZeroDivisionError): return None"], "math/sign": ["def _sign(x): return (x > 0) - (x < 0)"], "math/clamp": ["def _clamp(v, lo, hi): return min(max(v, lo), hi)"], "validate/required": ["def _required(v): return v is not None and v != ''"], "validate/number": ["def _is_number(v): return isinstance(v, (int, float)) and not isinstance(v, bool)"], "unsupported": ["def _unsupported(name): raise NotImplementedError('no native template for operator ' + name)"] }
       helperGap: "\n"
-      imports: { "Literal": "from typing import Literal", "Any": "from typing import Any", "field": "from dataclasses import field", "dataclass": "from dataclasses import dataclass", "%": "import math", "math/mod": "import math", "math/ceil": "import math", "math/floor": "import math", "math/sin": "import math", "math/cos": "import math", "math/tan": "import math", "math/atan": "import math", "math/atan2": "import math", "math/hypot": "import math", "math/round": "import math", "math/sqrt": "import math", "math/ln": "import math", "math/log10": "import math", "math/pow": "import math", "array/reduce": "import functools", "json/parse": "import json", "json/stringify": "import json" }
+      imports: { "router": "from collections import deque\nimport dataclasses\nimport json", "Literal": "from typing import Literal", "Any": "from typing import Any", "field": "from dataclasses import field", "dataclass": "from dataclasses import dataclass", "%": "import math", "math/mod": "import math", "math/ceil": "import math", "math/floor": "import math", "math/sin": "import math", "math/cos": "import math", "math/tan": "import math", "math/atan": "import math", "math/atan2": "import math", "math/hypot": "import math", "math/round": "import math", "math/sqrt": "import math", "math/ln": "import math", "math/log10": "import math", "math/pow": "import math", "array/reduce": "import functools", "json/parse": "import json", "json/stringify": "import json" }
       portEffects: ["persist", "fetch", "fetch-stream", "notify", "navigate", "navigate-back", "call-service", "cancel-call", "send-server", "spawn", "despawn", "log"]
       portCall: "self.ports.{{name}}({{*}})"
       portCase: "lower"
@@ -77,6 +77,16 @@ orbital LoloPythonOrbital {
       localCase: "keep"
       methodCase: "lower"
       methodName: "on_{{event}}"
+      programOpen: ["class Program(_Router):", "{{i}}def __init__(self, entities, ports=None):", "{{i}}{{i}}super().__init__()"]
+      programTrait: "{{i}}{{i}}self.add({{key}}, {{class}}(entities[{{key}}], ports))"
+      programHandles: "{{i}}{{i}}self.handles[{{key}}] = {{table}}"
+      programRow: "{{i}}{{i}}self.row({{source}}, {{event}}, {{target}}, {{trigger}}, {{guard}}, {{map}})"
+      deliverOpen: ["", "{{i}}def deliver(self, target, event, payload):"]
+      deliverCase: "{{i}}{{i}}if target == {{target}} and event == {{event}}:\n{{i}}{{i}}{{i}}return self.traits[target].{{method}}({{arg}})"
+      deliverCasePlain: "{{i}}{{i}}if target == {{target}} and event == {{event}}:\n{{i}}{{i}}{{i}}return self.traits[target].{{method}}()"
+      payloadDecode: "_decode({{type}}, {{value}})"
+      guardForm: ["", "", "def {{name}}(payload_json):", "{{i}}payload = {{decode}}", "{{i}}return {{expr}}"]
+      mapForm: ["", "", "def {{name}}(payload_json):", "{{i}}payload = {{decode}}", "{{i}}return {{expr}}"]
       modelImports: { "entity": "from orbital_app.generated.entities import {{names}}", "payload": "from orbital_app.generated.events import {{names}}" }
       modelImportEach: false
       modelImportSep: ", "
@@ -86,6 +96,9 @@ orbital LoloPythonOrbital {
       classEmpty: "{{i}}pass"
       constructor: ["{{i}}def __init__(self, entity: {{entity}}, ports=None, config: {{configType}} | None = None):", "{{noConfig}}{{i}}def __init__(self, entity: {{entity}}, ports=None):", "{{i}}{{i}}self.state = {{initial}}", "{{i}}{{i}}self.entity = entity", "{{i}}{{i}}self.ports = ports", "{{i}}{{i}}self.config = config if config is not None else {{configType}}()", "{{i}}{{i}}self.emitted: list[tuple[str, object]] = []"]
       emitMethod: ["{{i}}def emit(self, event, payload):", "{{i}}{{i}}self.emitted.append((event, payload))"]
+      completeMethod: ["", "{{i}}def complete(self, answer, success, failure):", "{{i}}{{i}}ok, payload = answer", "{{i}}{{i}}route = success if ok else failure", "{{i}}{{i}}if route is not None:", "{{i}}{{i}}{{i}}self.emitted.append((route, payload, True))"]
+      routedEffects: {"persist": "self.complete(self.ports.persist({{args}}), {{success}}, {{failure}})", "fetch": "self.complete(self.ports.fetch({{entity}}, {{filter}}), {{success}}, {{failure}})"}
+      fetchAll: "None"
       methodOpen: "{{i}}def {{method}}(self, payload: {{payloadType}}) -> None:"
       methodOpenPlain: "{{i}}def {{method}}(self, payload=None) -> None:"
       methodClose: ""