@semacode/cli 2.2.0 → 2.3.1

package/dist/sistemasInterativos/types.d.ts

@@ -0,0 +1,215 @@
+export type JsonPrimitivoSistemaInterativo = string | number | boolean | null;
+export type JsonValorSistemaInterativo = JsonPrimitivoSistemaInterativo | JsonObjetoSistemaInterativo | readonly JsonValorSistemaInterativo[];
+export interface JsonObjetoSistemaInterativo {
+    readonly [chave: string]: JsonValorSistemaInterativo;
+}
+export type KindSistemaInterativo = "GAME" | "SIMULATION" | "HYBRID";
+export type ModeloEspacialSistemaInterativo = "NON_SPATIAL" | "TWO_D" | "TWO_POINT_FIVE_D" | "THREE_D";
+export type ModoRenderSistemaInterativo = "HEADLESS" | "TEXT" | "VISUAL" | "XR";
+export type PerfilVisualSistemaInterativo = "NONE" | "PIXEL_8_BIT" | "PIXEL_16_BIT" | "RASTER" | "VECTOR" | "STYLIZED" | "REALISTIC";
+export type FidelidadeSistemaInterativo = "ARCADE" | "STYLIZED" | "SYSTEMIC" | "REALISTIC" | "CALIBRATED";
+export type ModoControleSistemaInterativo = "HUMAN" | "SCRIPTED" | "AI" | "HYBRID" | "AUTONOMOUS" | "UNCONTROLLED";
+export type ModeloTempoSistemaInterativo = "TURN_BASED" | "FIXED_STEP" | "VARIABLE_STEP" | "REAL_TIME" | "EVENT_DRIVEN" | "BATCH" | "ACCELERATED";
+export type DeterminismoSistemaInterativo = "NONE" | "BEST_EFFORT" | "STOCHASTIC" | "SEEDED" | "STRICT";
+export interface DefinicaoSistemaInterativo {
+    readonly schemaVersion: string;
+    readonly systemId: string;
+    readonly version: string;
+    readonly kind: KindSistemaInterativo;
+    readonly spatialModel: ModeloEspacialSistemaInterativo;
+    readonly renderMode: ModoRenderSistemaInterativo;
+    readonly visualProfile: PerfilVisualSistemaInterativo;
+    readonly fidelity: FidelidadeSistemaInterativo;
+    readonly controlModes: readonly ModoControleSistemaInterativo[];
+    readonly timeModel: ModeloTempoSistemaInterativo;
+    readonly determinism: DeterminismoSistemaInterativo;
+    readonly capabilities: readonly string[];
+    readonly pipelines: readonly string[];
+    readonly adapterTargets: readonly string[];
+    readonly world: JsonObjetoSistemaInterativo;
+    readonly budgets?: JsonObjetoSistemaInterativo;
+    readonly acceptance: JsonObjetoSistemaInterativo;
+}
+export interface ResultadoValidacaoDefinicaoSistemaInterativo {
+    readonly valida: boolean;
+    readonly definitionDigest: string;
+    readonly capabilitiesRequeridas: readonly string[];
+    readonly bloqueios: readonly string[];
+}
+export interface EtapaPipelineSistemaInterativo {
+    readonly stageId: string;
+    readonly capability: string;
+    readonly dependsOn: readonly string[];
+    readonly produces: readonly string[];
+    readonly requiredEvidence: readonly string[];
+}
+export interface PipelineSistemaInterativo {
+    readonly pipelineId: string;
+    readonly version: string;
+    readonly label: string;
+    readonly summary: string;
+    readonly kinds: readonly KindSistemaInterativo[];
+    readonly spatialModels: readonly ModeloEspacialSistemaInterativo[];
+    readonly renderModes: readonly ModoRenderSistemaInterativo[];
+    readonly visualProfiles: readonly PerfilVisualSistemaInterativo[];
+    readonly controlModes: readonly ModoControleSistemaInterativo[];
+    readonly fidelities: readonly FidelidadeSistemaInterativo[];
+    readonly capabilities: readonly string[];
+    readonly stages: readonly EtapaPipelineSistemaInterativo[];
+    readonly requiredEvidence: readonly string[];
+    readonly useWhen: readonly string[];
+    readonly avoidWhen: readonly string[];
+}
+export interface CapabilitySistemaInterativo {
+    readonly capability: string;
+    readonly label: string;
+    readonly summary: string;
+    readonly kinds: readonly KindSistemaInterativo[];
+}
+export type PapelAdaptadorSistemaInterativo = "ENGINE" | "RUNTIME" | "EDITOR" | "ASSET" | "BUILD" | "TELEMETRY" | "VALIDATOR" | "CUSTOM";
+export type FaseProtocoloAdaptador = "DETECT" | "PROBE" | "SNAPSHOT" | "PLAN" | "APPLY" | "VALIDATE" | "EVIDENCE" | "ROLLBACK";
+export interface AdaptadorSistemaInterativo {
+    readonly adapterId: string;
+    readonly version: string;
+    readonly role: PapelAdaptadorSistemaInterativo;
+    readonly engine: string;
+    readonly kinds: readonly KindSistemaInterativo[];
+    readonly spatialModels: readonly ModeloEspacialSistemaInterativo[];
+    readonly renderModes: readonly ModoRenderSistemaInterativo[];
+    readonly visualProfiles: readonly PerfilVisualSistemaInterativo[];
+    readonly controlModes: readonly ModoControleSistemaInterativo[];
+    readonly timeModels: readonly ModeloTempoSistemaInterativo[];
+    readonly fidelities: readonly FidelidadeSistemaInterativo[];
+    readonly capabilities: readonly string[];
+    readonly protocol: readonly FaseProtocoloAdaptador[];
+    readonly readOnlyProbe: true;
+    readonly mutatesWorkspace: boolean;
+    readonly supportsRollback: boolean;
+    readonly executionBoundary: "EXTERNAL";
+}
+export interface FiltrosAdaptadoresSistemasInterativos {
+    readonly kind?: KindSistemaInterativo;
+    readonly spatialModel?: ModeloEspacialSistemaInterativo;
+    readonly renderMode?: ModoRenderSistemaInterativo;
+    readonly visualProfile?: PerfilVisualSistemaInterativo;
+    readonly role?: PapelAdaptadorSistemaInterativo;
+    readonly controlMode?: ModoControleSistemaInterativo;
+    readonly timeModel?: ModeloTempoSistemaInterativo;
+    readonly fidelity?: FidelidadeSistemaInterativo;
+}
+export interface ResultadoListagemAdaptadoresSistemasInterativos {
+    readonly adapters: readonly AdaptadorSistemaInterativo[];
+    readonly filtrosAplicados: FiltrosAdaptadoresSistemasInterativos;
+    readonly executed: false;
+}
+export interface ResultadoValidacaoAdaptadorSistemaInterativo {
+    readonly valido: boolean;
+    readonly bloqueios: readonly string[];
+}
+export interface FaseExecutadaProtocoloAdapter {
+    readonly phaseId: string;
+    readonly phase: FaseProtocoloAdaptador;
+    readonly semanticTargetId: string;
+    readonly inputDigest: string;
+    readonly outputDigest: string;
+    readonly success: boolean;
+}
+export interface RegistroProtocoloAdapter {
+    readonly runId: string;
+    readonly adapterId: string;
+    readonly adapterVersion: string;
+    readonly semanticTargetId: string;
+    readonly phases: readonly FaseExecutadaProtocoloAdapter[];
+    readonly mutated: boolean;
+    readonly success: boolean;
+    readonly rollbackEvidenceId?: string;
+}
+export interface ResultadoValidacaoProtocoloAdapter {
+    readonly valido: boolean;
+    readonly faseAtual: FaseProtocoloAdaptador | "NOT_STARTED";
+    readonly bloqueios: readonly string[];
+    readonly exigeRollback: boolean;
+}
+export interface InstanciaEtapaSistemaInterativo extends EtapaPipelineSistemaInterativo {
+    readonly pipelineId: string;
+    readonly stageInstanceId: string;
+}
+export interface InstanciaPipelineSistemaInterativo {
+    readonly pipelineId: string;
+    readonly version: string;
+    readonly stageInstanceIds: readonly string[];
+    readonly requiredEvidence: readonly string[];
+}
+export interface ProvedorEtapaSistemaInterativo {
+    readonly stageInstanceId: string;
+    readonly capability: string;
+    readonly candidateAdapterIds: readonly string[];
+    readonly selectedAdapterIds: readonly string[];
+    readonly coveredBySelection: boolean;
+}
+export interface PlanoSistemaInterativo {
+    readonly systemId: string;
+    readonly definitionDigest: string;
+    readonly planDigest: string;
+    readonly capabilitiesRequeridas: readonly string[];
+    readonly capabilitiesAusentes: readonly string[];
+    readonly pipelines: readonly InstanciaPipelineSistemaInterativo[];
+    readonly adaptersCompativeis: readonly string[];
+    readonly adaptersSelecionados: readonly string[];
+    readonly adapterSelectionExplicit: boolean;
+    readonly adapterCoverageComplete: boolean;
+    readonly capabilitiesSemAdapter: readonly string[];
+    readonly stageProviderMap: readonly ProvedorEtapaSistemaInterativo[];
+    readonly stages: readonly InstanciaEtapaSistemaInterativo[];
+    readonly nextActions: readonly string[];
+    readonly executed: false;
+}
+export interface ResultadoPlanejamentoSistemaInterativo {
+    readonly plano: PlanoSistemaInterativo;
+    readonly bloqueios: readonly string[];
+}
+export interface ObservacaoSistemaInterativo {
+    readonly evidenceId: string;
+    readonly evidenceType: string;
+    readonly stageId: string;
+    readonly semanticTargetId: string;
+    readonly producerAdapterId: string;
+    readonly producerAdapterVersion: string;
+    readonly artifactDigest: string;
+    readonly observedAt: string;
+    readonly source: string;
+    readonly data: JsonObjetoSistemaInterativo;
+}
+export interface BundleEvidenciasSistemaInterativo {
+    readonly schemaVersion: string;
+    readonly runId: string;
+    readonly systemId: string;
+    readonly definitionDigest: string;
+    readonly planDigest: string;
+    readonly observations: readonly ObservacaoSistemaInterativo[];
+}
+export interface ResultadoValidacaoBundleEvidenciasSistemaInterativo {
+    readonly valido: boolean;
+    readonly evidenciasAceitas: readonly string[];
+    readonly evidenciasAusentes: readonly string[];
+    readonly bloqueios: readonly string[];
+}
+export type StatusSistemaInterativo = "INVALID" | "PLANNED" | "READY" | "RUNNING" | "WAITING_EVIDENCE" | "BLOCKED" | "STRUCTURALLY_COMPLETE";
+export interface EstadoEtapaSistemaInterativo {
+    readonly stageId: string;
+    readonly status: "WAITING_EVIDENCE" | "STRUCTURALLY_COMPLETE";
+    readonly evidenciasAusentes: readonly string[];
+}
+export interface EstadoSistemaInterativo {
+    readonly status: StatusSistemaInterativo;
+    readonly stages: readonly EstadoEtapaSistemaInterativo[];
+    readonly evidenciasAceitas: readonly string[];
+    readonly evidenciasAusentes: readonly string[];
+    readonly bloqueios: readonly string[];
+    readonly nextActions: readonly string[];
+    readonly completed: false;
+    readonly localCoverageComplete: boolean;
+    readonly awaitingExternalAttestation: true;
+    readonly completionScope: "STRUCTURAL_LOCAL";
+    readonly authoritative: false;
+}

