@streamsy/serve 0.4.0 → 0.6.0

package/dist/index.d.ts

@@ -1,10 +1,9 @@
-import { t as CanonicalValue } from "./contract-BUWJ-Sy2.js";
+import { t as CanonicalValue } from "./contract-CFoMXKuH.js";
 import { Duration, Effect, Layer, Runtime, Schema } from "effect";
 import { HttpRouter, HttpServerRequest, HttpServerRespondable, HttpServerResponse } from "effect/http";
 import { Http, StreamAddress, Streamsy } from "@streamsy/core";
 import { StreamRoute } from "@streamsy/core/protocol";
 import { ShutdownSignal } from "@streamsy/core/http";
-//#region src/errors.d.ts
 /** The public error body. `cases` gives one validating constructor per tag. */
 export declare const PublicErrorSchema: Schema.TaggedUnion<{
   readonly ContractChanged: Schema.TaggedStruct<"ContractChanged", {
@@ -95,8 +94,6 @@ declare class WireEncodeFailed extends WireEncodeFailed_base {
   [HttpServerRespondable.symbol](): Effect.Effect<HttpServerResponse.HttpServerResponse, never, never>;
 }
 type ServeError = InvalidParams | ProtocolVersionUnsupported | ResumeRejected | ContractChanged | TransportUnavailable | WireEncodeFailed;
-//#endregion
-//#region src/host.d.ts
 type DefaultServeRequires<R> = HttpRouter.Request.Only<"Requires", R> | HttpRouter.Request.Only<"GlobalRequires", R>;
 /** The options of `HttpRouter.serve`, plus the drain bound. */
 type LayerOptions<R = never, HE = never, HR = DefaultServeRequires<R>> = NonNullable<Parameters<typeof HttpRouter.serve<unknown, unknown, R, HE, HR>>[1]> & {
@@ -155,8 +152,8 @@ declare function mount<P, A, K, RD, RE, const Path extends `/${string}`>(declara
 }, path: Path & ExactPath<Path, NoInfer<P>>, options?: ReadOptions): import("effect/Layer").Layer<never, never, HttpRouter.HttpRouter | HttpRouter.Request<"Error", InvalidParams> | HttpRouter.Request<"Error", ProtocolVersionUnsupported> | HttpRouter.Request<"Error", ResumeRejected> | HttpRouter.Request<"Error", TransportUnavailable> | HttpRouter.Request<"Error", WireEncodeFailed> | HttpRouter.Request.From<"Requires", Exclude<K, HttpRouter.Provided>>>;
 /** Durable Streams response for one resolved address. */
 declare function stream<A, K, RD, RE>(address: Streamsy.Address<A, K, RD, RE>, options?: ReadOptions): Effect.Effect<HttpServerResponse.HttpServerResponse, ProtocolVersionUnsupported | ResumeRejected | TransportUnavailable | WireEncodeFailed, K | HttpServerRequest.HttpServerRequest | HttpRouter.RouteContext>;
-/** Durable State change response with replay-from-start recovery. */
-declare function state<C extends StreamAddress.Collections, K, RD, RE>(address: StreamAddress.StateAddress<C, RD, RE> & Streamsy.Address<StreamAddress.CollectionsChange<C>, K, RD, RE>, options?: ReadOptions): Effect.Effect<HttpServerResponse.HttpServerResponse, ProtocolVersionUnsupported | ResumeRejected | TransportUnavailable | WireEncodeFailed, K | HttpServerRequest.HttpServerRequest | HttpRouter.RouteContext>;
+/** Durable State response with replay-from-start recovery. Stored controls pass through. */
+declare function state<C extends StreamAddress.Collections, K, RD, RE>(address: StreamAddress.StateAddress<C, RD, RE> & Streamsy.Address<StreamAddress.CollectionsEvent<C>, K, RD, RE>, options?: ReadOptions): Effect.Effect<HttpServerResponse.HttpServerResponse, ProtocolVersionUnsupported | ResumeRejected | TransportUnavailable | WireEncodeFailed, K | HttpServerRequest.HttpServerRequest | HttpRouter.RouteContext>;
 interface ValueOptions {
   readonly cache?: {
     readonly visibility: "private" | "public";
@@ -167,5 +164,4 @@ interface ValueOptions {
 }
 /** Canonical JSON response for any computation, including mapped projection state. */
 declare const value: <A, I extends CanonicalValue, E, R, RE>(schema: Schema.Codec<A, I, never, RE>, compute: Effect.Effect<A, E, R>, options?: ValueOptions | undefined) => Effect.Effect<HttpServerResponse.HttpServerResponse, E | ContractChanged | WireEncodeFailed, R | RE | HttpServerRequest.HttpServerRequest | HttpRouter.RouteContext>;
-//#endregion
 export { serve_d_exports as Serve };

package/dist/index.js

@@ -1,11 +1,11 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.js";
 import { STATE_CONTRACT_HEADER, STATE_VERSION_HEADER, STREAM_CONTRACT_HEADER, STREAM_VERSION_HEADER, VALUE_CONTRACT_HEADER, canonicalJson, contractFingerprint, valueEtag } from "./contract.js";
-import { Cause, Duration, Effect, Exit, Layer, Runtime, Schema } from "effect";
+import { Array, Cause, Duration, Effect, Exit, Layer, Order, Record, Runtime, Schema } from "effect";
 import { HttpRouter, HttpServerRequest, HttpServerRespondable, HttpServerResponse } from "effect/http";
 import { Http, Offset } from "@streamsy/core";
 import { StreamsReader } from "@streamsy/core/protocol";
 import { ShutdownSignal, layerShutdownSignal } from "@streamsy/core/http";
-//#region src/errors.ts
+// src/errors.ts
 /** The public error body. `cases` gives one validating constructor per tag. */
 const PublicErrorSchema = Schema.TaggedUnion({
 	InvalidParams: {
@@ -92,8 +92,7 @@ function errorResponse(error, status, headers) {
 		}
 	});
 }
-//#endregion
-//#region src/host.ts
+// src/host.ts
 const drain = (timeout = Duration.seconds(2)) => (serve) => {
 	return Layer.effectDiscard(Effect.gen(function* () {
 		const signal = yield* ShutdownSignal;
@@ -131,8 +130,7 @@ const layer = (routes, options) => HttpRouter.serve(routes, options).pipe(drain(
 * caused. In a `Layer.launch` main the fiber ends only on failure or a signal.
 */
 const teardown = (exit, onExit) => Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause) ? onExit(0) : Runtime.defaultTeardown(exit, onExit);
-//#endregion
-//#region src/serve.ts
+// src/serve.ts
 var serve_exports = /* @__PURE__ */ __exportAll({
 	ContractChanged: () => ContractChanged,
 	InvalidParams: () => InvalidParams,
@@ -187,7 +185,7 @@ function mount(declaration, path, options) {
 function stream(address, options = {}) {
 	return read(address, options, "stream", Effect.succeed(null));
 }
-/** Durable State change response with replay-from-start recovery. */
+/** Durable State response with replay-from-start recovery. Stored controls pass through. */
 function state(address, options = {}) {
 	return read(address, options, "state", collectionDescriptor(address.collections));
 }
@@ -198,7 +196,7 @@ function collectionDescriptor(value) {
 			route: matchedRoute.path,
 			detail: "Invalid collection metadata"
 		})));
-		return Object.fromEntries(Object.entries(collections).map(([type, collection]) => [type, collection.key]));
+		return Record.fromEntries(Array.map(Record.toEntries(collections), ([type, collection]) => [type, collection.key]));
 	});
 }
 const read = Effect.fn("Serve.read")(function* (address, options, kind, descriptor) {
@@ -215,7 +213,7 @@ const read = Effect.fn("Serve.read")(function* (address, options, kind, descript
 		source,
 		id: address.id,
 		collections,
-		params: path.split("/").filter((segment) => segment.startsWith(":")).map((segment) => segment.slice(1)).toSorted(),
+		params: Array.sort(Array.map(Array.filter(path.split("/"), (segment) => segment.startsWith(":")), (segment) => segment.slice(1)), Order.String),
 		version: 1,
 		recovery: "replay-from-start",
 		contract: options.contract ?? null
@@ -324,7 +322,8 @@ const value = Effect.fn("Serve.value")(function* (schema, compute, options = {})
 		"cache-control": cacheControl,
 		etag
 	};
-	if (request.headers["if-none-match"]?.split(",").some((tag) => tag.trim() === "*" || tag.trim().replace(/^W\//, "") === etag)) return HttpServerResponse.empty({
+	const ifNoneMatch = request.headers["if-none-match"];
+	if (ifNoneMatch !== void 0 && Array.some(ifNoneMatch.split(","), (tag) => tag.trim() === "*" || tag.trim().replace(/^W\//, "") === etag)) return HttpServerResponse.empty({
 		status: 304,
 		headers: responseHeaders
 	});
@@ -333,5 +332,4 @@ const value = Effect.fn("Serve.value")(function* (schema, compute, options = {})
 		"content-type": "application/json"
 	} });
 });
-//#endregion
 export { PublicErrorSchema, serve_exports as Serve };

package/dist/node.d.ts

@@ -1,7 +1,6 @@
 import { Duration, Layer } from "effect";
 import { HttpServer } from "effect/http";
 import { ServerOptions } from "node:http";
-//#region src/node.d.ts
 export declare const DEFAULT_PORT = 3000;
 export declare const DEFAULT_HOSTNAME = "127.0.0.1";
 export interface ListenerOptions {
@@ -16,5 +15,4 @@ export interface ListenerOptions {
   readonly gracefulShutdownTimeout?: Duration.Input;
 }
 /** The Node listener for a Streamsy host. */
-export declare const listener: (options?: ListenerOptions) => Layer.Layer<import("effect/http/Etag").Generator | import("effect/http/HttpPlatform").HttpPlatform | HttpServer.HttpServer | import("@effect/platform-node/NodeServices").NodeServices, import("effect/http/HttpServerError").ServeError, never>;
-//#endregion
+export declare const listener: (options?: ListenerOptions) => Layer.Layer<import("effect/http/Etag").Generator | import("effect/http/HttpPlatform").HttpPlatform | HttpServer.HttpServer | import("@effect/platform-node/NodeServices").NodeServices, import("effect/http/HttpServerError").ServeError, never>;

package/dist/node.js

@@ -2,7 +2,7 @@ import { Effect, Layer } from "effect";
 import { HttpServer, HttpServerResponse } from "effect/http";
 import { createServer } from "node:http";
 import { NodeHttpServer } from "@effect/platform-node";
-//#region src/node.ts
+// src/node.ts
 const DEFAULT_PORT = 3e3;
 const DEFAULT_HOSTNAME = "127.0.0.1";
 const listenOptions = (options) => ({
@@ -54,5 +54,4 @@ const createUnavailableAwareServer = (options) => {
 };
 /** The Node listener for a Streamsy host. */
 const listener = (options = {}) => nodeServer.pipe(Layer.provideMerge(NodeHttpServer.layer(() => createUnavailableAwareServer(options.server ?? {}), listenOptions(options))));
-//#endregion
 export { DEFAULT_HOSTNAME, DEFAULT_PORT, listener };

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

@@ -0,0 +1,118 @@
+import { i as Wakeups } from "./wakeup-Cy6pvhmx.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-HD-tFY4o.js

@@ -0,0 +1,230 @@
+import { i as makeWakeups, r as Wakeups, t as RequestTouch } from "./wakeup-eIs0xIUh.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/{rolldown-runtime-D7D4PA-g.js → rolldown-runtime-D8jQpDG7.js}

@@ -1,4 +1,4 @@
-//#region \0rolldown/runtime.js
+// \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -9,5 +9,4 @@ var __exportAll = (all, no_symbols) => {
 	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
-//#endregion
 export { __exportAll as t };

package/dist/{wakeup-BtnMEjLv.d.ts → wakeup-Cy6pvhmx.d.ts}

@@ -1,7 +1,6 @@
-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";
-//#region src/cloudflare/alarm.d.ts
 declare const AlarmSlot_base: Context.ServiceClass<AlarmSlot, "@streamsy/serve/cloudflare/AlarmSlot", {
   readonly current: Effect.Effect<Option.Option<number>>;
   readonly arm: (at: number) => Effect.Effect<void>;
@@ -9,8 +8,6 @@ declare const AlarmSlot_base: Context.ServiceClass<AlarmSlot, "@streamsy/serve/c
 }>;
 declare class AlarmSlot extends AlarmSlot_base {}
 declare const alarmSlotLayer: (storage: DurableObjectStorage) => Layer.Layer<AlarmSlot>;
-//#endregion
-//#region src/cloudflare/wakeup.d.ts
 /**
  * A bounded run that stopped at its bound returns `{ more: true }`. The
  * scheduler then re-arms at once and does not count the pass as a failure.
@@ -27,11 +24,11 @@ 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>;
 }
+/** 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>;
 };
@@ -52,5 +49,4 @@ declare const Wakeups_base: Context.ServiceClass<Wakeups, "@streamsy/serve/cloud
   }>>;
 }>;
 declare class Wakeups extends Wakeups_base {}
-//#endregion
-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 };