@semacode/cli 2.2.0 → 2.3.0

package/dist/sistemasInterativos/render.js

@@ -0,0 +1,179 @@
+// SEMA-GOVERNED: sema.produto.sistemas_interativos.cli
+// Descricao: renderer textual contextual, deterministico e honesto sobre a fronteira externa.
+const MENSAGENS_ERRO = Object.freeze({
+    INTERATIVO_ENTRADA_INVALIDA: "A entrada ou o arquivo JSON informado não pôde ser validado.",
+    INTERATIVO_ARGUMENTOS_INVALIDOS: "As flags, valores ou argumentos não correspondem à allowlist do subcomando.",
+    INTERATIVO_FILTRO_INVALIDO: "Um filtro usa valor fora do vocabulário canônico.",
+    INTERATIVO_SUBCOMANDO_DESCONHECIDO: "O subcomando não existe na superfície de sistemas interativos.",
+});
+function registro(valor) {
+    return typeof valor === "object" && valor !== null && !Array.isArray(valor)
+        ? valor
+        : undefined;
+}
+function lista(valor) {
+    return Array.isArray(valor) ? valor : [];
+}
+function textos(valor) {
+    return lista(valor).filter((item) => typeof item === "string");
+}
+function unicos(valores) {
+    return [...new Set(valores.filter((item) => item.length > 0))];
+}
+function ids(valor, campo) {
+    return unicos(lista(valor).flatMap((item) => {
+        if (typeof item === "string")
+            return [item];
+        const objeto = registro(item);
+        return typeof objeto?.[campo] === "string" ? [objeto[campo]] : [];
+    }));
+}
+function adicionarSecao(linhas, titulo, itens) {
+    if (itens.length === 0)
+        return;
+    linhas.push("", `${titulo} · ${itens.length}`, ...itens.map((item) => `- ${item}`));
+}
+function obterBloqueios(payload, estado) {
+    const bloqueios = unicos([
+        ...textos(payload.bloqueios),
+        ...textos(estado?.bloqueios),
+    ]);
+    const errorCode = typeof payload.errorCode === "string" ? payload.errorCode : undefined;
+    return errorCode ? unicos([...bloqueios, errorCode]) : bloqueios;
+}
+function obterProximosPassos(payload, plano, estado, evidenciasAusentes) {
+    const explicitos = unicos([
+        ...textos(payload.nextActions),
+        ...textos(plano?.nextActions),
+        ...textos(estado?.nextActions),
+    ]);
+    if (explicitos.length > 0)
+        return explicitos;
+    if (evidenciasAusentes.length > 0) {
+        return evidenciasAusentes.map((item) => `coletar_evidencia_externa:${item}`);
+    }
+    const comando = typeof payload.comando === "string" ? payload.comando : "desconhecido";
+    const sucesso = payload.sucesso === true;
+    const padrao = {
+        capabilities: "consultar pipelines ou adapters com os filtros do sistema alvo",
+        schema: "usar o shape v1 e um examplePath como base para a definição",
+        pipelines: "validar uma definição e então gerar um plano declarativo",
+        adapters: "selecionar explicitamente um adapter compatível no runner externo",
+        validar: sucesso ? "planejar a definição validada" : "corrigir os bloqueios da definição",
+        planejar: sucesso ? "entregar o plano ao runner externo autorizado" : "corrigir os bloqueios antes de qualquer execução externa",
+        "validar-evidencias": sucesso ? "derivar o status local do bundle validado" : "coletar ou corrigir as evidências externas ausentes",
+        status: "usar o estado somente como visão local regenerável",
+        "validar-protocolo": sucesso ? "arquivar o registro junto às evidências externas" : "corrigir a sequência do protocolo e observar rollback quando exigido",
+        desconhecido: "usar capabilities, schema, pipelines, adapters, validar, planejar, validar-evidencias, status ou validar-protocolo",
+    };
+    return [padrao[comando] ?? padrao.desconhecido];
+}
+function adicionarCobertura(linhas, matrix) {
+    if (!matrix)
+        return;
+    const campos = [
+        ["TIPOS", "kinds"],
+        ["MODELOS ESPACIAIS", "spatialModels"],
+        ["MODOS DE RENDER", "renderModes"],
+        ["PERFIS VISUAIS", "visualProfiles"],
+        ["CONTROLES", "controlModes"],
+        ["MODELOS DE TEMPO", "timeModels"],
+        ["DETERMINISMOS", "determinisms"],
+        ["FIDELIDADES", "fidelities"],
+    ];
+    linhas.push("", "COBERTURA CANÔNICA");
+    for (const [rotulo, campo] of campos) {
+        const valores = textos(matrix[campo]);
+        if (valores.length > 0)
+            linhas.push(`- ${rotulo}: ${valores.join(", ")}`);
+    }
+}
+export function renderizarResultadoSistemasInterativos(payload) {
+    const comando = typeof payload.comando === "string" ? payload.comando : "desconhecido";
+    const plano = registro(payload.plano);
+    const estado = registro(payload.estado);
+    const bloqueios = obterBloqueios(payload, estado);
+    const status = typeof estado?.status === "string"
+        ? estado.status
+        : payload.sucesso === true
+            ? "OK"
+            : typeof payload.errorCode === "string"
+                ? "ERRO"
+                : "BLOQUEADO";
+    const systemId = typeof plano?.systemId === "string"
+        ? plano.systemId
+        : typeof payload.systemId === "string"
+            ? payload.systemId
+            : undefined;
+    const capabilities = unicos([
+        ...ids(payload.capabilities, "capability"),
+        ...textos(payload.capabilitiesRequeridas),
+        ...textos(plano?.capabilitiesRequeridas),
+    ]);
+    const pipelines = unicos([
+        ...textos(payload.pipelineIds),
+        ...ids(payload.pipelines, "pipelineId"),
+        ...ids(plano?.pipelines, "pipelineId"),
+    ]);
+    const adapters = unicos([
+        ...textos(payload.adapterIds),
+        ...ids(payload.adapters, "adapterId"),
+        ...textos(plano?.adaptersCompativeis),
+    ]);
+    const adaptersSelecionados = unicos(textos(plano?.adaptersSelecionados));
+    const stages = unicos([
+        ...ids(payload.stages, "stageInstanceId"),
+        ...ids(plano?.stages, "stageInstanceId"),
+        ...ids(estado?.stages, "stageId"),
+    ]);
+    const capabilitiesAusentes = unicos([
+        ...textos(payload.capabilitiesAusentes),
+        ...textos(plano?.capabilitiesAusentes),
+    ]);
+    const capabilitiesSemAdapter = unicos(textos(plano?.capabilitiesSemAdapter));
+    const evidenciasAceitas = unicos([
+        ...textos(payload.evidenciasAceitas),
+        ...textos(estado?.evidenciasAceitas),
+    ]);
+    const evidenciasAusentes = unicos([
+        ...textos(payload.evidenciasAusentes),
+        ...textos(estado?.evidenciasAusentes),
+    ]);
+    const proximosPassos = obterProximosPassos(payload, plano, estado, evidenciasAusentes);
+    const linhas = [
+        `SISTEMAS INTERATIVOS · ${comando.toUpperCase()}`,
+        `STATUS · ${status}`,
+        `COMANDO · ${comando}`,
+        `BLOQUEIOS · ${bloqueios.length}`,
+    ];
+    if (systemId)
+        linhas.push(`SISTEMA · ${systemId}`);
+    if (estado) {
+        linhas.push(`COBERTURA LOCAL · ${estado.localCoverageComplete === true ? "COMPLETA" : "INCOMPLETA"}`, `ESCOPO DE CONCLUSÃO · ${typeof estado.completionScope === "string" ? estado.completionScope : "STRUCTURAL_LOCAL"}`, `ATESTAÇÃO EXTERNA · ${estado.awaitingExternalAttestation === true ? "PENDENTE" : "NÃO DECLARADA"}`);
+    }
+    const errorCode = typeof payload.errorCode === "string" ? payload.errorCode : undefined;
+    if (errorCode) {
+        linhas.push("", `ERRO · ${errorCode}`, MENSAGENS_ERRO[errorCode] ?? "A operação não pôde ser concluída.");
+    }
+    adicionarCobertura(linhas, registro(payload.matrix));
+    const schema = registro(payload.definitionSchema);
+    adicionarSecao(linhas, "CAMPOS OBRIGATÓRIOS DO SHAPE V1", textos(schema?.requiredFields));
+    adicionarSecao(linhas, "EXEMPLOS", textos(payload.examplePaths));
+    adicionarSecao(linhas, "CAPABILITIES", capabilities);
+    adicionarSecao(linhas, "PIPELINES", pipelines);
+    adicionarSecao(linhas, "ADAPTERS CANDIDATOS COMPATÍVEIS", adapters);
+    adicionarSecao(linhas, "ADAPTERS SELECIONADOS", adaptersSelecionados);
+    adicionarSecao(linhas, "ETAPAS", stages);
+    adicionarSecao(linhas, "CAPABILITIES AUSENTES", capabilitiesAusentes);
+    adicionarSecao(linhas, "CAPABILITIES SEM ADAPTER SELECIONADO", capabilitiesSemAdapter);
+    adicionarSecao(linhas, "EVIDÊNCIAS ACEITAS", evidenciasAceitas);
+    adicionarSecao(linhas, "EVIDÊNCIAS AUSENTES", evidenciasAusentes);
+    adicionarSecao(linhas, "BLOQUEIOS DETALHADOS", bloqueios);
+    adicionarSecao(linhas, "PRÓXIMOS PASSOS", proximosPassos);
+    if (status === "STRUCTURALLY_COMPLETE") {
+        linhas.push("", "CONCLUSÃO ESTRUTURAL LOCAL — NÃO PROVA EXECUÇÃO REAL", "- Todos os requisitos estruturais locais têm cobertura, mas ainda falta atestação externa independente.");
+    }
+    linhas.push("", "FRONTEIRA OPERACIONAL", "- Runtime e adapters: externos; nenhum engine, editor ou runner foi iniciado.", "- Workspace: intacto; nenhuma escrita foi aplicada.", "- Autoridade: saída local e não autoritativa; bundle local não substitui trust, ledger ou checkpoint externo.");
+    return linhas.join("\n");
+}
+//# sourceMappingURL=render.js.map

