@casecore/release-agent 0.1.3 → 0.1.6

package/README.md

@@ -13,7 +13,7 @@
 ## Подключение
 
 ```sh
-pnpm add --save-exact @casecore/release-agent@0.1.0
+pnpm add --save-exact @casecore/release-agent@0.1.6
 ```
 
 В проекте фиксируются точная версия и `pnpm-lock.yaml`. Поддерживается Node.js
@@ -140,6 +140,12 @@ Alvori — `release-control-source.json`. Для старого формата A
 в миллисекундах UTC и доверенный `acquireGuard(command, context)`.
 Срок восстановления ограничен 30 секундами и не меняет исходные T0 и deadline.
 
+Начиная с SDK 0.1.4, `tenantId`, `workspaceId` и `parentRunId` принимают
+каноническую запись UUID из PostgreSQL без ограничения битов версии и варианта.
+`operationGeneration` сохраняет строгую проверку сгенерированного UUID.
+Значения области доступа не преобразуются: факт должен точно совпасть
+с удержанным контекстом и каноническим владением CaseCore.
+
 Адаптер удерживает общую блокировку приёма, worker, конфигурации и публикации;
 подтверждает остановку всех исходных обработчиков и операций; исключает поздний
 приём; проверяет отсутствие команды в том же защищённом журнале и получает
@@ -275,3 +281,45 @@ RELEASE_AGENT_TARBALL=/absolute/path/casecore-release-agent-0.1.0.tgz \
 
 Запуск проверок и сборок должен учитывать действующее разрешение владельца задачи;
 наличие команд и тестов не является подтверждением их успешного выполнения.
+
+## Завершение исходной попытки публикации
+
+Начиная с 0.1.6 адаптер может реализовать `publicationTerminal(command, context)`.
+Движок вызывает его после сохранения подтверждённого результата `deployed` либо
+штатного `failed` до установки. Адаптер закрывает свой исходный журнал под своей
+блокировкой; общий движок и исходные часы выполнения остаются единственными.
+
+`readPublicationTerminalAuthority(context.authority, context.bindings)` возвращает
+подтверждённый результат с точной исходной командой, исполнителем, кандидатом и
+исходными часами. Поле `artifactIdentity` отдельно хранит подписанную идентичность
+артефакта: её SHA может отличаться от SHA исходных изменений. Authority действует
+только внутри ограниченного 30 секундами callback; скопированный объект, snapshot
+или digest полномочия не дают. Перед записью адаптер проверяет `context.signal`.
+
+Ошибка callback сохраняет фактический результат установки и записывается в
+диагностику; она не подтверждает закрытие исходного журнала. Повторный
+`reconcile(commandId)` и восстановление после перезапуска получают новое
+полномочие только после свежей независимой проверки production либо штатного
+восстановления FAILED с native ACK. Запись адаптера должна быть идемпотентной для
+той же исходной попытки. Публикация 0.1.6 и обновление установок проверяются отдельно
+от локальной готовности этого исходного контракта.
+
+Для первой установки уже собранного артефакта тот же callback вызывается с
+`bindings.action: 'deploy'`. Его `repository` и `ref` берутся из сохранённого
+артефактного кандидата; исходные шесть полей `delivery` остаются неизменными.
+Адаптер обязан реализовать `verifyArtifactDelivery(command, identity, delivery,
+source, context)` и подтвердить подпись, исходную операцию и происхождение
+артефакта. `context.completedAt` — сохранённое время завершения установки.
+Повторное подтверждение после истечения срока проверяет этот результат и свежий
+production readback; новую установку или продление срока оно не разрешает.
+
+`await sealPublicationTerminalReceipt(authority, bindings, managementToken)`
+сохраняет заверенный результат в существующем журнале движка перед возвратом.
+`verifyPublicationTerminalReceipt(receipt, managementToken)` проверяет HMAC и
+возвращает данные, которые не являются authority. Токен управления уже должен
+быть настроен у обоих участников; передавать его с результатом нельзя.
+Авторизованный `GET /v1/release-control/publications/:commandId/terminal` читает
+сохранённый результат без нового workflow claim или запуска. Для результата,
+принятого через существующий report, адаптер может предоставить
+`readTerminalReceipt(commandId)`. Неизвестный результат возвращает 404;
+неподтверждённые ошибки установки не получают такой результат.

