@orkastery/cli 0.5.3 → 0.6.0

package/dist/noctum-maquinas.js

@@ -0,0 +1,383 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fatosLocaisDaMaquina = fatosLocaisDaMaquina;
+exports.reconciliarMaquina = reconciliarMaquina;
+exports.passoDaMaquina = passoDaMaquina;
+/**
+ * RM-058, fatia N3 (D10 a D14 da ork-rm058n3): o passo de uma máquina num arco #Noctum entre máquinas.
+ *
+ * Com o envelope `v1` ou `v2`, o passo é o da N2, como está. Com a `v3`, sob a trava `.orkastery/noctum/maquina.lock` (um
+ * passo de máquina por raiz de estado), a máquina:
+ *
+ * 1. reconcilia o que é dela: primeiro a vez de integrar (o merge provado que chegou à base vira entrega, sem integrar de
+ *    novo; o que chegou fora da base provada espera a inspeção), depois as ordens (conclui pela thread local, encerra a
+ *    vencida sem sessão viva) e as vagas (pelo desfecho local do despacho), e solta a reserva do arco nos itens sem ordem
+ *    viva dela. Com o arco revogado aqui, a revogação vai ao ramo e vale em todas; fora do envelope vigente (uma emenda a
+ *    tirou), o passo para aqui: ela só fecha o que é dela;
+ * 2. assume a autoridade quando o arco ainda não tem uma (a primeira vence pela troca atômica), bate e, sendo a
+ *    autoridade, abandona a vez de integrar de quem não dá sinal e distribui as ordens dos trabalhos livres, com as
+ *    reservas lidas agora (o item reservado fora do arco espera);
+ * 3. com o arco vigente nela, responde as ordens emitidas para ela (aceita ou recusa, com o motivo; antes de a janela
+ *    abrir aqui, a ordem fica emitida) e toma a reserva da RM-047 de cada ordem aceita, revalidada com leitura nova;
+ *    reserva de fora, ou item que o roadmap daqui não tem, encerra a ordem que nunca despachou;
+ * 4. chama o passo da N2 só com os trabalhos das ordens aceitas e vivas, a reserva revalidada agora e a vaga global tomada
+ *    no gancho `reservar` da coordenação, depois da reserva local: a sessão só começa se a máquina e a soma das máquinas
+ *    admitirem.
+ *
+ * Sem leitura nova do ramo, nada disso acontece e o passo espera (D7). Ninguém chama este passo ainda: o vigia é da N4,
+ * que usa a mesma interface para a retomada em outra máquina.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const estado_thread_1 = require("./estado-thread");
+const fila_pesada_1 = require("./fila-pesada");
+const ledger_1 = require("./ledger");
+const maquina_1 = require("./maquina");
+const noctum_arco_1 = require("./noctum-arco");
+const noctum_capacidade_1 = require("./noctum-capacidade");
+const noctum_coordenacao_1 = require("./noctum-coordenacao");
+const noctum_envelope_1 = require("./noctum-envelope");
+const noctum_execucao_1 = require("./noctum-execucao");
+const noctum_integracao_1 = require("./noctum-integracao");
+const noctum_transporte_1 = require("./noctum-transporte");
+const roadmap_reservas_1 = require("./roadmap-reservas");
+const runtime_profiles_1 = require("./runtime-profiles");
+const thread_1 = require("./thread");
+/** Quanto o passo espera a vez de outro passo desta máquina antes de devolver `aguardar`. */
+const ESPERA_DA_VEZ_DA_MAQUINA_MS = 30_000;
+const primeiraLinha = (e) => String(e?.message ?? e).split('\n')[0].slice(0, 300);
+const pausa = new Int32Array(new SharedArrayBuffer(4));
+/** A trava do passo da máquina: um passo por raiz de estado, para duas reconciliações não soltarem a mesma coisa. */
+function vezDaMaquina(raiz, esperarMs) {
+    const principal = (0, estado_thread_1.raizDoEstado)(raiz);
+    (0, estado_thread_1.exigirEstadoSemLink)(principal, ['.orkastery', 'noctum']);
+    const dir = path.join(principal, '.orkastery', 'noctum');
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const prazo = Date.now() + esperarMs;
+    for (;;) {
+        const fd = (0, fila_pesada_1.tentarTravaExclusiva)(path.join(dir, 'maquina.lock'));
+        if (fd !== null || Date.now() >= prazo)
+            return fd;
+        Atomics.wait(pausa, 0, 0, 200);
+    }
+}
+/** Os perfis do store que podem receber despacho agora, como no passo da N2; store ilegível é nenhum perfil. */
+function perfisDoStore(raiz, agoraMs) {
+    try {
+        return (0, runtime_profiles_1.lerPerfis)(raiz).perfis.filter(p => (0, runtime_profiles_1.perfilDisponivel)(p, agoraMs)).map(p => ({ id: p.id, runtime: p.runtime }));
+    }
+    catch {
+        return [];
+    }
+}
+/** A thread local de um trabalho: a do `thread`, ou a única que casa com o item e o sha256 do pedido. */
+function threadDoTrabalho(raiz, t) {
+    try {
+        if (t.thread)
+            return (0, thread_1.lerThread)(raiz, t.thread);
+        const sha = (0, noctum_envelope_1.shaDoPedido)(t.pedido ?? '');
+        const casam = [];
+        for (const id of (0, thread_1.listarIds)(raiz)) {
+            try {
+                const th = (0, thread_1.lerThread)(raiz, id);
+                if (th.roadmap === t.item && th.pedido?.sha256 === sha)
+                    casam.push(th);
+            }
+            catch { /* ilegível não decide */ }
+        }
+        return casam.length === 1 ? casam[0] : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * O que esta máquina sabe de si para reconciliar: a janela do arco, o desfecho local de cada reserva de despacho, as
+ * sessões que ocupam agora (com lacuna, `null`: incerta é viva) e a thread local de cada trabalho.
+ */
+function fatosLocaisDaMaquina(carregado, arco, estado, quando, consultar) {
+    const { raiz } = carregado;
+    const local = (0, noctum_arco_1.lerArco)(raiz, arco, quando);
+    let sessoesVivas;
+    try {
+        const cap = (0, noctum_capacidade_1.fatosDeCapacidade)(carregado, { quando, consultar });
+        sessoesVivas = cap.lacunas.length ? null : new Set(cap.ocupantes.map(o => o.sessionId).filter((x) => !!x));
+    }
+    catch {
+        sessoesVivas = null;
+    }
+    const threads = new Map();
+    // Os trabalhos de todas as versões autorizadas: a ordem de uma versão anterior também conclui pela thread local (A4).
+    const trabalhos = new Map();
+    for (const v of estado.versoes)
+        for (const t of v.conteudo.trabalhos ?? [])
+            trabalhos.set(t.id, t);
+    for (const t of trabalhos.values()) {
+        const th = threadDoTrabalho(raiz, t);
+        if (!th)
+            continue;
+        let entregue = false;
+        try {
+            entregue = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, th.id)).some(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.shipConcluido);
+        }
+        catch {
+            continue;
+        }
+        threads.set(t.id, { id: th.id, entregue, fechada: th.status === 'fechada' });
+    }
+    return { arcoVigente: local?.situacao === 'vigente', sessoesVivas, threads,
+        despachos: new Map((local?.despachos ?? []).map(d => [d.seq, { desfecho: d.desfecho, sessionId: d.sessionId, idempotente: d.idempotente }])) };
+}
+/**
+ * A reconciliação desta máquina, na volta ou a cada passo: a integração primeiro (o merge que chegou à base vira entrega
+ * sem integrar de novo, e só então a ordem dela pode encerrar), depois as ordens e as vagas, e por fim as reservas do arco
+ * nos itens sem ordem viva desta máquina. Lança a recusa tipada da leitura (sem remoto, adulterado).
+ */
+function reconciliarMaquinaComTravaTomada(carregado, arco, opcoes) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const integracao = (0, noctum_integracao_1.reconciliarIntegracao)(carregado, arco, opcoes);
+    const estado = (0, noctum_coordenacao_1.lerCoordenacao)(carregado, arco, opcoes);
+    const fatos = { ...fatosLocaisDaMaquina(carregado, arco, estado, quando, opcoes.consultarSessoes),
+        vezesConferidas: new Set(integracao.abandonadasConferidas), vezesSemProva: new Set(integracao.semProva) };
+    const reconciliacao = (0, noctum_coordenacao_1.reconciliarCoordenacao)(carregado, arco, fatos, opcoes);
+    const reservasSoltas = [];
+    const eu = (0, roadmap_reservas_1.quemSouEu)(carregado.raiz, { maquina: opcoes.maquina });
+    let painel;
+    try {
+        painel = (0, roadmap_reservas_1.listarReservas)(carregado.raiz, { remoto: opcoes.remoto ?? carregado.manifesto.fabrica.remoto, rede: opcoes.rede });
+    }
+    catch {
+        painel = null;
+    }
+    if (painel?.atualizado) {
+        const soltar = painel.reservas.filter(r => r.maquina === eu.maquina && r.por === eu.por && r.nota === (0, noctum_coordenacao_1.notaDaReserva)(arco) &&
+            reconciliacao.itensSemOrdemViva.includes(r.item));
+        for (const r of soltar) {
+            try {
+                if ((0, noctum_coordenacao_1.soltarReservaDoArco)(carregado, arco, r.item, opcoes))
+                    reservasSoltas.push(r.item);
+            }
+            catch { /* fica para o passo seguinte */ }
+        }
+    }
+    return { integracao, reconciliacao, reservasSoltas };
+}
+/** A retomada exportada toma a mesma trava do passo; assim, N4 e o passo nunca reconciliam esta máquina em paralelo. */
+function reconciliarMaquina(carregado, arco, opcoes = {}) {
+    if (!(0, fila_pesada_1.kernelDisponivel)())
+        throw new noctum_envelope_1.RecusaDoArco('noctum.coordenacao.concorrencia', 'sem /usr/bin/flock não há a trava da máquina, e a reconciliação não roda');
+    const trava = vezDaMaquina(carregado.raiz, 0);
+    if (trava === null)
+        throw new noctum_envelope_1.RecusaDoArco('noctum.coordenacao.concorrencia', 'outro passo ou reconciliação desta máquina está em curso');
+    try {
+        return reconciliarMaquinaComTravaTomada(carregado, arco, opcoes);
+    }
+    finally {
+        fs.closeSync(trava);
+    }
+}
+const aguardar = (motivo, detalhe, relatorio) => ({ acao: 'aguardar', motivo, detalhe, relatorio });
+/**
+ * Um passo desta máquina no arco. Com o envelope `v3`, coordena pelo ramo e chama o passo da N2 com a ordem, a reserva e a
+ * vaga global; com `v1` ou `v2`, é o passo da N2 como está. Toda recusa tipada da coordenação volta como `aguardar`.
+ */
+function passoDaMaquina(carregado, arco, opcoes = {}) {
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const { raiz } = carregado;
+    const local = (0, noctum_arco_1.lerArco)(raiz, arco, quando);
+    if (!local?.conteudo || !(0, noctum_envelope_1.envelopeMultimaquina)(local.conteudo)) {
+        return { acao: 'uma-maquina', passo: (0, noctum_execucao_1.passoDoArco)(carregado, arco, { ...opcoes.n2, quando, maquina: opcoes.maquina }) };
+    }
+    const eu = (0, maquina_1.nomeDaMaquina)(opcoes.maquina);
+    const relatorio = { maquina: eu, autoridade: null, integracao: null, reconciliacao: null, reservasSoltas: [],
+        ordensEmitidas: [], vezesAbandonadas: [], respostas: [], reservas: [], trabalhos: [] };
+    if (!(0, fila_pesada_1.kernelDisponivel)())
+        return aguardar('sem-trava-do-kernel', 'o arco entre máquinas só anda com /usr/bin/flock', relatorio);
+    const trava = vezDaMaquina(raiz, ESPERA_DA_VEZ_DA_MAQUINA_MS);
+    if (trava === null)
+        return aguardar('noctum.coordenacao.concorrencia', 'outro passo desta máquina está em curso', relatorio);
+    const op = { remoto: opcoes.remoto, maquina: opcoes.maquina, quando, rede: opcoes.rede };
+    try {
+        // 1. A reconciliação do que é desta máquina; vale até fora do envelope vigente e com o arco revogado.
+        const rec = reconciliarMaquinaComTravaTomada(carregado, arco, { ...op, consultarSessoes: opcoes.consultarSessoes ?? opcoes.n2?.consultarSessoes });
+        Object.assign(relatorio, { integracao: rec.integracao, reconciliacao: rec.reconciliacao, reservasSoltas: rec.reservasSoltas });
+        let estado = (0, noctum_coordenacao_1.lerCoordenacao)(carregado, arco, op);
+        relatorio.autoridade = estado.autoridade;
+        const c = estado.vigente.conteudo;
+        const chave = (0, noctum_transporte_1.identidadeDaMaquina)(raiz, opcoes.maquina).chave;
+        // S1 da rodada 2: a revogação do dono vai ao ramo antes de tudo, também da máquina que uma emenda tirou do arco (ela
+        // assina sob a última versão em que estava, como o resto do que fecha).
+        if (local.situacao === 'revogado') {
+            (0, noctum_coordenacao_1.revogarNaRede)(carregado, arco, op);
+            return aguardar('noctum.efeito.revogado', `o arco ${arco} foi revogado pelo dono nesta máquina; a revogação foi ao ramo e vale nas outras`, relatorio);
+        }
+        if (!(0, noctum_envelope_1.envelopeMultimaquina)(c) || !c.maquinas.some(m => m.nome === eu && m.chave === chave)) {
+            return aguardar('noctum.coordenacao.fora-do-envelope', `a máquina ${eu} não está no envelope vigente do arco; ela só fecha o que é dela`, relatorio);
+        }
+        if (estado.revogada) {
+            return aguardar('noctum.coordenacao.revogada', `o arco ${arco} foi revogado na máquina ${estado.revogada.por}; esta só fecha o que é dela`, relatorio);
+        }
+        // 2. A autoridade vaga, a batida, o abandono da vez de quem não dá sinal e a distribuição, com as reservas lidas agora.
+        if (!estado.autoridade && local.situacao === 'vigente') {
+            try {
+                (0, noctum_coordenacao_1.assumirAutoridade)(carregado, arco, op);
+            }
+            catch (e) {
+                if (!(e instanceof noctum_envelope_1.RecusaDoArco) || e.motivo !== 'noctum.coordenacao.autoridade-ativa')
+                    throw e;
+            }
+        }
+        const quem = (0, roadmap_reservas_1.quemSouEu)(raiz, { maquina: opcoes.maquina });
+        let painel;
+        try {
+            painel = (0, roadmap_reservas_1.listarReservas)(raiz, { remoto: op.remoto ?? carregado.manifesto.fabrica.remoto, rede: op.rede });
+        }
+        catch {
+            painel = null;
+        }
+        const vistas = painel?.atualizado ? (0, noctum_coordenacao_1.vistasDasReservas)(painel.reservas) : null;
+        const distribuicao = (0, noctum_coordenacao_1.gravarNaCoordenacao)(carregado, arco, op, (leitura) => {
+            const e = (0, noctum_coordenacao_1.derivarCoordenacao)(leitura);
+            // Sem a leitura das reservas, nenhuma ordem sai: o item reservado fora do arco iria e voltaria.
+            const ordens = local.situacao === 'vigente' && vistas ? (0, noctum_coordenacao_1.registrosDaDistribuicao)(e, eu, quando, vistas) : [];
+            const abandonos = (0, noctum_coordenacao_1.registrosDosAbandonos)(e, eu, quando);
+            // A2 da revisão do merge com a N6: a máquina em que o fechamento encerrou o arco para de bater. Sem sinal há mais de 15
+            // min, a autoridade não manda mais ordem para ela, e a tomada forçada da autoridade dela passa a valer.
+            const batida = local.situacao === 'encerrado' ? [] : [{ tipo: 'batida' }];
+            return { novos: [...batida, ...abandonos, ...ordens],
+                resultado: { ordens: ordens.map(o => String(o.ordem)), abandonos: abandonos.map(x => `${String(x.chave)}/${String(x.n)}`) } };
+        });
+        relatorio.ordensEmitidas = distribuicao.resultado.ordens;
+        relatorio.vezesAbandonadas = distribuicao.resultado.abandonos;
+        // 3. As respostas às ordens desta máquina e as reservas das aceitas: o item que outra máquina ou pessoa reservou é
+        // recusado de saída, e a reserva que já é desta máquina está revalidada pela leitura de agora.
+        const threadsLocais = new Map();
+        for (const id of (0, thread_1.listarIds)(raiz)) {
+            try {
+                const th = (0, thread_1.lerThread)(raiz, id);
+                threadsLocais.set(id, { roadmap: th.roadmap ?? null, modo: th.modo });
+            }
+            catch { /* ilegível não é aceita */ }
+        }
+        const itensDeOutros = painel?.atualizado
+            ? new Set(painel.reservas.filter(r => r.maquina !== quem.maquina || r.por !== quem.por).map(r => r.item)) : undefined;
+        // A-R2A-3 da rodada 2: com o arco ainda não vigente aqui (o relógio daqui atrás do da autoridade, na borda da janela), a
+        // máquina não responde: a ordem fica emitida até a janela abrir, em vez de virar recusa que a exclui nesta versão. Com o
+        // arco encerrado aqui pela N6, que é terminal, ela recusa o que chegar, e o trabalho vai a outra máquina (A2 da revisão).
+        const respostas = (0, noctum_coordenacao_1.gravarNaCoordenacao)(carregado, arco, op, (leitura) => {
+            const novos = local.situacao === 'vigente' || local.situacao === 'encerrado'
+                ? (0, noctum_coordenacao_1.registrosDasRespostas)((0, noctum_coordenacao_1.derivarCoordenacao)(leitura), eu, { arcoVigente: local.situacao === 'vigente', arcoEncerrado: local.situacao === 'encerrado', threadsLocais, itensDeOutros })
+                : [];
+            return { novos, resultado: novos.map(r => ({ ordem: String(r.ordem), recibo: String(r.recibo), motivo: String(r.motivo) })) };
+        });
+        relatorio.respostas = respostas.resultado;
+        estado = (0, noctum_coordenacao_1.lerCoordenacao)(carregado, arco, op);
+        relatorio.autoridade = estado.autoridade;
+        const minhas = [...estado.ordens.values()].filter(o => o.maquina === eu && o.estado === 'aceita' && o.envelopeSha256 === estado.vigente.envelopeSha256);
+        const reservadas = [];
+        const permitidos = new Set();
+        for (const o of minhas) {
+            const t = estado.vigente.conteudo.trabalhos.find(x => x.id === o.trabalho);
+            const thread = threadDoTrabalho(raiz, t)?.id ?? null;
+            const atual = painel?.atualizado ? painel.reservas.find(x => x.item === o.item) : undefined;
+            // A thread da reserva é informativa: renovar a cada passo por ela só faria commit novo no ramo de reservas.
+            const jaMinha = !!atual && atual.maquina === quem.maquina && atual.por === quem.por;
+            const r = !painel?.atualizado ? { ok: false, motivo: 'noctum.coordenacao.sem-remoto', detalhe: 'as reservas não se leram agora' }
+                : jaMinha ? { ok: true, acao: 'revalidada' } : (0, noctum_coordenacao_1.tomarReservaDoTrabalho)(carregado, arco, o.ordem, thread, op);
+            relatorio.reservas.push({ ordem: o.ordem, item: o.item, ok: r.ok, motivo: r.ok ? null : r.motivo });
+            if (r.ok) {
+                permitidos.add(o.trabalho);
+                if (!reservadas.some(x => x.item === o.item))
+                    reservadas.push({ item: o.item, thread });
+                continue;
+            }
+            // A reserva de outra máquina ou pessoa, ou o item que o roadmap daqui não tem: a ordem que nunca despachou acaba aqui,
+            // com o motivo tipado e só o item (o nome de quem reservou nunca vai ao ramo); a que tem vaga fica.
+            if (r.motivo !== 'noctum.coordenacao.sem-remoto' && !estado.vagas.some(v => v.ordem === o.ordem)) {
+                const motivo = r.motivo === 'noctum.reserva.item-invalido'
+                    ? `noctum.reserva.item-invalido: o item ${o.item} não está no roadmap desta máquina` : (0, noctum_coordenacao_1.motivoDaReservaDeFora)(o.item);
+                try {
+                    (0, noctum_coordenacao_1.encerrarOrdem)(carregado, arco, o.ordem, { motivo, checkpoint: { thread, vagasSoltas: [] } }, op);
+                }
+                catch (e) {
+                    // N1 do CHECK-REVERIFY do GO-FIX 8: a ordem cuja vez de integrar ainda não tem prova espera a reconciliação (ou a
+                    // inspeção do dono), e o passo segue com as outras ordens desta máquina.
+                    if (!(e instanceof noctum_envelope_1.RecusaDoArco) || (e.motivo !== 'noctum.integracao.nao-provada' && e.motivo !== 'noctum.integracao.base-nao-provada'))
+                        throw e;
+                }
+            }
+        }
+        relatorio.trabalhos = [...permitidos].sort();
+        // A conta sem vaga global agora não entra na escolha da N2, para o despacho sair por outra que tenha (a vaga do gancho
+        // continua sendo a conferência de verdade). Sem nenhuma, o passo espera a vaga em vez de despachar para ouvir a recusa.
+        const semVaga = (0, noctum_coordenacao_1.contasSemVagaGlobal)(estado);
+        const cv = estado.vigente.conteudo;
+        if (permitidos.size && (0, noctum_envelope_1.envelopeMultimaquina)(cv) && cv.capacidadeGlobal.porConta.every(x => semVaga.has(x.conta))) {
+            return aguardar('noctum.coordenacao.vaga-global', 'nenhuma conta do envelope tem vaga somando as máquinas agora', relatorio);
+        }
+        const perfisDaN2 = opcoes.n2?.perfis ?? (() => perfisDoStore(raiz, Date.parse(quando)));
+        // 4. O passo da N2, só com o que o ramo deu a esta máquina, e a vaga global no gancho da reserva da coordenação.
+        const ordemDoTrabalho = new Map(minhas.filter(o => permitidos.has(o.trabalho)).map(o => [o.trabalho, o.ordem]));
+        const reservar = (raizDoPasso, pedido, q) => {
+            const ordem = ordemDoTrabalho.get(pedido.trabalho);
+            if (!ordem)
+                throw new noctum_envelope_1.RecusaDoArco('noctum.coordenacao.ordem-vencida', `o trabalho ${pedido.trabalho} não tem ordem aceita desta máquina`);
+            const r = (0, noctum_arco_1.reservarDespacho)(raizDoPasso, pedido, q);
+            try {
+                (0, noctum_coordenacao_1.tomarVagaGlobal)(carregado, arco, { ordem, conta: pedido.conta, runtime: pedido.runtime, reserva: r.seq }, { ...op, quando: q });
+            }
+            catch (e) {
+                const recusa = e instanceof noctum_envelope_1.RecusaDoArco ? e : new noctum_envelope_1.RecusaDoArco('noctum.coordenacao.sem-remoto', primeiraLinha(e));
+                (0, noctum_arco_1.concluirDespacho)(raizDoPasso, arco, r.seq, { motivo: recusa.motivo });
+                throw recusa;
+            }
+            return r;
+        };
+        const passo = (0, noctum_execucao_1.passoDoArco)(carregado, arco, { ...opcoes.n2, quando, maquina: opcoes.maquina,
+            perfis: () => perfisDaN2().filter(p => !semVaga.has(p.id)),
+            lerReservas: () => ({ leitura: 'copia-local', reservas: reservadas.map(x => ({ item: x.item, maquina: eu, thread: x.thread })) }),
+            coordenacao: { trabalhos: permitidos, entregues: (0, noctum_coordenacao_1.entreguesNaRede)(estado), encerrados: (0, noctum_coordenacao_1.encerradosNaRede)(estado), reservar } });
+        return { acao: 'passo', passo, relatorio };
+    }
+    catch (e) {
+        if (!(e instanceof noctum_envelope_1.RecusaDoArco))
+            throw e;
+        return aguardar(e.motivo, e.message, relatorio);
+    }
+    finally {
+        fs.closeSync(trava);
+    }
+}