@wix/agent-skills 1.36.0 → 1.36.1

package/skills/wix-replatform/lib/product-media-deferral.js

@@ -1,96 +0,0 @@
-'use strict';
-
-// Deterministic construction and reporting for a product gallery that the source
-// media records could not confirm. Generated importers call these helpers instead of cloning the
-// journal row and completion-action contracts into each project.
-
-const { foldAttemptsBySourceKey } = require('./local-state.js');
-
-const WRITE_SPEC_ID = 'stores-product-media-guard';
-const OPERATION = 'confirm-product-pictures';
-const ACTION_CODE = 'product-pictures-deferred';
-const FAILURE_REASONS = new Set(['no-source-id', 'no-source-record', 'source-unreadable']);
-
-function requireString(value, label) {
-  if (typeof value !== 'string' || value.trim() === '') {
-    throw new TypeError(`${label} must be a non-empty string`);
-  }
-  return value;
-}
-
-function buildProductMediaFailureRow({
-  confirmation,
-  attemptId,
-  sourceStableKey,
-  sourceId,
-  targetId,
-  runId,
-  phase = 'import',
-} = {}) {
-  if (!confirmation || confirmation.confirmed !== false || !FAILURE_REASONS.has(confirmation.reason)) {
-    throw new TypeError('buildProductMediaFailureRow: confirmation must be a failed confirmPictures result');
-  }
-  const reason = confirmation.reason;
-  const source = requireString(String(sourceId == null ? '' : sourceId), 'sourceId');
-  const target = requireString(String(targetId == null ? '' : targetId), 'targetId');
-  return {
-    schemaVersion: 1,
-    attemptId: requireString(attemptId, 'attemptId'),
-    sourceStableKey: requireString(sourceStableKey, 'sourceStableKey'),
-    writeSpecId: WRITE_SPEC_ID,
-    operation: OPERATION,
-    targetEntityType: 'product',
-    status: 'failed_retryable',
-    runId: requireString(runId, 'runId'),
-    phase: requireString(phase, 'phase'),
-    failure: {
-      sourceId: source,
-      targetEntityId: target,
-      operation: OPERATION,
-      httpStatus: null,
-      errorCode: null,
-      scopeGroupName: null,
-      outcome: 'failed_retryable',
-      message: `Product media deferred: ${reason}`,
-      reason,
-    },
-  };
-}
-
-function productPicturesDeferredAction(rows) {
-  if (!Array.isArray(rows)) throw new TypeError('productPicturesDeferredAction: rows must be an array');
-  const latest = foldAttemptsBySourceKey(rows);
-  let affectedCount = 0;
-  for (const row of latest.values()) {
-    if (row.writeSpecId === WRITE_SPEC_ID && row.status === 'failed_retryable') affectedCount += 1;
-  }
-  if (affectedCount === 0) return null;
-  return {
-    code: ACTION_CODE,
-    severity: 'medium',
-    entity: 'products',
-    affectedCount,
-    deadlineReason: 'the source is the only place the original can be recovered while it is still the system of record',
-    action: 'Requires Import Operator. For no-source-id and no-source-record, correct the picture at the source (upload the original, or attach it to the product so a media record exists) and re-run the product extract. For source-unreadable, wait until the source answers. Then resume with the failed-only selector. The rows and reasons are in the ledger.',
-  };
-}
-
-function withProductPicturesDeferredAction(completionInput = {}, rows = []) {
-  if (!completionInput || typeof completionInput !== 'object' || Array.isArray(completionInput)) {
-    throw new TypeError('withProductPicturesDeferredAction: completionInput must be an object');
-  }
-  const existing = completionInput.operatorActions;
-  if (existing !== undefined && !Array.isArray(existing)) {
-    throw new TypeError('withProductPicturesDeferredAction: operatorActions must be an array');
-  }
-  const operatorActions = (existing || []).filter((action) => !action || action.code !== ACTION_CODE);
-  const action = productPicturesDeferredAction(rows);
-  if (action) operatorActions.push(action);
-  return { ...completionInput, operatorActions };
-}
-
-module.exports = {
-  buildProductMediaFailureRow,
-  productPicturesDeferredAction,
-  withProductPicturesDeferredAction,
-};

