Working draft · not stableSpecifications include planned features, not blanket implementation or proof claims.
SPEC-R001 · 0.1.0-draft.5

Canonical Cairn text, rendered directly. Historical status statements below are preserved; consult current implementation scope and the status ledger separately. A shorter reading guide is on the guide.

On this page

Bounded resource adapter contract

Purpose

This accepted specification records Noble draft contracts, not completed implementation. Original requirement IDs, explanatory prose, examples, and open decisions remain authoritative. Scenario clauses declare designs; the conformance ledger records execution and evidence.

Requirements

Document: SPEC-R001
Revision: 0.1.0-draft.5
Depends on: SPEC-0001 and SPEC-S001 at 0.1.0-draft.5
Status: Bounded synchronous M5 and selected native-async M6 implementations accepted; broader resource contracts remain open

Scope

Requirement: RA-SCOPE-01

r[RA-SCOPE-01]

RA-SCOPE-01.

Implementations of Component-Sync-Bootstrap MUST support synchronous WIT imports/exports and owned resources. Borrow support is limited to adapter-local borrows for imported calls. This is not full Component-Draft conformance.

The subset excludes borrowed exports, borrowed values in guest storage, and suspension during a borrowed call. It adds no source borrow type or general lifetime-polymorphic program.

The delivered M5 slice uses the pinned noble-test:sync/[email protected] world. Owners are move-only and noncapturable; imported borrows use adapter-local tokens, not guest values or serializable authority. Normal success and domain errors return the borrowed owner once. Owned transfer instead commits only after preflight and does not implicitly return ownership on a domain error.

The M5 runtime gate exercises the production resource table and an independent Rust/Wasmtime 40.0.2 component peer. Its bounded local cancellation and unexpected-suspension control revokes guest access, retains the native pin through actual guest GC, and handles completion, duplicate callbacks and repeated retirement without resurrection or a second release. This control is not native async execution. The peer independently links and converts component values but reuses Noble's resource/authority decision libraries for host policy.

The strict resource proof lane relates the extracted Rust transition and checked table-decision functions to their logical transitions, with separate owner-return, busy-owner, cancellation-pin and late-completion properties. The extraction audit binds those seven theorem roots to actual Rust definitions; broader authority and component body/dependency coverage is not refinement. Native release, authenticated host facts and callbacks, and engine/ABI correctness remain external assumptions. Fresh complete extraction/check receipts, not these descriptions or a diagnostic proof audit, determine milestone acceptance.

In addition to the existing M5 bootstrap world, the selected noble-test:bounded-region/[email protected] world provides only an imported region.read(s64,s64)->result<list<u8>,string> resource method and explicit regions.release(own<region>), with an exported read-region(own<region>,s64,s64)->result<list<u8>,string>. The host invoker alone selects up to 4096 immutable region bytes and creates its owner with context and read right before guest invocation. Distinct simultaneously live host Stores MUST use different TableId and Context identities even if slot and generation coincide; the host allocates identities monotonically without wraparound and fails closed on exhaustion. The borrowed method MUST restore that same owner on both normal result branches and the guest MUST release it once; abnormal exit remains a host cleanup obligation. This does not grant guest allocation, mutation, arbitrary address reads or implicit capability conversion from byte lists.

Scenario: RA-CASE-04 for RA-SCOPE-01

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-04
  • WHEN the static procedure for case RA-CASE-04 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-04

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: S-CASE-02 versioned resource call

  • GIVEN a host-selected 00 01 02 region registered for one component invocation and an actual compiled Noble guest whose method borrow is adapter-local
  • WHEN the guest enters read-region with the canonical offset and length and separately with valid in-bounds controls
  • THEN the canonical request is refused before protected access, valid reads return only bytes in the selected region, and ownership returns from borrow and is released or host-retired exactly once

Requirement: RA-SCOPE-02

r[RA-SCOPE-02]

RA-SCOPE-02. The compiler MUST reject unsupported borrow or async patterns before component emission. A boundary that unexpectedly suspends or reenters a busy owner must fail closed under the cleanup protocol.

Scenario: RA-CASE-02 for RA-SCOPE-02

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-02
  • WHEN the static procedure for case RA-CASE-02 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-02

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: RA-CASE-09 for RA-SCOPE-02

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-09
  • WHEN the adapter procedure for case RA-CASE-09 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-09

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Typed import adapter

Consider an imported WIT resource method:

package noble-test:[email protected];
interface counters {
  resource counter {
    read: func() -> result<s64, string>;
  }
}

Its receiver is borrowed at the component boundary. The generated Noble adapter exposes a move-threaded owner:

counter.read : S Counter
               -- S Counter Result<I64,Text> ! {CounterReadOpId}

CounterReadOpId names the exact versioned operation. Counter identifies the selected resource contract and owning instance context.

Requirement: RA-TYPE-01

r[RA-TYPE-01]

RA-TYPE-01. The adapter MUST remove the owner from the active guest stack during the call. On either normal result alternative, it returns that same owner exactly once. It does not create another owning handle.

For multiple borrowed parameters, the adapter returns their owners in original parameter order before the declared results. Owned WIT parameters follow their separate transfer contract and are not implicitly returned.

Scenario: RA-CASE-01 for RA-TYPE-01

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-01
  • WHEN the adapter procedure for case RA-CASE-01 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-01

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Requirement: RA-TYPE-02

r[RA-TYPE-02]

RA-TYPE-02. The borrow token exists only inside the adapter. It MUST NOT satisfy Data or Capture, enter guest aggregates or recipes, cross another unapproved boundary, or survive its call scope.

An imported interface can mention a borrowed parameter without exposing that borrow token in Noble source. This is an explicit generated adapter, not a silent change to WIT ownership.

Scenario: RA-CASE-02 for RA-TYPE-02

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-02
  • WHEN the static procedure for case RA-CASE-02 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-02

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

State and authority

