package gudusoft.gsqlparser.slpc.validation;

import gudusoft.gsqlparser.slpc.identity.SlpcIdentity;
import gudusoft.gsqlparser.slpc.model.SlpcDocument;
import gudusoft.gsqlparser.slpc.model.SlpcObject;

import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;

/** Executable cross-record invariants for SLPC v0.2. */
public final class SlpcSemanticValidator {

    public static final List<String> CAPABILITIES;
    private static final Set<String> CORE_DIAGNOSTICS;
    private static final Pattern SECRET = Pattern.compile(
            "(?i)(?:aws[_-]?(?:secret|access)[_-]?key|secret[_-]?key|access[_-]?token|password)\\s*[:=]\\s*(?!<SLPC-REDACTED)[^\\s,;)]+");

    static {
        ArrayList<String> values = new ArrayList<String>(Arrays.asList(
                "FACT_VALUE", "FACT_ROW_FILTER", "FACT_ROW_JOIN", "FACT_GROUP_BY", "FACT_WINDOW",
                "DATASET_SORT", "PHYSICAL_HOP_COLLAPSE", "DYNAMIC_SQL", "PROCEDURAL_COMPOSITION",
                "SOURCE_LOCATION", "TRANSFORM_EVIDENCE", "EXACT_IDENTIFIER_IDENTITY",
                "AUTHORITATIVE_CATALOG_IDENTITY", "SCOPED_OBJECTS", "OBJECT_RELATIONSHIP",
                "FOREIGN_KEY_RELATIONSHIP", "JOIN_SEMANTICS", "ROW_IMPACT_DETAIL", "STATEMENT_OPERATION",
                "INTERMEDIATE_GRAPH", "INTERACTIVE_EXPLAIN", "LITERAL_PROVENANCE", "SECRET_REDACTION",
                "STORAGE_ASSET_IDENTITY", "ROUTINE_CALL", "ROUTINE_PARAMETER_FLOW",
                "ROUTINE_OVERLOAD_IDENTITY", "STREAM_DEFINITION", "OBJECT_RENAME_SWAP_CLONE",
                "COPY_CLASSIFICATION"));
        Collections.sort(values);
        CAPABILITIES = Collections.unmodifiableList(values);
        CORE_DIAGNOSTICS = Collections.unmodifiableSet(new HashSet<String>(Arrays.asList(
                "SLPC_ADAPTER_CAPABILITY_GAP", "SLPC_IDENTITY_APPROXIMATE", "SLPC_IDENTITY_UNAVAILABLE",
                "SLPC_MALFORMED_IDENTIFIER", "SLPC_ENDPOINT_AMBIGUOUS", "SLPC_ENDPOINT_UNRESOLVED",
                "SLPC_ENDPOINT_NOT_PUBLISHABLE", "SLPC_UNBOUND_RESULT_SET", "SLPC_SCOPE_UNAVAILABLE",
                "SLPC_PSEUDO_COLUMN_REJECTED", "SLPC_INTERMEDIATE_HOP_COLLAPSED",
                "SLPC_INTERMEDIATE_HOP_UNCOLLAPSIBLE", "SLPC_INVALID_AXIS_ROLE_OPERATION", "SLPC_ROLE_UNKNOWN",
                "SLPC_OPERATION_UNSUPPORTED", "SLPC_RELATIONSHIP_UNMAPPED", "SLPC_DYNAMIC_LOW_CONFIDENCE",
                "SLPC_INVALID_REFERENCE", "SLPC_ID_COLLISION", "SLPC_EXTENSION_UNSUPPORTED",
                "SLPC_OBJECT_RELATIONSHIP_UNPUBLISHABLE", "SLPC_LEGACY_FK_DATAFLOW_RECLASSIFIED",
                "SLPC_COMPOSITE_FK_PAIRING_UNPROVEN", "SLPC_COMPOSITE_FK_PAIRING_PROVEN",
                "SLPC_ROUTINE_BINDING_UNPROVEN",
                "SLPC_JOIN_SEMANTICS_PARTIAL", "SLPC_DERIVED_FIELD_EXPANSION", "SLPC_LITERAL_TRUNCATED",
                "SLPC_SECRET_REDACTED", "SLPC_COPY_CLASSIFICATION_CONFLICT", "SLPC_STORAGE_IDENTITY_UNAVAILABLE",
                "SLPC_NON_FACT_TRAVERSAL_UNSUPPORTED", "SLPC_STATEMENT_OPERATION_MISMATCH",
                "SLPC_OBJECT_REBOUND_RISK", "SLPC_INTERMEDIATE_GRAPH_INCOMPLETE")));
    }

    public List<SlpcValidationError> validate(SlpcDocument document) {
        try {
            validateOrThrow(document.root());
            return Collections.emptyList();
        } catch (Failure failure) {
            return Collections.singletonList(new SlpcValidationError(
                    SlpcValidationError.Stage.SEMANTIC, failure.path, failure.getMessage()));
        } catch (IllegalArgumentException failure) {
            return Collections.singletonList(new SlpcValidationError(
                    SlpcValidationError.Stage.SEMANTIC, "$", failure.getMessage()));
        }
    }

    public List<SlpcValidationError> validateProjectionReport(SlpcDocument document, SlpcObject report) {
        try {
            validateProjectionReportOrThrow(document.root(), report);
            return Collections.emptyList();
        } catch (Failure failure) {
            return Collections.singletonList(new SlpcValidationError(
                    SlpcValidationError.Stage.SEMANTIC, failure.path, failure.getMessage()));
        } catch (IllegalArgumentException failure) {
            return Collections.singletonList(new SlpcValidationError(
                    SlpcValidationError.Stage.SEMANTIC, "$", failure.getMessage()));
        }
    }