package/skills/wix-replatform/lib/progress-log.js

@@ -1,240 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const crypto = require('node:crypto');
-
-const RUNNING_EVENTS = new Set(['start', 'progress', 'heartbeat', 'warning']);
-
-function slugify(value) {
-  return String(value || 'script')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '') || 'script';
-}
-
-function defaultRunId(script) {
-  return `${slugify(script)}-${Date.now()}-${crypto.randomBytes(2).toString('hex')}`;
-}
-
-function parseProgressArgs(argv, env = process.env) {
-  const args = [];
-  const progress = {
-    progressLog: env.PROGRESS_LOG || null,
-    runId: env.RUN_ID || null,
-    parentRunId: env.PARENT_RUN_ID || null,
-  };
-
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    if (arg === '--progress-log') {
-      progress.progressLog = argv[i + 1];
-      i += 1;
-    } else if (arg === '--run-id') {
-      progress.runId = argv[i + 1];
-      i += 1;
-    } else if (arg === '--parent-run-id') {
-      progress.parentRunId = argv[i + 1];
-      i += 1;
-    } else {
-      args.push(arg);
-    }
-  }
-
-  return { args, progress };
-}
-
-function statusForEvent(event) {
-  if (event === 'complete') {
-    return 'completed';
-  }
-  if (event === 'error') {
-    return 'failed';
-  }
-  if (RUNNING_EVENTS.has(event)) {
-    return 'running';
-  }
-  throw new Error(`unknown progress event: ${event}`);
-}
-
-function createProgressLogger(options = {}) {
-  const progressLog = options.progressLog || null;
-  const script = options.script || 'script';
-  const runId = options.runId || defaultRunId(script);
-  const parentRunId = options.parentRunId || null;
-  const heartbeatIntervalMs = options.heartbeatIntervalMs || 30000;
-
-  let seq = 0;
-  let started = false;
-  let terminal = false;
-  let lastProgressAt = 0;
-  let heartbeatTimer = null;
-  let heartbeatContext = null;
-
-  function enabled() {
-    return Boolean(progressLog);
-  }
-
-  function append(event, message, fields = {}) {
-    if (!enabled()) {
-      return null;
-    }
-    fs.mkdirSync(path.dirname(progressLog), { recursive: true });
-    seq += 1;
-    const record = {
-      ts: new Date().toISOString(),
-      runId,
-      ...(parentRunId ? { parentRunId } : {}),
-      script,
-      event,
-      status: statusForEvent(event),
-      seq,
-      // `host`/`pid` give a health-check reader a script-agnostic, same-machine liveness signal
-      // straight from the record itself -- the existing state/.lock/ owner-claim check only ever
-      // covers a process that calls withStateLock (import writers), so a read-only script (e.g.
-      // a generated run-extract.js) that never acquires that lock had no way to be corroborated
-      // as live once its heartbeat went stale. `host` is encoded the same way local-state.js's
-      // lock-claim filenames already are, so a reader only ever trusts a pid on ITS OWN machine.
-      // BUG FIX: `...fields` must spread BEFORE `host`/`pid`, not after --
-      // a caller-supplied heartbeat field literally named `host` or `pid` must never be able to
-      // shadow this record's own true liveness identity.
-      ...fields,
-      host: Buffer.from(os.hostname()).toString('base64url'),
-      pid: process.pid,
-      message: String(message || event),
-    };
-    fs.appendFileSync(progressLog, `${JSON.stringify(record)}\n`, { encoding: 'utf8', flag: 'a' });
-    // BUG FIX: this used to only reset on a NON-heartbeat event, so once
-    // the ticker's own `elapsed >= heartbeatIntervalMs` check first became true, `lastProgressAt`
-    // never moved again and every subsequent tick re-fired a heartbeat -- flooding the log at the
-    // ticker's poll rate (capped at 5s) instead of the configured interval. A heartbeat IS
-    // progress (proof the process is alive and looking), so it must reset the clock the same as
-    // any other event.
-    lastProgressAt = Date.now();
-    if (event === 'start') {
-      started = true;
-    }
-    if (event === 'complete' || event === 'error') {
-      terminal = true;
-      stopHeartbeat();
-    }
-    return record;
-  }
-
-  function start(message, fields = {}) {
-    return append('start', message, fields);
-  }
-
-  function progress(message, fields = {}) {
-    return append('progress', message, fields);
-  }
-
-  function heartbeat(message, fields = {}) {
-    return append('heartbeat', message, fields);
-  }
-
-  function warn(message, fields = {}) {
-    return append('warning', message, fields);
-  }
-
-  function error(message, fields = {}) {
-    return append('error', message, fields);
-  }
-
-  function complete(message, fields = {}) {
-    return append('complete', message, fields);
-  }
-
-  function startHeartbeat(fields = {}) {
-    if (!enabled() || heartbeatTimer) {
-      return;
-    }
-    heartbeatContext = fields;
-    heartbeatTimer = setInterval(() => {
-      if (terminal) {
-        stopHeartbeat();
-        return;
-      }
-      const elapsed = Date.now() - lastProgressAt;
-      if (elapsed >= heartbeatIntervalMs) {
-        heartbeat(fields.message || 'Still running', fields);
-      }
-    }, Math.max(1000, Math.min(heartbeatIntervalMs, 5000)));
-    heartbeatTimer.unref?.();
-  }
-
-  function stopHeartbeat() {
-    if (heartbeatTimer) {
-      clearInterval(heartbeatTimer);
-      heartbeatTimer = null;
-      heartbeatContext = null;
-    }
-  }
-
-  async function withHeartbeat(fields, fn) {
-    startHeartbeat(fields);
-    try {
-      return await fn();
-    } finally {
-      stopHeartbeat();
-    }
-  }
-
-  function childEnv(extra = {}) {
-    return {
-      ...extra,
-      ...(progressLog ? { PROGRESS_LOG: progressLog, PARENT_RUN_ID: runId } : {}),
-    };
-  }
-
-  function installTerminalHandlers() {
-    if (!enabled()) {
-      return;
-    }
-    process.on('exit', (code) => {
-      if (started && !terminal && code !== 0) {
-        append('error', `Process exited before writing a terminal progress record`, {
-          exitCode: code,
-          ...(heartbeatContext || {}),
-        });
-      }
-    });
-    process.on('uncaughtException', (err) => {
-      if (started && !terminal) {
-        error(err && err.message ? err.message : 'Uncaught exception', { errorName: err && err.name });
-      }
-      throw err;
-    });
-    process.on('unhandledRejection', (reason) => {
-      if (started && !terminal) {
-        error(reason && reason.message ? reason.message : 'Unhandled rejection', { errorName: reason && reason.name });
-      }
-    });
-  }
-
-  installTerminalHandlers();
-
-  return {
-    progressLog,
-    script,
-    runId,
-    parentRunId,
-    enabled,
-    start,
-    progress,
-    heartbeat,
-    warn,
-    error,
-    complete,
-    startHeartbeat,
-    stopHeartbeat,
-    withHeartbeat,
-    childEnv,
-  };
-}
-
-module.exports = {
-  createProgressLogger,
-  parseProgressArgs,
-};