The host tracks kind, owner context, generation, rights, call scope, and outstanding native access. A scalar index is never sufficient authority.

StateMeaning
LiveValid owner available to its guest context
Busy(scope)Owner held by the adapter; one approved borrow scope is active
Retiring(scope)Guest access revoked; native work still has an accounted pin
RetiredNo guest access and no outstanding native access

Requirement: RA-STATE-01

r[RA-STATE-01]

RA-STATE-01.

A Live to Busy transition MUST validate kind, context, generation, and rights before protected work. It consumes guest availability atomically with scope registration. In the selected bounded-region adapter the host MUST also validate signed nonnegative and overflow-free offset/length against the retained byte extent and output quota before taking that borrow/native pin. The host MUST retain the resource through begin, validate native access, read only the checked range and complete it before the guest's explicit release; invalid arithmetic or claims MUST leave the protected read count at zero.

The separate S-CASE-06 filesystem adapter retains its logical Directory owner over one preopened regular File in the host (no guest borrow, WIT Directory representation or OS directory preopen). It MUST validate that host table's owner identity, invocation context, kind, generation and liveness, and independent host-granted READ with Table::validate, plus the exact preopened-file key main.rs, before a protected file-content read. This retained Table right is the selected authorization boundary; it does not claim use of the service-specific Authority::authorize_from_trusted_host one-shot Plan/facts. A denied authorization, invalid owner or unmapped key has no protected read or native pin. For an approved read, the host begins its protected table scope, keeps the owner/file alive and returns at most 4096 bytes; it MAY read at most one extra bounded sentinel byte to reject an oversized file without returning those bytes. The host completes the scope and accounts for the operation before retiring the owner; neither a live owner nor a valid key is sufficient authority without READ.

Scenario: RA-CASE-01 for RA-STATE-01

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-01
  • WHEN the adapter procedure for case RA-CASE-01 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-01

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: S-CASE-06 refused and granted file reads

  • GIVEN the canonical live host-owned Directory with no READ grant and one vetted regular file at exact guest key main.rs, plus a separate READ-granted invocation
  • WHEN the same compiled guest requests fs.read through the production host
  • THEN the canonical invocation denies before protected content access, whereas the independently granted one returns only that preopened file's at-most-4096 bytes and retires its owner

Requirement: RA-STATE-02

r[RA-STATE-02]

RA-STATE-02. A busy owner MUST reject release, transfer, new borrows, and reentrant operations from guest entry points. Sequential invariants do not justify access during a callback.

Scenario: RA-CASE-03 for RA-STATE-02

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-03
  • WHEN the adapter procedure for case RA-CASE-03 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-03

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Requirement: RA-STATE-03

r[RA-STATE-03]

RA-STATE-03. A normal completion can return Busy to Live only for the matching live scope and generation. Duplicate, late, or wrong-context callbacks MUST NOT return an owner or revive retired state.

Scenario: RA-CASE-01 for RA-STATE-03

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-01
  • WHEN the adapter procedure for case RA-CASE-01 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-01

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: RA-CASE-06 for RA-STATE-03

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-06
  • WHEN the adapter procedure for case RA-CASE-06 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-06

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Completion and failure

EventRequired transition
Validation fails before call admissionNo protected work; no ownership transfer
Normal success or domain Result errorEnd borrow, release pin, return owner exactly once
Trap, cancellation, or unexpected suspensionRevoke guest access and begin retirement
Native completion after retirement requestRelease the final pin without returning guest ownership
Repeated retirement or late callbackNo second release and no resurrection

Requirement: RA-CLEAN-01

r[RA-CLEAN-01]

RA-CLEAN-01.

Abnormal cleanup MUST not depend on guest continuation. The host retires all invocation-owned obligations under the execution profile. It does not return a guessed pre-call session stack. For S-CASE-06 the host, not the guest, retains the live Directory throughout the invocation. Normal denied/successful result, domain error and guest trap MUST each settle that owner's custody or retain explicitly accounted cleanup debt until safe release; repeated cleanup, late callback and invalid claims MUST NOT release twice, revive a retired owner or gain a protected file read.

Scenario: RA-CASE-05 for RA-CLEAN-01

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-05
  • WHEN the adapter procedure for case RA-CASE-05 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-05

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: RA-CASE-08 for RA-CLEAN-01

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-08
  • WHEN the adapter procedure for case RA-CASE-08 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-08

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: RA-CASE-09 for RA-CLEAN-01

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-09
  • WHEN the adapter procedure for case RA-CASE-09 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-09

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: Host Directory settlement on refusal and completion

  • GIVEN an invocation-owned host Directory with no READ and a separately granted invocation of the same compiled guest
  • WHEN a denied result, successful bounded read or abnormal guest exit completes
  • THEN each owner's retirement is accounted exactly once and no later duplicate or stale event regains read authority

Requirement: RA-CLEAN-02

r[RA-CLEAN-02]

RA-CLEAN-02. Cancellation MUST revoke guest access immediately. Native storage MUST remain pinned until no callback or native operation can access it. Unstoppable work remains owned and charged as Retiring, not falsely reported as fully cleaned up.

Scenario: RA-CASE-05 for RA-CLEAN-02

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-05
  • WHEN the adapter procedure for case RA-CASE-05 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-05

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: RA-CASE-06 for RA-CLEAN-02

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-06
  • WHEN the adapter procedure for case RA-CASE-06 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-06

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: RA-CASE-09 for RA-CLEAN-02

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-09
  • WHEN the adapter procedure for case RA-CASE-09 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-09

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Requirement: RA-CLEAN-03

r[RA-CLEAN-03]

RA-CLEAN-03.

