@streamsy/serve 0.0.0-stage → 0.4.0

package/dist/action/runtime.js

@@ -0,0 +1,182 @@
+import { backoffAfter } from "./contract.js";
+import { ActionSinkDeliveryFailure } from "./errors.js";
+import { OutboxStore } from "./outbox.js";
+import { n as Wakeup } from "../wakeup-CWKg8pts.js";
+import { Cause, Clock, Effect, Exit, Semaphore } from "effect";
+import { StorageFault } from "@streamsy/core";
+//#region src/action/runtime.ts
+/**
+* The delivery runtime: one bounded, serialized pass over a sink's outbox.
+*
+* `drain` is the whole runtime. It claims the entries in one lane whose next
+* attempt instant has arrived, and delivers them **one at a time in enqueue
+* order** — never concurrently, because an external effect that must not be
+* duplicated must also not be interleaved with its own retry.
+*
+* With `ordered`, a future retry blocks later entries in the drained scope.
+* By default, serialized is not the same as blocking. A failing entry is rescheduled into
+* the future and the pass moves on to the next one, so a poisoned delivery
+* cannot hold a lane's healthy traffic hostage. That is the difference between
+* an ordered queue and a stuck one.
+*
+* A pass has exactly one operational failure mode: the outbox itself. Every
+* handler outcome — a typed refusal, a thrown defect, a payload that no longer
+* decodes — is recorded against the entry and the pass keeps going, so a broken
+* handler can never fail the caller that asked for a drain.
+*/
+/**
+* Bind a delivery function to a sink's declared handler.
+*
+* A handler's own dependencies stay ordinary Effect requirements, so a host
+* supplies them with a layer and the declaration never mentions the transport:
+* the same sink delivers through a real notifier in the host and through a
+* recording fake in a test, with no branch in between.
+*/
+function actionSinkHandler(sink, deliver) {
+	return { deliver: (delivery) => deliver(delivery, {
+		retryable: (detail) => ActionSinkDeliveryFailure.retryable(sink.handler.name, delivery.idempotencyKey, detail),
+		permanent: (detail) => ActionSinkDeliveryFailure.permanent(sink.handler.name, delivery.idempotencyKey, detail)
+	}) };
+}
+const DEFAULT_DRAIN_LIMIT = 100;
+/** Lower declared payloads to outbox drafts. Pure, so a caller can write them transactionally. */
+function draftsFor(sink, payloads, enqueuedAtMs) {
+	return payloads.map((payload) => ({
+		sink: sink.name,
+		partitionId: sink.partitionBy(payload),
+		idempotencyKey: sink.idempotencyKey(payload),
+		payload: sink.payload.encode(payload),
+		enqueuedAtMs
+	}));
+}
+const drainPermits = /* @__PURE__ */ new WeakMap();
+const drainPermit = (store, sink) => {
+	let permits = drainPermits.get(store);
+	if (permits === void 0) {
+		permits = /* @__PURE__ */ new Map();
+		drainPermits.set(store, permits);
+	}
+	let permit = permits.get(sink);
+	if (permit === void 0) {
+		permit = Semaphore.makeUnsafe(1);
+		permits.set(sink, permit);
+	}
+	return permit;
+};
+/**
+* Deliver due entries serially, applying the declared retry policy and optional strict order.
+*
+* Each sink's permit is not reentrant. A handler must not drain its own sink.
+*/
+const drain = (sink, handler, options = {}) => Effect.gen(function* () {
+	const store = yield* OutboxStore;
+	return yield* drainPermit(store, sink.name).withPermit(Effect.gen(function* () {
+		const startedAtMs = yield* Clock.currentTimeMillis;
+		const claimed = yield* store.claimDue(sink.name, options.partitionId, startedAtMs, options.limit ?? 100, options.ordered);
+		let attempted = 0;
+		let delivered = 0;
+		let retried = 0;
+		let deadLettered = 0;
+		for (const entry of claimed) {
+			if (entry.nextAttemptAtMs > (yield* Clock.currentTimeMillis)) break;
+			attempted += 1;
+			const attempt = entry.attempts + 1;
+			const decoded = decodePayload(sink, entry);
+			if (decoded.kind === "poison") {
+				yield* settle(entry, attempt, "payload-poison", decoded.detail);
+				deadLettered += 1;
+				continue;
+			}
+			const exit = yield* Effect.exit(handler.deliver({
+				entryId: entry.id,
+				sink: entry.sink,
+				partitionId: entry.partitionId,
+				idempotencyKey: entry.idempotencyKey,
+				attempt,
+				payload: decoded.payload
+			}));
+			if (Exit.isSuccess(exit)) {
+				const at = yield* Clock.currentTimeMillis;
+				yield* store.markDelivered(entry.id, attempt, at);
+				delivered += 1;
+				continue;
+			}
+			if (Cause.hasInterrupts(exit.cause)) return yield* Effect.interrupt;
+			const failure = failureOf(sink, entry, exit.cause);
+			const reason = deadLetterReason(sink, attempt, failure);
+			if (reason !== void 0) {
+				yield* settle(entry, attempt, reason, failure.detail);
+				deadLettered += 1;
+				continue;
+			}
+			const at = yield* Clock.currentTimeMillis;
+			yield* store.reschedule(entry.id, attempt, at + backoffAfter(sink.delivery, attempt), failure.detail);
+			retried += 1;
+			if (options.ordered) break;
+		}
+		return {
+			sink: sink.name,
+			claimed: attempted,
+			delivered,
+			retried,
+			deadLettered
+		};
+		function settle(entry, attempt, reason, detail) {
+			return Clock.currentTimeMillis.pipe(Effect.flatMap((at) => store.deadLetter(entry.id, attempt, reason, detail, at)));
+		}
+	}));
+});
+/**
+* A stored payload the declared codec now rejects is dead on arrival.
+*
+* Retrying it would re-run the same decode against the same bytes forever, so
+* it dead-letters immediately — fail-stop for that entry, and only that entry.
+*/
+function decodePayload(sink, entry) {
+	try {
+		return {
+			kind: "payload",
+			payload: sink.payload.decode(JSON.parse(entry.payload))
+		};
+	} catch (cause) {
+		return {
+			kind: "poison",
+			detail: describe(cause)
+		};
+	}
+}
+/** Every non-interrupt cause becomes one retryable refusal; a thrown handler is still a handler. */
+function failureOf(sink, entry, cause) {
+	const declared = cause.reasons.find(Cause.isFailReason);
+	if (declared !== void 0) return declared.error;
+	return ActionSinkDeliveryFailure.retryable(sink.handler.name, entry.idempotencyKey, Cause.pretty(cause).slice(0, 500));
+}
+function deadLetterReason(sink, attempt, failure) {
+	if (!failure.retryable) return "permanent";
+	if (attempt >= sink.delivery.maxAttempts) return "attempts-exhausted";
+}
+function describe(cause) {
+	return cause instanceof Error ? cause.message : String(cause);
+}
+/**
+* The wakeup for one action outbox. The host entry does not load action code.
+*
+* Its name is `streamsy/outbox/<sink>` or `streamsy/outbox/<sink>/<partition>`,
+* with each part URI-encoded so a sink named `a/b` cannot collide with a lane.
+* A pass that fills its limit reports more work, so a backlog is not backed off.
+*/
+const OutboxWakeup = { make: (sink, handler, options = {}) => Wakeup.make({
+	name: outboxWakeupName(sink.name, options.partitionId),
+	next: OutboxStore.use((store) => store.nextDue(sink.name, options.partitionId, options.ordered)).pipe(Effect.mapError((fault) => new StorageFault({
+		operation: fault.operation,
+		message: fault.detail,
+		retryable: true
+	}))),
+	run: drain(sink, handler, options).pipe(Effect.map((report) => ({ more: report.claimed >= (options.limit ?? 100) })))
+}) };
+function outboxWakeupName(sink, partitionId) {
+	const lane = partitionId === void 0 ? "" : `/${encodeURIComponent(partitionId)}`;
+	return `streamsy/outbox/${encodeURIComponent(sink)}${lane}`;
+}
+//#endregion
+export { DEFAULT_DRAIN_LIMIT, OutboxWakeup, actionSinkHandler, draftsFor, drain };

