pi-roundtable-line 0.9.13 → 0.11.0

package/src/icon.ts

@@ -0,0 +1,46 @@
+import type { HttpRoute } from "pi-roundtable";
+
+/** Serves one fixed PNG, so the host can give LINE a stable `iconUrl` for a sender without another service. */
+export interface SenderIconRoute {
+	/** Where it is served, such as `/line/sender-icon.png`. */
+	path: string;
+	/** The PNG's bytes. */
+	png: Uint8Array;
+}
+
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+/** What LINE accepts of a sender icon. */
+const ICON_MAX_BYTES = 1024 * 1024;
+
+/** Refuses an icon that is not a PNG LINE could show. */
+export function checkIcon(png: Uint8Array): void {
+	if (!(png instanceof Uint8Array) || png.length === 0)
+		throw new Error("line: senderIconRoute.png must hold the bytes of a PNG");
+	if (!PNG_SIGNATURE.every((byte, index) => png[index] === byte))
+		throw new Error("line: senderIconRoute.png is not a PNG file");
+	if (png.length > ICON_MAX_BYTES)
+		throw new Error(
+			`line: senderIconRoute.png must be at most ${ICON_MAX_BYTES} bytes`,
+		);
+}
+
+/** The route that serves the icon, to `GET` and `HEAD`, with a cache header for a year. */
+export function iconRoute(
+	options: SenderIconRoute,
+	listener: string,
+): HttpRoute {
+	const bytes = new Uint8Array(options.png);
+	const headers = {
+		"content-type": "image/png",
+		"content-length": String(bytes.length),
+		"cache-control": "public, max-age=31536000, immutable",
+	};
+	return {
+		name: "line-sender-icon",
+		listener,
+		path: { exact: options.path },
+		methods: ["GET", "HEAD"],
+		handle: (request) =>
+			new Response(request.method === "HEAD" ? null : bytes, { headers }),
+	};
+}

package/src/index.ts

@@ -1,21 +1,55 @@
+export type {
+	LineContentRequest,
+	LineContentResult,
+	MediaOptions,
+} from "./content.ts";
 export { errorCode, LineApiError, LineError } from "./errors.ts";
 export type { ParsedEvent, SourceKind } from "./events.ts";
 export { parseSourceKey, sourceKeyOf } from "./events.ts";
+export type { SenderIconRoute } from "./icon.ts";
 export type {
 	InboxEvent,
 	InboxOptions,
 	InboxProcessor,
 	InboxResult,
 } from "./inbox.ts";
+export type { JoinNoticeOptions } from "./join.ts";
+export { digestOf } from "./join.ts";
+export type {
+	JoinNotice,
+	LineContext,
+	LineEditedEvent,
+	LineEvent,
+	LineJoinedEvent,
+	LineLeftEvent,
+	LineMemberJoinedEvent,
+	LineMemberLeftEvent,
+	LineMessageBody,
+	LineMessageEvent,
+	LineMirror,
+	LineOutboxResultEvent,
+	LineSubscriber,
+	LineUnsentEvent,
+} from "./messages.ts";
 export type { LineOptions } from "./options.ts";
+export type {
+	EnqueueOptions,
+	LineOutbox,
+	LineOutMessage,
+	OutboxOptions,
+} from "./outbox.ts";
 export { line } from "./plugin.ts";
 export type { LineBridgePort } from "./port.ts";
 export { LINE } from "./port.ts";
+export type { QuotaOptions } from "./quota.ts";
+export type { RetentionOptions } from "./retention.ts";
+export type { LineSender, SenderOptions } from "./sender.ts";
 export type {
 	LineSource,
 	LineSourceSummary,
 	LineSources,
 	SourceStatus,
 } from "./sources.ts";
+export { LineSurface } from "./surface.ts";
 export type { LineCredentials, TokenMode } from "./token.ts";
 export { WEBHOOK_MAX_BYTES } from "./webhook.ts";

package/src/intake.ts

@@ -24,11 +24,11 @@ const MEMBERSHIP = new Set(["join", "leave"]);
  * the whole request's transaction and with it every other event stored beside this one. They are
  * replaced with U+FFFD, which loses nothing a chat mirror could use.
  */
