harnery 0.33.0 → 0.34.1

package/src/core/events/v3/authority-outbox.ts

@@ -0,0 +1,548 @@
+import { randomUUID } from "node:crypto";
+import {
+  closeSync,
+  existsSync,
+  fsyncSync,
+  linkSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { fsyncParentDirectory } from "../../workflow/durable-record.ts";
+import { canonicalJsonV3, sha256V3 } from "./canonical.ts";
+import type { EventV3 } from "./contract.ts";
+import { assertEventV3 } from "./validate.ts";
+import { ensureEventV3Layout, eventV3Paths, writeEventV3 } from "./writer.ts";
+
+const SHA256_PATTERN = /^sha256:[a-f0-9]{64}$/;
+const INSTANCE_PATTERN = /^inst_[a-zA-Z0-9._-]{1,128}$/;
+const TX_PATTERN = /^txn_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+const SAFE_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+const REASON_PATTERN = /^[a-z0-9][a-z0-9._-]{0,79}$/;
+
+export type AuthorityMutationV3 =
+  | {
+      kind: "task.transition";
+      state: "set" | "cleared";
+      task_fingerprint?: `sha256:${string}`;
+    }
+  | {
+      kind: "lifecycle.transition";
+      state: "active" | "blocked" | "done";
+      reason_code?: string;
+    }
+  | {
+      kind: "claim.transition";
+      operation: "acquired" | "released";
+      target_fingerprint: `sha256:${string}`;
+      access: "read" | "write";
+    }
+  | {
+      kind: "identity.assume";
+      identity_id: string;
+    }
+  | {
+      kind: "decision.resolve";
+      decision_id: string;
+      outcome: "approved" | "denied" | "deferred";
+    }
+  | {
+      kind: "wait.start";
+      wait_id: string;
+      wait_kind:
+        | "permission"
+        | "approval"
+        | "decision"
+        | "operator_input"
+        | "dependency"
+        | "scheduled";
+    }
+  | {
+      kind: "wait.end";
+      wait_id: string;
+      outcome:
+        | "succeeded"
+        | "failed"
+        | "cancelled"
+        | "timed_out"
+        | "denied"
+        | "interrupted"
+        | "unknown";
+    };
+
+export interface PrepareAuthorityTransactionV3Input {
+  transaction_id?: `txn_${string}`;
+  expected_prior_state_digest: `sha256:${string}`;
+  desired_state_digest: `sha256:${string}`;
+  actor_instance_id: string;
+  subject_instance_id: string;
+  mutation: AuthorityMutationV3;
+  event: EventV3;
+}
+
+export interface AuthorityTransactionV3 {
+  format: "harnery-event-v3-authority-transaction";
+  format_version: 1;
+  transaction_id: `txn_${string}`;
+  expected_prior_state_digest: `sha256:${string}`;
+  desired_state_digest: `sha256:${string}`;
+  actor_instance_id: string;
+  subject_instance_id: string;
+  mutation: AuthorityMutationV3;
+  event_id: string;
+  event_row: string;
+}
+
+export interface AuthorityReceiptV3 {
+  format: "harnery-event-v3-authority-receipt";
+  format_version: 1;
+  transaction_id: `txn_${string}`;
+  transaction_digest: `sha256:${string}`;
+  desired_state_digest: `sha256:${string}`;
+  event_id: string;
+  event_row_digest: `sha256:${string}`;
+  committed_at: string;
+}
+
+export interface AuthorityReconcilerV3 {
+  readStateDigest: () => `sha256:${string}`;
+  apply: (mutation: AuthorityMutationV3, transactionId: string) => void;
+  now?: () => Date;
+}
+
+/** Durably publish the full transaction before any authority-bearing state mutation. */
+export function prepareAuthorityTransactionV3(
+  coordRoot: string,
+  input: PrepareAuthorityTransactionV3Input,
+): AuthorityTransactionV3 {
+  return publishAuthorityTransactionV3(coordRoot, buildAuthorityTransactionV3(input));
+}
+
+/** Build and validate an authority transaction without touching durable state. */
+export function buildAuthorityTransactionV3(
+  input: PrepareAuthorityTransactionV3Input,
+): AuthorityTransactionV3 {
+  assertEventV3(input.event);
+  const transaction: AuthorityTransactionV3 = {
+    format: "harnery-event-v3-authority-transaction",
+    format_version: 1,
+    transaction_id: input.transaction_id ?? `txn_${randomUUID()}`,
+    expected_prior_state_digest: input.expected_prior_state_digest,
+    desired_state_digest: input.desired_state_digest,
+    actor_instance_id: input.actor_instance_id,
+    subject_instance_id: input.subject_instance_id,
+    mutation: input.mutation,
+    event_id: input.event.event_id,
+    event_row: `${canonicalJsonV3(input.event)}\n`,
+  };
+  validateTransaction(transaction);
+  return transaction;
+}
+
+/** Publish an already-built transaction exactly, preserving its pre-minted event. */
+export function publishAuthorityTransactionV3(
+  coordRoot: string,
+  transaction: AuthorityTransactionV3,
+): AuthorityTransactionV3 {
+  validateTransaction(transaction);
+  const paths = ensureEventV3Layout(coordRoot);
+  const readyPath = authorityReadyPath(paths.authorityOutbox, transaction.transaction_id);
+  const serialized = `${canonicalJsonV3(transaction)}\n`;
+  if (existsSync(readyPath)) {
+    if (readFileSync(readyPath, "utf8") !== serialized) {
+      throw new Error("authority transaction ID conflicts with another ready transaction");
+    }
+    return transaction;
+  }
+  try {
+    publishExclusive(readyPath, serialized);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+    if (readFileSync(readyPath, "utf8") !== serialized) {
+      throw new Error("authority transaction ID conflicts with another ready transaction");
+    }
+  }
+  return transaction;
+}
+
+/** Apply or recognize the desired state, durably submit its event, then leave a hash-only receipt. */
+export function reconcileAuthorityTransactionV3(
+  coordRoot: string,
+  transactionId: string,
+  reconciler: AuthorityReconcilerV3,
+): AuthorityReceiptV3 {
+  assertTransactionId(transactionId);
+  const paths = ensureEventV3Layout(coordRoot);
+  const committedPath = authorityCommittedPath(paths.authorityOutbox, transactionId);
+  if (existsSync(committedPath)) return readAuthorityReceiptV3(committedPath);
+  const readyPath = authorityReadyPath(paths.authorityOutbox, transactionId);
+  const transaction = readAuthorityTransactionV3(readyPath);
+  const current = reconciler.readStateDigest();
+  if (current === transaction.expected_prior_state_digest) {
+    reconciler.apply(transaction.mutation, transaction.transaction_id);
+  } else if (current !== transaction.desired_state_digest) {
+    throw new Error("authority transaction prior state conflicts with current state");
+  }
+  if (reconciler.readStateDigest() !== transaction.desired_state_digest) {
+    throw new Error("authority transaction did not reach its declared desired state");
+  }
+  const event = JSON.parse(transaction.event_row) as unknown;
+  assertEventV3(event);
+  writeEventV3(coordRoot, event);
+  const receipt: AuthorityReceiptV3 = {
+    format: "harnery-event-v3-authority-receipt",
+    format_version: 1,
+    transaction_id: transaction.transaction_id,
+    transaction_digest: sha256V3(`${canonicalJsonV3(transaction)}\n`),
+    desired_state_digest: transaction.desired_state_digest,
+    event_id: transaction.event_id,
+    event_row_digest: sha256V3(transaction.event_row),
+    committed_at: (reconciler.now ?? (() => new Date()))().toISOString(),
+  };
+  try {
+    publishExclusive(committedPath, `${canonicalJsonV3(receipt)}\n`);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+    return readAuthorityReceiptV3(committedPath);
+  }
+  unlinkSync(readyPath);
+  fsyncParentDirectory(readyPath);
+  return receipt;
+}
+
+export function listPendingAuthorityTransactionsV3(coordRoot: string): AuthorityTransactionV3[] {
+  const outbox = eventV3Paths(coordRoot).authorityOutbox;
+  if (!existsSync(outbox)) return [];
+  return readdirSync(outbox)
+    .filter((name) => name.endsWith(".ready.json"))
+    .sort()
+    .map((name) => readAuthorityTransactionV3(join(outbox, name)));
+}
+
+export function readAuthorityTransactionV3(path: string): AuthorityTransactionV3 {
+  const serialized = readFileSync(path, "utf8");
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(serialized);
+  } catch {
+    throw new Error("authority transaction is malformed");
+  }
+  const transaction = validateTransaction(parsed);
+  if (`${canonicalJsonV3(transaction)}\n` !== serialized) {
+    throw new Error("authority transaction is not canonical");
+  }
+  return transaction;
+}
+
+export function readAuthorityReceiptV3(path: string): AuthorityReceiptV3 {
+  const serialized = readFileSync(path, "utf8");
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(serialized);
+  } catch {
+    throw new Error("authority receipt is malformed");
+  }
+  const receipt = validateReceipt(parsed);
+  if (`${canonicalJsonV3(receipt)}\n` !== serialized) {
+    throw new Error("authority receipt is not canonical");
+  }
+  return receipt;
+}
+
+function validateTransaction(value: unknown): AuthorityTransactionV3 {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("authority transaction envelope is invalid");
+  }
+  const record = value as Record<string, unknown>;
+  if (
+    Object.keys(record).sort().join("\0") !==
+    "actor_instance_id\0desired_state_digest\0event_id\0event_row\0expected_prior_state_digest\0format\0format_version\0mutation\0subject_instance_id\0transaction_id"
+  ) {
+    throw new Error("authority transaction has unsupported fields");
+  }
+  if (
+    record.format !== "harnery-event-v3-authority-transaction" ||
+    record.format_version !== 1 ||
+    typeof record.transaction_id !== "string" ||
+    typeof record.expected_prior_state_digest !== "string" ||
+    typeof record.desired_state_digest !== "string" ||
+    typeof record.actor_instance_id !== "string" ||
+    typeof record.subject_instance_id !== "string" ||
+    typeof record.event_id !== "string" ||
+    typeof record.event_row !== "string"
+  ) {
+    throw new Error("authority transaction values are invalid");
+  }
+  assertTransactionId(record.transaction_id);
+  if (
+    !SHA256_PATTERN.test(record.expected_prior_state_digest) ||
+    !SHA256_PATTERN.test(record.desired_state_digest) ||
+    !INSTANCE_PATTERN.test(record.actor_instance_id) ||
+    !INSTANCE_PATTERN.test(record.subject_instance_id)
+  ) {
+    throw new Error("authority transaction authority fields are invalid");
+  }
+  const mutation = validateMutation(record.mutation);
+  let event: unknown;
+  try {
+    event = JSON.parse(record.event_row);
+  } catch {
+    throw new Error("authority transaction event row is malformed");
+  }
+  assertEventV3(event);
+  if (record.event_id !== event.event_id || `${canonicalJsonV3(event)}\n` !== record.event_row) {
+    throw new Error("authority transaction event row is not canonical or mismatched");
+  }
+  const transaction = { ...(record as unknown as AuthorityTransactionV3), mutation };
+  validateTransactionBinding(transaction, event);
+  return transaction;
+}
+
+function validateMutation(value: unknown): AuthorityMutationV3 {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("authority mutation is invalid");
+  }
+  const mutation = value as Record<string, unknown>;
+  if (mutation.kind === "task.transition") {
+    const allowed =
+      mutation.task_fingerprint === undefined ? "kind\0state" : "kind\0state\0task_fingerprint";
+    if (
+      Object.keys(mutation).sort().join("\0") !== allowed ||
+      !["set", "cleared"].includes(String(mutation.state)) ||
+      (mutation.state === "set" &&
+        (typeof mutation.task_fingerprint !== "string" ||
+          !SHA256_PATTERN.test(mutation.task_fingerprint))) ||
+      (mutation.state === "cleared" && mutation.task_fingerprint !== undefined)
+    ) {
+      throw new Error("authority task mutation is invalid");
+    }
+  } else if (mutation.kind === "lifecycle.transition") {
+    const allowed = mutation.reason_code === undefined ? "kind\0state" : "kind\0reason_code\0state";
+    if (
+      Object.keys(mutation).sort().join("\0") !== allowed ||
+      !["active", "blocked", "done"].includes(String(mutation.state)) ||
+      (mutation.reason_code !== undefined &&
+        (typeof mutation.reason_code !== "string" || !REASON_PATTERN.test(mutation.reason_code)))
+    ) {
+      throw new Error("authority lifecycle mutation is invalid");
+    }
+  } else if (mutation.kind === "claim.transition") {
+    if (
+      Object.keys(mutation).sort().join("\0") !== "access\0kind\0operation\0target_fingerprint" ||
+      !["read", "write"].includes(String(mutation.access)) ||
+      !["acquired", "released"].includes(String(mutation.operation)) ||
+      typeof mutation.target_fingerprint !== "string" ||
+      !SHA256_PATTERN.test(mutation.target_fingerprint)
+    ) {
+      throw new Error("authority claim mutation is invalid");
+    }
+  } else if (mutation.kind === "identity.assume") {
+    if (
+      Object.keys(mutation).sort().join("\0") !== "identity_id\0kind" ||
+      typeof mutation.identity_id !== "string" ||
+      !SAFE_ID_PATTERN.test(mutation.identity_id)
+    ) {
+      throw new Error("authority identity mutation is invalid");
+    }
+  } else if (mutation.kind === "decision.resolve") {
+    if (
+      Object.keys(mutation).sort().join("\0") !== "decision_id\0kind\0outcome" ||
+      typeof mutation.decision_id !== "string" ||
+      !SAFE_ID_PATTERN.test(mutation.decision_id) ||
+      !["approved", "denied", "deferred"].includes(String(mutation.outcome))
+    ) {
+      throw new Error("authority decision mutation is invalid");
+    }
+  } else if (mutation.kind === "wait.start") {
+    if (
+      Object.keys(mutation).sort().join("\0") !== "kind\0wait_id\0wait_kind" ||
+      typeof mutation.wait_id !== "string" ||
+      !SAFE_ID_PATTERN.test(mutation.wait_id) ||
+      !["permission", "approval", "decision", "operator_input", "dependency", "scheduled"].includes(
+        String(mutation.wait_kind),
+      )
+    ) {
+      throw new Error("authority wait-start mutation is invalid");
+    }
+  } else if (mutation.kind === "wait.end") {
+    if (
+      Object.keys(mutation).sort().join("\0") !== "kind\0outcome\0wait_id" ||
+      typeof mutation.wait_id !== "string" ||
+      !SAFE_ID_PATTERN.test(mutation.wait_id) ||
+      ![
+        "succeeded",
+        "failed",
+        "cancelled",
+        "timed_out",
+        "denied",
+        "interrupted",
+        "unknown",
+      ].includes(String(mutation.outcome))
+    ) {
+      throw new Error("authority wait-end mutation is invalid");
+    }
+  } else {
+    throw new Error("authority mutation kind is unsupported");
+  }
+  return mutation as unknown as AuthorityMutationV3;
+}
+
+function validateTransactionBinding(transaction: AuthorityTransactionV3, event: EventV3): void {
+  if (
+    event.scope.instance_id !== transaction.actor_instance_id ||
+    event.provenance.attribution.state !== "verified" ||
+    event.provenance.attribution.observer_instance_id !== transaction.actor_instance_id ||
+    event.provenance.attribution.subject_instance_id !== transaction.subject_instance_id
+  ) {
+    throw new Error("authority transaction attribution does not match its event");
+  }
+  const mutation = transaction.mutation;
+  if (mutation.kind === "task.transition") {
+    if (
+      event.event_type !== "coord.task_changed" ||
+      event.payload.actor_instance_id !== transaction.actor_instance_id ||
+      event.payload.subject_instance_id !== transaction.subject_instance_id ||
+      event.payload.authority.transaction_id !== transaction.transaction_id ||
+      event.payload.new_state !== mutation.state ||
+      event.payload.reason_fingerprint?.digest !== mutation.task_fingerprint
+    ) {
+      throw new Error("authority task transaction does not match its event");
+    }
+    return;
+  }
+  if (mutation.kind === "lifecycle.transition") {
+    if (
+      event.event_type !== "coord.lifecycle_changed" ||
+      event.payload.actor_instance_id !== transaction.actor_instance_id ||
+      event.payload.subject_instance_id !== transaction.subject_instance_id ||
+      event.payload.authority.transaction_id !== transaction.transaction_id ||
+      event.payload.new_state !== mutation.state ||
+      event.payload.reason !== (mutation.reason_code ?? "lifecycle_transition")
+    ) {
+      throw new Error("authority lifecycle transaction does not match its event");
+    }
+    return;
+  }
+  if (mutation.kind === "claim.transition") {
+    const operation = mutation.operation;
+    if (
+      event.event_type !== "coord.claim_changed" ||
+      event.payload.actor_instance_id !== transaction.actor_instance_id ||
+      event.payload.subject_instance_id !== transaction.subject_instance_id ||
+      event.payload.authority.transaction_id !== transaction.transaction_id ||
+      event.payload.operation !== operation ||
+      event.payload.target.fingerprint.digest !== mutation.target_fingerprint ||
+      event.payload.access !== mutation.access
+    ) {
+      throw new Error("authority claim transaction does not match its event");
+    }
+    return;
+  }
+  if (mutation.kind === "identity.assume") {
+    if (
+      event.event_type !== "coord.identity_attested" ||
+      event.payload.actor_instance_id !== transaction.actor_instance_id ||
+      event.payload.subject_instance_id !== transaction.subject_instance_id ||
+      event.payload.authority.transaction_id !== transaction.transaction_id ||
+      event.payload.identity_id !== mutation.identity_id
+    ) {
+      throw new Error("authority identity transaction does not match its event");
+    }
+    return;
+  }
+  if (mutation.kind === "decision.resolve") {
+    if (
+      event.event_type !== "decision.state_changed" ||
+      event.payload.authority.transaction_id !== transaction.transaction_id ||
+      event.payload.decision_id !== mutation.decision_id ||
+      event.payload.new_state !== mutation.outcome
+    ) {
+      throw new Error("authority decision transaction does not match its event");
+    }
+    return;
+  }
+  if (mutation.kind === "wait.start") {
+    if (
+      event.event_type !== "wait.started" ||
+      event.payload.authority_reference !== transaction.transaction_id ||
+      event.payload.wait_id !== mutation.wait_id ||
+      event.payload.kind !== mutation.wait_kind
+    ) {
+      throw new Error("authority wait-start transaction does not match its event");
+    }
+    return;
+  }
+  if (mutation.kind !== "wait.end") {
+    throw new Error("authority transaction mutation binding is unsupported");
+  }
+  if (
+    event.event_type !== "wait.ended" ||
+    event.payload.resolution_reference !== transaction.transaction_id ||
+    event.payload.wait_id !== mutation.wait_id ||
+    event.payload.outcome !== mutation.outcome
+  ) {
+    throw new Error("authority wait-end transaction does not match its event");
+  }
+}
+
+function validateReceipt(value: unknown): AuthorityReceiptV3 {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("authority receipt is invalid");
+  }
+  const receipt = value as Record<string, unknown>;
+  if (
+    Object.keys(receipt).sort().join("\0") !==
+      "committed_at\0desired_state_digest\0event_id\0event_row_digest\0format\0format_version\0transaction_digest\0transaction_id" ||
+    receipt.format !== "harnery-event-v3-authority-receipt" ||
+    receipt.format_version !== 1 ||
+    typeof receipt.transaction_id !== "string" ||
+    typeof receipt.transaction_digest !== "string" ||
+    typeof receipt.desired_state_digest !== "string" ||
+    typeof receipt.event_id !== "string" ||
+    typeof receipt.event_row_digest !== "string" ||
+    typeof receipt.committed_at !== "string" ||
+    !SHA256_PATTERN.test(receipt.transaction_digest) ||
+    !SHA256_PATTERN.test(receipt.desired_state_digest) ||
+    !SHA256_PATTERN.test(receipt.event_row_digest) ||
+    Number.isNaN(Date.parse(receipt.committed_at))
+  ) {
+    throw new Error("authority receipt values are invalid");
+  }
+  assertTransactionId(receipt.transaction_id);
+  return receipt as unknown as AuthorityReceiptV3;
+}
+
+function publishExclusive(path: string, serialized: string): void {
+  const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
+  let fd: number | undefined;
+  try {
+    fd = openSync(temporary, "wx", 0o600);
+    writeFileSync(fd, serialized, "utf8");
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = undefined;
+    linkSync(temporary, path);
+    fsyncParentDirectory(path);
+    unlinkSync(temporary);
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+    if (existsSync(temporary)) unlinkSync(temporary);
+  }
+}
+
+function authorityReadyPath(outbox: string, transactionId: string): string {
+  assertTransactionId(transactionId);
+  return join(outbox, `${transactionId}.ready.json`);
+}
+
+function authorityCommittedPath(outbox: string, transactionId: string): string {
+  assertTransactionId(transactionId);
+  return join(outbox, `${transactionId}.committed.json`);
+}
+
+function assertTransactionId(value: string): void {
+  if (!TX_PATTERN.test(value)) throw new Error("authority transaction ID is invalid");
+}