package/dist/sistemasInterativos/types.js

@@ -0,0 +1,4 @@
+// SEMA-GOVERNED: sema.produto.sistemas_interativos + adaptadores + evidencias
+// Descricao: tipos publicos do control plane declarativo para jogos e simulacoes.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/sistemasInterativos/validator.d.ts

@@ -0,0 +1,2 @@
+import type { DefinicaoSistemaInterativo, ResultadoValidacaoDefinicaoSistemaInterativo } from "./types.js";
+export declare function validarDefinicaoSistemaInterativo(definicao: DefinicaoSistemaInterativo): ResultadoValidacaoDefinicaoSistemaInterativo;

package/dist/sistemasInterativos/validator.js

@@ -0,0 +1,305 @@
+// SEMA-GOVERNED: sema.produto.sistemas_interativos
+// Descricao: validacao deterministica de definicoes sem executar engine, editor, runner ou adapter.
+import { digestJsonSistemaInterativo } from "./canonical.js";
+import { MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS, obterAdaptadorSistemaInterativo, obterPipelineSistemaInterativo, } from "./catalog.js";
+const VERSOES_FLUTUANTES = new Set(["latest", "next", "dev", "main", "master", "*"]);
+const VALOR_SENSIVEL = /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----|\bBearer\s+[A-Za-z0-9._~+/=-]+|\b(?:sk|ghp|github_pat)_[A-Za-z0-9_-]{12,}/i;
+function adicionar(bloqueios, valor) {
+    if (!bloqueios.includes(valor))
+        bloqueios.push(valor);
+}
+function textoOpaco(valor) {
+    return typeof valor === "string" && valor.trim().length > 0 && !/[\u0000-\u001f\u007f]/.test(valor);
+}
+function identificadorSeguro(valor) {
+    return textoOpaco(valor)
+        && valor.length <= 128
+        && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(valor)
+        && !VALOR_SENSIVEL.test(valor);
+}
+function objeto(valor) {
+    return valor !== null && typeof valor === "object" && !Array.isArray(valor);
+}
+function valorDeclarado(valor) {
+    if (typeof valor === "string")
+        return valor.trim().length > 0;
+    if (Array.isArray(valor))
+        return valor.length > 0;
+    if (objeto(valor))
+        return Object.keys(valor).length > 0;
+    return valor !== undefined && valor !== null;
+}
+function campoDeclarado(alvo, campo) {
+    return valorDeclarado(alvo[campo]);
+}
+function inteiroPositivo(valor) {
+    return typeof valor === "number" && Number.isSafeInteger(valor) && valor > 0;
+}
+function dimensaoPixelValida(valor) {
+    if (inteiroPositivo(valor))
+        return true;
+    if (typeof valor === "string") {
+        return /^[1-9]\d{0,4}x[1-9]\d{0,4}(?:\s+(?:and|to)\s+[1-9]\d{0,4}x[1-9]\d{0,4})?$/i.test(valor);
+    }
+    if (Array.isArray(valor))
+        return valor.length === 2 && valor.every(inteiroPositivo);
+    if (objeto(valor))
+        return inteiroPositivo(valor.width) && inteiroPositivo(valor.height);
+    return false;
+}
+function listaTextosUnicos(valor, permiteVazia = true) {
+    if (!Array.isArray(valor) || (!permiteVazia && valor.length === 0))
+        return false;
+    if (!valor.every(textoOpaco))
+        return false;
+    return new Set(valor).size === valor.length;
+}
+function slugCapability(valor) {
+    return valor.toLowerCase().replace(/two_point_five/g, "2_5").replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function capabilitiesEstruturais(definicao) {
+    const capabilities = ["interactive.world.model", "interactive.state.model"];
+    const eixos = [
+        ["kind", definicao.kind, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.kinds],
+        ["spatial", definicao.spatialModel, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.spatialModels],
+        ["render", definicao.renderMode, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.renderModes],
+        ["visual", definicao.visualProfile, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.visualProfiles],
+        ["fidelity", definicao.fidelity, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.fidelities],
+        ["time", definicao.timeModel, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.timeModels],
+        ["determinism", definicao.determinism, MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.determinisms],
+    ];
+    for (const [eixo, valor, permitidos] of eixos) {
+        if (typeof valor === "string" && permitidos.includes(valor))
+            capabilities.push(`interactive.${eixo}.${slugCapability(valor)}`);
+    }
+    for (const modo of Array.isArray(definicao.controlModes) ? definicao.controlModes : []) {
+        if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.controlModes.includes(modo))
+            continue;
+        capabilities.push(`interactive.control.${slugCapability(modo)}`);
+    }
+    for (const pipelineId of Array.isArray(definicao.pipelines) ? definicao.pipelines : []) {
+        const pipeline = obterPipelineSistemaInterativo(pipelineId);
+        if (pipeline)
+            capabilities.push(...pipeline.capabilities);
+    }
+    return [...new Set(capabilities)].sort();
+}
+function validarBase(definicao, bloqueios) {
+    if (definicao.schemaVersion !== "1.0")
+        adicionar(bloqueios, "schema_version_nao_suportada");
+    if (!identificadorSeguro(definicao.systemId))
+        adicionar(bloqueios, "system_id_invalido");
+    if (!textoOpaco(definicao.version) || VERSOES_FLUTUANTES.has(definicao.version.toLowerCase())) {
+        adicionar(bloqueios, "version_nao_fixada");
+    }
+    if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.kinds.includes(definicao.kind))
+        adicionar(bloqueios, "kind_invalido");
+    if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.spatialModels.includes(definicao.spatialModel))
+        adicionar(bloqueios, "spatial_model_invalido");
+    if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.renderModes.includes(definicao.renderMode))
+        adicionar(bloqueios, "render_mode_invalido");
+    if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.visualProfiles.includes(definicao.visualProfile))
+        adicionar(bloqueios, "visual_profile_invalido");
+    if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.fidelities.includes(definicao.fidelity))
+        adicionar(bloqueios, "fidelity_invalida");
+    if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.timeModels.includes(definicao.timeModel))
+        adicionar(bloqueios, "time_model_invalido");
+    if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.determinisms.includes(definicao.determinism))
+        adicionar(bloqueios, "determinism_invalido");
+    if (!listaTextosUnicos(definicao.controlModes, false))
+        adicionar(bloqueios, "control_modes_invalidos");
+    else if (!definicao.controlModes.every((modo) => MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.controlModes.includes(modo))) {
+        adicionar(bloqueios, "control_mode_fora_do_vocabulario");
+    }
+    if (!listaTextosUnicos(definicao.capabilities))
+        adicionar(bloqueios, "capabilities_invalidas");
+    if (!listaTextosUnicos(definicao.pipelines, false))
+        adicionar(bloqueios, "pipelines_invalidos_ou_ausentes");
+    if (!listaTextosUnicos(definicao.adapterTargets))
+        adicionar(bloqueios, "adapter_targets_invalidos");
+    if (!objeto(definicao.world))
+        adicionar(bloqueios, "world_invalido");
+    if (!objeto(definicao.acceptance))
+        adicionar(bloqueios, "acceptance_invalida");
+    if (definicao.budgets !== undefined && !objeto(definicao.budgets))
+        adicionar(bloqueios, "budgets_invalidos");
+}
+function validarEixos(definicao, bloqueios) {
+    const visual = definicao.visualProfile;
+    if ((definicao.renderMode === "HEADLESS" || definicao.renderMode === "TEXT") && visual !== "NONE") {
+        adicionar(bloqueios, "render_nao_visual_exige_visual_profile_none");
+    }
+    if ((definicao.renderMode === "VISUAL" || definicao.renderMode === "XR") && visual === "NONE") {
+        adicionar(bloqueios, "render_visual_exige_visual_profile");
+    }
+    if (definicao.renderMode === "XR" && definicao.spatialModel !== "THREE_D") {
+        adicionar(bloqueios, "render_xr_exige_spatial_model_three_d");
+    }
+    if (visual === "PIXEL_8_BIT" || visual === "PIXEL_16_BIT") {
+        const budgets = definicao.budgets;
+        if (!objeto(budgets)) {
+            adicionar(bloqueios, "pixel_profile_exige_budgets");
+            return;
+        }
+        for (const campo of ["paletteColors", "baseResolution", "tileSize", "spriteSize", "memoryBudgetBytes", "audioProfile"]) {
+            if (!campoDeclarado(budgets, campo))
+                adicionar(bloqueios, `pixel_budget_ausente:${campo}`);
+        }
+        const paletteColors = budgets.paletteColors;
+        if (typeof paletteColors !== "number" || !Number.isInteger(paletteColors) || paletteColors <= 0) {
+            adicionar(bloqueios, "pixel_palette_invalida");
+        }
+        else if (visual === "PIXEL_8_BIT" && paletteColors > 256) {
+            adicionar(bloqueios, "pixel_8_bit_palette_excede_256");
+        }
+        else if (visual === "PIXEL_16_BIT" && paletteColors > 65_536) {
+            adicionar(bloqueios, "pixel_16_bit_palette_excede_65536");
+        }
+        if (!dimensaoPixelValida(budgets.baseResolution))
+            adicionar(bloqueios, "pixel_base_resolution_invalida");
+        if (!dimensaoPixelValida(budgets.tileSize))
+            adicionar(bloqueios, "pixel_tile_size_invalido");
+        if (!dimensaoPixelValida(budgets.spriteSize))
+            adicionar(bloqueios, "pixel_sprite_size_invalido");
+        if (!inteiroPositivo(budgets.memoryBudgetBytes))
+            adicionar(bloqueios, "pixel_memory_budget_invalido");
+        if (!textoOpaco(budgets.audioProfile))
+            adicionar(bloqueios, "pixel_audio_profile_invalido");
+    }
+    if (objeto(definicao.world) && definicao.spatialModel === "THREE_D") {
+        for (const campo of ["units", "scale", "coordinateSystem"]) {
+            if (!campoDeclarado(definicao.world, campo))
+                adicionar(bloqueios, `world_3d_ausente:${campo}`);
+        }
+    }
+    if (objeto(definicao.world) && (definicao.spatialModel === "TWO_D" || definicao.spatialModel === "TWO_POINT_FIVE_D")) {
+        if (!campoDeclarado(definicao.world, "grid") && !campoDeclarado(definicao.world, "coordinateSystem")) {
+            adicionar(bloqueios, "world_2d_exige_grid_ou_coordinate_system");
+        }
+    }
+}
+function validarWorld(definicao, bloqueios) {
+    if (!objeto(definicao.world))
+        return;
+    for (const campo of ["identity", "state", "time", "events", "initialConditions"]) {
+        if (!campoDeclarado(definicao.world, campo))
+            adicionar(bloqueios, `world_campo_ausente:${campo}`);
+    }
+    if (definicao.kind === "GAME" || definicao.kind === "HYBRID") {
+        for (const campo of ["loop", "objective", "successConditions", "failureConditions", "rules"]) {
+            if (!campoDeclarado(definicao.world, campo))
+                adicionar(bloqueios, `game_world_ausente:${campo}`);
+        }
+    }
+    if (definicao.kind === "SIMULATION" || definicao.kind === "HYBRID") {
+        for (const campo of ["model", "assumptions", "boundaryConditions", "outputs", "validation"]) {
+            if (!campoDeclarado(definicao.world, campo))
+                adicionar(bloqueios, `simulation_world_ausente:${campo}`);
+        }
+    }
+    if (definicao.determinism === "SEEDED" || definicao.determinism === "STRICT") {
+        for (const campo of ["seed", "snapshot", "replay", "step"]) {
+            if (!campoDeclarado(definicao.world, campo))
+                adicionar(bloqueios, `determinism_world_ausente:${campo}`);
+        }
+    }
+    if (Array.isArray(definicao.controlModes) && definicao.controlModes.some((modo) => modo === "AUTONOMOUS" || modo === "UNCONTROLLED")) {
+        for (const campo of ["stopCriteria", "safetyConstraints"]) {
+            if (!campoDeclarado(definicao.world, campo))
+                adicionar(bloqueios, `autonomia_world_ausente:${campo}`);
+        }
+    }
+}
+function validarAceitacao(definicao, bloqueios) {
+    if (!objeto(definicao.acceptance))
+        return;
+    if (definicao.fidelity === "REALISTIC" || definicao.fidelity === "CALIBRATED") {
+        for (const campo of ["reference", "calibration", "tolerances", "uncertainty", "telemetry"]) {
+            if (!campoDeclarado(definicao.acceptance, campo))
+                adicionar(bloqueios, `realistic_acceptance_ausente:${campo}`);
+        }
+    }
+}
+function validarPipelinesEAdapters(definicao, bloqueios) {
+    const pipelines = Array.isArray(definicao.pipelines) ? definicao.pipelines : [];
+    for (const [indice, pipelineId] of pipelines.entries()) {
+        const pipeline = obterPipelineSistemaInterativo(pipelineId);
+        if (!pipeline) {
+            adicionar(bloqueios, `pipeline_desconhecido_indice:${indice}`);
+            continue;
+        }
+        if (!pipeline.kinds.includes(definicao.kind))
+            adicionar(bloqueios, `pipeline_kind_incompativel_indice:${indice}`);
+        if (!pipeline.spatialModels.includes(definicao.spatialModel))
+            adicionar(bloqueios, `pipeline_spatial_model_incompativel_indice:${indice}`);
+        if (!pipeline.renderModes.includes(definicao.renderMode))
+            adicionar(bloqueios, `pipeline_render_mode_incompativel_indice:${indice}`);
+        if (!pipeline.visualProfiles.includes(definicao.visualProfile))
+            adicionar(bloqueios, `pipeline_visual_profile_incompativel_indice:${indice}`);
+        const modos = Array.isArray(definicao.controlModes) ? definicao.controlModes : [];
+        if (!modos.some((modo) => pipeline.controlModes.includes(modo)))
+            adicionar(bloqueios, `pipeline_control_mode_incompativel_indice:${indice}`);
+        if (!pipeline.fidelities.includes(definicao.fidelity))
+            adicionar(bloqueios, `pipeline_fidelity_incompativel_indice:${indice}`);
+    }
+    for (const [indice, adapterId] of (Array.isArray(definicao.adapterTargets) ? definicao.adapterTargets : []).entries()) {
+        if (!obterAdaptadorSistemaInterativo(adapterId))
+            adicionar(bloqueios, `adapter_target_desconhecido_indice:${indice}`);
+    }
+    const exigeSafety = Array.isArray(definicao.controlModes)
+        && definicao.controlModes.some((modo) => modo === "AUTONOMOUS" || modo === "UNCONTROLLED");
+    const pipelinesSafety = definicao.kind === "GAME"
+        ? ["interactive.safety"]
+        : ["interactive.safety", "simulation.safety"];
+    if (exigeSafety && !pipelinesSafety.some((pipelineId) => pipelines.includes(pipelineId))) {
+        adicionar(bloqueios, "autonomia_exige_pipeline_safety_compativel");
+    }
+    const exigeCalibracao = definicao.fidelity === "REALISTIC" || definicao.fidelity === "CALIBRATED";
+    const pipelinesCalibracao = definicao.kind === "GAME"
+        ? ["interactive.calibrate"]
+        : ["interactive.calibrate", "simulation.calibrate"];
+    if (exigeCalibracao && !pipelinesCalibracao.some((pipelineId) => pipelines.includes(pipelineId))) {
+        adicionar(bloqueios, "fidelity_exige_pipeline_calibrate_compativel");
+    }
+    if ((definicao.determinism === "SEEDED" || definicao.determinism === "STRICT")
+        && !pipelines.includes("interactive.replay")) {
+        adicionar(bloqueios, "determinism_exige_pipeline_interactive_replay");
+    }
+}
+function validarCapabilitiesControle(definicao, bloqueios) {
+    const declaradas = new Set(Array.isArray(definicao.capabilities) ? definicao.capabilities : []);
+    for (const modo of Array.isArray(definicao.controlModes) ? definicao.controlModes : []) {
+        if (!MATRIZ_DOMINIO_SISTEMAS_INTERATIVOS.controlModes.includes(modo))
+            continue;
+        const capability = `interactive.control.${slugCapability(modo)}`;
+        if (!declaradas.has(capability))
+            adicionar(bloqueios, "capability_controle_ausente");
+    }
+}
+export function validarDefinicaoSistemaInterativo(definicao) {
+    const bloqueios = [];
+    let definitionDigest;
+    try {
+        definitionDigest = digestJsonSistemaInterativo(definicao);
+    }
+    catch {
+        definitionDigest = digestJsonSistemaInterativo({ definicaoInvalida: true });
+        adicionar(bloqueios, "definicao_nao_canonica");
+    }
+    const entrada = objeto(definicao) ? definicao : {};
+    if (entrada !== definicao)
+        adicionar(bloqueios, "definicao_invalida");
+    validarBase(entrada, bloqueios);
+    validarEixos(entrada, bloqueios);
+    validarWorld(entrada, bloqueios);
+    validarAceitacao(entrada, bloqueios);
+    validarPipelinesEAdapters(entrada, bloqueios);
+    validarCapabilitiesControle(entrada, bloqueios);
+    return {
+        valida: bloqueios.length === 0,
+        definitionDigest,
+        capabilitiesRequeridas: capabilitiesEstruturais(entrada),
+        bloqueios: [...bloqueios].sort(),
+    };
+}
+//# sourceMappingURL=validator.js.map

