@cratis/pi 7.66.0 → 7.67.0

package/package/corpus/product-sync.json

@@ -171,9 +171,9 @@
         }
       ],
       "synced": {
-        "version": "4.201.0",
+        "version": "4.204.0",
         "date": "2026-10-16",
-        "by": "Cratis/AI#733"
+        "by": "Cratis/AI#743"
       },
       "covers": {
         "skills": [
@@ -201,7 +201,7 @@
         ],
         "rules": []
       },
-      "notes": "Standalone 4.201.0 and byte-identical compiler contract pinned. Cratis/AI#733: the ui profile root template, shell options, appearance and new screens default (PLAY0788-PLAY0799, quick fix for the legacy layout line, ui-profiles MCP tool, 44 tools). Cratis/AI#735: chronological Date/DateTime ordering in command conditions and command/property literal validation (ESM v26), UTC tick precision and pre-rule offset validation; then matching remains ordinal. Source-checked Screenplay v4.199.0 commands, diagnostics, interoperability and specifications documentation plus decision 0087. Stage v4.127.1 still refuses v26 with STAGE-ESM-016 (stage-rendering.md and SemanticVersionFeatures.Supports); no render/runtime probe. Cratis/AI#576: prior mechanical compiler catch-up. Language batch #717/#722/#723/#724/#720/#728/#734 teaches atomic reaction batches (v22), described payload handlers (v23), portable linear matching, ordinal text rules (v24), protected command reads (v25), diagnostic arguments and event-source invokes mappings. Facts read at Screenplay v4.198.0 and introducing tags; Stage v4.127.0 admits exact v1-v21 and v23-v25 pairs but refuses v22/v26 and mixed pairs (STAGE-ESM-016), protected reads (044), atomic mode (043) and described handlers (STAGE-IMPL-002), even Stub mode. Stage text rules execute/render; no new renderer/runtime probe or Stage pin uplift. Cratis/AI#706: application navigation regions (module inherit, extend or override), toolbar slice buttons, blueprint template references and sample data packs in cratis-screenplay-ui-composition (references/application-shell.md), with the canonical shell vector and the rejection codes PLAY0710-PLAY0722 and PLAY0740-PLAY0765. Examples moved to the executable-state rules since 4.164: translator reactions in an Automation slice beside the Translate slice (PLAY0694) and the first record of a capture key appended with `when added`. Earlier: Standalone 4.164.0 and byte-identical compiler contract pinned. Cratis/AI#663: one origin per capture (PLAY0687). #668: executable no-event/redelivery v17. #684: concept query-argument validation in every version and query-error assertions v18. #681: executable refusal branches and refusal values v19. #666: proposal summary/severity counts and exact structural source proposals. Generated-concept rules select v20 with PLAY0688/0689 proofs and derived-matches repair; generated secrets and preview strategies remain refused. Release-baseline from-esm admission reads storedName. Standalone binding is not renderer admission: Stage 4.103.0 admits v1-v17 and v19; CLI 3.62.0 bundles Screenplay 4.159.0 / Stage 4.99.0 and renders through v16. Prior evidence remains unless superseded; no new renderer, Docker or browser probe."
+      "notes": "Standalone 4.204.0 and byte-identical compiler contract pinned. Cratis/AI#743: flat composite read-model keys (ESM v27): untyped projection key blocks on root from and remove with, equality-filter lists, single-instance by blocks and per-part fixtures, with PLAY0661/PLAY0662/PLAY0268 refusals checked against the 4.204.0 compiler; Stage origin/main still refuses v27 with STAGE-ESM-016 (stage-rendering.md); Stage v4.135.0 v26 admission (Host and executor run date comparisons; renderer STAGE-ESM-046) was source-checked for this sync; no render or runtime probe. Prior: Standalone 4.201.0 and byte-identical compiler contract pinned. Cratis/AI#733: the ui profile root template, shell options, appearance and new screens default (PLAY0788-PLAY0799, quick fix for the legacy layout line, ui-profiles MCP tool, 44 tools). Cratis/AI#735: chronological Date/DateTime ordering in command conditions and command/property literal validation (ESM v26), UTC tick precision and pre-rule offset validation; then matching remains ordinal. Source-checked Screenplay v4.199.0 commands, diagnostics, interoperability and specifications documentation plus decision 0087. Stage v4.127.1 still refuses v26 with STAGE-ESM-016 (stage-rendering.md and SemanticVersionFeatures.Supports); no render/runtime probe. Cratis/AI#576: prior mechanical compiler catch-up. Language batch #717/#722/#723/#724/#720/#728/#734 teaches atomic reaction batches (v22), described payload handlers (v23), portable linear matching, ordinal text rules (v24), protected command reads (v25), diagnostic arguments and event-source invokes mappings. Facts read at Screenplay v4.198.0 and introducing tags; Stage v4.127.0 admits exact v1-v21 and v23-v25 pairs but refuses v22/v26 and mixed pairs (STAGE-ESM-016), protected reads (044), atomic mode (043) and described handlers (STAGE-IMPL-002), even Stub mode. Stage text rules execute/render; no new renderer/runtime probe or Stage pin uplift. Cratis/AI#706: application navigation regions (module inherit, extend or override), toolbar slice buttons, blueprint template references and sample data packs in cratis-screenplay-ui-composition (references/application-shell.md), with the canonical shell vector and the rejection codes PLAY0710-PLAY0722 and PLAY0740-PLAY0765. Examples moved to the executable-state rules since 4.164: translator reactions in an Automation slice beside the Translate slice (PLAY0694) and the first record of a capture key appended with `when added`. Earlier: Standalone 4.164.0 and byte-identical compiler contract pinned. Cratis/AI#663: one origin per capture (PLAY0687). #668: executable no-event/redelivery v17. #684: concept query-argument validation in every version and query-error assertions v18. #681: executable refusal branches and refusal values v19. #666: proposal summary/severity counts and exact structural source proposals. Generated-concept rules select v20 with PLAY0688/0689 proofs and derived-matches repair; generated secrets and preview strategies remain refused. Release-baseline from-esm admission reads storedName. Standalone binding is not renderer admission: Stage 4.103.0 admits v1-v17 and v19; CLI 3.62.0 bundles Screenplay 4.159.0 / Stage 4.99.0 and renders through v16. Prior evidence remains unless superseded; no new renderer, Docker or browser probe."
     },
     {
       "id": "scene",

package/package/corpus/skills/cratis-screenplay-automations-and-translations/references/realization-and-gap-fill.md

@@ -23,7 +23,7 @@ rejected model renderable, and never claim a whole-application V5 from a subset.
 with `cratis-screenplay-render-and-gap-fill`.
 
 Application-root `reaction batches atomic` also blocks Stage delivery: v22
-refuses STAGE-ESM-016; mode in admitted v23–v25 refuses STAGE-ESM-043. Preserve the
+refuses STAGE-ESM-016; mode in admitted v23–v26 refuses STAGE-ESM-043. Preserve the
 per-occurrence/selected-branch batch boundary and independent invoked commands.
 Atomic appends do not prove redelivery deduplication or external exactly-once effects.
 

package/package/corpus/skills/cratis-screenplay-captures-and-reactions/references/atomic-batches-and-source-mappings.md

@@ -36,7 +36,7 @@ batch and unchanged read models with evaluator world/read-model assertions; earl
 accepted work can remain. `then no events` means accepted zero outcomes and cannot
 accompany `then error`. Do not invent a mixed success/error specification form.
 
-Stage refuses ESM v22 with STAGE-ESM-016. Even an admitted v23–v25 model carrying
+Stage refuses ESM v22 with STAGE-ESM-016. Even an admitted v23–v26 model carrying
 atomic mode is refused with STAGE-ESM-043 by renderer, Host and specification executor.
 Keep the declaration and report authorized gap-fill; do not promise a render date or
 strip atomicity to lower the version.

package/package/corpus/skills/cratis-screenplay-command-surface/SKILL.md

@@ -155,8 +155,9 @@ reads/concurrency cannot combine (PLAY0783). The Cratis C# renderer refuses prot
 semantic Host/executor support is separate.
 Uniqueness still uses a constraint; reference success is not target realization.
 
-Do not use `reads` to fetch data the caller could supply. A composite-key view's `by` block is
-`PLAY0268` (read-surface `references/named-keys.md`).
+Do not use `reads` to fetch data the caller could supply. A composite-key view's `by` block in a
+command read is `PLAY0271`, or `PLAY0781` ByParts under `command reads protected`
+(read-surface `references/named-keys.md`).
 
 ## `validate`
 
@@ -182,7 +183,7 @@ Requires Screenplay 4.199.0 (ESM v26; `screenplay --version`) for Date/DateTime
 comparisons; older binders report PLAY0268. Read [date comparisons](references/date-comparisons.md)
 when ordering a retention window with `require to >= from`, comparing instants
 across offsets, or rejecting offset-less inputs before rules. It covers admitted
-positions, PLAY0268/0273, ordinal `then` matching and Stage's v26 refusal.
+positions, PLAY0268/0273, ordinal `then` matching and Stage's STAGE-ESM-046 renderer refusal.
 
 **Rules whose logic is code.** A bare `rule <Name>` has no portable meaning (`PLAY0268`) and a bodied rule binds only as
 opaque code. Read [references/validate-rules.md](references/validate-rules.md) when a rule's logic must live in a `file`

package/package/corpus/skills/cratis-screenplay-command-surface/references/date-comparisons.md

@@ -3,6 +3,11 @@
 
 # Chronological command date comparisons
 
+## Contents
+
+- Retention window and rejection specifications
+- Missing-offset input rejection
+
 Requires Screenplay 4.199.0 (ESM v26; `screenplay --version`); older binders refuse date comparisons with PLAY0268. Upgrade the compiler without weakening the rule.
 
 Use `==`, `!=`, `>`, `>=`, `<` or `<=` with matching primitives: Date/Date or
@@ -27,13 +32,19 @@ Targets must enforce this before deserialization attaches a local offset, and
 preserve tick precision or refuse the comparison; JavaScript `Date` alone truncates
 precision. Client validators omit date ordering rules. Optional absent values still
 pass validation rules other than `not empty`; optional condition operands refuse.
+A .NET host that executes commands itself can reuse the reference evaluator's date semantics (Requires Screenplay 4.203.0): see [date comparison checks](https://github.com/Cratis/Screenplay/blob/main/Documentation/screenplay/date-comparison-checks.md) for `SemanticDateComparisons` and `SemanticConditionEvaluator`.
 
 PLAY0268 still refuses mixed Date/DateTime, `$context` operands (including
 `$context.occurred`), `today`, protected read paths, date rules on concepts and
 reaction `where`. A refused whole comparison reports only PLAY0268, without
 validating its literals. A `given clock` does not admit `today` or now.
-Stage refuses v26 with STAGE-ESM-016; standalone binding/reference execution is
-not rendering. Preserve the rule and route delivery to authorized gap-fill.
+Requires Stage 4.135.0 for v26 admission; older Stage refuses v26 with STAGE-ESM-016.
+The semantic Host and specification executor run the comparisons, including through
+concepts, and reject an offset-less DateTime input after authorization and before any
+rule. The renderer, legacy engines and default sandbox engine refuse them with
+STAGE-ESM-046, naming the property, and emit no artifacts or date validators. Standalone
+binding/reference execution is not rendering: preserve the rule and route delivery to
+authorized gap-fill.
 
 ## Retention window and rejection specifications
 

package/package/corpus/skills/cratis-screenplay-model-authoring/references/language-reference.md

@@ -272,9 +272,9 @@ See read-surface `references/named-keys.md` for the collection-key exclusion alg
 | Described handlers (ESM v23) | Pending implementation beside unconditional produces; payload-only contract, reached body Unsupported ImplementationBody; Stage STAGE-IMPL-002 even Stub mode |
 | Ordinal text rules (ESM v24) | contains/not contains/starts with/ends with on scalar non-enum text properties; quoted literals, not conditions; Stage semantic engines execute/render |
 | Protected command reads (ESM v25) | Root `command reads protected`; eligible read paths in requirements and production mappings, absence Validation, concurrent matching facts Conflict; Stage admits v25; Cratis C# rendering refuses STAGE-ESM-044, semantic Host/executor execute admitted reads with non-Error protected requirements refused STAGE-ESM-045 |
-| Chronological command dates (ESM v26) | Same-primitive Date/DateTime `==`, `!=`, `>`, `>=`, `<`, `<=` in require/produces-when (property or literal RHS) and command/property rules (literal RHS only). DateTime uses UTC ticks, participating offset-less inputs reject Validation before rules; then matching stays ordinal. Requires Screenplay 4.199.0 (`screenplay --version`); older binders refuse PLAY0268. Stage refuses v26 STAGE-ESM-016. Read command-surface `references/date-comparisons.md`. |
+| Chronological command dates (ESM v26) | Same-primitive Date/DateTime `==`, `!=`, `>`, `>=`, `<`, `<=` in require/produces-when (property or literal RHS) and command/property rules (literal RHS only). DateTime uses UTC ticks, participating offset-less inputs reject Validation before rules; then matching stays ordinal. Requires Screenplay 4.199.0 (`screenplay --version`); older binders refuse PLAY0268. The Stage Host and executor run v26 (older Stage refuses STAGE-ESM-016); the renderer and legacy engines refuse STAGE-ESM-046 (toolchain `language-admission.md`). Read command-surface `references/date-comparisons.md`. |
 | Current routing and actor admission | Sources/streams and command/specification routes bind and reference-execute as v8; reaction `runs as system role` supplies the invocation actor as v10. Whole-workspace binding determines executable availability; CLI/Stage realization remains separate |
-| Blocks binding (`PLAY0268`) | enum/identity compliance and events combining personal or explicitly subject-scoped secret values with explicit subject marks; a compiler that stops before v13 refuses all `pii`/`secret` concepts ("compliance attributes require portable data-subject semantics"), while v13 binds them and Stage renders protection; attached command `handler` (PLAY0035 beside productions; pending described intent instead binds v23), bare `rule <Name>`, read paths without protected opt-in or in unsupported positions such as `produces when`, date comparisons with mixed primitives, optional condition operands, `$context`, protected read paths or `today`, date rules on concepts or reaction `where`, `$context.tenant`/claims/roles/causation in `produces`, `$env` conditions, `file` constraints, unquoted `import` of an external contract, a read model with neither explicit `key` nor unambiguous query-based identity as described above (composite keys remain unadmitted), queries with context `from` sources (typed query context is unadmitted), single-result filters (collections only), `scoped to` (opaque scope), `performer` (opaque implementation) or composite `by` blocks; optional keyed and collection queries, including caller-supplied equality filters and observable delivery, bind, `$causedBy` and templates in projections |
+| Blocks binding (`PLAY0268`) | enum/identity compliance and events combining personal or explicitly subject-scoped secret values with explicit subject marks; a compiler that stops before v13 refuses all `pii`/`secret` concepts ("compliance attributes require portable data-subject semantics"), while v13 binds them and Stage renders protection; attached command `handler` (PLAY0035 beside productions; pending described intent instead binds v23), bare `rule <Name>`, read paths without protected opt-in or in unsupported positions such as `produces when`, date comparisons with mixed primitives, optional condition operands, `$context`, protected read paths or `today`, date rules on concepts or reaction `where`, `$context.tenant`/claims/roles/causation in `produces`, `$env` conditions, `file` constraints, unquoted `import` of an external contract, a read model with neither explicit `key` nor unambiguous query-based identity as described above (several key marks bind as v27; older binders refuse PLAY0268; toolchain `language-admission.md`), queries with context `from` sources (typed query context is unadmitted), single-result filters (collections only), `scoped to` (opaque scope), `performer` (opaque implementation) or a `by` block on a list query or non-optional single result; optional keyed and collection queries, including caller-supplied equality filters and observable delivery, bind, `$causedBy` and templates in projections |
 | Blocks binding (`PLAY0271`, legacy meaning) | Command reads without protected opt-in and `concurrency`; combined protected reads/concurrency is PLAY0783 |
 | Deferred (`PLAY0269`, information) | Screens, layouts, templates, forms, contributions, UI profiles, themes, behaviors and `on`/`uses` |
 | Metadata only (`PLAY0270`, information) | `domain`, `seed`, `persona`, trigger and other descriptions, and `file` provenance on declarations |

package/package/corpus/skills/cratis-screenplay-model-review/references/checklist.md

@@ -180,7 +180,7 @@ Nebulit (`provenance.md`).
 | Id | Check | Evidence | Tier |
 |---|---|---|---|
 | H1 | Query shape follows the business view (list where people scan; lookup where they open one) | queries, screens | D |
-| H2 | Executable scope: a keyed `=> RM optional` query with `by` named like a read-model property, or a collection (`=> RM[]`, observable too) with caller-supplied `by` and/or equality filters. `from`, single-result filters, opaque `scoped to`/`performer` and composite `by` remain PLAY0268. The projection routes by the same identity (a `from` key or an event property, or `$eventSourceId`; `$eventSourceId` is not mandated). Filtered models: supported v14 equality filters render within the CLI bundle's ESM ceiling. Renderable scope only: Stage-specific identity/filter limits; keyed optional snapshot lookups and snapshot/observable collections render (Requires Stage 4.90.0 for snapshot lists; older renderers report `STAGE-ESM-010`). Check query concept-validation parity separately; primitive-argument targets answer absence instead of Validation | queries, projections | C (executable); C (render admission, renderable only) |
+| H2 | Executable scope: a keyed `=> RM optional` query with `by` named like a read-model property, or a collection (`=> RM[]`, observable too) with caller-supplied `by` and/or equality filters. `from`, single-result filters, opaque `scoped to`/`performer` and a list-query `by` block remain PLAY0268. A read model with several key parts binds as v27 (Requires Screenplay 4.204.0). The projection routes by the same identity (a `from` key or an event property, or `$eventSourceId`; `$eventSourceId` is not mandated). Filtered models: supported v14 equality filters render within the CLI bundle's ESM ceiling. Renderable scope only: Stage-specific identity/filter limits; keyed optional snapshot lookups and snapshot/observable collections render (Requires Stage 4.90.0 for snapshot lists; older renderers report `STAGE-ESM-010`). Check query concept-validation parity separately; primitive-argument targets answer absence instead of Validation | queries, projections | C (executable); C (render admission, renderable only) |
 | H3 | One builder per read model; projection `key` only on `from` | projections | C |
 | H4 | Screens show one actor's point of view; a form submits one command | screens, forms | D |
 

package/package/corpus/skills/cratis-screenplay-model-review/references/public-keys-and-routes.md

@@ -16,8 +16,10 @@ Add these to the element sweep, with evidence pinned to the declaration:
 - Is the view identity explicitly marked `key` or unambiguously inferred? Does each
   single-instance query/read supply every part exactly once, with compatible types,
   and do state fixtures contain all parts? Do PDL keys align with the view's key?
-  Composite view keys still refuse binding (PLAY0268); compilation
-  is not executable evidence. Read read-surface `references/named-keys.md`.
+  Flat composite view keys bind as ESM v27 (older binders refuse with PLAY0268;
+  compiler requirement in read-surface `references/named-keys.md`); compilation alone is not executable evidence. Does
+  each projection `from` and `remove with` name every part in an untyped `key` block?
+  Read read-surface `references/named-keys.md`.
 - Does a production override replace the whole source/stream/id route, rather than
   assume partial inheritance? Is its `for` destination still explicit and compatible?
   Are skipped production routes valid, so eager resolution cannot fail unexpectedly?

package/package/corpus/skills/cratis-screenplay-projections/SKILL.md

@@ -100,6 +100,7 @@ the executable model routes any event by it, and it is not a default for the
 | From-level block | indented `key invoiceId` inside the `from` |
 | Per event, several events | `from A key idA, B key idB, C` |
 | Composite | `key OrderKey` with indented `<property> = <expr>` parts |
+| Flat composite parts | untyped `key` block naming every key part (Requires 4.204.0; ESM v27) |
 | Literal (constant) | `key literal "site-stats"` — every event updates the **same** instance |
 | Children identity | `children lines identified by lineNumber` |
 | **Default** | **the event source id** — `from X` ≡ `from X key $eventSourceId` |
@@ -120,6 +121,10 @@ subscribe to it exactly like a standalone event. Verified extraction preserves
 canonical ESM and identities, so it changes no projection contract. Removing a
 payload property is different and requires consumer/persistence review.
 
+A read model with several flat `key` parts needs that block in every root `from` and
+`remove with` (`PLAY0661`/`PLAY0662`); other blocks and reducers there are `PLAY0268`
+(`references/pdl-grammar.md`).
+
 A second key on one `from` is error `PLAY0060`. A template expression in a
 composite key is error `PLAY0073`; an empty composite key is `PLAY0074`.
 

package/package/corpus/skills/cratis-screenplay-projections/references/pdl-grammar.md

@@ -6,6 +6,7 @@
 - Parser regexes
 - Diagnostics
 - Syntax that parses but means something else
+- Flat composite read-model keys
 - Worked examples
 
 Checked against `Documentation/screenplay/projections/{grammar,semantic-model,keys,variants}.md`
@@ -69,11 +70,11 @@ NestedBlock     = "nested", Ident, NL,
 ClearWithBlock  = "clear", "with", TypeRef, NL ;
 
 RemoveWithBlock = "remove", "with", TypeRef, [ "key", Expr ], NL,
-                  [ INDENT, [ ParentDecl ], DEDENT ] ;
+                  [ INDENT, [ CompositeKeyDecl ], [ ParentDecl ], DEDENT ] ;
 RemoveWithJoinBlock = "remove", "via", "join", "on", TypeRef, [ "key", Expr ], NL ;
 
 KeyDecl         = "key", Expr, NL ;
-CompositeKeyDecl= "key", TypeRef, [ "{" ], NL,
+CompositeKeyDecl= "key", [ TypeRef ], [ "{" ], NL,
                   INDENT, KeyPart, { NL, KeyPart }, DEDENT, [ "}", NL ] ;
 KeyPart         = Ident, "=", Expr ;
 
@@ -172,6 +173,45 @@ LiteralKeyword  = "literal", " ", Literal ;   (* parsed at the Expr level *)
 | `all` beside removals, `children` or `nested` | Binds, but the reference execution plan refuses it |
 | `join`, `children` or `remove via join` inside `nested` | Not wired by Chronicle's engine; binds, but the reference execution plan refuses it |
 
+## Flat composite read-model keys
+
+Requires Screenplay 4.204.0 (ESM v27; `screenplay --version`); older binders refuse a
+read model with two or more `key` marks with PLAY0268.
+
+A read model with several flat `key` properties takes an **untyped** `key` block (no
+type name) in each root `from` and `remove with`, naming every key part once as
+`<property> = <expr>`. It differs from the typed composite key above, which fills one
+single property of composite type.
+
+```screenplay excerpt
+projection PaymentTotals => PaymentTotals
+  no automap
+  from PaymentReceived
+    key
+      invoiceId = invoice
+      method = method
+    total = amount
+  remove with PaymentRemoved
+    key
+      invoiceId = invoice
+      method = method
+```
+
+The block applies to every event the `from` names. Part order does not matter; creating
+an instance writes each part to its property even with `no automap`, and a mapping that
+contradicts a part fails the projection. `remove with` deletes only the instance whose
+parts all match, and a later `from` recreates it.
+
+| Written | Code |
+| --- | --- |
+| `from` or `remove with` with no key, `key <expr>`, an inline `from A key x`, or `parent` | PLAY0661 |
+| A part missing from the block | PLAY0661 |
+| An unknown, repeated or ill-typed part, a non-simple expression, or a typed key block on a composite-keyed read model | PLAY0662 |
+| `join`, `children`, `remove via join`, `every`, `all`, `nested`, `clear with`, `variant`, or a reducer on the read model | PLAY0268 |
+
+The complete executable example, with queries and specifications, is in read-surface
+`references/named-keys.md`.
+
 ## Worked examples
 
 Each example is an excerpt: the events and read models it names are declared

package/package/corpus/skills/cratis-screenplay-read-surface/SKILL.md

@@ -54,11 +54,13 @@ identity (all such queries must agree). Only with no single-instance identifier
 and an admitted list query does the binder infer an unambiguous `*Id`; queryless
 read models need an explicit `key`. See named keys below for collection-key exclusions.
 One explicit key binds byte-identically to equivalent inference. Several marks
-form a composite key, supplied by name in query/read
-`by` blocks. Composite keys and block queries remain
-**authoring-only** (PLAY0268); the scalar optional snapshot shape binds.
-Read [named keys](references/named-keys.md) for complete examples, trigger/command
-reads, all-parts fixtures, PLAY0660–0662 and command-read-only PLAY0661 repair.
+form a flat composite key: an optional single-instance query names every part in a
+`by` block, a list query narrows with equality filters, and fixtures state every part.
+Requires Screenplay 4.204.0 (ESM v27; `screenplay --version`); older binders refuse
+several key marks with PLAY0268. A list query over such a read model cannot use a
+`by` block (PLAY0268).
+Read [named keys](references/named-keys.md) for one complete executable example,
+trigger/command reads, all-parts fixtures, PLAY0660–0662 and command-read-only PLAY0661 repair.
 A `=>` target resolving to an event is an event-target builder, not a read model;
 keep event and read-model names distinct (see projections' public-event targets).
 
@@ -78,7 +80,7 @@ query ListInvoices => InvoiceListReadModel[]
 **Name the compiler and renderer.** Optional keyed queries and collection queries
 bind, including `observable`. Caller-supplied equality
 filters on collections bind as ESM v14; `from`, single-result filters, `scoped to`,
-`performer` and composite `by` remain PLAY0268, each with its reason. Read
+`performer` and a `by` block on a list query (or on a non-optional single result) remain PLAY0268, each with its reason. Read
 [equality filters](references/equality-filters.md) for the admitted shape, a complete
 compiled specification model and the Stage/CLI ceilings. Keep a list the domain needs.
 
@@ -177,7 +179,7 @@ primitive/concept/enum properties, same nominal type ignoring optionality, no
 `from`, distinct names not repeating `by`. `by` and supplied filters AND together;
 optional filters may be omitted, but supplied null is refused. PLAY0268 still
 rejects context sources, single-result filters, opaque scope/performer and
-composite `by`; a single non-optional result remains unadmitted too.
+a `by` block on a list query (or on a non-optional single result).
 Authorization runs before lookup, ANDed with module/feature gates; policies see
 only `by`, never filters. Pin denial with `given caller` and `then denied`.
 Specs pass `by` and filters by name (PLAY0468 for unknown, repeated or missing

package/package/corpus/skills/cratis-screenplay-read-surface/references/equality-filters.md

@@ -40,7 +40,7 @@ Each binding refusal reports PLAY0268 with its query/filter and reason:
 | Filter on a single-result query | Equality filters are admitted only for collections |
 | `scoped to` | The named scope has no portable executable scope contract |
 | `performer` | Query implementation code is opaque, not a portable declarative lookup |
-| Composite `by` block | Multipart lookup admission remains deferred (Screenplay#599) |
+| `by` block on a collection query | A composite lookup is admitted only for an optional single-instance query; narrow a list by composite-keyed read-model parts with equality filters instead |
 | Filter on a collection/composite property, missing property or mismatched nominal type | The v14 filter contract requires a same-named scalar primitive, concept or enum property with the same type |
 
 Keep those intents when the domain needs them; never drop a context source or

package/package/corpus/skills/cratis-screenplay-read-surface/references/named-keys.md

@@ -39,72 +39,188 @@ Chronicle's object keys are not ordered, encoded event stream ids.
 Choose a composite key when independent coordinates identify the business view,
 such as resource and reporting period. Prefer the natural single id when the view
 is one entity's state. Do not concatenate parts into an invented string id merely
-to pass binding; keep the truthful model and report the capability gap. Read-model
-keys do not supply projection routes: align each PDL `from ... key` mapping with
-the declared view identity (projection keys are a separate contract).
+to pass binding; keep the truthful model. Read-model keys do not supply projection
+routes: align each PDL `from ... key` block with the declared parts (several flat
+parts take an untyped `key` block naming every one; a single key of composite type
+is a different shape, and one read model has exactly one of them).
 
 ## Supply every part
 
-A scalar query keeps `by name Type` on its own body line. A composite query has a
-bare `by` header and at least two distinct `name Type [from source]` children.
-Do not combine scalar and block forms. A single-instance lookup must supply every
-key part exactly once, with the declared types; collection queries may narrow by
-a subset but still have their separate executable-query limitations.
+Requires Screenplay 4.204.0 (ESM v27; `screenplay --version`) to bind a read model with
+two or more `key` marks; older binders refuse it with PLAY0268. A model with one `key`
+mark keeps its earlier ESM version and bytes, so only models that use several parts
+select v27.
+
+A scalar query keeps `by name Type` on its own body line. Each lookup shape for a
+composite-keyed read model is separate:
+
+| Shape | Form | Result |
+| --- | --- | --- |
+| Optional single-instance query | bare `by` header, then every key part once as `name Type` | binds; the caller supplies every part |
+| List query | equality `filter name Type [optional]` lines (one filter per narrowed part) | binds; a row matches when every supplied filter is equal |
+| List query, one scalar `by` | `by name Type` on one line | binds as for a single key |
+| List query with a `by` block | bare `by` header over a collection | PLAY0268: use filters |
+| Non-optional single return, or a part with a `from` source | any `by` block | PLAY0268 |
+| Missing part | any single-instance lookup | PLAY0661 |
+| Unknown, optional, collection or ill-typed part; fewer than two parts | `by` block | PLAY0662 |
+
+Do not combine scalar and block `by` forms. A caller-supplied part is never a trusted
+tenant or subject: keep ownership at the runtime boundary.
+
+Each `by` part runs its concept rules at execution, like a single `by` argument. A
+specification argument that violates a rule still binds, so a Validation rejection
+can be specified.
+
+Command and trigger reads use a child `by` block of `part = source`, with required,
+noncollection sources of compatible nominal types, not literals. Neither executes
+over a composite view in the usual way:
+
+- A command `reads … by` without the application-root `command reads protected`
+  preamble is PLAY0271. With the preamble it is PLAY0781 (reason ByParts), PLAY0782
+  first when the command has no `identifier`, and PLAY0273 when the key is not an
+  input property.
+- A trigger `reads … by` binds when the reaction only invokes commands (information
+  PLAY0270); a reaction that produces events directly or runs code is PLAY0268.
 
-A command or reaction trigger read uses a child `by` block of `part = source`.
-Sources are required, noncollection property paths with compatible nominal types,
-not literals. Trigger reads map from the trigger's declared values. The historical
-single `reads View by value` form remains available for a single key.
+Screen `data ... via query ... by value`, forms and navigation remain scalar
+lookups: they cannot supply a composite single-instance key (PLAY0661). Do not
+invent UI tuple syntax.
 
-This complete authoring-only example declares all lookup parts:
+One executable example: a composite-keyed read model, a projection whose root `from`
+and `remove with` name every part in an untyped `key` block, a list query with
+equality filters, an optional single-instance query with a `by` block, and
+specifications that run.
 
 ```screenplay
-concept ResourceId : Uuid
-concept Period : String
-module Reporting
-  feature Months
+concept InvoiceId : String
+  validate
+    min 3 message "Invoice id is too short"
+concept PaymentMethod : Enum
+  card
+  cash
+
+module Billing
+  feature Payments
     slice StateView Totals
-      readmodel ResourceMonth
-        resourceId ResourceId key
-        period Period key
-        hours Decimal
-      query FindMonth => ResourceMonth optional
+      event PaymentReceived
+        invoice InvoiceId
+        method PaymentMethod
+        amount Int
+      event PaymentRemoved
+        invoice InvoiceId
+        method PaymentMethod
+      readmodel PaymentTotals
+        invoiceId InvoiceId key
+        method PaymentMethod key
+        total Int
+      query TotalsForInvoice => PaymentTotals[]
+        filter invoiceId InvoiceId
+        filter method PaymentMethod optional
+      query Total => PaymentTotals optional
         by
-          resourceId ResourceId
-          period Period
-    slice StateChange CloseMonth
-      command CloseMonth
-        resourceId ResourceId identifier
-        period Period
-        reads ResourceMonth as totals
-          by
-            resourceId = resourceId
-            period = period
-        produces event MonthClosed
-          for resourceId
-          period Period = period
+          invoiceId InvoiceId
+          method PaymentMethod
+      projection PaymentTotals => PaymentTotals
+        no automap
+        from PaymentReceived
+          key
+            invoiceId = invoice
+            method = method
+          total = amount
+        remove with PaymentRemoved
+          key
+            invoiceId = invoice
+            method = method
+      specification TwoMethodsOneInvoice
+        given readmodel PaymentTotals
+          invoiceId = "INV-1"
+          method = "card"
+          total = 12
+        given readmodel PaymentTotals
+          invoiceId = "INV-1"
+          method = "cash"
+          total = 8
+        when query Total
+          invoiceId = "INV-1"
+          method = "cash"
+        then result
+          total = 8
+      specification FilterOnePart
+        given readmodel PaymentTotals
+          invoiceId = "INV-1"
+          method = "card"
+          total = 12
+        given readmodel PaymentTotals
+          invoiceId = "INV-2"
+          method = "card"
+          total = 3
+        when query TotalsForInvoice
+          invoiceId = "INV-1"
+        then result
+          invoiceId = "INV-1"
+          method = "card"
+          total = 12
+      specification RemoveOneMethod
+        given readmodel PaymentTotals
+          invoiceId = "INV-1"
+          method = "card"
+          total = 12
+        given readmodel PaymentTotals
+          invoiceId = "INV-1"
+          method = "cash"
+          total = 8
+        when append PaymentRemoved
+          invoice = "INV-1"
+          method = "card"
+        then no readmodel PaymentTotals for {"invoiceId":"INV-1","method":"card"}
+        then readmodel PaymentTotals
+          invoiceId = "INV-1"
+          method = "cash"
+          total = 8
+      specification RecreateRemovedInstance
+        given PaymentReceived
+          invoice = "INV-1"
+          method = "card"
+          amount = 12
+        given PaymentRemoved
+          invoice = "INV-1"
+          method = "card"
+        when append PaymentReceived
+          invoice = "INV-1"
+          method = "card"
+          amount = 20
+        then readmodel PaymentTotals
+          invoiceId = "INV-1"
+          method = "card"
+          total = 20
 ```
 
-Screen `data ... via query ... by value`, forms and navigation remain scalar
-lookups: they cannot supply a composite single-instance key (PLAY0661). Do not
-invent UI tuple syntax. Context-derived query parts do not become caller inputs;
-keep tenant/subject ownership at the runtime boundary, not in editable UI filters.
+Projection rules for the same shape are in the projections skill (`SKILL.md`, keys).
+Verify with `screenplay <folder> --warnaserror` (0 errors, 0 warnings) and
+`screenplay test <folder>` (all passed, none Unsupported).
 
 ## Specifications and executable boundary
 
-`given readmodel` and `then readmodel` state every key part (PLAY0351 if missing).
-A composite absence fixture uses an object with every named part. Query result
-assertions may omit keys when arguments already select the instance.
-
-Composite read-model keys, query `by` blocks and fixtures
-over those views remain authoring-only: binding reports PLAY0268 citing
-Screenplay#599 (still open). They do not reference-execute or render. This is not
-ESM v10 admission; v10 covers reaction identity, production routes and observer
-filters. Eligible command reads separately opt into v25 with `command reads protected`;
-legacy reads remain PLAY0271, and composite keys are still refused (PLAY0781 ByParts).
-See command-surface [protected reads](../../cratis-screenplay-command-surface/references/protected-reads.md).
-A single explicit key does bind; Stage admission still depends on the complete
-model and projection/query shape, not just the key modifier.
+`given readmodel` and `then readmodel` state every key part (PLAY0351 if missing;
+a repeated part is PLAY0519). `then no readmodel` takes an object naming every part
+(missing PLAY0661, unknown PLAY0662, repeated member PLAY0294). Parts match one by
+one, in any order; Uuid parts compare as ordinal text with no case folding. Query
+arguments supply every `by` part (single) or the filters (list); a missing, unknown
+or repeated argument is PLAY0468. A single-instance query result may omit parts the
+arguments supply; list-query result rows state every part. A stated part that
+differs from the argument makes the row fail to match at run time, not at binding.
+
+Projections on a composite-keyed read model admit only root `from` and `remove with`.
+Joins, `children`, `remove via join`, `every`, `all`, `nested`, `clear with`,
+`variant` and reducers are PLAY0268. This is not ESM v10 admission.
+
+Stage does not admit v27: it refuses the whole model with `STAGE-ESM-016`, so
+`cratis render` cannot deliver it. Verify and reference-test the model with the
+standalone compiler, then hand the delivery to gap-fill
+(`cratis-screenplay-render-and-gap-fill`) with the model as the contract.
+Eligible command reads separately opt into v25 with `command reads protected`;
+a composite lookup there is still refused (PLAY0781 ByParts). See command-surface
+[protected reads](../../cratis-screenplay-command-surface/references/protected-reads.md).
 
 ## Repairs and evidence
 
@@ -116,9 +232,3 @@ model and projection/query shape, not just the key modifier.
 - Read-model property rename remains unsupported until its mapping chain can be
   preserved. Use the model-authoring proposal/preview/apply contract, not a text
   shortcut around an identity-preserving refusal.
-
-Source: Screenplay `Documentation/screenplay/{readmodels,queries,commands,reactions,specifications}.md`,
-`fixtures/named-read-model-keys.play`, and
-`Source/DotNET/Screenplay/Semantics/SemanticModelBinder.ReadModels.cs` (identity inference).
-Its authoring delivery does not include
-an executable composite-key contract.

package/package/corpus/skills/cratis-screenplay-read-surface/verification.json

@@ -3,9 +3,9 @@
   "input": "Declare a Screenplay query and the screen that binds to it.",
   "fixtures": [],
   "assertions": [
-    { "kind": "skill-contains", "value": "query FindMonth", "file": "references/named-keys.md" },
+    { "kind": "skill-contains", "value": "query Total => PaymentTotals optional", "file": "references/named-keys.md" },
     { "kind": "skill-contains", "value": "command reads only", "file": "references/named-keys.md" },
-    { "kind": "skill-contains", "value": "remain authoring-only", "file": "references/named-keys.md" },
+    { "kind": "skill-contains", "value": "Requires Screenplay 4.204.0 (ESM v27", "file": "references/named-keys.md" },
     { "kind": "play-compiles" },
     { "kind": "skill-contains", "value": "Caller-supplied equality query filters (ESM v14)", "file": "references/equality-filters.md" },
     { "kind": "skill-contains", "value": "Supplied `null` is refused", "file": "references/equality-filters.md" },

package/package/corpus/skills/cratis-screenplay-render-and-gap-fill/references/gap-fill-handoff.md

@@ -108,7 +108,7 @@ reaction or drop an effect to dodge rendering.
 Preserve declared `reaction batches atomic` boundaries: each trigger occurrence's
 direct productions and each selected refusal branch are separate batches, with
 invoked commands independent. Stage refuses v22 (STAGE-ESM-016) and atomic mode
-in admitted v23–v25 (STAGE-ESM-043); the declaration is not external-effect deduplication.
+in admitted v23–v26 (STAGE-ESM-043); the declaration is not external-effect deduplication.
 For described handlers, hand off only payload computation under the v23 result
 contract; Stage STAGE-IMPL-002 means no stubs, even Stub mode. Protected v25 reads
 refuse Cratis C# rendering with STAGE-ESM-044 despite version admission and need

package/package/corpus/skills/cratis-screenplay-render-and-gap-fill/references/renderability-gate.md

@@ -31,7 +31,7 @@ ESM). Only the probe answers renderability. `PLAY0270` entries are information,
 | Class | Meaning | Typical examples (each verified in `admission.md`) | Action |
 | --- | --- | --- | --- |
 | **Model fix (in mode)** | the model is in, or the user chose, renderable mode and breaks its own subset in a way that has a renderable equivalent with the same meaning | a `produces` whose `for` is not the command identifier; two projections for one read model (`-007`); a policy Stage cannot express portably (`-015`; role-only and opaque pure policies render) | edit request to the modeler session with address, change and rationale |
-| **Capability gap** | the intended meaning needs a construct Stage does not render yet | DateTime equality filters and required parameters after optional filters (`-010`); context/single-result filters, opaque `scoped to`/`performer` and composite `by` remain PLAY0268; Translate, clocks, captures, non-event triggers and opaque reaction bodies (`-024`); claim-reading/opaque `runs as` gates (`-034`), legacy `from` (`-035`), mixed effects in one handler (`-037`, retries can duplicate events; keep it whole), unsupported reaction mappings (`-039`); unsupported generated types/result combinations (`-028`/`-038`); `then no readmodel` (`-027`); evolved events (`STAGE-ESM-026`); unsupported expression/enum production conditions (`-006`; supported conditional productions render); legacy reads (`PLAY0271`), protected-read rendering (STAGE-ESM-044 despite v25 admission; semantic Host/executor support is separate); code validation (`-005`); protected identities/enums (`-040`) or unadmitted explicit subject lineage (`PLAY0268`); attached command handlers (PLAY0268), described handlers (v23, STAGE-IMPL-002 even Stub mode), atomic mode (STAGE-ESM-016 for v22, STAGE-ESM-043 in admitted v23–v25) | keep the model; fallback record entry; options a to c in `SKILL.md`; link the Stage issue |
+| **Capability gap** | the intended meaning needs a construct Stage does not render yet | DateTime equality filters and required parameters after optional filters (`-010`); context/single-result filters, opaque `scoped to`/`performer` and a list-query `by` block remain PLAY0268; a read model with several key parts (v27) refuses `STAGE-ESM-016`; Translate, clocks, captures, non-event triggers and opaque reaction bodies (`-024`); claim-reading/opaque `runs as` gates (`-034`), legacy `from` (`-035`), mixed effects in one handler (`-037`, retries can duplicate events; keep it whole), unsupported reaction mappings (`-039`); unsupported generated types/result combinations (`-028`/`-038`); `then no readmodel` (`-027`); evolved events (`STAGE-ESM-026`); unsupported expression/enum production conditions (`-006`; supported conditional productions render); legacy reads (`PLAY0271`), protected-read rendering (STAGE-ESM-044 despite v25 admission; semantic Host/executor support is separate); code validation (`-005`); protected identities/enums (`-040`) or unadmitted explicit subject lineage (`PLAY0268`); attached command handlers (PLAY0268), described handlers (v23, STAGE-IMPL-002 even Stub mode), atomic mode (STAGE-ESM-016 for v22, STAGE-ESM-043 in admitted v23–v26) | keep the model; fallback record entry; options a to c in `SKILL.md`; link the Stage issue |
 | **Tool skew** | the bundled compiler disagrees with documented semantics | the false `PLAY0285` on reaction cascades from an older bundle; codes the standalone compiler does not raise | record in the session state and the fallback record; never "fix" a correct model |
 | **Environment** | not the model | restore failures, missing SDK, a destination that is not writable | fix the environment or report blocked |
 

package/package/corpus/skills/cratis-screenplay-scenario-coverage/references/scenario-examples.md

@@ -219,6 +219,6 @@ empty-list intent is a separate claim from a keyed row being absent (`view-and-s
 queries are executable too (`ListOpenInvoices` in the backing example); caller-supplied equality filters on collections bind as ESM v14.
 Pass `by` and filters in query arguments; PLAY0468 reports unknown, repeated or
 missing required arguments. Optional filters may be omitted, supplied null is refused.
-Context-sourced/single-result filters, opaque `scoped to`/`performer`, and composite
-`by` remain PLAY0268. Compiled coverage and renderer ceilings:
+Context-sourced/single-result filters, opaque `scoped to`/`performer`, and a list-query
+`by` block remain PLAY0268. Compiled coverage and renderer ceilings:
 read-surface [equality filters](../../cratis-screenplay-read-surface/references/equality-filters.md).