jaz-cli 2.7.0 → 2.8.0

package/dist/__tests__/jobs-audit-prep.test.js

@@ -0,0 +1,125 @@
+import { describe, it, expect } from 'vitest';
+import { generateAuditPrepBlueprint } from '../jobs/audit-prep.js';
+import { JobValidationError } from '../jobs/validate.js';
+describe('generateAuditPrepBlueprint (basic)', () => {
+    it('produces a valid JobBlueprint with correct jobType', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.jobType).toBe('audit-prep');
+    });
+    it('has 4 phases and 14 total steps', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.phases).toHaveLength(4);
+        expect(bp.summary.totalSteps).toBe(14);
+    });
+    it('phase names are correct', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.phases.map(p => p.name)).toEqual([
+            'Financial Statements',
+            'Supporting Schedules',
+            'Reconciliations',
+            'Export & Compile Audit Pack',
+        ]);
+    });
+    it('step categories match expectations', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        const categories = bp.phases.flatMap(p => p.steps.map(s => s.category));
+        expect(categories).toEqual([
+            'report', // 1 — trial balance
+            'report', // 2 — balance sheet
+            'report', // 3 — P&L
+            'report', // 4 — cash flow
+            'report', // 5 — equity movement
+            'report', // 6 — AR aging
+            'report', // 7 — AP aging
+            'report', // 8 — fixed assets
+            'report', // 9 — tax ledger
+            'verify', // 10 — bank reconciliation
+            'verify', // 11 — intercompany
+            'verify', // 12 — loan schedule
+            'export', // 13 — export data
+            'report', // 14 — compile audit pack
+        ]);
+    });
+    it('summary has non-empty apiCalls', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.summary.apiCalls.length).toBeGreaterThan(0);
+    });
+    it('mode is standalone', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.mode).toBe('standalone');
+    });
+});
+describe('generateAuditPrepBlueprint (defaults)', () => {
+    it('default currency is SGD', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.currency).toBe('SGD');
+    });
+});
+describe('generateAuditPrepBlueprint (options)', () => {
+    it('custom currency works', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025', currency: 'PHP' });
+        expect(bp.currency).toBe('PHP');
+    });
+    it('full year period produces FY label', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.period).toBe('FY2025');
+    });
+    it('full year period uses Jan 1 to Dec 31', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        const step1 = bp.phases[0].steps[0];
+        const body = step1.apiBody;
+        expect(body.startDate).toBe('2025-01-01');
+        expect(body.endDate).toBe('2025-12-31');
+    });
+    it('quarter period produces Q label', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025-Q3' });
+        expect(bp.period).toBe('Q3 2025');
+    });
+    it('quarter period uses correct date range', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025-Q3' });
+        const step1 = bp.phases[0].steps[0];
+        const body = step1.apiBody;
+        expect(body.startDate).toBe('2025-07-01');
+        expect(body.endDate).toBe('2025-09-30');
+    });
+});
+describe('generateAuditPrepBlueprint (validation)', () => {
+    it('invalid period throws JobValidationError', () => {
+        expect(() => generateAuditPrepBlueprint({ period: '2025-06' }))
+            .toThrow(JobValidationError);
+    });
+    it('invalid quarter throws JobValidationError', () => {
+        expect(() => generateAuditPrepBlueprint({ period: '2025-Q5' }))
+            .toThrow(JobValidationError);
+    });
+    it('malformed period throws JobValidationError', () => {
+        expect(() => generateAuditPrepBlueprint({ period: 'FY2025' }))
+            .toThrow(JobValidationError);
+    });
+    it('empty period throws JobValidationError', () => {
+        expect(() => generateAuditPrepBlueprint({ period: '' }))
+            .toThrow(JobValidationError);
+    });
+});
+describe('generateAuditPrepBlueprint (summary)', () => {
+    it('recipeReferences include bank-reconciliation', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.summary.recipeReferences).toContain('bank-reconciliation');
+    });
+    it('calcReferences include jaz calc loan', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.summary.calcReferences).toContain('jaz calc loan');
+    });
+    it('apiCalls include key report endpoints', () => {
+        const bp = generateAuditPrepBlueprint({ period: '2025' });
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/trial-balance');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/balance-sheet');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/profit-and-loss');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/cashflow');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/equity-movement');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/ar-aging');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/ap-aging');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/fixed-assets');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/vat-ledger');
+    });
+});

package/dist/__tests__/jobs-bank-recon.test.js

