@electric-ax/agents-server 0.4.9 → 0.4.12

package/dist/entrypoint.js

@@ -446,7 +446,7 @@ const ErrCodeForkWaitTimeout = `FORK_WAIT_TIMEOUT`;
 const ErrCodeEntityPersistFailed = `ENTITY_PERSIST_FAILED`;
 const ErrCodeAgentUiNotFound = `AGENT_UI_NOT_FOUND`;
 const ErrCodeSubscriptionNotFound = `SUBSCRIPTION_NOT_FOUND`;
-const ErrCodeCallbackNotFound = `CALLBACK_NOT_FOUND`;
+const ErrCodeWakeCallbackNotFound = `WAKE_CALLBACK_NOT_FOUND`;
 
 //#endregion
 //#region src/utils/electric-url.ts
@@ -466,7 +466,7 @@ function electricUrlWithPath(electricUrl, path$1) {
 //#region src/routing/durable-streams-routing-adapter.ts
 function appendSearch(target, source) {
 	source.searchParams.forEach((value, key) => {
-		if (key !== `service`) target.searchParams.append(key, value);
+		target.searchParams.append(key, value);
 	});
 	return target;
 }
@@ -1610,7 +1610,7 @@ async function rewriteSubscriptionRequestBody(request, ctx, subscriptionId, rout
 	let targetWebhookUrl = null;
 	if (payload.webhook?.url !== void 0) {
 		targetWebhookUrl = rewriteLoopbackWebhookUrl(payload.webhook.url) ?? null;
-		payload.webhook.url = appendPathToUrl(ctx.publicUrl, `/_electric/webhook-forward/${encodeURIComponent(subscriptionId)}`);
+		payload.webhook.url = appendPathToUrl(ctx.publicUrl, `/_electric/subscription-webhooks/${encodeURIComponent(subscriptionId)}`);
 	}
 	rewriteSubscriptionBodyForBackend(payload, ctx.service, routingAdapter);
 	return {
@@ -1733,20 +1733,6 @@ async function proxyPassThrough(request, ctx) {
 	}
 }
 
-//#endregion
-//#region src/routing/cron-router.ts
-const cronRegisterBodySchema = Type.Object({
-	expression: Type.String(),
-	timezone: Type.Optional(Type.String())
-});
-const cronRouter = Router({ base: `/_electric/cron` });
-cronRouter.post(`/register`, withSchema(cronRegisterBodySchema), registerCron);
-async function registerCron(request, ctx) {
-	const parsed = routeBody(request);
-	const streamPath = await ctx.entityManager.getOrCreateCronStream(parsed.expression, parsed.timezone);
-	return json({ streamUrl: streamPath });
-}
-
 //#endregion
 //#region src/routing/electric-proxy-router.ts
 const electricProxyRouter = Router({ base: `/_electric/electric` });
@@ -3632,7 +3618,7 @@ var EntityManager = class {
 		};
 	}
 	/**
-	* Deliver a message to an entity's main stream, with optional input schema
+	* Deliver a message to an entity's main stream, with optional inbox schema
 	* validation.
 	*/
 	async send(entityUrl, req, opts) {
@@ -3720,7 +3706,7 @@ var EntityManager = class {
 		if (result.changed && this.entityBridgeManager) await this.entityBridgeManager.onEntityChanged(entityUrl);
 		return updated;
 	}
-	async removeTag(entityUrl, key, token) {
+	async deleteTag(entityUrl, key, token) {
 		const entity = await this.registry.getEntity(entityUrl);
 		if (!entity) throw new ElectricAgentsError(ErrCodeNotFound, `Entity not found`, 404);
 		if (!this.isValidWriteToken(entity, token)) throw new ElectricAgentsError(ErrCodeUnauthorized, `Invalid write token`, 401);
@@ -3731,7 +3717,7 @@ var EntityManager = class {
 		if (result.changed && this.entityBridgeManager) await this.entityBridgeManager.onEntityChanged(entityUrl);
 		return updated;
 	}
-	async registerEntitiesSource(tags) {
+	async ensureEntitiesMembershipStream(tags) {
 		if (!this.entityBridgeManager) throw new Error(`Entity bridge manager not configured`);
 		return this.entityBridgeManager.register(this.validateTags(tags));
 	}
@@ -4160,7 +4146,7 @@ var EntityManager = class {
 		return null;
 	}
 	/**
-	* Add new input/output schema keys to an entity type directly in Postgres.
+	* Add new inbox/state schema keys to an entity type directly in Postgres.
 	*/
 	async amendSchemas(typeName, schemas) {
 		if (typeName === `principal`) throw new ElectricAgentsError(ErrCodeInvalidRequest, `Entity type "principal" is built in and cannot be amended`, 400);
@@ -4200,7 +4186,7 @@ var EntityManager = class {
 	}
 	/**
 	* Enrich webhook payload with entity context.
-	* Called by ElectricAgentsServer during webhook forwarding to inject entity context.
+	* Called by ElectricAgentsServer during subscription webhook dispatch to inject entity context.
 	*/
 	async enrichPayload(payload, consumer) {
 		const entity = await this.registry.getEntityByStream(consumer.primary_stream);
@@ -4465,7 +4451,7 @@ async function linkStreamToTargetSubscription(ctx, target, entity, subscriptionI
 	}
 	const webhookUrl = rewriteLoopbackWebhookUrl(target.url);
 	if (!webhookUrl) throw new ElectricAgentsError(ErrCodeInvalidRequest, `Webhook dispatch target must include a valid URL`, 400);
-	const forwardUrl = appendPathToUrl(ctx.publicUrl, `/_electric/webhook-forward/${encodeURIComponent(subscriptionId)}`);
+	const forwardUrl = appendPathToUrl(ctx.publicUrl, `/_electric/subscription-webhooks/${encodeURIComponent(subscriptionId)}`);
 	await ensureSubscriptionIncludesStream(ctx, subscriptionId, streamPath, {
 		type: `webhook`,
 		streams: [streamPath],
@@ -4484,7 +4470,7 @@ async function linkStreamToTargetSubscription(ctx, target, entity, subscriptionI
 
 //#endregion
 //#region src/routing/entities-router.ts
-const stringRecordSchema = Type.Record(Type.String(), Type.String());
+const stringRecordSchema$1 = Type.Record(Type.String(), Type.String());
 function writeTokenFromRequest(request) {
 	const electricClaimToken = request.headers.get(`electric-claim-token`)?.trim();
 	if (electricClaimToken) return electricClaimToken;
@@ -4501,7 +4487,7 @@ const wakeConditionSchema = Type.Union([Type.Literal(`runFinished`), Type.Object
 })]);
 const spawnBodySchema = Type.Object({
 	args: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
-	tags: Type.Optional(stringRecordSchema),
+	tags: Type.Optional(stringRecordSchema$1),
 	parent: Type.Optional(Type.String()),
 	dispatch_policy: Type.Optional(dispatchPolicySchema),
 	initialMessage: Type.Optional(Type.Unknown()),
@@ -4593,10 +4579,8 @@ const eventSourceSubscriptionBodySchema = Type.Object({
 	lifetime: Type.Optional(subscriptionLifetimeSchema),
 	reason: Type.Optional(Type.String())
 });
-const entitiesRegisterBodySchema = Type.Object({ tags: Type.Optional(stringRecordSchema) });
 const entitiesRouter = Router({ base: `/_electric/entities` });
 entitiesRouter.get(`/`, listEntities);
-entitiesRouter.post(`/register`, withSchema(entitiesRegisterBodySchema), registerEntitiesSource);
 entitiesRouter.put(`/:type/:instanceId`, withSpawnableEntityType, withSchema(spawnBodySchema), spawnEntity);
 entitiesRouter.get(`/:type/:instanceId`, withExistingEntity, getEntity);
 entitiesRouter.head(`/:type/:instanceId`, withExistingEntity, headEntity);
@@ -4607,7 +4591,7 @@ entitiesRouter.patch(`/:type/:instanceId/inbox/:messageKey`, withExistingEntity,
 entitiesRouter.delete(`/:type/:instanceId/inbox/:messageKey`, withExistingEntity, deleteInboxMessage);
 entitiesRouter.post(`/:type/:instanceId/fork`, withExistingEntity, withSchema(forkBodySchema), forkEntity);
 entitiesRouter.post(`/:type/:instanceId/tags/:tagKey`, withExistingEntity, withSchema(setTagBodySchema), setTag);
-entitiesRouter.delete(`/:type/:instanceId/tags/:tagKey`, withExistingEntity, removeTag);
+entitiesRouter.delete(`/:type/:instanceId/tags/:tagKey`, withExistingEntity, deleteTag);
 entitiesRouter.put(`/:type/:instanceId/schedules/:scheduleId`, withExistingEntity, withSchema(scheduleBodySchema), upsertSchedule);
 entitiesRouter.delete(`/:type/:instanceId/schedules/:scheduleId`, withExistingEntity, deleteSchedule);
 entitiesRouter.put(`/:type/:instanceId/event-source-subscriptions/:subscriptionId`, withExistingEntity, withSchema(eventSourceSubscriptionBodySchema), upsertEventSourceSubscription);
@@ -4675,11 +4659,6 @@ async function listEntities({ query }, ctx) {
 	});
 	return json(entities$1.map((entity) => toPublicEntity(entity)));
 }
-async function registerEntitiesSource(request, ctx) {
-	const parsed = routeBody(request);
-	const result = await ctx.entityManager.registerEntitiesSource(parsed.tags ?? {});
-	return json(result);
-}
 async function upsertSchedule(request, ctx) {
 	const principalMutationError = rejectPrincipalEntityMutation(request, `scheduled`);
 	if (principalMutationError) return principalMutationError;
@@ -4760,7 +4739,7 @@ async function deleteEventSourceSubscription(request, ctx) {
 	return json(result);
 }
 async function setTag(request, ctx) {
-	const principalMutationError = rejectPrincipalEntityMutation(request, `tagged`);
+	const principalMutationError = rejectPrincipalEntityMutation(request, `tag updated`);
 	if (principalMutationError) return principalMutationError;
 	const parsed = routeBody(request);
 	const { entityUrl } = requireExistingEntityRoute(request);
@@ -4768,12 +4747,12 @@ async function setTag(request, ctx) {
 	const updated = await ctx.entityManager.setTag(entityUrl, decodeURIComponent(request.params.tagKey), { value: parsed.value }, token);
 	return json(toPublicEntity(updated));
 }
-async function removeTag(request, ctx) {
-	const principalMutationError = rejectPrincipalEntityMutation(request, `untagged`);
+async function deleteTag(request, ctx) {
+	const principalMutationError = rejectPrincipalEntityMutation(request, `tag deleted`);
 	if (principalMutationError) return principalMutationError;
 	const { entityUrl } = requireExistingEntityRoute(request);
 	const token = writeTokenFromRequest(request);
-	const updated = await ctx.entityManager.removeTag(entityUrl, decodeURIComponent(request.params.tagKey), token);
+	const updated = await ctx.entityManager.deleteTag(entityUrl, decodeURIComponent(request.params.tagKey), token);
 	return json(toPublicEntity(updated));
 }
 async function forkEntity(request, ctx) {
@@ -4905,17 +4884,13 @@ const registerEntityTypeBodySchema = Type.Object({
 	creation_schema: Type.Optional(jsonObjectSchema),
 	inbox_schemas: Type.Optional(schemaMapSchema),
 	state_schemas: Type.Optional(schemaMapSchema),
-	input_schemas: Type.Optional(schemaMapSchema),
-	output_schemas: Type.Optional(schemaMapSchema),
 	serve_endpoint: Type.Optional(Type.String()),
 	default_dispatch_policy: Type.Optional(dispatchPolicySchema)
-});
+}, { additionalProperties: false });
 const amendEntityTypeSchemasBodySchema = Type.Object({
-	input_schemas: Type.Optional(schemaMapSchema),
-	output_schemas: Type.Optional(schemaMapSchema),
 	inbox_schemas: Type.Optional(schemaMapSchema),
 	state_schemas: Type.Optional(schemaMapSchema)
-});
+}, { additionalProperties: false });
 const entityTypesRouter = Router({ base: `/_electric/entity-types` });
 entityTypesRouter.get(`/`, listEntityTypes);
 entityTypesRouter.post(`/`, withSchema(registerEntityTypeBodySchema), registerEntityType);
@@ -4955,8 +4930,8 @@ async function getEntityType(request, ctx) {
 async function amendSchemas(request, ctx) {
 	const parsed = routeBody(request);
 	const updated = await ctx.entityManager.amendSchemas(request.params.name, {
-		inbox_schemas: parsed.inbox_schemas ?? parsed.input_schemas,
-		state_schemas: parsed.state_schemas ?? parsed.output_schemas
+		inbox_schemas: parsed.inbox_schemas,
+		state_schemas: parsed.state_schemas
 	});
 	return json(toPublicEntityType(updated));
 }
@@ -4966,13 +4941,12 @@ async function deleteEntityType(request, ctx) {
 }
 function normalizeEntityTypeRequest(parsed) {
 	const serveEndpoint = rewriteLoopbackWebhookUrl(parsed.serve_endpoint);
-	const compatibilityFields = parsed;
 	return {
 		name: parsed.name ?? ``,
 		description: parsed.description ?? ``,
 		creation_schema: parsed.creation_schema,
-		inbox_schemas: parsed.inbox_schemas ?? compatibilityFields.input_schemas,
-		state_schemas: parsed.state_schemas ?? compatibilityFields.output_schemas,
+		inbox_schemas: parsed.inbox_schemas,
+		state_schemas: parsed.state_schemas,
 		serve_endpoint: serveEndpoint,
 		default_dispatch_policy: parsed.default_dispatch_policy ?? (serveEndpoint ? { targets: [{
 			type: `webhook`,
@@ -4983,8 +4957,6 @@ function normalizeEntityTypeRequest(parsed) {
 function toPublicEntityType(entityType) {
 	return {
 		...entityType,
-		input_schemas: entityType.inbox_schemas,
-		output_schemas: entityType.state_schemas,
 		revision: entityType.revision
 	};
 }
@@ -5068,13 +5040,35 @@ function errorMapper(err, req) {
 function rejectIfShuttingDown(req, ctx) {
 	if (!ctx.isShuttingDown()) return void 0;
 	const path$1 = new URL(req.url).pathname;
-	if (!path$1.startsWith(`/_electric/webhook-forward/`)) return void 0;
+	if (!path$1.startsWith(`/_electric/subscription-webhooks/`)) return void 0;
 	return apiError(503, `SERVER_STOPPING`, `Server is shutting down`);
 }
 function getRequestSpan(req) {
 	return carrier(req)[SPAN_KEY];
 }
 
+//#endregion
+//#region src/routing/observations-router.ts
+const stringRecordSchema = Type.Record(Type.String(), Type.String());
+const ensureEntitiesMembershipStreamBodySchema = Type.Object({ tags: Type.Optional(stringRecordSchema) });
+const ensureCronStreamBodySchema = Type.Object({
+	expression: Type.String(),
+	timezone: Type.Optional(Type.String())
+});
+const observationsRouter = Router({ base: `/_electric/observations` });
+observationsRouter.post(`/entities/ensure-stream`, withSchema(ensureEntitiesMembershipStreamBodySchema), ensureEntitiesMembershipStream);
+observationsRouter.post(`/cron/ensure-stream`, withSchema(ensureCronStreamBodySchema), ensureCronStream);
+async function ensureEntitiesMembershipStream(request, ctx) {
+	const parsed = routeBody(request);
+	const result = await ctx.entityManager.ensureEntitiesMembershipStream(parsed.tags ?? {});
+	return json(result);
+}
+async function ensureCronStream(request, ctx) {
+	const parsed = routeBody(request);
+	const streamPath = await ctx.entityManager.getOrCreateCronStream(parsed.expression, parsed.timezone);
+	return json({ streamUrl: streamPath });
+}
+
 //#endregion
 //#region src/routing/tenant-stream-paths.ts
 function withLeadingSlash(path$1) {
@@ -5413,7 +5407,7 @@ async function notificationFromClaim(ctx, input) {
 		wakeId: input.claim.wake_id,
 		streamPath: primaryStream,
 		streams: streams$1,
-		callback: appendPathToUrl(ctx.publicUrl, `/_electric/callback-forward/${encodeURIComponent(input.claim.wake_id)}`),
+		callback: appendPathToUrl(ctx.publicUrl, `/_electric/wake-callbacks/${encodeURIComponent(input.claim.wake_id)}`),
 		claimToken: input.claim.token,
 		triggerEvent: `message_received`,
 		entity: {
@@ -5448,7 +5442,7 @@ const wakeRegistrationBodySchema = Type.Object({
 	includeResponse: Type.Optional(Type.Boolean()),
 	manifestKey: Type.Optional(Type.String())
 });
-const webhookForwardBodySchema = Type.Object({
+const subscriptionWebhookBodySchema = Type.Object({
 	subscription_id: Type.Optional(Type.String()),
 	wake_id: Type.Optional(Type.String()),
 	generation: Type.Optional(Type.Number()),
@@ -5462,7 +5456,7 @@ const webhookForwardBodySchema = Type.Object({
 	consumer_id: Type.Optional(Type.String()),
 	callback: Type.Optional(Type.String())
 }, { additionalProperties: true });
-const callbackForwardBodySchema = Type.Object({
+const wakeCallbackBodySchema = Type.Object({
 	epoch: Type.Optional(Type.Number()),
 	generation: Type.Optional(Type.Number()),
 	wakeId: Type.Optional(Type.String()),
@@ -5475,13 +5469,13 @@ const internalRouter = Router({ base: `/_electric` });
 internalRouter.get(`/health`, () => json({ status: `ok` }));
 internalRouter.get(`/event-sources`, listEventSources);
 internalRouter.post(`/wake`, withSchema(wakeRegistrationBodySchema), registerWake);
-internalRouter.post(`/webhook-forward/:subscriptionId`, webhookForward);
-internalRouter.post(`/callback-forward/:consumerId`, callbackForward);
+internalRouter.post(`/subscription-webhooks/:subscriptionId`, subscriptionWebhook);
+internalRouter.post(`/wake-callbacks/:consumerId`, wakeCallback);
 internalRouter.all(`/runners`, runnersRouter.fetch);
 internalRouter.all(`/runners/*`, runnersRouter.fetch);
 internalRouter.all(`/entities/*`, entitiesRouter.fetch);
 internalRouter.all(`/entity-types/*`, entityTypesRouter.fetch);
-internalRouter.all(`/cron/*`, cronRouter.fetch);
+internalRouter.all(`/observations/*`, observationsRouter.fetch);
 internalRouter.get(`/electric/*`, electricProxyRouter.fetch);
 internalRouter.all(`*`, () => status(404));
 function routeParam(request, name) {
@@ -5514,13 +5508,30 @@ function resolveWebhookSigner(ctx) {
 	return ctx.webhookSigner ?? getDefaultWebhookSigner();
 }
 function durableStreamsWebhookJwksUrl(ctx) {
-	if (!ctx.durableStreamsRouting) return appendPathToUrl(ctx.durableStreamsUrl, `/__ds/jwks.json`);
+	if (!ctx.durableStreamsRouting) return appendPathToBackendUrl(ctx.durableStreamsUrl, `/__ds/jwks.json`);
 	return resolveDurableStreamsRoutingAdapter(ctx.durableStreamsRouting, ctx.durableStreamsUrl).controlUrl({
 		durableStreamsUrl: ctx.durableStreamsUrl,
 		serviceId: ctx.service,
 		requestUrl: appendPathToUrl(ctx.publicUrl, `/__ds/jwks.json`)
 	}).toString();
 }
+function appendPathToBackendUrl(baseUrl, path$1) {
+	const base = new URL(baseUrl);
+	const pathUrl = new URL(path$1, `http://electric-agents.local`);
+	const basePath = base.pathname === `/` ? `` : base.pathname.replace(/\/+$/, ``);
+	const suffix = pathUrl.pathname.startsWith(`/`) ? pathUrl.pathname : `/${pathUrl.pathname}`;
+	const target = new URL(base);
+	target.pathname = `${basePath}${suffix}`;
+	target.search = ``;
+	target.hash = pathUrl.hash;
+	base.searchParams.forEach((value, key) => {
+		target.searchParams.append(key, value);
+	});
+	pathUrl.searchParams.forEach((value, key) => {
+		target.searchParams.append(key, value);
+	});
+	return target.toString();
+}
 function durableStreamsJwksFetchClient(ctx) {
 	return async (input, init) => {
 		const headers = new Headers(init?.headers);
@@ -5584,10 +5595,10 @@ async function listEventSources(_request, ctx) {
 function isAgentVisibleEventSource(source) {
 	return source.agentVisible === true && source.status === `active`;
 }
-async function webhookForward(request, ctx) {
+async function subscriptionWebhook(request, ctx) {
 	const subscriptionId = routeParam(request, `subscriptionId`);
 	const rootSpan = getRequestSpan(request);
-	rootSpan?.updateName(`webhook-forward`);
+	rootSpan?.updateName(`subscription-webhook`);
 	rootSpan?.setAttribute(`electric_agents.webhook.subscription_id`, subscriptionId);
 	const body = await readRequestBody(request);
 	const signatureError = await verifyDurableStreamsWebhook(request, ctx, body);
@@ -5601,7 +5612,7 @@ async function webhookForward(request, ctx) {
 		}
 	});
 	if (!targetWebhookUrl) return apiError(404, ErrCodeSubscriptionNotFound, `Unknown webhook subscription`);
-	const parsedBodyResult = validateOptionalJsonBody(webhookForwardBodySchema, body, request.headers.get(`content-type`));
+	const parsedBodyResult = validateOptionalJsonBody(subscriptionWebhookBodySchema, body, request.headers.get(`content-type`));
 	if (!parsedBodyResult.ok) return parsedBodyResult.response;
 	let forwardBody = body;
 	let runningEntityUrl = null;
@@ -5647,7 +5658,7 @@ async function webhookForward(request, ctx) {
 					span.end();
 				}
 			}).catch((err) => {
-				serverLog.warn(`[webhook-forward] consumerCallbacks upsert failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+				serverLog.warn(`[subscription-webhook] consumerCallbacks upsert failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
 			}) : void 0;
 			const [entity, enriched] = await Promise.all([entityPromise, enrichPromise]);
 			if (entity?.status === `stopped` || entity?.status === `paused`) {
@@ -5668,7 +5679,7 @@ async function webhookForward(request, ctx) {
 				runningEntityUrl = entity.url;
 			}
 			if (consumerId && callbackUrl) {
-				const callback = appendPathToUrl(ctx.publicUrl, `/_electric/callback-forward/${encodeURIComponent(consumerId)}`);
+				const callback = appendPathToUrl(ctx.publicUrl, `/_electric/wake-callbacks/${encodeURIComponent(consumerId)}`);
 				enriched.callback = callback;
 				if (newWebhook) {
 					enriched.consumerId = newWebhook.wakeId;
@@ -5705,21 +5716,21 @@ async function webhookForward(request, ctx) {
 		});
 	} catch (err) {
 		if (runningEntityUrl) await ctx.entityManager.registry.updateStatus(runningEntityUrl, `idle`);
-		return apiError(502, `WEBHOOK_FORWARD_FAILED`, err instanceof Error ? err.message : String(err));
+		return apiError(502, `SUBSCRIPTION_WEBHOOK_FAILED`, err instanceof Error ? err.message : String(err));
 	}
 	const responseBytes = upstream.body ? new Uint8Array(await upstream.arrayBuffer()) : new Uint8Array();
 	return responseFromUpstream(upstream, responseBytes);
 }
-async function callbackForward(request, ctx) {
+async function wakeCallback(request, ctx) {
 	const consumerId = routeParam(request, `consumerId`);
 	const rows = await ctx.pgDb.select().from(consumerCallbacks).where(and(eq(consumerCallbacks.tenantId, ctx.service), eq(consumerCallbacks.consumerId, consumerId))).limit(1);
 	const target = rows[0] ? {
 		callbackUrl: rows[0].callbackUrl,
 		primaryStream: rows[0].primaryStream
 	} : void 0;
-	if (!target) return apiError(404, ErrCodeCallbackNotFound, `Unknown callback-forward consumer`);
+	if (!target) return apiError(404, ErrCodeWakeCallbackNotFound, `Unknown wake-callback consumer`);
 	const body = await readRequestBody(request);
-	const parsedBodyResult = validateOptionalJsonBody(callbackForwardBodySchema, body, request.headers.get(`content-type`));
+	const parsedBodyResult = validateOptionalJsonBody(wakeCallbackBodySchema, body, request.headers.get(`content-type`));
 	if (!parsedBodyResult.ok) return parsedBodyResult.response;
 	const requestBody = parsedBodyResult.value;
 	const isClaimRequest = requestBody?.wakeId !== void 0 || requestBody?.wake_id !== void 0;
@@ -5737,14 +5748,14 @@ async function callbackForward(request, ctx) {
 		}
 		return json(responseBody);
 	}
-	const upstreamBody = encodeCallbackForwardBody(ctx.service, consumerId, requestBody, resolveDurableStreamsRoutingAdapter(ctx.durableStreamsRouting, ctx.durableStreamsUrl));
+	const upstreamBody = encodeWakeCallbackBody(ctx.service, consumerId, requestBody, resolveDurableStreamsRoutingAdapter(ctx.durableStreamsRouting, ctx.durableStreamsUrl));
 	let upstream;
 	try {
 		const subscriptionId = durableStreamsSubscriptionCallback(target.callbackUrl);
 		if (subscriptionId) {
 			const token = claimTokenFromRequest(request);
 			if (!token) return apiError(401, `UNAUTHORIZED`, `Missing claim token`);
-			const upstreamPayload = encodeCallbackForwardPayload(consumerId, requestBody, (stream) => stream.replace(/^\/+/, ``));
+			const upstreamPayload = encodeWakeCallbackPayload(consumerId, requestBody, (stream) => stream.replace(/^\/+/, ``));
 			const result = await ctx.streamClient.ackSubscription(subscriptionId, token, upstreamPayload);
 			upstream = json(result);
 		} else upstream = await fetch(target.callbackUrl, {
@@ -5753,7 +5764,7 @@ async function callbackForward(request, ctx) {
 			body: bodyFromBytes(upstreamBody)
 		});
 	} catch (err) {
-		return apiError(502, `CALLBACK_FORWARD_FAILED`, err instanceof Error ? err.message : String(err));
+		return apiError(502, `WAKE_CALLBACK_FAILED`, err instanceof Error ? err.message : String(err));
 	}
 	let responseBytes = upstream.body ? new Uint8Array(await upstream.arrayBuffer()) : new Uint8Array();
 	if (isClaimRequest && upstream.ok && target.primaryStream) {
@@ -5773,7 +5784,7 @@ async function callbackForward(request, ctx) {
 			epoch
 		});
 		if (upstream.ok && isDoneRequest && target.primaryStream) {
-			serverLog.info(`[callback-forward] done received for stream=${target.primaryStream} consumer=${consumerId}`);
+			serverLog.info(`[wake-callback] done received for stream=${target.primaryStream} consumer=${consumerId}`);
 			const stillOwnsClaim = ctx.runtime.claimWriteTokens.owns(ctx.service, target.primaryStream, consumerId);
 			const entity = await ctx.entityManager.registry.getEntityByStream(target.primaryStream);
 			let entityCleared = false;
@@ -5795,13 +5806,13 @@ async function callbackForward(request, ctx) {
 			if (entity && (entityCleared || stillOwnsClaim)) {
 				await ctx.entityManager.registry.updateStatus(entity.url, entity.status === `stopping` ? `stopped` : `idle`);
 				await ctx.entityBridgeManager.onEntityChanged(entity.url);
-				serverLog.info(`[callback-forward] status updated after done for ${entity.url}`);
-			} else if (!entity) serverLog.warn(`[callback-forward] done received but no entity found for stream=${target.primaryStream}`);
+				serverLog.info(`[wake-callback] status updated after done for ${entity.url}`);
+			} else if (!entity) serverLog.warn(`[wake-callback] done received but no entity found for stream=${target.primaryStream}`);
 			if (stillOwnsClaim) ctx.runtime.claimWriteTokens.clearStream(ctx.service, target.primaryStream);
-			else if (entity) serverLog.info(`[callback-forward] done arrived after in-memory token evicted (stream=${target.primaryStream} consumer=${consumerId})`);
-		} else if (requestBody?.done === true) serverLog.warn(`[callback-forward] done received but skipped: upstream.ok=${upstream.ok} primaryStream=${target.primaryStream ?? `null`} consumer=${consumerId}`);
+			else if (entity) serverLog.info(`[wake-callback] done arrived after in-memory token evicted (stream=${target.primaryStream} consumer=${consumerId})`);
+		} else if (requestBody?.done === true) serverLog.warn(`[wake-callback] done received but skipped: upstream.ok=${upstream.ok} primaryStream=${target.primaryStream ?? `null`} consumer=${consumerId}`);
 	} catch (err) {
-		serverLog.error(`[callback-forward] error processing done for consumer=${consumerId}: ${err instanceof Error ? err.message : String(err)}`);
+		serverLog.error(`[wake-callback] error processing done for consumer=${consumerId}: ${err instanceof Error ? err.message : String(err)}`);
 	}
 	return responseFromUpstream(upstream, responseBytes);
 }
@@ -5810,11 +5821,11 @@ async function mintClaimWriteToken(ctx, streamPath, consumerId) {
 	if (!entity) return void 0;
 	return ctx.runtime.claimWriteTokens.mint(ctx.service, streamPath, consumerId);
 }
-function encodeCallbackForwardBody(service, consumerId, body, routingAdapter) {
-	const payload = encodeCallbackForwardPayload(consumerId, body, (stream) => routingAdapter.toBackendStreamPath(service, stream));
+function encodeWakeCallbackBody(service, consumerId, body, routingAdapter) {
+	const payload = encodeWakeCallbackPayload(consumerId, body, (stream) => routingAdapter.toBackendStreamPath(service, stream));
 	return new TextEncoder().encode(JSON.stringify(payload));
 }
-function encodeCallbackForwardPayload(consumerId, body, mapStream) {
+function encodeWakeCallbackPayload(consumerId, body, mapStream) {
 	if (!body) return {};
 	const generation = body.generation ?? body.epoch;
 	const wakeId = body.wake_id ?? body.wakeId ?? consumerId;
@@ -7396,7 +7407,7 @@ var WakeRegistry = class {
 				try {
 					for (const message of messages) {
 						await this.applyShapeMessage(message);
-						if (!settled && `control` in message.headers && message.headers.control === `up-to-date`) {
+						if (!settled && isControlMessage(message) && message.headers.control === `up-to-date`) {
 							settled = true;
 							resolve$1();
 						}