lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

commit 4d73dcb5d73d81031e799a2c9f200ca5e6a417ff
parent 25db2ec84e5e5e56586a0657b8dffa07936363c5
Author: triesap <tyson@radroots.org>
Date:   Sun, 25 Oct 2026 23:30:06 +0000

storage: expose preparation abort through the shared inventory port

- Own cleanup selectors and bounded reports in shared storage.
- Dispatch generic native transaction and recovery calls to the same owner.
- Remove native type exports while preserving exact catalog13 records.
- Verify shared and WASM inputs plus native and Linux effects and refusal.

Diffstat:
Mcontracts/api_baselines/radroots_storage.txt | 26++++++++++++++++++++++++++
Mcontracts/api_baselines/radroots_storage_sqlite.txt | 27++++++---------------------
Mcontracts/architecture/decisions/shared_sdk_refactor.v1.json | 6+++++-
Mcrates/storage/README.md | 10++++++++++
Mcrates/storage/src/inventory.rs | 21+++++++++++++++++++++
Acrates/storage/src/inventory/abort.rs | 122+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage/tests/workspace.rs | 3+++
Acrates/storage/tests/workspace/inventory_abort.rs | 135+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/README.md | 4++++
Mcrates/storage_sqlite/src/workspace/mod.rs | 24++++++++++++------------
Mcrates/storage_sqlite/src/workspace/stock.rs | 24+++++++++++++++++++++++-
Mcrates/storage_sqlite/src/workspace/stock/inventory/abort.rs | 120++++++++++++++++++-------------------------------------------------------------
Mcrates/storage_sqlite/src/workspace/stock/inventory/abort/codec.rs | 17+++++++++--------
Mcrates/storage_sqlite/src/workspace/stock/inventory/acceptance.rs | 2+-
Mcrates/storage_sqlite/src/workspace/stock/public_source/abort_tests.rs | 27++++++++++++++++++++++++---
Mcrates/storage_sqlite/src/workspace/stock/public_source/process_death_tests.rs | 2+-
Acrates/storage_sqlite/tests/support/stock_abort_port.rs | 45+++++++++++++++++++++++++++++++++++++++++++++
Mcrates/storage_sqlite/tests/workspace_attachment.rs | 2++
Mtools/xtask/src/architecture/decision_package.rs | 13+++++++++++++
19 files changed, 489 insertions(+), 141 deletions(-)

