@party-stack/ontology 0.20.0 → 0.21.0

package/lib/live/outbox/createOntologyOutbox.js

@@ -1,292 +0,0 @@
-import { runOutboxLeader } from "./leaderExecutor.js";
-import { OUTBOX_COORDINATION_SERVICE } from "./service.js";
-import { serveOntologyOutbox } from "./outboxService.js";
-import { OntologyOutboxRepository } from "./repository.js";
-import { OutboxProjectionManager } from "./projectionManager.js";
-import { CoordinationError, createLocalCollection, isCoordinationHost } from "@party-stack/runtime";
-import { cloneValue } from "@party-stack/coordination";
-import { useConnectivityChanges } from "@party-stack/runtime/effection";
-import { createSignal, each, resource, run, spawn, suspend, until, useAbortSignal } from "effection";
-//#region src/live/outbox/createOntologyOutbox.ts
-const DEFAULT_MAX_RETRIES = 3;
-const DEFAULT_RETRY_DELAY_MS = 1e3;
-function nonNegativeInteger(value, fallback, name) {
-	const resolved = value ?? fallback;
-	if (!Number.isSafeInteger(resolved) || resolved < 0) throw new RangeError(`${name} must be a non-negative safe integer.`);
-	return resolved;
-}
-function deferred() {
-	let resolvePromise;
-	let rejectPromise;
-	const value = {
-		promise: void 0,
-		settled: false,
-		resolve(result) {
-			if (value.settled) return;
-			value.settled = true;
-			resolvePromise(result);
-		},
-		reject(error) {
-			if (value.settled) return;
-			value.settled = true;
-			rejectPromise(error);
-		}
-	};
-	value.promise = new Promise((resolve, reject) => {
-		resolvePromise = resolve;
-		rejectPromise = reject;
-	});
-	return value;
-}
-function normalizeError(error) {
-	return error instanceof Error ? error : new Error(String(error));
-}
-function eventError(event) {
-	const error = new Error(event.error.message);
-	error.name = event.error.name;
-	return error;
-}
-function createOutboxCollection(options) {
-	return createLocalCollection({
-		name: "ontology-outbox",
-		getKey: (entry) => entry.id,
-		runtime: options.runtime,
-		schemaVersion: 1
-	});
-}
-function useOntologyOutbox(options, collection = createOutboxCollection(options)) {
-	return resource(function* (provide) {
-		const repository = new OntologyOutboxRepository(collection);
-		const failureStrategy = options.failureStrategy ?? "discard-all";
-		const service = options.runtime.coordination.service(OUTBOX_COORDINATION_SERVICE);
-		const wake = createSignal();
-		const projections = new OutboxProjectionManager(options.project ? async (entry) => options.project?.(entry) : void 0);
-		const completions = /* @__PURE__ */ new Map();
-		const lifetime = {};
-		let disposing = false;
-		let reconciliationVersion = 0;
-		const deliverResult = async (event) => {
-			const completion = completions.get(event.id);
-			if (event.type === "completed") {
-				await projections.discard(event.id);
-				if (completion) {
-					completions.delete(event.id);
-					completion.resolve(event.result);
-				}
-				return;
-			}
-			const error = eventError(event);
-			await projections.discard(event.id, error);
-			if (completion) {
-				completions.delete(event.id);
-				completion.reject(error);
-			}
-		};
-		try {
-			lifetime.unsubscribeResults = service.events.subscribe("result", (event) => {
-				deliverResult(event);
-			});
-			yield* until(repository.preload());
-			if (isCoordinationHost(options.runtime.coordination)) lifetime.server = serveOntologyOutbox(options.runtime.coordination, repository);
-			const reconcileProjections = async () => {
-				const version = ++reconciliationVersion;
-				const entries = await repository.entries();
-				if (disposing || version !== reconciliationVersion) return;
-				await projections.reconcile(entries);
-			};
-			lifetime.unsubscribeCollection = collection.subscribeChanges(() => {
-				wake.send();
-				reconcileProjections();
-			});
-			lifetime.unsubscribeConnection = options.connection ? { unsubscribe: options.connection.subscribe(() => {
-				wake.send();
-			}) } : void 0;
-			const existing = yield* until(repository.entries());
-			yield* until(projections.restore(existing));
-			const connectivityChanges = yield* useConnectivityChanges(options.runtime);
-			lifetime.connectivityTask = yield* spawn(function* () {
-				for (const isConnected of yield* each(connectivityChanges)) {
-					wake.send();
-					yield* each.next();
-				}
-			});
-			if (isCoordinationHost(options.runtime.coordination)) {
-				const host = options.runtime.coordination;
-				const leaderOptions = {
-					runtime: options.runtime,
-					service,
-					wake,
-					failureStrategy,
-					maxRetries: nonNegativeInteger(options.maxRetries, DEFAULT_MAX_RETRIES, "Outbox maxRetries"),
-					retryDelayMs: DEFAULT_RETRY_DELAY_MS,
-					execute: (entry) => options.execute(entry),
-					connection: options.connection
-				};
-				lifetime.leaderTask = yield* spawn(function* () {
-					const lifetimeSignal = yield* useAbortSignal();
-					while (!lifetimeSignal.aborted) try {
-						const leaderRun = host.runAsLeader(({ signal }) => runOutboxLeader(signal, leaderOptions), { signal: lifetimeSignal });
-						lifetime.leaderRun = leaderRun;
-						yield* until(leaderRun);
-						return;
-					} catch (error) {
-						if (lifetimeSignal.aborted) return;
-						if (!host.isLeader && !(error instanceof CoordinationError)) continue;
-						throw error;
-					}
-				});
-			}
-			yield* provide({
-				collection,
-				ready: Promise.resolve(),
-				async enqueue(request, enqueueOptions) {
-					const timestamp = Date.now();
-					const proposed = {
-						id: crypto.randomUUID(),
-						sequence: 0,
-						request: {
-							...request,
-							idempotencyKey: request.idempotencyKey ?? crypto.randomUUID()
-						},
-						visibility: enqueueOptions?.visibility ?? "confirmed",
-						status: "queued",
-						createdAt: timestamp,
-						updatedAt: timestamp,
-						attempts: 0,
-						retryable: true,
-						nextAttemptAt: timestamp
-					};
-					const completion = deferred();
-					completion.promise.catch(() => void 0);
-					completions.set(proposed.id, completion);
-					let entry;
-					try {
-						entry = await service.methods.enqueue({ entry: proposed });
-					} catch (error) {
-						completions.delete(proposed.id);
-						completion.reject(normalizeError(error));
-						throw error;
-					}
-					await projections.ensure(entry);
-					return {
-						entry,
-						completed: completion.promise
-					};
-				},
-				async edit(id, update) {
-					const current = repository.get(id);
-					if (!current) throw new Error(`Outbox entry "${id}" was not found in this context.`);
-					const request = cloneValue(current.request);
-					update(request);
-					const entry = await service.methods.edit({
-						id,
-						request
-					});
-					await projections.ensure(entry);
-					return entry;
-				},
-				async remove(id) {
-					await service.methods.remove({ id });
-				},
-				async retry(id) {
-					await service.methods.retry({ id });
-					wake.send();
-				},
-				cleanup() {
-					return Promise.resolve();
-				}
-			});
-		} finally {
-			disposing = true;
-			reconciliationVersion += 1;
-			const cleanupErrors = [];
-			const capture = (error) => {
-				cleanupErrors.push(normalizeError(error));
-			};
-			lifetime.unsubscribeResults?.();
-			lifetime.unsubscribeCollection?.unsubscribe();
-			lifetime.unsubscribeConnection?.unsubscribe();
-			if (lifetime.server) try {
-				yield* until(lifetime.server.close());
-			} catch (error) {
-				capture(error);
-			}
-			if (lifetime.leaderTask !== void 0) try {
-				yield* lifetime.leaderTask.halt();
-			} catch (error) {
-				capture(error);
-			}
-			if (lifetime.leaderRun) yield* until(Promise.allSettled([lifetime.leaderRun]));
-			if (lifetime.connectivityTask !== void 0) try {
-				yield* lifetime.connectivityTask.halt();
-			} catch (error) {
-				capture(error);
-			}
-			try {
-				yield* until(projections.close());
-			} catch (error) {
-				capture(error);
-			}
-			const disposed = /* @__PURE__ */ new Error("Outbox disposed.");
-			for (const completion of completions.values()) completion.reject(disposed);
-			completions.clear();
-			try {
-				yield* until(collection.cleanup());
-			} catch (error) {
-				capture(error);
-			}
-			if (cleanupErrors[0]) yield* until(Promise.reject(cleanupErrors[0]));
-		}
-	});
-}
-function createOntologyOutbox(options) {
-	const collection = createOutboxCollection(options);
-	let outbox;
-	const ready = deferred();
-	ready.promise.catch(() => void 0);
-	let cleanupPromise;
-	const task = run(function* () {
-		try {
-			outbox = yield* useOntologyOutbox(options, collection);
-			ready.resolve();
-			yield* suspend();
-		} catch (error) {
-			ready.reject(normalizeError(error));
-			throw error;
-		}
-	});
-	task.catch(() => void 0);
-	return {
-		collection,
-		ready: ready.promise,
-		task,
-		async enqueue(request, enqueueOptions) {
-			await ready.promise;
-			return outbox.enqueue(request, enqueueOptions);
-		},
-		async edit(id, update) {
-			await ready.promise;
-			return outbox.edit(id, update);
-		},
-		async remove(id) {
-			await ready.promise;
-			return outbox.remove(id);
-		},
-		async retry(id) {
-			await ready.promise;
-			return outbox.retry(id);
-		},
-		async cleanup() {
-			cleanupPromise ??= (async () => {
-				await Promise.allSettled([ready.promise, collection.preload()]);
-				await task.halt().catch(() => void 0);
-				if (collection.status !== "cleaned-up") await collection.cleanup().catch(() => void 0);
-			})();
-			return cleanupPromise;
-		}
-	};
-}
-//#endregion
-export { createOntologyOutbox, useOntologyOutbox };
-
-//# sourceMappingURL=createOntologyOutbox.js.map

