@dakkitor/api-contracts 1.1.153 → 1.4.0

package/dist/workers/do-not-contact.contract.spec.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const do_not_contact_contract_1 = require("./do-not-contact.contract");
+describe('SetDoNotContactSchema', () => {
+    it('accepts a standard DNC window', () => {
+        expect(do_not_contact_contract_1.SetDoNotContactSchema.parse({ reason: 'ALREADY_WORKING', days: 14 })).toEqual({
+            reason: 'ALREADY_WORKING',
+            days: 14,
+        });
+    });
+    it('accepts the bridge-only 90-day window and its note', () => {
+        expect(do_not_contact_contract_1.SetDoNotContactSchema.parse({
+            reason: 'NOT_INTERESTED',
+            note: 'Rate: wants £20+',
+            days: do_not_contact_contract_1.DNC_WRITE_MAX_DAYS,
+        })).toEqual({
+            reason: 'NOT_INTERESTED',
+            note: 'Rate: wants £20+',
+            days: 90,
+        });
+    });
+    it('accepts indefinite or days, but never both or neither', () => {
+        expect(do_not_contact_contract_1.SetDoNotContactSchema.safeParse({
+            reason: 'NOT_INTERESTED',
+            indefinite: true,
+        }).success).toBe(true);
+        expect(do_not_contact_contract_1.SetDoNotContactSchema.safeParse({
+            reason: 'NOT_INTERESTED',
+            days: 14,
+            indefinite: true,
+        }).success).toBe(false);
+        expect(do_not_contact_contract_1.SetDoNotContactSchema.safeParse({ reason: 'NOT_INTERESTED' }).success).toBe(false);
+    });
+    it('rejects 0 days', () => {
+        expect(do_not_contact_contract_1.SetDoNotContactSchema.safeParse({ reason: 'ALREADY_WORKING', days: 0 })
+            .success).toBe(false);
+    });
+    it(`rejects more than ${do_not_contact_contract_1.DNC_WRITE_MAX_DAYS} days`, () => {
+        expect(do_not_contact_contract_1.SetDoNotContactSchema.safeParse({
+            reason: 'ALREADY_WORKING',
+            days: do_not_contact_contract_1.DNC_WRITE_MAX_DAYS + 1,
+        }).success).toBe(false);
+    });
+    it('rejects non-DNC reasons like NO_ANSWER', () => {
+        expect(do_not_contact_contract_1.DoNotContactReasonSchema.safeParse('NO_ANSWER').success).toBe(false);
+    });
+});

package/dist/workers/duplicate-group-worker.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=duplicate-group-worker.spec.d.ts.map

package/dist/workers/duplicate-group-worker.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-group-worker.spec.d.ts","sourceRoot":"","sources":["../../contracts/workers/duplicate-group-worker.spec.ts"],"names":[],"mappings":""}

package/dist/workers/duplicate-group-worker.spec.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const workers_contract_1 = require("./workers.contract");
+describe('DuplicateGroupWorkerSchema', () => {
+    it('parses a worker with location and updatedAt', () => {
+        const input = {
+            id: '00000000-0000-0000-0000-000000000001',
+            firstName: 'Ana',
+            lastName: 'Pop',
+            hasTools: false,
+            hasPpe: false,
+            locationId: '00000000-0000-0000-0000-000000000002',
+            location: { postcode: 'SW1A 1AA', postTown: 'London' },
+            createdAt: '2026-05-01T10:00:00.000Z',
+            updatedAt: '2026-05-10T11:00:00.000Z',
+        };
+        const parsed = workers_contract_1.DuplicateGroupWorkerSchema.parse(input);
+        expect(parsed.location?.postcode).toBe('SW1A 1AA');
+        expect(parsed.location?.postTown).toBe('London');
+        expect(parsed.updatedAt).toBeInstanceOf(Date);
+    });
+    it('accepts null location', () => {
+        const input = {
+            id: '00000000-0000-0000-0000-000000000001',
+            firstName: 'Ana',
+            hasTools: false,
+            hasPpe: false,
+            location: null,
+            createdAt: '2026-05-01T10:00:00.000Z',
+            updatedAt: '2026-05-01T10:00:00.000Z',
+        };
+        expect(() => workers_contract_1.DuplicateGroupWorkerSchema.parse(input)).not.toThrow();
+    });
+});