package/src/core/events/v3/base-builder.ts

@@ -0,0 +1,60 @@
+import type { EventOfTypeV3Base, EventPayloadV3Base, EventTypeV3Base } from "./base-contract.ts";
+import { EVENT_V3_BASE_CONTRACT_MAJOR, EVENT_V3_BASE_CONTRACT_NAME } from "./base-contract.ts";
+import { EVENT_V3_SCHEMA_DIGEST } from "./generated.ts";
+import { clockIdV3, eventIdV3 } from "./ids.ts";
+
+type EventWithoutDiscriminator<T extends EventTypeV3Base> = Omit<
+  EventOfTypeV3Base<T>,
+  "attestation_id" | "contract" | "event_id" | "event_type" | "payload" | "time"
+>;
+
+type RootEventTypeV3Base =
+  | "ledger.genesis"
+  | "ledger.activated"
+  | "ledger.schema_advanced"
+  | "ledger.comparability_advanced";
+
+type AttestationInputV3Base<T extends EventTypeV3Base> = T extends RootEventTypeV3Base
+  ? { attestation_id?: never }
+  : { attestation_id: `att_${string}` };
+
+export type BuildEventV3BaseInput<T extends EventTypeV3Base> = EventWithoutDiscriminator<T> &
+  AttestationInputV3Base<T> & {
+    payload: EventPayloadV3Base<T>;
+    event_id?: `evt_${string}`;
+    observed_at?: string;
+    recorded_at?: string;
+    monotonic_ns?: string;
+    clock_id?: `clk_${string}`;
+    skew?: "normal" | "regressed" | "unknown";
+  };
+
+export function buildEventV3Base<T extends EventTypeV3Base>(
+  eventType: T,
+  input: BuildEventV3BaseInput<T>,
+): EventOfTypeV3Base<T> {
+  const now = input.recorded_at ?? new Date().toISOString();
+  const event = {
+    contract: {
+      name: EVENT_V3_BASE_CONTRACT_NAME,
+      major: EVENT_V3_BASE_CONTRACT_MAJOR,
+      schema_digest: EVENT_V3_SCHEMA_DIGEST,
+    },
+    event_id: input.event_id ?? eventIdV3(),
+    event_type: eventType,
+    time: {
+      observed_at: input.observed_at ?? now,
+      recorded_at: now,
+      ...(input.monotonic_ns ? { monotonic_ns: input.monotonic_ns } : {}),
+      clock_id: input.clock_id ?? clockIdV3(),
+      skew: input.skew ?? "unknown",
+    },
+    producer: input.producer,
+    scope: input.scope,
+    ...(input.attestation_id ? { attestation_id: input.attestation_id } : {}),
+    links: input.links,
+    provenance: input.provenance,
+    payload: input.payload,
+  };
+  return event as unknown as EventOfTypeV3Base<T>;
+}