@vercel/board 0.16.0 → 0.17.0

package/dist/{contract-CuJmlrhw.mjs → reducers-BFmIXilu.mjs}

@@ -1,305 +1,210 @@
-import { S as storable, _ as RemoteWatcherId, c as ChannelPath, d as LabelKey, g as MessageText, h as MessageId, i as Attachment, l as Emoji, m as MESSAGE_TEXT_MAX, n as ActorId, o as Author, p as Labels, u as Handle, v as SCOPE_MAX, y as SeenActorKind } from "./schemas-Be08nyfW.mjs";
+import { S as storable, _ as RemoteWatcherId, c as ChannelPath, d as LabelKey, g as MessageText, h as MessageId, i as Attachment, l as Emoji, n as ActorId, o as Author, p as Labels, u as Handle, v as SCOPE_MAX, y as SeenActorKind } from "./schemas-Be08nyfW.mjs";
+import { a as Link, i as ExternalTarget, n as ExternalEvent, o as Origin } from "./external-BV_cUncs.mjs";
+import { n as setOwn, t as own } from "./own-OwgPWdmh.mjs";
+import { a as reducer, i as makeReducerBuilder, t as assertSyncSchema } from "./reducer-CjmvZSAb-D_OSISmj.mjs";
+import { n as foldMessages, t as foldActors } from "./folds-Dyjput8M.mjs";
 import { z } from "zod";
-import { contract } from "experimental-a2";
-//#region src/contract/contract.ts
-/**
-* An external thread or channel, prefixed with its sync key:
-* `slack:C0123ABC` (a channel), `slack:C0123ABC:1727.1234` (a thread),
-* `github:basehub-ai/www:12` (a PR thread).
-*/
-const ExternalTarget = z.string().min(3).max(300);
-/** Where a message came from on a platform. `thread` is grouped (GitHub review threads fold into their PR). */
-const Origin = z.object({
-	channel: ExternalTarget.optional(),
-	thread: ExternalTarget,
-	/** The exact platform thread, when it differs from `thread`. */
-	subthread: ExternalTarget.nullable(),
-	message: z.string().min(1).max(300),
-	context: z.string().max(300).nullable()
-});
-/** What a linked message said, as the board saw it when the link arrived. */
-const LinkSnapshot = z.object({
-	author: z.string().min(1).max(256),
-	text: z.string().max(MESSAGE_TEXT_MAX),
-	/** When it was written, if the platform said. */
-	createdAt: z.string().max(64).nullable(),
-	/** Its files, linked rather than copied. */
-	files: z.array(z.object({
-		name: z.string().min(1).max(1e3),
-		url: z.string().max(4e3).nullable()
-	})).max(20)
-});
-/**
-* A platform message linked from a message (a Slack permalink): the board message
-* it was synced to, if any, and a snapshot of it, or why the board couldn't read it.
-*/
-const Link = z.object({
-	url: z.string().min(1).max(4e3),
-	message: MessageId.nullable(),
-	snapshot: LinkSnapshot.nullable(),
-	/** Why there's no snapshot: `not_in_channel`, `channel_not_found`. */
-	unavailable: z.string().max(300).nullable()
-});
+//#region ../../node_modules/.pnpm/experimental-a2@0.22.0_@upstash+qstash@2.12.0_@vercel+queue@0.7.0_ai@7.0.130_zod@4.6.5__52060f00b21aecfab049c27fa3abd2f9/node_modules/experimental-a2/dist/contract-CWukt01d.js
+function contract(options) {
+	for (const type of Object.keys(options.events ?? {})) if (type.startsWith("a2.")) throw new TypeError(`contract '${String(options.name)}': event types starting with 'a2.' are reserved`);
+	return defineContract(options);
+}
+function defineContract(options) {
+	const { name } = options;
+	if (typeof name !== "string" || name.length === 0) throw new TypeError("contract name must be a non-empty string");
+	if (name.includes("")) throw new TypeError("contract name contains a reserved control character");
+	const defs = options.events;
+	for (const [type, schema] of Object.entries(defs)) {
+		if (typeof schema?.["~standard"]?.validate !== "function") throw new TypeError(`contract '${name}': the value for '${type}' is not a Standard Schema (expected an object with '~standard')`);
+		assertSyncSchema(schema, `event '${type}'`);
+	}
+	const events = Object.freeze({ ...defs });
+	const presenceDefs = options.presence ?? {};
+	for (const [field, schema] of Object.entries(presenceDefs)) {
+		if (typeof schema?.["~standard"]?.validate !== "function") throw new TypeError(`contract '${name}': the value for presence field '${field}' is not a Standard Schema (expected an object with '~standard')`);
+		assertSyncSchema(schema, `presence field '${field}'`);
+	}
+	const presence = Object.freeze({ ...presenceDefs });
+	return {
+		name,
+		events,
+		presence,
+		batch: (...items) => items,
+		reducer: options.reducer === void 0 ? void 0 : {
+			...options.reducer,
+			...makeReducerBuilder(events, presence, options.reducer).fold(options.reducer.fold)
+		}
+	};
+}
+//#endregion
+//#region src/contract/events.ts
 /** The sync key a write came from, or null when it was written on the board. */
 const From = z.string().nullable();
 /** The thread key: the event ID of the thread's root. Lanes and sync state are keyed by it. */
 const ThreadKey = z.string().min(1).max(200).refine(storable, "thread key has a NUL character or a lone surrogate");
 /** The board's one log. Every board fact is an event in session `board`. */
