use crate::cpn::mcard_token::{PlaceMCard, TokenMCard, TransitionMCard};
use crate::cpn::place_type_lattice::{PlaceRole, PlaceTypeBinding, PlaceTypeLattice};
use crate::cpn::token_namespace::{MCardMarking, MCardTokenNamespace};
use crate::layer2::vfs::MCardFileSystem;
use crate::layer1::fractal_net_harness::{register_place_specs, PlaceSpec};
pub struct StoragePetriNet {
pub fs: MCardFileSystem,
pub namespace: MCardTokenNamespace,
pub lattice: PlaceTypeLattice,
}
impl Default for StoragePetriNet {
fn default() -> Self {
Self::new()
}
}
impl StoragePetriNet {
pub fn new() -> Self {
let fs = MCardFileSystem::new_in_memory().expect("in-memory fs");
let mut namespace = MCardTokenNamespace::new("storage_net");
let specs = [
PlaceSpec::new("p_raw_bytes", crate::layer0::vocabulary_types::TYPE_URI_CLM_TYPE_STORAGE_RAW_BYTES, PlaceRole::InitialBottom),
PlaceSpec::new("p_staged_card", crate::layer0::vocabulary_types::TYPE_URI_CLM_TYPE_STORAGE_VERIFIED_MCARD, PlaceRole::Intermediate),
PlaceSpec::new("p_directory_manifest", crate::layer0::vocabulary_types::TYPE_URI_CLM_TYPE_STORAGE_DIRECTORY_MANIFEST, PlaceRole::TerminalTop),
PlaceSpec::new("p_handle_history", crate::layer0::vocabulary_types::TYPE_URI_CLM_TYPE_STORAGE_HANDLE_HISTORY, PlaceRole::Intermediate),
PlaceSpec::new("p_storage_exception", crate::layer0::vocabulary_types::TYPE_URI_CLM_TYPE_STORAGE_EXCEPTION_TRAP, PlaceRole::Exception),
];
let places = register_place_specs(&mut namespace, &specs).expect("valid storage places");
let lattice = PlaceTypeLattice::from_net(&places, &[], None);
Self {
fs,
namespace,
lattice,
}
}
pub fn create_typed_directory_place(
&mut self,
place_id: &str,
allowed_type_uri: &str,
) -> Result<PlaceMCard, String> {
let place = PlaceMCard::create(
place_id,
allowed_type_uri,
None,
"Intermediate",
Some(crate::layer0::vocabulary::HASH_ALGORITHM_BLAKE3),
None,
)?;
let binding = PlaceTypeBinding::new(
place.clone(),
PlaceRole::Intermediate,
Some(allowed_type_uri.to_string()),
None,
);
self.namespace.register_place(place.clone(), Some(binding));
Ok(place)
}
pub fn deposit_into_directory_place(
&self,
marking: &MCardMarking,
place_id: &str,
token: &TokenMCard,
) -> Result<MCardMarking, String> {
let Some(place) = self.namespace.places.get(place_id) else {
return Err(format!("Directory Place '{place_id}' not found"));
};
if !place.admits(token, marking.count(place_id)) {
return Err(format!(
"Directory PlaceMCard '{place_id}' rejected TokenMCard with color_type='{}'",
token.color_type
));
}
let mut next = marking.clone();
next.append(place_id, token.qualified_hash());
Ok(next)
}
pub fn put_file_transition(
&mut self,
marking: &MCardMarking,
uri: &str,
raw_bytes: &[u8],
) -> Result<(MCardMarking, TokenMCard), String> {
let payload = serde_json::json!({
"content_hex": hex::encode(raw_bytes),
"size": raw_bytes.len(),
});
let in_tok = TokenMCard::from_payload(
payload,
crate::layer0::vocabulary_types::TYPE_URI_CLM_TYPE_STORAGE_RAW_BYTES,
"tok_raw",
Some(crate::layer0::vocabulary::HASH_ALGORITHM_BLAKE3),
None,
)?;
let mut next = marking.clone();
next.append("p_raw_bytes", in_tok.qualified_hash());
let trans = TransitionMCard::create(
&format!("t_put_file:{uri}"),
vec!["p_raw_bytes".to_string()],
vec!["p_staged_card".to_string()],
crate::layer0::vocabulary_types::TYPE_URI_CLM_TYPE_STORAGE_RAW_BYTES,
crate::layer0::vocabulary_types::TYPE_URI_CLM_TYPE_STORAGE_VERIFIED_MCARD,
None,
&format!("put_file({uri})"),
Some(crate::layer0::vocabulary::HASH_ALGORITHM_BLAKE3),
None,
)?;
self.namespace.register_transition(trans);
let rec = self.fs.write_raw_bytes(uri, raw_bytes, Some(crate::layer0::vocabulary::HASH_ALGORITHM_BLAKE3)).map_err(|e| e.to_string())?;
let out_tok = TokenMCard::from_payload(
serde_json::json!({ "uri": uri, "bytes_written": raw_bytes.len(), "record_ref": crate::cpn::mcard_token::qualified_record_hash(&rec)? }),
crate::layer0::vocabulary_types::TYPE_URI_CLM_TYPE_STORAGE_VERIFIED_MCARD,
&format!("tok:verified:{uri}"),
Some(crate::layer0::vocabulary::HASH_ALGORITHM_BLAKE3), None,
)?;
let mut final_marking = next.clone();
final_marking.append("p_staged_card", out_tok.qualified_hash());
Ok((final_marking, out_tok))
}
}