@happyvertical/smrt-bookings 0.60.8 → 0.60.10

package/dist/index.js

@@ -99,6 +99,57 @@ async function migrateBookingsV1(db) {
 		for (const statement of statements) await tx.query(statement);
 	});
 }
+var v2 = [
+	`ALTER TABLE smrt_booking_offerings ADD COLUMN unit text`,
+	`UPDATE smrt_booking_offerings SET unit = CASE kind WHEN 'supervision-day' THEN 'day' ELSE 'hour' END`,
+	`ALTER TABLE smrt_booking_offerings ALTER COLUMN unit SET NOT NULL`,
+	`ALTER TABLE smrt_booking_offerings ADD COLUMN price_cents bigint`,
+	`ALTER TABLE smrt_booking_offerings ADD COLUMN currency text`,
+	`ALTER TABLE smrt_booking_offerings
+    ADD CONSTRAINT smrt_booking_offerings_unit CHECK (unit IN ('hour','day','week','month')),
+    ADD CONSTRAINT smrt_booking_offerings_supervision_unit CHECK (kind <> 'supervision-day' OR unit = 'day'),
+    ADD CONSTRAINT smrt_booking_offerings_price CHECK (price_cents IS NULL OR price_cents >= 0),
+    ADD CONSTRAINT smrt_booking_offerings_currency CHECK (currency IS NULL OR currency ~ '^[A-Z]{3}$'),
+    ADD CONSTRAINT smrt_booking_offerings_priced CHECK ((price_cents IS NULL) = (currency IS NULL))`,
+	`ALTER TABLE smrt_booking_offerings ADD COLUMN title text NOT NULL DEFAULT ''`,
+	`ALTER TABLE smrt_booking_offerings ADD COLUMN description text NOT NULL DEFAULT ''`,
+	`ALTER TABLE smrt_booking_offerings ADD COLUMN public boolean NOT NULL DEFAULT false`,
+	`ALTER TABLE smrt_booking_offerings ADD CONSTRAINT smrt_booking_offerings_title CHECK (char_length(title) <= 120)`,
+	`ALTER TABLE smrt_booking_offerings ADD CONSTRAINT smrt_booking_offerings_description CHECK (char_length(description) <= 2000)`,
+	`ALTER TABLE smrt_bookings ADD COLUMN unit text`,
+	`UPDATE smrt_bookings b SET unit = o.unit FROM smrt_booking_offerings o
+    WHERE o.tenant_id = b.tenant_id AND o.id = b.offering_id`,
+	`ALTER TABLE smrt_bookings ALTER COLUMN unit SET NOT NULL`,
+	`ALTER TABLE smrt_bookings ADD COLUMN quantity integer NOT NULL DEFAULT 1`,
+	`ALTER TABLE smrt_bookings
+    ADD CONSTRAINT smrt_bookings_unit CHECK (unit IN ('hour','day','week','month')),
+    ADD CONSTRAINT smrt_bookings_quantity CHECK (quantity >= 1 AND quantity <= 1000),
+    ADD CONSTRAINT smrt_bookings_supervision_quantity CHECK (kind <> 'supervision-day' OR (unit = 'day' AND quantity = 1))`,
+	`ALTER TABLE smrt_booking_proposals ADD COLUMN windows jsonb`,
+	`UPDATE smrt_booking_proposals SET windows = jsonb_build_array(coverage)`,
+	`ALTER TABLE smrt_booking_proposals ALTER COLUMN windows SET NOT NULL`,
+	`ALTER TABLE smrt_booking_proposals ADD COLUMN unit text`,
+	`UPDATE smrt_booking_proposals p SET unit = b.unit FROM smrt_bookings b
+    WHERE b.tenant_id = p.tenant_id AND b.id = p.booking_id`,
+	`ALTER TABLE smrt_booking_proposals ALTER COLUMN unit SET NOT NULL`,
+	`ALTER TABLE smrt_booking_proposals ADD COLUMN quantity integer NOT NULL DEFAULT 1`,
+	`ALTER TABLE smrt_booking_proposals ADD COLUMN unit_price_cents bigint`,
+	`ALTER TABLE smrt_booking_proposals ADD COLUMN currency text`,
+	`ALTER TABLE smrt_booking_proposals ADD COLUMN total_cents bigint`,
+	`ALTER TABLE smrt_booking_proposals
+    ADD CONSTRAINT smrt_booking_proposals_unit CHECK (unit IN ('hour','day','week','month')),
+    ADD CONSTRAINT smrt_booking_proposals_quantity CHECK (quantity >= 1 AND quantity <= 1000),
+    ADD CONSTRAINT smrt_booking_proposals_priced
+      CHECK ((unit_price_cents IS NULL) = (currency IS NULL) AND (unit_price_cents IS NULL) = (total_cents IS NULL)),
+    ADD CONSTRAINT smrt_booking_proposals_total CHECK (total_cents IS NULL OR total_cents = unit_price_cents * quantity),
+    ADD CONSTRAINT smrt_booking_proposals_windows CHECK (jsonb_typeof(windows) = 'array' AND jsonb_array_length(windows) >= 1)`
+];
+async function migrateBookingsV2(db) {
+	if (!db.transaction) throw new TypeError("Bookings requires a PostgreSQL transaction");
+	await db.transaction(async (tx) => {
+		for (const statement of v2) await tx.query(statement);
+	});
+}
 //#endregion
 //#region src/windows.ts
 var WALL = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2})([+-]\d{2}:\d{2})$/;