package/dist/action/sql.d.ts

@@ -0,0 +1,8 @@
+import { OutboxUnavailable } from "./errors.js";
+import { OutboxBacking } from "./outbox.js";
+import { Effect } from "effect";
+import { SqlClient } from "effect/sql/SqlClient";
+//#region src/action/sql.d.ts
+export declare function migrateOutbox(sql: SqlClient): Effect.Effect<void, OutboxUnavailable>;
+export declare function createSqlOutboxBacking(sql: SqlClient): OutboxBacking;
+//#endregion

package/dist/action/sql.js

@@ -0,0 +1,229 @@
+import { OutboxUnavailable } from "./errors.js";
+import { Effect, Option, Predicate, Schema } from "effect";
+//#region src/action/sql.ts
+const TABLE = "streamsy_effect_outbox";
+/** MySQL key columns. Their sum fits the 3072-byte InnoDB index limit at 4 bytes a character. */
+const MYSQL_SINK_LENGTH = 255;
+const MYSQL_PARTITION_LENGTH = 255;
+const MYSQL_KEY_LENGTH = 512;
+const MYSQL_KEY_TYPE = "CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin NOT NULL";
+const CREATE_TABLE = {
+	sqlite: `CREATE TABLE IF NOT EXISTS ${TABLE} (
+  id                 INTEGER PRIMARY KEY AUTOINCREMENT,
+  sink               TEXT NOT NULL,
+  partition_id       TEXT NOT NULL,
+  idempotency_key    TEXT NOT NULL,
+  payload            TEXT NOT NULL,
+  state              TEXT NOT NULL,
+  attempts           INTEGER NOT NULL DEFAULT 0,
+  next_attempt_at_ms INTEGER NOT NULL,
+  last_error         TEXT,
+  dead_letter_reason TEXT,
+  enqueued_at_ms     INTEGER NOT NULL,
+  settled_at_ms      INTEGER
+)`,
+	pg: `CREATE TABLE IF NOT EXISTS ${TABLE} (
+  id                 BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  sink               TEXT NOT NULL,
+  partition_id       TEXT NOT NULL,
+  idempotency_key    TEXT NOT NULL,
+  payload            TEXT NOT NULL,
+  state              TEXT NOT NULL,
+  attempts           INTEGER NOT NULL DEFAULT 0,
+  next_attempt_at_ms BIGINT NOT NULL,
+  last_error         TEXT,
+  dead_letter_reason TEXT,
+  enqueued_at_ms     BIGINT NOT NULL,
+  settled_at_ms      BIGINT
+)`,
+	mysql: `CREATE TABLE IF NOT EXISTS ${TABLE} (
+  id                 BIGINT AUTO_INCREMENT PRIMARY KEY,
+  sink               VARCHAR(${MYSQL_SINK_LENGTH}) ${MYSQL_KEY_TYPE},
+  partition_id       VARCHAR(${MYSQL_PARTITION_LENGTH}) ${MYSQL_KEY_TYPE},
+  idempotency_key    VARCHAR(${MYSQL_KEY_LENGTH}) ${MYSQL_KEY_TYPE},
+  payload            LONGTEXT NOT NULL,
+  state              VARCHAR(16) NOT NULL,
+  attempts           INT NOT NULL DEFAULT 0,
+  next_attempt_at_ms BIGINT NOT NULL,
+  last_error         LONGTEXT,
+  dead_letter_reason VARCHAR(32),
+  enqueued_at_ms     BIGINT NOT NULL,
+  settled_at_ms      BIGINT
+)`
+};
+const INDEXES = [
+	{
+		name: `${TABLE}_identity`,
+		unique: true,
+		columns: "(sink, idempotency_key)"
+	},
+	{
+		name: `${TABLE}_due`,
+		unique: false,
+		columns: "(sink, state, next_attempt_at_ms, id)"
+	},
+	{
+		name: `${TABLE}_order`,
+		unique: false,
+		columns: "(sink, state, id)"
+	}
+];
+const createIndex = (index, ifNotExists) => `CREATE ${index.unique ? "UNIQUE " : ""}INDEX ${ifNotExists ? "IF NOT EXISTS " : ""}${index.name} ON ${TABLE} ${index.columns}`;
+const isOutboxUnavailable = Schema.is(OutboxUnavailable);
+const attempt = (operation, effect) => effect.pipe(Effect.mapError((cause) => isOutboxUnavailable(cause) ? cause : new OutboxUnavailable({
+	operation,
+	detail: cause instanceof Error ? cause.message : String(cause)
+})));
+const unsupported = (operation) => Effect.fail(new OutboxUnavailable({
+	operation,
+	detail: "Unsupported SQL dialect; the SQL outbox supports sqlite, pg and mysql"
+}));
+/** The names of the outbox indexes that exist in the current MySQL database. */
+const mysqlIndexes = (sql) => sql`SELECT DISTINCT index_name AS name FROM information_schema.statistics
+ WHERE table_schema = DATABASE() AND table_name = ${TABLE}`.pipe(Effect.map((rows) => new Set(rows.map(({ name }) => name))));
+/** MySQL has no `CREATE INDEX IF NOT EXISTS`. A concurrent migration may win the create. */
+const migrateMysql = (sql) => Effect.gen(function* () {
+	if (Option.isSome(yield* Effect.serviceOption(sql.transactionService))) return yield* new OutboxUnavailable({
+		operation: "migrateOutbox",
+		detail: "On MySQL, run migrateOutbox outside a transaction, at placement start"
+	});
+	yield* sql.unsafe(CREATE_TABLE.mysql);
+	for (const index of INDEXES) {
+		if ((yield* mysqlIndexes(sql)).has(index.name)) continue;
+		yield* sql.unsafe(createIndex(index, false)).pipe(Effect.catch((error) => Effect.flatMap(mysqlIndexes(sql), (names) => names.has(index.name) ? Effect.void : Effect.fail(error))));
+	}
+});
+function migrateOutbox(sql) {
+	const statements = (dialect) => Effect.forEach([CREATE_TABLE[dialect], ...INDEXES.map((index) => createIndex(index, true))], (statement) => sql.unsafe(statement), { discard: true });
+	return attempt("migrateOutbox", sql.onDialectOrElse({
+		sqlite: () => statements("sqlite"),
+		pg: () => statements("pg"),
+		mysql: () => migrateMysql(sql),
+		orElse: () => unsupported("migrateOutbox")
+	}));
+}
+/**
+* MySQL readiness only reads the catalog. The backing may run inside a caller's
+* transaction, and DDL there would commit it early.
+*/
+const mysqlReady = (sql) => Effect.flatMap(mysqlIndexes(sql), (names) => INDEXES.every((index) => names.has(index.name)) ? Effect.void : Effect.fail(new OutboxUnavailable({
+	operation: "ready",
+	detail: `${TABLE} is not migrated; on MySQL, run migrateOutbox at placement start`
+})));
+/** MySQL `INSERT IGNORE` would truncate an over-long key, so refuse it first. */
+const mysqlKeyFault = (draft) => {
+	const limits = [
+		[
+			"sink",
+			draft.sink,
+			MYSQL_SINK_LENGTH
+		],
+		[
+			"partition id",
+			draft.partitionId,
+			MYSQL_PARTITION_LENGTH
+		],
+		[
+			"idempotency key",
+			draft.idempotencyKey,
+			MYSQL_KEY_LENGTH
+		]
+	];
+	for (const [label, value, limit] of limits) {
+		const length = [...value].length;
+		if (length > limit) return new OutboxUnavailable({
+			operation: "enqueue",
+			detail: `The ${label} has ${length} characters; the MySQL outbox limit is ${limit}`
+		});
+	}
+};
+function createSqlOutboxBacking(sql) {
+	const ready = Effect.suspend(() => sql.onDialectOrElse({
+		mysql: () => mysqlReady(sql),
+		orElse: () => migrateOutbox(sql)
+	}));
+	const run = (operation, statement) => attempt(operation, Effect.andThen(ready, statement));
+	const execute = (operation, statement) => run(operation, statement).pipe(Effect.asVoid);
+	const rows = (operation, statement) => run(operation, statement).pipe(Effect.map((found) => found.map(decodeRow)));
+	/** Whether the draft was new. A draft with a known sink and key changes nothing. */
+	const insert = (draft) => {
+		const row = sql.insert({
+			sink: draft.sink,
+			partition_id: draft.partitionId,
+			idempotency_key: draft.idempotencyKey,
+			payload: draft.payload,
+			state: "pending",
+			attempts: 0,
+			next_attempt_at_ms: draft.enqueuedAtMs,
+			enqueued_at_ms: draft.enqueuedAtMs
+		});
+		return sql.onDialectOrElse({
+			mysql: () => {
+				const fault = mysqlKeyFault(draft);
+				if (fault !== void 0) return Effect.fail(fault);
+				return sql`INSERT IGNORE INTO streamsy_effect_outbox ${row}`.raw.pipe(Effect.map((result) => Predicate.hasProperty(result, "affectedRows") && Number(result.affectedRows) > 0));
+			},
+			orElse: () => sql`INSERT INTO streamsy_effect_outbox ${row}
+ ON CONFLICT (sink, idempotency_key) DO NOTHING RETURNING 1 AS inserted`.pipe(Effect.map((inserted) => inserted.length > 0))
+		});
+	};
+	return {
+		enqueue: (drafts) => run("enqueue", Effect.gen(function* () {
+			let enqueued = 0;
+			for (const draft of drafts) if (yield* insert(draft)) enqueued += 1;
+			return {
+				enqueued,
+				absorbed: drafts.length - enqueued
+			};
+		})),
+		nextDue: (sink, partitionId, ordered = false) => run("nextDue", sql`SELECT next_attempt_at_ms AS at
+ FROM streamsy_effect_outbox WHERE ${sql.and([
+			sql`sink = ${sink}`,
+			sql`state = 'pending'`,
+			...partitionId === void 0 ? [] : [sql`partition_id = ${partitionId}`]
+		])} ORDER BY ${ordered ? sql`id` : sql`next_attempt_at_ms, id`} LIMIT 1`).pipe(Effect.map((found) => Option.fromUndefinedOr(found[0]).pipe(Option.map((row) => Number(row.at))))),
+		claimDue: (sink, partitionId, nowMs, limit, ordered = false) => rows("claimDue", sql`SELECT * FROM streamsy_effect_outbox WHERE ${sql.and([
+			sql`sink = ${sink}`,
+			...partitionId === void 0 ? [] : [sql`partition_id = ${partitionId}`],
+			sql`state = 'pending'`,
+			...ordered ? [] : [sql`next_attempt_at_ms <= ${nowMs}`]
+		])} ORDER BY id LIMIT ${limit}`),
+		markDelivered: (id, attempts, atMs) => execute("markDelivered", sql`UPDATE streamsy_effect_outbox SET state = 'delivered', attempts = ${attempts},
+ last_error = NULL, settled_at_ms = ${atMs} WHERE id = ${id}`),
+		reschedule: (id, attempts, nextAttemptAtMs, detail) => execute("reschedule", sql`UPDATE streamsy_effect_outbox SET state = 'pending', attempts = ${attempts},
+ next_attempt_at_ms = ${nextAttemptAtMs}, last_error = ${detail} WHERE id = ${id}`),
+		deadLetter: (id, attempts, reason, detail, atMs) => execute("deadLetter", sql`UPDATE streamsy_effect_outbox SET state = 'dead', attempts = ${attempts},
+ dead_letter_reason = ${reason}, last_error = ${detail}, settled_at_ms = ${atMs} WHERE id = ${id}`),
+		list: (sink, partitionId) => rows("list", sql`SELECT * FROM streamsy_effect_outbox WHERE ${sql.and([sql`sink = ${sink}`, ...partitionId === void 0 ? [] : [sql`partition_id = ${partitionId}`]])} ORDER BY id`)
+	};
+}
+/** Postgres returns BIGINT as a `bigint`; SQLite and MySQL return a `number`. */
+const toNumber = (value) => Number(value);
+function decodeRow(row) {
+	return {
+		id: toNumber(row.id),
+		sink: row.sink,
+		partitionId: row.partition_id,
+		idempotencyKey: row.idempotency_key,
+		payload: row.payload,
+		state: decodeState(row.state),
+		attempts: row.attempts,
+		nextAttemptAtMs: toNumber(row.next_attempt_at_ms),
+		lastError: row.last_error ?? void 0,
+		deadLetterReason: decodeReason(row.dead_letter_reason),
+		enqueuedAtMs: toNumber(row.enqueued_at_ms),
+		settledAtMs: row.settled_at_ms === null ? void 0 : toNumber(row.settled_at_ms)
+	};
+}
+/** A stored state this build does not know is a schema fault, never a silent "pending". */
+function decodeState(value) {
+	if (value === "pending" || value === "delivered" || value === "dead") return value;
+	throw new TypeError(`unknown outbox state ${value}`);
+}
+function decodeReason(value) {
+	if (value === null) return void 0;
+	if (value === "attempts-exhausted" || value === "permanent" || value === "payload-poison") return value;
+	throw new TypeError(`unknown outbox dead-letter reason ${value}`);
+}
+//#endregion
+export { createSqlOutboxBacking, migrateOutbox };

