@streamsy/serve 0.5.0 → 0.7.0

package/README.md

@@ -2,7 +2,7 @@
 
 Effect HttpRouter routes for streams, Durable State and JSON values, plus Bun,
 Node, Deno and Cloudflare host glue and durable action delivery. Requires Effect
-`4.0.1`.
+`4.0.5`.
 
 ```ts
 import { Layer, Schema } from "effect";
@@ -85,8 +85,8 @@ The Durable Object host does not get a stop signal and uses neither.
 | `/bun`                                                               | `listener`, its options and defaults                                                                                                                               |
 | `/node`                                                              | `listener`, its options and defaults                                                                                                                               |
 | `/deno`                                                              | `listener`, its options and defaults; `nodeSqliteCompat`                                                                                                           |
-| `/cloudflare`                                                        | `StreamsyObject`, placement router/rules, alarm service                                                                                                            |
-| `/alchemy`                                                           | `objectHandlers`, placement router/rules, alarm service                                                                                                            |
+| `/cloudflare`                                                        | `StreamsyObject`, placement router/rules, alarm service, `ObjectLink`, `ObjectStreams`                                                                             |
+| `/alchemy`                                                           | `objectHandlers`, placement router/rules, alarm service, `ObjectLink`, `objectFetch`                                                                               |
 | `/action`                                                            | Unchanged action declarations                                                                                                                                      |
 | `/action/errors`, `/action/outbox`, `/action/runtime`, `/action/sql` | Action delivery and backing APIs; `createSqlOutboxBacking` runs on SQLite, Postgres and MySQL                                                                      |
 
@@ -106,3 +106,38 @@ Guides: [Serve routes](https://streamsy.dev/docs/http/serve),
 [Cloudflare](https://streamsy.dev/docs/hosting/cloudflare),
 [Host contract](https://streamsy.dev/docs/hosting/host-contract),
 [Alchemy](https://streamsy.dev/docs/hosting/cloudflare#alchemy).
+
+## Object links and projection wakeups
+
+`ObjectLink.make({ group, prefix, placement, access })` from `/cloudflare` or
+`/alchemy` declares an internal protocol mount and its client together. Add
+`link.routes` to the owner app and the client to the caller's `links`.
+The prefix must start with `/__`. Both public placement routers return 404
+for paths whose first segment starts with `__`, without calling an object.
+The owner still needs the explicit internal route.
+
+Both hosts use one `ObjectLink` and one `LinkClient`. A native Cloudflare
+object takes `links: (env) => [link.client(env.OWNERS)]`. Alchemy
+`objectHandlers` takes `links: [link.client(objectFetch(owners))]`. A linked
+declaration must not also be provided by local storage; the host rejects that
+clash during acquisition.
+
+`ObjectStreams.layer(group, { objects, placement, prefix })` builds the same
+remote stream services for an existing protocol mount. `objects` is a native
+namespace or an `ObjectFetch`: `(name, request) => Effect<Response,
+HttpClientError>`. The client uses `HttpClient.make`, retaining caller context,
+tracing and interruption. Alchemy's `objectFetch` adapts its stub Effects.
+
+Access is mount policy for every stream. `Streamsy.wake` is a State preset
+with the normal writer service. Use `read` for public projection outputs,
+`full` when an internal producer creates its output, or `append` when the
+owner creates it first. `Serve.mount` accepts GET and HEAD.
+
+Object hosts acquire `ProjectionWakeup.attach(projection)` from
+`@streamsy/projection` in their scope through `wakeups: [...]`. Local
+`Storage.committed` events populate its in-memory pending set, and each commit
+writes a durable pending mark in the same transaction. Alarms drain bounded
+passes. After an eviction, acquisition reads the marks and arms the alarm.
+Retry options take an Effect `Schedule`; finite schedules stop on exhaustion.
+`Wakeups.status` reports each wakeup's deferred bindings.
+See the [projection host reference](https://streamsy.dev/docs/hosting/cloudflare#projections).

package/dist/action/runtime.d.ts

@@ -1,7 +1,7 @@
 import { ActionSinkRelation, CheckedActionSink } from "./contract.js";
 import { ActionSinkDeliveryFailure, OutboxUnavailable } from "./errors.js";
 import { OutboxDraft, OutboxStore } from "./outbox.js";
-import { t as Wakeup } from "../wakeup--kIoqiIE.js";
+import { t as Wakeup } from "../wakeup-BJGZnq4x.js";
 import { Effect } from "effect";
 /** One attempt at one delivery, as the handler sees it. */
 export interface ActionSinkDelivery<Payload> {

package/dist/action/runtime.js

@@ -1,7 +1,7 @@
 import { backoffAfter } from "./contract.js";
 import { ActionSinkDeliveryFailure } from "./errors.js";
 import { OutboxStore } from "./outbox.js";
-import { n as Wakeup } from "../wakeup-CcJE8k3i.js";
+import { n as Wakeup } from "../wakeup-Cb5DAcpF.js";
 import { Array, Cause, Clock, Effect, Exit, Option, Semaphore } from "effect";
 import { StorageFault } from "@streamsy/core";
 // src/action/runtime.ts

package/dist/alchemy.d.ts

@@ -1,5 +1,5 @@
-import { a as alarmSlotLayer, i as AlarmSlot, n as WakeupProgress, r as Wakeups, t as Wakeup } from "./wakeup--kIoqiIE.js";
-import { i as ObjectServices, n as rule, r as ObjectApp, t as Placement } from "./placement-Cj3sd02S.js";
+import { a as AlarmSlot, i as Wakeups, n as WakeupProgress, o as alarmSlotLayer, r as WakeupSource, t as Wakeup } from "./wakeup-BJGZnq4x.js";
+import { a as ObjectLinkOptions, c as ObjectStreamsOptions, d as ObjectApp, i as ObjectLink, l as Placement, n as LinkClient, o as ObjectFetch, r as LinkRoutes, s as ObjectStreams, t as LinkAccess, u as rule } from "./object-link-B3cvdzGy.js";
 import { Effect, Layer, Scope } from "effect";
 import { HttpServerError, HttpServerRequest, HttpServerResponse } from "effect/http";
 import { Storage, StorageFault } from "@streamsy/core";
@@ -10,13 +10,20 @@ export declare const router: (options: {
   readonly prefix?: `/${string}`;
   readonly placement?: Placement;
 }) => Effect.Effect<HttpServerResponse.HttpServerResponse, HttpServerError.HttpServerError, HttpServerRequest.HttpServerRequest>;
+/**
+ * An `ObjectFetch` over an Alchemy Durable Object binding, for
+ * `ObjectStreams.layer` and `ObjectLink.client`.
+ */
+export declare const objectFetch: (objects: Pick<DurableObject, "getByName">) => ObjectFetch;
 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>>>;
+export declare function objectHandlers<R = never, L = never>(options: {
+  readonly app: ObjectApp<R | L>;
+  readonly layer: Layer.Layer<Storage | AlarmSlot | R, StorageFault, L>;
+  readonly wakeups?: ReadonlyArray<WakeupSource<Storage | R | L>>;
+  /** Streams that live on other objects, through `link.client(objectFetch(binding))`. */
+  readonly links?: ReadonlyArray<LinkClient<L>>;
 }): Effect.Effect<ObjectHandlers, never, Scope.Scope>;
-export { Placement, Wakeup, type WakeupProgress, Wakeups, alarmSlotLayer, rule };
+export { type LinkAccess, type LinkClient, type LinkRoutes, type ObjectFetch, ObjectLink, type ObjectLinkOptions, ObjectStreams, type ObjectStreamsOptions, Placement, Wakeup, type WakeupProgress, type WakeupSource, Wakeups, alarmSlotLayer, rule };

package/dist/alchemy.js

@@ -1,5 +1,5 @@
-import { a as alarmSlotLayer, n as Wakeup, r as Wakeups } from "./wakeup-CcJE8k3i.js";
-import { a as acquireObject, i as rule, o as providedApp, r as Placement, s as unavailable, t as resolvePlacement } from "./router-C2p1T25K.js";
+import { a as alarmSlotLayer, n as Wakeup, r as Wakeups } from "./wakeup-Cb5DAcpF.js";
+import { a as resolvePlacement, c as rule, d as unavailable, f as withLinks, i as isReserved, l as acquireObject, n as ObjectStreams, r as objectTransportError, s as Placement, t as ObjectLink, u as providedApp } from "./object-link-pdzpEY0s.js";
 import { Effect, Option } from "effect";
 import { HttpRouter, HttpServerRequest, HttpServerRespondable, HttpServerResponse } from "effect/http";
 import { securityHeaders, streamPath } from "@streamsy/core/http";
@@ -11,6 +11,10 @@ const router = (options) => {
 	return Effect.gen(function* () {
 		const request = yield* HttpServerRequest.HttpServerRequest;
 		const pathname = new URL(request.url, "https://streamsy.internal").pathname;
+		if (isReserved(pathname)) return HttpServerResponse.empty({
+			status: 404,
+			headers: securityHeaders
+		});
 		const streamPath = path.strip(pathname);
 		if (!streamPath || streamPath === pathname) return HttpServerResponse.text(`Stream path required: ${path.requiredPathPattern()}`, {
 			status: 400,
@@ -21,9 +25,17 @@ const router = (options) => {
 		return yield* options.objects.getByName(child.name).fetch(request);
 	});
 };
+/**
+* An `ObjectFetch` over an Alchemy Durable Object binding, for
+* `ObjectStreams.layer` and `ObjectLink.client`.
+*/
+const objectFetch = (objects) => Effect.fn("Alchemy.objectFetch")(function* (name, request) {
+	const response = yield* objects.getByName(name).fetch(HttpServerRequest.fromWeb(request)).pipe(Effect.mapError((cause) => objectTransportError(request, cause)));
+	return HttpServerResponse.toWeb(response);
+});
 function objectHandlers(options) {
 	return Effect.gen(function* () {
-		const get = yield* acquireObject(options.layer, (context, alarm) => Effect.gen(function* () {
+		const get = yield* acquireObject(withLinks(options.layer, options.links), (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))
@@ -35,4 +47,4 @@ function objectHandlers(options) {
 		};
 	});
 }
-export { Placement, Wakeup, Wakeups, alarmSlotLayer, objectHandlers, router, rule };
+export { ObjectLink, ObjectStreams, Placement, Wakeup, Wakeups, alarmSlotLayer, objectFetch, objectHandlers, router, rule };

package/dist/cloudflare.d.ts

@@ -1,26 +1,32 @@
-import { a as alarmSlotLayer, n as WakeupProgress, r as Wakeups, t as Wakeup } from "./wakeup--kIoqiIE.js";
-import { i as ObjectServices, n as rule, r as ObjectApp, t as Placement } from "./placement-Cj3sd02S.js";
+import { i as Wakeups, n as WakeupProgress, o as alarmSlotLayer, r as WakeupSource, t as Wakeup } from "./wakeup-BJGZnq4x.js";
+import { a as ObjectLinkOptions, c as ObjectStreamsOptions, d as ObjectApp, i as ObjectLink, l as Placement, n as LinkClient, o as ObjectFetch, r as LinkRoutes, s as ObjectStreams, t as LinkAccess, u as rule } from "./object-link-B3cvdzGy.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";
-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 ObjectConfiguration<Env, R = never, L = never> {
+  readonly app: ObjectApp<R | L>;
+  readonly wakeups?: ReadonlyArray<WakeupSource<Storage | R | L>>;
+  readonly layer: (state: DurableObjectState, env: Env) => Layer.Layer<Storage | R, StorageFault, L>;
+  /**
+   * Streams that live on other objects. Their services come from these links
+   * and never from `layer`. An object whose `layer` also provides a linked
+   * stream fails to start.
+   */
+  readonly links?: (env: Env) => ReadonlyArray<LinkClient<L>>;
 }
 interface ObjectInstance {
   fetch(request: Request): Promise<Response>;
   alarm(info?: AlarmInvocationInfo): Promise<void>;
 }
-declare class ObjectHost<Env, R> extends DurableObject<Env> {
+declare class ObjectHost<Env, R, L> extends DurableObject<Env> {
   #private;
-  constructor(state: DurableObjectState, env: Env, configuration: ObjectConfiguration<Env, R>);
+  constructor(state: DurableObjectState, env: Env, configuration: ObjectConfiguration<Env, R, L>);
   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>;
+  make: <Env = unknown, R = never, L = never>(configuration: ObjectConfiguration<Env, R, L>) => new (state: DurableObjectState, env: Env) => ObjectHost<Env, R, L>;
 };
 interface RouterOptions<Env> {
   readonly namespace: (env: Env) => DurableObjectNamespace;
@@ -28,4 +34,4 @@ interface RouterOptions<Env> {
   readonly prefix?: `/${string}`;
 }
 export declare const router: <Env>(options: RouterOptions<Env>) => ExportedHandler<Env>;
-export { type ObjectConfiguration, type ObjectInstance, Placement, type RouterOptions, Wakeup, type WakeupProgress, Wakeups, alarmSlotLayer, rule };
+export { type LinkAccess, type LinkClient, type LinkRoutes, type ObjectConfiguration, type ObjectFetch, type ObjectInstance, ObjectLink, type ObjectLinkOptions, ObjectStreams, type ObjectStreamsOptions, Placement, type RouterOptions, Wakeup, type WakeupProgress, type WakeupSource, Wakeups, alarmSlotLayer, rule };

package/dist/cloudflare.js

@@ -1,5 +1,5 @@
-import { a as alarmSlotLayer, n as Wakeup, r as Wakeups } from "./wakeup-CcJE8k3i.js";
-import { a as acquireObject, i as rule, n as router, o as providedApp, r as Placement, s as unavailable } from "./router-C2p1T25K.js";
+import { a as alarmSlotLayer, n as Wakeup, r as Wakeups } from "./wakeup-Cb5DAcpF.js";
+import { c as rule, d as unavailable, f as withLinks, l as acquireObject, n as ObjectStreams, o as router, s as Placement, t as ObjectLink, u as providedApp } from "./object-link-pdzpEY0s.js";
 import { Context, Effect, Layer, ManagedRuntime, Option } from "effect";
 import { HttpRouter, HttpServerResponse } from "effect/http";
 import { DurableObject } from "cloudflare:workers";
@@ -9,7 +9,7 @@ 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* () {
+		this.#runtime = ManagedRuntime.make(Layer.effect(ObjectOwner, Effect.map(acquireObject(Layer.suspend(() => Layer.merge(withLinks(configuration.layer(state, env), configuration.links?.(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 {
@@ -36,4 +36,4 @@ const StreamsyObject = { make: (configuration) => class extends ObjectHost {
 		super(state, env, configuration);
 	}
 } };
-export { Placement, StreamsyObject, Wakeup, Wakeups, alarmSlotLayer, router, rule };
+export { ObjectLink, ObjectStreams, Placement, StreamsyObject, Wakeup, Wakeups, alarmSlotLayer, router, rule };

package/dist/object-link-B3cvdzGy.d.ts

@@ -0,0 +1,118 @@
+import { i as Wakeups } from "./wakeup-BJGZnq4x.js";
+import { Context, Effect, Layer, Option, Scope } from "effect";
+import { HttpClientError, HttpRouter, HttpServerRespondable, HttpServerResponse } from "effect/http";
+import { Storage, StorageFault, Streamsy } from "@streamsy/core";
+import { DurableObjectNamespace } from "@cloudflare/workers-types";
+type ObjectServices<R = never> = Storage | Wakeups | R;
+type ObjectApp<R = never> = Layer.Layer<never, never, HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", ObjectServices<R>> | HttpRouter.Request.From<"Error", HttpServerRespondable.Respondable>>;
+interface Placement {
+  readonly name: (streamPath: string) => string;
+}
+/** The parse side of a stream, which is all a placement rule reads. */
+interface Parser<Params> {
+  parse(id: string): Option.Option<Params>;
+}
+/**
+ * One rule in a stream placement: a stream and the object name its
+ * addresses belong to.
+ *
+ * The owner takes the same parameters its own stream decodes, so the object name
+ * and the storage routing agree by construction. `owner` uses method syntax on
+ * purpose: it gives the parameter its contextually typed shape at the call site
+ * and keeps the rule assignable to the erased table.
+ */
+interface OwnerRule<Params> {
+  readonly stream: Parser<Params>;
+  /** Names the object that owns every stream matching `stream`. */
+  owner(params: Params): string;
+}
+/**
+ * A rule after its parameter type is erased. `byRoute` reads each rule only
+ * through that rule's own `parse`, so the erased parameter is never observed.
+ */
+interface ErasedOwnerRule {
+  readonly stream: Parser<unknown>;
+  owner(params: never): string;
+}
+/**
+ * Declare one placement rule with its stream's parameters in scope.
+ *
+ * The helper exists so the owner parameter is typed and checked. A rule passed
+ * to `Placement.byRoute` without it would see the erased parameter set instead.
+ */
+declare const rule: <Params>(spec: OwnerRule<Params>) => ErasedOwnerRule;
+declare const Placement: {
+  readonly byStream: () => Placement;
+  readonly byKey: (key: (streamPath: string) => string) => Placement;
+  /**
+   * The first matching rule names the object.
+   *
+   * A path that no rule matches yields `""`, which the router turns into
+   * `400 Invalid placement key`. An owner that throws is a `500`. A rule whose
+   * stream cannot decode a segment does not own that path, so the table falls
+   * through to the next rule.
+   */
+  readonly byRoute: (rules: ReadonlyArray<ErasedOwnerRule>) => Placement;
+};
+/** Sends one request to the object with this name. */
+type ObjectFetch = (name: string, request: Request) => Effect.Effect<Response, HttpClientError.HttpClientError>;
+interface ObjectStreamsOptions {
+  /** The namespace of the owner objects, or a function that sends a request to one object by name. */
+  readonly objects: DurableObjectNamespace | ObjectFetch;
+  /** Names the owner object of each stream id. Use the same value that the app gives to `router`. */
+  readonly placement: Placement;
+  /** The mount prefix on the owner object, for example "/streams" or "/__wake". */
+  readonly prefix: `/${string}`;
+  /** Extra headers on each request. */
+  readonly headers?: Readonly<Record<string, string>>;
+}
+/**
+ * A `RemoteStreams` layer whose requests go to the object that owns each
+ * stream, and never to the network. The owner side is always a Streamsy
+ * `Http.routes` mount, so the client declares producer and expected-offset support.
+ */
+declare function layer<const Keys extends ReadonlyArray<Streamsy.Any>>(group: Streamsy.Group<Keys>, options: ObjectStreamsOptions): Layer.Layer<Streamsy.Services<Streamsy.Group<Keys>>>;
+declare const ObjectStreams: {
+  readonly layer: typeof layer;
+};
+/** What callers may do on a link mount. It applies to wake streams too. */
+type LinkAccess = "read" | "append" | "full";
+interface ObjectLinkOptions<Keys extends ReadonlyArray<Streamsy.Any>> {
+  /** The streams that the owner serves to other objects. */
+  readonly group: Streamsy.Group<Keys>;
+  /** The internal mount. It must start with "/__", so that no package router forwards it. */
+  readonly prefix: `/__${string}`;
+  /** Names the owner object of each stream id. */
+  readonly placement: Placement;
+  readonly access: LinkAccess;
+}
+/**
+ * The caller side of a link. Return it from the caller object's `links`. The
+ * host refuses an object whose own layer also provides one of `streams`.
+ */
+interface LinkClient<I> {
+  readonly streams: ReadonlyArray<Streamsy.Any>;
+  readonly layer: Layer.Layer<I>;
+}
+/** The owner mount, typed as `Http.routes` types it. */
+type LinkRoutes<I> = Layer.Layer<never, never, HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", Exclude<I, HttpRouter.Provided>>>;
+interface ObjectLink<Keys extends ReadonlyArray<Streamsy.Any>> {
+  readonly group: Streamsy.Group<Keys>;
+  readonly prefix: `/__${string}`;
+  /** The owner side. Add it to the owner object's `app`. */
+  readonly routes: LinkRoutes<Streamsy.Services<Streamsy.Group<Keys>>>;
+  /**
+   * The caller side. `objects` is the owner namespace, or an `ObjectFetch` such
+   * as Alchemy's `objectFetch(binding)`. Return the result from the caller's `links`.
+   */
+  readonly client: (objects: DurableObjectNamespace | ObjectFetch) => LinkClient<Streamsy.Services<Streamsy.Group<Keys>>>;
+}
+/**
+ * One value for both sides of an internal mount between objects: the owner
+ * mount and the caller client read the same group, prefix and access.
+ */
+declare const make: <const Keys extends ReadonlyArray<Streamsy.Any>>(options: ObjectLinkOptions<Keys>) => ObjectLink<Keys>;
+declare const ObjectLink: {
+  readonly make: typeof make;
+};
+export { ObjectLinkOptions as a, ObjectStreamsOptions as c, ObjectApp as d, ObjectLink as i, Placement as l, LinkClient as n, ObjectFetch as o, LinkRoutes as r, ObjectStreams as s, LinkAccess as t, rule as u };

package/dist/object-link-pdzpEY0s.js

@@ -0,0 +1,230 @@
+import { i as makeWakeups, r as Wakeups, t as RequestTouch } from "./wakeup-Cb5DAcpF.js";
+import { Array, Context, Effect, Exit, Layer, Option, Predicate, Scope } from "effect";
+import { HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
+import { Http, StorageFault } from "@streamsy/core";
+import { securityHeaders, streamPath } from "@streamsy/core/http";
+import { RemoteStreams } from "@streamsy/core/remote";
+// src/cloudflare/links.ts
+const clashMessage = (stream) => `${stream.key} is linked to another object, but this object's layer also provides it. Remove it from the storage group.`;
+/**
+* Puts the link layers under the object's own layer and beside it. The own
+* layer sees the linked services at start, and the object sees them at run
+* time. An own layer that also provides a linked stream fails with a
+* `StorageFault`, because its rows would go to a local stream that no
+* client reads.
+*/
+function withLinks(own, links) {
+	const clients = links ?? [];
+	const streams = Array.flatMap(clients, (link) => link.streams);
+	const linked = Layer.mergeAll(Layer.empty, ...Array.map(clients, (link) => link.layer));
+	const checked = Layer.provide(own, linked).pipe(Layer.tap((local) => Option.match(Array.findFirst(streams, (stream) => Option.isSome(Context.getOption(local, stream))), {
+		onNone: () => Effect.void,
+		onSome: (stream) => Effect.fail(new StorageFault({
+			operation: "streamsy.links",
+			message: clashMessage(stream),
+			retryable: false
+		}))
+	})));
+	return Layer.merge(checked, linked);
+}
+// src/cloudflare/host-program.ts
+/**
+* Reconciliation belongs to the mutation's finalizer. A request interruption
+* can be pending when the mutation's own uninterruptible region ends, so a
+* second sequential uninterruptible effect is not sufficient. A failed
+* reconciliation is logged and does not replace the mutation's result.
+*/
+const withMutationReconciliation = (effect, reconcile) => effect.pipe(Effect.ensuring(reconcile.pipe(Effect.uninterruptible, Effect.catchCause((cause) => Effect.logError("Wakeup reconciliation failed", cause)))));
+// src/cloudflare/object-runtime.ts
+/** Both object hosts install this middleware, including around user routes. */
+function objectApp(app, context) {
+	const middleware = HttpRouter.middleware((handler) => Effect.gen(function* () {
+		const request = yield* HttpServerRequest.HttpServerRequest;
+		const marker = { touched: false };
+		const wakeups = Context.get(context, Wakeups);
+		return yield* withMutationReconciliation(handler, Effect.suspend(() => [
+			"PUT",
+			"POST",
+			"DELETE"
+		].includes(request.method) || marker.touched ? wakeups.reconcile : Effect.void)).pipe(Effect.catchDefect(() => Effect.succeed(HttpServerResponse.text("Internal server error", {
+			status: 500,
+			headers: Http.securityHeaders
+		}))), Effect.provideService(RequestTouch, marker));
+	}).pipe(Effect.provide(context)), { global: true });
+	return Layer.merge(app, middleware);
+}
+const unavailable = () => HttpServerResponse.text("Storage unavailable", {
+	status: 503,
+	headers: {
+		...Http.securityHeaders,
+		"retry-after": "1"
+	}
+});
+/** One lazy successful acquisition per object owner. Failed attempts close before retry. */
+function acquireObject(layer, compile, wakeups) {
+	return Effect.gen(function* () {
+		const owner = yield* Scope.Scope;
+		return yield* Effect.gen(function* () {
+			const attempt = yield* Scope.fork(owner);
+			return yield* Effect.gen(function* () {
+				const context = yield* Layer.buildWithScope(layer, attempt);
+				const scheduler = yield* makeWakeups(context, wakeups).pipe(Effect.provideService(Scope.Scope, attempt));
+				return yield* compile(scheduler.context, scheduler.alarm).pipe(Effect.provideService(Scope.Scope, attempt));
+			}).pipe(Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(attempt, exit) : Effect.void));
+		}).pipe(Effect.cachedWithTTL((exit) => Exit.isSuccess(exit) ? "Infinity" : 0));
+	});
+}
+/** Request markers are all supplied by this exact object context. */
+function providedApp(app, context) {
+	return objectApp(app, context).pipe(HttpRouter.provideRequest(Layer.succeedContext(context)));
+}
+// src/cloudflare/placement.ts
+/**
+* Declare one placement rule with its stream's parameters in scope.
+*
+* The helper exists so the owner parameter is typed and checked. A rule passed
+* to `Placement.byRoute` without it would see the erased parameter set instead.
+*/
+const rule = (spec) => spec;
+const Placement = {
+	byStream: () => ({ name: (streamPath) => streamPath }),
+	byKey: (key) => ({ name: key }),
+	/**
+	* The first matching rule names the object.
+	*
+	* A path that no rule matches yields `""`, which the router turns into
+	* `400 Invalid placement key`. An owner that throws is a `500`. A rule whose
+	* stream cannot decode a segment does not own that path, so the table falls
+	* through to the next rule.
+	*/
+	byRoute: (rules) => ({ name: (streamPath) => {
+		for (const entry of rules) {
+			const params = entry.stream.parse(streamPath);
+			if (Option.isNone(params)) continue;
+			return entry.owner(params.value);
+		}
+		return "";
+	} })
+};
+// src/cloudflare/router.ts
+const badRequest = (message) => new Response(message, {
+	status: 400,
+	headers: securityHeaders
+});
+const internalError = () => new Response("Internal server error", {
+	status: 500,
+	headers: securityHeaders
+});
+const notFound = () => new Response(null, {
+	status: 404,
+	headers: securityHeaders
+});
+/**
+* Paths whose first segment starts with `__` belong to object links and
+* other internal mounts. No package router forwards them to an object.
+*/
+const isReserved = (pathname) => pathname.startsWith("/__");
+const invalidPlacement = () => badRequest("Invalid placement key");
+const resolvePlacement = (placement, streamPath) => {
+	try {
+		const candidate = placement.name(streamPath);
+		const name = String(candidate);
+		return candidate === name && name.length > 0 ? {
+			ok: true,
+			name
+		} : {
+			ok: false,
+			response: invalidPlacement()
+		};
+	} catch {
+		return {
+			ok: false,
+			response: internalError()
+		};
+	}
+};
+const router = (options) => {
+	const path = streamPath(options.prefix);
+	const placement = options.placement ?? Placement.byStream();
+	return { fetch(request, env) {
+		const url = new URL(request.url);
+		if (isReserved(url.pathname)) return notFound();
+		const streamPath = path.strip(url.pathname);
+		if (!streamPath || streamPath === url.pathname) return badRequest(`Stream path required: ${path.requiredPathPattern()}`);
+		const child = resolvePlacement(placement, streamPath);
+		if (!child.ok) return child.response;
+		const namespace = options.namespace(env);
+		return namespace.get(namespace.idFromName(child.name)).fetch(request);
+	} };
+};
+// src/cloudflare/object-streams.ts
+/** Translate a host transport error at the Web request boundary. */
+const objectTransportError = (request, cause) => new HttpClientError.HttpClientError({ reason: new HttpClientError.TransportError({
+	request: HttpClientRequest.fromWeb(request),
+	cause
+}) });
+/** The host is never resolved. It only makes a valid base URL for `RemoteStreams`. */
+const base = "https://streamsy.internal";
+/** A namespace becomes "send to the object with this name". */
+const toObjectFetch = (objects) => Predicate.isFunction(objects) ? objects : (name, request) => Effect.tryPromise({
+	try: () => Promise.resolve(objects.get(objects.idFromName(name)).fetch(request)),
+	catch: (cause) => objectTransportError(request, cause)
+});
+/** An HTTP client that calls `fetch` in place of the network. */
+const stubClient = (send) => Layer.succeed(HttpClient.HttpClient, HttpClient.make((request, _url, signal) => HttpClientRequest.toWeb(request, { signal }).pipe(Effect.mapError((cause) => new HttpClientError.HttpClientError({ reason: new HttpClientError.InvalidUrlError({
+	request,
+	cause
+}) })), Effect.flatMap(send), Effect.map((response) => HttpClientResponse.fromWeb(request, response)))));
+/**
+* The `fetch` that `ObjectStreams` gives its HTTP client. A path outside the
+* prefix, or a stream outside the group, answers 404 here and calls no
+* object. A bad placement answers as the public router does.
+*/
+const objectRouter = (group, options) => {
+	const path = streamPath(options.prefix);
+	const send = toObjectFetch(options.objects);
+	return Effect.fn("ObjectStreams.route")(function* (request) {
+		const pathname = new URL(request.url).pathname;
+		const id = path.strip(pathname);
+		if (!id || id === pathname || !Array.some(group.streams, (stream) => stream.match(id))) return new Response(null, { status: 404 });
+		const owner = resolvePlacement(options.placement, id);
+		return owner.ok ? yield* send(owner.name, request) : owner.response;
+	});
+};
+function layer(group, options) {
+	return RemoteStreams.layer(group, {
+		baseUrl: `${base}${options.prefix}`,
+		headers: options.headers ?? {},
+		capabilities: {
+			producer: true,
+			expectedOffset: true
+		}
+	}).pipe(Layer.provide(stubClient(objectRouter(group, options))), Layer.orDie);
+}
+const ObjectStreams = { layer };
+// src/cloudflare/object-link.ts
+/**
+* One value for both sides of an internal mount between objects: the owner
+* mount and the caller client read the same group, prefix and access.
+*/
+const make = (options) => {
+	if (!/^\/__[^/]/.test(options.prefix)) throw new RangeError(`An object link prefix must start with "/__", got "${options.prefix}"`);
+	return {
+		group: options.group,
+		prefix: options.prefix,
+		routes: Http.routes(options.group, {
+			prefix: options.prefix,
+			access: options.access
+		}),
+		client: (objects) => ({
+			streams: options.group.streams,
+			layer: ObjectStreams.layer(options.group, {
+				objects,
+				placement: options.placement,
+				prefix: options.prefix
+			})
+		})
+	};
+};
+const ObjectLink = { make };
+export { resolvePlacement as a, rule as c, unavailable as d, withLinks as f, isReserved as i, acquireObject as l, ObjectStreams as n, router as o, objectTransportError as r, Placement as s, ObjectLink as t, providedApp as u };