@@ -0,0 +1,108 @@
+import { describe, it, expect } from 'vitest';
+import { generateBankReconBlueprint } from '../jobs/bank-recon.js';
+describe('generateBankReconBlueprint (basic)', () => {
+    it('produces a valid JobBlueprint with correct jobType', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.jobType).toBe('bank-recon');
+    });
+    it('has 4 phases and 10 total steps', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.phases).toHaveLength(4);
+        expect(bp.summary.totalSteps).toBe(10);
+    });
+    it('phase names are correct', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.phases.map(p => p.name)).toEqual([
+            'Identify Bank Accounts',
+            'Pull Unreconciled Records',
+            'Resolve Unreconciled Items',
+            'Verification',
+        ]);
+    });
+    it('step categories match expectations', () => {
+        const bp = generateBankReconBlueprint();
+        const categories = bp.phases.flatMap(p => p.steps.map(s => s.category));
+        expect(categories).toEqual([
+            'verify', // 1 — list bank accounts
+            'verify', // 2 — search unreconciled
+            'verify', // 3 — check duplicates
+            'resolve', // 4 — match bank records
+            'resolve', // 5 — create transactions (import)
+            'resolve', // 6 — create cash journals
+            'review', // 7 — flag remaining items
+            'verify', // 8 — re-check unreconciled count
+            'verify', // 9 — review bank balance
+            'report', // 10 — generate reconciliation report
+        ]);
+    });
+    it('summary has non-empty apiCalls', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.summary.apiCalls.length).toBeGreaterThan(0);
+    });
+    it('mode is standalone', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.mode).toBe('standalone');
+    });
+});
+describe('generateBankReconBlueprint (defaults)', () => {
+    it('default currency is SGD', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.currency).toBe('SGD');
+    });
+    it('default period is current', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.period).toBe('current');
+    });
+});
+describe('generateBankReconBlueprint (options)', () => {
+    it('custom currency works', () => {
+        const bp = generateBankReconBlueprint({ currency: 'PHP' });
+        expect(bp.currency).toBe('PHP');
+    });
+    it('account filter is applied', () => {
+        const bp = generateBankReconBlueprint({ account: 'DBS Current' });
+        const step1 = bp.phases[0].steps[0];
+        expect(step1.apiBody).toBeDefined();
+        expect(step1.apiBody.filters).toHaveProperty('accountName', 'DBS Current');
+        expect(step1.notes).toContain('DBS Current');
+    });
+    it('account filter absent by default', () => {
+        const bp = generateBankReconBlueprint();
+        const step1 = bp.phases[0].steps[0];
+        const filters = step1.apiBody.filters;
+        expect(filters).not.toHaveProperty('accountName');
+    });
+    it('period filter is applied to unreconciled search with correct end-of-month', () => {
+        const bp = generateBankReconBlueprint({ period: '2025-06' });
+        expect(bp.period).toBe('2025-06');
+        const step2 = bp.phases[1].steps[0];
+        const filters = step2.apiBody.filters;
+        expect(filters).toHaveProperty('valueDateFrom', '2025-06-01');
+        expect(filters).toHaveProperty('valueDateTo', '2025-06-30');
+    });
+    it('period filter handles February correctly', () => {
+        const bp = generateBankReconBlueprint({ period: '2025-02' });
+        const step2 = bp.phases[1].steps[0];
+        const filters = step2.apiBody.filters;
+        expect(filters).toHaveProperty('valueDateTo', '2025-02-28');
+    });
+    it('period filter handles leap year February', () => {
+        const bp = generateBankReconBlueprint({ period: '2024-02' });
+        const step2 = bp.phases[1].steps[0];
+        const filters = step2.apiBody.filters;
+        expect(filters).toHaveProperty('valueDateTo', '2024-02-29');
+    });
+});
+describe('generateBankReconBlueprint (summary)', () => {
+    it('recipeReferences include bank-reconciliation and cash-receipt', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.summary.recipeReferences).toContain('bank-reconciliation');
+        expect(bp.summary.recipeReferences).toContain('cash-receipt');
+    });
+    it('apiCalls include key endpoints', () => {
+        const bp = generateBankReconBlueprint();
+        expect(bp.summary.apiCalls).toContain('POST /chart-of-accounts/search');
+        expect(bp.summary.apiCalls).toContain('POST /bank-records/search');
+        expect(bp.summary.apiCalls).toContain('POST /journals');
+    });
+});

package/dist/__tests__/jobs-credit-control.test.js