package/dist/alchemy.d.ts

@@ -0,0 +1,25 @@
+import { a as alarmSlotLayer, i as AlarmSlot, n as WakeupProgress, r as Wakeups, t as Wakeup } from "./wakeup-BtnMEjLv.js";
+import { i as ObjectServices, n as rule, r as ObjectApp, t as Placement } from "./placement-BOM3E08P.js";
+import { Effect, Layer, Scope } from "effect";
+import { HttpServerRequest, HttpServerResponse } from "effect/http";
+import { Storage, StorageFault } from "@streamsy/core";
+import { DurableObject } from "alchemy/Cloudflare";
+import { HttpServerError } from "effect/http/HttpServerError";
+//#region src/alchemy.d.ts
+/** An Alchemy HttpEffect; authenticate before evaluating this router. */
+export declare const router: (options: {
+  readonly objects: Pick<DurableObject, "getByName">;
+  readonly prefix?: `/${string}`;
+  readonly placement?: Placement;
+}) => Effect.Effect<HttpServerResponse.HttpServerResponse, HttpServerError, HttpServerRequest.HttpServerRequest>;
+export type ObjectHandlers = {
+  readonly fetch: Effect.Effect<HttpServerResponse.HttpServerResponse, never, HttpServerRequest.HttpServerRequest>;
+  readonly alarm: () => Effect.Effect<void>;
+};
+export declare function objectHandlers<R = never>(options: {
+  readonly app: ObjectApp<R>;
+  readonly layer: Layer.Layer<Storage | AlarmSlot | R, StorageFault>;
+  readonly wakeups?: ReadonlyArray<Wakeup<ObjectServices<R>>>;
+}): Effect.Effect<ObjectHandlers, never, Scope.Scope>;
+//#endregion
+export { Placement, Wakeup, type WakeupProgress, Wakeups, alarmSlotLayer, rule };

