@oomol-lab/open-flow 0.1.0-beta.3 → 0.1.0-beta.30

package/dist/common/flowInspection.d.ts

@@ -0,0 +1,16 @@
+import type { Draft, Flow } from './control-api.js';
+export declare function inspectFlowDraft(flow: Flow, readDraft: () => Draft | Promise<Draft>): Promise<{
+    flow: Flow;
+    draft: Draft;
+    version: 1;
+    draftIssue?: undefined;
+} | {
+    flow: Flow;
+    draft: null;
+    draftIssue: {
+        code: unknown;
+        message: string;
+        revisionId: string;
+    };
+    version: 1;
+}>;

package/dist/common/fr-iv1541dF.js

@@ -0,0 +1,93 @@
+//#region src/trigger/providers/airtable/locales/fr.json
+var e = { "airtable.on_record_changed": {
+	displayName: "Création ou mise à jour d’un enregistrement",
+	description: "Interroge périodiquement une table Airtable et se déclenche à la création ou à la mise à jour d’un enregistrement, dans l’ordre d’un champ temporel."
+} }, t = { "feishu_app_bot.on_event": {
+	displayName: "Événement d’application",
+	description: "Reçoit les événements Feishu sélectionnés via une source partagée."
+} }, n = {
+	"github.on_repo_event": {
+		displayName: "Événement de dépôt",
+		description: "Se déclenche lors des événements webhook GitHub sélectionnés dans un dépôt."
+	},
+	"github.watch_pull_request": {
+		displayName: "Suivi d’une pull request",
+		description: "Suit une pull request grâce aux notifications et à des vérifications périodiques. Part de son état actuel et signale les changements observés, sans garantir chaque transition intermédiaire ou événement de revue."
+	}
+}, r = { "gitlab.on_project_event": {
+	displayName: "Événement de projet",
+	description: "Se déclenche lors des événements webhook GitLab sélectionnés dans un projet."
+} }, i = { "gmail.on_message_received": {
+	displayName: "Nouveau message reçu",
+	description: "Interroge périodiquement la boîte Gmail et se déclenche à la réception d’un nouveau message."
+} }, a = { "googlecalendar.on_event_changed": {
+	displayName: "Modification d’un événement",
+	description: "Interroge périodiquement un agenda Google et se déclenche à la création, à la modification ou à l’annulation d’un événement."
+} }, o = {
+	"googledrive.changes_detected": {
+		displayName: "Modifications détectées",
+		description: "Utilise un canal Google Drive changes.watch et se déclenche lorsque des modifications Drive sont disponibles."
+	},
+	"googledrive.watch_changes": {
+		displayName: "Suivi des modifications",
+		description: "Surveille les modifications Drive grâce aux notifications et à des analyses périodiques du même flux de modifications."
+	},
+	"googledrive.on_file_change": {
+		displayName: "Modification d’un fichier ou dossier dans un dossier",
+		description: "Interroge périodiquement un dossier Google Drive et se déclenche à la création ou à la modification d’un fichier ou dossier directement à l’intérieur."
+	}
+}, s = { "googlesheets.on_row_added": {
+	displayName: "Nouvelle ligne ajoutée",
+	description: "Interroge périodiquement une feuille et se déclenche une fois pour chaque nouvelle ligne ajoutée après la dernière ligne déjà observée."
+} }, c = { "linear.on_issue_changed": {
+	displayName: "Création ou mise à jour d’un ticket",
+	description: "Vérifie périodiquement les tickets nouveaux et modifiés d’une équipe Linear. Commence maintenant, sans déclencher les tickets existants. Signale les états actuels observés, sans couvrir les suppressions ni chaque changement de statut intermédiaire."
+} }, l = { "notion.on_database_page_event": {
+	displayName: "Ajout ou mise à jour d’une page de base de données",
+	description: "Interroge périodiquement une base Notion et se déclenche à l’ajout d’une page ou à la modification d’une page existante."
+} }, u = { "one_drive.on_item_changed": {
+	displayName: "Modification d’un fichier ou dossier",
+	description: "Interroge périodiquement le flux de modifications OneDrive et se déclenche à la création, à la modification ou à la suppression d’un fichier ou dossier."
+} }, d = { "outlook.on_message_received": {
+	displayName: "Nouveau message reçu",
+	description: "Interroge périodiquement un dossier de courrier Microsoft Outlook et se déclenche à l’arrivée d’un nouveau message."
+} }, f = { "shopify.on_shop_event": {
+	displayName: "Événement de boutique",
+	description: "Se déclenche lors des événements correspondant aux sujets webhook Shopify sélectionnés dans la boutique connectée."
+} }, p = { "slack.on_message_posted": {
+	displayName: "Nouveau message de canal",
+	description: "Interroge périodiquement une conversation Slack et se déclenche à la publication d’un nouveau message."
+} }, m = { "stripe.on_event": {
+	displayName: "Événement de compte",
+	description: "Se déclenche lors des événements Stripe sélectionnés sur le compte connecté."
+} }, h = { "telegram.on_update": {
+	displayName: "Mise à jour du bot",
+	description: "Se déclenche lorsque le bot Telegram connecté reçoit une mise à jour sélectionnée."
+} }, g = { "woocommerce.on_store_event": {
+	displayName: "Événement de boutique",
+	description: "Se déclenche lors des événements de boutique WooCommerce sélectionnés."
+} }, _ = { "zendesk.on_event": {
+	displayName: "Abonnement aux événements",
+	description: "Se déclenche lorsque l’un des événements de compte Zendesk sélectionnés se produit."
+} }, v = {
+	...e,
+	...t,
+	...n,
+	...r,
+	...i,
+	...a,
+	...o,
+	...s,
+	...c,
+	...l,
+	...u,
+	...d,
+	...f,
+	...p,
+	...m,
+	...h,
+	...g,
+	..._
+};
+//#endregion
+export { v as default };

