@almadar/std 17.0.3 → 17.1.0

package/behaviors/lolo/spec/codec/lolo-source.fixtures/compose-pair.lolo

@@ -0,0 +1,44 @@
+app compose-pair [
+  version: "1.0.0",
+  description: "Fixture for the native renderers' composed mode: a local trait whose emit feeds a composed std atom (std-score's ScoreKeeper) with call-site config, so the native program must carry the composed traits the kernel runs."
+]
+
+orbital ArenaOrbital {
+  uses S from "std/behaviors/std-score"
+
+  entity Match [runtime] {
+    id : string!
+    enemies : number = 3
+    score : number = 0
+    scoreBaseline : number = 0
+  }
+
+  trait Arena -> Match [client] {
+    initial: idle
+
+    state idle {
+      INIT -> idle
+      HIT -> idle
+        (set @entity.enemies (- @entity.enemies ?n))
+        (emit WAVE { enemiesAlive: @entity.enemies, playersAlive: 1 })
+    }
+
+    emits {
+      WAVE -> external { enemiesAlive : number!, playersAlive : number! }
+    }
+
+    listens {
+      HIT { n : number! }
+    }
+  }
+
+  trait Score = S.traits.ScoreKeeper -> Match {
+    config { running: true, pointsPerKill: 5, startScore: 0, initialEnemies: 3 }
+    listens {
+      Arena.WAVE -> UNITS_CHANGED
+      UNITS_CHANGED { playersAlive : number, enemiesAlive : number }
+    }
+  }
+
+  page boot as ArenaStart -> Arena, Score
+}

package/behaviors/lolo/spec/codec/lolo-source.fixtures/config-read.lolo