@@ -144,9 +195,6 @@ function resolveBookingWindow(window) {
 		endUtc
 	};
 }
-function elapsedHour(window) {
-	return Date.parse(window.endUtc) - Date.parse(window.startUtc) === 60 * MINUTE_MS;
-}
 function oneLocalDay(window) {
 	const startDate = window.start.slice(0, 10);
 	const endDate = window.end.slice(0, 10);
@@ -184,7 +232,7 @@ function declareWindows(zone, windows) {
 function supervisionDeclared(candidate, windows) {
 	return windows.some((window) => window.supervision && candidate.start === window.start && candidate.end === window.end && candidate.zone === window.zone);
 }
-function fitsCapacity(candidate, declared, occupied) {
+function remainingCapacity(candidate, declared, occupied) {
 	const boundaries = /* @__PURE__ */ new Map();
 	const add = (at, key, delta) => {
 		const event = boundaries.get(at) ?? {
@@ -206,23 +254,138 @@ function fitsCapacity(candidate, declared, occupied) {
 	let capacity = 0;
 	let shared = 0;
 	let exclusive = 0;
+	let remaining = Number.POSITIVE_INFINITY;
 	for (const at of [...boundaries.keys()].sort()) {
 		const delta = boundaries.get(at);
 		if (!delta) continue;
 		capacity += delta.capacity;
 		shared += delta.shared;
 		exclusive += delta.exclusive;
-		if (capacity < 1 || exclusive > 0 || (candidate.exclusive ? shared > 0 : shared >= capacity)) return false;
+		if (capacity < 1 || exclusive > 0 || (candidate.exclusive ? shared > 0 : shared >= capacity)) return 0;
+		remaining = Math.min(remaining, candidate.exclusive ? 1 : capacity - shared);
+	}
+	return Number.isFinite(remaining) ? remaining : 0;
+}
+function fitsCapacity(candidate, declared, occupied) {
+	return remainingCapacity(candidate, declared, occupied) >= 1;
+}
+function resolveCoverage(windows) {
+	if (!Array.isArray(windows) || windows.length < 1 || windows.length > 400) throw new BookingError("invalid", `Expected between 1 and 400 booking windows`);
+	const resolved = windows.map((window) => resolveBookingWindow(window)).sort((a, b) => a.startUtc.localeCompare(b.startUtc));
+	for (const [i, window] of resolved.entries()) {
+		if (window.zone !== resolved[0].zone) throw new BookingError("invalid", "Booking windows must share one zone");
+		if (i > 0 && resolved[i - 1].endUtc > window.startUtc) throw new BookingError("invalid", "Booking windows must not overlap");
+	}
+	const first = resolved[0];
+	const last = resolved[resolved.length - 1];
+	return {
+		windows: resolved,
+		span: {
+			zone: first.zone,
+			start: first.start,
+			end: last.end,
+			startUtc: first.startUtc,
+			endUtc: last.endUtc
+		}
+	};
+}
+function pad(value, width = 2) {
+	return String(value).padStart(width, "0");
+}
+function addLocalDays(date, days) {
+	const moved = /* @__PURE__ */ new Date(`${date}T00:00:00Z`);
+	moved.setUTCDate(moved.getUTCDate() + days);
+	return moved.toISOString().slice(0, 10);
+}
+function addLocalMonths(date, months) {
+	const [year, month, day] = date.split("-").map(Number);
+	const index = year * 12 + (month - 1) + months;
+	const targetYear = Math.floor(index / 12);
+	const targetMonth = index % 12;
+	const length = new Date(Date.UTC(targetYear, targetMonth + 1, 0)).getUTCDate();
+	return `${pad(targetYear, 4)}-${pad(targetMonth + 1)}-${pad(Math.min(day, length))}`;
+}
+function localEnd(unit, quantity, start) {
+	if (unit === "day") return addLocalDays(start, quantity);
+	if (unit === "week") return addLocalDays(start, 7 * quantity);
+	return addLocalMonths(start, quantity);
+}
+function within(window, from, to) {
+	return window.start.slice(0, 10) >= from && (window.end.slice(0, 10) < to || window.end.slice(0, 16) === `${to}T00:00`);
+}
+function measures(unit, quantity, windows) {
+	if (!Number.isSafeInteger(quantity) || quantity < 1 || windows.length < 1) return false;
+	if (unit === "hour") return windows.reduce((sum, w) => sum + (Date.parse(w.endUtc) - Date.parse(w.startUtc)), 0) === quantity * 60 * MINUTE_MS;
+	if (unit !== "day" && unit !== "week" && unit !== "month") return false;
+	const from = windows[0].start.slice(0, 10);
+	const to = localEnd(unit, quantity, from);
+	if (!windows.every((window) => within(window, from, to))) return false;
+	if (unit === "day") {
+		const days = /* @__PURE__ */ new Set();
+		for (const window of windows) {
+			const last = window.end.slice(0, 16) === `${window.end.slice(0, 10)}T00:00` && window.end.slice(0, 10) > window.start.slice(0, 10) ? addLocalDays(window.end.slice(0, 10), -1) : window.end.slice(0, 10);
+			for (let day = window.start.slice(0, 10); day <= last; day = addLocalDays(day, 1)) days.add(day);
+		}
+		return days.size === quantity;
 	}
 	return true;
 }
+function formatWall(instantIso, zone) {
+	const time = Date.parse(instantIso);
+	if (!Number.isFinite(time)) throw new BookingError("invalid", "Invalid instant");
+	const parts = Object.fromEntries(formatter(zone).formatToParts(time).map(({ type, value }) => [type, value]));
+	const local = Date.UTC(Number(parts.year), Number(parts.month) - 1, Number(parts.day), Number(parts.hour), Number(parts.minute), Number(parts.second));
+	const offset = Math.round((local - time) / MINUTE_MS);
+	const sign = offset < 0 ? "-" : "+";
+	const abs = Math.abs(offset);
+	return `${pad(Number(parts.year), 4)}-${parts.month}-${parts.day}T${parts.hour}:${parts.minute}${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+}
+function windowFromInstants(zone, startMs, endMs) {
+	return resolveBookingWindow({
+		zone,
+		start: formatWall(new Date(startMs).toISOString(), zone),
+		end: formatWall(new Date(endMs).toISOString(), zone)
+	});
+}
 //#endregion
 //#region src/service.ts
+var CURRENCY = /^[A-Z]{3}$/;
+var UNITS = [
+	"hour",
+	"day",
+	"week",
+	"month"
+];
+var MAX_QUANTITY = 1e3;
+var MAX_SLOT_RANGE_MS = 400 * 864e5;
+var HOUR_MS = 36e5;
+var SLOT_CURSOR = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z\|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function project(window) {
+	const { zone, start, end, startUtc, endUtc } = window;
+	return {
+		zone,
+		start,
+		end,
+		startUtc,
+		endUtc
+	};
+}
 var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function id(value) {
 	if (typeof value !== "string" || !UUID.test(value)) throw new BookingError("invalid", "Expected a UUID reference");
 	return value.toLowerCase();
 }
+function quantityOf(value, fallback = 1) {
+	const quantity = value === void 0 ? fallback : value;
+	if (!Number.isSafeInteger(quantity) || quantity < 1 || quantity > MAX_QUANTITY) throw new BookingError("invalid", `Quantity must be an integer between 1 and ${MAX_QUANTITY}`);
+	return quantity;
+}
+function money(value) {
+	if (value === null) return null;
+	const amount = Number(value);
+	if (!Number.isSafeInteger(amount)) throw new BookingError("invalid", "Amount is not a safe integer");
+	return amount;
+}
 function pageBounds({ afterId, limit = 50 }) {
 	if (!Number.isInteger(limit) || limit < 1 || limit > 100) throw new BookingError("invalid", "Page limit must be between 1 and 100");
 	return {
@@ -243,6 +406,8 @@ function bookingView(row, proposal) {
 		contactId: row.contact_id,
 		projectId: row.project_id,
 		kind: row.kind,
+		unit: row.unit,
+		quantity: row.quantity,
 		status: row.status,
 		proposal,
 		assentedProposalId: row.assented_proposal_id,
@@ -254,6 +419,12 @@ function proposalView(proposalId, row) {
 		id: proposalId,
 		providerId: row.provider_id,
 		window: JSON.parse(row.coverage),
+		windows: JSON.parse(row.windows),
+		unit: row.proposal_unit,
+		quantity: row.proposal_quantity,
+		unitPriceCents: money(row.unit_price_cents),
+		currency: row.currency,
+		totalCents: money(row.total_cents),
 		terms: JSON.parse(row.terms),
 		approvedPlan: row.approved_plan === null ? null : JSON.parse(row.approved_plan)
 	};
@@ -300,14 +471,35 @@ var BookingService = class {
 		const offeringId = id(input.offeringId);
 		const { kind, enabled } = input;
 		if (kind !== "developer-hour" && kind !== "supervision-day" || typeof enabled !== "boolean") throw new BookingError("invalid", "Invalid offering kind or enabled flag");
+		const unit = input.unit ?? (kind === "supervision-day" ? "day" : "hour");
+		if (!UNITS.includes(unit) || kind === "supervision-day" && unit !== "day") throw new BookingError("invalid", "Invalid offering unit; supervision is sold by the day");
+		const priceCents = input.priceCents ?? null;
+		const currency = input.currency ?? null;
+		if (priceCents !== null && (!Number.isSafeInteger(priceCents) || priceCents < 0) || currency !== null && (typeof currency !== "string" || !CURRENCY.test(currency)) || priceCents === null !== (currency === null)) throw new BookingError("invalid", "A price needs a nonnegative integer amount in minor units and an uppercase ISO 4217 currency");
+		const title = input.title ?? "";
+		const description = input.description ?? "";
+		const isPublic = input.public ?? false;
+		if (typeof title !== "string" || typeof description !== "string" || title.length > 120 || description.length > 2e3 || title.includes("\0") || description.includes("\0") || typeof isPublic !== "boolean") throw new BookingError("invalid", "Offering title (120), description (2000) and public flag are invalid");
 		return this.#write(context, "configure-offering", key, {
 			offeringId,
 			kind,
-			enabled
+			enabled,
+			...unit !== (kind === "supervision-day" ? "day" : "hour") ? { unit } : {},
+			...priceCents !== null ? {
+				priceCents,
+				currency
+			} : {},
+			...title !== "" ? { title } : {},
+			...description !== "" ? { description } : {},
+			...isPublic ? { public: true } : {}
 		}, operator, async (tx, ctx) => {
-			if (!(await tx.query(`INSERT INTO smrt_booking_offerings (tenant_id, id, kind, enabled) VALUES (?, ?, ?, ?)
-         ON CONFLICT (tenant_id, id) DO UPDATE SET enabled = EXCLUDED.enabled
-         WHERE smrt_booking_offerings.kind = EXCLUDED.kind RETURNING id`, ctx.tenantId, offeringId, kind, enabled)).rows.length) throw new BookingError("conflict", "An offering kind cannot change");
+			if (!(await tx.query(`INSERT INTO smrt_booking_offerings (tenant_id, id, kind, unit, price_cents, currency, title, description, public, enabled)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT (tenant_id, id) DO UPDATE
+           SET enabled = EXCLUDED.enabled, price_cents = EXCLUDED.price_cents, currency = EXCLUDED.currency,
+               title = EXCLUDED.title, description = EXCLUDED.description, public = EXCLUDED.public
+         WHERE smrt_booking_offerings.kind = EXCLUDED.kind AND smrt_booking_offerings.unit = EXCLUDED.unit
+         RETURNING id`, ctx.tenantId, offeringId, kind, unit, priceCents, currency, title, description, isPublic, enabled)).rows.length) throw new BookingError("conflict", "An offering kind or unit cannot change");
 			return { id: offeringId };
 		});
 	}
@@ -333,31 +525,36 @@ var BookingService = class {
 		const offeringId = id(input.offeringId);
 		const contactId = id(input.contactId);
 		const projectId = input.projectId === void 0 ? null : id(input.projectId);
+		const quantity = quantityOf(input.quantity);
 		return this.#write(context, "request", key, {
 			offeringId,
 			contactId,
-			projectId
+			projectId,
+			...quantity !== 1 ? { quantity } : {}
 		}, (access) => {
 			if (!access.operator) contact(access, contactId);
 		}, async (tx, ctx) => {
-			const { rows } = await tx.query("SELECT kind, enabled FROM smrt_booking_offerings WHERE tenant_id = ? AND id = ? FOR SHARE", ctx.tenantId, offeringId);
+			const { rows } = await tx.query("SELECT kind, unit, enabled FROM smrt_booking_offerings WHERE tenant_id = ? AND id = ? FOR SHARE", ctx.tenantId, offeringId);
 			if (!rows[0]?.enabled) throw new BookingError("not-found", "Offering is not available");
 			const kind = rows[0].kind;
-			if (kind === "supervision-day" && !projectId) throw new BookingError("invalid", "A supervision request requires a project");
+			const unit = rows[0].unit;
+			if (kind === "supervision-day" && (!projectId || quantity !== 1)) throw new BookingError("invalid", "A supervision request requires a project and a quantity of one");
 			await this.#verify(ctx, {
 				contactId,
 				projectId: projectId ?? void 0
 			});
 			const bookingId = randomUUID();
-			await tx.query(`INSERT INTO smrt_bookings (tenant_id, id, offering_id, contact_id, project_id, kind, status)
-         VALUES (?, ?, ?, ?, ?, ?, 'requested')`, ctx.tenantId, bookingId, offeringId, contactId, projectId, kind);
+			await tx.query(`INSERT INTO smrt_bookings (tenant_id, id, offering_id, contact_id, project_id, kind, unit, quantity, status)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'requested')`, ctx.tenantId, bookingId, offeringId, contactId, projectId, kind, unit, quantity);
 			return { id: bookingId };
 		}, { createsBooking: true });
 	}
 	async propose(context, key, input) {
 		const bookingId = id(input.bookingId);
 		const providerId = id(input.providerId);
-		const window = resolveBookingWindow(input.window);
+		if (input.window === void 0 === (input.windows === void 0)) throw new BookingError("invalid", "Provide exactly one of window or windows");
+		const { windows, span } = resolveCoverage(input.windows ?? [input.window]);
+		const requestedQuantity = input.quantity === void 0 ? null : quantityOf(input.quantity);
 		const terms = {
 			revision: required(input.terms.revision),
 			text: required(input.terms.text, 65536)
@@ -370,22 +567,38 @@ var BookingService = class {
 		return this.#write(context, "propose", key, {
 			bookingId,
 			providerId,
-			window,
+			...windows.length === 1 ? { window: windows[0] } : { windows },
+			...requestedQuantity !== null ? { quantity: requestedQuantity } : {},
 			terms,
 			approvedPlan
 		}, operator, async (tx, ctx) => {
 			const row = await this.#booking(tx, ctx, bookingId, true);
 			pending(row);
-			if (row.kind === "supervision-day" ? !approvedPlan : approvedPlan || !elapsedHour(window)) throw new BookingError("invalid", "Supervision requires a plan version; dedicated time requires one elapsed hour");
+			const quantity = requestedQuantity ?? row.quantity;
+			if (row.kind === "supervision-day") {
+				if (!approvedPlan || quantity !== 1 || windows.length !== 1) throw new BookingError("invalid", "Supervision requires a plan version, one window and a quantity of one");
+			} else {
+				if (approvedPlan) throw new BookingError("invalid", "Dedicated time does not take an approved plan");
+				if (!measures(row.unit, quantity, windows)) throw new BookingError("invalid", "Proposed windows do not measure the requested quantity");
+			}
 			await this.#verify(ctx, {
 				...this.#refs(row),
 				providerId,
 				approvedPlan: approvedPlan ?? void 0
 			});
-			declared(row.kind, window, await this.#resource(tx, ctx, providerId, false));
+			const availability = await this.#resource(tx, ctx, providerId, false);
+			for (const window of windows) declared(row.kind, window, availability);
+			const offering = await tx.query(`SELECT price_cents, currency FROM smrt_booking_offerings
+           WHERE tenant_id = ? AND id = ? FOR SHARE`, ctx.tenantId, row.offering_id);
+			const unitPriceCents = money(offering.rows[0]?.price_cents ?? null);
+			const currency = offering.rows[0]?.currency ?? null;
+			const totalCents = unitPriceCents === null ? null : unitPriceCents * quantity;
+			if (totalCents !== null && !Number.isSafeInteger(totalCents)) throw new BookingError("invalid", "Total price is too large");
 			const proposalId = randomUUID();
-			await tx.query(`INSERT INTO smrt_booking_proposals (tenant_id, booking_id, id, provider_id, coverage, terms, approved_plan)
-         VALUES (?, ?, ?, ?, ?, ?, ?)`, ctx.tenantId, bookingId, proposalId, providerId, JSON.stringify(window), JSON.stringify(terms), approvedPlan && JSON.stringify(approvedPlan));
+			await tx.query(`INSERT INTO smrt_booking_proposals
+             (tenant_id, booking_id, id, provider_id, coverage, windows, unit, quantity,
+              unit_price_cents, currency, total_cents, terms, approved_plan)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, ctx.tenantId, bookingId, proposalId, providerId, JSON.stringify(span), JSON.stringify(windows), row.unit, quantity, unitPriceCents, currency, totalCents, JSON.stringify(terms), approvedPlan && JSON.stringify(approvedPlan));
 			await tx.query(`UPDATE smrt_bookings SET status = 'proposed', proposal_id = ?, assented_proposal_id = NULL
          WHERE tenant_id = ? AND id = ?`, proposalId, ctx.tenantId, bookingId);
 			return {
@@ -437,11 +650,14 @@ var BookingService = class {
 			});
 			const exclusive = row.kind === "developer-hour";
 			const window = proposal.window;
-			declared(row.kind, window, availability);
-			if (!fitsCapacity({
-				...window,
-				exclusive
-			}, availability, await this.#allocations(tx, ctx, proposal.providerId, window))) throw new BookingError("unavailable", "The proposed window has insufficient capacity");
+			const occupied = await this.#allocations(tx, ctx, proposal.providerId, window);
+			for (const segment of proposal.windows) {
+				declared(row.kind, segment, availability);
+				if (!fitsCapacity({
+					...segment,
+					exclusive
+				}, availability, occupied)) throw new BookingError("unavailable", "The proposed window has insufficient capacity");
+			}
 			if (!(await tx.query(`INSERT INTO smrt_booking_allocations
            (tenant_id, booking_id, proposal_id, provider_id, project_id, exclusive, start_at, end_at)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
@@ -455,6 +671,26 @@ var BookingService = class {
 			};
 		}, { bookingId });
 	}
+	/** Operator command: bind a lead-bound booking to a project once one exists. */
+	async attachProject(context, key, input) {
+		const bookingId = id(input.bookingId);
+		const projectId = id(input.projectId);
+		return this.#write(context, "attach-project", key, {
+			bookingId,
+			projectId
+		}, operator, async (tx, ctx) => {
+			const row = await this.#booking(tx, ctx, bookingId, true);
+			if (row.status === "declined" || row.status === "cancelled") throw new BookingError("conflict", "Booking is no longer active");
+			if (row.project_id === projectId) return { id: bookingId };
+			if (row.project_id !== null) throw new BookingError("conflict", "Booking is already bound to a different project");
+			await this.#verify(ctx, {
+				contactId: row.contact_id,
+				projectId
+			});
+			await tx.query("UPDATE smrt_bookings SET project_id = ? WHERE tenant_id = ? AND id = ?", projectId, ctx.tenantId, bookingId);
+			return { id: bookingId };
+		}, { bookingId });
+	}
 	decline(context, key, input) {
 		return this.#close(context, "decline", key, input);
 	}
@@ -474,32 +710,137 @@ var BookingService = class {
 		const access = await this.#discover(ctx);
 		const { after, limit } = pageBounds(options);
 		const projectId = options.projectId === void 0 ? null : id(options.projectId);
-		const rows = (await this.#db.query(`SELECT b.id, b.offering_id, b.contact_id, b.project_id, b.kind, b.status,
+		const contactId = options.contactId === void 0 ? null : id(options.contactId);
+		if (!access.operator && contactId && contactId !== access.contactId) throw new BookingError("forbidden", "Only the named customer contact may be listed");
+		const rows = (await this.#db.query(`SELECT b.id, b.offering_id, b.contact_id, b.project_id, b.kind, b.unit, b.quantity, b.status,
               b.proposal_id, b.assented_proposal_id, b.confirmed_proposal_id,
-              p.provider_id, p.coverage::text, p.terms::text, p.approved_plan::text
+              p.provider_id, p.coverage::text, p.windows::text, p.unit AS proposal_unit,
+              p.quantity AS proposal_quantity, p.unit_price_cents, p.currency, p.total_cents,
+              p.terms::text, p.approved_plan::text
        FROM smrt_bookings b
        LEFT JOIN smrt_booking_proposals p
          ON p.tenant_id = b.tenant_id AND p.booking_id = b.id AND p.id = b.proposal_id
        WHERE b.tenant_id = ? AND (?::boolean OR b.contact_id = ?)
          AND (?::uuid IS NULL OR b.project_id = ?)
+         AND (?::uuid IS NULL OR b.contact_id = ?)
          AND (?::uuid IS NULL OR b.id > ?)
-       ORDER BY b.id LIMIT ?`, ctx.tenantId, access.operator, access.contactId ?? null, projectId, projectId, after, after, limit + 1)).rows;
+       ORDER BY b.id LIMIT ?`, ctx.tenantId, access.operator, access.contactId ?? null, projectId, projectId, contactId, contactId, after, after, limit + 1)).rows;
 		const selected = page(rows, limit, (row) => row.id);
 		return {
 			items: selected.items.map((row) => bookingView(row, row.proposal_id ? proposalView(row.proposal_id, row) : null)),
 			nextCursor: selected.nextCursor
 		};
 	}
-	/** Lists configured offerings. Contacts only see enabled offerings. */
+	/**
+	* Lists configured offerings. Operators see all, contacts see enabled
+	* offerings, and a reader with no contact mapping sees enabled public ones.
+	*/
 	async listOfferings(context, options = {}) {
 		const ctx = identity(context);
-		const access = await this.#discover(ctx);
+		const access = await this.#access(ctx, "read");
 		const { after, limit } = pageBounds(options);
-		const { rows } = await this.#db.query(`SELECT id, kind, enabled FROM smrt_booking_offerings
-       WHERE tenant_id = ? AND (?::boolean OR enabled)
+		const { rows } = await this.#db.query(`SELECT id, kind, unit, price_cents, currency, title, description, public, enabled
+       FROM smrt_booking_offerings
+       WHERE tenant_id = ? AND (?::boolean OR (enabled AND (?::boolean OR public)))
          AND (?::uuid IS NULL OR id > ?)
-       ORDER BY id LIMIT ?`, ctx.tenantId, access.operator, after, after, limit + 1);
-		return page(rows, limit, (row) => row.id);
+       ORDER BY id LIMIT ?`, ctx.tenantId, access.operator, access.operator || access.contactId !== void 0, after, after, limit + 1);
+		return page(rows.map((row) => ({
+			id: row.id,
+			kind: row.kind,
+			unit: row.unit,
+			priceCents: money(row.price_cents),
+			currency: row.currency,
+			title: row.title,
+			description: row.description,
+			public: row.public,
+			enabled: row.enabled
+		})), limit, (row) => row.id);
+	}
+	/**
+	* Lists candidate open slots for an offering: a pure read that reserves nothing
+	* and takes no retry key. Confirmation re-checks capacity under the provider lock.
+	* Offerings are discoverable by operators (all), contact-mapped readers (enabled)
+	* and contact-less readers (enabled and public); the host decides who may read.
+	*/
+	async listOpenSlots(context, options) {
+		const ctx = identity(context);
+		const access = await this.#access(ctx, "read");
+		const offeringId = id(options.offeringId);
+		const fromMs = Date.parse(options.from);
+		const toMs = Date.parse(options.to);
+		if (!Number.isFinite(fromMs) || !Number.isFinite(toMs) || toMs <= fromMs || toMs - fromMs > MAX_SLOT_RANGE_MS) throw new BookingError("invalid", "Expected from before to, at most 400 days apart");
+		const from = new Date(fromMs).toISOString();
+		const to = new Date(toMs).toISOString();
+		const quantity = quantityOf(options.quantity);
+		const providerId = options.providerId === void 0 ? null : id(options.providerId);
+		const { limit } = pageBounds({ limit: options.limit });
+		if (options.after !== void 0 && !SLOT_CURSOR.test(options.after)) throw new BookingError("invalid", "Invalid slot cursor");
+		const after = options.after?.replace(/\|.*$/, (provider) => provider.toLowerCase());
+		const offering = (await this.#db.query("SELECT kind, unit, enabled, public FROM smrt_booking_offerings WHERE tenant_id = ? AND id = ?", ctx.tenantId, offeringId)).rows[0];
+		if (!(offering && (access.operator || offering.enabled && (access.contactId !== void 0 || offering.public)))) throw new BookingError("not-found", "Offering is not available");
+		const kind = offering.kind;
+		const unit = offering.unit;
+		if (kind === "supervision-day" && quantity !== 1) throw new BookingError("invalid", "Supervision slots have a quantity of one");
+		const resources = await this.#db.query(`SELECT id, windows::text FROM smrt_booking_resources
+       WHERE tenant_id = ? AND (?::uuid IS NULL OR id = ?)`, ctx.tenantId, providerId, providerId);
+		const occupied = await this.#allocations(this.#db, ctx, providerId, {
+			startUtc: from,
+			endUtc: to
+		});
+		const slots = [];
+		for (const resource of resources.rows) {
+			const declaredWindows = JSON.parse(resource.windows).sort((a, b) => a.startUtc.localeCompare(b.startUtc));
+			const taken = occupied.filter((item) => item.providerId === resource.id);
+			const inRange = (w) => w.startUtc >= from && w.endUtc <= to;
+			const push = (windows, remaining) => {
+				if (remaining >= 1) slots.push({
+					providerId: resource.id,
+					offeringId,
+					unit,
+					quantity,
+					windows,
+					remainingCapacity: remaining
+				});
+			};
+			if (kind === "supervision-day") {
+				for (const w of declaredWindows) if (w.supervision && inRange(w)) push([project(w)], remainingCapacity({
+					...w,
+					exclusive: false
+				}, declaredWindows, taken));
+			} else if (unit === "hour") {
+				const length = quantity * HOUR_MS;
+				for (const w of declaredWindows) {
+					const start = Date.parse(w.startUtc);
+					const end = Date.parse(w.endUtc);
+					if (w.endUtc <= from || w.startUtc >= to) continue;
+					const first = Math.max(0, Math.ceil((fromMs - start) / HOUR_MS));
+					for (let k = first; start + k * HOUR_MS + length <= end; k++) {
+						const candidate = windowFromInstants(w.zone, start + k * HOUR_MS, start + k * HOUR_MS + length);
+						if (candidate.startUtc >= to) break;
+						if (!inRange(candidate)) continue;
+						push([candidate], remainingCapacity({
+							...candidate,
+							exclusive: true
+						}, declaredWindows, taken));
+					}
+				}
+			} else {
+				const starts = [...new Set(declaredWindows.map((w) => w.start.slice(0, 10)))];
+				for (const d0 of starts) {
+					const d1 = localEnd(unit, quantity, d0);
+					const bundle = declaredWindows.filter((w) => w.start.slice(0, 10) >= d0 && w.start.slice(0, 10) < d1 && (w.end.slice(0, 10) < d1 || w.end.slice(0, 16) === `${d1}T00:00`));
+					const segments = bundle.map(project);
+					if (segments.length === 0 || segments.length > 400 || segments[0].start.slice(0, 10) !== d0 || !segments.every(inRange) || !measures(unit, quantity, segments) || !bundle.every((w) => remainingCapacity({
+						...w,
+						exclusive: true
+					}, declaredWindows, taken) >= 1)) continue;
+					push(segments, 1);
+				}
+			}
+		}
+		const key = (slot) => `${slot.windows[0].startUtc}|${slot.providerId}`;
+		const seen = /* @__PURE__ */ new Set();
+		return page(slots.sort((a, b) => key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0).filter((slot) => !seen.has(key(slot)) && seen.add(key(slot))).filter((slot) => after === void 0 || key(slot) > after).slice(0, limit + 1), limit, key);
 	}
 	/** Lists provider schedules so operators can inspect or replace existing windows. */
 	async listAvailability(context, options = {}) {
@@ -578,6 +919,13 @@ var BookingService = class {
 		return access;
 	}
 	async #verify(ctx, refs) {
+		if (refs.projectId === void 0 && refs.contactId !== void 0 && this.#authority.verifyContact) {
+			if (await this.#authority.verifyContact(ctx, refs.contactId) !== true) throw new BookingError("forbidden", "Booking references or approval could not be verified");
+			const { contactId: _contact, ...others } = refs;
+			const rest = Object.fromEntries(Object.entries(others).filter(([, value]) => value !== void 0));
+			if (Object.keys(rest).length === 0) return;
+			refs = rest;
+		}
 		if (await this.#authority.verifyReferences(ctx, structuredClone(refs)) !== true) throw new BookingError("forbidden", "Booking references or approval could not be verified");
 	}
 	#refs(row) {
@@ -595,7 +943,8 @@ var BookingService = class {
 		if (row.status !== "proposed" || row.proposal_id !== proposalId) throw new BookingError("conflict", "Booking does not have this current proposal");
 	}
 	async #proposal(tx, ctx, booking, proposalId) {
-		const { rows } = await tx.query(`SELECT provider_id, coverage::text, terms::text, approved_plan::text FROM smrt_booking_proposals
+		const { rows } = await tx.query(`SELECT provider_id, coverage::text, windows::text, unit AS proposal_unit, quantity AS proposal_quantity,
+              unit_price_cents, currency, total_cents, terms::text, approved_plan::text FROM smrt_booking_proposals
        WHERE tenant_id = ? AND booking_id = ? AND id = ?`, ctx.tenantId, booking.id, proposalId);
 		const row = rows[0];
 		if (!row) throw new BookingError("not-found", "Proposal does not exist");
@@ -607,17 +956,15 @@ var BookingService = class {
 		return JSON.parse(rows[0].windows);
 	}
 	async #allocations(tx, ctx, providerId, window) {
-		const { rows } = await tx.query(`SELECT a.exclusive, p.coverage::text FROM smrt_booking_allocations a
+		const { rows } = await tx.query(`SELECT a.provider_id, a.exclusive, p.windows::text FROM smrt_booking_allocations a
        JOIN smrt_booking_proposals p ON p.tenant_id = a.tenant_id AND p.booking_id = a.booking_id AND p.id = a.proposal_id
-       WHERE a.tenant_id = ? AND a.provider_id = ? AND a.released_at IS NULL${window ? " AND a.start_at < ? AND a.end_at > ?" : ""}`, ctx.tenantId, providerId, ...window ? [window.endUtc, window.startUtc] : []);
-		return rows.map((row) => {
-			const snapshot = JSON.parse(row.coverage);
-			return {
-				...snapshot,
-				window: snapshot,
-				exclusive: row.exclusive
-			};
-		});
+       WHERE a.tenant_id = ? AND (?::uuid IS NULL OR a.provider_id = ?) AND a.released_at IS NULL${window ? " AND a.start_at < ? AND a.end_at > ?" : ""}`, ctx.tenantId, providerId, providerId, ...window ? [window.endUtc, window.startUtc] : []);
+		return rows.flatMap((row) => JSON.parse(row.windows).filter((segment) => !window || segment.startUtc < window.endUtc && segment.endUtc > window.startUtc).map((segment) => ({
+			...segment,
+			window: segment,
+			providerId: row.provider_id,
+			exclusive: row.exclusive
+		})));
 	}
 	async #write(context, operation, key, canonical, permit, work, options = {}) {
 		const ctx = identity(context);
@@ -644,6 +991,6 @@ var BookingService = class {
 	}
 };
 //#endregion
-export { BookingError, BookingService, migrateBookingsV1, resolveBookingWindow };
+export { BookingError, BookingService, migrateBookingsV1, migrateBookingsV2, resolveBookingWindow };
 
 //# sourceMappingURL=index.js.map