@semacode/cli 2.2.0 → 2.3.0

package/dist/sistemasInterativos/operationsTypes.d.ts

@@ -0,0 +1,297 @@
+export declare const OPERATION_RESULT_SCHEMA_V1: "sema.interactive.operation-result/v1";
+export declare const ENGINE_SNAPSHOT_SCHEMA_V1: "sema.interactive.engine-snapshot/v1";
+export declare const ENGINE_DIFF_SCHEMA_V1: "sema.interactive.engine-diff/v1";
+export declare const ASSET_PROVENANCE_SCHEMA_V1: "sema.interactive.asset-provenance/v1";
+export declare const EDITOR_STATE_SCHEMA_V1: "sema.interactive.editor-state/v1";
+export declare const JOB_ORCHESTRATION_SCHEMA_V1: "sema.interactive.job-orchestration/v1";
+export declare const ACCEPTANCE_LOCK_SCHEMA_V1: "sema.interactive.acceptance-lock/v1";
+export declare const MULTIMODAL_EVIDENCE_SCHEMA_V1: "sema.interactive.multimodal-evidence/v1";
+export type Sha256 = string & {
+    readonly __sha256Brand: unique symbol;
+};
+export type OpaqueSha256 = string & {
+    readonly __opaqueSha256Brand: unique symbol;
+};
+export interface OperationIssue {
+    readonly code: string;
+    readonly field: string;
+}
+export interface OperationResult<T> {
+    readonly schemaVersion: typeof OPERATION_RESULT_SCHEMA_V1;
+    readonly valid: boolean;
+    readonly issues: readonly OperationIssue[];
+    readonly value?: T;
+    readonly digest?: Sha256;
+    readonly executed: false;
+    readonly workspaceMutated: false;
+    readonly engineProbed: false;
+    readonly editorInspected: false;
+    readonly processesInspected: false;
+    readonly resourcesReserved: false;
+    readonly authoritative: false;
+}
+export interface EngineSemanticObjectSnapshot {
+    readonly semanticId: string;
+    readonly kind: string;
+    readonly parentSemanticId?: string;
+    readonly stateDigest: Sha256;
+    readonly componentDigests: Readonly<Record<string, Sha256>>;
+}
+export interface EngineSnapshotV1 {
+    readonly schemaVersion: typeof ENGINE_SNAPSHOT_SCHEMA_V1;
+    readonly snapshotId: string;
+    readonly projectId: string;
+    readonly sceneId: string;
+    readonly adapter: {
+        readonly adapterId: string;
+        readonly adapterVersion: string;
+    };
+    readonly semanticObjects: readonly EngineSemanticObjectSnapshot[];
+    readonly artifactDigest: Sha256;
+    readonly readOnly: true;
+    readonly authoritative: false;
+}
+export interface ValidatedEngineSnapshot {
+    readonly snapshot: EngineSnapshotV1;
+    readonly snapshotDigest: Sha256;
+    readonly localValidationOnly: true;
+}
+export interface EngineSnapshotChange {
+    readonly semanticId: string;
+    readonly change: "ADDED" | "REMOVED" | "MODIFIED";
+    readonly beforeDigest?: Sha256;
+    readonly afterDigest?: Sha256;
+}
+export interface EngineSnapshotDiffV1 {
+    readonly schemaVersion: typeof ENGINE_DIFF_SCHEMA_V1;
+    readonly beforeSnapshotDigest: Sha256;
+    readonly afterSnapshotDigest: Sha256;
+    readonly bindingDigest: Sha256;
+    readonly artifactDigestChanged: boolean;
+    readonly changes: readonly EngineSnapshotChange[];
+    readonly diffDigest: Sha256;
+    readonly readOnly: true;
+    readonly authoritative: false;
+}
+export interface AssetProvenanceV1 {
+    readonly schemaVersion: typeof ASSET_PROVENANCE_SCHEMA_V1;
+    readonly assetId: string;
+    readonly sourceUriRef: OpaqueSha256;
+    readonly sourceUriRedacted: true;
+    readonly license: {
+        readonly licenseId: string;
+        readonly evidenceDigest: Sha256;
+        readonly redistributable: boolean;
+    };
+    readonly sourceHash: Sha256;
+    readonly contentHash: Sha256;
+    readonly transforms: readonly {
+        readonly transformId: string;
+        readonly toolRef: string;
+        readonly toolVersion: string;
+        readonly inputDigest: Sha256;
+        readonly outputDigest: Sha256;
+        readonly parametersDigest: Sha256;
+    }[];
+    readonly derivatives: readonly {
+        readonly assetId: string;
+        readonly parentContentHash: Sha256;
+        readonly contentHash: Sha256;
+        readonly transformDigest: Sha256;
+    }[];
+    readonly authoritative: false;
+}
+export interface EditorStateV1 {
+    readonly schemaVersion: typeof EDITOR_STATE_SCHEMA_V1;
+    readonly editorSessionId: string;
+    readonly adapter: {
+        readonly adapterId: string;
+        readonly adapterVersion: string;
+    };
+    readonly scene: {
+        readonly semanticId: string;
+        readonly artifactDigest: Sha256;
+    };
+    readonly selection: readonly string[];
+    readonly mode: "EDIT" | "PLAY" | "PAUSED";
+    readonly unsavedChanges: boolean;
+    readonly shaderJobs: readonly {
+        readonly jobId: string;
+        readonly status: string;
+        readonly progressBasisPoints: number;
+    }[];
+    readonly importJobs: readonly {
+        readonly jobId: string;
+        readonly status: string;
+        readonly progressBasisPoints: number;
+    }[];
+    readonly plugins: readonly {
+        readonly pluginId: string;
+        readonly version: string;
+        readonly enabled: boolean;
+        readonly provenanceDigest: Sha256;
+    }[];
+    readonly modals: readonly {
+        readonly modalId: string;
+        readonly kind: string;
+        readonly blocking: boolean;
+    }[];
+    readonly processes: readonly {
+        readonly processRef: OpaqueSha256;
+        readonly role: string;
+        readonly state: string;
+    }[];
+    readonly observedAt: string;
+    readonly readOnly: true;
+    readonly authoritative: false;
+}
+export type ResourceLock = "GPU" | "EDITOR" | "CACHE";
+export interface JobOrchestrationRequestV1 {
+    readonly schemaVersion: typeof JOB_ORCHESTRATION_SCHEMA_V1;
+    readonly queueId: string;
+    readonly capacity: {
+        readonly ramMb: number;
+        readonly vramMb: number;
+        readonly diskMb: number;
+    };
+    readonly lockCapacity: Readonly<Record<ResourceLock, number>>;
+    readonly jobs: readonly {
+        readonly jobId: string;
+        readonly kind: string;
+        readonly priority: number;
+        readonly dependencies: readonly string[];
+        readonly locks: readonly ResourceLock[];
+        readonly budget: {
+            readonly ramMb: number;
+            readonly vramMb: number;
+            readonly diskMb: number;
+        };
+        readonly heartbeat: {
+            readonly intervalMs: number;
+            readonly timeoutMs: number;
+        };
+        readonly checkpoint: {
+            readonly intervalMs: number;
+            readonly resume: boolean;
+            readonly checkpointDigest?: Sha256;
+            readonly recoveryToken: OpaqueSha256;
+        };
+        readonly adapter: {
+            readonly adapterId: string;
+            readonly adapterVersion: string;
+        };
+    }[];
+}
+export interface JobOrchestrationPlanV1 {
+    readonly schemaVersion: typeof JOB_ORCHESTRATION_SCHEMA_V1;
+    readonly queueId: string;
+    readonly queue: readonly {
+        readonly position: number;
+        readonly jobId: string;
+        readonly kind: string;
+        readonly priority: number;
+        readonly adapter: {
+            readonly adapterId: string;
+            readonly adapterVersion: string;
+        };
+        readonly dependencies: readonly string[];
+        readonly locks: readonly ResourceLock[];
+        readonly budget: {
+            readonly ramMb: number;
+            readonly vramMb: number;
+            readonly diskMb: number;
+        };
+        readonly heartbeatIntervalMs: number;
+        readonly heartbeatTimeoutMs: number;
+        readonly checkpointIntervalMs: number;
+        readonly resume: boolean;
+        readonly checkpointDigest?: Sha256;
+        readonly recoveryToken: OpaqueSha256;
+    }[];
+    readonly requestDigest: Sha256;
+    readonly planDigest: Sha256;
+    readonly externalRunnerRequired: true;
+    readonly resourcesReserved: false;
+    readonly authoritative: false;
+}
+export type AcceptanceOperation = "VALIDATE" | "EVALUATE" | "INVALIDATE";
+export type AcceptanceInvalidationReason = "ARTIFACT_CHANGED" | "SCENE_CHANGED" | "TIME_RANGE_CHANGED" | "APPROVER_REVOKED" | "MANUAL_WITHDRAWAL";
+export type AcceptanceTimeRange = {
+    readonly start: number;
+    readonly end: number;
+    readonly unit: "FRAME" | "TICK" | "SECOND";
+};
+export interface AcceptanceLockV1 {
+    readonly schemaVersion: typeof ACCEPTANCE_LOCK_SCHEMA_V1;
+    readonly lockId: string;
+    readonly artifactDigest: Sha256;
+    readonly sceneId: string;
+    readonly timeRange: AcceptanceTimeRange;
+    readonly approver: {
+        readonly approverIdDigest: Sha256;
+        readonly role: string;
+        readonly method: "HUMAN" | "POLICY";
+    };
+    readonly decision: "ACCEPTED";
+    readonly status: "ACTIVE" | "INVALIDATED";
+    readonly createdAt: string;
+    readonly invalidation?: {
+        readonly previousLockDigest: Sha256;
+        readonly invalidatedByDigest: Sha256;
+        readonly reasonCode: AcceptanceInvalidationReason;
+        readonly invalidatedAt: string;
+    };
+    readonly authoritative: false;
+}
+export interface AcceptanceOperationValue {
+    readonly operation: AcceptanceOperation;
+    readonly accepted: boolean;
+    readonly bindingMatches: boolean;
+    readonly invalidated: boolean;
+    readonly blockers: readonly string[];
+    readonly lock: AcceptanceLockV1;
+    readonly lockDigest: Sha256;
+}
+export type MultimodalChannelType = "SCREENSHOT" | "VIDEO" | "DEPTH" | "NORMALS" | "OBJECT_ID" | "MOTION" | "TRANSFORMS" | "EVENTS" | "AUDIO" | "TELEMETRY";
+export interface MultimodalEvidenceDescriptorV1 {
+    readonly schemaVersion: typeof MULTIMODAL_EVIDENCE_SCHEMA_V1;
+    readonly evidenceId: string;
+    readonly runId: string;
+    readonly claimId: string;
+    readonly definitionDigest: Sha256;
+    readonly planDigest: Sha256;
+    readonly contractDigest: Sha256;
+    readonly claimBindingDigest: Sha256;
+    readonly artifactDigest: Sha256;
+    readonly sceneId: string;
+    readonly timeRange: AcceptanceTimeRange;
+    readonly requiredModalities: readonly MultimodalChannelType[];
+    readonly channels: readonly {
+        readonly channelId: string;
+        readonly type: MultimodalChannelType;
+        readonly artifactDigest: Sha256;
+        readonly mediaType: string;
+        readonly metadataDigest: Sha256;
+        readonly sampleCount: number;
+    }[];
+    readonly producer: {
+        readonly producerIdDigest: Sha256;
+        readonly producerType: "ENGINE" | "EDITOR" | "RUNNER" | "MODEL" | "HUMAN" | "SENSOR";
+        readonly version: string;
+        readonly configurationDigest: Sha256;
+    };
+    readonly verifier: {
+        readonly verifierIdDigest: Sha256;
+        readonly verifierType: "RULE" | "MODEL" | "HUMAN" | "SENSOR";
+        readonly version: string;
+        readonly independent: true;
+        readonly configurationDigest: Sha256;
+    };
+    readonly decision: {
+        readonly verdict: "PASS" | "FAIL" | "INCONCLUSIVE";
+        readonly reasonCodes: readonly string[];
+        readonly confidenceBasisPoints: number;
+    };
+    readonly observedAt: string;
+    readonly authoritative: false;
+}

