@complior/engine 0.9.0

package/src/domain/fria/fria-generator.test.ts

@@ -0,0 +1,273 @@
+import { describe, it, expect } from 'vitest';
+import { generateFria, generateFriaStructured } from './fria-generator.js';
+import type { AgentPassport } from '../../types/passport.types.js';
+import { createMockPassport } from '../../test-helpers/factories.js';
+
+const TEMPLATE = `# Template 3: Fundamental Rights Impact Assessment (FRIA)
+
+### 1. Assessment Header
+
+| Field | Value |
+|-------|-------|
+| Document Title | Fundamental Rights Impact Assessment — [AI System Name] |
+| Assessment ID | FRIA-[YYYY]-[NNN] |
+| Date | [Date] |
+| Assessor | [Name, Title] |
+| DPO Consulted | [Name, Date] |
+
+### 2. AI System Description
+
+- System name: [Name]
+- Provider: [Name]
+- Version: [Number]
+- Intended purpose: [Description]
+- Deployment context: [Where and how the system is used]
+
+### 3. Deployer Information
+
+- Organisation: [Name]
+
+### 4. Fundamental Rights Risk Assessment
+
+| Fundamental Right | Risk Level | Description |
+|---|---|---|
+| Non-discrimination | [H/M/L/N] | [Description] |
+| Privacy | [H/M/L/N] | [Description] |
+
+### 5. Mitigation Measures and Human Oversight
+- Override mechanism: [Description of how human can intervene/stop the system]
+`;
+
+const createManifest = createMockPassport;
+
+describe('generateFria', () => {
+  it('replaces AI System Name from manifest', () => {
+    const result = generateFria({ manifest: createManifest(), template: TEMPLATE });
+    expect(result.markdown).toContain('Fundamental Rights Impact Assessment — Test Agent');
+    expect(result.prefilledFields).toContain('AI System Name');
+  });
+
+  it('replaces Provider from manifest.model.provider', () => {
+    const result = generateFria({ manifest: createManifest(), template: TEMPLATE });
+    expect(result.markdown).toContain('Provider: OpenAI');
+    expect(result.prefilledFields).toContain('Provider');
+  });
+
+  it('replaces Version from manifest.version', () => {
+    const result = generateFria({ manifest: createManifest(), template: TEMPLATE });
+    expect(result.markdown).toContain('Version: 1.0.0');
+    expect(result.prefilledFields).toContain('Version');
+  });
+
+  it('replaces Intended purpose from manifest.description', () => {
+    const result = generateFria({ manifest: createManifest(), template: TEMPLATE });
+    expect(result.markdown).toContain('Intended purpose: An AI agent for testing compliance');
+    expect(result.prefilledFields).toContain('Intended purpose');
+  });
+
+  it('generates FRIA ID with current year', () => {
+    const result = generateFria({ manifest: createManifest(), template: TEMPLATE });
+    const year = new Date().getFullYear();
+    expect(result.markdown).toMatch(new RegExp(`FRIA-${year}-\\d{3}`));
+    expect(result.prefilledFields).toContain('Assessment ID');
+  });
+
+  it('fills date with current date', () => {
+    const result = generateFria({ manifest: createManifest(), template: TEMPLATE });
+    const today = new Date().toISOString().slice(0, 10);
+    expect(result.markdown).toContain(today);
+  });
+
+  it('uses organization param over manifest.owner.team', () => {
+    const result = generateFria({
+      manifest: createManifest(),
+      template: TEMPLATE,
+      organization: 'Custom Org',
+    });
+    expect(result.markdown).toContain('Organisation: Custom Org');
+  });
+
+  it('falls back to owner.team when no organization param', () => {
+    const result = generateFria({ manifest: createManifest(), template: TEMPLATE });
+    expect(result.markdown).toContain('Organisation: Acme Corp');
+  });
+
+  it('fills assessor when provided', () => {
+    const result = generateFria({
+      manifest: createManifest(),
+      template: TEMPLATE,
+      assessor: 'Jane Doe, CTO',
+    });
+    expect(result.markdown).toContain('Jane Doe, CTO');
+    expect(result.prefilledFields).toContain('Assessor');
+  });
+
+  it('lists assessor as manual field when not provided', () => {
+    const result = generateFria({ manifest: createManifest(), template: TEMPLATE });
+    expect(result.manualFields).toContain('Assessor (Name, Title)');
+  });
+
+  it('pre-fills risk level from high-risk passport', () => {
+    const result = generateFria({ manifest: createManifest(), template: TEMPLATE });
+    // First row should get H (high risk)
+    expect(result.markdown).toContain('| H |');
+  });
+
+  it('generates human oversight description from autonomy level', () => {
+    const result = generateFria({ manifest: createManifest(), template: TEMPLATE });
+    expect(result.markdown).toContain('direct human supervision');
+    expect(result.prefilledFields).toContain('Human oversight mechanism');
+  });
+
+  it('includes human_approval_required in oversight', () => {
+    const result = generateFria({ manifest: createManifest(), template: TEMPLATE });
+    expect(result.markdown).toContain('deploy, delete');
+  });
+
+  it('lists manual fields that cannot be auto-filled', () => {
+    const result = generateFria({ manifest: createManifest(), template: TEMPLATE });
+    expect(result.manualFields).toContain('DPO Consulted (Name, Date)');
+    expect(result.manualFields).toContain('Deployment context');
+    expect(result.manualFields).toContain('Overall risk assessment decision');
+    expect(result.manualFields).toContain('Assessor sign-off');
+    expect(result.manualFields.length).toBeGreaterThan(10);
+  });
+
+  it('returns frozen result', () => {
+    const result = generateFria({ manifest: createManifest(), template: TEMPLATE });
+    expect(Object.isFrozen(result)).toBe(true);
+    expect(Object.isFrozen(result.prefilledFields)).toBe(true);
+    expect(Object.isFrozen(result.manualFields)).toBe(true);
+  });
+
+  it('pre-fills impact when provided', () => {
+    const result = generateFria({
+      manifest: createManifest(),
+      template: TEMPLATE + '\n[e.g., AI may produce biased outcomes against certain ethnic groups in credit decisions]',
+      impact: 'Credit scoring bias against minorities',
+    });
+    expect(result.markdown).toContain('Credit scoring bias against minorities');
+    expect(result.prefilledFields).toContain('Impact description');
+    expect(result.manualFields).not.toContain('Fundamental Rights risk descriptions');
+  });
+
+  it('pre-fills mitigation when provided', () => {
+    const result = generateFria({
+      manifest: createManifest(),
+      template: TEMPLATE + '\n[e.g., Regular bias audits, human review of rejections, fairness metrics monitoring]',
+      mitigation: 'Quarterly bias audits and model retraining',
+    });
+    expect(result.markdown).toContain('Quarterly bias audits and model retraining');
+    expect(result.prefilledFields).toContain('Mitigation measures');
+    expect(result.manualFields).not.toContain('Mitigation measures');
+  });
+
+  it('pre-fills approval when provided', () => {
+    const result = generateFria({
+      manifest: createManifest(),
+      template: TEMPLATE + '\nDecision-maker: _________________ Date: _________',
+      approval: 'Jane Doe, CTO',
+    });
+    expect(result.markdown).toContain('Decision-maker: Jane Doe, CTO');
+    expect(result.prefilledFields).toContain('Decision-maker sign-off');
+    expect(result.manualFields).not.toContain('Decision-maker sign-off');
+  });
+
+  it('leaves manual fields when flags not provided', () => {
+    const result = generateFria({
+      manifest: createManifest(),
+      template: TEMPLATE + '\n[e.g., AI may produce biased outcomes against certain ethnic groups in credit decisions]\n[e.g., Regular bias audits, human review of rejections, fairness metrics monitoring]\nDecision-maker: _________________ Date: _________',
+    });
+    expect(result.manualFields).toContain('Fundamental Rights risk descriptions');
+    expect(result.manualFields).toContain('Mitigation measures');
+    expect(result.manualFields).toContain('Decision-maker sign-off');
+  });
+
+  it('includes structured payload in result', () => {
+    const result = generateFria({ manifest: createManifest(), template: TEMPLATE });
+    expect(result.structured).toBeDefined();
+    expect(result.structured.toolSlug).toBe('agent-test-001');
+    expect(result.structured.sections.general_info.toolName).toBe('Test Agent');
+  });
+});
+
+describe('generateFriaStructured', () => {
+  it('maps general_info from manifest', () => {
+    const s = generateFriaStructured({ manifest: createManifest(), template: '' });
+    expect(s.toolSlug).toBe('agent-test-001');
+    expect(s.sections.general_info.toolName).toBe('Test Agent');
+    expect(s.sections.general_info.vendor).toBe('Acme Corp');
+    expect(s.sections.general_info.purpose).toBe('An AI agent for testing compliance');
+    expect(s.sections.general_info.riskLevel).toBe('high');
+    expect(s.sections.general_info.version).toBe('1.0.0');
+    expect(s.sections.general_info.provider).toBe('OpenAI');
+  });
+
+  it('uses organization option over manifest.owner.team', () => {
+    const s = generateFriaStructured({ manifest: createManifest(), template: '', organization: 'Custom Org' });
+    expect(s.sections.general_info.organisation).toBe('Custom Org');
+  });
+
+  it('falls back to owner.team for organisation', () => {
+    const s = generateFriaStructured({ manifest: createManifest(), template: '' });
+    expect(s.sections.general_info.organisation).toBe('Acme Corp');
+  });
+
+  it('fills assessorName when assessor provided', () => {
+    const s = generateFriaStructured({ manifest: createManifest(), template: '', assessor: 'Jane Doe' });
+    expect(s.sections.general_info.assessorName).toBe('Jane Doe');
+  });
+
+  it('generates 8 Charter rights in specific_risks', () => {
+    const s = generateFriaStructured({ manifest: createManifest(), template: '' });
+    expect(s.sections.specific_risks.risks).toHaveLength(8);
+    expect(s.sections.specific_risks.risks[0]!.right).toBe('Non-discrimination');
+    expect(s.sections.specific_risks.risks[0]!.article).toBe('Art. 21');
+  });
+
+  it('pre-fills first risk severity from high-risk passport', () => {
+    const s = generateFriaStructured({ manifest: createManifest(), template: '' });
+    expect(s.sections.specific_risks.risks[0]!.severity).toBe('H');
+    expect(s.sections.specific_risks.risks[1]!.severity).toBe('');
+  });
+
+  it('sets severity L for minimal risk', () => {
+    const manifest = createManifest({
+      compliance: { ...createManifest().compliance, eu_ai_act: { ...createManifest().compliance.eu_ai_act, risk_class: 'minimal' } },
+    } as Partial<AgentPassport>);
+    const s = generateFriaStructured({ manifest, template: '' });
+    expect(s.sections.specific_risks.risks[0]!.severity).toBe('L');
+  });
+
+  it('derives human_oversight from autonomy level L2', () => {
+    const s = generateFriaStructured({ manifest: createManifest(), template: '' });
+    expect(s.sections.human_oversight.hasHumanOversight).toBe(true);
+    expect(s.sections.human_oversight.oversightType).toBe('pre_decision');
+    expect(s.sections.human_oversight.mechanism).toContain('3 human approval gate(s)');
+  });
+
+  it('derives human_oversight from autonomy level L4', () => {
+    const manifest = createManifest({ autonomy_level: 'L4' } as Partial<AgentPassport>);
+    const s = generateFriaStructured({ manifest, template: '' });
+    expect(s.sections.human_oversight.hasHumanOversight).toBe(false);
+    expect(s.sections.human_oversight.oversightType).toBe('post_hoc');
+  });
+
+  it('leaves manual fields as empty strings/arrays', () => {
+    const s = generateFriaStructured({ manifest: createManifest(), template: '' });
+    expect(s.sections.general_info.deploymentContext).toBe('');
+    expect(s.sections.general_info.geographicScope).toBe('');
+    expect(s.sections.affected_persons.categories).toEqual([]);
+    expect(s.sections.affected_persons.description).toBe('');
+    expect(s.sections.mitigation_measures.measures).toEqual([]);
+    expect(s.sections.monitoring_plan.metrics).toEqual([]);
+    expect(s.sections.monitoring_plan.frequency).toBe('');
+  });
+
+  it('generates valid assessmentId and date', () => {
+    const s = generateFriaStructured({ manifest: createManifest(), template: '' });
+    const year = new Date().getFullYear();
+    expect(s.assessmentId).toMatch(new RegExp(`^FRIA-${year}-\\d{3}$`));
+    expect(s.date).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+  });
+});

