@cassiomc1/forgeloop 0.1.1 → 0.1.3

package/src/core/completion.js

@@ -0,0 +1,266 @@
+import { ARTIFACT_PATHS, canonicalFingerprint, readJsonArtifact, writeJsonArtifact } from "./artifacts.js";
+import { requiredEvidenceForTarget } from "./completion-artifacts.js";
+import { appendProtocolEvent, LIFECYCLE_MILESTONES, validateEventLedger } from "./events.js";
+import { evaluatePreflight } from "./preflight.js";
+import { readContract } from "./contract.js";
+import { readPersistedRoute } from "./route-artifact.js";
+import { readWorkState, writeWorkState, classifyLoadedWorkState } from "./work-state.js";
+import { createReceipt, validateReceipt } from "./receipt.js";
+import { completionRelationshipErrors } from "./completion-relationships.js";
+import { assertSafePath, ensureWithin, fileExists } from "./filesystem.js";
+import { evaluateStartExecutionPrerequisites, hasExecutionStarted } from "./execution-prerequisites.js";
+
+function issue(code, message, artifacts = [], details = {}) {
+  return { code, message, artifacts, ...details };
+}
+
+export function completionIdentityErrors({ contract, state, receipt } = {}) {
+  return completionRelationshipErrors({ contract, state, receipt })
+    .filter((error) => ["E_STATE_TASK_MISMATCH", "E_RECEIPT_TASK_MISMATCH"].includes(error.code));
+}
+
+function repairNext(error) {
+  switch (error.code) {
+    case "E_RECEIPT_MISSING":
+      return "Run forgeloop prepare-completion after recording verification evidence.";
+    case "E_RECEIPT_INVALID":
+    case "E_RECEIPT_CONTRACT_MISMATCH":
+    case "E_RECEIPT_ROUTE_MISMATCH":
+    case "E_RECEIPT_STATE_MISMATCH":
+      return "Run forgeloop prepare-completion, inspect the receipt, and validate it before retrying completion.";
+    case "E_PHASE_PREREQUISITE_MISSING":
+      return "Advance from EXECUTING through VERIFYING and REVIEWING, resolving the named prerequisite before completion.";
+    case "E_PHASE_CHRONOLOGY_INVALID":
+      return "Record the missing lifecycle event through the normal phase transition or forgeloop record-check path.";
+    case "E_EVIDENCE_REQUIRED":
+    case "E_EVIDENCE_COVERAGE_INVALID":
+    case "E_EVIDENCE_COVERAGE_PARTIAL":
+    case "E_EVIDENCE_KIND_INVALID":
+    case "E_CHECK_INVALID":
+    case "E_CHECK_STATUS_CONTRADICTION":
+      return "Run forgeloop record-check with compatible observed evidence for the named requirement.";
+    case "E_GATE_UNVERIFIED":
+    case "E_GATE_STALE":
+      return "Satisfy or refresh the named gate, then rerun forgeloop preflight.";
+    case "E_PROFILE_UNVERIFIED":
+      return "Use Standard mode for a fresh target, or verify PROJECT_PROFILE.md before Strict completion.";
+    default:
+      return "Resolve this validator finding in the named artifact before retrying completion.";
+  }
+}
+
+function withRepairGuidance(error) {
+  const normalized = {
+    ...error,
+    code: error.code ?? "E_COMPLETION_REJECTED",
+    message: error.message ?? String(error),
+    artifacts: error.artifacts ?? [],
+  };
+  if (!normalized.next) normalized.next = repairNext(normalized);
+  return normalized;
+}
+
+function sortIssues(errors) {
+  const unique = [...new Map(errors.map((rawError) => {
+    const error = withRepairGuidance(rawError);
+    return [
+      `${error.code}\0${(error.artifacts ?? []).join("\0")}\0${error.message}`,
+      error,
+    ];
+  })).values()];
+  return unique.sort((left, right) => left.code.localeCompare(right.code)
+    || left.artifacts.join("\0").localeCompare(right.artifacts.join("\0"))
+    || left.message.localeCompare(right.message));
+}
+
+async function loadRequired(loader, code, message, artifacts, errors) {
+  try {
+    return await loader();
+  } catch (error) {
+    errors.push(issue(error.code === "ARTIFACT_MISSING" ? code : `${code.replace(/_MISSING$/, "")}_INVALID`, `${message}: ${error.message}`, artifacts));
+    return null;
+  }
+}
+
+function publicationStatus(receipt) {
+  if (receipt.publicationStatus) return receipt.publicationStatus;
+  if (receipt.publication?.deployed) return "deployed";
+  if (receipt.publication?.pushed) return "pushed";
+  if (receipt.publication?.committed) return "committed";
+  return receipt.changedPaths?.length > 0 ? "local-only" : "not-published";
+}
+
+async function validateLedger(target, taskId, state, errors, packageRoot) {
+  await assertSafePath(target, ARTIFACT_PATHS.events);
+  const eventsPath = ensureWithin(target, ARTIFACT_PATHS.events);
+  if (!(await fileExists(eventsPath))) {
+    errors.push(issue("E_PHASE_CHRONOLOGY_INVALID", "Protocol event ledger is required before completion", [ARTIFACT_PATHS.events]));
+    return { valid: false, events: [], errors: [] };
+  }
+  const ledger = await validateEventLedger(target, packageRoot);
+  for (const error of ledger.errors) errors.push({ ...error, artifacts: [ARTIFACT_PATHS.events] });
+  const requiredEvents = LIFECYCLE_MILESTONES.slice(0, state?.phase === "COMPLETE" ? undefined : -1);
+  const observed = new Set(ledger.events.filter((event) => event.taskId === taskId).map((event) => event.event));
+  for (const event of requiredEvents) {
+    if (!observed.has(event)) {
+      errors.push(issue("E_PHASE_CHRONOLOGY_INVALID", `Required protocol event is missing: ${event}`, [ARTIFACT_PATHS.events], { event }));
+    }
+  }
+  if (ledger.events.some((event) => event.taskId !== taskId)) {
+    errors.push(issue("E_PHASE_CHRONOLOGY_INVALID", "Protocol events must belong to the current task", [ARTIFACT_PATHS.events]));
+  }
+  if (state?.phase !== "COMPLETE" && observed.has("COMPLETION_VALIDATED")) {
+    errors.push(issue("E_PHASE_CHRONOLOGY_INVALID", "COMPLETION_VALIDATED requires COMPLETE state", [ARTIFACT_PATHS.events]));
+  }
+  return ledger;
+}
+
+export async function evaluateCompletion({ target, packageRoot, strict = false } = {}) {
+  const errors = [];
+  const preflight = await evaluatePreflight({ target, packageRoot, strict });
+  errors.push(...preflight.errors);
+  const contract = await loadRequired(
+    () => readContract(target, packageRoot),
+    "E_CONTRACT_MISSING",
+    "Current contract is not available",
+    [ARTIFACT_PATHS.contract],
+    errors,
+  );
+  const route = await loadRequired(
+    () => readPersistedRoute(target, packageRoot),
+    "E_ROUTE_MISSING",
+    "Persisted routing result is not available",
+    [ARTIFACT_PATHS.route],
+    errors,
+  );
+  const state = await loadRequired(
+    () => readWorkState(target, packageRoot).then((value) => {
+      if (!value) {
+        const error = new Error("Work state is missing");
+        error.code = "ARTIFACT_MISSING";
+        throw error;
+      }
+      return value;
+    }),
+    "E_STATE_MISSING",
+    "Work state is not available",
+    [ARTIFACT_PATHS.state],
+    errors,
+  );
+  const receipt = await loadRequired(
+    () => readJsonArtifact(target, ARTIFACT_PATHS.receipt, "execution-receipt", packageRoot),
+    "E_RECEIPT_MISSING",
+    "Execution receipt is not available",
+    [ARTIFACT_PATHS.receipt],
+    errors,
+  );
+
+  if (state && hasExecutionStarted(state.phase)) {
+    const prerequisites = await evaluateStartExecutionPrerequisites({ target, state, packageRoot });
+    errors.push(...prerequisites.errors);
+  }
+
+  if (receipt) {
+    try {
+      await validateReceipt(receipt.value, packageRoot);
+    } catch (error) {
+      errors.push(issue(error.code ?? "E_RECEIPT_INVALID", `Execution receipt is invalid: ${error.message}`, [ARTIFACT_PATHS.receipt]));
+    }
+  }
+
+  if (state && !["REVIEWING", "COMPLETE"].includes(state.phase)) {
+    errors.push(issue("E_PHASE_PREREQUISITE_MISSING", `Completion requires REVIEWING or COMPLETE state, found ${state.phase}`, [ARTIFACT_PATHS.state]));
+  }
+
+  let coverage = [];
+  if (contract && route) {
+    const requiredEvidence = await requiredEvidenceForTarget({
+      target,
+      contract,
+      route,
+      packageRoot,
+      additionalEvidence: preflight?.policy?.requiredEvidence ?? [],
+    });
+    const relationshipErrors = completionRelationshipErrors({
+      contract,
+      route,
+      state,
+      receipt: receipt?.value,
+      requiredEvidence,
+    });
+    errors.push(...relationshipErrors);
+    coverage = receipt?.value?.evidenceCoverage ?? [];
+  }
+
+  const ledger = contract && state
+    ? await validateLedger(target, contract.value.taskId, state, errors, packageRoot)
+    : { valid: false, events: [], errors: [] };
+
+  if (state) {
+    try {
+      const classification = await classifyLoadedWorkState({
+        target,
+        state,
+        contractFile: ARTIFACT_PATHS.contract,
+      });
+      if (classification.status === "REVALIDATION_REQUIRED") {
+        for (const reason of classification.reasons) {
+          errors.push(issue(reason === "CONTRACT_CHANGED" ? "E_CONTRACT_STALE" : "E_PHASE_ARTIFACT_STALE", `State freshness check failed: ${reason}`, [ARTIFACT_PATHS.state]));
+        }
+      }
+    } catch (error) {
+      errors.push(issue("E_PHASE_ARTIFACT_STALE", error.message, [ARTIFACT_PATHS.state]));
+    }
+  }
+
+  const sortedErrors = sortIssues(errors);
+  const receiptValue = receipt?.value;
+  const publication = receiptValue ? publicationStatus(receiptValue) : "not-published";
+  const valid = sortedErrors.length === 0;
+  return {
+    status: valid ? "VALID" : "REJECTED",
+    taskStatus: valid ? "COMPLETE" : receiptValue?.status === "blocked" ? "BLOCKED" : "INCOMPLETE",
+    verificationStatus: valid ? "VALID" : "invalid",
+    publicationStatus: publication,
+    productionReadiness: receiptValue?.productionReadiness ?? "not-verified",
+    errors: sortedErrors,
+    warnings: [],
+    preflight,
+    coverage,
+    ledger: {
+      status: ledger.valid ? "valid" : "invalid",
+      events: ledger.events.length,
+    },
+  };
+}
+
+export async function runComplete({ target, packageRoot, strict = false, persist = true } = {}) {
+  const result = await evaluateCompletion({ target, packageRoot, strict });
+  if (persist && result.status === "VALID") {
+    const state = await readWorkState(target, packageRoot);
+    if (state && state.phase !== "COMPLETE") {
+      const receipt = await readJsonArtifact(target, ARTIFACT_PATHS.receipt, "execution-receipt", packageRoot);
+      const next = {
+        ...state,
+        previousPhase: state.phase,
+        phase: "COMPLETE",
+        evidenceCoverage: result.coverage,
+        verificationEvidence: receipt.value.evidence,
+        publicationStatus: result.publicationStatus,
+        lastUpdated: new Date().toISOString(),
+      };
+      const nextReceipt = await createReceipt({
+        ...receipt.value,
+        stateFingerprint: canonicalFingerprint(next),
+      }, packageRoot);
+      await writeWorkState(target, next, { packageRoot });
+      await writeJsonArtifact(target, ARTIFACT_PATHS.receipt, nextReceipt, "execution-receipt", packageRoot);
+    }
+    const contract = await readContract(target, packageRoot);
+    const ledger = await validateEventLedger(target, packageRoot);
+    if (!ledger.events.some((event) => event.event === "COMPLETION_VALIDATED")) {
+      await appendProtocolEvent(target, { taskId: contract.value.taskId, event: "COMPLETION_VALIDATED" }, packageRoot);
+    }
+  }
+  return result;
+}