package/dist/exclusive-operation.mjs

@@ -18,6 +18,9 @@ function metadata(producer) {
   assert.ok(state, 'DELIVERY_OPERATION_BARRIER_REQUIRED');
   return state;
 }
+export function assertProducerOperation(producer) {
+  assert.ok(metadata(producer).activity > 0, 'DELIVERY_OPERATION_AUTHORITY_REQUIRED');
+}
 function pendingFailures(producer, state) {
   return [
     ...Object.values(producer.state.commands),

package/dist/producer-admission.mjs

@@ -151,6 +151,9 @@ export class ProducerAdmission extends ProducerState {
         command: structuredClone(input),
         baseline: structuredClone(current.installed),
         ...(publication && candidate ? { sourceCandidate: structuredClone(candidate) } : {}),
+        ...(!publication && input.action === 'deploy' && candidate?.deliveryExecution
+          ? { artifactCandidate: structuredClone(candidate) }
+          : {}),
         ...(candidate?.deliveryExecution ? { deliveryExecution: candidate.deliveryExecution } : {}),
         ack,
       };

package/dist/producer-delivery.mjs

@@ -6,7 +6,7 @@ export async function verifyPublicationDelivery(
   producer,
   command,
   delivery,
-  { fresh = true } = {}
+  { fresh = true, verification } = {}
 ) {
   assert.equal(command.action, 'publish');
   validateOriginalDelivery(delivery, command.expectedSource.sourceCommit);
@@ -19,7 +19,7 @@ export async function verifyPublicationDelivery(
     assert.deepEqual(item.deliveryExecution, delivery, 'Original published delivery changed');
   if (typeof producer.provider.verifyPublicationDelivery === 'function')
     assert.equal(
-      await producer.provider.verifyPublicationDelivery(command, delivery),
+      await producer.provider.verifyPublicationDelivery(command, delivery, verification),
       true,
       'Original delivery correlation was not verified'
     );

package/dist/producer-execution.mjs

@@ -1,4 +1,5 @@
 import assert from 'node:assert/strict';
+import { notifyPublicationTerminal } from './publication-terminal.mjs';
 import { canonical } from './protocol-internals.mjs';
 import { sameIdentity, acceptedProduction } from './protocol.mjs';
 import { blocker, failureMessage, failedProduction } from './producer-support.mjs';
@@ -6,10 +7,7 @@ import { ProducerPublication } from './producer-publication.mjs';
 
 export class ProducerExecution extends ProducerPublication {
   async qualifyForwardRecovery(run, command) {
-    if (
-      command.action === 'publish' &&
-      !this.state.commands[command.commandId]?.artifactIdentity
-    )
+    if (command.action === 'publish' && !this.state.commands[command.commandId]?.artifactIdentity)
       return;
     command = this.resolvedCommand(command);
     if (
@@ -49,33 +47,27 @@ export class ProducerExecution extends ProducerPublication {
           run.committedReadback = fact;
           run.completedAt ??= this.now().toISOString();
           for (const row of run.stages.filter((s) =>
-            ['running', 'unverified'].includes(s.status),
+            ['running', 'unverified'].includes(s.status)
           )) {
             row.status = 'failed';
             row.completedAt ??= run.completedAt;
             row.elapsedMs = row.startedAt
-              ? Math.max(
-                  0,
-                  Date.parse(row.completedAt) - Date.parse(row.startedAt),
-                )
+              ? Math.max(0, Date.parse(row.completedAt) - Date.parse(row.startedAt))
               : null;
-            row.failure = blocker(
-              'INTERRUPTED_PROOF',
-              'Подтверждение результата было прервано',
-            );
+            row.failure = blocker('INTERRUPTED_PROOF', 'Подтверждение результата было прервано');
           }
           run.blockers.push(
             blocker(
               'FORWARD_CORRECTION_REQUIRED',
-              'Установка завершена, приёмка не пройдена; требуется исправляющий релиз',
-            ),
+              'Установка завершена, приёмка не пройдена; требуется исправляющий релиз'
+            )
           );
           this.event(
             run.id,
             null,
             'failure',
             'Разрешён исправляющий релиз; исходная выкатка завершилась ошибкой',
-            'error',
+            'error'
           );
         }
       } catch (qualificationError) {
@@ -87,13 +79,12 @@ export class ProducerExecution extends ProducerPublication {
   }
   async execute(command, { activated = false } = {}) {
     const run = this.state.runs.find((r) => r.commandId === command.commandId);
-    const remaining = () =>
-      Date.parse(command.deadlineAt) - this.now().getTime();
+    const remaining = () => Date.parse(command.deadlineAt) - this.now().getTime();
     let suspended = false;
     const stage = async (
       id,
       operation,
-      { inputsDigest = null, reusedFromRunId = null, queuedAt = null } = {},
+      { inputsDigest = null, reusedFromRunId = null, queuedAt = null } = {}
     ) => {
       assert.ok(remaining() > 0, 'Original deadline exceeded');
       if (id === 'deploy') run.recoveryState = 'unverified';
@@ -103,8 +94,7 @@ export class ProducerExecution extends ProducerPublication {
         command.action === 'publish' &&
         this.provider.remotePublication === true &&
         row.startedAt !== null;
-      if (!retained || !['passed', 'reused'].includes(row.status))
-        row.status = 'running';
+      if (!retained || !['passed', 'reused'].includes(row.status)) row.status = 'running';
       if (!retained) row.startedAt = this.now().toISOString();
       if (!retained) row.inputsDigest = inputsDigest;
       if (!retained)
@@ -149,10 +139,7 @@ export class ProducerExecution extends ProducerPublication {
       } finally {
         if (!suspended) {
           row.completedAt = this.now().toISOString();
-          row.elapsedMs = Math.max(
-            0,
-            Date.parse(row.completedAt) - Date.parse(row.startedAt),
-          );
+          row.elapsedMs = Math.max(0, Date.parse(row.completedAt) - Date.parse(row.startedAt));
           this.event(run.id, id, 'stage', `${row.title}: ${row.status}`);
         }
         await this.save();
@@ -160,21 +147,15 @@ export class ProducerExecution extends ProducerPublication {
     };
     try {
       if (command.lane === 'scheduled' && !activated) {
-        assert.ok(
-          this.provider.announce,
-          'Scheduled notice transport is not configured',
-        );
+        assert.ok(this.provider.announce, 'Scheduled notice transport is not configured');
         await this.provider.announce(command);
         run.noticeAt = this.now().toISOString();
-        if (
-          Date.parse(command.activationAt) <
-          Date.parse(run.noticeAt) + 86400000
-        ) {
+        if (Date.parse(command.activationAt) < Date.parse(run.noticeAt) + 86400000) {
           run.status = 'blocked';
           run.blockers = [
             blocker(
               'NOTICE_WINDOW_TOO_SHORT',
-              'От фактического уведомления до установки должно пройти минимум 24 часа',
+              'От фактического уведомления до установки должно пройти минимум 24 часа'
             ),
           ];
           await this.save();
@@ -184,11 +165,7 @@ export class ProducerExecution extends ProducerPublication {
         // Scheduling is durable; reconciliation resumes after the activation time.
         run.status = 'queued';
         run.blockers = [
-          blocker(
-            'SCHEDULED_ACTIVATION',
-            'Ожидается согласованное окно установки',
-            true,
-          ),
+          blocker('SCHEDULED_ACTIVATION', 'Ожидается согласованное окно установки', true),
         ];
         await this.save();
         return;
@@ -202,27 +179,23 @@ export class ProducerExecution extends ProducerPublication {
         admitted?.ack.state === 'accepted' &&
         canonical(admitted.command) === canonical(command) &&
         Number.isFinite(Date.parse(run.noticeAt)) &&
-        Date.parse(command.activationAt) >=
-          Date.parse(run.noticeAt) + 86400000 &&
+        Date.parse(command.activationAt) >= Date.parse(run.noticeAt) + 86400000 &&
         Date.parse(command.activationAt) <= this.now().getTime();
       await this.provider.execute(command, {
         stage,
         remainingMs: remaining,
         admittedScheduled,
-        bindDelivery: (delivery) =>
-          this.bindPublicationDelivery(command, delivery),
+        bindDelivery: (delivery) => this.bindPublicationDelivery(command, delivery),
         bindArtifact: (identity, options) =>
           this.bindPublicationArtifact(command, identity, options),
         event: async (fact) => {
-          assert.ok(
-            ['source_ready', 'quality', 'source_merge'].includes(fact.stage),
-          );
+          assert.ok(['source_ready', 'quality', 'source_merge'].includes(fact.stage));
           assert.ok(['running', 'completed', 'failed'].includes(fact.status));
           this.event(
             run.id,
             fact.stage === 'source_ready' ? 'source_ready' : 'ci',
             'log',
-            `${fact.stage}: ${fact.status}`,
+            `${fact.stage}: ${fact.status}`
           );
           await this.save();
         },
@@ -232,7 +205,7 @@ export class ProducerExecution extends ProducerPublication {
         run.stages
           .filter((s) => s.id !== 'production_acceptance')
           .every((s) => ['passed', 'reused'].includes(s.status)),
-        'Every prerequisite stage needs actual proof',
+        'Every prerequisite stage needs actual proof'
       );
       const readback = await stage('production_acceptance', async (signal) => {
         const fact = await this.provider.readProduction(resolved, { signal });
@@ -243,15 +216,13 @@ export class ProducerExecution extends ProducerPublication {
         }
         assert.ok(
           acceptedProduction(fact, resolved, this.now()),
-          'Independent production identity and functional proof required',
+          'Independent production identity and functional proof required'
         );
         return fact;
       });
       run.recoveryState = 'verified';
       if (command.action === 'rollback') {
-        const previous = this.state.runs.find(
-          (r) => r.id === command.previousRunId,
-        );
+        const previous = this.state.runs.find((r) => r.id === command.previousRunId);
         if (previous) {
           previous.status = 'failed';
           previous.recoveryState = 'verified';
@@ -259,7 +230,7 @@ export class ProducerExecution extends ProducerPublication {
           previous.blockers = [
             blocker(
               'RECOVERY_VERIFIED',
-              'Предыдущая установка восстановлена; исходная выкатка завершилась ошибкой',
+              'Предыдущая установка восстановлена; исходная выкатка завершилась ошибкой'
             ),
           ];
         }
@@ -270,7 +241,7 @@ export class ProducerExecution extends ProducerPublication {
         run.id,
         null,
         'readback',
-        'Производственная версия и функциональная проверка подтверждены',
+        'Производственная версия и функциональная проверка подтверждены'
       );
     } catch (error) {
       if (
@@ -288,19 +259,17 @@ export class ProducerExecution extends ProducerPublication {
           remaining() <= 0 ? 'DEADLINE_EXCEEDED' : 'RECONCILIATION_REQUIRED',
           remaining() <= 0
             ? 'Исходный срок выполнения истёк'
-            : 'Выполнение требует проверки фактического результата',
+            : 'Выполнение требует проверки фактического результата'
         ),
       ];
       this.event(run.id, null, 'failure', run.blockers[0].message, 'error');
       await this.qualifyForwardRecovery(run, command);
     } finally {
-      if (
-        !suspended &&
-        !run.blockers.some((b) => b.code === 'SCHEDULED_ACTIVATION')
-      )
+      if (!suspended && !run.blockers.some((b) => b.code === 'SCHEDULED_ACTIVATION'))
         run.completedAt = this.now().toISOString();
       await this.save();
     }
+    await notifyPublicationTerminal(this, this.state.commands[command.commandId], run);
   }
   async resumeScheduled() {
     if (this.scheduling) return;
@@ -310,11 +279,11 @@ export class ProducerExecution extends ProducerPublication {
         (r) =>
           r.status === 'queued' &&
           r.lane === 'scheduled' &&
-          Date.parse(r.activationAt) <= this.now().getTime(),
+          Date.parse(r.activationAt) <= this.now().getTime()
       )) {
         const command = this.state.commands[run.commandId].command;
         const candidate = (await this.snapshot()).candidates.find(
-          (c) => c.id === command.candidateId,
+          (c) => c.id === command.candidateId
         );
         if (
           Date.parse(command.deadlineAt) <= this.now().getTime() ||
@@ -325,22 +294,19 @@ export class ProducerExecution extends ProducerPublication {
           run.blockers = [
             blocker(
               'SCHEDULED_CANDIDATE_INVALID',
-              'Срок истёк или подготовленный кандидат изменился',
+              'Срок истёк или подготовленный кандидат изменился'
             ),
           ];
           await this.save();
           continue;
         }
         run.blockers = [];
-        if (
-          Date.parse(command.activationAt) <
-          Date.parse(run.noticeAt) + 86400000
-        ) {
+        if (Date.parse(command.activationAt) < Date.parse(run.noticeAt) + 86400000) {
           run.status = 'blocked';
           run.blockers = [
             blocker(
               'NOTICE_WINDOW_TOO_SHORT',
-              'Недостаточно времени после фактического уведомления',
+              'Недостаточно времени после фактического уведомления'
             ),
           ];
           await this.save();

package/dist/producer-journal.mjs

@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict';
 import { hash, canonical, keys, uuid } from './protocol-internals.mjs';
 import { validateRunnerCommand, validateProducerSnapshot } from './protocol.mjs';
+import { validatePublicationTerminalReceipt } from './publication-terminal-receipt.mjs';
 import {
   validatePublicationFailureRecord,
   validatePublicationFailureReadback,
@@ -29,6 +30,46 @@ export function validProducerState(state, installationKey, sourcePolicy) {
       assert.equal(item.ack.protocolVersion, 1);
       assert.ok(['accepted', 'rejected'].includes(item.ack.state));
       assert.match(item.ack.runId, uuid);
+      if (item.artifactCandidate) {
+        assert.equal(item.command.action, 'deploy');
+        assert.equal(
+          canonical(item.artifactCandidate.identity),
+          canonical(item.command.expectedIdentity)
+        );
+        assert.equal(
+          canonical(item.artifactCandidate.deliveryExecution),
+          canonical(item.deliveryExecution)
+        );
+      }
+      if (item.deliveryTerminalReceipt) {
+        const proof = validatePublicationTerminalReceipt(item.deliveryTerminalReceipt).proof;
+        assert.equal(proof.bindings.commandId, id);
+        assert.equal(proof.bindings.runId, item.ack.runId);
+        assert.equal(proof.bindings.installationKey, installationKey);
+        assert.equal(proof.bindings.action, item.command.action);
+        assert.equal(proof.bindings.candidateId, item.command.candidateId);
+        assert.equal(proof.bindings.provider, item.command.executionProvider);
+        assert.equal(canonical(proof.bindings.delivery), canonical(item.deliveryExecution));
+        const source =
+          item.command.action === 'publish'
+            ? item.command.expectedSource
+            : item.artifactCandidate?.source;
+        assert.equal(proof.bindings.repository, source?.repository);
+        assert.equal(proof.bindings.ref, source?.ref);
+        assert.equal(
+          canonical({ identity: proof.artifactIdentity }),
+          canonical({
+            identity:
+              item.command.action === 'publish'
+                ? (item.artifactIdentity ?? null)
+                : item.command.expectedIdentity,
+          })
+        );
+        const run = state.runs.find((value) => value.id === item.ack.runId);
+        assert.equal(run?.status, proof.status);
+        assert.equal(run?.completedAt, proof.completedAt);
+        assert.equal(run?.recoveryState, 'verified');
+      }
       if (item.publicationFailureReconciliation !== undefined)
         validatePublicationFailureRecord(
           item.publicationFailureReconciliation,

package/dist/producer-publication-failure.mjs

@@ -11,6 +11,7 @@ import { acceptedProduction, sameIdentity } from './protocol.mjs';
 import { validateOriginalDelivery, blocker } from './producer-support.mjs';
 import { verifyPublicationDelivery } from './producer-delivery.mjs';
 import { reservePublicationFailureReconciliation } from './exclusive-operation.mjs';
+import { notifyPublicationTerminal } from './publication-terminal.mjs';
 
 const stages = ['source_ready', 'ci', 'build', 'verify', 'publish'];
 export function publicationFailureProofDigest(fact, baselineReadback) {
@@ -97,10 +98,20 @@ export function validatePublicationFailureRecord(record, command, delivery, base
     assert.ok(record.baselineReadback, 'Settled recovery requires its production baseline proof');
 }
 
-export async function reconcilePublicationFailure(producer, item, run) {
+export async function reconcilePublicationFailure(
+  producer,
+  item,
+  run,
+  { terminalRetry = false } = {}
+) {
   assert.equal(item.ack.state, 'accepted');
   assert.equal(item.command.action, 'publish');
-  assert.equal(run.status, 'blocked');
+  assert.ok(
+    run.status === 'blocked' ||
+      (terminalRetry &&
+        run.status === 'failed' &&
+        item.publicationFailureReconciliation?.state === 'settled')
+  );
   assert.ok(!item.artifactIdentity);
   for (const id of ['deploy', 'production_acceptance']) {
     const row = run.stages.find((stage) => stage.id === id);
@@ -137,7 +148,9 @@ export async function reconcilePublicationFailure(producer, item, run) {
       fact: null,
       baselineReadback: null,
     };
+    if (terminalRetry) item.publicationFailureReconciliation.state = 'pending';
     assert.equal(item.publicationFailureReconciliation.state, 'pending');
+    run.status = 'blocked';
     run.recoveryState = 'unverified';
     run.completedAt = null;
     await bounded(producer.save());
@@ -267,4 +280,5 @@ export async function reconcilePublicationFailure(producer, item, run) {
     if (guard && !settled && !releasing && typeof guard.release === 'function') void cleanup(guard);
     lease.release({ resolved: settled });
   }
+  if (settled) await notifyPublicationTerminal(producer, item, run);
 }

package/dist/producer-server.mjs

@@ -2,11 +2,10 @@ import assert from 'node:assert/strict';
 import { timingSafeEqual } from 'node:crypto';
 import { createServer } from 'node:http';
 import { configurationHook } from './configuration-hook.mjs';
+import { verifyPublicationTerminalReceipt } from './publication-terminal-receipt.mjs';
 
 export function producerServer(producer, token, publication = {}) {
-  assert.ok(
-    typeof token === 'string' && token.length >= 43 && !/\s/.test(token),
-  );
+  assert.ok(typeof token === 'string' && token.length >= 43 && !/\s/.test(token));
   const expected = Buffer.from(`Bearer ${token}`);
   const server = createServer(async (req, res) => {
     const reply = (code, body) => {
@@ -17,31 +16,29 @@ export function producerServer(producer, token, publication = {}) {
       res.end(JSON.stringify(body));
     };
     const supplied = Buffer.from(req.headers.authorization ?? '');
-    if (
-      supplied.length !== expected.length ||
-      !timingSafeEqual(supplied, expected)
-    )
+    if (supplied.length !== expected.length || !timingSafeEqual(supplied, expected))
       return reply(401, { error: 'Unauthorized' });
     try {
       const url = new URL(req.url, 'http://localhost');
       if (await configurationHook(req, url, producer, publication, reply)) return;
-      if (
-        req.method === 'GET' &&
-        url.pathname === '/v1/release-control/snapshot'
-      ) {
-        assert.equal(
-          url.searchParams.get('installationKey'),
-          producer.installationKey,
-        );
-        return reply(
-          200,
-          await producer.snapshot(url.searchParams.get('after') ?? '0'),
-        );
+      const terminal = url.pathname.match(
+        /^\/v1\/release-control\/publications\/([a-f\d-]{36})\/terminal$/i
+      );
+      if (req.method === 'GET' && terminal && !url.search) {
+        const receipt = publication.readTerminalReceipt
+          ? await publication.readTerminalReceipt(terminal[1])
+          : producer.journal.read().commands[terminal[1]]?.deliveryTerminalReceipt;
+        if (!receipt) return reply(404, { error: 'Terminal receipt unavailable' });
+        const verified = verifyPublicationTerminalReceipt(receipt, token);
+        assert.equal(verified.proof.bindings.commandId, terminal[1]);
+        assert.equal(verified.proof.bindings.installationKey, producer.installationKey);
+        return reply(200, verified);
+      }
+      if (req.method === 'GET' && url.pathname === '/v1/release-control/snapshot') {
+        assert.equal(url.searchParams.get('installationKey'), producer.installationKey);
+        return reply(200, await producer.snapshot(url.searchParams.get('after') ?? '0'));
       }
-      if (
-        req.method === 'POST' &&
-        url.pathname === '/v1/release-control/commands'
-      ) {
+      if (req.method === 'POST' && url.pathname === '/v1/release-control/commands') {
         let bytes = 0;
         const chunks = [];
         for await (const chunk of req) {
@@ -51,37 +48,21 @@ export function producerServer(producer, token, publication = {}) {
         }
         return reply(
           200,
-          await producer.command(
-            JSON.parse(Buffer.concat(chunks).toString('utf8')),
-          ),
+          await producer.command(JSON.parse(Buffer.concat(chunks).toString('utf8')))
         );
       }
       const publicationMatch = url.pathname.match(
-        /^\/v1\/release-control\/publications\/([a-f\d-]{36})(\/report)?$/i,
+        /^\/v1\/release-control\/publications\/([a-f\d-]{36})(\/report)?$/i
       );
       if (publicationMatch && !url.search) {
-        if (
-          req.method === 'GET' &&
-          !publicationMatch[2] &&
-          publication.claimPublication
-        ) {
+        if (req.method === 'GET' && !publicationMatch[2] && publication.claimPublication) {
           const rawRun = req.headers[publication.workflowRunHeader ?? 'x-myrobotica-workflow-run'];
           assert.ok(typeof rawRun === 'string' && /^[1-9]\d*$/.test(rawRun));
           const workflowRunId = Number(rawRun);
           assert.ok(Number.isSafeInteger(workflowRunId));
-          return reply(
-            200,
-            await publication.claimPublication(
-              publicationMatch[1],
-              workflowRunId,
-            ),
-          );
+          return reply(200, await publication.claimPublication(publicationMatch[1], workflowRunId));
         }
-        if (
-          req.method === 'POST' &&
-          publicationMatch[2] &&
-          publication.reportPublication
-        ) {
+        if (req.method === 'POST' && publicationMatch[2] && publication.reportPublication) {
           let bytes = 0;
           const chunks = [];
           for await (const chunk of req) {
@@ -93,17 +74,14 @@ export function producerServer(producer, token, publication = {}) {
             200,
             await publication.reportPublication(
               publicationMatch[1],
-              JSON.parse(Buffer.concat(chunks).toString('utf8')),
-            ),
+              JSON.parse(Buffer.concat(chunks).toString('utf8'))
+            )
           );
         }
       }
-      const match = url.pathname.match(
-        /^\/v1\/release-control\/commands\/([a-f\d-]{36})$/i,
-      );
+      const match = url.pathname.match(/^\/v1\/release-control\/commands\/([a-f\d-]{36})$/i);
       if (req.method === 'GET' && match) {
-        if (!producer.acknowledgement(match[1]))
-          return reply(404, { error: 'Unknown command' });
+        if (!producer.acknowledgement(match[1])) return reply(404, { error: 'Unknown command' });
         const ack = await producer.reconcile(match[1]);
         return reply(ack ? 200 : 404, ack ?? { error: 'Unknown command' });
       }