@unson/brainbase-mcp 0.6.0 → 0.8.0

package/dist/judgment-view.js

@@ -0,0 +1,627 @@
+/**
+ * Read-only projection contract for following one judgment from its
+ * conclusion back to the exact Problem, Objective, evidence, child runs, and
+ * evaluation that were used at the time.
+ *
+ * This module deliberately owns neither a store nor an authorization policy.
+ * A host supplies a port after authenticating the request and binding its
+ * tenant/scope.  Every reference read is explicitly historical so the view
+ * cannot silently replace a past definition with its latest revision.
+ */
+export const JUDGMENT_VIEW_CONTRACT_VERSION = 'judgment-view.v1';
+export const JUDGMENT_VIEW_STATUSES = Object.freeze([
+    'resolved',
+    'unknown',
+    'permission_denied',
+    'unavailable',
+    'undecidable',
+    'invalid',
+]);
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function isStatus(value) {
+    return typeof value === 'string' && JUDGMENT_VIEW_STATUSES.includes(value);
+}
+function failure(status, reason) {
+    return { status, reason };
+}
+function sectionFailure(result) {
+    return { status: result.status, reason: result.reason };
+}
+function collectionFailure(result) {
+    return { status: result.status, items: null, absence_confirmed: false, reason: result.reason };
+}
+function resolvedSection(value) {
+    return { status: 'resolved', value };
+}
+function resolvedCollection(items) {
+    return { status: 'resolved', items, absence_confirmed: items.length === 0 };
+}
+function unknownCollection(reason) {
+    return { status: 'unknown', items: null, absence_confirmed: false, reason };
+}
+function statusFromResult(result) {
+    return result.status;
+}
+function safeReason(error) {
+    return error instanceof Error && error.message.trim().length > 0 ? error.message : 'read failed';
+}
+async function safeRead(reader) {
+    try {
+        const result = await reader();
+        if (!isRecord(result) || result.status === 'resolved' && !hasOwn(result, 'value')) {
+            return failure('unknown', 'read port returned an invalid result');
+        }
+        if (result.status !== 'resolved') {
+            if (!isStatus(result.status) || !nonEmptyString(result.reason)) {
+                return failure('unknown', 'read port returned an invalid failure');
+            }
+            return { status: result.status, reason: result.reason };
+        }
+        return { status: 'resolved', value: result.value };
+    }
+    catch (error) {
+        return failure('unavailable', safeReason(error));
+    }
+}
+function validDAGReference(value) {
+    return isRecord(value) && nonEmptyString(value.id) && nonEmptyString(value.version);
+}
+function validProblemReference(value) {
+    return isRecord(value)
+        && nonEmptyString(value.snapshot_id)
+        && nonEmptyString(value.problem_id)
+        && nonEmptyString(value.revision);
+}
+function sameProblemReference(left, right) {
+    return left.snapshot_id === right.snapshot_id
+        && left.problem_id === right.problem_id
+        && left.revision === right.revision;
+}
+function validEvidenceReference(value) {
+    return isRecord(value)
+        && nonEmptyString(value.kind)
+        && nonEmptyString(value.id)
+        && (value.revision === undefined || nonEmptyString(value.revision));
+}
+function validHistoricalEvidenceReference(value) {
+    return validEvidenceReference(value) && nonEmptyString(value.revision);
+}
+function validEvidenceRecord(value, reference) {
+    return isRecord(value)
+        && nonEmptyString(value.kind)
+        && value.kind === reference.kind
+        && nonEmptyString(value.id)
+        && value.id === reference.id
+        && nonEmptyString(value.revision)
+        && value.revision === reference.revision
+        && (value.digest === undefined || nonEmptyString(value.digest));
+}
+function validSubdagResult(value) {
+    if (!isRecord(value)
+        || !['completed', 'failed', 'held'].includes(String(value.status))
+        || !nonEmptyString(value.input_contract)
+        || !nonEmptyString(value.output_contract)
+        || !Array.isArray(value.evidence)) {
+        return false;
+    }
+    if (value.run_reference !== null && value.run_reference !== undefined) {
+        if (!isRecord(value.run_reference) || !nonEmptyString(value.run_reference.run_id) || !validDAGReference(value.run_reference.dag))
+            return false;
+    }
+    if (!Array.isArray(value.evidence) || value.evidence.some((item) => !validEvidenceReference(item)))
+        return false;
+    if (value.reason !== undefined && typeof value.reason !== 'string')
+        return false;
+    return true;
+}
+function validateCompositionRun(value, expectedRunId) {
+    if (!isRecord(value)
+        || value.run_id !== expectedRunId
+        || !validDAGReference(value.composition)
+        || !validDAGReference(value.parent_dag)
+        || !nonEmptyString(value.question)
+        || !validProblemReference(value.problem_snapshot)
+        || !['completed', 'failed', 'held'].includes(String(value.status))
+        || !Array.isArray(value.execution_order)
+        || value.execution_order.some((item) => !nonEmptyString(item))
+        || !Array.isArray(value.children)) {
+        return false;
+    }
+    return value.children.every((child) => {
+        if (!isRecord(child)
+            || !nonEmptyString(child.invocation_id)
+            || !validDAGReference(child.dag)
+            || !nonEmptyString(child.question)
+            || !nonEmptyString(child.input_contract)
+            || !nonEmptyString(child.output_contract)
+            || !validProblemReference(child.problem_snapshot)
+            || !Array.isArray(child.dependency_invocation_ids)
+            || child.dependency_invocation_ids.some((item) => !nonEmptyString(item))
+            || !Array.isArray(child.dependency_results)
+            || !validSubdagResult(child.result)) {
+            return false;
+        }
+        if (!sameProblemReference(child.problem_snapshot, value.problem_snapshot))
+            return false;
+        return true;
+    });
+}
+function validateSnapshot(value, expected) {
+    if (!isRecord(value)
+        || value.snapshot_version !== 'judgment-problem-snapshot.v1'
+        || value.problem_id !== expected.problem_id
+        || value.revision !== expected.revision
+        || !nonEmptyString(value.question)
+        || !Array.isArray(value.references)) {
+        return false;
+    }
+    return value.references.every((reference) => (isRecord(reference)
+        && nonEmptyString(reference.kind)
+        && nonEmptyString(reference.id)
+        && nonEmptyString(reference.revision)
+        && nonEmptyString(reference.digest)));
+}
+function validFoundationRef(value, type) {
+    return isRecord(value)
+        && nonEmptyString(value.id)
+        && nonEmptyString(value.revision)
+        && nonEmptyString(value.digest)
+        && (type === undefined || value.type === type);
+}
+function validFoundationRecord(value, reference) {
+    if (!isRecord(value) || !nonEmptyString(value.digest) || value.digest !== reference.digest || !isRecord(value.definition))
+        return false;
+    const definition = value.definition;
+    return definition.id === reference.id && definition.type === reference.type && definition.revision === reference.revision;
+}
+function sameFoundationRef(left, right) {
+    return left.id === right.id && left.type === right.type && left.revision === right.revision && left.digest === right.digest;
+}
+function asFoundationRef(reference) {
+    return {
+        id: reference.id,
+        type: reference.type,
+        revision: reference.revision,
+        digest: reference.digest,
+    };
+}
+function isObjectiveDefinition(value) {
+    return value.type === 'objective';
+}
+function isVariableDefinition(value) {
+    return value.type === 'variable';
+}
+function validObjectiveCriterion(value) {
+    return isRecord(value)
+        && isRecord(value.variableRef)
+        && value.variableRef.type === 'variable'
+        && nonEmptyString(value.variableRef.id)
+        && nonEmptyString(value.variableRef.revision)
+        && ['at_least', 'at_most', 'equals'].includes(String(value.operator))
+        && (value.target === undefined || typeof value.target === 'string' || typeof value.target === 'number' || typeof value.target === 'boolean');
+}
+function extractConclusion(artifact, runId, dag) {
+    if (!isRecord(artifact)
+        || artifact.run_id !== runId
+        || !validDAGReference(artifact.dag)
+        || artifact.dag.id !== dag.id
+        || artifact.dag.version !== dag.version
+        || !Array.isArray(artifact.execution_order)
+        || !Array.isArray(artifact.nodes)
+        || artifact.execution_order.length === 0) {
+        return null;
+    }
+    const finalNodeId = artifact.execution_order[artifact.execution_order.length - 1];
+    if (!nonEmptyString(finalNodeId))
+        return null;
+    const finalNode = artifact.nodes.find((node) => isRecord(node) && node.node_id === finalNodeId);
+    if (!finalNode || !hasOwn(finalNode, 'output'))
+        return null;
+    return {
+        source: 'parent-run-artifact',
+        runId,
+        dag,
+        value: finalNode.output,
+    };
+}
+function sectionStatus(section) {
+    return section.status;
+}
+function collectionStatus(collection) {
+    return collection.status;
+}
+function aggregateStatus(sections) {
+    const statuses = sections.map((section) => sectionStatus(section) ?? collectionStatus(section));
+    if (statuses.includes('invalid'))
+        return 'invalid';
+    if (statuses.includes('permission_denied'))
+        return 'permission_denied';
+    if (statuses.includes('unavailable'))
+        return 'unavailable';
+    if (statuses.includes('unknown'))
+        return 'unknown';
+    if (statuses.includes('undecidable'))
+        return 'undecidable';
+    return 'resolved';
+}
+function baseDocument(status, reason) {
+    return {
+        contract_version: JUDGMENT_VIEW_CONTRACT_VERSION,
+        mode: 'historical',
+        status,
+        ...(reason ? { reason } : {}),
+        run: { status, reason },
+        conclusion: { status, reason },
+        problem: { status, reason },
+        objective: { status, reason },
+        evidence: { status, items: null, absence_confirmed: false, reason },
+        childRuns: { status, items: null, absence_confirmed: false, reason },
+        resultEvaluation: { status, reason },
+        judgmentValidity: { status, reason },
+    };
+}
+function buildRunView(run) {
+    return {
+        runId: run.run_id,
+        status: run.status,
+        question: run.question,
+        composition: run.composition,
+        parentDag: run.parent_dag,
+        problemSnapshot: run.problem_snapshot,
+    };
+}
+function buildProblemView(snapshot, reference) {
+    return {
+        snapshotId: reference.snapshot_id,
+        problemId: snapshot.problem_id,
+        revision: snapshot.revision,
+        question: snapshot.question,
+        references: snapshot.references.map((item) => ({
+            kind: item.kind,
+            id: item.id,
+            revision: item.revision,
+            digest: item.digest,
+        })),
+    };
+}
+function buildChildView(child) {
+    return {
+        invocationId: child.invocation_id,
+        dag: child.dag,
+        status: child.result.status,
+        question: child.question,
+        ...(child.result.run_reference?.run_id ? { runId: child.result.run_reference.run_id } : {}),
+        conclusion: child.result.conclusion,
+        uncertainty: child.result.uncertainty,
+        applicability: child.result.applicability,
+        ...(child.result.reason ? { reason: child.result.reason } : {}),
+    };
+}
+async function buildObjectiveView(snapshot, access, port) {
+    const objectiveReferences = snapshot.references.filter((reference) => reference.kind === 'objective');
+    if (objectiveReferences.length === 0)
+        return { status: 'unknown', reason: 'objective reference is absent from the historical snapshot' };
+    if (objectiveReferences.length !== 1)
+        return { status: 'invalid', reason: 'historical snapshot must contain exactly one objective reference' };
+    const objectiveReference = objectiveReferences[0];
+    const foundationReference = {
+        id: objectiveReference.id,
+        type: 'objective',
+        revision: objectiveReference.revision,
+        digest: objectiveReference.digest,
+    };
+    const objectiveResult = await safeRead(() => port.readFoundationReference({
+        reference: foundationReference,
+        access,
+        resolution: 'historical',
+    }));
+    if (objectiveResult.status !== 'resolved')
+        return sectionFailure(objectiveResult);
+    if (!validFoundationRecord(objectiveResult.value, foundationReference) || !isObjectiveDefinition(objectiveResult.value.definition)) {
+        return { status: 'invalid', reason: 'historical objective reference readback does not match the requested objective' };
+    }
+    const objective = objectiveResult.value.definition;
+    if (!Array.isArray(objective.criteria) || objective.criteria.some((criterion) => !validObjectiveCriterion(criterion))) {
+        return { status: 'invalid', reason: 'objective criteria are malformed' };
+    }
+    const variableReferences = snapshot.references.filter((reference) => reference.kind === 'variable');
+    const criteria = [];
+    for (const criterion of objective.criteria) {
+        const variableReference = criterion.variableRef;
+        const matches = variableReferences.filter((reference) => (reference.id === variableReference.id && reference.revision === variableReference.revision));
+        if (matches.length !== 1)
+            return { status: 'unknown', reason: 'a criterion variable is not pinned in the historical snapshot' };
+        const requestedVariable = {
+            id: matches[0].id,
+            type: 'variable',
+            revision: matches[0].revision,
+            digest: matches[0].digest,
+        };
+        const variableResult = await safeRead(() => port.readFoundationReference({
+            reference: requestedVariable,
+            access,
+            resolution: 'historical',
+        }));
+        if (variableResult.status !== 'resolved')
+            return sectionFailure(variableResult);
+        if (!validFoundationRecord(variableResult.value, requestedVariable) || !isVariableDefinition(variableResult.value.definition)) {
+            return { status: 'invalid', reason: 'historical criterion variable readback does not match the requested variable' };
+        }
+        const variable = variableResult.value.definition;
+        criteria.push({
+            variableRef: requestedVariable,
+            operator: criterion.operator,
+            ...(criterion.target === undefined ? {} : { target: criterion.target }),
+            variable: {
+                meaning: variable.meaning,
+                subject: variable.subject,
+                valueKind: variable.valueKind,
+                ...(variable.unit === undefined ? {} : { unit: variable.unit }),
+                aggregation: variable.aggregation,
+                granularity: variable.granularity,
+            },
+        });
+    }
+    return resolvedSection({
+        ref: foundationReference,
+        meaning: objective.meaning,
+        desiredState: objective.desiredState,
+        adoptionState: objective.adoptionState,
+        ...(objective.epistemicState === undefined ? {} : { epistemicState: objective.epistemicState }),
+        beneficiaryIds: objective.beneficiaryIds,
+        criteria: resolvedCollection(criteria),
+    });
+}
+function highestFailure(results) {
+    const priority = [
+        'invalid',
+        'permission_denied',
+        'unavailable',
+        'unknown',
+        'undecidable',
+    ];
+    return [...results].sort((left, right) => priority.indexOf(left.status) - priority.indexOf(right.status))[0]
+        ?? failure('unknown', 'historical evidence could not be resolved');
+}
+async function buildEvidenceCollection(run, access, port) {
+    const evidence = [];
+    const failures = [];
+    for (const child of run.children) {
+        for (const reference of child.result.evidence) {
+            if (!validHistoricalEvidenceReference(reference)) {
+                failures.push(failure('invalid', 'historical evidence reference must include a revision'));
+                continue;
+            }
+            const evidenceResult = await safeRead(() => port.readEvidence({
+                invocationId: child.invocation_id,
+                ...(child.result.run_reference?.run_id ? { runId: child.result.run_reference.run_id } : {}),
+                reference,
+                access,
+                resolution: 'historical',
+            }));
+            if (evidenceResult.status !== 'resolved') {
+                failures.push(evidenceResult);
+                continue;
+            }
+            if (!validEvidenceRecord(evidenceResult.value, reference)) {
+                failures.push(failure('invalid', 'historical evidence readback does not match the requested reference'));
+                continue;
+            }
+            evidence.push({
+                source: 'subdag',
+                invocationId: child.invocation_id,
+                ...(child.result.run_reference?.run_id ? { runId: child.result.run_reference.run_id } : {}),
+                kind: evidenceResult.value.kind,
+                id: evidenceResult.value.id,
+                revision: evidenceResult.value.revision,
+                ...(evidenceResult.value.digest === undefined ? {} : { digest: evidenceResult.value.digest }),
+            });
+        }
+    }
+    if (failures.length > 0)
+        return collectionFailure(highestFailure(failures));
+    return resolvedCollection(evidence);
+}
+function validEvaluationRecord(value) {
+    if (!isRecord(value)
+        || value.version !== 1
+        || !nonEmptyString(value.id)
+        || !isRecord(value.snapshot)
+        || !isRecord(value.objectiveRef)
+        || !isRecord(value.outcomeCaseRef)
+        || !Array.isArray(value.predictions)
+        || !Array.isArray(value.actuals)
+        || !Array.isArray(value.criteria)
+        || !Array.isArray(value.predictionComparisons)
+        || !['achieved', 'not_achieved', 'indeterminate'].includes(String(value.achievement))
+        || !isRecord(value.judgmentAtTimeValidity)
+        || !['valid', 'invalid', 'indeterminate'].includes(String(value.judgmentAtTimeValidity.status))
+        || !nonEmptyString(value.judgmentAtTimeValidity.basis)
+        || !nonEmptyString(value.evaluatedAt))
+        return false;
+    if (!nonEmptyString(value.snapshot.snapshotId) || !nonEmptyString(value.snapshot.problemId) || !nonEmptyString(value.snapshot.revision))
+        return false;
+    if (!validFoundationRef(value.objectiveRef, 'objective'))
+        return false;
+    if (!nonEmptyString(value.outcomeCaseRef.id) || !nonEmptyString(value.outcomeCaseRef.revision) || !nonEmptyString(value.outcomeCaseRef.digest))
+        return false;
+    if (value.judgmentAtTimeValidity.evidenceRefs !== undefined
+        && (!Array.isArray(value.judgmentAtTimeValidity.evidenceRefs)
+            || value.judgmentAtTimeValidity.evidenceRefs.some((item) => !nonEmptyString(item))))
+        return false;
+    return true;
+}
+function sameEvaluationSnapshot(evaluation, snapshot) {
+    return evaluation.snapshot.snapshotId === snapshot.snapshot_id
+        && evaluation.snapshot.problemId === snapshot.problem_id
+        && evaluation.snapshot.revision === snapshot.revision
+        // snapshot_id is the canonical immutable Problem snapshot digest.  The
+        // evaluation must carry the same digest; matching locator fields alone is
+        // insufficient because a tampered evaluation could otherwise look
+        // historical while pointing at a different snapshot body.
+        && evaluation.snapshot.digest === snapshot.snapshot_id;
+}
+function buildEvaluationSections(evaluation, objective) {
+    if (!sameFoundationRef(evaluation.objectiveRef, objective)) {
+        return {
+            resultEvaluation: { status: 'invalid', reason: 'evaluation objective reference differs from the historical objective' },
+            judgmentValidity: { status: 'invalid', reason: 'evaluation objective reference differs from the historical objective' },
+        };
+    }
+    if (!Array.isArray(evaluation.criteria)
+        || !Array.isArray(evaluation.predictionComparisons)
+        || evaluation.criteria.some((item) => !isRecord(item))
+        || evaluation.predictionComparisons.some((item) => !isRecord(item))) {
+        return {
+            resultEvaluation: { status: 'invalid', reason: 'evaluation arrays are malformed' },
+            judgmentValidity: { status: 'invalid', reason: 'evaluation arrays are malformed' },
+        };
+    }
+    return {
+        resultEvaluation: resolvedSection({
+            evaluationId: evaluation.id,
+            achievement: evaluation.achievement,
+            criteria: evaluation.criteria,
+            predictionComparisons: evaluation.predictionComparisons,
+            evaluatedAt: evaluation.evaluatedAt,
+            outcomeCaseRef: evaluation.outcomeCaseRef,
+        }),
+        judgmentValidity: resolvedSection({
+            status: evaluation.judgmentAtTimeValidity.status,
+            basis: evaluation.judgmentAtTimeValidity.basis,
+            evidenceRefs: evaluation.judgmentAtTimeValidity.evidenceRefs ?? [],
+        }),
+    };
+}
+function requestIsValid(request) {
+    return isRecord(request)
+        && nonEmptyString(request.runId)
+        && isRecord(request.access)
+        && nonEmptyString(request.access.tenantId)
+        && nonEmptyString(request.access.principal)
+        && nonEmptyString(request.access.scopeId)
+        && (request.evaluationId === undefined || nonEmptyString(request.evaluationId));
+}
+export function createJudgmentViewService(port) {
+    if (!port || typeof port !== 'object')
+        throw new TypeError('A judgment view read port is required');
+    for (const method of ['readCompositionRun', 'readProblemSnapshot', 'readFoundationReference', 'readRunArtifact', 'readEvidence']) {
+        if (typeof port[method] !== 'function') {
+            throw new TypeError(`${method} is required`);
+        }
+    }
+    return {
+        async read(request) {
+            if (!requestIsValid(request))
+                return baseDocument('invalid', 'runId and trusted access context are required');
+            const runResult = await safeRead(() => port.readCompositionRun({ runId: request.runId, access: request.access }));
+            if (runResult.status !== 'resolved')
+                return baseDocument(runResult.status, runResult.reason);
+            if (!validateCompositionRun(runResult.value, request.runId))
+                return baseDocument('invalid', 'composition run record is malformed');
+            const run = runResult.value;
+            const runSection = resolvedSection(buildRunView(run));
+            const childRuns = resolvedCollection(run.children.map(buildChildView));
+            const evidence = await buildEvidenceCollection(run, request.access, port);
+            const problemResult = await safeRead(() => port.readProblemSnapshot({
+                reference: run.problem_snapshot,
+                access: request.access,
+                resolution: 'historical',
+            }));
+            const document = {
+                contract_version: JUDGMENT_VIEW_CONTRACT_VERSION,
+                mode: 'historical',
+                status: 'unknown',
+                run: runSection,
+                conclusion: { status: 'unknown', reason: 'parent run artifact is not available' },
+                problem: problemResult.status === 'resolved'
+                    && validateSnapshot(problemResult.value, run.problem_snapshot)
+                    ? resolvedSection(buildProblemView(problemResult.value, run.problem_snapshot))
+                    : problemResult.status === 'resolved'
+                        ? { status: 'invalid', reason: 'problem snapshot readback does not match the composition run' }
+                        : sectionFailure(problemResult),
+                objective: { status: 'unknown', reason: 'historical Problem snapshot is unavailable' },
+                evidence,
+                childRuns,
+                resultEvaluation: { status: 'unknown', reason: 'evaluation is not available' },
+                judgmentValidity: { status: 'unknown', reason: 'evaluation is not available' },
+            };
+            const artifactResult = await safeRead(() => port.readRunArtifact({
+                runId: run.run_id,
+                dag: run.parent_dag,
+                access: request.access,
+                resolution: 'historical',
+            }));
+            if (artifactResult.status === 'resolved') {
+                const conclusion = extractConclusion(artifactResult.value, run.run_id, run.parent_dag);
+                document.conclusion = conclusion ? resolvedSection(conclusion) : { status: 'invalid', reason: 'parent run artifact does not match the historical run' };
+            }
+            else {
+                document.conclusion = sectionFailure(artifactResult);
+            }
+            if (document.problem.status === 'resolved' && problemResult.status === 'resolved' && validateSnapshot(problemResult.value, run.problem_snapshot)) {
+                document.objective = await buildObjectiveView(problemResult.value, request.access, port);
+            }
+            if (port.readEvaluation && document.problem.status === 'resolved' && document.objective.status === 'resolved') {
+                const objective = document.objective.value?.ref;
+                if (objective) {
+                    const evaluationResult = await safeRead(() => port.readEvaluation({
+                        runId: run.run_id,
+                        snapshot: run.problem_snapshot,
+                        objective,
+                        ...(request.evaluationId ? { evaluationId: request.evaluationId } : {}),
+                        access: request.access,
+                        resolution: 'historical',
+                    }));
+                    if (evaluationResult.status === 'resolved') {
+                        if (!validEvaluationRecord(evaluationResult.value) || !sameEvaluationSnapshot(evaluationResult.value, run.problem_snapshot)) {
+                            document.resultEvaluation = { status: 'invalid', reason: 'evaluation readback does not match the historical Problem snapshot' };
+                            document.judgmentValidity = { status: 'invalid', reason: 'evaluation readback does not match the historical Problem snapshot' };
+                        }
+                        else {
+                            const sections = buildEvaluationSections(evaluationResult.value, objective);
+                            document.resultEvaluation = sections.resultEvaluation;
+                            document.judgmentValidity = sections.judgmentValidity;
+                        }
+                    }
+                    else {
+                        document.resultEvaluation = sectionFailure(evaluationResult);
+                        document.judgmentValidity = sectionFailure(evaluationResult);
+                    }
+                }
+            }
+            const status = aggregateStatus([
+                document.run,
+                document.conclusion,
+                document.problem,
+                document.objective,
+                document.evidence,
+                document.childRuns,
+                document.resultEvaluation,
+                document.judgmentValidity,
+            ]);
+            const reasons = [
+                document.conclusion.reason,
+                document.problem.reason,
+                document.objective.reason,
+                document.resultEvaluation.reason,
+                document.judgmentValidity.reason,
+            ].filter((reason) => nonEmptyString(reason));
+            document.status = status;
+            if (reasons.length > 0)
+                document.reason = reasons[0];
+            return document;
+        },
+    };
+}
+export async function readJudgmentView(port, request) {
+    return createJudgmentViewService(port).read(request);
+}