-const boardContract = contract({
-	name: "board",
-	events: {
-		"message.posted": z.object({
-			channel: ChannelPath,
-			/** Empty only when the message has attachments. */
-			text: z.union([MessageText, z.literal("")]),
-			/** The thread root, or null for a root. */
-			re: MessageId.nullable(),
-			/** The exact message replied to, when it isn't the root. */
-			replyTo: MessageId.nullable(),
-			thread: ThreadKey,
-			labels: Labels,
-			noSync: z.boolean(),
-			mentions: z.array(ActorId),
-			by: Author,
-			origin: Origin.nullable(),
-			from: From,
-			/** Files on the message. Events written before attachments have none. */
-			attachments: z.array(Attachment).max(10).optional(),
-			/** Platform messages it links to. Events written before links have none. */
-			links: z.array(Link).max(10).optional(),
-			/** (server) Posted by a schedule: its ID and which send this is, from 0. Other messages have none. */
-			schedule: z.object({
-				id: z.number().int().positive(),
-				n: z.number().int().nonnegative()
-			}).optional(),
-			/**
-			* (server) Its author couldn't read the channel it posted in. Where a
-			* caller can't read, it edits and deletes only these of its own. Events
-			* from before channel access have none: everyone read everything then.
-			*/
-			blind: z.literal(true).optional(),
-			/**
-			* (server) The principal of the sync elsewhere that imported it, whose copy `origin` names:
-			* that sync's to act on. None for the board's own sync, or a write on the board.
-			*/
-			importedBy: ActorId.optional()
-		}),
-		/** A message's links changed: an edit linked something new, or the platform sent what a link says. */
-		"message.linked": z.object({
-			id: MessageId,
-			thread: ThreadKey,
-			links: z.array(Link).max(10),
-			by: Author,
-			from: From
-		}),
-		"message.edited": z.object({
-			id: MessageId,
-			thread: ThreadKey,
-			text: MessageText,
-			mentions: z.array(ActorId),
-			by: Author,
-			from: From
-		}),
-		"message.deleted": z.object({
-			id: MessageId,
-			thread: ThreadKey,
-			by: Author,
-			from: From
-		}),
-		"reaction.added": z.object({
-			id: MessageId,
-			thread: ThreadKey,
-			emoji: Emoji,
-			by: Author,
-			from: From
-		}),
-		"reaction.removed": z.object({
-			id: MessageId,
-			thread: ThreadKey,
-			emoji: Emoji,
-			by: Author,
-			from: From
-		}),
-		"labels.changed": z.object({
-			id: MessageId,
-			thread: ThreadKey,
-			set: Labels,
-			unset: z.array(LabelKey),
-			by: Author
-		}),
-		/** A thread is synced with an external channel (start a thread there) or thread (join it). */
-		"thread.synced": z.object({
-			thread: ThreadKey,
-			target: ExternalTarget,
-			cause: z.enum(["config", "request"]),
-			kind: z.enum(["channel", "thread"]).optional(),
-			by: Author
-		}),
-		/** An outbound delivery receipt: board message `id` exists on the platform as `external`. */
-		"message.synced": z.object({
-			id: MessageId,
-			thread: ThreadKey,
-			target: ExternalTarget,
-			external: z.object({
-				thread: ExternalTarget,
-				message: z.string().min(1).max(300),
-				/** Posted with its author's own platform token, so it shows as them. Older receipts have none. */
-				asUser: z.literal(true).optional()
-			}),
-			/**
-			* (server) The principal of the sync elsewhere that recorded it: its copy is that sync's to
-			* change. None for the board's own sync.
-			*/
-			syncedBy: ActorId.optional()
-		}),
+const boardEvents = {
+	"message.posted": z.object({
+		channel: ChannelPath,
+		/** Empty only when the message has attachments. */
+		text: z.union([MessageText, z.literal("")]),
+		/** The thread root, or null for a root. */
+		re: MessageId.nullable(),
+		/** The exact message replied to, when it isn't the root. */
+		replyTo: MessageId.nullable(),
+		thread: ThreadKey,
+		labels: Labels,
+		noSync: z.boolean(),
+		mentions: z.array(ActorId),
+		by: Author,
+		origin: Origin.nullable(),
+		from: From,
+		/** Files on the message. Events written before attachments have none. */
+		attachments: z.array(Attachment).max(10).optional(),
+		/** Platform messages it links to. Events written before links have none. */
+		links: z.array(Link).max(10).optional(),
+		/** (server) Posted by a schedule: its ID and which send this is, from 0. Other messages have none. */
+		schedule: z.object({
+			id: z.number().int().positive(),
+			n: z.number().int().nonnegative()
+		}).optional(),
 		/**
-		* Board message `id`'s files reached `target` after its text: `files` are the
-		* platform's IDs for them, or null when the platform refused files and the
-		* text got a line for each instead.
+		* (server) Its author couldn't read the channel it posted in. Where a
+		* caller can't read, it edits and deletes only these of its own. Events
+		* from before channel access have none: everyone read everything then.
 		*/
-		"message.files_synced": z.object({
-			id: MessageId,
-			thread: ThreadKey,
-			target: ExternalTarget,
-			files: z.array(z.string().min(1).max(300)).max(10).nullable(),
-			/** (server) As on `message.synced`: only the sync that recorded the copy sets its files. */
-			syncedBy: ActorId.optional()
-		}),
-		/** A delivery that gave up: board message `id` didn't reach `target`, and `error` says why. */
-		"message.sync_failed": z.object({
-			id: MessageId,
-			thread: ThreadKey,
-			target: ExternalTarget,
-			error: z.string().min(1).max(500)
-		}),
-		"actor.seen": z.object({
-			actor: ActorId,
-			kind: SeenActorKind,
-			handle: Handle,
-			name: z.string().min(1).max(128).refine(storable, "name has a NUL character or a lone surrogate"),
-			avatar: z.string().url().nullable(),
-			/**
-			* (server) A principal a host's `authenticate` made, or one of its profiles: someone the board
-			* signs in, whatever its ID or kind, so sync never writes as it. Others have none.
-			*/
-			host: z.literal(true).optional()
-		}),
+		blind: z.literal(true).optional(),
 		/**
-		* A platform actor (`slack:user:U0456`) is the same person as a principal
-		* (`vercel:user:…`): for display, `--by`, and mentions, never for permissions.
-		* `method` says how it was proved: a one-time code posted from that account,
-		* or the account's own sign-in (`consent`).
+		* (server) The principal of the sync elsewhere that imported it, whose copy `origin` names:
+		* that sync's to act on. None for the board's own sync, or a write on the board.
 		*/
-		"actor.linked": z.object({
-			actor: ActorId,
-			to: ActorId,
-			method: z.enum(["code", "consent"]),
-			by: Author
+		importedBy: ActorId.optional()
+	}),
+	/** A message's links changed: an edit linked something new, or the platform sent what a link says. */
+	"message.linked": z.object({
+		id: MessageId,
+		thread: ThreadKey,
+		links: z.array(Link).max(10),
+		by: Author,
+		from: From
+	}),
+	"message.edited": z.object({
+		id: MessageId,
+		thread: ThreadKey,
+		text: MessageText,
+		mentions: z.array(ActorId),
+		by: Author,
+		from: From
+	}),
+	"message.deleted": z.object({
+		id: MessageId,
+		thread: ThreadKey,
+		by: Author,
+		from: From
+	}),
+	"reaction.added": z.object({
+		id: MessageId,
+		thread: ThreadKey,
+		emoji: Emoji,
+		by: Author,
+		from: From
+	}),
+	"reaction.removed": z.object({
+		id: MessageId,
+		thread: ThreadKey,
+		emoji: Emoji,
+		by: Author,
+		from: From
+	}),
+	"labels.changed": z.object({
+		id: MessageId,
+		thread: ThreadKey,
+		set: Labels,
+		unset: z.array(LabelKey),
+		by: Author
+	}),
+	/** A thread is synced with an external channel (start a thread there) or thread (join it). */
+	"thread.synced": z.object({
+		thread: ThreadKey,
+		target: ExternalTarget,
+		cause: z.enum(["config", "request"]),
+		kind: z.enum(["channel", "thread"]).optional(),
+		by: Author
+	}),
+	/** An outbound delivery receipt: board message `id` exists on the platform as `external`. */
+	"message.synced": z.object({
+		id: MessageId,
+		thread: ThreadKey,
+		target: ExternalTarget,
+		external: z.object({
+			thread: ExternalTarget,
+			message: z.string().min(1).max(300),
+			/** Posted with its author's own platform token, so it shows as them. Older receipts have none. */
+			asUser: z.literal(true).optional()
 		}),
-		"actor.unlinked": z.object({
-			actor: ActorId,
-			by: Author
-		})
-	}
-});
-const BOARD_SESSION = "board";
-const ExternalAuthor = z.object({
-	/** The platform principal, e.g. `slack:user:U0456`. */
-	id: z.string().min(1),
-	handle: z.string().min(1),
-	name: z.string().min(1),
-	avatar: z.string().nullable(),
-	isBot: z.boolean()
-});
-/**
-* A file on a platform message, as Chat SDK describes it: enough for the
-* platform's adapter to fetch it later (`rehydrateAttachment`), never the bytes.
-*/
-const ExternalFile = z.object({
-	type: z.enum([
-		"image",
-		"file",
-		"video",
-		"audio"
-	]),
-	name: z.string().max(1e3).optional(),
-	mimeType: z.string().max(255).optional(),
-	size: z.number().int().nonnegative().optional(),
-	url: z.string().max(4e3).optional(),
-	fetchMetadata: z.record(z.string(), z.string().max(4e3)).optional()
-});
-/**
-* A platform message a platform message links to, at intake: where it lives
-* (`thread`, with the sync key prefix, and `message`), and what it said when the
-* platform sent that along (Slack's unfurl).
-*/
-const ExternalLink = z.object({
-	url: z.string().min(1).max(4e3),
-	thread: ExternalTarget,
-	message: z.string().min(1).max(300),
-	snapshot: LinkSnapshot.nullable()
-});
-const ExternalLocation = z.object({
-	channel: ExternalTarget,
-	thread: ExternalTarget,
-	subthread: ExternalTarget.nullable()
-});
-/** A platform event, normalized at intake. Thread IDs are external IDs with the sync key prefix. */
-const ExternalEvent = z.discriminatedUnion("kind", [
-	z.object({
-		kind: z.literal("message"),
-		...ExternalLocation.shape,
-		message: z.string(),
-		isRoot: z.boolean(),
-		text: z.string(),
-		context: z.string().nullable(),
-		author: ExternalAuthor,
-		/** Files on the message, fetched when it lands on the board. Older events have none. */
-		files: z.array(ExternalFile).max(20).optional(),
-		/** Platform messages it links to. Older events have none. */
-		links: z.array(ExternalLink).max(10).optional()
+		/**
+		* (server) The principal of the sync elsewhere that recorded it: its copy is that sync's to
+		* change. None for the board's own sync.
+		*/
+		syncedBy: ActorId.optional()
+	}),
+	/**
+	* Board message `id`'s files reached `target` after its text: `files` are the
+	* platform's IDs for them, or null when the platform refused files and the
+	* text got a line for each instead.
+	*/
+	"message.files_synced": z.object({
+		id: MessageId,
+		thread: ThreadKey,
+		target: ExternalTarget,
+		files: z.array(z.string().min(1).max(300)).max(10).nullable(),
+		/** (server) As on `message.synced`: only the sync that recorded the copy sets its files. */
+		syncedBy: ActorId.optional()
 	}),
-	z.object({
-		kind: z.literal("edited"),
-		...ExternalLocation.shape,
-		message: z.string(),
-		text: z.string(),
-		author: ExternalAuthor,
-		links: z.array(ExternalLink).max(10).optional(),
-		/** Only the links changed (the platform sent what they say), so `text` isn't news. */
-		linksOnly: z.boolean().optional()
+	/** A delivery that gave up: board message `id` didn't reach `target`, and `error` says why. */
+	"message.sync_failed": z.object({
+		id: MessageId,
+		thread: ThreadKey,
+		target: ExternalTarget,
+		error: z.string().min(1).max(500)
 	}),
-	z.object({
-		kind: z.literal("deleted"),
-		...ExternalLocation.shape,
-		message: z.string()
+	"actor.seen": z.object({
+		actor: ActorId,
+		kind: SeenActorKind,
+		handle: Handle,
+		name: z.string().min(1).max(128).refine(storable, "name has a NUL character or a lone surrogate"),
+		avatar: z.string().url().nullable(),
+		/**
+		* (server) A principal a host's `authenticate` made, or one of its profiles: someone the board
+		* signs in, whatever its ID or kind, so sync never writes as it. Others have none.
+		*/
+		host: z.literal(true).optional()
 	}),
-	z.object({
-		kind: z.literal("reaction"),
-		...ExternalLocation.shape,
-		message: z.string(),
-		emoji: z.string(),
-		added: z.boolean(),
-		author: ExternalAuthor
+	/**
+	* A platform actor (`slack:user:U0456`) is the same person as a principal
+	* (`vercel:user:…`): for display, `--by`, and mentions, never for permissions.
+	* `method` says how it was proved: a one-time code posted from that account,
+	* or the account's own sign-in (`consent`).
+	*/
+	"actor.linked": z.object({
+		actor: ActorId,
+		to: ActorId,
+		method: z.enum(["code", "consent"]),
+		by: Author
 	}),
-	z.object({
-		/** A platform lifecycle event: a PR opening, closing, being reviewed. */
-		kind: z.literal("lifecycle"),
-		...ExternalLocation.omit({ subthread: true }).shape,
-		type: z.string(),
-		title: z.string(),
-		url: z.string().nullable(),
-		labels: z.record(z.string(), z.string()),
-		unset: z.array(z.string()),
-		/** Key prefixes the platform owns on the root, e.g. `tag.`: keys under them that aren't in `labels` are unset. */
-		owns: z.array(z.string()).optional(),
-		/** A reply to add to the thread, e.g. "merged by julian". */
-		reply: z.string().nullable(),
-		/** Create the root if the board hasn't seen this thread. */
-		createRoot: z.boolean(),
-		author: ExternalAuthor
+	"actor.unlinked": z.object({
+		actor: ActorId,
+		by: Author
 	})
-]);
+};
+const BOARD_SESSION = "board";
+//#endregion
+//#region src/contract/contract.ts
+/** The board's one log. Every board fact is an event in session `board`. */
+const boardContract = contract({
+	name: "board",
+	events: boardEvents
+});
 /** Raw platform events live outside the board log, one session per external channel. */
 const inboxContract = contract({
 	name: "board-inbox",
@@ -563,4 +468,72 @@ const identityContract = contract({
 });
 const IDENTITY_SESSION = "identity";
 //#endregion
-export { schedulesContract as _, ExternalTarget as a, Link as c, SCHEDULES_SESSION as d, boardContract as f, registryContract as g, inboxSession as h, ExternalLocation as i, Origin as l, inboxContract as m, ExternalAuthor as n, IDENTITY_SESSION as o, identityContract as p, ExternalEvent as r, INBOXES_SESSION as s, BOARD_SESSION as t, REGISTRY_SESSION as u, watchContract as v, watchSession as y };
+//#region src/contract/reducers.ts
+const messagesReducer = reducer({
+	contract: boardContract,
+	name: "board.messages.v5",
+	initialState: {
+		byId: {},
+		replies: {}
+	}
+}).fold(foldMessages);
+reducer({
+	contract: boardContract,
+	name: "board.posted.v1",
+	initialState: {}
+}).fold((state, event) => {
+	if (event.type === "message.posted") setOwn(state, event.id, event.index);
+	return state;
+});
+const channelsReducer = reducer({
+	contract: boardContract,
+	name: "board.channels.v1",
+	initialState: {}
+}).fold((state, event) => {
+	if (event.type !== "message.posted") return state;
+	const { channel, re } = event.payload;
+	const entry = own(state, channel) ?? setOwn(state, channel, {
+		path: channel,
+		lastIndex: 0,
+		messages: 0,
+		threads: 0
+	});
+	entry.lastIndex = event.index;
+	entry.messages += 1;
+	if (re === null) entry.threads += 1;
+	return state;
+});
+const actorsReducer = reducer({
+	contract: boardContract,
+	name: "board.actors.v2",
+	initialState: {
+		byId: {},
+		byHandle: {},
+		links: {}
+	}
+}).fold(foldActors);
+const identityCodesReducer = reducer({
+	contract: identityContract,
+	name: "board.identity-codes.v1",
+	initialState: {}
+}).fold((state, event) => {
+	if (event.type === "identity.code_issued") {
+		const { hash, principal, sync, expiresAt } = event.payload;
+		state[hash] ??= {
+			principal,
+			sync,
+			expiresAt,
+			usedBy: null,
+			usedIn: null
+		};
+	} else if (event.type === "identity.code_used") {
+		const code = state[event.payload.hash];
+		if (code && code.usedBy === null) {
+			code.usedBy = event.payload.actor;
+			code.usedIn = event.payload.message ?? null;
+		}
+	}
+	return state;
+});
+//#endregion
+export { BOARD_SESSION as _, IDENTITY_SESSION as a, SCHEDULES_SESSION as c, inboxContract as d, inboxSession as f, watchSession as g, watchContract as h, messagesReducer as i, boardContract as l, schedulesContract as m, channelsReducer as n, INBOXES_SESSION as o, registryContract as p, identityCodesReducer as r, REGISTRY_SESSION as s, actorsReducer as t, identityContract as u };

package/dist/retryable-lazy-DZWmHpii-Bye-W8q7.mjs

@@ -0,0 +1,19 @@
+//#region ../../node_modules/.pnpm/experimental-a2@0.22.0_@upstash+qstash@2.12.0_@vercel+queue@0.7.0_ai@7.0.130_zod@4.6.5__52060f00b21aecfab049c27fa3abd2f9/node_modules/experimental-a2/dist/retryable-lazy-DZWmHpii.js
+const retryableLazy = (initialize) => {
+	let current = null;
+	const get = () => {
+		if (current) return current;
+		const attempt = Promise.resolve().then(initialize);
+		current = attempt;
+		attempt.catch(() => {
+			if (current === attempt) current = null;
+		});
+		return attempt;
+	};
+	return {
+		get,
+		peek: () => current
+	};
+};
+//#endregion
+export { retryableLazy as t };

package/dist/scheduler-task-X1SToDjP-BVoWuInI.mjs

@@ -0,0 +1,69 @@
+//#region ../../node_modules/.pnpm/experimental-a2@0.22.0_@upstash+qstash@2.12.0_@vercel+queue@0.7.0_ai@7.0.130_zod@4.6.5__52060f00b21aecfab049c27fa3abd2f9/node_modules/experimental-a2/dist/scheduler-task-X1SToDjP.js
+const recordOf = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+const validName = (value) => typeof value === "string" && value.length > 0;
+const validDueAt = (value) => typeof value === "number" && Number.isInteger(value) && value % 1e3 === 0;
+const validIndex = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+const baseTask = (record) => Object.hasOwn(record, "contract") && Object.hasOwn(record, "sessionId") && validName(record["contract"]) && validName(record["sessionId"]) ? {
+	contract: record["contract"],
+	sessionId: record["sessionId"]
+} : null;
+/**
+* Validate one delivered task.
+* Adapters call this only after their transport authentication has succeeded.
+*/
+function normalizeSchedulerTask(value) {
+	const record = recordOf(value);
+	if (!record) return null;
+	const base = baseTask(record);
+	if (!base) return null;
+	if (record["version"] !== 1) return null;
+	if (record["kind"] === "drain") {
+		const dueAt = record["dueAt"];
+		if (!validDueAt(dueAt)) return null;
+		return {
+			version: 1,
+			kind: "drain",
+			...base,
+			dueAt
+		};
+	}
+	if (record["kind"] === "clear") {
+		const { dueAt, id, ifLastIndex } = record;
+		if (!validName(id) || !validDueAt(dueAt) || !validIndex(ifLastIndex)) return null;
+		return {
+			version: 1,
+			kind: "clear",
+			id,
+			...base,
+			dueAt,
+			ifLastIndex
+		};
+	}
+	if (record["kind"] !== "append") return null;
+	const { dueAt, events, id, originIndex } = record;
+	if (!validName(id) || !validDueAt(dueAt)) return null;
+	if (originIndex !== void 0 && (!validIndex(originIndex) || originIndex === 0)) return null;
+	if (!Array.isArray(events) || events.length === 0) return null;
+	const parsedEvents = [];
+	for (const event of events) {
+		const item = recordOf(event);
+		if (!item || typeof item["id"] !== "string" || typeof item["type"] !== "string" || !Object.hasOwn(item, "payload")) return null;
+		parsedEvents.push({
+			id: item["id"],
+			type: item["type"],
+			payload: item["payload"]
+		});
+	}
+	if (new Set(parsedEvents.map((event) => event.id)).size !== parsedEvents.length) return null;
+	return {
+		version: 1,
+		kind: "append",
+		id,
+		...base,
+		dueAt,
+		events: parsedEvents,
+		...originIndex === void 0 ? {} : { originIndex }
+	};
+}
+//#endregion
+export { normalizeSchedulerTask as t };