package/lib/live/outbox/createOntologyOutbox.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createOntologyOutbox.js","names":[],"sources":["../../../src/live/outbox/createOntologyOutbox.ts"],"sourcesContent":["import { cloneValue } from \"@party-stack/coordination\";\nimport {\n    createLocalCollection,\n    isCoordinationHost,\n    CoordinationError,\n    type CoordinationServiceServer,\n    type RuntimeAdapter,\n} from \"@party-stack/runtime\";\nimport { useConnectivityChanges } from \"@party-stack/runtime/effection\";\nimport {\n    createSignal,\n    each,\n    resource,\n    run,\n    spawn,\n    suspend,\n    until,\n    useAbortSignal,\n    type Operation,\n    type Task,\n} from \"effection\";\nimport { runOutboxLeader, type OutboxLeaderOptions } from \"./leaderExecutor.js\";\nimport { serveOntologyOutbox } from \"./outboxService.js\";\nimport { OutboxProjectionManager, type OutboxProjection } from \"./projectionManager.js\";\nimport { OntologyOutboxRepository } from \"./repository.js\";\nimport {\n    OUTBOX_COORDINATION_SERVICE,\n    type OutboxCoordinationService,\n    type OutboxResultEvent,\n} from \"./service.js\";\nimport type {\n    EnqueuedOntologyAction,\n    OntologyActionRequest,\n    OntologyOutbox,\n    OntologyOutboxEntry,\n} from \"./types.js\";\nimport type { ConnectionMonitor } from \"@party-stack/connections\";\nimport type { Collection } from \"@tanstack/db\";\n\nexport type { OutboxProjection } from \"./projectionManager.js\";\n\nconst DEFAULT_MAX_RETRIES = 3;\nconst DEFAULT_RETRY_DELAY_MS = 1_000;\n\nexport interface CreateOntologyOutboxOptions {\n    runtime: RuntimeAdapter;\n    execute(entry: OntologyOutboxEntry): Promise<unknown>;\n    project?(entry: OntologyOutboxEntry): Promise<OutboxProjection | undefined>;\n    failureStrategy?: \"pause\" | \"discard-all\";\n    maxRetries?: number;\n    connection?: ConnectionMonitor;\n}\n\nfunction nonNegativeInteger(value: number | undefined, fallback: number, name: string): number {\n    const resolved = value ?? fallback;\n    if (!Number.isSafeInteger(resolved) || resolved < 0) {\n        throw new RangeError(`${name} must be a non-negative safe integer.`);\n    }\n    return resolved;\n}\n\ninterface Deferred<T> {\n    promise: Promise<T>;\n    settled: boolean;\n    resolve(value: T): void;\n    reject(error: Error): void;\n}\n\nfunction deferred<T>(): Deferred<T> {\n    let resolvePromise!: (value: T) => void;\n    let rejectPromise!: (error: Error) => void;\n    const value: Deferred<T> = {\n        promise: undefined as unknown as Promise<T>,\n        settled: false,\n        resolve(result) {\n            if (value.settled) return;\n            value.settled = true;\n            resolvePromise(result);\n        },\n        reject(error) {\n            if (value.settled) return;\n            value.settled = true;\n            rejectPromise(error);\n        },\n    };\n    value.promise = new Promise<T>((resolve, reject) => {\n        resolvePromise = resolve;\n        rejectPromise = reject;\n    });\n    return value;\n}\n\nfunction normalizeError(error: unknown): Error {\n    return error instanceof Error ? error : new Error(String(error));\n}\n\nfunction eventError(event: Extract<OutboxResultEvent, { type: \"rejected\" }>): Error {\n    const error = new Error(event.error.message);\n    error.name = event.error.name;\n    return error;\n}\n\nfunction createOutboxCollection(\n    options: CreateOntologyOutboxOptions\n): Collection<OntologyOutboxEntry, string> {\n    return createLocalCollection<OntologyOutboxEntry, string>({\n        name: \"ontology-outbox\",\n        getKey: (entry) => entry.id,\n        runtime: options.runtime,\n        schemaVersion: 1,\n    });\n}\n\nexport function useOntologyOutbox(\n    options: CreateOntologyOutboxOptions,\n    collection: Collection<OntologyOutboxEntry, string> = createOutboxCollection(options)\n): Operation<OntologyOutbox> {\n    return resource(function* (provide) {\n        const repository = new OntologyOutboxRepository(collection);\n        const failureStrategy = options.failureStrategy ?? \"discard-all\";\n        const service =\n            options.runtime.coordination.service<OutboxCoordinationService>(OUTBOX_COORDINATION_SERVICE);\n        const wake = createSignal<void>();\n        const projections = new OutboxProjectionManager(\n            options.project ? async (entry) => options.project?.(entry) : undefined\n        );\n        const completions = new Map<string, Deferred<unknown>>();\n        const lifetime: {\n            server?: CoordinationServiceServer<OutboxCoordinationService>;\n            unsubscribeResults?: () => void;\n            unsubscribeCollection?: {\n                unsubscribe(): void;\n            };\n            connectivityTask?: Task<void>;\n            unsubscribeConnection?: {\n                unsubscribe(): void;\n            };\n            leaderTask?: Task<void>;\n            leaderRun?: Promise<unknown>;\n        } = {};\n        let disposing = false;\n        let reconciliationVersion = 0;\n\n        const deliverResult = async (event: OutboxResultEvent) => {\n            const completion = completions.get(event.id);\n            if (event.type === \"completed\") {\n                await projections.discard(event.id);\n                if (completion) {\n                    completions.delete(event.id);\n                    completion.resolve(event.result);\n                }\n                return;\n            }\n\n            const error = eventError(event);\n            await projections.discard(event.id, error);\n            if (completion) {\n                completions.delete(event.id);\n                completion.reject(error);\n            }\n        };\n        try {\n            lifetime.unsubscribeResults = service.events.subscribe(\"result\", (event) => {\n                void deliverResult(event);\n            });\n\n            yield* until(repository.preload());\n            if (isCoordinationHost(options.runtime.coordination)) {\n                lifetime.server = serveOntologyOutbox(options.runtime.coordination, repository);\n            }\n\n            const reconcileProjections = async (): Promise<void> => {\n                const version = ++reconciliationVersion;\n                const entries = await repository.entries();\n                if (disposing || version !== reconciliationVersion) {\n                    return;\n                }\n                await projections.reconcile(entries);\n            };\n            lifetime.unsubscribeCollection = collection.subscribeChanges(() => {\n                wake.send();\n                void reconcileProjections();\n            });\n            lifetime.unsubscribeConnection = options.connection\n                ? {\n                      unsubscribe: options.connection.subscribe(() => {\n                          wake.send();\n                      }),\n                  }\n                : undefined;\n\n            const existing = yield* until(repository.entries());\n            yield* until(projections.restore(existing));\n\n            const connectivityChanges = yield* useConnectivityChanges(options.runtime);\n            lifetime.connectivityTask = yield* spawn(function* () {\n                for (const isConnected of yield* each(connectivityChanges)) {\n                    void isConnected;\n                    wake.send();\n                    yield* each.next();\n                }\n            });\n\n            if (isCoordinationHost(options.runtime.coordination)) {\n                const host = options.runtime.coordination;\n                const leaderOptions: OutboxLeaderOptions = {\n                    runtime: options.runtime,\n                    service,\n                    wake,\n                    failureStrategy: failureStrategy,\n                    maxRetries: nonNegativeInteger(\n                        options.maxRetries,\n                        DEFAULT_MAX_RETRIES,\n                        \"Outbox maxRetries\"\n                    ),\n                    retryDelayMs: DEFAULT_RETRY_DELAY_MS,\n                    execute: (entry) => options.execute(entry),\n                    connection: options.connection,\n                };\n                lifetime.leaderTask = yield* spawn(function* () {\n                    const lifetimeSignal = yield* useAbortSignal();\n                    while (!lifetimeSignal.aborted) {\n                        try {\n                            const leaderRun = host.runAsLeader(\n                                ({ signal }) => runOutboxLeader(signal, leaderOptions),\n                                {\n                                    signal: lifetimeSignal,\n                                }\n                            );\n                            lifetime.leaderRun = leaderRun;\n                            yield* until(leaderRun);\n                            return;\n                        } catch (error) {\n                            if (lifetimeSignal.aborted) {\n                                return;\n                            }\n                            if (!host.isLeader && !(error instanceof CoordinationError)) {\n                                continue;\n                            }\n                            throw error;\n                        }\n                    }\n                });\n            }\n\n            const outbox: OntologyOutbox = {\n                collection,\n                ready: Promise.resolve(),\n                async enqueue<Result>(\n                    request: Omit<OntologyActionRequest, \"idempotencyKey\"> & {\n                        idempotencyKey?: string;\n                    },\n                    enqueueOptions?: {\n                        visibility?: \"confirmed\" | \"optimistic\";\n                    }\n                ) {\n                    const timestamp = Date.now();\n                    const proposed: OntologyOutboxEntry = {\n                        id: crypto.randomUUID(),\n                        sequence: 0,\n                        request: {\n                            ...request,\n                            idempotencyKey: request.idempotencyKey ?? crypto.randomUUID(),\n                        },\n                        visibility: enqueueOptions?.visibility ?? \"confirmed\",\n                        status: \"queued\",\n                        createdAt: timestamp,\n                        updatedAt: timestamp,\n                        attempts: 0,\n                        retryable: true,\n                        nextAttemptAt: timestamp,\n                    };\n                    const completion = deferred<Result>();\n                    void completion.promise.catch(() => undefined);\n                    completions.set(proposed.id, completion);\n\n                    let entry: OntologyOutboxEntry;\n                    try {\n                        entry = await service.methods.enqueue({\n                            entry: proposed,\n                        });\n                    } catch (error) {\n                        completions.delete(proposed.id);\n                        completion.reject(normalizeError(error));\n                        throw error;\n                    }\n\n                    await projections.ensure(entry);\n\n                    return {\n                        entry,\n                        completed: completion.promise,\n                    } as EnqueuedOntologyAction<Result>;\n                },\n                async edit(id, update) {\n                    const current = repository.get(id);\n                    if (!current) {\n                        throw new Error(`Outbox entry \"${id}\" was not found in this context.`);\n                    }\n                    const request = cloneValue(current.request);\n                    update(request);\n                    const entry = await service.methods.edit({\n                        id,\n                        request,\n                    });\n                    await projections.ensure(entry);\n                    return entry;\n                },\n                async remove(id) {\n                    await service.methods.remove({ id });\n                },\n                async retry(id) {\n                    await service.methods.retry({ id });\n                    wake.send();\n                },\n                cleanup() {\n                    return Promise.resolve();\n                },\n            };\n\n            yield* provide(outbox);\n        } finally {\n            disposing = true;\n            reconciliationVersion += 1;\n            const cleanupErrors: Error[] = [];\n            const capture = (error: unknown) => {\n                cleanupErrors.push(normalizeError(error));\n            };\n\n            lifetime.unsubscribeResults?.();\n            lifetime.unsubscribeCollection?.unsubscribe();\n            lifetime.unsubscribeConnection?.unsubscribe();\n            if (lifetime.server) {\n                try {\n                    yield* until(lifetime.server.close());\n                } catch (error) {\n                    capture(error);\n                }\n            }\n            if (lifetime.leaderTask !== undefined) {\n                try {\n                    yield* lifetime.leaderTask.halt();\n                } catch (error) {\n                    capture(error);\n                }\n            }\n            if (lifetime.leaderRun) {\n                yield* until(Promise.allSettled([lifetime.leaderRun]));\n            }\n            if (lifetime.connectivityTask !== undefined) {\n                try {\n                    yield* lifetime.connectivityTask.halt();\n                } catch (error) {\n                    capture(error);\n                }\n            }\n            try {\n                yield* until(projections.close());\n            } catch (error) {\n                capture(error);\n            }\n            const disposed = new Error(\"Outbox disposed.\");\n            for (const completion of completions.values()) {\n                completion.reject(disposed);\n            }\n            completions.clear();\n            try {\n                yield* until(collection.cleanup());\n            } catch (error) {\n                capture(error);\n            }\n\n            if (cleanupErrors[0]) {\n                yield* until(Promise.reject(cleanupErrors[0]));\n            }\n        }\n    });\n}\n\nexport interface StartedOntologyOutbox extends OntologyOutbox {\n    readonly task: Task<void>;\n}\n\nexport function createOntologyOutbox(options: CreateOntologyOutboxOptions): StartedOntologyOutbox {\n    const collection = createOutboxCollection(options);\n    let outbox: OntologyOutbox | undefined;\n    const ready = deferred<void>();\n    // Prevent unhandled rejection when cleanup races startup.\n    void ready.promise.catch(() => undefined);\n    let cleanupPromise: Promise<void> | undefined;\n    const task = run(function* () {\n        try {\n            const value = yield* useOntologyOutbox(options, collection);\n            outbox = value;\n            ready.resolve();\n            yield* suspend();\n        } catch (error) {\n            ready.reject(normalizeError(error));\n            throw error;\n        }\n    });\n    void task.catch(() => undefined);\n\n    return {\n        collection,\n        ready: ready.promise,\n        task,\n        async enqueue(request, enqueueOptions) {\n            await ready.promise;\n            return outbox!.enqueue(request, enqueueOptions);\n        },\n        async edit(id, update) {\n            await ready.promise;\n            return outbox!.edit(id, update);\n        },\n        async remove(id) {\n            await ready.promise;\n            return outbox!.remove(id);\n        },\n        async retry(id) {\n            await ready.promise;\n            return outbox!.retry(id);\n        },\n        async cleanup() {\n            cleanupPromise ??= (async () => {\n                // Let persistence startup settle before tearing down so\n                // loopback markReady cannot race cleaned-up status.\n                await Promise.allSettled([ready.promise, collection.preload()]);\n                await task.halt().catch(() => undefined);\n                if (collection.status !== \"cleaned-up\") {\n                    await collection.cleanup().catch(() => undefined);\n                }\n            })();\n            return cleanupPromise;\n        },\n    };\n}\n"],"mappings":"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"}

