@complior/engine 0.9.0

package/src/domain/passport/export/aiuc1-mapper.ts

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+import type { AgentPassport } from '../../../types/passport.types.js';
+
+// --- AIUC-1 Compliance Profile Schema ---
+
+const DomainStatusSchema = z.object({
+  status: z.enum(['not_assessed', 'partial', 'compliant']),
+  findings: z.array(z.string()),
+  coveragePercent: z.number().min(0).max(100),
+});
+
+export const AIUC1ProfileSchema = z.object({
+  framework: z.literal('AIUC-1'),
+  version: z.literal('1.0'),
+  agent: z.object({ name: z.string(), id: z.string(), version: z.string() }),
+  domains: z.object({
+    a_data_privacy: DomainStatusSchema,
+    b_security: DomainStatusSchema,
+    c_safety: DomainStatusSchema,
+    d_reliability: DomainStatusSchema,
+    e_accountability: DomainStatusSchema,
+    f_society: DomainStatusSchema,
+  }),
+  overallReadiness: z.number().min(0).max(100),
+  assessmentDate: z.string(),
+});
+
+export type AIUC1Profile = z.infer<typeof AIUC1ProfileSchema>;
+
+type DomainStatus = z.infer<typeof DomainStatusSchema>;
+
+// --- Shared assessment helper (DRY: used by all 6 domain assessors) ---
+
+interface DomainCheck {
+  readonly filled: boolean;
+  readonly label: string;
+}
+
+const assessDomain = (checks: readonly DomainCheck[]): DomainStatus => {
+  const passed = checks.filter(c => c.filled);
+  const total = checks.length;
+  const ratio = total === 0 ? 0 : passed.length / total;
+
+  return {
+    status: ratio >= 1 ? 'compliant' : ratio > 0 ? 'partial' : 'not_assessed',
+    findings: passed.map(c => c.label),
+    coveragePercent: Math.round(ratio * 100),
+  };
+};
+
+// --- Domain assessors (pure functions, each returns checklist for its domain) ---
+
+const dataPrivacyChecks = (m: AgentPassport): readonly DomainCheck[] => [
+  { filled: m.disclosure.user_facing, label: 'User-facing disclosure configured' },
+  { filled: m.disclosure.disclosure_text !== '', label: 'Disclosure text provided' },
+  { filled: m.disclosure.ai_marking.responses_marked, label: 'AI marking enabled' },
+  { filled: m.logging.actions_logged, label: 'Actions logging enabled' },
+  { filled: m.model.data_residency !== '', label: 'Data residency specified' },
+];
+
+const securityChecks = (m: AgentPassport): readonly DomainCheck[] => [
+  { filled: m.constraints.rate_limits.max_actions_per_minute > 0, label: 'Rate limits configured' },
+  { filled: m.constraints.budget.max_cost_per_session_usd > 0, label: 'Budget limits set' },
+  { filled: m.permissions.denied.length > 0, label: 'Denied permissions defined' },
+  { filled: m.constraints.human_approval_required.length > 0, label: 'Human approval gates defined' },
+];
+
+const safetyChecks = (m: AgentPassport): readonly DomainCheck[] => [
+  { filled: true, label: `Autonomy level assessed: ${m.autonomy_level}` },
+  { filled: m.constraints.human_approval_required.length > 0, label: 'Human approval required for critical actions' },
+  { filled: m.compliance.fria_completed === true, label: 'FRIA completed' },
+  { filled: m.autonomy_evidence.human_approval_gates > 0, label: 'Human approval gates present' },
+];
+
+const reliabilityChecks = (m: AgentPassport): readonly DomainCheck[] => [
+  { filled: m.compliance.complior_score > 0, label: `Complior score: ${m.compliance.complior_score}` },
+  { filled: m.logging.includes_decision_rationale, label: 'Decision rationale logging enabled' },
+  { filled: m.compliance.last_scan !== '', label: 'Compliance scan performed' },
+  { filled: m.source.confidence > 0.5, label: `Source confidence: ${Math.round(m.source.confidence * 100)}%` },
+];
+
+const accountabilityChecks = (m: AgentPassport): readonly DomainCheck[] => [
+  { filled: m.logging.actions_logged, label: 'Actions logged' },
+  { filled: m.logging.retention_days > 0, label: `Retention: ${m.logging.retention_days} days` },
+  { filled: m.owner.responsible_person !== '', label: `Responsible person: ${m.owner.responsible_person}` },
+  { filled: m.owner.contact !== '', label: 'Contact information provided' },
+  { filled: m.lifecycle.review_frequency_days > 0, label: `Review frequency: ${m.lifecycle.review_frequency_days} days` },
+];
+
+const societyChecks = (m: AgentPassport): readonly DomainCheck[] => [
+  { filled: m.constraints.prohibited_actions.length > 0, label: 'Prohibited actions policy defined' },
+  { filled: true, label: `EU AI Act risk class: ${m.compliance.eu_ai_act.risk_class}` },
+  { filled: m.compliance.eu_ai_act.applicable_articles.length > 0, label: 'Applicable articles identified' },
+  { filled: m.compliance.worker_notification_sent === true, label: 'Worker notification sent' },
+];
+
+// --- Main export function ---
+
+export const mapToAIUC1 = (manifest: AgentPassport): AIUC1Profile => {
+  const domains = {
+    a_data_privacy: assessDomain(dataPrivacyChecks(manifest)),
+    b_security: assessDomain(securityChecks(manifest)),
+    c_safety: assessDomain(safetyChecks(manifest)),
+    d_reliability: assessDomain(reliabilityChecks(manifest)),
+    e_accountability: assessDomain(accountabilityChecks(manifest)),
+    f_society: assessDomain(societyChecks(manifest)),
+  };
+
+  const allCoverages = Object.values(domains).map(d => d.coveragePercent);
+  const overallReadiness = Math.round(
+    allCoverages.reduce((sum, c) => sum + c, 0) / allCoverages.length,
+  );
+
+  return {
+    framework: 'AIUC-1' as const,
+    version: '1.0' as const,
+    agent: {
+      name: manifest.display_name,
+      id: manifest.agent_id,
+      version: manifest.version,
+    },
+    domains,
+    overallReadiness,
+    assessmentDate: new Date().toISOString(),
+  };
+};