package/dist/{wakeup--kIoqiIE.d.ts → wakeup-BJGZnq4x.d.ts}

@@ -1,4 +1,4 @@
-import { Context, Duration, Effect, Layer, Option } from "effect";
+import { Context, Effect, Layer, Option, Schedule, Scope } from "effect";
 import { Storage, StorageFault } from "@streamsy/core";
 import { DurableObjectStorage } from "@cloudflare/workers-types";
 declare const AlarmSlot_base: Context.ServiceClass<AlarmSlot, "@streamsy/serve/cloudflare/AlarmSlot", {
@@ -24,11 +24,16 @@ interface Wakeup<R = never> {
    * name is not reentrant, so a run must not call its own wakeup's `run`.
    */
   readonly run: Effect.Effect<void | WakeupProgress, unknown, R>;
-  readonly retry?: {
-    readonly initial?: Duration.Input;
-    readonly max?: Duration.Input;
-  };
+  /** Alarm retries use this schedule's delays without sleeping in an alarm. */
+  readonly retry?: Schedule.Schedule<unknown>;
+  /**
+   * Units of work that failed and wait on their own backoff, for `status`.
+   * A durable `ProjectionWakeup` counts its deferred bindings here.
+   */
+  readonly deferred?: Effect.Effect<number, StorageFault, R>;
 }
+/** The host acquires effectful wakeups in the same scope as its storage layer. */
+type WakeupSource<R = never> = Wakeup<R | Wakeups> | Effect.Effect<Wakeup<R | Wakeups>, never, R | Scope.Scope>;
 declare const Wakeup: {
   make: <R>(wakeup: Wakeup<R>) => Wakeup<R>;
 };
@@ -46,7 +51,9 @@ declare const Wakeups_base: Context.ServiceClass<Wakeups, "@streamsy/serve/cloud
     readonly failures: number;
     /** The backoff floor. The wakeup does not run before this instant. */
     readonly retryAt: Option.Option<number>;
+    /** Units that wait on their own backoff, such as failed projection bindings. */
+    readonly deferred: number;
   }>>;
 }>;
 declare class Wakeups extends Wakeups_base {}