package/dist/sistemasInterativos/operationsTypes.js

@@ -0,0 +1,11 @@
+// SEMA-GOVERNED: sema.produto.sistemas_interativos.operacao
+// Descricao: schemas JSON v1 e tipos estaveis da fundacao operacional interativa.
+export const OPERATION_RESULT_SCHEMA_V1 = "sema.interactive.operation-result/v1";
+export const ENGINE_SNAPSHOT_SCHEMA_V1 = "sema.interactive.engine-snapshot/v1";
+export const ENGINE_DIFF_SCHEMA_V1 = "sema.interactive.engine-diff/v1";
+export const ASSET_PROVENANCE_SCHEMA_V1 = "sema.interactive.asset-provenance/v1";
+export const EDITOR_STATE_SCHEMA_V1 = "sema.interactive.editor-state/v1";
+export const JOB_ORCHESTRATION_SCHEMA_V1 = "sema.interactive.job-orchestration/v1";
+export const ACCEPTANCE_LOCK_SCHEMA_V1 = "sema.interactive.acceptance-lock/v1";
+export const MULTIMODAL_EVIDENCE_SCHEMA_V1 = "sema.interactive.multimodal-evidence/v1";
+//# sourceMappingURL=operationsTypes.js.map

package/dist/sistemasInterativos/planner.d.ts

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