    public void validateProjectionReportOrThrow(SlpcObject document, SlpcObject report) {
        String[] collections = {"facts", "factCandidates", "datasetOperationInfluences", "datasetOperationCandidates",
                "objectRelationships", "objectRelationshipCandidates", "statementOperations", "joinSemantics", "intermediateGraphs"};
        String[] kinds = {"FACT", "FACT_CANDIDATE", "DATASET_OPERATION", "DATASET_OPERATION_CANDIDATE",
                "OBJECT_RELATIONSHIP", "OBJECT_RELATIONSHIP_CANDIDATE", "STATEMENT_OPERATION", "JOIN_SEMANTICS", "INTERMEDIATE_GRAPH"};
        String[] ids = {"factId", "candidateId", "influenceId", "candidateId", "relationshipId", "candidateId",
                "statementOperationId", "joinSemanticsId", "graphRef"};
        SlpcObject inputCounts = object(report, "inputCounts");
        Set<String> expectedOwners = new HashSet<String>(); int total = 0;
        for (int index = 0; index < collections.length; index++) {
            List<Object> records = array(document, collections[index]); int count = records.size(); total += count;
            equal(integer(inputCounts, collections[index]), (long) count, "projection report inputCounts." + collections[index]);
            for (Object value : records) expectedOwners.add(kinds[index] + "\u0000" + string(asObject(value), ids[index]));
        }
        equal(integer(inputCounts, "total"), (long) total, "projection report inputCounts.total");
        List<Object> records = array(report, "records");
        equal(records.size(), total, "projection report records length");
        Set<String> observedOwners = new HashSet<String>(); List<String> order = new ArrayList<String>();
        Map<String, Integer> outcomes = new HashMap<String, Integer>(), diagnostics = new HashMap<String, Integer>();
        for (Object value : records) {
            SlpcObject record = asObject(value), owner = object(record, "ownerRef");
            String ownerKey = string(owner, "kind") + "\u0000" + string(owner, "id");
            if (!observedOwners.add(ownerKey)) fail("$.records", "projection report has duplicate owner: " + ownerKey.replace('\u0000', ':'));
            order.add(ownerKey); String outcome = string(record, "outcome");
            outcomes.put(outcome, outcomes.containsKey(outcome) ? outcomes.get(outcome) + 1 : 1);
            List<String> extensionTypes = strings(array(record, "extensionTypes"));
            List<String> diagnosticCodes = strings(array(record, "diagnosticCodes"));
            equal(extensionTypes, sorted(extensionTypes), "projection report extensionTypes order");
            equal(diagnosticCodes, sorted(diagnosticCodes), "projection report diagnosticCodes order");
            if (ownerKey.startsWith("FACT_CANDIDATE\u0000") || ownerKey.startsWith("DATASET_OPERATION_CANDIDATE\u0000")
                    || ownerKey.startsWith("OBJECT_RELATIONSHIP_CANDIDATE\u0000")) {
                if (!"INELIGIBLE".equals(outcome) || integer(record, "standardOutputCount") != 0)
                    fail("$.records", "projection candidate must be INELIGIBLE with standardOutputCount 0: " + ownerKey.replace('\u0000', ':'));
            }
            for (String code : diagnosticCodes) diagnostics.put(code, diagnostics.containsKey(code) ? diagnostics.get(code) + 1 : 1);
        }
        equal(observedOwners, expectedOwners, "projection report owner coverage");
        equal(order, sorted(order), "projection report record order");
        SlpcObject outcomeCounts = object(report, "outcomeCounts"); long outcomeTotal = 0;
        for (String code : Arrays.asList("STANDARD", "EXTENSION_ONLY", "CONDITIONAL", "INELIGIBLE", "UNSUPPORTED")) {
            long actual = integer(outcomeCounts, code); int expected = outcomes.containsKey(code) ? outcomes.get(code) : 0;
            equal(actual, (long) expected, "projection report outcomeCounts." + code); outcomeTotal += actual;
        }
        equal(outcomeTotal, (long) total, "projection report outcome total");
        List<Object> diagnosticCounts = array(report, "diagnosticCounts"); List<String> diagnosticOrder = new ArrayList<String>();
        Set<String> seenCodes = new HashSet<String>();
        for (Object value : diagnosticCounts) {
            SlpcObject count = asObject(value); String code = string(count, "code");
            if (!seenCodes.add(code)) fail("$.diagnosticCounts", "duplicate projection diagnostic count: " + code);
            diagnosticOrder.add(code); equal(integer(count, "count"), (long) (diagnostics.containsKey(code) ? diagnostics.get(code) : 0),
                    "projection report diagnosticCounts." + code);
        }
        equal(diagnosticOrder, sorted(diagnosticOrder), "projection report diagnosticCounts order");
        equal(seenCodes, diagnostics.keySet(), "projection report diagnostic code coverage");
    }