package/src/core/config.js

@@ -0,0 +1,35 @@
+import { PROTOCOL_VERSION } from "./protocol.js";
+import { ARTIFACT_PATHS, readJsonArtifact, writeJsonArtifact } from "./artifacts.js";
+
+export const CONFIG_SCHEMA_VERSION = 1;
+export const COMPLIANCE_MODES = Object.freeze(["advisory", "standard", "strict"]);
+
+function stringArray(value, label) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.trim() === "")) {
+    throw new Error(`${label} must be an array of non-empty strings`);
+  }
+  return [...new Set(value)];
+}
+
+export function createConfig(input = {}) {
+  const complianceMode = input.complianceMode ?? "standard";
+  if (!COMPLIANCE_MODES.includes(complianceMode)) {
+    throw new Error(`Unknown compliance mode: ${complianceMode}`);
+  }
+  return {
+    schemaVersion: CONFIG_SCHEMA_VERSION,
+    protocolVersion: PROTOCOL_VERSION,
+    complianceMode,
+    ...(input.policy !== undefined ? { policy: input.policy } : {}),
+    ...(input.requiredGates !== undefined ? { requiredGates: stringArray(input.requiredGates, "requiredGates") } : {}),
+    ...(input.requiredEvidence !== undefined ? { requiredEvidence: stringArray(input.requiredEvidence, "requiredEvidence") } : {}),
+  };
+}
+
+export async function readConfig(target, packageRoot) {
+  return (await readJsonArtifact(target, ARTIFACT_PATHS.config, "config", packageRoot)).value;
+}
+
+export async function writeConfig(target, config, packageRoot, options = {}) {
+  return writeJsonArtifact(target, ARTIFACT_PATHS.config, config, "config", packageRoot, options);
+}

