@electric-ax/agents-server 0.4.2 → 0.4.3

package/dist/entrypoint.js

@@ -331,76 +331,6 @@ async function runMigrations(postgresUrl) {
 	await migrationClient.end();
 }
 
-//#endregion
-//#region src/routing/tenant-stream-paths.ts
-function withoutLeadingSlash(path$1) {
-	return path$1.replace(/^\/+/, ``);
-}
-function withLeadingSlash(path$1) {
-	return path$1.startsWith(`/`) ? path$1 : `/${path$1}`;
-}
-function prefixTenantStreamPath(path$1, tenantId) {
-	const normalized = withoutLeadingSlash(path$1);
-	if (!normalized || normalized === tenantId) return tenantId;
-	if (normalized.startsWith(`${tenantId}/`)) return normalized;
-	return `${tenantId}/${normalized}`;
-}
-function stripTenantStreamPrefix(path$1, tenantId) {
-	const normalized = withoutLeadingSlash(path$1);
-	if (normalized === tenantId) return ``;
-	if (normalized.startsWith(`${tenantId}/`)) return normalized.slice(tenantId.length + 1);
-	return normalized;
-}
-
-//#endregion
-//#region src/routing/durable-streams-routing-adapter.ts
-function appendSearch(target, source) {
-	target.search = source.search;
-	return target;
-}
-function removeServiceQuery(target) {
-	target.searchParams.delete(`service`);
-	return target;
-}
-function logicalStreamPathFromRequest(requestUrl, serviceId) {
-	const incomingUrl = new URL(requestUrl, `http://localhost`);
-	const segments = incomingUrl.pathname.split(`/`).filter(Boolean);
-	if (segments[0] === `v1` && segments[1] === `stream`) return {
-		incomingUrl,
-		streamPath: segments.length > 2 ? `/${segments.slice(3).join(`/`)}` : `/`
-	};
-	return {
-		incomingUrl,
-		streamPath: incomingUrl.pathname || `/${serviceId}`
-	};
-}
-function backendStreamUrl(input, backendStreamPath) {
-	const path$1 = backendStreamPath.replace(/^\/+/, ``);
-	const target = new URL(`/v1/stream/${path$1}`, input.durableStreamsUrl);
-	return target;
-}
-function streamMetaUrlWithoutService(input) {
-	const incomingUrl = new URL(input.requestUrl, `http://localhost`);
-	return removeServiceQuery(appendSearch(new URL(incomingUrl.pathname, input.durableStreamsUrl), incomingUrl));
-}
-const pathPrefixedSingleTenantDurableStreamsRoutingAdapter = {
-	streamUrl(input) {
-		const { incomingUrl, streamPath } = logicalStreamPathFromRequest(input.requestUrl, input.serviceId);
-		const target = backendStreamUrl(input, prefixTenantStreamPath(streamPath, input.serviceId));
-		return removeServiceQuery(appendSearch(target, incomingUrl));
-	},
-	streamMetaUrl: streamMetaUrlWithoutService,
-	toBackendStreamPath(serviceId, streamPath) {
-		return prefixTenantStreamPath(streamPath, serviceId);
-	},
-	toRuntimeStreamPath(serviceId, streamPath) {
-		return stripTenantStreamPrefix(streamPath, serviceId);
-	}
-};
-function resolveDurableStreamsRoutingAdapter(adapter) {
-	return adapter ?? pathPrefixedSingleTenantDurableStreamsRoutingAdapter;
-}
-
 //#endregion
 //#region src/electric-agents-http.ts
 function apiError(status$1, code, message, details) {
@@ -501,6 +431,40 @@ function electricUrlWithPath(electricUrl, path$1) {
 	return target;
 }
 
+//#endregion
+//#region src/routing/durable-streams-routing-adapter.ts
+function appendSearch(target, source) {
+	target.search = source.search;
+	return target;
+}
+function removeServiceQuery(target) {
+	target.searchParams.delete(`service`);
+	return target;
+}
+function withoutTrailingSlash(pathname) {
+	return pathname.replace(/\/+$/, ``) || `/`;
+}
+function appendRequestPathToStreamRoot(input) {
+	const incomingUrl = new URL(input.requestUrl, `http://localhost`);
+	const path$1 = incomingUrl.pathname.replace(/^\/+/, ``);
+	const target = new URL(input.durableStreamsUrl);
+	target.pathname = path$1 ? `${withoutTrailingSlash(target.pathname)}/${path$1}` : withoutTrailingSlash(target.pathname);
+	return removeServiceQuery(appendSearch(target, incomingUrl));
+}
+const streamRootDurableStreamsRoutingAdapter = {
+	streamUrl: appendRequestPathToStreamRoot,
+	controlUrl: appendRequestPathToStreamRoot,
+	toBackendStreamPath(_serviceId, streamPath) {
+		return streamPath.replace(/^\/+/, ``);
+	},
+	toRuntimeStreamPath(_serviceId, streamPath) {
+		return streamPath.replace(/^\/+/, ``);
+	}
+};
+function resolveDurableStreamsRoutingAdapter(adapter, _durableStreamsUrl) {
+	return adapter ?? streamRootDurableStreamsRoutingAdapter;
+}
+
 //#endregion
 //#region src/tracing.ts
 const tracer = trace.getTracer(`agent-server`);
@@ -579,11 +543,18 @@ function durableStreamsBearerHeaders(bearer) {
 	if (!bearer) return void 0;
 	return { authorization: async () => await resolveDurableStreamsBearer(bearer) ?? `` };
 }
-function durableStreamsServiceUrl(baseUrl, serviceId) {
+function durableStreamsServiceUrl(baseUrl, serviceId, options = {}) {
 	const url = new URL(baseUrl);
-	if (/^\/v1\/stream\/[^/]+\/?$/.test(url.pathname)) return baseUrl.replace(/\/+$/, ``);
-	const base = baseUrl.replace(/\/+$/, ``);
-	return `${base}/v1/stream/${encodeURIComponent(serviceId)}`;
+	if (/\/v1\/streams\/[^/]+\/?$/.test(url.pathname)) return baseUrl.replace(/\/+$/, ``);
+	if (/\/v1\/stream\/[^/]+\/?$/.test(url.pathname)) return baseUrl.replace(/\/+$/, ``);
+	const scope = options.scope ?? `service`;
+	const encodedServiceId = encodeURIComponent(serviceId);
+	const path$1 = url.pathname.replace(/\/+$/, ``) || `/`;
+	if (path$1.endsWith(`/v1/streams`)) url.pathname = `${path$1}/${encodedServiceId}`;
+	else if (path$1.endsWith(`/v1/stream`)) url.pathname = scope === `service` ? `${path$1}/${encodedServiceId}` : path$1;
+	else if (scope === `stream-root`) url.pathname = `${path$1 === `/` ? `` : path$1}/v1/stream`;
+	else url.pathname = `${path$1 === `/` ? `` : path$1}/v1/stream/${encodedServiceId}`;
+	return url.toString().replace(/\/+$/, ``);
 }
 function isNotFoundError(err) {
 	return err instanceof DurableStreamError && err.code === ErrCodeNotFound || err instanceof FetchError && err.status === 404;
@@ -616,34 +587,15 @@ var StreamClient = class {
 		await applyDurableStreamsBearer(headers, this.options.bearer, { overwrite: opts.overwriteBearer });
 		return headers;
 	}
-	subscriptionServiceId() {
-		const url = new URL(this.baseUrl);
-		const match = /^(.*)\/v1\/stream\/([^/]+)\/?$/.exec(url.pathname);
-		return match ? decodeURIComponent(match[2]) : null;
-	}
 	backendSubscriptionPath(path$1) {
-		const normalized = normalizeSubscriptionPath(path$1);
-		const serviceId = this.subscriptionServiceId();
-		if (!serviceId) return normalized;
-		if (normalized === serviceId || normalized.startsWith(`${serviceId}/`)) return normalized;
-		return `${serviceId}/${normalized}`;
+		return normalizeSubscriptionPath(path$1);
 	}
 	runtimeSubscriptionPath(path$1) {
-		const normalized = normalizeSubscriptionPath(path$1);
-		const serviceId = this.subscriptionServiceId();
-		if (!serviceId) return normalized;
-		return normalized.startsWith(`${serviceId}/`) ? normalized.slice(serviceId.length + 1) : normalized;
+		return normalizeSubscriptionPath(path$1);
 	}
 	subscriptionUrl(subscriptionId) {
 		const url = new URL(this.baseUrl);
-		const match = /^(.*)\/v1\/stream\/([^/]+)\/?$/.exec(url.pathname);
-		if (match) {
-			const [, prefix = ``, serviceId] = match;
-			url.pathname = `${prefix}/v1/stream-meta/subscriptions/${encodeURIComponent(subscriptionId)}`;
-			url.searchParams.set(`service`, decodeURIComponent(serviceId));
-			return url.toString();
-		}
-		url.pathname = `${url.pathname.replace(/\/+$/, ``)}/v1/stream-meta/subscriptions/${encodeURIComponent(subscriptionId)}`;
+		url.pathname = `${url.pathname.replace(/\/+$/, ``)}/__ds/subscriptions/${encodeURIComponent(subscriptionId)}`;
 		return url.toString();
 	}
 	subscriptionChildUrl(subscriptionId, ...segments) {
@@ -1112,13 +1064,13 @@ function buildElectricProxyTarget(options) {
 	return target;
 }
 async function forwardFetchRequest(options) {
-	const routingAdapter = resolveDurableStreamsRoutingAdapter(options.durableStreamsRouting);
+	const routingAdapter = resolveDurableStreamsRoutingAdapter(options.durableStreamsRouting, options.durableStreamsUrl);
 	const routingInput = {
 		durableStreamsUrl: options.durableStreamsUrl,
 		serviceId: options.serviceId,
 		requestUrl: options.request.url
 	};
-	const upstreamUrl = options.route === `stream-meta` ? routingAdapter.streamMetaUrl(routingInput) : routingAdapter.streamUrl(routingInput);
+	const upstreamUrl = options.route === `control` ? routingAdapter.controlUrl(routingInput) : routingAdapter.streamUrl(routingInput);
 	const headers = new Headers(options.request.headers);
 	if (options.durableStreamsBearerMode !== `none`) await applyDurableStreamsBearer(headers, options.durableStreamsBearer, { overwrite: options.durableStreamsBearerMode !== `if-missing` });
 	const init = {
@@ -1434,8 +1386,21 @@ function isLoopbackHostname(hostname) {
 //#endregion
 //#region src/routing/durable-streams-router.ts
 const subscriptionProxyBodySchema = Type.Object({ webhook: Type.Optional(Type.Object({ url: Type.String() }, { additionalProperties: true })) }, { additionalProperties: true });
+const subscriptionControlActions = [
+	`callback`,
+	`claim`,
+	`ack`,
+	`release`
+];
 const durableStreamsRouter = Router();
-durableStreamsRouter.all(`/v1/stream-meta/subscriptions/*`, subscriptionProxy);
+durableStreamsRouter.put(`/__ds/subscriptions/:subscriptionId`, putSubscriptionBase);
+durableStreamsRouter.get(`/__ds/subscriptions/:subscriptionId`, getSubscriptionBase);
+durableStreamsRouter.delete(`/__ds/subscriptions/:subscriptionId`, deleteSubscriptionBase);
+durableStreamsRouter.post(`/__ds/subscriptions/:subscriptionId/streams`, postSubscriptionStreams);
+durableStreamsRouter.delete(`/__ds/subscriptions/:subscriptionId/streams/:streamPath+`, deleteSubscriptionStream);
+for (const action of subscriptionControlActions) durableStreamsRouter.post(`/__ds/subscriptions/:subscriptionId/${action}`, subscriptionAction(action));
+durableStreamsRouter.all(`/__ds`, controlPassThrough);
+durableStreamsRouter.all(`/__ds/*`, controlPassThrough);
 durableStreamsRouter.post(`*`, streamAppend);
 durableStreamsRouter.all(`*`, proxyPassThrough);
 function bodyFromBytes$1(body) {
@@ -1448,7 +1413,7 @@ function responseFromUpstream$1(response, body) {
 		headers: responseHeaders(response)
 	});
 }
-async function forwardToDurableStreams(ctx, request, body, route = `stream`, urlOverride) {
+async function forwardToDurableStreams(ctx, request, body, route = `stream`, urlOverride, durableStreamsBearerMode = `overwrite`) {
 	const headers = new Headers(request.headers);
 	headers.delete(`host`);
 	let requestBody = body;
@@ -1462,24 +1427,13 @@ async function forwardToDurableStreams(ctx, request, body, route = `stream`, url
 		body: requestBody,
 		durableStreamsUrl: ctx.durableStreamsUrl,
 		durableStreamsBearer: ctx.durableStreamsBearer,
-		durableStreamsBearerMode: usesSubscriptionScopedBearer(urlOverride ?? request.url) ? `if-missing` : `overwrite`,
+		durableStreamsBearerMode,
 		durableStreamsRouting: ctx.durableStreamsRouting,
 		serviceId: ctx.service,
 		dispatcher: ctx.durableStreamsDispatcher,
 		route
 	});
 }
-function subscriptionIdFromPath(pathname) {
-	const match = /^\/v1\/stream-meta\/subscriptions\/([^/]+)(?:\/.*)?$/.exec(pathname);
-	return match ? decodeURIComponent(match[1]) : null;
-}
-function isSubscriptionBasePath(pathname) {
-	return /^\/v1\/stream-meta\/subscriptions\/[^/]+\/?$/.test(pathname);
-}
-function usesSubscriptionScopedBearer(requestUrl) {
-	const pathname = new URL(requestUrl, `http://localhost`).pathname;
-	return /^\/v1\/stream-meta\/subscriptions\/[^/]+\/(?:ack|release|callback)\/?$/.test(pathname);
-}
 function rewriteSubscriptionBodyForBackend(payload, service, routingAdapter) {
 	if (typeof payload.pattern === `string`) payload.pattern = routingAdapter.toBackendStreamPath(service, payload.pattern);
 	if (Array.isArray(payload.streams)) payload.streams = payload.streams.map((stream) => typeof stream === `string` ? routingAdapter.toBackendStreamPath(service, stream) : stream);
@@ -1524,44 +1478,50 @@ function decodeJson(bytes) {
 		return null;
 	}
 }
-function rewriteSubscriptionStreamPathInUrl(requestUrl, service, routingAdapter) {
-	const match = /^(\/v1\/stream-meta\/subscriptions\/[^/]+\/streams\/)(.+)$/.exec(requestUrl.pathname);
-	if (!match) return requestUrl.toString();
-	const [, prefix, encodedPath] = match;
-	const streamPath = decodeURIComponent(encodedPath);
-	requestUrl.pathname = `${prefix}${encodeURIComponent(routingAdapter.toBackendStreamPath(service, streamPath))}`;
-	return requestUrl.toString();
+function routeParam$2(request, name) {
+	const value = request.params[name];
+	const raw = Array.isArray(value) ? value[0] : value;
+	return decodeURIComponent(raw ?? ``);
+}
+function subscriptionRoutingAdapter(ctx) {
+	return resolveDurableStreamsRoutingAdapter(ctx.durableStreamsRouting, ctx.durableStreamsUrl);
 }
-async function subscriptionProxy(request, ctx) {
-	const url = new URL(request.url);
-	const subscriptionId = subscriptionIdFromPath(url.pathname);
-	if (!subscriptionId) return void 0;
-	const routingAdapter = resolveDurableStreamsRoutingAdapter(ctx.durableStreamsRouting);
-	let requestBody;
+async function rewriteSubscriptionRequestBody(request, ctx, subscriptionId, routingAdapter) {
+	const body = await readRequestBody(request);
+	if (body.length === 0) return {
+		ok: true,
+		body,
+		targetWebhookUrl: null
+	};
+	const validation = validateBody(subscriptionProxyBodySchema, body);
+	if (!validation.ok) return {
+		ok: false,
+		response: validation.response
+	};
+	const payload = validation.value;
 	let targetWebhookUrl = null;
-	let requestUrl = request.url;
-	if ([`PUT`, `POST`].includes(request.method.toUpperCase())) {
-		requestBody = await readRequestBody(request);
-		if (requestBody.length > 0) {
-			const validation = validateBody(subscriptionProxyBodySchema, requestBody);
-			if (!validation.ok) return validation.response;
-			const payload = validation.value;
-			if (payload.webhook?.url !== void 0) {
-				targetWebhookUrl = rewriteLoopbackWebhookUrl(payload.webhook.url) ?? null;
-				payload.webhook.url = appendPathToUrl(ctx.publicUrl, `/_electric/webhook-forward/${encodeURIComponent(subscriptionId)}`);
-			}
-			rewriteSubscriptionBodyForBackend(payload, ctx.service, routingAdapter);
-			requestBody = new TextEncoder().encode(JSON.stringify(payload));
-		}
+	if (payload.webhook?.url !== void 0) {
+		targetWebhookUrl = rewriteLoopbackWebhookUrl(payload.webhook.url) ?? null;
+		payload.webhook.url = appendPathToUrl(ctx.publicUrl, `/_electric/webhook-forward/${encodeURIComponent(subscriptionId)}`);
 	}
-	if (request.method.toUpperCase() === `DELETE` && /\/streams\/.+$/.test(url.pathname)) requestUrl = rewriteSubscriptionStreamPathInUrl(url, ctx.service, routingAdapter);
-	const upstream = await forwardToDurableStreams(ctx, request, requestBody, `stream-meta`, requestUrl);
+	rewriteSubscriptionBodyForBackend(payload, ctx.service, routingAdapter);
+	return {
+		ok: true,
+		body: new TextEncoder().encode(JSON.stringify(payload)),
+		targetWebhookUrl
+	};
+}
+async function forwardSubscriptionRequest(request, ctx, routingAdapter, opts = {}) {
+	const upstream = await forwardToDurableStreams(ctx, request, opts.body, `control`, opts.requestUrl, opts.bearerMode ?? `overwrite`);
 	let responseBytes = upstream.body ? new Uint8Array(await upstream.arrayBuffer()) : new Uint8Array();
 	responseBytes = rewriteSubscriptionResponseForClient(responseBytes, upstream, ctx.service, routingAdapter);
-	const response = responseFromUpstream$1(upstream, responseBytes);
-	if (!upstream.ok) return response;
-	if (request.method.toUpperCase() === `DELETE` && isSubscriptionBasePath(url.pathname)) await ctx.pgDb.delete(subscriptionWebhooks).where(and(eq(subscriptionWebhooks.tenantId, ctx.service), eq(subscriptionWebhooks.subscriptionId, subscriptionId)));
-	else if (targetWebhookUrl) await ctx.pgDb.insert(subscriptionWebhooks).values({
+	return {
+		upstream,
+		response: responseFromUpstream$1(upstream, responseBytes)
+	};
+}
+async function upsertSubscriptionWebhook(ctx, subscriptionId, targetWebhookUrl) {
+	await ctx.pgDb.insert(subscriptionWebhooks).values({
 		tenantId: ctx.service,
 		subscriptionId,
 		webhookUrl: targetWebhookUrl
@@ -1569,8 +1529,64 @@ async function subscriptionProxy(request, ctx) {
 		target: [subscriptionWebhooks.tenantId, subscriptionWebhooks.subscriptionId],
 		set: { webhookUrl: targetWebhookUrl }
 	});
+}
+async function deleteSubscriptionWebhook(ctx, subscriptionId) {
+	await ctx.pgDb.delete(subscriptionWebhooks).where(and(eq(subscriptionWebhooks.tenantId, ctx.service), eq(subscriptionWebhooks.subscriptionId, subscriptionId)));
+}
+function rewriteSubscriptionStreamPathInUrl(requestUrl, service, routingAdapter, streamPath) {
+	const prefix = requestUrl.pathname.slice(0, requestUrl.pathname.indexOf(`/streams/`) + `/streams/`.length);
+	requestUrl.pathname = `${prefix}${encodeURIComponent(routingAdapter.toBackendStreamPath(service, streamPath))}`;
+	return requestUrl.toString();
+}
+async function putSubscriptionBase(request, ctx) {
+	const subscriptionId = routeParam$2(request, `subscriptionId`);
+	const routingAdapter = subscriptionRoutingAdapter(ctx);
+	const rewrite = await rewriteSubscriptionRequestBody(request, ctx, subscriptionId, routingAdapter);
+	if (!rewrite.ok) return rewrite.response;
+	const { upstream, response } = await forwardSubscriptionRequest(request, ctx, routingAdapter, { body: rewrite.body });
+	if (upstream.ok && rewrite.targetWebhookUrl) await upsertSubscriptionWebhook(ctx, subscriptionId, rewrite.targetWebhookUrl);
+	return response;
+}
+async function getSubscriptionBase(request, ctx) {
+	const routingAdapter = subscriptionRoutingAdapter(ctx);
+	return (await forwardSubscriptionRequest(request, ctx, routingAdapter)).response;
+}
+async function deleteSubscriptionBase(request, ctx) {
+	const subscriptionId = routeParam$2(request, `subscriptionId`);
+	const routingAdapter = subscriptionRoutingAdapter(ctx);
+	const { upstream, response } = await forwardSubscriptionRequest(request, ctx, routingAdapter);
+	if (upstream.ok) await deleteSubscriptionWebhook(ctx, subscriptionId);
 	return response;
 }
+async function postSubscriptionStreams(request, ctx) {
+	const subscriptionId = routeParam$2(request, `subscriptionId`);
+	const routingAdapter = subscriptionRoutingAdapter(ctx);
+	const rewrite = await rewriteSubscriptionRequestBody(request, ctx, subscriptionId, routingAdapter);
+	if (!rewrite.ok) return rewrite.response;
+	return (await forwardSubscriptionRequest(request, ctx, routingAdapter, { body: rewrite.body })).response;
+}
+async function deleteSubscriptionStream(request, ctx) {
+	const routingAdapter = subscriptionRoutingAdapter(ctx);
+	const requestUrl = rewriteSubscriptionStreamPathInUrl(new URL(request.url), ctx.service, routingAdapter, routeParam$2(request, `streamPath`));
+	return (await forwardSubscriptionRequest(request, ctx, routingAdapter, { requestUrl })).response;
+}
+function subscriptionAction(action) {
+	return async (request, ctx) => {
+		const subscriptionId = routeParam$2(request, `subscriptionId`);
+		const routingAdapter = subscriptionRoutingAdapter(ctx);
+		const rewrite = await rewriteSubscriptionRequestBody(request, ctx, subscriptionId, routingAdapter);
+		if (!rewrite.ok) return rewrite.response;
+		const bearerMode = action === `ack` || action === `release` || action === `callback` ? `if-missing` : `overwrite`;
+		return (await forwardSubscriptionRequest(request, ctx, routingAdapter, {
+			body: rewrite.body,
+			bearerMode
+		})).response;
+	};
+}
+async function controlPassThrough(request, ctx) {
+	const upstream = await forwardToDurableStreams(ctx, request, void 0, `control`);
+	return responseFromUpstream$1(upstream);
+}
 async function streamAppend(request, ctx) {
 	return await electricAgentsStreamAppendRouter.fetch(createStreamAppendRouteRequest(request), ctx.runtime, (req, body) => forwardFetchRequest({
 		request: {
@@ -1591,10 +1607,9 @@ async function proxyPassThrough(request, ctx) {
 	const upstream = await forwardToDurableStreams(ctx, request);
 	const streamPath = new URL(request.url).pathname;
 	const method = request.method.toUpperCase();
-	const isControlPath = streamPath.startsWith(`/v1/stream-meta/`);
-	const endTrackedRead = method === `GET` && !isControlPath ? await ctx.entityBridgeManager.beginClientRead(streamPath) : null;
+	const endTrackedRead = method === `GET` ? await ctx.entityBridgeManager.beginClientRead(streamPath) : null;
 	try {
-		if (method === `HEAD` && !isControlPath) await ctx.entityBridgeManager.touchByStreamPath(streamPath);
+		if (method === `HEAD`) await ctx.entityBridgeManager.touchByStreamPath(streamPath);
 		return responseFromUpstream$1(upstream);
 	} finally {
 		await endTrackedRead?.();
@@ -4378,11 +4393,11 @@ async function spawnEntity(request, ctx) {
 		wake: parsed.wake,
 		created_by: principal.url
 	});
+	await linkEntityDispatchSubscription(ctx, entity);
 	if (parsed.initialMessage !== void 0) await ctx.entityManager.send(entity.url, {
 		from: principal.url,
 		payload: parsed.initialMessage
 	});
-	await linkEntityDispatchSubscription(ctx, entity);
 	return json({
 		...toPublicEntity(entity),
 		txid: entity.txid
@@ -4581,6 +4596,12 @@ function getRequestSpan(req) {
 	return carrier(req)[SPAN_KEY];
 }
 
+//#endregion
+//#region src/routing/tenant-stream-paths.ts
+function withLeadingSlash(path$1) {
+	return path$1.startsWith(`/`) ? path$1 : `/${path$1}`;
+}
+
 //#endregion
 //#region src/routing/runners-router.ts
 const registerRunnerBodySchema = Type.Object({
@@ -4904,7 +4925,7 @@ async function webhookForward(request, ctx) {
 	let runningEntityUrl = null;
 	const parsedBody = parsedBodyResult.value;
 	const newWebhook = newWebhookPayload(parsedBody);
-	const routingAdapter = resolveDurableStreamsRoutingAdapter(ctx.durableStreamsRouting);
+	const routingAdapter = resolveDurableStreamsRoutingAdapter(ctx.durableStreamsRouting, ctx.durableStreamsUrl);
 	if (parsedBody) {
 		const rawPrimaryStream = newWebhook?.primaryStream ?? parsedBody.primary_stream ?? parsedBody.primaryStream ?? parsedBody.streamPath ?? null;
 		const primaryStream = typeof rawPrimaryStream === `string` ? toRuntimeStreamPath(rawPrimaryStream, ctx.service, routingAdapter) : null;
@@ -5033,7 +5054,7 @@ async function callbackForward(request, ctx) {
 		}
 		return json(responseBody);
 	}
-	const upstreamBody = encodeCallbackForwardBody(ctx.service, consumerId, requestBody, resolveDurableStreamsRoutingAdapter(ctx.durableStreamsRouting));
+	const upstreamBody = encodeCallbackForwardBody(ctx.service, consumerId, requestBody, resolveDurableStreamsRoutingAdapter(ctx.durableStreamsRouting, ctx.durableStreamsUrl));
 	let upstream;
 	try {
 		const subscriptionId = durableStreamsSubscriptionCallback(target.callbackUrl);
@@ -6202,7 +6223,7 @@ var ElectricAgentsTenantRuntime = class {
 		this.service = this.serviceId;
 		this.db = options.db;
 		if (options.streamClient) this.streamClient = options.streamClient;
-		else if (options.durableStreamsUrl) this.streamClient = new StreamClient(durableStreamsServiceUrl(options.durableStreamsUrl, this.serviceId), { bearer: options.durableStreamsBearer });
+		else if (options.durableStreamsUrl) this.streamClient = new StreamClient(durableStreamsServiceUrl(options.durableStreamsUrl, this.serviceId, { scope: `stream-root` }), { bearer: options.durableStreamsBearer });
 		else throw new Error(`Either durableStreamsUrl or streamClient is required`);
 		this.registry = options.registry ?? new PostgresRegistry(this.db, this.serviceId);
 		this.wakeRegistry = options.wakeRegistry;
@@ -7120,7 +7141,7 @@ var WakeRegistry = class {
 //#region src/standalone-runtime.ts
 async function startStandaloneAgentsRuntime(options) {
 	const serviceId = options.service ?? options.tenantId ?? DEFAULT_TENANT_ID;
-	const streamClient = options.streamClient ?? (options.durableStreamsUrl ? new StreamClient(durableStreamsServiceUrl(options.durableStreamsUrl, serviceId), { bearer: options.durableStreamsBearer }) : void 0);
+	const streamClient = options.streamClient ?? (options.durableStreamsUrl ? new StreamClient(durableStreamsServiceUrl(options.durableStreamsUrl, serviceId, { scope: `stream-root` }), { bearer: options.durableStreamsBearer }) : void 0);
 	if (!streamClient) throw new Error(`Either durableStreamsUrl or streamClient is required`);
 	const registry = new PostgresRegistry(options.db, serviceId);
 	const wakeRegistry = options.wakeRegistry ?? new WakeRegistry(options.db, serviceId);
@@ -7284,7 +7305,7 @@ var ElectricAgentsServer = class {
 	constructor(options) {
 		if (!options.durableStreamsUrl && !options.durableStreamsServer) throw new Error(`Either durableStreamsUrl or durableStreamsServer is required`);
 		this.options = options;
-		this.streamClient = options.durableStreamsUrl ? new StreamClient(durableStreamsServiceUrl(options.durableStreamsUrl, this.tenantId), { bearer: options.durableStreamsBearer }) : null;
+		this.streamClient = options.durableStreamsUrl ? new StreamClient(durableStreamsServiceUrl(options.durableStreamsUrl, this.tenantId, { scope: `stream-root` }), { bearer: options.durableStreamsBearer }) : null;
 	}
 	get url() {
 		if (!this._url) throw new Error(`Server not started`);
@@ -7305,7 +7326,7 @@ var ElectricAgentsServer = class {
 				const streamsUrl = await this.options.durableStreamsServer.start();
 				serverLog.info(`[agent-server] durable streams server started at ${streamsUrl}`);
 				this.options.durableStreamsUrl = streamsUrl;
-				this.streamClient = new StreamClient(durableStreamsServiceUrl(streamsUrl, this.tenantId), { bearer: this.options.durableStreamsBearer });
+				this.streamClient = new StreamClient(durableStreamsServiceUrl(streamsUrl, this.tenantId, { scope: `stream-root` }), { bearer: this.options.durableStreamsBearer });
 			}
 			this.streamsAgent = new Agent({
 				keepAliveTimeout: 6e4,
@@ -7435,9 +7456,9 @@ var ElectricAgentsServer = class {
 			principal,
 			publicUrl: this.publicUrl,
 			localUrl: this._url,
-			durableStreamsUrl: this.options.durableStreamsUrl,
+			durableStreamsUrl: this.streamClient.baseUrl,
 			durableStreamsBearer: this.options.durableStreamsBearer,
-			durableStreamsRouting: this.options.durableStreamsRouting ?? pathPrefixedSingleTenantDurableStreamsRoutingAdapter,
+			durableStreamsRouting: this.options.durableStreamsRouting,
 			durableStreamsDispatcher: this.streamsAgent,
 			electricUrl: this.options.electricUrl,
 			electricSecret: this.options.electricSecret,