package/dist/sistemasInterativos/planner.js

@@ -0,0 +1,159 @@
+// SEMA-GOVERNED: sema.produto.sistemas_interativos
+// Descricao: expande pipelines e adapters em plano deterministico sem executar ou escrever no workspace.
+import { digestJsonSistemaInterativo } from "./canonical.js";
+import { CATALOGO_ADAPTADORES_INTERATIVOS, obterPipelineSistemaInterativo, } from "./catalog.js";
+import { validarDefinicaoSistemaInterativo } from "./validator.js";
+function adapterCompativel(adapter, definicao) {
+    return adapter.kinds.includes(definicao.kind)
+        && adapter.spatialModels.includes(definicao.spatialModel)
+        && adapter.renderModes.includes(definicao.renderMode)
+        && adapter.visualProfiles.includes(definicao.visualProfile)
+        && Array.isArray(definicao.controlModes)
+        && definicao.controlModes.every((modo) => adapter.controlModes.includes(modo))
+        && adapter.timeModels.includes(definicao.timeModel)
+        && adapter.fidelities.includes(definicao.fidelity);
+}
+function expandirPipelines(definicao) {
+    const pipelines = [];
+    const stages = [];
+    for (const pipelineId of definicao.pipelines) {
+        const descriptor = obterPipelineSistemaInterativo(pipelineId);
+        if (!descriptor)
+            continue;
+        const stageInstanceIds = descriptor.stages.map((stage) => `${pipelineId}/${stage.stageId}`);
+        pipelines.push({
+            pipelineId,
+            version: descriptor.version,
+            stageInstanceIds,
+            requiredEvidence: [...descriptor.requiredEvidence],
+        });
+        for (const stage of descriptor.stages) {
+            stages.push({
+                ...stage,
+                pipelineId,
+                stageInstanceId: `${pipelineId}/${stage.stageId}`,
+                dependsOn: stage.dependsOn.map((dependencia) => `${pipelineId}/${dependencia}`),
+            });
+        }
+    }
+    return { pipelines, stages };
+}
+function planoComDigest(plano) {
+    return { ...plano, planDigest: digestJsonSistemaInterativo(plano) };
+}
+function mapearProvedores(stages, candidatos, selecionados) {
+    return stages.map((stage) => {
+        const candidateAdapterIds = candidatos
+            .filter((adapter) => adapter.capabilities.includes(stage.capability))
+            .map((adapter) => adapter.adapterId)
+            .sort();
+        const selectedAdapterIds = selecionados
+            .filter((adapter) => adapter.capabilities.includes(stage.capability))
+            .map((adapter) => adapter.adapterId)
+            .sort();
+        return {
+            stageInstanceId: stage.stageInstanceId,
+            capability: stage.capability,
+            candidateAdapterIds,
+            selectedAdapterIds,
+            coveredBySelection: selectedAdapterIds.length > 0,
+        };
+    });
+}
+function recomendarComposicao(mapa, idsJaSelecionados) {
+    let pendentes = mapa.filter((item) => !item.coveredBySelection);
+    const recomendados = [];
+    for (let iteracao = 0; pendentes.length > 0 && iteracao < mapa.length; iteracao += 1) {
+        const candidatos = [...new Set(pendentes.flatMap((item) => item.candidateAdapterIds))]
+            .filter((adapterId) => !idsJaSelecionados.has(adapterId) && !recomendados.includes(adapterId))
+            .sort();
+        const melhor = candidatos.map((adapterId) => ({
+            adapterId,
+            cobertura: pendentes.filter((item) => item.candidateAdapterIds.includes(adapterId)).length,
+        })).sort((a, b) => b.cobertura - a.cobertura || a.adapterId.localeCompare(b.adapterId))[0];
+        if (!melhor || melhor.cobertura === 0)
+            break;
+        recomendados.push(melhor.adapterId);
+        const restantes = pendentes.filter((item) => !item.candidateAdapterIds.includes(melhor.adapterId));
+        if (restantes.length >= pendentes.length)
+            break;
+        pendentes = restantes;
+    }
+    return recomendados;
+}
+export function planejarSistemaInterativo(definicao) {
+    const validacao = validarDefinicaoSistemaInterativo(definicao);
+    const bloqueios = [...validacao.bloqueios];
+    const declaradas = new Set(Array.isArray(definicao.capabilities) ? definicao.capabilities : []);
+    const capabilitiesAusentes = validacao.capabilitiesRequeridas.filter((item) => !declaradas.has(item));
+    const expandidos = validacao.valida ? expandirPipelines(definicao) : { pipelines: [], stages: [] };
+    const alvos = Array.isArray(definicao.adapterTargets) ? definicao.adapterTargets : [];
+    const adapterSelectionExplicit = alvos.length > 0;
+    const candidatos = validacao.valida
+        ? CATALOGO_ADAPTADORES_INTERATIVOS.filter((adapter) => adapterCompativel(adapter, definicao))
+        : [];
+    const selecionados = candidatos.filter((adapter) => alvos.includes(adapter.adapterId));
+    const adaptersCompativeis = candidatos.map((adapter) => adapter.adapterId).sort();
+    const adaptersSelecionados = selecionados.map((adapter) => adapter.adapterId).sort();
+    const selecionadosSet = new Set(adaptersSelecionados);
+    if (capabilitiesAusentes.length > 0)
+        bloqueios.push("capabilities_obrigatorias_ausentes");
+    if (validacao.valida && adaptersCompativeis.length === 0)
+        bloqueios.push("adapter_compativel_ausente");
+    if (validacao.valida && !adapterSelectionExplicit)
+        bloqueios.push("adapter_selecao_explicita_ausente");
+    if (validacao.valida) {
+        for (const [indice, adapterId] of alvos.entries()) {
+            const conhecido = CATALOGO_ADAPTADORES_INTERATIVOS.some((adapter) => adapter.adapterId === adapterId);
+            if (conhecido && !selecionadosSet.has(adapterId))
+                bloqueios.push(`adapter_target_incompativel_indice:${indice}`);
+        }
+    }
+    const stageProviderMap = mapearProvedores(expandidos.stages, candidatos, selecionados);
+    const capabilitiesSemAdapter = [...new Set(stageProviderMap
+            .filter((item) => !item.coveredBySelection)
+            .map((item) => item.capability))].sort();
+    const semCandidato = stageProviderMap.some((item) => item.candidateAdapterIds.length === 0);
+    const adapterCoverageComplete = adapterSelectionExplicit
+        && stageProviderMap.length > 0
+        && stageProviderMap.every((item) => item.coveredBySelection);
+    if (validacao.valida && semCandidato)
+        bloqueios.push("adapter_provedor_candidato_ausente");
+    if (validacao.valida && adapterSelectionExplicit && !adapterCoverageComplete) {
+        bloqueios.push("adapter_capability_coverage_incompleta");
+    }
+    const nextActions = [];
+    for (const bloqueio of [...new Set(bloqueios)].sort())
+        nextActions.push(`corrigir:${bloqueio}`);
+    for (const capability of capabilitiesAusentes)
+        nextActions.push(`declarar_capability:${capability}`);
+    for (const adapterId of recomendarComposicao(stageProviderMap, selecionadosSet)) {
+        nextActions.push(`${adapterSelectionExplicit ? "adicionar" : "selecionar"}_adapter_externo:${adapterId}`);
+    }
+    for (const evidenceType of [...new Set(expandidos.stages.flatMap((stage) => stage.requiredEvidence))].sort()) {
+        nextActions.push(`coletar_evidencia_externa:${evidenceType}`);
+    }
+    if (validacao.valida && bloqueios.length === 0)
+        nextActions.push("entregar_plano_ao_runner_externo");
+    const plano = planoComDigest({
+        systemId: validacao.bloqueios.includes("system_id_invalido") ? "INVALID" : definicao.systemId,
+        definitionDigest: validacao.definitionDigest,
+        capabilitiesRequeridas: validacao.capabilitiesRequeridas,
+        capabilitiesAusentes,
+        pipelines: expandidos.pipelines,
+        adaptersCompativeis,
+        adaptersSelecionados,
+        adapterSelectionExplicit,
+        adapterCoverageComplete,
+        capabilitiesSemAdapter,
+        stageProviderMap,
+        stages: expandidos.stages,
+        nextActions,
+        executed: false,
+    });
+    return {
+        plano,
+        bloqueios: [...new Set(bloqueios)].sort(),
+    };
+}
+//# sourceMappingURL=planner.js.map