package/dist/alchemy.js

@@ -0,0 +1,39 @@
+import { a as alarmSlotLayer, n as Wakeup, r as Wakeups } from "./wakeup-CWKg8pts.js";
+import { a as acquireObject, i as rule, o as providedApp, r as Placement, s as unavailable, t as resolvePlacement } from "./router-DviIc1O7.js";
+import { Effect, Option } from "effect";
+import { HttpRouter, HttpServerRequest, HttpServerRespondable, HttpServerResponse } from "effect/http";
+import { securityHeaders, streamPath } from "@streamsy/core/http";
+//#region src/alchemy.ts
+/** An Alchemy HttpEffect; authenticate before evaluating this router. */
+const router = (options) => {
+	const path = streamPath(options.prefix);
+	const placement = options.placement ?? Placement.byStream();
+	return Effect.gen(function* () {
+		const request = yield* HttpServerRequest.HttpServerRequest;
+		const pathname = new URL(request.url, "https://streamsy.internal").pathname;
+		const streamPath = path.strip(pathname);
+		if (!streamPath || streamPath === pathname) return HttpServerResponse.text(`Stream path required: ${path.requiredPathPattern()}`, {
+			status: 400,
+			headers: securityHeaders
+		});
+		const child = resolvePlacement(placement, streamPath);
+		if (!child.ok) return HttpServerResponse.fromWeb(child.response);
+		return yield* options.objects.getByName(child.name).fetch(request);
+	});
+};
+function objectHandlers(options) {
+	return Effect.gen(function* () {
+		const get = yield* acquireObject(options.layer, (context, alarm) => Effect.gen(function* () {
+			return {
+				fetch: (yield* HttpRouter.toHttpEffect(providedApp(options.app, context))).pipe(Effect.scoped, Effect.catch(HttpServerRespondable.toResponse)),
+				alarm: alarm.pipe(Effect.provide(context))
+			};
+		}), options.wakeups);
+		return {
+			fetch: Effect.flatMap(get.pipe(Effect.asSome, Effect.catch(() => Effect.succeedNone), Effect.catchDefect(() => Effect.succeedNone)), (compiled) => Option.isSome(compiled) ? compiled.value.fetch : Effect.succeed(unavailable())),
+			alarm: () => Effect.flatMap(get, (compiled) => compiled.alarm).pipe(Effect.orDie)
+		};
+	});
+}
+//#endregion
+export { Placement, Wakeup, Wakeups, alarmSlotLayer, objectHandlers, router, rule };