package/dist/workers/filter-exact-flags.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=filter-exact-flags.spec.d.ts.map

package/dist/workers/filter-exact-flags.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-exact-flags.spec.d.ts","sourceRoot":"","sources":["../../contracts/workers/filter-exact-flags.spec.ts"],"names":[],"mappings":""}

package/dist/workers/filter-exact-flags.spec.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const workers_contract_1 = require("./workers.contract");
+const bookings_contract_1 = require("../bookings/bookings.contract");
+const actives_contract_1 = require("../actives/actives.contract");
+describe('nested name filter with exact flag', () => {
+    it('FilterWorkerSchema parses name.value + coerces name.exact', () => {
+        expect(workers_contract_1.FilterWorkerSchema.parse({ name: { value: 'x', exact: 'true' } }).name).toEqual({ value: 'x', exact: true });
+        expect(workers_contract_1.FilterWorkerSchema.parse({ name: { value: 'x', exact: 'false' } }).name
+            ?.exact).toBe(false);
+        expect(workers_contract_1.FilterWorkerSchema.parse({ name: { value: 'x', exact: true } }).name
+            ?.exact).toBe(true);
+        expect(workers_contract_1.FilterWorkerSchema.parse({ name: { value: 'x' } }).name?.exact).toBeUndefined();
+        expect(workers_contract_1.FilterWorkerSchema.parse({}).name).toBeUndefined();
+    });
+    it('FilterBookingSchema parses workerName.value + coerces workerName.exact', () => {
+        expect(bookings_contract_1.FilterBookingSchema.parse({ workerName: { value: 'x', exact: 'true' } })
+            .workerName).toEqual({ value: 'x', exact: true });
+        expect(bookings_contract_1.FilterBookingSchema.parse({ workerName: { value: 'x', exact: 'false' } })
+            .workerName?.exact).toBe(false);
+        expect(bookings_contract_1.FilterBookingSchema.parse({}).workerName).toBeUndefined();
+    });
+    it('FilterActiveSchema parses workerName.value + coerces workerName.exact', () => {
+        expect(actives_contract_1.FilterActiveSchema.parse({ workerName: { value: 'x', exact: 'true' } })
+            .workerName).toEqual({ value: 'x', exact: true });
+        expect(actives_contract_1.FilterActiveSchema.parse({ workerName: { value: 'x', exact: 'false' } })
+            .workerName?.exact).toBe(false);
+        expect(actives_contract_1.FilterActiveSchema.parse({}).workerName).toBeUndefined();
+    });
+    it('FilterActiveByJobSchema parses workerName.value + coerces workerName.exact', () => {
+        expect(actives_contract_1.FilterActiveByJobSchema.parse({
+            date: '2026-06-25',
+            workerName: { value: 'x', exact: 'true' },
+        }).workerName).toEqual({ value: 'x', exact: true });
+        expect(actives_contract_1.FilterActiveByJobSchema.parse({ date: '2026-06-25' }).workerName).toBeUndefined();
+    });
+});

package/dist/workers/worker-source-attribution.contract.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker-source-attribution.contract.spec.d.ts.map

package/dist/workers/worker-source-attribution.contract.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-source-attribution.contract.spec.d.ts","sourceRoot":"","sources":["../../contracts/workers/worker-source-attribution.contract.spec.ts"],"names":[],"mappings":""}

package/dist/workers/worker-source-attribution.contract.spec.js