package/dist/sistemasInterativos/portability.d.ts

@@ -0,0 +1,164 @@
+export declare const SCHEMA_PORTABILIDADE: "sema.interactive.portability/v1";
+export declare const SCHEMA_WORKERS_DISTRIBUIDOS: "sema.interactive.distributed-jobs/v1";
+export type StatusMapeamentoPortabilidade = "EXACT" | "APPROXIMATE" | "UNSUPPORTED";
+export interface EntradaManifestoFontePortabilidade {
+    readonly semanticId: string;
+    readonly sourceKind: string;
+    readonly contentDigest: string;
+    readonly required: boolean;
+}
+export interface ManifestoFontePortabilidade {
+    readonly experienceIrDigest: string;
+    readonly snapshotDigest: string;
+    readonly entries: readonly EntradaManifestoFontePortabilidade[];
+    readonly manifestDigest: string;
+}
+export interface OrigemPortabilidade {
+    readonly engine: string;
+    readonly version: string;
+    readonly snapshotDigest: string;
+    readonly coordinateSystem: string;
+}
+export interface MapeamentoPortabilidade {
+    readonly mappingId: string;
+    readonly semanticId: string;
+    readonly sourceKind: string;
+    readonly targetKind: string;
+    readonly status: StatusMapeamentoPortabilidade;
+    readonly losses: readonly string[];
+    readonly fallback?: string;
+    readonly acceptanceCriteria: readonly string[];
+}
+export interface AlvoPortabilidade {
+    readonly targetId: string;
+    readonly engine: string;
+    readonly version: string;
+    readonly outputFormat: string;
+    readonly mappings: readonly MapeamentoPortabilidade[];
+}
+export interface MigracaoEngine {
+    readonly migrationId: string;
+    readonly targetId: string;
+    readonly engine: string;
+    readonly fromVersion: string;
+    readonly toVersion: string;
+    readonly backupDigest: string;
+    readonly compatibilityReportDigest: string;
+    readonly testPlanDigest: string;
+    readonly rollbackPlanDigest: string;
+}
+export interface PlanoPortabilidadeInterativa {
+    readonly schemaVersion: typeof SCHEMA_PORTABILIDADE;
+    readonly planId: string;
+    readonly systemId: string;
+    readonly experienceIrDigest: string;
+    readonly source: OrigemPortabilidade;
+    readonly sourceManifest: ManifestoFontePortabilidade;
+    readonly targets: readonly AlvoPortabilidade[];
+    readonly migrations: readonly MigracaoEngine[];
+    readonly acceptance: {
+        readonly maxUnsupportedPerTarget: number;
+        readonly allowApproximate: boolean;
+        readonly requiredEvidence: readonly string[];
+    };
+}
+export interface RelatorioAlvoPortabilidade {
+    readonly targetId: string;
+    readonly exact: number;
+    readonly approximate: number;
+    readonly unsupported: number;
+    readonly sourceCoverageComplete: boolean;
+    readonly mappingsBoundToSource: boolean;
+    readonly migrationLinked: boolean;
+    readonly readyForExternalMigration: boolean;
+    readonly requiresExternalValidation: true;
+    readonly converted: false;
+}
+export interface PerdaPortabilidade {
+    readonly targetId: string;
+    readonly mappingId: string;
+    readonly status: "APPROXIMATE" | "UNSUPPORTED";
+    readonly lossCodes: readonly string[];
+    readonly fallback: string;
+}
+export interface ResultadoPortabilidadeInterativa {
+    readonly valido: boolean;
+    readonly planDigest: string;
+    readonly targetReports: readonly RelatorioAlvoPortabilidade[];
+    readonly declaredLosses: readonly PerdaPortabilidade[];
+    readonly migrationGaps: readonly string[];
+    readonly nextActions: readonly string[];
+    readonly converted: false;
+    readonly authoritative: false;
+    readonly executed: false;
+    readonly bloqueios: readonly string[];
+}
+export interface WorkerDistribuido {
+    readonly workerId: string;
+    readonly capabilities: readonly string[];
+    readonly ramMb: number;
+    readonly vramMb: number;
+    readonly diskMb: number;
+    readonly maxConcurrency: number;
+    readonly isolation: "CONTAINER" | "VM" | "PROCESS_SANDBOX";
+}
+export interface JobDistribuido {
+    readonly jobId: string;
+    readonly type: "COOK" | "SHADERS" | "RENDER" | "TEST";
+    readonly inputDigest: string;
+    readonly dependsOn: readonly string[];
+    readonly requiredCapabilities: readonly string[];
+    readonly budgets: {
+        readonly ramMb: number;
+        readonly vramMb: number;
+        readonly diskMb: number;
+        readonly runtimeSeconds: number;
+    };
+    readonly idempotencyKey: string;
+    readonly checkpointIntervalSeconds: number;
+    readonly retry: {
+        readonly maxAttempts: number;
+        readonly backoffSeconds: number;
+    };
+    readonly resourceLockIds: readonly string[];
+    readonly requiredEvidence: readonly string[];
+}
+export interface LeaseRecursoDistribuido {
+    readonly lockId: string;
+    readonly resourceId: string;
+    readonly resourceType: "GPU" | "EDITOR" | "CACHE";
+    readonly ownerJobId: string;
+    readonly exclusive: boolean;
+    readonly ttlSeconds: number;
+    readonly heartbeatSeconds: number;
+    readonly checkpointDigest: string;
+}
+export interface PlanoWorkersDistribuidos {
+    readonly schemaVersion: typeof SCHEMA_WORKERS_DISTRIBUIDOS;
+    readonly planId: string;
+    readonly systemId: string;
+    readonly inputDigest: string;
+    readonly workers: readonly WorkerDistribuido[];
+    readonly jobs: readonly JobDistribuido[];
+    readonly leases: readonly LeaseRecursoDistribuido[];
+    readonly evidenceRequirements: readonly string[];
+}
+export interface ResultadoWorkersDistribuidos {
+    readonly valido: boolean;
+    readonly planDigest: string;
+    readonly topologicalOrder: readonly string[];
+    readonly assignments: readonly {
+        readonly jobId: string;
+        readonly workerId: string;
+    }[];
+    readonly capabilityGaps: readonly string[];
+    readonly lockConflicts: readonly string[];
+    readonly nextActions: readonly string[];
+    readonly completed: false;
+    readonly authoritative: false;
+    readonly executed: false;
+    readonly bloqueios: readonly string[];
+}
+export declare function digestManifestoFontePortabilidade(manifesto: Omit<ManifestoFontePortabilidade, "manifestDigest">): string;
+export declare function analisarPlanoPortabilidadeInterativa(entrada: unknown): ResultadoPortabilidadeInterativa;
+export declare function validarPlanoWorkersDistribuidos(entrada: unknown): ResultadoWorkersDistribuidos;