package/dist/bun.d.ts

@@ -0,0 +1,13 @@
+import { Duration } from "effect";
+//#region src/bun.d.ts
+export declare const DEFAULT_PORT = 3000;
+export declare const DEFAULT_HOSTNAME = "127.0.0.1";
+export interface ListenerOptions {
+  readonly port?: number;
+  readonly hostname?: string;
+  readonly idleTimeout?: number;
+  readonly gracefulShutdownTimeout?: Duration.Input;
+}
+/** The Bun listener that keeps a parked long poll alive. */
+export declare const listener: (options?: ListenerOptions) => import("effect/Layer").Layer<import("effect/http/Etag").Generator | import("effect/http/HttpPlatform").HttpPlatform | import("effect/http/HttpServer").HttpServer | import("@effect/platform-bun/BunServices").BunServices, import("effect/http/HttpServerError").ServeError, never>;
+//#endregion

package/dist/bun.js

@@ -0,0 +1,14 @@
+import { BunHttpServer } from "@effect/platform-bun";
+//#region src/bun.ts
+const DEFAULT_PORT = 3e3;
+const DEFAULT_HOSTNAME = "127.0.0.1";
+const listenerOptions = (options) => ({
+	port: options.port ?? 3e3,
+	hostname: options.hostname ?? "127.0.0.1",
+	idleTimeout: options.idleTimeout ?? 0,
+	...options.gracefulShutdownTimeout === void 0 ? { disablePreemptiveShutdown: true } : { gracefulShutdownTimeout: options.gracefulShutdownTimeout }
+});
+/** The Bun listener that keeps a parked long poll alive. */
+const listener = (options = {}) => BunHttpServer.layer(listenerOptions(options));
+//#endregion
+export { DEFAULT_HOSTNAME, DEFAULT_PORT, listener };