@@ -0,0 +1,98 @@
+import { describe, it, expect } from 'vitest';
+import { generateCreditControlBlueprint } from '../jobs/credit-control.js';
+import { JobValidationError } from '../jobs/validate.js';
+describe('generateCreditControlBlueprint (basic)', () => {
+    it('produces a valid JobBlueprint with correct jobType', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.jobType).toBe('credit-control');
+    });
+    it('has 4 phases and 7 total steps', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.phases).toHaveLength(4);
+        expect(bp.summary.totalSteps).toBe(7);
+    });
+    it('phase names are correct', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.phases.map(p => p.name)).toEqual([
+            'AR Analysis',
+            'Chase List',
+            'Bad Debt Assessment',
+            'Verification',
+        ]);
+    });
+    it('step categories match expectations', () => {
+        const bp = generateCreditControlBlueprint();
+        const categories = bp.phases.flatMap(p => p.steps.map(s => s.category));
+        expect(categories).toEqual([
+            'report', // 1 — AR aging report
+            'verify', // 2 — identify overdue invoices
+            'review', // 3 — group by customer priority
+            'report', // 4 — follow-up action list
+            'review', // 5 — identify doubtful debts
+            'value', // 6 — calculate ECL provision
+            'verify', // 7 — review AR aging after actions
+        ]);
+    });
+    it('summary has non-empty apiCalls', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.summary.apiCalls.length).toBeGreaterThan(0);
+    });
+    it('mode is standalone', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.mode).toBe('standalone');
+    });
+});
+describe('generateCreditControlBlueprint (defaults)', () => {
+    it('default currency is SGD', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.currency).toBe('SGD');
+    });
+    it('default overdueDays is 30', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.period).toBe('Overdue > 30 days');
+    });
+});
+describe('generateCreditControlBlueprint (options)', () => {
+    it('custom currency works', () => {
+        const bp = generateCreditControlBlueprint({ currency: 'PHP' });
+        expect(bp.currency).toBe('PHP');
+    });
+    it('custom overdueDays works', () => {
+        const bp = generateCreditControlBlueprint({ overdueDays: 60 });
+        expect(bp.period).toBe('Overdue > 60 days');
+    });
+    it('overdueDays is reflected in step description', () => {
+        const bp = generateCreditControlBlueprint({ overdueDays: 90 });
+        const step2 = bp.phases[0].steps[1];
+        expect(step2.description).toContain('90');
+    });
+});
+describe('generateCreditControlBlueprint (validation)', () => {
+    it('zero overdueDays throws JobValidationError', () => {
+        expect(() => generateCreditControlBlueprint({ overdueDays: 0 }))
+            .toThrow(JobValidationError);
+    });
+    it('negative overdueDays throws JobValidationError', () => {
+        expect(() => generateCreditControlBlueprint({ overdueDays: -10 }))
+            .toThrow(JobValidationError);
+    });
+    it('fractional overdueDays throws JobValidationError', () => {
+        expect(() => generateCreditControlBlueprint({ overdueDays: 30.5 }))
+            .toThrow(JobValidationError);
+    });
+});
+describe('generateCreditControlBlueprint (summary)', () => {
+    it('recipeReferences include bad-debt-provision', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.summary.recipeReferences).toContain('bad-debt-provision');
+    });
+    it('calcReferences include jaz calc ecl', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.summary.calcReferences).toContain('jaz calc ecl');
+    });
+    it('apiCalls include key endpoints', () => {
+        const bp = generateCreditControlBlueprint();
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/ar-aging');
+        expect(bp.summary.apiCalls).toContain('POST /invoices/search');
+    });
+});

package/dist/__tests__/jobs-fa-review.test.js