package/src/core/conformance.js

@@ -1,5 +1,6 @@
 import { PROTOCOL_VERSION } from "./protocol.js";
 import { createEvidence } from "./evidence.js";
+import { canonicalFingerprint } from "./artifacts.js";
 
 function error(code, message, artifacts = []) {
   return { code, message, artifacts };
@@ -51,6 +52,12 @@ export function validateTaskArtifactSet({
   if (route && state && JSON.stringify(route.guides) !== JSON.stringify(state.selectedGuides)) {
     errors.push(error("ROUTE_STATE_GUIDES_MISMATCH", "work-state.selectedGuides must equal routing-result.guides", ["route", "state"]));
   }
+  if (route && state && state.routeFingerprint !== undefined && state.routeFingerprint !== canonicalFingerprint(route)) {
+    errors.push(error("ROUTE_STATE_FINGERPRINT_MISMATCH", "work-state.routeFingerprint must match routing-result", ["route", "state"]));
+  }
+  if (route && receipt && receipt.routeFingerprint !== undefined && receipt.routeFingerprint !== canonicalFingerprint(route)) {
+    errors.push(error("STATE_RECEIPT_ROUTE_MISMATCH", "execution-receipt.routeFingerprint must match routing-result", ["route", "receipt"]));
+  }
   if (state && receipt && JSON.stringify(state.selectedGuides) !== JSON.stringify(receipt.selectedGuides)) {
     errors.push(error("STATE_RECEIPT_GUIDES_MISMATCH", "execution-receipt.selectedGuides must equal work-state.selectedGuides", ["state", "receipt"]));
   }

package/src/core/contract.js

@@ -0,0 +1,141 @@
+import { PROTOCOL_VERSION } from "./protocol.js";
+import { ARTIFACT_PATHS, canonicalFingerprint, readJsonArtifact, writeJsonArtifact } from "./artifacts.js";
+import { assertSchema, readSchema } from "./schema-validation.js";
+import { assertSecretFree } from "./receipt.js";
+
+export const CONTRACT_SCHEMA_VERSION = 1;
+
+const CONTRACT_ARRAY_FIELDS = Object.freeze([
+  "deliverables",
+  "constraints",
+  "risks",
+  "verification",
+  "successCriteria",
+  "stopConditions",
+  "unresolvedDecisions",
+  "sourceRefs",
+]);
+
+function assertStringArray(value, label) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.trim() === "")) {
+    throw new Error(`${label} must be an array of non-empty strings`);
+  }
+}
+
+const ASSUMPTION_FIELDS = Object.freeze([
+  "value",
+  "reason",
+  "scope",
+  "reversible",
+  "source",
+]);
+
+function assertAssumptionObject(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be a plain object`);
+  }
+
+  const keys = Object.keys(value);
+  const unexpected = keys.filter((key) => !ASSUMPTION_FIELDS.includes(key));
+  if (unexpected.length > 0) {
+    throw new Error(`${label} contains unknown property: ${unexpected[0]}`);
+  }
+
+  for (const field of ASSUMPTION_FIELDS) {
+    if (!Object.prototype.hasOwnProperty.call(value, field)) {
+      throw new Error(`${label}.${field} is required`);
+    }
+  }
+
+  if (typeof value.value !== "string" || value.value.trim() === "") {
+    throw new Error(`${label}.value must be a non-empty string`);
+  }
+  if (typeof value.reason !== "string" || value.reason.trim() === "") {
+    throw new Error(`${label}.reason must be a non-empty string`);
+  }
+  if (typeof value.scope !== "string" || value.scope.trim() === "") {
+    throw new Error(`${label}.scope must be a non-empty string`);
+  }
+  if (value.reversible !== true) {
+    throw new Error(`${label}.reversible must be true`);
+  }
+  if (value.source !== "agent-default") {
+    throw new Error(`${label}.source must be agent-default`);
+  }
+}
+
+export function assertAssumptions(value, label = "Contract assumptions") {
+  if (!Array.isArray(value)) {
+    throw new Error(`${label} must be an array`);
+  }
+  value.forEach((item, index) => {
+    assertAssumptionObject(item, `${label}[${index}]`);
+  });
+  return value;
+}
+
+export function createContract(input = {}) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("Contract must be a JSON object");
+  }
+  if (typeof input.taskId !== "string" || input.taskId.trim() === "") {
+    throw new Error("Contract taskId is required");
+  }
+  if (typeof input.objective !== "string" || input.objective.trim() === "") {
+    throw new Error("Contract objective is required");
+  }
+
+  const contract = {
+    schemaVersion: CONTRACT_SCHEMA_VERSION,
+    protocolVersion: PROTOCOL_VERSION,
+    taskId: input.taskId,
+    objective: input.objective,
+    assumptions: [],
+  };
+  assertAssumptions(input.assumptions ?? []);
+  for (const field of CONTRACT_ARRAY_FIELDS) {
+    const value = input[field] ?? [];
+    assertStringArray(value, `Contract ${field}`);
+    contract[field] = [...value];
+  }
+  contract.assumptions = (input.assumptions ?? []).map((assumption) => ({
+    value: assumption.value,
+    reason: assumption.reason,
+    scope: assumption.scope,
+    reversible: assumption.reversible,
+    source: assumption.source,
+  }));
+  assertSecretFree(contract);
+  return contract;
+}
+
+export function contractFingerprint(contract) {
+  return canonicalFingerprint(contract);
+}
+
+export async function validateContract(contract, packageRoot) {
+  assertSecretFree(contract);
+  assertAssumptions(contract.assumptions ?? []);
+  const schema = await readSchema("current-contract", packageRoot);
+  assertSchema(contract, schema, "current contract");
+  return contract;
+}
+
+export async function readContract(target, packageRoot) {
+  const artifact = await readJsonArtifact(target, ARTIFACT_PATHS.contract, "current-contract", packageRoot);
+  await validateContract(artifact.value, packageRoot);
+  return artifact;
+}
+
+export async function writeContract(target, contract, packageRoot, options = {}) {
+  assertSecretFree(contract);
+  assertAssumptions(contract.assumptions ?? []);
+  return writeJsonArtifact(
+    target,
+    ARTIFACT_PATHS.contract,
+    contract,
+    "current-contract",
+    packageRoot,
+    options,
+  );
+}

package/src/core/coverage.js

@@ -0,0 +1,89 @@
+import { PROTOCOL_VERSION } from "./protocol.js";
+
+export const COVERAGE_SCHEMA_VERSION = 1;
+export const COVERAGE_STATUSES = Object.freeze(["COVERED", "PARTIAL", "NOT_VERIFIED", "BLOCKED"]);
+
+function coverageError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+function stringArray(value, label) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.trim() === "")) {
+    throw coverageError("E_EVIDENCE_COVERAGE_INVALID", `${label} must be an array of non-empty strings`);
+  }
+  return [...new Set(value)];
+}
+
+export function evaluateCoverage(requiredEvidence, observedEvidence, { blocked = false } = {}) {
+  const required = stringArray(requiredEvidence, "requiredEvidence");
+  const observed = stringArray(observedEvidence, "observedEvidence");
+  if (blocked) return "BLOCKED";
+  if (required.length === 0 || required.every((item) => observed.includes(item))) return "COVERED";
+  if (required.some((item) => observed.includes(item))) return "PARTIAL";
+  return "NOT_VERIFIED";
+}
+
+export function createCoverage(input = {}) {
+  const requiredEvidence = stringArray(input.requiredEvidence ?? [], "requiredEvidence");
+  const observedEvidence = stringArray(input.observedEvidence ?? [], "observedEvidence");
+  const status = input.status ?? evaluateCoverage(requiredEvidence, observedEvidence, { blocked: input.blocked === true });
+  const value = {
+    schemaVersion: COVERAGE_SCHEMA_VERSION,
+    protocolVersion: PROTOCOL_VERSION,
+    requirement: input.requirement,
+    requiredEvidence,
+    observedEvidence,
+    status,
+    ...(input.details !== undefined ? { details: structuredClone(input.details) } : {}),
+  };
+  return assertCoverage(value);
+}
+
+export function assertCoverage(value, label = "evidence coverage") {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw coverageError("E_EVIDENCE_COVERAGE_INVALID", `${label} must be an object`);
+  }
+  if (value.schemaVersion !== COVERAGE_SCHEMA_VERSION || value.protocolVersion !== PROTOCOL_VERSION) {
+    throw coverageError("E_EVIDENCE_COVERAGE_INVALID", `${label} has an unsupported protocol version`);
+  }
+  if (typeof value.requirement !== "string" || value.requirement.trim() === "") {
+    throw coverageError("E_EVIDENCE_COVERAGE_INVALID", `${label}.requirement is required`);
+  }
+  const requiredEvidence = stringArray(value.requiredEvidence, `${label}.requiredEvidence`);
+  const observedEvidence = stringArray(value.observedEvidence, `${label}.observedEvidence`);
+  if (!COVERAGE_STATUSES.includes(value.status)) {
+    throw coverageError("E_EVIDENCE_COVERAGE_INVALID", `${label}.status is invalid`);
+  }
+  const expected = evaluateCoverage(requiredEvidence, observedEvidence, {
+    blocked: value.status === "BLOCKED",
+  });
+  if (value.status !== expected && !(value.status === "BLOCKED" && expected === "BLOCKED")) {
+    throw coverageError("E_EVIDENCE_COVERAGE_PARTIAL", `${label}.status does not match its observed evidence`);
+  }
+  return value;
+}
+
+export function assertCoverageList(value, label = "evidenceCoverage") {
+  if (!Array.isArray(value)) throw coverageError("E_EVIDENCE_COVERAGE_INVALID", `${label} must be an array`);
+  value.forEach((item, index) => assertCoverage(item, `${label}[${index}]`));
+  return value;
+}
+
+export function coverageForRequirements(requirements, checks, { blockedIds = [] } = {}) {
+  const normalizedRequirements = stringArray(requirements ?? [], "requirements");
+  const normalizedChecks = Array.isArray(checks) ? checks : [];
+  const observed = new Set(
+    normalizedChecks
+      .filter((check) => check?.status === "passed" && check.evidenceKind === "OBSERVED")
+      .flatMap((check) => [check.id, check.kind, check.requirement]),
+  );
+  const blocked = new Set(blockedIds);
+  return normalizedRequirements.map((requirement) => createCoverage({
+    requirement,
+    requiredEvidence: [requirement],
+    observedEvidence: observed.has(requirement) ? [requirement] : [],
+    blocked: blocked.has(requirement),
+  }));
+}