@yiaany/ghostapi 0.1.8 → 0.2.0

package/dist/trust/trustLadder.js

@@ -3,7 +3,7 @@ import { lstat, readFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { getDataPaths } from "../config/dataPaths.js";
 import { sanitizeSecretString } from "../security/secrets.js";
-import { atomicWriteJson, ensurePrivateDirectory, withFileLock } from "../storage/fileStore.js";
+import { atomicWriteJson, ensurePrivateDirectory, withFileLock, } from "../storage/fileStore.js";
 const SCHEMA_VERSION = 1;
 const MAX_STORE_BYTES = 1024 * 1024;
 const MAX_TARGETS = 1_000;
@@ -12,7 +12,14 @@ const MAX_EVALS = 100;
 const IDENTIFIER = /^[a-z0-9][a-z0-9._-]{0,127}$/;
 const HASH = /^[a-f0-9]{64}$/;
 const MAX_FRESHNESS_MS = 30 * 24 * 60 * 60 * 1000;
-export const TRUST_LEVELS = ["simulate", "shadow", "dry-run", "approve", "bounded-auto", "trusted"];
+export const TRUST_LEVELS = [
+    "simulate",
+    "shadow",
+    "dry-run",
+    "approve",
+    "bounded-auto",
+    "trusted",
+];
 export class TrustLadderError extends Error {
     constructor(message) {
         super(message);
@@ -27,12 +34,39 @@ export function createLocalSyntheticTrustCapabilities() {
         environment: "synthetic",
         levels: [
             { level: "simulate", status: "supported", externalSideEffects: false },
-            { level: "shadow", status: "supported", externalSideEffects: false, requiresActualContext: true },
-            { level: "dry-run", status: "unsupported", externalSideEffects: false, requiresOfficialProviderSemantics: true, reason: "ghostapi-synthetic has no provider-official dry-run semantic." },
-            { level: "approve", status: "supported", externalSideEffects: false, requiresApproval: true },
-            { level: "bounded-auto", status: "supported", externalSideEffects: false, requiresCanary: true, requiresOutcomeComparison: true },
-            { level: "trusted", status: "unsupported", externalSideEffects: false, reason: "The local synthetic runtime is not production authorization." }
-        ]
+            {
+                level: "shadow",
+                status: "supported",
+                externalSideEffects: false,
+                requiresActualContext: true,
+            },
+            {
+                level: "dry-run",
+                status: "unsupported",
+                externalSideEffects: false,
+                requiresOfficialProviderSemantics: true,
+                reason: "ghostapi-synthetic has no provider-official dry-run semantic.",
+            },
+            {
+                level: "approve",
+                status: "supported",
+                externalSideEffects: false,
+                requiresApproval: true,
+            },
+            {
+                level: "bounded-auto",
+                status: "supported",
+                externalSideEffects: false,
+                requiresCanary: true,
+                requiresOutcomeComparison: true,
+            },
+            {
+                level: "trusted",
+                status: "unsupported",
+                externalSideEffects: false,
+                reason: "The local synthetic runtime is not production authorization.",
+            },
+        ],
     };
 }
 export function createLocalTrustLadder(options) {
@@ -106,7 +140,9 @@ export class LocalTrustLadder {
             const current = findOrCreateTarget(state, prediction.target, now);
             assertActiveLevel(current, "shadow");
             const evidence = comparisonEvidence(prediction.target, "shadow", observationHash(prediction), observationHash(actual), now);
-            appendAudit(state, "shadow.compared", current, undefined, undefined, evidence.matched ? "predicted action matches actual input context" : "predicted action differs from actual input context", now);
+            appendAudit(state, "shadow.compared", current, undefined, undefined, evidence.matched
+                ? "predicted action matches actual input context"
+                : "predicted action differs from actual input context", now);
             return evidence;
         });
     }
