@semacode/cli 2.3.1 → 3.5.0

package/dist/saidaCli.js

@@ -0,0 +1,118 @@
+// SEMA-GOVERNED: sema.produto.cli_invocacao_publica, sema.produto.cli_invocacao_publica.resultados
+// Descrição: cria e emite os envelopes JSON públicos de controle v1 e resultado v1 da CLI.
+import { criarEnvelopeResultadoCliV1, } from "./resultadoCli.js";
+export { CODIGO_SAIDA_FATAL_RUNTIME_CLI, SCHEMA_RESULTADO_CLI_V1, criarEnvelopeResultadoCliV1, interpretarPayloadRuntimeCli, } from "./resultadoCli.js";
+export const SCHEMA_CONTROLE_CLI_V1 = "sema.cli.control/v1";
+const CODIGO_PADRAO = {
+    HELP: "CLI_HELP",
+    UNKNOWN_COMMAND: "CLI_UNKNOWN_COMMAND",
+    ARGUMENT_ERROR: "CLI_ARGUMENT_ERROR",
+    FATAL_ERROR: "CLI_FATAL_ERROR",
+};
+const MENSAGEM_PADRAO = {
+    HELP: "Ajuda da CLI Sema.",
+    UNKNOWN_COMMAND: "Comando Sema desconhecido.",
+    ARGUMENT_ERROR: "Argumentos inválidos. Consulte a ajuda do comando.",
+    FATAL_ERROR: "Falha ao executar a CLI da Sema.",
+};
+const CODIGO_PUBLICO_VALIDO = /^[A-Z][A-Z0-9_]{2,63}$/u;
+const PREFIXO_ERRO_INTERNO = /\b(?:Aggregate|Eval|Internal|Range|Reference|Syntax|Type|URI)?Error\s*:/iu;
+const TRECHO_STACK = /(?:^|[\s;|=(:,])at\s+(?:async\s+)?(?:new\s+)?[^\n]{0,240}?(?:\([^()\n]*:\d+:\d+\)|[^\s()\n]+:\d+:\d+)/iu;
+function decodificarPercentAscii(valor) {
+    return valor.replace(/%([0-9a-f]{2})/giu, (_trecho, hexadecimal) => String.fromCharCode(Number.parseInt(hexadecimal, 16)));
+}
+function variantesTextoPublico(valor) {
+    const variantes = new Set([valor.normalize("NFC")]);
+    let atual = valor;
+    for (let tentativa = 0; tentativa < 3; tentativa += 1) {
+        const decodificado = decodificarPercentAscii(atual);
+        if (decodificado === atual) {
+            break;
+        }
+        variantes.add(decodificado.normalize("NFC"));
+        atual = decodificado;
+    }
+    return [...variantes];
+}
+function contemCaminhoAbsoluto(valor) {
+    return variantesTextoPublico(valor).some((variante) => {
+        const normalizada = variante.replaceAll("\\", "/");
+        const semUrlsPublicas = normalizada.replace(/\b(?:https?|wss?):\/\/[^\s"'<>]+/giu, "");
+        return /(?:^|[^A-Za-z0-9])file:\/{1,3}/iu.test(semUrlsPublicas)
+            || /(?:^|[^A-Za-z0-9])[A-Za-z]:\/(?:[^/\s"'<>]+(?:\/[^/\s"'<>]*)*)?/u.test(semUrlsPublicas)
+            || /(?:^|[^A-Za-z0-9_./])\/\/[^/\s"'<>]+\/[^/\s"'<>]+/u.test(semUrlsPublicas)
+            || /(?:^|[^A-Za-z0-9_./])\/(?!\/)[^/\s"'<>]+(?:\/[^/\s"'<>]*)*/u.test(semUrlsPublicas);
+    });
+}
+function normalizarCodigoPublico(categoria, codigo) {
+    const candidato = codigo.trim();
+    return CODIGO_PUBLICO_VALIDO.test(candidato) ? candidato : CODIGO_PADRAO[categoria];
+}
+function normalizarMensagemPublica(categoria, mensagem) {
+    if (categoria !== "HELP") {
+        return MENSAGEM_PADRAO[categoria];
+    }
+    const candidata = mensagem.trim();
+    if (!candidata
+        || contemCaminhoAbsoluto(candidata)
+        || TRECHO_STACK.test(candidata)
+        || PREFIXO_ERRO_INTERNO.test(candidata)) {
+        return MENSAGEM_PADRAO[categoria];
+    }
+    return candidata;
+}
+export function criarEnvelopeControleJsonV1(entrada) {
+    const help = entrada.categoria === "HELP";
+    const exitCode = help
+        ? 0
+        : entrada.codigoSaida === 0
+            ? 1
+            : entrada.codigoSaida;
+    return {
+        schemaVersion: SCHEMA_CONTROLE_CLI_V1,
+        ok: help,
+        kind: entrada.categoria,
+        code: normalizarCodigoPublico(entrada.categoria, entrada.codigoPublico),
+        message: normalizarMensagemPublica(entrada.categoria, entrada.mensagemPublica),
+        exitCode,
+    };
+}
+export function emitirResultadoCliJsonV1(entrada) {
+    const envelope = criarEnvelopeResultadoCliV1(entrada);
+    // Uma única escrita lógica impede documentos JSON parciais no processo público.
+    console.log(JSON.stringify(envelope, null, 2));
+    return envelope;
+}
+function envelopeSeguroParaInvocacao(resultado, envelope, mensagemTexto) {
+    const coerente = envelope?.kind === resultado ? envelope : undefined;
+    return criarEnvelopeControleJsonV1({
+        categoria: resultado,
+        codigoPublico: coerente?.code ?? CODIGO_PADRAO[resultado],
+        mensagemPublica: resultado === "HELP"
+            ? coerente?.message ?? mensagemTexto ?? MENSAGEM_PADRAO.HELP
+            : MENSAGEM_PADRAO[resultado],
+        codigoSaida: coerente?.exitCode ?? (resultado === "HELP" ? 0 : 1),
+    });
+}
+export function executarInvocacaoPublica(opcoes) {
+    const envelope = envelopeSeguroParaInvocacao(opcoes.resultado, opcoes.envelopeControle, opcoes.mensagemTexto);
+    if (opcoes.modoJson) {
+        // Uma única escrita lógica mantém JSON de controle em um único documento no stdout.
+        console.log(JSON.stringify(envelope, null, 2));
+    }
+    else if (opcoes.resultado === "HELP") {
+        console.log(envelope.message);
+    }
+    else {
+        console.error(envelope.message);
+    }
+    return {
+        codigoSaida: envelope.exitCode,
+        envelopeControleEmitido: opcoes.modoJson,
+        stderrVazio: opcoes.modoJson || opcoes.resultado === "HELP",
+        handlerExecutado: false,
+        politicaControleJsonV1Respeitada: true,
+        politicaHelpPuroRespeitada: true,
+    };
+}
+//# sourceMappingURL=saidaCli.js.map

package/dist/sistemasInterativos/acceptanceEvidence.d.ts

@@ -0,0 +1,22 @@
+import { type AcceptanceLockV1, type AcceptanceOperationValue, type AcceptanceTimeRange, type MultimodalChannelType, type MultimodalEvidenceDescriptorV1, type OperationResult, type Sha256 } from "./operationsTypes.js";
+export declare function validarAcceptanceLock(input: unknown): OperationResult<{
+    readonly lock: AcceptanceLockV1;
+    readonly lockDigest: Sha256;
+}>;
+export declare function operarAcceptanceLock(operation: unknown, lockInput: unknown, contextInput: unknown): OperationResult<AcceptanceOperationValue>;
+export declare function digestVinculoClaimMultimodal(input: {
+    readonly claimId: string;
+    readonly runId: string;
+    readonly definitionDigest: Sha256;
+    readonly planDigest: Sha256;
+    readonly contractDigest: Sha256;
+    readonly artifactDigest: Sha256;
+    readonly sceneId: string;
+    readonly timeRange: AcceptanceTimeRange;
+    readonly requiredModalities: readonly MultimodalChannelType[];
+}): Sha256;
+export declare function validarEvidenciaMultimodal(input: unknown): OperationResult<{
+    readonly descriptor: MultimodalEvidenceDescriptorV1;
+    readonly descriptorDigest: Sha256;
+    readonly localDescriptorOnly: true;
+}>;

package/dist/sistemasInterativos/acceptanceEvidence.js

@@ -0,0 +1,345 @@
+// SEMA-GOVERNED: sema.produto.sistemas_interativos.operacao.acceptance_evidencias
+// Descricao: acceptance locks, invalidacao explicita e evidencia multimodal local nao autoritativa.
+import { ACCEPTANCE_LOCK_SCHEMA_V1, MULTIMODAL_EVIDENCE_SCHEMA_V1, } from "./operationsTypes.js";
+import { MEDIA_TYPE_PATTERN, canonicalJson, digestJsonOperacional, failure, hasOnlyKeys, inspectPlainJson, isIntegerIn, isIsoTimestamp, isRecord, isSafeName, isSemanticId, isSha256, isVersion, issue, success, } from "./operationPrimitives.js";
+const ACCEPTANCE_REASONS = new Set([
+    "ARTIFACT_CHANGED", "SCENE_CHANGED", "TIME_RANGE_CHANGED", "APPROVER_REVOKED", "MANUAL_WITHDRAWAL",
+]);
+function validateTimeRange(input, field, issues) {
+    if (!isRecord(input)
+        || !hasOnlyKeys(input, ["start", "end", "unit"])
+        || typeof input.start !== "number"
+        || !Number.isFinite(input.start)
+        || input.start < 0
+        || typeof input.end !== "number"
+        || !Number.isFinite(input.end)
+        || input.end <= input.start
+        || (input.unit !== "FRAME" && input.unit !== "TICK" && input.unit !== "SECOND")) {
+        issues.push(issue("time_range_invalid", field));
+        return false;
+    }
+    return true;
+}
+export function validarAcceptanceLock(input) {
+    const issues = inspectPlainJson(input, "acceptanceLock");
+    if (!isRecord(input))
+        return failure([...issues, issue("acceptance_lock_object_required", "acceptanceLock")]);
+    if (!hasOnlyKeys(input, [
+        "schemaVersion", "lockId", "artifactDigest", "sceneId", "timeRange", "approver",
+        "decision", "status", "createdAt", "invalidation", "authoritative",
+    ]))
+        issues.push(issue("acceptance_lock_unknown_field", "acceptanceLock"));
+    if (input.schemaVersion !== ACCEPTANCE_LOCK_SCHEMA_V1)
+        issues.push(issue("acceptance_lock_schema_invalid", "schemaVersion"));
+    if (!isSemanticId(input.lockId))
+        issues.push(issue("acceptance_lock_id_invalid", "lockId"));
+    if (!isSha256(input.artifactDigest))
+        issues.push(issue("acceptance_artifact_digest_invalid", "artifactDigest"));
+    if (!isSemanticId(input.sceneId))
+        issues.push(issue("acceptance_scene_id_invalid", "sceneId"));
+    validateTimeRange(input.timeRange, "timeRange", issues);
+    if (!isRecord(input.approver)
+        || !hasOnlyKeys(input.approver, ["approverIdDigest", "role", "method"])
+        || !isSha256(input.approver.approverIdDigest)
+        || !isSafeName(input.approver.role)
+        || (input.approver.method !== "HUMAN" && input.approver.method !== "POLICY")) {
+        issues.push(issue("acceptance_approver_invalid", "approver"));
+    }
+    if (input.decision !== "ACCEPTED")
+        issues.push(issue("acceptance_decision_invalid", "decision"));
+    if (input.status !== "ACTIVE" && input.status !== "INVALIDATED")
+        issues.push(issue("acceptance_status_invalid", "status"));
+    if (!isIsoTimestamp(input.createdAt))
+        issues.push(issue("acceptance_created_at_invalid", "createdAt"));
+    if (input.authoritative !== false)
+        issues.push(issue("acceptance_lock_must_be_non_authoritative", "authoritative"));
+    if (input.status === "ACTIVE" && input.invalidation !== undefined) {
+        issues.push(issue("active_lock_cannot_have_invalidation", "invalidation"));
+    }
+    if (input.status === "INVALIDATED") {
+        const invalidation = input.invalidation;
+        if (!isRecord(invalidation)
+            || !hasOnlyKeys(invalidation, ["previousLockDigest", "invalidatedByDigest", "reasonCode", "invalidatedAt"])
+            || !isSha256(invalidation.previousLockDigest)
+            || !isSha256(invalidation.invalidatedByDigest)
+            || typeof invalidation.reasonCode !== "string"
+            || !ACCEPTANCE_REASONS.has(invalidation.reasonCode)
+            || !isIsoTimestamp(invalidation.invalidatedAt)) {
+            issues.push(issue("acceptance_invalidation_invalid", "invalidation"));
+        }
+    }
+    if (issues.length > 0)
+        return failure(issues);
+    const lock = input;
+    const normalized = {
+        ...lock,
+        timeRange: { ...lock.timeRange },
+        approver: { ...lock.approver },
+        ...(lock.invalidation === undefined ? {} : { invalidation: { ...lock.invalidation } }),
+    };
+    const lockDigest = digestJsonOperacional(normalized);
+    return success({ lock: normalized, lockDigest }, lockDigest);
+}
+export function operarAcceptanceLock(operation, lockInput, contextInput) {
+    if (operation !== "VALIDATE" && operation !== "EVALUATE" && operation !== "INVALIDATE") {
+        return failure([issue("acceptance_operation_invalid", "operation")]);
+    }
+    const lockResult = validarAcceptanceLock(lockInput);
+    if (!lockResult.value)
+        return failure(lockResult.issues);
+    const contextIssues = inspectPlainJson(contextInput, "context");
+    if (!isRecord(contextInput))
+        return failure([...contextIssues, issue("acceptance_context_object_required", "context")]);
+    const lock = lockResult.value.lock;
+    const active = lock.status === "ACTIVE";
+    if (operation === "VALIDATE") {
+        if (!hasOnlyKeys(contextInput, []))
+            contextIssues.push(issue("acceptance_validate_context_must_be_empty", "context"));
+        if (contextIssues.length > 0)
+            return failure(contextIssues);
+        return success({
+            operation,
+            accepted: active,
+            bindingMatches: active,
+            invalidated: !active,
+            blockers: active ? [] : ["acceptance_lock_invalidated"],
+            lock,
+            lockDigest: lockResult.value.lockDigest,
+        }, lockResult.value.lockDigest);
+    }
+    if (operation === "EVALUATE") {
+        if (!hasOnlyKeys(contextInput, ["artifactDigest", "sceneId", "timeRange"])) {
+            contextIssues.push(issue("acceptance_evaluate_unknown_field", "context"));
+        }
+        if (!isSha256(contextInput.artifactDigest))
+            contextIssues.push(issue("acceptance_context_artifact_invalid", "context"));
+        if (!isSemanticId(contextInput.sceneId))
+            contextIssues.push(issue("acceptance_context_scene_invalid", "context"));
+        validateTimeRange(contextInput.timeRange, "context", contextIssues);
+        if (contextIssues.length > 0)
+            return failure(contextIssues);
+        const bindingMatches = lock.artifactDigest === contextInput.artifactDigest
+            && lock.sceneId === contextInput.sceneId
+            && canonicalJson(lock.timeRange) === canonicalJson(contextInput.timeRange);
+        const blockers = [
+            ...(active ? [] : ["acceptance_lock_invalidated"]),
+            ...(bindingMatches ? [] : ["acceptance_binding_mismatch"]),
+        ];
+        return success({
+            operation,
+            accepted: active && bindingMatches,
+            bindingMatches,
+            invalidated: !active,
+            blockers,
+            lock,
+            lockDigest: lockResult.value.lockDigest,
+        }, lockResult.value.lockDigest);
+    }
+    if (!hasOnlyKeys(contextInput, ["lockDigest", "invalidatedByDigest", "reasonCode", "invalidatedAt"])) {
+        contextIssues.push(issue("acceptance_invalidate_unknown_field", "context"));
+    }
+    if (!isSha256(contextInput.lockDigest) || contextInput.lockDigest !== lockResult.value.lockDigest) {
+        contextIssues.push(issue("acceptance_lock_digest_mismatch", "context"));
+    }
+    if (!isSha256(contextInput.invalidatedByDigest))
+        contextIssues.push(issue("acceptance_invalidator_invalid", "context"));
+    if (typeof contextInput.reasonCode !== "string"
+        || !ACCEPTANCE_REASONS.has(contextInput.reasonCode)) {
+        contextIssues.push(issue("acceptance_invalidation_reason_invalid", "context"));
+    }
+    if (!isIsoTimestamp(contextInput.invalidatedAt))
+        contextIssues.push(issue("acceptance_invalidated_at_invalid", "context"));
+    if (!active)
+        contextIssues.push(issue("acceptance_lock_already_invalidated", "acceptanceLock"));
+    if (contextIssues.length > 0)
+        return failure(contextIssues);
+    const invalidatedLock = {
+        ...lock,
+        status: "INVALIDATED",
+        invalidation: {
+            previousLockDigest: lockResult.value.lockDigest,
+            invalidatedByDigest: contextInput.invalidatedByDigest,
+            reasonCode: contextInput.reasonCode,
+            invalidatedAt: contextInput.invalidatedAt,
+        },
+    };
+    const lockDigest = digestJsonOperacional(invalidatedLock);
+    return success({
+        operation,
+        accepted: false,
+        bindingMatches: true,
+        invalidated: true,
+        blockers: ["acceptance_lock_invalidated"],
+        lock: invalidatedLock,
+        lockDigest,
+    }, lockDigest);
+}
+const MULTIMODAL_CHANNEL_TYPES = new Set([
+    "SCREENSHOT", "VIDEO", "DEPTH", "NORMALS", "OBJECT_ID",
+    "MOTION", "TRANSFORMS", "EVENTS", "AUDIO", "TELEMETRY",
+]);
+export function digestVinculoClaimMultimodal(input) {
+    return digestJsonOperacional({ ...input, requiredModalities: [...input.requiredModalities].sort() });
+}
+export function validarEvidenciaMultimodal(input) {
+    const issues = inspectPlainJson(input, "evidence");
+    if (!isRecord(input))
+        return failure([...issues, issue("evidence_object_required", "evidence")]);
+    if (!hasOnlyKeys(input, [
+        "schemaVersion", "evidenceId", "runId", "claimId", "definitionDigest", "planDigest", "contractDigest",
+        "claimBindingDigest", "artifactDigest", "sceneId", "timeRange", "requiredModalities", "channels",
+        "producer", "verifier", "decision", "observedAt", "authoritative",
+    ]))
+        issues.push(issue("evidence_unknown_field", "evidence"));
+    if (input.schemaVersion !== MULTIMODAL_EVIDENCE_SCHEMA_V1)
+        issues.push(issue("evidence_schema_invalid", "schemaVersion"));
+    if (!isSemanticId(input.evidenceId))
+        issues.push(issue("evidence_id_invalid", "evidenceId"));
+    if (!isSemanticId(input.runId))
+        issues.push(issue("evidence_run_id_invalid", "runId"));
+    if (!isSemanticId(input.claimId))
+        issues.push(issue("evidence_claim_id_invalid", "claimId"));
+    if (!isSha256(input.definitionDigest))
+        issues.push(issue("evidence_definition_digest_invalid", "definitionDigest"));
+    if (!isSha256(input.planDigest))
+        issues.push(issue("evidence_plan_digest_invalid", "planDigest"));
+    if (!isSha256(input.contractDigest))
+        issues.push(issue("evidence_contract_digest_invalid", "contractDigest"));
+    if (!isSha256(input.artifactDigest))
+        issues.push(issue("evidence_artifact_digest_invalid", "artifactDigest"));
+    if (!isSemanticId(input.sceneId))
+        issues.push(issue("evidence_scene_id_invalid", "sceneId"));
+    const timeRange = input.timeRange;
+    const timeRangeValid = validateTimeRange(timeRange, "timeRange", issues);
+    const requiredModalitiesInput = input.requiredModalities;
+    const requiredModalitiesValid = Array.isArray(requiredModalitiesInput)
+        && requiredModalitiesInput.length > 0
+        && requiredModalitiesInput.every((type) => typeof type === "string"
+            && MULTIMODAL_CHANNEL_TYPES.has(type))
+        && new Set(requiredModalitiesInput).size === requiredModalitiesInput.length;
+    const requiredModalities = requiredModalitiesValid
+        ? requiredModalitiesInput
+        : [];
+    if (!requiredModalitiesValid)
+        issues.push(issue("evidence_required_modalities_invalid", "requiredModalities"));
+    if (!isSha256(input.claimBindingDigest)
+        || !isSemanticId(input.claimId)
+        || !isSemanticId(input.runId)
+        || !isSha256(input.definitionDigest)
+        || !isSha256(input.planDigest)
+        || !isSha256(input.contractDigest)
+        || !isSha256(input.artifactDigest)
+        || !isSemanticId(input.sceneId)
+        || !timeRangeValid
+        || input.claimBindingDigest !== digestVinculoClaimMultimodal({
+            claimId: input.claimId,
+            runId: input.runId,
+            definitionDigest: input.definitionDigest,
+            planDigest: input.planDigest,
+            contractDigest: input.contractDigest,
+            artifactDigest: input.artifactDigest,
+            sceneId: input.sceneId,
+            timeRange,
+            requiredModalities,
+        }))
+        issues.push(issue("evidence_claim_binding_invalid", "claimBindingDigest"));
+    if (!isIsoTimestamp(input.observedAt))
+        issues.push(issue("evidence_observed_at_invalid", "observedAt"));
+    if (input.authoritative !== false)
+        issues.push(issue("evidence_must_be_non_authoritative", "authoritative"));
+    const channelIds = new Set();
+    const channelTypes = new Set();
+    if (!Array.isArray(input.channels) || input.channels.length === 0) {
+        issues.push(issue("evidence_channels_required", "channels"));
+    }
+    else
+        for (const channel of input.channels) {
+            if (!isRecord(channel)
+                || !hasOnlyKeys(channel, [
+                    "channelId", "type", "artifactDigest", "mediaType", "metadataDigest", "sampleCount",
+                ])
+                || !isSemanticId(channel.channelId)
+                || typeof channel.type !== "string"
+                || !MULTIMODAL_CHANNEL_TYPES.has(channel.type)
+                || !isSha256(channel.artifactDigest)
+                || typeof channel.mediaType !== "string"
+                || !MEDIA_TYPE_PATTERN.test(channel.mediaType)
+                || !isSha256(channel.metadataDigest)
+                || !isIntegerIn(channel.sampleCount, 1, 1_000_000_000)) {
+                issues.push(issue("evidence_channel_invalid", "channels"));
+                continue;
+            }
+            if (channelIds.has(channel.channelId))
+                issues.push(issue("evidence_channel_id_duplicate", "channels"));
+            if (channelTypes.has(channel.type))
+                issues.push(issue("evidence_channel_type_duplicate", "channels"));
+            channelIds.add(channel.channelId);
+            channelTypes.add(channel.type);
+        }
+    const producer = input.producer;
+    if (!isRecord(producer)
+        || !hasOnlyKeys(producer, ["producerIdDigest", "producerType", "version", "configurationDigest"])
+        || !isSha256(producer.producerIdDigest)
+        || (producer.producerType !== "ENGINE"
+            && producer.producerType !== "EDITOR"
+            && producer.producerType !== "RUNNER"
+            && producer.producerType !== "MODEL"
+            && producer.producerType !== "HUMAN"
+            && producer.producerType !== "SENSOR")
+        || !isVersion(producer.version)
+        || !isSha256(producer.configurationDigest))
+        issues.push(issue("evidence_producer_invalid", "producer"));
+    const verifier = input.verifier;
+    if (!isRecord(verifier)
+        || !hasOnlyKeys(verifier, [
+            "verifierIdDigest", "verifierType", "version", "independent", "configurationDigest",
+        ])
+        || !isSha256(verifier.verifierIdDigest)
+        || (verifier.verifierType !== "RULE"
+            && verifier.verifierType !== "MODEL"
+            && verifier.verifierType !== "HUMAN"
+            && verifier.verifierType !== "SENSOR")
+        || !isVersion(verifier.version)
+        || verifier.independent !== true
+        || !isSha256(verifier.configurationDigest))
+        issues.push(issue("evidence_verifier_invalid", "verifier"));
+    if (isRecord(producer) && isRecord(verifier)
+        && isSha256(producer.producerIdDigest) && isSha256(verifier.verifierIdDigest)
+        && producer.producerIdDigest === verifier.verifierIdDigest) {
+        issues.push(issue("evidence_verifier_not_independent", "verifier"));
+    }
+    const decision = input.decision;
+    if (!isRecord(decision)
+        || !hasOnlyKeys(decision, ["verdict", "reasonCodes", "confidenceBasisPoints"])
+        || (decision.verdict !== "PASS" && decision.verdict !== "FAIL" && decision.verdict !== "INCONCLUSIVE")
+        || !Array.isArray(decision.reasonCodes)
+        || decision.reasonCodes.length === 0
+        || decision.reasonCodes.some((code) => !isSafeName(code))
+        || new Set(decision.reasonCodes).size !== decision.reasonCodes.length
+        || !isIntegerIn(decision.confidenceBasisPoints, 0, 10_000))
+        issues.push(issue("evidence_decision_invalid", "decision"));
+    if (isRecord(decision) && decision.verdict === "PASS") {
+        if (!requiredModalitiesValid || requiredModalities.length < 2) {
+            issues.push(issue("evidence_pass_requires_multiple_modalities", "requiredModalities"));
+        }
+        else if (!requiredModalities.every((type) => channelTypes.has(type))) {
+            issues.push(issue("evidence_pass_missing_required_modality", "channels"));
+        }
+    }
+    if (issues.length > 0)
+        return failure(issues);
+    const descriptor = input;
+    const normalized = {
+        ...descriptor,
+        timeRange: { ...descriptor.timeRange },
+        requiredModalities: [...descriptor.requiredModalities].sort(),
+        channels: descriptor.channels.map((channel) => ({ ...channel }))
+            .sort((left, right) => left.type.localeCompare(right.type) || left.channelId.localeCompare(right.channelId)),
+        producer: { ...descriptor.producer },
+        verifier: { ...descriptor.verifier },
+        decision: { ...descriptor.decision, reasonCodes: [...descriptor.decision.reasonCodes].sort() },
+    };
+    const descriptorDigest = digestJsonOperacional(normalized);
+    return success({ descriptor: normalized, descriptorDigest, localDescriptorOnly: true }, descriptorDigest);
+}
+//# sourceMappingURL=acceptanceEvidence.js.map

package/dist/sistemasInterativos/engineObservation.d.ts

@@ -0,0 +1,12 @@
+import { type AssetProvenanceV1, type EditorStateV1, type EngineSnapshotDiffV1, type OperationResult, type Sha256, type ValidatedEngineSnapshot } from "./operationsTypes.js";
+export declare function validarSnapshotEngine(input: unknown): OperationResult<ValidatedEngineSnapshot>;
+export declare function derivarDiffSnapshotsEngine(beforeInput: unknown, afterInput: unknown): OperationResult<EngineSnapshotDiffV1>;
+export declare function validarProvenienciaAsset(input: unknown): OperationResult<{
+    readonly provenance: AssetProvenanceV1;
+    readonly provenanceDigest: Sha256;
+}>;
+export declare function validarEstadoEditor(input: unknown): OperationResult<{
+    readonly state: EditorStateV1;
+    readonly editorStateDigest: Sha256;
+    readonly externallyObserved: false;
+}>;