better-supabase 0.13.0 → 0.15.0

package/dist/blocks/shipments/index.js

@@ -0,0 +1,548 @@
+import { n as dbError } from "../../errors-BVFgt8BZ.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as temporal } from "../../temporal-required-Dy0GGD8E.js";
+import { a as ok, r as err, t as AsyncResult } from "../../result-ntFBW2p2.js";
+import { t as shipmentsSqlOptions } from "../../options-IHPg8ZoA.js";
+import { n as SHIPMENT_STATUSES, r as TRACKING_STATUSES, t as LABEL_FORMATS } from "../../statuses-zRcc2TeZ.js";
+import { A as requiredInstant, B as dbTransport, C as optionalText, D as recordOf, H as rpcTransport, I as textOf, S as optionalInstant, U as sqlTransport, d as enumOrThrow, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-CtBdjgO4.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
+import { n as entitySchema } from "../../entity-schema-BDv6w-OQ.js";
+import { i as recordRowInput, t as defineRecordBinding } from "../../record-bindings-DkBJpC5A.js";
+import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
+import { s as verifyWebhook } from "../../signatures-CNcoq392.js";
+import { n as blockFields } from "../../block-fields-DE_FgpOU.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { n as optionalRecordRefOf } from "../../block-subjects-BhDKK_j7.js";
+import { t as requireOrganization } from "../../block-tenant-DHp7subc.js";
+import { a as compareMoney, c as isMoney, d as money } from "../../money-BZl985O-.js";
+import { o as optionalMoneyOf, t as amountText } from "../../money-codec-BzddguAQ.js";
+//#region src/blocks/shipments/carrier.ts
+/** Checks the carrier's `apiVersion` before a block uses it. */
+function shipmentCarrierOf(carrier) {
+	const version = carrier.apiVersion;
+	if (version !== 1) throw new TypeError(`carrier "${carrier.name}" targets shipment carrier API ${String(version)}; this better-supabase supports 1. Upgrade better-supabase or use a release of the carrier for API 1.`);
+	return carrier;
+}
+const invalid = (message, hint) => dbError("invalid_input", message, { hint });
+const isPositiveInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+/**
+* The first problem with a rate or label request: an address without a line,
+* city or two-letter country, no parcels, or a parcel whose weight or size
+* isn't a positive whole number.
+*/
+function invalidShipmentRequest(request) {
+	for (const [side, address] of [["from", request.from], ["to", request.to]]) {
+		if (!/^[A-Z]{2}$/.test(address.country)) return invalid(`The ${side} address needs a two-letter country code`, "SHIPMENT_ADDRESS_INVALID");
+		if (address.line1.trim() === "" || address.city.trim() === "") return invalid(`The ${side} address needs a street line and a city`, "SHIPMENT_ADDRESS_INVALID");
+	}
+	if (request.parcels.length === 0) return invalid("A shipment needs at least one package", "SHIPMENT_EMPTY");
+	for (const parcel of request.parcels) {
+		const sizes = [
+			parcel.lengthMm,
+			parcel.widthMm,
+			parcel.heightMm
+		].filter((size) => size !== void 0);
+		if (!isPositiveInteger(parcel.weightGrams) || !sizes.every(isPositiveInteger)) return invalid("Package weights and sizes are positive whole numbers of grams and millimeters", "SHIPMENT_PACKAGE_INVALID");
+	}
+}
+const randomCode = () => crypto.randomUUID().replaceAll("-", "").slice(0, 16).toUpperCase();
+function parcelsTotal(service, parcels) {
+	const additional = service.additional ?? service.amount;
+	return money(service.amount.amount + additional.amount * BigInt(parcels.length - 1), service.amount.currency);
+}
+function instantOf(value) {
+	if (typeof value !== "string") return;
+	try {
+		return temporal().Instant.from(value);
+	} catch {
+		return;
+	}
+}
+const optionalString = (key, value) => typeof value === "string" && value !== "" ? { [key]: value } : {};
+/**
+* Reads a tracking webhook body in the flat-rate format: `{ "trackingNumber":
+* "…", "events": [{ "id", "status", "occurredAt", "description"?, "location"?
+* }] }`, or an array of those.
+*/
+function trackingUpdatesOf(payload) {
+	const items = Array.isArray(payload) ? payload : [payload];
+	const updates = [];
+	const statuses = TRACKING_STATUSES;
+	for (const item of items) {
+		if (typeof item !== "object" || item === null || !("trackingNumber" in item) || typeof item.trackingNumber !== "string" || item.trackingNumber === "" || !("events" in item) || !Array.isArray(item.events)) return err(invalid("A tracking update needs a trackingNumber and an events array", "SHIPMENT_TRACKING_INVALID"));
+		const events = [];
+		for (const event of item.events) {
+			if (typeof event !== "object" || event === null || !("id" in event) || typeof event.id !== "string" || event.id === "" || !("status" in event) || typeof event.status !== "string" || !statuses.includes(event.status)) return err(invalid("Each tracking event needs an id and a known status", "SHIPMENT_TRACKING_INVALID"));
+			const occurredAt = instantOf("occurredAt" in event ? event.occurredAt : void 0);
+			if (occurredAt === void 0) return err(invalid("Each tracking event needs an ISO 8601 occurredAt", "SHIPMENT_TRACKING_INVALID"));
+			events.push({
+				id: event.id,
+				status: event.status,
+				occurredAt,
+				...optionalString("description", "description" in event ? event.description : void 0),
+				...optionalString("location", "location" in event ? event.location : void 0)
+			});
+		}
+		updates.push({
+			trackingNumber: item.trackingNumber,
+			events
+		});
+	}
+	return ok(updates);
+}
+/**
+* A `ShippingProvider` with fixed prices per service and package. It stores
+* nothing beyond the labels of recent idempotency keys: labels carry a
+* generated tracking number and no file, `track` returns no events, and
+* `cancel` always succeeds. With `webhookSecret` it reads Standard Webhooks
+* tracking updates in the format of `trackingUpdatesOf`, so drivers, a
+* forwarding service or tests can post tracking events.
+*/
+function flatRateCarrier(options) {
+	const name = options.name ?? "flat-rate";
+	const prefix = options.trackingPrefix ?? "FR";
+	for (const [code, service] of Object.entries(options.services)) if (!isMoney(service.amount) || service.additional !== void 0 && (!isMoney(service.additional) || service.additional.currency !== service.amount.currency)) throw new TypeError(`flatRateCarrier: the "${code}" service needs an amount, and an additional amount in the same currency`);
+	const labels = /* @__PURE__ */ new Map();
+	const ratesOf = (request) => {
+		const problem = invalidShipmentRequest(request);
+		if (problem) return err(problem);
+		return ok(Object.entries(options.services).filter(([, service]) => request.currency === void 0 || service.amount.currency === request.currency).map(([service, rate]) => ({
+			carrier: name,
+			service,
+			amount: parcelsTotal(rate, request.parcels),
+			...rate.estimatedDays === void 0 ? {} : { estimatedDays: rate.estimatedDays }
+		})));
+	};
+	const labelOf = (request, key) => {
+		const problem = invalidShipmentRequest(request);
+		if (problem) return err(problem);
+		const service = options.services[request.service];
+		if (service === void 0) return err(invalid(`The carrier has no "${request.service}" service`, "SHIPMENT_SERVICE_UNKNOWN"));
+		const earlier = key === void 0 ? void 0 : labels.get(key);
+		if (earlier) return ok(earlier);
+		const code = randomCode();
+		const label = {
+			labelId: `label_${code}`,
+			trackingNumber: `${prefix}${code}`,
+			service: request.service,
+			cost: parcelsTotal(service, request.parcels),
+			format: "pdf"
+		};
+		if (key !== void 0 && labels.size < 1e3) labels.set(key, label);
+		return ok(label);
+	};
+	const secrets = options.webhookSecret;
+	return {
+		apiVersion: 1,
+		name,
+		rates: (request) => new AsyncResult(Promise.resolve(ratesOf(request))),
+		createLabel: (request, call) => new AsyncResult(Promise.resolve(labelOf(request, call?.idempotencyKey))),
+		track: (trackingNumber) => trackingNumber.startsWith(prefix) ? AsyncResult.ok([]) : AsyncResult.err(dbError("not_found", "Unknown tracking number", { hint: "SHIPMENT_TRACKING_UNKNOWN" })),
+		cancel: () => AsyncResult.ok({ cancelled: true }),
+		...secrets === void 0 ? {} : { parseWebhook: (input) => AsyncResult.from(async () => {
+			const verified = await verifyWebhook(input, secrets, options.verify);
+			return verified.ok ? trackingUpdatesOf(verified.data.payload) : verified;
+		}) }
+	};
+}
+//#endregion
+//#region src/blocks/shipments/shipments.ts
+/** Copies the defined values only, so absent fields stay absent. */
+function defined(values) {
+	return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== void 0));
+}
+const optionalNumber = (value) => value === null || value === void 0 ? void 0 : Number(value);
+function addressOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		line1: textOf(row["line1"]),
+		city: textOf(row["city"]),
+		country: textOf(row["country"]),
+		...defined({
+			name: optionalText(row["name"]),
+			company: optionalText(row["company"]),
+			line2: optionalText(row["line2"]),
+			postalCode: optionalText(row["postalCode"]),
+			state: optionalText(row["state"]),
+			phone: optionalText(row["phone"]),
+			email: optionalText(row["email"])
+		})
+	};
+}
+function packageOf(row) {
+	return {
+		id: textOf(row["id"]),
+		position: Number(row["position"]),
+		weightGrams: Number(row["weightGrams"]),
+		...defined({
+			lengthMm: optionalNumber(row["lengthMm"]),
+			widthMm: optionalNumber(row["widthMm"]),
+			heightMm: optionalNumber(row["heightMm"]),
+			reference: optionalText(row["reference"])
+		})
+	};
+}
+function shipmentOf(value, fn) {
+	const row = recordOf(value, fn);
+	const format = optionalText(row["labelFormat"]);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		reference: textOf(row["reference"]),
+		status: enumOrThrow(row["status"], SHIPMENT_STATUSES, "status"),
+		from: addressOf(row["from"], fn),
+		to: addressOf(row["to"], fn),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		packages: recordsOf(row["packages"], fn).map(packageOf),
+		fields: isRecord(row["fields"]) ? row["fields"] : {},
+		...defined({
+			fromLocationId: optionalText(row["fromLocationId"]),
+			subject: optionalRecordRefOf(row["subjectType"], row["subjectId"]),
+			carrier: optionalText(row["carrier"]),
+			service: optionalText(row["service"]),
+			trackingNumber: optionalText(row["trackingNumber"]),
+			trackingUrl: optionalText(row["trackingUrl"]),
+			labelId: optionalText(row["labelId"]),
+			labelUrl: optionalText(row["labelUrl"]),
+			labelFormat: format === void 0 ? void 0 : enumOrThrow(format, LABEL_FORMATS, "labelFormat"),
+			labelCost: optionalMoneyOf(row["labelCost"], row["currency"], "labelCost"),
+			labeledAt: optionalInstant(row["labeledAt"]),
+			deliveredAt: optionalInstant(row["deliveredAt"]),
+			cancelledAt: optionalInstant(row["cancelledAt"]),
+			createdBy: optionalText(row["createdBy"])
+		})
+	};
+}
+const SOURCES = [
+	"carrier",
+	"webhook",
+	"manual"
+];
+function trackingEventOf(row) {
+	return {
+		id: textOf(row["id"]),
+		externalId: textOf(row["externalId"]),
+		status: enumOrThrow(row["status"], TRACKING_STATUSES, "status"),
+		occurredAt: requiredInstant(row["occurredAt"], "occurredAt"),
+		source: enumOrThrow(row["source"], SOURCES, "source"),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		...defined({
+			description: optionalText(row["description"]),
+			location: optionalText(row["location"])
+		})
+	};
+}
+const eventsArg = (events) => events.map((event) => ({
+	id: event.id,
+	status: event.status,
+	occurredAt: event.occurredAt.toString(),
+	description: event.description ?? null,
+	location: event.location ?? null
+}));
+const parcelsOf = (shipment) => shipment.packages.map((item) => ({
+	weightGrams: item.weightGrams,
+	...defined({
+		lengthMm: item.lengthMm,
+		widthMm: item.widthMm,
+		heightMm: item.heightMm,
+		reference: item.reference
+	})
+}));
+const notFound = () => AsyncResult.err(dbError("not_found", "Shipment not found", { hint: "SHIPMENT_NOT_FOUND" }));
+/** The `shipments` SQL module and the configured carriers as typed calls. */
+function createShipments(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const service = blockCall(options.service ?? options.transport, options.schema, options.mappers);
+	const tenant = () => requireOrganization(options.tenant);
+	const logger = options.logger ?? console;
+	const fields = blockFields(options.fields, "shipment fields");
+	const carriers = new Map((options.carriers ?? []).map((carrier) => [carrier.name, shipmentCarrierOf(carrier)]));
+	const carrierNamed = (name) => {
+		const found = name === void 0 ? void 0 : carriers.get(name);
+		return found ? AsyncResult.ok(found) : AsyncResult.err(dbError("invalid_input", `No carrier named "${String(name)}" is configured`, { hint: "SHIPMENT_CARRIER_UNKNOWN" }));
+	};
+	const one = (fn) => (value) => shipmentOf(value, fn);
+	const find = (id) => call("get_shipment", { shipment_id: id }, (value) => value === null || value === void 0 ? null : shipmentOf(value, "get_shipment")).andThen((found) => found === null ? notFound() : AsyncResult.ok(found));
+	const recorded = (fn) => (value) => {
+		const row = recordOf(value, fn);
+		return {
+			recorded: Number(row["recorded"]),
+			shipment: shipmentOf(row["shipment"], fn)
+		};
+	};
+	const withFields = (result) => result.andThen((found) => fields.row(found.shipment).map((shipment) => ({
+		recorded: found.recorded,
+		shipment
+	})));
+	const record = (id, events, source) => withFields(call("record_tracking_events", {
+		shipment_id: id,
+		events: eventsArg(events),
+		source
+	}, recorded("record_tracking_events")));
+	return withBlockHooks({
+		create: (input) => tenant().andThen((organizationId) => fields.args(input.fields).andThen((checked) => call("create_shipment", {
+			tenant: organizationId,
+			from_address: input.from,
+			to_address: input.to,
+			packages: input.packages.map((item) => ({ ...item })),
+			reference: input.reference ?? null,
+			from_location_id: input.fromLocationId ?? null,
+			subject_type: input.subject?.type ?? null,
+			subject_id: input.subject?.id ?? null,
+			fields: checked
+		}, one("create_shipment")).andThen(fields.row))),
+		get: (id) => call("get_shipment", { shipment_id: id }, (value) => value === null || value === void 0 ? null : shipmentOf(value, "get_shipment")).andThen((found) => found === null ? AsyncResult.ok(null) : fields.row(found)),
+		list: (list = {}) => tenant().andThen((organizationId) => call("list_shipments", {
+			tenant: organizationId,
+			status: list.status ?? null,
+			subject_type: list.subject?.type ?? null,
+			subject_id: list.subject?.id ?? null,
+			carrier: list.carrier ?? null,
+			before: instantArg(list.before) ?? null,
+			page_size: list.limit ?? 50
+		}, (value) => recordsOf(value, "list_shipments").map((row) => shipmentOf(row, "list_shipments"))).andThen(fields.rows)),
+		rates: (id, quote = {}) => find(id).andThen((shipment) => AsyncResult.from(async () => {
+			const found = [];
+			for (const carrier of carriers.values()) {
+				const rates = await carrier.rates({
+					from: shipment.from,
+					to: shipment.to,
+					parcels: parcelsOf(shipment),
+					...quote.currency === void 0 ? {} : { currency: quote.currency }
+				});
+				if (!rates.ok) return rates;
+				found.push(...rates.data);
+			}
+			return ok(found.toSorted((a, b) => a.amount.currency === b.amount.currency ? compareMoney(a.amount, b.amount) : a.amount.currency.localeCompare(b.amount.currency)));
+		})),
+		buyLabel: (id, choice) => carrierNamed(choice.carrier).andThen((carrier) => find(id).andThen((shipment) => {
+			if (shipment.status !== "draft") return AsyncResult.err(dbError("conflict", "The shipment already has a label", { hint: "SHIPMENT_NOT_DRAFT" }));
+			return carrier.createLabel({
+				from: shipment.from,
+				to: shipment.to,
+				parcels: parcelsOf(shipment),
+				service: choice.service,
+				reference: shipment.reference
+			}, { idempotencyKey: `label:${shipment.id}` }).andThen((label) => AsyncResult.from(async () => {
+				const stored = await call("set_shipment_label", {
+					shipment_id: shipment.id,
+					carrier: carrier.name,
+					service: label.service,
+					tracking_number: label.trackingNumber,
+					label_id: label.labelId,
+					label_cost: amountText(label.cost),
+					currency: label.cost.currency,
+					label_format: label.format,
+					label_url: label.labelUrl ?? null,
+					tracking_url: label.trackingUrl ?? null
+				}, one("set_shipment_label")).andThen(fields.row);
+				if (!stored.ok) {
+					const voided = await carrier.cancel({
+						labelId: label.labelId,
+						trackingNumber: label.trackingNumber
+					});
+					if (!voided.ok) logger.error(`shipments: label ${label.labelId} from ${carrier.name} was bought but not stored or voided`, { error: voided.error });
+				}
+				return stored;
+			}));
+		})),
+		refresh: (id) => find(id).andThen((shipment) => {
+			const trackingNumber = shipment.trackingNumber;
+			if (trackingNumber === void 0) return AsyncResult.err(dbError("conflict", "The shipment has no label yet", { hint: "SHIPMENT_NOT_LABELED" }));
+			return carrierNamed(shipment.carrier).andThen((carrier) => carrier.track(trackingNumber).andThen((events) => record(id, events, "carrier")));
+		}),
+		recordTracking: (id, events) => record(id, events, "manual"),
+		ingest: (name, request) => carrierNamed(name).andThen((carrier) => {
+			if (!carrier.parseWebhook) return AsyncResult.err(dbError("invalid_input", `Carrier "${name}" doesn't send tracking webhooks`, { hint: "SHIPMENT_WEBHOOK_UNSUPPORTED" }));
+			return carrier.parseWebhook(request).andThen((updates) => AsyncResult.from(async () => {
+				const done = [];
+				for (const update of updates) {
+					const stored = await service("ingest_tracking_events", {
+						carrier: carrier.name,
+						tracking_number: update.trackingNumber,
+						events: eventsArg(update.events)
+					}, (value) => {
+						if (value === null || value === void 0) return {
+							trackingNumber: update.trackingNumber,
+							recorded: 0
+						};
+						const row = recordOf(value, "ingest_tracking_events");
+						return {
+							trackingNumber: update.trackingNumber,
+							shipmentId: textOf(row["id"]),
+							status: enumOrThrow(row["status"], SHIPMENT_STATUSES, "status"),
+							recorded: Number(row["recorded"])
+						};
+					});
+					if (!stored.ok) return stored;
+					done.push(stored.data);
+				}
+				return ok(done);
+			}));
+		}),
+		cancel: (id) => find(id).andThen((shipment) => {
+			if (shipment.status !== "draft" && shipment.status !== "label_created") return AsyncResult.err(dbError("conflict", "The shipment has already shipped", { hint: "SHIPMENT_SHIPPED" }));
+			const cancelled = () => call("cancel_shipment", { shipment_id: id }, one("cancel_shipment")).andThen(fields.row);
+			const { labelId, trackingNumber } = shipment;
+			if (labelId === void 0 || trackingNumber === void 0) return cancelled();
+			return carrierNamed(shipment.carrier).andThen((carrier) => carrier.cancel({
+				labelId,
+				trackingNumber
+			}, { idempotencyKey: `void:${id}` }).andThen(cancelled));
+		}),
+		trackingEvents: (id) => call("list_tracking_events", { shipment_id: id }, (value) => recordsOf(value, "list_tracking_events").map(trackingEventOf))
+	}, options.hooks, {
+		block: "shipments",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/shipments/events.ts
+/** The `shipments` block's event types, for its manifest and `onBlockEvent`. */
+const shipmentsEvents = defineEvents({
+	"shipment.created": event(),
+	"shipment.labeled": event(),
+	"shipment.status_changed": event(),
+	"shipment.cancelled": event()
+});
+//#endregion
+//#region src/blocks/shipments/schemas.ts
+const address = {
+	kind: "json",
+	description: "`{ line1, city, country, name?, company?, line2?, postalCode?, state?, phone?, email? }`, with a two-letter country."
+};
+/** What `create` takes, with the bounds the SQL checks. */
+const shipmentInputSchema = entitySchema({
+	title: "ShipmentInput",
+	fields: {
+		from: address,
+		to: address,
+		packages: {
+			kind: "json",
+			array: true,
+			description: "1 to 50 `{ weightGrams, lengthMm?, widthMm?, heightMm?, reference? }`, in whole grams and millimeters."
+		},
+		reference: {
+			kind: "string",
+			optional: true,
+			minLength: 1,
+			maxLength: 100
+		},
+		fromLocationId: {
+			kind: "uuid",
+			optional: true
+		},
+		subject: {
+			kind: "json",
+			optional: true,
+			description: "The record it ships for: `{ type, id }`."
+		},
+		fields: {
+			kind: "json",
+			optional: true,
+			description: "The extra columns, keyed by database name."
+		}
+	}
+});
+const shipmentSectionInputSchema = entitySchema({
+	title: "ShipmentSectionInput",
+	fields: {
+		from: address,
+		to: address,
+		packages: {
+			kind: "json",
+			array: true,
+			description: "1 to 50 `{ weightGrams, lengthMm?, widthMm?, heightMm?, reference? }`."
+		},
+		reference: {
+			kind: "string",
+			optional: true,
+			minLength: 1,
+			maxLength: 100
+		},
+		fromLocationId: {
+			kind: "uuid",
+			optional: true
+		}
+	}
+});
+/** One event `recordTracking` takes. */
+const trackingEventInputSchema = entitySchema({
+	title: "TrackingEventInput",
+	fields: {
+		id: {
+			kind: "string",
+			minLength: 1,
+			maxLength: 200
+		},
+		status: {
+			kind: "enum",
+			values: TRACKING_STATUSES
+		},
+		occurredAt: { kind: "instant" },
+		description: {
+			kind: "string",
+			optional: true,
+			maxLength: 1e3
+		},
+		location: {
+			kind: "string",
+			optional: true,
+			maxLength: 200
+		}
+	}
+});
+//#endregion
+//#region src/blocks/shipments/record-binding.ts
+/** The shipments sent for a record, with their status and tracking. */
+const shipmentsBinding = defineRecordBinding({
+	permissions: {
+		read: "read",
+		write: "manage"
+	},
+	module: "shipments",
+	load: (client, subject) => client.list({ subject }),
+	events: ["shipment.*"],
+	writes: {
+		create: {
+			input: shipmentSectionInputSchema,
+			run: (client, subject, input) => client.create({
+				...input,
+				subject
+			})
+		},
+		cancel: {
+			input: recordRowInput,
+			run: (client, _subject, { id }) => client.cancel(id)
+		}
+	}
+});
+//#endregion
+//#region src/blocks/shipments/manifest.ts
+/** The `shipments` block's manifest (ADR 0029). */
+const shipmentsBlock = defineBlock({
+	name: "shipments",
+	sql: ["shipments"],
+	options: { shipments: shipmentsSqlOptions },
+	events: shipmentsEvents,
+	schemas: {
+		shipment: { input: shipmentInputSchema },
+		shipment_tracking_event: { input: trackingEventInputSchema }
+	},
+	create: createShipments,
+	record: shipmentsBinding,
+	category: "commerce",
+	recipes: ["shipment-tracking"],
+	providers: [{
+		option: "carriers",
+		type: "ShippingProvider",
+		from: "better-supabase/blocks/shipments",
+		required: false,
+		description: "Quotes, labels and tracks shipments; without one, shipments are recorded by hand.",
+		example: "[yourCarrier]"
+	}]
+});
+//#endregion
+export { LABEL_FORMATS, SHIPMENT_STATUSES, TRACKING_STATUSES, createShipments, dbTransport, extendBlock, flatRateCarrier, invalidShipmentRequest, rpcTransport, shipmentCarrierOf, shipmentInputSchema, shipmentSectionInputSchema, shipmentsBinding, shipmentsBlock, shipmentsEvents, shipmentsSqlOptions, sqlTransport, trackingEventInputSchema, trackingUpdatesOf, withBlockHooks, wrapTransport };