@@ -0,0 +1,104 @@
+import { describe, it, expect } from 'vitest';
+import { generateFaReviewBlueprint } from '../jobs/fa-review.js';
+describe('generateFaReviewBlueprint (basic)', () => {
+    it('produces a valid JobBlueprint with correct jobType', () => {
+        const bp = generateFaReviewBlueprint();
+        expect(bp.jobType).toBe('fa-review');
+    });
+    it('has 4 phases and 8 total steps', () => {
+        const bp = generateFaReviewBlueprint();
+        expect(bp.phases).toHaveLength(4);
+        expect(bp.summary.totalSteps).toBe(8);
+    });
+    it('phase names are correct', () => {
+        const bp = generateFaReviewBlueprint();
+        expect(bp.phases.map(p => p.name)).toEqual([
+            'Register Review',
+            'Depreciation Check',
+            'Disposals & Write-offs',
+            'Verification',
+        ]);
+    });
+    it('step categories match expectations', () => {
+        const bp = generateFaReviewBlueprint();
+        const categories = bp.phases.flatMap(p => p.steps.map(s => s.category));
+        expect(categories).toEqual([
+            'report', // 1 — pull FA summary
+            'verify', // 2 — verify against GL
+            'verify', // 3 — verify depreciation runs
+            'review', // 4 — check fully depreciated
+            'adjust', // 5 — process disposals
+            'adjust', // 6 — process write-offs
+            'verify', // 7 — reconcile FA to TB
+            'review', // 8 — check NBV reasonableness
+        ]);
+    });
+    it('summary has non-empty apiCalls', () => {
+        const bp = generateFaReviewBlueprint();
+        expect(bp.summary.apiCalls.length).toBeGreaterThan(0);
+    });
+    it('mode is standalone', () => {
+        const bp = generateFaReviewBlueprint();
+        expect(bp.mode).toBe('standalone');
+    });
+});
+describe('generateFaReviewBlueprint (defaults)', () => {
+    it('default currency is SGD', () => {
+        const bp = generateFaReviewBlueprint();
+        expect(bp.currency).toBe('SGD');
+    });
+    it('period is always current', () => {
+        const bp = generateFaReviewBlueprint();
+        expect(bp.period).toBe('current');
+    });
+});
+describe('generateFaReviewBlueprint (options)', () => {
+    it('custom currency works', () => {
+        const bp = generateFaReviewBlueprint({ currency: 'PHP' });
+        expect(bp.currency).toBe('PHP');
+    });
+    it('USD currency works', () => {
+        const bp = generateFaReviewBlueprint({ currency: 'USD' });
+        expect(bp.currency).toBe('USD');
+    });
+});
+describe('generateFaReviewBlueprint (summary)', () => {
+    it('recipeReferences include asset-disposal', () => {
+        const bp = generateFaReviewBlueprint();
+        expect(bp.summary.recipeReferences).toContain('asset-disposal');
+    });
+    it('calcReferences include depreciation and asset-disposal calcs', () => {
+        const bp = generateFaReviewBlueprint();
+        expect(bp.summary.calcReferences).toContain('jaz calc depreciation');
+        expect(bp.summary.calcReferences).toContain('jaz calc asset-disposal');
+    });
+    it('apiCalls include key endpoints', () => {
+        const bp = generateFaReviewBlueprint();
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/fixed-assets');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/trial-balance');
+        expect(bp.summary.apiCalls).toContain('POST /journals');
+    });
+});
+describe('generateFaReviewBlueprint (phase structure)', () => {
+    it('phase 1 has 2 steps (register review)', () => {
+        const bp = generateFaReviewBlueprint();
+        expect(bp.phases[0].steps).toHaveLength(2);
+    });
+    it('phase 2 has 2 steps (depreciation check)', () => {
+        const bp = generateFaReviewBlueprint();
+        expect(bp.phases[1].steps).toHaveLength(2);
+    });
+    it('phase 3 has 2 steps (disposals & write-offs)', () => {
+        const bp = generateFaReviewBlueprint();
+        expect(bp.phases[2].steps).toHaveLength(2);
+    });
+    it('phase 4 has 2 steps (verification)', () => {
+        const bp = generateFaReviewBlueprint();
+        expect(bp.phases[3].steps).toHaveLength(2);
+    });
+    it('step orders are sequential 1-8', () => {
+        const bp = generateFaReviewBlueprint();
+        const orders = bp.phases.flatMap(p => p.steps.map(s => s.order));
+        expect(orders).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
+    });
+});

package/dist/__tests__/jobs-gst-vat.test.js