package/lib/live/outbox/leaderExecutor.d.ts

@@ -1,20 +0,0 @@
-import { OntologyOutboxEntry } from "./types.js";
-import { OutboxCoordinationService } from "./service.js";
-import { CoordinationServiceClient, RuntimeAdapter } from "@party-stack/runtime";
-import { Operation, Stream } from "effection";
-import { ConnectionMonitor } from "@party-stack/connections";
-//#region src/live/outbox/leaderExecutor.d.ts
-export interface OutboxLeaderOptions {
-  runtime: RuntimeAdapter;
-  service: CoordinationServiceClient<OutboxCoordinationService>;
-  wake: Stream<void, never>;
-  failureStrategy: "pause" | "discard-all";
-  maxRetries: number;
-  retryDelayMs: number;
-  execute(entry: OntologyOutboxEntry): Promise<unknown>;
-  connection?: ConnectionMonitor;
-}
-export declare function useOutboxLeader(options: OutboxLeaderOptions): Operation<void>;
-export declare function runOutboxLeader(signal: AbortSignal, options: OutboxLeaderOptions): Promise<void>;
-//#endregion
-//# sourceMappingURL=leaderExecutor.d.ts.map

package/lib/live/outbox/leaderExecutor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"leaderExecutor.d.ts","names":[],"sources":["../../../src/live/outbox/leaderExecutor.ts"],"mappings":";;;;;;iBAWiB;EACb,SAAS;EACT,SAAS,0BAA0B;EACnC,MAAM;EACN;EACA;EACA;EACA,QAAQ,OAAO,sBAAsB;EACrC,aAAa;;wBA2BD,gBAAgB,SAAS,sBAAsB;wBA8HzC,gBAAgB,QAAQ,aAAa,SAAS,sBAAsB"}

