@electric-ax/agents-server 0.4.1 → 0.4.3

package/dist/index.cjs

@@ -316,7 +316,7 @@ function createDb(postgresUrl) {
 	const poolMax = Number(process.env.ELECTRIC_AGENTS_PG_POOL_MAX ?? `100`);
 	const client = (0, postgres.default)(postgresUrl, {
 		max: poolMax,
-		fetch_types: false
+		fetch_types: true
 	});
 	const db = (0, drizzle_orm_postgres_js.drizzle)(client, { schema: schema_exports });
 	return {
@@ -4206,11 +4206,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$2 = url.pathname.replace(/\/+$/, ``) || `/`;
+	if (path$2.endsWith(`/v1/streams`)) url.pathname = `${path$2}/${encodedServiceId}`;
+	else if (path$2.endsWith(`/v1/stream`)) url.pathname = scope === `service` ? `${path$2}/${encodedServiceId}` : path$2;
+	else if (scope === `stream-root`) url.pathname = `${path$2 === `/` ? `` : path$2}/v1/stream`;
+	else url.pathname = `${path$2 === `/` ? `` : path$2}/v1/stream/${encodedServiceId}`;
+	return url.toString().replace(/\/+$/, ``);
 }
 function isNotFoundError(err) {
 	return err instanceof __durable_streams_client.DurableStreamError && err.code === ErrCodeNotFound || err instanceof __durable_streams_client.FetchError && err.status === 404;
@@ -4243,34 +4250,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$2) {
-		const normalized = normalizeSubscriptionPath(path$2);
-		const serviceId = this.subscriptionServiceId();
-		if (!serviceId) return normalized;
-		if (normalized === serviceId || normalized.startsWith(`${serviceId}/`)) return normalized;
-		return `${serviceId}/${normalized}`;
+		return normalizeSubscriptionPath(path$2);
 	}
 	runtimeSubscriptionPath(path$2) {
-		const normalized = normalizeSubscriptionPath(path$2);
-		const serviceId = this.subscriptionServiceId();
-		if (!serviceId) return normalized;
-		return normalized.startsWith(`${serviceId}/`) ? normalized.slice(serviceId.length + 1) : normalized;
+		return normalizeSubscriptionPath(path$2);
 	}
 	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) {
@@ -4685,7 +4673,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;
@@ -5954,27 +5942,6 @@ function validateParsedBody(schema, parsed) {
 	};
 }
 