Retirement and callback handling MUST be idempotent with respect to local release. The invariant includes hidden adapter state and native pins, not only the guest stack. For selected S-CASE-08, an invalid callback-returned claim MUST NOT discard the separately retained live pending authentic owner, and repeated cleanup, callback failure or abnormal exit MUST NOT create a second release, resurrect the rejected claim or leave a hidden pin. The noble-callback-owner/v1 report MUST account exactly one released pending owner, zero live owners/native pins, and fixture_releases:0 in authentic mode or fixture_releases:1 in each hostile mode. The hostile fixture release is the stale setup retirement or one wrong-kind/foreign-context live-owner cleanup; neither is a second release of the pending authentic owner. Each mode MUST allocate only its necessary fixture.

Scenario: RA-CASE-06 for RA-CLEAN-03

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-06
  • WHEN the adapter procedure for case RA-CASE-06 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-06

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: Failed callback construction settles the retained owner

  • GIVEN one pre-registered pending authentic owner in every mode, with no fixture for authentic, a prior retired generation for stale, or one live wrong-kind/foreign-context fixture
  • WHEN a hostile returned claim refuses before resource construction, an authentic guest consumes its validated owner, or cleanup is repeated after either terminal outcome
  • THEN the invocation reports one and only one pending-owner release, zero authentic or one hostile fixture release, no residual live owner or native pin, and no rejected claim becomes a guest-owned value

Requirement: RA-OWN-01

r[RA-OWN-01]

RA-OWN-01.

Before committing an owned WIT transfer, the adapter MUST finish argument validation and establish a cleanup owner for each obligation. A failed preflight leaves ownership with the caller.

After commit, the sender cannot use the transferred handle. A domain error does not reverse the transfer unless the declared result explicitly returns ownership. The receiver or host retains cleanup responsibility after a trap.

This contract describes local handle ownership. It does not prove physical exclusivity of an external object or exactly-once remote cleanup.

For selected S-CASE-08 noble-test:callback-owner/[email protected], the tokens.issue() -> own<token> callback result is an incoming host-produced owner claim, not an already trusted guest value. Only after complete recipe byte-match, Host::new MUST pre-register one pending authentic owner and at most one mode-selected fixture: none for authentic, a retired prior generation for stale, or one live wrong-kind or foreign-context owner. The issue callback selects a retained claim without creating a new owner. The production host MUST retain custody of the pending actual Table::Owner and validate the selected claim's table namespace, slot, generation, expected token kind, current invocation context, liveness and applicable rights before constructing Wasmtime ResourceAny and publishing exactly one Val::Resource as a guest WIT-owned value. Only a matching live claim permits that publication. The host retains its Table::Owner custody and deterministic cleanup accounting; this selected callback path does not invoke Table::transfer or claim to move the kernel owner into Wasmtime. A stale-generation, wrong-kind or foreign-context result MUST publish no guest owner while host custody of the pending owner remains for exactly-once retirement; matching numeric slot/generation in a distinct table/context is insufficient. The authentic guest tokens.consume(own<token>) request MUST consume the published WIT owner representation only once, account its one protected operation and let the host release the retained table owner once; an invalid result MUST perform no protected operation or create a native pin.

Scenario: RA-CASE-07 for RA-OWN-01

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-07
  • WHEN the adapter procedure for case RA-CASE-07 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-07

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: RA-CASE-08 for RA-OWN-01

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-08
  • WHEN the adapter procedure for case RA-CASE-08 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-08

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: Callback owner obligation before and after validated publication

  • GIVEN a matched component with one pending authentic host-table owner and at most one mode-selective real fixture pre-registered before guest entry
  • WHEN the host preflights the returned claim before Wasmtime owned-resource creation and the authentic guest subsequently calls tokens.consume
  • THEN only the authentic result publishes one trusted WIT-owned guest value and reaches the second guest request, while the host retains its table owner until consume; invalid results leave the host responsible for retiring that pending owner once and settling the selected fixture separately without publishing a trusted value

Requirement: RA-OWN-02

r[RA-OWN-02]

RA-OWN-02. Memory reclamation MUST remain separate from resource retirement. GC reachability MUST NOT make a resource capturable or remove its release obligation. Guest operations MUST NOT convert a live owner into freely duplicable unmanaged authority.

A WIT borrow does not imply a Rust shared-reference contract or an immutable external object. No new guest Unmanaged, disown, or adopt regime is selected. Ordinary user-defined names do not bypass these semantic restrictions.

Scenario: RA-CASE-05 for RA-OWN-02

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-05
  • WHEN the adapter procedure for case RA-CASE-05 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-05

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Requirement: RA-CLEAN-04

r[RA-CLEAN-04]

RA-CLEAN-04. Any later scoped cleanup convenience MUST specify cleanup order, declared effects, and all ownership outcomes. It MUST preserve host retirement on abnormal exit and accounting for outstanding native pins. Shielding cancellation MUST NOT imply eventual host completion.

Test design remains open for this requirement. No scenario or execution evidence is supplied.

Async extension gate

The selected Component-Async-Bootstrap implementation uses the noble-test:async-boundary/[email protected] world and Wasmtime 40.0.2 native async support, with the toolchain, ABI and driver selections recorded in M6 pins. This bounded selection extends, rather than relaxes, the resource-lowering obligation in WI-RES-04. It does not enable suspension in Component-Sync-Bootstrap or imply full Component-Draft support.

Requirement: RA-ASYNC-01

r[RA-ASYNC-01]

RA-ASYNC-01. The synchronous subset MUST reject an async call that retains a borrow. Full async support requires an explicit task/owner transfer contract, cancellation points, completion rules, and backpressure limits. The selected Component-Async-Bootstrap profile MUST also reject borrow-retaining async calls before component emission; native suspension does not extend an adapter-local borrow's lifetime.

Every async extension MUST satisfy the retirement and pinning invariants here and define its live stream<T> and future<T> operations. Native async ABI availability alone does not supply those semantics. The selected bounded implementation supplies task admission, completion, delivery, cancellation and retirement under RA-ASYNC-02 through RA-ASYNC-05, including live future<s64>, future<result<s64,string>> and stream<u8> values. Those live values remain move-only and ineligible for Data, Capture, generic duplication, generic discard or serialization. Explicit future cancellation and stream read-end closure have distinct contracts: closing a stream reader does not by itself cancel the invocation or establish the producer's terminal outcome.