    public void validateOrThrow(SlpcObject document) {
        String version = string(document, "contractVersion");
        if (!version.startsWith("0.2.")) fail("$", "semantic validator only accepts contractVersion 0.2.x");

        SlpcObject producer = object(document, "producer");
        List<String> capabilityCodes = fields(array(producer, "capabilities"), "code");
        equal(capabilityCodes, CAPABILITIES, "capability registry/order");
        Map<String, String> capabilityStatus = new HashMap<String, String>();
        for (Object value : array(producer, "capabilities")) {
            SlpcObject capability = asObject(value);
            capabilityStatus.put(string(capability, "code"), string(capability, "status"));
        }
        if (capabilityStatus.containsValue("PARTIAL") && !hasDiagnosticCode(document, "SLPC_ADAPTER_CAPABILITY_GAP")) {
            fail("$.producer.capabilities", "PARTIAL capability requires SLPC_ADAPTER_CAPABILITY_GAP diagnostic");
        }
        if (!"UNSUPPORTED".equals(capabilityStatus.get("INTERACTIVE_EXPLAIN"))
                && "UNSUPPORTED".equals(capabilityStatus.get("INTERMEDIATE_GRAPH"))) {
            fail("$.producer.capabilities", "INTERACTIVE_EXPLAIN requires INTERMEDIATE_GRAPH capability");
        }
        validateProfileLocations(document);

        List<Object> artifactsList = array(document, "artifacts");
        List<Object> statementsList = array(document, "statements");
        List<Object> endpointsList = array(document, "endpoints");
        Map<String, SlpcObject> artifacts = uniqueIndex(artifactsList, "artifactId", "artifact");
        Map<String, SlpcObject> statements = uniqueIndex(statementsList, "statementId", "statement");
        Map<String, SlpcObject> endpoints = uniqueIndex(endpointsList, "endpointRef", "endpoint");
        equal(fields(artifactsList, "artifactId"), sorted(artifacts.keySet()), "artifact order");
        equal(fields(statementsList, "statementId"), sorted(statements.keySet()), "statement order");
        for (Object value : artifactsList) {
            SlpcObject item = asObject(value);
            equal(string(item, "artifactId"), SlpcIdentity.artifactId(item), "artifactId");
        }
        for (Object value : statementsList) {
            SlpcObject item = asObject(value);
            requireRef(artifacts, string(item, "artifactId"), "statement references missing artifact");
            equal(string(item, "statementId"), SlpcIdentity.statementId(item), "statementId");
        }

        List<String> endpointSort = new ArrayList<String>();
        for (Object value : endpointsList) {
            SlpcObject endpoint = asObject(value);
            String canonical = endpoint.string("canonicalEndpointId");
            if (canonical != null) {
                equal(canonical, SlpcIdentity.endpointId(endpoint), string(endpoint, "endpointRef") + " canonicalEndpointId");
                endpointSort.add("0\u0000" + canonical);
            } else {
                endpointSort.add("1\u0000" + SlpcIdentity.candidateEndpointKey(endpoint));
            }
            validateUriDigest(endpoint);
        }
        validateRoutineParameterProfiles(endpointsList);
        equal(endpointSort, sorted(endpointSort), "endpoint order");
        localIds(fields(endpointsList, "endpointRef"), "ep-", "endpoint");

        List<Object> facts = array(document, "facts");
        List<Object> factCandidates = array(document, "factCandidates");
        List<Object> influences = array(document, "datasetOperationInfluences");
        List<Object> operationCandidates = array(document, "datasetOperationCandidates");
        List<Object> relationships = array(document, "objectRelationships");
        List<Object> relationshipCandidates = array(document, "objectRelationshipCandidates");
        Map<String, SlpcObject> factById = uniqueIndex(facts, "factId", "factId");
        Map<String, SlpcObject> factCandidateById = uniqueIndex(factCandidates, "candidateId", "fact candidateId");
        Map<String, SlpcObject> influenceById = uniqueIndex(influences, "influenceId", "influenceId");
        Map<String, SlpcObject> operationCandidateById = uniqueIndex(operationCandidates, "candidateId", "operation candidateId");
        Map<String, SlpcObject> relationshipById = uniqueIndex(relationships, "relationshipId", "object relationshipId");
        Map<String, SlpcObject> relationshipCandidateById = uniqueIndex(relationshipCandidates, "candidateId", "object relationship candidateId");
        unique(fields(factCandidates, "candidateFingerprint"), "fact candidate fingerprint");
        unique(fields(operationCandidates, "candidateFingerprint"), "operation candidate fingerprint");
        unique(fields(relationshipCandidates, "candidateFingerprint"), "object relationship candidate fingerprint");

        for (Object value : facts) {
            SlpcObject item = asObject(value); validateFactEndpointLevels(item, endpoints);
            equal(string(item, "factId"), SlpcIdentity.factId(item, endpoints), "factId");
        }
        for (Object value : factCandidates) {
            SlpcObject item = asObject(value); validateFactEndpointLevels(item, endpoints);
            equal(string(item, "candidateFingerprint"), SlpcIdentity.factCandidateFingerprint(item, endpoints), "fact candidate fingerprint");
        }
        for (Object value : influences) {
            SlpcObject item = asObject(value); equal(string(item, "influenceId"), SlpcIdentity.datasetOperationInfluenceId(item, endpoints), "dataset influenceId");
        }
        for (Object value : operationCandidates) {
            SlpcObject item = asObject(value); equal(string(item, "candidateFingerprint"), SlpcIdentity.datasetOperationCandidateFingerprint(item, endpoints), "dataset operation candidate fingerprint");
        }
        equal(fields(facts, "factId"), sorted(factById.keySet()), "fact order");
        equal(fields(influences, "influenceId"), sorted(influenceById.keySet()), "influence order");
        equal(fields(factCandidates, "candidateFingerprint"), sorted(fields(factCandidates, "candidateFingerprint")), "fact candidate order");
        localIds(fields(factCandidates, "candidateId"), "fact-cand-", "fact candidate");
        equal(fields(operationCandidates, "candidateFingerprint"), sorted(fields(operationCandidates, "candidateFingerprint")), "operation candidate order");
        localIds(fields(operationCandidates, "candidateId"), "op-cand-", "operation candidate");

        for (Object value : relationships) {
            SlpcObject item = asObject(value); validateRelationshipRoles(item);
            equal(string(item, "relationshipId"), SlpcIdentity.objectRelationshipId(item, endpoints), "object relationshipId");
        }
        for (Object value : relationshipCandidates) {
            SlpcObject item = asObject(value); validateRelationshipRoles(item);
            equal(string(item, "candidateFingerprint"), SlpcIdentity.objectRelationshipCandidateFingerprint(item, endpoints), "object relationship candidate fingerprint");
        }
        equal(fields(relationships, "relationshipId"), sorted(relationshipById.keySet()), "object relationship order");
        equal(fields(relationshipCandidates, "candidateFingerprint"), sorted(fields(relationshipCandidates, "candidateFingerprint")), "object relationship candidate order");
        localIds(fields(relationshipCandidates, "candidateId"), "objrel-cand-", "object relationship candidate");

        List<Object> operations = array(document, "statementOperations");
        Map<String, SlpcObject> operationById = uniqueIndex(operations, "statementOperationId", "statement operationId");
        validateGroupedOrdinals(operations, "statementId", "operationOrdinal", statements, "statement operation references missing statement", " operation");
        for (Object value : operations) {
            SlpcObject item = asObject(value); validateOperationRoles(item, endpoints);
            equal(string(item, "statementOperationId"), SlpcIdentity.statementOperationId(item, endpoints), "statement operationId");
        }
        equal(fields(operations, "statementOperationId"), sorted(operationById.keySet()), "statement operation order");

        List<Object> joins = array(document, "joinSemantics");
        Map<String, SlpcObject> joinById = uniqueIndex(joins, "joinSemanticsId", "joinSemanticsId");
        validateGroupedOrdinals(joins, "statementId", "joinOrdinal", statements, "join semantics references missing statement", " join");
        Set<String> factCandidateFingerprints = new HashSet<String>(fields(factCandidates, "candidateFingerprint"));
        for (Object value : joins) {
            SlpcObject item = asObject(value);
            contiguous(integers(array(item, "keyPairs"), "ordinal"), string(item, "joinSemanticsId") + " key-pair");
            equal(string(item, "joinSemanticsId"), SlpcIdentity.joinSemanticsId(item, endpoints), "joinSemanticsId");
            refsExist(strings(array(item, "refinesFactIds")), factById.keySet(), "join semantics references missing fact");
            refsExist(strings(array(item, "refinesFactCandidateFingerprints")), factCandidateFingerprints, "join semantics references missing fact candidate fingerprint");
        }
        equal(fields(joins, "joinSemanticsId"), sorted(joinById.keySet()), "join semantics order");

        List<Object> graphs = array(document, "intermediateGraphs");
        Map<String, SlpcObject> graphByRef = uniqueIndex(graphs, "graphRef", "intermediate graphRef");
        unique(fields(graphs, "graphFingerprint"), "intermediate graph fingerprint");
        validateGroupedOrdinals(graphs, "statementId", "graphOrdinal", statements, "intermediate graph references missing statement", " graph");
        List<String> graphSort = new ArrayList<String>();
        for (Object value : graphs) {
            SlpcObject graph = asObject(value);
            validateGraph(graph, endpoints, document, capabilityStatus);
            graphSort.add(string(graph, "statementId") + "\u0000" + string(graph, "graphFingerprint"));
        }
        equal(graphSort, sorted(graphSort), "intermediate graph order");
        localIds(fields(graphs, "graphRef"), "graph-", "intermediate graph");

        Map<String, String> ownerKeys = new HashMap<String, String>();
        addOwnerKeys(ownerKeys, facts, "FACT", "factId", "factId");
        addOwnerKeys(ownerKeys, factCandidates, "FACT_CANDIDATE", "candidateId", "candidateFingerprint");
        addOwnerKeys(ownerKeys, influences, "DATASET_OPERATION", "influenceId", "influenceId");
        addOwnerKeys(ownerKeys, operationCandidates, "DATASET_OPERATION_CANDIDATE", "candidateId", "candidateFingerprint");
        addOwnerKeys(ownerKeys, relationships, "OBJECT_RELATIONSHIP", "relationshipId", "relationshipId");
        addOwnerKeys(ownerKeys, relationshipCandidates, "OBJECT_RELATIONSHIP_CANDIDATE", "candidateId", "candidateFingerprint");

        List<Object> occurrences = array(document, "occurrences");
        Map<String, List<SlpcObject>> occurrencesByOwner = new HashMap<String, List<SlpcObject>>();
        List<String> occurrenceIds = new ArrayList<String>();
        for (Object value : occurrences) {
            SlpcObject occurrence = asObject(value);
            SlpcObject owner = object(occurrence, "ownerRef");
            String ownerKey = string(owner, "kind") + "\u0000" + string(owner, "id");
            if (!ownerKeys.containsKey(ownerKey)) fail("$.occurrences", "occurrence references missing owner: " + ownerKey.replace('\u0000', ':'));
            requireRef(artifacts, string(occurrence, "artifactId"), "occurrence references missing artifact/statement");
            if (occurrence.string("statementId") != null) requireRef(statements, occurrence.string("statementId"), "occurrence references missing artifact/statement");
            equal(string(occurrence, "occurrenceId"), SlpcIdentity.occurrenceId(occurrence, ownerKeys), "occurrenceId");
            validateSupportPaths(occurrence, graphByRef);
            validateLiterals(occurrence, artifacts);
            if (!occurrencesByOwner.containsKey(ownerKey)) occurrencesByOwner.put(ownerKey, new ArrayList<SlpcObject>());
            occurrencesByOwner.get(ownerKey).add(occurrence);
            occurrenceIds.add(string(occurrence, "occurrenceId"));
        }
        equal(occurrenceIds, sorted(occurrenceIds), "occurrence order");
        unique(occurrenceIds, "occurrenceId");
        validateQuality(facts, "FACT", "factId", false, occurrencesByOwner);
        validateQuality(factCandidates, "FACT_CANDIDATE", "candidateId", true, occurrencesByOwner);
        validateQuality(influences, "DATASET_OPERATION", "influenceId", false, occurrencesByOwner);
        validateQuality(operationCandidates, "DATASET_OPERATION_CANDIDATE", "candidateId", true, occurrencesByOwner);
        validateQuality(relationships, "OBJECT_RELATIONSHIP", "relationshipId", false, occurrencesByOwner);
        validateQuality(relationshipCandidates, "OBJECT_RELATIONSHIP_CANDIDATE", "candidateId", true, occurrencesByOwner);

        validateRenameSwap(operations, facts);
        validateCreateStream(operations, relationships);
        validateDiagnostics(document, artifacts.keySet(), statements.keySet(), endpoints.keySet(), factById.keySet(),
                factCandidateById.keySet(), influenceById.keySet(), operationCandidateById.keySet(), relationshipById.keySet(),
                relationshipCandidateById.keySet(), operationById.keySet(), joinById.keySet(), graphByRef, occurrenceIds);
        validateSecretHygiene(document);
    }