diff --git a/contracts/api_baselines/radroots_storage.txt b/contracts/api_baselines/radroots_storage.txt @@ -1369,6 +1369,9 @@ pub use radroots_storage::inventory::InventoryCommandKind pub enum radroots_storage::inventory::InventoryOutcome pub radroots_storage::inventory::InventoryOutcome::Committed(alloc::boxed::Box<radroots_storage::inventory::InventoryReceipt>) pub radroots_storage::inventory::InventoryOutcome::Unknown(radroots_storage::command::CommitAttempt) +pub enum radroots_storage::inventory::StockAbortOutcome +pub radroots_storage::inventory::StockAbortOutcome::Aborted(alloc::boxed::Box<radroots_storage::inventory::StockAbortReceipt>) +pub radroots_storage::inventory::StockAbortOutcome::Unknown(radroots_storage::command::CommitAttempt) pub struct radroots_storage::inventory::InventoryCheckpointRef impl radroots_storage::inventory::InventoryCheckpointRef pub const fn radroots_storage::inventory::InventoryCheckpointRef::authority(self) -> radroots_domain::context::AuthorityRef @@ -1400,11 +1403,34 @@ pub const fn radroots_storage::inventory::InventoryRequest::replay_only(&self) - pub fn radroots_storage::inventory::InventoryRequest::retained_copy(&self) -> core::result::Result<Self, radroots_storage::command::OperationError> impl core::fmt::Debug for radroots_storage::inventory::InventoryRequest pub fn radroots_storage::inventory::InventoryRequest::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_storage::inventory::StockAbortReceipt +impl radroots_storage::inventory::StockAbortReceipt +pub const fn radroots_storage::inventory::StockAbortReceipt::aborted_at(&self) -> radroots_domain::context::UnixSeconds +pub const fn radroots_storage::inventory::StockAbortReceipt::attempt(&self) -> radroots_storage::command::CommitAttempt +pub const fn radroots_storage::inventory::StockAbortReceipt::checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef +pub fn radroots_storage::inventory::StockAbortReceipt::from_committed_store(&radroots_storage::workspace::AttachmentInput, radroots_storage::command::CommitAttempt, radroots_domain::identifier::OrderId, radroots_domain::context::UnixSeconds, radroots_storage::inventory::InventoryCheckpointRef, alloc::vec::Vec<radroots_domain::stock::PoolSnapshot>) -> core::result::Result<Self, radroots_storage::command::OperationError> +pub fn radroots_storage::inventory::StockAbortReceipt::into_released_pools(self) -> alloc::vec::Vec<radroots_domain::stock::PoolSnapshot> +pub const fn radroots_storage::inventory::StockAbortReceipt::order_id(&self) -> radroots_domain::identifier::OrderId +pub fn radroots_storage::inventory::StockAbortReceipt::released_pools(&self) -> &[radroots_domain::stock::PoolSnapshot] +impl core::fmt::Debug for radroots_storage::inventory::StockAbortReceipt +pub fn radroots_storage::inventory::StockAbortReceipt::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result +pub struct radroots_storage::inventory::StockAbortRequest +impl radroots_storage::inventory::StockAbortRequest +pub fn radroots_storage::inventory::StockAbortRequest::attempt(&self) -> radroots_storage::command::CommitAttempt +pub const fn radroots_storage::inventory::StockAbortRequest::binding(&self) -> &radroots_storage::workspace::WorkspaceBinding +pub const fn radroots_storage::inventory::StockAbortRequest::command_digest(&self) -> radroots_domain::identifier::CommandDigest +pub const fn radroots_storage::inventory::StockAbortRequest::minimum_checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef +pub const fn radroots_storage::inventory::StockAbortRequest::new(radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest) -> Self +pub const fn radroots_storage::inventory::StockAbortRequest::operation_id(&self) -> radroots_domain::identifier::OperationId +impl core::fmt::Debug for radroots_storage::inventory::StockAbortRequest +pub fn radroots_storage::inventory::StockAbortRequest::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub trait radroots_storage::inventory::InventoryStore: radroots_storage::workspace::WorkspaceStore +pub fn radroots_storage::inventory::InventoryStore::abort_proven_unissued(&self, radroots_storage::inventory::StockAbortRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::StockAbortOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::execute_inventory(&self, radroots_storage::inventory::InventoryRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::InventoryOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::inventory_operation(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, core::option::Option<radroots_domain::identifier::CommandDigest>, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::InventoryReceipt>, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::option_mapping(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::stock::mapping::OptionMappingKey, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_domain::stock::mapping::OptionPoolMapping>, radroots_storage::command::OperationError>> pub fn radroots_storage::inventory::InventoryStore::pool(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::PoolId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_domain::stock::PoolView>, radroots_storage::command::OperationError>> +pub fn radroots_storage::inventory::InventoryStore::stock_preparation_abort(&self, radroots_storage::inventory::StockAbortRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::StockAbortReceipt>, radroots_storage::command::OperationError>> pub mod radroots_storage::journal pub use radroots_storage::journal::BoxFuture pub use radroots_storage::journal::EventId diff --git a/contracts/api_baselines/radroots_storage_sqlite.txt b/contracts/api_baselines/radroots_storage_sqlite.txt @@ -368,11 +368,8 @@ pub use radroots_storage_sqlite::workspace::WorkspaceBinding pub use radroots_storage_sqlite::workspace::WorkspaceClock pub use radroots_storage_sqlite::workspace::WorkspaceError pub use radroots_storage_sqlite::workspace::WorkspaceScope -pub enum radroots_storage_sqlite::workspace::StockAbortOutcome -pub radroots_storage_sqlite::workspace::StockAbortOutcome::Aborted(alloc::boxed::Box<radroots_storage_sqlite::workspace::StockAbortReceipt>) -pub radroots_storage_sqlite::workspace::StockAbortOutcome::Unknown(radroots_storage::command::CommitAttempt) pub enum radroots_storage_sqlite::workspace::StockAcceptanceOutcome -pub radroots_storage_sqlite::workspace::StockAcceptanceOutcome::Aborted(alloc::boxed::Box<radroots_storage_sqlite::workspace::StockAbortReceipt>) +pub radroots_storage_sqlite::workspace::StockAcceptanceOutcome::Aborted(alloc::boxed::Box<radroots_storage::inventory::abort::StockAbortReceipt>) pub radroots_storage_sqlite::workspace::StockAcceptanceOutcome::Prepared(alloc::boxed::Box<radroots_storage_sqlite::workspace::StockAcceptanceReceipt>) pub radroots_storage_sqlite::workspace::StockAcceptanceOutcome::Unknown(radroots_storage::command::CommitAttempt) pub enum radroots_storage_sqlite::workspace::StockClaimOutcome @@ -422,8 +419,8 @@ pub radroots_storage_sqlite::workspace::StockSourceProfile::Rejected pub radroots_storage_sqlite::workspace::StockSourceProfile::Unsupported pub struct radroots_storage_sqlite::workspace::NativeWorkspace impl radroots_storage_sqlite::workspace::NativeWorkspace -pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::abort_proven_unissued(&self, radroots_storage_sqlite::workspace::StockAbortRequest, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage_sqlite::workspace::StockAbortOutcome, radroots_storage::command::OperationError> -pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_preparation_abort(&self, radroots_storage_sqlite::workspace::StockAbortRequest, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<core::option::Option<radroots_storage_sqlite::workspace::StockAbortReceipt>, radroots_storage::command::OperationError> +pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::abort_proven_unissued(&self, radroots_storage::inventory::abort::StockAbortRequest, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage::inventory::abort::StockAbortOutcome, radroots_storage::command::OperationError> +pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_preparation_abort(&self, radroots_storage::inventory::abort::StockAbortRequest, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<core::option::Option<radroots_storage::inventory::abort::StockAbortReceipt>, radroots_storage::command::OperationError> impl radroots_storage_sqlite::workspace::NativeWorkspace pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::authenticate(&self, radroots_storage::workspace::AttachmentInput, &radroots_storage::workspace::AttachmentProof) -> core::result::Result<radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::WorkspaceError> pub async fn radroots_storage_sqlite::workspace::NativeWorkspace::close(&self) -> core::result::Result<(), radroots_storage::workspace::WorkspaceError> @@ -485,27 +482,15 @@ pub fn radroots_storage_sqlite::workspace::NativeWorkspace::record_delivery_obse pub fn radroots_storage_sqlite::workspace::NativeWorkspace::signing_attempt(&self, radroots_storage::command::issuance::ClaimAttemptRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::issuance::SigningAttempt>, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::signing_plan(&self, radroots_storage::workspace::WorkspaceBinding, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::command::BoundSigningPlan>, radroots_storage::command::OperationError>> impl radroots_storage::inventory::InventoryStore for radroots_storage_sqlite::workspace::NativeWorkspace +pub fn radroots_storage_sqlite::workspace::NativeWorkspace::abort_proven_unissued(&self, radroots_storage::inventory::abort::StockAbortRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::abort::StockAbortOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::execute_inventory(&self, radroots_storage::inventory::InventoryRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::inventory::InventoryOutcome, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::inventory_operation(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, core::option::Option<radroots_domain::identifier::CommandDigest>, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::InventoryReceipt>, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::option_mapping(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::stock::mapping::OptionMappingKey, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_domain::stock::mapping::OptionPoolMapping>, radroots_storage::command::OperationError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::pool(&self, radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::PoolId, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_domain::stock::PoolView>, radroots_storage::command::OperationError>> +pub fn radroots_storage_sqlite::workspace::NativeWorkspace::stock_preparation_abort(&self, radroots_storage::inventory::abort::StockAbortRequest, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<core::option::Option<radroots_storage::inventory::abort::StockAbortReceipt>, radroots_storage::command::OperationError>> impl radroots_storage::workspace::WorkspaceStore for radroots_storage_sqlite::workspace::NativeWorkspace pub fn radroots_storage_sqlite::workspace::NativeWorkspace::authenticate(&self, radroots_storage::workspace::AttachmentInput, radroots_storage::workspace::AttachmentProof) -> radroots_transport::source::BoxFuture<'_, core::result::Result<radroots_storage::workspace::WorkspaceBinding, radroots_storage::workspace::WorkspaceError>> pub fn radroots_storage_sqlite::workspace::NativeWorkspace::close_workspace(&self) -> radroots_transport::source::BoxFuture<'_, core::result::Result<(), radroots_storage::workspace::WorkspaceError>> -pub struct radroots_storage_sqlite::workspace::StockAbortReceipt -impl radroots_storage_sqlite::workspace::StockAbortReceipt -pub const fn radroots_storage_sqlite::workspace::StockAbortReceipt::aborted_at(&self) -> radroots_domain::context::UnixSeconds -pub const fn radroots_storage_sqlite::workspace::StockAbortReceipt::attempt(&self) -> radroots_storage::command::CommitAttempt -pub const fn radroots_storage_sqlite::workspace::StockAbortReceipt::checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef -pub const fn radroots_storage_sqlite::workspace::StockAbortReceipt::order_id(&self) -> radroots_domain::identifier::OrderId -pub fn radroots_storage_sqlite::workspace::StockAbortReceipt::released_pools(&self) -> &[radroots_domain::stock::PoolSnapshot] -impl core::fmt::Debug for radroots_storage_sqlite::workspace::StockAbortReceipt -pub fn radroots_storage_sqlite::workspace::StockAbortReceipt::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result -pub struct radroots_storage_sqlite::workspace::StockAbortRequest -impl radroots_storage_sqlite::workspace::StockAbortRequest -pub const fn radroots_storage_sqlite::workspace::StockAbortRequest::new(radroots_storage::workspace::WorkspaceBinding, radroots_storage::inventory::InventoryCheckpointRef, radroots_domain::identifier::OperationId, radroots_domain::identifier::CommandDigest) -> Self -impl core::fmt::Debug for radroots_storage_sqlite::workspace::StockAbortRequest -pub fn radroots_storage_sqlite::workspace::StockAbortRequest::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage_sqlite::workspace::StockAcceptanceReceipt impl radroots_storage_sqlite::workspace::StockAcceptanceReceipt pub const fn radroots_storage_sqlite::workspace::StockAcceptanceReceipt::allocation_count(&self) -> usize @@ -682,7 +667,7 @@ impl core::fmt::Debug for radroots_storage_sqlite::workspace::StockListingSnapsh pub fn radroots_storage_sqlite::workspace::StockListingSnapshot::fmt(&self, &mut core::fmt::Formatter<'_>) -> core::fmt::Result pub struct radroots_storage_sqlite::workspace::StockOperationSnapshot impl radroots_storage_sqlite::workspace::StockOperationSnapshot -pub fn radroots_storage_sqlite::workspace::StockOperationSnapshot::aborted(&self) -> core::option::Option<&radroots_storage_sqlite::workspace::StockAbortReceipt> +pub fn radroots_storage_sqlite::workspace::StockOperationSnapshot::aborted(&self) -> core::option::Option<&radroots_storage::inventory::abort::StockAbortReceipt> pub const fn radroots_storage_sqlite::workspace::StockOperationSnapshot::checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef pub fn radroots_storage_sqlite::workspace::StockOperationSnapshot::installation(&self) -> core::option::Option<&radroots_storage_sqlite::workspace::StockInstallationReceipt> pub const fn radroots_storage_sqlite::workspace::StockOperationSnapshot::preparation(&self) -> &radroots_storage_sqlite::workspace::StockAcceptanceReceipt diff --git a/contracts/architecture/decisions/shared_sdk_refactor.v1.json b/contracts/architecture/decisions/shared_sdk_refactor.v1.json @@ -276,7 +276,11 @@ "later_initial_requires_original_abort": true, "fresh_signing_after_abort": false, "unknown_commit_fences_owner": true, - "signer_or_transport_invoked": false + "signer_or_transport_invoked": false, + "shared_storage_port": "radroots_storage.inventory.InventoryStore", + "shared_model_owner": "radroots_storage.inventory", + "native_workspace_type_aliases": false, + "unsupported_hosts_return": "capability_unavailable" } }, "provenance": { diff --git a/crates/storage/README.md b/crates/storage/README.md @@ -89,6 +89,16 @@ bindings retain that exact scope. Neither scope grants firm stock, delegation, organization access or recovery of old obligations. Scope separates route, genesis and credential commitments; changing an actor cannot upgrade a grant. Concrete native/browser hosts share these rules and exact envelope context. +Shared `inventory::StockAbortRequest`, `StockAbortOutcome` and `StockAbortReceipt` +carry explicit original-preparation cleanup selectors and reports. +`InventoryStore::abort_proven_unissued` and `stock_preparation_abort` are typed +transaction/query ports; unsupported hosts return `UnsupportedOperation`, whose +stable code is `capability_unavailable`. +Report reconstruction checks namespace, committed anchor, progress and bounded +canonical after-images, and supplies no credential, absence or commit proof. +Qualified stores must authenticate all original claims and exact release effects +inside their owned atomic transaction. The native implementation uses its same +bounded connection owner; ordinary outboxes acquire no stock authority. The codec's Serde wire stays private; decoding enforces the 16 KiB limit and validates current scope. Enrollment takes qualified host identities and proof without acquiring a backend or establishing durable authority. Concrete hosts diff --git a/crates/storage/src/inventory.rs b/crates/storage/src/inventory.rs @@ -7,6 +7,8 @@ use crate::{ use radroots_domain::{CommandDigest, OperationId, PoolId, TransactionId, stock::PoolSnapshot}; pub use radroots_protocol::command::{CapturedInventoryCommand, InventoryCommandKind}; use radroots_transport::BoxFuture; +mod abort; +pub use abort::{StockAbortOutcome, StockAbortReceipt, StockAbortRequest}; /// Exact captured owner-private inventory command and original authenticated observation. pub struct InventoryRequest { @@ -262,6 +264,25 @@ pub enum InventoryOutcome { /// Native and browser hosts enforce these same atomic rules, never a memory /// success placeholder. No signing or network work occurs in these methods. pub trait InventoryStore: WorkspaceStore { + /// Explicit original-preparation cleanup. The concrete store must prove + /// every original claim absent and retain the exact release atomically. + /// Neither this port nor an unsupported host supplies an absence proof. + fn abort_proven_unissued( + &self, + _request: StockAbortRequest, + _proof: AttachmentProof, + ) -> BoxFuture<'_, Result<StockAbortOutcome, OperationError>> { + Box::pin(async { Err(OperationError::UnsupportedOperation) }) + } + /// Reads original cleanup under current access; absence is not permission + /// to retry issuance or release. Unsupported hosts refuse explicitly. + fn stock_preparation_abort( + &self, + _request: StockAbortRequest, + _proof: AttachmentProof, + ) -> BoxFuture<'_, Result<Option<StockAbortReceipt>, OperationError>> { + Box::pin(async { Err(OperationError::UnsupportedOperation) }) + } /// Reads current owner-private configuration after authenticating retained /// progress. Physical inventory scopes confer no configuration access. fn option_mapping( diff --git a/crates/storage/src/inventory/abort.rs b/crates/storage/src/inventory/abort.rs @@ -0,0 +1,122 @@ +//! Shared explicit cleanup selectors and reports, without backend qualification. +use super::*; +use crate::workspace::AttachmentInput; +use radroots_domain::{OrderId, UnixSeconds}; + +/// Original-operation selectors. These values supply no nonissuance proof. +pub struct StockAbortRequest { + binding: WorkspaceBinding, + minimum: InventoryCheckpointRef, + operation: OperationId, + digest: CommandDigest, +} +impl StockAbortRequest { + pub const fn new( + binding: WorkspaceBinding, + minimum: InventoryCheckpointRef, + operation: OperationId, + digest: CommandDigest, + ) -> Self { + Self { + binding, + minimum, + operation, + digest, + } + } + pub const fn binding(&self) -> &WorkspaceBinding { + &self.binding + } + pub const fn minimum_checkpoint(&self) -> InventoryCheckpointRef { + self.minimum + } + pub const fn operation_id(&self) -> OperationId { + self.operation + } + pub const fn command_digest(&self) -> CommandDigest { + self.digest + } + /// Original recovery metadata, never evidence of admission or completion. + pub fn attempt(&self) -> CommitAttempt { + CommitAttempt::new( + self.binding.input().workspace_id(), + self.operation, + self.digest, + None, + ) + } +} +impl core::fmt::Debug for StockAbortRequest { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + f.write_str("StockAbortRequest(<redacted>)") + } +} + +/// Reported original cleanup, distinct from cancellation or delivery. +pub struct StockAbortReceipt { + attempt: CommitAttempt, + order: OrderId, + at: UnixSeconds, + checkpoint: InventoryCheckpointRef, + pools: Vec<PoolSnapshot>, +} +impl StockAbortReceipt { + /// Checks bounded report metadata only. A qualified store must authenticate + /// the original absence and effects and confirm its actual atomic commit. + pub fn from_committed_store( + namespace: &AttachmentInput, + attempt: CommitAttempt, + order: OrderId, + at: UnixSeconds, + checkpoint: InventoryCheckpointRef, + pools: Vec<PoolSnapshot>, + ) -> Result<Self, OperationError> { + if attempt.workspace_id() != namespace.workspace_id() + || attempt.transaction_id().is_none() + || checkpoint.authority() != namespace.authority() + || checkpoint.revision().get() == 0 + || checkpoint.authorization().is_none() + || pools.len() > 64 + || pools.iter().any(|pool| pool.version().get() < 3) + || pools.windows(2).any(|pair| pair[0].id() >= pair[1].id()) + { + return Err(OperationError::RecoveryRequired); + } + Ok(Self { + attempt, + order, + at, + checkpoint, + pools, + }) + } + pub const fn attempt(&self) -> CommitAttempt { + self.attempt + } + pub const fn order_id(&self) -> OrderId { + self.order + } + pub const fn aborted_at(&self) -> UnixSeconds { + self.at + } + pub const fn checkpoint(&self) -> InventoryCheckpointRef { + self.checkpoint + } + pub fn released_pools(&self) -> &[PoolSnapshot] { + &self.pools + } + /// Transfers the original reported after-images without another copy. + pub fn into_released_pools(self) -> Vec<PoolSnapshot> { + self.pools + } +} +impl core::fmt::Debug for StockAbortReceipt { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + f.write_str("StockAbortReceipt(<redacted>)") + } +} +#[derive(Debug)] +pub enum StockAbortOutcome { + Aborted(Box<StockAbortReceipt>), + Unknown(CommitAttempt), +} diff --git a/crates/storage/tests/workspace.rs b/crates/storage/tests/workspace.rs @@ -5,6 +5,9 @@ use radroots_domain::{ use radroots_storage::workspace::{ AttachmentInput, AttachmentProof, WorkspaceBinding, WorkspaceError, }; +#[cfg(feature = "protected_outbox")] +#[path = "workspace/inventory_abort.rs"] +mod inventory_abort; fn key() -> PublicKey { PublicKey::from_hex("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798").unwrap() } diff --git a/crates/storage/tests/workspace/inventory_abort.rs b/crates/storage/tests/workspace/inventory_abort.rs @@ -0,0 +1,135 @@ +use super::*; +use radroots_domain::{ + CommandDigest, OperationId, OrderId, PoolId, TransactionId, + listing::MeasurementUnit, + stock::{PhysicalBalances, PoolBalances, PoolSnapshot, PoolUnit, StockTicks}, +}; +use radroots_storage::{ + command::{CommitAttempt, OperationError}, + inventory::{InventoryCheckpointRef, StockAbortReceipt}, + workspace::seller_stock::StockAuthorizationRef, +}; + +fn checkpoint( + namespace: &AttachmentInput, + revision: u64, + authorization: bool, +) -> InventoryCheckpointRef { + InventoryCheckpointRef::from_host_metadata( + namespace.authority(), + Sequence::new(revision).unwrap(), + (revision != 0).then_some(CheckpointDigest::from_bytes([7; 32])), + ) + .unwrap() + .with_optional_authorization(authorization.then(|| { + StockAuthorizationRef::from_host_metadata( + Sequence::new(1).unwrap(), + CheckpointDigest::from_bytes([8; 32]), + ) + .unwrap() + })) +} +fn attempt(namespace: &AttachmentInput, committed: bool) -> CommitAttempt { + CommitAttempt::new( + namespace.workspace_id(), + OperationId::from_bytes([70; 32]), + CommandDigest::from_bytes([71; 32]), + committed.then_some(TransactionId::from_bytes([72; 32])), + ) +} +fn report( + namespace: &AttachmentInput, + attempt: CommitAttempt, + checkpoint: InventoryCheckpointRef, + pools: Vec<PoolSnapshot>, +) -> Result<StockAbortReceipt, OperationError> { + StockAbortReceipt::from_committed_store( + namespace, + attempt, + OrderId::from_bytes([73; 32]), + UnixSeconds::new(111).unwrap(), + checkpoint, + pools, + ) +} +fn pool(id: u8, revision: u64) -> PoolSnapshot { + PoolSnapshot::new( + PoolId::from_bytes([id; 32]), + PoolUnit::new(MeasurementUnit::Each, 0).unwrap(), + PoolBalances::new(StockTicks::ZERO, PhysicalBalances::ZERO).unwrap(), + Sequence::new(revision).unwrap(), + ) +} + +#[test] +fn shared_cleanup_metadata_refuses_missing_commit_progress_authorization_and_foreign_namespace() { + let namespace = input(); + let valid = checkpoint(&namespace, 1, true); + for (anchor, progress) in [ + (attempt(&namespace, false), valid), + (attempt(&namespace, true), checkpoint(&namespace, 0, true)), + (attempt(&namespace, true), checkpoint(&namespace, 1, false)), + ( + CommitAttempt::new( + WorkspaceId::from_bytes([99; 32]), + OperationId::from_bytes([70; 32]), + CommandDigest::from_bytes([71; 32]), + Some(TransactionId::from_bytes([72; 32])), + ), + valid, + ), + ( + attempt(&namespace, true), + InventoryCheckpointRef::from_host_metadata( + AuthorityRef::new( + ExecutorId::from_bytes([99; 32]), + Generation::new(1).unwrap(), + ), + valid.revision(), + valid.head(), + ) + .unwrap() + .with_optional_authorization(valid.authorization()), + ), + ] { + assert_eq!( + report(&namespace, anchor, progress, vec![]).unwrap_err(), + OperationError::RecoveryRequired + ); + } + let value = report(&namespace, attempt(&namespace, true), valid, vec![]).unwrap(); + assert_eq!(value.attempt(), attempt(&namespace, true)); + assert_eq!(value.checkpoint(), valid); + assert!(value.released_pools().is_empty()); + assert_eq!(format!("{value:?}"), "StockAbortReceipt(<redacted>)"); +} + +#[test] +fn shared_cleanup_pool_reports_are_bounded_canonical_and_keep_the_original_after_images() { + let namespace = input(); + let selected = |pools| { + report( + &namespace, + attempt(&namespace, true), + checkpoint(&namespace, 1, true), + pools, + ) + }; + for invalid in [ + vec![pool(1, 3), pool(1, 3)], + vec![pool(2, 3), pool(1, 3)], + vec![pool(1, 0)], + vec![pool(1, 1)], + vec![pool(1, 2)], + (0..65).map(|id| pool(id, 3)).collect(), + ] { + assert_eq!( + selected(invalid).unwrap_err(), + OperationError::RecoveryRequired + ); + } + let expected: Vec<_> = (0..64).map(|id| pool(id, 3)).collect(); + let value = selected(expected.clone()).unwrap(); + assert!(value.released_pools() == expected); + assert!(value.into_released_pools() == expected); +} diff --git a/crates/storage_sqlite/README.md b/crates/storage_sqlite/README.md @@ -469,6 +469,10 @@ stock or complete ordinary caller orchestration. Fresh installation also refuses an observed time before its original bound plan, before any write; recovery of an existing installation remains historical. +Cleanup request/result types belong to `radroots_storage::inventory`. +The `InventoryStore` transaction/query ports dispatch to this same native owner; +the former native workspace type exports have been removed. + `abort_proven_unissued` explicitly releases an original preparation only after authenticating absence of both recipient claims through protected history. T1 may be absent or bound. A claim, unknown dispatch, obtained artifact or installed diff --git a/crates/storage_sqlite/src/workspace/mod.rs b/crates/storage_sqlite/src/workspace/mod.rs @@ -23,18 +23,18 @@ mod schema; mod snapshot; mod stock; pub use stock::{ - SellerStockConfig, StockAbortOutcome, StockAbortReceipt, StockAbortRequest, - StockAcceptanceOutcome, StockAcceptanceReceipt, StockAcceptanceRequest, StockAuthorityReceipt, - StockBoundSigningPlan, StockCapturedEvidence, StockClaimOutcome, StockClaimReference, - StockClaimRequest, StockConsentCapture, StockConsentMode, StockConsentOutcome, - StockConsentReceipt, StockDispatchPermit, StockEnrollment, StockEvidenceCapture, - StockEvidenceOutcome, StockEvidencePage, StockEvidenceReceipt, StockGrantEnrollment, - StockGrantOutcome, StockGrantReceipt, StockHistorySnapshot, StockInstallationOutcome, - StockInstallationReceipt, StockInstallationRequest, StockListingCapture, StockListingOutcome, - StockListingReceipt, StockListingSnapshot, StockOperationSnapshot, StockPublicationWork, - StockRecipientSnapshot, StockRequestSnapshot, StockSigningAttempt, StockSigningPlanOutcome, - StockSigningPlanRequest, StockSigningProgress, StockSnapshotRequest, StockSourceCapture, - StockSourceOutcome, StockSourceProfile, StockSourceReceipt, StockSourceSnapshot, + SellerStockConfig, StockAcceptanceOutcome, StockAcceptanceReceipt, StockAcceptanceRequest, + StockAuthorityReceipt, StockBoundSigningPlan, StockCapturedEvidence, StockClaimOutcome, + StockClaimReference, StockClaimRequest, StockConsentCapture, StockConsentMode, + StockConsentOutcome, StockConsentReceipt, StockDispatchPermit, StockEnrollment, + StockEvidenceCapture, StockEvidenceOutcome, StockEvidencePage, StockEvidenceReceipt, + StockGrantEnrollment, StockGrantOutcome, StockGrantReceipt, StockHistorySnapshot, + StockInstallationOutcome, StockInstallationReceipt, StockInstallationRequest, + StockListingCapture, StockListingOutcome, StockListingReceipt, StockListingSnapshot, + StockOperationSnapshot, StockPublicationWork, StockRecipientSnapshot, StockRequestSnapshot, + StockSigningAttempt, StockSigningPlanOutcome, StockSigningPlanRequest, StockSigningProgress, + StockSnapshotRequest, StockSourceCapture, StockSourceOutcome, StockSourceProfile, + StockSourceReceipt, StockSourceSnapshot, }; mod worker; diff --git a/crates/storage_sqlite/src/workspace/stock.rs b/crates/storage_sqlite/src/workspace/stock.rs @@ -13,7 +13,6 @@ pub use consent::{ StockConsentCapture, StockConsentMode, StockConsentOutcome, StockConsentReceipt, }; pub(in crate::workspace) mod grants; -pub use inventory::abort::{StockAbortOutcome, StockAbortReceipt, StockAbortRequest}; pub use inventory::acceptance::{ StockAcceptanceOutcome, StockAcceptanceReceipt, StockAcceptanceRequest, }; @@ -21,6 +20,9 @@ pub use inventory::installation::{ StockInstallationOutcome, StockInstallationReceipt, StockInstallationRequest, StockPublicationWork, }; +pub(in crate::workspace) use radroots_storage::inventory::{ + StockAbortOutcome, StockAbortReceipt, StockAbortRequest, +}; pub(in crate::workspace) mod issuance; mod ledger; mod order_state; @@ -1099,6 +1101,26 @@ async fn unchanged( } impl radroots_storage::inventory::InventoryStore for NativeWorkspace { + fn abort_proven_unissued( + &self, + request: StockAbortRequest, + proof: AttachmentProof, + ) -> radroots_transport::BoxFuture< + '_, + Result<StockAbortOutcome, radroots_storage::command::OperationError>, + > { + Box::pin(self.worker.abort_proven_unissued(request, proof)) + } + fn stock_preparation_abort( + &self, + request: StockAbortRequest, + proof: AttachmentProof, + ) -> radroots_transport::BoxFuture< + '_, + Result<Option<StockAbortReceipt>, radroots_storage::command::OperationError>, + > { + Box::pin(self.worker.stock_preparation_abort(request, proof)) + } fn option_mapping( &self, binding: WorkspaceBinding, diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/abort.rs b/crates/storage_sqlite/src/workspace/stock/inventory/abort.rs @@ -2,83 +2,12 @@ use super::super::{issuance::claim, ledger, order_state, signing_plan}; use super::*; use checkpoint::{EntryIdentity, IdentityTarget}; -use radroots_domain::{OrderId, stock::StockTicks}; +use radroots_domain::stock::StockTicks; mod codec; mod projection; pub(in crate::workspace::stock) use codec::read_entry; pub(in crate::workspace::stock) use projection::{Projection, raw_projection}; -/// Original-operation selectors; this value supplies no nonissuance proof. -pub struct StockAbortRequest { - binding: WorkspaceBinding, - minimum: radroots_storage::inventory::InventoryCheckpointRef, - operation: OperationId, - digest: CommandDigest, -} -impl StockAbortRequest { - pub const fn new( - binding: WorkspaceBinding, - minimum: radroots_storage::inventory::InventoryCheckpointRef, - operation: OperationId, - digest: CommandDigest, - ) -> Self { - Self { - binding, - minimum, - operation, - digest, - } - } - pub(in crate::workspace) fn attempt(&self) -> CommitAttempt { - CommitAttempt::new( - self.binding.input().workspace_id(), - self.operation, - self.digest, - None, - ) - } -} -impl std::fmt::Debug for StockAbortRequest { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.write_str("StockAbortRequest(<redacted>)") - } -} -/// Confirmed original cleanup, distinct from business cancellation or delivery. -pub struct StockAbortReceipt { - attempt: CommitAttempt, - order: OrderId, - at: UnixSeconds, - checkpoint: radroots_storage::inventory::InventoryCheckpointRef, - pools: Vec<PoolSnapshot>, -} -impl StockAbortReceipt { - pub const fn attempt(&self) -> CommitAttempt { - self.attempt - } - pub const fn order_id(&self) -> OrderId { - self.order - } - pub const fn aborted_at(&self) -> UnixSeconds { - self.at - } - pub const fn checkpoint(&self) -> radroots_storage::inventory::InventoryCheckpointRef { - self.checkpoint - } - pub fn released_pools(&self) -> &[PoolSnapshot] { - &self.pools - } -} -impl std::fmt::Debug for StockAbortReceipt { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.write_str("StockAbortReceipt(<redacted>)") - } -} -#[derive(Debug)] -pub enum StockAbortOutcome { - Aborted(Box<StockAbortReceipt>), - Unknown(CommitAttempt), -} - #[derive(Clone, Copy, Serialize, Deserialize, Eq, PartialEq)] #[serde(deny_unknown_fields)] struct Effect { @@ -213,17 +142,17 @@ pub(in crate::workspace) async fn abort( ) -> Result<StockAbortOutcome, OperationError> { let auth = Box::pin(signing_plan::load( turn, - &request.binding, - request.minimum, - request.operation, - request.digest, + request.binding(), + request.minimum_checkpoint(), + request.operation_id(), + request.command_digest(), &proof, )) .await?; if auth.access.authority.catalog != 13 { return Err(OperationError::UnsupportedOperation); } - let (old, identity) = Box::pin(existing(turn, &auth.access, request.operation)).await?; + let (old, identity) = Box::pin(existing(turn, &auth.access, request.operation_id())).await?; if let Some(old) = old { Box::pin(confirm_read(turn, &auth, &identity, Some(&old), &proof)).await?; return Ok(StockAbortOutcome::Aborted(Box::new(old.receipt))); @@ -247,14 +176,19 @@ pub(in crate::workspace) async fn abort( )) .await?; if current.witness.expected.is_none_or(|value| { - value.phase != order_state::Phase::Prepared || value.operation != request.operation + value.phase != order_state::Phase::Prepared || value.operation != request.operation_id() }) { return Err(OperationError::StaleState); } let mut claims = Vec::with_capacity(2); for recipient in auth.original.receipt.rumor().recipients() { - let (claim, witness) = - Box::pin(claim::existing(turn, &auth, request.operation, *recipient)).await?; + let (claim, witness) = Box::pin(claim::existing( + turn, + &auth, + request.operation_id(), + *recipient, + )) + .await?; if claim.is_some() { return Err(OperationError::RecoveryRequired); } @@ -263,7 +197,7 @@ pub(in crate::workspace) async fn abort( no_claims( turn.connection, turn.selected.participant(), - request.operation, + request.operation_id(), ) .await?; let backing = Box::pin(super::backing::read( @@ -303,7 +237,7 @@ pub(in crate::workspace) async fn abort( .map_err(|_| WorkspaceError::Capacity)?; let body = Body { version: 1, - operation: request.operation, + operation: request.operation_id(), original_head: auth.original.frame.header.head, plan: auth.plan.as_ref().map(|plan| Plan { entry: plan.frame.header.operation, @@ -329,14 +263,14 @@ pub(in crate::workspace) async fn abort( namespace: SellerAuthoritySelection::from_attachment(turn.selected), actor: auth.access.current.actor(), operation: entry, - digest: request.digest, + digest: request.command_digest(), transaction, revision, previous: before.head, head: CheckpointDigest::from_bytes([0; 32]), pool: None, order: Some(auth.original.receipt.order_id()), - related_operation: Some(request.operation), + related_operation: Some(request.operation_id()), subject_grant: None, bytes: 0, parts: 0, @@ -372,8 +306,8 @@ pub(in crate::workspace) async fn abort( &encode(&codec::Movement { version: 1, operation: entry, - digest: request.digest, - original: request.operation, + digest: request.command_digest(), + original: request.operation_id(), effect: *effect, })?, ) @@ -398,7 +332,7 @@ pub(in crate::workspace) async fn abort( .crypto .seal_stock_root(turn.selected, next.catalog, &next.encode()?) .await?; - let anchor = receipt.attempt; + let anchor = receipt.attempt(); let mut tx = turn .connection .begin_with("BEGIN IMMEDIATE") @@ -407,7 +341,7 @@ pub(in crate::workspace) async fn abort( let changed:Result<(),OperationError>=async { Box::pin(identity.confirm(&mut tx)).await?; for claim in &claims {Box::pin(claim.confirm(&mut tx)).await?;} - no_claims(&mut tx,turn.selected.participant(),request.operation).await?; + no_claims(&mut tx,turn.selected.participant(),request.operation_id()).await?; let checked=Box::pin(auth.confirm(&mut tx,turn.namespace,turn.clock,&proof,false)).await?; if checked.observed_at()<at {return Err(WorkspaceError::Unavailable.into());} for pool in &backing {Box::pin(pool.confirm(&mut tx)).await?;} @@ -448,17 +382,17 @@ pub(in crate::workspace) async fn read( ) -> Result<Option<StockAbortReceipt>, OperationError> { let auth = Box::pin(signing_plan::load( turn, - &request.binding, - request.minimum, - request.operation, - request.digest, + request.binding(), + request.minimum_checkpoint(), + request.operation_id(), + request.command_digest(), &proof, )) .await?; if auth.access.authority.catalog != 13 { return Err(OperationError::UnsupportedOperation); } - let (old, identity) = Box::pin(existing(turn, &auth.access, request.operation)).await?; + let (old, identity) = Box::pin(existing(turn, &auth.access, request.operation_id())).await?; Box::pin(confirm_read(turn, &auth, &identity, old.as_ref(), &proof)).await?; Ok(old.map(|value| value.receipt)) } diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/abort/codec.rs b/crates/storage_sqlite/src/workspace/stock/inventory/abort/codec.rs @@ -52,23 +52,24 @@ pub(super) fn receipt( header: &ledger::Header, body: &Body, ) -> Result<StockAbortReceipt, OperationError> { - Ok(StockAbortReceipt { - attempt: CommitAttempt::new( + StockAbortReceipt::from_committed_store( + input, + CommitAttempt::new( input.workspace_id(), body.operation, header.digest, Some(header.transaction), ), - order: header.order.ok_or(OperationError::RecoveryRequired)?, - at: body.aborted_at, - checkpoint: radroots_storage::inventory::InventoryCheckpointRef::from_host_metadata( + header.order.ok_or(OperationError::RecoveryRequired)?, + body.aborted_at, + radroots_storage::inventory::InventoryCheckpointRef::from_host_metadata( input.authority(), header.revision, Some(header.head), )? .with_authorization(body.authorization), - pools: body.effects.iter().map(|effect| effect.after).collect(), - }) + body.effects.iter().map(|effect| effect.after).collect(), + ) } async fn plan_selector( connection: &mut SqliteConnection, @@ -299,7 +300,7 @@ impl Retained { header: self.frame.header, protected: self.frame.protected, parts_witness: self.frame.parts_witness, - pools: self.receipt.pools, + pools: self.receipt.into_released_pools(), mapping: None, movements: self.movements, } diff --git a/crates/storage_sqlite/src/workspace/stock/inventory/acceptance.rs b/crates/storage_sqlite/src/workspace/stock/inventory/acceptance.rs @@ -109,7 +109,7 @@ impl std::fmt::Debug for StockAcceptanceReceipt { #[derive(Debug)] pub enum StockAcceptanceOutcome { Prepared(Box<StockAcceptanceReceipt>), - Aborted(Box<super::abort::StockAbortReceipt>), + Aborted(Box<radroots_storage::inventory::StockAbortReceipt>), Unknown(CommitAttempt), } diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/abort_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/abort_tests.rs @@ -5,7 +5,9 @@ use super::super::super::super::super::{ consent as acceptance_consent, inspect_named, request as acceptance_request, }; use super::*; -use crate::workspace::{StockAbortOutcome, StockAbortReceipt, StockAbortRequest}; +use radroots_storage::inventory::{ + InventoryStore, StockAbortOutcome, StockAbortReceipt, StockAbortRequest, +}; #[path = "abort_failures_tests.rs"] mod failures; @@ -21,8 +23,14 @@ pub(super) async fn abort( r: &Rig, receipt: &StockAcceptanceReceipt, ) -> Result<StockAbortOutcome, OperationError> { - r.store - .abort_proven_unissued(abort_request(r, receipt).await, r.enrollment.proof()) + let store: &dyn InventoryStore = &r.store; + store + .abort_proven_unissued( + abort_request(r, receipt).await, + r.enrollment + .proof() + .with_secret(|bytes| AttachmentProof::from_protected_input(bytes))?, + ) .await } pub(super) fn released(value: StockAbortOutcome) -> StockAbortReceipt { @@ -41,6 +49,19 @@ async fn unclaimed_preparation_aborts_before_or_after_t1_and_originals_survive_n } let before = inventory_minimum(&r).await; let first = released(abort(&r, &receipt).await.unwrap()); + let shared: &dyn InventoryStore = &r.store; + let retained = shared + .stock_preparation_abort( + abort_request(&r, &receipt).await, + r.enrollment + .proof() + .with_secret(|bytes| AttachmentProof::from_protected_input(bytes)) + .unwrap(), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(retained.attempt(), first.attempt()); assert_eq!( first.attempt().operation_id(), receipt.attempt().operation_id() diff --git a/crates/storage_sqlite/src/workspace/stock/public_source/process_death_tests.rs b/crates/storage_sqlite/src/workspace/stock/public_source/process_death_tests.rs @@ -196,7 +196,7 @@ async fn stock_process_child() { aborts::released( store .abort_proven_unissued( - crate::workspace::StockAbortRequest::new( + radroots_storage::inventory::StockAbortRequest::new( binding, minimum, control.operation, diff --git a/crates/storage_sqlite/tests/support/stock_abort_port.rs b/crates/storage_sqlite/tests/support/stock_abort_port.rs @@ -0,0 +1,45 @@ +use super::*; +use radroots_domain::{CommandDigest, OperationId, Sequence}; +use radroots_storage::command::OperationError; +use radroots_storage::inventory::{InventoryCheckpointRef, InventoryStore, StockAbortRequest}; + +#[tokio::test] +async fn shared_abort_port_never_upgrades_an_ordinary_outbox_or_fabricates_cleanup() { + let f = Fixture::new(); + let (store, input, proof) = f.create().await; + let binding = store.authenticate(input.clone(), &proof).await.unwrap(); + let minimum = InventoryCheckpointRef::from_host_metadata( + input.authority(), + Sequence::new(0).unwrap(), + None, + ) + .unwrap(); + let selected = || { + StockAbortRequest::new( + binding.clone(), + minimum, + OperationId::from_bytes([80; 32]), + CommandDigest::from_bytes([81; 32]), + ) + }; + let copy = || { + proof + .with_secret(|bytes| AttachmentProof::from_protected_input(bytes)) + .unwrap() + }; + let port: &dyn InventoryStore = &store; + for error in [ + port.abort_proven_unissued(selected(), copy()) + .await + .unwrap_err(), + port.stock_preparation_abort(selected(), copy()) + .await + .unwrap_err(), + ] { + assert_eq!(error, OperationError::UnsupportedOperation); + assert_eq!(error.code(), "capability_unavailable"); + } + assert!(!f.path.join("stock_execution_v1.sqlite").exists()); + store.authenticate(input, &proof).await.unwrap(); + store.close().await.unwrap(); +} diff --git a/crates/storage_sqlite/tests/workspace_attachment.rs b/crates/storage_sqlite/tests/workspace_attachment.rs @@ -540,6 +540,8 @@ async fn unsafe_links_permissions_and_schema_are_refused_without_repair() { )); } +#[path = "support/stock_abort_port.rs"] +mod stock_abort_port; #[path = "support/stock_authority.rs"] mod stock_authority; diff --git a/tools/xtask/src/architecture/decision_package.rs b/tools/xtask/src/architecture/decision_package.rs @@ -217,6 +217,10 @@ struct AcceptancePreparation { #[derive(Deserialize)] #[serde(deny_unknown_fields)] struct PreparationAbort { + shared_storage_port: String, + shared_model_owner: String, + native_workspace_type_aliases: bool, + unsupported_hosts_return: String, payload_version: u32, journal_family: u32, worker_charge_bytes: u32, @@ -575,6 +579,11 @@ fn validate_bytes(raw: &[u8]) -> Result<(), String> { && stock.preparation_abort.payload_version == 1 && stock.preparation_abort.journal_family == 7 && stock.preparation_abort.worker_charge_bytes == 1048576 + && stock.preparation_abort.shared_storage_port + == "radroots_storage.inventory.InventoryStore" + && stock.preparation_abort.shared_model_owner == "radroots_storage.inventory" + && !stock.preparation_abort.native_workspace_type_aliases + && stock.preparation_abort.unsupported_hosts_return == "capability_unavailable" && stock.preparation_abort.all_recipient_claims_must_be_absent && !stock .preparation_abort @@ -1311,6 +1320,10 @@ mod tests { #[test] fn abort_requires_protected_absence_exact_original_release_and_retained_preparations() { for (field, bad) in [ + ("shared_storage_port", json!("native_only")), + ("shared_model_owner", json!("radroots_storage_sqlite")), + ("native_workspace_type_aliases", json!(true)), + ("unsupported_hosts_return", json!("aborted")), ("payload_version", json!(2)), ("journal_family", json!(6)), ("worker_charge_bytes", json!(1048577)),