From 25c5a1510952193097a1fc3600b4bd8fb995cab5 Mon Sep 17 00:00:00 2001 From: James Ross Date: Sat, 23 May 2026 14:26:38 -0700 Subject: [PATCH 1/2] fix(wasm): remove hardcoded stack witness text fixture --- CHANGELOG.md | 9 + crates/warp-core/src/dynamic_binding.rs | 273 +++---- crates/warp-wasm/src/warp_kernel.rs | 719 +----------------- .../fixtures/stack-witness-0001-vectors.json | 88 --- .../stack-witness-0001-jedit-file-history.md | 76 +- 5 files changed, 190 insertions(+), 975 deletions(-) delete mode 100644 crates/warp-wasm/test/fixtures/stack-witness-0001-vectors.json diff --git a/CHANGELOG.md b/CHANGELOG.md index 5b99238c..f0238024 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -528,6 +528,15 @@ Applied, Rejected, Obstructed}` with receipt evidence and typed contract ### Changed +- `warp-wasm` no longer contains the legacy Stack Witness 0001 + `createBuffer`/`replaceRange`/`textWindow` shortcut. QueryView requests now + route through the generic installed contract observer boundary only; without + an installed observer, WASM `observe(...)` returns `UNSUPPORTED_QUERY` + instead of materializing hardcoded text bytes. +- `warp-core` structured binding tests no longer use rope/text-shaped fixture + names. The executable examples now exercise generic authored scopes, heads, + segments, and markers so core test fixtures do not imply built-in editor + semantics. - The canonical pre-push hook now runs the narrowest changed-file Rust witness instead of reusing the broader local PR gate. Rust module edits map to exact `cargo test -p --lib ::tests` slices, integration-test edits diff --git a/crates/warp-core/src/dynamic_binding.rs b/crates/warp-core/src/dynamic_binding.rs index bb687a40..069ef7cd 100644 --- a/crates/warp-core/src/dynamic_binding.rs +++ b/crates/warp-core/src/dynamic_binding.rs @@ -500,18 +500,18 @@ mod tests { binding: BoundNodeRef, worldline_id: String, byte_length: usize, - rope_members: Vec, + segment_members: Vec, } #[derive(Debug, Clone)] - struct MockRopeMember { + struct MockSegmentMember { start: usize, end: usize, binding: ClosureMemberBinding, } #[derive(Debug, Clone)] - struct MockAnchor { + struct MockMarker { basis_head_id: String, start: usize, end: usize, @@ -519,14 +519,14 @@ mod tests { } #[derive(Debug, Clone)] - struct MockTextRuntime { + struct MockStructuredRuntime { worldlines: BTreeMap, heads: BTreeMap, - anchors: Vec, + markers: Vec, } #[derive(Debug, Clone)] - struct ReplaceRangeAsTickBindingRequest { + struct UpdateWindowBindingRequest { worldline_id: String, base_head_id: String, start_byte: usize, @@ -542,7 +542,7 @@ mod tests { start < other_end && other_start < end } - impl StructuredBindingRuntime for MockTextRuntime { + impl StructuredBindingRuntime for MockStructuredRuntime { fn resolve_direct_slot( &self, slot: &str, @@ -550,7 +550,7 @@ mod tests { reference: &str, ) -> Result { match slot { - "worldline" => self + "scope" => self .worldlines .get(reference) .map(|worldline| worldline.binding.clone()) @@ -558,7 +558,7 @@ mod tests { slot: slot.to_owned(), reference: reference.to_owned(), }), - "baseHead" => self + "basisHead" => self .heads .get(reference) .map(|head| head.binding.clone()) @@ -581,7 +581,7 @@ mod tests { source: &BoundNodeRef, _expected_kind: &str, ) -> Result { - if from_slot != "worldline" || relation != "CANONICAL_HEAD" { + if from_slot != "scope" || relation != "CURRENT_HEAD" { return Err(DynamicBindingRuntimeError::MissingRelationTarget { slot: slot.to_owned(), from_slot: from_slot.to_owned(), @@ -624,7 +624,7 @@ mod tests { related: Option<&BoundNodeRef>, ) -> Result, DynamicBindingRuntimeError> { match request.operator { - "ropeRangeClosure" => { + "segmentWindowClosure" => { let base_head = self .heads .values() @@ -652,7 +652,7 @@ mod tests { } Ok(base_head - .rope_members + .segment_members .iter() .filter(|member| { overlap(request.start, request.end, member.start, member.end) @@ -660,7 +660,7 @@ mod tests { .map(|member| member.binding.clone()) .collect()) } - "anchorsIntersectingEditWindow" => { + "markersIntersectingWindow" => { let worldline = self .worldlines .values() @@ -672,7 +672,7 @@ mod tests { let related = related.ok_or_else(|| { DynamicBindingRuntimeError::MissingClosureSource { slot: request.slot.to_owned(), - from_slot: "baseHead".to_owned(), + from_slot: "basisHead".to_owned(), } })?; let base_head = self @@ -692,13 +692,13 @@ mod tests { } Ok(self - .anchors + .markers .iter() - .filter(|anchor| { - anchor.basis_head_id == base_head.id - && overlap(request.start, request.end, anchor.start, anchor.end) + .filter(|marker| { + marker.basis_head_id == base_head.id + && overlap(request.start, request.end, marker.start, marker.end) }) - .map(|anchor| anchor.binding.clone()) + .map(|marker| marker.binding.clone()) .collect()) } _ => Err(DynamicBindingRuntimeError::UnknownClosureOperator { @@ -709,26 +709,26 @@ mod tests { } } - fn bind_replace_range_as_tick( - runtime: &MockTextRuntime, - request: &ReplaceRangeAsTickBindingRequest, + fn bind_update_window( + runtime: &MockStructuredRuntime, + request: &UpdateWindowBindingRequest, ) -> Result { let mut resolver = StructuredBindingResolver::new(runtime); - resolver.bind_direct_slot("worldline", "BufferWorldline", &request.worldline_id)?; - resolver.bind_direct_slot("baseHead", "RopeHead", &request.base_head_id)?; + resolver.bind_direct_slot("scope", "AuthoredScope", &request.worldline_id)?; + resolver.bind_direct_slot("basisHead", "AuthoredHead", &request.base_head_id)?; resolver.bind_range_closure(RangeClosureBindingRequest { - slot: "touchedRope", - from_slot: "baseHead", - operator: "ropeRangeClosure", + slot: "touchedSegments", + from_slot: "basisHead", + operator: "segmentWindowClosure", related_slot: None, start: request.start_byte, end: request.end_byte, })?; resolver.bind_range_closure(RangeClosureBindingRequest { - slot: "affectedAnchors", - from_slot: "worldline", - operator: "anchorsIntersectingEditWindow", - related_slot: Some("baseHead"), + slot: "affectedMarkers", + from_slot: "scope", + operator: "markersIntersectingWindow", + related_slot: Some("basisHead"), start: request.start_byte, end: request.end_byte, })?; @@ -736,66 +736,66 @@ mod tests { } fn bind_create_checkpoint( - runtime: &MockTextRuntime, + runtime: &MockStructuredRuntime, request: &CreateCheckpointBindingRequest, ) -> Result { let mut resolver = StructuredBindingResolver::new(runtime); - resolver.bind_direct_slot("worldline", "BufferWorldline", &request.worldline_id)?; - resolver.bind_relation_slot("currentHead", "RopeHead", "worldline", "CANONICAL_HEAD")?; + resolver.bind_direct_slot("scope", "AuthoredScope", &request.worldline_id)?; + resolver.bind_relation_slot("currentHead", "AuthoredHead", "scope", "CURRENT_HEAD")?; Ok(resolver.into_bindings()) } - fn mock_runtime() -> MockTextRuntime { + fn mock_runtime() -> MockStructuredRuntime { let warp_id = make_warp_id("binding-warp"); - let worldline_id = "wl:buf-1".to_owned(); + let worldline_id = "wl:entity-1".to_owned(); let canonical_head_id = "head:current".to_owned(); let stale_head_id = "head:stale".to_owned(); let worldline = MockWorldline { id: worldline_id.clone(), binding: BoundNodeRef::from_ids( - "BufferWorldline", + "AuthoredScope", warp_id, - make_node_id("buffer-worldline"), + make_node_id("authored-scope"), ), canonical_head_id: Some(canonical_head_id.clone()), }; let current_head = MockHead { id: canonical_head_id.clone(), - binding: BoundNodeRef::from_ids("RopeHead", warp_id, make_node_id("head-current")), + binding: BoundNodeRef::from_ids("AuthoredHead", warp_id, make_node_id("head-current")), worldline_id: worldline_id.clone(), byte_length: 20, - rope_members: vec![ - MockRopeMember { + segment_members: vec![ + MockSegmentMember { start: 0, end: 5, binding: ClosureMemberBinding::new( - "RopeLeaf", + "SegmentLeaf", NodeKey { warp_id, - local_id: make_node_id("leaf-0-5"), + local_id: make_node_id("segment-leaf-0-5"), }, ), }, - MockRopeMember { + MockSegmentMember { start: 5, end: 10, binding: ClosureMemberBinding::new( - "RopeBranch", + "SegmentBranch", NodeKey { warp_id, - local_id: make_node_id("branch-5-10"), + local_id: make_node_id("segment-branch-5-10"), }, ), }, - MockRopeMember { + MockSegmentMember { start: 10, end: 15, binding: ClosureMemberBinding::new( - "TextBlob", + "SegmentBlob", NodeKey { warp_id, - local_id: make_node_id("blob-10-15"), + local_id: make_node_id("segment-blob-10-15"), }, ), }, @@ -803,40 +803,40 @@ mod tests { }; let stale_head = MockHead { id: stale_head_id, - binding: BoundNodeRef::from_ids("RopeHead", warp_id, make_node_id("head-stale")), + binding: BoundNodeRef::from_ids("AuthoredHead", warp_id, make_node_id("head-stale")), worldline_id: "wl:other".to_owned(), byte_length: 8, - rope_members: vec![], + segment_members: vec![], }; - MockTextRuntime { + MockStructuredRuntime { worldlines: BTreeMap::from([(worldline_id, worldline)]), heads: BTreeMap::from([ (canonical_head_id.clone(), current_head), ("head:stale".to_owned(), stale_head), ]), - anchors: vec![ - MockAnchor { + markers: vec![ + MockMarker { basis_head_id: canonical_head_id.clone(), start: 4, end: 7, binding: ClosureMemberBinding::new( - "Anchor", + "Marker", NodeKey { warp_id, - local_id: make_node_id("anchor-overlap"), + local_id: make_node_id("marker-overlap"), }, ), }, - MockAnchor { + MockMarker { basis_head_id: canonical_head_id, start: 15, end: 18, binding: ClosureMemberBinding::new( - "Anchor", + "Marker", NodeKey { warp_id, - local_id: make_node_id("anchor-outside"), + local_id: make_node_id("marker-outside"), }, ), }, @@ -847,25 +847,24 @@ mod tests { #[test] fn structured_runtime_bindings_store_direct_relation_and_closure_bindings() { let warp_id = make_warp_id("binding-warp"); - let worldline = - BoundNodeRef::from_ids("BufferWorldline", warp_id, make_node_id("worldline")); - let base_head = BoundNodeRef::from_ids("RopeHead", warp_id, make_node_id("base-head")); + let worldline = BoundNodeRef::from_ids("AuthoredScope", warp_id, make_node_id("worldline")); + let base_head = BoundNodeRef::from_ids("AuthoredHead", warp_id, make_node_id("base-head")); let branch = ClosureMemberBinding::new( - "RopeBranch", + "SegmentBranch", NodeKey { warp_id, local_id: make_node_id("branch"), }, ); let leaf = ClosureMemberBinding::new( - "RopeLeaf", + "SegmentLeaf", NodeKey { warp_id, local_id: make_node_id("leaf"), }, ); let blob = ClosureMemberBinding::new( - "TextBlob", + "SegmentBlob", NodeKey { warp_id, local_id: make_node_id("blob"), @@ -874,39 +873,39 @@ mod tests { let mut bindings = StructuredRuntimeBindings::new(); bindings - .bind_direct_slot("worldline", worldline.clone()) + .bind_direct_slot("scope", worldline.clone()) .expect("bind direct slot"); bindings - .bind_relation_slot("baseHead", "worldline", "CANONICAL_HEAD", base_head.clone()) + .bind_relation_slot("basisHead", "scope", "CURRENT_HEAD", base_head.clone()) .expect("bind relation slot"); bindings .bind_closure( - "touchedRope", - "baseHead", - "ropeRangeClosure", + "touchedSegments", + "basisHead", + "segmentWindowClosure", vec![branch.clone(), leaf.clone(), blob.clone()], ) .expect("bind closure"); - let worldline_binding = bindings.slot("worldline").expect("worldline slot"); + let worldline_binding = bindings.slot("scope").expect("scope slot"); assert_eq!(worldline_binding.binding(), &worldline); - assert_eq!(worldline_binding.slot(), "worldline"); + assert_eq!(worldline_binding.slot(), "scope"); - let base_head_binding = bindings.slot("baseHead").expect("baseHead slot"); + let base_head_binding = bindings.slot("basisHead").expect("basisHead slot"); assert_eq!(base_head_binding.binding(), &base_head); match base_head_binding { ResolvedSlotBinding::Relation(binding) => { - assert_eq!(binding.from_slot, "worldline"); - assert_eq!(binding.relation, "CANONICAL_HEAD"); + assert_eq!(binding.from_slot, "scope"); + assert_eq!(binding.relation, "CURRENT_HEAD"); } ResolvedSlotBinding::Direct(_) => panic!("expected relation-derived slot"), } let closure = bindings - .closure("touchedRope") - .expect("touchedRope closure"); - assert_eq!(closure.from_slot, "baseHead"); - assert_eq!(closure.operator, "ropeRangeClosure"); + .closure("touchedSegments") + .expect("touchedSegments closure"); + assert_eq!(closure.from_slot, "basisHead"); + assert_eq!(closure.operator, "segmentWindowClosure"); assert_eq!(closure.members, vec![branch, leaf, blob]); } @@ -915,29 +914,29 @@ mod tests { let warp_id = make_warp_id("binding-warp"); let mut bindings = StructuredRuntimeBindings::new(); let original_worldline = - BoundNodeRef::from_ids("BufferWorldline", warp_id, make_node_id("worldline")); + BoundNodeRef::from_ids("AuthoredScope", warp_id, make_node_id("worldline")); bindings - .bind_direct_slot("worldline", original_worldline.clone()) + .bind_direct_slot("scope", original_worldline.clone()) .expect("initial direct slot bind"); assert_eq!( bindings.bind_relation_slot( - "worldline", - "worldline", - "CANONICAL_HEAD", - BoundNodeRef::from_ids("RopeHead", warp_id, make_node_id("head")), + "scope", + "scope", + "CURRENT_HEAD", + BoundNodeRef::from_ids("AuthoredHead", warp_id, make_node_id("head")), ), Err(DynamicBindingError::DuplicateSlot { - slot: "worldline".to_owned(), + slot: "scope".to_owned(), }) ); assert_eq!( - bindings.slot("worldline").unwrap().binding(), + bindings.slot("scope").unwrap().binding(), &original_worldline ); let original_closure = vec![ClosureMemberBinding::new( - "RopeLeaf", + "SegmentLeaf", NodeKey { warp_id, local_id: make_node_id("leaf"), @@ -945,62 +944,64 @@ mod tests { )]; bindings .bind_closure( - "touchedRope", - "worldline", - "ropeRangeClosure", + "touchedSegments", + "scope", + "segmentWindowClosure", original_closure.clone(), ) .expect("initial closure bind"); assert_eq!( - bindings.bind_closure("touchedRope", "worldline", "ropeRangeClosure", vec![]), + bindings.bind_closure("touchedSegments", "scope", "segmentWindowClosure", vec![]), Err(DynamicBindingError::DuplicateClosure { - slot: "touchedRope".to_owned(), + slot: "touchedSegments".to_owned(), }) ); assert_eq!( - bindings.closure("touchedRope").unwrap().members, + bindings.closure("touchedSegments").unwrap().members, original_closure ); } #[test] - fn mock_replace_range_runtime_binds_direct_slots_and_resolves_declared_closures() { + fn mock_runtime_binds_direct_slots_and_resolves_declared_closures() { let runtime = mock_runtime(); - let bindings = bind_replace_range_as_tick( + let bindings = bind_update_window( &runtime, - &ReplaceRangeAsTickBindingRequest { - worldline_id: "wl:buf-1".to_owned(), + &UpdateWindowBindingRequest { + worldline_id: "wl:entity-1".to_owned(), base_head_id: "head:current".to_owned(), start_byte: 4, end_byte: 12, }, ) - .expect("bind replace-range runtime"); + .expect("bind update-window runtime"); - let worldline = bindings.slot("worldline").expect("worldline"); - assert_eq!(worldline.binding().kind, "BufferWorldline"); + let worldline = bindings.slot("scope").expect("scope"); + assert_eq!(worldline.binding().kind, "AuthoredScope"); - let base_head = bindings.slot("baseHead").expect("baseHead"); - assert_eq!(base_head.binding().kind, "RopeHead"); + let base_head = bindings.slot("basisHead").expect("basisHead"); + assert_eq!(base_head.binding().kind, "AuthoredHead"); - let touched_rope = bindings.closure("touchedRope").expect("touchedRope"); - assert_eq!(touched_rope.operator, "ropeRangeClosure"); - assert_eq!(touched_rope.members.len(), 3); + let touched_segments = bindings + .closure("touchedSegments") + .expect("touchedSegments"); + assert_eq!(touched_segments.operator, "segmentWindowClosure"); + assert_eq!(touched_segments.members.len(), 3); assert_eq!( - touched_rope + touched_segments .members .iter() .map(|member| member.kind.as_str()) .collect::>(), - vec!["RopeBranch", "RopeLeaf", "TextBlob"] + vec!["SegmentBlob", "SegmentBranch", "SegmentLeaf"] ); - let affected_anchors = bindings - .closure("affectedAnchors") - .expect("affectedAnchors"); - assert_eq!(affected_anchors.operator, "anchorsIntersectingEditWindow"); - assert_eq!(affected_anchors.members.len(), 1); - assert_eq!(affected_anchors.members[0].kind, "Anchor"); + let affected_markers = bindings + .closure("affectedMarkers") + .expect("affectedMarkers"); + assert_eq!(affected_markers.operator, "markersIntersectingWindow"); + assert_eq!(affected_markers.members.len(), 1); + assert_eq!(affected_markers.members[0].kind, "Marker"); } #[test] @@ -1009,33 +1010,33 @@ mod tests { let bindings = bind_create_checkpoint( &runtime, &CreateCheckpointBindingRequest { - worldline_id: "wl:buf-1".to_owned(), + worldline_id: "wl:entity-1".to_owned(), }, ) .expect("bind checkpoint"); - let worldline = bindings.slot("worldline").expect("worldline"); - assert_eq!(worldline.binding().kind, "BufferWorldline"); + let worldline = bindings.slot("scope").expect("scope"); + assert_eq!(worldline.binding().kind, "AuthoredScope"); let current_head = bindings.slot("currentHead").expect("currentHead"); match current_head { ResolvedSlotBinding::Relation(binding) => { - assert_eq!(binding.from_slot, "worldline"); - assert_eq!(binding.relation, "CANONICAL_HEAD"); - assert_eq!(binding.binding.kind, "RopeHead"); + assert_eq!(binding.from_slot, "scope"); + assert_eq!(binding.relation, "CURRENT_HEAD"); + assert_eq!(binding.binding.kind, "AuthoredHead"); } ResolvedSlotBinding::Direct(_) => panic!("expected relation-derived currentHead"), } } #[test] - fn mock_runtime_reports_invalid_replace_range_bindings() { + fn mock_runtime_reports_invalid_update_window_bindings() { let runtime = mock_runtime(); assert_eq!( - bind_replace_range_as_tick( + bind_update_window( &runtime, - &ReplaceRangeAsTickBindingRequest { + &UpdateWindowBindingRequest { worldline_id: "wl:missing".to_owned(), base_head_id: "head:current".to_owned(), start_byte: 0, @@ -1043,39 +1044,39 @@ mod tests { }, ), Err(DynamicBindingRuntimeError::MissingDirectSlotTarget { - slot: "worldline".to_owned(), + slot: "scope".to_owned(), reference: "wl:missing".to_owned(), }) ); assert_eq!( - bind_replace_range_as_tick( + bind_update_window( &runtime, - &ReplaceRangeAsTickBindingRequest { - worldline_id: "wl:buf-1".to_owned(), + &UpdateWindowBindingRequest { + worldline_id: "wl:entity-1".to_owned(), base_head_id: "head:stale".to_owned(), start_byte: 0, end_byte: 1, }, ), Err(DynamicBindingRuntimeError::BasisHeadMismatch { - worldline: "wl:buf-1".to_owned(), + worldline: "wl:entity-1".to_owned(), head: "head:stale".to_owned(), }) ); assert_eq!( - bind_replace_range_as_tick( + bind_update_window( &runtime, - &ReplaceRangeAsTickBindingRequest { - worldline_id: "wl:buf-1".to_owned(), + &UpdateWindowBindingRequest { + worldline_id: "wl:entity-1".to_owned(), base_head_id: "head:current".to_owned(), start_byte: 12, end_byte: 21, }, ), Err(DynamicBindingRuntimeError::InvalidClosureRange { - slot: "touchedRope".to_owned(), + slot: "touchedSegments".to_owned(), start: 12, end: 21, limit: 20, @@ -1088,7 +1089,7 @@ mod tests { let mut runtime = mock_runtime(); runtime .worldlines - .get_mut("wl:buf-1") + .get_mut("wl:entity-1") .expect("worldline") .canonical_head_id = None; @@ -1096,13 +1097,13 @@ mod tests { bind_create_checkpoint( &runtime, &CreateCheckpointBindingRequest { - worldline_id: "wl:buf-1".to_owned(), + worldline_id: "wl:entity-1".to_owned(), }, ), Err(DynamicBindingRuntimeError::MissingRelationTarget { slot: "currentHead".to_owned(), - from_slot: "worldline".to_owned(), - relation: "CANONICAL_HEAD".to_owned(), + from_slot: "scope".to_owned(), + relation: "CURRENT_HEAD".to_owned(), }) ); } diff --git a/crates/warp-wasm/src/warp_kernel.rs b/crates/warp-wasm/src/warp_kernel.rs index 1cf03630..65bfe5a4 100644 --- a/crates/warp-wasm/src/warp_kernel.rs +++ b/crates/warp-wasm/src/warp_kernel.rs @@ -18,19 +18,15 @@ use echo_wasm_abi::kernel_port::{ HeadEligibility as AbiHeadEligibility, HeadId as AbiHeadId, HeadInfo, KernelPort, NeighborhoodCore as AbiNeighborhoodCore, NeighborhoodSite as AbiNeighborhoodSite, ObservationArtifact as AbiObservationArtifact, ObservationFrame as AbiObservationFrame, - ObservationPayload as AbiObservationPayload, ObservationProjection as AbiObservationProjection, + ObservationProjection as AbiObservationProjection, ObservationReadBudget as AbiObservationReadBudget, ObservationRequest as AbiObservationRequest, ObservationRights as AbiObservationRights, ObserveOpticRequest as AbiObserveOpticRequest, ObserveOpticResult as AbiObserveOpticResult, ObserverInstanceRef as AbiObserverInstanceRef, OpticAperture as AbiOpticAperture, OpticApertureShape as AbiOpticApertureShape, OpticFocus as AbiOpticFocus, ProjectionVersion as AbiProjectionVersion, - ReadingBudgetPosture as AbiReadingBudgetPosture, - ReadingObserverBasis as AbiReadingObserverBasis, ReadingObserverPlan as AbiReadingObserverPlan, - ReadingResidualPosture as AbiReadingResidualPosture, - ReadingRightsPosture as AbiReadingRightsPosture, ReducerVersion as AbiReducerVersion, - RegistryInfo, ResolvedObservationCoordinate as AbiResolvedObservationCoordinate, - RetainedReadingKey as AbiRetainedReadingKey, RunCompletion, RunId as AbiRunId, SchedulerMode, - SchedulerState, SchedulerStatus, SettlementDelta as AbiSettlementDelta, + ReadingObserverPlan as AbiReadingObserverPlan, ReducerVersion as AbiReducerVersion, + RegistryInfo, RetainedReadingKey as AbiRetainedReadingKey, RunCompletion, RunId as AbiRunId, + SchedulerMode, SchedulerState, SchedulerStatus, SettlementDelta as AbiSettlementDelta, SettlementPlan as AbiSettlementPlan, SettlementRequest as AbiSettlementRequest, SettlementResult as AbiSettlementResult, TrustedKernelControlPort, WorkState, WorldlineId as AbiWorldlineId, WorldlineTick as AbiWorldlineTick, @@ -123,63 +119,6 @@ pub struct WarpKernel { next_run_id: RunId, /// Registry metadata (injected at construction, immutable after). registry: RegistryInfo, - stack_witness_create_buffer_admitted_at: Option, - stack_witness_replace_range_admitted_at: Option, -} - -const STACK_WITNESS_CONTRACT_OP_ID_MASK: u32 = 0xffff_0000; -const STACK_WITNESS_CONTRACT_OP_ID_PREFIX: u32 = 0x5357_0000; -const STACK_WITNESS_CREATE_BUFFER_OP_ID: u32 = 0x5357_0001; -const STACK_WITNESS_REPLACE_RANGE_OP_ID: u32 = 0x5357_0002; -const STACK_WITNESS_TEXT_WINDOW_QUERY_ID: u32 = 0x5357_1001; -const STACK_WITNESS_FIXTURE_ARTIFACT_ID: &str = "fixture-file-history-v0"; -#[cfg(test)] -const STACK_WITNESS_FIXTURE_VARS_ENCODING: &str = "utf8-semicolon-kv/v0"; -const STACK_WITNESS_CREATE_BUFFER_VARS: &[u8] = - b"stack-witness-0001/createBuffer;name=demo.txt;artifact=fixture-file-history-v0"; -const STACK_WITNESS_REPLACE_RANGE_VARS: &[u8] = b"stack-witness-0001/replaceRange;bufferId=demo.txt;basis=B0;coord=utf8-bytes;start=0;end=0;text=hello;artifact=fixture-file-history-v0"; -const STACK_WITNESS_TEXT_WINDOW_VARS: &[u8] = b"stack-witness-0001/textWindow;bufferId=demo.txt;basis=B1;coord=utf8-bytes;start=0;length=5;artifact=fixture-file-history-v0"; -const STACK_WITNESS_TEXT_WINDOW_BYTES: &[u8] = b"hello"; - -fn is_stack_witness_contract_op_id(op_id: u32) -> bool { - op_id & STACK_WITNESS_CONTRACT_OP_ID_MASK == STACK_WITNESS_CONTRACT_OP_ID_PREFIX -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -enum FixtureContractOperationKind { - Mutation, -} - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -struct FixtureContractOperation { - op_id: u32, - name: &'static str, - kind: FixtureContractOperationKind, -} - -fn stack_witness_fixture_operation(op_id: u32) -> Option { - match op_id { - STACK_WITNESS_CREATE_BUFFER_OP_ID => Some(FixtureContractOperation { - op_id, - name: "createBuffer", - kind: FixtureContractOperationKind::Mutation, - }), - STACK_WITNESS_REPLACE_RANGE_OP_ID => Some(FixtureContractOperation { - op_id, - name: "replaceRange", - kind: FixtureContractOperationKind::Mutation, - }), - _ => None, - } -} - -fn stack_witness_text_window_artifact_hash() -> Vec { - let mut hasher = blake3::Hasher::new(); - hasher.update(STACK_WITNESS_FIXTURE_ARTIFACT_ID.as_bytes()); - hasher.update(&STACK_WITNESS_TEXT_WINDOW_QUERY_ID.to_le_bytes()); - hasher.update(STACK_WITNESS_TEXT_WINDOW_VARS); - hasher.update(STACK_WITNESS_TEXT_WINDOW_BYTES); - hasher.finalize().as_bytes().to_vec() } impl WarpKernel { @@ -262,8 +201,6 @@ impl WarpKernel { }, next_run_id: RunId::from_raw(1), registry, - stack_witness_create_buffer_admitted_at: None, - stack_witness_replace_range_admitted_at: None, }) } @@ -712,150 +649,6 @@ impl WarpKernel { .map_err(Self::map_observation_error) } - fn observe_stack_witness_fixture( - &self, - request: &AbiObservationRequest, - ) -> Result, AbiError> { - let AbiObservationProjection::Query { - query_id, - vars_bytes, - } = &request.projection - else { - return Ok(None); - }; - if request.frame != AbiObservationFrame::QueryView - || *query_id != STACK_WITNESS_TEXT_WINDOW_QUERY_ID - || vars_bytes.as_slice() != STACK_WITNESS_TEXT_WINDOW_VARS - { - return Ok(None); - } - - if !matches!(request.rights, AbiObservationRights::KernelPublic) { - return Err(AbiError { - code: error_codes::UNSUPPORTED_OBSERVATION_RIGHTS, - message: "Stack Witness 0001 fixture observer requires kernel-public rights".into(), - }); - } - if Self::to_core_worldline_id(&request.coordinate.worldline_id) != self.default_worldline { - return Err(AbiError { - code: error_codes::OBSERVATION_UNAVAILABLE, - message: "Stack Witness 0001 fixture observer requires the default worldline" - .into(), - }); - } - - let head = self.current_head()?; - if !self.stack_witness_fixture_history_is_materialized(&head) { - return Err(AbiError { - code: error_codes::OBSERVATION_UNAVAILABLE, - message: "Stack Witness 0001 textWindow requires admitted createBuffer and replaceRange history".into(), - }); - } - - let payload_bytes = STACK_WITNESS_TEXT_WINDOW_BYTES.len() as u64; - if let AbiObservationReadBudget::Bounded { - max_payload_bytes, .. - } = request.budget - { - if payload_bytes > max_payload_bytes { - return Err(AbiError { - code: error_codes::OBSERVATION_BUDGET_EXCEEDED, - message: format!( - "Stack Witness 0001 textWindow payload requires {payload_bytes} bytes but budget allows {max_payload_bytes}" - ), - }); - } - } - - let budget_posture = match request.budget { - AbiObservationReadBudget::UnboundedOneShot => AbiReadingBudgetPosture::UnboundedOneShot, - AbiObservationReadBudget::Bounded { - max_payload_bytes, - max_witness_refs, - } => AbiReadingBudgetPosture::Bounded { - max_payload_bytes, - payload_bytes, - max_witness_refs, - witness_refs: 0, - }, - }; - - Ok(Some(AbiObservationArtifact { - resolved: AbiResolvedObservationCoordinate { - observation_version: 2, - worldline_id: request.coordinate.worldline_id, - requested_at: request.coordinate.at.clone(), - resolved_worldline_tick: head.worldline_tick, - commit_global_tick: head.commit_global_tick, - observed_after_global_tick: head.commit_global_tick, - state_root: head.state_root, - commit_hash: head.commit_id, - }, - reading: echo_wasm_abi::kernel_port::ReadingEnvelope { - observer_plan: request.observer_plan.clone(), - observer_instance: request.observer_instance.clone(), - observer_basis: AbiReadingObserverBasis::QueryView, - contract: None, - query_identity: None, - witness_refs: Vec::new(), - parent_basis_posture: - echo_wasm_abi::kernel_port::ObservationBasisPosture::Worldline, - budget_posture, - rights_posture: AbiReadingRightsPosture::KernelPublic, - residual_posture: AbiReadingResidualPosture::Complete, - }, - frame: request.frame.clone(), - projection: request.projection.clone(), - artifact_hash: stack_witness_text_window_artifact_hash(), - payload: AbiObservationPayload::QueryBytes { - data: STACK_WITNESS_TEXT_WINDOW_BYTES.to_vec(), - }, - })) - } - - fn stack_witness_fixture_history_is_materialized(&self, head: &HeadInfo) -> bool { - let Some(create_buffer_admitted_at) = self.stack_witness_create_buffer_admitted_at else { - return false; - }; - let Some(replace_range_admitted_at) = self.stack_witness_replace_range_admitted_at else { - return false; - }; - head.worldline_tick.0 > create_buffer_admitted_at.0 - && head.worldline_tick.0 > replace_range_admitted_at.0 - } - - fn validate_stack_witness_fixture_vars(op_id: u32, vars: &[u8]) -> Result<(), AbiError> { - let expected = match op_id { - STACK_WITNESS_CREATE_BUFFER_OP_ID => STACK_WITNESS_CREATE_BUFFER_VARS, - STACK_WITNESS_REPLACE_RANGE_OP_ID => STACK_WITNESS_REPLACE_RANGE_VARS, - _ => return Ok(()), - }; - if vars != expected { - return Err(AbiError { - code: error_codes::INVALID_INTENT, - message: "Stack Witness 0001 fixture vars do not match installed artifact".into(), - }); - } - Ok(()) - } - - fn record_stack_witness_fixture_admission( - &mut self, - op_id: u32, - vars: &[u8], - admitted_at: AbiWorldlineTick, - ) { - match op_id { - STACK_WITNESS_CREATE_BUFFER_OP_ID if vars == STACK_WITNESS_CREATE_BUFFER_VARS => { - self.stack_witness_create_buffer_admitted_at = Some(admitted_at); - } - STACK_WITNESS_REPLACE_RANGE_OP_ID if vars == STACK_WITNESS_REPLACE_RANGE_VARS => { - self.stack_witness_replace_range_admitted_at = Some(admitted_at); - } - _ => {} - } - } - pub(crate) fn current_head(&self) -> Result { let request = ObservationRequest::builtin_one_shot( ObservationCoordinate { @@ -1052,7 +845,7 @@ impl WarpKernel { impl KernelPort for WarpKernel { fn dispatch_intent(&mut self, intent_bytes: &[u8]) -> Result { - let (op_id, vars) = unpack_intent_v1(intent_bytes).map_err(|e| AbiError { + let (op_id, _vars) = unpack_intent_v1(intent_bytes).map_err(|e| AbiError { code: error_codes::INVALID_INTENT, message: format!( "malformed EINT envelope ({} bytes): {e}", @@ -1084,18 +877,6 @@ impl KernelPort for WarpKernel { })?; } - if is_stack_witness_contract_op_id(op_id) - && stack_witness_fixture_operation(op_id).is_none() - { - return Err(AbiError { - code: error_codes::NOT_SUPPORTED, - message: format!( - "contract artifact is not installed for Stack Witness 0001 op id {op_id}" - ), - }); - } - Self::validate_stack_witness_fixture_vars(op_id, vars)?; - let envelope = IngressEnvelope::local_intent( IngressTarget::DefaultWriter { worldline_id: self.default_worldline, @@ -1122,10 +903,6 @@ impl KernelPort for WarpKernel { Some(submission_generation.as_u64()), ), }; - if accepted { - let admitted_at = self.current_head()?.worldline_tick; - self.record_stack_witness_fixture_admission(op_id, vars, admitted_at); - } self.refresh_scheduler_status(); Ok(DispatchResponse { accepted, @@ -1179,9 +956,6 @@ impl KernelPort for WarpKernel { } fn observe(&self, request: AbiObservationRequest) -> Result { - if let Some(artifact) = self.observe_stack_witness_fixture(&request)? { - return Ok(artifact); - } let request = Self::to_core_request(request)?; Ok(self.observe_core(request)?.to_abi()) } @@ -1357,234 +1131,6 @@ mod tests { } } - const STACK_WITNESS_UNKNOWN_OP_ID: u32 = 0x5357_00ff; - const STACK_WITNESS_FIXTURE_FAMILY_ID: &str = "stack-witness-0001.file-history"; - const STACK_WITNESS_FIXTURE_SCHEMA_ID: &str = "stack-witness-0001.file-history.v0"; - const STACK_WITNESS_FIXTURE_VERSION: &str = "0"; - const STACK_WITNESS_TARGET_CODEC: &str = "wesley-binary/v0"; - const STACK_WITNESS_HELPER_MUTATION_FIELDS: &[&str] = &[ - "contract_artifact_id", - "operation_id", - "fixture_vars_bytes", - "declared_footprint", - ]; - const STACK_WITNESS_HELPER_QUERY_FIELDS: &[&str] = &[ - "contract_artifact_id", - "query_id", - "fixture_vars_bytes", - "reading_envelope", - "query_bytes", - ]; - const STACK_WITNESS_FORBIDDEN_FOOTPRINTS: &[&str] = - &["AstState", "Diagnostics", "GitWitness", "UiState"]; - - fn stack_witness_create_buffer_vars() -> Vec { - STACK_WITNESS_CREATE_BUFFER_VARS.to_vec() - } - - fn stack_witness_replace_range_vars() -> Vec { - STACK_WITNESS_REPLACE_RANGE_VARS.to_vec() - } - - fn stack_witness_text_window_vars() -> Vec { - STACK_WITNESS_TEXT_WINDOW_VARS.to_vec() - } - - #[test] - fn stack_witness_fixture_vectors_match_wesley_artifact_shape() { - let vectors = include_str!("../test/fixtures/stack-witness-0001-vectors.json"); - - assert_string_field(vectors, "familyId", STACK_WITNESS_FIXTURE_FAMILY_ID); - assert_string_field(vectors, "schemaId", STACK_WITNESS_FIXTURE_SCHEMA_ID); - assert_string_field(vectors, "artifactId", STACK_WITNESS_FIXTURE_ARTIFACT_ID); - assert_string_field(vectors, "version", STACK_WITNESS_FIXTURE_VERSION); - assert_string_field( - vectors, - "fixtureVarsEncoding", - STACK_WITNESS_FIXTURE_VARS_ENCODING, - ); - assert_string_field(vectors, "targetCodec", STACK_WITNESS_TARGET_CODEC); - - assert_stack_witness_vector( - vectors, - StackWitnessVectorExpectation { - name: "createBuffer", - operation_type: "MUTATION", - op_id: STACK_WITNESS_CREATE_BUFFER_OP_ID, - helper_kind: "EINT", - helper_frame: "EINT", - helper_entrypoint: "dispatch_intent", - fixture_vars: STACK_WITNESS_CREATE_BUFFER_VARS, - footprint_reads: &[], - footprint_writes: &[], - footprint_creates: &["Buffer"], - footprint_forbids: STACK_WITNESS_FORBIDDEN_FOOTPRINTS, - helper_fields: STACK_WITNESS_HELPER_MUTATION_FIELDS, - }, - ); - assert_stack_witness_vector( - vectors, - StackWitnessVectorExpectation { - name: "replaceRange", - operation_type: "MUTATION", - op_id: STACK_WITNESS_REPLACE_RANGE_OP_ID, - helper_kind: "EINT", - helper_frame: "EINT", - helper_entrypoint: "dispatch_intent", - fixture_vars: STACK_WITNESS_REPLACE_RANGE_VARS, - footprint_reads: &["Buffer"], - footprint_writes: &["Buffer"], - footprint_creates: &["Tick", "Receipt"], - footprint_forbids: STACK_WITNESS_FORBIDDEN_FOOTPRINTS, - helper_fields: STACK_WITNESS_HELPER_MUTATION_FIELDS, - }, - ); - assert_stack_witness_vector( - vectors, - StackWitnessVectorExpectation { - name: "textWindow", - operation_type: "QUERY", - op_id: STACK_WITNESS_TEXT_WINDOW_QUERY_ID, - helper_kind: "QueryView", - helper_frame: "QueryView", - helper_entrypoint: "observe", - fixture_vars: STACK_WITNESS_TEXT_WINDOW_VARS, - footprint_reads: &["Buffer", "Tick", "Receipt"], - footprint_writes: &[], - footprint_creates: &[], - footprint_forbids: STACK_WITNESS_FORBIDDEN_FOOTPRINTS, - helper_fields: STACK_WITNESS_HELPER_QUERY_FIELDS, - }, - ); - - let text_window = stack_witness_vector(vectors, "textWindow"); - assert_string_field(text_window, "payloadCodec", "QueryBytes"); - assert_string_field(text_window, "envelope", "ReadingEnvelope"); - assert_string_field( - text_window, - "expectedQueryBytesHex", - &lower_hex(STACK_WITNESS_TEXT_WINDOW_BYTES), - ); - } - - struct StackWitnessVectorExpectation { - name: &'static str, - operation_type: &'static str, - op_id: u32, - helper_kind: &'static str, - helper_frame: &'static str, - helper_entrypoint: &'static str, - fixture_vars: &'static [u8], - footprint_reads: &'static [&'static str], - footprint_writes: &'static [&'static str], - footprint_creates: &'static [&'static str], - footprint_forbids: &'static [&'static str], - helper_fields: &'static [&'static str], - } - - fn assert_stack_witness_vector(vectors: &str, expected: StackWitnessVectorExpectation) { - let vector = stack_witness_vector(vectors, expected.name); - assert_string_field(vector, "operationType", expected.operation_type); - assert_number_field(vector, "opIdDecimal", expected.op_id); - assert_string_field(vector, "opIdHex", &format!("0x{:08x}", expected.op_id)); - assert_string_field(vector, "helperKind", expected.helper_kind); - assert_string_field(vector, "frame", expected.helper_frame); - assert_string_field(vector, "entrypoint", expected.helper_entrypoint); - assert_string_field( - vector, - "fixtureVarsBytes", - std::str::from_utf8(expected.fixture_vars) - .expect("Stack Witness fixture vars should be UTF-8 fixture bytes"), - ); - assert_string_array_field(vector, "reads", expected.footprint_reads); - assert_string_array_field(vector, "writes", expected.footprint_writes); - assert_string_array_field(vector, "creates", expected.footprint_creates); - assert_string_array_field(vector, "forbids", expected.footprint_forbids); - assert_ordered_field_values(vector, "fields", expected.helper_fields); - } - - fn stack_witness_vector<'a>(vectors: &'a str, name: &str) -> &'a str { - let name_pattern = format!(r#""name": "{name}""#); - let start = vectors - .find(&name_pattern) - .expect("Stack Witness operation vector should exist"); - let end = vectors[start..] - .find("\n }") - .expect("Stack Witness operation vector should close"); - &vectors[start..start + end] - } - - fn lower_hex(bytes: &[u8]) -> String { - bytes.iter().map(|byte| format!("{byte:02x}")).collect() - } - - fn assert_string_field(document: &str, field: &str, expected: &str) { - let needle = format!(r#""{field}": "{expected}""#); - assert!( - document.contains(&needle), - "fixture vector should contain string field {field}={expected}" - ); - } - - fn assert_number_field(document: &str, field: &str, expected: u32) { - let needle = format!(r#""{field}": {expected}"#); - assert!( - document.contains(&needle), - "fixture vector should contain numeric field {field}={expected}" - ); - } - - fn assert_string_array_field(document: &str, field: &str, expected: &[&str]) { - let items = expected - .iter() - .map(|item| format!(r#""{item}""#)) - .collect::>() - .join(", "); - let needle = format!(r#""{field}": [{items}]"#); - assert!( - document.contains(&needle), - "fixture vector should contain string array field {field}" - ); - } - - fn assert_ordered_field_values(document: &str, field: &str, expected: &[&str]) { - let field_pattern = format!(r#""{field}": ["#); - let mut cursor = document - .find(&field_pattern) - .expect("fixture vector should contain ordered field list"); - for item in expected { - let item_pattern = format!(r#""{item}""#); - let relative = document[cursor..] - .find(&item_pattern) - .expect("fixture vector field item should appear in order"); - cursor += relative + item_pattern.len(); - } - } - - #[test] - fn stack_witness_fixture_registry_names_mutations() { - assert_eq!( - stack_witness_fixture_operation(STACK_WITNESS_CREATE_BUFFER_OP_ID), - Some(FixtureContractOperation { - op_id: STACK_WITNESS_CREATE_BUFFER_OP_ID, - name: "createBuffer", - kind: FixtureContractOperationKind::Mutation, - }) - ); - assert_eq!( - stack_witness_fixture_operation(STACK_WITNESS_REPLACE_RANGE_OP_ID), - Some(FixtureContractOperation { - op_id: STACK_WITNESS_REPLACE_RANGE_OP_ID, - name: "replaceRange", - kind: FixtureContractOperationKind::Mutation, - }) - ); - assert_eq!( - stack_witness_fixture_operation(STACK_WITNESS_UNKNOWN_OP_ID), - None - ); - } - fn sample_import_suffix_request(kernel: &WarpKernel) -> AbiImportSuffixRequest { let worldline_id = kernel.default_worldline; let base_frontier = abi_provenance_ref(worldline_id, 0, 1); @@ -2161,265 +1707,26 @@ mod tests { } #[test] - fn stack_witness_contract_intent_without_installed_artifact_obstructs() { - let mut kernel = WarpKernel::new().unwrap(); - let intent = pack_intent_v1( - STACK_WITNESS_UNKNOWN_OP_ID, - &stack_witness_create_buffer_vars(), - ) - .unwrap(); - - let error = kernel.dispatch_intent(&intent).expect_err( - "contract-shaped EINT must obstruct until a generated artifact is installed", - ); - - assert_eq!(error.code, error_codes::NOT_SUPPORTED); - assert!( - error.message.contains("contract"), - "obstruction should explain the missing contract artifact" - ); - } - - #[test] - fn stack_witness_create_buffer_and_replace_range_enter_dispatch_intent() { - let mut kernel = WarpKernel::new().unwrap(); - - admit_stack_witness_create_buffer(&mut kernel); - admit_stack_witness_replace_range(&mut kernel); - } - - fn advance_non_fixture_tick(kernel: &mut WarpKernel, vars: &[u8]) { - let intent = pack_intent_v1(1, vars).unwrap(); - let dispatch = kernel.dispatch_intent(&intent).unwrap(); - assert!(dispatch.accepted); - let run = start_until_idle(kernel, Some(4)); - assert_eq!( - run.scheduler_status.last_run_completion, - Some(RunCompletion::Quiesced) - ); - } - - fn admit_stack_witness_create_buffer(kernel: &mut WarpKernel) { - let create_buffer = pack_intent_v1( - STACK_WITNESS_CREATE_BUFFER_OP_ID, - &stack_witness_create_buffer_vars(), - ) - .unwrap(); - let create = kernel.dispatch_intent(&create_buffer).unwrap(); - assert!(create.accepted); - assert_eq!(create.intent_id.len(), 32); - let create_run = start_until_idle(kernel, Some(4)); - assert_eq!( - create_run.scheduler_status.last_run_completion, - Some(RunCompletion::Quiesced) - ); - } - - fn admit_stack_witness_replace_range(kernel: &mut WarpKernel) { - let replace_range = pack_intent_v1( - STACK_WITNESS_REPLACE_RANGE_OP_ID, - &stack_witness_replace_range_vars(), - ) - .unwrap(); - let replace = kernel.dispatch_intent(&replace_range).unwrap(); - assert!(replace.accepted); - assert_eq!(replace.intent_id.len(), 32); - let replace_run = start_until_idle(kernel, Some(4)); - assert_eq!( - replace_run.scheduler_status.last_run_completion, - Some(RunCompletion::Quiesced) - ); - } - - fn admit_stack_witness_fixture_history(kernel: &mut WarpKernel) { - admit_stack_witness_create_buffer(kernel); - admit_stack_witness_replace_range(kernel); - } - - fn stack_witness_text_window_request(kernel: &WarpKernel) -> AbiObservationRequest { - abi_builtin_one_shot( + fn queryview_without_installed_contract_observer_is_unsupported() { + let kernel = WarpKernel::new().unwrap(); + let request = abi_builtin_one_shot( AbiObservationCoordinate { worldline_id: abi_worldline_id(kernel.default_worldline), at: echo_wasm_abi::kernel_port::ObservationAt::Frontier, }, AbiObservationFrame::QueryView, AbiObservationProjection::Query { - query_id: STACK_WITNESS_TEXT_WINDOW_QUERY_ID, - vars_bytes: stack_witness_text_window_vars(), - }, - ) - } - - fn stack_witness_text_window_request_for_worldline( - worldline_id: WorldlineId, - ) -> AbiObservationRequest { - abi_builtin_one_shot( - AbiObservationCoordinate { - worldline_id: abi_worldline_id(worldline_id), - at: echo_wasm_abi::kernel_port::ObservationAt::Frontier, - }, - AbiObservationFrame::QueryView, - AbiObservationProjection::Query { - query_id: STACK_WITNESS_TEXT_WINDOW_QUERY_ID, - vars_bytes: stack_witness_text_window_vars(), + query_id: 0x5357_1001, + vars_bytes: b"app-owned-query-vars".to_vec(), }, - ) - } - - fn expected_stack_witness_text_window_artifact_hash() -> Vec { - let mut hasher = blake3::Hasher::new(); - hasher.update(STACK_WITNESS_FIXTURE_ARTIFACT_ID.as_bytes()); - hasher.update(&STACK_WITNESS_TEXT_WINDOW_QUERY_ID.to_le_bytes()); - hasher.update(STACK_WITNESS_TEXT_WINDOW_VARS); - hasher.update(STACK_WITNESS_TEXT_WINDOW_BYTES); - hasher.finalize().as_bytes().to_vec() - } - - #[test] - fn stack_witness_text_window_obstructs_without_fixture_history() { - let kernel = WarpKernel::new().unwrap(); - let request = stack_witness_text_window_request(&kernel); - - let error = kernel - .observe(request) - .expect_err("textWindow must not materialize without fixture mutation history"); - - assert_eq!(error.code, error_codes::OBSERVATION_UNAVAILABLE); - } - - #[test] - fn stack_witness_text_window_obstructs_wrong_worldline() { - let mut kernel = WarpKernel::new().unwrap(); - admit_stack_witness_fixture_history(&mut kernel); - let request = stack_witness_text_window_request_for_worldline(wl(99)); - - let error = kernel - .observe(request) - .expect_err("textWindow must not materialize for a non-default worldline"); - - assert_eq!(error.code, error_codes::OBSERVATION_UNAVAILABLE); - } - - #[test] - fn stack_witness_text_window_obstructs_pending_fixture_history_on_advanced_head() { - let mut kernel = WarpKernel::new().unwrap(); - advance_non_fixture_tick(&mut kernel, b"advance-a"); - advance_non_fixture_tick(&mut kernel, b"advance-b"); - assert_eq!( - kernel.current_head().unwrap().worldline_tick, - AbiWorldlineTick(2) ); - let create_buffer = pack_intent_v1( - STACK_WITNESS_CREATE_BUFFER_OP_ID, - &stack_witness_create_buffer_vars(), - ) - .unwrap(); - let replace_range = pack_intent_v1( - STACK_WITNESS_REPLACE_RANGE_OP_ID, - &stack_witness_replace_range_vars(), - ) - .unwrap(); - assert!(kernel.dispatch_intent(&create_buffer).unwrap().accepted); - assert!(kernel.dispatch_intent(&replace_range).unwrap().accepted); - let request = stack_witness_text_window_request(&kernel); - - let error = kernel - .observe(request) - .expect_err("textWindow must not materialize before fixture intents commit"); - - assert_eq!(error.code, error_codes::OBSERVATION_UNAVAILABLE); - } - - #[test] - fn stack_witness_fixture_mutations_reject_wrong_fixture_vars() { - let mut kernel = WarpKernel::new().unwrap(); - for (op_id, vars) in [ - ( - STACK_WITNESS_CREATE_BUFFER_OP_ID, - b"wrong-create".as_slice(), - ), - ( - STACK_WITNESS_REPLACE_RANGE_OP_ID, - b"wrong-replace".as_slice(), - ), - ] { - let intent = pack_intent_v1(op_id, vars).unwrap(); - let error = kernel - .dispatch_intent(&intent) - .expect_err("fixture mutation vars must match the installed fixture bytes"); - assert_eq!(error.code, error_codes::INVALID_INTENT); - } - } - - #[test] - fn stack_witness_text_window_respects_bounded_payload_budget() { - let mut kernel = WarpKernel::new().unwrap(); - admit_stack_witness_fixture_history(&mut kernel); - let mut request = stack_witness_text_window_request(&kernel); - request.budget = AbiObservationReadBudget::Bounded { - max_payload_bytes: 4, - max_witness_refs: 0, - }; - let error = kernel .observe(request) - .expect_err("textWindow must obstruct when payload exceeds the read budget"); - - assert_eq!(error.code, error_codes::OBSERVATION_BUDGET_EXCEEDED); - } - - #[test] - fn stack_witness_text_window_artifact_hash_is_deterministic_identity() { - let mut kernel = WarpKernel::new().unwrap(); - admit_stack_witness_fixture_history(&mut kernel); - let request = stack_witness_text_window_request(&kernel); - - let artifact = kernel - .observe(request) - .expect("textWindow QueryView should return a reading artifact"); - - assert_eq!( - artifact.artifact_hash, - expected_stack_witness_text_window_artifact_hash() - ); - } - - #[test] - fn stack_witness_text_window_query_returns_reading_envelope_and_query_bytes() { - let mut kernel = WarpKernel::new().unwrap(); - admit_stack_witness_fixture_history(&mut kernel); - let request = stack_witness_text_window_request(&kernel); - - let artifact = kernel - .observe(request) - .expect("textWindow QueryView should return ReadingEnvelope + QueryBytes"); - - let AbiObservationPayload::QueryBytes { data } = artifact.payload else { - panic!("textWindow should return QueryBytes"); - }; + .expect_err("QueryView must route through installed observers only"); - assert_eq!(data, b"hello"); - assert_eq!( - artifact.reading.observer_basis, - AbiReadingObserverBasis::QueryView - ); - assert_eq!( - artifact.reading.budget_posture, - AbiReadingBudgetPosture::UnboundedOneShot - ); - assert_eq!( - artifact.reading.rights_posture, - AbiReadingRightsPosture::KernelPublic - ); - assert_eq!( - artifact.reading.residual_posture, - AbiReadingResidualPosture::Complete - ); - assert_eq!( - artifact.artifact_hash, - expected_stack_witness_text_window_artifact_hash() - ); + assert_eq!(error.code, error_codes::UNSUPPORTED_QUERY); + assert!(error.message.contains("query id 1398214657")); } #[test] diff --git a/crates/warp-wasm/test/fixtures/stack-witness-0001-vectors.json b/crates/warp-wasm/test/fixtures/stack-witness-0001-vectors.json deleted file mode 100644 index c2c5997a..00000000 --- a/crates/warp-wasm/test/fixtures/stack-witness-0001-vectors.json +++ /dev/null @@ -1,88 +0,0 @@ -{ - "artifact": { - "familyId": "stack-witness-0001.file-history", - "schemaId": "stack-witness-0001.file-history.v0", - "artifactId": "fixture-file-history-v0", - "version": "0" - }, - "fixtureVarsEncoding": "utf8-semicolon-kv/v0", - "targetCodec": "wesley-binary/v0", - "operations": [ - { - "name": "createBuffer", - "operationType": "MUTATION", - "opIdHex": "0x53570001", - "opIdDecimal": 1398210561, - "helperKind": "EINT", - "fixtureVarsBytes": "stack-witness-0001/createBuffer;name=demo.txt;artifact=fixture-file-history-v0", - "declaredFootprint": { - "reads": [], - "writes": [], - "creates": ["Buffer"], - "forbids": ["AstState", "Diagnostics", "GitWitness", "UiState"] - }, - "helperShape": { - "frame": "EINT", - "entrypoint": "dispatch_intent", - "fields": [ - "contract_artifact_id", - "operation_id", - "fixture_vars_bytes", - "declared_footprint" - ] - } - }, - { - "name": "replaceRange", - "operationType": "MUTATION", - "opIdHex": "0x53570002", - "opIdDecimal": 1398210562, - "helperKind": "EINT", - "fixtureVarsBytes": "stack-witness-0001/replaceRange;bufferId=demo.txt;basis=B0;coord=utf8-bytes;start=0;end=0;text=hello;artifact=fixture-file-history-v0", - "declaredFootprint": { - "reads": ["Buffer"], - "writes": ["Buffer"], - "creates": ["Tick", "Receipt"], - "forbids": ["AstState", "Diagnostics", "GitWitness", "UiState"] - }, - "helperShape": { - "frame": "EINT", - "entrypoint": "dispatch_intent", - "fields": [ - "contract_artifact_id", - "operation_id", - "fixture_vars_bytes", - "declared_footprint" - ] - } - }, - { - "name": "textWindow", - "operationType": "QUERY", - "opIdHex": "0x53571001", - "opIdDecimal": 1398214657, - "helperKind": "QueryView", - "fixtureVarsBytes": "stack-witness-0001/textWindow;bufferId=demo.txt;basis=B1;coord=utf8-bytes;start=0;length=5;artifact=fixture-file-history-v0", - "payloadCodec": "QueryBytes", - "envelope": "ReadingEnvelope", - "expectedQueryBytesHex": "68656c6c6f", - "declaredFootprint": { - "reads": ["Buffer", "Tick", "Receipt"], - "writes": [], - "creates": [], - "forbids": ["AstState", "Diagnostics", "GitWitness", "UiState"] - }, - "helperShape": { - "frame": "QueryView", - "entrypoint": "observe", - "fields": [ - "contract_artifact_id", - "query_id", - "fixture_vars_bytes", - "reading_envelope", - "query_bytes" - ] - } - } - ] -} diff --git a/docs/design/stack-witness-0001-jedit-file-history.md b/docs/design/stack-witness-0001-jedit-file-history.md index 1136ce06..aeede599 100644 --- a/docs/design/stack-witness-0001-jedit-file-history.md +++ b/docs/design/stack-witness-0001-jedit-file-history.md @@ -3,12 +3,19 @@ # Stack Witness 0001 - jedit File History Walking Skeleton -Status: GREEN witness spec -Scope: first jedit-through-Echo executable story. +Status: HISTORICAL walking-skeleton packet, superseded for release-grade +generic Echo behavior. +Scope: early jedit-through-Echo fixture story. -This witness is the first serious stack slice. It exists to prevent the stack -from drifting into schema-first protocol architecture before one local -contract-hosted file history works. +This witness was the first serious stack slice. It prevented the stack from +drifting into schema-first protocol architecture before one local +contract-hosted file history could be described. + +Important correction: Echo no longer carries this Stack Witness fixture inside +the production WASM kernel. Release-grade Echo must route jedit-shaped +mutations and QueryView reads through installed contract packages and generated +host adapters. A hardcoded `createBuffer`/`replaceRange`/`textWindow` shortcut +inside Echo is an architectural violation, not a proof. ## Claim @@ -196,52 +203,31 @@ The first RED tests proved: 2. QueryView/textWindow must return `ReadingEnvelope + QueryBytes`, not `UnsupportedQuery` or naked payload bytes. -## Current GREEN State - -As of branch `wip/stack-witness-0001`, Echo has a fixture-backed walking -skeleton for this witness: - -- a static/as-if-generated fixture registry exists for `createBuffer` and - `replaceRange`; -- unknown Stack Witness contract op ids obstruct with a contract/missing - artifact error; -- `createBuffer` and `replaceRange("hello")` enter through `dispatch_intent` - and the existing scheduler path; -- the Stack Witness `textWindow` QueryView routes to a fixture observer; -- the fixture observer only returns `ReadingEnvelope + QueryBytes("hello")` - after fixture `createBuffer` and `replaceRange("hello")` history has been - admitted and materialized; -- the fixture observer enforces bounded payload budgets and obstructs if the - caller budgets fewer than five payload bytes; -- the fixture observer carries a deterministic BLAKE3 artifact hash over the - fixture artifact id, query id, fixture vars bytes, and payload bytes; -- Echo mirrors Wesley's Stack Witness 0001 fixture vector and verifies artifact - family/schema/version, op ids, helper entrypoints, helper fields, - buffer-inclusive fixture vars bytes, target codec, declared footprints, and - expected query bytes against that artifact shape; -- Echo core still does not expose public jedit, editor, rope, buffer, cursor, - or selection APIs. - -Targeted command: +## Current State + +The earlier fixture-backed WASM shortcut has been removed. Current Echo +behavior is: + +- `warp-wasm` does not recognize `createBuffer`, `replaceRange`, or + `textWindow` as kernel-owned operations; +- QueryView observations route through `ObservationService` and installed + contract query observers only; +- without an installed observer, WASM `observe(...)` returns + `UNSUPPORTED_QUERY`; +- text, rope, file-history, editor, cursor, and buffer semantics belong in + jedit-authored contracts, Wesley-generated adapters, or jedit host code; +- Echo core remains a generic deterministic runtime and contract host. + +Current targeted command: ```sh -cargo test -p warp-wasm --features engine stack_witness_ +cargo test -p warp-wasm --features engine queryview_without ``` -Current result: +Current witness: ```text -running 8 tests -test warp_kernel::tests::stack_witness_fixture_registry_names_mutations ... ok -test warp_kernel::tests::stack_witness_fixture_vectors_match_wesley_artifact_shape ... ok -test warp_kernel::tests::stack_witness_contract_intent_without_installed_artifact_obstructs ... ok -test warp_kernel::tests::stack_witness_text_window_obstructs_without_fixture_history ... ok -test warp_kernel::tests::stack_witness_create_buffer_and_replace_range_enter_dispatch_intent ... ok -test warp_kernel::tests::stack_witness_text_window_respects_bounded_payload_budget ... ok -test warp_kernel::tests::stack_witness_text_window_artifact_hash_is_deterministic_identity ... ok -test warp_kernel::tests::stack_witness_text_window_query_returns_reading_envelope_and_query_bytes ... ok - -test result: ok. 8 passed; 0 failed; 0 ignored; 0 measured; 44 filtered out +test warp_kernel::tests::queryview_without_installed_contract_observer_is_unsupported ... ok ``` Engine feature compile target: From 282f817f6c8148118242b84dbf4e2864c97e896a Mon Sep 17 00:00:00 2001 From: James Ross Date: Sun, 24 May 2026 01:09:19 -0700 Subject: [PATCH 2/2] Fix: Remove brittle query error assertion --- crates/warp-wasm/src/warp_kernel.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/crates/warp-wasm/src/warp_kernel.rs b/crates/warp-wasm/src/warp_kernel.rs index 65bfe5a4..3d21ce56 100644 --- a/crates/warp-wasm/src/warp_kernel.rs +++ b/crates/warp-wasm/src/warp_kernel.rs @@ -1726,7 +1726,6 @@ mod tests { .expect_err("QueryView must route through installed observers only"); assert_eq!(error.code, error_codes::UNSUPPORTED_QUERY); - assert!(error.message.contains("query id 1398214657")); } #[test]