    private void validateGraph(SlpcObject graph, Map<String, SlpcObject> endpoints, SlpcObject document,
            Map<String, String> capabilityStatus) {
        List<Object> nodeList = array(graph, "nodes"), edgeList = array(graph, "edges"), pathList = array(graph, "paths");
        Map<String, SlpcObject> nodes = uniqueIndex(nodeList, "nodeRef", string(graph, "graphRef") + " nodeRef");
        Map<String, SlpcObject> edges = uniqueIndex(edgeList, "edgeRef", string(graph, "graphRef") + " edgeRef");
        unique(fields(nodeList, "nodeFingerprint"), string(graph, "graphRef") + " node fingerprint");
        unique(fields(edgeList, "edgeFingerprint"), string(graph, "graphRef") + " edge fingerprint");
        unique(fields(pathList, "pathRef"), string(graph, "graphRef") + " pathRef");
        unique(fields(pathList, "pathFingerprint"), string(graph, "graphRef") + " path fingerprint");
        contiguous(sortedIntegers(nodeList, "nodeOrdinal"), string(graph, "graphRef") + " node");
        for (Object value : nodeList) {
            SlpcObject node = asObject(value); String parentRef = nullableString(node, "parentNodeRef");
            if (parentRef != null) {
                SlpcObject parent = nodes.get(parentRef);
                if (parent == null) fail("$.intermediateGraphs", "intermediate node references missing parent: " + parentRef);
                if ("BOUNDARY_ENDPOINT".equals(string(parent, "nodeKind"))) fail("$.intermediateGraphs", "BOUNDARY_ENDPOINT cannot contain intermediate nodes");
                if (integer(parent, "nodeOrdinal") >= integer(node, "nodeOrdinal")) fail("$.intermediateGraphs", "intermediate containment must be acyclic and parent ordinal must precede child");
            }
            equal(string(node, "nodeFingerprint"), SlpcIdentity.intermediateNodeFingerprint(node, graph, endpoints), "intermediate node fingerprint");
        }
        equal(fields(nodeList, "nodeFingerprint"), sorted(fields(nodeList, "nodeFingerprint")), string(graph, "graphRef") + " node order");
        localIds(fields(nodeList, "nodeRef"), "ign-", string(graph, "graphRef") + " node");
        for (Object value : edgeList) {
            SlpcObject edge = asObject(value);
            validateAnchor(object(edge, "source"), nodes, endpoints, "edge");
            validateAnchor(object(edge, "target"), nodes, endpoints, "edge");
            equal(string(edge, "edgeFingerprint"), SlpcIdentity.intermediateEdgeFingerprint(edge, endpoints, nodes), "intermediate edge fingerprint");
        }
        equal(fields(edgeList, "edgeFingerprint"), sorted(fields(edgeList, "edgeFingerprint")), string(graph, "graphRef") + " edge order");
        localIds(fields(edgeList, "edgeRef"), "ige-", string(graph, "graphRef") + " edge");
        for (Object value : pathList) {
            SlpcObject path = asObject(value);
            refsExist(strings(array(path, "edgeRefs")), edges.keySet(), "path references missing graph edge");
            equal(string(path, "pathFingerprint"), SlpcIdentity.intermediatePathFingerprint(path, edges), "intermediate path fingerprint");
        }
        equal(fields(pathList, "pathFingerprint"), sorted(fields(pathList, "pathFingerprint")), string(graph, "graphRef") + " path order");
        localIds(fields(pathList, "pathRef"), "igp-", string(graph, "graphRef") + " path");
        equal(string(graph, "graphFingerprint"), SlpcIdentity.intermediateGraphFingerprint(graph), "intermediate graph fingerprint");

        List<SlpcObject> profiles = extensions(graph, "gsp.interactive-explain.v1");
        if (profiles.size() > 1) fail("$.intermediateGraphs", string(graph, "graphRef") + " has duplicate interactive explain profiles");
        if (!profiles.isEmpty()) {
            if ("UNSUPPORTED".equals(capabilityStatus.get("INTERACTIVE_EXPLAIN"))) fail("$.intermediateGraphs", "interactive explain profile requires declared capability");
            List<Object> steps = array(object(profiles.get(0), "payload"), "steps");
            contiguous(integers(steps, "stepOrdinal"), string(graph, "graphRef") + " interactive step");
            localIds(fields(steps, "stepRef"), "igs-", string(graph, "graphRef") + " interactive step");
            unique(fields(steps, "stepFingerprint"), string(graph, "graphRef") + " interactive step fingerprint");
            Set<String> usedEdges = new HashSet<String>();
            for (Object value : steps) {
                SlpcObject step = asObject(value); List<Object> bindings = array(step, "inputBindings");
                contiguous(integers(bindings, "ordinal"), string(step, "stepRef") + " input binding");
                for (Object bindingValue : bindings) {
                    SlpcObject binding = asObject(bindingValue); String edgeRef = string(binding, "edgeRef");
                    SlpcObject edge = edges.get(edgeRef);
                    if (edge == null) fail("$.intermediateGraphs", "interactive step references missing graph edge: " + edgeRef);
                    if (!usedEdges.add(edgeRef)) fail("$.intermediateGraphs", "interactive edge is bound to multiple steps: " + edgeRef);
                    if (!object(edge, "target").equals(object(step, "resultAnchor"))) fail("$.intermediateGraphs", "interactive input edge target does not match resultAnchor: " + edgeRef);
                }
                validateAnchor(object(step, "resultAnchor"), nodes, endpoints, "interactive step");
                equal(string(step, "stepFingerprint"), SlpcIdentity.interactiveStepFingerprint(step, graph, endpoints, nodes, edges), "interactive step fingerprint");
            }
        }
        validateGraphCompleteness(graph, array(document, "diagnostics"));
    }