package/src/domain/passport/export/export.test.ts

@@ -0,0 +1,207 @@
+import { describe, it, expect } from 'vitest';
+import { createMockPassport } from '../../../test-helpers/factories.js';
+import { mapToA2A, A2ACardSchema } from './a2a-mapper.js';
+import { mapToAIUC1, AIUC1ProfileSchema } from './aiuc1-mapper.js';
+import { mapToNIST, NISTProfileSchema } from './nist-mapper.js';
+import { exportPassport } from './index.js';
+import type { AgentPassport } from '../../../types/passport.types.js';
+
+// --- A2A Tests ---
+
+describe('A2A Mapper', () => {
+  it('maps complete passport to valid A2A card', () => {
+    const manifest = createMockPassport();
+    const card = mapToA2A(manifest);
+
+    expect(card.schemaVersion).toBe('1.0.0');
+    expect(card.name).toBe('Test Agent');
+    expect(card.humanReadableId).toBe('test-agent');
+    expect(card.agentVersion).toBe('1.0.0');
+    expect(card.description).toBe('An AI agent for testing compliance');
+    expect(card.provider.name).toBe('OpenAI');
+    expect(card.provider.url).toBe('https://openai.com');
+    expect(card.lastUpdated).toBe('2026-01-01T00:00:00Z');
+  });
+
+  it('maps tools to skills array', () => {
+    const manifest = createMockPassport({
+      permissions: {
+        tools: ['search', 'read', 'write'],
+        data_access: { read: [], write: [], delete: [] },
+        denied: [],
+      },
+    });
+    const card = mapToA2A(manifest);
+
+    expect(card.skills).toHaveLength(3);
+    expect(card.skills[0]).toEqual({
+      id: 'skill-1',
+      name: 'search',
+      description: 'Tool capability: search',
+    });
+    expect(card.skills[1]?.name).toBe('read');
+    expect(card.skills[2]?.name).toBe('write');
+  });
+
+  it('handles empty optional fields gracefully', () => {
+    const manifest = createMockPassport({
+      permissions: {
+        tools: [],
+        data_access: { read: [], write: [], delete: [] },
+        denied: [],
+      },
+    });
+    const card = mapToA2A(manifest);
+
+    expect(card.skills).toHaveLength(0);
+    expect(card.tags.length).toBeGreaterThan(0);
+  });
+
+  it('output validates against A2ACardSchema', () => {
+    const manifest = createMockPassport();
+    const card = mapToA2A(manifest);
+
+    expect(A2ACardSchema.safeParse(card).success).toBe(true);
+  });
+});
+
+// --- AIUC-1 Tests ---
+
+describe('AIUC-1 Mapper', () => {
+  it('maps complete passport to 6 domains populated', () => {
+    const manifest = createMockPassport();
+    const profile = mapToAIUC1(manifest);
+
+    expect(profile.framework).toBe('AIUC-1');
+    expect(profile.version).toBe('1.0');
+    expect(profile.agent.name).toBe('Test Agent');
+    expect(profile.domains.a_data_privacy).toBeDefined();
+    expect(profile.domains.b_security).toBeDefined();
+    expect(profile.domains.c_safety).toBeDefined();
+    expect(profile.domains.d_reliability).toBeDefined();
+    expect(profile.domains.e_accountability).toBeDefined();
+    expect(profile.domains.f_society).toBeDefined();
+  });
+
+  it('derives domain status from field completeness', () => {
+    const manifest = createMockPassport();
+    const profile = mapToAIUC1(manifest);
+
+    for (const domain of Object.values(profile.domains)) {
+      expect(['not_assessed', 'partial', 'compliant']).toContain(domain.status);
+      expect(domain.coveragePercent).toBeGreaterThanOrEqual(0);
+      expect(domain.coveragePercent).toBeLessThanOrEqual(100);
+    }
+    expect(profile.overallReadiness).toBeGreaterThan(0);
+  });
+
+  it('handles incomplete passport with degraded coverage', () => {
+    const manifest = createMockPassport({
+      disclosure: { user_facing: false, disclosure_text: '', ai_marking: { responses_marked: false, method: '' } },
+      logging: { actions_logged: false, retention_days: 0, includes_decision_rationale: false },
+      constraints: {
+        rate_limits: { max_actions_per_minute: 0 },
+        budget: { max_cost_per_session_usd: 0 },
+        human_approval_required: [],
+        prohibited_actions: [],
+      },
+    });
+    const profile = mapToAIUC1(manifest);
+
+    // Data privacy: 1/5 (data_residency still set) → partial
+    expect(profile.domains.a_data_privacy.coveragePercent).toBe(20);
+    expect(profile.domains.a_data_privacy.status).toBe('partial');
+    // Security: 0/4 checks pass → not_assessed
+    expect(profile.domains.b_security.status).toBe('not_assessed');
+  });
+
+  it('output validates against AIUC1ProfileSchema', () => {
+    const manifest = createMockPassport();
+    const profile = mapToAIUC1(manifest);
+
+    expect(AIUC1ProfileSchema.safeParse(profile).success).toBe(true);
+  });
+});
+
+// --- NIST Tests ---
+
+describe('NIST AI RMF Mapper', () => {
+  it('maps complete passport to 4 functions populated', () => {
+    const manifest = createMockPassport();
+    const profile = mapToNIST(manifest);
+
+    expect(profile.framework).toBe('NIST-AI-RMF');
+    expect(profile.version).toBe('1.0');
+    expect(profile.agent.name).toBe('Test Agent');
+    expect(profile.functions.govern).toBeDefined();
+    expect(profile.functions.map).toBeDefined();
+    expect(profile.functions.measure).toBeDefined();
+    expect(profile.functions.manage).toBeDefined();
+  });
+
+  it('derives function status from field presence', () => {
+    const manifest = createMockPassport();
+    const profile = mapToNIST(manifest);
+
+    for (const fn of Object.values(profile.functions)) {
+      expect(['not_started', 'in_progress', 'implemented']).toContain(fn.status);
+      expect(fn.categories.length).toBeGreaterThan(0);
+      for (const cat of fn.categories) {
+        expect(cat.id).toBeTruthy();
+        expect(cat.name).toBeTruthy();
+      }
+    }
+    expect(profile.overallMaturity).toBeGreaterThan(0);
+  });
+
+  it('handles incomplete passport with not_started status', () => {
+    const manifest = createMockPassport({
+      owner: { team: '', contact: '', responsible_person: '' },
+      constraints: {
+        rate_limits: { max_actions_per_minute: 0 },
+        budget: { max_cost_per_session_usd: 0 },
+        human_approval_required: [],
+        prohibited_actions: [],
+      },
+      compliance: {
+        eu_ai_act: {
+          risk_class: 'minimal',
+          applicable_articles: [],
+          deployer_obligations_met: [],
+          deployer_obligations_pending: [],
+        },
+        complior_score: 0,
+        last_scan: '',
+      },
+      logging: { actions_logged: false, retention_days: 0, includes_decision_rationale: false },
+      disclosure: { user_facing: false, disclosure_text: '', ai_marking: { responses_marked: false, method: '' } },
+    });
+    const profile = mapToNIST(manifest);
+
+    // Govern: no owner fields, no constraints → GV-1 not_started
+    expect(profile.functions.govern.completionPercent).toBe(0);
+  });
+
+  it('output validates against NISTProfileSchema', () => {
+    const manifest = createMockPassport();
+    const profile = mapToNIST(manifest);
+
+    expect(NISTProfileSchema.safeParse(profile).success).toBe(true);
+  });
+});
+
+// --- Orchestrator Tests ---
+
+describe('exportPassport orchestrator', () => {
+  it('exports to all three formats with valid flag', () => {
+    const manifest = createMockPassport();
+
+    for (const format of ['a2a', 'aiuc-1', 'nist'] as const) {
+      const result = exportPassport(manifest, format);
+      expect(result.format).toBe(format);
+      expect(result.valid).toBe(true);
+      expect(result.data).toBeDefined();
+      expect(result.timestamp).toBeTruthy();
+    }
+  });
+});