package/dist/common/integration-trigger.d.ts

@@ -1,13 +1,34 @@
 import type { ConnectorProxy } from './connector-proxy.js';
 import type { IntegrationEndpointMethod, JsonValue, TriggerKeySnapshot } from '../browser/flow-change.js';
+import type { TriggerConfigOption, TriggerConfigOptionsContext } from './trigger-config-options.js';
 export declare const maximumIntegrationBodyBytes: number;
 export declare const maximumIntegrationDeliveryPages = 5;
+export interface ListenerReadContext {
+    readonly checkpoint: JsonValue;
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly connector: ConnectorProxy;
+    readonly now: Date;
+    readonly signal?: AbortSignal;
+}
+export interface ListenerPage {
+    readonly checkpoint: JsonValue;
+    readonly dedupeKey: string;
+    readonly hasMore: boolean;
+    readonly outputs: Readonly<Record<string, JsonValue>> | null;
+}
+export interface ListenerSource {
+    readonly intervalMs: number;
+    readonly read: (context: ListenerReadContext) => Promise<ListenerPage>;
+}
+export declare function validateListenerPage(value: unknown): asserts value is ListenerPage;
 export type IntegrationReceiveResult = {
+    readonly outcome: 'wake';
+} | {
     readonly checkpoint?: JsonValue;
     readonly continue?: boolean;
     readonly dedupeKey?: string;
     readonly outcome: 'event';
-    readonly payload: Readonly<Record<string, JsonValue>>;
+    readonly outputs: Readonly<Record<string, JsonValue>>;
 } | {
     readonly checkpoint?: JsonValue;
     readonly continue?: boolean;
@@ -27,6 +48,8 @@ export interface IntegrationStateContext {
     readonly saveSubscription: (subscription: Readonly<Record<string, JsonValue>>, reconcileAt: Date) => Promise<void>;
 }
 export interface IntegrationReceiveContext {
+    readonly eventSourceId?: string;
+    readonly signal?: AbortSignal;
     readonly admit: boolean;
     readonly allow?: () => Promise<boolean>;
     readonly bindingId: string;
@@ -57,6 +80,9 @@ export interface IntegrationReconcileResult {
     readonly outcome: 'pending' | 'ready';
 }
 export interface IntegrationDefinition {
+    readonly eventSource?: 'feishu';
+    readonly configOptions?: (context: TriggerConfigOptionsContext) => Promise<readonly TriggerConfigOption[]>;
+    readonly listener?: ListenerSource;
     readonly initialState?: {
         readonly checkpoint: JsonValue;
         readonly subscription: Readonly<Record<string, JsonValue>>;
@@ -82,7 +108,7 @@ export declare function integrationOccurrenceId(bindingId: string, runtimeVersio
 export interface IntegrationConformanceFixture {
     readonly config: Readonly<Record<string, JsonValue>>;
     readonly connectionId: string;
-    readonly definition: Pick<IntegrationDefinition, 'initialState' | 'receive' | 'reconcile'>;
+    readonly definition: Pick<IntegrationDefinition, 'initialState' | 'listener' | 'receive' | 'reconcile'>;
     readonly publishedAt: string;
 }
 export interface IntegrationConformanceState {
@@ -111,3 +137,4 @@ export interface IntegrationConformanceCase {
     verify(harness: IntegrationConformanceHarness): Promise<void>;
 }
 export declare const integrationConformanceCases: readonly IntegrationConformanceCase[];
+export declare const listenerConformanceCases: readonly IntegrationConformanceCase[];

package/dist/common/integration-trigger.js

@@ -18,32 +18,106 @@ function t(n, r) {
 	return n !== n && r !== r;
 }
 //#endregion
+//#region src/base/common/json.ts
+function n(e) {
+	if (e === null || typeof e == "boolean" || typeof e == "string") return !0;
+	if (typeof e == "number") return Number.isFinite(e);
+	if (typeof e != "object") return !1;
+	let t = /* @__PURE__ */ new Set(), n = [], r = e;
+	traversal: for (;;) {
+		let e, i;
+		if (Array.isArray(r)) {
+			if (i = r.length, e = Reflect.ownKeys(r), e.length != i + 1) return !1;
+		} else {
+			let t = Reflect.getPrototypeOf(r);
+			if (t != Object.prototype && t != null) return !1;
+			e = Reflect.ownKeys(r), i = void 0;
+		}
+		t.add(r);
+		let a = 0;
+		for (;;) {
+			if (a >= e.length) {
+				t.delete(r);
+				let o = n.pop();
+				if (o === void 0) return !0;
+				r = o.value, e = o.keys, i = o.arrayLength, a = o.index;
+				continue;
+			}
+			let o = e[a++];
+			if (i !== void 0) {
+				if (o == "length") continue;
+				if (typeof o != "string") return !1;
+				let e = Number(o);
+				if (!Number.isSafeInteger(e) || e < 0 || e >= i || String(e) != o) return !1;
+			} else if (typeof o != "string") return !1;
+			let s = Reflect.getOwnPropertyDescriptor(r, o);
+			if (s?.enumerable != 1 || !Object.hasOwn(s, "value")) return !1;
+			let c = s.value;
+			if (c !== null && typeof c != "boolean" && typeof c != "string") {
+				if (typeof c == "number") {
+					if (!Number.isFinite(c)) return !1;
+					continue;
+				}
+				if (typeof c != "object" || t.has(c)) return !1;
+				n.push({
+					value: r,
+					keys: e,
+					arrayLength: i,
+					index: a
+				}), r = c;
+				continue traversal;
+			}
+		}
+	}
+}
+function r(e) {
+	try {
+		return n(e);
+	} catch {
+		return !1;
+	}
+}
+function i(e) {
+	try {
+		return typeof e == "object" && !!e && !Array.isArray(e) && n(e);
+	} catch {
+		return !1;
+	}
+}
+//#endregion
 //#region src/trigger/common/integration.ts
-var n = 65536, r = 5, i = /^\/v1\/integrations\/(endpoint_[0-9a-f]{32})$/, a = new TextEncoder(), o = class extends Error {
+var a = 65536, o = 5, s = /^\/v1\/integrations\/(endpoint_[0-9a-f]{32})$/, c = new TextEncoder();
+function l(e) {
+	if (!i(e) || e.checkpoint == null || !r(e.checkpoint) || typeof e.hasMore != "boolean") throw TypeError("Listener page must contain a JSON checkpoint and a boolean hasMore.");
+	if (typeof e.dedupeKey != "string" || e.dedupeKey.length == 0 || c.encode(e.dedupeKey).byteLength > 1024) throw TypeError("Listener page identity must contain between 1 and 1024 bytes.");
+	if (e.outputs !== null && !i(e.outputs)) throw TypeError("Listener page outputs must be an object or null.");
+	if (c.encode(JSON.stringify(e.checkpoint)).byteLength > 65536) throw TypeError("Listener checkpoint exceeds 64 KiB.");
+}
+var u = class extends Error {
 	constructor(...e) {
 		super(...e), this.name = "IntegrationConnectionError";
 	}
-}, s = class extends Error {
+}, d = class extends Error {
 	constructor(...e) {
 		super(...e), this.name = "PermanentIntegrationError";
 	}
-}, c = class extends Error {
+}, f = class extends Error {
 	constructor(...e) {
 		super(...e), this.name = "TransientIntegrationError";
 	}
 };
-function l(e) {
-	return i.exec(e.pathname)?.[1];
+function p(e) {
+	return s.exec(e.pathname)?.[1];
 }
-async function u(e, t) {
+async function m(e, t) {
 	if (e == null || e.length == 0) throw TypeError("Integration callback key is required.");
-	let n = await crypto.subtle.importKey("raw", a.encode(e), {
+	let n = await crypto.subtle.importKey("raw", c.encode(e), {
 		hash: "SHA-256",
 		name: "HMAC"
-	}, !1, ["sign"]), r = new Uint8Array(await crypto.subtle.sign("HMAC", n, a.encode(`open-flow-integration/v1/${t}`)));
+	}, !1, ["sign"]), r = new Uint8Array(await crypto.subtle.sign("HMAC", n, c.encode(`open-flow-integration/v1/${t}`)));
 	return btoa(String.fromCharCode(...r)).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
 }
-async function d(e, t, n, r) {
+async function h(e, t, n, r) {
 	if (r == null) return `integration_${crypto.randomUUID().replaceAll("-", "")}`;
 	let i = JSON.stringify([
 		1,
@@ -53,9 +127,9 @@ async function d(e, t, n, r) {
 		n,
 		r
 	]);
-	return [...new Uint8Array(await crypto.subtle.digest("SHA-256", a.encode(i)))].map((e) => e.toString(16).padStart(2, "0")).join("");
+	return [...new Uint8Array(await crypto.subtle.digest("SHA-256", c.encode(i)))].map((e) => e.toString(16).padStart(2, "0")).join("");
 }
-var f = {
+var g = {
 	config: { source: "primary" },
 	connectionId: "connection-primary",
 	definition: {
@@ -70,7 +144,7 @@ var f = {
 				outcome: "respond",
 				status: 404
 			};
-			let t = _(e.payload);
+			let t = C(e.payload);
 			if (t?.action == "handshake") return {
 				body: "accepted",
 				contentType: "text/plain",
@@ -83,50 +157,50 @@ var f = {
 				reason: "Conformance delivery was ignored."
 			};
 			if (t?.action == "pages") {
-				let n = _(e.state?.checkpoint), r = typeof n?.page == "number" ? n.page + 1 : 1, i = typeof t.pages == "number" ? t.pages : 1, a = typeof t.deliveryId == "string" ? t.deliveryId : "pages";
+				let n = C(e.state?.checkpoint), r = typeof n?.page == "number" ? n.page + 1 : 1, i = typeof t.pages == "number" ? t.pages : 1, a = typeof t.deliveryId == "string" ? t.deliveryId : "pages";
 				return {
 					checkpoint: { page: r },
 					continue: r < i,
 					dedupeKey: `${a}:${r}`,
 					outcome: "event",
-					payload: {
+					outputs: { payload: {
 						body: { page: r },
 						deliveryId: a,
 						event: "conformance"
-					}
+					} }
 				};
 			}
-			let n = typeof t?.deliveryId == "string" ? t.deliveryId : "delivery", r = _(t?.body) ?? {};
+			let n = typeof t?.deliveryId == "string" ? t.deliveryId : "delivery", r = C(t?.body) ?? {};
 			return {
 				checkpoint: { deliveryId: n },
 				dedupeKey: n,
 				outcome: "event",
-				payload: {
+				outputs: { payload: {
 					body: r,
 					deliveryId: n,
 					event: "conformance"
-				}
+				} }
 			};
 		},
 		async reconcile(e) {
-			if (e.state == null) throw new s("Conformance Integration state is missing.");
+			if (e.state == null) throw new d("Conformance Integration state is missing.");
 			return await e.state.saveSubscription(e.active ? { endpointUrl: e.endpointUrl } : {}, new Date(e.now.getTime() + 6e4)), { outcome: "ready" };
 		}
 	},
 	publishedAt: "2026-08-21T00:00:30.000Z"
-}, p = [
+}, _ = [
 	{
-		fixture: f,
+		fixture: g,
 		name: "enforces callback routing, method, body, and handshake boundaries",
 		async verify(e) {
 			let t = new URL(e.endpointUrl);
-			await v(await m(e, { url: new URL("/v1/integrations/not-an-endpoint", t).href }), { status: 404 }, "Malformed endpoint"), await v(await m(e, { url: new URL("/v1/integrations/endpoint_00000000000000000000000000000000", t).href }), { status: 404 }, "Unknown endpoint"), await v(await m(e, { method: "GET" }), {
+			await w(await b(e, { url: new URL("/v1/integrations/not-an-endpoint", t).href }), { status: 404 }, "Malformed endpoint"), await w(await b(e, { url: new URL("/v1/integrations/endpoint_00000000000000000000000000000000", t).href }), { status: 404 }, "Unknown endpoint"), await w(await b(e, { method: "GET" }), {
 				headers: { allow: "POST" },
 				status: 405
-			}, "Method"), await v(await m(e, { body: "{" }), { status: 400 }, "Invalid JSON"), await v(await m(e, {
+			}, "Method"), await w(await b(e, { body: "{" }), { status: 400 }, "Invalid JSON"), await w(await b(e, {
 				body: "a=1",
 				headers: { "content-type": "application/x-www-form-urlencoded" }
-			}), { status: 400 }, "Unsupported body format"), await v(await m(e, { body: "x".repeat(65537) }), { status: 413 }, "Oversized body"), await v(await h(e, { action: "handshake" }), {
+			}), { status: 400 }, "Unsupported body format"), await w(await b(e, { body: "x".repeat(65537) }), { status: 413 }, "Oversized body"), await w(await x(e, { action: "handshake" }), {
 				body: "accepted",
 				headers: {
 					"content-type": "text/plain",
@@ -137,18 +211,18 @@ var f = {
 		}
 	},
 	{
-		fixture: f,
+		fixture: g,
 		name: "verifies initializing callbacks before activating the subscription",
 		async verify(e) {
-			await v(await h(e, {
+			await w(await x(e, {
 				action: "event",
 				body: { value: "before" },
 				deliveryId: "before"
-			}, !1), { status: 404 }, "Secret"), await v(await h(e, {
+			}, !1), { status: 404 }, "Secret"), await w(await x(e, {
 				action: "event",
 				body: { value: "before" },
 				deliveryId: "before"
-			}), { status: 202 }, "Initializing delivery"), g(await e.state(), {
+			}), { status: 202 }, "Initializing delivery"), S(await e.state(), {
 				checkpoint: null,
 				health: "initializing",
 				payloads: [],
@@ -156,7 +230,7 @@ var f = {
 				reconcileCalls: 0,
 				runtimeVersion: 1,
 				subscription: {}
-			}, "Initializing state"), await e.reconcile("2026-08-21T00:00:31.000Z"), g(await e.state(), {
+			}, "Initializing state"), await e.reconcile("2026-08-21T00:00:31.000Z"), S(await e.state(), {
 				checkpoint: null,
 				health: "healthy",
 				payloads: [],
@@ -168,7 +242,7 @@ var f = {
 		}
 	},
 	{
-		fixture: f,
+		fixture: g,
 		name: "deduplicates keyed events and rejects conflicting payloads",
 		async verify(e) {
 			await e.reconcile("2026-08-21T00:00:31.000Z");
@@ -177,12 +251,12 @@ var f = {
 				body: { value: "first" },
 				deliveryId: "delivery-1"
 			};
-			await v(await h(e, t), { status: 202 }, "Initial event"), await v(await h(e, t), { status: 202 }, "Repeated event"), await v(await h(e, {
+			await w(await x(e, t), { status: 202 }, "Initial event"), await w(await x(e, t), { status: 202 }, "Repeated event"), await w(await x(e, {
 				...t,
 				body: { value: "changed" }
 			}), { status: 409 }, "Conflicting event");
 			let n = await e.state();
-			g(n.checkpoint, { deliveryId: "delivery-1" }, "Event checkpoint"), g(n.payloads, [{
+			S(n.checkpoint, { deliveryId: "delivery-1" }, "Event checkpoint"), S(n.payloads, [{
 				body: { value: "first" },
 				deliveryId: "delivery-1",
 				event: "conformance"
@@ -190,7 +264,7 @@ var f = {
 		}
 	},
 	{
-		fixture: f,
+		fixture: g,
 		name: "bounds callback pages and resumes from the durable checkpoint",
 		async verify(e) {
 			await e.reconcile("2026-08-21T00:00:31.000Z");
@@ -199,26 +273,26 @@ var f = {
 				deliveryId: "delivery-pages",
 				pages: 7
 			};
-			await v(await h(e, t), { status: 202 }, "First page batch");
+			await w(await x(e, t), { status: 202 }, "First page batch");
 			let n = await e.state();
-			g(n.checkpoint, { page: 5 }, "Bounded checkpoint"), g(n.payloads.length, 5, "Bounded payload count"), await v(await h(e, t), { status: 202 }, "Resumed page batch"), n = await e.state(), g(n.checkpoint, { page: 7 }, "Resumed checkpoint"), g(n.payloads.length, 7, "Resumed payload count");
+			S(n.checkpoint, { page: 5 }, "Bounded checkpoint"), S(n.payloads.length, 5, "Bounded payload count"), await w(await x(e, t), { status: 202 }, "Resumed page batch"), n = await e.state(), S(n.checkpoint, { page: 7 }, "Resumed checkpoint"), S(n.payloads.length, 7, "Resumed payload count");
 		}
 	},
 	{
-		fixture: f,
+		fixture: g,
 		name: "restores subscription state and callback admission after restart",
 		async verify(e) {
-			await e.reconcile("2026-08-21T00:00:31.000Z"), await h(e, {
+			await e.reconcile("2026-08-21T00:00:31.000Z"), await x(e, {
 				action: "event",
 				body: { value: "before" },
 				deliveryId: "before"
-			}), await e.restart(), await h(e, {
+			}), await e.restart(), await x(e, {
 				action: "event",
 				body: { value: "after" },
 				deliveryId: "after"
 			});
 			let t = await e.state();
-			g(t.checkpoint, { deliveryId: "after" }, "Restart checkpoint"), g(t.payloads, [{
+			S(t.checkpoint, { deliveryId: "after" }, "Restart checkpoint"), S(t.payloads, [{
 				body: { value: "before" },
 				deliveryId: "before",
 				event: "conformance"
@@ -230,7 +304,7 @@ var f = {
 		}
 	},
 	{
-		fixture: f,
+		fixture: g,
 		name: "retires the old runtime before activating a republished target",
 		async verify(e) {
 			await e.reconcile("2026-08-21T00:00:31.000Z");
@@ -239,28 +313,90 @@ var f = {
 				body: { value: "event" },
 				deliveryId: "same-delivery"
 			};
-			await h(e, t);
+			await x(e, t);
 			let n = e.endpointUrl;
-			await e.republish("2026-08-21T00:00:40.000Z"), g(e.endpointUrl, n, "Republished endpoint"), await v(await h(e, t), { status: 202 }, "Old runtime delivery"), g((await e.state()).payloads.length, 1, "Old runtime payload count"), await e.reconcile("2026-08-21T00:00:41.000Z"), await v(await h(e, t), { status: 202 }, "New runtime delivery");
+			await e.republish("2026-08-21T00:00:40.000Z"), S(e.endpointUrl, n, "Republished endpoint"), await w(await x(e, t), { status: 202 }, "Old runtime delivery"), S((await e.state()).payloads.length, 1, "Old runtime payload count"), await e.reconcile("2026-08-21T00:00:41.000Z"), await w(await x(e, t), { status: 202 }, "New runtime delivery");
 			let r = await e.state();
-			g(r.runtimeVersion, 2, "Republished runtime"), g(r.health, "healthy", "Republished health"), g(r.payloads.length, 2, "Republished payload count");
+			S(r.runtimeVersion, 2, "Republished runtime"), S(r.health, "healthy", "Republished health"), S(r.payloads.length, 2, "Republished payload count");
 		}
 	},
 	{
-		fixture: f,
+		fixture: g,
 		name: "retires the remote subscription and rejects later callbacks",
 		async verify(e) {
-			await e.reconcile("2026-08-21T00:00:31.000Z"), await e.retire("2026-08-21T00:00:40.000Z"), await v(await h(e, {
+			await e.reconcile("2026-08-21T00:00:31.000Z"), await e.retire("2026-08-21T00:00:40.000Z"), await w(await x(e, {
 				action: "event",
 				deliveryId: "retired"
-			}), { status: 404 }, "Retired callback"), await e.reconcile("2026-08-21T00:00:41.000Z"), await v(await h(e, {
+			}), { status: 404 }, "Retired callback"), await e.reconcile("2026-08-21T00:00:41.000Z"), await w(await x(e, {
 				action: "event",
 				deliveryId: "retired"
-			}), { status: 404 }, "Reconciled retirement"), g((await e.state()).payloads, [], "Retired payloads");
+			}), { status: 404 }, "Reconciled retirement"), S((await e.state()).payloads, [], "Retired payloads");
+		}
+	}
+], v = {
+	...g,
+	definition: {
+		initialState: {
+			checkpoint: null,
+			subscription: {}
+		},
+		async reconcile({ active: e, state: t, now: n }) {
+			return e && t?.checkpoint == null && await t.saveCheckpoint(0), e && await t.saveSubscription({}, new Date(n.getTime() + 36e5)), { outcome: "ready" };
+		},
+		receive(e) {
+			return e.header("x-integration-secret") == e.callbackSecret ? { outcome: "wake" } : {
+				outcome: "respond",
+				status: 404,
+				body: "",
+				contentType: "text/plain"
+			};
+		},
+		listener: {
+			intervalMs: 6e4,
+			async read({ checkpoint: e, now: t }) {
+				let n = Number(e), r = t.getTime() >= Date.parse("2026-08-21T00:01:31.000Z") ? 8 : 7;
+				return n < r ? {
+					checkpoint: n + 1,
+					dedupeKey: String(n),
+					hasMore: n + 1 < r,
+					outputs: { payload: {
+						body: {},
+						deliveryId: String(n),
+						event: "change"
+					} }
+				} : {
+					checkpoint: e,
+					dedupeKey: String(n),
+					hasMore: !1,
+					outputs: null
+				};
+			}
+		}
+	}
+}, y = [
+	{
+		fixture: v,
+		name: "drains listener pages without a callback and resumes periodic scanning after restart",
+		async verify(e) {
+			await e.reconcile("2026-08-21T00:00:31.000Z"), S((await e.state()).checkpoint, 7, "Drained cursor"), S((await e.state()).payloads.length, 7, "Drained pages"), await e.restart(), await e.reconcile("2026-08-21T00:01:31.000Z"), S((await e.state()).checkpoint, 8, "Periodic cursor"), S((await e.state()).payloads.length, 8, "Periodic pages");
+		}
+	},
+	{
+		fixture: v,
+		name: "persists verified listener wakes across restart without duplicating accepted pages",
+		async verify(e) {
+			await e.reconcile("2026-08-21T00:00:31.000Z"), await w(await x(e, {}, !1), { status: 404 }, "Invalid wake"), await w(await x(e, {}), { status: 202 }, "First wake"), await w(await x(e, {}), { status: 202 }, "Duplicate wake"), await e.restart(), await e.reconcile("2026-08-21T00:00:32.000Z"), S((await e.state()).checkpoint, 7, "Retained cursor"), S((await e.state()).payloads.length, 7, "Deduplicated pages");
+		}
+	},
+	{
+		fixture: v,
+		name: "preserves a listener cursor on unchanged publication and fences retirement",
+		async verify(e) {
+			await e.reconcile("2026-08-21T00:00:31.000Z"), await e.republish("2026-08-21T00:00:40.000Z"), S((await e.state()).checkpoint, 7, "Republished cursor"), await e.reconcile("2026-08-21T00:01:31.000Z"), S((await e.state()).payloads.length, 8, "Republished pages"), await e.retire("2026-08-21T00:01:40.000Z"), await w(await x(e, {}), { status: 404 }, "Retired wake"), await e.reconcile("2026-08-21T00:02:40.000Z"), S((await e.state()).payloads.length, 8, "Retired pages");
 		}
 	}
 ];
-function m(e, t = {}) {
+function b(e, t = {}) {
 	return e.request(new Request(t.url ?? e.endpointUrl, {
 		...t.body == null ? {} : { body: t.body },
 		headers: {
@@ -270,21 +406,21 @@ function m(e, t = {}) {
 		method: t.method ?? "POST"
 	}));
 }
-function h(e, t, n = !0) {
-	return m(e, {
+function x(e, t, n = !0) {
+	return b(e, {
 		body: JSON.stringify(t),
 		headers: n ? { "x-integration-secret": e.callbackSecret } : {}
 	});
 }
-function g(e, n, r) {
+function S(e, n, r) {
 	if (!t(e, n)) throw Error(`${r}: expected ${JSON.stringify(n)}, received ${JSON.stringify(e)}.`);
 }
-function _(e) {
+function C(e) {
 	return typeof e == "object" && e && !Array.isArray(e) ? e : void 0;
 }
-async function v(e, t, n) {
-	g(e.status, t.status, `${n} status`), t.body != null && g(await e.text(), t.body, `${n} body`);
-	for (let [r, i] of Object.entries(t.headers ?? {})) g(e.headers.get(r), i, `${n} header ${r}`);
+async function w(e, t, n) {
+	S(e.status, t.status, `${n} status`), t.body != null && S(await e.text(), t.body, `${n} body`);
+	for (let [r, i] of Object.entries(t.headers ?? {})) S(e.headers.get(r), i, `${n} header ${r}`);
 }
 //#endregion
-export { o as IntegrationConnectionError, s as PermanentIntegrationError, c as TransientIntegrationError, u as integrationCallbackSecret, p as integrationConformanceCases, l as integrationEndpointId, d as integrationOccurrenceId, n as maximumIntegrationBodyBytes, r as maximumIntegrationDeliveryPages };
+export { u as IntegrationConnectionError, d as PermanentIntegrationError, f as TransientIntegrationError, m as integrationCallbackSecret, _ as integrationConformanceCases, p as integrationEndpointId, h as integrationOccurrenceId, y as listenerConformanceCases, a as maximumIntegrationBodyBytes, o as maximumIntegrationDeliveryPages, l as validateListenerPage };