    private void validateGraphCompleteness(SlpcObject graph, List<Object> diagnostics) {
        List<SlpcObject> incomplete = new ArrayList<SlpcObject>(), bare = new ArrayList<SlpcObject>();
        String graphRef = string(graph, "graphRef");
        for (Object value : diagnostics) {
            SlpcObject diagnostic = asObject(value);
            String ref = nullableString(diagnostic, "ref");
            if ("SLPC_INTERMEDIATE_GRAPH_INCOMPLETE".equals(string(diagnostic, "code"))
                    && "INTERMEDIATE_GRAPH".equals(string(diagnostic, "scope")) && ref != null
                    && (ref.equals(graphRef) || ref.startsWith(graphRef + "/"))) {
                incomplete.add(diagnostic); if (ref.equals(graphRef)) bare.add(diagnostic);
            }
        }
        String completeness = string(graph, "analysisCompleteness");
        if ("COMPLETE".equals(completeness) && !incomplete.isEmpty()) fail("$.intermediateGraphs", "COMPLETE graph cannot carry an incomplete diagnostic");
        if (("PARTIAL".equals(completeness) || "UNKNOWN".equals(completeness)) && bare.isEmpty()) {
            fail("$.intermediateGraphs", "PARTIAL/UNKNOWN graph requires a bare graph incomplete diagnostic");
        }
        for (SlpcObject diagnostic : bare) {
            if (!"WARN".equals(string(diagnostic, "severity")) && !"ERROR".equals(string(diagnostic, "severity")))
                fail("$.diagnostics", "incomplete graph diagnostic severity must be WARN or ERROR");
        }
    }

    private void validateLiterals(SlpcObject occurrence, Map<String, SlpcObject> artifacts) {
        List<Object> literals = optionalArray(occurrence, "literalInputs");
        contiguous(integers(literals, "inputOrdinal"), string(occurrence, "occurrenceId") + " literal input");
        String dialect = string(artifacts.get(string(occurrence, "artifactId")), "sqlDialect");
        for (Object value : literals) {
            SlpcObject literal = asObject(value); SlpcObject fingerprint = object(literal, "fingerprint");
            String algorithm = string(fingerprint, "algorithm"), expected;
            if ("SLPC-REDACTED-LITERAL-V1".equals(algorithm)) {
                long ordinal = integer(literal, "redactionOrdinal");
                expected = sha256("SLPC-REDACTED-LITERAL-V1", SlpcIdentity.string(dialect),
                        SlpcIdentity.string(string(literal, "literalKind")), SlpcIdentity.integer(ordinal));
                equal(string(fingerprint, "value"), expected, "redacted literal fingerprint");
                if (literal.contains("text")) equal(literal.string("text"), "<SLPC-REDACTED:" + string(literal, "literalKind") + ":" + ordinal + ">", "redacted literal marker");
            } else if ("SLPC-LITERAL-TEXT-V1".equals(algorithm) && literal.contains("text")) {
                expected = sha256("SLPC-LITERAL-TEXT-V1", SlpcIdentity.string(dialect),
                        SlpcIdentity.string(string(literal, "literalKind")), SlpcIdentity.string(literal.string("text")));
                equal(string(fingerprint, "value"), expected, "literal fingerprint");
            }
        }
    }

    private void validateSupportPaths(SlpcObject occurrence, Map<String, SlpcObject> graphs) {
        for (Object value : optionalArray(occurrence, "supportPathRefs")) {
            SlpcObject support = asObject(value); SlpcObject graph = graphs.get(string(support, "graphRef"));
            if (graph == null || !fields(array(graph, "paths"), "pathRef").contains(string(support, "pathRef")))
                fail("$.occurrences", "occurrence has dangling support path: " + support.asMap());
        }
    }

    private void validateQuality(List<Object> records, String ownerKind, String idField, boolean alwaysIneligible,
            Map<String, List<SlpcObject>> occurrencesByOwner) {
        for (Object value : records) {
            SlpcObject record = asObject(value); String owner = ownerKind + "\u0000" + string(record, idField);
            List<SlpcObject> evidence = occurrencesByOwner.get(owner);
            if (evidence == null || evidence.isEmpty()) fail("$", "owner has no occurrence: " + owner.replace('\u0000', ':'));
            boolean ineligible = alwaysIneligible || ("UNKNOWN".equals(record.string("role"))
                    && "NONE".equals(record.string("operationKind")) && optionalArray(record, "extensions").isEmpty());
            equal(object(record, "qualitySummary"), aggregateQuality(evidence, ineligible), owner.replace('\u0000', ':') + " qualitySummary");
        }
    }

    private SlpcObject aggregateQuality(List<SlpcObject> occurrences, boolean ineligible) {
        String resolution = worst(occurrences, "resolutionGrade", Arrays.asList("NOT_APPLICABLE", "RESOLVED", "GUESSED", "PARTIAL", "UNRESOLVED", "AMBIGUOUS", "PARSER_UNSUPPORTED"));
        String evaluation = worst(occurrences, "evaluationModel", Arrays.asList("EXACT", "OVER_APPROXIMATE", "HEURISTIC", "UNKNOWN"));
        String proof = worst(occurrences, "semanticProof", Arrays.asList("PROVEN", "INFERRED", "ASSUMED", "UNKNOWN"));
        boolean dynamic = false; long confidence = 1000000;
        Set<String> ids = new HashSet<String>();
        for (SlpcObject occurrence : occurrences) {
            SlpcObject quality = object(occurrence, "quality");
            dynamic |= Boolean.TRUE.equals(quality.get("dynamic"));
            confidence = Math.min(confidence, integer(quality, "confidenceMicros")); ids.add(string(occurrence, "occurrenceId"));
        }
        String eligibility = ineligible ? "INELIGIBLE" :
                (("RESOLVED".equals(resolution) || "NOT_APPLICABLE".equals(resolution)) && "EXACT".equals(evaluation)
                        && "PROVEN".equals(proof) && !dynamic && confidence == 1000000 ? "ELIGIBLE" : "CONDITIONAL");
        return SlpcObject.builder().put("projectionEligibility", eligibility).put("resolutionGrade", resolution)
                .put("evaluationModel", evaluation).put("semanticProof", proof).put("dynamic", dynamic)
                .put("confidenceMicros", confidence).put("evidenceCount", ids.size()).build();
    }

    private String worst(List<SlpcObject> occurrences, String field, List<String> rank) {
        String worst = rank.get(0);
        for (SlpcObject occurrence : occurrences) {
            String value = string(object(occurrence, "quality"), field);
            if (rank.indexOf(value) > rank.indexOf(worst)) worst = value;
        }
        return worst;
    }

    private void validateRelationshipRoles(SlpcObject record) {
        List<String> actual = fields(array(record, "participants"), "role");
        List<String> expected = relationshipRoles(string(record, "relationshipKind"));
        equal(actual, expected, (record.string("relationshipId") == null ? record.string("candidateId") : record.string("relationshipId")) + " participant roles");
        List<Object> details = record.array("keyFields"); if (details == null || details.isEmpty()) details = optionalArray(record, "keyPairs");
        if (!details.isEmpty()) contiguous(integers(details, "ordinal"), "relationship detail");
    }