@@ -0,0 +1,113 @@
+import { describe, it, expect } from 'vitest';
+import { generateGstVatBlueprint } from '../jobs/gst-vat.js';
+import { JobValidationError } from '../jobs/validate.js';
+describe('generateGstVatBlueprint (basic)', () => {
+    it('produces a valid JobBlueprint with correct jobType', () => {
+        const bp = generateGstVatBlueprint({ period: '2025-Q1' });
+        expect(bp.jobType).toBe('gst-vat-filing');
+    });
+    it('has 6 phases and 10 total steps', () => {
+        const bp = generateGstVatBlueprint({ period: '2025-Q1' });
+        expect(bp.phases).toHaveLength(6);
+        expect(bp.summary.totalSteps).toBe(10);
+    });
+    it('phase names are correct', () => {
+        const bp = generateGstVatBlueprint({ period: '2025-Q1' });
+        expect(bp.phases.map(p => p.name)).toEqual([
+            'Generate Tax Ledger',
+            'Review Output Tax',
+            'Review Input Tax',
+            'Error Checks',
+            'GST Return Summary',
+            'Export & File',
+        ]);
+    });
+    it('step categories match expectations', () => {
+        const bp = generateGstVatBlueprint({ period: '2025-Q1' });
+        const categories = bp.phases.flatMap(p => p.steps.map(s => s.category));
+        expect(categories).toEqual([
+            'report', // 1 — generate tax ledger
+            'export', // 2 — export tax ledger
+            'verify', // 3 — cross-reference invoices
+            'verify', // 4 — check missing tax profiles
+            'verify', // 5 — cross-reference bills
+            'review', // 6 — identify blocked input tax
+            'review', // 7 — review common errors
+            'report', // 8 — compile F5 box mapping
+            'report', // 9 — generate supporting reports
+            'export', // 10 — export final tax ledger
+        ]);
+    });
+    it('summary has non-empty apiCalls', () => {
+        const bp = generateGstVatBlueprint({ period: '2025-Q1' });
+        expect(bp.summary.apiCalls.length).toBeGreaterThan(0);
+    });
+    it('mode is standalone', () => {
+        const bp = generateGstVatBlueprint({ period: '2025-Q1' });
+        expect(bp.mode).toBe('standalone');
+    });
+});
+describe('generateGstVatBlueprint (defaults)', () => {
+    it('default currency is SGD', () => {
+        const bp = generateGstVatBlueprint({ period: '2025-Q1' });
+        expect(bp.currency).toBe('SGD');
+    });
+    it('period label is formatted as Q label', () => {
+        const bp = generateGstVatBlueprint({ period: '2025-Q1' });
+        expect(bp.period).toBe('Q1 2025');
+    });
+});
+describe('generateGstVatBlueprint (options)', () => {
+    it('custom currency works', () => {
+        const bp = generateGstVatBlueprint({ period: '2025-Q2', currency: 'PHP' });
+        expect(bp.currency).toBe('PHP');
+    });
+    it('Q2 period generates correct date range', () => {
+        const bp = generateGstVatBlueprint({ period: '2025-Q2' });
+        expect(bp.period).toBe('Q2 2025');
+        // Verify date range is embedded in step apiBody
+        const step1 = bp.phases[0].steps[0];
+        const body = step1.apiBody;
+        expect(body.startDate).toBe('2025-04-01');
+        expect(body.endDate).toBe('2025-06-30');
+    });
+    it('Q4 period generates correct date range', () => {
+        const bp = generateGstVatBlueprint({ period: '2025-Q4' });
+        expect(bp.period).toBe('Q4 2025');
+        const step1 = bp.phases[0].steps[0];
+        const body = step1.apiBody;
+        expect(body.startDate).toBe('2025-10-01');
+        expect(body.endDate).toBe('2025-12-31');
+    });
+});
+describe('generateGstVatBlueprint (validation)', () => {
+    it('invalid period throws JobValidationError', () => {
+        expect(() => generateGstVatBlueprint({ period: '2025-06' }))
+            .toThrow(JobValidationError);
+    });
+    it('invalid quarter number throws JobValidationError', () => {
+        expect(() => generateGstVatBlueprint({ period: '2025-Q5' }))
+            .toThrow(JobValidationError);
+    });
+    it('malformed period throws JobValidationError', () => {
+        expect(() => generateGstVatBlueprint({ period: 'Q1-2025' }))
+            .toThrow(JobValidationError);
+    });
+    it('empty period throws JobValidationError', () => {
+        expect(() => generateGstVatBlueprint({ period: '' }))
+            .toThrow(JobValidationError);
+    });
+});
+describe('generateGstVatBlueprint (summary)', () => {
+    it('apiCalls include key endpoints', () => {
+        const bp = generateGstVatBlueprint({ period: '2025-Q1' });
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/vat-ledger');
+        expect(bp.summary.apiCalls).toContain('POST /invoices/search');
+        expect(bp.summary.apiCalls).toContain('POST /bills/search');
+        expect(bp.summary.apiCalls).toContain('POST /generate-reports/profit-and-loss');
+    });
+    it('no recipe references', () => {
+        const bp = generateGstVatBlueprint({ period: '2025-Q1' });
+        expect(bp.summary.recipeReferences).toHaveLength(0);
+    });
+});