@cratis/pi 7.62.0 → 7.64.0

package/package/corpus/skills/cratis-screenplay-toolchain/references/generation-checks.md

@@ -0,0 +1,93 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Generation checks for tool and renderer authors
+
+Use the language-owned APIs instead of copying option tables, rule evaluators or
+proof logic. These are .NET APIs of Screenplay, not Cratis C# target contracts.
+They never generate a value or execute an attached body.
+
+## Choose the check
+
+| Need | API | Result and boundary |
+| --- | --- | --- |
+| Populate strategy/option controls | `GenerationStrategyCatalog.All`, `Find(string name)` in `Cratis.Screenplay.Semantics` | Exact case-sensitive source spelling; unknown names return null. Descriptors expose ESM kind, source primitives, introducing version, admission/executability, fixed bits and options with placement, kinds, bounds, choices, defaults and conditions. `rule` serializes as `implementation`; reserved `sequence` is not admitted. Metadata alone is not validation. |
+| Check one concept declaration | `SemanticConceptCheck.Check(concept, utcAssessmentYear: 2026)` in `Cratis.Screenplay.Semantics` | Accepts `ConceptSyntax` or `SemanticConcept`; returns `Concept`, `Findings`, `Proofs`, `Support`, `RequiredVersion`. No enclosing application is invented. |
+| Check a concrete value | `SemanticValidationRules.Check(concept, value)` in `Cratis.Screenplay.Semantics` | Rule results in declaration order; also single-rule and application/type/value overloads. Not a declaration check or a general type validator. |
+| Prove every generated-concept rule | `RuleConsistency.Check(concept, utcAssessmentYear: 2026)` in `Cratis.Screenplay.Semantics.Generation` | Results parallel `concept.Validations`: Proven, Refuted with witness, Unproven with reason. Status is not serialized in ESM. |
+
+Requires Screenplay 4.174.0 (`screenplay --version`) for `RuleConsistency.Check`;
+older consumers must not infer proof from missing serialized status.
+Requires Screenplay 4.185.0 for `SemanticValidationRules.Check`; older consumers
+lack the standalone value-check API.
+Requires Screenplay 4.191.0 for `GenerationStrategyCatalog` and
+`SemanticConceptCheck.Check`; older tools must use whole-model binding, not a
+hand-maintained imitation of admission.
+
+## Check a declaration, not a sample
+
+```csharp
+using Cratis.Screenplay.Diagnostics;
+using Cratis.Screenplay.Semantics;
+using Cratis.Screenplay.Syntax;
+
+var concept = new ConceptSyntax("InviteCode", "String", [], [], SourceLocation.Start)
+{
+    Generation = new("nanoid", SourceLocation.Start) { Size = 8, Alphabet = "ab" }
+};
+var check = SemanticConceptCheck.Check(concept, utcAssessmentYear: 2026);
+Console.WriteLine(check.Support!.Count); // 256
+Console.WriteLine(check.Support.MeetsIdentifierMinimum); // False
+```
+
+The assessment year is nullable (null uses the current UTC year); pass it explicitly
+for reproducible date support and witnesses. Valid years are 1–9899; invalid years
+return PLAY0673 without an assessment. Both overloads accept optional
+`assumeGenerated: false`: set true only for an implicit Uuid concept actually used
+by a generated property, never to invent generation for String/Int.
+
+Findings carry compiler code, severity, message and construct `Target`, not source
+coordinates: a generation-wide finding, an option named by `Option`, or a rule
+named by zero-based `RuleIndex`. Syntax indices count authored rules even when
+some fail binding; proofs follow the inspected semantic validation array.
+Unknown targets are not successful checks. A partial `Concept` is not admission.
+
+Keep `Support.Count` as `BigInteger`; `Bits` is display data and
+`MeetsIdentifierMinimum` can be null for unknown support. Unknown entropy is not
+zero or proof of sufficient entropy. `RequiredVersion` describes this concept
+only. PLAY0683/0684 depend on command-property use and uniqueness, so a concept
+check cannot replace whole-application binding. It also proves no authorization,
+implementation linkage, uniqueness or runtime readiness.
+
+## Check values and interpret proofs
+
+`SemanticValidationRules.Check` overloads accept `(SemanticValidationRule,
+SemanticValue)`, `(SemanticConcept, SemanticValue)` or `(SemanticApplication,
+SemanticTypeReference, SemanticValue)`. The last walks supplied composite and
+collection values. Pass contract-validated inputs; incompatible rule/value kinds
+throw `InvalidSemanticContract` rather than becoming ordinary failed rules.
+
+A `SemanticRuleCheck` carries `Status`, `Rule`, `Message`, optional `Concept` and
+`Pattern`. Status is Satisfied, Failed or NotEvaluable: never treat NotEvaluable
+as a pass. Absent values satisfy evaluable rules except NotEmpty; opaque rules
+remain NotEvaluable. Text compares ordinally, length counts UTF-16 code units,
+and numbers compare as exact decimals. Severity does not waive a failed rule.
+The API allocates nothing and executes no opaque predicate.
+
+All-Proven rules permit unpinned generation only on targets that support it.
+Unproven/Refuted rules need deterministic pins; refuted source contracts must
+first be repaired. Passing samples do not prove containment. Stage supports the
+all-Proven case from 4.115.0; Screenplay's reference runner and Stage's independent
+specification executor still require every reached generated value to be pinned.
+A strategy-shape fixture check is separate from checksum arithmetic: author
+`validate checksum` to enforce arithmetic on pins too.
+
+## References and verification
+
+Read the product references for complete overload/result contracts:
+[concept checks](https://github.com/Cratis/Screenplay/blob/main/Documentation/screenplay/concept-checks.md),
+[value-rule checks](https://github.com/Cratis/Screenplay/blob/main/Documentation/screenplay/value-rule-checks.md),
+and [strategy catalog and proofs](https://github.com/Cratis/Screenplay/blob/main/Documentation/screenplay/generated-values/strategies.md).
+Build a tool against the required Screenplay library; the example's observable
+result is count 256 and identifier minimum False. Then bind and verify the whole
+model: a declaration check is not an executable-model verdict.

package/package/corpus/skills/cratis-screenplay-toolchain/references/generation-strategies-example.md

@@ -1,42 +1,124 @@
-# Generation strategies example (ESM v15)
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
 
-A deterministic UUIDv7 identifier and NanoID receipt, with an accepted response
-and a reused-source rejection. Fixtures, not random seeds, make this executable.
-Contract: the Screenplay documentation pages `generated-values.md` and `generated-values/strategies.md`.
+# Shop generation strategies example (ESM v21)
+
+## Contents
+
+- Choosing a strategy
+- Pinned creation and freshness
+- Attached generation rule
+- When not to
+- Verify
+
+## Choosing a strategy
+
+Requires Screenplay 4.172.0 or later (`screenplay --version`) for pattern/random
+and checksum validation; older compilers refuse PLAY0268.
+Requires Stage 4.118.0 for checksum validation and 4.119.0 for pattern/random
+rendering; older renderers refuse them with STAGE-ESM-042/-028. The attached rule
+below still refuses STAGE-ESM-028. The reference runner uses whole-value fixtures,
+never random seeds.
+
+OrderId stays the high-entropy source identity. InvoiceNumber is a readable
+reference, not a gapless/sequential invoice allocator or secret; its check digit
+catches typos, not forgery. The Int pickup ticket is a value, not an identifier.
+Unique constraints protect short payload codes, while serialized generation
+activates freshness for the whole generated source. Dates/check digits add no
+entropy. The clock fixes every UTC pattern segment, not the random digits.
+
+## Pinned creation and freshness
 
 ```screenplay
-concept InvoiceId : Uuid
-  generate uuidv7
-concept Receipt : String
-  generate nanoid
-module Billing
-  feature Drafts
-    slice StateChange Start
-      command StartDraft
-        invoiceId InvoiceId generated identifier
-        receipt Receipt generated
-        produces event DraftStarted
-          receipt Receipt = receipt
-        returns invoiceId
-      specification StartsWithPinnedValues
-        when StartDraft
-          for "00112233-4455-7677-8899-aabbccddeeff"
-          generated receipt = "abcdefghijklmnopqrstu"
-        then DraftStarted
-          for "00112233-4455-7677-8899-aabbccddeeff"
-          receipt = "abcdefghijklmnopqrstu"
-        then returns "00112233-4455-7677-8899-aabbccddeeff"
+concept OrderId : String
+  generate typeid "order"
+concept InvoiceNumber : String
+  generate pattern "INV-{yyyy}{MM}-#{7}" checksum luhn
+  validate checksum luhn
+concept TicketNumber : Int
+  generate random 100000..999999
+module Shop
+  feature Orders
+    slice StateChange Place
+      constraint UniqueInvoiceNumber
+        unique invoiceNumber on OrderPlaced
+      constraint UniquePickupTicket
+        unique pickupTicket on OrderPlaced
+      command PlaceOrder
+        orderId OrderId generated identifier
+        invoiceNumber InvoiceNumber generated
+        pickupTicket TicketNumber generated
+        produces event OrderPlaced
+          invoiceNumber InvoiceNumber = invoiceNumber
+          pickupTicket TicketNumber = pickupTicket
+        returns orderId
+      specification PlacesWithPinnedValues
+        given clock "2026-10-02T09:00:00Z"
+        when PlaceOrder
+          for "order_0000000000e008000000000000"
+          generated invoiceNumber = "INV-202610-00000004"
+          generated pickupTicket = 123456
+        then OrderPlaced
+          for "order_0000000000e008000000000000"
+          invoiceNumber = "INV-202610-00000004"
+          pickupTicket = 123456
+        then returns "order_0000000000e008000000000000"
       specification RejectsAUsedGeneratedSource
-        given DraftStarted
-          for "00112233-4455-7677-8899-aabbccddeeff"
-          receipt = "abcdefghijklmnopqrstu"
-        when StartDraft
-          for "00112233-4455-7677-8899-aabbccddeeff"
-          generated receipt = "abcdefghijklmnopqrstu"
+        given clock "2026-10-02T09:00:00Z"
+        given OrderPlaced
+          for "order_0000000000e008000000000000"
+          invoiceNumber = "INV-202610-00000004"
+          pickupTicket = 123456
+        when PlaceOrder
+          for "order_0000000000e008000000000000"
+          generated invoiceNumber = "INV-202610-00000004"
+          generated pickupTicket = 123456
         then error "A generated event source already has facts; retry the command with a fresh generated value."
 ```
 
-The rejection appends no new facts and returns no response. v15 guards the whole
-source even if the old fact uses another stream or event type. Removing every
-serialized generation strategy restores the earlier Unguarded contract, not an
-alternative way to make a stale-source specification pass.
+The rejection appends no new facts and returns no response. Freshness guards the
+whole source even if its old facts use another stream or event type. Without a
+serialized strategy the model is Unguarded, even if generated-concept rules
+select v20; removing strategies is not a way to repair stale-source behavior.
+Pin failure against shape or authored rules is a server Contract rejection,
+never a client validation failure or a reason to redraw. Without `validate
+checksum`, a fixture checks suffix shape only, not arithmetic. Without `given
+clock`, date segments check digit widths only, never today's date.
+
+## Attached generation rule
+
+An implementation-specific tenant-bearing reference can instead attach one
+generation rule; its entropy is unknown, not zero. The body gets only Now and
+Tenant. The reference evaluator consumes a String fixture without running code:
+
+````screenplay
+concept TenantOrderReference : String
+  generate rule TenantOrder
+    ```csharp
+    return $"{context.Tenant}:order_{context.Now:yyyyMMdd}-{Guid.NewGuid():N}";
+    ```
+module Shop
+  feature Orders
+    slice StateChange ReserveReference
+      command ReserveReference
+        reference TenantOrderReference generated
+        returns reference
+      specification UsesThePinnedReference
+        when ReserveReference
+          generated reference = "shop-eu:order_example"
+        then returns "shop-eu:order_example"
+````
+
+## When not to
+
+Keep client-minted values as inputs. Generation is neither idempotency nor
+authorization. Use an allocator for gapless numbering, and preserve secret
+classification rather than trying to bind generated credentials. A short code's
+uniqueness constraint protects its payload claim, not source freshness or retry
+safety after an unknown append outcome.
+
+## Verify
+
+Compile with `screenplay <file> --warnaserror`; then `screenplay test <file>` must report
+all selected specifications passed, none failed or unsupported. Passing reference
+specifications do not prove target support or that attached generation code runs.

package/package/corpus/skills/cratis-screenplay-toolchain/references/language-admission.md

@@ -0,0 +1,61 @@
+<!-- Copyright (c) Cratis. All rights reserved. -->
+<!-- Licensed under the MIT license. See LICENSE file in the project root for full license information. -->
+
+# Language admission: batches, described bodies, text, reads and dates
+
+Select the highest version required by constructs in the model. A newer version
+alone never opts into either application mode. Consumers must explicitly admit
+exact language/semantic pairs; binding, reference execution and rendering are separate.
+
+| ESM | Selecting construct | Binding/reference behavior | Stage boundary |
+| --- | --- | --- | --- |
+| v22 | Application-root `reaction batches atomic` | Direct productions per trigger occurrence and each selected refusal branch are separate atomic batches; commands remain independent | v22 refused STAGE-ESM-016; mode in admitted v23–v25 refused STAGE-ESM-043 |
+| v23 | Pending `handler implementation` beside unconditional `produces` | Payload-only body; PLAY0695 information; reaching body gives Unsupported ImplementationBody | v23 admitted, body refused STAGE-IMPL-002 in renderer/Host/executor, even Stub mode |
+| v24 | `contains`, `not contains`, `starts with`, `ends with` property/concept rules | Ordinal UTF-16, absent optional passes; not text-condition operators | v24 admitted; semantic Host/executor and generated ordinal comparisons preserve rules |
+| v25 | Application-root `command reads protected` | Admitted reads in requirements/mappings, absence Validation, matching decide/commit changes Conflict | v25 admitted; protected reads refused STAGE-ESM-044 in renderer/Host/executor |
+| v26 | Chronological command Date/DateTime comparisons | Same-primitive `==`, `!=`, `>`, `>=`, `<`, `<=`; DateTime UTC ticks and pre-rule offset validation | v26 refused STAGE-ESM-016 |
+
+Requires Screenplay 4.181.0 or later (`screenplay --version`) for atomic batches; older compilers cannot admit the preamble.
+
+Requires Screenplay 4.182.0 or later (`screenplay --version`) for described handlers; older binders report PLAY0268.
+
+Requires Screenplay 4.184.0 or later (`screenplay --version`) for literal text rules; older binders do not admit those rules.
+
+Requires Screenplay 4.193.0 or later (`screenplay --version`) for protected reads; older binders retain PLAY0271/PLAY0268.
+
+Requires Screenplay 4.199.0 (ESM v26; `screenplay --version`) for date comparisons; older binders report PLAY0268.
+
+Requires Stage 4.124.0 for v24 text-rule admission (`cratis --version` identifies the CLI bundle); older renderers refuse v24 with STAGE-ESM-016. V23 admission alone does not implement described bodies.
+
+Requires Stage 4.127.0 for v25 version admission; older renderers refuse v25 with STAGE-ESM-016. Protected reads still refuse STAGE-ESM-044, including on legacy paths; no artifacts are emitted.
+
+Read [atomic batches and event-source invocation mappings](../../cratis-screenplay-captures-and-reactions/references/atomic-batches-and-source-mappings.md)
+for atomic boundaries and the source-identity mapping prerequisite. Start new models
+with atomic mode; explicitly review opt-in for legacy models. Keep protection when
+Stage refuses: do not remove the declaration or promise a target release date.
+
+Read [described handlers](../../cratis-screenplay-command-surface/references/described-handlers.md)
+for the payload result contract and [protected reads](../../cratis-screenplay-command-surface/references/protected-reads.md)
+for finite event-source-keyed view admission, single-level paths and repair guards.
+Text comparisons and matching are in [text and match rules](../../cratis-screenplay-command-surface/references/text-and-match-rules.md).
+`matches` uses the portable linear dialect without selecting a new ESM version;
+PLAY0699 refuses nonportable constructs, PLAY0367 invalid syntax, PLAY0787 warns
+on exact Studio text-rule patterns and offers a literal-rule repair.
+
+For v26, `require`/`produces when` compare a required scalar command property to
+a required same-primitive property or literal. Command/property validation rules
+compare only to literals. Date is a calendar date; DateTime is a UTC instant at
+seven-fractional-digit tick precision. Participating DateTime inputs without an
+offset or `Z` reject with Validation before any rule, even if a comparison is skipped.
+`then` matching, keys, constraints and freshness remain ordinal. PLAY0268 retains
+mixed Date/DateTime, optional condition operands, `$context` (including occurred),
+`today`, protected read paths, concept date rules and reaction `where`. In admitted
+positions, invalid date literals or offset-less DateTime literals use PLAY0273.
+Read [date comparisons](../../cratis-screenplay-command-surface/references/date-comparisons.md)
+for the complete interval example and input/target boundaries.
+
+Stage's semantic engines admit exact v1–v21 and v23–v25 pairs. V22/v26 and mixed
+pairs refuse STAGE-ESM-016. Admission of v23–v25 is not admission of described bodies,
+atomic mode or protected reads. A CLI may bundle an older compiler/Stage pair: run no-write render
+admission rather than transferring a standalone verdict. Pattern diagnostics arise
+in Screenplay before rendering; diagnostic arguments add no ESM version or new tool.

package/package/corpus/skills/cratis-screenplay-toolchain/references/preferred-syntax.md

@@ -5,7 +5,7 @@
 
 Use these forms when writing or reviewing `.play`. Acceptance of an older
 spelling is not a recommendation to teach it. Information diagnostics do not
-fail `--warnaserror`; the corpus verification gate rejects the nine style codes
+fail `--warnaserror`; the corpus verification gate rejects the eleven style codes
 below even when a fence declares `expect`, unless an exact, reasoned migration
 exception exists in the verifier's preferred-syntax allowlist. That allowlist also
 covers deliberate legacy explanations in prose; stale entries fail.
@@ -23,6 +23,8 @@ covers deliberate legacy explanations in prose; stale entries fail.
 | Imports | Import only declarations not already declared by the application | Importing the application's own names | PLAY0290 (warning) |
 | Interaction guard | Block-form `when` alternatives | Opaque interaction `where` on click, double click or select | PLAY0564 (warning or information) |
 | Projection transition cardinality | Source binding emits `One` | Constructed/deserialized ESM v1–v3 `ZeroOrOne` / `Many` | PLAY0445 (warning; ESM-only, not a source spelling) |
+| Command decision reads | `command reads protected` after reviewing every read's admission, absence and conflict semantics | Eligible legacy command reads without the application-root preamble | PLAY0786 (information; individual typed repair review, never fix-all) |
+| Literal text rules | `starts with`, `ends with`, `contains`, `not contains` or equality, preserving message and severity | Exact deprecated Studio `matches` shapes | PLAY0787 (warning; not arbitrary regex rewriting) |
 
 `query Q => observable?` is not a legacy optional type suffix and has no keyword
 replacement. Reaction/Translate `where` is current syntax, not an interaction

package/package/corpus/skills/cratis-screenplay-toolchain/references/renderable-subset.md

@@ -21,24 +21,36 @@ and concept compliance (v13) render.
 
 ## Current admission
 
-Stage admits exact ESM v1–v17 and v19 pairs, not v18 or v20; v19 does not imply v18
-admission. The CLI's bundled Stage can be older: read installed versions and the
-pins in `product-sync.json`, not the standalone compiler's version. Each construct
-it does not render refuses with its own code before any artifact is planned.
+Stage admits exact ESM v1–v21 and v23–v25 pairs; v22/v26 and mixed pairs
+refuse STAGE-ESM-016. Chronological command Date/DateTime comparisons select v26:
+standalone binding/reference execution does not make them renderable. Keep the
+rule and use authorized gap-fill. Version admission is separate from construct support.
+Requires Stage 4.106.0 for v18 admission; older Stage refuses it with `STAGE-ESM-016`.
+For generated-concept v20/v21 admission and construct prerequisites, read
+[Stage admission](../../cratis-stage-rendering-and-sandbox/references/admission.md).
+The CLI's bundled Stage can be older: read installed versions and the pins in
+`product-sync.json`, not the standalone compiler's version. Each construct it
+does not render refuses with its own code before any artifact is planned.
 
 Requires Stage 4.96.0 for stored event names (v16), 4.101.0 for no-event assertions (v17), 4.102.0 for refusal branches (v19), and 4.103.0 for rendered redelivery; older renderers refuse the respective shapes.
 Requires Cratis CLI 3.60.0 (`cratis --version`) for v16 rendering; a bundle that stops at v16 refuses newer models with CLI-RENDER-004.
 
+With an admitting renderer, all-Proven generated-concept rules allow unpinned
+rendered specs; warning/info rules and semantic checksum validation are enforced,
+and pattern/random strategies render. `generate rule` remains STAGE-ESM-028.
+The independent executor still needs deterministic pins. Dated patterns use
+receipt-time UTC; random ranges use `long` with inclusive endpoints.
+
 This table is a reading of the renderer's admission, not a render result: run the bundled renderer before asserting renderability.
 
 | Area | Renders | Refused (code) |
 | --- | --- | --- |
 | Slice kinds | `StateChange`, `StateView`, supported event-triggered `Automation` with Chronicle reactors | Translate, captures, non-event triggers, opaque bodies, clock/trigger/capture specs (`-024`); claim-reading/opaque `runs as` gates (`-034`), mixed effects from one handler (`-037`, redelivery can duplicate events), unsupported conditions/destinations/mappings (`-039`). Keep refused reactions whole |
-| Queries | optional keyed snapshot lookups; snapshot or observable collections, keyed or unkeyed, with v14 equality filters | context/single-result filters, opaque `scoped to`/`performer` and composite `by`: PLAY0268. DateTime filters and required parameters after optional filters refuse `-010`; filter-name collisions refuse `-012`; validated scalar keys render as primitives and convert inside the query (an out-of-rule key finds no instance), nested validated keys still refuse `-010` |
+| Queries | optional keyed snapshot lookups; snapshot or observable collections, keyed or unkeyed, with v14 equality filters | context/single-result filters, opaque `scoped to`/`performer` and composite `by`: PLAY0268. DateTime filters and required parameters after optional filters refuse `-010`; filter-name collisions refuse `-012`; concept arguments retain Arc validation, including nested members/elements; nullable keys or optional concept filters with `not empty` refuse `-010` rather than changing null behavior |
 | Authorization | role-only, authenticated, opaque pure policies, claim conditions with Uuid, Date, DateTime or text targets (numeric and Boolean claim matches render as always false), `not`/and/or; roles read through the identity's `RoleClaimType` | role-claim URIs, nested opaque policies, unresolved or non-portable policies, no single identifier, opaque-policy subjects that are not text, Uuid, Date or DateTime (`STAGE-ESM-015`, a restriction separate from declarative claim targets) |
 | Event sources, streams, routes (ESM v8) | rendered, including routed read-model/query companion replay | reserved stored names, unformattable routed fixtures (`STAGE-ESM-030`) |
 | Numbers, case tables | whole numbers as `long` from ESM v8; case tables | out-of-`int` literals below v8 (`STAGE-ESM-031`) |
-| Generated values and responses (v7/v15) | required scalar UUID/String strategies, Guarded v15 freshness, scalar/named responses, generation fixtures and `then returns` | unsupported generated types (`-028`); routed/generated-rule/legacy-allocation/name-collision or unsupported response combinations, unpinned unordered/projected expectations (`-038`); no blanket `-029` refusal |
+| Generated values and responses (v7/v15/v20/v21) | required scalar UUID/String strategies and Int random, pattern/checksum, concept validators at all severities, all-Proven unpinned relational specs, Guarded v15 freshness, scalar/named responses and fixtures | `generate rule`, unknown strategies and unsupported generated types (`-028`); unsupported response combinations, generated-property validation, name collisions, unpinned Unproven/Refuted rules or unordered/projected/collision-sensitive expectations (`-038`); invalid pins (`-011`); opaque concept rules (`-005`); unknown rule kinds and legacy checksum (`-042`) |
 | Enum numbers / compliance | explicit enum numbers (v12); concept `[PII]` or scoped `[Encrypted]` + `[NotAudited]` (v13), property-level `[NotAudited]` for protected command inputs | protected identities/enums (`-040`); explicit subject lineage remains unadmitted |
 | Specifications | command scenarios and supported single-hop reaction appends; Stage's `admission.md` | appends outside the single-hop subset and commands cascading into reactions (`-011`); `then no readmodel` (`-027`); an unauthenticated caller carrying roles or claims (`-011`); command `given clock` renders only whole milliseconds at or after 1970 |
 | v9 and v10 | reaction/reducer `from` filters; role/authenticated `runs as` | public events and event-target projections (`-032`); foreign origins and event-source captures (`-033`); directed Translate (`-024`); claim-reading/opaque `runs as` gates (`-034`); legacy `from` (`-035`); per-production route overrides (`-036`) |
@@ -48,8 +60,12 @@ This table is a reading of the renderer's admission, not a render result: run th
 | Evolved events | initial revisions only (migrations are not rendered) | `STAGE-ESM-026` |
 | Descriptions, documentation | XML `<summary>`/`<remarks>` doc comments only | characters invalid in XML: `CLI-RENDER-005`; never behavior |
 
-The CLI's bundled compiler still refuses `reads` and `concurrency` (PLAY0271) and command
-`handler`s (PLAY0268) at binding, before Stage admission. Supported filters and strategies render.
+Stage refuses protected command reads with STAGE-ESM-044, described handlers
+with STAGE-IMPL-002 (even Stub mode), and atomic mode in admitted pairs with
+STAGE-ESM-043. Literal
+text rules execute/render ordinal UTF-16 comparisons. Read [language admission](language-admission.md).
+A CLI's older bundled compiler may fail first: legacy reads/concurrency PLAY0271,
+attached handlers PLAY0268. Protected reads bind standalone v25, not a Stage render.
 Response-name authoring scopes are not rendered and Scene runtime does not supply them.
 
 Compliance mapping in the generated C#: personal data to `[PII]`, operational secrets to
@@ -76,8 +92,9 @@ ids into routing to fit a renderer (PLAY0515).
   older renderers refuse snapshot lists with STAGE-ESM-010.
   context/single-result filters, opaque `scoped to` and `performer` block binding. Keep a list the domain needs and report
   the capability gap; marking it `observable` or keying it is a modeling decision for the user.
-- A `handler` (with or without `implementation` or `hint`) never binds; the slice is
-  gap-fill, never "customized into" rendering.
+- Attached handlers remain PLAY0268. Pending handlers beside unconditional
+  productions bind v23 but Stage refuses their bodies (STAGE-IMPL-002), even Stub mode;
+  deliver as authorized gap-fill, never as implemented generated stubs.
 - Descriptions and documentation render only as XML doc comments, never as
   behavior: a rule that exists only in prose is unenforced in rendered code.