@almadar/std 17.0.0 → 17.0.2

package/behaviors/lolo/cli/atoms/std-orb-lint-entity-field-type.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-entity-field-type [
   version: "1.0.0",
   inbound: ["cli-lint-entity-field-type"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-entity-field-type — the `orb lint entity-field-type <file>` command, the port. It lowers the file with program/read and reports, for every primary and auxiliary entity, each top-level field with an empty name or, in an English program, a name that is not camelCase (ORB_E_INVALID_FIELD_NAME), a type outside the valid field types (ORB_E_INVALID_FIELD_TYPE) or a relation type with no relation configuration (ORB_E_INVALID_RELATION), the validate_field checks, with the Rust path, message and suggestion (status 500, exit 1). Orbitals marked `spec` are skipped, as validate_all_entities skips them. Clean answers `lint entity-field-type: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-entity-locale-instances.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-entity-locale-instances [
   version: "1.0.0",
   inbound: ["cli-lint-entity-locale-instances"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-entity-locale-instances — the `orb lint entity-locale-instances <file>` command, the port of ORB_E_LOCALE_INSTANCES_NOT_LOCAL, ORB_E_LOCALE_INSTANCES_UNKNOWN_LOCALE and ORB_E_LOCALE_INSTANCES_INCOMPLETE (entity.rs validate_all_locale_instances), plus ORB_E_INSTANCE_INVALID (entity.rs check_instance_rows) for the default `instances` rows and every locale block: a row key that is no field, a missing required field with no default, and, on a browser-stored entity, a row without an `id`. It lowers the file with program/read and, for every inline primary and auxiliary entity that writes per-locale rows, reports a non-browser-stored entity, a block for an undeclared or default locale, a missing default `instances` block and a missing block for a declared non-default locale, each with the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint entity-locale-instances: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-entity-mock-member.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-entity-mock-member [
   version: "1.0.0",
   inbound: ["cli-lint-entity-mock-member"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-entity-mock-member — the `orb lint entity-mock-member <file>` command, the port of ORB_E_MOCK_NOT_IN_ENUM (entity.rs validate_field). It lowers the file with program/read and, for every non-union field of a primary or auxiliary entity with declared values and a @mock, reports the comma-separated trimmed candidates that are not among the values, with the Rust path, message and suggestion (status 500, exit 1). Orbitals marked `spec` are skipped, as validate_all_entities skips them. Clean answers `lint entity-mock-member: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-entity-mutation.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-entity-mutation [
   version: "1.0.0",
   inbound: ["cli-lint-entity-mutation"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-entity-mutation - the `orb lint entity-mutation <file>` command, the port of the multi-trait entity mutation trio of entities/entity_mutation.rs. Per orbital, over its inline traits: a trait's mutated fields are the `(set @entity.<f> …)` targets in its guards, transition effects and tick effects, and its reads are every `@entity.<f>` it names there (id, createdAt and updatedAt aside). On a `[shared]` entity, a field written by two or more traits is ORB_SHARED_ENTITY_FIELD_CONFLICT unless the field is `@intrinsic` (each trait's own frame, G-ORB-540), and a slot that two or more render roots read it into is ORB_SHARED_ENTITY_RENDER_AUTHORITY: a top-level render-ui effect counts as a read only when it names a field of the entity that is not `@intrinsic` (an intrinsic field is the trait's own frame, never persisted, so reading it is not a render read of the shared row — this is a deliberate difference from the Rust check), each reader is attributed to the root trait that embeds it through `@trait.<Name>` in render-ui effects. On a `[runtime]` entity that is not shared, two or more mutating traits that are not instances of one source trait and that can share a page (page membership closes over `@trait.<Name>` embeds in effects) are ORB_ENTITY_SPLIT_MUTATION when one of them reads a field it never writes that another writes. Each finding carries the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint entity-mutation: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-entity-name-shadows-trait-union.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-entity-name-shadows-trait-union [
   version: "1.0.0",
   inbound: ["cli-lint-entity-name-shadows-trait-union"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-entity-name-shadows-trait-union — the `orb lint entity-name-shadows-trait-union <file>` command, the port of ORB_T_ENTITY_NAME_SHADOWS_TRAIT_UNION (entities/entity.rs validate_all_entities). It lowers the file with program/read and, for every non-spec orbital's inline primary and auxiliary entity, reports an entity named `<Trait>State` or `<Trait>Event` for any trait of the orbital (an inline trait by its name, a reference trait by its ref, else its name), the state shadow before the event shadow, at `orbitals[i].entity` or `orbitals[i].auxiliaryEntities[j]` with the Rust message and suggestion (status 500, exit 1). Orbitals marked `spec` are skipped. Clean answers `lint entity-name-shadows-trait-union: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-entity-persistence.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-entity-persistence [
   version: "1.0.0",
   inbound: ["cli-lint-entity-persistence"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-entity-persistence — the `orb lint entity-persistence <file>` command, the port of ORB_E_MISSING_COLLECTION and ORB_S_SHARED_WITHOUT_PERSISTENCE_MODE (entity.rs validate_entity and validate_all_entities). It lowers the file with program/read and reports each primary and auxiliary entity that is persistent and carries no collection name, and each shared entity (primary, auxiliary or a trait's data entity) with no persistence mode, with its path and suggestion (status 500, exit 1). Orbitals marked `spec` are skipped, as validate_all_entities skips them. Clean answers `lint entity-persistence: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-entity-semantic-default.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-entity-semantic-default [
   version: "1.0.0",
   inbound: ["cli-lint-entity-semantic-default"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-entity-semantic-default — the `orb lint entity-semantic-default <file>` command, the port of ORB_E_SEMANTIC_VALUE_INVALID (entity.rs validate_field). It lowers the file with program/read and, for every top-level field of a primary or auxiliary entity typed email, url, phone, uuid or image whose default is a string literal, reports an empty default and a default the validate/email, validate/url (also for image), validate/phone or validate/uuid operator rejects, with the Rust path, message and suggestion (status 500, exit 1). Orbitals marked `spec` are skipped, as validate_all_entities skips them. The default-against-declared-type check (ORB_E_DEFAULT_TYPE_MISMATCH, check_field_def_shape) is the compiler type checker's (config_type), not this lint's. Clean answers `lint entity-semantic-default: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-entity-shape.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-entity-shape [
   version: "1.0.0",
   inbound: ["cli-lint-entity-shape"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-entity-shape — the `orb lint entity-shape <file>` command, the port. It lowers the file with program/read and reports an entity with no name (ORB_E_MISSING_NAME), a non-PascalCase entity name (ORB_E_INVALID_FIELD_NAME, an English program only) and an entity with no fields (ORB_E_NO_FIELDS), the validate_entity checks, for every orbital's inline primary and auxiliary entity, with the Rust path, message and suggestion (status 500, exit 1). Orbitals marked `spec` are skipped, as validate_all_entities skips them. Clean answers `lint entity-shape: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-event-id-uniqueness.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-event-id-uniqueness [
   version: "1.0.0",
   inbound: ["cli-lint-event-id-uniqueness"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-event-id-uniqueness — the `orb lint event-id-uniqueness <file>` command, the port of ORB_ID_DUPLICATE_EVENT_ID (id_integrity.rs check_duplicate_event_ids; the other ORB_ID rules walk the ledger and are not ported). It lowers the file with program/read and, per orbital, reports each event id (stateMachine.events[].id or emits[].eventId) declared by two or more different inline traits, once per id sorted by id, with the Rust path and message (status 500, exit 1). An id repeated inside one trait is one owner. Clean answers `lint event-id-uniqueness: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-event-wiring.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-event-wiring [
   version: "1.0.0",
   inbound: ["cli-lint-event-wiring"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-event-wiring - the `orb lint event-wiring <file>` command, the port of validate_event_wiring (circuit/cross_orbital/event_wiring.rs): ORB_X_ORPHAN_LISTENER (a source-scoped listen, not external, not a wildcard or cross-orbital source and not of an event the kernel delivers itself (the bus-excluded lifecycle events, e.g. `$MOUNT`), whose event no trait emits, produces or handles: the declared emits and top-level emit effects of a trait, std-orb-produced-events' effect-tree productions, and every transition trigger), ORB_X_UNUSED_EMISSION (an emitted event nothing listens for and no trait handles, classified by std-orb-fired-events as a rendered dead control, a programmatic broadcast, an undecidable runtime-bound name or a stale declaration, with the exemptions for external scope, call-site emitsScope, config-knob offers and the unexercised offers of imported traits) and ORB_EMIT_UNROUTED_TO_HANDLER (a sibling trait with an arm for an event another trait fires, with no listens route delivering it, unless another trait routes that emission and the handler is wired by source-scoped routes of its own, so the composer stated what it hears). Each finding carries the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint event-wiring: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-expectation-config-knob.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-expectation-config-knob [
   version: "1.0.0",
   inbound: ["cli-lint-expectation-config-knob"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-expectation-config-knob — the `orb lint expectation-config-knob <file>` command, the port of check_config_knob (composition/expectations.rs), codes ORB_S_EXPECTED_FIELD_TYPE_MISMATCH and ORB_S_EXPECTATION_UNSATISFIED. An `expects config { name : type = default }` of a non-spec orbital is checked against the knobs of that name the program's inline traits declare: none is deferred; when no knob has the expected type (the same type name, the same closed value set in any order, and the same element and record shapes) the type mismatch lists what each trait declares; when the expectation states a default and no knob of the right type has it, the unsatisfied finding lists each trait's default. The program is the resolved program the lint input reads. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint expectation-config-knob: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-expectation-event-unfired.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-expectation-event-unfired [
   version: "1.0.0",
   inbound: ["cli-lint-expectation-event-unfired"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-expectation-event-unfired — the `orb lint expectation-event-unfired <file>` command, the port of the strict-event arm of validate_expectation_links (composition/expectations.rs), code ORB_S_EXPECTATION_UNSATISFIED. A strict (spec obligation) `expects trait T { emits E }` whose present trait declares E in `emits` but nothing in the program fires it is reported, unless the trait binds an event-bearing render prop to an @-binding in an effect (a dynamic event name, the pattern registry's event props read from std-orb-lint-input). It composes std-orb-fired-events for which events each trait fires by a control or by an effect. A lenient expectation, an absent trait and an event the trait does not emit are not this rule. The program is the resolved program the lint input reads. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint expectation-event-unfired: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-expectation-field-undeclared.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-expectation-field-undeclared [
   version: "1.0.0",
   inbound: ["cli-lint-expectation-field-undeclared"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-expectation-field-undeclared — the `orb lint expectation-field-undeclared <file>` command, the port of the persist-payload arm of validate_expectations (composition/expectations.rs validate_persist_payload_self_consistency), code ORB_S_EXPECTATION_FIELD_UNDECLARED. In an orbital that declares `expects`, a top-level `persist create|update|upsert|delete <Entity> { payload }` effect of an authored trait (one with no sourceBehavior, in a transition or a tick) or a statically readable persist batch op writing to an `expects entity <Entity> { shape }` the orbital itself declares (a non-strict one; the first such entry decides) must keep its payload keys inside that shape; an existence-only expectation, a spec obligation and an entity with no expectation opt out. The program is the resolved program the lint input reads. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint expectation-field-undeclared: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-expectation-final.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-expectation-final [
   version: "1.0.0",
   inbound: ["cli-lint-expectation-final"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-expectation-final — the `orb lint expectation-final <file>` command, the port of validate_final_expectations (composition/expectations.rs), the `orb validate --final` rule: where a generation concludes the program is the whole app, so every `expects` entry of every orbital (spec orbitals included, strict or not) that nothing in the program provides is ORB_S_EXPECTATION_UNSATISFIED. Providers are the inline entities of non-spec orbitals (entity, named identity, bare [identity]); a trait (event, state, transition), a page (by route path or protocol word) and a config knob are looked up in every orbital. The program is the resolved program the lint input reads. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint expectation-final: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-expectation-persistent-unwritten.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-expectation-persistent-unwritten [
   version: "1.0.0",
   inbound: ["cli-lint-expectation-persistent-unwritten"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-expectation-persistent-unwritten — the `orb lint expectation-persistent-unwritten <file>` command, the port of persistent_never_written (composition/expectations.rs), code ORB_S_EXPECTATION_UNSATISFIED. A strict (spec obligation) `expects entity X [persistent]` whose provider entity is present obliges the program to write X: it is reported when no inline trait of any orbital lands a `persist create|update|upsert` of X in a transition or tick effect (a single persist op, or a persist batch whose followable list builders array/concat, array/prepend, array/append, array/filter, array/map over an op template, array/flatten, array/take and if are folded with tree/fold, falling back to the literal and mapped op tuples when a builder cannot be followed). A lenient expectation, an absent provider and a non-persistent storage mode are not this rule. The program is the resolved program the lint input reads. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint expectation-persistent-unwritten: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-expectation-provider-mismatch.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-expectation-provider-mismatch [
   version: "1.0.0",
   inbound: ["cli-lint-expectation-provider-mismatch"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-expectation-provider-mismatch — the `orb lint expectation-provider-mismatch <file>` command, the port of the ORB_S_EXPECTATION_PROVIDER_MISMATCH findings of validate_expectation_links (composition/expectations.rs: check_identity_link, check_entity_facts, the @key/@unique marks of check_shape, and the page-trait arm). For every non-spec orbital's `expects` entry whose provider is present it reports: an `expects entity Name [identity]` whose named provider entity carries no [identity] tag; an `expects entity X` shape field marked @key or @unique that the provider declares without the mark (at the field path); an `expects entity X` stating a storage mode, [shared], [browser], an @read/@create/@update/@delete policy (structurally equal) or an `@op none` waiver the provider entity does not carry; and an `expects page` listing traits that none of the matching provider pages mounts. An absent provider is deferred. The program is the resolved program the lint input reads. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint expectation-provider-mismatch: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-expectation-unsatisfied.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-expectation-unsatisfied [
   version: "1.0.0",
   inbound: ["cli-lint-expectation-unsatisfied"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-expectation-unsatisfied — the `orb lint expectation-unsatisfied <file>` command, the port of the ORB_S_EXPECTATION_UNSATISFIED findings of validate_expectation_links (composition/expectations.rs). For every non-spec orbital's `expects` entry it reports: a strict (spec obligation) entity, identity, event, state, transition, page or config expectation nothing in the program provides (providers are the inline entities of non-spec orbitals; traits and pages are looked up in every orbital), `a spec obligation is never deferred`; an `expects trait T { state S }` whose present trait declares no such state; an `expects trait T { S --E--> S2 }` whose present trait has no such transition; and an `expects trait T { emits E }` whose present trait does not emit E. An absent provider of a lenient expectation is deferred, never reported. The program is the resolved program the lint input reads. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint expectation-unsatisfied: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-expected-field-not-provided.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-expected-field-not-provided [
   version: "1.0.0",
   inbound: ["cli-lint-expected-field-not-provided"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-expected-field-not-provided — the `orb lint expected-field-not-provided <file>` command, the port of the ORB_S_EXPECTED_FIELD_NOT_PROVIDED findings of validate_expectation_links (composition/expectations.rs: the name arm of check_shape and of check_event_payload). For every non-spec orbital's `expects` entry whose provider is present it reports: an `expects entity X { shape }` (or `expects entity Name [identity] { shape }` whose provider carries the [identity] tag, or a bare `expects entity [identity]` against the first [identity] entity) field the provider entity declares no field of that name for (at the field path); and an `expects trait T { emits E { payload } }` field the present trait's emitted E declares no payload field for. Width is free: extra provider fields are fine; an absent provider or trait is deferred. Whether a present field is compatible (requiredness, vocabulary, type) is not this rule. The program is the resolved program the lint input reads. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint expected-field-not-provided: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-external-emit-payload.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-external-emit-payload [
   version: "1.0.0",
   inbound: ["cli-lint-external-emit-payload"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-external-emit-payload — the `orb lint external-emit-payload <file>` command, the port of validate_external_emit_payloads (circuit/cross_orbital/payload.rs, ORB_T_EVT_EXTERNAL_MISSING_PAYLOAD). An emit declared `scope: external` with no payload fields only matters when a listener in ANOTHER orbital is wired to this emitter and would receive nothing. A listener is wired to this emitter by its recorded source trait (a trait or orbital source names the emitting trait, a wildcard or absent source matches any emitter of the event), and it expects fields only when the event its route triggers (the listen's `triggers`, else its own event) declares at least one required payload field on its trait's state machine; an empty emit satisfies a listener that expects nothing. Reports at traits.<Trait>.emits.<EVENT> (status 500, exit 1). Clean answers `lint external-emit-payload: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-fetch-by-id-payload.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-fetch-by-id-payload [
   version: "1.0.0",
   inbound: ["cli-lint-fetch-by-id-payload"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-fetch-by-id-payload — the `orb lint fetch-by-id-payload <file>` command, the port of ORB_EFF_FETCH_BY_ID_PAYLOAD_LIST (entities/fetch_by_id_payload.rs, run per trait from closed_circuit). It needs the RESOLVED program (program/read resolve), so a `use`-imported atom's traits are checked too. For every trait with a state machine it finds each `(fetch X { emit: { success: E } … })` in transition effects (through nested arrays, not through objects), keyed when the options carry `id`. An event E that only by-id fetches produce and whose declared `data` field (the trait's emits, then its state-machine events) has a list type is reported once at `orbitals[i (O)].traits[j (T)].stateMachine.transitions[n].effects` with the Rust message and suggestion (status 500, exit 1); an event a list fetch in the same trait also produces is not reported. Clean answers `lint fetch-by-id-payload: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-fetch-deliver.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-fetch-deliver [
   version: "1.0.0",
   inbound: ["cli-lint-fetch-deliver"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-fetch-deliver - the `orb lint fetch-deliver <file>` command, the port of entities/fetch_deliver.rs. Option checks: for every inline trait it finds each `(fetch X { … })` in the transition effects (through nested arrays, not through objects) whose options carry `deliver: \"ids\"`: with an `include` option it is ORB_FETCH_DELIVER_IDS_ENTITY_REFS, without a non-empty `emit.success` it is ORB_FETCH_DELIVER_IDS_NO_SUCCESS, each reported at `orbitals[i (O)].traits[j (T)].stateMachine.transitions[n].effects` with the include findings first, once per fetch. Reads: a fetch with `deliver: ids` and/or `total: none` and a success event restricts what the receiving arms may read of that event's payload. The receivers are the fetching trait's own arms of the success event plus the arms a `listens` route triggers (the route's source decided by the listen-address rules; a mapped payload carries only the mapped fields, the original delivery stays reachable as `@event.payload`). Every receiving guard, effect and route guard or mapping is walked with the operators' declared value-source slots (std-orb-lint-input's LINT_OPERATOR_WALK) and field projections: a binding or interpolated binding that reads inside a restricted `data` is ORB_FETCH_DELIVER_IDS_ROWS_READ, one that reads `totalCount` of a `total: none` fetch is ORB_FETCH_TOTAL_NONE_READ; the one allowed read of `data` is a whole `@payload.data` as a first-level prop of a `render-ui` argument. Clean answers `lint fetch-deliver: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-field-path.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-field-path [
   version: "1.0.0",
   inbound: ["cli-lint-field-path"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-field-path — the `orb lint field-path <file>` command, the port of ORB_RUI_INVALID_FIELD_PATH (field_path.rs validate_field_paths). It lowers the file with program/read and walks the pattern (third element) of every render-ui effect of every transition the way the compiler's pattern validator does (a pattern object with a type, then its children: one object, a list, a mapped-children `array/map` with a lambda, or the arms of a conditional node). For a pattern with a literal entity name the program defines and a `fields` list, each dotted entry is checked: its first segment must be a relation field of the entity (name or name+Id), the second must be a field of the relation's target entity, and more than two segments is reported. Entity definitions are the primary and auxiliary entities of every orbital, a later one replacing an earlier one of the same name and a primary name declared in two orbitals dropped, as the compiler builds them. An unknown entity or relation target is silent. ORB_X_UNRESOLVED_PATTERN_FIELD_REF is not ported: it reads the pattern registry's field-ref prop kinds, which no lint input carries. Children written as operator calls are not expanded, since no lint input carries the namespaced operator names. Clean answers `lint field-path: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-filter-field-never-written.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-filter-field-never-written [
   version: "1.0.0",
   inbound: ["cli-lint-filter-field-never-written"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-filter-field-never-written — the `orb lint filter-field-never-written <file>` command, the port of ORB_X_FILTER_FIELD_NEVER_WRITTEN (circuit/cross_orbital/filter_field_written.rs). A fetch in a client-bound trait (a trait a route page mounts, plus its @trait embed closure) whose filter reads a literal (object/get @entity <field>) that no persist create/update/upsert (a single op or a statically readable persist batch) of the fetched entity or a persistent-collection mate ever supplies. An [identity] entity, an unresolved entity, an @intrinsic field, a declared field of an entity nothing in the program creates, and a declared field with a default stay silent; a default only exempts when an equality comparand is undecidable or folds to the default, a comparand folding as a literal or an @config.<knob> default and anything else as undecidable. The program is the resolved program the lint input reads. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint filter-field-never-written: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-finding-codes.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-finding-codes [
   version: "1.0.0",
   inbound: ["cli-lint-finding-codes"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-finding-codes - the `orb lint finding-codes <file>` command, the prevention rung of the lint code registry: a trait that declares a `codes` knob (a lint rule) may name a finding code only from that knob's declared record, which the generated registry reads. Every object under a transition or tick of such a trait whose `code` is a string the record does not declare is an error at the trait, one per occurrence. The program is the resolved one, so a `@config.codes.<name>.code` read is already its declared value: a literal that spells a declared code cannot be told from the read, and the type checker owns an undeclared name. Each finding reads its code from the rule's `codes` record (findingCodeUndeclared). Clean answers `lint finding-codes: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-generic-types.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-generic-types [
   version: "1.0.0",
   inbound: ["cli-lint-generic-types"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-generic-types - the `orb lint generic-types <file>` command, the port of ORB_T_GENERIC_TYPE_DEPRECATED. It lowers the file with program/read and reports every inline trait config knob typed json, any or scalar (or a list of them) and every emit payload field typed json, any, scalar or shapeless object, with its path and suggestion (status 500, exit 1). Entity fields, the schema and orbital types maps and emit and event payloads are walked through nested properties and array items at any depth with tree/fold, like the Rust check. Clean answers `lint generic-types: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-groupby-enum-column-gap.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-groupby-enum-column-gap [
   version: "1.0.0",
   inbound: ["cli-lint-groupby-enum-column-gap"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-groupby-enum-column-gap — the `orb lint groupby-enum-column-gap <file>` command, the port of ORB_RENDER_GROUPBY_ENUM_COLUMN_GAP (validate_groupby_enum_column_gap, types/config_type.rs). It lowers the file with program/read and, for every inline trait whose config holds a `groupByField` string default and a `columns` array default of `{ key }` objects, looks up the trait's linked entity (a primary or auxiliary inline entity; a primary name declared by more than one orbital is ambiguous and skipped, a later declaration of a name wins) and its field of that name; when the field is an enum whose values include some the columns do not key, it reports the hidden values at `<trait>.config.groupByField` with the compiler's message and suggestion (status 500, exit 1). Clean answers `lint groupby-enum-column-gap: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-guest-view-not-client.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-guest-view-not-client [
   version: "1.0.0",
   inbound: ["cli-lint-guest-view-not-client"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-guest-view-not-client — the `orb lint guest-view-not-client <file>` command. It lowers the file with program/read and reports ORB_GUEST_VIEW_NOT_CLIENT for every transition of an inline trait whose dispatch mode is not client and whose render-ui effect, at any depth of the effect list, holds a `guest-view` node anywhere in its content tree. The kernel delivers a click inside a guest session's view only when the trait that paints it runs on the client, because only the client render store holds that paint, so a server trait painting a guest-view leaves its controls dead. One finding per transition at `orbitals[i (Orbital)].traits[j (Trait)].stateMachine.transitions[k]` (status 500, exit 1). A guest-view that appears only as text, or a client trait, is not reported. Clean answers `lint guest-view-not-client: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-host-effects.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-host-effects [
   version: "1.0.0",
   inbound: ["cli-lint-host-effects"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-host-effects — the `orb lint host-effects <file>` command, the port of effect/host_effects.rs (validate_host_effects): every call of an operator the installed operator table marks `closedCall` (random-bytes, access-check and the credential-* effects), found at any depth of a guard or effect of an inline trait. The operators, their arity bounds, the integer range of an argument, whether the first parameter is a request object with its declared and required fields, and the options keys all come from the table through std-orb-lint-host-calls, never from this atom. Reports ORB_HOST_EFFECT_ARITY (the call has fewer or more arguments than the table allows), ORB_RANDOM_BYTES_COUNT (a literal number at the table's intRange argument that is not a whole number inside the range), ORB_CREDENTIAL_REQUEST_INVALID (a literal request that is not an object, carries a field the table does not declare, or lacks a required one; a binding is the runtime's to check) and ORB_HOST_EFFECT_OPTION_UNKNOWN (an options argument that is not an object or carries a key the table does not declare). The `emit` block of an options object is checked through std-orb-emit-config against the operator's emit keys (ORB_EFF_EMIT_KEY_INVALID, ORB_EFF_EMIT_INVALID_NAME, ORB_EFF_EMIT_UNDECLARED_EVENT); the key findings belong to std-orb-lint-keyed-call-keys. Findings carry the Rust path (the guard or effect), message and suggestion (status 500, exit 1). Clean answers `lint host-effects: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-http-egress-entry.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-http-egress-entry [
   version: "1.0.0",
   inbound: ["cli-lint-http-egress-entry"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-http-egress-entry — the `orb lint http-egress-entry <file>` command, the port of ORB_HTTP_EGRESS_ENTRY_INVALID (effect/http.rs validate_http_effects over http_wire parse_egress_entry). It lowers the file with program/read and reports each app `egress` entry that is not `scheme://host[:port]` for http, https, redis, rediss, postgres or postgresql (no path, query, credentials, space, backslash, empty host or a port outside 0..65535), with the Rust path, message and suggestion (status 500, exit 1). The other ORB_HTTP rules check the arguments of `http` calls nested in effects, which this lint cannot walk without a tree fold. Clean answers `lint http-egress-entry: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-icon-exists.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-icon-exists [
   version: "1.0.0",
   inbound: ["cli-lint-icon-exists"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-icon-exists — the `orb lint icon-exists <file>` command, the port of the ORB_UI_ICON_NOT_FOUND check of icon.rs (validate_icon_value). It walks the same icon positions as icon-format (the `icon` prop, `actions[i].icon` and `itemActions[i].icon` of every object inside the pattern of a `render-ui` effect, recursing as the compiler does) and reports a well-formed icon name (kebab-case or PascalCase, not a binding, not blank) whose kebab-case form (PascalCase lowers each capital to -x, kebab-case lowercases) is not in the installed Lucide set, which comes from std-orb-lint-input's LINT_UI_VOCAB (orbLanguage.uiVocabulary.lucideIcons). The suggestion lists up to three installed icons whose distinct-character overlap with the name (shared distinct characters over the larger distinct-character count) is above 0.3, best first, ties in vocabulary order. An unreadable vocabulary answers ORB_LINT_UI_VOCAB_UNREAD. Clean answers `lint icon-exists: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-icon-format.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-icon-format [
   version: "1.0.0",
   inbound: ["cli-lint-icon-format"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-icon-format — the `orb lint icon-format <file>` command, the port of the ORB_UI_ICON_INVALID_FORMAT and ORB_UI_ICON_EMPTY checks of icon.rs (validate_all_icons). It lowers the file with program/read and walks the pattern (third element) of every `render-ui` effect of every transition for an `icon` prop, an `actions[i].icon` and an `itemActions[i].icon` on each object, recursing into object-valued props and into the object elements of array-valued props (an actions entry is therefore reached twice, as the compiler does). An icon that is not a string, an empty or blank name, and a name that is neither kebab-case nor PascalCase are reported; a binding (starts with @) is skipped. ORB_UI_ICON_NOT_FOUND (a name outside the Lucide set) is not ported: no lint input carries the Lucide icon list. Clean answers `lint icon-format: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-id-refs.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-id-refs [
   version: "1.0.0",
   inbound: ["cli-lint-id-refs"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-id-refs — the `orb lint id-refs <file>` command, the port of the compiler's ORB_ID_UNKNOWN_REF, ORB_ID_KIND_MISMATCH, ORB_ID_NAME_MISMATCH and ORB_ID_LEDGER_ORPHAN (id_integrity.rs). It lowers the file with program/read and checks every dual-carry id the compiler walks: the primary and auxiliary entities (extends, and field relations at any depth through items and properties), each trait data entity, every trait of the orbital and of its inline pages and page objects (linked entity, entityRefIds, emits, listens and their sources, a reference trait's ref), and the page object ref, linkedEntity and traitRefIds: the id's kind prefix against the position, the id against the declared nodes and the ledger, and the sibling name against the ledger curName (an `@config.<key>` curName is satisfied by the owning trait's config default). A ledger row that no declared node, checked id or `@trait.<Name>` embed carries is an orphan (an event row is carried by its live parent trait). Each finding has the Rust path and message (status 500, exit 1): positions of the entities and pages come first, then the traits, then the orphans. Clean answers `lint id-refs: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-identity-unique.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-identity-unique [
   version: "1.0.0",
   inbound: ["cli-lint-identity-unique"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-identity-unique — the `orb lint identity-unique <file>` command, the port of ORB_S_IDENTITY_NOT_UNIQUE (user_identity.rs validate_user_identity, roster check). It lowers the file with program/read and reports when more than one differently named entity is tagged [identity]; primary entities shadow imported auxiliary copies. Status 500, exit 1. Clean answers `lint identity-unique: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-inbound-answer-foreign.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-inbound-answer-foreign [
   version: "1.0.0",
   inbound: ["cli-lint-inbound-answer-foreign"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-inbound-answer-foreign — the `orb lint inbound-answer-foreign <file>` command, the port of ORB_INBOUND_ANSWER_FOREIGN (effect/inbound.rs validate_inbound). Only the handler trait's own emit of its answer event answers an inbound hook (EXEC-INBOUND-1). It lowers the file with program/read and, for every inline trait event that handles an inbound hook, reports each other trait that emits the answer event by an effect (std-orb-fired-events' byEffect) when that trait does not handle a hook answering the same event itself and the handler has no `listens` route from it that relays the event, once per emitter in name order, at the event with the Rust message and suggestion (status 500, exit 1). The entry, undeclared, duplicate, verifies and answer-undeclared checks of validate_inbound are `std-orb-lint-inbound`. Clean answers `lint inbound-answer-foreign: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-inbound.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-inbound [
   version: "1.0.0",
   inbound: ["cli-lint-inbound"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-inbound — the `orb lint inbound <file>` command, the port of ORB_INBOUND_ENTRY_INVALID, ORB_INBOUND_UNDECLARED, ORB_INBOUND_DUPLICATE, ORB_INBOUND_VERIFY_INVALID and ORB_INBOUND_ANSWER_UNDECLARED (effect/inbound.rs validate_inbound). It lowers the file with program/read, checks the app's `inbound` entries (a lower-case hook name, listed once) and every inline trait event that handles an inbound hook (declared by the app, one handler per name, a `verifies` header and credential of the right form, an answer the trait emits), each with the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint inbound: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-init-coverage.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-init-coverage [
   version: "1.0.0",
   inbound: ["cli-lint-init-coverage"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-init-coverage — the `orb lint init-coverage <file>` command, the port of ORB_CIRCUIT_INIT_UNCOVERED_STATE (G-ORB-186). It lowers the file with program/read and, for every trait a page of its orbital declares whose initial state handles INIT, reports each reachable state with no INIT arm (status 500, exit 1). Reachability follows transitions from their from states or the wildcard and skips a statically false guard (statically false (a falsy literal, a comparison of two literals, or an and/or/not of those, folded with tree/fold) that cannot hold). Clean answers `lint init-coverage: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-input.lolo

@@ -1,7 +1,7 @@
 app std-orb-lint-input [
   version: "1.0.0",
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-input — the one place a lint run reads its file. For a LINT_REQUEST { file } it reads the file, scans the installed language packs (std-orb-language's engine, std-semver for the range check), decides from the raw text whether the program is in the English vocabulary (a .orb document by its top-level keys, a .lolo source by its first token), reads the installed @almadar/core component mapping (the root the language scan reports) and answers LINT_COMPONENTS { names }, reads the pattern registry the manifest declares at orbLanguage.patterns and answers LINT_EVENT_PROPS { names, maps, listens } (the event-bearing prop names), reads the installed @almadar/std operator table and answers LINT_OPERATORS { names } (the names with no namespace) and LINT_OPERATOR_SEMANTICS { semantics, functions } (the function-returning operators), resolves it with program/read { resolve } (the inlined program `orb resolve` prints, its `uses lazy` behaviors split off) and answers LINT_LAZY { orbitals } (the lazy children by orbital) LINT_INDEX { scope, heads, roots } (the structural index of the pass: per inline trait and per transition effect list, the operator heads and the binding roots it uses, built by one tree/fold pass per unit) and LINT_INPUT { file, raw, latin, program } to every rule trait that listens (a rule that walks effect expressions also asks the OrbLintExprNodes trait of this file: LINT_EXPR_ASK { requestId, items } answers LINT_EXPR_NODES { requestId, nodes }, the typed flat nodes of each asked expression), the index first; a LINT_CHILD_REQUEST { index } answers LINT_INPUT again with that lazy child's program and its orbital as `scope` (empty for the program itself), which each rule echoes in LINT_FOUND; an unreadable or unlowerable file, or a failed pack scan, answers LINT_INPUT_UNREAD { file }. A rule trait only analyzes this input; the rule cli traits and the lint-all umbrella each issue one request."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-item-action-event.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-item-action-event [
   version: "1.0.0",
   inbound: ["cli-lint-item-action-event"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-item-action-event — the `orb lint item-action-event <file>` command, the port of ORB_RUI_INVALID_ITEM_ACTION (item_actions.rs validate_item_actions, the required-event half). It lowers the file with program/read and walks the pattern (third element) of every render-ui effect of every transition the way the compiler's pattern validator does: a pattern object with a type is checked, then its children (one object, a list, a mapped-children `array/map` with a lambda, or the arms of a conditional node) are walked with their paths. Each itemActions entry that is an object with neither `event` nor `navigatesTo` is reported at the pattern's path plus itemActions[i]. ORB_RUI_UNKNOWN_ITEM_ACTION_PROP (the other half of validate_item_actions) is not ported: it needs the union of itemActions item properties over the pattern registry, which no lint input carries. Children written as operator calls (array/concat and the like) are not expanded, since no lint input carries the namespaced operator names. Clean answers `lint item-action-event: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-keyed-call-keys.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-keyed-call-keys [
   version: "1.0.0",
   inbound: ["cli-lint-keyed-call-keys"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-keyed-call-keys — the `orb lint keyed-call-keys <file>` command, the port of the key rules of keyed_call.rs and check_key_and_cancelled: ORB_CALL_SERVICE_KEY_TYPE (a `key` that is null, an empty string, or a number, boolean, object or array literal), ORB_CALL_SERVICE_CANCELLED_WITHOUT_KEY (an `emit.cancelled` route on a call with no non-null `key`) and ORB_CALL_KEY_UNUSED (a literal `(as \"k\" CallKey)` in a program whose every keyed call is keyed by a literal, none of them \"k\"). The keyed operators come from LINT_OPERATOR_SHAPES: an operator is keyed when a param's object type has a `key` field; the param is the options object when it also has `emit`, a request that only names the call (browser/beacon) otherwise. It needs the RESOLVED program (program/read resolve). A key-type finding is reported at the top effect of the transition or tick, once per violation; an unused key at the guard or effect that holds the cast. Findings print as `[code] path: message` (status 500, exit 1); clean answers `lint keyed-call-keys: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500. A key whose type only inference decides (a number-typed @config knob, `(+ 1 2)`) is not decided here; it stays with the compiler."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-keyed-call.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-keyed-call [
   version: "1.0.0",
   inbound: ["cli-lint-keyed-call"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-keyed-call — the `orb lint keyed-call <file>` command, the port of the key-and-emit rules of keyed_call.rs that need no type inference: ORB_EFFECT_OPTION_DROPPED (a `persist` or `fetch` whose options object declares both `emit` and `key`, which the completion never echoes; reported at the top effect of the transition or tick, once per such call) and ORB_CALL_SERVICE_KEY_DUPLICATE (two `call-service` calls in one transition whose trailing options carry the same literal `key`; a key starting with @ or ? is computed and never duplicates; reported at the second call). It needs the RESOLVED program (program/read resolve), so a `use`-imported atom's traits are checked too. Findings print as `[code] path: message` (status 500, exit 1); clean answers `lint keyed-call: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500. ORB_CALL_KEY_UNUSED, ORB_CANCEL_CALL_NO_KEYED_CALL and the key-expression type check are not ported here: they need the substrate and tab operator set or inferred expression types, which the lint input does not carry."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-listen-per.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-listen-per [
   version: "1.0.0",
   inbound: ["cli-lint-listen-per"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-listen-per — the `orb lint listen-per <file>` command (EXEC-STEP-1a). A trait whose listens carry a `per <expr>` clause is stepped on rows addressed by that key, so its entity must be a `[runtime]` entity that declares an `id : string` field (ORB_X_LISTEN_PER_ENTITY) and the trait must not be placed on a route page (ORB_X_LISTEN_PER_ROUTED_PAGE): a route page mounts one viewer frame, never keyed rows. Both are errors. Clean answers `lint listen-per: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-listen-redundant-embed-route.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-listen-redundant-embed-route [
   version: "1.0.0",
   inbound: ["cli-lint-listen-redundant-embed-route"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-listen-redundant-embed-route — the `orb lint listen-redundant-embed-route <file>` command, the port of ORB_LISTEN_REDUNDANT_EMBED_ROUTE (circuit/cross_orbital/listen_redundant.rs). A control inside an embedded trait emits under every scope on its embed chain, so a host that embeds Child and declares a transition on EV already hears Child's control-fired EV; a same-name route `listens { Child.EV -> EV }` on that host delivers the same event a second time. It resolves the program, builds each orbital's embed graph (a trait's first referrer by @trait.<Name> in its config defaults, guards, effects and tick effects is its host), asks the std-orb-fired-events trait which events each trait fires by a control or by an effect, and reports each same-name trait route from a trait the host embeds, to an event the host has a transition on, that the source does not emit by an effect and some control under the source fires. Findings carry the Rust path, message and suggestion (status 500, exit 1). Clean answers `lint listen-redundant-embed-route: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-listen-route-starves-required-field.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-listen-route-starves-required-field [
   version: "1.0.0",
   inbound: ["cli-lint-listen-route-starves-required-field"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-listen-route-starves-required-field — the `orb lint listen-route-starves-required-field <file>` command, the port of validate_listen_route_starves_required_field (circuit/cross_orbital/listen_starvation.rs, ORB_LISTEN_ROUTE_STARVES_REQUIRED_FIELD). A `listens { Src.EVENT -> TRIGGER }` route delivers what the source trait's declared emit contract produces (pass-through) or, with an explicit `with { … }` mapping, only the mapping's top-level keys. When the listening trait's TRIGGER declares a required leaf field (dotted path; a required field inside an optional container is owed only when the route delivers that container; an entity-typed field is one leaf) the route can never supply, the consumer reads it as undefined. A pass-through route is credited with the source emit's declared payload path, or, for an emit fired by a definer knob that carries no schema, the literal default of the source's `@payload(<knob>)` companion config field. Only trait and orbital sources whose orbital is in the program and whose trait and emit contract resolve are compared. Reports one error per starved path at orbitals.<Orbital>.traits.<Trait>.listens (status 500, exit 1). Clean answers `lint listen-route-starves-required-field: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-listen-source-never-produces.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-listen-source-never-produces [
   version: "1.0.0",
   inbound: ["cli-lint-listen-source-never-produces"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-listen-source-never-produces — the `orb lint listen-source-never-produces <file>` command, the port of validate_listen_source_never_produces (circuit/cross_orbital/listens.rs, ORB_X_LISTEN_SOURCE_NEVER_PRODUCES). A `listens` route sourced at a trait (the listener's own orbital) or at an orbital's trait resolves by the source trait's `emits` contract; this second half asks whether anything live still backs the event. The route is reported when the source trait declares the event in `emits`, std-orb-fired-events finds no control or effect of that trait firing it, and no other trait embedded under the source (std-orb-embed-chain's host chains) fires it either; it holds whatever the emit's declared scope. A source orbital not in the program, a source trait not found, or an event the source never declares are skipped. Reports once per route at orbitals.<Orbital>.traits.<Trait>.listens (status 500, exit 1). Clean answers `lint listen-source-never-produces: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-listen-source-unresolved.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-listen-source-unresolved [
   version: "1.0.0",
   inbound: ["cli-lint-listen-source-unresolved"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-listen-source-unresolved — the `orb lint listen-source-unresolved <file>` command, the port of validate_listens_integrity (circuit/cross_orbital/listens.rs, ORB_X_LISTEN_SOURCE_UNRESOLVED). A `listens` entry sourced at a trait (the listener's own orbital) or at an orbital's trait must name an event the source trait declares in `emits` or produces: the events std-orb-produced-events finds produced by its effect trees (an emit map slot of an operator call, a rendered pattern's event prop or event-list field). A source orbital that is not in the program is out of scope and skipped. An unresolved entry is reported once per entry at orbitals.<Orbital>.traits.<Trait>.listens; a bare `Trait.EVENT` source whose trait declares the event in a sibling orbital names that orbital's qualified form in the suggestion (the first such orbital in program order). Reports ORB_X_LISTEN_SOURCE_UNRESOLVED (status 500, exit 1). Clean answers `lint listen-source-unresolved: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-listen-trigger.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-listen-trigger [
   version: "1.0.0",
   inbound: ["cli-lint-listen-trigger"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-listen-trigger — the `orb lint listen-trigger <file>` command, the port of ORB_X_LISTEN_TRIGGER_UNMATCHED. It lowers the file with program/read and, for every inline trait with listens, requires each listen's trigger (its `-> TRIGGER`, else the listened event) to be the event of a transition in the same trait. Each unmatched listen is reported with its path and suggestion (status 500, exit 1). Clean answers `lint listen-trigger: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-listen-wildcard-unkeyed.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-listen-wildcard-unkeyed [
   version: "1.0.0",
   inbound: ["cli-lint-listen-wildcard-unkeyed"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-listen-wildcard-unkeyed — the `orb lint listen-wildcard-unkeyed <file>` command, the port of ORB_LISTEN_WILDCARD_UNKEYED (listen_unkeyed.rs validate_wildcard_listen_keyed, a warning). A trait that makes call keys (an (as … CallKey) anywhere in its own definition) and listens `*.EVENT` for an event some trait emits with a CallKey-typed `key` payload field, with a guard that never reads @payload.key, hears other callers' replies. It lowers the file with program/read and reports each such listens route at orbitals.<orbital>.traits.<trait>.listens with the Rust message and suggestion (status 500, exit 1). Clean answers `lint listen-wildcard-unkeyed: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-literal-default.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-literal-default [
   version: "1.0.0",
   inbound: ["cli-lint-literal-default"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-literal-default — the `orb lint literal-default <file>` command, the port of ORB_E_LITERAL_UNION_DEFAULT_MISMATCH. It lowers the file with program/read and, for every orbital's inline entity, checks each field that declares a non-empty values list and a string default: the default must be one of the values. Each mismatch is reported with its path and suggestion (status 500, exit 1). A non-string default is not this rule's business. Clean answers `lint literal-default: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]

package/behaviors/lolo/cli/atoms/std-orb-lint-llm-wire-unrouted.lolo

@@ -2,7 +2,7 @@ app std-orb-lint-llm-wire-unrouted [
   version: "1.0.0",
   inbound: ["cli-lint-llm-wire-unrouted"],
   env: ["PATH"],
-  exec: ["orb"],
+  exec: [exe],
   fs: { cwd: "**": [read], "/**": [read], "~/.orb/node_modules/**": [read] },
   description: "std-orb-lint-llm-wire-unrouted — the `orb lint llm-wire-unrouted <file>` command (ORB_X_LLM_WIRE_UNROUTED). std-llm hands its HTTP calls to the composer: LLM_CHAT_WIRE and LLM_EMBED_WIRE carry the request, LLM_CHAT_WIRE_CANCEL and LLM_EMBED_WIRE_CANCEL abort it, and the composer routes each to std-http-request. A composed trait that declares one of these in its `emits`, reaches it from an event a route delivers to it (std-orb-effect-leaves flattens the emit effects of its transitions; the events that lead to the wire event are the transitions' emit chain, followed backwards to a fixed point), and has no trait in the program listening to its wire event, sends a request that never leaves the program: the call waits for an answer nothing sends. A trait no route reaches the wire from (an embed-only composer's chat wire) is not reported, and a cancel wire is reported only when its request wire is routed (nothing is in flight to abort otherwise). A route sourced at the trait (the listener's own orbital) or at the trait's orbital counts. Reports once per trait and wire event at orbitals.<Orbital>.traits.<Trait> (status 500, exit 1). The rule asks std-orb-effect-leaves for the emit effects (heads: emit) and reads each emitted event name from their flat typed nodes. Clean answers `lint llm-wire-unrouted: clean` (status 200, exit 0). Anything but one file argument is the usage (status 400, exit 2); an unreadable or unlowerable file is status 500."
 ]