package/skills/wix-replatform/lib/progress-log.sh

@@ -1,140 +0,0 @@
-#!/usr/bin/env bash
-
-progress_log_path="${PROGRESS_LOG:-}"
-progress_run_id="${RUN_ID:-}"
-progress_parent_run_id="${PARENT_RUN_ID:-}"
-progress_script="${PROGRESS_SCRIPT:-${0#"$PWD"/}}"
-progress_seq=0
-progress_seq_state=""
-progress_started=0
-progress_terminal=0
-progress_heartbeat_pid=""
-progress_heartbeat_message="Still running"
-
-progress_slugify() {
-  printf '%s' "$1" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9]+/-/g; s/^-+//; s/-+$//'
-}
-
-progress_init() {
-  if [[ -z "$progress_run_id" ]]; then
-    local slug
-    slug="$(progress_slugify "$progress_script")"
-    [[ -n "$slug" ]] || slug="script"
-    progress_run_id="${slug}-$(date +%s)-$(od -An -N2 -tx1 /dev/urandom | tr -d ' \n')"
-  fi
-  if [[ -z "$progress_seq_state" ]]; then
-    progress_seq_state="${TMPDIR:-/tmp}/rp-progress-${progress_run_id}.seq"
-  fi
-}
-
-progress_json_escape() {
-  local value="${1:-}"
-  value="${value//\\/\\\\}"
-  value="${value//\"/\\\"}"
-  value="${value//$'\n'/\\n}"
-  value="${value//$'\r'/\\r}"
-  value="${value//$'\t'/\\t}"
-  printf '%s' "$value"
-}
-
-progress_status_for_event() {
-  case "$1" in
-    complete) printf 'completed' ;;
-    error) printf 'failed' ;;
-    start|progress|heartbeat|warning) printf 'running' ;;
-    *) printf 'running' ;;
-  esac
-}
-
-progress_next_seq() {
-  progress_init
-  local lock="${progress_seq_state}.lock"
-  while ! mkdir "$lock" 2>/dev/null; do
-    sleep 0.05
-  done
-  local current=0
-  if [[ -f "$progress_seq_state" ]]; then
-    current="$(cat "$progress_seq_state")"
-  fi
-  progress_seq=$((current + 1))
-  printf '%s\n' "$progress_seq" > "$progress_seq_state"
-  rmdir "$lock"
-}
-
-progress_write() {
-  local event="$1"
-  local message="$2"
-  local fields="${3:-}"
-  [[ -n "$progress_log_path" ]] || return 0
-  progress_init
-  mkdir -p "$(dirname "$progress_log_path")"
-  progress_next_seq
-  local status ts line
-  status="$(progress_status_for_event "$event")"
-  ts="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
-  line="{\"ts\":\"$ts\",\"runId\":\"$(progress_json_escape "$progress_run_id")\""
-  if [[ -n "$progress_parent_run_id" ]]; then
-    line="$line,\"parentRunId\":\"$(progress_json_escape "$progress_parent_run_id")\""
-  fi
-  line="$line,\"script\":\"$(progress_json_escape "$progress_script")\",\"event\":\"$event\",\"status\":\"$status\",\"seq\":$progress_seq"
-  if [[ -n "$fields" ]]; then
-    line="$line,$fields"
-  fi
-  line="$line,\"message\":\"$(progress_json_escape "$message")\"}"
-  printf '%s\n' "$line" >> "$progress_log_path"
-  [[ "$event" == "start" ]] && progress_started=1
-  if [[ "$event" == "complete" || "$event" == "error" ]]; then
-    progress_terminal=1
-    progress_heartbeat_stop
-  fi
-}
-
-progress_start() { progress_write start "$1" "${2:-}"; }
-progress_progress() { progress_write progress "$1" "${2:-}"; }
-progress_heartbeat_line() { progress_write heartbeat "${1:-$progress_heartbeat_message}" "${2:-}"; }
-progress_warn() { progress_write warning "$1" "${2:-}"; }
-progress_error() { progress_write error "$1" "${2:-}"; }
-progress_complete() { progress_write complete "$1" "${2:-}"; }
-
-progress_heartbeat_start() {
-  local interval="${1:-30}"
-  progress_heartbeat_message="${2:-Still running}"
-  [[ -n "$progress_log_path" ]] || return 0
-  if [[ -n "$progress_heartbeat_pid" ]]; then
-    progress_error "heartbeat already active"
-    return 1
-  fi
-  (
-    while sleep "$interval"; do
-      progress_heartbeat_line "$progress_heartbeat_message"
-    done
-  ) &
-  progress_heartbeat_pid="$!"
-}
-
-progress_heartbeat_stop() {
-  if [[ -n "${progress_heartbeat_pid:-}" ]]; then
-    kill "$progress_heartbeat_pid" 2>/dev/null || true
-    wait "$progress_heartbeat_pid" 2>/dev/null || true
-    progress_heartbeat_pid=""
-  fi
-}
-
-progress_child_env() {
-  progress_init
-  if [[ -n "$progress_log_path" ]]; then
-    printf 'PROGRESS_LOG=%q PARENT_RUN_ID=%q ' "$progress_log_path" "$progress_run_id"
-  fi
-}
-
-progress_on_exit() {
-  local code=$?
-  progress_heartbeat_stop
-  if [[ "$progress_started" == "1" && "$progress_terminal" == "0" && "$code" != "0" ]]; then
-    progress_error "Process exited before writing a terminal progress record" "\"exitCode\":$code"
-  fi
-}
-
-trap progress_on_exit EXIT
-trap 'progress_heartbeat_stop; exit 130' INT
-trap 'progress_heartbeat_stop; exit 143' TERM