Scenario: RA-CASE-04 for RA-ASYNC-01

  • GIVEN the Component-Sync-Bootstrap profile and every field of input in RA-CASE-04
  • WHEN the static procedure for case RA-CASE-04 runs against those inputs
  • THEN the observations match every field of expected in case RA-CASE-04

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: Suspension does not extend an imported borrow

  • GIVEN an async call that retains an adapter-local WIT borrow in the selected Component-Async-Bootstrap profile
  • WHEN the compiler checks the boundary before component emission
  • THEN it rejects that call without extending the borrow lifetime, transferring the owner or starting protected work

Scenario: Explicit live-value disposal keeps distinct terminal obligations

  • GIVEN an admitted live future or stream with an outstanding native producer
  • WHEN the caller explicitly cancels the future or closes the stream read end
  • THEN future cancellation revokes that task's guest access, while stream reader closure alone neither cancels the invocation nor supplies a terminal producer outcome, and native obligations remain accounted until settlement

Requirement: RA-ASYNC-02

r[RA-ASYNC-02]

RA-ASYNC-02. Before async admission, the adapter MUST validate arguments, authority, ownership, and available task/buffer quotas. A failed preflight leaves owners with the caller and starts no protected work. Successful admission MUST atomically assign every transferred obligation to a task before the caller loses access.

A task in Pending owns the inputs and outstanding native pins. A task in Ready owns its terminal result and every resource in that result. Only explicit result delivery transfers those result obligations to the receiver. Task creation does not copy, serialize, or grant additional authority over the inputs.

The selected admission boundary MUST preflight task, terminal-result, payload, parked-payload, native-pin, wakeup, retirement-work and native-job capacity, and reserve the required bounded payload backing before consuming authorization or transferring caller custody. The production Table::prepare checks capacity and generation while holding exclusive access to the table; it does not itself consume an owner, reserve retained capacity, advance the generation or start native work. Abandoning preparation leaves the table unchanged. Admission::commit records the reservation and task custody after the independent preflights.

Protected admission additionally follows H-AUTH-01 through H-AUTH-04. One-shot witness consumption and attempt registration, resource transfer, and task admission MUST remain distinct obligations at the same serialized boundary, before protected native work starts. Task admission is not authorization. After commit, a transfer or execution-start failure MUST retain task custody for retirement, not reconstruct caller ownership or restore a consumed witness.

The retained table's opaque Task token is move-only; successful result delivery or cancellation consumes it, and rejection returns the supplied token unchanged. Dropping that token does not retire its task. Descriptive kernel Handle, Callback, NativeId, snapshot and decision values are not independently authenticated capabilities, native-access permits, authorization witnesses or receipts. The embedding MUST authenticate provenance, retain actual payload storage and serialize these local decisions with its authority and resource tables.

Scenario: WORKER-01 for RA-ASYNC-02

  • GIVEN the Worker-Design profile and every field of input in WORKER-01
  • WHEN the runtime procedure for case WORKER-01 runs against those inputs
  • THEN the observations match every field of expected in case WORKER-01

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: WORKER-08 for RA-ASYNC-02

  • GIVEN the Worker-Design profile and every field of input in WORKER-08
  • WHEN the adapter procedure for case WORKER-08 runs against those inputs
  • THEN the observations match every field of expected in case WORKER-08

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: Admission refusal preserves caller custody and authorization

  • GIVEN a valid caller owner and unconsumed one-shot witness, with one required admission capacity unavailable
  • WHEN task, storage and authority preflights run before the serialized admission commit
  • THEN the call starts no protected operation, consumes neither caller custody nor the witness, and leaves retained task capacity and generation unchanged

Scenario: Post-commit failure is retirement rather than rollback

  • GIVEN successful independent preflights and a committed task reservation, witness consumption and task-owned input
  • WHEN a later resource-transfer or execution-start step fails at that boundary
  • THEN the host retains the input for task retirement, preserves the consumed witness state and does not reconstruct caller ownership or authorize a retry

Requirement: RA-ASYNC-03

r[RA-ASYNC-03]

RA-ASYNC-03. The host MUST serialize local completion, result delivery, cancellation, and retirement decisions for each task generation. The selected protocol MUST account for all five states and all fifteen event constructors under DX-PROTOCOL-03:

EventPendingReadyDeliveredRetiringRetired
InspectInspectInspectInspectInspectInspect
CompleteSuccessCompleteDuplicateDuplicateComplete for retirementDuplicate
CompleteDomainErrorCompleteDuplicateDuplicateComplete for retirementDuplicate
DeliverReject PendingDeliverReject DeliveredReject RetiringReject Retired
CancelRetire CancelledRetire CancelledDuplicateDuplicateDuplicate
TrapRetire TrapRetire TrapDuplicateDuplicateDuplicate
DeadlineRetire DeadlineRetire DeadlineDuplicateDuplicateDuplicate
BudgetRetire BudgetRetire BudgetDuplicateDuplicateDuplicate
InternalFailureRetire InternalRetire InternalDuplicateDuplicateDuplicate
NativeStoppedObserve stopObserve stopObserve stopObserve stopDuplicate
SettlePinsSettle pinsSettle pinsSettle pinsSettle pinsReject Retired
CleanupReject PendingClean eligible obligationsClean eligible obligationsClean eligible obligationsReject Retired
WakeQueue/coalesce/budgetQueue/coalesce/budgetReject DeliveredReject RetiringReject Retired
TakeWakeTake queued wakeTake queued wakeReject DeliveredReject RetiringReject Retired
FinishReject PendingReject ReadyFinalize DeliveredFinalize RetiredDuplicate

