meta.language.calls.declared

Every observed architectural call must be permitted by its caller’s resolved dependency envelope. An undeclared call is an error, including recursive entry into the same operation and requests satisfied from a query cache.

Read in specification context · design/meta/language.md

Implementation

Implemented crates/sage-meta/src/contracts.rs:231–236

sage_meta::contracts · lib:sage_meta

#![allow(unused)]
fn main() {
    // {anchor}`meta.language.calls.declared`
    // {anchor}`meta.language.envelopes.class_calls`
    // {anchor}`meta.language.envelopes.receiver_calls`
    // {anchor}`meta.language.envelopes.direct_calls`
    fn check_request(&mut self, invocation: &Invocation) {
        if let Some(caller) = self.active.last().cloned() {

}

See more source ↗

Implemented crates/sage-meta/src/validate.rs:29–34

sage_meta::validate · lib:sage_meta

#![allow(unused)]
fn main() {
// {anchor}`meta.language.calls.declared`
// {anchor}`meta.language.calls.forbidden`
// {anchor}`meta.language.envelopes.permissions`
pub(crate) fn resolve_contracts(
    documents: &[Document],
) -> Result<BTreeMap<String, crate::contracts::OperationContract>, Vec<Diagnostic>> {

}

See more source ↗

Tests and review

Indexed tests and the implementation-completeness and test-adequacy review; no test run is implied.

Implemented sage_meta::real_salsa_contract_fixture

crates/sage-meta/tests/contracts.rs · test:contracts

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.language.calls.declared)]
#[sage::test(meta.language.calls.forbidden)]
#[sage::test(meta.contracts.validated_session)]
#[sage::test(meta.contracts.cache_invocations)]
#[sage::test(meta.contracts.observation_coverage)]
fn real_salsa_contract_fixture() {
    let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
    let fixture = root.join("tests/fixtures/contracts");
    let output = std::process::Command::new(env!("CARGO"))
        .args(["test", "--locked", "--manifest-path"])
        .arg(fixture.join("Cargo.toml"))
        .args(["--", "--nocapture", "--test-threads=1"])
        .env(
            "CARGO_TARGET_DIR",
            root.join("../../target/sage-contract-fixture"),
        )
        .output()
        .expect("run the isolated contracts fixture");
    assert!(
        output.status.success(),
        "contract fixture failed:\n{}\n{}",
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    );
    let stdout = String::from_utf8(output.stdout).unwrap();
    let evidence: Vec<serde_json::Value> = stdout
        .lines()
        .filter_map(|line| line.split_once("SAGE_CONTRACT_EVIDENCE:"))
        .map(|(_, json)| serde_json::from_str(json).unwrap())
        .collect();
    assert_eq!(evidence.len(), 2, "expected cold and prewarmed reports");
    let root = "sage_contract_fixture::nodes::Root::run";
    let helper = "sage_contract_fixture::nodes::Helper::work";
    let leaf = "sage_contract_fixture::nodes::Leaf::read";
    for prewarmed in [false, true] {
        let sample = evidence
            .iter()
            .find(|sample| sample["prewarmed"] == prewarmed)
            .expect("each cache scenario must report evidence");
        let operations = &sample["model"]["operations"];
        assert!(operations[helper]["invokes"].as_array().unwrap().is_empty());
        assert_eq!(
            operations[root]["prohibits"][0]["targets"],
            serde_json::json!([leaf])
        );
        let report = &sample["contracts"];
        assert_eq!(report["calls_conform"], false);
        assert_eq!(report["coverage"]["checked_requests"], 3);
        assert!(report["coverage"]["gaps"].as_array().unwrap().is_empty());
        let violations = report["violations"].as_array().unwrap();
        assert_eq!(violations.len(), 2);
        assert_eq!(violations[0]["kind"], "UndeclaredCall");
        assert_eq!(violations[1]["kind"], "ForbiddenTransitive");
        assert_eq!(violations[1]["rule"]["operation"], root);
        assert_eq!(
            violations[1]["path"]
                .as_array()
                .unwrap()
                .iter()
                .map(|frame| frame["operation"].as_str().unwrap())
                .collect::<Vec<_>>(),
            [root, helper, leaf],
        );
        if prewarmed {
            let events = sample["query_events"].as_array().unwrap();
            assert!(events.iter().any(|event| {
                let event = event.as_str().unwrap();
                event.starts_with("return Leaf::read") && event.contains("[Reused]")
            }));
            assert!(
                !events
                    .iter()
                    .any(|event| event.as_str().unwrap().starts_with("execute Leaf::read"))
            );
        }
    }
}
}

See more source ↗

Implemented sage_meta::reports_direct_and_ancestor_violation_with_complete_path_and_rule