    private void validateOperationRoles(SlpcObject record, Map<String, SlpcObject> endpoints) {
        List<RoleRule> rules = operationRoles(string(record, "operationKind"));
        Map<String, List<SlpcObject>> byRole = new LinkedHashMap<String, List<SlpcObject>>();
        for (Object value : array(record, "participants")) {
            SlpcObject participant = asObject(value); String role = string(participant, "role");
            if (!byRole.containsKey(role)) byRole.put(role, new ArrayList<SlpcObject>());
            byRole.get(role).add(participant);
        }
        Set<String> known = new HashSet<String>(); for (RoleRule rule : rules) known.add(rule.role);
        Set<String> unknown = new HashSet<String>(byRole.keySet()); unknown.removeAll(known);
        if (!unknown.isEmpty()) fail("$.statementOperations", string(record, "statementOperationId") + " has invalid participant roles: " + unknown);
        List<Object> expected = new ArrayList<Object>();
        for (RoleRule rule : rules) {
            List<SlpcObject> values = byRole.containsKey(rule.role) ? byRole.get(rule.role) : new ArrayList<SlpcObject>();
            if (rule.required && values.size() != 1) fail("$.statementOperations", string(record, "statementOperationId") + " requires exactly one " + rule.role);
            if (!rule.setLike && values.size() > 1) fail("$.statementOperations", string(record, "statementOperationId") + " repeats singleton role " + rule.role);
            if (rule.setLike) Collections.sort(values, endpointParticipantComparator(endpoints));
            expected.addAll(values);
        }
        equal(array(record, "participants"), expected, string(record, "statementOperationId") + " participant order");
    }

    private void validateRenameSwap(List<Object> operations, List<Object> facts) {
        for (Object value : operations) {
            SlpcObject operation = asObject(value); String kind = string(operation, "operationKind");
            if (!"RENAME".equals(kind) && !"SWAP".equals(kind)) continue;
            Set<String> refs = new HashSet<String>(fields(array(operation, "participants"), "endpointRef"));
            for (Object factValue : facts) {
                SlpcObject fact = asObject(factValue);
                if ("VALUE".equals(string(fact, "axis")) && "DIRECT".equals(string(fact, "role"))
                        && refs.contains(fact.string("sourceEndpointRef")) && refs.contains(string(fact, "targetEndpointRef")))
                    fail("$.facts", kind + " must not create a default VALUE/DIRECT fact");
            }
        }
    }

    private void validateCreateStream(List<Object> operations, List<Object> relationships) {
        Set<String> index = new HashSet<String>();
        for (Object value : relationships) {
            SlpcObject relation = asObject(value); StringBuilder key = new StringBuilder(string(relation, "relationshipKind"));
            for (Object p : array(relation, "participants")) { SlpcObject participant = asObject(p); key.append('|').append(string(participant, "role")).append('=').append(string(participant, "endpointRef")); }
            index.add(key.toString());
        }
        for (Object value : operations) {
            SlpcObject operation = asObject(value); if (!"CREATE_STREAM".equals(string(operation, "operationKind"))) continue;
            Map<String, String> roles = new HashMap<String, String>();
            for (Object p : array(operation, "participants")) { SlpcObject participant = asObject(p); roles.put(string(participant, "role"), string(participant, "endpointRef")); }
            String expected = "STREAMS_FROM|STREAM=" + roles.get("CREATED_STREAM") + "|BASE_RELATION=" + roles.get("BASE_RELATION");
            if (!index.contains(expected)) fail("$.statementOperations", "CREATE_STREAM requires a STREAMS_FROM object relationship");
        }
    }

    private void validateDiagnostics(SlpcObject document, Set<String> artifacts, Set<String> statements, Set<String> endpoints,
            Set<String> facts, Set<String> factCandidates, Set<String> influences, Set<String> operationCandidates,
            Set<String> relationships, Set<String> relationshipCandidates, Set<String> operations, Set<String> joins,
            Map<String, SlpcObject> graphs, List<String> occurrences) {
        Set<String> factLike = union(facts, factCandidates, influences, operationCandidates);
        Set<String> relationshipLike = union(relationships, relationshipCandidates);
        Set<String> intermediate = new HashSet<String>(graphs.keySet());
        for (SlpcObject graph : graphs.values()) {
            String prefix = string(graph, "graphRef") + "/";
            for (String ref : fields(array(graph, "nodes"), "nodeRef")) intermediate.add(prefix + ref);
            for (String ref : fields(array(graph, "edges"), "edgeRef")) intermediate.add(prefix + ref);
            for (String ref : fields(array(graph, "paths"), "pathRef")) intermediate.add(prefix + ref);
            for (SlpcObject extension : extensions(graph, "gsp.interactive-explain.v1"))
                for (String ref : fields(array(object(extension, "payload"), "steps"), "stepRef")) intermediate.add(prefix + ref);
        }
        Map<String, Set<String>> targets = new HashMap<String, Set<String>>();
        targets.put("ARTIFACT", artifacts); targets.put("STATEMENT", statements); targets.put("ENDPOINT", endpoints);
        targets.put("FACT", factLike); targets.put("OCCURRENCE", new HashSet<String>(occurrences));
        targets.put("OBJECT_RELATIONSHIP", relationshipLike); targets.put("STATEMENT_OPERATION", operations);
        targets.put("JOIN_SEMANTICS", joins); targets.put("INTERMEDIATE_GRAPH", intermediate);
        Set<String> extensionTargets = union(factLike, relationshipLike, operations, joins, graphs.keySet(), new HashSet<String>(occurrences), endpoints);
        for (Object value : array(document, "diagnostics")) {
            SlpcObject diagnostic = asObject(value); String scope = string(diagnostic, "scope"), ref = nullableString(diagnostic, "ref");
            String code = string(diagnostic, "code");
            if (code.startsWith("SLPC_") && !CORE_DIAGNOSTICS.contains(code))
                fail("$.diagnostics", "unregistered core diagnostic code: " + code);
            if ("DOCUMENT".equals(scope) && ref != null) fail("$.diagnostics", "DOCUMENT diagnostic ref must be null");
            if (targets.containsKey(scope) && !targets.get(scope).contains(ref)) fail("$.diagnostics", "diagnostic references missing " + scope + " owner: " + ref);
            if ("EXTENSION".equals(scope) && ref != null && !extensionTargets.contains(ref)) fail("$.diagnostics", "diagnostic references missing EXTENSION owner: " + ref);
        }
    }

    private void validateSecretHygiene(SlpcObject document) {
        ArrayDeque<PathValue> stack = new ArrayDeque<PathValue>(); stack.push(new PathValue("$", document));
        while (!stack.isEmpty()) {
            PathValue current = stack.pop(); Object value = current.value;
            if (value instanceof String && SECRET.matcher((String) value).find()) fail(current.path, "secret-bearing text is not redacted at " + current.path);
            if (value instanceof SlpcObject) for (String name : ((SlpcObject) value).names()) stack.push(new PathValue(current.path + "." + name, ((SlpcObject) value).get(name)));
            else if (value instanceof List<?>) for (int index = 0; index < ((List<?>) value).size(); index++) stack.push(new PathValue(current.path + "[" + index + "]", ((List<?>) value).get(index)));
        }
    }

    private boolean hasDiagnosticCode(SlpcObject document, String expected) {
        for (Object value : array(document, "diagnostics")) {
            if (expected.equals(asObject(value).string("code"))) return true;
        }
        return false;
    }