These are all 75 constructor pairs, not a wildcard fallback or permission to omit payload guards. Inspect is read-only. Duplicate leaves the record unchanged and carries no second acquisition, delivery, cleanup or release. A rejected pair MUST preserve retained ownership and publish no result. Allowed cells remain subject to the checked identities and completion data below, the settlement guards in RA-ASYNC-04, and the wakeup limits in RA-ASYNC-05.

Before classification, the implementation MUST validate the retained record and match table namespace, slot, owner context and generation. Native completion, stop, pin-settlement and wake events MUST also match the independent native-operation identity. The host MUST NOT reuse a table namespace while an old callback can exist; exhausted generations fail rather than wrap. A stale, foreign-context or wrong-native event MUST NOT change the current generation or release its pins. The embedding still owns any obligation associated with the original event.

Each first accepted completion MUST account for every admitted input through disjoint returned, consumed and retired sets whose union is exactly the admitted input set. Newly produced result owners are accounted separately and MUST fit the reserved result-owner set. Success and domain error have the same obligation. A fitting normal completion changes Pending to Ready, not to Delivered; both returned inputs and newly produced result owners remain task-owned. Invalid disposition leaves the task unchanged. Oversized bytes follow RA-ASYNC-05 rather than being admitted.

A first accepted late completion in Retiring remains there: returned inputs and produced results enter host retirement, while explicit consumption can discharge the corresponding input-retirement obligation. It MUST NOT deliver owners or replace the primary failure. Once completion is closed, another matching completion is a duplicate, not another disposition or pin release. Delivery alone changes Ready to Delivered and transfers result obligations once; host-owned pin and cleanup debt can remain afterward. Repeated cancellation during retirement leaves the existing status and cleanup intact.

Scenario: WORKER-01 for RA-ASYNC-03

  • GIVEN the Worker-Design profile and every field of input in WORKER-01
  • WHEN the runtime procedure for case WORKER-01 runs against those inputs
  • THEN the observations match every field of expected in case WORKER-01

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: WORKER-08 for RA-ASYNC-03

  • GIVEN the Worker-Design profile and every field of input in WORKER-08
  • WHEN the adapter procedure for case WORKER-08 runs against those inputs
  • THEN the observations match every field of expected in case WORKER-08

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: Invalid events preserve the current generation

  • GIVEN the retained production task table and its five-state, fifteen-event schema
  • WHEN an invalid state/event pair or a callback with a foreign table, context, generation or native-operation identity is submitted
  • THEN the declared rejection preserves the current task's ownership and pins, publishes no result and leaves any original-event obligation with its embedding owner

Scenario: A ready result is owned before it is delivered

  • GIVEN a pending task with admitted inputs and separately reserved result-owner capacity
  • WHEN a matching success or domain-error completion supplies a disjoint complete input disposition and fitting result metadata
  • THEN the task becomes Ready with returned inputs and produced results still in task custody, native stop remains unestablished, and a duplicate completion neither reacquires owners nor releases a pin

Requirement: RA-ASYNC-04

r[RA-ASYNC-04]

RA-ASYNC-04. If cancellation commits before delivery, the task MUST NOT later deliver a successful result or restore an input owner. Cancellation of a Ready task MUST retire resource-bearing results that the receiver never obtained. If delivery commits first, later cancellation through the consumed task handle MUST NOT revoke the delivered owners implicitly.

A cancellation acknowledgement means guest access was revoked. It does not mean native work stopped, cleanup finished, or an external action failed. Pending external outcomes remain unknown until the host observes a terminal outcome. Retry requires a separate operation contract. Local transition order does not establish distributed exactly-once behavior.

Cancellation, trap, deadline, budget exhaustion and internal failure MUST retain their primary outcome through late completion and cleanup. An authenticated late operation-success or operation-failure receipt may describe that operation under H-RECEIPT-01, but MUST NOT promote a cancelled or failed invocation to success, deliver its abandoned owners, restore a consumed witness or grant retry rights. Local task outcomes and identity checks do not establish receipt provenance; observation and receipt validation remain separate host obligations.

Native completion, native stop, pin settlement, cleanup acknowledgement and final reservation release MUST remain separate decisions. Completion alone releases no pin. NativeStopped records the host's observation that native access ended; it does not itself settle pins or release reservations. SettlePins requires that observation and a nonempty subset of the remaining pin identities. Cleanup requires native stop, zero outstanding pins and a nonempty subset of eligible outstanding obligations; it acknowledges cleanup already performed by the shell. A Ready task's returned inputs, produced results and result buffer MUST NOT be cleaned up as undelivered waste while they are still available for delivery. Cancellation first places them under retirement.

Finish MUST refuse while native work, pins or any task-owned input, result or buffer obligation remains. Only a settled Delivered or Retiring task can release its admission reservation: the former remains Delivered, and the latter becomes Retired. Repeated finalization releases nothing again. Slot reuse is permitted only after finalization, with a new checked generation. Pure retirement or an accounting delta is not a native destructor call or proof of physical release; the embedding MUST retain storage and charges until actual access and cleanup obligations end.

The selected native peer serializes task, resource and authority decisions under its host lock, isolates an invocation in its Wasmtime Store, and retains host state and native jobs independently of that Store. Abnormal invocation exit revokes guest access before Store destruction; native pins survive destruction until actual native accesses end and settlement is acknowledged. Wasmtime 40.0.2 supplies no per-task cancellation API for this selection. Dropping a Store, a task token or guest GC reachability MUST NOT be treated as native-stop evidence. Authentic callbacks, serialization, native execution and physical cleanup remain trusted embedding obligations.