@@ -119,7 +155,9 @@ export class LocalTrustLadder {
             const current = findOrCreateTarget(state, prediction.target, now);
             assertActiveLevel(current, "bounded-auto");
             const evidence = comparisonEvidence(prediction.target, "bounded-auto", outcomeHash(prediction), outcomeHash(actual), now);
-            appendAudit(state, "bounded.outcome_compared", current, undefined, undefined, evidence.matched ? "predicted and actual bounded outcomes match" : "predicted and actual bounded outcomes differ", now);
+            appendAudit(state, "bounded.outcome_compared", current, undefined, undefined, evidence.matched
+                ? "predicted and actual bounded outcomes match"
+                : "predicted and actual bounded outcomes differ", now);
             return evidence;
         });
     }
@@ -144,14 +182,23 @@ export class LocalTrustLadder {
                 current.canary.errors += 1;
             current.updatedAt = now;
             appendAudit(state, "canary.outcome", current, undefined, undefined, reason, now);
-            if (outcome === "violation" && policy.violationResponse === "demote_to_approve") {
+            if (outcome === "violation" &&
+                policy.violationResponse === "demote_to_approve") {
                 const previous = current.level;
                 current.level = "approve";
                 appendAudit(state, "trust.auto_demoted", current, previous, "approve", "policy violation automatically returned trust to approval mode", now);
             }
-            if ((outcome === "violation" && policy.violationResponse === "open_circuit_breaker") || (current.canary.violations > 0 && current.canary.violations >= policy.stopConditions.maxViolations) || (current.canary.errors > 0 && current.canary.errors >= policy.stopConditions.maxErrors)) {
+            if ((outcome === "violation" &&
+                policy.violationResponse === "open_circuit_breaker") ||
+                (current.canary.violations > 0 &&
+                    current.canary.violations >= policy.stopConditions.maxViolations) ||
+                (current.canary.errors > 0 &&
+                    current.canary.errors >= policy.stopConditions.maxErrors)) {
                 current.circuitBreaker = "open";
-                appendAudit(state, "canary.circuit_opened", current, undefined, undefined, outcome === "violation" && policy.violationResponse === "open_circuit_breaker" ? "policy violation opened the configured circuit breaker" : "configured canary stop condition was breached", now);
+                appendAudit(state, "canary.circuit_opened", current, undefined, undefined, outcome === "violation" &&
+                    policy.violationResponse === "open_circuit_breaker"
+                    ? "policy violation opened the configured circuit breaker"
+                    : "configured canary stop condition was breached", now);
             }
             return clone(current);
         });
@@ -214,33 +261,62 @@ export function createTestTrustOwnerVerifier() {
     return {
         verifier: {
             async authenticate(identity) {
-                if (identity === null || typeof identity !== "object" || !issued.has(identity))
+                if (identity === null ||
+                    typeof identity !== "object" ||
+                    !issued.has(identity))
                     throw new TrustLadderError("Trust owner identity is not authenticated.");
                 return validateOwner(identity);
-            }
+            },
         },
         issue(input) {
             const owner = Object.freeze(validateOwner({ ...input, principalId: input.principalId ?? input.id }));
             issued.add(owner);
             return owner;
-        }
+        },
     };
 }
 function validateCapabilities(value) {
     const capabilities = object(value, "Trust capabilities are invalid.");
     exactKeys(capabilities, ["schemaVersion", "kind", "provider", "environment", "levels"], "Trust capabilities");
-    if (capabilities.schemaVersion !== SCHEMA_VERSION || capabilities.kind !== "ghostapi.trust-capabilities" || capabilities.provider !== "ghostapi-synthetic" || capabilities.environment !== "synthetic")
+    if (capabilities.schemaVersion !== SCHEMA_VERSION ||
+        capabilities.kind !== "ghostapi.trust-capabilities" ||
+        capabilities.provider !== "ghostapi-synthetic" ||
+        capabilities.environment !== "synthetic")
         throw new TrustLadderError("Only local synthetic trust capabilities are available.");
     const levels = array(capabilities.levels, "Trust level capabilities", TRUST_LEVELS.length).map(validateCapability);
-    if (levels.length !== TRUST_LEVELS.length || levels.some((capability, index) => capability.level !== TRUST_LEVELS[index]))
+    if (levels.length !== TRUST_LEVELS.length ||
+        levels.some((capability, index) => capability.level !== TRUST_LEVELS[index]))
         throw new TrustLadderError("Trust capabilities must define every level in stable order.");
     if (levels.some((capability) => capability.externalSideEffects))
         throw new TrustLadderError("Local trust capabilities cannot enable external side effects.");
-    return { schemaVersion: 1, kind: "ghostapi.trust-capabilities", provider: "ghostapi-synthetic", environment: "synthetic", levels };
+    return {
+        schemaVersion: 1,
+        kind: "ghostapi.trust-capabilities",
+        provider: "ghostapi-synthetic",
+        environment: "synthetic",
+        levels,
+    };
 }
 function validateCapability(value) {
     const capability = object(value, "Trust level capability is invalid.");
-    exactKeys(capability, ["level", "status", "externalSideEffects", "requiresActualContext", "requiresOfficialProviderSemantics", "requiresApproval", "requiresCanary", "requiresOutcomeComparison", "reason"], "Trust level capability", ["requiresActualContext", "requiresOfficialProviderSemantics", "requiresApproval", "requiresCanary", "requiresOutcomeComparison", "reason"]);
+    exactKeys(capability, [
+        "level",
+        "status",
+        "externalSideEffects",
+        "requiresActualContext",
+        "requiresOfficialProviderSemantics",
+        "requiresApproval",
+        "requiresCanary",
+        "requiresOutcomeComparison",
+        "reason",
+    ], "Trust level capability", [
+        "requiresActualContext",
+        "requiresOfficialProviderSemantics",
+        "requiresApproval",
+        "requiresCanary",
+        "requiresOutcomeComparison",
+        "reason",
+    ]);
     const level = trustLevel(capability.level, "Trust capability level");
     if (capability.status !== "supported" && capability.status !== "unsupported")
         throw new TrustLadderError("Trust capability status is invalid.");
@@ -251,21 +327,54 @@ function validateCapability(value) {
     const requiresApproval = booleanFlag(capability.requiresApproval, "Trust capability flag");
     const requiresCanary = booleanFlag(capability.requiresCanary, "Trust capability flag");
     const requiresOutcomeComparison = booleanFlag(capability.requiresOutcomeComparison, "Trust capability flag");
-    const reason = capability.reason === undefined ? undefined : text(capability.reason, "Trust capability reason", 200);
+    const reason = capability.reason === undefined
+        ? undefined
+        : text(capability.reason, "Trust capability reason", 200);
     if (capability.status === "unsupported" && reason === undefined)
         throw new TrustLadderError("Unsupported trust capability requires a reason.");
-    return { level, status: capability.status, externalSideEffects: false, ...(requiresActualContext === undefined ? {} : { requiresActualContext }), ...(requiresOfficialProviderSemantics === undefined ? {} : { requiresOfficialProviderSemantics }), ...(requiresApproval === undefined ? {} : { requiresApproval }), ...(requiresCanary === undefined ? {} : { requiresCanary }), ...(requiresOutcomeComparison === undefined ? {} : { requiresOutcomeComparison }), ...(reason === undefined ? {} : { reason }) };
+    return {
+        level,
+        status: capability.status,
+        externalSideEffects: false,
+        ...(requiresActualContext === undefined ? {} : { requiresActualContext }),
+        ...(requiresOfficialProviderSemantics === undefined
+            ? {}
+            : { requiresOfficialProviderSemantics }),
+        ...(requiresApproval === undefined ? {} : { requiresApproval }),
+        ...(requiresCanary === undefined ? {} : { requiresCanary }),
+        ...(requiresOutcomeComparison === undefined
+            ? {}
+            : { requiresOutcomeComparison }),
+        ...(reason === undefined ? {} : { reason }),
+    };
 }
 function validatePolicy(value) {
     const policy = object(value, "Trust promotion policy is invalid.");
-    exactKeys(policy, ["schemaVersion", "kind", "id", "ownerPrincipalId", "automaticPromotion", "minimumRuns", "requiredEvalIds", "maxViolationRateBps", "maxErrorRateBps", "evidenceFreshnessMs", "canary", "stopConditions", "violationResponse"], "Trust promotion policy");
-    if (policy.schemaVersion !== SCHEMA_VERSION || policy.kind !== "ghostapi.trust-promotion-policy" || policy.automaticPromotion !== false)
+    exactKeys(policy, [
+        "schemaVersion",
+        "kind",
+        "id",
+        "ownerPrincipalId",
+        "automaticPromotion",
+        "minimumRuns",
+        "requiredEvalIds",
+        "maxViolationRateBps",
+        "maxErrorRateBps",
+        "evidenceFreshnessMs",
+        "canary",
+        "stopConditions",
+        "violationResponse",
+    ], "Trust promotion policy");
+    if (policy.schemaVersion !== SCHEMA_VERSION ||
+        policy.kind !== "ghostapi.trust-promotion-policy" ||
+        policy.automaticPromotion !== false)
         throw new TrustLadderError("Automatic trust promotion is disabled.");
     const canary = object(policy.canary, "Trust canary scope is invalid.");
     exactKeys(canary, ["tenantIds", "resourceIds", "percentageBps"], "Trust canary scope");
     const stopConditions = object(policy.stopConditions, "Trust canary stop conditions are invalid.");
     exactKeys(stopConditions, ["maxViolations", "maxErrors"], "Trust canary stop conditions");
-    if (policy.violationResponse !== "demote_to_approve" && policy.violationResponse !== "open_circuit_breaker")
+    if (policy.violationResponse !== "demote_to_approve" &&
+        policy.violationResponse !== "open_circuit_breaker")
         throw new TrustLadderError("Trust violation response is invalid.");
     return {
         schemaVersion: 1,
@@ -278,9 +387,16 @@ function validatePolicy(value) {
         maxViolationRateBps: bps(policy.maxViolationRateBps, "Trust maximum violation rate"),
         maxErrorRateBps: bps(policy.maxErrorRateBps, "Trust maximum error rate"),
         evidenceFreshnessMs: positive(policy.evidenceFreshnessMs, "Trust evidence freshness", MAX_FRESHNESS_MS),
-        canary: { tenantIds: identifiers(canary.tenantIds, "Trust canary tenant ids", MAX_TARGETS, true), resourceIds: identifiers(canary.resourceIds, "Trust canary resource ids", MAX_TARGETS, true), percentageBps: bps(canary.percentageBps, "Trust canary percentage") },
-        stopConditions: { maxViolations: nonNegative(stopConditions.maxViolations, "Trust canary maximum violations", 1_000_000), maxErrors: nonNegative(stopConditions.maxErrors, "Trust canary maximum errors", 1_000_000) },
-        violationResponse: policy.violationResponse
+        canary: {
+            tenantIds: identifiers(canary.tenantIds, "Trust canary tenant ids", MAX_TARGETS, true),
+            resourceIds: identifiers(canary.resourceIds, "Trust canary resource ids", MAX_TARGETS, true),
+            percentageBps: bps(canary.percentageBps, "Trust canary percentage"),
+        },
+        stopConditions: {
+            maxViolations: nonNegative(stopConditions.maxViolations, "Trust canary maximum violations", 1_000_000),
+            maxErrors: nonNegative(stopConditions.maxErrors, "Trust canary maximum errors", 1_000_000),
+        },
+        violationResponse: policy.violationResponse,
     };
 }
 function validateEvidence(value) {
@@ -294,32 +410,61 @@ function validateEvidence(value) {
         exactKeys(evaluation, ["id", "status", "completedAt"], "Trust evidence eval");
         if (evaluation.status !== "passed" && evaluation.status !== "failed")
             throw new TrustLadderError("Trust evidence eval status is invalid.");
-        return { id: identifier(evaluation.id, "Trust evidence eval id"), status: evaluation.status, completedAt: timestamp(evaluation.completedAt, "Trust evidence eval completion") };
+        return {
+            id: identifier(evaluation.id, "Trust evidence eval id"),
+            status: evaluation.status,
+            completedAt: timestamp(evaluation.completedAt, "Trust evidence eval completion"),
+        };
     });
     unique(evals.map((evaluation) => evaluation.id), "Trust evidence eval ids");
-    return { runCount, violations, errors, evals, observedAt: timestamp(evidence.observedAt, "Trust evidence observation time") };
+    return {
+        runCount,
+        violations,
+        errors,
+        evals,
+        observedAt: timestamp(evidence.observedAt, "Trust evidence observation time"),
+    };
 }
 function validateTarget(value) {
     const target = object(value, "Trust target is invalid.");
     exactKeys(target, ["provider", "environment", "tenantId", "resourceId"], "Trust target");
-    if (target.provider !== "ghostapi-synthetic" || target.environment !== "synthetic")
+    if (target.provider !== "ghostapi-synthetic" ||
+        target.environment !== "synthetic")
         throw new TrustLadderError("Local trust preparation accepts synthetic identities only; production identities are unsupported.");
-    return { provider: "ghostapi-synthetic", environment: "synthetic", tenantId: identifier(target.tenantId, "Trust target tenant id"), resourceId: identifier(target.resourceId, "Trust target resource id") };
+    return {
+        provider: "ghostapi-synthetic",
+        environment: "synthetic",
+        tenantId: identifier(target.tenantId, "Trust target tenant id"),
+        resourceId: identifier(target.resourceId, "Trust target resource id"),
+    };
 }
 function validateObservation(value) {
     const observation = object(value, "Shadow observation is invalid.");
     exactKeys(observation, ["target", "actionHash", "operation", "contextHash"], "Shadow observation");
-    return { target: validateTarget(observation.target), actionHash: hash(observation.actionHash, "Shadow action hash"), operation: identifier(observation.operation, "Shadow operation"), contextHash: hash(observation.contextHash, "Shadow context hash") };
+    return {
+        target: validateTarget(observation.target),
+        actionHash: hash(observation.actionHash, "Shadow action hash"),
+        operation: identifier(observation.operation, "Shadow operation"),
+        contextHash: hash(observation.contextHash, "Shadow context hash"),
+    };
 }
 function validateOutcomeObservation(value) {
     const observation = object(value, "Bounded outcome observation is invalid.");
     exactKeys(observation, ["target", "actionHash", "outcomeHash", "executionReceiptHash"], "Bounded outcome observation");
-    return { target: validateTarget(observation.target), actionHash: hash(observation.actionHash, "Bounded action hash"), outcomeHash: hash(observation.outcomeHash, "Bounded outcome hash"), executionReceiptHash: hash(observation.executionReceiptHash, "Bounded execution receipt hash") };
+    return {
+        target: validateTarget(observation.target),
+        actionHash: hash(observation.actionHash, "Bounded action hash"),
+        outcomeHash: hash(observation.outcomeHash, "Bounded outcome hash"),
+        executionReceiptHash: hash(observation.executionReceiptHash, "Bounded execution receipt hash"),
+    };
 }
 function validateOwner(value) {
     const owner = object(value, "Trust owner identity is invalid.");
     exactKeys(owner, ["id", "principalId"], "Trust owner identity");
-    return { id: identifier(owner.id, "Trust owner id"), principalId: identifier(owner.principalId, "Trust owner principal id") };
+    return {
+        id: identifier(owner.id, "Trust owner id"),
+        principalId: identifier(owner.principalId, "Trust owner principal id"),
+    };
 }
 function validateState(value) {
     const state = object(value, "Trust ladder store must be an object.");
@@ -343,22 +488,43 @@ function validateTargetState(value) {
     const errors = nonNegative(canary.errors, "Trust canary error count", observed);
     if (state.circuitBreaker !== "closed" && state.circuitBreaker !== "open")
         throw new TrustLadderError("Trust circuit breaker state is invalid.");
-    return { target: validateTarget(state.target), level: trustLevel(state.level, "Trust target level"), circuitBreaker: state.circuitBreaker, canary: { observed, violations, errors }, updatedAt: timestamp(state.updatedAt, "Trust target update time") };
+    return {
+        target: validateTarget(state.target),
+        level: trustLevel(state.level, "Trust target level"),
+        circuitBreaker: state.circuitBreaker,
+        canary: { observed, violations, errors },
+        updatedAt: timestamp(state.updatedAt, "Trust target update time"),
+    };
 }
 function validateAudit(value) {
     const record = object(value, "Trust audit record is invalid.");
-    exactKeys(record, ["sequence", "event", "targetKey", "fromLevel", "toLevel", "reason", "timestamp", "previousHash", "recordHash"], "Trust audit record", ["fromLevel", "toLevel"]);
+    exactKeys(record, [
+        "sequence",
+        "event",
+        "targetKey",
+        "fromLevel",
+        "toLevel",
+        "reason",
+        "timestamp",
+        "previousHash",
+        "recordHash",
+    ], "Trust audit record", ["fromLevel", "toLevel"]);
     const base = {
         sequence: positive(record.sequence, "Trust audit sequence", MAX_AUDIT),
         event: text(record.event, "Trust audit event", 80),
         targetKey: identifier(record.targetKey, "Trust audit target key"),
-        ...(record.fromLevel === undefined ? {} : { fromLevel: trustLevel(record.fromLevel, "Trust audit from level") }),
-        ...(record.toLevel === undefined ? {} : { toLevel: trustLevel(record.toLevel, "Trust audit to level") }),
+        ...(record.fromLevel === undefined
+            ? {}
+            : { fromLevel: trustLevel(record.fromLevel, "Trust audit from level") }),
+        ...(record.toLevel === undefined
+            ? {}
+            : { toLevel: trustLevel(record.toLevel, "Trust audit to level") }),
         reason: text(record.reason, "Trust audit reason", 200),
         timestamp: timestamp(record.timestamp, "Trust audit timestamp"),
-        previousHash: hash(record.previousHash, "Trust audit previous hash")
+        previousHash: hash(record.previousHash, "Trust audit previous hash"),
     };
-    if (hash(record.recordHash, "Trust audit record hash") !== sha256(canonical(base)))
+    if (hash(record.recordHash, "Trust audit record hash") !==
+        sha256(canonical(base)))
         throw new TrustLadderError("Trust audit record hash is invalid.");
     return { ...base, recordHash: record.recordHash };
 }
@@ -373,7 +539,12 @@ function validateAuditChain(anchor, records) {
     }
 }
 function emptyState() {
-    return { schemaVersion: 1, targets: [], auditAnchor: sha256("ghostapi.trust.audit.v1"), audit: [] };
+    return {
+        schemaVersion: 1,
+        targets: [],
+        auditAnchor: sha256("ghostapi.trust.audit.v1"),
+        audit: [],
+    };
 }
 function findOrCreateTarget(state, target, now) {
     const existing = state.targets.find((candidate) => sameTarget(candidate.target, target));
@@ -381,7 +552,13 @@ function findOrCreateTarget(state, target, now) {
         return existing;
     if (state.targets.length >= MAX_TARGETS)
         throw new TrustLadderError("Trust target limit was reached.");
-    const created = { target: clone(target), level: "simulate", circuitBreaker: "closed", canary: { observed: 0, violations: 0, errors: 0 }, updatedAt: now };
+    const created = {
+        target: clone(target),
+        level: "simulate",
+        circuitBreaker: "closed",
+        canary: { observed: 0, violations: 0, errors: 0 },
+        updatedAt: now,
+    };
     state.targets.push(created);
     return created;
 }
@@ -390,7 +567,8 @@ function assertPromotionEvidence(evidence, policy, now) {
         throw new TrustLadderError("Trust promotion evidence has too few runs.");
     if (Date.parse(evidence.observedAt) > Date.parse(now))
         throw new TrustLadderError("Trust promotion evidence is from the future.");
-    if (Date.parse(now) - Date.parse(evidence.observedAt) > policy.evidenceFreshnessMs)
+    if (Date.parse(now) - Date.parse(evidence.observedAt) >
+        policy.evidenceFreshnessMs)
         throw new TrustLadderError("Trust promotion evidence is stale.");
     for (const required of policy.requiredEvalIds) {
         const evaluation = evidence.evals.find((candidate) => candidate.id === required);
@@ -398,7 +576,8 @@ function assertPromotionEvidence(evidence, policy, now) {
             throw new TrustLadderError(`Trust promotion requires passing eval: ${required}`);
         if (Date.parse(evaluation.completedAt) > Date.parse(now))
             throw new TrustLadderError(`Trust promotion eval is from the future: ${required}`);
-        if (Date.parse(now) - Date.parse(evaluation.completedAt) > policy.evidenceFreshnessMs)
+        if (Date.parse(now) - Date.parse(evaluation.completedAt) >
+            policy.evidenceFreshnessMs)
             throw new TrustLadderError(`Trust promotion eval is stale: ${required}`);
     }
     if (rateBps(evidence.violations, evidence.runCount) > policy.maxViolationRateBps)
@@ -420,20 +599,54 @@ function capabilityFor(capabilities, level) {
     return capability;
 }
 function canaryDecision(target, policy) {
-    if (policy.canary.tenantIds.length > 0 && !policy.canary.tenantIds.includes(target.tenantId))
-        return { target: clone(target), assigned: false, bucket: deterministicBucket(policy.id, target), reason: "tenant is outside the configured canary scope" };
-    if (policy.canary.resourceIds.length > 0 && !policy.canary.resourceIds.includes(target.resourceId))
-        return { target: clone(target), assigned: false, bucket: deterministicBucket(policy.id, target), reason: "resource is outside the configured canary scope" };
+    if (policy.canary.tenantIds.length > 0 &&
+        !policy.canary.tenantIds.includes(target.tenantId))
+        return {
+            target: clone(target),
+            assigned: false,
+            bucket: deterministicBucket(policy.id, target),
+            reason: "tenant is outside the configured canary scope",
+        };
+    if (policy.canary.resourceIds.length > 0 &&
+        !policy.canary.resourceIds.includes(target.resourceId))
+        return {
+            target: clone(target),
+            assigned: false,
+            bucket: deterministicBucket(policy.id, target),
+            reason: "resource is outside the configured canary scope",
+        };
     const bucket = deterministicBucket(policy.id, target);
     return bucket < policy.canary.percentageBps
-        ? { target: clone(target), assigned: true, bucket, reason: "target is inside deterministic canary scope" }
-        : { target: clone(target), assigned: false, bucket, reason: "target is outside the configured canary percentage" };
+        ? {
+            target: clone(target),
+            assigned: true,
+            bucket,
+            reason: "target is inside deterministic canary scope",
+        }
+        : {
+            target: clone(target),
+            assigned: false,
+            bucket,
+            reason: "target is outside the configured canary percentage",
+        };
 }
 function deterministicBucket(policyId, target) {
-    return createHash("sha256").update(`ghostapi.trust.canary.v1:${policyId}:${targetKey(target)}`, "utf8").digest().readUInt32BE(0) % 10_000;
+    return (createHash("sha256")
+        .update(`ghostapi.trust.canary.v1:${policyId}:${targetKey(target)}`, "utf8")
+        .digest()
+        .readUInt32BE(0) % 10_000);
 }
 function comparisonEvidence(target, level, predictedHash, actualHash, observedAt) {
-    return { schemaVersion: 1, kind: "ghostapi.trust-comparison", target: clone(target), level, matched: predictedHash === actualHash, predictedHash, actualHash, observedAt };
+    return {
+        schemaVersion: 1,
+        kind: "ghostapi.trust-comparison",
+        target: clone(target),
+        level,
+        matched: predictedHash === actualHash,
+        predictedHash,
+        actualHash,
+        observedAt,
+    };
 }
 function observationHash(value) {
     return sha256(canonical(value));
@@ -445,7 +658,16 @@ function appendAudit(state, event, target, fromLevel, toLevel, reason, timestamp
     if (state.audit.length >= MAX_AUDIT)
         throw new TrustLadderError("Trust audit limit was reached.");
     const previousHash = state.audit.at(-1)?.recordHash ?? state.auditAnchor;
-    const base = { sequence: state.audit.length + 1, event: text(event, "Trust audit event", 80), targetKey: targetKey(target.target), ...(fromLevel === undefined ? {} : { fromLevel }), ...(toLevel === undefined ? {} : { toLevel }), reason: text(reason, "Trust audit reason", 200), timestamp: timestampValue, previousHash };
+    const base = {
+        sequence: state.audit.length + 1,
+        event: text(event, "Trust audit event", 80),
+        targetKey: targetKey(target.target),
+        ...(fromLevel === undefined ? {} : { fromLevel }),
+        ...(toLevel === undefined ? {} : { toLevel }),
+        reason: text(reason, "Trust audit reason", 200),
+        timestamp: timestampValue,
+        previousHash,
+    };
     state.audit.push({ ...base, recordHash: sha256(canonical(base)) });
 }
 function assertActiveLevel(state, level) {
@@ -455,7 +677,10 @@ function assertActiveLevel(state, level) {
         throw new TrustLadderError(`Trust target is not active at ${level}.`);
 }
 function sameTarget(left, right) {
-    return left.provider === right.provider && left.environment === right.environment && left.tenantId === right.tenantId && left.resourceId === right.resourceId;
+    return (left.provider === right.provider &&
+        left.environment === right.environment &&
+        left.tenantId === right.tenantId &&
+        left.resourceId === right.resourceId);
 }
 function targetKey(target) {
     return `target-${sha256(canonical(target)).slice(0, 32)}`;
@@ -471,7 +696,9 @@ function canaryOutcome(value) {
     return value;
 }
 function identifier(value, label) {
-    if (typeof value !== "string" || !IDENTIFIER.test(value) || sanitizeSecretString(value) !== value)
+    if (typeof value !== "string" ||
+        !IDENTIFIER.test(value) ||
+        sanitizeSecretString(value) !== value)
         throw new TrustLadderError(`${label} must be a safe identifier.`);
     return value;
 }
@@ -488,17 +715,25 @@ function hash(value, label) {
     return value;
 }
 function timestamp(value, label) {
-    if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value) || !Number.isFinite(Date.parse(value)))
+    if (typeof value !== "string" ||
+        !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value) ||
+        !Number.isFinite(Date.parse(value)))
         throw new TrustLadderError(`${label} must be an ISO UTC timestamp.`);
     return value;
 }
 function positive(value, label, max) {
-    if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > max)
+    if (typeof value !== "number" ||
+        !Number.isInteger(value) ||
+        value < 1 ||
+        value > max)
         throw new TrustLadderError(`${label} is invalid.`);
     return value;
 }
 function nonNegative(value, label, max) {
-    if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > max)
+    if (typeof value !== "number" ||
+        !Number.isInteger(value) ||
+        value < 0 ||
+        value > max)
         throw new TrustLadderError(`${label} is invalid.`);
     return value;
 }
@@ -516,7 +751,11 @@ function rateBps(count, total) {
     return total === 0 ? 10_000 : Math.floor((count * 10_000) / total);
 }
 function text(value, label, maxLength) {
-    if (typeof value !== "string" || value.trim() === "" || value.length > maxLength || /[\u0000-\u001f]/.test(value) || sanitizeSecretString(value) !== value)
+    if (typeof value !== "string" ||
+        value.trim() === "" ||
+        value.length > maxLength ||
+        /[\u0000-\u001f]/.test(value) ||
+        sanitizeSecretString(value) !== value)
         throw new TrustLadderError(`${label} is invalid.`);
     return value.trim();
 }
@@ -532,7 +771,8 @@ function array(value, label, max) {
 }
 function exactKeys(value, keys, label, optional = []) {
     for (const key of Object.keys(value))
-        if (!keys.includes(key) || (value[key] === undefined && !optional.includes(key)))
+        if (!keys.includes(key) ||
+            (value[key] === undefined && !optional.includes(key)))
             throw new TrustLadderError(`${label} contains unsupported field: ${key}`);
 }
 function unique(values, label) {
@@ -540,12 +780,18 @@ function unique(values, label) {
         throw new TrustLadderError(`${label} must be unique.`);
 }
 function canonical(value) {
-    if (value === null || typeof value === "boolean" || typeof value === "string" || typeof value === "number")
+    if (value === null ||
+        typeof value === "boolean" ||
+        typeof value === "string" ||
+        typeof value === "number")
         return JSON.stringify(value);
     if (Array.isArray(value))
         return `[${value.map(canonical).join(",")}]`;
     if (typeof value === "object")
-        return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+        return `{${Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
+            .join(",")}}`;
     throw new TrustLadderError("Trust data must be JSON.");
 }
 function sha256(value) {