package/lib/live/outbox/leaderExecutor.js

@@ -1,130 +0,0 @@
-import { NonRetryableError } from "./types.js";
-import { CoordinationTaskRejectedError } from "@party-stack/runtime";
-import { race, run, sleep, until, useAbortSignal } from "effection";
-import { isUnauthenticatedError } from "@party-stack/errors";
-//#region src/live/outbox/leaderExecutor.ts
-function normalizeError(error) {
-	return error instanceof Error ? error : new Error(String(error));
-}
-function isStaleExecution(error) {
-	return error instanceof CoordinationTaskRejectedError && error.code === "STALE_EXECUTION";
-}
-function retryDelay(baseDelayMs, retryIndex) {
-	return Math.min(Number.MAX_SAFE_INTEGER, baseDelayMs * 2 ** Math.min(retryIndex, 16));
-}
-function isConnected(runtime) {
-	return runtime.connectivity?.isConnected !== false;
-}
-function isConnectionReady(connection) {
-	return !connection || connection.state.status === "active";
-}
-function canExecute(options) {
-	return isConnected(options.runtime) && isConnectionReady(options.connection);
-}
-function useOutboxLeader(options) {
-	return (function* () {
-		const signal = yield* useAbortSignal();
-		yield* until(options.service.methods.recover({
-			failureStrategy: options.failureStrategy,
-			maxRetries: options.maxRetries
-		}));
-		const wakes = yield* options.wake;
-		while (true) {
-			if (canExecute(options)) while (true) {
-				if (!canExecute(options)) break;
-				const entry = yield* until(options.service.methods.claim({}));
-				if (!entry) {
-					const retryAt = yield* until(options.service.methods.nextRetryAt({}));
-					if (retryAt === void 0) break;
-					const delay = Math.max(0, retryAt - Date.now());
-					if (delay > 0) yield* race([sleep(delay), wakes.next()]);
-					continue;
-				}
-				const executionId = entry.executionId;
-				let result;
-				try {
-					result = yield* until(options.execute(entry));
-				} catch (error) {
-					if (signal.aborted) throw error;
-					const normalized = normalizeError(error);
-					if (isUnauthenticatedError(error) && options.connection) {
-						yield* until(options.service.methods.fail({
-							id: entry.id,
-							executionId,
-							retryable: true,
-							retryAt: Date.now(),
-							error: {
-								name: normalized.name,
-								message: normalized.message
-							}
-						}));
-						break;
-					}
-					const retryable = !(normalized instanceof NonRetryableError);
-					const retryScheduled = retryable && entry.attempts < options.maxRetries;
-					try {
-						const errorDetails = {
-							name: normalized.name,
-							message: normalized.message
-						};
-						if (retryScheduled) yield* until(options.service.methods.fail({
-							id: entry.id,
-							executionId,
-							retryable: true,
-							retryAt: Date.now() + retryDelay(options.retryDelayMs, entry.attempts),
-							error: errorDetails
-						}));
-						else if (options.failureStrategy === "discard-all") yield* until(options.service.methods.discardAll({
-							id: entry.id,
-							executionId,
-							error: errorDetails
-						}));
-						else yield* until(options.service.methods.fail({
-							id: entry.id,
-							executionId,
-							retryable,
-							error: errorDetails
-						}));
-					} catch (claimError) {
-						if (isStaleExecution(claimError)) break;
-						throw claimError;
-					}
-					if (retryScheduled) continue;
-					break;
-				}
-				if (signal.aborted) throw signal.reason;
-				try {
-					yield* until(options.service.methods.complete({
-						id: entry.id,
-						executionId,
-						result
-					}));
-				} catch (error) {
-					if (isStaleExecution(error)) break;
-					throw error;
-				}
-			}
-			yield* wakes.next();
-		}
-	})();
-}
-async function runOutboxLeader(signal, options) {
-	const task = run(() => useOutboxLeader(options));
-	let halt;
-	const haltTask = () => {
-		halt ??= Promise.resolve(task.halt()).then(() => void 0);
-	};
-	signal.addEventListener("abort", haltTask, { once: true });
-	if (signal.aborted) haltTask();
-	try {
-		await task;
-	} finally {
-		signal.removeEventListener("abort", haltTask);
-		haltTask();
-		await halt;
-	}
-}
-//#endregion
-export { runOutboxLeader, useOutboxLeader };
-
-//# sourceMappingURL=leaderExecutor.js.map