package/dist/cloudflare.d.ts

@@ -0,0 +1,35 @@
+import { a as alarmSlotLayer, n as WakeupProgress, r as Wakeups, t as Wakeup } from "./wakeup-BtnMEjLv.js";
+import { i as ObjectServices, n as rule, r as ObjectApp, t as Placement } from "./placement-BOM3E08P.js";
+import { Layer } from "effect";
+import { Storage, StorageFault } from "@streamsy/core";
+import { DurableObject } from "cloudflare:workers";
+import { AlarmInvocationInfo, DurableObjectNamespace, DurableObjectState, ExportedHandler } from "@cloudflare/workers-types";
+//#region src/cloudflare/object.d.ts
+interface ObjectConfiguration<Env, R = never> {
+  readonly app: ObjectApp<R>;
+  readonly wakeups?: ReadonlyArray<Wakeup<ObjectServices<R>>>;
+  readonly layer: (state: DurableObjectState, env: Env) => Layer.Layer<Storage | R, StorageFault>;
+}
+interface ObjectInstance {
+  fetch(request: Request): Promise<Response>;
+  alarm(info?: AlarmInvocationInfo): Promise<void>;
+}
+declare class ObjectHost<Env, R> extends DurableObject<Env> {
+  #private;
+  constructor(state: DurableObjectState, env: Env, configuration: ObjectConfiguration<Env, R>);
+  fetch(request: Request): Promise<Response>;
+  alarm(_info?: AlarmInvocationInfo): Promise<void>;
+}
+export declare const StreamsyObject: {
+  make: <Env = unknown, R = never>(configuration: ObjectConfiguration<Env, R>) => new (state: DurableObjectState, env: Env) => ObjectHost<Env, R>;
+};
+//#endregion
+//#region src/cloudflare/router.d.ts
+interface RouterOptions<Env> {
+  readonly namespace: (env: Env) => DurableObjectNamespace;
+  readonly placement?: Placement;
+  readonly prefix?: `/${string}`;
+}
+export declare const router: <Env>(options: RouterOptions<Env>) => ExportedHandler<Env>;
+//#endregion
+export { type ObjectConfiguration, type ObjectInstance, Placement, type RouterOptions, Wakeup, type WakeupProgress, Wakeups, alarmSlotLayer, rule };