package/dist/sync/index.js

@@ -46,25 +46,25 @@ export async function gerarSchemaPrisma(pastaContratos, saidaSchema, datasourceP
     for (const contrato of contratos) {
         const nomeModel = path.basename(contrato, '.sema').replace(/\./g, '_');
         // Schema simplificado - em producao, fazer parsing real do contrato
-        models += `\nmodel ${nomeModel.charAt(0).toUpperCase() + nomeModel.slice(1)} {
-  id        String   @id @default(uuid())
-  criadoEm  DateTime @default(now())
-  // Gerado a partir de: ${contrato}
-  // TODO: Adicionar campos do contrato Sema
+        models += `\nmodel ${nomeModel.charAt(0).toUpperCase() + nomeModel.slice(1)} {
+  id        String   @id @default(uuid())
+  criadoEm  DateTime @default(now())
+  // Gerado a partir de: ${contrato}
+  // TODO: Adicionar campos do contrato Sema
 }\n`;
         modelCount++;
     }
-    const schema = `// Gerado automaticamente pelo Sema
-// Fonte: ${pastaContratos}
-
-generator client {
-  provider = "prisma-client-js"
-}
-
-datasource db {
-  provider = "${datasourceProvider}"
-  url      = env("SEMA_PRISMA_URL")
-}
+    const schema = `// Gerado automaticamente pelo Sema
+// Fonte: ${pastaContratos}
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "${datasourceProvider}"
+  url      = env("SEMA_PRISMA_URL")
+}
 ${models}`;
     // Salvar
     fs.writeFileSync(saidaSchema, schema, 'utf-8');
@@ -90,25 +90,25 @@ export async function importarSchemaPrisma(caminhoSchema, pastaSaida, nomeModulo
         const nomeContrato = `${nomeModel.toLowerCase()}.sema`;
         const caminhoContrato = path.join(pastaSaida, nomeContrato);
         // Gerar contrato basico
-        const conteudo = `module ${nomeModulo}.${nomeModel.toLowerCase()} {
-  entity ${nomeModel} {
-    fields {
-      id: Id
-      // TODO: Mapear campos do schema Prisma
-    }
-  }
-
-  task criar_${nomeModel.toLowerCase()} {
-    input {
-      // TODO: Definir inputs
-    }
-    output {
-      ${nomeModel.toLowerCase()}: ${nomeModel}
-    }
-    effects {
-      persistencia ${nomeModel}
-    }
-  }
+        const conteudo = `module ${nomeModulo}.${nomeModel.toLowerCase()} {
+  entity ${nomeModel} {
+    fields {
+      id: Id
+      // TODO: Mapear campos do schema Prisma
+    }
+  }
+
+  task criar_${nomeModel.toLowerCase()} {
+    input {
+      // TODO: Definir inputs
+    }
+    output {
+      ${nomeModel.toLowerCase()}: ${nomeModel}
+    }
+    effects {
+      persistencia ${nomeModel}
+    }
+  }
 }`;
         fs.writeFileSync(caminhoContrato, conteudo, 'utf-8');
         contratos.push(caminhoContrato);