package/lib/live/outbox/leaderExecutor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"leaderExecutor.js","names":[],"sources":["../../../src/live/outbox/leaderExecutor.ts"],"sourcesContent":["import { type ConnectionMonitor } from \"@party-stack/connections\";\nimport { isUnauthenticatedError } from \"@party-stack/errors\";\nimport {\n    CoordinationTaskRejectedError,\n    type CoordinationServiceClient,\n    type RuntimeAdapter,\n} from \"@party-stack/runtime\";\nimport { race, run, sleep, until, useAbortSignal, type Operation, type Stream, type Task } from \"effection\";\nimport { NonRetryableError, type OntologyOutboxEntry } from \"./types.js\";\nimport type { OutboxCoordinationService } from \"./service.js\";\n\nexport interface OutboxLeaderOptions {\n    runtime: RuntimeAdapter;\n    service: CoordinationServiceClient<OutboxCoordinationService>;\n    wake: Stream<void, never>;\n    failureStrategy: \"pause\" | \"discard-all\";\n    maxRetries: number;\n    retryDelayMs: number;\n    execute(entry: OntologyOutboxEntry): Promise<unknown>;\n    connection?: ConnectionMonitor;\n}\n\nfunction normalizeError(error: unknown): Error {\n    return error instanceof Error ? error : new Error(String(error));\n}\n\nfunction isStaleExecution(error: unknown): boolean {\n    return error instanceof CoordinationTaskRejectedError && error.code === \"STALE_EXECUTION\";\n}\n\nfunction retryDelay(baseDelayMs: number, retryIndex: number): number {\n    return Math.min(Number.MAX_SAFE_INTEGER, baseDelayMs * 2 ** Math.min(retryIndex, 16));\n}\n\nfunction isConnected(runtime: RuntimeAdapter): boolean {\n    return runtime.connectivity?.isConnected !== false;\n}\n\nfunction isConnectionReady(connection: OutboxLeaderOptions[\"connection\"]): boolean {\n    return !connection || connection.state.status === \"active\";\n}\n\nfunction canExecute(options: OutboxLeaderOptions): boolean {\n    return isConnected(options.runtime) && isConnectionReady(options.connection);\n}\n\nexport function useOutboxLeader(options: OutboxLeaderOptions): Operation<void> {\n    return (function* () {\n        const signal = yield* useAbortSignal();\n        yield* until(\n            options.service.methods.recover({\n                failureStrategy: options.failureStrategy,\n                maxRetries: options.maxRetries,\n            })\n        );\n        const wakes = yield* options.wake;\n\n        while (true) {\n            if (canExecute(options)) {\n                while (true) {\n                    if (!canExecute(options)) {\n                        break;\n                    }\n                    const entry = yield* until(options.service.methods.claim({}));\n                    if (!entry) {\n                        const retryAt = yield* until(options.service.methods.nextRetryAt({}));\n                        if (retryAt === undefined) {\n                            break;\n                        }\n                        const delay = Math.max(0, retryAt - Date.now());\n                        if (delay > 0) {\n                            yield* race([sleep(delay), wakes.next()]);\n                        }\n                        continue;\n                    }\n                    const executionId = entry.executionId!;\n\n                    let result: unknown;\n                    try {\n                        result = yield* until(options.execute(entry));\n                    } catch (error) {\n                        if (signal.aborted) throw error;\n                        const normalized = normalizeError(error);\n                        if (isUnauthenticatedError(error) && options.connection) {\n                            // Connection egress currently reports authentication\n                            // failures. A future LiveOntology backend supervisor\n                            // should own reporting for every adapter operation.\n                            yield* until(\n                                options.service.methods.fail({\n                                    id: entry.id,\n                                    executionId,\n                                    retryable: true,\n                                    retryAt: Date.now(),\n                                    error: {\n                                        name: normalized.name,\n                                        message: normalized.message,\n                                    },\n                                })\n                            );\n                            break;\n                        }\n                        const retryable = !(normalized instanceof NonRetryableError);\n                        const retryScheduled = retryable && entry.attempts < options.maxRetries;\n                        try {\n                            const errorDetails = {\n                                name: normalized.name,\n                                message: normalized.message,\n                            };\n                            if (retryScheduled) {\n                                yield* until(\n                                    options.service.methods.fail({\n                                        id: entry.id,\n                                        executionId,\n                                        retryable: true,\n                                        retryAt:\n                                            Date.now() + retryDelay(options.retryDelayMs, entry.attempts),\n                                        error: errorDetails,\n                                    })\n                                );\n                            } else if (options.failureStrategy === \"discard-all\") {\n                                yield* until(\n                                    options.service.methods.discardAll({\n                                        id: entry.id,\n                                        executionId,\n                                        error: errorDetails,\n                                    })\n                                );\n                            } else {\n                                yield* until(\n                                    options.service.methods.fail({\n                                        id: entry.id,\n                                        executionId,\n                                        retryable,\n                                        error: errorDetails,\n                                    })\n                                );\n                            }\n                        } catch (claimError) {\n                            if (isStaleExecution(claimError)) {\n                                break;\n                            }\n                            throw claimError;\n                        }\n                        if (retryScheduled) {\n                            continue;\n                        }\n                        break;\n                    }\n\n                    if (signal.aborted) {\n                        throw signal.reason;\n                    }\n                    try {\n                        yield* until(\n                            options.service.methods.complete({\n                                id: entry.id,\n                                executionId,\n                                result,\n                            })\n                        );\n                    } catch (error) {\n                        if (isStaleExecution(error)) break;\n                        throw error;\n                    }\n                }\n            }\n\n            yield* wakes.next();\n        }\n    })();\n}\n\nexport async function runOutboxLeader(signal: AbortSignal, options: OutboxLeaderOptions): Promise<void> {\n    const task: Task<void> = run(() => useOutboxLeader(options));\n    let halt: Promise<void> | undefined;\n    const haltTask = () => {\n        halt ??= Promise.resolve(task.halt()).then(() => undefined);\n    };\n    signal.addEventListener(\"abort\", haltTask, {\n        once: true,\n    });\n    if (signal.aborted) haltTask();\n\n    try {\n        await task;\n    } finally {\n        signal.removeEventListener(\"abort\", haltTask);\n        haltTask();\n        await halt;\n    }\n}\n"],"mappings":"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"}