package/dist/cloudflare.js

@@ -0,0 +1,40 @@
+import { a as alarmSlotLayer, n as Wakeup, r as Wakeups } from "./wakeup-CWKg8pts.js";
+import { a as acquireObject, i as rule, n as router, o as providedApp, r as Placement, s as unavailable } from "./router-DviIc1O7.js";
+import { Context, Effect, Layer, ManagedRuntime, Option } from "effect";
+import { HttpRouter, HttpServerResponse } from "effect/http";
+import { DurableObject } from "cloudflare:workers";
+//#region src/cloudflare/object.ts
+var ObjectOwner = class extends Context.Service()("streamsy/ObjectOwner") {};
+var ObjectHost = class extends DurableObject {
+	#runtime;
+	constructor(state, env, configuration) {
+		super(state, env);
+		this.#runtime = ManagedRuntime.make(Layer.effect(ObjectOwner, Effect.map(acquireObject(Layer.suspend(() => Layer.merge(configuration.layer(state, env), alarmSlotLayer(state.storage))), (context, alarm) => Effect.gen(function* () {
+			const web = HttpRouter.toWebHandler(providedApp(configuration.app, context), { disableLogger: true });
+			yield* Effect.addFinalizer(() => Effect.promise(web.dispose));
+			return {
+				handler: web.handler,
+				alarm: alarm.pipe(Effect.provide(context))
+			};
+		}), configuration.wakeups), (get) => ({ get }))));
+	}
+	fetch(request) {
+		return this.#runtime.runPromise(Effect.gen(function* () {
+			const compiled = yield* (yield* ObjectOwner).get.pipe(Effect.asSome, Effect.catch(() => Effect.succeedNone), Effect.catchDefect(() => Effect.succeedNone));
+			if (Option.isNone(compiled)) return HttpServerResponse.toWeb(unavailable());
+			return yield* Effect.promise(() => compiled.value.handler(request));
+		}));
+	}
+	alarm(_info) {
+		return this.#runtime.runPromise(Effect.gen(function* () {
+			yield* (yield* (yield* ObjectOwner).get).alarm;
+		}));
+	}
+};
+const StreamsyObject = { make: (configuration) => class extends ObjectHost {
+	constructor(state, env) {
+		super(state, env, configuration);
+	}
+} };
+//#endregion
+export { Placement, StreamsyObject, Wakeup, Wakeups, alarmSlotLayer, router, rule };

package/dist/contract-BUWJ-Sy2.d.ts