@@ -0,0 +1,442 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const workers_contract_1 = require("./workers.contract");
+const GENERIC_WORKER_CREATE_CONFLICT_CODES = [
+    'BAD_REQUEST',
+    'CREW_MEMBER_LIMIT_REACHED',
+    'ENTITY_HAS_RELATED_RECORDS',
+    'FILE_ATTACHMENT_INVALID',
+    'INVALID_WORKER_DATA',
+    'VALIDATION_ERROR',
+    'WORKER_ALREADY_EXISTS',
+    'WORKER_ALREADY_HAS_QUALIFICATION',
+];
+const workerCreateConflictCodesAreStructurallyDisjoint = true;
+describe('worker source attribution contracts', () => {
+    const evidence = {
+        curatedWorker: {
+            id: crypto.randomUUID(),
+            firstName: 'Earl',
+            lastName: 'Kearney',
+        },
+        phoneMasked: '+44••••1417',
+        contactedAt: '2026-07-17T15:35:52.270Z',
+        channel: 'PHONE',
+        outcome: 'INTERESTED',
+        qualifyingContactCount: 1,
+    };
+    const challenge = {
+        id: crypto.randomUUID(),
+        context: 'SINGLE',
+        status: 'PENDING',
+        submittedWorkerName: 'Earl Kearney',
+        match: evidence,
+        expiresAt: '2026-07-22T15:35:52.270Z',
+        createdAt: '2026-07-21T15:35:52.270Z',
+    };
+    const identityConflict = {
+        id: crypto.randomUUID(),
+        status: 'OPEN',
+        reviewUrl: '/workers/identity-matches?workerSourceIdentityConflictId=case-id',
+    };
+    it('parses an attribution-required response', () => {
+        expect(workers_contract_1.WorkerLeadAttributionRequiredResponseSchema.parse({
+            message: 'Worker Leads attribution is required',
+            code: 'WORKER_LEAD_ATTRIBUTION_REQUIRED',
+            statusCode: 409,
+            details: {
+                challengeId: crypto.randomUUID(),
+                expiresAt: '2026-07-22T15:35:52.270Z',
+                submittedWorkerName: 'Earl Kearney',
+                match: evidence,
+                identityReviewAdjustment: null,
+            },
+        }).details.match.outcome).toBe('INTERESTED');
+    });
+    it('requires a strict display-safe review adjustment on attribution-required responses', () => {
+        const adjustment = {
+            caseId: identityConflict.id,
+            retainedPhoneMasks: ['+44••••1417'],
+            excludedPhoneMasks: ['+44••••2894'],
+        };
+        const response = {
+            message: 'Worker Leads attribution is required',
+            code: 'WORKER_LEAD_ATTRIBUTION_REQUIRED',
+            statusCode: 409,
+            details: {
+                challengeId: crypto.randomUUID(),
+                expiresAt: '2026-07-22T15:35:52.270Z',
+                submittedWorkerName: 'Earl Kearney',
+                match: evidence,
+                identityReviewAdjustment: adjustment,
+            },
+        };
+        expect(workers_contract_1.WorkerLeadAttributionRequiredResponseSchema.parse(response).details
+            .identityReviewAdjustment).toEqual(adjustment);
+        expect(workers_contract_1.WorkerLeadAttributionRequiredResponseSchema.parse({
+            ...response,
+            details: { ...response.details, identityReviewAdjustment: null },
+        }).details.identityReviewAdjustment).toBeNull();
+        expect(() => workers_contract_1.WorkerLeadAttributionRequiredResponseSchema.parse({
+            ...response,
+            details: {
+                ...response.details,
+                identityReviewAdjustment: {
+                    ...adjustment,
+                    retainedPhoneMasks: ['+447700901417'],
+                },
+            },
+        })).toThrow();
+        expect(() => workers_contract_1.WorkerLeadAttributionRequiredResponseSchema.parse({
+            ...response,
+            details: {
+                ...response.details,
+                identityReviewAdjustment: {
+                    ...adjustment,
+                    retainedPhoneE164s: ['+447700901417'],
+                },
+            },
+        })).toThrow();
+        expect(() => workers_contract_1.WorkerLeadAttributionRequiredResponseSchema.parse({
+            ...response,
+            details: {
+                challengeId: response.details.challengeId,
+                expiresAt: response.details.expiresAt,
+                submittedWorkerName: response.details.submittedWorkerName,
+                match: response.details.match,
+            },
+        })).toThrow();
+    });
+    it('accepts an explicit pending challenge to supersede on single resubmit', () => {
+        const supersedesAttributionChallengeId = crypto.randomUUID();
+        expect(workers_contract_1.CreateSingleWorkerBodySchema.parse({
+            firstName: 'Alice',
+            phoneNumbers: [{ phoneNumber: '+447768468895', isPrimary: true }],
+            trades: [{ tradeId: crypto.randomUUID(), mainTrade: true }],
+            supersedesAttributionChallengeId,
+        }).supersedesAttributionChallengeId).toBe(supersedesAttributionChallengeId);
+        expect(() => workers_contract_1.CreateSingleWorkerBodySchema.parse({
+            firstName: 'Alice',
+            phoneNumbers: [{ phoneNumber: '+447768468895', isPrimary: true }],
+            trades: [{ tradeId: crypto.randomUUID(), mainTrade: true }],
+            supersedesAttributionChallengeId: 'not-a-uuid',
+        })).toThrow();
+    });
+    it('rejects attribution evidence missing a qualifying contact', () => {
+        expect(() => workers_contract_1.WorkerLeadAttributionRequiredResponseSchema.parse({
+            message: 'Worker Leads attribution is required',
+            code: 'WORKER_LEAD_ATTRIBUTION_REQUIRED',
+            statusCode: 409,
+            details: {
+                challengeId: crypto.randomUUID(),
+                expiresAt: '2026-07-22T15:35:52.270Z',
+                submittedWorkerName: 'Earl Kearney',
+                match: {
+                    ...evidence,
+                    qualifyingContactCount: 0,
+                },
+                identityReviewAdjustment: null,
+            },
+        })).toThrow();
+    });
+    it('rejects a raw E.164 value in a public phoneMasked field', () => {
+        expect(() => workers_contract_1.WorkerLeadAttributionMatchSchema.parse({
+            ...evidence,
+            phoneMasked: '+447700901417',
+        })).toThrow();
+    });
+    it('represents strict display-safe identity review adjustments', () => {
+        const identityReviewAdjustment = {
+            caseId: identityConflict.id,
+            retainedPhoneMasks: ['+44••••1417'],
+            excludedPhoneMasks: ['+44••••2894'],
+        };
+        expect(workers_contract_1.WorkerSourceAttributionChallengeSchema.parse({
+            ...challenge,
+            identityReviewAdjustment,
+        }).identityReviewAdjustment).toEqual(identityReviewAdjustment);
+        expect(() => workers_contract_1.WorkerSourceAttributionChallengeSchema.parse({
+            ...challenge,
+            identityReviewAdjustment: {
+                ...identityReviewAdjustment,
+                retainedPhoneMasks: ['+447700901417'],
+            },
+        })).toThrow();
+        expect(() => workers_contract_1.WorkerSourceAttributionChallengeSchema.parse({
+            ...challenge,
+            identityReviewAdjustment: {
+                ...identityReviewAdjustment,
+                retainedPhoneE164s: ['+447700901417'],
+            },
+        })).toThrow();
+    });
+    it('requires YES or NO and keeps explanation optional', () => {
+        expect(workers_contract_1.ResolveWorkerSourceAttributionBodySchema.parse({ answer: 'YES' })).toEqual({ answer: 'YES' });
+        expect(workers_contract_1.ResolveWorkerSourceAttributionBodySchema.parse({
+            answer: 'NO',
+            explanation: 'Known from a previous site',
+        }).answer).toBe('NO');
+        expect(() => workers_contract_1.ResolveWorkerSourceAttributionBodySchema.parse({ answer: 'SKIP' })).toThrow();
+        expect(workers_contract_1.ResolveWorkerSourceAttributionBodySchema.parse({
+            answer: 'NO',
+            explanation: '  Known from a previous site  ',
+        }).explanation).toBe('Known from a previous site');
+        expect(() => workers_contract_1.ResolveWorkerSourceAttributionBodySchema.parse({
+            answer: 'NO',
+            explanation: 'x'.repeat(501),
+        })).toThrow();
+    });
+    it('rejects the pending worker payload at the public boundary', () => {
+        expect(() => workers_contract_1.WorkerSourceAttributionChallengeSchema.parse({
+            ...challenge,
+            pendingPayload: {
+                firstName: 'Earl',
+                lastName: 'Kearney',
+                email: 'earl.kearney@example.com',
+                phoneNumbers: [{ phoneNumber: '+447700901417', isPrimary: true }],
+            },
+        })).toThrow();
+        expect('pendingPayload' in workers_contract_1.WorkerSourceAttributionChallengeSchema.shape).toBe(false);
+    });
+    it('extends availability, batch results, and import progress', () => {
+        const importJobId = crypto.randomUUID();
+        const identityConflictReviewUrl = `/workers/identity-matches?workerSourceIdentityConflictContext=IMPORT&` +
+            `workerSourceIdentityConflictContextId=${importJobId}`;
+        expect(workers_contract_1.CheckWorkerAvailabilityResponseSchema.parse({
+            email: null,
+            phoneNumber: null,
+            workerLeadAttributionMatch: evidence,
+        }).workerLeadAttributionMatch).toEqual(evidence);
+        expect(workers_contract_1.CheckWorkerAvailabilityResponseSchema.parse({
+            email: null,
+            phoneNumber: null,
+            workerLeadAttributionMatch: null,
+        }).workerLeadAttributionMatch).toBeNull();
+        expect(workers_contract_1.BatchCreateWorkerResultSchema.parse({
+            index: 0,
+            status: 'ATTRIBUTION_REQUIRED',
+            challenge,
+        }).status).toBe('ATTRIBUTION_REQUIRED');
+        expect(workers_contract_1.BatchCreateWorkerResultSchema.parse({
+            index: 1,
+            status: 'IDENTITY_CONFLICT',
+            identityConflict,
+        }).status).toBe('IDENTITY_CONFLICT');
+        expect(workers_contract_1.WorkerImportJobSchema.parse({
+            id: importJobId,
+            status: 'COMPLETED',
+            totalRows: 3,
+            successCount: 1,
+            failedCount: 0,
+            skippedCount: 0,
+            awaitingAttributionCount: 1,
+            identityConflictCount: 1,
+            identityConflictReviewUrl,
+            identityConflictCaseIds: [identityConflict.id],
+            sourceFileId: crypto.randomUUID(),
+            createdByUserId: crypto.randomUUID(),
+            createdAt: '2026-07-21T15:35:52.270Z',
+        }).awaitingAttributionCount).toBe(1);
+        const baseImportJob = {
+            id: importJobId,
+            status: 'COMPLETED',
+            totalRows: 1,
+            successCount: 0,
+            failedCount: 0,
+            skippedCount: 0,
+            awaitingAttributionCount: 0,
+            identityConflictCount: 1,
+            identityConflictCaseIds: [identityConflict.id],
+            sourceFileId: crypto.randomUUID(),
+            createdByUserId: crypto.randomUUID(),
+            createdAt: '2026-07-21T15:35:52.270Z',
+        };
+        expect(workers_contract_1.WorkerImportJobSchema.safeParse({
+            ...baseImportJob,
+            identityConflictReviewUrl: 'https://example.com/workers/identity-matches?workerSourceIdentityConflictContext=IMPORT&' +
+                `workerSourceIdentityConflictContextId=${importJobId}`,
+        }).success).toBe(false);
+        expect(workers_contract_1.WorkerImportJobSchema.safeParse({
+            ...baseImportJob,
+            identityConflictReviewUrl: '/workers/identity-matches?workerSourceIdentityConflictContext=IMPORT',
+        }).success).toBe(false);
+        expect(workers_contract_1.WorkerImportJobSchema.safeParse({
+            ...baseImportJob,
+            identityConflictReviewUrl: '/workers/identity-matches?workerSourceIdentityConflictContext=IMPORT&' +
+                `workerSourceIdentityConflictContextId=${crypto.randomUUID()}`,
+        }).success).toBe(false);
+    });
+    it('defines the bounded agent challenge routes', () => {
+        const listRoute = workers_contract_1.workersContractRouter.listSourceAttributionChallenges;
+        const resolveRoute = workers_contract_1.workersContractRouter.resolveSourceAttributionChallenge;
+        const batchRoute = workers_contract_1.workersContractRouter.resolveSourceAttributionChallengesBatch;
+        expect(listRoute.method).toBe('GET');
+        expect(listRoute.path).toBe('/v2/workers/source-attribution-challenges');
+        const importJobId = crypto.randomUUID();
+        expect(workers_contract_1.ListWorkerSourceAttributionChallengesQuerySchema.parse({
+            context: 'IMPORT',
+            contextId: importJobId,
+        })).toMatchObject({ context: 'IMPORT', contextId: importJobId });
+        const sourceIdentityConflictId = crypto.randomUUID();
+        expect(workers_contract_1.ListWorkerSourceAttributionChallengesQuerySchema.parse({
+            context: 'SINGLE',
+            sourceIdentityConflictId,
+        })).toMatchObject({
+            context: 'SINGLE',
+            sourceIdentityConflictId,
+        });
+        expect(() => workers_contract_1.ListWorkerSourceAttributionChallengesQuerySchema.parse({
+            sourceIdentityConflictId: 'not-a-uuid',
+        })).toThrow();
+        expect(listRoute.query.parse({})).toEqual({ page: 1, limit: 50 });
+        expect(listRoute.query.parse({ context: 'BATCH' })).toEqual({
+            page: 1,
+            limit: 50,
+            context: 'BATCH',
+        });
+        expect(() => listRoute.query.parse({ page: 0 })).toThrow();
+        expect(() => listRoute.query.parse({ limit: 0 })).toThrow();
+        expect(() => listRoute.query.parse({ limit: 101 })).toThrow();
+        expect(listRoute.responses[200].parse({
+            data: [challenge],
+            total: 1,
+            page: 1,
+            limit: 50,
+        }).data).toHaveLength(1);
+        expect(resolveRoute.method).toBe('POST');
+        expect(resolveRoute.path).toBe('/v2/workers/source-attribution-challenges/:id/resolve');
+        expect(resolveRoute.responses[201]).toBeDefined();
+        expect(batchRoute.method).toBe('POST');
+        expect(batchRoute.path).toBe('/v2/workers/source-attribution-challenges/resolve-batch');
+        expect(batchRoute.body.parse({
+            items: [{ challengeId: challenge.id, answer: 'YES' }],
+        }).items).toHaveLength(1);
+        expect(() => batchRoute.body.parse({ items: [] })).toThrow();
+        expect(() => batchRoute.body.parse({
+            items: Array.from({ length: 101 }, () => ({
+                challengeId: crypto.randomUUID(),
+                answer: 'NO',
+            })),
+        })).toThrow();
+        expect(batchRoute.responses[200].parse({
+            results: [
+                {
+                    challengeId: challenge.id,
+                    status: 'IDENTITY_CONFLICT',
+                    error: 'Identity changed while awaiting an answer',
+                    terminal: true,
+                    identityConflict,
+                },
+                {
+                    challengeId: crypto.randomUUID(),
+                    status: 'FAILED',
+                    error: 'Temporary database error',
+                    terminal: false,
+                },
+            ],
+        }).results).toEqual([
+            {
+                challengeId: challenge.id,
+                status: 'IDENTITY_CONFLICT',
+                error: 'Identity changed while awaiting an answer',
+                terminal: true,
+                identityConflict,
+            },
+            {
+                challengeId: expect.any(String),
+                status: 'FAILED',
+                error: 'Temporary database error',
+                terminal: false,
+            },
+        ]);
+        expect(() => batchRoute.responses[200].parse({
+            results: [
+                {
+                    challengeId: challenge.id,
+                    status: 'FAILED',
+                    error: 'Missing terminal classification',
+                },
+            ],
+        })).toThrow();
+        expect(() => batchRoute.responses[200].parse({
+            results: [
+                {
+                    challengeId: challenge.id,
+                    status: 'IDENTITY_CONFLICT',
+                    error: 'Missing owner-safe review reference',
+                    terminal: true,
+                },
+            ],
+        })).toThrow();
+        expect(() => batchRoute.responses[200].parse({
+            results: [
+                {
+                    challengeId: challenge.id,
+                    status: 'IDENTITY_CONFLICT',
+                    error: 'Cross-branch field supplied',
+                    terminal: true,
+                    identityConflict,
+                    workerId: crypto.randomUUID(),
+                },
+            ],
+        })).toThrow();
+    });
+    it('defines read and invalidation-only administrator routes', () => {
+        const listRoute = workers_contract_1.workersContractRouter.adminListSourceAttributionChallenges;
+        const invalidateRoute = workers_contract_1.workersContractRouter.adminInvalidateSourceAttributionChallenge;
+        expect(listRoute.method).toBe('GET');
+        expect(listRoute.path).toBe('/v2/workers/admin/source-attribution-challenges');
+        expect(listRoute.query.parse({ context: 'IMPORT', status: 'RESOLVED_NO' })).toEqual({
+            page: 1,
+            limit: 50,
+            context: 'IMPORT',
+            status: 'RESOLVED_NO',
+        });
+        expect(invalidateRoute.method).toBe('POST');
+        expect(invalidateRoute.path).toBe('/v2/workers/admin/source-attribution-challenges/:id/invalidate');
+        expect(invalidateRoute.body.parse({ reason: 'Duplicate submission' })).toEqual({ reason: 'Duplicate submission' });
+        expect(() => invalidateRoute.body.parse({ reason: '   ' })).toThrow();
+        expect(invalidateRoute.responses[200].parse(challenge).id).toBe(challenge.id);
+        expect(Object.keys(workers_contract_1.workersContractRouter).filter((routeName) => routeName.startsWith('admin') && routeName.includes('Resolve'))).toEqual([]);
+    });
+    it('keeps existing create conflicts alongside attribution-required conflicts', () => {
+        const createConflictSchema = workers_contract_1.workersContractRouter.create.responses[409];
+        expect(workerCreateConflictCodesAreStructurallyDisjoint).toBe(true);
+        expect(createConflictSchema.parse({
+            message: 'Worker Leads attribution is required',
+            code: 'WORKER_LEAD_ATTRIBUTION_REQUIRED',
+            statusCode: 409,
+            details: {
+                challengeId: crypto.randomUUID(),
+                expiresAt: '2026-07-22T15:35:52.270Z',
+                submittedWorkerName: 'Earl Kearney',
+                match: evidence,
+                identityReviewAdjustment: null,
+            },
+        }).code).toBe('WORKER_LEAD_ATTRIBUTION_REQUIRED');
+        for (const code of GENERIC_WORKER_CREATE_CONFLICT_CODES) {
+            expect(createConflictSchema.parse({
+                statusCode: 409,
+                message: 'Worker creation conflict',
+                code,
+                timestamp: '2026-07-21T15:35:52.270Z',
+                path: '/v2/workers',
+            }).code).toBe(code);
+        }
+        expect(() => createConflictSchema.parse({
+            statusCode: 409,
+            message: 'Unmodeled generic conflict',
+            code: 'CONFLICT',
+            timestamp: '2026-07-21T15:35:52.270Z',
+            path: '/v2/workers',
+        })).toThrow();
+        expect(() => createConflictSchema.parse({
+            statusCode: 409,
+            message: 'Typed identity conflict using a generic shape',
+            code: 'WORKER_IDENTITY_CONFLICT',
+            details: { curatedWorkerIds: [crypto.randomUUID()] },
+            timestamp: '2026-07-21T15:35:52.270Z',
+            path: '/v2/workers',
+        })).toThrow();
+    });
+});

