@oomol-lab/open-flow 0.1.0-alpha.0

package/dist/common/engine-contract.d.ts

@@ -0,0 +1,7 @@
+export interface EngineContract {
+    readonly platformExports: ReadonlySet<string>;
+    readonly platformModule: string;
+    readonly platformSource: string;
+}
+export declare const currentEngineContract = "open-flow-engine/v1";
+export declare function findEngineContract(contract: string): EngineContract | undefined;

package/dist/common/favicon.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <style>
+    path { fill: #24292f; }
+    @media (prefers-color-scheme: dark) { path { fill: #f0f3f6; } }
+  </style>
+  <path d="M9.5 8h10.6a5 5 0 1 0 0-2H9.5a5.5 5.5 0 0 0 0 11h11a3.5 3.5 0 0 1 0 7h-8.6a5 5 0 1 0 0 2h8.6a5.5 5.5 0 0 0 0-11h-11a3.5 3.5 0 0 1 0-7zM25 4a3 3 0 1 1-3 3 3 3 0 0 1 3-3zM7 28a3 3 0 1 1 3-3 3 3 0 0 1-3 3z" />
+</svg>

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

@@ -0,0 +1,111 @@
+import type { ConnectorProxy } from './connector-proxy.js';
+import type { IntegrationEndpointMethod, JsonValue, TriggerKeySnapshot } from '../browser/project-change.js';
+export declare const maximumIntegrationBodyBytes: number;
+export declare const maximumIntegrationDeliveryPages = 5;
+export type IntegrationReceiveResult = {
+    readonly checkpoint?: JsonValue;
+    readonly continue?: boolean;
+    readonly dedupeKey?: string;
+    readonly outcome: 'event';
+    readonly payload: Readonly<Record<string, JsonValue>>;
+} | {
+    readonly checkpoint?: JsonValue;
+    readonly continue?: boolean;
+    readonly outcome: 'ignored';
+    readonly reason: string;
+} | {
+    readonly body: string;
+    readonly contentType: string;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly outcome: 'respond';
+    readonly status: number;
+};
+export interface IntegrationStateContext {
+    readonly checkpoint: JsonValue;
+    readonly subscription: Readonly<Record<string, JsonValue>>;
+    readonly saveCheckpoint: (checkpoint: JsonValue) => Promise<void>;
+    readonly saveSubscription: (subscription: Readonly<Record<string, JsonValue>>, reconcileAt: Date) => Promise<void>;
+}
+export interface IntegrationReceiveContext {
+    readonly admit: boolean;
+    readonly allow?: () => Promise<boolean>;
+    readonly bindingId: string;
+    readonly callbackSecret: string;
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly connector: ConnectorProxy;
+    readonly current: boolean;
+    readonly header: (name: string) => string | undefined;
+    readonly method: IntegrationEndpointMethod;
+    readonly now: Date;
+    readonly payload: JsonValue;
+    readonly query: (name: string) => string | undefined;
+    readonly state?: IntegrationStateContext;
+}
+export interface IntegrationReconcileContext {
+    readonly active: boolean;
+    readonly callbackSecret: string;
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly connector: ConnectorProxy;
+    readonly endpointUrl: string;
+    readonly now: Date;
+    readonly signal?: AbortSignal;
+    readonly state?: IntegrationStateContext;
+}
+export interface IntegrationReconcileResult {
+    readonly outcome: 'pending' | 'ready';
+}
+export interface IntegrationDefinition {
+    readonly initialState?: {
+        readonly checkpoint: JsonValue;
+        readonly subscription: Readonly<Record<string, JsonValue>>;
+    };
+    readonly receive: (context: IntegrationReceiveContext) => IntegrationReceiveResult | Promise<IntegrationReceiveResult>;
+    readonly reconcile: (context: IntegrationReconcileContext) => Promise<IntegrationReconcileResult>;
+    readonly snapshot: TriggerKeySnapshot & {
+        readonly type: 'integration';
+    };
+}
+export declare class IntegrationConnectionError extends Error {
+    readonly name = "IntegrationConnectionError";
+}
+export declare class PermanentIntegrationError extends Error {
+    readonly name = "PermanentIntegrationError";
+}
+export declare class TransientIntegrationError extends Error {
+    readonly name = "TransientIntegrationError";
+}
+export declare function integrationEndpointId(url: URL): string | undefined;
+export declare function integrationCallbackSecret(callbackKey: string | undefined, endpointId: string): Promise<string>;
+export declare function integrationOccurrenceId(bindingId: string, runtimeVersion: number, definitionKey: string, dedupeKey: string | null): Promise<string>;
+export interface IntegrationConformanceFixture {
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly connectionId: string;
+    readonly definition: Pick<IntegrationDefinition, 'initialState' | 'receive' | 'reconcile'>;
+    readonly publishedAt: string;
+}
+export interface IntegrationConformanceState {
+    readonly checkpoint: JsonValue | null;
+    readonly health: 'healthy' | 'initializing';
+    readonly payloads: readonly JsonValue[];
+    readonly receiveCalls: number;
+    readonly reconcileCalls: number;
+    readonly runtimeVersion: number;
+    readonly subscription: Readonly<Record<string, JsonValue>> | null;
+}
+export interface IntegrationConformanceHarness {
+    readonly callbackSecret: string;
+    readonly endpointUrl: string;
+    dispose(): Promise<void>;
+    reconcile(at: string): Promise<void>;
+    republish(at: string): Promise<void>;
+    request(request: Request): Promise<Response>;
+    restart(): Promise<void>;
+    retire(at: string): Promise<void>;
+    state(): Promise<IntegrationConformanceState>;
+}
+export interface IntegrationConformanceCase {
+    readonly fixture: IntegrationConformanceFixture;
+    readonly name: string;
+    verify(harness: IntegrationConformanceHarness): Promise<void>;
+}
+export declare const integrationConformanceCases: readonly IntegrationConformanceCase[];

package/dist/common/integration-trigger.js

@@ -0,0 +1,290 @@
+//#region ../../node_modules/dequal/lite/index.mjs
+var e = Object.prototype.hasOwnProperty;
+function t(n, r) {
+	var i, a;
+	if (n === r) return !0;
+	if (n && r && (i = n.constructor) === r.constructor) {
+		if (i === Date) return n.getTime() === r.getTime();
+		if (i === RegExp) return n.toString() === r.toString();
+		if (i === Array) {
+			if ((a = n.length) === r.length) for (; a-- && t(n[a], r[a]););
+			return a === -1;
+		}
+		if (!i || typeof n == "object") {
+			for (i in a = 0, n) if (e.call(n, i) && ++a && !e.call(r, i) || !(i in r) || !t(n[i], r[i])) return !1;
+			return Object.keys(r).length === a;
+		}
+	}
+	return n !== n && r !== r;
+}
+//#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 {
+	constructor(...e) {
+		super(...e), this.name = "IntegrationConnectionError";
+	}
+}, s = class extends Error {
+	constructor(...e) {
+		super(...e), this.name = "PermanentIntegrationError";
+	}
+}, c = class extends Error {
+	constructor(...e) {
+		super(...e), this.name = "TransientIntegrationError";
+	}
+};
+function l(e) {
+	return i.exec(e.pathname)?.[1];
+}
+async function u(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), {
+		hash: "SHA-256",
+		name: "HMAC"
+	}, !1, ["sign"]), r = new Uint8Array(await crypto.subtle.sign("HMAC", n, a.encode(`open-flow-integration/v1/${t}`)));
+	return btoa(String.fromCharCode(...r)).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+async function d(e, t, n, r) {
+	if (r == null) return `integration_${crypto.randomUUID().replaceAll("-", "")}`;
+	let i = JSON.stringify([
+		1,
+		"integration-occurrence",
+		e,
+		t,
+		n,
+		r
+	]);
+	return [...new Uint8Array(await crypto.subtle.digest("SHA-256", a.encode(i)))].map((e) => e.toString(16).padStart(2, "0")).join("");
+}
+var f = {
+	config: { source: "primary" },
+	connectionId: "connection-primary",
+	definition: {
+		initialState: {
+			checkpoint: null,
+			subscription: {}
+		},
+		receive(e) {
+			if (e.header("x-integration-secret") != e.callbackSecret) return {
+				body: "",
+				contentType: "text/plain",
+				outcome: "respond",
+				status: 404
+			};
+			let t = _(e.payload);
+			if (t?.action == "handshake") return {
+				body: "accepted",
+				contentType: "text/plain",
+				headers: { "x-integration-response": "conformance" },
+				outcome: "respond",
+				status: 201
+			};
+			if (t?.action == "ignored") return {
+				outcome: "ignored",
+				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";
+				return {
+					checkpoint: { page: r },
+					continue: r < i,
+					dedupeKey: `${a}:${r}`,
+					outcome: "event",
+					payload: {
+						body: { page: r },
+						deliveryId: a,
+						event: "conformance"
+					}
+				};
+			}
+			let n = typeof t?.deliveryId == "string" ? t.deliveryId : "delivery", r = _(t?.body) ?? {};
+			return {
+				checkpoint: { deliveryId: n },
+				dedupeKey: n,
+				outcome: "event",
+				payload: {
+					body: r,
+					deliveryId: n,
+					event: "conformance"
+				}
+			};
+		},
+		async reconcile(e) {
+			if (e.state == null) throw new s("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,
+		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" }), {
+				headers: { allow: "POST" },
+				status: 405
+			}, "Method"), await v(await m(e, { body: "{" }), { status: 400 }, "Invalid JSON"), await v(await m(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" }), {
+				body: "accepted",
+				headers: {
+					"content-type": "text/plain",
+					"x-integration-response": "conformance"
+				},
+				status: 201
+			}, "Handshake");
+		}
+	},
+	{
+		fixture: f,
+		name: "verifies initializing callbacks before activating the subscription",
+		async verify(e) {
+			await v(await h(e, {
+				action: "event",
+				body: { value: "before" },
+				deliveryId: "before"
+			}, !1), { status: 404 }, "Secret"), await v(await h(e, {
+				action: "event",
+				body: { value: "before" },
+				deliveryId: "before"
+			}), { status: 202 }, "Initializing delivery"), g(await e.state(), {
+				checkpoint: null,
+				health: "initializing",
+				payloads: [],
+				receiveCalls: 2,
+				reconcileCalls: 0,
+				runtimeVersion: 1,
+				subscription: {}
+			}, "Initializing state"), await e.reconcile("2026-08-21T00:00:31.000Z"), g(await e.state(), {
+				checkpoint: null,
+				health: "healthy",
+				payloads: [],
+				receiveCalls: 2,
+				reconcileCalls: 1,
+				runtimeVersion: 1,
+				subscription: { endpointUrl: e.endpointUrl }
+			}, "Active subscription");
+		}
+	},
+	{
+		fixture: f,
+		name: "deduplicates keyed events and rejects conflicting payloads",
+		async verify(e) {
+			await e.reconcile("2026-08-21T00:00:31.000Z");
+			let t = {
+				action: "event",
+				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, {
+				...t,
+				body: { value: "changed" }
+			}), { status: 409 }, "Conflicting event");
+			let n = await e.state();
+			g(n.checkpoint, { deliveryId: "delivery-1" }, "Event checkpoint"), g(n.payloads, [{
+				body: { value: "first" },
+				deliveryId: "delivery-1",
+				event: "conformance"
+			}], "Event payloads");
+		}
+	},
+	{
+		fixture: f,
+		name: "bounds callback pages and resumes from the durable checkpoint",
+		async verify(e) {
+			await e.reconcile("2026-08-21T00:00:31.000Z");
+			let t = {
+				action: "pages",
+				deliveryId: "delivery-pages",
+				pages: 7
+			};
+			await v(await h(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");
+		}
+	},
+	{
+		fixture: f,
+		name: "restores subscription state and callback admission after restart",
+		async verify(e) {
+			await e.reconcile("2026-08-21T00:00:31.000Z"), await h(e, {
+				action: "event",
+				body: { value: "before" },
+				deliveryId: "before"
+			}), await e.restart(), await h(e, {
+				action: "event",
+				body: { value: "after" },
+				deliveryId: "after"
+			});
+			let t = await e.state();
+			g(t.checkpoint, { deliveryId: "after" }, "Restart checkpoint"), g(t.payloads, [{
+				body: { value: "before" },
+				deliveryId: "before",
+				event: "conformance"
+			}, {
+				body: { value: "after" },
+				deliveryId: "after",
+				event: "conformance"
+			}], "Restart payloads");
+		}
+	},
+	{
+		fixture: f,
+		name: "retires the old runtime before activating a republished target",
+		async verify(e) {
+			await e.reconcile("2026-08-21T00:00:31.000Z");
+			let t = {
+				action: "event",
+				body: { value: "event" },
+				deliveryId: "same-delivery"
+			};
+			await h(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");
+			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");
+		}
+	},
+	{
+		fixture: f,
+		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, {
+				action: "event",
+				deliveryId: "retired"
+			}), { status: 404 }, "Retired callback"), await e.reconcile("2026-08-21T00:00:41.000Z"), await v(await h(e, {
+				action: "event",
+				deliveryId: "retired"
+			}), { status: 404 }, "Reconciled retirement"), g((await e.state()).payloads, [], "Retired payloads");
+		}
+	}
+];
+function m(e, t = {}) {
+	return e.request(new Request(t.url ?? e.endpointUrl, {
+		...t.body == null ? {} : { body: t.body },
+		headers: {
+			...t.body == null ? {} : { "content-type": "application/json" },
+			...t.headers
+		},
+		method: t.method ?? "POST"
+	}));
+}
+function h(e, t, n = !0) {
+	return m(e, {
+		body: JSON.stringify(t),
+		headers: n ? { "x-integration-secret": e.callbackSecret } : {}
+	});
+}
+function g(e, n, r) {
+	if (!t(e, n)) throw Error(`${r}: expected ${JSON.stringify(n)}, received ${JSON.stringify(e)}.`);
+}
+function _(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}`);
+}
+//#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 };

package/dist/common/licenses.md

@@ -0,0 +1,27 @@
+# Licenses
+
+The app bundles dependencies which contain the following licenses:
+
+## dequal - 2.0.3 (MIT)
+
+The MIT License (MIT)
+
+Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

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

@@ -0,0 +1,69 @@
+import type { ConnectorProxy } from './connector-proxy.js';
+import type { JsonValue, TriggerKeySnapshot, TriggerSchedule } from '../browser/project-change.js';
+export declare const maximumPollCheckpointBytes: number;
+export declare const maximumPollDedupeKeyBytes = 1024;
+export declare const maximumPollEventsPerPage = 100;
+export interface PollEvent {
+    readonly dedupeKey: string;
+    readonly payload: Readonly<Record<string, JsonValue>>;
+}
+export interface PollResult {
+    readonly checkpoint: JsonValue;
+    readonly events: readonly PollEvent[];
+    readonly filtered?: number;
+    readonly hasMore?: boolean;
+}
+export interface PollContext {
+    readonly checkpoint: JsonValue;
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly connector: ConnectorProxy;
+    readonly now: Date;
+    readonly signal?: AbortSignal;
+}
+export interface PollDefinition {
+    readonly poll: (context: PollContext) => Promise<PollResult>;
+    readonly snapshot: TriggerKeySnapshot & {
+        readonly type: 'poll';
+    };
+}
+export declare class PollConnectionError extends Error {
+    readonly name = "PollConnectionError";
+}
+export declare class PermanentPollError extends Error {
+    readonly name = "PermanentPollError";
+}
+export declare class TransientPollError extends Error {
+    readonly name = "TransientPollError";
+}
+export declare function pollPageClaimId(bindingId: string, runtimeVersion: number, rootOccurrenceId: string, page: number): Promise<string>;
+export declare function providerEventId(bindingId: string, triggerKey: string, dedupeKey: string): Promise<string>;
+export interface PollConformanceFixture {
+    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly connectionId: string;
+    readonly publishedAt: string;
+    readonly rules: readonly TriggerSchedule[];
+}
+export interface PollConformanceState {
+    readonly calls: number;
+    readonly checkpoint: JsonValue;
+    readonly health: 'healthy' | 'initializing';
+    readonly payloads: readonly JsonValue[];
+}
+export interface PollConformanceHarness {
+    dispose(): Promise<void>;
+    replayLast(): Promise<void>;
+    republish(at: string, change?: {
+        readonly config?: Readonly<Record<string, JsonValue>>;
+        readonly connectionId?: string;
+    }): Promise<void>;
+    restart(): Promise<void>;
+    retire(at: string): Promise<void>;
+    state(): Promise<PollConformanceState>;
+    tick(at: string, pages: readonly PollResult[]): Promise<void>;
+}
+export interface PollConformanceCase {
+    readonly fixture: PollConformanceFixture;
+    readonly name: string;
+    verify(harness: PollConformanceHarness): Promise<void>;
+}
+export declare const pollConformanceCases: readonly PollConformanceCase[];

package/dist/common/poll-trigger.js

@@ -0,0 +1,155 @@
+//#region src/trigger/common/poll.ts
+var e = new TextEncoder(), t = 65536, n = 1024, r = 100, i = class extends Error {
+	constructor(...e) {
+		super(...e), this.name = "PollConnectionError";
+	}
+}, a = class extends Error {
+	constructor(...e) {
+		super(...e), this.name = "PermanentPollError";
+	}
+}, o = class extends Error {
+	constructor(...e) {
+		super(...e), this.name = "TransientPollError";
+	}
+};
+async function s(e, t, n, r) {
+	if (!Number.isSafeInteger(r) || r <= 0) throw RangeError("Poll continuation page must be a positive integer.");
+	return await d(`${e}\0${t}\0${n}\0${r}`);
+}
+async function c(t, n, r) {
+	if (e.encode(r).byteLength > 1024) throw RangeError("Poll event dedupe key exceeds 1024 bytes.");
+	return await d(`${t}\0${n}\0${r}`);
+}
+var l = {
+	config: { source: "primary" },
+	connectionId: "connection-primary",
+	publishedAt: "2026-08-21T00:00:30.000Z",
+	rules: [{
+		type: "every",
+		unit: "minute",
+		value: 1
+	}]
+}, u = [
+	{
+		fixture: l,
+		name: "baselines every continuation page before becoming healthy",
+		async verify(e) {
+			await e.tick("2026-08-21T00:01:00.000Z", [{
+				checkpoint: { cursor: "baseline-1" },
+				events: [{
+					dedupeKey: "old-1",
+					payload: { value: "old-1" }
+				}],
+				hasMore: !0
+			}, {
+				checkpoint: { cursor: "baseline-2" },
+				events: [{
+					dedupeKey: "old-2",
+					payload: { value: "old-2" }
+				}]
+			}]), f(await e.state(), {
+				calls: 2,
+				checkpoint: { cursor: "baseline-2" },
+				health: "healthy",
+				payloads: []
+			}, "Baseline state");
+		}
+	},
+	{
+		fixture: l,
+		name: "batches fresh page events and suppresses duplicate identities",
+		async verify(e) {
+			await e.tick("2026-08-21T00:01:00.000Z", [{
+				checkpoint: { cursor: "baseline" },
+				events: []
+			}]);
+			let t = {
+				dedupeKey: "event-1",
+				payload: { value: "first" }
+			};
+			await e.tick("2026-08-21T00:02:00.000Z", [{
+				checkpoint: { cursor: "next" },
+				events: [
+					t,
+					t,
+					{
+						dedupeKey: "event-2",
+						payload: { value: "second" }
+					}
+				]
+			}]), await e.tick("2026-08-21T00:03:00.000Z", [{
+				checkpoint: { cursor: "last" },
+				events: [t]
+			}]), f(await e.state(), {
+				calls: 3,
+				checkpoint: { cursor: "last" },
+				health: "healthy",
+				payloads: [{ events: [{ value: "first" }, { value: "second" }] }]
+			}, "Deduplicated state");
+		}
+	},
+	{
+		fixture: l,
+		name: "replays a completed root across restart without polling again",
+		async verify(e) {
+			await e.tick("2026-08-21T00:01:00.000Z", [{
+				checkpoint: { cursor: "baseline" },
+				events: []
+			}]), await e.tick("2026-08-21T00:02:00.000Z", [{
+				checkpoint: { cursor: "event" },
+				events: [{
+					dedupeKey: "event-1",
+					payload: { value: "first" }
+				}]
+			}]), await e.restart(), await e.replayLast(), f(await e.state(), {
+				calls: 2,
+				checkpoint: { cursor: "event" },
+				health: "healthy",
+				payloads: [{ events: [{ value: "first" }] }]
+			}, "Replayed state");
+		}
+	},
+	{
+		fixture: l,
+		name: "preserves an unchanged checkpoint and baselines changed semantics",
+		async verify(e) {
+			await e.tick("2026-08-21T00:01:00.000Z", [{
+				checkpoint: { cursor: "baseline" },
+				events: []
+			}]), await e.republish("2026-08-21T00:01:30.000Z"), f(await e.state(), {
+				calls: 1,
+				checkpoint: { cursor: "baseline" },
+				health: "healthy",
+				payloads: []
+			}, "Unchanged publication state"), await e.republish("2026-08-21T00:01:40.000Z", { config: { source: "secondary" } }), await e.tick("2026-08-21T00:02:00.000Z", [{
+				checkpoint: { cursor: "secondary-baseline" },
+				events: [{
+					dedupeKey: "old-secondary",
+					payload: { value: "old" }
+				}]
+			}]), f(await e.state(), {
+				calls: 2,
+				checkpoint: { cursor: "secondary-baseline" },
+				health: "healthy",
+				payloads: []
+			}, "Changed publication state"), await e.retire("2026-08-21T00:02:30.000Z"), await e.tick("2026-08-21T00:03:00.000Z", [{
+				checkpoint: { cursor: "retired" },
+				events: []
+			}]), f(await e.state(), {
+				calls: 2,
+				checkpoint: { cursor: "secondary-baseline" },
+				health: "healthy",
+				payloads: []
+			}, "Retired state");
+		}
+	}
+];
+async function d(t) {
+	let n = new Uint8Array(await crypto.subtle.digest("SHA-256", e.encode(t)));
+	return `sha256:${Array.from(n, (e) => e.toString(16).padStart(2, "0")).join("")}`;
+}
+function f(e, t, n) {
+	if (JSON.stringify(e) != JSON.stringify(t)) throw Error(`${n}: expected ${JSON.stringify(t)}, received ${JSON.stringify(e)}.`);
+}
+//#endregion
+export { a as PermanentPollError, i as PollConnectionError, o as TransientPollError, t as maximumPollCheckpointBytes, n as maximumPollDedupeKeyBytes, r as maximumPollEventsPerPage, u as pollConformanceCases, s as pollPageClaimId, c as providerEventId };

package/dist/common/project-encoding.d.ts

@@ -0,0 +1,11 @@
+import type { CodeModule, Graph, InputPortDefinition, JsonValue, OutputMapping, PortDefinition, ProjectDocument, RevisionContent } from '@oomol-lab/open-flow/project-change';
+export declare const maxJsonDepth = 64;
+export declare function canonicalJsonBytes(value: JsonValue): Uint8Array;
+export declare function digestBytes(bytes: Uint8Array): Promise<string>;
+export declare function canonicalPorts(value: Readonly<Record<string, InputPortDefinition | PortDefinition>>): JsonValue;
+export declare function canonicalOutputs(value: Readonly<Record<string, OutputMapping & PortDefinition>>): JsonValue;
+export declare function canonicalGraph(value: Graph): JsonValue;
+export declare function canonicalTask(task: ProjectDocument['tasks'][string]): JsonValue;
+export declare function canonicalDocument(document: ProjectDocument): JsonValue;
+export declare function canonicalModule(module: CodeModule): JsonValue;
+export declare function encodeRevision(content: RevisionContent): Uint8Array;