package/src/domain/passport/export/index.ts

@@ -0,0 +1,41 @@
+import type { AgentPassport } from '../../../types/passport.types.js';
+import { mapToA2A, A2ACardSchema } from './a2a-mapper.js';
+import type { A2ACard } from './a2a-mapper.js';
+import { mapToAIUC1, AIUC1ProfileSchema } from './aiuc1-mapper.js';
+import type { AIUC1Profile } from './aiuc1-mapper.js';
+import { mapToNIST, NISTProfileSchema } from './nist-mapper.js';
+import type { NISTProfile } from './nist-mapper.js';
+
+export type ExportFormat = 'a2a' | 'aiuc-1' | 'nist';
+
+// Discriminated union — каждый format гарантирует свой тип data
+export type ExportResult =
+  | { readonly format: 'a2a'; readonly data: A2ACard; readonly timestamp: string; readonly valid: boolean }
+  | { readonly format: 'aiuc-1'; readonly data: AIUC1Profile; readonly timestamp: string; readonly valid: boolean }
+  | { readonly format: 'nist'; readonly data: NISTProfile; readonly timestamp: string; readonly valid: boolean };
+
+export const exportPassport = (manifest: AgentPassport, format: ExportFormat): ExportResult => {
+  const timestamp = new Date().toISOString();
+
+  switch (format) {
+    case 'a2a': {
+      const data = mapToA2A(manifest);
+      return { format, data, timestamp, valid: A2ACardSchema.safeParse(data).success };
+    }
+    case 'aiuc-1': {
+      const data = mapToAIUC1(manifest);
+      return { format, data, timestamp, valid: AIUC1ProfileSchema.safeParse(data).success };
+    }
+    case 'nist': {
+      const data = mapToNIST(manifest);
+      return { format, data, timestamp, valid: NISTProfileSchema.safeParse(data).success };
+    }
+  }
+};
+
+export { mapToA2A, A2ACardSchema } from './a2a-mapper.js';
+export type { A2ACard } from './a2a-mapper.js';
+export { mapToAIUC1, AIUC1ProfileSchema } from './aiuc1-mapper.js';
+export type { AIUC1Profile } from './aiuc1-mapper.js';
+export { mapToNIST, NISTProfileSchema } from './nist-mapper.js';
+export type { NISTProfile } from './nist-mapper.js';