-export { alarmSlotLayer as a, AlarmSlot as i, WakeupProgress as n, Wakeups as r, Wakeup as t };
+export { AlarmSlot as a, Wakeups as i, WakeupProgress as n, alarmSlotLayer as o, WakeupSource as r, Wakeup as t };

package/dist/{wakeup-CcJE8k3i.js → wakeup-Cb5DAcpF.js}

@@ -1,4 +1,4 @@
-import { Array, Clock, Context, Duration, Effect, Exit, Layer, Option, Predicate, Semaphore } from "effect";
+import { Array, Clock, Context, Duration, Effect, Exit, Layer, Option, Predicate, Pull, Schedule, Semaphore } from "effect";
 import { Storage } from "@streamsy/core";
 import { Protocol } from "@streamsy/core/protocol";
 // src/cloudflare/alarm.ts
@@ -9,6 +9,7 @@ const alarmSlotLayer = (storage) => Layer.succeed(AlarmSlot, {
 	clear: Effect.promise(() => storage.deleteAlarm())
 });
 // src/cloudflare/wakeup.ts
+const defaultRetry = Schedule.exponential("1 second").pipe(Schedule.modifyDelay(({ duration }) => Effect.succeed(Duration.min(duration, Duration.hours(1)))));
 const Permits = Context.Reference("@streamsy/serve/cloudflare/WakeupPermits", { defaultValue: () => void 0 });
 const Guarded = Symbol.for("@streamsy/serve/cloudflare/WakeupPermit");
 const reportsMore = (value) => Predicate.hasProperty(value, "more") && value.more;
