@semacode/cli 2.3.0 → 3.0.0

package/dist/sistemasInterativos/engineObservation.js

@@ -0,0 +1,438 @@
+// SEMA-GOVERNED: sema.produto.sistemas_interativos.operacao, sema.produto.sistemas_interativos.operacao.observacao_engine
+// Descricao: snapshots, diffs, proveniencia de assets e estado declarado de editor, sem sondar runtimes.
+import { ASSET_PROVENANCE_SCHEMA_V1, EDITOR_STATE_SCHEMA_V1, ENGINE_DIFF_SCHEMA_V1, ENGINE_SNAPSHOT_SCHEMA_V1, } from "./operationsTypes.js";
+import { digestJsonOperacional, failure, hasOnlyKeys, inspectPlainJson, isIntegerIn, isIsoTimestamp, isOpaqueSha256, isRecord, isSafeName, isSemanticId, isSha256, isVersion, issue, success, } from "./operationPrimitives.js";
+export function validarSnapshotEngine(input) {
+    const issues = inspectPlainJson(input, "snapshot");
+    if (!isRecord(input))
+        return failure([...issues, issue("snapshot_object_required", "snapshot")]);
+    if (!hasOnlyKeys(input, [
+        "schemaVersion", "snapshotId", "projectId", "sceneId", "adapter",
+        "semanticObjects", "artifactDigest", "readOnly", "authoritative",
+    ]))
+        issues.push(issue("snapshot_unknown_field", "snapshot"));
+    if (input.schemaVersion !== ENGINE_SNAPSHOT_SCHEMA_V1)
+        issues.push(issue("snapshot_schema_invalid", "schemaVersion"));
+    if (!isSemanticId(input.snapshotId))
+        issues.push(issue("snapshot_id_invalid", "snapshotId"));
+    if (!isSemanticId(input.projectId))
+        issues.push(issue("project_id_invalid", "projectId"));
+    if (!isSemanticId(input.sceneId))
+        issues.push(issue("scene_id_invalid", "sceneId"));
+    if (!isSha256(input.artifactDigest))
+        issues.push(issue("artifact_digest_invalid", "artifactDigest"));
+    if (input.readOnly !== true)
+        issues.push(issue("snapshot_must_be_read_only", "readOnly"));
+    if (input.authoritative !== false)
+        issues.push(issue("snapshot_must_be_non_authoritative", "authoritative"));
+    const adapter = input.adapter;
+    if (!isRecord(adapter)
+        || !hasOnlyKeys(adapter, ["adapterId", "adapterVersion"])
+        || !isSafeName(adapter.adapterId)
+        || !isVersion(adapter.adapterVersion))
+        issues.push(issue("snapshot_adapter_invalid", "adapter"));
+    const objects = input.semanticObjects;
+    const ids = new Set();
+    if (!Array.isArray(objects) || objects.length === 0) {
+        issues.push(issue("snapshot_objects_required", "semanticObjects"));
+    }
+    else {
+        for (const object of objects) {
+            if (!isRecord(object) || !hasOnlyKeys(object, [
+                "semanticId", "kind", "parentSemanticId", "stateDigest", "componentDigests",
+            ])) {
+                issues.push(issue("snapshot_object_invalid", "semanticObjects"));
+                continue;
+            }
+            if (!isSemanticId(object.semanticId))
+                issues.push(issue("semantic_object_id_invalid", "semanticObjects"));
+            else if (ids.has(object.semanticId))
+                issues.push(issue("semantic_object_id_duplicate", "semanticObjects"));
+            else
+                ids.add(object.semanticId);
+            if (!isSafeName(object.kind))
+                issues.push(issue("semantic_object_kind_invalid", "semanticObjects"));
+            if (object.parentSemanticId !== undefined && !isSemanticId(object.parentSemanticId)) {
+                issues.push(issue("semantic_parent_id_invalid", "semanticObjects"));
+            }
+            if (!isSha256(object.stateDigest))
+                issues.push(issue("semantic_state_digest_invalid", "semanticObjects"));
+            if (!isRecord(object.componentDigests)) {
+                issues.push(issue("component_digests_invalid", "semanticObjects"));
+            }
+            else
+                for (const [name, digest] of Object.entries(object.componentDigests)) {
+                    if (!isSafeName(name) || !isSha256(digest))
+                        issues.push(issue("component_digest_invalid", "semanticObjects"));
+                }
+        }
+        for (const object of objects) {
+            if (isRecord(object) && typeof object.parentSemanticId === "string" && !ids.has(object.parentSemanticId)) {
+                issues.push(issue("semantic_parent_missing", "semanticObjects"));
+            }
+        }
+        const parentById = new Map();
+        for (const object of objects) {
+            if (!isRecord(object) || !isSemanticId(object.semanticId) || !isSemanticId(object.parentSemanticId))
+                continue;
+            if (object.parentSemanticId === object.semanticId) {
+                issues.push(issue("semantic_parent_self_reference", "semanticObjects"));
+            }
+            else if (ids.has(object.parentSemanticId))
+                parentById.set(object.semanticId, object.parentSemanticId);
+        }
+        for (const start of parentById.keys()) {
+            const path = new Set();
+            let cursor = start;
+            while (cursor !== undefined && parentById.has(cursor)) {
+                if (path.has(cursor)) {
+                    issues.push(issue("semantic_parent_cycle", "semanticObjects"));
+                    break;
+                }
+                path.add(cursor);
+                cursor = parentById.get(cursor);
+            }
+            if (issues.some((item) => item.code === "semantic_parent_cycle"))
+                break;
+        }
+    }
+    if (issues.length > 0)
+        return failure(issues);
+    const snapshot = input;
+    const normalized = {
+        ...snapshot,
+        adapter: { ...snapshot.adapter },
+        semanticObjects: snapshot.semanticObjects.map((object) => ({
+            ...object,
+            componentDigests: Object.fromEntries(Object.entries(object.componentDigests).sort(([left], [right]) => left.localeCompare(right))),
+        })).sort((left, right) => left.semanticId.localeCompare(right.semanticId)),
+    };
+    const snapshotDigest = digestJsonOperacional(normalized);
+    return success({ snapshot: normalized, snapshotDigest, localValidationOnly: true }, snapshotDigest);
+}
+export function derivarDiffSnapshotsEngine(beforeInput, afterInput) {
+    const beforeResult = validarSnapshotEngine(beforeInput);
+    const afterResult = validarSnapshotEngine(afterInput);
+    const issues = [];
+    if (!beforeResult.valid)
+        issues.push(issue("before_snapshot_invalid", "snapshotBefore"), ...beforeResult.issues);
+    if (!afterResult.valid)
+        issues.push(issue("after_snapshot_invalid", "snapshotAfter"), ...afterResult.issues);
+    if (!beforeResult.value || !afterResult.value)
+        return failure(issues);
+    const before = beforeResult.value.snapshot;
+    const after = afterResult.value.snapshot;
+    if (before.projectId !== after.projectId)
+        issues.push(issue("snapshot_project_binding_mismatch", "projectId"));
+    if (before.sceneId !== after.sceneId)
+        issues.push(issue("snapshot_scene_binding_mismatch", "sceneId"));
+    if (before.adapter.adapterId !== after.adapter.adapterId
+        || before.adapter.adapterVersion !== after.adapter.adapterVersion) {
+        issues.push(issue("snapshot_adapter_binding_mismatch", "adapter"));
+    }
+    if (issues.length > 0)
+        return failure(issues);
+    const beforeById = new Map(before.semanticObjects.map((item) => [item.semanticId, item]));
+    const afterById = new Map(after.semanticObjects.map((item) => [item.semanticId, item]));
+    const allIds = [...new Set([...beforeById.keys(), ...afterById.keys()])].sort();
+    const changes = [];
+    for (const semanticId of allIds) {
+        const previous = beforeById.get(semanticId);
+        const current = afterById.get(semanticId);
+        if (!previous && current) {
+            changes.push({ semanticId, change: "ADDED", afterDigest: digestJsonOperacional(current) });
+        }
+        else if (previous && !current) {
+            changes.push({ semanticId, change: "REMOVED", beforeDigest: digestJsonOperacional(previous) });
+        }
+        else if (previous && current) {
+            const beforeDigest = digestJsonOperacional(previous);
+            const afterDigest = digestJsonOperacional(current);
+            if (beforeDigest !== afterDigest)
+                changes.push({ semanticId, change: "MODIFIED", beforeDigest, afterDigest });
+        }
+    }
+    const withoutDigest = {
+        schemaVersion: ENGINE_DIFF_SCHEMA_V1,
+        beforeSnapshotDigest: beforeResult.value.snapshotDigest,
+        afterSnapshotDigest: afterResult.value.snapshotDigest,
+        bindingDigest: digestJsonOperacional({ projectId: before.projectId, sceneId: before.sceneId, adapter: before.adapter }),
+        artifactDigestChanged: before.artifactDigest !== after.artifactDigest,
+        changes,
+        readOnly: true,
+        authoritative: false,
+    };
+    const diff = { ...withoutDigest, diffDigest: digestJsonOperacional(withoutDigest) };
+    return success(diff, diff.diffDigest);
+}
+export function validarProvenienciaAsset(input) {
+    const issues = inspectPlainJson(input, "provenance");
+    if (!isRecord(input))
+        return failure([...issues, issue("provenance_object_required", "provenance")]);
+    if (!hasOnlyKeys(input, [
+        "schemaVersion", "assetId", "sourceUriRef", "sourceUriRedacted", "license",
+        "sourceHash", "contentHash", "transforms", "derivatives", "authoritative",
+    ]))
+        issues.push(issue("provenance_unknown_field", "provenance"));
+    if (input.schemaVersion !== ASSET_PROVENANCE_SCHEMA_V1)
+        issues.push(issue("provenance_schema_invalid", "schemaVersion"));
+    if (!isSemanticId(input.assetId))
+        issues.push(issue("asset_id_invalid", "assetId"));
+    if (!isOpaqueSha256(input.sourceUriRef))
+        issues.push(issue("source_uri_ref_must_be_opaque", "sourceUriRef"));
+    if (input.sourceUriRedacted !== true)
+        issues.push(issue("source_uri_must_be_redacted", "sourceUriRedacted"));
+    if (!isSha256(input.sourceHash))
+        issues.push(issue("source_hash_invalid", "sourceHash"));
+    if (!isSha256(input.contentHash))
+        issues.push(issue("content_hash_invalid", "contentHash"));
+    if (input.authoritative !== false)
+        issues.push(issue("provenance_must_be_non_authoritative", "authoritative"));
+    const license = input.license;
+    if (!isRecord(license)
+        || !hasOnlyKeys(license, ["licenseId", "evidenceDigest", "redistributable"])
+        || !isSafeName(license.licenseId)
+        || !isSha256(license.evidenceDigest)
+        || typeof license.redistributable !== "boolean")
+        issues.push(issue("asset_license_invalid", "license"));
+    const transforms = input.transforms;
+    const transformIds = new Set();
+    let previousDigest = input.sourceHash;
+    if (!Array.isArray(transforms)) {
+        issues.push(issue("asset_transforms_invalid", "transforms"));
+    }
+    else {
+        for (const transform of transforms) {
+            if (!isRecord(transform) || !hasOnlyKeys(transform, [
+                "transformId", "toolRef", "toolVersion", "inputDigest", "outputDigest", "parametersDigest",
+            ])) {
+                issues.push(issue("asset_transform_invalid", "transforms"));
+                continue;
+            }
+            if (!isSemanticId(transform.transformId))
+                issues.push(issue("transform_id_invalid", "transforms"));
+            else if (transformIds.has(transform.transformId))
+                issues.push(issue("transform_id_duplicate", "transforms"));
+            else
+                transformIds.add(transform.transformId);
+            if (!isSafeName(transform.toolRef) || !isVersion(transform.toolVersion))
+                issues.push(issue("transform_tool_invalid", "transforms"));
+            if (!isSha256(transform.inputDigest) || !isSha256(transform.outputDigest) || !isSha256(transform.parametersDigest)) {
+                issues.push(issue("transform_digest_invalid", "transforms"));
+            }
+            if (transform.inputDigest !== previousDigest)
+                issues.push(issue("transform_chain_broken", "transforms"));
+            previousDigest = transform.outputDigest;
+        }
+        if (previousDigest !== input.contentHash)
+            issues.push(issue("transform_final_hash_mismatch", "contentHash"));
+    }
+    const derivatives = input.derivatives;
+    const derivativeIds = new Set();
+    const derivativeHashes = new Set();
+    const parentByHash = new Map();
+    if (!Array.isArray(derivatives)) {
+        issues.push(issue("asset_derivatives_invalid", "derivatives"));
+    }
+    else {
+        for (const derivative of derivatives) {
+            if (!isRecord(derivative) || !hasOnlyKeys(derivative, [
+                "assetId", "parentContentHash", "contentHash", "transformDigest",
+            ])) {
+                issues.push(issue("asset_derivative_invalid", "derivatives"));
+                continue;
+            }
+            if (!isSemanticId(derivative.assetId))
+                issues.push(issue("derivative_asset_id_invalid", "derivatives"));
+            else if (derivativeIds.has(derivative.assetId))
+                issues.push(issue("derivative_asset_id_duplicate", "derivatives"));
+            else
+                derivativeIds.add(derivative.assetId);
+            if (!isSha256(derivative.parentContentHash)
+                || !isSha256(derivative.contentHash)
+                || !isSha256(derivative.transformDigest)) {
+                issues.push(issue("derivative_digest_invalid", "derivatives"));
+                continue;
+            }
+            if (derivativeHashes.has(derivative.contentHash) || derivative.contentHash === input.contentHash) {
+                issues.push(issue("derivative_content_hash_duplicate", "derivatives"));
+            }
+            derivativeHashes.add(derivative.contentHash);
+            parentByHash.set(derivative.contentHash, derivative.parentContentHash);
+        }
+        const knownHashes = new Set([input.contentHash, ...derivativeHashes]);
+        for (const [contentHash, parentHash] of parentByHash) {
+            if (!knownHashes.has(parentHash))
+                issues.push(issue("derivative_parent_missing", "derivatives"));
+            const visited = new Set();
+            let cursor = contentHash;
+            while (cursor !== undefined && cursor !== input.contentHash) {
+                if (visited.has(cursor)) {
+                    issues.push(issue("derivative_cycle_detected", "derivatives"));
+                    break;
+                }
+                visited.add(cursor);
+                cursor = parentByHash.get(cursor);
+                if (cursor === undefined)
+                    issues.push(issue("derivative_lineage_incomplete", "derivatives"));
+            }
+        }
+    }
+    if (issues.length > 0)
+        return failure(issues);
+    const provenance = input;
+    const normalized = {
+        ...provenance,
+        license: { ...provenance.license },
+        transforms: provenance.transforms.map((item) => ({ ...item })),
+        derivatives: provenance.derivatives.map((item) => ({ ...item }))
+            .sort((left, right) => left.assetId.localeCompare(right.assetId)),
+    };
+    const provenanceDigest = digestJsonOperacional(normalized);
+    return success({ provenance: normalized, provenanceDigest }, provenanceDigest);
+}
+const BACKGROUND_JOB_STATES = new Set(["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED"]);
+const EDITOR_MODES = new Set(["EDIT", "PLAY", "PAUSED"]);
+const PROCESS_ROLES = new Set(["ENGINE", "EDITOR", "SHADER_COMPILER", "IMPORT_WORKER", "BUILD_WORKER"]);
+const PROCESS_STATES = new Set(["IDLE", "RUNNING", "BLOCKED", "FAILED", "EXITED"]);
+function validateBackgroundJobs(value, field, issues) {
+    const ids = new Set();
+    if (!Array.isArray(value)) {
+        issues.push(issue("editor_jobs_invalid", field));
+        return;
+    }
+    for (const job of value) {
+        if (!isRecord(job)
+            || !hasOnlyKeys(job, ["jobId", "status", "progressBasisPoints"])
+            || !isSemanticId(job.jobId)
+            || typeof job.status !== "string"
+            || !BACKGROUND_JOB_STATES.has(job.status)
+            || !isIntegerIn(job.progressBasisPoints, 0, 10_000)) {
+            issues.push(issue("editor_job_invalid", field));
+            continue;
+        }
+        if (ids.has(job.jobId))
+            issues.push(issue("editor_job_id_duplicate", field));
+        ids.add(job.jobId);
+    }
+}
+export function validarEstadoEditor(input) {
+    const issues = inspectPlainJson(input, "editorState");
+    if (!isRecord(input))
+        return failure([...issues, issue("editor_state_object_required", "editorState")]);
+    if (!hasOnlyKeys(input, [
+        "schemaVersion", "editorSessionId", "adapter", "scene", "selection", "mode",
+        "unsavedChanges", "shaderJobs", "importJobs", "plugins", "modals", "processes",
+        "observedAt", "readOnly", "authoritative",
+    ]))
+        issues.push(issue("editor_state_unknown_field", "editorState"));
+    if (input.schemaVersion !== EDITOR_STATE_SCHEMA_V1)
+        issues.push(issue("editor_state_schema_invalid", "schemaVersion"));
+    if (!isSemanticId(input.editorSessionId))
+        issues.push(issue("editor_session_id_invalid", "editorSessionId"));
+    if (typeof input.mode !== "string" || !EDITOR_MODES.has(input.mode))
+        issues.push(issue("editor_mode_invalid", "mode"));
+    if (typeof input.unsavedChanges !== "boolean")
+        issues.push(issue("unsaved_changes_invalid", "unsavedChanges"));
+    if (!isIsoTimestamp(input.observedAt))
+        issues.push(issue("editor_observed_at_invalid", "observedAt"));
+    if (input.readOnly !== true)
+        issues.push(issue("editor_state_must_be_read_only", "readOnly"));
+    if (input.authoritative !== false)
+        issues.push(issue("editor_state_must_be_non_authoritative", "authoritative"));
+    if (!isRecord(input.adapter)
+        || !hasOnlyKeys(input.adapter, ["adapterId", "adapterVersion"])
+        || !isSafeName(input.adapter.adapterId)
+        || !isVersion(input.adapter.adapterVersion))
+        issues.push(issue("editor_adapter_invalid", "adapter"));
+    if (!isRecord(input.scene)
+        || !hasOnlyKeys(input.scene, ["semanticId", "artifactDigest"])
+        || !isSemanticId(input.scene.semanticId)
+        || !isSha256(input.scene.artifactDigest))
+        issues.push(issue("editor_scene_invalid", "scene"));
+    const selectionIds = new Set();
+    if (!Array.isArray(input.selection))
+        issues.push(issue("editor_selection_invalid", "selection"));
+    else
+        for (const selected of input.selection) {
+            if (!isSemanticId(selected))
+                issues.push(issue("editor_selection_id_invalid", "selection"));
+            else if (selectionIds.has(selected))
+                issues.push(issue("editor_selection_duplicate", "selection"));
+            else
+                selectionIds.add(selected);
+        }
+    validateBackgroundJobs(input.shaderJobs, "shaderJobs", issues);
+    validateBackgroundJobs(input.importJobs, "importJobs", issues);
+    const pluginIds = new Set();
+    if (!Array.isArray(input.plugins))
+        issues.push(issue("editor_plugins_invalid", "plugins"));
+    else
+        for (const plugin of input.plugins) {
+            if (!isRecord(plugin)
+                || !hasOnlyKeys(plugin, ["pluginId", "version", "enabled", "provenanceDigest"])
+                || !isSafeName(plugin.pluginId)
+                || !isVersion(plugin.version)
+                || typeof plugin.enabled !== "boolean"
+                || !isSha256(plugin.provenanceDigest)) {
+                issues.push(issue("editor_plugin_invalid", "plugins"));
+                continue;
+            }
+            if (pluginIds.has(plugin.pluginId))
+                issues.push(issue("editor_plugin_id_duplicate", "plugins"));
+            pluginIds.add(plugin.pluginId);
+        }
+    const modalIds = new Set();
+    if (!Array.isArray(input.modals))
+        issues.push(issue("editor_modals_invalid", "modals"));
+    else
+        for (const modal of input.modals) {
+            if (!isRecord(modal)
+                || !hasOnlyKeys(modal, ["modalId", "kind", "blocking"])
+                || !isSemanticId(modal.modalId)
+                || !isSafeName(modal.kind)
+                || typeof modal.blocking !== "boolean") {
+                issues.push(issue("editor_modal_invalid", "modals"));
+                continue;
+            }
+            if (modalIds.has(modal.modalId))
+                issues.push(issue("editor_modal_id_duplicate", "modals"));
+            modalIds.add(modal.modalId);
+        }
+    const processRefs = new Set();
+    if (!Array.isArray(input.processes))
+        issues.push(issue("editor_processes_invalid", "processes"));
+    else
+        for (const process of input.processes) {
+            if (!isRecord(process)
+                || !hasOnlyKeys(process, ["processRef", "role", "state"])
+                || !isOpaqueSha256(process.processRef)
+                || typeof process.role !== "string"
+                || !PROCESS_ROLES.has(process.role)
+                || typeof process.state !== "string"
+                || !PROCESS_STATES.has(process.state)) {
+                issues.push(issue("editor_process_invalid", "processes"));
+                continue;
+            }
+            if (processRefs.has(process.processRef))
+                issues.push(issue("editor_process_ref_duplicate", "processes"));
+            processRefs.add(process.processRef);
+        }
+    if (issues.length > 0)
+        return failure(issues);
+    const state = input;
+    const normalized = {
+        ...state,
+        adapter: { ...state.adapter },
+        scene: { ...state.scene },
+        selection: [...state.selection].sort(),
+        shaderJobs: state.shaderJobs.map((item) => ({ ...item })).sort((a, b) => a.jobId.localeCompare(b.jobId)),
+        importJobs: state.importJobs.map((item) => ({ ...item })).sort((a, b) => a.jobId.localeCompare(b.jobId)),
+        plugins: state.plugins.map((item) => ({ ...item })).sort((a, b) => a.pluginId.localeCompare(b.pluginId)),
+        modals: state.modals.map((item) => ({ ...item })).sort((a, b) => a.modalId.localeCompare(b.modalId)),
+        processes: state.processes.map((item) => ({ ...item })).sort((a, b) => a.processRef.localeCompare(b.processRef)),
+    };
+    const editorStateDigest = digestJsonOperacional(normalized);
+    return success({ state: normalized, editorStateDigest, externallyObserved: false }, editorStateDigest);
+}
+//# sourceMappingURL=engineObservation.js.map