package/lib/live/outbox/outboxService.d.ts

@@ -1,7 +0,0 @@
-import { OutboxCoordinationService } from "./service.js";
-import { OntologyOutboxRepository } from "./repository.js";
-import { CoordinationHost, CoordinationServiceServer } from "@party-stack/runtime";
-//#region src/live/outbox/outboxService.d.ts
-export declare function serveOntologyOutbox(host: CoordinationHost, repository: OntologyOutboxRepository): CoordinationServiceServer<OutboxCoordinationService>;
-//#endregion
-//# sourceMappingURL=outboxService.d.ts.map

package/lib/live/outbox/outboxService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"outboxService.d.ts","names":[],"sources":["../../../src/live/outbox/outboxService.ts"],"mappings":";;;;wBAYgB,oBACZ,MAAM,kBACN,YAAY,2BACb,0BAA0B"}

package/lib/live/outbox/outboxService.js

@@ -1,68 +0,0 @@
-import { OUTBOX_COORDINATION_SERVICE } from "./service.js";
-//#region src/live/outbox/outboxService.ts
-function serveOntologyOutbox(host, repository) {
-	let publishResult = () => void 0;
-	const server = host.serve(OUTBOX_COORDINATION_SERVICE, {
-		enqueue: ({ entry }) => repository.enqueue(entry),
-		edit: ({ id, request }) => repository.edit(id, request),
-		remove: async ({ id }) => {
-			await repository.remove(id);
-			publishResult({
-				type: "rejected",
-				id,
-				error: {
-					name: "OutboxEntryRemoved",
-					message: "Outbox entry removed."
-				}
-			});
-		},
-		retry: ({ id }) => repository.retry(id),
-		recover: async ({ failureStrategy, maxRetries }) => {
-			const discarded = await repository.recover(failureStrategy, maxRetries);
-			for (const entry of discarded) publishResult({
-				type: "rejected",
-				id: entry.id,
-				error: {
-					name: "InterruptedExecutionDiscarded",
-					message: "Discarded because execution was interrupted before its result was recorded."
-				}
-			});
-		},
-		claim: () => repository.claim(),
-		nextRetryAt: () => repository.nextRetryAt(),
-		complete: async ({ id, executionId, result }) => {
-			await repository.complete(id, executionId);
-			publishResult({
-				type: "completed",
-				id,
-				result
-			});
-		},
-		fail: async ({ id, executionId, retryable, retryAt, error }) => {
-			const entry = await repository.fail(id, executionId, retryable, error, retryAt);
-			if (!retryable) publishResult({
-				type: "rejected",
-				id,
-				error
-			});
-			return entry;
-		},
-		discardAll: async ({ id, executionId, error }) => {
-			const discarded = await repository.discardAll(id, executionId);
-			for (const entry of discarded) publishResult({
-				type: "rejected",
-				id: entry.id,
-				error: entry.id === id ? error : {
-					name: "OutboxDiscardedAfterNonRetryableError",
-					message: `Discarded because outbox entry "${id}" failed permanently: ${error.message}`
-				}
-			});
-		}
-	});
-	publishResult = (event) => server.events.publish("result", event);
-	return server;
-}
-//#endregion
-export { serveOntologyOutbox };
-
-//# sourceMappingURL=outboxService.js.map