@@ -34,7 +35,8 @@ const expiry = Wakeup.make({
 });
 /** Internal object owner. Its context closes over the same services as fetch. */
 const makeWakeups = (context, definitions = []) => Effect.gen(function* () {
-	const wakeups = Array.map([expiry, ...definitions], (wakeup) => Wakeup.make(wakeup));
+	const acquired = yield* Effect.forEach(definitions, (definition) => Effect.isEffect(definition) ? definition.pipe(Effect.provide(context)) : Effect.succeed(definition));
+	const wakeups = Array.map([expiry, ...acquired], (wakeup) => Wakeup.make(wakeup));
 	const names = /* @__PURE__ */ new Set();
 	for (const wakeup of wakeups) {
 		if (names.has(wakeup.name)) return yield* Effect.die(/* @__PURE__ */ new Error(`Duplicate wakeup name: ${wakeup.name}`));
@@ -43,32 +45,47 @@ const makeWakeups = (context, definitions = []) => Effect.gen(function* () {
 	const permits = new Map(Array.map(wakeups, (wakeup) => [wakeup.name, Semaphore.makeUnsafe(1)]));
 	const reconcilePermit = yield* Semaphore.make(1);
 	const turnPermit = yield* Semaphore.make(1);
-	const states = Array.map(wakeups, (wakeup) => ({
-		wakeup,
-		failures: 0,
-		floor: 0,
-		initial: Duration.toMillis(wakeup.retry?.initial ?? "1 second"),
-		max: Duration.toMillis(wakeup.retry?.max ?? "1 hour")
+	const states = yield* Effect.forEach(wakeups, (wakeup) => Effect.gen(function* () {
+		const policy = wakeup.retry ?? defaultRetry;
+		return {
+			wakeup,
+			failures: 0,
+			floor: 0,
+			exhausted: false,
+			policy,
+			step: yield* Schedule.toStep(policy)
+		};
 	}));
 	const slot = Context.get(context, AlarmSlot);
 	const provided = () => Context.add(Context.add(context, Permits, permits), Wakeups, service);
-	const backOff = (state, at) => {
+	const backOff = (state, at) => Effect.gen(function* () {
 		state.failures += 1;
-		state.floor = at + Math.min(state.max, state.initial * 2 ** (state.failures - 1));
-	};
-	const recover = (state) => {
+		const delay = yield* state.step(at, void 0).pipe(Effect.map(([, duration]) => Option.some(duration)), Pull.catchDone(() => Effect.succeedNone));
+		state.exhausted = Option.isNone(delay);
+		state.floor = Option.isSome(delay) ? at + Duration.toMillis(delay.value) : 0;
+	});
+	const recover = (state) => Effect.gen(function* () {
 		state.failures = 0;
 		state.floor = 0;
-	};
-	const status = Effect.forEach(states, (state) => state.wakeup.next.pipe(Effect.map((next) => ({
+		state.exhausted = false;
+		state.step = yield* Schedule.toStep(state.policy);
+	});
+	const status = Effect.forEach(states, (state) => Effect.all({
+		next: state.wakeup.next,
+		deferred: state.wakeup.deferred ?? Effect.succeed(0)
+	}).pipe(Effect.map(({ next, deferred }) => ({
 		name: state.wakeup.name,
 		next,
 		failures: state.failures,
-		retryAt: state.floor > 0 ? Option.some(state.floor) : Option.none()
+		retryAt: state.floor > 0 ? Option.some(state.floor) : Option.none(),
+		deferred
 	}))));
-	const deadlineOf = (state, now) => state.wakeup.next.pipe(Effect.map(Option.map((next) => Math.max(next, state.floor))), Effect.catchCause((cause) => {
-		if (state.floor <= now) backOff(state, now);
-		return Effect.logError(`Wakeup ${state.wakeup.name} deadline failed`, cause).pipe(Effect.as(Option.some(state.floor)));
+	const deadlineOf = (state, now) => state.exhausted ? Effect.succeedNone : state.wakeup.next.pipe(Effect.map(Option.map((next) => Math.max(next, state.floor))), Effect.catchCause((cause) => {
+		return Effect.gen(function* () {
+			if (state.floor <= now) yield* backOff(state, now);
+			yield* Effect.logError(`Wakeup ${state.wakeup.name} deadline failed`, cause);
+			return state.exhausted ? Option.none() : Option.some(state.floor);
+		});
 	}));
 	const reconcileWith = (force) => reconcilePermit.withPermit(Effect.gen(function* () {
 		const now = yield* Clock.currentTimeMillis;
@@ -95,22 +112,21 @@ const makeWakeups = (context, definitions = []) => Effect.gen(function* () {
 		const now = yield* Clock.currentTimeMillis;
 		yield* slot.arm(now + 3e4);
 		for (const state of states) yield* Effect.gen(function* () {
-			const at = yield* Clock.currentTimeMillis;
-			if (state.floor > at) return;
+			if (state.exhausted || state.floor > (yield* Clock.currentTimeMillis)) return;
 			const next = yield* state.wakeup.next;
+			const at = yield* Clock.currentTimeMillis;
 			if (Option.isNone(next) || next.value > at) return;
 			const exit = yield* Effect.exit(state.wakeup.run);
 			if (Exit.isFailure(exit)) {
-				backOff(state, yield* Clock.currentTimeMillis);
+				yield* backOff(state, yield* Clock.currentTimeMillis);
 				yield* Effect.logError(`Wakeup ${state.wakeup.name} failed`, exit.cause);
 				return;
 			}
 			const after = yield* state.wakeup.next;
-			if (!reportsMore(exit.value) && Option.isSome(after) && after.value <= at) backOff(state, yield* Clock.currentTimeMillis);
-			else recover(state);
+			if (!reportsMore(exit.value) && Option.isSome(after) && after.value <= at) yield* backOff(state, yield* Clock.currentTimeMillis);
+			else yield* recover(state);
 		}).pipe(Effect.catchCause((cause) => Clock.currentTimeMillis.pipe(Effect.flatMap((at) => {
-			backOff(state, at);
-			return Effect.logError(`Wakeup ${state.wakeup.name} deadline failed`, cause);
+			return backOff(state, at).pipe(Effect.andThen(Effect.logError(`Wakeup ${state.wakeup.name} deadline failed`, cause)));
 		}))));
 	}).pipe(Effect.ensuring(reconcileWith(true).pipe(Effect.catchCause((cause) => Effect.logError("Wakeup reconciliation failed", cause)))), Effect.catchCause((cause) => Effect.logError("Wakeup alarm failed", cause))));
 	const complete = provided();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamsy/serve",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Effect HttpRouter routes, Bun, Node, Deno and Cloudflare hosts, and durable action delivery.",
   "license": "MIT",
   "repository": {
@@ -87,7 +87,7 @@
     "test:dialects": "bun --bun vitest run test/action/outbox-dialects.test.ts"
   },
   "dependencies": {
-    "@streamsy/core": "^0.5.0"
+    "@streamsy/core": "^0.7.0"
   },
   "devDependencies": {
     "@cloudflare/workers-types": "4.20251228.0",
@@ -98,7 +98,7 @@
     "@effect/sql-pg": "4.0.5",
     "@effect/sql-sqlite-do": "4.0.5",
     "@effect/vitest": "4.0.5",
-    "@streamsy/storage": "0.5.0",
+    "@streamsy/storage": "0.7.0",
     "@types/bun": "^1.4.3",
     "alchemy": "2.0.0-beta.83",
     "effect": "4.0.5",

package/dist/placement-Cj3sd02S.d.ts

@@ -1,56 +0,0 @@
-import { r as Wakeups } from "./wakeup--kIoqiIE.js";
-import { Context, Effect, Layer, Option, Scope } from "effect";
-import { HttpRouter, HttpServerRespondable, HttpServerResponse } from "effect/http";
-import { Storage, StorageFault } from "@streamsy/core";
-type ObjectServices<R = never> = Storage | Wakeups | R;
-type ObjectApp<R = never> = Layer.Layer<never, never, HttpRouter.HttpRouter | HttpRouter.Request.From<"Requires", ObjectServices<R>> | HttpRouter.Request.From<"Error", HttpServerRespondable.Respondable>>;
-interface Placement {
-  readonly name: (streamPath: string) => string;
-}
-/** The parse side of a stream, which is all a placement rule reads. */
-interface Parser<Params> {
-  parse(id: string): Option.Option<Params>;
-}
-/**
- * One rule in a stream placement: a stream and the object name its
- * addresses belong to.
- *
- * The owner takes the same parameters its own stream decodes, so the object name
- * and the storage routing agree by construction. `owner` uses method syntax on
- * purpose: it gives the parameter its contextually typed shape at the call site
- * and keeps the rule assignable to the erased table.
- */
-interface OwnerRule<Params> {
-  readonly stream: Parser<Params>;
-  /** Names the object that owns every stream matching `stream`. */
-  owner(params: Params): string;
-}
-/**
- * A rule after its parameter type is erased. `byRoute` reads each rule only
- * through that rule's own `parse`, so the erased parameter is never observed.
- */
-interface ErasedOwnerRule {
-  readonly stream: Parser<unknown>;
-  owner(params: never): string;
-}
-/**
- * Declare one placement rule with its stream's parameters in scope.
- *
- * The helper exists so the owner parameter is typed and checked. A rule passed
- * to `Placement.byRoute` without it would see the erased parameter set instead.
- */
-declare const rule: <Params>(spec: OwnerRule<Params>) => ErasedOwnerRule;
-declare const Placement: {
-  readonly byStream: () => Placement;
-  readonly byKey: (key: (streamPath: string) => string) => Placement;
-  /**
-   * The first matching rule names the object.
-   *
-   * A path that no rule matches yields `""`, which the router turns into
-   * `400 Invalid placement key`. An owner that throws is a `500`. A rule whose
-   * stream cannot decode a segment does not own that path, so the table falls
-   * through to the next rule.
-   */
-  readonly byRoute: (rules: ReadonlyArray<ErasedOwnerRule>) => Placement;
-};
-export { ObjectServices as i, rule as n, ObjectApp as r, Placement as t };

package/dist/router-C2p1T25K.js

@@ -1,126 +0,0 @@
-import { i as makeWakeups, r as Wakeups, t as RequestTouch } from "./wakeup-CcJE8k3i.js";
-import { Context, Effect, Exit, Layer, Option, Scope } from "effect";
-import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
-import { Http } from "@streamsy/core";
-import { securityHeaders, streamPath } from "@streamsy/core/http";
-// src/cloudflare/host-program.ts
-/**
-* Reconciliation belongs to the mutation's finalizer. A request interruption
-* can be pending when the mutation's own uninterruptible region ends, so a
-* second sequential uninterruptible effect is not sufficient. A failed
-* reconciliation is logged and does not replace the mutation's result.
-*/
-const withMutationReconciliation = (effect, reconcile) => effect.pipe(Effect.ensuring(reconcile.pipe(Effect.uninterruptible, Effect.catchCause((cause) => Effect.logError("Wakeup reconciliation failed", cause)))));
-// src/cloudflare/object-runtime.ts
-/** Both object hosts install this middleware, including around user routes. */
-function objectApp(app, context) {
-	const middleware = HttpRouter.middleware((handler) => Effect.gen(function* () {
-		const request = yield* HttpServerRequest.HttpServerRequest;
-		const marker = { touched: false };
-		const wakeups = Context.get(context, Wakeups);
-		return yield* withMutationReconciliation(handler, Effect.suspend(() => [
-			"PUT",
-			"POST",
-			"DELETE"
-		].includes(request.method) || marker.touched ? wakeups.reconcile : Effect.void)).pipe(Effect.catchDefect(() => Effect.succeed(HttpServerResponse.text("Internal server error", {
-			status: 500,
-			headers: Http.securityHeaders
-		}))), Effect.provideService(RequestTouch, marker));
-	}).pipe(Effect.provide(context)), { global: true });
-	return Layer.merge(app, middleware);
-}
-const unavailable = () => HttpServerResponse.text("Storage unavailable", {
-	status: 503,
-	headers: {
-		...Http.securityHeaders,
-		"retry-after": "1"
-	}
-});
-/** One lazy successful acquisition per object owner. Failed attempts close before retry. */
-function acquireObject(layer, compile, wakeups) {
-	return Effect.gen(function* () {
-		const owner = yield* Scope.Scope;
-		return yield* Effect.gen(function* () {
-			const attempt = yield* Scope.fork(owner);
-			return yield* Effect.gen(function* () {
-				const context = yield* Layer.buildWithScope(layer, attempt);
-				const scheduler = yield* makeWakeups(context, wakeups);
-				return yield* compile(scheduler.context, scheduler.alarm).pipe(Effect.provideService(Scope.Scope, attempt));
-			}).pipe(Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(attempt, exit) : Effect.void));
-		}).pipe(Effect.cachedWithTTL((exit) => Exit.isSuccess(exit) ? "Infinity" : 0));
-	});
-}
-/** Request markers are all supplied by this exact object context. */
-function providedApp(app, context) {
-	return objectApp(app, context).pipe(HttpRouter.provideRequest(Layer.succeedContext(context)));
-}
-// src/cloudflare/placement.ts
-/**
-* Declare one placement rule with its stream's parameters in scope.
-*
-* The helper exists so the owner parameter is typed and checked. A rule passed
-* to `Placement.byRoute` without it would see the erased parameter set instead.
-*/
-const rule = (spec) => spec;
-const Placement = {
-	byStream: () => ({ name: (streamPath) => streamPath }),
-	byKey: (key) => ({ name: key }),
-	/**
-	* The first matching rule names the object.
-	*
-	* A path that no rule matches yields `""`, which the router turns into
-	* `400 Invalid placement key`. An owner that throws is a `500`. A rule whose
-	* stream cannot decode a segment does not own that path, so the table falls
-	* through to the next rule.
-	*/
-	byRoute: (rules) => ({ name: (streamPath) => {
-		for (const entry of rules) {
-			const params = entry.stream.parse(streamPath);
-			if (Option.isNone(params)) continue;
-			return entry.owner(params.value);
-		}
-		return "";
-	} })
-};
-// src/cloudflare/router.ts
-const badRequest = (message) => new Response(message, {
-	status: 400,
-	headers: securityHeaders
-});
-const internalError = () => new Response("Internal server error", {
-	status: 500,
-	headers: securityHeaders
-});
-const invalidPlacement = () => badRequest("Invalid placement key");
-const resolvePlacement = (placement, streamPath) => {
-	try {
-		const candidate = placement.name(streamPath);
-		const name = String(candidate);
-		return candidate === name && name.length > 0 ? {
-			ok: true,
-			name
-		} : {
-			ok: false,
-			response: invalidPlacement()
-		};
-	} catch {
-		return {
-			ok: false,
-			response: internalError()
-		};
-	}
-};
-const router = (options) => {
-	const path = streamPath(options.prefix);
-	const placement = options.placement ?? Placement.byStream();
-	return { fetch(request, env) {
-		const url = new URL(request.url);
-		const streamPath = path.strip(url.pathname);
-		if (!streamPath || streamPath === url.pathname) return badRequest(`Stream path required: ${path.requiredPathPattern()}`);
-		const child = resolvePlacement(placement, streamPath);
-		if (!child.ok) return child.response;
-		const namespace = options.namespace(env);
-		return namespace.get(namespace.idFromName(child.name)).fetch(request);
-	} };
-};
-export { acquireObject as a, rule as i, router as n, providedApp as o, Placement as r, unavailable as s, resolvePlacement as t };