Scenario: WORKER-01 for RA-ASYNC-04

  • GIVEN the Worker-Design profile and every field of input in WORKER-01
  • WHEN the runtime procedure for case WORKER-01 runs against those inputs
  • THEN the observations match every field of expected in case WORKER-01

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: WORKER-08 for RA-ASYNC-04

  • GIVEN the Worker-Design profile and every field of input in WORKER-08
  • WHEN the adapter procedure for case WORKER-08 runs against those inputs
  • THEN the observations match every field of expected in case WORKER-08

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: OCTET-04 for RA-ASYNC-04

  • GIVEN the Octet-Adoption-Design profile and every field of input in OCTET-04
  • WHEN the adapter procedure for case OCTET-04 runs against those inputs
  • THEN the observations match every field of expected in case OCTET-04

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: Cancellation and delivery preserve their committed order

  • GIVEN a Ready task whose terminal result contains an owner
  • WHEN cancellation commits before delivery, or delivery commits before cancellation
  • THEN the first order retires the undelivered owner without subsequent guest delivery, while the second transfers it once to the receiver without implicit revocation by late task cancellation

Scenario: Late operation evidence does not revive an invocation

  • GIVEN a cancelled or failed invocation with a consumed one-shot witness and a still-pinned native operation
  • WHEN the host admits an authenticated late operation-success observation and constructs its operation receipt
  • THEN the operation outcome may be reported without restoring invocation success, abandoned owners, the witness or retry rights, and the primary invocation failure remains unchanged

Scenario: Native debt survives guest teardown

  • GIVEN a retiring task with outstanding native access after invocation Store destruction
  • WHEN cleanup or finalization is attempted before native stop and pin settlement, then retried after actual native access and named cleanup obligations end
  • THEN the early attempt releases no reservation, while the settled task can become Retired and release its reservation once without relying on guest continuation or treating a pure decision as physical cleanup

Requirement: RA-ASYNC-05

r[RA-ASYNC-05]

RA-ASYNC-05. The async profile MUST define task-handle disposition, await/result/error interfaces, cancellation observation, and cleanup ownership before implementation acceptance. It MUST enforce limits for tasks, buffered results, outstanding pins, and retirement work. A full queue MUST return an explicit bounded failure without a hidden ownership transfer. Admission MUST reserve capacity for a terminal outcome and bound buffered result storage. An oversized result MUST trigger retirement with a budget failure rather than an unaccounted allocation. Wakeup and callback paths MUST preserve the same state/generation checks.

The selected peer's ordinary task-table limits are eight tasks, eight terminal-result reservations, 4,096 aggregate reserved payload bytes, eight parked payloads, eight native pins, 64 wakeup credits, 128 retirement-work units and 128 admitted generations. An ordinary request reserves one native pin and four wakeups. Every admitted task reserves a terminal outcome even when its result has no bytes. Retirement-work reservation accounts for declared input and result owners, each nonempty input/result/parked buffer, and terminal cleanup. The complete admission reservation remains charged through Ready, Delivered and Retiring until Finish; logical cancellation or early native stop does not make that capacity reusable.

For each selected live future or stream, admission reserves 128 result bytes and 256 parked bytes, split into 128 local and 128 external native-worker/channel payload bytes. The driver limits live values to eight and retained native jobs to 32. The stream producer uses a one-byte engine buffer; the consumer has a 64-byte bounded payload, with terminal success/domain error observed separately from read-end closure. These are payload-storage reservations, not whole-process heap accounting: engine allocation, task metadata and bounded worker thread stacks are not thereby charged as payload. The selected Wasmtime linear-memory limit is 4,194,304 bytes, and driver event observation is bounded to 256 entries.

The host MUST check completion metadata before retaining result bytes. A result exceeding its byte reservation is not admitted; its bounded owner obligations enter retirement and its rejected bytes remain the shell's rejection obligation. A pre-existing cancellation or failure remains primary. Wakeups have at most one queued notification per task: repeated wake events coalesce, a newly queued wake consumes one reserved credit, and TakeWake without a queued notification rejects. Exhaustion retires the task with Budget without starting new native work.

The selected driver uses a single-thread cooperative engine with 100,000 guest fuel and a 1,000-fuel yield quantum, fuel exhaustion and epoch interruption enabled, and explicitly awaits task exit before successful export observation. Blocking native work runs on bounded external workers, not on that cooperative thread. Separate progress controls use their declared probe budgets to exercise continuously runnable fuel exhaustion, host-driven epoch interruption and a driver deadline while native work remains pinned. An epoch deadline depends on host epoch advancement, not on an autonomous wall clock. These mechanisms and measured probes do not promise a universal interruption latency, scheduler fairness, eventual native completion or eventual cleanup. Wider scheduler and interruption contracts remain open; this selection is not a second concurrency model or full worker service.

Scenario: WORKER-08 for RA-ASYNC-05

  • GIVEN the Worker-Design profile and every field of input in WORKER-08
  • WHEN the adapter procedure for case WORKER-08 runs against those inputs
  • THEN the observations match every field of expected in case WORKER-08

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: WORKER-09 for RA-ASYNC-05

  • GIVEN the Worker-Design profile and every field of input in WORKER-09
  • WHEN the runtime procedure for case WORKER-09 runs against those inputs
  • THEN the observations match every field of expected in case WORKER-09

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: Bounded result storage cannot escape retirement accounting

  • GIVEN an admitted task with a fixed result-byte reservation and reserved terminal and retirement capacity
  • WHEN its first accepted completion reports an oversized payload
  • THEN the excess bytes are not retained, bounded result owners enter retirement with a budget failure unless an earlier failure is already primary, and admission capacity stays charged until final settlement

Scenario: Wakeups coalesce without unbounded callback work

  • GIVEN a live task with one queued wake and a finite remaining wakeup reservation
  • WHEN duplicate wakes arrive, the queued wake is taken, and subsequent newly queued wakes exhaust the reservation
  • THEN duplicates do not consume extra credits, taking an absent wake rejects, and exhaustion retires the task with Budget without new native work or ownership resurrection