@@ -1,5 +1,6 @@
 app config-read [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: a transition guarded by a boolean config knob that multiplies a payload number by a numeric config knob."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/divide-default.lolo

@@ -1,5 +1,6 @@
 app divide-default [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: division of two payload numbers wrapped in default, so a divide by zero falls back to 0."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/divide-plain.lolo

@@ -1,5 +1,6 @@
 app divide-plain [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: plain division of two payload numbers into a nullable number field."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/get-past-end.lolo

@@ -1,5 +1,6 @@
 app get-past-end [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: object/get of a missing key wrapped in default with a string fallback."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/list-call.lolo

@@ -1,5 +1,6 @@
 app list-call [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: a transition that calls str/upper on a literal and emits the result."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/list-plain.lolo

@@ -1,5 +1,6 @@
 app list-plain [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: a list literal assigned to a string-list field, then array/len of it."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/minus-binary.lolo

@@ -1,5 +1,6 @@
 app minus-binary [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: the minus operator applied to two operands (subtraction)."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/minus-unary.lolo

@@ -1,5 +1,6 @@
 app minus-unary [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: the minus operator applied to a single operand (negation)."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/nested-let.lolo

@@ -1,5 +1,6 @@
 app nested-let [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: a let expression nested inside another let, with later bindings reading earlier ones."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/no-machine.lolo

@@ -1,5 +1,6 @@
 app no-machine [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: a trait with no states beyond its initial one and only an emit declaration, so the renderer handles an empty machine."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/no-template.lolo

@@ -1,5 +1,6 @@
 app no-template [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: format/phone, an operator the native renderers have no template for."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/nth-past-end.lolo

@@ -1,5 +1,6 @@
 app nth-past-end [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: array/nth past the end of a list wrapped in default with a fallback of -1."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/nth-raw.lolo

@@ -1,5 +1,6 @@
 app nth-raw [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: array/nth without a default, assigned to a nullable number field."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/ports-call.lolo

@@ -1,5 +1,6 @@
 app ports-call [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: a server trait that upserts a row, sets scalar fields, adds one to a counter and maps a payload list with a lambda."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/range-one.lolo

@@ -1,5 +1,6 @@
 app range-one [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: array/range with a single argument, then array/len of the result."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/range-two.lolo

@@ -1,5 +1,6 @@
 app range-two [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: array/range with a start and an end argument, then array/len of the result."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.fixtures/router-trio.lolo

@@ -0,0 +1,88 @@
+app router-trio [
+  version: "1.0.0",
+  description: "Fixture for the native renderers' generated router: three traits whose emits exercise the dispatch queue rules (own emits first, listeners after in registration order, a listen guard on the raw payload, and a with mapping)."
+]
+
+orbital TrioOrbital {
+  entity Tally [runtime] {
+    id : string!
+    hits : number = 0
+    log : [string] = []
+  }
+
+  trait Lead -> Tally [client] {
+    initial: idle
+
+    state idle {
+      INIT -> idle
+      GO -> busy
+        (set @entity.hits (+ @entity.hits 1))
+        (emit PING { n: ?n })
+        (emit NOTE { text: "go" })
+    }
+
+    state busy {
+      INIT -> idle
+      PING -> idle
+        (set @entity.hits (+ @entity.hits 10))
+        (emit PONG { n: ?n })
+      GO -> busy
+    }
+
+    emits {
+      PING -> internal { n : number! }
+      NOTE -> external { text : string! }
+      PONG -> external { n : number! }
+    }
+
+    listens {
+      GO { n : number! }
+      PING { n : number! }
+    }
+  }
+
+  trait Echo -> Tally [client] {
+    initial: idle
+
+    state idle {
+      INIT -> idle
+      HEARD -> idle
+        (set @entity.log (array/append @entity.log (str/concat "echo " ?label)))
+        (emit ECHOED { label: ?label })
+    }
+
+    emits {
+      ECHOED -> external { label : string! }
+    }
+
+    listens {
+      Lead.PING -> HEARD with { label: (str/concat "n=" ?n) } when (> ?n 0)
+      HEARD { label : string! }
+    }
+  }
+
+  trait Tail -> Tally [client] {
+    initial: idle
+
+    state idle {
+      INIT -> idle
+      NOTED -> idle
+        (set @entity.log (array/append @entity.log (str/concat "note " ?text)))
+      PONGED -> idle
+        (set @entity.log (array/append @entity.log "pong"))
+      SEEN -> idle
+        (set @entity.log (array/append @entity.log (str/concat "seen " ?label)))
+    }
+
+    listens {
+      Lead.NOTE -> NOTED
+      Lead.PONG -> PONGED
+      Echo.ECHOED -> SEEN
+      NOTED { text : string! }
+      PONGED { n : number! }
+      SEEN { label : string! }
+    }
+  }
+
+  page boot as TrioStart -> Lead, Echo, Tail
+}

package/behaviors/lolo/spec/codec/lolo-source.fixtures/store-pair.lolo

@@ -0,0 +1,62 @@
+app store-pair [
+  version: "1.0.0",
+  description: "Fixture for the native renderers' typed ports: a trait that persists a row and fetches rows back through their success and failure routes, so a native store must answer what the kernel's store answers."
+]
+
+orbital StoreOrbital {
+  entity Note [runtime] {
+    id : string!
+    text : string = ""
+    kind : string = ""
+    seen : number = 0
+    last : string = ""
+  }
+
+  trait Notes -> Note {
+    initial: idle
+
+    state idle {
+      INIT -> idle
+      ADD -> idle
+        (persist create Note { text: ?text, kind: ?kind } { emit: { success: ADDED, failure: ADD_FAILED } })
+      ADDED -> idle
+        (set @entity.last ?text)
+        (fetch Note { filter: (= (object/get @entity "kind") "todo"), emit: { success: LOADED, failure: LOAD_FAILED } })
+      LOADED -> idle
+        (set @entity.seen (array/len ?data))
+      ADD_FAILED -> idle
+        (set @entity.last "failed")
+      LOAD_FAILED -> idle
+        (set @entity.last "load failed")
+      EDIT -> idle
+        (persist update Note { id: ?id, text: ?text } { emit: { success: EDITED, failure: EDIT_FAILED } })
+      EDITED -> idle
+        (set @entity.last (str/concat "edited " ?text))
+      EDIT_FAILED -> idle
+        (set @entity.last (str/concat "edit failed " ?error))
+      DROP -> idle
+        (persist delete Note ?id { emit: { success: DROPPED, failure: DROP_FAILED } })
+      DROPPED -> idle
+        (set @entity.last (str/concat "dropped " ?id))
+        (fetch Note { emit: { success: LOADED, failure: LOAD_FAILED } })
+      DROP_FAILED -> idle
+        (set @entity.last (str/concat "drop failed " ?error))
+    }
+
+    listens {
+      ADD { text : string!, kind : string! }
+      ADDED { id : string!, text : string!, kind : string! }
+      LOADED { data : [Note]!, totalCount : number! }
+      ADD_FAILED { error : string! }
+      LOAD_FAILED { error : string! }
+      EDIT { id : string!, text : string! }
+      EDITED { id : string!, text : string!, kind : string! }
+      EDIT_FAILED { error : string!, code : string }
+      DROP { id : string! }
+      DROPPED { id : string!, deleted : boolean! }
+      DROP_FAILED { error : string!, code : string }
+    }
+  }
+
+  page boot as StoreStart -> Notes
+}

package/behaviors/lolo/spec/codec/lolo-source.fixtures/string-literal.lolo

@@ -1,5 +1,6 @@
 app string-literal [
-  version: "1.0.0"
+  version: "1.0.0",
+  description: "Fixture for the native source renderers: string and object literals containing braces, quotes, a backslash, a non-ASCII character and a newline, plus a key that needs quoting."
 ]
 orbital Fx {
   entity Rec [runtime] {

package/behaviors/lolo/spec/codec/lolo-source.gen/knobs.py

@@ -20,6 +20,12 @@ KNOBS = [
  ("portEffects", "[string]", [], "domain", "Port effects", "Effects outside the native core, called on the ports object the caller injects"),
  ("portCall", "string", "", "domain", "Port call", "How a port effect is called: {{name}} and {{*}}"),
  ("portCase", "string", "keep", "domain", "Port name case", "keep, lower, upper, camel or pascal (each word lowercased first), or split-camel or split-pascal (the shell models' identifier spelling: split on _ and -, each word's tail kept), or lower-camel (split-pascal with its first letter lowered)"),
+ ("routedEffects", "Map string string", {}, "domain", "Routed effects", "Template per port effect answered through its emit routes, which the trait completes in the same dispatch: {{args}} its arguments without the options object ({{0}}, {{1}}, {{2}} one by one), {{entity}} the quoted entity name, {{model}} the entity's model name, {{filter}} the fetch filter as a lambda over one row (fetchAll when the fetch has none), {{success}} and {{failure}} the quoted route events (nullLit when absent). Its helpers and imports are under the token store"),
+ ("rowLocal", "string", "fetchRow", "domain", "Fetch row local", "The parameter of a fetch filter's lambda, in localCase: the filter's @entity reads the candidate row through it"),
+ ("fetchAll", "string", "", "domain", "Fetch all", "The filter written for a fetch with none"),
+ ("routeForm", "string", "{{route}}", "domain", "Route form", "A routed effect's present route event ({{route}} the quoted event); an absent route is nullLit"),
+ ("filterForm", "string", "{{lambda}}", "domain", "Filter form", "A fetch filter that is present, {{lambda}} the filter as a lambda over one row"),
+ ("completeMethod", "[string]", [], "domain", "Complete method", "Lines of the method a trait with a routed effect completes it by: it records the answer's route (success or failure) as a completion emit, and nothing when that route is absent"),
  ("portWarn", "string", "{{op}} is called on the ports object", "domain", "Port warning", "The warning written for each port effect"),
  ("attributeRoots", "Map string string", {}, "domain", "Attribute roots", "Target expression per sigil whose path reads as attributes (@entity.x)"),
  ("itemRoots", "Map string string", {}, "domain", "Item roots", "Target expression per sigil whose path reads as items (@config.x)"),
@@ -51,6 +57,26 @@ KNOBS = [
  ("unionArmCase", "string", "keep", "domain", "Union arm case", "The case of {{arm}} in unionArmForm: keep, lower, upper, camel, pascal, split-camel, split-pascal or lower-camel"),
  ("enumForm", "string", "", "domain", "Enum member", "A string literal the checker names an enum for: {{enum}} the enum model, {{member}} the member (enumMemberCase); empty keeps every string literal a string"),
  ("enumMemberCase", "string", "split-pascal", "domain", "Enum member case", "keep, lower, upper, camel, pascal, split-camel or split-pascal"),
+ ("programOpen", "[string]", [], "domain", "Program open", "Lines that open the generated router of a program whose traits listen to each other ({{i}} indent, {{entities}} the programEntity entries); empty renders no router"),
+ ("programTrait", "string", "", "domain", "Program trait", "One trait instance of the router: {{key}} the orbital-qualified trait, {{class}}, {{entity}}, {{n}} its position"),
+ ("programStoreParam", "string", "", "domain", "Program store parameter", "programOpen's {{store}} when a trait of the program has a routed effect (the store the Program hands those traits); empty otherwise"),
+ ("programTraitStore", "string", "", "domain", "Program store trait", "The programTrait line for a trait with a routed effect, which also hands it the store ({{key}}, {{class}}, {{entity}}, {{n}}); empty writes programTrait"),
+ ("programEntity", "string", "", "domain", "Program entity", "One entry of programOpen's {{entities}}, the row each trait starts from: {{key}}, {{entity}}, {{n}} the trait's position"),
+ ("programEntitySep", "string", ", ", "domain", "Program entity separator", "Between the entries of {{entities}}"),
+ ("programHandles", "string", "", "domain", "Program handles", "The events a trait handles per state: {{key}}, {{table}} (a map literal of state to event list)"),
+ ("programRow", "string", "", "domain", "Program row", "One listen route in registration order: {{source}}, {{event}}, {{target}}, {{trigger}}, {{guard}} and {{map}} (a function name, or the null literal)"),
+ ("deliverOpen", "[string]", [], "domain", "Deliver open", "Lines that open the router's typed delivery to a trait method"),
+ ("deliverCase", "string", "", "domain", "Deliver case", "One delivery of an event with a payload: {{target}}, {{class}} (the trait's class), {{event}}, {{method}}, {{arg}} (the decoded payload)"),
+ ("deliverCasePlain", "string", "", "domain", "Deliver case (no payload)", "One delivery of an event with no payload: {{target}}, {{class}}, {{event}}, {{method}}"),
+ ("deliverClose", "[string]", [], "domain", "Deliver close", "Lines that close the delivery"),
+ ("programClose", "[string]", [], "domain", "Program close", "Lines that close the router"),
+ ("payloadDecode", "string", "", "domain", "Payload decode", "A payload model read from a router value: {{type}}, {{value}}"),
+ ("guardForm", "[string]", [], "domain", "Listen guard", "A listen guard as a function of the raw source payload: {{name}}, {{decode}}, {{expr}}"),
+ ("mapForm", "[string]", [], "domain", "Listen mapping", "A listen's with mapping as a function of the source payload: {{name}}, {{decode}}, {{expr}}"),
+ ("guardName", "string", "_guard_{{n}}", "domain", "Guard name", "The function of listen route {{n}}'s guard"),
+ ("mapName", "string", "_map_{{n}}", "domain", "Mapping name", "The function of listen route {{n}}'s mapping"),
+ ("guardRef", "string", "{{name}}", "domain", "Guard reference", "A route's guard as programRow passes it: {{name}} the function (a route with no guard passes the null literal)"),
+ ("mapRef", "string", "{{name}}", "domain", "Mapping reference", "A route's mapping as programRow passes it: {{name}} the function (a route with no mapping passes the null literal)"),
  ("fieldNames", "Map string string", {}, "domain", "Field names", "Model field spellings that differ from fieldCase (a target keyword the shell renames): .lolo field name to model field name"),
  ("letStmt", "string", "{{name}} = {{value}}", "domain", "Let statement", "A binding in statement position: {{name}}, {{value}}, {{type}}"),
  ("letExpr", "string", "{{body}}", "domain", "Let expression", "A binding in expression position, one per name, nested: {{name}}, {{value}}, {{body}}, {{type}}"),
@@ -86,7 +112,7 @@ KNOBS = [
  ("classOpen", "string", "class {{class}} {", "domain", "Class open", "Head of a trait class"),
  ("classClose", "string", "}", "domain", "Class close", "Foot of a trait class; empty when none"),
  ("classEmpty", "string", "", "domain", "Class empty", "Body of a trait class that has no state machine (pass); empty when none is needed"),
- ("constructor", "[string]", [], "domain", "Constructor", "Lines of the constructor and fields: {{i}} indent, {{class}}, {{entity}}, {{initial}} quoted, {{config}} the config map literal, {{configType}} the trait's config type (configType)"),
+ ("constructor", "[string]", [], "domain", "Constructor", "Lines of the constructor and fields: {{i}} indent, {{class}}, {{entity}}, {{initial}} quoted, {{config}} the config map literal, {{configType}} the trait's config type (configType); a line starting {{withStore}} is written only for a trait with a routed effect and one starting {{noStore}} only for one without"),
  ("emitMethod", "[string]", [], "domain", "Emit method", "Lines of the method that records an emit"),
  ("methodOpen", "string", "{{i}}fun {{method}}(payload: {{payloadType}}) {", "domain", "Method open", "Head of an event method that has a payload: {{i}}, {{method}}, {{payloadType}}"),
  ("methodOpenPlain", "string", "{{i}}fun {{method}}() {", "domain", "Method open (no payload)", "Head of an event method with no payload"),

package/behaviors/lolo/spec/codec/lolo-source.gen/src_assemble.in

@@ -46,7 +46,7 @@
                         (if (!= @config.modelClassClose "") [@config.modelClassClose] [])))))))
               [])
             (array/map (array/range 0 (array/len @entity.traits)) (fn ti
-              (let ((t (default (array/nth @entity.traits @ti) { name: "", path: "", entity: "", initial: "", hasMachine: false, knobs: [], transitions: [], events: [], listenTypes: {}, emitTypes: {}, emitVoid: [], configType: "" }))
+              (let ((t (default (array/nth @entity.traits @ti) { name: "", path: "", entity: "", initial: "", hasMachine: false, knobs: [], transitions: [], events: [], listenTypes: {}, emitTypes: {}, emitVoid: [], configType: "", orbital: "", listenRows: [] }))
                     (rs (default (array/nth @entity.renders (+ @nC @ti)) []))
                     (cn : string CASE{(default (object/get (default (array/nth @entity.traits @ti) { name: "" }) "name") "") ## @config.classCase}))
                 (if (not (object/get @t "hasMachine"))
@@ -60,9 +60,10 @@
                                   @config.mapClose))))
                     (array/concat
                       [FILL{@config.classOpen ## class => @cn ## i => @ind}]
-                      (array/map (array/filter @config.constructor (fn l (if (= (object/get @t "configType") "") (not (or (str/includes @l "{{configType}}") (str/includes @l "{{withConfig}}"))) (not (str/includes @l "{{noConfig}}"))))) (fn l FILL{@l ## i => @ind ## class => @cn ## entity => ENT{(object/get @t "entity")} ## initial => STR{(object/get @t "initial")} ## config => @cfgLit ## configType => (object/get @t "configType") ## noConfig => "" ## withConfig => ""}))
+                      (array/map (array/filter @config.constructor (fn l (and (if (= (object/get @t "configType") "") (not (or (str/includes @l "{{configType}}") (str/includes @l "{{withConfig}}"))) (not (str/includes @l "{{noConfig}}"))) (if (array/some @rs (fn sr (array/includes (object/get @sr "uses") "store"))) (not (str/includes @l "{{noStore}}")) (not (str/includes @l "{{withStore}}")))))) (fn l FILL{@l ## i => @ind ## class => @cn ## entity => ENT{(object/get @t "entity")} ## initial => STR{(object/get @t "initial")} ## config => @cfgLit ## configType => (object/get @t "configType") ## noConfig => "" ## withConfig => "" ## noStore => "" ## withStore => ""}))
                       [""]
                       (array/map @config.emitMethod (fn l FILL{@l ## i => @ind}))
+                      (if (array/some @rs (fn sr (array/includes (object/get @sr "uses") "store"))) (array/map @config.completeMethod (fn l FILL{@l ## i => @ind})) [])
                       (array/flatten (array/map (object/get @t "events") (fn ev
                         (let ((mine (array/filter (array/range 0 (array/len @trs)) (fn mi (= (object/get (default (array/nth @trs @mi) { from: "", to: "", event: "" }) "event") @ev))))
                               (ptype LOOKUP{(object/get @t "listenTypes") ## @ev})
@@ -86,9 +87,60 @@
                             (if (!= @config.branchClose "") [FILL{@config.branchClose ## i => @ind}] [])
                             (if (!= @config.methodClose "") [FILL{@config.methodClose ## i => @ind}] []))))))
                       (if (!= @config.classClose "") [FILL{@config.classClose ## i => @ind}] []))))))))))
+        (set @entity.blocks (let ((nC (if @config.renderModels (array/len @entity.containers) 0))
+                                  (ind : string @config.indent)
+                                  (nullR : SrcRender RECL{ expr => @config.nullLit ## stmt => [@config.nullLit] ## body => @config.nullLit }))
+          (let ((storeUsed (array/some (array/flatten @entity.renders) (fn sr (array/includes (object/get @sr "uses") "store"))))
+                (rows (array/flatten (array/map (array/range 0 (array/len @entity.traits)) (fn ti
+                  (array/map (array/range 0 (array/len (object/get (default (array/nth @entity.traits @ti) { name: "", path: "", entity: "", initial: "", hasMachine: false, knobs: [], transitions: [], events: [], listenTypes: {}, emitTypes: {}, emitVoid: [], configType: "", orbital: "", listenRows: [] }) "listenRows"))) (fn li { ti: @ti, li: @li })))))))
+            (if (or (= (array/len @config.programOpen) 0) (and (= (array/len @rows) 0) (not @storeUsed)))
+              @entity.blocks
+              (array/concat @entity.blocks [(array/concat
+                (array/map @config.programOpen (fn l FILL{@l ## i => @ind ## store => (if @storeUsed @config.programStoreParam "") ## entities => (str/join (array/map (array/range 0 (array/len @entity.traits)) (fn pei (let ((t (default (array/nth @entity.traits @pei) { name: "", path: "", entity: "", initial: "", hasMachine: false, knobs: [], transitions: [], events: [], listenTypes: {}, emitTypes: {}, emitVoid: [], configType: "", orbital: "", listenRows: [] }))) FILL{@config.programEntity ## n => (str/concat "" @pei) ## key => STR{(str/concat (object/get @t "orbital") "." (object/get @t "name"))} ## entity => ENT{(object/get @t "entity")}}))) @config.programEntitySep)}))
+                (array/map (array/range 0 (array/len @entity.traits)) (fn pti (let ((t (default (array/nth @entity.traits @pti) { name: "", path: "", entity: "", initial: "", hasMachine: false, knobs: [], transitions: [], events: [], listenTypes: {}, emitTypes: {}, emitVoid: [], configType: "", orbital: "", listenRows: [] })))
+                  FILL{(if (and (!= @config.programTraitStore "") (array/some (default (array/nth @entity.renders (+ @nC @pti)) []) (fn sr (array/includes (object/get @sr "uses") "store")))) @config.programTraitStore @config.programTrait) ## i => @ind ## n => (str/concat "" @pti) ## key => STR{(str/concat (object/get @t "orbital") "." (object/get @t "name"))} ## class => CASE{(object/get @t "name") ## @config.classCase} ## entity => ENT{(object/get @t "entity")}})))
+                (array/map @entity.traits (fn t
+                  (let ((trs : [SrcTransition] (object/get @t "transitions")))
+                    (let ((sts (array/unique (array/map @trs (fn tr (object/get @tr "from"))))))
+                      FILL{@config.programHandles ## i => @ind ## key => STR{(str/concat (object/get @t "orbital") "." (object/get @t "name"))}
+                        ## table => (str/concat @config.mapOpen (str/join (array/map @sts (fn st FILL{@config.mapPair ## key => STR{@st} ## value => FILL{@config.listForm ## "*" => (str/join (array/map (array/unique (array/map (array/filter @trs (fn tr (= (object/get @tr "from") @st))) (fn tr (object/get @tr "event")))) (fn ev STR{@ev})) ", ")}})) @config.mapSep) @config.mapClose)}))))
+                (array/map (array/range 0 (array/len @rows)) (fn ri
+                  (let ((r (default (array/nth @rows @ri) { ti: 0, li: 0 })))
+                    (let ((t (default (array/nth @entity.traits (object/get @r "ti")) { name: "", path: "", entity: "", initial: "", hasMachine: false, knobs: [], transitions: [], events: [], listenTypes: {}, emitTypes: {}, emitVoid: [], configType: "", orbital: "", listenRows: [] })))
+                      (let ((lr (default (array/nth (object/get @t "listenRows") (object/get @r "li")) { source: "", event: "", trigger: "" })))
+                        FILL{@config.programRow ## i => @ind ## source => STR{(str/concat (object/get @t "orbital") "." (object/get @lr "source"))} ## event => STR{(object/get @lr "event")}
+                          ## target => STR{(str/concat (object/get @t "orbital") "." (object/get @t "name"))} ## trigger => STR{(object/get @lr "trigger")}
+                          ## guard => (if (= (object/get @lr "guard" null) null) @config.nullLit FILL{@config.guardRef ## name => FILL{@config.guardName ## n => (str/concat "" @ri)}})
+                          ## map => (if (= (object/get @lr "map" null) null) @config.nullLit FILL{@config.mapRef ## name => FILL{@config.mapName ## n => (str/concat "" @ri)}})})))))
+                (array/map @config.deliverOpen (fn l FILL{@l ## i => @ind}))
+                (array/flatten (array/map @entity.traits (fn t
+                  (array/map (object/get @t "events") (fn ev
+                    (let ((pt LOOKUP{(object/get @t "listenTypes") ## @ev})
+                          (mn FILL{@config.methodName ## event => CASE{@ev ## @config.methodCase}})
+                          (tk STR{(str/concat (object/get @t "orbital") "." (object/get @t "name"))}))
+                      (if (= @pt "")
+                        FILL{@config.deliverCasePlain ## i => @ind ## target => @tk ## event => STR{@ev} ## method => @mn ## class => CASE{(object/get @t "name") ## @config.classCase}}
+                        FILL{@config.deliverCase ## i => @ind ## target => @tk ## event => STR{@ev} ## method => @mn ## class => CASE{(object/get @t "name") ## @config.classCase} ## arg => FILL{@config.payloadDecode ## type => @pt ## value => "payload"}})))))))
+                (array/map @config.deliverClose (fn l FILL{@l ## i => @ind}))
+                (array/map @config.programClose (fn l FILL{@l ## i => @ind}))
+                (array/flatten (array/map (array/range 0 (array/len @rows)) (fn ri
+                  (let ((r (default (array/nth @rows @ri) { ti: 0, li: 0 })))
+                    (let ((t (default (array/nth @entity.traits (object/get @r "ti")) { name: "", path: "", entity: "", initial: "", hasMachine: false, knobs: [], transitions: [], events: [], listenTypes: {}, emitTypes: {}, emitVoid: [], configType: "", orbital: "", listenRows: [] }))
+                          (job (default (array/nth (default (array/nth @entity.renders (+ @nC (object/get @r "ti"))) []) (+ (+ 1 (array/len (object/get (default (array/nth @entity.traits (object/get @r "ti")) { name: "", path: "", entity: "", initial: "", hasMachine: false, knobs: [], transitions: [], events: [], listenTypes: {}, emitTypes: {}, emitVoid: [], configType: "", orbital: "", listenRows: [] }) "transitions"))) (object/get @r "li"))) @nullR)))
+                      (let ((lr (default (array/nth (object/get @t "listenRows") (object/get @r "li")) { source: "", event: "", trigger: "" }))
+                            (base (str/concat (object/get @t "path") ".listens[" (object/get @r "li") "]")))
+                        (let ((st LOOKUP{(object/get (default (array/find @entity.traits (fn s (and (= (object/get @s "name") (object/get @lr "source")) (= (object/get @s "orbital") (object/get @t "orbital"))))) { name: "", path: "", entity: "", initial: "", hasMachine: false, knobs: [], transitions: [], events: [], listenTypes: {}, emitTypes: {}, emitVoid: [], configType: "", orbital: "", listenRows: [] }) "emitTypes") ## (object/get @lr "event")}))
+                          (let ((dec (if (= @st "") @config.nullLit FILL{@config.payloadDecode ## type => @st ## value => "payload_json"})))
+                            (array/concat
+                              (if (= (object/get @lr "guard" null) null) []
+                                (array/map @config.guardForm (fn l FILL{@l ## i => @ind ## name => FILL{@config.guardName ## n => (str/concat "" @ri)} ## decode => @dec ## expr => RESOLVE{(default (array/nth (object/get @job "items") 1) @config.trueLit) ## @base}})))
+                              (if (= (object/get @lr "map" null) null) []
+                                (array/map @config.mapForm (fn l FILL{@l ## i => @ind ## name => FILL{@config.mapName ## n => (str/concat "" @ri)} ## decode => @dec ## expr => RESOLVE{(default (array/nth (object/get @job "items") 2) @config.nullLit) ## @base}}))))))))))))
+              )])))))
         (set @entity.tokens (array/concat
           (array/flatten (array/flatten (array/map @entity.renders (fn g (array/map @g (fn r (object/get @r "uses")))))))
           (array/flatten (array/flatten (array/map @entity.typeRenders (fn g (array/map @g (fn r (object/get @r "uses")))))))
           (if (and @config.renderModels (array/some @entity.containers (fn c (not (object/get @c "alias"))))) ["dataclass"] [])
           (if (and @config.renderModels (array/some @entity.containers (fn c (array/some (object/get @c "fields") (fn f (and (!= (object/get @f "default" null) null) (or (validate/array (object/get @f "default" null)) (validate/object (object/get @f "default" null))))))))) ["field"] [])))
+        (set @entity.tokens (array/concat @entity.tokens (if (and (> (array/len @config.programOpen) 0) (or (array/some @entity.traits (fn t (> (array/len (object/get @t "listenRows")) 0))) (array/includes @entity.tokens "store"))) ["router"] [])))
         (set @entity.helperTexts (array/sort (array/unique (array/flatten (array/map (array/unique @entity.tokens) (fn tk (object/get @config.helpers @tk [])))))))

package/behaviors/lolo/spec/codec/lolo-source.gen/src_finish.in

@@ -9,4 +9,4 @@
                                 [(str/join @entity.helperTexts @config.helperGap)]
                                 (array/map @entity.blocks (fn b (str/join @b "\n"))))
                               (fn s (!= @s "")))))
-              (str/concat (str/join @sections @config.sectionGap) "\n")))))
+              (str/replaceAll (str/replaceAll (str/concat (str/join @sections @config.sectionGap) "\n") "\ue00d" "") "\ue00e" "")))))

package/behaviors/lolo/spec/codec/lolo-source.gen/src_fold.in

@@ -103,10 +103,30 @@
                                   (if (and (= @ptype "") (not @void) (> (array/len @n) 2)) [(str/concat "emit " @ev " carries a payload the trait does not declare")]
                                     (if (and (!= @ptype "") (> (array/len @n) 2) (not @isObj)) [(str/concat "emit " @ev " passes a payload that is not an object literal, so it is not built as " @ptype)] [])))))
                         (let ((call FILL{@config.emitForm ## event => (default (array/nth @ex 1) "") ## payload => @pld}))
-                          REC{ expr => @call ## stmt => [(str/concat @call @term)] ## warns => (array/concat @ws @warn) ## uses => @us })))))
+                          REC{ expr => @call ## stmt => [(str/concat @call @term)] ## warns => (array/concat @ws @warn) ## uses => (if (and (!= @ptype "") @isObj) (array/concat @us ["payload"]) @us) })))))
               (if (= @hd "render-ui")
                 (let ((kind : string (let ((pr (if (> @argc 1) (array/nth @n 2) null))) (if (validate/object @pr) (let ((tv (object/get @pr "type" "ui"))) (if (validate/string @tv) @tv "ui")) "ui"))))
                   REC{ expr => @config.nullLit ## stmt => [FILL{@config.commentForm ## text => (str/concat "render: " @kind)}] ## warns => @ws ## uses => @us })
+              (if (object/has @config.routedEffects @hd)
+                (let ((oi (if (= @hd "fetch") 2 4))
+                      (ei (if (= @hd "fetch") 1 2)))
+                  (let ((rawO (array/nth @n @oi))
+                        (orR : SrcRender (default (array/nth @rs @oi) @nullR))
+                        (ename : string (let ((ev (array/nth @n @ei))) (if (validate/string @ev) @ev ""))))
+                    (let ((opts : SrcMap (if (validate/object @rawO) (let ((om : SrcMap @rawO)) @om) {}))
+                          (okeys : [string] (object/get @orR "keys")))
+                      (let ((routes : SrcMap (let ((em (object/get @opts "emit" null))) (if (validate/object @em) (let ((emm : SrcMap @em)) @emm) {})))
+                            (fi (array/indexOf @okeys "filter")))
+                        (let ((okT (let ((rv (object/get @routes "success" null))) (if (validate/string @rv) (let ((rvs : string @rv)) FILL{@config.routeForm ## route => STR{@rvs}}) @config.nullLit)))
+                              (errT (let ((rv (object/get @routes "failure" null))) (if (validate/string @rv) (let ((rvs : string @rv)) FILL{@config.routeForm ## route => STR{@rvs}}) @config.nullLit)))
+                              (filterT (if (< @fi 0) @config.fetchAll FILL{@config.filterForm ## lambda => FILL{@config.lambdaForm ## params => CASE{@config.rowLocal ## @config.localCase} ## body => (str/replaceAll (default (array/nth (object/get @orR "items") @fi) @config.nullLit) (str/concat "\ue00d" (object/get @config.attributeRoots "entity" "") "\ue00e") CASE{@config.rowLocal ## @config.localCase})}}))
+                              (extra (array/filter @okeys (fn ok (not (array/includes (if (= @hd "fetch") ["emit", "filter"] ["emit"]) @ok))))))
+                          (let ((txt FILL{(object/get @config.routedEffects @hd "") ## args => (str/join (array/slice @ex 1 (if (< @argc @oi) (+ @argc 1) @oi)) ", ") ## "0" => (default (array/nth @ex 1) "") ## "1" => (default (array/nth @ex 2) "") ## "2" => (default (array/nth @ex 3) "") ## entity => STR{@ename} ## model => ENT{@ename} ## filter => @filterT ## success => @okT ## failure => @errT})
+                                (warn (array/concat
+                                  (if (validate/object @rawO) [] [(str/concat @hd " has no options object with emit routes, so its answer reaches no event")])
+                                  (if (and (= @hd "persist") (not (let ((pop (array/nth @n 1))) (if (validate/string @pop) (let ((pops : string @pop)) (array/includes ["create", "update", "delete"] @pops)) false)))) ["persist has an operation the native store does not answer (create, update and delete are rendered)"] [])
+                                  (array/map @extra (fn ok (str/concat @hd " option " @ok " is not rendered natively"))))))
+                            REC{ expr => @txt ## stmt => [(str/concat @txt @term)] ## items => @ex ## warns => (array/concat @ws @warn) ## uses => (array/concat @us ["store"]) }))))))
               (if (array/includes @config.portEffects @hd)
                 (let ((args (array/drop @ex 1)))
                   (let ((txt FILL{@config.portCall ## name => CASE{@hd ## @config.portCase} ## "*" => (str/join @args ", ")}))
@@ -136,13 +156,13 @@
                                      (if (= @mode "callee") FILL{@config.calleeForm ## callee => @callee ## "*" => @joined}
                                        FILL{@config.unsupportedForm ## op => STR{@hd}})))))
                           (warn (if (= @mode "none") [FILL{@config.unsupportedWarn ## language => @config.language ## op => @hd}] [])))
-                      REC{ expr => @txt ## stmt => [(str/concat @txt @term)] ## items => @ex ## warns => (array/concat @ws @warn) ## uses => (array/concat @us [@hd] (if (= @mode "none") ["unsupported"] [])) }))))))))))))))))))
+                      REC{ expr => @txt ## stmt => [(str/concat @txt @term)] ## items => @ex ## warns => (array/concat @ws @warn) ## uses => (array/concat @us [@hd] (if (= @mode "none") ["unsupported"] [])) })))))))))))))))))))
     (if (validate/object @n)
       (let ((es (object/entries @k)))
         (let ((typedEs (if @typed (array/map @es (fn e (let ((rr (default (array/nth @e 1) @nullR)) (m (str/concat "." (default (array/nth @e 0) "")))) [(array/nth @e 0) REC{ expr => (str/replaceAll (object/get @rr "expr") "" @m) ## stmt => (object/get @rr "stmt") ## params => (object/get @rr "params") ## body => (object/get @rr "body") ## items => (object/get @rr "items") ## keys => (object/get @rr "keys") ## stmts => (object/get @rr "stmts") ## pairVals => (object/get @rr "pairVals") ## warns => (object/get @rr "warns") ## uses => (object/get @rr "uses") }]))) @es)))
           (let ((pairsText (str/join (array/map @typedEs (fn e FILL{@config.mapPair ## key => STR{(array/nth @e 0)} ## value => (object/get (default (array/nth @e 1) @nullR) "expr")})) @config.mapSep)))
             (let ((txt (if (and @typed (!= @config.recordForm "") (> (array/len @typedEs) 0))
-                         (str/concat "" (str/join (array/map @typedEs (fn e (str/concat "" (default (array/nth @e 0) "") "" (object/get (default (array/nth @e 1) @nullR) "expr") ""))) "") "")
+                         (str/concat "" (str/join (array/map (if (= @config.payloadFieldOrder "sorted") (array/map (array/sort (array/map @typedEs (fn se (default (array/nth @se 0) "")))) (fn sk (default (array/find @typedEs (fn se (= (array/nth @se 0) @sk))) [@sk @nullR]))) @typedEs) (fn e (str/concat "" (default (array/nth @e 0) "") "" (object/get (default (array/nth @e 1) @nullR) "expr") ""))) "") "")
                          (if (and (!= @config.mapEmpty "") (= (array/len @typedEs) 0)) @config.mapEmpty (str/concat @config.mapOpen @pairsText @config.mapClose)))))
               REC{ expr => @txt ## stmt => [(str/concat @txt @term)]
                 ## items => (array/map @typedEs (fn e (object/get (default (array/nth @e 1) @nullR) "expr")))
@@ -156,7 +176,7 @@
  (let ((root (default (array/nth @path 0) "")) (rest (array/drop @path 1)))
   (let ((attrBase (object/get @config.attributeRoots @root "")) (itemBase (object/get @config.itemRoots @root "")))
    (let ((kind (if (!= @attrBase "") "attr" (if (!= @itemBase "") "item" @config.localAccess)))
-         (base (if (!= @attrBase "") @attrBase (if (!= @itemBase "") @itemBase CASE{@root ## @config.localCase}))))
+         (base (if (!= @attrBase "") (if (= @root "entity") (str/concat "\ue00d" @attrBase "\ue00e") @attrBase) (if (!= @itemBase "") @itemBase CASE{@root ## @config.localCase}))))
     (let ((tail (str/join (array/map @rest (fn x (if (and (> (str/len @x) 0) (= (str/replace-pattern @x "[0-9]" "") "")) FILL{@config.indexAccess ## "0" => @x} (if (= @kind "attr") FILL{@config.attrAccess ## name => CASE{@x ## @config.fieldCase}} FILL{@config.itemAccess ## key => STR{@x}})))) "")))
      (let ((plain (str/concat @base @tail))
            (dtext (if (and (= @root "entity") (= (array/len @rest) 1)) LOOKUP{@ctx.defaults ## (default (array/nth @rest 0) "")} "")))

package/behaviors/lolo/spec/codec/lolo-source.gen/src_head.in

@@ -9,6 +9,7 @@ uses Spec from "almadar-std/lolo-source"
 type SrcExpr = string | number | boolean | [SrcExpr?] | Map string SrcExpr?
 type SrcJob = [SrcExpr?]
 type SrcList = [SrcExpr]
+type SrcMap = Map string SrcExpr?
 type SrcLists = [SrcList]
 type SrcVars = Map string string
 type SrcRef = { type : string! }
@@ -19,14 +20,18 @@ type SrcTransition = { from : string!, to : string!, event : string!, guard : Sr
 type SrcEvent = { key : string!, payloadSchema : [SrcField]? }
 type SrcMachine = { states : [SrcState]!, transitions : [SrcTransition]!, events : [SrcEvent]? }
 type SrcEmitDecl = { event : string!, payloadSchema : [SrcField]? }
-type SrcTraitDecl = { name : string!, linkedEntity : string?, config : Map string SrcKnobDecl?, emits : [SrcEmitDecl]?, stateMachine : SrcMachine? }
+type SrcListenSource = { kind : string!, trait : string?, orbital : string? }
+type SrcListenDecl = { event : string!, triggers : string?, source : SrcListenSource?, guard : SrcExpr?, payloadMapping : SrcExpr? }
+type SrcTraitDecl = { name : string!, ref : string?, linkedEntity : string?, config : Map string SrcKnobDecl?, emits : [SrcEmitDecl]?, stateMachine : SrcMachine?, listens : [SrcListenDecl]? }
+type SrcListenRow = { source : string!, event : string!, trigger : string!, guard : SrcExpr?, map : SrcExpr? }
 type SrcEntityDecl = { name : string!, fields : [SrcField]! }
 type SrcOrbital = { name : string!, entity : SrcEntityDecl?, traits : [SrcTraitDecl]! }
 type SrcProgram = { types : Map string [SrcField]?, orbitals : [SrcOrbital]! }
-type SrcInspect = { authoredProgram : SrcProgram!, types : Map string string!, expected : Map string string!, models : Map string [string]! }
+type SrcResolved = { program : SrcProgram! }
+type SrcInspect = { program : SrcProgram!, authoredProgram : SrcProgram!, types : Map string string!, expected : Map string string!, models : Map string [string]! }
 type SrcContainer = { name : string!, alias : boolean!, fields : [SrcField]! }
 type SrcKnob = { key : string!, default : SrcExpr? }
-type SrcTraitInfo = { name : string!, path : string!, entity : string!, initial : string!, hasMachine : boolean!, knobs : [SrcKnob]!, transitions : [SrcTransition]!, events : [string]!, listenTypes : Map string string!, emitTypes : Map string string!, emitVoid : [string]!, configType : string! }
+type SrcTraitInfo = { name : string!, path : string!, entity : string!, initial : string!, hasMachine : boolean!, knobs : [SrcKnob]!, transitions : [SrcTransition]!, events : [string]!, listenTypes : Map string string!, emitTypes : Map string string!, emitVoid : [string]!, configType : string!, orbital : string!, listenRows : [SrcListenRow]! }
 type SrcCtx = { emitTypes : Map string string!, emitVoid : [string]!, defaults : Map string string! }
 type SrcRender = { expr : string!, stmt : [string]!, params : [string]!, body : string!, items : [string]!, keys : [string]!, stmts : [[string]]!, pairVals : [string]!, warns : [string]!, uses : [string]! }
 type SrcTypeRender = { text : string!, uses : [string]! }