package/lib/live/outbox/outboxService.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"outboxService.js","names":[],"sources":["../../../src/live/outbox/outboxService.ts"],"sourcesContent":["import { OntologyOutboxRepository } from \"./repository.js\";\nimport {\n    OUTBOX_COORDINATION_SERVICE,\n    type OutboxCoordinationService,\n    type OutboxResultEvent,\n} from \"./service.js\";\nimport type {\n    CoordinationHost,\n    CoordinationServiceHandlers,\n    CoordinationServiceServer,\n} from \"@party-stack/runtime\";\n\nexport function serveOntologyOutbox(\n    host: CoordinationHost,\n    repository: OntologyOutboxRepository\n): CoordinationServiceServer<OutboxCoordinationService> {\n    let publishResult: (event: OutboxResultEvent) => void = () => undefined;\n    const handlers: CoordinationServiceHandlers<OutboxCoordinationService> = {\n        enqueue: ({ entry }) => repository.enqueue(entry),\n        edit: ({ id, request }) => repository.edit(id, request),\n        remove: async ({ id }) => {\n            await repository.remove(id);\n            publishResult({\n                type: \"rejected\",\n                id,\n                error: {\n                    name: \"OutboxEntryRemoved\",\n                    message: \"Outbox entry removed.\",\n                },\n            });\n        },\n        retry: ({ id }) => repository.retry(id),\n        recover: async ({ failureStrategy, maxRetries }) => {\n            const discarded = await repository.recover(failureStrategy, maxRetries);\n            for (const entry of discarded) {\n                publishResult({\n                    type: \"rejected\",\n                    id: entry.id,\n                    error: {\n                        name: \"InterruptedExecutionDiscarded\",\n                        message:\n                            \"Discarded because execution was interrupted before its result was recorded.\",\n                    },\n                });\n            }\n        },\n        claim: () => repository.claim(),\n        nextRetryAt: () => repository.nextRetryAt(),\n        complete: async ({ id, executionId, result }) => {\n            await repository.complete(id, executionId);\n            publishResult({\n                type: \"completed\",\n                id,\n                result,\n            });\n        },\n        fail: async ({ id, executionId, retryable, retryAt, error }) => {\n            const entry = await repository.fail(id, executionId, retryable, error, retryAt);\n            if (!retryable) {\n                publishResult({\n                    type: \"rejected\",\n                    id,\n                    error,\n                });\n            }\n            return entry;\n        },\n        discardAll: async ({ id, executionId, error }) => {\n            const discarded = await repository.discardAll(id, executionId);\n            for (const entry of discarded) {\n                publishResult({\n                    type: \"rejected\",\n                    id: entry.id,\n                    error:\n                        entry.id === id\n                            ? error\n                            : {\n                                  name: \"OutboxDiscardedAfterNonRetryableError\",\n                                  message: `Discarded because outbox entry \"${id}\" failed permanently: ${error.message}`,\n                              },\n                });\n            }\n        },\n    };\n\n    const server = host.serve<OutboxCoordinationService>(OUTBOX_COORDINATION_SERVICE, handlers);\n    publishResult = (event) => server.events.publish(\"result\", event);\n    return server;\n}\n"],"mappings":";;AAYA,SAAgB,oBACZ,MACA,YACoD;CACpD,IAAI,sBAA0D,KAAA;CAqE9D,MAAM,SAAS,KAAK,MAAiC,6BAA6B;EAnE9E,UAAU,EAAE,YAAY,WAAW,QAAQ,KAAK;EAChD,OAAO,EAAE,IAAI,cAAc,WAAW,KAAK,IAAI,OAAO;EACtD,QAAQ,OAAO,EAAE,SAAS;GACtB,MAAM,WAAW,OAAO,EAAE;GAC1B,cAAc;IACV,MAAM;IACN;IACA,OAAO;KACH,MAAM;KACN,SAAS;IACb;GACJ,CAAC;EACL;EACA,QAAQ,EAAE,SAAS,WAAW,MAAM,EAAE;EACtC,SAAS,OAAO,EAAE,iBAAiB,iBAAiB;GAChD,MAAM,YAAY,MAAM,WAAW,QAAQ,iBAAiB,UAAU;GACtE,KAAK,MAAM,SAAS,WAChB,cAAc;IACV,MAAM;IACN,IAAI,MAAM;IACV,OAAO;KACH,MAAM;KACN,SACI;IACR;GACJ,CAAC;EAET;EACA,aAAa,WAAW,MAAM;EAC9B,mBAAmB,WAAW,YAAY;EAC1C,UAAU,OAAO,EAAE,IAAI,aAAa,aAAa;GAC7C,MAAM,WAAW,SAAS,IAAI,WAAW;GACzC,cAAc;IACV,MAAM;IACN;IACA;GACJ,CAAC;EACL;EACA,MAAM,OAAO,EAAE,IAAI,aAAa,WAAW,SAAS,YAAY;GAC5D,MAAM,QAAQ,MAAM,WAAW,KAAK,IAAI,aAAa,WAAW,OAAO,OAAO;GAC9E,IAAI,CAAC,WACD,cAAc;IACV,MAAM;IACN;IACA;GACJ,CAAC;GAEL,OAAO;EACX;EACA,YAAY,OAAO,EAAE,IAAI,aAAa,YAAY;GAC9C,MAAM,YAAY,MAAM,WAAW,WAAW,IAAI,WAAW;GAC7D,KAAK,MAAM,SAAS,WAChB,cAAc;IACV,MAAM;IACN,IAAI,MAAM;IACV,OACI,MAAM,OAAO,KACP,QACA;KACI,MAAM;KACN,SAAS,mCAAmC,GAAG,wBAAwB,MAAM;IACjF;GACd,CAAC;EAET;CAGqF,CAAC;CAC1F,iBAAiB,UAAU,OAAO,OAAO,QAAQ,UAAU,KAAK;CAChE,OAAO;AACX"}