-function clean(text: string): string {
+export function clean(text: string): string {
 	return text.replaceAll("\u0000", "\uFFFD").toWellFormed();
 }
 
-function scrub(value: unknown): unknown {
+export function scrub(value: unknown): unknown {
 	if (typeof value === "string") return clean(value);
 	if (Array.isArray(value)) return value.map(scrub);
 	if (typeof value === "object" && value !== null)

package/src/join.ts

@@ -0,0 +1,136 @@
+import { createHash } from "node:crypto";
+import type { SQL } from "bun";
+import type { Logger } from "pi-roundtable";
+import type { LineApi } from "./api.ts";
+import { errorCode } from "./errors.ts";
+import { type JoinNotice, nonEmpty } from "./messages.ts";
+
+/** The most characters one LINE text message holds. */
+export const NOTICE_MAX_CHARS = 5000;
+
+/** The text sent when the bot joins a chat, and the SHA-256 (hex) of its UTF-8 bytes that gates it. */
+export interface JoinNoticeOptions {
+	text: string;
+	sha256: string;
+}
+
+const DIGEST = /^[0-9a-f]{64}$/;
+
+/** The SHA-256 of a text's UTF-8 bytes, as lower-case hex. */
+export const digestOf = (text: string): string =>
+	createHash("sha256").update(text, "utf8").digest("hex");
+
+/** Refuses a join notice that cannot work: a digest that is not 64 hex digits, or a text LINE would refuse. */
+export function checkJoinNotice(notice: JoinNoticeOptions): void {
+	if (typeof notice !== "object" || notice === null)
+		throw new Error("line: joinNotice is { text, sha256 }");
+	if (typeof notice.sha256 !== "string" || !DIGEST.test(notice.sha256))
+		throw new Error(
+			"line: joinNotice.sha256 must be 64 lower-case hex digits (the SHA-256 of the text's UTF-8 bytes)",
+		);
+	if (
+		typeof notice.text !== "string" ||
+		notice.text === "" ||
+		notice.text.length > NOTICE_MAX_CHARS
+	)
+		throw new Error(
+			`line: joinNotice.text must be a text of 1 to ${NOTICE_MAX_CHARS} characters`,
+		);
+}
+
+export interface JoinNotifierDeps {
+	sql: SQL;
+	api: LineApi;
+	logger: Logger;
+	now: () => Date;
+	notice?: JoinNoticeOptions;
+}
+
+/**
+ * Answers a `join` event with the configured notice, once, as a Reply with the event's reply token.
+ * It sends only text whose SHA-256 is the configured digest, to any chat the bot joins, allowed or
+ * not, and never as a push: when LINE refuses the Reply or the token has lapsed the notice is `failed`,
+ * and nothing else is sent. A Reply that got no answer is `unconfirmed`, and its record stays
+ * `attempting`.
+ *
+ * The outcome is recorded before the Reply is made, so a join that is handed out again never
+ * replies twice: it learns `sent` or `failed`, or `unconfirmed` when the first try was cut short
+ * and nobody knows whether LINE got the reply.
+ */
+export class JoinNotifier {
+	readonly #sql: SQL;
+	readonly #api: LineApi;
+	readonly #logger: Logger;
+	readonly #now: () => Date;
+	readonly #notice: JoinNoticeOptions | undefined;
+	readonly #matches: boolean;
+
+	constructor(deps: JoinNotifierDeps) {
+		this.#sql = deps.sql;
+		this.#api = deps.api;
+		this.#logger = deps.logger;
+		this.#now = deps.now;
+		this.#notice = deps.notice;
+		this.#matches = deps.notice
+			? digestOf(deps.notice.text) === deps.notice.sha256
+			: false;
+	}
+
+	/** Whether a notice is configured and its text is the one the digest names. */
+	get armed(): boolean {
+		return this.#notice !== undefined && this.#matches;
+	}
+
+	async send(event: {
+		id: string;
+		payload: Record<string, unknown>;
+	}): Promise<JoinNotice> {
+		const notice = this.#notice;
+		// Nothing configured: nothing is sent, and nobody should take that for a notice.
+		if (!notice) return "unconfirmed";
+		if (!this.#matches) {
+			this.#logger.warn(
+				{ code: "join_notice_digest_mismatch" },
+				"the LINE join notice text is not the one its digest names, so it was not sent",
+			);
+			return "failed";
+		}
+		const claimed = await this
+			.#sql`INSERT INTO line_notices (webhook_event_id, outcome, created_at)
+			VALUES (${event.id}, 'attempting', ${this.#now()})
+			ON CONFLICT (webhook_event_id) DO NOTHING RETURNING 1`;
+		if (claimed.length === 0) {
+			const [row] = (await this
+				.#sql`SELECT outcome FROM line_notices WHERE webhook_event_id = ${event.id}`) as {
+				outcome: string;
+			}[];
+			return row?.outcome === "sent"
+				? "sent"
+				: row?.outcome === "failed"
+					? "failed"
+					: "unconfirmed";
+		}
+		const token = nonEmpty(event.payload.replyToken);
+		let outcome: "sent" | "failed" | "attempting" = "failed";
+		if (!token) {
+			this.#logger.warn(
+				{ code: "no_reply_token" },
+				"a LINE join came without a reply token, so the notice was not sent",
+			);
+		} else {
+			try {
+				await this.#api.reply(token, [{ type: "text", text: notice.text }]);
+				outcome = "sent";
+			} catch (error) {
+				const code = errorCode(error);
+				// No answer is not a refusal: LINE may have taken the Reply, so nobody can say it failed.
+				if (code === "api_unreachable") outcome = "attempting";
+				this.#logger.warn({ code }, "the LINE join notice could not be sent");
+			}
+		}
+		if (outcome === "attempting") return "unconfirmed";
+		await this
+			.#sql`UPDATE line_notices SET outcome = ${outcome} WHERE webhook_event_id = ${event.id}`;
+		return outcome;
+	}
+}

package/src/messages.ts

@@ -0,0 +1,267 @@
+import { LineError } from "./errors.ts";
+
+/** What a message is, reduced to what a mirror needs. Media bytes are fetched apart, with `LINE.content`. */
+export type LineMessageBody =
+	| { kind: "text"; text: string }
+	| { kind: "image" }
+	| { kind: "video"; durationMs?: number }
+	| { kind: "audio"; durationMs?: number }
+	| { kind: "file"; fileName: string; fileSize?: number }
+	| {
+			kind: "sticker";
+			packageId: string;
+			stickerId: string;
+			keywords?: string[];
+			text?: string;
+	  }
+	| {
+			kind: "location";
+			title?: string;
+			address?: string;
+			latitude: number;
+			longitude: number;
+	  }
+	/** A message type this version does not know; shown as a placeholder rather than dropped. */
+	| { kind: "unsupported"; messageType: string };
+
+interface EventBase {
+	/** LINE's `webhookEventId`: the same on every redelivery, so a subscriber may use it to deduplicate. */
+	eventId: string;
+	/** The chat: `line:<group|room|user>:<id>`. */
+	sourceKey: string;
+	/** LINE's event time, milliseconds since the epoch. */
+	timestamp: number;
+}
+
+/** A new message. The subscriber mirrors it and answers `{ refs }`, the opaque references to what it made. */
+export interface LineMessageEvent extends EventBase {
+	type: "message";
+	messageId: string;
+	/** The sender's user id, when LINE names one. */
+	userId?: string;
+	body: LineMessageBody;
+	/** The message this one quotes, when it quotes one. */
+	quotedMessageId?: string;
+}
+
+/** The text of a message was edited (groups only; the event with the latest time is the latest state). */
+export interface LineEditedEvent extends EventBase {
+	type: "edited";
+	messageId: string;
+	text: string;
+	/** What the subscriber answered for the original message, in the order it gave it. */
+	refs: readonly string[];
+}
+
+/**
+ * The sender took a message back. By the time the subscriber hears of it the stored payload is gone
+ * and a tombstone stops the message from being mirrored again. `refs` are what it answered for the
+ * message, in the order it gave them; empty when nothing was mirrored (yet). Heard more than once
+ * when the event is redelivered, so deleting must be idempotent.
+ */
+export interface LineUnsentEvent extends EventBase {
+	type: "unsent";
+	messageId: string;
+	refs: readonly string[];
+}
+
+/**
+ * Whether the join notice went out: `"sent"` (LINE took the Reply), `"failed"` (the Reply was
+ * refused, the token had lapsed or the notice's text is not the one its digest names; nothing else
+ * was sent in its place), or `"unconfirmed"` when no notice is configured, or the first try was cut
+ * short and nobody knows whether LINE got it.
+ */
+export type JoinNotice = "sent" | "unconfirmed" | "failed";
+
+/** The bot was added to a chat. */
+export interface LineJoinedEvent extends EventBase {
+	type: "joined";
+	notice: JoinNotice;
+}
+
+/** The bot was removed from a chat. */
+export interface LineLeftEvent extends EventBase {
+	type: "left";
+}
+
+export interface LineMemberJoinedEvent extends EventBase {
+	type: "memberJoined";
+	userIds: readonly string[];
+}
+
+export interface LineMemberLeftEvent extends EventBase {
+	type: "memberLeft";
+	userIds: readonly string[];
+}
+
+/**
+ * How a push ended, told once per `origin` the push carries (or once with `originRef: null` when it
+ * carries none). At least once: a subscriber that fails is told again later, so it must be idempotent.
+ * It has no event id or time; the push is not a webhook event.
+ */
+export interface LineOutboxResultEvent {
+	type: "outboxResult";
+	sourceKey: string;
+	/** The `origin` the subscriber gave when it enqueued, or null. */
+	originRef: string | null;
+	/**
+	 * `sent` (accepted, or already accepted under the same retry key), `dead` (LINE refused it, or it
+	 * kept failing, or its retry key lapsed), or `refused` (the quota gate would have been exceeded; nothing was sent).
+	 */
+	status: "sent" | "dead" | "refused";
+	/**
+	 * Why the push did not go out: LINE's refusal as a code (`http_400`, `sender_name_refused`,
+	 * `sender_icon_refused`, ...) or the package's reason (`quota_exhausted`, `retry_key_expired`,
+	 * `source_not_allowed`); null when it was sent.
+	 */
+	errorCode: string | null;
+}
+
+export type LineEvent =
+	| LineMessageEvent
+	| LineEditedEvent
+	| LineUnsentEvent
+	| LineJoinedEvent
+	| LineLeftEvent
+	| LineMemberJoinedEvent
+	| LineMemberLeftEvent
+	| LineOutboxResultEvent;
+
+/** What a subscriber answers a `message` with. Any other event needs no answer. */
+export interface LineMirror {
+	/** Opaque references to what the subscriber made for the message (one message may become several posts). */
+	refs: readonly string[];
+}
+
+/**
+ * What a subscriber can do while it handles a `message`. For any other event `keep` rejects with
+ * `keep_unavailable`.
+ */
+export interface LineContext {
+	/**
+	 * Keeps the reference of a post the subscriber has just made, at once: stored under the same
+	 * per-message lock and tombstone check as the references it answers at the end, so the post can
+	 * still be taken back if the handler fails later (the references stay stored for the retry and for
+	 * an `unsent`). Calling it again for a kept reference changes nothing. Resolves `{ unsent: true }`
+	 * when the sender had already taken the message back: the reference has then been handed to the
+	 * subscriber as `unsent` already, and the subscriber should stop mirroring.
+	 */
+	keep(ref: string): Promise<{ unsent: boolean }>;
+}
+
+/**
+ * The one consumer of the package. It is called at least once per event, so it must be idempotent;
+ * `signal` aborts when the worker stops or the event is no longer its own. To give up, throw: the
+ * event is retried with backoff (a returned value is never read as a retry request, and a `message`
+ * answer that is not `{ refs }` fails with `bad_refs`).
+ *
+ * A `message` may become several posts. Call `context.keep(ref)` as each post lands: the references
+ * of posts made before a later one fails are then still known to the retry and to an `unsent`, so
+ * none is left behind. Refs returned at the end merge with the kept ones. Only a crash between a post
+ * and its `keep` can leave a post the package does not know of.
+ */
+export type LineSubscriber = (
+	event: LineEvent,
+	signal: AbortSignal,
+	context: LineContext,
+) => // biome-ignore lint/suspicious/noConfusingVoidType: an async handler that returns nothing is Promise<void>
+Promise<LineMirror | undefined | void>;
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+	typeof value === "object" && value !== null && !Array.isArray(value);
+
+export const nonEmpty = (value: unknown): string | undefined =>
+	typeof value === "string" && value !== "" ? value : undefined;
+
+const num = (value: unknown): number | undefined =>
+	typeof value === "number" && Number.isFinite(value) ? value : undefined;
+
+const bad = (what: string): LineError =>
+	new LineError("bad_message", `line: the event has no valid ${what}`);
+
+/** The user id inside an event's `source`, when it names one. */
+export function senderOf(payload: Record<string, unknown>): string | undefined {
+	return isRecord(payload.source) ? nonEmpty(payload.source.userId) : undefined;
+}
+
+/** The `message` object of an event. */
+export function messageOf(
+	payload: Record<string, unknown>,
+): Record<string, unknown> {
+	if (!isRecord(payload.message)) throw bad("message");
+	return payload.message;
+}
+
+/** The body of a `message` event's message. Throws `bad_message` when a known type lacks what it needs. */
+export function readBody(message: Record<string, unknown>): LineMessageBody {
+	const type = nonEmpty(message.type);
+	if (!type) throw bad("message type");
+	switch (type) {
+		case "text": {
+			if (typeof message.text !== "string") throw bad("text");
+			return { kind: "text", text: message.text };
+		}
+		case "image":
+			return { kind: "image" };
+		case "video":
+		case "audio": {
+			const duration = num(message.duration);
+			return duration === undefined
+				? { kind: type }
+				: { kind: type, durationMs: duration };
+		}
+		case "file": {
+			const fileName = nonEmpty(message.fileName) ?? "file";
+			const size = num(message.fileSize);
+			return size === undefined
+				? { kind: "file", fileName }
+				: { kind: "file", fileName, fileSize: size };
+		}
+		case "sticker": {
+			const packageId = nonEmpty(message.packageId);
+			const stickerId = nonEmpty(message.stickerId);
+			if (!packageId || !stickerId) throw bad("sticker");
+			const keywords = Array.isArray(message.keywords)
+				? message.keywords.filter((k): k is string => typeof k === "string")
+				: undefined;
+			const text = nonEmpty(message.text);
+			return {
+				kind: "sticker",
+				packageId,
+				stickerId,
+				...(keywords && keywords.length > 0 ? { keywords } : {}),
+				...(text ? { text } : {}),
+			};
+		}
+		case "location": {
+			const latitude = num(message.latitude);
+			const longitude = num(message.longitude);
+			if (latitude === undefined || longitude === undefined)
+				throw bad("location");
+			const title = nonEmpty(message.title);
+			const address = nonEmpty(message.address);
+			return {
+				kind: "location",
+				latitude,
+				longitude,
+				...(title ? { title } : {}),
+				...(address ? { address } : {}),
+			};
+		}
+		default:
+			return { kind: "unsupported", messageType: type.slice(0, 64) };
+	}
+}
+
+/** The ids of the members a `memberJoined` or `memberLeft` event names. */
+export function readMembers(
+	payload: Record<string, unknown>,
+	field: "joined" | "left",
+): string[] {
+	const holder = payload[field];
+	if (!isRecord(holder) || !Array.isArray(holder.members)) return [];
+	return holder.members.flatMap((member) => {
+		const id = isRecord(member) ? nonEmpty(member.userId) : undefined;
+		return id ? [id] : [];
+	});
+}

package/src/migrations.ts

@@ -2,7 +2,7 @@ import type { Migration } from "pi-roundtable";
 
 /**
  * The sources and the inbox. Later migrations add the tables of messages, tombstones and the
- * outbox; this one is never edited once released.
+ * outbox; this one is never edited once released, and a migration is only ever appended.
  */
 export const INBOX_MIGRATION: Migration = {
 	name: "inbox",
@@ -43,3 +43,102 @@ export const INBOX_MIGRATION: Migration = {
 			ON line_inbox (message_id) WHERE message_id IS NOT NULL`;
 	},
 };
+
+/**
+ * What the consumer keeps about a message while it is mirrored: its tokens, the opaque references
+ * the subscriber returned, and the tombstones that stop an unsent message from being mirrored.
+ * Every row goes after the retention window.
+ */
+export const MESSAGES_MIGRATION: Migration = {
+	name: "messages",
+	up: async (sql) => {
+		await sql`CREATE TABLE IF NOT EXISTS line_messages (
+			source_key TEXT NOT NULL,
+			message_id TEXT NOT NULL,
+			message_type TEXT NOT NULL,
+			event_ts BIGINT NOT NULL,
+			reply_token TEXT,
+			reply_token_at TIMESTAMPTZ,
+			quote_token TEXT,
+			edit_ts BIGINT NOT NULL DEFAULT 0,
+			created_at TIMESTAMPTZ NOT NULL,
+			PRIMARY KEY (source_key, message_id)
+		)`;
+		await sql`CREATE TABLE IF NOT EXISTS line_message_refs (
+			source_key TEXT NOT NULL,
+			message_id TEXT NOT NULL,
+			ref TEXT NOT NULL,
+			position INTEGER NOT NULL,
+			created_at TIMESTAMPTZ NOT NULL,
+			PRIMARY KEY (source_key, message_id, ref)
+		)`;
+		await sql`CREATE TABLE IF NOT EXISTS line_tombstones (
+			source_key TEXT NOT NULL,
+			message_id TEXT NOT NULL,
+			created_at TIMESTAMPTZ NOT NULL,
+			PRIMARY KEY (source_key, message_id)
+		)`;
+		await sql`CREATE INDEX IF NOT EXISTS line_messages_age ON line_messages (created_at)`;
+		await sql`CREATE INDEX IF NOT EXISTS line_message_refs_age ON line_message_refs (created_at)`;
+		await sql`CREATE INDEX IF NOT EXISTS line_tombstones_age ON line_tombstones (created_at)`;
+		await sql`CREATE INDEX IF NOT EXISTS line_tombstones_message ON line_tombstones (message_id)`;
+		// The retention sweeper looks at finished events by their completion time and at waiting ones by age.
+		await sql`CREATE INDEX IF NOT EXISTS line_inbox_finished
+			ON line_inbox (completed_at) WHERE status IN ('done', 'skipped', 'dead')`;
+		await sql`CREATE INDEX IF NOT EXISTS line_inbox_waiting_age
+			ON line_inbox (created_at) WHERE status = 'pending'`;
+	},
+};
+
+/**
+ * The outbox: pushes queued for a chat, each with its retry key from the moment it exists, and the
+ * outcome of every join notice. The messages of a push are nulled when it is finished; rows go after
+ * the retention window.
+ */
+export const OUTBOX_MIGRATION: Migration = {
+	name: "outbox",
+	up: async (sql) => {
+		await sql`CREATE TABLE IF NOT EXISTS line_outbox (
+			id BIGSERIAL PRIMARY KEY,
+			source_key TEXT NOT NULL,
+			sender_name TEXT,
+			sender_icon_url TEXT,
+			messages JSONB,
+			message_count INTEGER NOT NULL,
+			origin_refs JSONB NOT NULL DEFAULT '[]'::jsonb,
+			retry_key UUID NOT NULL,
+			recipients INTEGER,
+			status TEXT NOT NULL CHECK (status IN ('queued', 'sending', 'sent', 'dead', 'refused')),
+			attempts INTEGER NOT NULL DEFAULT 0,
+			created_at TIMESTAMPTZ NOT NULL,
+			ready_at TIMESTAMPTZ NOT NULL,
+			next_attempt_at TIMESTAMPTZ NOT NULL,
+			first_attempt_at TIMESTAMPTZ,
+			claimed_at TIMESTAMPTZ,
+			completed_at TIMESTAMPTZ,
+			line_request_id TEXT,
+			last_error_code TEXT,
+			notified_at TIMESTAMPTZ,
+			notify_attempts INTEGER NOT NULL DEFAULT 0,
+			notify_after TIMESTAMPTZ
+		)`;
+		await sql`CREATE INDEX IF NOT EXISTS line_outbox_open
+			ON line_outbox (source_key, id) WHERE status IN ('queued', 'sending')`;
+		await sql`CREATE INDEX IF NOT EXISTS line_outbox_unnotified
+			ON line_outbox (id) WHERE notified_at IS NULL AND status IN ('sent', 'dead', 'refused')`;
+		await sql`CREATE INDEX IF NOT EXISTS line_outbox_age ON line_outbox (created_at)`;
+		await sql`CREATE TABLE IF NOT EXISTS line_notices (
+			webhook_event_id TEXT PRIMARY KEY,
+			outcome TEXT NOT NULL CHECK (outcome IN ('attempting', 'sent', 'failed')),
+			created_at TIMESTAMPTZ NOT NULL
+		)`;
+		await sql`CREATE INDEX IF NOT EXISTS line_notices_age ON line_notices (created_at)`;
+	},
+};
+
+/** Every migration of the package, in the order they run. */
+export const MIGRATIONS: Migration[] = [
+	INBOX_MIGRATION,
+	MESSAGES_MIGRATION,
+	OUTBOX_MIGRATION,
+];