From 57992cf214e8a5f9de53a40dba9aaa7fab038c91 Mon Sep 17 00:00:00 2001 From: Nilton Constantino Date: Fri, 23 Oct 2026 09:53:11 +0100 Subject: [PATCH] feat(vm): publish typed fields across multiple structs atomically Add schema-driven FIELDS_PUBLISH without collection-specific runtime behavior. Validate every nullable destination and complete field group before allocation-free publication, with neutral ownership, malformed-input and quota coverage. --- .../prometeu-bytecode/src/assembler.rs | 5 +- .../prometeu-bytecode/src/disassembler.rs | 5 +- .../console/prometeu-bytecode/src/opcode.rs | 5 +- .../prometeu-bytecode/src/opcode_spec.rs | 6 +- .../src/registry_instruction.rs | 30 +++- .../prometeu-vm/src/registry_verifier.rs | 11 ++ .../src/registry_verifier/types.rs | 21 +++ .../prometeu-vm/src/virtual_machine.rs | 3 + .../virtual_machine/storage_publication.rs | 104 ++++++++++++ .../storage_publication_tests.rs | 154 ++++++++++++++++++ docs/specs/runtime/02-vm-instruction-set.md | 34 ++++ docs/vm-arch/ARCHITECTURE.md | 9 + docs/vm-arch/ISA_CORE.md | 9 + 13 files changed, 384 insertions(+), 12 deletions(-) diff --git a/crates/console/prometeu-bytecode/src/assembler.rs b/crates/console/prometeu-bytecode/src/assembler.rs index ec72e5c..d39bd10 100644 --- a/crates/console/prometeu-bytecode/src/assembler.rs +++ b/crates/console/prometeu-bytecode/src/assembler.rs @@ -179,7 +179,7 @@ pub fn assemble(src: &str) -> Result, AsmError> { emit_u16(CoreOpCode::Ret as u16, &mut out); } "YIELD" | "SLEEP" | "SPAWN" => { - return Err(AsmError::InvalidOperand("retired coroutine instruction".into())) + return Err(AsmError::InvalidOperand("retired coroutine instruction".into())); } "FRAME_SYNC" => { emit_u16(CoreOpCode::FrameSync as u16, &mut out); @@ -362,11 +362,12 @@ pub fn assemble(src: &str) -> Result, AsmError> { emit_u32(field, &mut out); } "STRUCT_NEW" | "ARRAY_NEW" | "ARRAY_LEN" | "ARRAY_GET" | "ARRAY_SET" - | "ARRAY_CHECK_LENGTH" | "ARRAY_COPY" => { + | "ARRAY_CHECK_LENGTH" | "ARRAY_COPY" | "FIELDS_PUBLISH" => { if ops.is_empty() { return Err(AsmError::MissingOperand(line.into())); } let op = match mn { + "FIELDS_PUBLISH" => CoreOpCode::FieldsPublish, "STRUCT_NEW" => CoreOpCode::StructNew, "ARRAY_NEW" => CoreOpCode::ArrayNew, "ARRAY_LEN" => CoreOpCode::ArrayLen, diff --git a/crates/console/prometeu-bytecode/src/disassembler.rs b/crates/console/prometeu-bytecode/src/disassembler.rs index 888234a..8d55d6f 100644 --- a/crates/console/prometeu-bytecode/src/disassembler.rs +++ b/crates/console/prometeu-bytecode/src/disassembler.rs @@ -21,9 +21,9 @@ //! - Floats use exact bit-pattern format to prevent locale/rounding differences. //! - Ordering is the canonical decode order; no address prefixes are emitted. +use crate::DecodeError; use crate::decode_next; use crate::isa::core::{CoreOpCode, CoreOpCodeSpecExt}; -use crate::DecodeError; fn fmt_f64_bits(bits: u64) -> String { // Fixed-width 16 hex digits, lowercase. @@ -72,7 +72,8 @@ fn format_operand(op: CoreOpCode, imm: &[u8]) -> String { | CoreOpCode::ArrayGet | CoreOpCode::ArraySet | CoreOpCode::ArrayCheckLength - | CoreOpCode::ArrayCopy => { + | CoreOpCode::ArrayCopy + | CoreOpCode::FieldsPublish => { let v = u32::from_le_bytes(imm.try_into().unwrap()); format!("{}", v) } diff --git a/crates/console/prometeu-bytecode/src/opcode.rs b/crates/console/prometeu-bytecode/src/opcode.rs index 8ca9cc5..b9d379e 100644 --- a/crates/console/prometeu-bytecode/src/opcode.rs +++ b/crates/console/prometeu-bytecode/src/opcode.rs @@ -210,6 +210,8 @@ pub enum OpCode { /// Move/fill array ranges and two selected Struct fields in one attempt. /// Array TypeId, Struct TypeId, first field, second field (four u32). StoragePublish = 0xAA, + /// Atomic full-field writes to schema-selected nullable Struct destinations. + FieldsPublish = 0xAB, } impl TryFrom for OpCode { @@ -287,6 +289,7 @@ impl TryFrom for OpCode { 0xA8 => Ok(OpCode::ArrayCheckLength), 0xA9 => Ok(OpCode::ArrayCopy), 0xAA => Ok(OpCode::StoragePublish), + 0xAB => Ok(OpCode::FieldsPublish), _ => Err(format!("Invalid OpCode: 0x{:04X}", value)), } @@ -366,7 +369,7 @@ impl OpCode { OpCode::ArraySet => 4, OpCode::IndexGuard | OpCode::ArrayCheckLength => 2, OpCode::ArrayCopy => 4, - OpCode::StoragePublish => 6, + OpCode::StoragePublish | OpCode::FieldsPublish => 6, } } } diff --git a/crates/console/prometeu-bytecode/src/opcode_spec.rs b/crates/console/prometeu-bytecode/src/opcode_spec.rs index e9807a7..2e6132c 100644 --- a/crates/console/prometeu-bytecode/src/opcode_spec.rs +++ b/crates/console/prometeu-bytecode/src/opcode_spec.rs @@ -676,10 +676,14 @@ impl OpCodeSpecExt for OpCode { may_trap: true, is_safepoint: false, }, - OpCode::ArrayCheckLength | OpCode::ArrayCopy | OpCode::StoragePublish => OpcodeSpec { + OpCode::ArrayCheckLength + | OpCode::ArrayCopy + | OpCode::StoragePublish + | OpCode::FieldsPublish => OpcodeSpec { name: match self { OpCode::ArrayCheckLength => "ARRAY_CHECK_LENGTH", OpCode::ArrayCopy => "ARRAY_COPY", + OpCode::FieldsPublish => "FIELDS_PUBLISH", _ => "STORAGE_PUBLISH", }, imm_bytes: if *self == OpCode::StoragePublish { 16 } else { 4 }, diff --git a/crates/console/prometeu-bytecode/src/registry_instruction.rs b/crates/console/prometeu-bytecode/src/registry_instruction.rs index 3374c83..51c6223 100644 --- a/crates/console/prometeu-bytecode/src/registry_instruction.rs +++ b/crates/console/prometeu-bytecode/src/registry_instruction.rs @@ -86,7 +86,7 @@ impl DecodedInstr<'_> { ) } Op::GetCapture => { - return Err(LoadFailure::new(LoadCode::InvalidReference, LoadReason::CaptureIndex)) + return Err(LoadFailure::new(LoadCode::InvalidReference, LoadReason::CaptureIndex)); } Op::CallTrait => { let (ty, method) = self.imm_u32x2().map_err(|_| malformed())?; @@ -133,6 +133,28 @@ impl DecodedInstr<'_> { }; (source_layout.storage.slots, pushes) } + Op::FieldsPublish => { + let schema = self.imm_u32().map_err(|_| malformed())?; + let (decl, _) = type_info(schema)?; + let TypeKind::Struct(entries) = &decl.kind else { + return Err(bad_category(schema)); + }; + let mut slots = 0u32; + for entry in entries { + let (owner, layout) = type_info(entry.type_id.0)?; + if !matches!(owner.kind, TypeKind::Struct(_)) { + return Err(bad_category(entry.type_id.0)); + } + let fields = + u32::try_from(layout.instance.as_ref().unwrap().initialization_slots) + .map_err(|_| malformed())?; + slots = slots + .checked_add(1) + .and_then(|n| n.checked_add(fields)) + .ok_or_else(malformed)?; + } + (slots, 0) + } Op::ArrayCheckLength | Op::ArrayCopy | Op::StoragePublish => { let (array, owner, first, second) = if self.opcode == Op::StoragePublish { let [a, o, f, s] = self.imm_u32x4().map_err(|_| malformed())?; @@ -188,11 +210,7 @@ impl DecodedInstr<'_> { .get(field as usize) .ok_or_else(|| bad_category(id).member(field))?; let w = registry.type_layout(f.type_id).unwrap().storage.slots; - if op == Op::StructGet { - (1, w) - } else { - (1 + w, 0) - } + if op == Op::StructGet { (1, w) } else { (1 + w, 0) } } } } else { diff --git a/crates/console/prometeu-vm/src/registry_verifier.rs b/crates/console/prometeu-vm/src/registry_verifier.rs index 5531874..d6a0943 100644 --- a/crates/console/prometeu-vm/src/registry_verifier.rs +++ b/crates/console/prometeu-vm/src/registry_verifier.rs @@ -87,6 +87,17 @@ fn validate_inner( }, )?; } + if instruction.opcode == Op::FieldsPublish { + if let Some(declaration) = + registry.declarations().types.get(instruction.imm_u32().unwrap() as usize) + { + if let prometeu_bytecode::registry::TypeKind::Struct(entries) = + &declaration.kind + { + budget.work(entries.len())?; + } + } + } instruction .registry_stack_effect_in(registry, FunctionId(function_id)) .map_err(|e| contextual(e, start + pc))?; diff --git a/crates/console/prometeu-vm/src/registry_verifier/types.rs b/crates/console/prometeu-vm/src/registry_verifier/types.rs index 0691657..9e95025 100644 --- a/crates/console/prometeu-vm/src/registry_verifier/types.rs +++ b/crates/console/prometeu-vm/src/registry_verifier/types.rs @@ -709,6 +709,27 @@ fn check( require(working[end - 2], I64, 0, registry, budget)?; require(working[end - 1], I64, 1, registry, budget)?; } + Op::FieldsPublish => { + let schema = TypeId(instruction.imm_u32().unwrap()); + let effect = instruction.registry_stack_effect(registry)?.unwrap(); + let mut at = end - effect.pops as usize; + let TypeKind::Struct(entries) = ®istry.declarations().types[schema.0 as usize].kind + else { + unreachable!() + }; + for entry in entries { + budget.work(1)?; + check_group(&working[at..], entry.type_id, registry, budget)?; + at += 1; + for field in + ®istry.type_layout(entry.type_id).unwrap().instance.as_ref().unwrap().fields + { + budget.work(1)?; + check_group(&working[at..], field.type_id, registry, budget)?; + at += registry.type_layout(field.type_id).unwrap().storage.slots as usize; + } + } + } Op::ArrayCopy | Op::StoragePublish => { let [a, o, f, s] = if instruction.opcode == Op::StoragePublish { instruction.imm_u32x4().unwrap() diff --git a/crates/console/prometeu-vm/src/virtual_machine.rs b/crates/console/prometeu-vm/src/virtual_machine.rs index 7e38d9f..addf494 100644 --- a/crates/console/prometeu-vm/src/virtual_machine.rs +++ b/crates/console/prometeu-vm/src/virtual_machine.rs @@ -1086,6 +1086,9 @@ impl VirtualMachine { let (source, target) = instr.imm_u32x2().unwrap(); return self.execute_reference(opcode, source, target, start_pc as u32); } + OpCode::FieldsPublish => { + return self.execute_fields_publication(instr.imm_u32().unwrap(), start_pc as u32); + } OpCode::IndexGuard | OpCode::ArrayCheckLength | OpCode::ArrayCopy diff --git a/crates/console/prometeu-vm/src/virtual_machine/storage_publication.rs b/crates/console/prometeu-vm/src/virtual_machine/storage_publication.rs index 3941529..0abf28e 100644 --- a/crates/console/prometeu-vm/src/virtual_machine/storage_publication.rs +++ b/crates/console/prometeu-vm/src/virtual_machine/storage_publication.rs @@ -180,3 +180,107 @@ impl VirtualMachine { Ok(()) } } + +impl VirtualMachine { + /// A Struct schema lists destination Struct types, without allocating a request. + /// Inputs stay rooted and unconsumed until validation of the entire attempt. + pub(super) fn execute_fields_publication( + &mut self, + schema: u32, + pc: u32, + ) -> Result<(), LogicalFrameEndingReason> { + let opcode = OpCode::FieldsPublish; + self.cycles += opcode.cycles(); + let image = self.validated_image.clone().expect("validated Registry operation"); + let registry = image.registry(); + let prometeu_bytecode::registry::TypeKind::Struct(entries) = + ®istry.declarations().types[schema as usize].kind + else { + unreachable!() + }; + let consumed: usize = entries + .iter() + .map(|entry| { + 1 + registry + .type_layout(entry.type_id) + .unwrap() + .instance + .as_ref() + .unwrap() + .fields + .iter() + .map(|f| registry.type_layout(f.type_id).unwrap().storage.slots as usize) + .sum::() + }) + .sum(); + if self.temporary_slots() < consumed { + return Err(self.trap( + TRAP_STACK_UNDERFLOW, + opcode as u16, + "Incomplete field publication operands".into(), + pc, + )); + } + self.cycles += consumed as u64; + let base = self.operand_stack.len() - consumed; + let mut at = base; + for entry in entries { + match self.operand_stack[at] { + Value::Null => {} + Value::HeapRef(receiver) => { + if self + .heap + .concrete_type(receiver, registry) + .map_err(|e| self.value_trap(e, opcode, pc))? + != entry.type_id + { + return Err(self.value_trap(ValueError::Type, opcode, pc)); + } + } + _ => return Err(self.value_trap(ValueError::Type, opcode, pc)), + } + at += 1; + for field in + ®istry.type_layout(entry.type_id).unwrap().instance.as_ref().unwrap().fields + { + let width = registry.type_layout(field.type_id).unwrap().storage.slots as usize; + value_contract::validate( + registry, + &self.heap, + field.type_id, + &self.operand_stack[at..at + width], + ) + .map_err(|e| self.value_trap(e, opcode, pc))?; + at += width; + } + } + // No allocation, provenance lookup, validation, callback, GC or scheduler + // boundary follows. Repeated destinations use ordered last-write semantics. + at = base; + for entry in entries { + let receiver = match self.operand_stack[at] { + Value::HeapRef(r) => Some(r), + _ => None, + }; + at += 1; + for (index, field) in registry + .type_layout(entry.type_id) + .unwrap() + .instance + .as_ref() + .unwrap() + .fields + .iter() + .enumerate() + { + let width = registry.type_layout(field.type_id).unwrap().storage.slots as usize; + if let Some(receiver) = receiver { + self.heap.commit_typed(receiver, index, &self.operand_stack[at..at + width]); + } + at += width; + } + } + self.operand_stack.truncate(base); + Ok(()) + } +} diff --git a/crates/console/prometeu-vm/src/virtual_machine/storage_publication_tests.rs b/crates/console/prometeu-vm/src/virtual_machine/storage_publication_tests.rs index 2c77fdf..4799a31 100644 --- a/crates/console/prometeu-vm/src/virtual_machine/storage_publication_tests.rs +++ b/crates/console/prometeu-vm/src/virtual_machine/storage_publication_tests.rs @@ -222,3 +222,157 @@ fn dead_invalid_operands_and_split_typed_groups_are_rejected() { support::load(&assemble("PUSH_BOOL 1\nPUSH_I64 3\nINDEX_GUARD\nHALT").unwrap()).is_err() ); } + +fn fields_machine() -> VirtualMachine { + use prometeu_bytecode::registry::{NamedType, TypeDecl, TypeKind}; + let mut code = String::new(); + for i in 0..12 { + code += &format!("GET_GLOBAL {i}\n"); + } + code += "FIELDS_PUBLISH 27\nHALT"; + let code = assemble(&code).unwrap(); + let mut declarations = support::declarations(code.len()); + assert_eq!(declarations.types.len(), 26); + let field = |id| NamedType { type_id: TypeId(id), name: None }; + declarations.types.push(TypeDecl { + name: None, + kind: TypeKind::Struct([0, 5, 4, 9].into_iter().map(field).collect()), + }); + declarations.types.push(TypeDecl { + name: None, + kind: TypeKind::Struct([26, 26].into_iter().map(field).collect()), + }); + let image = crate::ValidatedProgramImage::load( + &support::bytes_with(&code, declarations), + &mut prometeu_bytecode::load_limits::LoadBudget::new(Default::default()), + prometeu_hal::syscalls::caps::NONE, + ) + .unwrap(); + let mut vm = VirtualMachine::from_image(image, RuntimeLimits::default()); + vm.prepare_boot_call().unwrap(); + vm +} + +#[test] +fn fields_publication_is_complete_preserves_native_and_reference_groups_and_needs_no_scratch() { + for alias in [false, true] { + let mut vm = fields_machine(); + let registry = vm.validated_image.as_ref().unwrap().registry().clone(); + let first = vm.heap.allocate_typed_struct(registry.clone(), TypeId(26)).unwrap(); + let second = if alias { + first + } else { + vm.heap.allocate_typed_struct(registry.clone(), TypeId(26)).unwrap() + }; + let payload = vm.heap.allocate_typed_struct(registry.clone(), TypeId(9)).unwrap(); + let text: std::sync::Arc = "owned".into(); + let inputs = [ + Value::HeapRef(first), + Value::Int32(1), + Value::Float(2.), + Value::Float(3.), + Value::String(text.clone()), + Value::HeapRef(payload), + Value::HeapRef(second), + Value::Int32(42), + Value::Float(20.), + Value::Float(22.), + Value::String(text.clone()), + Value::HeapRef(payload), + ]; + operands(&mut vm, &inputs); + for resource in [ + RuntimeResource::GuestBytes, + RuntimeResource::HandleSlots, + RuntimeResource::TemporaryBytes, + RuntimeResource::AuxiliaryBytes, + ] { + vm.budget.test_lower_limit(resource, vm.budget.used(resource)); + } + let count = vm.heap.allocation_count(); + let cycles = vm.cycles; + step(&mut vm).unwrap(); + assert_eq!(vm.cycles - cycles, 18); + assert_eq!(count, vm.heap.allocation_count()); + assert!(vm.operand_stack.is_empty()); + assert_eq!( + vm.heap.load_typed(®istry, first, 0).unwrap().as_slice(), + [Value::Int32(if alias { 42 } else { 1 })] + ); + assert_eq!( + vm.heap.load_typed(®istry, second, 1).unwrap().as_slice(), + [Value::Float(20.), Value::Float(22.)] + ); + let native = vm.heap.load_typed(®istry, first, 2).unwrap(); + let Value::String(stored) = &native.as_slice()[0] else { panic!() }; + assert!(std::sync::Arc::ptr_eq(stored, &text)); + assert_eq!( + vm.heap.load_typed(®istry, first, 3).unwrap().as_slice(), + [Value::HeapRef(payload)] + ); + } +} + +#[test] +fn fields_publication_checks_late_groups_and_skipped_destinations_before_any_write() { + for skipped in [false, true] { + let mut vm = fields_machine(); + let registry = vm.validated_image.as_ref().unwrap().registry().clone(); + let first = vm.heap.allocate_typed_struct(registry.clone(), TypeId(26)).unwrap(); + let second = vm.heap.allocate_typed_struct(registry.clone(), TypeId(26)).unwrap(); + let inputs = [ + Value::HeapRef(first), + Value::Int32(42), + Value::Float(1.), + Value::Float(2.), + Value::Null, + Value::Null, + if skipped { Value::Null } else { Value::HeapRef(second) }, + Value::Int32(7), + Value::Float(3.), + Value::Float(4.), + Value::Boolean(true), + Value::Null, + ]; + operands(&mut vm, &inputs); + fault(step(&mut vm), TRAP_TYPE); + assert_eq!(vm.operand_stack.as_slice(), inputs); + for owner in [first, second] { + assert_eq!( + vm.heap.load_typed(®istry, owner, 0).unwrap().as_slice(), + [Value::Int32(0)] + ); + } + } + let mut vm = fields_machine(); + let registry = vm.validated_image.as_ref().unwrap().registry().clone(); + let first = vm.heap.allocate_typed_struct(registry.clone(), TypeId(26)).unwrap(); + let inputs = [ + Value::HeapRef(first), + Value::Int32(42), + Value::Float(1.), + Value::Float(2.), + Value::Null, + Value::Null, + Value::Null, + Value::Int32(7), + Value::Float(3.), + Value::Float(4.), + Value::Null, + Value::Null, + ]; + operands(&mut vm, &inputs); + step(&mut vm).unwrap(); + assert_eq!(vm.heap.load_typed(®istry, first, 0).unwrap().as_slice(), [Value::Int32(42)]); +} + +#[test] +fn fields_publication_rejects_bad_schemas_dead_operands_and_truncation() { + for text in ["HALT\nFIELDS_PUBLISH 0", "HALT\nFIELDS_PUBLISH 99", "HALT\nFIELDS_PUBLISH 9"] { + assert!(support::load(&assemble(text).unwrap()).is_err(), "{text}"); + } + let bytes = assemble("FIELDS_PUBLISH 26").unwrap(); + for end in 2..bytes.len() { + assert!(prometeu_bytecode::decode_next(0, &bytes[..end]).is_err()); + } +} diff --git a/docs/specs/runtime/02-vm-instruction-set.md b/docs/specs/runtime/02-vm-instruction-set.md index 5b4845f..3a1e260 100644 --- a/docs/specs/runtime/02-vm-instruction-set.md +++ b/docs/specs/runtime/02-vm-instruction-set.md @@ -219,3 +219,37 @@ before mutation. A refused preparation still charges the attempted work. Neither operation is a safepoint. Consumers must prepare any potentially failing return carrier and all call operands before publication; a series of ordinary stores is not a substitute for whole-operation safety. + + +## Atomic publication of multiple Struct instances + +FIELDS_PUBLISH (`0xAB`) has one little-endian u32 schema TypeId immediate. The +schema MUST be a Registry Struct whose ordered field types are all Struct types. +Names are descriptive only. The schema is declarative metadata; no request object, +new Registry category or preparation token is allocated or exposed. + +For each schema entry, the operand stack supplies one nullable destination +reference followed by every destination field's complete typed value group, in +field declaration order. The stack effect is the sum, over entries, of one plus +the destination instance's initialization-slot count; no results are produced. +Null skips that destination, but every supplied field group is still validated. +Non-null destinations require exact concrete Struct identity and a live reference +of the current session/generation. Array, Trait, Fn and builtin schema entries are +invalid, including in unreachable instructions. The full schema and exact stack +height/groups are checked under normal Registry admission/work limits. + +Validate all destinations and value groups before any shared write or operand +consumption. The original operands remain roots throughout preparation. Then write +all fields in schema order, without allocation, fallible validation, callbacks, +GC or scheduler interleaving, and consume the entire input. Input values are +captured before publication; repeated destinations use ordered last-write +semantics. Complete multi-slot/native/reference groups retain identity and normal +ownership. A failed attempt preserves every destination and the operand stack. + +The operation allocates no publication scratch or guest object. Operand/frame and +source value preparation remain normally charged and may fail before publication. +Base cost is 6 cycles. After the stack-height check, precharge one cycle per schema +entry and one per destination field execution slot for the complete declared +attempt, including skipped destinations. Quotas are unchanged. +This is a generic typed storage mechanism; collection algorithms and node topology +remain source-owned, with no collection-specific VM instruction or syscall. diff --git a/docs/vm-arch/ARCHITECTURE.md b/docs/vm-arch/ARCHITECTURE.md index 6e95828..e14fa72 100644 --- a/docs/vm-arch/ARCHITECTURE.md +++ b/docs/vm-arch/ARCHITECTURE.md @@ -202,3 +202,12 @@ The [Program Registry contract](../specs/runtime/02c-program-registry-and-pbx-v0 ## VM-owned random core See the [random contract](../specs/runtime/02e-vm-owned-random-core.md) for Random BuiltinId 0x0016, ObjectKind tag 9, intrinsics 0x4000–0x4003, atomic state mutation, bounded 4+8*N costs and rejection-limit trap 0x00000015. Random is managed by the VM heap and existing GC, without host entropy or PBX changes. + + +## Atomic publication of multiple Struct instances + +FIELDS_PUBLISH (0xAB) atomically publishes complete typed fields to multiple +source-selected Struct destinations. Its schema is an ordinary Registry Struct; +no new category, request object, syscall or safepoint is introduced. Exact nullable +destination rules, stack effects, validation, costs and commit semantics are in the +[canonical instruction contract](../specs/runtime/02-vm-instruction-set.md#atomic-publication-of-multiple-struct-instances). diff --git a/docs/vm-arch/ISA_CORE.md b/docs/vm-arch/ISA_CORE.md index d50b3e4..a2263af 100644 --- a/docs/vm-arch/ISA_CORE.md +++ b/docs/vm-arch/ISA_CORE.md @@ -198,3 +198,12 @@ STORAGE_PUBLISH (0xAA) provide generic logical validation, complete stored-group transfer and prepared atomic publication. Their encoding, typed operands, exact faults, overlap semantics, costs and preflight/commit guarantees are defined by the [canonical instruction contract](../specs/runtime/02-vm-instruction-set.md#logical-guards-and-atomic-storage-publication). No new Registry category, syscall, collection algorithm or safepoint is introduced. + + +## Atomic publication of multiple Struct instances + +FIELDS_PUBLISH (0xAB) atomically publishes complete typed fields to multiple +source-selected Struct destinations. Its schema is an ordinary Registry Struct; +no new category, request object, syscall or safepoint is introduced. Exact nullable +destination rules, stack effects, validation, costs and commit semantics are in the +[canonical instruction contract](../specs/runtime/02-vm-instruction-set.md#atomic-publication-of-multiple-struct-instances).