package/lib/live/outbox/projectionManager.d.ts

@@ -1,31 +0,0 @@
-import { OntologyOutboxEntry } from "./types.js";
-//#region src/live/outbox/projectionManager.d.ts
-export interface OutboxProjection {
-  settle(error?: Error): void | Promise<void>;
-}
-export declare class OutboxProjectionManager {
-  private readonly project;
-  private desired;
-  private readonly projections;
-  private readonly installedFingerprints;
-  private readonly versions;
-  private tail;
-  private closed;
-  private disabledError;
-  constructor(project: ((entry: OntologyOutboxEntry) => Promise<OutboxProjection | undefined>) | undefined);
-  get error(): Error | undefined;
-  restore(entries: readonly OntologyOutboxEntry[]): Promise<void>;
-  reconcile(entries: readonly OntologyOutboxEntry[]): Promise<void>;
-  ensure(entry: OntologyOutboxEntry): Promise<void>;
-  discard(id: string, error?: Error): Promise<void>;
-  close(): Promise<void>;
-  private schedule;
-  private applyDesired;
-  private disable;
-  private firstDivergence;
-  private install;
-  private invalidate;
-  private settle;
-}
-//#endregion
-//# sourceMappingURL=projectionManager.d.ts.map

package/lib/live/outbox/projectionManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"projectionManager.d.ts","names":[],"sources":["../../../src/live/outbox/projectionManager.ts"],"mappings":";;iBAGiB;EACb,OAAO,QAAQ,eAAe;;qBAsBrB;mBAUY;UATb;mBACS;mBACA;mBACA;UACT;UACA;UACA;EAER,YACqB,WACT,OAAO,wBAAwB,QAAQ;MAI/C,SAAS;EAIb,QAAQ,kBAAkB,wBAAwB;EAIlD,UAAU,kBAAkB,wBAAwB;EAIpD,OAAO,OAAO,sBAAsB;EAUpC,QAAQ,YAAY,QAAQ,QAAQ;EAUpC,SAAS;UASD;UAWM;UAsCA;UAQN;UAkBM;UAsBA;UAOA"}