package/dist/sistemasInterativos/jobOrchestration.d.ts

@@ -0,0 +1,2 @@
+import { type JobOrchestrationPlanV1, type OperationResult } from "./operationsTypes.js";
+export declare function planejarOrquestracaoJobs(input: unknown): OperationResult<JobOrchestrationPlanV1>;

package/dist/sistemasInterativos/jobOrchestration.js

@@ -0,0 +1,204 @@
+// SEMA-GOVERNED: sema.produto.sistemas_interativos.operacao.orquestracao_jobs
+// Descricao: planejamento deterministico de filas, locks, budgets, heartbeat, checkpoint e retomada.
+import { JOB_ORCHESTRATION_SCHEMA_V1, } from "./operationsTypes.js";
+import { digestJsonOperacional, failure, hasOnlyKeys, inspectPlainJson, isIntegerIn, isOpaqueSha256, isRecord, isSafeName, isSemanticId, isSha256, isVersion, issue, success, } from "./operationPrimitives.js";
+const RESOURCE_LOCKS = ["GPU", "EDITOR", "CACHE"];
+function validateBudget(value, field, issues) {
+    if (!isRecord(value)
+        || !hasOnlyKeys(value, ["ramMb", "vramMb", "diskMb"])
+        || !isIntegerIn(value.ramMb, 1, 16_777_216)
+        || !isIntegerIn(value.vramMb, 0, 16_777_216)
+        || !isIntegerIn(value.diskMb, 1, 1_073_741_824)) {
+        issues.push(issue("resource_budget_invalid", field));
+        return false;
+    }
+    return true;
+}
+export function planejarOrquestracaoJobs(input) {
+    const issues = inspectPlainJson(input, "jobRequest");
+    if (!isRecord(input))
+        return failure([...issues, issue("job_request_object_required", "jobRequest")]);
+    if (!hasOnlyKeys(input, ["schemaVersion", "queueId", "capacity", "lockCapacity", "jobs"])) {
+        issues.push(issue("job_request_unknown_field", "jobRequest"));
+    }
+    if (input.schemaVersion !== JOB_ORCHESTRATION_SCHEMA_V1)
+        issues.push(issue("job_schema_invalid", "schemaVersion"));
+    if (!isSemanticId(input.queueId))
+        issues.push(issue("queue_id_invalid", "queueId"));
+    const capacity = input.capacity;
+    const capacityValid = validateBudget(capacity, "capacity", issues);
+    const lockCapacity = input.lockCapacity;
+    if (!isRecord(lockCapacity)
+        || !hasOnlyKeys(lockCapacity, RESOURCE_LOCKS)
+        || !RESOURCE_LOCKS.every((lock) => isIntegerIn(lockCapacity[lock], 0, 1))) {
+        issues.push(issue("lock_capacity_invalid", "lockCapacity"));
+    }
+    const jobs = input.jobs;
+    const ids = new Set();
+    if (!Array.isArray(jobs) || jobs.length === 0) {
+        issues.push(issue("jobs_required", "jobs"));
+    }
+    else {
+        for (const job of jobs) {
+            if (!isRecord(job) || !hasOnlyKeys(job, [
+                "jobId", "kind", "priority", "dependencies", "locks", "budget",
+                "heartbeat", "checkpoint", "adapter",
+            ])) {
+                issues.push(issue("job_invalid", "jobs"));
+                continue;
+            }
+            if (!isSemanticId(job.jobId))
+                issues.push(issue("job_id_invalid", "jobs"));
+            else if (ids.has(job.jobId))
+                issues.push(issue("job_id_duplicate", "jobs"));
+            else
+                ids.add(job.jobId);
+            if (!isSafeName(job.kind))
+                issues.push(issue("job_kind_invalid", "jobs"));
+            if (!isIntegerIn(job.priority, 0, 100))
+                issues.push(issue("job_priority_invalid", "jobs"));
+            if (!Array.isArray(job.dependencies)
+                || job.dependencies.some((dependency) => !isSemanticId(dependency))
+                || new Set(job.dependencies).size !== job.dependencies.length
+                || job.dependencies.includes(job.jobId))
+                issues.push(issue("job_dependencies_invalid", "jobs"));
+            if (!Array.isArray(job.locks)
+                || job.locks.some((lock) => typeof lock !== "string" || !RESOURCE_LOCKS.includes(lock))
+                || new Set(job.locks).size !== job.locks.length)
+                issues.push(issue("job_locks_invalid", "jobs"));
+            const budget = job.budget;
+            const budgetValid = validateBudget(budget, "jobs", issues);
+            if (budgetValid && capacityValid
+                && (budget.ramMb > capacity.ramMb
+                    || budget.vramMb > capacity.vramMb
+                    || budget.diskMb > capacity.diskMb))
+                issues.push(issue("job_budget_exceeds_capacity", "jobs"));
+            if (Array.isArray(job.locks) && isRecord(lockCapacity)) {
+                for (const lock of job.locks) {
+                    if (typeof lock === "string"
+                        && RESOURCE_LOCKS.includes(lock)
+                        && lockCapacity[lock] !== 1)
+                        issues.push(issue("job_lock_unavailable", "jobs"));
+                }
+                if (job.locks.includes("GPU") && isRecord(job.budget) && job.budget.vramMb === 0) {
+                    issues.push(issue("gpu_job_requires_vram", "jobs"));
+                }
+            }
+            if (!isRecord(job.heartbeat)
+                || !hasOnlyKeys(job.heartbeat, ["intervalMs", "timeoutMs"])
+                || !isIntegerIn(job.heartbeat.intervalMs, 100, 86_400_000)
+                || !isIntegerIn(job.heartbeat.timeoutMs, 100, 86_400_000)
+                || (typeof job.heartbeat.intervalMs === "number"
+                    && typeof job.heartbeat.timeoutMs === "number"
+                    && job.heartbeat.timeoutMs < job.heartbeat.intervalMs * 2))
+                issues.push(issue("job_heartbeat_invalid", "jobs"));
+            if (!isRecord(job.checkpoint)
+                || !hasOnlyKeys(job.checkpoint, ["intervalMs", "resume", "checkpointDigest", "recoveryToken"])
+                || !isIntegerIn(job.checkpoint.intervalMs, 100, 86_400_000)
+                || typeof job.checkpoint.resume !== "boolean"
+                || !isOpaqueSha256(job.checkpoint.recoveryToken)
+                || (job.checkpoint.checkpointDigest !== undefined && !isSha256(job.checkpoint.checkpointDigest))
+                || (job.checkpoint.resume === true && !isSha256(job.checkpoint.checkpointDigest))) {
+                issues.push(issue("job_checkpoint_invalid", "jobs"));
+            }
+            if (!isRecord(job.adapter)
+                || !hasOnlyKeys(job.adapter, ["adapterId", "adapterVersion"])
+                || !isSafeName(job.adapter.adapterId)
+                || !isVersion(job.adapter.adapterVersion))
+                issues.push(issue("job_adapter_invalid", "jobs"));
+        }
+        for (const job of jobs) {
+            if (!isRecord(job) || !Array.isArray(job.dependencies))
+                continue;
+            for (const dependency of job.dependencies) {
+                if (typeof dependency === "string" && !ids.has(dependency))
+                    issues.push(issue("job_dependency_missing", "jobs"));
+            }
+        }
+    }
+    if (issues.length > 0)
+        return failure(issues);
+    const request = input;
+    const byId = new Map(request.jobs.map((job) => [job.jobId, job]));
+    const indegree = new Map(request.jobs.map((job) => [job.jobId, job.dependencies.length]));
+    const dependents = new Map();
+    for (const job of request.jobs)
+        for (const dependency of job.dependencies) {
+            const list = dependents.get(dependency) ?? [];
+            list.push(job.jobId);
+            dependents.set(dependency, list);
+        }
+    const compareJobs = (leftId, rightId) => {
+        const left = byId.get(leftId);
+        const right = byId.get(rightId);
+        return right.priority - left.priority || left.jobId.localeCompare(right.jobId);
+    };
+    const ready = request.jobs.filter((job) => job.dependencies.length === 0)
+        .map((job) => job.jobId).sort(compareJobs);
+    const ordered = [];
+    while (ready.length > 0) {
+        const id = ready.shift();
+        ordered.push(byId.get(id));
+        for (const dependent of (dependents.get(id) ?? []).sort()) {
+            const next = (indegree.get(dependent) ?? 0) - 1;
+            indegree.set(dependent, next);
+            if (next === 0) {
+                ready.push(dependent);
+                ready.sort(compareJobs);
+            }
+        }
+    }
+    if (ordered.length !== request.jobs.length)
+        return failure([issue("job_dependency_cycle", "jobs")]);
+    const normalizedRequest = {
+        schemaVersion: request.schemaVersion,
+        queueId: request.queueId,
+        capacity: { ...request.capacity },
+        lockCapacity: Object.fromEntries(RESOURCE_LOCKS.map((lock) => [lock, request.lockCapacity[lock]])),
+        jobs: request.jobs.map((job) => ({
+            jobId: job.jobId,
+            kind: job.kind,
+            priority: job.priority,
+            dependencies: [...job.dependencies].sort(),
+            locks: [...job.locks].sort((a, b) => RESOURCE_LOCKS.indexOf(a) - RESOURCE_LOCKS.indexOf(b)),
+            budget: { ...job.budget },
+            heartbeat: { ...job.heartbeat },
+            checkpoint: {
+                intervalMs: job.checkpoint.intervalMs,
+                resume: job.checkpoint.resume,
+                ...(job.checkpoint.checkpointDigest === undefined ? {} : { checkpointDigest: job.checkpoint.checkpointDigest }),
+                recoveryToken: job.checkpoint.recoveryToken,
+            },
+            adapter: { ...job.adapter },
+        })).sort((left, right) => left.jobId.localeCompare(right.jobId)),
+    };
+    const requestDigest = digestJsonOperacional(normalizedRequest);
+    const queue = ordered.map((job, index) => ({
+        position: index + 1,
+        jobId: job.jobId,
+        kind: job.kind,
+        priority: job.priority,
+        adapter: { ...job.adapter },
+        dependencies: [...job.dependencies].sort(),
+        locks: [...job.locks].sort((a, b) => RESOURCE_LOCKS.indexOf(a) - RESOURCE_LOCKS.indexOf(b)),
+        budget: { ...job.budget },
+        heartbeatIntervalMs: job.heartbeat.intervalMs,
+        heartbeatTimeoutMs: job.heartbeat.timeoutMs,
+        checkpointIntervalMs: job.checkpoint.intervalMs,
+        resume: job.checkpoint.resume,
+        ...(job.checkpoint.checkpointDigest === undefined ? {} : { checkpointDigest: job.checkpoint.checkpointDigest }),
+        recoveryToken: job.checkpoint.recoveryToken,
+    }));
+    const withoutDigest = {
+        schemaVersion: JOB_ORCHESTRATION_SCHEMA_V1,
+        queueId: request.queueId,
+        queue,
+        requestDigest,
+        externalRunnerRequired: true,
+        resourcesReserved: false,
+        authoritative: false,
+    };
+    const plan = { ...withoutDigest, planDigest: digestJsonOperacional(withoutDigest) };
+    return success(plan, plan.planDigest);
+}
+//# sourceMappingURL=jobOrchestration.js.map