package/dist/workers/worker-source.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker-source.spec.d.ts.map

package/dist/workers/worker-source.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-source.spec.d.ts","sourceRoot":"","sources":["../../contracts/workers/worker-source.spec.ts"],"names":[],"mappings":""}

package/dist/workers/worker-source.spec.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const workers_contract_1 = require("./workers.contract");
+describe('WorkerSource contract', () => {
+    it('accepts the four source values', () => {
+        expect(workers_contract_1.WorkerSourceSchema.parse('LEAD_MATCH')).toBe('LEAD_MATCH');
+        expect(() => workers_contract_1.WorkerSourceSchema.parse('NOPE')).toThrow();
+    });
+    it('FilterWorkerSchema accepts a source array', () => {
+        const parsed = workers_contract_1.FilterWorkerSchema.parse({ source: ['LEAD_MATCH', 'MANUAL'] });
+        expect(parsed.source).toEqual(['LEAD_MATCH', 'MANUAL']);
+    });
+});

package/dist/workers/worker-status-facets.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker-status-facets.spec.d.ts.map

package/dist/workers/worker-status-facets.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-status-facets.spec.d.ts","sourceRoot":"","sources":["../../contracts/workers/worker-status-facets.spec.ts"],"names":[],"mappings":""}

package/dist/workers/worker-status-facets.spec.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const workers_contract_1 = require("./workers.contract");
+const curated_workers_contract_1 = require("../curated-workers/curated-workers.contract");
+describe('worker status facets', () => {
+    it('defines nullable booking-derived occupancy', () => {
+        expect(workers_contract_1.OccupancyStatusSchema.parse('ACTIVE')).toBe('ACTIVE');
+        expect(workers_contract_1.OccupancyStatusSchema.parse('BOOKED')).toBe('BOOKED');
+        expect(workers_contract_1.OccupancyStatusSchema.parse(null)).toBeNull();
+        expect(workers_contract_1.OccupancyStatusSchema.safeParse('FREE').success).toBe(false);
+    });
+    it('exposes occupancyStatus and required suppression on both worker responses', () => {
+        for (const shape of [workers_contract_1.WorkerSchema.shape, workers_contract_1.WorkerListItemSchema.shape]) {
+            expect(shape.occupancyStatus).toBeDefined();
+            expect(shape.suppression).toBeDefined();
+            expect(shape.suppression.safeParse(undefined).success).toBe(false);
+        }
+    });
+    it('exposes the same independent facets on curated worker responses', () => {
+        expect(curated_workers_contract_1.CuratedWorkerResponseSchema.shape.occupancyStatus).toBeDefined();
+        expect(curated_workers_contract_1.CuratedWorkerResponseSchema.shape.suppression).toBeDefined();
+        expect(curated_workers_contract_1.CuratedWorkerResponseSchema.shape.suppression.safeParse(undefined)
+            .success).toBe(false);
+    });
+    it('replaces the unified status filters with singular occupancy and contact filters', () => {
+        for (const schema of [workers_contract_1.FilterWorkerSchema, curated_workers_contract_1.FilterCuratedWorkerSchema]) {
+            expect(schema.parse({ occupancy: 'FREE', contact: 'CHASEABLE' })).toMatchObject({ occupancy: 'FREE', contact: 'CHASEABLE' });
+            expect(schema.shape.status).toBeUndefined();
+            expect(schema.safeParse({ occupancy: ['BOOKED'] }).success).toBe(false);
+            expect(schema.safeParse({ contact: 'BLACKLISTED' }).success).toBe(true);
+            expect(schema.safeParse({ contact: 'PAUSED' }).success).toBe(true);
+        }
+    });
+});