@dakkitor/api-contracts 1.1.154 → 1.5.0

package/dist/offices/offices.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"offices.contract.d.ts","sourceRoot":"","sources":["../../contracts/offices/offices.contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,YAAY;;;;;;;;;EAIrB,CAAC;AAEL,eAAO,MAAM,kBAAkB;;;;;;EAIM,CAAC;AAEtC,eAAO,MAAM,kBAAkB;;;;;;EAIM,CAAC;AAEtC,eAAO,MAAM,iBAAiB;;;;;;;;;WAEM,CAAC;AAGrC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAClD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAG9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoE3B,CAAC"}
+{"version":3,"file":"offices.contract.d.ts","sourceRoot":"","sources":["../../contracts/offices/offices.contract.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIvB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;EAKM,CAAC;AAEtC,eAAO,MAAM,kBAAkB;;;;;;;;;EAWM,CAAC;AAEtC,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAEM,CAAC;AAGrC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAClD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAG9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoE3B,CAAC"}

package/dist/offices/offices.contract.js

@@ -6,19 +6,33 @@ const zod_1 = require("zod");
 const error_schemas_1 = require("../common/error-schemas");
 const c = (0, core_1.initContract)();
 // --- Schemas ---
-exports.OfficeSchema = zod_1.z
-    .object({
+/** Inline to avoid circular dependency with users.contract (which imports OfficeSchema). */
+const OfficeManagerSchema = zod_1.z.object({
+    id: zod_1.z.string().describe('The unique identifier of the user.'),
+    firstName: zod_1.z.string().describe('The first name of the user.'),
+    lastName: zod_1.z.string().describe('The last name of the user.'),
+});
+exports.OfficeSchema = zod_1.z.object({
     id: zod_1.z.string().uuid().describe('Unique identifier for the office'),
     name: zod_1.z.string().describe('Name of the office'),
+    managers: zod_1.z.array(OfficeManagerSchema).optional(),
 });
 exports.CreateOfficeSchema = zod_1.z
     .object({
-    name: zod_1.z.string().min(1).max(255).describe('Name of the office'),
+    name: zod_1.z.string().trim().min(1).max(255).describe('Name of the office'),
+    managerIds: zod_1.z.array(zod_1.z.string().uuid()).optional(),
 })
     .openapi({ title: 'CreateOffice' });
 exports.UpdateOfficeSchema = zod_1.z
     .object({
-    name: zod_1.z.string().min(1).max(255).optional().describe('Name of the office'),
+    name: zod_1.z
+        .string()
+        .trim()
+        .min(1)
+        .max(255)
+        .optional()
+        .describe('Name of the office'),
+    managerIds: zod_1.z.array(zod_1.z.string().uuid()).optional(),
 })
     .openapi({ title: 'UpdateOffice' });
 exports.OfficeArraySchema = zod_1.z

package/dist/outreach/__tests__/outreach-claim.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=outreach-claim.test.d.ts.map

package/dist/outreach/__tests__/outreach-claim.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outreach-claim.test.d.ts","sourceRoot":"","sources":["../../../contracts/outreach/__tests__/outreach-claim.test.ts"],"names":[],"mappings":""}

package/dist/outreach/__tests__/outreach-claim.test.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const outreach_contract_1 = require("../outreach.contract");
+// --- request ---------------------------------------------------------------
+node_assert_1.default.ok(outreach_contract_1.ClaimNextOutreachBodySchema.safeParse({ deviceId: 'rack-01' }).success);
+// Eligibility is server-side policy and takes no parameters. A caller able to
+// widen its own commute budget is a caller able to message someone the policy
+// excluded, so unknown keys must not survive into the parsed body.
+const widened = outreach_contract_1.ClaimNextOutreachBodySchema.safeParse({
+    deviceId: 'rack-01',
+    maxCommuteMinutes: 240,
+});
+node_assert_1.default.ok(widened.success);
+node_assert_1.default.equal(Object.prototype.hasOwnProperty.call(widened.data, 'maxCommuteMinutes'), false);
+node_assert_1.default.ok(!outreach_contract_1.ClaimNextOutreachBodySchema.safeParse({}).success);
+// --- TTL -------------------------------------------------------------------
+node_assert_1.default.equal(outreach_contract_1.OUTREACH_LEASE_TTL_MINUTES, 15);
+// --- CLAIMED ---------------------------------------------------------------
+const CLAIMED_PAYLOAD = {
+    status: 'CLAIMED',
+    lease: {
+        leaseId: '3f2504e0-4f89-41d3-9a0c-0305e82c3301',
+        expiresAt: '2026-07-28T10:15:00.000Z',
+    },
+    candidate: {
+        subjectKind: 'CURATED',
+        subjectId: '9c858901-8a57-4791-81fe-4c455b099bc9',
+        canonicalKind: 'CURATED_WORKER',
+        canonicalId: '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
+        name: 'Adam Kowalski',
+        phoneNumber: '+447700900123',
+        commuteMinutes: 45,
+        transportMode: 'PUBLIC_TRANSPORT',
+    },
+    job: {
+        title: 'Carpenter needed',
+        trade: 'CARPENTER',
+        payText: '£180/day',
+        locationText: 'Croydon, CR0',
+        createdByName: 'Sam Okoro',
+    },
+};
+const claimed = outreach_contract_1.ClaimNextOutreachResponseSchema.safeParse(CLAIMED_PAYLOAD);
+node_assert_1.default.ok(claimed.success);
+node_assert_1.default.equal(claimed.data.status, 'CLAIMED');
+// A CLAIMED response missing a required branch member is rejected.
+const { job: _omittedJob, ...claimedWithoutJob } = CLAIMED_PAYLOAD;
+node_assert_1.default.ok(!outreach_contract_1.ClaimNextOutreachResponseSchema.safeParse(claimedWithoutJob).success);
+// --- POOL_EMPTY ------------------------------------------------------------
+// An empty pool is a 200, not an error: the caller winds the campaign down
+// rather than backing off, and must not have to parse an error string.
+const empty = outreach_contract_1.ClaimNextOutreachResponseSchema.safeParse({
+    status: 'POOL_EMPTY',
+});
+node_assert_1.default.ok(empty.success);
+node_assert_1.default.equal(empty.data.status, 'POOL_EMPTY');
+// Both are instances of the SAME 200 schema.
+node_assert_1.default.ok(claimed.success && empty.success, 'CLAIMED and POOL_EMPTY are both valid 200 bodies');
+// POOL_EMPTY carries none of the CLAIMED members.
+const pollutedEmpty = outreach_contract_1.ClaimNextOutreachResponseSchema.safeParse({
+    status: 'POOL_EMPTY',
+    candidate: CLAIMED_PAYLOAD.candidate,
+});
+node_assert_1.default.ok(pollutedEmpty.success);
+node_assert_1.default.equal(Object.prototype.hasOwnProperty.call(pollutedEmpty.data, 'candidate'), false);
+// An unrecognised discriminant is rejected outright.
+node_assert_1.default.ok(!outreach_contract_1.ClaimNextOutreachResponseSchema.safeParse({ status: 'ERROR' }).success);
+// --- compile-time discrimination -------------------------------------------
+// These probes are never called at runtime. They exist so `tsc` (run by
+// `bun run build`) fails if the union stops discriminating: an unsatisfied
+// `@ts-expect-error` is itself a compile error.
+function renderClaim(res) {
+    if (res.status === 'POOL_EMPTY')
+        return 'idle';
+    return `${res.candidate.name} -> ${res.job.title}`;
+}
+function _unguardedAccessMustNotTypecheck(res) {
+    // @ts-expect-error `candidate` exists only on the CLAIMED member.
+    void res.candidate;
+}
+void _unguardedAccessMustNotTypecheck;
+function _partialHandlingMustNotTypecheck(res) {
+    if (res.status === 'CLAIMED')
+        return res.candidate.name;
+    // POOL_EMPTY is unhandled, so `res` is not narrowed to `never` here.
+    // @ts-expect-error a consumer that handles only one branch fails to typecheck.
+    const exhaustive = res;
+    return exhaustive;
+}
+void _partialHandlingMustNotTypecheck;
+// The narrowing path does work.
+node_assert_1.default.equal(renderClaim(claimed.data), 'Adam Kowalski -> Carpenter needed');
+node_assert_1.default.equal(renderClaim(empty.data), 'idle');
+console.log('outreach claim contract OK');

package/dist/outreach/__tests__/outreach-confirm-release.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=outreach-confirm-release.test.d.ts.map

package/dist/outreach/__tests__/outreach-confirm-release.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outreach-confirm-release.test.d.ts","sourceRoot":"","sources":["../../../contracts/outreach/__tests__/outreach-confirm-release.test.ts"],"names":[],"mappings":""}

package/dist/outreach/__tests__/outreach-confirm-release.test.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const outreach_contract_1 = require("../outreach.contract");
+const BASE_SENT = {
+    deviceId: 'rack-01',
+    variantKey: 'greeting_v2',
+    deliveryVerified: true,
+    sentAt: '2026-07-28T10:07:31.000Z',
+};
+// --- sent: required shape --------------------------------------------------
+const sent = outreach_contract_1.ConfirmOutreachSentBodySchema.safeParse(BASE_SENT);
+node_assert_1.default.ok(sent.success);
+node_assert_1.default.equal(sent.data.deliveryVerified, true);
+node_assert_1.default.equal(sent.data.metadata, undefined);
+// deliveryVerified distinguishes a send whose bubble was SEEN from one that was
+// tapped but never confirmed. Both count as contacted, so `false` is valid.
+const unverified = outreach_contract_1.ConfirmOutreachSentBodySchema.safeParse({
+    ...BASE_SENT,
+    deliveryVerified: false,
+});
+node_assert_1.default.ok(unverified.success);
+// Missing required fields are rejected, one at a time.
+for (const key of ['deviceId', 'variantKey', 'deliveryVerified', 'sentAt']) {
+    const partial = { ...BASE_SENT };
+    delete partial[key];
+    node_assert_1.default.ok(!outreach_contract_1.ConfirmOutreachSentBodySchema.safeParse(partial).success, `${key} must be required`);
+}
+// sentAt must be an instant, not a free string.
+node_assert_1.default.ok(!outreach_contract_1.ConfirmOutreachSentBodySchema.safeParse({ ...BASE_SENT, sentAt: 'now' })
+    .success);
+// --- deviceId is opaque ----------------------------------------------------
+// It is a correlation key, not a parsed identifier. Anything non-empty goes,
+// including values that look nothing like an ADB serial.
+for (const deviceId of [
+    'emulator-5554',
+    'RF8N20XXXXX',
+    'shelf-3/slot-2 (spare)',
+    'urn:relay-lab:device:7',
+    '中文设备',
+    'x'.repeat(200),
+]) {
+    node_assert_1.default.ok(outreach_contract_1.ConfirmOutreachSentBodySchema.safeParse({ ...BASE_SENT, deviceId }).success, `deviceId ${deviceId} must be accepted`);
+}
+node_assert_1.default.ok(!outreach_contract_1.ConfirmOutreachSentBodySchema.safeParse({ ...BASE_SENT, deviceId: '' })
+    .success);
+// --- metadata round-trips an arbitrary nested object -----------------------
+const metadata = {
+    attempt: 2,
+    bubbles: ['hi', 'details', 'cta'],
+    timings: { openMs: 812, sendMs: 1503, nested: { deep: { flag: true } } },
+    note: null,
+};
+const withMeta = outreach_contract_1.ConfirmOutreachSentBodySchema.safeParse({
+    ...BASE_SENT,
+    metadata,
+});
+node_assert_1.default.ok(withMeta.success);
+node_assert_1.default.deepStrictEqual(withMeta.data.metadata, metadata);
+// --- sent: response --------------------------------------------------------
+// Confirming against an expired lease still succeeds — the message really was
+// sent, and refusing to record it is how a worker gets messaged twice.
+const late = outreach_contract_1.ConfirmOutreachSentResponseSchema.safeParse({
+    recorded: true,
+    lateConfirm: true,
+});
+node_assert_1.default.ok(late.success);
+node_assert_1.default.equal(late.data.lateConfirm, true);
+node_assert_1.default.ok(outreach_contract_1.ConfirmOutreachSentResponseSchema.safeParse({
+    recorded: true,
+    lateConfirm: false,
+}).success);
+node_assert_1.default.ok(!outreach_contract_1.ConfirmOutreachSentResponseSchema.safeParse({ recorded: true }).success);
+// --- release ---------------------------------------------------------------
+const released = outreach_contract_1.ReleaseOutreachLeaseBodySchema.safeParse({
+    deviceId: 'rack-01',
+    reason: 'CHAT_OPEN_FAILED',
+});
+node_assert_1.default.ok(released.success);
+node_assert_1.default.equal(released.data.detail, undefined);
+node_assert_1.default.ok(outreach_contract_1.ReleaseOutreachLeaseBodySchema.safeParse({
+    deviceId: 'rack-01',
+    reason: 'OTHER',
+    detail: 'accessibility service restarted mid-compose',
+}).success);
+// Release is for failures BEFORE the send button is tapped, never after: there
+// is no "already sent" reason.
+node_assert_1.default.ok(!outreach_contract_1.ReleaseOutreachLeaseBodySchema.safeParse({
+    deviceId: 'rack-01',
+    reason: 'ALREADY_SENT',
+}).success);
+node_assert_1.default.ok(!outreach_contract_1.ReleaseOutreachLeaseBodySchema.safeParse({ deviceId: 'rack-01' }).success);
+node_assert_1.default.ok(outreach_contract_1.ReleaseOutreachLeaseResponseSchema.safeParse({ released: true }).success);
+node_assert_1.default.ok(!outreach_contract_1.ReleaseOutreachLeaseResponseSchema.safeParse({ released: false }).success);
+console.log('outreach confirm/release contract OK');

package/dist/outreach/__tests__/outreach-contract-additions.spec.d.ts

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

package/dist/outreach/__tests__/outreach-contract-additions.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outreach-contract-additions.spec.d.ts","sourceRoot":"","sources":["../../../contracts/outreach/__tests__/outreach-contract-additions.spec.ts"],"names":[],"mappings":""}

package/dist/outreach/__tests__/outreach-contract-additions.spec.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bun_test_1 = require("bun:test");
+const outreach_schemas_1 = require("../outreach.schemas");
+const jobs_tab_contract_1 = require("../../curated-worker-leads/jobs-tab.contract");
+(0, bun_test_1.describe)('1.5.0 additions stay backward compatible', () => {
+    (0, bun_test_1.it)('OutreachJobSchema carries createdByName, nullable', () => {
+        (0, bun_test_1.expect)(outreach_schemas_1.OutreachJobSchema.parse({
+            title: 'Need 1 x bricklayer',
+            trade: 'Bricklayer',
+            payText: null,
+            locationText: 'SW1A 1AA',
+            createdByName: null,
+        }).createdByName).toBeNull();
+    });
+    (0, bun_test_1.it)('JobFeedMatchCountSchema still parses a 1.4.0-shaped payload', () => {
+        // The whole point of `.optional()`: an API that has not deployed the new
+        // CTE yet, and a 1.4.0 consumer, both keep working.
+        const parsed = jobs_tab_contract_1.JobFeedMatchCountSchema.parse({
+            owned: 3,
+            curated: 4,
+            workersContactedByViewerCount: 1,
+            workersContactedByOthersCount: 2,
+            pendingEnrichmentCount: 0,
+        });
+        (0, bun_test_1.expect)(parsed.outreachRequest).toBeUndefined();
+    });
+    (0, bun_test_1.it)('JobFeedMatchCountSchema carries an outreach request when there is one', () => {
+        const parsed = jobs_tab_contract_1.JobFeedMatchCountSchema.parse({
+            owned: 3,
+            curated: 4,
+            workersContactedByViewerCount: 1,
+            workersContactedByOthersCount: 2,
+            pendingEnrichmentCount: 0,
+            outreachRequest: {
+                id: '22222222-2222-4222-8222-222222222222',
+                status: 'RUNNING',
+                requestedByName: 'Priya Shah',
+                contactedCount: 142,
+            },
+        });
+        (0, bun_test_1.expect)(parsed.outreachRequest?.contactedCount).toBe(142);
+        (0, bun_test_1.expect)(parsed.outreachRequest?.id).toBe('22222222-2222-4222-8222-222222222222');
+    });
+    (0, bun_test_1.it)('rejects an open request without an id', () => {
+        // The id is REQUIRED inside the object (the object itself stays nullable
+        // and optional). It is the only route a browser has to the request id:
+        // cancel is agent-lane while the queue list route is service-key only, so
+        // omitting it would leave the cancel route unreachable.
+        (0, bun_test_1.expect)(() => jobs_tab_contract_1.JobFeedMatchCountSchema.parse({
+            owned: 0,
+            curated: 0,
+            workersContactedByViewerCount: 0,
+            workersContactedByOthersCount: 0,
+            pendingEnrichmentCount: 0,
+            outreachRequest: {
+                status: 'PENDING',
+                requestedByName: null,
+                contactedCount: 0,
+            },
+        })).toThrow();
+    });
+    (0, bun_test_1.it)('null means "no open request", distinct from "not computed"', () => {
+        (0, bun_test_1.expect)(jobs_tab_contract_1.JobFeedMatchCountSchema.parse({
+            owned: 0,
+            curated: 0,
+            workersContactedByViewerCount: 0,
+            workersContactedByOthersCount: 0,
+            pendingEnrichmentCount: 0,
+            outreachRequest: null,
+        }).outreachRequest).toBeNull();
+    });
+    (0, bun_test_1.it)('the candidates query takes outreachEligible as a coerced boolean', () => {
+        const query = jobs_tab_contract_1.jobsTabContract.candidates.query;
+        (0, bun_test_1.expect)(query.parse({ outreachEligible: 'true' }).outreachEligible).toBe(true);
+        (0, bun_test_1.expect)(query.parse({}).outreachEligible).toBeUndefined();
+    });
+});

package/dist/outreach/__tests__/outreach-requests.contract.spec.d.ts

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

package/dist/outreach/__tests__/outreach-requests.contract.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outreach-requests.contract.spec.d.ts","sourceRoot":"","sources":["../../../contracts/outreach/__tests__/outreach-requests.contract.spec.ts"],"names":[],"mappings":""}

package/dist/outreach/__tests__/outreach-requests.contract.spec.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bun_test_1 = require("bun:test");
+const outreach_requests_contract_1 = require("../outreach-requests.contract");
+(0, bun_test_1.describe)('outreachRequestsContract', () => {
+    (0, bun_test_1.it)('enumerates exactly the four request states', () => {
+        (0, bun_test_1.expect)(outreach_requests_contract_1.OutreachRequestStatusSchema.options).toEqual([
+            'PENDING',
+            'RUNNING',
+            'COMPLETED',
+            'CANCELLED',
+        ]);
+    });
+    (0, bun_test_1.it)('parses a request row', () => {
+        const parsed = outreach_requests_contract_1.OutreachRequestSchema.parse({
+            id: '11111111-1111-4111-8111-111111111111',
+            jobId: '22222222-2222-4222-8222-222222222222',
+            status: 'PENDING',
+            eligibleAtRequest: 214,
+            requestedByName: 'Priya Shah',
+            contactedCount: 0,
+            createdAt: '2026-07-29T09:00:00.000Z',
+            startedAt: null,
+            completedAt: null,
+        });
+        (0, bun_test_1.expect)(parsed.status).toBe('PENDING');
+    });
+    (0, bun_test_1.it)('carries job facts on a queue item so the rack can label a campaign', () => {
+        const item = outreach_requests_contract_1.OutreachRequestQueueItemSchema.parse({
+            id: '11111111-1111-4111-8111-111111111111',
+            jobId: '22222222-2222-4222-8222-222222222222',
+            status: 'RUNNING',
+            eligibleAtRequest: 12,
+            requestedByName: null,
+            contactedCount: 3,
+            createdAt: '2026-07-29T09:00:00.000Z',
+            startedAt: '2026-07-29T09:05:00.000Z',
+            completedAt: null,
+            job: {
+                title: 'Need 1 x bricklayer',
+                trade: 'Bricklayer',
+                payText: '£20 per hour',
+                locationText: 'SW1A 1AA',
+                createdByName: 'Sam Okoro',
+            },
+        });
+        // `trade` is the label Relay Lab shows: `title` is j.description, the raw
+        // ad text. `locationText` is the job postcode, carried since 1.4.0.
+        (0, bun_test_1.expect)(item.job.trade).toBe('Bricklayer');
+        (0, bun_test_1.expect)(item.job.locationText).toBe('SW1A 1AA');
+    });
+    (0, bun_test_1.it)('routes both lanes under /v2', () => {
+        (0, bun_test_1.expect)(outreach_requests_contract_1.outreachRequestsContract.create.path).toBe('/v2/outreach/requests');
+        (0, bun_test_1.expect)(outreach_requests_contract_1.outreachRequestsContract.list.path).toBe('/v2/outreach/requests');
+        (0, bun_test_1.expect)(outreach_requests_contract_1.outreachRequestsContract.list.method).toBe('GET');
+        (0, bun_test_1.expect)(outreach_requests_contract_1.outreachRequestsContract.cancel.path).toBe('/v2/outreach/requests/:id/cancel');
+        (0, bun_test_1.expect)(outreach_requests_contract_1.outreachRequestsContract.start.path).toBe('/v2/outreach/requests/:id/start');
+        (0, bun_test_1.expect)(outreach_requests_contract_1.outreachRequestsContract.complete.path).toBe('/v2/outreach/requests/:id/complete');
+    });
+    (0, bun_test_1.it)('declares 200 on create, because a second click returns the open request', () => {
+        (0, bun_test_1.expect)(Object.keys(outreach_requests_contract_1.outreachRequestsContract.create.responses)).toContain('200');
+        (0, bun_test_1.expect)(Object.keys(outreach_requests_contract_1.outreachRequestsContract.create.responses)).not.toContain('409');
+    });
+});

package/dist/outreach/__tests__/outreach-routes.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=outreach-routes.test.d.ts.map

package/dist/outreach/__tests__/outreach-routes.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outreach-routes.test.d.ts","sourceRoot":"","sources":["../../../contracts/outreach/__tests__/outreach-routes.test.ts"],"names":[],"mappings":""}

package/dist/outreach/__tests__/outreach-routes.test.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const index_1 = require("../../index");
+const outreach_contract_1 = require("../outreach.contract");
+// `pathPrefix: '/v2'` is applied by c.router, so the runtime paths are absolute.
+node_assert_1.default.equal(outreach_contract_1.outreachContract.claimNext.method, 'POST');
+node_assert_1.default.equal(outreach_contract_1.outreachContract.claimNext.path, '/v2/outreach/jobs/:jobId/claim-next');
+node_assert_1.default.equal(outreach_contract_1.outreachContract.confirmSent.method, 'POST');
+node_assert_1.default.equal(outreach_contract_1.outreachContract.confirmSent.path, '/v2/outreach/leases/:leaseId/sent');
+node_assert_1.default.equal(outreach_contract_1.outreachContract.release.method, 'POST');
+node_assert_1.default.equal(outreach_contract_1.outreachContract.release.path, '/v2/outreach/leases/:leaseId/release');
+// Error taxonomy. Exhaustion is a 200, so claim-next declares no 404, and
+// 410 is not used anywhere: a late confirm succeeds. `commonResponses` are
+// merged into every route's `responses` by c.router, so 400, 401, 403 and 500
+// appear here.
+const declared = (route) => Object.keys(route.responses).map(Number).sort((a, b) => a - b);
+node_assert_1.default.deepStrictEqual(declared(outreach_contract_1.outreachContract.claimNext), [200, 400, 401, 403, 409, 500]);
+node_assert_1.default.deepStrictEqual(declared(outreach_contract_1.outreachContract.confirmSent), [200, 400, 401, 403, 404, 500]);
+node_assert_1.default.deepStrictEqual(declared(outreach_contract_1.outreachContract.release), [200, 400, 401, 403, 404, 500]);
+for (const route of [
+    outreach_contract_1.outreachContract.claimNext,
+    outreach_contract_1.outreachContract.confirmSent,
+    outreach_contract_1.outreachContract.release,
+]) {
+    node_assert_1.default.ok(!Object.prototype.hasOwnProperty.call(route.responses, '410'), '410 is not used: an expired lease that is confirmed late succeeds');
+}
+// Path params are validated as uuids.
+node_assert_1.default.ok(outreach_contract_1.outreachContract.claimNext.pathParams.safeParse({
+    jobId: '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
+}).success);
+node_assert_1.default.ok(!outreach_contract_1.outreachContract.claimNext.pathParams.safeParse({ jobId: 'nope' }).success);
+node_assert_1.default.ok(outreach_contract_1.outreachContract.confirmSent.pathParams.safeParse({
+    leaseId: '3f2504e0-4f89-41d3-9a0c-0305e82c3301',
+}).success);
+// Following the codebase convention, no route declares headers: the Bearer
+// token rides the existing `authorization` header and is documented in the
+// module header, not typed here. `c.router`'s zodMerge(baseHeaders, headers)
+// falls back to `Object.assign({}, undefined, undefined)` when neither side
+// is a strict zod object, so an undeclared `headers` comes out as `{}` at
+// runtime, not `undefined` — verified against the pre-existing
+// `healthContract.check` route, which also declares no headers.
+const headersOf = (route) => route.headers;
+for (const route of [
+    outreach_contract_1.outreachContract.claimNext,
+    outreach_contract_1.outreachContract.confirmSent,
+    outreach_contract_1.outreachContract.release,
+]) {
+    node_assert_1.default.deepStrictEqual(headersOf(route), {});
+}
+// Reachable from the aggregate router, which is what spec 2's controllers use.
+node_assert_1.default.equal(index_1.apiContractRouter.Outreach.claimNext.method, 'POST');
+node_assert_1.default.equal(index_1.apiContractRouter.Outreach.release.path, '/v2/outreach/leases/:leaseId/release');
+console.log('outreach routes OK');

package/dist/outreach/__tests__/outreach.schemas.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=outreach.schemas.test.d.ts.map

package/dist/outreach/__tests__/outreach.schemas.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outreach.schemas.test.d.ts","sourceRoot":"","sources":["../../../contracts/outreach/__tests__/outreach.schemas.test.ts"],"names":[],"mappings":""}

package/dist/outreach/__tests__/outreach.schemas.test.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const outreach_schemas_1 = require("../outreach.schemas");
+// --- enums -----------------------------------------------------------------
+node_assert_1.default.ok(outreach_schemas_1.OutreachSubjectKindSchema.safeParse('OWNED').success);
+node_assert_1.default.ok(outreach_schemas_1.OutreachSubjectKindSchema.safeParse('CURATED').success);
+node_assert_1.default.ok(!outreach_schemas_1.OutreachSubjectKindSchema.safeParse('WORKER').success);
+// The mode is the mode the commute figure was MEASURED against, not the
+// worker's saved transportation method, so the six-value method enum is
+// deliberately not reused here.
+node_assert_1.default.ok(outreach_schemas_1.OutreachTransportModeSchema.safeParse('DRIVE').success);
+node_assert_1.default.ok(outreach_schemas_1.OutreachTransportModeSchema.safeParse('PUBLIC_TRANSPORT').success);
+node_assert_1.default.ok(!outreach_schemas_1.OutreachTransportModeSchema.safeParse('OWN_VAN').success);
+node_assert_1.default.ok(outreach_schemas_1.OutreachReleaseReasonSchema.safeParse('CONTACT_SAVE_FAILED').success);
+node_assert_1.default.ok(outreach_schemas_1.OutreachReleaseReasonSchema.safeParse('CHAT_OPEN_FAILED').success);
+node_assert_1.default.ok(outreach_schemas_1.OutreachReleaseReasonSchema.safeParse('COMPOSE_FAILED').success);
+node_assert_1.default.ok(outreach_schemas_1.OutreachReleaseReasonSchema.safeParse('OTHER').success);
+node_assert_1.default.ok(!outreach_schemas_1.OutreachReleaseReasonSchema.safeParse('SENT').success);
+// canonicalKind is a separate axis from subjectKind: an OWNED subject can
+// legitimately carry canonicalKind CURATED_WORKER (see the candidate tests
+// below), so both values must parse regardless of lane.
+node_assert_1.default.ok(outreach_schemas_1.OutreachCanonicalKindSchema.safeParse('WORKER').success);
+node_assert_1.default.ok(outreach_schemas_1.OutreachCanonicalKindSchema.safeParse('CURATED_WORKER').success);
+node_assert_1.default.ok(!outreach_schemas_1.OutreachCanonicalKindSchema.safeParse('OWNED').success);
+// --- lease -----------------------------------------------------------------
+const lease = outreach_schemas_1.OutreachLeaseSchema.safeParse({
+    leaseId: '3f2504e0-4f89-41d3-9a0c-0305e82c3301',
+    expiresAt: '2026-07-28T10:15:00.000Z',
+});
+node_assert_1.default.ok(lease.success);
+node_assert_1.default.equal(lease.data.expiresAt, '2026-07-28T10:15:00.000Z');
+// A missing required field is rejected.
+node_assert_1.default.ok(!outreach_schemas_1.OutreachLeaseSchema.safeParse({
+    leaseId: '3f2504e0-4f89-41d3-9a0c-0305e82c3301',
+}).success);
+// --- candidate -------------------------------------------------------------
+const candidate = outreach_schemas_1.OutreachCandidateSchema.safeParse({
+    subjectKind: 'CURATED',
+    subjectId: '9c858901-8a57-4791-81fe-4c455b099bc9',
+    canonicalKind: 'CURATED_WORKER',
+    canonicalId: '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
+    name: 'Adam Kowalski',
+    phoneNumber: '+447700900123',
+    commuteMinutes: 45,
+    transportMode: 'PUBLIC_TRANSPORT',
+});
+node_assert_1.default.ok(candidate.success);
+node_assert_1.default.equal(candidate.data.commuteMinutes, 45);
+// commuteMinutes is a plain number, not an integer: the source proximity
+// columns (drive_minutes / transit_minutes) are `real`, so a fractional
+// figure must parse — an .int() constraint here would make a well-behaved
+// server response fail client-side validation on a successful claim.
+const fractionalCandidate = outreach_schemas_1.OutreachCandidateSchema.safeParse({
+    subjectKind: 'CURATED',
+    subjectId: '9c858901-8a57-4791-81fe-4c455b099bc9',
+    canonicalKind: 'CURATED_WORKER',
+    canonicalId: '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
+    name: 'Adam Kowalski',
+    phoneNumber: '+447700900123',
+    commuteMinutes: 44.3,
+    transportMode: 'DRIVE',
+});
+node_assert_1.default.ok(fractionalCandidate.success);
+node_assert_1.default.equal(fractionalCandidate.data.commuteMinutes, 44.3);
+// commuteMinutes is NOT nullable: eligibility is strict on nulls, so a
+// claimed candidate always has a known figure for its resolved mode.
+node_assert_1.default.ok(!outreach_schemas_1.OutreachCandidateSchema.safeParse({
+    subjectKind: 'CURATED',
+    subjectId: '9c858901-8a57-4791-81fe-4c455b099bc9',
+    canonicalKind: 'CURATED_WORKER',
+    canonicalId: '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
+    name: 'Adam Kowalski',
+    phoneNumber: '+447700900123',
+    commuteMinutes: null,
+    transportMode: 'PUBLIC_TRANSPORT',
+}).success);
+// transportMode is resolved server-side AFTER the fallback, so it is never null.
+node_assert_1.default.ok(!outreach_schemas_1.OutreachCandidateSchema.safeParse({
+    subjectKind: 'OWNED',
+    subjectId: '9c858901-8a57-4791-81fe-4c455b099bc9',
+    canonicalKind: 'WORKER',
+    canonicalId: '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
+    name: 'Adam Kowalski',
+    phoneNumber: '+447700900123',
+    commuteMinutes: 20,
+    transportMode: null,
+}).success);
+// canonicalKind is required: a candidate carrying only canonicalId cannot be
+// correlated against the ledger, which keys canonical identity on the pair.
+node_assert_1.default.ok(!outreach_schemas_1.OutreachCandidateSchema.safeParse({
+    subjectKind: 'OWNED',
+    subjectId: '9c858901-8a57-4791-81fe-4c455b099bc9',
+    canonicalId: '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
+    name: 'Adam Kowalski',
+    phoneNumber: '+447700900123',
+    commuteMinutes: 20,
+    transportMode: 'DRIVE',
+}).success);
+// canonicalKind is NOT derivable from subjectKind: an OWNED subject backed by
+// a linked curated_workers row resolves to canonicalKind CURATED_WORKER, per
+// apps/api's candidate-eligibility.util.ts. This is the case the field
+// exists for, so it must parse cleanly.
+const ownedWithCuratedCanonical = outreach_schemas_1.OutreachCandidateSchema.safeParse({
+    subjectKind: 'OWNED',
+    subjectId: '9c858901-8a57-4791-81fe-4c455b099bc9',
+    canonicalKind: 'CURATED_WORKER',
+    canonicalId: '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
+    name: 'Adam Kowalski',
+    phoneNumber: '+447700900123',
+    commuteMinutes: 20,
+    transportMode: 'DRIVE',
+});
+node_assert_1.default.ok(ownedWithCuratedCanonical.success);
+// --- job -------------------------------------------------------------------
+const job = outreach_schemas_1.OutreachJobSchema.safeParse({
+    title: 'Carpenter needed',
+    trade: 'CARPENTER',
+    payText: '£180/day',
+    locationText: 'Croydon, CR0',
+    createdByName: 'Sam Okoro',
+});
+node_assert_1.default.ok(job.success);
+// Real jobs routinely lack pay, trade text, or a raising agent; those fields
+// are nullable.
+const sparseJob = outreach_schemas_1.OutreachJobSchema.safeParse({
+    title: 'Carpenter needed',
+    trade: null,
+    payText: null,
+    locationText: null,
+    createdByName: null,
+});
+node_assert_1.default.ok(sparseJob.success);
+// title is not.
+node_assert_1.default.ok(!outreach_schemas_1.OutreachJobSchema.safeParse({
+    trade: null,
+    payText: null,
+    locationText: null,
+    createdByName: null,
+}).success);
+console.log('outreach.schemas OK');