package/dist/sistemasInterativos/temporal.d.ts

@@ -0,0 +1,183 @@
+export declare const SCHEMA_CONTRATO_TEMPORAL: "sema.interactive.temporal/v1";
+export declare const SCHEMA_EVIDENCIA_TEMPORAL: "sema.interactive.temporal-evidence/v1";
+export type UnidadeTempoTemporal = "FRAME" | "MILLISECOND" | "SECOND" | "TICK";
+export type TipoTrackTemporal = "TRANSFORM" | "ANIMATION" | "VFX" | "AUDIO" | "SPEECH" | "SUBTITLE" | "EVENT";
+export type TipoInvariantTemporal = "ORDER" | "SYNC" | "VISIBILITY" | "BOUNDS" | "NO_OVERLAP" | "CONTINUITY";
+export type TipoRelacaoFisica = "COLLISION" | "ATTACHMENT" | "SEPARATION" | "CONSTRAINT";
+export type TipoQaTemporal = "FLICKER" | "GHOSTING" | "POPPING" | "EXPOSURE" | "JITTER";
+export type TipoEvidenciaTemporal = "SCREENSHOT" | "VIDEO" | "DEPTH" | "NORMALS" | "OBJECT_ID" | "MOTION_VECTORS" | "TRANSFORMS" | "EVENT_TRACE" | "COLLISION_TRACE" | "AUDIO_TRACE" | "TELEMETRY" | "INSTALL_LOG" | "LAUNCH_LOG" | "PLAYTEST_TRACE";
+export type DecisaoObservacaoTemporal = "PASS" | "FAIL" | "INCONCLUSIVE";
+export interface SistemaCoordenadasTemporal {
+    readonly unit: string;
+    readonly handedness: "LEFT" | "RIGHT";
+    readonly upAxis: "X" | "Y" | "Z";
+    readonly forwardAxis: "X" | "Y" | "Z";
+}
+export interface FaseTemporal {
+    readonly phaseId: string;
+    readonly start: number;
+    readonly end: number;
+    readonly timeUnit: UnidadeTempoTemporal;
+}
+export interface ClipTemporal {
+    readonly clipId: string;
+    readonly phaseId: string;
+    readonly semanticTargetId: string;
+    readonly start: number;
+    readonly end: number;
+    readonly timeUnit: UnidadeTempoTemporal;
+}
+export interface TrackTemporal {
+    readonly trackId: string;
+    readonly type: TipoTrackTemporal;
+    readonly clips: readonly ClipTemporal[];
+}
+export interface InvariantTemporal {
+    readonly invariantId: string;
+    readonly type: TipoInvariantTemporal;
+    readonly phaseId: string;
+    readonly trackIds: readonly string[];
+    readonly subjectIds: readonly string[];
+    readonly threshold: number;
+    readonly unit: string;
+}
+export interface ShotTemporal {
+    readonly shotId: string;
+    readonly phaseId: string;
+    readonly cameraId: string;
+    readonly subjectIds: readonly string[];
+    readonly start: number;
+    readonly end: number;
+    readonly timeUnit: UnidadeTempoTemporal;
+    readonly composition: string;
+    readonly minimumVisibilityRatio: number;
+    readonly maximumJitter: number;
+}
+export interface RelacaoFisicaTemporal {
+    readonly relationId: string;
+    readonly type: TipoRelacaoFisica;
+    readonly phaseId: string;
+    readonly sourceId: string;
+    readonly targetId: string;
+    readonly start: number;
+    readonly end: number;
+    readonly timeUnit: UnidadeTempoTemporal;
+    readonly tolerance: number;
+    readonly unit: string;
+}
+export interface CheckQaTemporal {
+    readonly checkId: string;
+    readonly type: TipoQaTemporal;
+    readonly phaseId: string;
+    readonly threshold: number;
+    readonly unit: string;
+}
+export interface AceitacaoBuildTemporal {
+    readonly required: boolean;
+    readonly artifactDigest?: string;
+    readonly cleanInstallRequired: boolean;
+    readonly launchRequired: boolean;
+    readonly smokePlaytestRequired: boolean;
+}
+export interface AlvoHardwareTemporal {
+    readonly profileId: string;
+    readonly gpu: string;
+    readonly cpu: string;
+    readonly resolution: {
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly targetFps: number;
+    readonly frameTimeP95Ms: number;
+    readonly maxRamMb: number;
+    readonly maxVramMb: number;
+    readonly maxDiskMb: number;
+}
+export interface ContratoTemporalInterativo {
+    readonly schemaVersion: typeof SCHEMA_CONTRATO_TEMPORAL;
+    readonly contractId: string;
+    readonly systemId: string;
+    readonly experienceIrDigest: string;
+    readonly coordinateSystem: SistemaCoordenadasTemporal;
+    readonly phases: readonly FaseTemporal[];
+    readonly tracks: readonly TrackTemporal[];
+    readonly invariants: readonly InvariantTemporal[];
+    readonly shots: readonly ShotTemporal[];
+    readonly physics: readonly RelacaoFisicaTemporal[];
+    readonly temporalQa: {
+        readonly checks: readonly CheckQaTemporal[];
+    };
+    readonly buildAcceptance: AceitacaoBuildTemporal;
+    readonly hardwareTargets: readonly AlvoHardwareTemporal[];
+}
+export interface MetricaTemporal {
+    readonly name: string;
+    readonly value: number;
+    readonly unit: string;
+    readonly threshold: number;
+}
+export interface ObservacaoTemporal {
+    readonly observationId: string;
+    readonly checkId: string;
+    readonly decision: DecisaoObservacaoTemporal;
+    readonly evidenceTypes: readonly TipoEvidenciaTemporal[];
+    readonly artifactDigests: readonly string[];
+    readonly sampleCount: number;
+    readonly traceDigest?: string;
+    readonly phaseId?: string;
+    readonly frame?: number;
+    readonly time?: number;
+    readonly timeUnit?: UnidadeTempoTemporal;
+    readonly metrics?: readonly MetricaTemporal[];
+}
+export interface BundleVerificacaoTemporal {
+    readonly schemaVersion: typeof SCHEMA_EVIDENCIA_TEMPORAL;
+    readonly runId: string;
+    readonly contractDigest: string;
+    readonly producerId: string;
+    readonly producerVersion: string;
+    readonly producerConfigurationDigest: string;
+    readonly verifierId: string;
+    readonly verifierVersion: string;
+    readonly verifierConfigurationDigest: string;
+    readonly independentOfProducer: boolean;
+    readonly observations: readonly ObservacaoTemporal[];
+}
+export interface ResultadoValidacaoContratoTemporal {
+    readonly valido: boolean;
+    readonly contractDigest: string;
+    readonly requiredCheckIds: readonly string[];
+    readonly bloqueios: readonly string[];
+    readonly executed: false;
+    readonly authoritative: false;
+}
+export interface DiagnosticoTemporal {
+    readonly failedInvariant: string;
+    readonly phase?: string;
+    readonly frame?: number;
+    readonly time?: number;
+    readonly timeUnit?: UnidadeTempoTemporal;
+    readonly evidenceIds: readonly string[];
+    readonly decision: "FAIL" | "INCONCLUSIVE";
+    readonly likelyCauses: readonly string[];
+}
+export interface ResultadoValidacaoBundleTemporal {
+    readonly valido: boolean;
+    readonly contractDigest: string;
+    readonly bundleDigest: string;
+    readonly resultDigest: string;
+    readonly checksAceitos: readonly string[];
+    readonly checksAusentes: readonly string[];
+    readonly checksFalhos: readonly string[];
+    readonly diagnostics: readonly DiagnosticoTemporal[];
+    readonly nextActions: readonly string[];
+    readonly bloqueios: readonly string[];
+    readonly completed: false;
+    readonly localCoverageComplete: boolean;
+    readonly awaitingExternalAttestation: true;
+    readonly completionScope: "STRUCTURAL_LOCAL";
+    readonly authoritative: false;
+    readonly executed: false;
+}
+export declare function validarContratoTemporalInterativo(entrada: unknown): ResultadoValidacaoContratoTemporal;
+export declare function validarBundleVerificacaoTemporal(contratoEntrada: unknown, bundleEntrada: unknown): ResultadoValidacaoBundleTemporal;