domainforge 0.13.0

package/domainforge-core/src/semantic_pack/validator.rs

@@ -0,0 +1,368 @@
+use super::canonical_json;
+use super::diagnostics::{
+    DiagnosticSeverity, SemanticDiagnostic, SemanticDiagnosticCode, SemanticTruth,
+    SemanticValidationResult, SemanticValidationStatus, ValidationMode, ValidationOptions,
+};
+use super::resolver::{self, ResolveRequest};
+use super::schema::{ConceptStatus, PackRef, PackSetRef, SemanticPack, SignatureState, SourceRef};
+
+const CURRENT_SCHEMA_VERSION: &str = "0.3";
+
+/// Validate a semantic pack itself (internal consistency).
+pub fn validate_semantic_pack(
+    pack: &SemanticPack,
+) -> Result<Vec<SemanticDiagnostic>, SemanticPackError> {
+    let mut diagnostics = Vec::new();
+    let pack_ref = make_pack_ref(pack);
+
+    // Schema version check
+    if pack.schema_version != CURRENT_SCHEMA_VERSION {
+        diagnostics.push(SemanticDiagnostic {
+            code: SemanticDiagnosticCode::PackSchemaMismatch,
+            severity: DiagnosticSeverity::Error,
+            semantic_truth: SemanticTruth::Invalid,
+            message: format!(
+                "Expected schema_version '{}', got '{}'",
+                CURRENT_SCHEMA_VERSION, pack.schema_version
+            ),
+            source_ref: SourceRef::pack_uri(&pack.pack_id),
+            pack_ref: pack_ref.clone(),
+            suggestions: vec![],
+            recoverability_hint: format!("Update schema_version to {}", CURRENT_SCHEMA_VERSION),
+        });
+    }
+
+    // Duplicate concept IDs
+    let mut seen_ids: std::collections::HashSet<String> = std::collections::HashSet::new();
+    for c in &pack.concepts {
+        if !seen_ids.insert(c.id.clone()) {
+            diagnostics.push(SemanticDiagnostic {
+                code: SemanticDiagnosticCode::DuplicateConceptId,
+                severity: DiagnosticSeverity::Error,
+                semantic_truth: SemanticTruth::Invalid,
+                message: format!("Duplicate concept ID: '{}'", c.id),
+                source_ref: SourceRef::pack_uri(&pack.pack_id),
+                pack_ref: pack_ref.clone(),
+                suggestions: vec![],
+                recoverability_hint: "Rename one of the duplicate concepts".to_string(),
+            });
+        }
+    }
+
+    // Duplicate canonical names targeting different IDs
+    let mut seen_names: std::collections::HashMap<String, String> =
+        std::collections::HashMap::new();
+    for c in &pack.concepts {
+        let norm = resolver::normalize_lookup_key(&c.canonical_name);
+        if let Some(existing_id) = seen_names.get(&norm) {
+            if existing_id != &c.id {
+                diagnostics.push(SemanticDiagnostic {
+                    code: SemanticDiagnosticCode::DuplicateCanonicalName,
+                    severity: DiagnosticSeverity::Error,
+                    semantic_truth: SemanticTruth::Invalid,
+                    message: format!(
+                        "Duplicate canonical name '{}' targets '{}' and '{}'",
+                        c.canonical_name, existing_id, c.id
+                    ),
+                    source_ref: SourceRef::pack_uri(&pack.pack_id),
+                    pack_ref: pack_ref.clone(),
+                    suggestions: vec![],
+                    recoverability_hint: "Ensure canonical names are unique".to_string(),
+                });
+            }
+        } else {
+            seen_names.insert(norm, c.id.clone());
+        }
+    }
+
+    // Missing definitions on active concepts
+    for c in &pack.concepts {
+        if matches!(c.status, ConceptStatus::Active | ConceptStatus::Proposed) {
+            if c.definition.text.is_empty() {
+                diagnostics.push(SemanticDiagnostic {
+                    code: SemanticDiagnosticCode::MissingDefinition,
+                    severity: DiagnosticSeverity::Warning,
+                    semantic_truth: SemanticTruth::Unknown,
+                    message: format!("Active concept '{}' has no definition", c.id),
+                    source_ref: SourceRef::pack_uri(&pack.pack_id),
+                    pack_ref: pack_ref.clone(),
+                    suggestions: vec![],
+                    recoverability_hint: "Add a definition text".to_string(),
+                });
+            }
+            if c.owner.is_empty() {
+                diagnostics.push(SemanticDiagnostic {
+                    code: SemanticDiagnosticCode::MissingOwner,
+                    severity: DiagnosticSeverity::Warning,
+                    semantic_truth: SemanticTruth::Unknown,
+                    message: format!("Active concept '{}' has no owner", c.id),
+                    source_ref: SourceRef::pack_uri(&pack.pack_id),
+                    pack_ref: pack_ref.clone(),
+                    suggestions: vec![],
+                    recoverability_hint: "Assign an owner".to_string(),
+                });
+            }
+        }
+    }
+
+    // Alias target validation
+    let concept_ids: std::collections::HashSet<&str> =
+        pack.concepts.iter().map(|c| c.id.as_str()).collect();
+    for a in &pack.aliases {
+        if !concept_ids.contains(a.target_concept_id.as_str()) {
+            diagnostics.push(SemanticDiagnostic {
+                code: SemanticDiagnosticCode::UnknownConcept,
+                severity: DiagnosticSeverity::Error,
+                semantic_truth: SemanticTruth::Invalid,
+                message: format!(
+                    "Alias '{}' targets unknown concept '{}'",
+                    a.alias, a.target_concept_id
+                ),
+                source_ref: SourceRef::pack_uri(&pack.pack_id),
+                pack_ref: pack_ref.clone(),
+                suggestions: vec![],
+                recoverability_hint: "Add the target concept or fix the alias".to_string(),
+            });
+        }
+    }
+
+    // Relation endpoint validation
+    for r in &pack.relations {
+        if !concept_ids.contains(r.subject_id.as_str()) {
+            diagnostics.push(SemanticDiagnostic {
+                code: SemanticDiagnosticCode::InvalidRelation,
+                severity: DiagnosticSeverity::Error,
+                semantic_truth: SemanticTruth::Invalid,
+                message: format!(
+                    "Relation '{}' references unknown subject '{}'",
+                    r.id, r.subject_id
+                ),
+                source_ref: SourceRef::pack_uri(&pack.pack_id),
+                pack_ref: pack_ref.clone(),
+                suggestions: vec![],
+                recoverability_hint: "Add the missing concept or fix the relation".to_string(),
+            });
+        }
+        if !concept_ids.contains(r.object_id.as_str()) {
+            diagnostics.push(SemanticDiagnostic {
+                code: SemanticDiagnosticCode::InvalidRelation,
+                severity: DiagnosticSeverity::Error,
+                semantic_truth: SemanticTruth::Invalid,
+                message: format!(
+                    "Relation '{}' references unknown object '{}'",
+                    r.id, r.object_id
+                ),
+                source_ref: SourceRef::pack_uri(&pack.pack_id),
+                pack_ref: pack_ref.clone(),
+                suggestions: vec![],
+                recoverability_hint: "Add the missing concept or fix the relation".to_string(),
+            });
+        }
+    }
+
+    // Metric dimension/unit validation
+    let dimension_ids: std::collections::HashSet<&str> =
+        pack.dimensions.iter().map(|d| d.id.as_str()).collect();
+    let unit_ids: std::collections::HashSet<&str> =
+        pack.units.iter().map(|u| u.id.as_str()).collect();
+    for m in &pack.metrics {
+        if let Some(ref dim_id) = m.dimension_id {
+            if !dimension_ids.contains(dim_id.as_str()) {
+                diagnostics.push(SemanticDiagnostic {
+                    code: SemanticDiagnosticCode::UnknownDimension,
+                    severity: DiagnosticSeverity::Warning,
+                    semantic_truth: SemanticTruth::Unknown,
+                    message: format!(
+                        "Metric '{}' references unknown dimension '{}'",
+                        m.id, dim_id
+                    ),
+                    source_ref: SourceRef::pack_uri(&pack.pack_id),
+                    pack_ref: pack_ref.clone(),
+                    suggestions: vec![],
+                    recoverability_hint: "Add the missing dimension".to_string(),
+                });
+            }
+        }
+        if let Some(ref unit_id) = m.unit_id {
+            if !unit_ids.contains(unit_id.as_str()) {
+                diagnostics.push(SemanticDiagnostic {
+                    code: SemanticDiagnosticCode::UnknownUnit,
+                    severity: DiagnosticSeverity::Warning,
+                    semantic_truth: SemanticTruth::Unknown,
+                    message: format!("Metric '{}' references unknown unit '{}'", m.id, unit_id),
+                    source_ref: SourceRef::pack_uri(&pack.pack_id),
+                    pack_ref: pack_ref.clone(),
+                    suggestions: vec![],
+                    recoverability_hint: "Add the missing unit".to_string(),
+                });
+            }
+        }
+    }
+
+    Ok(diagnostics)
+}
+
+/// Validate a parsed graph against a semantic pack.
+pub fn validate_graph_with_pack(
+    pack: &SemanticPack,
+    source_uri: &str,
+    options: &ValidationOptions,
+) -> SemanticValidationResult {
+    let pack_ref = make_pack_ref(pack);
+
+    // Check unsigned requirement
+    if options.require_signed_pack
+        && pack.trust.signature_state != SignatureState::Signed
+        && !options.allow_unsigned_test_fixtures
+    {
+        let mut result = empty_result(&pack_ref, options);
+        result.status = SemanticValidationStatus::Blocked;
+        result.diagnostics.push(SemanticDiagnostic {
+            code: SemanticDiagnosticCode::PackUnsigned,
+            severity: DiagnosticSeverity::Error,
+            semantic_truth: SemanticTruth::Invalid,
+            message: format!(
+                "Pack '{}' is unsigned but signature is required",
+                pack.pack_id
+            ),
+            source_ref: SourceRef::pack_uri(&pack.pack_id),
+            pack_ref: pack_ref.clone(),
+            suggestions: vec![],
+            recoverability_hint: "Sign the pack or use --allow-unsigned-for-test-fixtures"
+                .to_string(),
+        });
+        return result;
+    }
+
+    // Run pack self-validation first
+    let mut diagnostics = match validate_semantic_pack(pack) {
+        Ok(d) => d,
+        Err(e) => {
+            let mut result = empty_result(&pack_ref, options);
+            result.status = SemanticValidationStatus::Failed;
+            result.diagnostics.push(SemanticDiagnostic {
+                code: SemanticDiagnosticCode::PackSchemaMismatch,
+                severity: DiagnosticSeverity::Error,
+                semantic_truth: SemanticTruth::Invalid,
+                message: format!("Pack self-validation failed: {:?}", e),
+                source_ref: SourceRef::synthetic("internal"),
+                pack_ref: pack_ref.clone(),
+                suggestions: vec![],
+                recoverability_hint: "Check pack structure and retry".to_string(),
+            });
+            return result;
+        }
+    };
+
+    // Sort diagnostics deterministically
+    super::canonical_json::sort_diagnostics(&mut diagnostics);
+
+    // Compute status per §4.7
+    let status = compute_status(&diagnostics, options);
+
+    SemanticValidationResult {
+        status,
+        diagnostics,
+        pack_set_ref: PackSetRef {
+            merged_pack_hash: pack_ref.pack_content_hash.clone(),
+            pack_refs: vec![pack_ref.clone()],
+        },
+        input_hash: canonical_json::hash_canonical_json(&serde_json::json!({
+            "source_uri": source_uri,
+            "pack_id": pack.pack_id,
+        })),
+        validation_mode: options.mode,
+        expected_hashes: vec![],
+        unsigned_fixture_bypass_used: options.allow_unsigned_test_fixtures,
+        first_approved_version_bypass_used: false,
+        evidence_ref: None,
+    }
+}
+
+/// Validate a specific term against a pack (resolver-backed).
+pub fn validate_term(
+    raw_text: &str,
+    pack: &SemanticPack,
+    options: &ValidationOptions,
+    source_ref: SourceRef,
+) -> Option<SemanticDiagnostic> {
+    let request = ResolveRequest {
+        raw_text,
+        expected_kind: None,
+        source_ref: source_ref.clone(),
+    };
+    let result = resolver::resolve_concept(&request, pack, options);
+
+    if let Some(code) = result.diagnostic_code {
+        let pack_ref = make_pack_ref(pack);
+        Some(SemanticDiagnostic {
+            code,
+            severity: result.diagnostic_severity,
+            semantic_truth: result.semantic_truth,
+            message: result.message,
+            source_ref,
+            pack_ref,
+            suggestions: result.suggestions,
+            recoverability_hint: String::new(),
+        })
+    } else {
+        None
+    }
+}
+
+fn compute_status(
+    diagnostics: &[SemanticDiagnostic],
+    options: &ValidationOptions,
+) -> SemanticValidationStatus {
+    if matches!(options.mode, ValidationMode::Off) {
+        return SemanticValidationStatus::Passed;
+    }
+
+    let has_blocking_error = diagnostics
+        .iter()
+        .any(|d| d.severity == DiagnosticSeverity::Error);
+    let has_unknown = diagnostics
+        .iter()
+        .any(|d| d.semantic_truth == SemanticTruth::Unknown);
+
+    if has_blocking_error || (matches!(options.mode, ValidationMode::Strict) && has_unknown) {
+        SemanticValidationStatus::Failed
+    } else if has_unknown {
+        SemanticValidationStatus::Unknown
+    } else {
+        SemanticValidationStatus::Passed
+    }
+}
+
+fn make_pack_ref(pack: &SemanticPack) -> PackRef {
+    PackRef {
+        pack_id: pack.pack_id.clone(),
+        pack_content_hash: canonical_json::compute_pack_content_hash(pack),
+        path_or_uri: format!("pack://{}", pack.pack_id),
+        priority: 0,
+    }
+}
+
+fn empty_result(pack_ref: &PackRef, options: &ValidationOptions) -> SemanticValidationResult {
+    SemanticValidationResult {
+        status: SemanticValidationStatus::Passed,
+        diagnostics: vec![],
+        pack_set_ref: PackSetRef {
+            merged_pack_hash: pack_ref.pack_content_hash.clone(),
+            pack_refs: vec![pack_ref.clone()],
+        },
+        input_hash: String::new(),
+        validation_mode: options.mode,
+        expected_hashes: vec![],
+        unsigned_fixture_bypass_used: false,
+        first_approved_version_bypass_used: false,
+        evidence_ref: None,
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum SemanticPackError {
+    IoError(String),
+    JsonError(String),
+    ValidationError(String),
+}

package/domainforge-core/src/semantic_version.rs

@@ -0,0 +1,140 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+pub struct SemanticVersion {
+    pub major: u32,
+    pub minor: u32,
+    pub patch: u32,
+}
+
+impl SemanticVersion {
+    pub fn new(major: u32, minor: u32, patch: u32) -> Self {
+        Self {
+            major,
+            minor,
+            patch,
+        }
+    }
+
+    pub fn parse(s: &str) -> Result<Self, String> {
+        let parts: Vec<&str> = s.split('.').collect();
+        if parts.len() != 3 {
+            return Err("Version must be in format major.minor.patch".to_string());
+        }
+
+        Ok(Self {
+            major: parts[0]
+                .parse()
+                .map_err(|_| "Invalid major version".to_string())?,
+            minor: parts[1]
+                .parse()
+                .map_err(|_| "Invalid minor version".to_string())?,
+            patch: parts[2]
+                .parse()
+                .map_err(|_| "Invalid patch version".to_string())?,
+        })
+    }
+
+    pub fn bump_major(&mut self) {
+        self.major += 1;
+        self.minor = 0;
+        self.patch = 0;
+    }
+
+    pub fn bump_minor(&mut self) {
+        self.minor += 1;
+        self.patch = 0;
+    }
+
+    pub fn bump_patch(&mut self) {
+        self.patch += 1;
+    }
+}
+
+impl std::fmt::Display for SemanticVersion {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}.{}.{}", self.major, self.minor, self.patch)
+    }
+}
+
+impl Default for SemanticVersion {
+    fn default() -> Self {
+        Self::new(1, 0, 0)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_semantic_version_parsing() {
+        let v = SemanticVersion::parse("1.2.3").unwrap();
+        assert_eq!(v.major, 1);
+        assert_eq!(v.minor, 2);
+        assert_eq!(v.patch, 3);
+    }
+
+    #[test]
+    fn test_semantic_version_parsing_invalid() {
+        assert!(SemanticVersion::parse("1.2").is_err());
+        assert!(SemanticVersion::parse("1.2.3.4").is_err());
+        assert!(SemanticVersion::parse("a.b.c").is_err());
+    }
+
+    #[test]
+    fn test_version_comparison() {
+        let v1 = SemanticVersion::new(1, 0, 0);
+        let v2 = SemanticVersion::new(2, 0, 0);
+        assert!(v1 < v2);
+
+        let v3 = SemanticVersion::new(1, 2, 0);
+        let v4 = SemanticVersion::new(1, 1, 0);
+        assert!(v3 > v4);
+
+        let v5 = SemanticVersion::new(1, 1, 2);
+        let v6 = SemanticVersion::new(1, 1, 1);
+        assert!(v5 > v6);
+    }
+
+    #[test]
+    fn test_version_bump_major() {
+        let mut v = SemanticVersion::new(1, 2, 3);
+        v.bump_major();
+        assert_eq!(v, SemanticVersion::new(2, 0, 0));
+    }
+
+    #[test]
+    fn test_version_bump_minor() {
+        let mut v = SemanticVersion::new(1, 2, 3);
+        v.bump_minor();
+        assert_eq!(v, SemanticVersion::new(1, 3, 0));
+    }
+
+    #[test]
+    fn test_version_bump_patch() {
+        let mut v = SemanticVersion::new(1, 2, 3);
+        v.bump_patch();
+        assert_eq!(v, SemanticVersion::new(1, 2, 4));
+    }
+
+    #[test]
+    fn test_version_display() {
+        let v = SemanticVersion::new(1, 2, 3);
+        assert_eq!(format!("{}", v), "1.2.3");
+    }
+
+    #[test]
+    fn test_version_default() {
+        let v = SemanticVersion::default();
+        assert_eq!(v, SemanticVersion::new(1, 0, 0));
+    }
+
+    #[test]
+    fn test_version_serialization() {
+        let v = SemanticVersion::new(1, 2, 3);
+        let json = serde_json::to_string(&v).unwrap();
+        let deserialized: SemanticVersion = serde_json::from_str(&json).unwrap();
+        assert_eq!(v, deserialized);
+    }
+}

package/domainforge-core/src/test_utils.rs

@@ -0,0 +1,12 @@
+#[cfg(test)]
+mod proptest_integration {
+    use crate::uuid_module;
+    use proptest::prelude::*;
+
+    proptest! {
+        #[test]
+        fn uuid_generation_never_panics(_seed in 0u64..1_000_000) {
+            let _ = uuid_module::generate_uuid_v7();
+        }
+    }
+}

package/domainforge-core/src/typescript/authority.rs

@@ -0,0 +1,184 @@
+use crate::authority::{
+    AuthorityEnvironment as RustAuthorityEnvironment,
+    AuthorityEnvironmentConfig as RustAuthorityEnvironmentConfig, ClaimLevel as RustClaimLevel,
+    FactEnvelope as RustFactEnvelope, FinalDecision as RustFinalDecision,
+    PolicyModality as RustPolicyModality, SourceClass as RustSourceClass,
+};
+use napi_derive::napi;
+
+// =============================================================================
+// Enums
+// =============================================================================
+
+#[napi]
+pub enum FinalDecision {
+    Allow,
+    Deny,
+    Escalate,
+    NotApplicable,
+    Reject,
+}
+
+impl From<FinalDecision> for RustFinalDecision {
+    fn from(v: FinalDecision) -> Self {
+        match v {
+            FinalDecision::Allow => RustFinalDecision::Allow,
+            FinalDecision::Deny => RustFinalDecision::Deny,
+            FinalDecision::Escalate => RustFinalDecision::Escalate,
+            FinalDecision::NotApplicable => RustFinalDecision::NotApplicable,
+            FinalDecision::Reject => RustFinalDecision::Reject,
+        }
+    }
+}
+
+impl From<RustFinalDecision> for FinalDecision {
+    fn from(v: RustFinalDecision) -> Self {
+        match v {
+            RustFinalDecision::Allow => FinalDecision::Allow,
+            RustFinalDecision::Deny => FinalDecision::Deny,
+            RustFinalDecision::Escalate => FinalDecision::Escalate,
+            RustFinalDecision::NotApplicable => FinalDecision::NotApplicable,
+            RustFinalDecision::Reject => FinalDecision::Reject,
+        }
+    }
+}
+
+#[napi]
+pub enum PolicyModality {
+    Permission,
+    Prohibition,
+    Obligation,
+    Override,
+}
+
+impl From<PolicyModality> for RustPolicyModality {
+    fn from(v: PolicyModality) -> Self {
+        match v {
+            PolicyModality::Permission => RustPolicyModality::Permission,
+            PolicyModality::Prohibition => RustPolicyModality::Prohibition,
+            PolicyModality::Obligation => RustPolicyModality::Obligation,
+            PolicyModality::Override => RustPolicyModality::Override,
+        }
+    }
+}
+
+impl From<RustPolicyModality> for PolicyModality {
+    fn from(v: RustPolicyModality) -> Self {
+        match v {
+            RustPolicyModality::Permission => PolicyModality::Permission,
+            RustPolicyModality::Prohibition => PolicyModality::Prohibition,
+            RustPolicyModality::Obligation => PolicyModality::Obligation,
+            RustPolicyModality::Override => PolicyModality::Override,
+        }
+    }
+}
+
+#[napi]
+pub enum SourceClass {
+    CallerSupplied,
+    RuntimeObserved,
+    SystemOfRecord,
+    Attested,
+    ManualApproval,
+    Derived,
+    UnknownSource,
+}
+
+impl From<SourceClass> for RustSourceClass {
+    fn from(v: SourceClass) -> Self {
+        match v {
+            SourceClass::CallerSupplied => RustSourceClass::CallerSupplied,
+            SourceClass::RuntimeObserved => RustSourceClass::RuntimeObserved,
+            SourceClass::SystemOfRecord => RustSourceClass::SystemOfRecord,
+            SourceClass::Attested => RustSourceClass::Attested,
+            SourceClass::ManualApproval => RustSourceClass::ManualApproval,
+            SourceClass::Derived => RustSourceClass::Derived,
+            SourceClass::UnknownSource => RustSourceClass::UnknownSource,
+        }
+    }
+}
+
+impl From<RustSourceClass> for SourceClass {
+    fn from(v: RustSourceClass) -> Self {
+        match v {
+            RustSourceClass::CallerSupplied => SourceClass::CallerSupplied,
+            RustSourceClass::RuntimeObserved => SourceClass::RuntimeObserved,
+            RustSourceClass::SystemOfRecord => SourceClass::SystemOfRecord,
+            RustSourceClass::Attested => SourceClass::Attested,
+            RustSourceClass::ManualApproval => SourceClass::ManualApproval,
+            RustSourceClass::Derived => SourceClass::Derived,
+            RustSourceClass::UnknownSource => SourceClass::UnknownSource,
+        }
+    }
+}
+
+#[napi]
+pub enum ClaimLevel {
+    AuditBacked,
+    Validated,
+    FormallyProven,
+}
+
+impl From<ClaimLevel> for RustClaimLevel {
+    fn from(v: ClaimLevel) -> Self {
+        match v {
+            ClaimLevel::AuditBacked => RustClaimLevel::AuditBacked,
+            ClaimLevel::Validated => RustClaimLevel::Validated,
+            ClaimLevel::FormallyProven => RustClaimLevel::FormallyProven,
+        }
+    }
+}
+
+impl From<RustClaimLevel> for ClaimLevel {
+    fn from(v: RustClaimLevel) -> Self {
+        match v {
+            RustClaimLevel::AuditBacked => ClaimLevel::AuditBacked,
+            RustClaimLevel::Validated => ClaimLevel::Validated,
+            RustClaimLevel::FormallyProven => ClaimLevel::FormallyProven,
+        }
+    }
+}
+
+// =============================================================================
+// Functions
+// =============================================================================
+
+/// Evaluate an authority request against a policy environment.
+#[napi]
+pub fn evaluate_authority(
+    config_json: String,
+    request_json: String,
+    facts_json: Option<String>,
+) -> napi::Result<EvaluateAuthorityResult> {
+    let facts = facts_json.unwrap_or_else(|| "[]".to_string());
+
+    let config: RustAuthorityEnvironmentConfig = serde_json::from_str(&config_json)
+        .map_err(|e| napi::Error::from_reason(format!("Invalid config: {}", e)))?;
+    let mut env = RustAuthorityEnvironment::new(config)
+        .map_err(|e| napi::Error::from_reason(format!("Environment error: {}", e)))?;
+    env.validate()
+        .map_err(|e| napi::Error::from_reason(format!("Validation error: {}", e)))?;
+
+    let request: crate::authority::AuthorityRequest = serde_json::from_str(&request_json)
+        .map_err(|e| napi::Error::from_reason(format!("Invalid request: {}", e)))?;
+    let fact_envs: Vec<RustFactEnvelope> = serde_json::from_str(&facts)
+        .map_err(|e| napi::Error::from_reason(format!("Invalid facts: {}", e)))?;
+
+    let (trace, decision) = env
+        .evaluate(&request, &fact_envs)
+        .map_err(|e| napi::Error::from_reason(format!("Evaluation error: {}", e)))?;
+
+    Ok(EvaluateAuthorityResult {
+        trace_json: serde_json::to_string(&trace)
+            .map_err(|e| napi::Error::from_reason(format!("Trace serialization error: {}", e)))?,
+        decision_json: serde_json::to_string(&decision).map_err(|e| {
+            napi::Error::from_reason(format!("Decision serialization error: {}", e))
+        })?,
+    })
+}
+
+#[napi(object)]
+pub struct EvaluateAuthorityResult {
+    pub trace_json: String,
+    pub decision_json: String,
+}