@streamsy/serve 0.4.0 → 0.6.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,36 @@ 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. Alarms drain
+bounded passes. Retry options take an Effect `Schedule`; finite schedules stop
+on exhaustion. A crash can leave work pending until the next source commit.
+See the [projection host reference](https://streamsy.dev/docs/hosting/cloudflare#projections).

package/dist/action/contract.d.ts

@@ -1,4 +1,3 @@
-//#region src/action/contract.d.ts
 /**
  * The action-sink declaration.
  *
@@ -96,5 +95,4 @@ export interface CheckedActionSink<Payload, From extends ActionSinkRelation = Ac
 export declare function defineActionSink<Payload, From extends ActionSinkRelation>(spec: ActionSinkSpec<Payload, From>): CheckedActionSink<Payload, From>;
 /** The next backoff, in milliseconds, after `attempts` failed attempts. */
 export declare function backoffAfter(policy: ActionSinkDeliveryPolicy, attempts: number): number;
-export type PayloadOf<Sink> = Sink extends CheckedActionSink<infer Payload, infer _From> ? Payload : never;
-//#endregion
+export type PayloadOf<Sink> = Sink extends CheckedActionSink<infer Payload, infer _From> ? Payload : never;

package/dist/action/contract.js

@@ -1,5 +1,6 @@
 import { contractFingerprint } from "../contract.js";
-//#region src/action/contract.ts
+import { Array, Record } from "effect";
+// src/action/contract.ts
 function defineActionSink(spec) {
 	if (!Number.isInteger(spec.delivery.maxAttempts) || spec.delivery.maxAttempts < 1) throw new TypeError(`action sink ${spec.name} must declare at least one delivery attempt`);
 	if (spec.delivery.backoffFactor < 1) throw new TypeError(`action sink ${spec.name} must not shrink its backoff`);
@@ -9,7 +10,7 @@ function defineActionSink(spec) {
 		name: spec.name,
 		key,
 		handler: { ...spec.handler },
-		delivery: Object.fromEntries(Object.entries(spec.delivery).map(([name, value]) => [name, Number.isFinite(value) ? value : String(value)]))
+		delivery: Record.fromEntries(Array.map(Record.toEntries(spec.delivery), ([name, value]) => [name, Number.isFinite(value) ? value : String(value)]))
 	});
 	return Object.freeze({
 		...spec,
@@ -24,5 +25,4 @@ function backoffAfter(policy, attempts) {
 	const raw = policy.initialBackoffMs * policy.backoffFactor ** exponent;
 	return Math.min(policy.maxBackoffMs, Math.round(raw));
 }
-//#endregion
 export { backoffAfter, defineActionSink };

package/dist/action/errors.d.ts

@@ -1,6 +1,4 @@
-import { Schema } from "effect";
-import * as Cause$1 from "effect/Cause";
-//#region src/action/errors.d.ts
+import { Cause, Schema } from "effect";
 export declare const ACTION_SINK_ERROR_TAGS: readonly ["ActionSinkDeliveryFailure", "OutboxUnavailable"];
 export type ActionSinkErrorTag = (typeof ACTION_SINK_ERROR_TAGS)[number];
 /** The durable outbox could not be read or written. Never a delivery outcome. */
@@ -8,7 +6,7 @@ type OutboxUnavailableSchema = Schema.TaggedStruct<"OutboxUnavailable", {
   readonly operation: Schema.String;
   readonly detail: Schema.String;
 }>;
-declare const OutboxUnavailableBase: Schema.Class<OutboxUnavailable, OutboxUnavailableSchema, Cause$1.YieldableError>;
+declare const OutboxUnavailableBase: Schema.Class<OutboxUnavailable, OutboxUnavailableSchema, Cause.YieldableError>;
 export declare class OutboxUnavailable extends OutboxUnavailableBase {}
 /**
  * A handler refused one delivery.
@@ -23,7 +21,7 @@ type ActionSinkDeliveryFailureSchema = Schema.TaggedStruct<"ActionSinkDeliveryFa
   readonly detail: Schema.String;
   readonly retryable: Schema.Boolean;
 }>;
-declare const ActionSinkDeliveryFailureBase: Schema.Class<ActionSinkDeliveryFailure, ActionSinkDeliveryFailureSchema, Cause$1.YieldableError>;
+declare const ActionSinkDeliveryFailureBase: Schema.Class<ActionSinkDeliveryFailure, ActionSinkDeliveryFailureSchema, Cause.YieldableError>;
 export declare class ActionSinkDeliveryFailure extends ActionSinkDeliveryFailureBase {
   static retryable(handler: string, idempotencyKey: string, detail: string): ActionSinkDeliveryFailure;
   static permanent(handler: string, idempotencyKey: string, detail: string): ActionSinkDeliveryFailure;
@@ -31,5 +29,4 @@ export declare class ActionSinkDeliveryFailure extends ActionSinkDeliveryFailure
 /** Why one outbox entry stopped being retried. */
 export declare const DEAD_LETTER_REASONS: readonly ["attempts-exhausted", "permanent", "payload-poison"];
 export type DeadLetterReason = (typeof DEAD_LETTER_REASONS)[number];
-//#endregion
 export {};

package/dist/action/errors.js

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-//#region src/action/errors.ts
+// src/action/errors.ts
 /**
 * Typed action-sink failures.
 *
@@ -47,5 +47,4 @@ const DEAD_LETTER_REASONS = [
 	"permanent",
 	"payload-poison"
 ];
-//#endregion
 export { ACTION_SINK_ERROR_TAGS, ActionSinkDeliveryFailure, DEAD_LETTER_REASONS, OutboxUnavailable };

package/dist/action/outbox.d.ts

@@ -1,6 +1,5 @@
 import { DeadLetterReason, OutboxUnavailable } from "./errors.js";
 import { Context, Effect, Layer, Option } from "effect";
-//#region src/action/outbox.d.ts
 export type OutboxEntryState = "pending" | "delivered" | "dead";
 export interface OutboxEntry {
   /** Monotonic enqueue order. Delivery walks a lane in this order. */
@@ -63,5 +62,4 @@ export declare const outboxStoreLayer: (backing: OutboxBacking) => Layer.Layer<O
  * host behaves the same way on the durable one.
  */
 export declare function makeMemoryOutboxBacking(): OutboxBacking;
-//#endregion
 export {};

package/dist/action/outbox.js

@@ -1,6 +1,6 @@
 import "./errors.js";
-import { Context, Effect, Layer, Option } from "effect";
-//#region src/action/outbox.ts
+import { Array, Context, Effect, Layer, Option, Order } from "effect";
+// src/action/outbox.ts
 /**
 * The durable outbox.
 *
@@ -35,7 +35,7 @@ function makeMemoryOutboxBacking() {
 			...patch
 		});
 	};
-	const ordered = () => [...entries.values()].toSorted((left, right) => left.id - right.id);
+	const ordered = () => Array.sort([...entries.values()], Order.mapInput(Order.Number, (entry) => entry.id));
 	return {
 		enqueue: (drafts) => Effect.sync(() => {
 			let enqueued = 0;
@@ -72,11 +72,11 @@ function makeMemoryOutboxBacking() {
 			};
 		}),
 		nextDue: (sink, partitionId, inOrder = false) => Effect.sync(() => {
-			const pending = ordered().filter((entry) => entry.sink === sink && entry.state === "pending" && (partitionId === void 0 || entry.partitionId === partitionId));
+			const pending = Array.filter(ordered(), (entry) => entry.sink === sink && entry.state === "pending" && (partitionId === void 0 || entry.partitionId === partitionId));
 			const first = pending[0];
-			return first === void 0 ? Option.none() : Option.some(inOrder ? first.nextAttemptAtMs : pending.reduce((at, entry) => Math.min(at, entry.nextAttemptAtMs), Infinity));
+			return first === void 0 ? Option.none() : Option.some(inOrder ? first.nextAttemptAtMs : Array.reduce(pending, Infinity, (at, entry) => Math.min(at, entry.nextAttemptAtMs)));
 		}),
-		claimDue: (sink, partitionId, nowMs, limit, inOrder = false) => Effect.sync(() => ordered().filter((entry) => entry.sink === sink && entry.state === "pending" && (inOrder || entry.nextAttemptAtMs <= nowMs) && (partitionId === void 0 || entry.partitionId === partitionId)).slice(0, limit)),
+		claimDue: (sink, partitionId, nowMs, limit, inOrder = false) => Effect.sync(() => Array.filter(ordered(), (entry) => entry.sink === sink && entry.state === "pending" && (inOrder || entry.nextAttemptAtMs <= nowMs) && (partitionId === void 0 || entry.partitionId === partitionId)).slice(0, limit)),
 		markDelivered: (id, attempts, atMs) => Effect.sync(() => {
 			replace(id, {
 				state: "delivered",
@@ -102,8 +102,7 @@ function makeMemoryOutboxBacking() {
 				settledAtMs: atMs
 			});
 		}),
-		list: (sink, partitionId) => Effect.sync(() => ordered().filter((entry) => entry.sink === sink && (partitionId === void 0 || entry.partitionId === partitionId)))
+		list: (sink, partitionId) => Effect.sync(() => Array.filter(ordered(), (entry) => entry.sink === sink && (partitionId === void 0 || entry.partitionId === partitionId)))
 	};
 }
-//#endregion
 export { OutboxStore, makeMemoryOutboxBacking, outboxStore, outboxStoreLayer };

package/dist/action/runtime.d.ts

@@ -1,9 +1,8 @@
 import { ActionSinkRelation, CheckedActionSink } from "./contract.js";
 import { ActionSinkDeliveryFailure, OutboxUnavailable } from "./errors.js";
 import { OutboxDraft, OutboxStore } from "./outbox.js";
-import { t as Wakeup } from "../wakeup-BtnMEjLv.js";
+import { t as Wakeup } from "../wakeup-Cy6pvhmx.js";
 import { Effect } from "effect";
-//#region src/action/runtime.d.ts
 /** One attempt at one delivery, as the handler sees it. */
 export interface ActionSinkDelivery<Payload> {
   readonly entryId: number;
@@ -76,5 +75,4 @@ export declare const drain: <Payload, From extends ActionSinkRelation, Requireme
  */
 export declare const OutboxWakeup: {
   make: <Payload, From extends ActionSinkRelation, R = never>(sink: CheckedActionSink<Payload, From>, handler: ActionSinkHandler<Payload, R>, options?: DrainOptions) => Wakeup<OutboxStore | R>;
-};
-//#endregion
+};

package/dist/action/runtime.js

@@ -1,10 +1,10 @@
 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 { n as Wakeup } from "../wakeup-eIs0xIUh.js";
+import { Array, Cause, Clock, Effect, Exit, Option, Semaphore } from "effect";
 import { StorageFault } from "@streamsy/core";
-//#region src/action/runtime.ts
+// src/action/runtime.ts
 /**
 * The delivery runtime: one bounded, serialized pass over a sink's outbox.
 *
@@ -41,7 +41,7 @@ function actionSinkHandler(sink, deliver) {
 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) => ({
+	return Array.map(payloads, (payload) => ({
 		sink: sink.name,
 		partitionId: sink.partitionBy(payload),
 		idempotencyKey: sink.idempotencyKey(payload),
@@ -147,8 +147,8 @@ function decodePayload(sink, entry) {
 }
 /** 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;
+	const declared = Array.findFirst(cause.reasons, Cause.isFailReason);
+	if (Option.isSome(declared)) return declared.value.error;
 	return ActionSinkDeliveryFailure.retryable(sink.handler.name, entry.idempotencyKey, Cause.pretty(cause).slice(0, 500));
 }
 function deadLetterReason(sink, attempt, failure) {
@@ -178,5 +178,4 @@ 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

@@ -1,8 +1,6 @@
 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
+import { SqlClient } from "effect/sql";
+export declare function migrateOutbox(sql: SqlClient.SqlClient): Effect.Effect<void, OutboxUnavailable>;
+export declare function createSqlOutboxBacking(sql: SqlClient.SqlClient): OutboxBacking;

package/dist/action/sql.js

@@ -1,6 +1,6 @@
 import { OutboxUnavailable } from "./errors.js";
-import { Effect, Option, Predicate, Schema } from "effect";
-//#region src/action/sql.ts
+import { Array, Effect, Option, Predicate, Schema } from "effect";
+// 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;
@@ -80,7 +80,7 @@ const unsupported = (operation) => Effect.fail(new OutboxUnavailable({
 }));
 /** 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))));
+ WHERE table_schema = DATABASE() AND table_name = ${TABLE}`.pipe(Effect.map((rows) => new Set(Array.map(rows, ({ 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({
@@ -94,7 +94,7 @@ const migrateMysql = (sql) => Effect.gen(function* () {
 	}
 });
 function migrateOutbox(sql) {
-	const statements = (dialect) => Effect.forEach([CREATE_TABLE[dialect], ...INDEXES.map((index) => createIndex(index, true))], (statement) => sql.unsafe(statement), { discard: true });
+	const statements = (dialect) => Effect.forEach([CREATE_TABLE[dialect], ...Array.map(INDEXES, (index) => createIndex(index, true))], (statement) => sql.unsafe(statement), { discard: true });
 	return attempt("migrateOutbox", sql.onDialectOrElse({
 		sqlite: () => statements("sqlite"),
 		pg: () => statements("pg"),
@@ -106,7 +106,7 @@ function migrateOutbox(sql) {
 * 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({
+const mysqlReady = (sql) => Effect.flatMap(mysqlIndexes(sql), (names) => Array.every(INDEXES, (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`
 })));
@@ -144,7 +144,7 @@ function createSqlOutboxBacking(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)));
+	const rows = (operation, statement) => run(operation, statement).pipe(Effect.map((found) => Array.map(found, (row) => decodeRow(row))));
 	/** Whether the draft was new. A draft with a known sink and key changes nothing. */
 	const insert = (draft) => {
 		const row = sql.insert({
@@ -225,5 +225,4 @@ function decodeReason(value) {
 	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

@@ -1,25 +1,29 @@
-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 { a as AlarmSlot, i as Wakeups, n as WakeupProgress, o as alarmSlotLayer, r as WakeupSource, t as Wakeup } from "./wakeup-Cy6pvhmx.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-BbxO01Z5.js";
 import { Effect, Layer, Scope } from "effect";
-import { HttpServerRequest, HttpServerResponse } from "effect/http";
+import { HttpServerError, 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>;
+}) => 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>;
-//#endregion
-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,9 +1,9 @@
-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 { a as alarmSlotLayer, n as Wakeup, r as Wakeups } from "./wakeup-eIs0xIUh.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-HD-tFY4o.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
+// src/alchemy.ts
 /** An Alchemy HttpEffect; authenticate before evaluating this router. */
 const router = (options) => {
 	const path = streamPath(options.prefix);
@@ -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,5 +47,4 @@ function objectHandlers(options) {
 		};
 	});
 }
-//#endregion
-export { Placement, Wakeup, Wakeups, alarmSlotLayer, objectHandlers, router, rule };
+export { ObjectLink, ObjectStreams, Placement, Wakeup, Wakeups, alarmSlotLayer, objectFetch, objectHandlers, router, rule };

package/dist/bun.d.ts

@@ -1,5 +1,4 @@
 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 {
@@ -9,5 +8,4 @@ export interface ListenerOptions {
   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
+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>;

package/dist/bun.js

@@ -1,5 +1,5 @@
 import { BunHttpServer } from "@effect/platform-bun";
-//#region src/bun.ts
+// src/bun.ts
 const DEFAULT_PORT = 3e3;
 const DEFAULT_HOSTNAME = "127.0.0.1";
 const listenerOptions = (options) => ({
@@ -10,5 +10,4 @@ const listenerOptions = (options) => ({
 });
 /** 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

@@ -1,35 +1,37 @@
-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 { i as Wakeups, n as WakeupProgress, o as alarmSlotLayer, r as WakeupSource, t as Wakeup } from "./wakeup-Cy6pvhmx.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-BbxO01Z5.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 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>;
 };
-//#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 };
+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,15 +1,15 @@
-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 { a as alarmSlotLayer, n as Wakeup, r as Wakeups } from "./wakeup-eIs0xIUh.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-HD-tFY4o.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
+// 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* () {
+		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,5 +36,4 @@ const StreamsyObject = { make: (configuration) => class extends ObjectHost {
 		super(state, env, configuration);
 	}
 } };
-//#endregion
-export { Placement, StreamsyObject, Wakeup, Wakeups, alarmSlotLayer, router, rule };
+export { ObjectLink, ObjectStreams, Placement, StreamsyObject, Wakeup, Wakeups, alarmSlotLayer, router, rule };

package/dist/{contract-BUWJ-Sy2.d.ts → contract-CFoMXKuH.d.ts}

@@ -1,4 +1,3 @@
-//#region src/contract.d.ts
 /**
  * Canonical encoding and the change-detection digests served routes need.
  *
@@ -63,5 +62,4 @@ declare const PUBLIC_ERROR_TAGS: readonly ["InvalidParams", "ProtocolVersionUnsu
 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

@@ -1,2 +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";
+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-CFoMXKuH.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 };

package/dist/contract.js

@@ -1,7 +1,19 @@
-//#region src/contract.ts
+import { Array, Order, Record } from "effect";
+// src/contract.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.
+*/
 /** Encode a value with object keys sorted, recursively. Array order is preserved. */
 function canonicalJson(value) {
-	if (isCanonicalArray(value)) return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+	if (isCanonicalArray(value)) return `[${Array.join(Array.map(value, (item) => canonicalJson(item)), ",")}]`;
 	if (value === null) return "null";
 	if (value instanceof Object) return canonicalObject(value);
 	if (typeof value === "number" && !Number.isFinite(value)) throw new TypeError("Expected finite JSON number");
@@ -16,16 +28,12 @@ function isCanonicalArray(value) {
 }
 function canonicalObject(value) {
 	const entries = [];
-	for (const key of Object.keys(value).toSorted(compareKeys)) {
+	for (const key of Array.sort(Record.keys(value), Order.String)) {
 		const member = value[key];
 		if (member === void 0) continue;
 		entries.push(`${JSON.stringify(key)}:${canonicalJson(member)}`);
 	}
-	return `{${entries.join(",")}}`;
-}
-function compareKeys(left, right) {
-	if (left === right) return 0;
-	return left < right ? -1 : 1;
+	return `{${Array.join(entries, ",")}}`;
 }
 /** Eight lowercase hex characters of FNV-1a over the canonical encoding's UTF-16 code units. */
 function contractFingerprint(value) {
@@ -120,5 +128,4 @@ function decodePublicError(value) {
 		default: throw new TypeError("Unknown public error tag");
 	}
 }
-//#endregion
 export { DURABLE_STATE_PROTOCOL, PUBLIC_ERROR_TAGS, STATE_CONTRACT_HEADER, STATE_VERSION_HEADER, STREAM_CONTRACT_HEADER, STREAM_VERSION_HEADER, VALUE_CONTRACT_HEADER, canonicalJson, contractFingerprint, decodePublicError, valueEtag };

package/dist/deno.d.ts

@@ -1,5 +1,4 @@
 import { Duration, Effect } from "effect";
-//#region src/deno.d.ts
 export declare const DEFAULT_PORT = 3000;
 export declare const DEFAULT_HOSTNAME = "127.0.0.1";
 export interface ListenerOptions {
@@ -23,5 +22,4 @@ export declare const listener: (options?: ListenerOptions) => import("effect/Lay
  * );
  * ```
  */
-export declare const nodeSqliteCompat: Effect.Effect<void>;
-//#endregion
+export declare const nodeSqliteCompat: Effect.Effect<void>;

package/dist/deno.js

@@ -1,6 +1,6 @@
 import { Effect } from "effect";
 import { DenoHttpServer } from "@effect/platform-deno";
-//#region src/deno.ts
+// src/deno.ts
 const DEFAULT_PORT = 3e3;
 const DEFAULT_HOSTNAME = "127.0.0.1";
 const listenerOptions = (options) => ({
@@ -28,5 +28,4 @@ const nodeSqliteCompat = Effect.promise(() => import("node:sqlite")).pipe(Effect
 	const prototype = DatabaseSync.prototype;
 	if (prototype.enableLoadExtension === void 0) prototype.enableLoadExtension = () => {};
 })));
-//#endregion
 export { DEFAULT_HOSTNAME, DEFAULT_PORT, listener, nodeSqliteCompat };