    private void validateFactEndpointLevels(SlpcObject fact, Map<String, SlpcObject> endpoints) {
        if (!"ROW".equals(string(fact, "axis"))) return;
        String targetRef = string(fact, "targetEndpointRef");
        SlpcObject target = endpoints.get(targetRef);
        if (target == null) fail("$.facts", "ROW fact references missing target endpoint: " + targetRef);
        if (!"RELATION".equals(string(target, "endpointLevel")))
            fail("$.facts", "ROW fact target must be a holder RELATION endpoint: " + targetRef);
    }

    private void validateProfileLocations(SlpcObject document) {
        ArrayDeque<PathValue> stack = new ArrayDeque<PathValue>(); stack.push(new PathValue("$", document));
        Pattern allowed = Pattern.compile("\\$\\.intermediateGraphs\\[[0-9]+\\]\\.extensions\\[[0-9]+\\]");
        while (!stack.isEmpty()) {
            PathValue current = stack.pop(); Object value = current.value;
            if (value instanceof SlpcObject) {
                SlpcObject object = (SlpcObject) value;
                if ("gsp.interactive-explain.v1".equals(object.string("extensionType")) && object.contains("schemaVersion")
                        && object.contains("criticality") && object.contains("payload") && !allowed.matcher(current.path).matches())
                    fail(current.path, "interactive explain profile must be graph-local: " + current.path);
                for (String name : object.names()) stack.push(new PathValue(current.path + "." + name, object.get(name)));
            } else if (value instanceof List<?>) for (int index = 0; index < ((List<?>) value).size(); index++) stack.push(new PathValue(current.path + "[" + index + "]", ((List<?>) value).get(index)));
        }
    }

    private void validateRoutineParameterProfiles(List<Object> endpoints) {
        for (Object value : endpoints) {
            SlpcObject endpoint = asObject(value); int profiles = 0;
            for (Object extensionValue : array(endpoint, "extensions")) {
                SlpcObject extension = asObject(extensionValue);
                if ("gsp.routine-parameter.v1".equals(extension.string("extensionType"))) profiles++;
            }
            boolean parameter = "PARAMETER".equals(endpoint.string("objectKind"));
            if (parameter && profiles != 1) fail("$.endpoints",
                    "PARAMETER endpoint requires exactly one gsp.routine-parameter.v1 profile");
            if (!parameter && profiles != 0) fail("$.endpoints",
                    "gsp.routine-parameter.v1 is allowed only on PARAMETER endpoints");
        }
    }

    private void validateUriDigest(SlpcObject endpoint) {
        SlpcObject identity = object(endpoint, "identity"); if (!"URI_EXACT".equals(string(identity, "kind"))) return;
        for (SlpcObject extension : extensions(endpoint, "gsp.storage-asset.v1")) {
            String locator = object(extension, "payload").string("secretFreeNormalizedLocator");
            if (locator != null) {
                String expected = sha256("SLPC-URI-LOCATOR-DIGEST-V1",
                        SlpcIdentity.string(string(identity, "normalizationPolicyId")), SlpcIdentity.string(string(identity, "scheme")), SlpcIdentity.string(locator));
                equal(string(identity, "locatorDigest"), expected, string(endpoint, "endpointRef") + " locatorDigest");
            }
        }
    }