package/dist/sistemasInterativos/operationPrimitives.d.ts

@@ -0,0 +1,21 @@
+import { type OpaqueSha256, type OperationIssue, type OperationResult, type Sha256 } from "./operationsTypes.js";
+export declare const MEDIA_TYPE_PATTERN: RegExp;
+export declare function issue(code: string, field: string): OperationIssue;
+export declare function failure<T>(issues: readonly OperationIssue[]): OperationResult<T>;
+export declare function success<T>(value: T, digest?: Sha256): OperationResult<T>;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isSha256(value: unknown): value is Sha256;
+export declare function isOpaqueSha256(value: unknown): value is OpaqueSha256;
+export declare function isSemanticId(value: unknown): value is string;
+export declare function isSafeName(value: unknown): value is string;
+export declare function isVersion(value: unknown): value is string;
+export declare function isIsoTimestamp(value: unknown): value is string;
+export declare function isIntegerIn(value: unknown, minimum: number, maximum: number): value is number;
+export declare function hasOnlyKeys(value: Record<string, unknown>, allowed: readonly string[]): boolean;
+export declare function inspectPlainJson(input: unknown, rootField: string): OperationIssue[];
+export declare function canonicalJson(value: unknown): string;
+export declare function digestJsonOperacional(value: unknown): Sha256;
+export declare function criarReferenciaFonteOpaca(sourceUri: unknown): OperationResult<{
+    readonly sourceUriRef: OpaqueSha256;
+    readonly sourceUriRedacted: true;
+}>;