-//#endregion
-//#region src/routing/tenant-stream-paths.ts
-function withoutLeadingSlash(path$2) {
-	return path$2.replace(/^\/+/, ``);
-}
-function withLeadingSlash(path$2) {
-	return path$2.startsWith(`/`) ? path$2 : `/${path$2}`;
-}
-function prefixTenantStreamPath(path$2, tenantId) {
-	const normalized = withoutLeadingSlash(path$2);
-	if (!normalized || normalized === tenantId) return tenantId;
-	if (normalized.startsWith(`${tenantId}/`)) return normalized;
-	return `${tenantId}/${normalized}`;
-}
-function stripTenantStreamPrefix(path$2, tenantId) {
-	const normalized = withoutLeadingSlash(path$2);
-	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) {
@@ -5985,43 +5952,30 @@ 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 withoutTrailingSlash(pathname) {
+	return pathname.replace(/\/+$/, ``) || `/`;
 }
-function backendStreamUrl(input, backendStreamPath) {
-	const path$2 = backendStreamPath.replace(/^\/+/, ``);
-	const target = new URL(`/v1/stream/${path$2}`, input.durableStreamsUrl);
-	return target;
-}
-function streamMetaUrlWithoutService(input) {
+function appendRequestPathToStreamRoot(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);
+	const path$2 = incomingUrl.pathname.replace(/^\/+/, ``);
+	const target = new URL(input.durableStreamsUrl);
+	target.pathname = path$2 ? `${withoutTrailingSlash(target.pathname)}/${path$2}` : withoutTrailingSlash(target.pathname);
+	return removeServiceQuery(appendSearch(target, incomingUrl));
+}
+const streamRootDurableStreamsRoutingAdapter = {
+	streamUrl: appendRequestPathToStreamRoot,
+	controlUrl: appendRequestPathToStreamRoot,
+	toBackendStreamPath(_serviceId, streamPath) {
+		return streamPath.replace(/^\/+/, ``);
 	},
-	toRuntimeStreamPath(serviceId, streamPath) {
-		return stripTenantStreamPrefix(streamPath, serviceId);
+	toRuntimeStreamPath(_serviceId, streamPath) {
+		return streamPath.replace(/^\/+/, ``);
 	}
 };
-function resolveDurableStreamsRoutingAdapter(adapter) {
-	return adapter ?? pathPrefixedSingleTenantDurableStreamsRoutingAdapter;
+const pathPrefixedSingleTenantDurableStreamsRoutingAdapter = streamRootDurableStreamsRoutingAdapter;
+const tenantRootDurableStreamsRoutingAdapter = streamRootDurableStreamsRoutingAdapter;
+function resolveDurableStreamsRoutingAdapter(adapter, _durableStreamsUrl) {
+	return adapter ?? streamRootDurableStreamsRoutingAdapter;
 }
 
 //#endregion
@@ -6058,13 +6012,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 = {
@@ -6102,8 +6056,21 @@ function sqlStringLiteral(value) {
 //#endregion
 //#region src/routing/durable-streams-router.ts
 const subscriptionProxyBodySchema = __sinclair_typebox.Type.Object({ webhook: __sinclair_typebox.Type.Optional(__sinclair_typebox.Type.Object({ url: __sinclair_typebox.Type.String() }, { additionalProperties: true })) }, { additionalProperties: true });
+const subscriptionControlActions = [
+	`callback`,
+	`claim`,
+	`ack`,
+	`release`
+];
 const durableStreamsRouter = (0, itty_router.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) {
@@ -6116,7 +6083,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;
@@ -6130,24 +6097,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);
@@ -6192,44 +6148,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 = (0, __electric_ax_agents_runtime.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 = (0, __electric_ax_agents_runtime.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((0, drizzle_orm.and)((0, drizzle_orm.eq)(subscriptionWebhooks.tenantId, ctx.service), (0, drizzle_orm.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
@@ -6237,8 +6199,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((0, drizzle_orm.and)((0, drizzle_orm.eq)(subscriptionWebhooks.tenantId, ctx.service), (0, drizzle_orm.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: {
@@ -6259,10 +6277,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?.();
@@ -6809,6 +6826,12 @@ function getRequestSpan(req) {
 	return carrier(req)[SPAN_KEY];
 }
 
+//#endregion
+//#region src/routing/tenant-stream-paths.ts
+function withLeadingSlash(path$2) {
+	return path$2.startsWith(`/`) ? path$2 : `/${path$2}`;
+}
+
 //#endregion
 //#region src/routing/runners-router.ts
 const registerRunnerBodySchema = __sinclair_typebox.Type.Object({
@@ -7132,7 +7155,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;
@@ -7261,7 +7284,7 @@ async function callbackForward(request, ctx) {
 		}
 		return (0, itty_router.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);
@@ -7380,4 +7403,6 @@ exports.createDb = createDb
 exports.globalRouter = globalRouter
 exports.isUnregisteredTenantError = isUnregisteredTenantError
 exports.pathPrefixedSingleTenantDurableStreamsRoutingAdapter = pathPrefixedSingleTenantDurableStreamsRoutingAdapter
-exports.runMigrations = runMigrations
+exports.runMigrations = runMigrations
+exports.streamRootDurableStreamsRoutingAdapter = streamRootDurableStreamsRoutingAdapter
+exports.tenantRootDurableStreamsRoutingAdapter = tenantRootDurableStreamsRoutingAdapter

package/dist/index.d.cts

@@ -3551,7 +3551,6 @@ declare class StreamClient {
   private streamUrl;
   private streamHeaders;
   private requestHeaders;
-  private subscriptionServiceId;
   private backendSubscriptionPath;
   private runtimeSubscriptionPath;
   private subscriptionUrl;
@@ -4251,11 +4250,13 @@ interface DurableStreamsRoutingInput {
 }
 interface DurableStreamsRoutingAdapter {
   streamUrl(input: DurableStreamsRoutingInput): URL;
-  streamMetaUrl(input: DurableStreamsRoutingInput): URL;
+  controlUrl(input: DurableStreamsRoutingInput): URL;
   toBackendStreamPath(serviceId: string, streamPath: string): string;
   toRuntimeStreamPath(serviceId: string, streamPath: string): string;
 }
+declare const streamRootDurableStreamsRoutingAdapter: DurableStreamsRoutingAdapter;
 declare const pathPrefixedSingleTenantDurableStreamsRoutingAdapter: DurableStreamsRoutingAdapter;
+declare const tenantRootDurableStreamsRoutingAdapter: DurableStreamsRoutingAdapter;
 
 //#endregion
 //#region src/routing/context.d.ts
@@ -4270,6 +4271,7 @@ interface TenantContext {
   principal: Principal;
   publicUrl: string;
   localUrl?: string;
+  /** Resolved Durable Streams root URL for this tenant. */
   durableStreamsUrl: string;
   durableStreamsBearer?: DurableStreamsBearerProvider;
   durableStreamsRouting?: DurableStreamsRoutingAdapter;
@@ -4301,4 +4303,4 @@ declare class UnregisteredTenantError extends Error {
 declare function isUnregisteredTenantError(error: unknown): error is UnregisteredTenantError;
 
 //#endregion
-export { AgentsHost, AgentsHostOptions, AgentsHostTenantConfig, AgentsHostTenantRuntime, AuthenticateRequest, ConsumerClaim, DEFAULT_TENANT_ID, DispatchPolicy, DispatchTarget, DrizzleDB, DurableStreamsBearerProvider, DurableStreamsRoutingAdapter, DurableStreamsRoutingInput, ElectricAgentsRunner, ElectricAgentsUser, EntityBridgeCoordinator, EntityDispatchState, GlobalRoutes, PgClient, Principal, PrincipalKind, PublicWakeNotification, RegisterRunnerRequest, RequestPrincipal, RunnerAdminStatus, RunnerHeartbeatRequest, RunnerKind, RunnerLiveness, SourceStreamOffset, StreamClient, StreamClientOptions, SubscriptionClaimResponse, SubscriptionCreateInput, SubscriptionResponse, SubscriptionStreamInfo, TenantContext, UnregisteredTenantError, WakeNotificationRow, createDb, globalRouter, isUnregisteredTenantError, pathPrefixedSingleTenantDurableStreamsRoutingAdapter, runMigrations };
+export { AgentsHost, AgentsHostOptions, AgentsHostTenantConfig, AgentsHostTenantRuntime, AuthenticateRequest, ConsumerClaim, DEFAULT_TENANT_ID, DispatchPolicy, DispatchTarget, DrizzleDB, DurableStreamsBearerProvider, DurableStreamsRoutingAdapter, DurableStreamsRoutingInput, ElectricAgentsRunner, ElectricAgentsUser, EntityBridgeCoordinator, EntityDispatchState, GlobalRoutes, PgClient, Principal, PrincipalKind, PublicWakeNotification, RegisterRunnerRequest, RequestPrincipal, RunnerAdminStatus, RunnerHeartbeatRequest, RunnerKind, RunnerLiveness, SourceStreamOffset, StreamClient, StreamClientOptions, SubscriptionClaimResponse, SubscriptionCreateInput, SubscriptionResponse, SubscriptionStreamInfo, TenantContext, UnregisteredTenantError, WakeNotificationRow, createDb, globalRouter, isUnregisteredTenantError, pathPrefixedSingleTenantDurableStreamsRoutingAdapter, runMigrations, streamRootDurableStreamsRoutingAdapter, tenantRootDurableStreamsRoutingAdapter };

package/dist/index.d.ts

@@ -3552,7 +3552,6 @@ declare class StreamClient {
   private streamUrl;
   private streamHeaders;
   private requestHeaders;
-  private subscriptionServiceId;
   private backendSubscriptionPath;
   private runtimeSubscriptionPath;
   private subscriptionUrl;
@@ -4252,11 +4251,13 @@ interface DurableStreamsRoutingInput {
 }
 interface DurableStreamsRoutingAdapter {
   streamUrl(input: DurableStreamsRoutingInput): URL;
-  streamMetaUrl(input: DurableStreamsRoutingInput): URL;
+  controlUrl(input: DurableStreamsRoutingInput): URL;
   toBackendStreamPath(serviceId: string, streamPath: string): string;
   toRuntimeStreamPath(serviceId: string, streamPath: string): string;
 }
+declare const streamRootDurableStreamsRoutingAdapter: DurableStreamsRoutingAdapter;
 declare const pathPrefixedSingleTenantDurableStreamsRoutingAdapter: DurableStreamsRoutingAdapter;
+declare const tenantRootDurableStreamsRoutingAdapter: DurableStreamsRoutingAdapter;
 
 //#endregion
 //#region src/routing/context.d.ts
@@ -4271,6 +4272,7 @@ interface TenantContext {
   principal: Principal;
   publicUrl: string;
   localUrl?: string;
+  /** Resolved Durable Streams root URL for this tenant. */
   durableStreamsUrl: string;
   durableStreamsBearer?: DurableStreamsBearerProvider;
   durableStreamsRouting?: DurableStreamsRoutingAdapter;
@@ -4302,4 +4304,4 @@ declare class UnregisteredTenantError extends Error {
 declare function isUnregisteredTenantError(error: unknown): error is UnregisteredTenantError;
 
 //#endregion
-export { AgentsHost, AgentsHostOptions, AgentsHostTenantConfig, AgentsHostTenantRuntime, AuthenticateRequest, ConsumerClaim, DEFAULT_TENANT_ID, DispatchPolicy, DispatchTarget, DrizzleDB, DurableStreamsBearerProvider, DurableStreamsRoutingAdapter, DurableStreamsRoutingInput, ElectricAgentsRunner, ElectricAgentsUser, EntityBridgeCoordinator, EntityDispatchState, GlobalRoutes, PgClient, Principal, PrincipalKind, PublicWakeNotification, RegisterRunnerRequest, RequestPrincipal, RunnerAdminStatus, RunnerHeartbeatRequest, RunnerKind, RunnerLiveness, SourceStreamOffset, StreamClient, StreamClientOptions, SubscriptionClaimResponse, SubscriptionCreateInput, SubscriptionResponse, SubscriptionStreamInfo, TenantContext, UnregisteredTenantError, WakeNotificationRow, createDb, globalRouter, isUnregisteredTenantError, pathPrefixedSingleTenantDurableStreamsRoutingAdapter, runMigrations };
+export { AgentsHost, AgentsHostOptions, AgentsHostTenantConfig, AgentsHostTenantRuntime, AuthenticateRequest, ConsumerClaim, DEFAULT_TENANT_ID, DispatchPolicy, DispatchTarget, DrizzleDB, DurableStreamsBearerProvider, DurableStreamsRoutingAdapter, DurableStreamsRoutingInput, ElectricAgentsRunner, ElectricAgentsUser, EntityBridgeCoordinator, EntityDispatchState, GlobalRoutes, PgClient, Principal, PrincipalKind, PublicWakeNotification, RegisterRunnerRequest, RequestPrincipal, RunnerAdminStatus, RunnerHeartbeatRequest, RunnerKind, RunnerLiveness, SourceStreamOffset, StreamClient, StreamClientOptions, SubscriptionClaimResponse, SubscriptionCreateInput, SubscriptionResponse, SubscriptionStreamInfo, TenantContext, UnregisteredTenantError, WakeNotificationRow, createDb, globalRouter, isUnregisteredTenantError, pathPrefixedSingleTenantDurableStreamsRoutingAdapter, runMigrations, streamRootDurableStreamsRoutingAdapter, tenantRootDurableStreamsRoutingAdapter };