    private static String sha256(String domain, byte[]... payload) {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256"); digest.update(domain.getBytes(StandardCharsets.US_ASCII)); digest.update((byte) 0);
            for (byte[] value : payload) digest.update(value); StringBuilder hex = new StringBuilder();
            for (byte value : digest.digest()) hex.append(String.format("%02x", value & 255)); return hex.toString();
        } catch (NoSuchAlgorithmException impossible) { throw new IllegalStateException(impossible); }
    }

    private void validateGroupedOrdinals(List<Object> records, String groupField, String ordinalField,
            Map<String, SlpcObject> validGroups, String missingMessage, String suffix) {
        Map<String, List<Long>> groups = new HashMap<String, List<Long>>();
        for (Object value : records) { SlpcObject record = asObject(value); String group = string(record, groupField);
            requireRef(validGroups, group, missingMessage); if (!groups.containsKey(group)) groups.put(group, new ArrayList<Long>()); groups.get(group).add(integer(record, ordinalField)); }
        for (Map.Entry<String, List<Long>> entry : groups.entrySet()) { Collections.sort(entry.getValue()); contiguous(entry.getValue(), entry.getKey() + suffix); }
    }

    private void validateAnchor(SlpcObject anchor, Map<String, SlpcObject> nodes, Map<String, SlpcObject> endpoints, String kind) {
        if ("NODE".equals(string(anchor, "kind")) && !nodes.containsKey(string(anchor, "nodeRef"))) fail("$.intermediateGraphs", kind + " references missing graph node: " + anchor.string("nodeRef"));
        if ("ENDPOINT".equals(string(anchor, "kind")) && !endpoints.containsKey(string(anchor, "endpointRef"))) fail("$.intermediateGraphs", kind + " references missing endpoint: " + anchor.string("endpointRef"));
    }

    private static void addOwnerKeys(Map<String, String> target, List<Object> records, String kind, String idField, String semanticField) {
        for (Object value : records) { SlpcObject record = asObject(value); target.put(kind + "\u0000" + string(record, idField), string(record, semanticField)); }
    }

    private static List<SlpcObject> extensions(SlpcObject owner, String type) {
        ArrayList<SlpcObject> result = new ArrayList<SlpcObject>();
        for (Object value : optionalArray(owner, "extensions")) { SlpcObject extension = asObject(value); if (type.equals(extension.string("extensionType"))) result.add(extension); }
        return result;
    }

    private static Comparator<SlpcObject> endpointParticipantComparator(final Map<String, SlpcObject> endpoints) {
        return new Comparator<SlpcObject>() { @Override public int compare(SlpcObject left, SlpcObject right) {
            String a = SlpcIdentity.candidateEndpointKey(endpoints.get(string(left, "endpointRef")));
            String b = SlpcIdentity.candidateEndpointKey(endpoints.get(string(right, "endpointRef")));
            return utf8Compare(a, b);
        }};
    }

    private static int utf8Compare(String left, String right) {
        byte[] a = left.getBytes(StandardCharsets.UTF_8), b = right.getBytes(StandardCharsets.UTF_8); int common = Math.min(a.length, b.length);
        for (int index = 0; index < common; index++) { int difference = (a[index] & 255) - (b[index] & 255); if (difference != 0) return difference; }
        return a.length - b.length;
    }

    private static Map<String, SlpcObject> uniqueIndex(List<Object> records, String field, String label) {
        LinkedHashMap<String, SlpcObject> result = new LinkedHashMap<String, SlpcObject>();
        for (Object value : records) { SlpcObject record = asObject(value); String key = string(record, field); if (result.put(key, record) != null) fail("$", "duplicate " + label); }
        return result;
    }

    private static List<String> relationshipRoles(String kind) {
        if ("PRIMARY_KEY".equals(kind) || "UNIQUE_KEY".equals(kind)) return Arrays.asList("KEY_RELATION");
        if ("FOREIGN_KEY_REFERENCE".equals(kind)) return Arrays.asList("FOREIGN_KEY_RELATION", "REFERENCED_RELATION");
        if ("CALLS".equals(kind)) return Arrays.asList("CALLER_ROUTINE", "CALLEE_ROUTINE");
        if ("STREAMS_FROM".equals(kind)) return Arrays.asList("STREAM", "BASE_RELATION");
        if ("SYNONYM_OF".equals(kind)) return Arrays.asList("SYNONYM", "BASE_OBJECT");
        if ("READS_FROM".equals(kind)) return Arrays.asList("CONSUMER_RELATION", "STORAGE_ASSET");
        if ("WRITES_TO".equals(kind)) return Arrays.asList("PRODUCER_RELATION", "STORAGE_ASSET");
        fail("$", "unsupported relationship kind: " + kind); return Collections.emptyList();
    }

    private static List<RoleRule> operationRoles(String kind) {
        if ("QUERY".equals(kind)) return rules("READ_RELATION", true, false, "OUTPUT_RELATION", true, false);
        if ("INSERT".equals(kind) || "UPDATE".equals(kind) || "DELETE".equals(kind)) return rules("WRITE_TARGET", false, true, "READ_SOURCE", true, false);
        if ("MERGE".equals(kind)) return rules("MERGE_TARGET", false, true, "MERGE_SOURCE", true, false);
        if ("CREATE_TABLE".equals(kind)) return rules("CREATED_OBJECT", false, true);
        if ("CREATE_TABLE_AS".equals(kind) || "CREATE_VIEW".equals(kind) || "CREATE_MATERIALIZED_VIEW".equals(kind)) return rules("CREATED_OBJECT", false, true, "READ_SOURCE", true, false);
        if ("CREATE_EXTERNAL_TABLE".equals(kind) || "CREATE_STAGE".equals(kind)) return rules("CREATED_OBJECT", false, true, "STORAGE_SOURCE", true, false);
        if ("CREATE_STREAM".equals(kind)) return rules("CREATED_STREAM", false, true, "BASE_RELATION", false, true);
        if ("CREATE_ROUTINE".equals(kind)) return rules("CREATED_ROUTINE", false, true);
        if ("CREATE_SYNONYM".equals(kind)) return rules("SYNONYM", false, true, "BASE_OBJECT", false, true);
        if ("CREATE_INDEX".equals(kind)) return rules("CREATED_INDEX", false, true, "INDEXED_RELATION", false, true);
        if ("RENAME".equals(kind)) return rules("BEFORE_OBJECT", false, true, "AFTER_OBJECT", false, true);
        if ("SWAP".equals(kind)) return rules("SWAP_LEFT_OBJECT", false, true, "SWAP_RIGHT_OBJECT", false, true);
        if ("CLONE".equals(kind)) return rules("CLONE_SOURCE", false, true, "CLONE_TARGET", false, true);
        if ("LOAD".equals(kind)) return rules("STORAGE_SOURCE", true, false, "WRITE_TARGET", false, true);
        if ("UNLOAD".equals(kind) || "INSERT_OVERWRITE_DIRECTORY".equals(kind)) return rules("READ_SOURCE", true, false, "STORAGE_TARGET", false, true);
        if ("CALL_ROUTINE".equals(kind)) return rules("CALLEE_ROUTINE", false, true, "ARGUMENT_SOURCE", true, false);
        if ("ALTER".equals(kind) || "DROP".equals(kind) || "TRUNCATE".equals(kind)) return rules("AFFECTED_OBJECT", false, true);
        if ("OTHER".equals(kind)) return rules("AFFECTED_OBJECT", true, false);
        fail("$", "unsupported operation kind: " + kind); return Collections.emptyList();
    }

    private static List<RoleRule> rules(Object... values) {
        ArrayList<RoleRule> result = new ArrayList<RoleRule>();
        for (int index = 0; index < values.length; index += 3) result.add(new RoleRule((String) values[index], (Boolean) values[index + 1], (Boolean) values[index + 2]));
        return result;
    }

    @SafeVarargs private static Set<String> union(Set<String>... values) {
        HashSet<String> result = new HashSet<String>(); for (Set<String> value : values) result.addAll(value); return result;
    }

    private static List<String> sorted(Iterable<String> values) { ArrayList<String> result = new ArrayList<String>(); for (String value : values) result.add(value); Collections.sort(result); return result; }
    private static List<Long> sortedIntegers(List<Object> values, String field) { ArrayList<Long> result = new ArrayList<Long>(integers(values, field)); Collections.sort(result); return result; }
    private static List<String> fields(List<Object> values, String field) { ArrayList<String> result = new ArrayList<String>(); for (Object value : values) result.add(string(asObject(value), field)); return result; }
    private static List<String> strings(List<Object> values) { ArrayList<String> result = new ArrayList<String>(); for (Object value : values) result.add((String) value); return result; }
    private static List<Long> integers(List<Object> values, String field) { ArrayList<Long> result = new ArrayList<Long>(); for (Object value : values) result.add(integer(asObject(value), field)); return result; }
    private static List<Object> optionalArray(SlpcObject object, String field) { List<Object> result = object.array(field); return result == null ? Collections.<Object>emptyList() : result; }
    private static List<Object> array(SlpcObject object, String field) { List<Object> result = object.array(field); if (result == null) fail("$", "missing array field: " + field); return result; }
    private static SlpcObject object(SlpcObject object, String field) { SlpcObject result = object.object(field); if (result == null) fail("$", "missing object field: " + field); return result; }
    private static String string(SlpcObject object, String field) { String result = object == null ? null : object.string(field); if (result == null) fail("$", "missing string field: " + field); return result; }
    private static String nullableString(SlpcObject object, String field) { if (!object.contains(field)) fail("$", "missing nullable field: " + field); Object result = object.get(field); if (result != null && !(result instanceof String)) fail("$", "field is not string/null: " + field); return (String) result; }
    private static long integer(SlpcObject object, String field) { BigInteger result = object.integer(field); if (result == null) fail("$", "missing integer field: " + field); return result.longValueExact(); }
    private static SlpcObject asObject(Object value) { if (!(value instanceof SlpcObject)) fail("$", "expected object"); return (SlpcObject) value; }
    private static void requireRef(Map<String, SlpcObject> values, String ref, String message) { if (!values.containsKey(ref)) fail("$", message + ": " + ref); }
    private static void refsExist(List<String> refs, Set<String> values, String message) { for (String ref : refs) if (!values.contains(ref)) fail("$", message + ": " + ref); }
    private static void unique(List<String> values, String label) { if (new HashSet<String>(values).size() != values.size()) fail("$", "duplicate " + label); }
    private static void contiguous(List<Long> values, String label) { for (int index = 0; index < values.size(); index++) if (values.get(index) != index + 1L) fail("$", label + " ordinals: expected contiguous values starting at 1, got " + values); }
    private static void localIds(List<String> values, String prefix, String label) { for (int index = 0; index < values.size(); index++) { String expected = String.format("%s%06d", prefix, index + 1); if (!expected.equals(values.get(index))) fail("$", label + " local IDs: expected " + expected + ", got " + values.get(index)); } }
    private static void equal(Object actual, Object expected, String message) { if (actual == null ? expected != null : !actual.equals(expected)) fail("$", message + ": expected " + expected + ", got " + actual); }
    private static void fail(String path, String message) { throw new Failure(path, message); }

    private static final class RoleRule { private final String role; private final boolean setLike; private final boolean required; private RoleRule(String role, boolean setLike, boolean required) { this.role = role; this.setLike = setLike; this.required = required; } }
    private static final class PathValue { private final String path; private final Object value; private PathValue(String path, Object value) { this.path = path; this.value = value; } }
    private static final class Failure extends IllegalArgumentException { private static final long serialVersionUID = 1L; private final String path; private Failure(String path, String message) { super(message); this.path = path; } }
}