crates/sage-meta/tests/runtime_contracts.rs · test:runtime_contracts

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.language.calls.declared)]
#[sage::test(meta.language.calls.forbidden)]
fn reports_direct_and_ancestor_violation_with_complete_path_and_rule() {
    let mut session = session(model(FORBIDDEN), &["Root::run"]);
    let root = session.enter("demo::Root::run", Some("root:1"));
    let helper = session.enter("demo::Helper::work", Some("helper:2"));
    let leaf = session.enter("demo::Leaf::read", Some("leaf:3"));
    session.exit(leaf);
    session.exit(helper);
    session.exit(root);
    let report = session.finish();
    assert!(!report.calls_conform);
    assert_eq!(report.coverage.checked_requests, 3);
    assert_eq!(report.violations.len(), 2);
    assert_eq!(report.violations[0].kind, ViolationKind::UndeclaredCall);
    let forbidden = &report.violations[1];
    assert_eq!(forbidden.kind, ViolationKind::ForbiddenTransitive);
    assert_eq!(
        forbidden.rule.as_ref().unwrap().operation,
        "demo::Root::run"
    );
    assert_eq!(
        forbidden
            .path
            .iter()
            .map(|frame| frame.operation.as_str())
            .collect::<Vec<_>>(),
        ["demo::Root::run", "demo::Helper::work", "demo::Leaf::read"]
    );
    assert_eq!(forbidden.path[2].receiver.as_deref(), Some("leaf:3"));
    assert_eq!(report.trace.len(), 6);
}
}

See more source ↗

Implemented sage_meta::same_operation_entry_is_recursion_and_needs_permission

crates/sage-meta/tests/runtime_contracts.rs · test:runtime_contracts

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.language.calls.declared)]
#[sage::test(meta.contracts.cache_invocations)]
#[sage::test(meta.language.envelopes.receiver_calls)]
fn same_operation_entry_is_recursion_and_needs_permission() {
    let leaf = r#"class Tree { """Tree.""" fn walk() -> u32 { """Walk.""" envelope {} } }"#;
    let mut denied = session(model(leaf), &["Tree::walk"]);
    let a = denied.enter("demo::Tree::walk", Some("tree:1"));
    let b = denied.enter("demo::Tree::walk", Some("tree:1"));
    denied.exit(b);
    denied.exit(a);
    assert_eq!(
        denied.finish().violations[0].kind,
        ViolationKind::UndeclaredCall
    );

    let recursive = leaf.replace("envelope {}", "envelope { invokes self.walk(); }");
    let mut allowed = session(model(&recursive), &["Tree::walk"]);
    let a = allowed.enter("demo::Tree::walk", Some("tree:1"));
    let b = allowed.enter("demo::Tree::walk", Some("tree:1"));
    allowed.exit(b);
    allowed.exit(a);
    let report = allowed.finish();
    report.assert_calls_conform();
    assert_eq!(report.coverage.checked_requests, 2);
    assert!(matches!(&report.trace[1], ContractEvent::Enter(frame) if frame.parent == Some(a)));
}
}

See more source ↗

Review: Accepted · Codex /root/anchor_187.

Source review complete for meta.language.calls.declared. Independently verified exact byte equality of both implementation files and both containing test files against the historical input; that baseline supports, but does not replace, this assessment of the current claim and complete association set. The claim requires caller-envelope permission for every observed architectural call, specifically including same-operation recursion and cache-satisfied requests. resolve_contracts resolves each operation's own invokes targets (including permitted dispatch and receiver restrictions); ContractSession enters every source request through check_request against the immediate caller and records UndeclaredCall when no permission/dispatch exists. There is no self-recursion exemption and checking occurs before any execution/cache distinction; unknown operations and receiver gaps cannot yield conformance. Both ordinary implementation entries are sufficient. All three ordinary associated tests were inspected: reports_direct_and_ancestor_violation_with_complete_path_and_rule asserts three checked requests and the undeclared Helper-to-Leaf error alongside the separate ancestor prohibition; same_operation_entry_is_recursion_and_needs_permission rejects an empty-envelope recursive call, then explicitly permits self.walk and asserts conformance, two requests and parent identity; real_salsa_contract_fixture asserts empty Helper permissions, nonconformance and UndeclaredCall for both cold and prewarmed cases, with a Reused Leaf return and no Leaf execution when warm. Captured runtime setup confirms the unit model and roots. Captured fixture queries, model, callback setup and evidence serialization establish that integration assertions inspect actual request observations. Captured SalsaObserver checks WillRequest independently of WillExecute and delegates ordinary fetches to session.enter; internal validation/traversal contexts are not invented source calls. These assertions would detect exemptions for recursion or cache hits and permissive handling of undeclared direct calls. Scope remains observed architectural calls, without a guarantee of instrumentation for every Rust call. No TODO/N/A entries or deferred prerequisites exist. Execution: personally ran review start/read and exact-comparison commands; no behavioral tests or workspace build were run by this reviewer. The supplied coordinator baseline reports 321 passing functional sage-meta tests and a passing root cargo build; those are separately reported execution. No source changes or requested edits.

Browse meta anchors

116 anchors

Anchor Implementation Tests

meta (116) 102 Implemented24 TODO 103 Implemented36 TODO

meta.anchors (22) 22 Implemented 21 Implemented12 TODO

anchor_pages Implemented ImplementedTODO

Every specification anchor has a stable page identifying the rule and showing its definition, context, implementation entries, and tests/evidence. The page includes Rust excerpts and access to surrounding source, and exposes each entry’s placeholder status and explanation. Multiple sites remain individually inspectable rather than being reduced to a single coverage badge.

Symposiun AGentic Environment (SAGE)

meta.language.calls.declared

Implementation

Tests and review