Scenario: Guest interruption is distinct from native completion

  • GIVEN the cooperative native driver, bounded external blocking work and the declared fuel, epoch or deadline progress-control budget
  • WHEN runnable guest work exhausts fuel or receives a host-driven epoch interrupt, or an invocation deadline expires while native work remains active
  • THEN guest access is revoked independently of native completion, retained pins remain charged until actual stop and settlement, and measured progress is not promoted to a wall-clock, fairness or eventual-cleanup guarantee

Requirement: EPROTO-OBS-01

r[EPROTO-OBS-01]

EPROTO-OBS-01.

Before any RegionProtocol-v1 runtime observation counts as protocol evidence, the bounded-region host report MUST be a new schema version that keeps the existing noble-bounded-region/v1 receipts unchanged.

The new report MUST:

  • separately count guest releases, destructor releases and host retirements, with abnormal cleanup recording its retirement reason;
  • classify guest trap, quota exhaustion, scope exhaustion, cancellation and outside-model responses distinctly (as H-OUTCOME-01 requires), instead of a single adapter-trap or invalid-handle;
  • report any owner or native pin that remains after cleanup;
  • record an ordered event trace of requests, responses and committed effects up to the abort point.

Cancellation claims additionally require a real host interruption control that revokes guest access immediately. Until that control exists, cancellation remains unsupported. A finite monitored trace is evidence about that execution only and MUST NOT be reported as a universal protocol proof.

Scenario: EPROTO-CASE-03 for EPROTO-OBS-01

  • GIVEN the Effect-Protocol-Draft profile and every field of input in EPROTO-CASE-03
  • WHEN the adapter procedure for case EPROTO-CASE-03 runs against those inputs
  • THEN the observations match every field of expected in case EPROTO-CASE-03

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: EPROTO-CASE-04 for EPROTO-OBS-01

  • GIVEN the Effect-Protocol-Draft profile and every field of input in EPROTO-CASE-04
  • WHEN the adapter procedure for case EPROTO-CASE-04 runs against those inputs
  • THEN the observations match every field of expected in case EPROTO-CASE-04

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: EPROTO-CASE-05 for EPROTO-OBS-01

  • GIVEN the Effect-Protocol-Draft profile and every field of input in EPROTO-CASE-05
  • WHEN the adapter procedure for case EPROTO-CASE-05 runs against those inputs
  • THEN the observations match every field of expected in case EPROTO-CASE-05

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: EPROTO-CASE-06 for EPROTO-OBS-01

  • GIVEN the Effect-Protocol-Draft profile and every field of input in EPROTO-CASE-06
  • WHEN the adapter procedure for case EPROTO-CASE-06 runs against those inputs
  • THEN the observations match every field of expected in case EPROTO-CASE-06

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: EPROTO-CASE-07 for EPROTO-OBS-01

  • GIVEN the Effect-Protocol-Draft profile and every field of input in EPROTO-CASE-07
  • WHEN the adapter procedure for case EPROTO-CASE-07 runs against those inputs
  • THEN the observations match every field of expected in case EPROTO-CASE-07

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: EPROTO-CASE-08 for EPROTO-OBS-01

  • GIVEN the Effect-Protocol-Draft profile and every field of input in EPROTO-CASE-08
  • WHEN the adapter procedure for case EPROTO-CASE-08 runs against those inputs
  • THEN the observations match every field of expected in case EPROTO-CASE-08

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Scenario: EPROTO-CASE-11 for EPROTO-OBS-01

  • GIVEN the Effect-Protocol-Draft profile and every field of input in EPROTO-CASE-11
  • WHEN the adapter procedure for case EPROTO-CASE-11 runs against those inputs
  • THEN the observations match every field of expected in case EPROTO-CASE-11

This is a scenario design, not an execution result. The case's state and evidence fields record its status.

Requirement: RA-GROUP-01

r[RA-GROUP-01]

RA-GROUP-01.

A host scope MUST be bounded at two children and MUST be identified by a host-issued scope identity that no copied handle, callback, snapshot, decision, slot index, generation or serialized descriptor can substitute for. Membership MUST be retained as an ordered list of child references (scope identity, slot, generation), appended in attachment order, and MUST be granted only through the scope's own move-only admitted child value. Duplicate attachment, attachment of a child from a foreign table or scope, attachment of a stale generation, attachment after close and fabricated membership MUST be refused, and a refusal MUST leave both the membership and the child's task unchanged. The scope MUST remain a host-side composition layer: the kernel table's per-task state machine is not changed and no new kernel surface is added.

Test design remains open for this requirement. No scenario or execution evidence is supplied.

Scenario: a copied handle does not attach

  • GIVEN a child admitted into a scope whose move-only value has already been consumed by attachment, and a copied descriptive handle naming the same slot and generation
  • WHEN attachment is attempted through the copied handle
  • THEN it MUST be refused and the retained membership MUST NOT change

Scenario: stale and post-close attachment are refused

  • GIVEN a scope holding a live child and a task naming an older generation of that slot, and separately a scope that has already closed
  • WHEN attachment is attempted with the stale task, and with a valid task after the close
  • THEN both MUST be refused, and the refused task MUST remain usable by its current owner

Requirement: RA-GROUP-02

r[RA-GROUP-02]

RA-GROUP-02.

Scope admission MUST be incremental, one child at a time, because the kernel's Admission value holds the table exclusively; no more than one scope-issued child value may await attachment, and whole-group preflight MUST NOT be claimed or implied. Dropping an unattached scope-issued value MUST transfer its retirement to the host registry and leave the scope fail-closed. A refused admission MUST preserve every previously committed child as a member with its custody, reservations, pins and native obligations unchanged, and MUST return every caller-owned input unchanged. A refused or failed later admission MUST NOT be described as rollback of native work, of a consumed authorization, or of a committed child. Each admitted child's footprint MUST be charged once by the existing Request/Limits accounting, and the scope MUST NOT introduce a second accounting of the same capacity.

Test design remains open for this requirement. No scenario or execution evidence is supplied.