package/src/domain/passport/export/nist-mapper.ts

@@ -0,0 +1,227 @@
+import { z } from 'zod';
+import type { AgentPassport } from '../../../types/passport.types.js';
+
+// --- NIST AI RMF Profile Schema ---
+
+const CategorySchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  status: z.enum(['not_started', 'in_progress', 'implemented']),
+  evidence: z.array(z.string()),
+});
+
+const FunctionStatusSchema = z.object({
+  status: z.enum(['not_started', 'in_progress', 'implemented']),
+  categories: z.array(CategorySchema),
+  completionPercent: z.number().min(0).max(100),
+});
+
+export const NISTProfileSchema = z.object({
+  framework: z.literal('NIST-AI-RMF'),
+  version: z.literal('1.0'),
+  agent: z.object({ name: z.string(), id: z.string(), version: z.string() }),
+  functions: z.object({
+    govern: FunctionStatusSchema,
+    map: FunctionStatusSchema,
+    measure: FunctionStatusSchema,
+    manage: FunctionStatusSchema,
+  }),
+  overallMaturity: z.number().min(0).max(100),
+  profileDate: z.string(),
+});
+
+export type NISTProfile = z.infer<typeof NISTProfileSchema>;
+
+type FunctionStatus = z.infer<typeof FunctionStatusSchema>;
+
+// --- Shared helpers (DRY: status derivation used by all category/function assessors) ---
+
+interface CategoryInput {
+  readonly id: string;
+  readonly name: string;
+  readonly evidence: readonly string[];
+}
+
+const deriveCategoryStatus = (evidence: readonly string[]): 'not_started' | 'in_progress' | 'implemented' => {
+  if (evidence.length === 0) return 'not_started';
+  if (evidence.length >= 2) return 'implemented';
+  return 'in_progress';
+};
+
+const buildFunction = (inputs: readonly CategoryInput[]): FunctionStatus => {
+  const categories = inputs.map(input => ({
+    id: input.id,
+    name: input.name,
+    status: deriveCategoryStatus(input.evidence),
+    evidence: [...input.evidence],
+  }));
+
+  const implemented = categories.filter(c => c.status === 'implemented').length;
+  const hasProgress = categories.some(c => c.status === 'in_progress');
+
+  return {
+    status: implemented === categories.length ? 'implemented'
+      : (implemented > 0 || hasProgress) ? 'in_progress'
+        : 'not_started',
+    categories,
+    completionPercent: Math.round((implemented / categories.length) * 100),
+  };
+};
+
+// --- Conditional evidence collector (avoids spread noise) ---
+
+const evidence = (...items: readonly (string | false)[]): string[] =>
+  items.filter((item): item is string => item !== false);
+
+// --- Function assessors (pure functions returning category inputs) ---
+
+const governCategories = (m: AgentPassport): readonly CategoryInput[] => [
+  {
+    id: 'GV-1',
+    name: 'Policies & Procedures',
+    evidence: evidence(
+      m.owner.responsible_person !== '' && `Responsible person: ${m.owner.responsible_person}`,
+      m.owner.team !== '' && `Team: ${m.owner.team}`,
+      m.owner.contact !== '' && `Contact: ${m.owner.contact}`,
+    ),
+  },
+  {
+    id: 'GV-2',
+    name: 'Accountability Structures',
+    evidence: evidence(
+      m.constraints.human_approval_required.length > 0 && `Human approval required for: ${m.constraints.human_approval_required.join(', ')}`,
+      m.lifecycle.review_frequency_days > 0 && `Review frequency: ${m.lifecycle.review_frequency_days} days`,
+    ),
+  },
+  {
+    id: 'GV-3',
+    name: 'Risk Constraints',
+    evidence: evidence(
+      m.constraints.rate_limits.max_actions_per_minute > 0 && `Rate limit: ${m.constraints.rate_limits.max_actions_per_minute}/min`,
+      m.constraints.budget.max_cost_per_session_usd > 0 && `Budget: $${m.constraints.budget.max_cost_per_session_usd}/session`,
+      m.constraints.prohibited_actions.length > 0 && `Prohibited actions: ${m.constraints.prohibited_actions.length}`,
+    ),
+  },
+];
+
+const mapCategories = (m: AgentPassport): readonly CategoryInput[] => [
+  {
+    id: 'MP-1',
+    name: 'System Context',
+    evidence: evidence(
+      `Agent type: ${m.type}`,
+      `Autonomy level: ${m.autonomy_level}`,
+      m.description !== '' && 'Description provided',
+    ),
+  },
+  {
+    id: 'MP-2',
+    name: 'AI Model Identification',
+    evidence: evidence(
+      m.model.provider !== '' && `Provider: ${m.model.provider}`,
+      m.model.model_id !== '' && `Model: ${m.model.model_id}`,
+      m.model.deployment !== '' && `Deployment: ${m.model.deployment}`,
+    ),
+  },
+  {
+    id: 'MP-3',
+    name: 'Risk Categorization',
+    evidence: evidence(
+      `Risk class: ${m.compliance.eu_ai_act.risk_class}`,
+      m.compliance.eu_ai_act.applicable_articles.length > 0 && `Applicable articles: ${m.compliance.eu_ai_act.applicable_articles.join(', ')}`,
+    ),
+  },
+  {
+    id: 'MP-4',
+    name: 'Permissions & Data Access',
+    evidence: evidence(
+      m.permissions.tools.length > 0 && `Tools: ${m.permissions.tools.join(', ')}`,
+      m.permissions.denied.length > 0 && `Denied: ${m.permissions.denied.join(', ')}`,
+    ),
+  },
+];
+
+const measureCategories = (m: AgentPassport): readonly CategoryInput[] => [
+  {
+    id: 'MS-1',
+    name: 'Compliance Scoring',
+    evidence: evidence(
+      m.compliance.complior_score > 0 && `Complior score: ${m.compliance.complior_score}`,
+      m.compliance.last_scan !== '' && `Last scan: ${m.compliance.last_scan}`,
+    ),
+  },
+  {
+    id: 'MS-2',
+    name: 'Autonomy Assessment',
+    evidence: evidence(
+      m.autonomy_evidence.human_approval_gates > 0 && `Human approval gates: ${m.autonomy_evidence.human_approval_gates}`,
+      m.autonomy_evidence.unsupervised_actions > 0 && `Unsupervised actions tracked: ${m.autonomy_evidence.unsupervised_actions}`,
+    ),
+  },
+  {
+    id: 'MS-3',
+    name: 'Transparency & Disclosure',
+    evidence: evidence(
+      m.disclosure.user_facing && 'User-facing disclosure enabled',
+      m.disclosure.ai_marking.responses_marked && `AI marking: ${m.disclosure.ai_marking.method}`,
+    ),
+  },
+];
+
+const manageCategories = (m: AgentPassport): readonly CategoryInput[] => [
+  {
+    id: 'MG-1',
+    name: 'Lifecycle Management',
+    evidence: evidence(
+      `Status: ${m.lifecycle.status}`,
+      m.lifecycle.deployed_since !== '' && `Deployed since: ${m.lifecycle.deployed_since}`,
+      m.lifecycle.next_review !== '' && `Next review: ${m.lifecycle.next_review}`,
+    ),
+  },
+  {
+    id: 'MG-2',
+    name: 'Monitoring & Logging',
+    evidence: evidence(
+      m.logging.actions_logged && 'Actions logged',
+      m.logging.retention_days > 0 && `Retention: ${m.logging.retention_days} days`,
+      m.logging.includes_decision_rationale && 'Decision rationale included',
+    ),
+  },
+  {
+    id: 'MG-3',
+    name: 'Impact Assessment',
+    evidence: evidence(
+      m.compliance.fria_completed === true && 'FRIA completed',
+      m.compliance.worker_notification_sent === true && 'Worker notification sent',
+    ),
+  },
+];
+
+// --- Main export function ---
+
+export const mapToNIST = (manifest: AgentPassport): NISTProfile => {
+  const functions = {
+    govern: buildFunction(governCategories(manifest)),
+    map: buildFunction(mapCategories(manifest)),
+    measure: buildFunction(measureCategories(manifest)),
+    manage: buildFunction(manageCategories(manifest)),
+  };
+
+  const allCompletions = Object.values(functions).map(f => f.completionPercent);
+  const overallMaturity = Math.round(
+    allCompletions.reduce((sum, c) => sum + c, 0) / allCompletions.length,
+  );
+
+  return {
+    framework: 'NIST-AI-RMF' as const,
+    version: '1.0' as const,
+    agent: {
+      name: manifest.display_name,
+      id: manifest.agent_id,
+      version: manifest.version,
+    },
+    functions,
+    overallMaturity,
+    profileDate: new Date().toISOString(),
+  };
+};