package/skills/wix-replatform/lib/read-back-approval.js

@@ -1,184 +0,0 @@
-'use strict';
-
-const fs = require('node:fs/promises');
-const path = require('node:path');
-const state = require('./read-back-state');
-const contract = require('./read-back-contract');
-const {
-  requireOperatorIdentity
-} = require('./operator-identity');
-const {
-  loadArtifacts,
-  updateApprovalObject
-} = require('./orchestration-state');
-async function gatedEntities(projectDir) {
-  let files;
-  try {
-    files = await fs.readdir(path.join(projectDir, 'mapping/entity-decisions'));
-  } catch (e) {
-    if (e.code === 'ENOENT') return [];
-    throw e;
-  }
-  const result = [];
-  for (const name of files) if (name.endsWith('.json') && Object.hasOwn(contract.DOMAINS, name.slice(0, -5))) {
-    const d = await state.readJson(projectDir, `mapping/entity-decisions/${name}`);
-    if (d.readBackContract) result.push(name.slice(0, -5));
-  }
-  return result.sort();
-}
-async function applyApproval(projectDir, request, answer, {
-  identity = requireOperatorIdentity
-} = {}) {
-  const type = request.effect?.approvalType;
-  const status = {
-    approved: 'approved',
-    approve: 'approved',
-    declined: 'rejected',
-    reject: 'rejected'
-  }[answer.choice];
-  if (!['mapping', 'execution'].includes(type) || !status) throw new Error('Unsupported approval choice/type');
-  return state.locked(projectDir, async () => {
-    const artifacts = await loadArtifacts(projectDir);
-    const entities = type === 'mapping' ? await gatedEntities(projectDir) : [];
-    const bindingDigests = {};
-    if (status === 'approved') for (const entity of entities) {
-      Object.assign(bindingDigests, contract.bindings(projectDir, entity));
-      const decision = await state.readJson(projectDir, `mapping/entity-decisions/${entity}.json`);
-      const omissions = (decision.fieldDispositions || []).filter(d => d.status === 'notMigrated');
-      const gate = await state.load(projectDir);
-      const history = [...gate.observedLosses, ...Object.values(gate.runs).flatMap(r => Object.values(r.entities || {}).flatMap(e => [...(e.attemptedPaths || []), ...(e.settlements || []).filter(x => x.status !== 'passed')]))];
-      for (const d of omissions) if (history.some(h => (!h.entity || h.entity === entity) && [...(h.sourcePaths || []), h.writePath, h.intendedTargetPath].includes(d.path || d.sourcePath || d.targetPath))) throw new Error('Attempted or observed loss cannot become approved omission');
-    }
-    for (const [p, h] of Object.entries(bindingDigests)) if (!request.artifactRefs?.some(r => r.path === p && String(r.sha256).replace(/^sha256:/, '') === h)) throw new Error(`Missing or stale read-back approval reference: ${p}`);
-    const artifactRefs = await require('./user-actions').approvalArtifactRefs(projectDir, { approvalType: type, status, decidedBy: 'user', artifactRefs: request.artifactRefs, requireRequestRef: true });
-    // Freshness is checked again under the state lock, not just by the caller's earlier check.
-    if (!(type === 'mapping' && status === 'rejected') && require('./user-actions').staleArtifactRefs(projectDir, request).length) throw new Error('user_action_stale: approval inputs changed');
-    const approvedBy = status === 'approved' && entities.length ? identity() : null;
-    updateApprovalObject(artifacts.approvals, type, status, {
-      artifactRefs,
-      notes: request.title,
-      decidedBy: 'user'
-    });
-    if (approvedBy) Object.assign(artifacts.approvals[type], {
-      approvedBy,
-      requestId: request.requestId,
-      bindingDigests
-    });
-    await state.atomic(projectDir, 'orchestration/approvals.json', artifacts.approvals);
-    return artifacts.approvals[type];
-  });
-}
-function omissionDigest(omissions) {
-  return contract.digest(omissions.map(({
-    path,
-    kind,
-    recordCount,
-    approvedBy
-  }) => ({
-    path,
-    kind,
-    recordCount,
-    approvedBy
-  })));
-}
-async function acknowledge(projectDir, request, answer, {
-  identity = requireOperatorIdentity
-} = {}) {
-  if (request.effect?.kind !== 'read-back-omission-ack' || request.kind !== 'manual_action' || request.response?.mode !== 'none' || answer.acknowledged !== true) throw new Error('Invalid omission acknowledgement');
-  const {
-    runId,
-    entity,
-    omissionSetDigest
-  } = request.effect;
-  contract.entityKey(entity);
-  return state.update(projectDir, async gate => {
-    const omissions = gate.runs[runId]?.entities?.[entity]?.approvedOmissions;
-    if (!omissions || omissionDigest(omissions) !== omissionSetDigest || omissions.some(o => o.merchantAcknowledgement?.requestId !== request.requestId)) throw new Error('Omission acknowledgement binding changed');
-    const pending = omissions.filter(o => o.merchantAcknowledgement.status !== 'acknowledged');
-    if (!pending.length) return;
-    if (require('./user-actions').staleArtifactRefs(projectDir, request).length) throw new Error('Omission acknowledgement artifact binding changed');
-    const recordedBy = identity();
-    for (const o of pending) o.merchantAcknowledgement = {
-      status: 'acknowledged',
-      requestId: request.requestId,
-      answeredAt: new Date().toISOString(),
-      recordedBy,
-      ...(answer.note ? {
-        note: answer.note
-      } : {})
-    };
-  });
-}
-// Called at gate load and report generation to heal effect-before-answer crash/restore windows.
-async function recoverAcknowledgements(projectDir, options = {}) {
-  const {
-    listUserActions,
-    readUserAction
-  } = require('./user-actions');
-  const rows = await listUserActions(projectDir, {
-    status: 'answered'
-  });
-  for (const row of rows) {
-    const r = await readUserAction(projectDir, row.requestId);
-    if (r.effect?.kind === 'read-back-omission-ack') await acknowledge(projectDir, r, r.answer, options);
-  }
-}
-async function createAcknowledgement(projectDir, runId, entity) {
-  const gate = await state.load(projectDir),
-    item = gate.runs[runId]?.entities?.[entity];
-  if (!item?.approvedOmissions?.length || item.approvedOmissions.every(o => o.merchantAcknowledgement?.status === 'acknowledged')) return;
-  const {
-      createUserAction,
-      readUserAction
-    } = require('./user-actions'),
-    {
-      randomUUID
-    } = require('node:crypto');
-  let req = item.pendingAcknowledgementRequest;
-  if (!req) {
-    const requestId = item.approvedOmissions[0].merchantAcknowledgement?.requestId || `uar_${randomUUID()}`,
-      omissions = item.approvedOmissions;
-    req = {
-      requestId,
-      kind: 'manual_action',
-      stage: 'completion',
-      title: `Acknowledge omitted ${entity} fields`,
-      prompt: `Tell the merchant these fields were not migrated before launch: ${omissions.map(o => `${o.path} (${o.recordCount} records)`).join(', ')}`,
-      response: {
-        mode: 'none'
-      },
-      artifactRefs: Object.entries(item.bindingDigests || contract.bindings(projectDir, entity)).map(([p, sha256]) => ({
-        path: p,
-        sha256
-      })),
-      effect: {
-        kind: 'read-back-omission-ack',
-        runId,
-        entity,
-        omissionSetDigest: omissionDigest(omissions)
-      }
-    };
-    await state.update(projectDir, g => {
-      const e = g.runs[runId].entities[entity];
-      e.pendingAcknowledgementRequest = req;
-      for (const o of e.approvedOmissions) o.merchantAcknowledgement = {
-        status: 'pending',
-        requestId
-      };
-    });
-  }
-  try {
-    await readUserAction(projectDir, req.requestId);
-  } catch (e) {
-    if (e.code !== 'ENOENT') throw e;
-    await createUserAction(projectDir, req);
-  }
-}
-module.exports = {
-  applyApproval,
-  gatedEntities,
-  acknowledge,
-  recoverAcknowledgements,
-  createAcknowledgement,
-  omissionDigest
-};