package/src/domain/fria/fria-generator.ts

@@ -0,0 +1,366 @@
+import type { AgentPassport } from '../../types/passport.types.js';
+import { mapDomain } from '../passport/builder/domain-mapper.js';
+import { deriveOversightDescription } from '../documents/passport-helpers.js';
+
+// --- Types ---
+
+export interface FriaGeneratorInput {
+  readonly manifest: AgentPassport;
+  readonly template: string;
+  readonly organization?: string;
+  readonly assessor?: string;
+  readonly impact?: string;
+  readonly mitigation?: string;
+  readonly approval?: string;
+}
+
+export interface FriaResult {
+  readonly markdown: string;
+  readonly structured: FriaStructuredPayload;
+  readonly prefilledFields: readonly string[];
+  readonly manualFields: readonly string[];
+}
+
+/** Structured FRIA payload — matches SaaS FRIASection schema */
+export interface FriaStructuredPayload {
+  readonly toolSlug: string;
+  readonly assessmentId: string;
+  readonly date: string;
+  readonly sections: {
+    readonly general_info: {
+      readonly toolName: string;
+      readonly vendor: string;
+      readonly purpose: string;
+      readonly domain: string;
+      readonly riskLevel: string;
+      readonly version: string;
+      readonly provider: string;
+      readonly deploymentContext: string;
+      readonly assessorName: string;
+      readonly assessorTitle: string;
+      readonly geographicScope: string;
+      readonly organisation: string;
+      readonly organisationType: string;
+    };
+    readonly affected_persons: {
+      readonly categories: readonly string[];
+      readonly vulnerableGroups: boolean;
+      readonly estimatedCount: string;
+      readonly description: string;
+    };
+    readonly specific_risks: {
+      readonly risks: ReadonlyArray<{
+        readonly right: string;
+        readonly article: string;
+        readonly severity: string;
+        readonly likelihood: string;
+        readonly description: string;
+        readonly affectedGroups: string;
+        readonly mitigation: string;
+      }>;
+    };
+    readonly human_oversight: {
+      readonly hasHumanOversight: boolean;
+      readonly oversightType: string;
+      readonly mechanism: string;
+      readonly responsibleRole: string;
+      readonly escalationProcess: string;
+      readonly reviewFrequency: string;
+    };
+    readonly mitigation_measures: {
+      readonly measures: ReadonlyArray<{
+        readonly risk: string;
+        readonly measure: string;
+        readonly responsible: string;
+        readonly deadline: string;
+      }>;
+      readonly incidentResponse: string;
+      readonly communicationPlan: string;
+      readonly suspensionCriteria: string;
+      readonly remediationProcess: string;
+      readonly internalComplaint: string;
+      readonly externalComplaint: string;
+    };
+    readonly monitoring_plan: {
+      readonly frequency: string;
+      readonly metrics: readonly string[];
+      readonly responsibleTeam: string;
+      readonly reviewProcess: string;
+      readonly nextReviewDate: string;
+      readonly dpiaReference: string;
+      readonly legalBasis: string;
+      readonly overallRiskDecision: string;
+      readonly conditionsForDeployment: string;
+    };
+  };
+}
+
+// --- Helpers ---
+
+const generateFriaId = (): string => {
+  const year = new Date().getFullYear();
+  const seq = String(Math.floor(Math.random() * 999) + 1).padStart(3, '0');
+  return `FRIA-${year}-${seq}`;
+};
+
+const deriveRiskLevel = (riskClass: string): string => {
+  switch (riskClass) {
+    case 'prohibited': return 'H';
+    case 'high': return 'H';
+    case 'limited': return 'M';
+    case 'minimal': return 'L';
+    default: return '[H/M/L/N]';
+  }
+};
+
+// --- Charter Rights for FRIA ---
+
+const CHARTER_RIGHTS = [
+  { right: 'Non-discrimination', article: 'Art. 21' },
+  { right: 'Privacy and data protection', article: 'Arts. 7-8' },
+  { right: 'Freedom of expression', article: 'Art. 11' },
+  { right: 'Human dignity', article: 'Art. 1' },
+  { right: 'Right to effective remedy', article: 'Art. 47' },
+  { right: 'Rights of the child', article: 'Art. 24' },
+  { right: 'Workers\' rights', article: 'Art. 31' },
+  { right: 'Right to good administration', article: 'Art. 41' },
+] as const;
+
+const mapOversightType = (level: string): string => {
+  if (level === 'L1' || level === 'L2') return 'pre_decision';
+  if (level === 'L3') return 'concurrent';
+  return 'post_hoc';
+};
+
+/** Generate structured FRIA JSON from manifest data */
+export const generateFriaStructured = (input: FriaGeneratorInput): FriaStructuredPayload => {
+  const { manifest, organization, assessor } = input;
+  const today = new Date().toISOString().slice(0, 10);
+  const riskClass = manifest.compliance?.eu_ai_act?.risk_class ?? '';
+  const firstSeverity = deriveRiskLevel(riskClass);
+
+  return {
+    toolSlug: manifest.agent_id,
+    assessmentId: generateFriaId(),
+    date: today,
+    sections: {
+      general_info: {
+        toolName: manifest.display_name,
+        vendor: manifest.owner?.team ?? '',
+        purpose: manifest.description,
+        domain: mapDomain(manifest),
+        riskLevel: riskClass,
+        version: manifest.version,
+        provider: manifest.model?.provider ?? '',
+        deploymentContext: '',
+        assessorName: assessor ?? '',
+        assessorTitle: '',
+        geographicScope: '',
+        organisation: organization ?? manifest.owner?.team ?? '',
+        organisationType: '',
+      },
+      affected_persons: {
+        categories: [],
+        vulnerableGroups: false,
+        estimatedCount: '',
+        description: '',
+      },
+      specific_risks: {
+        risks: CHARTER_RIGHTS.map((cr, i) => ({
+          right: cr.right,
+          article: cr.article,
+          severity: i === 0 && firstSeverity !== '[H/M/L/N]' ? firstSeverity : '',
+          likelihood: '',
+          description: '',
+          affectedGroups: '',
+          mitigation: '',
+        })),
+      },
+      human_oversight: {
+        hasHumanOversight: ['L1', 'L2', 'L3'].includes(manifest.autonomy_level),
+        oversightType: mapOversightType(manifest.autonomy_level),
+        mechanism: manifest.autonomy_evidence?.human_approval_gates > 0
+          ? `${manifest.autonomy_evidence.human_approval_gates} human approval gate(s) detected`
+          : '',
+        responsibleRole: '',
+        escalationProcess: '',
+        reviewFrequency: '',
+      },
+      mitigation_measures: {
+        measures: [],
+        incidentResponse: '',
+        communicationPlan: '',
+        suspensionCriteria: '',
+        remediationProcess: '',
+        internalComplaint: '',
+        externalComplaint: '',
+      },
+      monitoring_plan: {
+        frequency: '',
+        metrics: [],
+        responsibleTeam: '',
+        reviewProcess: '',
+        nextReviewDate: '',
+        dpiaReference: '',
+        legalBasis: '',
+        overallRiskDecision: '',
+        conditionsForDeployment: '',
+      },
+    },
+  };
+};
+
+// --- Markdown Generator ---
+
+export const generateFria = (input: FriaGeneratorInput): FriaResult => {
+  const { manifest, template, organization, assessor, impact, mitigation, approval } = input;
+  const prefilledFields: string[] = [];
+  const manualFields: string[] = [];
+
+  let markdown = template;
+
+  // 1. Assessment Header
+  // [AI System Name]
+  markdown = markdown.replaceAll('[AI System Name]', manifest.display_name);
+  prefilledFields.push('AI System Name');
+
+  // FRIA-[YYYY]-[NNN]
+  const friaId = generateFriaId();
+  markdown = markdown.replace('FRIA-[YYYY]-[NNN]', friaId);
+  prefilledFields.push('Assessment ID');
+
+  // [Date] in header
+  const today = new Date().toISOString().slice(0, 10);
+  markdown = markdown.replaceAll('[Date]', today);
+  prefilledFields.push('Date');
+
+  // Assessor
+  if (assessor) {
+    markdown = markdown.replace('[Name, Title]', assessor);
+    prefilledFields.push('Assessor');
+  } else {
+    manualFields.push('Assessor (Name, Title)');
+  }
+
+  // DPO
+  manualFields.push('DPO Consulted (Name, Date)');
+
+  // 2. AI System Description
+  // System name in section 2
+  markdown = markdown.replace('System name: [Name]', `System name: ${manifest.display_name}`);
+
+  // Provider
+  markdown = markdown.replace('Provider: [Name]', `Provider: ${manifest.model.provider}`);
+  prefilledFields.push('Provider');
+
+  // Version
+  markdown = markdown.replace('Version: [Number]', `Version: ${manifest.version}`);
+  prefilledFields.push('Version');
+
+  // Intended purpose
+  markdown = markdown.replace('Intended purpose: [Description]', `Intended purpose: ${manifest.description}`);
+  prefilledFields.push('Intended purpose');
+
+  // Deployment context, categories, geographic scope — manual
+  manualFields.push('Deployment context');
+  manualFields.push('Categories of persons affected');
+  manualFields.push('Geographic scope');
+
+  // 3. Deployer Information
+  const orgName = organization ?? manifest.owner.team;
+  if (orgName) {
+    markdown = markdown.replace('Organisation: [Name]', `Organisation: ${orgName}`);
+    prefilledFields.push('Organisation');
+  } else {
+    manualFields.push('Organisation');
+  }
+  manualFields.push('Organisation type');
+  manualFields.push('Article 27 trigger');
+
+  // 4. Risk Assessment table — set default risk level from passport
+  const riskLevel = deriveRiskLevel(manifest.compliance.eu_ai_act.risk_class);
+
+  // Impact description — replace placeholder or leave as manual
+  if (impact) {
+    markdown = markdown.replace('[e.g., AI may produce biased outcomes against certain ethnic groups in credit decisions]', impact);
+    prefilledFields.push('Impact description');
+  } else {
+    manualFields.push('Fundamental Rights risk descriptions');
+  }
+
+  manualFields.push('Affected groups');
+
+  // Mitigation measures — replace placeholder or leave as manual
+  if (mitigation) {
+    markdown = markdown.replace('[e.g., Regular bias audits, human review of rejections, fairness metrics monitoring]', mitigation);
+    prefilledFields.push('Mitigation measures');
+  } else {
+    manualFields.push('Mitigation measures');
+  }
+
+  // Pre-fill first risk row level if we know the risk class
+  if (riskLevel !== '[H/M/L/N]') {
+    // Replace only in the table rows (after the header)
+    const tableRows = markdown.split('\n');
+    let replaced = false;
+    for (let i = 0; i < tableRows.length; i++) {
+      if (tableRows[i]!.includes('| [H/M/L/N]') && !replaced) {
+        tableRows[i] = tableRows[i]!.replace('[H/M/L/N]', riskLevel);
+        replaced = true;
+        // Only pre-fill first row to hint, rest remain manual
+      }
+    }
+    markdown = tableRows.join('\n');
+  }
+
+  // 5. Mitigation Measures and Human Oversight
+  const oversightDesc = deriveOversightDescription(manifest);
+  markdown = markdown.replace(
+    '[Description of how human can intervene/stop the system]',
+    oversightDesc,
+  );
+  prefilledFields.push('Human oversight mechanism');
+  manualFields.push('Assigned oversight person');
+  manualFields.push('Escalation process');
+  manualFields.push('Review frequency');
+
+  // 6-8: Mostly manual
+  manualFields.push('Incident response plan');
+  manualFields.push('Communication to affected persons');
+  manualFields.push('System suspension criteria');
+  manualFields.push('Remediation process');
+  manualFields.push('Internal complaint mechanism');
+  manualFields.push('External complaint options');
+  manualFields.push('DPIA reference');
+  manualFields.push('Legal basis for data processing');
+
+  // 9. Conclusion — manual
+  manualFields.push('Overall risk assessment decision');
+  manualFields.push('Conditions for deployment');
+  manualFields.push('Next review date');
+
+  // 10. Sign-off
+  manualFields.push('Assessor sign-off');
+  manualFields.push('DPO sign-off');
+
+  if (approval) {
+    markdown = markdown.replace(
+      'Decision-maker: _________________ Date: _________',
+      `Decision-maker: ${approval} Date: ${new Date().toISOString().split('T')[0]}`,
+    );
+    prefilledFields.push('Decision-maker sign-off');
+  } else {
+    manualFields.push('Decision-maker sign-off');
+  }
+
+  manualFields.push('Market surveillance notification');
+
+  const structured = generateFriaStructured(input);
+
+  return Object.freeze({
+    markdown,
+    structured,
+    prefilledFields: Object.freeze([...prefilledFields]),
+    manualFields: Object.freeze([...manualFields]),
+  });
+};