@@ -0,0 +1,67 @@
+//#region src/contract.d.ts
+/**
+ * Canonical encoding and the change-detection digests served routes need.
+ *
+ * A contract fingerprint and a value ETag answer the same question — "is
+ * this still the thing you were holding?" — so both are computed from one
+ * canonical encoding. Object keys are sorted and array order is preserved, so
+ * two values that differ only in property order encode identically and cannot
+ * invalidate a consumer's cache for no reason.
+ *
+ * These are change-detection identities, not security digests.
+ */
+type CanonicalValue = string | number | boolean | null | readonly CanonicalValue[] | {
+  readonly [key: string]: CanonicalValue;
+};
+/** Encode a value with object keys sorted, recursively. Array order is preserved. */
+declare function canonicalJson(value: CanonicalValue): string;
+/** Eight lowercase hex characters of FNV-1a over the canonical encoding's UTF-16 code units. */
+declare function contractFingerprint(value: CanonicalValue): string;
+/**
+ * Sixteen lowercase hex characters, as a strong entity tag body.
+ *
+ * Two FNV-1a passes with different offset bases are concatenated, because a
+ * cache validator that collides serves a stale value: eight hex characters
+ * are enough to notice that a contract changed, but not enough to key a
+ * consumer's cache on.
+ */
+declare function valueEtag(canonical: string): string;
+declare const STATE_VERSION_HEADER = "x-streamsy-state-version";
+declare const STATE_CONTRACT_HEADER = "x-streamsy-state-contract";
+declare const STREAM_VERSION_HEADER = "x-streamsy-stream-version";
+declare const STREAM_CONTRACT_HEADER = "x-streamsy-stream-contract";
+declare const VALUE_CONTRACT_HEADER = "x-streamsy-value-contract";
+declare const DURABLE_STATE_PROTOCOL = "https://durable-streams.dev/state-protocol/v1";
+type ReplayRecovery = "replay-from-start";
+type ResumeRejectedReason = "invalid-offset" | "history-unavailable" | "contract-changed";
+type PublicError = {
+  readonly _tag: "InvalidParams";
+  readonly route: string;
+  readonly parameter: string;
+  readonly detail: string;
+} | {
+  readonly _tag: "ProtocolVersionUnsupported";
+  readonly route: string;
+  readonly supported: 1;
+  readonly received: string;
+  readonly recovery: ReplayRecovery;
+} | {
+  readonly _tag: "ResumeRejected";
+  readonly route: string;
+  readonly reason: ResumeRejectedReason;
+  readonly recovery: ReplayRecovery;
+} | {
+  readonly _tag: "ContractChanged";
+  readonly route: string;
+  readonly recovery: "refetch";
+} | {
+  readonly _tag: "TransportUnavailable" | "WireEncodeFailed";
+  readonly route: string;
+  readonly detail: string;
+};
+declare const PUBLIC_ERROR_TAGS: readonly ["InvalidParams", "ProtocolVersionUnsupported", "ResumeRejected", "ContractChanged", "TransportUnavailable", "WireEncodeFailed"];
+type PublicErrorTag = PublicError["_tag"];
+/** The browser's JSON error boundary; unknown fields are discarded. */
+declare function decodePublicError(value: unknown): PublicError;
+//#endregion
+export { PublicErrorTag as a, STATE_CONTRACT_HEADER as c, STREAM_VERSION_HEADER as d, VALUE_CONTRACT_HEADER as f, valueEtag as g, decodePublicError as h, PublicError as i, STATE_VERSION_HEADER as l, contractFingerprint as m, DURABLE_STATE_PROTOCOL as n, ReplayRecovery as o, canonicalJson as p, PUBLIC_ERROR_TAGS as r, ResumeRejectedReason as s, CanonicalValue as t, STREAM_CONTRACT_HEADER as u };

package/dist/contract.d.ts

@@ -0,0 +1,2 @@
+import { a as PublicErrorTag, c as STATE_CONTRACT_HEADER, d as STREAM_VERSION_HEADER, f as VALUE_CONTRACT_HEADER, g as valueEtag, h as decodePublicError, i as PublicError, l as STATE_VERSION_HEADER, m as contractFingerprint, n as DURABLE_STATE_PROTOCOL, o as ReplayRecovery, p as canonicalJson, r as PUBLIC_ERROR_TAGS, s as ResumeRejectedReason, t as CanonicalValue, u as STREAM_CONTRACT_HEADER } from "./contract-BUWJ-Sy2.js";
+export { CanonicalValue, DURABLE_STATE_PROTOCOL, PUBLIC_ERROR_TAGS, PublicError, PublicErrorTag, ReplayRecovery, ResumeRejectedReason, STATE_CONTRACT_HEADER, STATE_VERSION_HEADER, STREAM_CONTRACT_HEADER, STREAM_VERSION_HEADER, VALUE_CONTRACT_HEADER, canonicalJson, contractFingerprint, decodePublicError, valueEtag };