Scenario: the first child survives a refused second admission

  • GIVEN a scope holding one committed child and a table whose remaining capacity or generation budget cannot admit the second child
  • WHEN the second admission is attempted and refused
  • THEN the first child MUST remain a member, its accounting and retirement obligations MUST be unchanged, and the caller's second input MUST be returned unchanged

Scenario: no whole-group preflight

  • GIVEN a host that would prefer to preflight both children together
  • WHEN the scope's admission policy is inspected
  • THEN it MUST be incremental and MUST NOT claim atomic group admission, because the second preparation cannot exist while the first holds the table

Requirement: RA-GROUP-03

r[RA-GROUP-03]

RA-GROUP-03.

The scope MUST report child results in attachment order regardless of the order in which the children complete, and MUST NOT report a result the kernel table has not delivered. The scope's primary failure MUST be the first abnormal outcome in the host's serialized order and MUST stick: a later success, a later failure, a late completion of a cancelled child and a duplicate callback MUST NOT replace it. A cancellation acknowledgement MUST be recorded as neither a result nor a settlement. Membership MUST be released exactly once per member, and a repeated release MUST be refused without changing accounting.

Test design remains open for this requirement. No scenario or execution evidence is supplied.

Scenario: attachment order, not completion order

  • GIVEN two members attached in one order whose completions arrive in the opposite order
  • WHEN the scope reports its results
  • THEN the reported order MUST be the attachment order, and the same results MUST be reported when the completion order is reversed

Scenario: the sticky primary failure

  • GIVEN a member that fails abnormally and a later member success, and separately a cancelled child whose late completion arrives afterwards
  • WHEN the scope selects its failure
  • THEN it MUST retain the first abnormal outcome, and the late completion MUST NOT deliver a result or replace that failure

Requirement: RA-GROUP-04

r[RA-GROUP-04]

RA-GROUP-04.

Each undelivered child MUST be retired on cancellation, deadline, trap and host failure, and a native cancellation request, a native-stop observation, pin settlement and cleanup MUST remain separate decisions rather than one shielded operation. An unsettled child MUST keep the scope unsettled. Dropping the scope wrapper MUST NOT invent cleanup: the retained host owner (the scope registry) MUST inherit the outstanding retirement, because dropping a task value performs no cleanup in the kernel. The host-retained input payload MUST remain owned while cleanup is outstanding and MUST be dropped only after the table accepts cleanup; the host registry MUST inherit that payload if the wrapper is dropped earlier. If the table snapshot confirms an empty pin set after native stop, the host MUST record the empty settlement without issuing a zero-mask table operation, and MUST still acknowledge cleanup separately.

Test design remains open for this requirement. No scenario or execution evidence is supplied.

Scenario: cancellation is not settlement

  • GIVEN a member cancelled before its result was delivered, with native work still running and pins outstanding
  • WHEN the scope reports its state
  • THEN it MUST report the retirement and MUST NOT report settlement until the native stop, pin settlement and cleanup obligations are discharged

Scenario: a dropped wrapper leaves retirement to the host

  • GIVEN a scope wrapper dropped while one member still owes native stop, pins or cleanup
  • WHEN retirement is asked for afterwards
  • THEN the host scope registry MUST own it, and no cleanup MUST be reported as complete merely because the wrapper no longer exists

Scenario: cleanup releases the host input only when accepted

  • GIVEN a child whose input payload remains host-owned while native stop, pins or cleanup are outstanding
  • WHEN table cleanup is refused or succeeds
  • THEN refusal MUST preserve the payload, and successful cleanup MUST release it

Scenario: an empty pin set needs no fabricated table release

  • GIVEN a native-stopped child whose table snapshot has no outstanding pins
  • WHEN the host acknowledges pin settlement
  • THEN it MUST record the empty settlement without changing table accounting, and cleanup MUST remain a separate required step

Requirement: RA-GROUP-05

r[RA-GROUP-05]

RA-GROUP-05.

Final close MUST require every member to satisfy the existing M6 finalization contract — a successful finish after native stop, pin settlement and complete cleanup — together with settled membership accounting; otherwise the close MUST be refused. A repeated close after a successful close MUST be idempotent and MUST NOT release accounting a second time. Close MUST NOT manufacture completion, delivery, native stop or a result.

Test design remains open for this requirement. No scenario or execution evidence is supplied.

Scenario: early close is refused

  • GIVEN a scope with a member that has not passed finish, or whose membership accounting is not settled
  • WHEN the scope is closed
  • THEN the close MUST be refused and the scope MUST remain able to settle

Scenario: repeated close is idempotent

  • GIVEN a scope closed after every member finalized
  • WHEN close is requested again
  • THEN it MUST succeed idempotently, report the same settled state and change no accounting

Requirement: RA-GROUP-06

r[RA-GROUP-06]

RA-GROUP-06.

The scope policy MUST be exercised by a finite bounded model — one scope, at most two children, a declared action alphabet and a declared depth — compared against an adapter driving the actual Rust M6 table API and reusing the completed #46 interleaving study. Every result MUST identify whether it establishes scope policy, transition composition or adapter correspondence, and model proofs, runtime tests and host assumptions MUST remain separately identified. Evidence MUST bind the source revision, the scope policy, the model revision and the declared bounds. No eventual native completion, cleanup after host death, fairness or liveness is claimed, and a model obligation MUST NOT be reported as an adapter guarantee.

Test design remains open for this requirement. No scenario or execution evidence is supplied.

Scenario: model and adapter are labelled separately

  • GIVEN a scope trace proved in the model and the same trace replayed through the adapter
  • WHEN the evidence is reported
  • THEN the model obligation and the adapter replay MUST be reported as separate results, and neither MUST be described as the other

Scenario: the bound is declared with the evidence

  • GIVEN retained evidence for the scope policy
  • WHEN its bindings are inspected
  • THEN the source revision, the change revision, the model module and the declared alphabet and depth MUST be recorded