@electric-ax/agents-server 0.4.20 → 0.5.1

package/dist/entrypoint.js

@@ -4,7 +4,7 @@ import { DurableStreamTestServer } from "@durable-streams/server";
 import { createServer } from "node:http";
 import { createServerAdapter } from "@whatwg-node/server";
 import { Agent } from "undici";
-import { COMPOSER_INPUT_MESSAGE_TYPE, appendPathToUrl, assertTags, buildEventSourceManifestEntry, buildTagsIndex, canonicalPgSyncOptions, createEntityRegistry, createRuntimeHandler, entityStateSchema, eventSourceSubscriptionManifestKey, getCronStreamPath, getCronStreamPathFromSpec, getEntitiesStreamPath, getNextCronFireAt, getPgSyncStreamPath, getSharedStateStreamPath, getWebhookStreamPath, hashString, manifestChildKey, manifestSharedStateKey, manifestSourceKey, normalizeTags, parseCronStreamPath, resolveCronScheduleSpec, resolveEventSourceSubscription, sourceRefForPgSync, sourceRefForTags, validateComposerInputPayload, validateSlashCommandDefinitions, verifyWebhookSignature } from "@electric-ax/agents-runtime";
+import { COMMENTS_CONTRACT, COMPOSER_INPUT_MESSAGE_TYPE, appendPathToUrl, assertTags, buildTagsIndex, buildWebhookSourceManifestEntry, canonicalPgSyncOptions, createEntityRegistry, createRuntimeHandler, entityStateSchema, getCronStreamPath, getCronStreamPathFromSpec, getEntitiesStreamPath, getNextCronFireAt, getPgSyncStreamPath, getSharedStateStreamPath, getWebhookStreamPath, hashString, manifestChildKey, manifestSharedStateKey, manifestSourceKey, normalizeTags, parseCronStreamPath, resolveCronScheduleSpec, resolveWebhookSourceSubscription, sourceRefForPgSync, sourceRefForTags, validateComposerInputPayload, validateSlashCommandDefinitions, verifyWebhookSignature, webhookSourceSubscriptionManifestKey } from "@electric-ax/agents-runtime";
 import fs, { existsSync } from "node:fs";
 import path, { dirname, resolve } from "node:path";
 import { drizzle } from "drizzle-orm/postgres-js";
@@ -65,6 +65,7 @@ const entityTypes = pgTable(`entity_types`, {
 	creationSchema: jsonb(`creation_schema`),
 	inboxSchemas: jsonb(`inbox_schemas`),
 	stateSchemas: jsonb(`state_schemas`),
+	externallyWritableCollections: jsonb(`externally_writable_collections`).$type(),
 	slashCommands: jsonb(`slash_commands`),
 	serveEndpoint: text(`serve_endpoint`),
 	defaultDispatchPolicy: jsonb(`default_dispatch_policy`),
@@ -2796,6 +2797,7 @@ var PostgresRegistry = class {
 			creationSchema: et.creation_schema ?? null,
 			inboxSchemas: et.inbox_schemas ?? null,
 			stateSchemas: et.state_schemas ?? null,
+			externallyWritableCollections: et.externally_writable_collections ?? null,
 			slashCommands: et.slash_commands ?? null,
 			serveEndpoint: et.serve_endpoint ?? null,
 			defaultDispatchPolicy: et.default_dispatch_policy ?? null,
@@ -2809,6 +2811,7 @@ var PostgresRegistry = class {
 				creationSchema: et.creation_schema ?? null,
 				inboxSchemas: et.inbox_schemas ?? null,
 				stateSchemas: et.state_schemas ?? null,
+				externallyWritableCollections: et.externally_writable_collections ?? null,
 				slashCommands: et.slash_commands ?? null,
 				serveEndpoint: et.serve_endpoint ?? null,
 				defaultDispatchPolicy: et.default_dispatch_policy ?? null,
@@ -2827,6 +2830,7 @@ var PostgresRegistry = class {
 			creationSchema: et.creation_schema ?? null,
 			inboxSchemas: et.inbox_schemas ?? null,
 			stateSchemas: et.state_schemas ?? null,
+			externallyWritableCollections: et.externally_writable_collections ?? null,
 			slashCommands: et.slash_commands ?? null,
 			serveEndpoint: et.serve_endpoint ?? null,
 			defaultDispatchPolicy: et.default_dispatch_policy ?? null,
@@ -2854,6 +2858,7 @@ var PostgresRegistry = class {
 			creationSchema: et.creation_schema ?? null,
 			inboxSchemas: et.inbox_schemas ?? null,
 			stateSchemas: et.state_schemas ?? null,
+			externallyWritableCollections: et.externally_writable_collections ?? null,
 			slashCommands: et.slash_commands ?? null,
 			serveEndpoint: et.serve_endpoint ?? null,
 			defaultDispatchPolicy: et.default_dispatch_policy ?? null,
@@ -3298,7 +3303,6 @@ var PostgresRegistry = class {
 			set: {
 				options: row.options,
 				streamUrl: row.streamUrl,
-				initialSnapshotComplete: false,
 				lastTouchedAt: new Date(),
 				updatedAt: new Date()
 			}
@@ -3337,6 +3341,9 @@ var PostgresRegistry = class {
 			updatedAt: new Date()
 		}).where(this.pgSyncBridgeWhere(sourceRef));
 	}
+	async deletePgSyncBridge(sourceRef) {
+		await this.db.delete(pgSyncBridges).where(this.pgSyncBridgeWhere(sourceRef));
+	}
 	async upsertEntityBridge(row) {
 		await this.db.insert(entityBridges).values({
 			tenantId: this.tenantId,
@@ -3499,6 +3506,7 @@ var PostgresRegistry = class {
 			creation_schema: row.creationSchema,
 			inbox_schemas: row.inboxSchemas,
 			state_schemas: row.stateSchemas,
+			externally_writable_collections: row.externallyWritableCollections ?? void 0,
 			slash_commands: row.slashCommands ?? void 0,
 			serve_endpoint: row.serveEndpoint ?? void 0,
 			default_dispatch_policy: row.defaultDispatchPolicy ?? void 0,
@@ -3650,9 +3658,6 @@ var PostgresRegistry = class {
 function isRecord$1(value) {
 	return typeof value === `object` && value !== null && !Array.isArray(value);
 }
-function getPgSyncManifestStreamPath(sourceRef) {
-	return `/_electric/pg-sync/${sourceRef}`;
-}
 function extractManifestSourceUrl(manifest) {
 	if (!manifest) return void 0;
 	if (manifest.kind === `child` || manifest.kind === `observe`) return typeof manifest.entity_url === `string` ? manifest.entity_url : void 0;
@@ -3665,7 +3670,7 @@ function extractManifestSourceUrl(manifest) {
 		}
 		if (manifest.sourceType === `entities`) return typeof manifest.sourceRef === `string` ? `/_entities/${manifest.sourceRef}` : void 0;
 		if (manifest.sourceType === `db`) return typeof manifest.sourceRef === `string` ? getSharedStateStreamPath(manifest.sourceRef) : void 0;
-		if (manifest.sourceType === `pgSync`) return typeof manifest.sourceRef === `string` ? getPgSyncManifestStreamPath(manifest.sourceRef) : void 0;
+		if (manifest.sourceType === `pgSync`) return typeof config?.streamUrl === `string` ? config.streamUrl : void 0;
 		if (manifest.sourceType === `webhook`) {
 			if (typeof config?.streamUrl === `string`) return config.streamUrl;
 			if (typeof config?.endpointKey === `string`) return getWebhookStreamPath(config.endpointKey, typeof config.bucket === `string` ? config.bucket : void 0);
@@ -3861,6 +3866,7 @@ var EntityManager = class {
 			creation_schema: req.creation_schema,
 			inbox_schemas: req.inbox_schemas,
 			state_schemas: req.state_schemas,
+			externally_writable_collections: req.externally_writable_collections,
 			slash_commands: req.slash_commands,
 			serve_endpoint: req.serve_endpoint,
 			default_dispatch_policy: defaultDispatchPolicy,
@@ -4956,6 +4962,40 @@ var EntityManager = class {
 			throw err;
 		}
 	}
+	async writeCollection(entityUrl, collection, req) {
+		const entity = await this.registry.getEntity(entityUrl);
+		if (!entity) throw new ElectricAgentsError(ErrCodeNotFound, `Entity not found`, 404);
+		const { externallyWritableCollections } = await this.getEffectiveSchemas(entity);
+		const config = externallyWritableCollections?.[collection];
+		if (!config) throw new ElectricAgentsError(ErrCodeUnauthorized, `Collection "${collection}" is not writable`, 403);
+		const allowedOperations = config.operations ?? [`insert`];
+		if (!allowedOperations.includes(req.operation)) throw new ElectricAgentsError(ErrCodeUnauthorized, `Operation "${req.operation}" is not allowed on collection "${collection}"`, 403);
+		if (rejectsNormalWrites(entity.status)) throw new ElectricAgentsError(ErrCodeNotRunning, `Entity is not accepting writes`, 409);
+		if (this.isForkWorkLockedEntity(entityUrl)) this.assertEntityNotForkWorkLocked(entityUrl);
+		if (req.operation !== `delete` && (req.value === void 0 || req.value === null)) throw new ElectricAgentsError(ErrCodeInvalidRequest, `value is required for ${req.operation}`, 400);
+		if (req.operation !== `insert` && !req.key) throw new ElectricAgentsError(ErrCodeInvalidRequest, `key is required for ${req.operation}`, 400);
+		const key = req.key ?? `${collection}-${randomUUID()}`;
+		const event = {
+			type: config.type,
+			key,
+			headers: {
+				operation: req.operation,
+				timestamp: new Date().toISOString(),
+				principal: req.principal
+			}
+		};
+		if (req.operation !== `delete`) event.value = req.value;
+		const validationError = await this.validateWriteEvent(entity, event);
+		if (validationError) throw new ElectricAgentsError(validationError.code, validationError.message, validationError.status);
+		const encoded = this.encodeChangeEvent(event);
+		try {
+			await this.streamClient.append(entity.streams.main, encoded);
+		} catch (err) {
+			if (this.isClosedStreamError(err)) throw new ElectricAgentsError(ErrCodeNotRunning, `Entity is stopped`, 409);
+			throw err;
+		}
+		return { key };
+	}
 	async updateInboxMessage(entityUrl, key, req) {
 		const entity = await this.registry.getEntity(entityUrl);
 		if (!entity) throw new ElectricAgentsError(ErrCodeNotFound, `Entity not found`, 404);
@@ -5222,7 +5262,7 @@ var EntityManager = class {
 		await this.writeManifestEntry(entityUrl, manifestKey, `delete`, void 0, { txid });
 		return { txid };
 	}
-	async upsertEventSourceSubscription(entityUrl, req) {
+	async upsertWebhookSourceSubscription(entityUrl, req) {
 		const manifestKey = req.subscription.manifestKey;
 		const txid = randomUUID();
 		await this.writeManifestEntry(entityUrl, manifestKey, `upsert`, req.manifest, { txid });
@@ -5244,8 +5284,20 @@ var EntityManager = class {
 			subscription: req.subscription
 		};
 	}
-	async deleteEventSourceSubscription(entityUrl, req) {
-		const manifestKey = eventSourceSubscriptionManifestKey(req.id);
+	async deleteWebhookSourceSubscription(entityUrl, req) {
+		const manifestKey = webhookSourceSubscriptionManifestKey(req.id);
+		const txid = randomUUID();
+		await this.writeManifestEntry(entityUrl, manifestKey, `delete`, void 0, { txid });
+		await this.wakeRegistry.unregisterByManifestKey(entityUrl, manifestKey, this.tenantId);
+		return { txid };
+	}
+	/**
+	* Stop this entity observing a pg-sync source: drop its manifest entry and
+	* the wake it anchors. The shared pg-sync bridge (keyed by sourceRef, not by
+	* subscriber) is intentionally left running for any other observers.
+	*/
+	async deletePgSyncObservation(entityUrl, req) {
+		const manifestKey = `source:pgSync:${req.sourceRef}`;
 		const txid = randomUUID();
 		await this.writeManifestEntry(entityUrl, manifestKey, `delete`, void 0, { txid });
 		await this.wakeRegistry.unregisterByManifestKey(entityUrl, manifestKey, this.tenantId);
@@ -5648,7 +5700,8 @@ var EntityManager = class {
 	async getEffectiveSchemas(entity) {
 		if (!entity.type) return {
 			inboxSchemas: entity.inbox_schemas,
-			stateSchemas: entity.state_schemas
+			stateSchemas: entity.state_schemas,
+			externallyWritableCollections: void 0
 		};
 		const latestType = await this.registry.getEntityType(entity.type);
 		return {
@@ -5659,7 +5712,8 @@ var EntityManager = class {
 			stateSchemas: latestType?.state_schemas ? {
 				...entity.state_schemas ?? {},
 				...latestType.state_schemas
-			} : entity.state_schemas
+			} : entity.state_schemas,
+			externallyWritableCollections: latestType?.externally_writable_collections
 		};
 	}
 	isClosedStreamError(err) {
@@ -5922,6 +5976,15 @@ const spawnBodySchema = Type.Object({
 		manifestKey: Type.Optional(Type.String())
 	}))
 });
+const writeCollectionBodySchema = Type.Object({
+	operation: Type.Union([
+		Type.Literal(`insert`),
+		Type.Literal(`update`),
+		Type.Literal(`delete`)
+	]),
+	key: Type.Optional(Type.String()),
+	value: Type.Optional(Type.Record(Type.String(), Type.Unknown()))
+}, { additionalProperties: false });
 const sendBodySchema = Type.Object({
 	payload: Type.Optional(Type.Unknown()),
 	key: Type.Optional(Type.String()),
@@ -6031,8 +6094,8 @@ const subscriptionLifetimeSchema = Type.Union([
 	}),
 	Type.Object({ kind: Type.Literal(`manual`) })
 ]);
-const eventSourceSubscriptionBodySchema = Type.Object({
-	sourceKey: Type.String(),
+const webhookSourceSubscriptionBodySchema = Type.Object({
+	webhookKey: Type.String(),
 	bucketKey: Type.Optional(Type.String()),
 	params: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
 	filterKey: Type.Optional(Type.String()),
@@ -6054,6 +6117,7 @@ entitiesRouter.head(`/:type/:instanceId`, withExistingEntity, withEntityPermissi
 entitiesRouter.delete(`/:type/:instanceId`, withExistingEntity, withEntityPermission(`delete`), killEntity);
 entitiesRouter.post(`/:type/:instanceId/signal`, withExistingEntity, withSchema(signalBodySchema), withEntityPermission(`signal`), signalEntity);
 entitiesRouter.post(`/:type/:instanceId/send`, withExistingEntity, withSchema(sendBodySchema), withEntityPermission(`write`), sendEntity);
+entitiesRouter.post(`/:type/:instanceId/collections/:collection`, withExistingEntity, withSchema(writeCollectionBodySchema), withEntityPermission(`write`), writeCollection);
 entitiesRouter.post(`/:type/:instanceId/attachments`, withExistingEntity, withEntityPermission(`write`), createAttachment);
 entitiesRouter.get(`/:type/:instanceId/attachments/:attachmentId`, withExistingEntity, withEntityPermission(`read`), readAttachment);
 entitiesRouter.delete(`/:type/:instanceId/attachments/:attachmentId`, withExistingEntity, withEntityPermission(`write`), deleteAttachment);
@@ -6064,8 +6128,9 @@ entitiesRouter.post(`/:type/:instanceId/tags/:tagKey`, withExistingEntity, withS
 entitiesRouter.delete(`/:type/:instanceId/tags/:tagKey`, withExistingEntity, withEntityPermission(`write`), deleteTag);
 entitiesRouter.put(`/:type/:instanceId/schedules/:scheduleId`, withExistingEntity, withSchema(scheduleBodySchema), withEntityPermission(`schedule`), upsertSchedule);
 entitiesRouter.delete(`/:type/:instanceId/schedules/:scheduleId`, withExistingEntity, withEntityPermission(`schedule`), deleteSchedule);
-entitiesRouter.put(`/:type/:instanceId/event-source-subscriptions/:subscriptionId`, withExistingEntity, withSchema(eventSourceSubscriptionBodySchema), withEntityPermission(`write`), upsertEventSourceSubscription);
-entitiesRouter.delete(`/:type/:instanceId/event-source-subscriptions/:subscriptionId`, withExistingEntity, withEntityPermission(`write`), deleteEventSourceSubscription);
+entitiesRouter.put(`/:type/:instanceId/webhook-source-subscriptions/:subscriptionId`, withExistingEntity, withSchema(webhookSourceSubscriptionBodySchema), withEntityPermission(`write`), upsertWebhookSourceSubscription);
+entitiesRouter.delete(`/:type/:instanceId/webhook-source-subscriptions/:subscriptionId`, withExistingEntity, withEntityPermission(`write`), deleteWebhookSourceSubscription);
+entitiesRouter.delete(`/:type/:instanceId/pg-sync-observations/:sourceRef`, withExistingEntity, withEntityPermission(`write`), deletePgSyncObservation);
 entitiesRouter.get(`/:type/:instanceId/grants`, withExistingEntity, withEntityPermission(`manage`), listEntityPermissionGrants);
 entitiesRouter.post(`/:type/:instanceId/grants`, withExistingEntity, withSchema(entityPermissionGrantInputSchema), withEntityPermission(`manage`), createEntityPermissionGrant);
 entitiesRouter.delete(`/:type/:instanceId/grants/:grantId`, withExistingEntity, withEntityPermission(`manage`), deleteEntityPermissionGrant);
@@ -6316,22 +6381,22 @@ async function deleteSchedule(request, ctx) {
 	const result = await ctx.entityManager.deleteSchedule(entityUrl, { id: decodeURIComponent(request.params.scheduleId) });
 	return json(result);
 }
-async function upsertEventSourceSubscription(request, ctx) {
-	const principalMutationError = rejectPrincipalEntityMutation(request, `subscribed to event sources`);
+async function upsertWebhookSourceSubscription(request, ctx) {
+	const principalMutationError = rejectPrincipalEntityMutation(request, `subscribed to webhook sources`);
 	if (principalMutationError) return principalMutationError;
-	const catalog = ctx.eventSources;
-	if (!catalog) return apiError(404, ErrCodeNotFound, `No event source catalog is configured`);
+	const catalog = ctx.webhookSources;
+	if (!catalog) return apiError(404, ErrCodeNotFound, `No webhook source catalog is configured`);
 	const { entityUrl } = requireExistingEntityRoute(request);
 	const parsed = routeBody(request);
-	const source = await catalog.getEventSource(parsed.sourceKey);
-	if (!source) return apiError(404, ErrCodeNotFound, `Event source "${parsed.sourceKey}" not found`);
+	const source = await catalog.getWebhookSource(parsed.webhookKey);
+	if (!source) return apiError(404, ErrCodeNotFound, `Webhook source "${parsed.webhookKey}" not found`);
 	if (parsed.lifetime?.kind === `expires_at`) {
 		const expiresAt = new Date(parsed.lifetime.at);
 		if (Number.isNaN(expiresAt.getTime())) return apiError(400, ErrCodeInvalidRequest, `Invalid expires_at lifetime timestamp`);
 	}
 	let resolved;
 	try {
-		resolved = resolveEventSourceSubscription({
+		resolved = resolveWebhookSourceSubscription({
 			contract: source,
 			entityUrl,
 			request: {
@@ -6343,18 +6408,25 @@ async function upsertEventSourceSubscription(request, ctx) {
 	} catch (error) {
 		return apiError(400, ErrCodeInvalidRequest, error instanceof Error ? error.message : String(error));
 	}
-	await ctx.ensureEventSourceWakeSource?.(resolved.subscription.sourceUrl);
-	const result = await ctx.entityManager.upsertEventSourceSubscription(entityUrl, {
+	await ctx.ensureWebhookSourceWakeSource?.(resolved.subscription.sourceUrl);
+	const result = await ctx.entityManager.upsertWebhookSourceSubscription(entityUrl, {
 		subscription: resolved.subscription,
-		manifest: buildEventSourceManifestEntry(resolved)
+		manifest: buildWebhookSourceManifestEntry(resolved)
 	});
 	return json(result);
 }
-async function deleteEventSourceSubscription(request, ctx) {
-	const principalMutationError = rejectPrincipalEntityMutation(request, `unsubscribed from event sources`);
+async function deleteWebhookSourceSubscription(request, ctx) {
+	const principalMutationError = rejectPrincipalEntityMutation(request, `unsubscribed from webhook sources`);
+	if (principalMutationError) return principalMutationError;
+	const { entityUrl } = requireExistingEntityRoute(request);
+	const result = await ctx.entityManager.deleteWebhookSourceSubscription(entityUrl, { id: decodeURIComponent(request.params.subscriptionId) });
+	return json(result);
+}
+async function deletePgSyncObservation(request, ctx) {
+	const principalMutationError = rejectPrincipalEntityMutation(request, `unobserved a pg-sync source`);
 	if (principalMutationError) return principalMutationError;
 	const { entityUrl } = requireExistingEntityRoute(request);
-	const result = await ctx.entityManager.deleteEventSourceSubscription(entityUrl, { id: decodeURIComponent(request.params.subscriptionId) });
+	const result = await ctx.entityManager.deletePgSyncObservation(entityUrl, { sourceRef: decodeURIComponent(request.params.sourceRef) });
 	return json(result);
 }
 function tagResponseBody(entity) {
@@ -6452,6 +6524,23 @@ async function sendEntity(request, ctx) {
 	const result = await ctx.entityManager.send(entityUrl, sendReq);
 	return json(result);
 }
+async function writeCollection(request, ctx) {
+	const parsed = routeBody(request);
+	await ctx.entityManager.ensurePrincipal(ctx.principal);
+	const { entityUrl } = requireExistingEntityRoute(request);
+	const collection = request.params.collection;
+	const result = await ctx.entityManager.writeCollection(entityUrl, collection, {
+		operation: parsed.operation,
+		key: parsed.key,
+		value: parsed.value,
+		principal: {
+			url: ctx.principal.url,
+			kind: ctx.principal.kind,
+			id: ctx.principal.id
+		}
+	});
+	return json(result, { status: parsed.operation === `insert` ? 201 : 200 });
+}
 async function createAttachment(request, ctx) {
 	const principalMutationError = rejectPrincipalEntityMutation(request, `given attachments`);
 	if (principalMutationError) return principalMutationError;
@@ -6549,8 +6638,13 @@ async function spawnEntity(request, ctx) {
 		headers: { "x-write-token": entity.write_token }
 	});
 }
-function getEntity(request) {
-	return json(toPublicEntity(requireExistingEntityRoute(request).entity));
+async function getEntity(request, ctx) {
+	const { entity } = requireExistingEntityRoute(request);
+	const entityType = entity.type ? await ctx.entityManager.registry.getEntityType(entity.type) : null;
+	return json({
+		...toPublicEntity(entity),
+		...entityType?.externally_writable_collections && { externally_writable_collections: entityType.externally_writable_collections }
+	});
 }
 function headEntity() {
 	return status(200);
@@ -6585,6 +6679,16 @@ async function signalEntity(request, ctx) {
 //#region src/routing/entity-types-router.ts
 const jsonObjectSchema = Type.Record(Type.String(), Type.Unknown());
 const schemaMapSchema = Type.Record(Type.String(), jsonObjectSchema);
+const externallyWritableCollectionsSchema = Type.Record(Type.String(), Type.Object({
+	type: Type.String(),
+	contract: Type.Optional(Type.String()),
+	operations: Type.Optional(Type.Array(Type.Union([
+		Type.Literal(`insert`),
+		Type.Literal(`update`),
+		Type.Literal(`delete`)
+	]))),
+	principalColumn: Type.Optional(Type.String())
+}, { additionalProperties: false }));
 const slashCommandArgumentSchema = Type.Object({
 	name: Type.String(),
 	type: Type.Union([
@@ -6615,7 +6719,8 @@ const registerEntityTypeBodySchema = Type.Object({
 	slash_commands: Type.Optional(Type.Array(slashCommandSchema)),
 	serve_endpoint: Type.Optional(Type.String()),
 	default_dispatch_policy: Type.Optional(dispatchPolicySchema),
-	permission_grants: Type.Optional(Type.Array(typePermissionGrantInputSchema))
+	permission_grants: Type.Optional(Type.Array(typePermissionGrantInputSchema)),
+	externally_writable_collections: Type.Optional(externallyWritableCollectionsSchema)
 }, { additionalProperties: false });
 const amendEntityTypeSchemasBodySchema = Type.Object({
 	inbox_schemas: Type.Optional(schemaMapSchema),
@@ -6746,7 +6851,20 @@ function parseExpiresAt(value) {
 	if (Number.isNaN(expiresAt.getTime())) throw new ElectricAgentsError(ErrCodeInvalidRequest, `Invalid expires_at timestamp`, 400);
 	return expiresAt;
 }
+/**
+* The `comments` collection name is reserved for the canonical comments
+* contract: the UI keys its comment affordances on it, so a divergent
+* collection registered under that name (or the contract mounted under
+* another name) would break that assumption silently.
+*/
+function validateExternallyWritableCollections(collections) {
+	for (const [name, config] of Object.entries(collections ?? {})) {
+		if (name === `comments` && config.contract !== COMMENTS_CONTRACT) throw new ElectricAgentsError(ErrCodeInvalidRequest, `The externally-writable collection name "comments" is reserved for the "${COMMENTS_CONTRACT}" contract`, 400);
+		if (config.contract === COMMENTS_CONTRACT && name !== `comments`) throw new ElectricAgentsError(ErrCodeInvalidRequest, `The "${COMMENTS_CONTRACT}" contract must be registered under the collection name "comments"`, 400);
+	}
+}
 function normalizeEntityTypeRequest(parsed) {
+	validateExternallyWritableCollections(parsed.externally_writable_collections);
 	const serveEndpoint = rewriteLoopbackWebhookUrl(parsed.serve_endpoint);
 	return {
 		name: parsed.name ?? ``,
@@ -6760,7 +6878,8 @@ function normalizeEntityTypeRequest(parsed) {
 			type: `webhook`,
 			url: serveEndpoint
 		}] } : void 0),
-		permission_grants: parsed.permission_grants
+		permission_grants: parsed.permission_grants,
+		externally_writable_collections: parsed.externally_writable_collections
 	};
 }
 function toPublicEntityType(entityType) {
@@ -6771,130 +6890,481 @@ function toPublicEntityType(entityType) {
 }
 
 //#endregion
-//#region src/routing/pg-sync-router.ts
-const pgSyncOptionsSchema = Type.Object({
-	url: Type.Optional(Type.String()),
-	table: Type.String(),
-	columns: Type.Optional(Type.Array(Type.String())),
-	where: Type.Optional(Type.String()),
-	params: Type.Optional(Type.Union([Type.Array(Type.String()), Type.Record(Type.String(), Type.String())])),
-	replica: Type.Optional(Type.Union([Type.Literal(`default`), Type.Literal(`full`)]))
-});
-const pgSyncRequestMetadataSchema = Type.Object({
-	entityUrl: Type.Optional(Type.String()),
-	entityType: Type.Optional(Type.String()),
-	streamPath: Type.Optional(Type.String()),
-	runtimeConsumerId: Type.Optional(Type.String()),
-	wakeId: Type.Optional(Type.String())
-});
-const pgSyncRegisterBodySchema = Type.Object({
-	options: pgSyncOptionsSchema,
-	metadata: Type.Optional(pgSyncRequestMetadataSchema)
-});
-const pgSyncRouter = Router({ base: `/_electric/pg-sync` });
-pgSyncRouter.post(`/register`, withSchema(pgSyncRegisterBodySchema), registerPgSync);
-async function registerPgSync(request, ctx) {
-	const { options, metadata } = routeBody(request);
-	if (options.table.trim() === ``) return apiError(400, ErrCodeInvalidRequest, `pgSync table must be non-empty`);
-	if (!ctx.pgSyncBridgeManager) return apiError(503, ErrCodeInvalidRequest, `pgSync bridge manager is not configured`);
+//#region src/pg-sync-bridge-manager.ts
+/** Registration was rejected because the source itself is invalid — map to a 4xx. */
+var PgSyncSourceValidationError = class extends Error {
+	name = `PgSyncSourceValidationError`;
+};
+const DEFAULT_RETRY_INITIAL_DELAY_MS = 1e3;
+const DEFAULT_RETRY_MAX_DELAY_MS = 3e4;
+const DEFAULT_PROBE_TIMEOUT_MS = 1e4;
+function buildElectricShapeParams(options) {
+	return {
+		table: options.table,
+		...options.columns !== void 0 ? { columns: [...options.columns] } : {},
+		...options.where !== void 0 ? { where: options.where } : {},
+		...options.params !== void 0 ? { params: Array.isArray(options.params) ? [...options.params] : { ...options.params } } : {},
+		...options.replica !== void 0 ? { replica: options.replica } : {},
+		...options.metadata?.tenantId ? { electric_agents_tenant_id: options.metadata.tenantId } : {},
+		...options.metadata?.principalKind ? { electric_agents_principal_kind: options.metadata.principalKind } : {},
+		...options.metadata?.principalId ? { electric_agents_principal_id: options.metadata.principalId } : {},
+		...options.metadata?.principalKey ? { electric_agents_principal_key: options.metadata.principalKey } : {},
+		...options.metadata?.principalUrl ? { electric_agents_principal_url: options.metadata.principalUrl } : {},
+		...options.metadata?.entityUrl ? { electric_agents_entity_url: options.metadata.entityUrl } : {},
+		...options.metadata?.entityType ? { electric_agents_entity_type: options.metadata.entityType } : {},
+		...options.metadata?.streamPath ? { electric_agents_stream_path: options.metadata.streamPath } : {},
+		...options.metadata?.runtimeConsumerId ? { electric_agents_runtime_consumer_id: options.metadata.runtimeConsumerId } : {},
+		...options.metadata?.wakeId ? { electric_agents_wake_id: options.metadata.wakeId } : {}
+	};
+}
+/**
+* Build the one-shot URL used to validate a shape source at registration
+* time. Approximates the query-param encoding of the Electric TS client
+* (arrays comma-joined, where-clause params as `params[n]`) — unlike the
+* client it does not quote column identifiers, so probe and stream encoding
+* can diverge for exotic column names.
+*/
+function buildShapeProbeUrl(sourceUrl, options) {
+	let url;
 	try {
-		const requestMetadata$1 = {
-			tenantId: ctx.service,
-			principalKind: ctx.principal.kind,
-			principalId: ctx.principal.id,
-			principalKey: ctx.principal.key,
-			principalUrl: ctx.principal.url,
-			...metadata ?? {}
-		};
-		const result = await ctx.pgSyncBridgeManager.register(options, requestMetadata$1);
-		return json(result);
-	} catch (error) {
-		return apiError(500, ErrCodeInvalidRequest, `pgSync registration failed: ${error instanceof Error ? error.message : String(error)}`);
+		url = new URL(sourceUrl);
+	} catch {
+		throw new PgSyncSourceValidationError(`pgSync url "${sourceUrl}" is not a valid URL`);
 	}
+	if (url.protocol !== `http:` && url.protocol !== `https:`) throw new PgSyncSourceValidationError(`pgSync url "${sourceUrl}" must be an HTTP(S) Electric shape endpoint, not a database connection string`);
+	for (const [key, value] of Object.entries(buildElectricShapeParams(options))) {
+		if (value === void 0 || value === null) continue;
+		if (Array.isArray(value)) if (key === `params`) value.forEach((item, index$1) => url.searchParams.set(`params[${index$1 + 1}]`, String(item)));
+		else url.searchParams.set(key, value.join(`,`));
+		else if (typeof value === `object`) for (const [k, v] of Object.entries(value)) url.searchParams.set(`${key}[${k}]`, String(v));
+		else url.searchParams.set(key, String(value));
+	}
+	url.searchParams.set(`offset`, `now`);
+	return url;
 }
-
-//#endregion
-//#region src/routing/hooks.ts
-const SPAN_KEY = Symbol(`agents-server.otel-span`);
-function headersRecord(headers) {
-	const out = {};
-	headers.forEach((value, key) => {
-		out[key] = value;
-	});
-	return out;
-}
-function carrier(req) {
-	return req;
+function jsonSafe(value) {
+	if (typeof value === `bigint`) return value.toString();
+	if (value === null || typeof value !== `object`) return value;
+	if (Array.isArray(value)) return value.map(jsonSafe);
+	return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, jsonSafe(item)]));
 }
-function startRequestSpan(req, ctx) {
-	const existing = carrier(req)[SPAN_KEY];
-	if (existing) return existing;
-	const url = new URL(req.url);
-	const parentCtx = extractTraceContext(headersRecord(req.headers));
-	const span = tracer.startSpan(`HTTP ${req.method}`, {
-		kind: SpanKind.SERVER,
-		attributes: {
-			[ATTR.HTTP_METHOD]: req.method,
-			[ATTR.HTTP_ROUTE]: url.pathname,
-			"electric_agents.tenant_id": ctx.service
-		}
-	}, parentCtx);
-	carrier(req)[SPAN_KEY] = span;
-	return span;
+function stableJson(value) {
+	if (typeof value === `bigint`) return JSON.stringify(value.toString());
+	if (value === null || typeof value !== `object`) return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(stableJson).join(`,`)}]`;
+	return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(`,`)}}`;
 }
-function otelStartSpan(req, ctx) {
-	startRequestSpan(req, ctx);
-	return void 0;
+function parseElectricOffset$1(offset) {
+	if (offset === `-1`) return offset;
+	return /^\d+_\d+$/.test(offset) ? offset : null;
 }
-function otelEndSpan(response, req) {
-	const span = carrier(req)[SPAN_KEY];
-	if (!span) return;
-	if (response) span.setAttribute(ATTR.HTTP_STATUS, response.status);
-	span.end();
-	carrier(req)[SPAN_KEY] = void 0;
+function rowKeyForMessage(message) {
+	const headers = message.headers;
+	const candidate = headers.key ?? headers.rowKey ?? message.value?.id ?? message.value?.key ?? message.old_value?.id ?? message.old_value?.key;
+	return candidate === void 0 ? void 0 : stableJson(candidate);
 }
-function applyCors(response) {
-	if (!response) return response;
-	const headers = new Headers(response.headers);
-	headers.set(`access-control-allow-origin`, `*`);
-	headers.set(`access-control-allow-methods`, `GET, POST, PUT, PATCH, DELETE, OPTIONS`);
-	headers.set(`access-control-allow-headers`, [
-		`content-type`,
-		`authorization`,
-		`electric-claim-token`,
-		`electric-owner-entity`,
-		ELECTRIC_PRINCIPAL_HEADER,
-		`ngrok-skip-browser-warning`
-	].join(`, `));
-	headers.set(`access-control-expose-headers`, `*`);
-	return new Response(response.body, {
-		status: response.status,
-		statusText: response.statusText,
-		headers
-	});
+function pgSyncMessageToDurableEvent(message) {
+	const operation = message.headers.operation;
+	if (operation !== `insert` && operation !== `update` && operation !== `delete`) return null;
+	const key = message.key ?? (typeof message.headers.key === `string` ? message.headers.key : void 0) ?? rowKeyForMessage(message);
+	if (!key) return null;
+	const safeMessage = jsonSafe(message);
+	return {
+		type: `pg_sync_change`,
+		key,
+		value: safeMessage,
+		headers: {
+			...jsonSafe(message.headers),
+			operation
+		}
+	};
 }
-function preflightCors(req) {
-	if (req.method !== `OPTIONS`) return void 0;
-	return new Response(null, { status: 204 });
+function cursorFromRow(row) {
+	return row?.shapeHandle && row.shapeOffset ? {
+		handle: row.shapeHandle,
+		offset: row.shapeOffset,
+		initialSnapshotComplete: row.initialSnapshotComplete
+	} : void 0;
 }
-function errorMapper(err, req) {
-	const span = carrier(req)[SPAN_KEY];
-	if (err instanceof Error) {
-		span?.recordException(err);
-		span?.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: err.message
-		});
+var PgSyncBridge = class {
+	producer = null;
+	unsubscribe = null;
+	abortController = null;
+	skipChangesUntilUpToDate = false;
+	recovering = false;
+	committedCursor;
+	retryAttempt = 0;
+	constructor(sourceRef, streamUrl, options, resolvedSource, retry, streamClient, registry, evaluateWakes, initialCursor) {
+		this.sourceRef = sourceRef;
+		this.streamUrl = streamUrl;
+		this.options = options;
+		this.resolvedSource = resolvedSource;
+		this.retry = retry;
+		this.streamClient = streamClient;
+		this.registry = registry;
+		this.evaluateWakes = evaluateWakes;
+		this.initialCursor = initialCursor;
+		this.committedCursor = initialCursor;
 	}
-	if (err instanceof ElectricAgentsError) return apiError(err.status, err.code, err.message, err.details);
-	if (err instanceof ElectricProxyError) {
-		serverLog.warn(`[agent-server] Electric proxy rejected request (${err.code}): ${req.url}`);
-		return apiError(err.status, err.code, err.message);
+	async start() {
+		if (!this.producer) this.producer = new IdempotentProducer(new DurableStream({
+			url: `${this.streamClient.baseUrl}${this.streamUrl}`,
+			contentType: `application/json`
+		}), `pg-sync-bridge-${this.sourceRef}`);
+		if (this.initialCursor) {
+			const offset = parseElectricOffset$1(this.initialCursor.offset);
+			if (offset) {
+				this.startStream(offset, this.initialCursor.handle, !this.initialCursor.initialSnapshotComplete);
+				return;
+			}
+		}
+		await this.registry?.clearPgSyncBridgeCursor(this.sourceRef);
+		this.startStream(`now`, void 0, true);
 	}
-	serverLog.error(`[agent-server] Unhandled error:`, err);
-	return apiError(500, `INTERNAL_SERVER_ERROR`, `Internal server error`);
-}
-function rejectIfShuttingDown(req, ctx) {
+	async stop() {
+		this.unsubscribe?.();
+		this.abortController?.abort();
+		this.unsubscribe = null;
+		this.abortController = null;
+		try {
+			await this.producer?.flush();
+		} finally {
+			await this.producer?.detach();
+			this.producer = null;
+		}
+	}
+	startStream(offset, handle, skipChangesUntilUpToDate = false, log = offset === `now` ? `changes_only` : `full`) {
+		this.unsubscribe?.();
+		this.abortController?.abort();
+		this.skipChangesUntilUpToDate = skipChangesUntilUpToDate;
+		this.abortController = new AbortController();
+		const stream = new ShapeStream({
+			url: this.resolvedSource.url,
+			params: buildElectricShapeParams(this.options),
+			offset,
+			log,
+			...handle ? { handle } : {},
+			signal: this.abortController.signal
+		});
+		this.unsubscribe = stream.subscribe(async (messages) => {
+			try {
+				for (const message of messages) {
+					if (isControlMessage(message)) {
+						if (message.headers.control === `must-refetch`) {
+							await this.registry?.clearPgSyncBridgeCursor(this.sourceRef);
+							this.startStream(`now`, void 0, true);
+							return;
+						}
+						if (message.headers.control === `up-to-date`) {
+							this.skipChangesUntilUpToDate = false;
+							await this.persistCursor(stream, true);
+							continue;
+						}
+						await this.persistCursor(stream);
+						continue;
+					}
+					if (!isChangeMessage(message)) continue;
+					if (!this.skipChangesUntilUpToDate) {
+						const event = pgSyncMessageToDurableEvent(message);
+						if (event) {
+							if (!this.producer) throw new Error(`pg-sync producer is not started`);
+							await this.producer.append(JSON.stringify(event));
+							await this.producer.flush?.();
+							await this.evaluateWakes?.(this.streamUrl, event);
+						} else serverLog.warn(`[pg-sync-bridge] dropped change message for ${this.sourceRef} (unknown operation or missing row key):`, message.headers);
+					}
+					await this.persistCursor(stream);
+					this.retryAttempt = 0;
+				}
+			} catch (error) {
+				serverLog.warn(`[pg-sync-bridge] subscription callback failed for ${this.sourceRef}:`, error);
+				await this.recoverStream();
+			}
+		}, (error) => {
+			if (this.abortController?.signal.aborted) return;
+			serverLog.warn(`[pg-sync-bridge] subscription failed for ${this.sourceRef}:`, error);
+			this.recoverStream();
+		});
+	}
+	async recoverStream() {
+		if (this.recovering) return;
+		this.recovering = true;
+		try {
+			const attempt = this.retryAttempt++;
+			const baseDelay = Math.min(this.retry.initialDelayMs * 2 ** attempt, this.retry.maxDelayMs);
+			const jitter = Math.floor(baseDelay * .2 * this.retry.random());
+			const delay = baseDelay + jitter;
+			if (delay > 0) await this.retry.sleep(delay);
+			const offset = this.committedCursor ? parseElectricOffset$1(this.committedCursor.offset) : null;
+			if (offset && this.committedCursor) this.startStream(offset, this.committedCursor.handle, !this.committedCursor.initialSnapshotComplete);
+			else {
+				await this.registry?.clearPgSyncBridgeCursor(this.sourceRef);
+				this.startStream(`now`, void 0, true);
+			}
+		} finally {
+			this.recovering = false;
+		}
+	}
+	async persistCursor(stream, initialSnapshotComplete = !this.skipChangesUntilUpToDate) {
+		const shapeHandle = stream.shapeHandle;
+		const shapeOffset = stream.lastOffset;
+		if (!shapeHandle || !shapeOffset || shapeOffset === `-1`) return;
+		await this.registry?.updatePgSyncBridgeCursor(this.sourceRef, shapeHandle, shapeOffset, initialSnapshotComplete);
+		this.committedCursor = {
+			handle: shapeHandle,
+			offset: shapeOffset,
+			initialSnapshotComplete
+		};
+	}
+};
+var PgSyncBridgeManager = class {
+	bridges = new Map();
+	starting = new Map();
+	retry;
+	fetchFn;
+	probeTimeoutMs;
+	constructor(streamClient, evaluateWakes, registry, options = {}) {
+		this.streamClient = streamClient;
+		this.evaluateWakes = evaluateWakes;
+		this.registry = registry;
+		this.fetchFn = options.fetchFn;
+		this.probeTimeoutMs = options.probeTimeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+		this.retry = {
+			initialDelayMs: options.retry?.initialDelayMs ?? DEFAULT_RETRY_INITIAL_DELAY_MS,
+			maxDelayMs: options.retry?.maxDelayMs ?? DEFAULT_RETRY_MAX_DELAY_MS,
+			random: options.retry?.random ?? Math.random,
+			sleep: options.retry?.sleep ?? ((ms) => new Promise((resolve$1) => setTimeout(resolve$1, ms)))
+		};
+	}
+	async start() {
+		const rows = await this.registry?.listPgSyncBridges?.();
+		if (!rows) return;
+		await Promise.all(rows.map(async (row) => {
+			if (!row.options.url) {
+				serverLog.warn(`[pg-sync-bridge] deleting registration ${row.sourceRef}: it predates required source URLs; re-register the observation with an explicit Electric shape URL`);
+				await this.registry?.deletePgSyncBridge?.(row.sourceRef);
+				return;
+			}
+			await this.ensureBridge(row).catch((error) => {
+				serverLog.warn(`[pg-sync-bridge] failed to start ${row.sourceRef}:`, error);
+			});
+		}));
+	}
+	async register(options, metadata) {
+		const mergedMetadata = {
+			...options.metadata,
+			...metadata
+		};
+		const canonicalOptions = {
+			...canonicalPgSyncOptions(options),
+			...Object.keys(mergedMetadata).length > 0 ? { metadata: mergedMetadata } : {}
+		};
+		const resolvedSource = this.resolveSource(canonicalOptions);
+		const sourceRef = sourceRefForPgSync(canonicalOptions);
+		const streamUrl = getPgSyncStreamPath(sourceRef, this.registry?.tenantId);
+		if (!this.bridges.has(sourceRef) && !this.starting.has(sourceRef)) await this.probeSource(resolvedSource, canonicalOptions);
+		const row = await this.registry?.upsertPgSyncBridge({
+			sourceRef,
+			options: canonicalOptions,
+			streamUrl
+		});
+		await this.streamClient.ensure(streamUrl, { contentType: `application/json` });
+		if (!this.bridges.has(sourceRef)) {
+			let start = this.starting.get(sourceRef);
+			if (!start) {
+				start = (async () => {
+					const bridge = new PgSyncBridge(sourceRef, streamUrl, canonicalOptions, resolvedSource, this.retry, this.streamClient, this.registry, this.evaluateWakes, cursorFromRow(row));
+					await bridge.start();
+					this.bridges.set(sourceRef, bridge);
+				})().finally(() => this.starting.delete(sourceRef));
+				this.starting.set(sourceRef, start);
+			}
+			await start;
+		}
+		return {
+			sourceRef,
+			streamUrl
+		};
+	}
+	async ensureBridge(row) {
+		if (this.bridges.has(row.sourceRef)) return;
+		let start = this.starting.get(row.sourceRef);
+		if (!start) {
+			start = (async () => {
+				await this.streamClient.ensure(row.streamUrl, { contentType: `application/json` });
+				const canonicalOptions = canonicalPgSyncOptions(row.options);
+				const resolvedSource = this.resolveSource(canonicalOptions);
+				const bridge = new PgSyncBridge(row.sourceRef, row.streamUrl, canonicalOptions, resolvedSource, this.retry, this.streamClient, this.registry, this.evaluateWakes, cursorFromRow(row));
+				await bridge.start();
+				this.bridges.set(row.sourceRef, bridge);
+			})().finally(() => this.starting.delete(row.sourceRef));
+			this.starting.set(row.sourceRef, start);
+		}
+		await start;
+	}
+	resolveSource(options) {
+		if (!options.url) throw new PgSyncSourceValidationError(`pgSync source url is required; no server default is configured`);
+		return { url: options.url };
+	}
+	/**
+	* One-shot fetch of the shape log before a bridge is created, so a bad
+	* URL or rejected shape fails the registration instead of dying silently
+	* in the bridge's retry loop.
+	*/
+	async probeSource(source, options) {
+		const probeUrl = buildShapeProbeUrl(source.url, options);
+		const fetchFn = this.fetchFn ?? globalThis.fetch;
+		let response;
+		try {
+			response = await fetchFn(probeUrl, { signal: AbortSignal.timeout(this.probeTimeoutMs) });
+		} catch (error) {
+			throw new PgSyncSourceValidationError(`pgSync source at ${source.url} is unreachable: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (!response.ok) {
+			const body = (await response.text().catch(() => `<failed to read body>`)).slice(0, 500);
+			throw new PgSyncSourceValidationError(`pgSync source at ${source.url} rejected the shape request (${response.status})${body ? `: ${body}` : ``}`);
+		}
+		if (!response.headers.get(`electric-handle`)) {
+			const suggestion = new URL(source.url);
+			suggestion.pathname = `/v1/shape`;
+			throw new PgSyncSourceValidationError(`pgSync source at ${source.url} responded but is not a shape log (missing electric-handle header) — the Electric shape API is usually served at ${suggestion.origin}/v1/shape`);
+		}
+	}
+	async stop() {
+		await Promise.allSettled(this.starting.values());
+		await Promise.all([...this.bridges.values()].map((bridge) => bridge.stop()));
+		this.bridges.clear();
+	}
+};
+
+//#endregion
+//#region src/routing/pg-sync-router.ts
+const pgSyncOptionsSchema = Type.Object({
+	url: Type.String(),
+	table: Type.String(),
+	columns: Type.Optional(Type.Array(Type.String())),
+	where: Type.Optional(Type.String()),
+	params: Type.Optional(Type.Union([Type.Array(Type.String()), Type.Record(Type.String(), Type.String())])),
+	replica: Type.Optional(Type.Union([Type.Literal(`default`), Type.Literal(`full`)]))
+});
+const pgSyncRequestMetadataSchema = Type.Object({
+	entityUrl: Type.Optional(Type.String()),
+	entityType: Type.Optional(Type.String()),
+	streamPath: Type.Optional(Type.String()),
+	runtimeConsumerId: Type.Optional(Type.String()),
+	wakeId: Type.Optional(Type.String())
+});
+const pgSyncRegisterBodySchema = Type.Object({
+	options: pgSyncOptionsSchema,
+	metadata: Type.Optional(pgSyncRequestMetadataSchema)
+});
+const pgSyncRouter = Router({ base: `/_electric/pg-sync` });
+pgSyncRouter.post(`/register`, withSchema(pgSyncRegisterBodySchema), registerPgSync);
+async function registerPgSync(request, ctx) {
+	const { options, metadata } = routeBody(request);
+	if (options.url.trim() === ``) return apiError(400, ErrCodeInvalidRequest, `pgSync url must be non-empty`);
+	if (options.table.trim() === ``) return apiError(400, ErrCodeInvalidRequest, `pgSync table must be non-empty`);
+	if (!ctx.pgSyncBridgeManager) return apiError(503, ErrCodeInvalidRequest, `pgSync bridge manager is not configured`);
+	try {
+		const requestMetadata$1 = {
+			tenantId: ctx.service,
+			principalKind: ctx.principal.kind,
+			principalId: ctx.principal.id,
+			principalKey: ctx.principal.key,
+			principalUrl: ctx.principal.url,
+			...metadata ?? {}
+		};
+		const result = await ctx.pgSyncBridgeManager.register(options, requestMetadata$1);
+		return json(result);
+	} catch (error) {
+		if (error instanceof PgSyncSourceValidationError) return apiError(400, ErrCodeInvalidRequest, error.message);
+		serverLog.error(`[pg-sync] registration failed for table "${options.table}":`, error);
+		return apiError(500, ErrCodeInvalidRequest, `pgSync registration failed: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+
+//#endregion
+//#region src/routing/hooks.ts
+const SPAN_KEY = Symbol(`agents-server.otel-span`);
+function headersRecord(headers) {
+	const out = {};
+	headers.forEach((value, key) => {
+		out[key] = value;
+	});
+	return out;
+}
+function carrier(req) {
+	return req;
+}
+function startRequestSpan(req, ctx) {
+	const existing = carrier(req)[SPAN_KEY];
+	if (existing) return existing;
+	const url = new URL(req.url);
+	const parentCtx = extractTraceContext(headersRecord(req.headers));
+	const span = tracer.startSpan(`HTTP ${req.method}`, {
+		kind: SpanKind.SERVER,
+		attributes: {
+			[ATTR.HTTP_METHOD]: req.method,
+			[ATTR.HTTP_ROUTE]: url.pathname,
+			"electric_agents.tenant_id": ctx.service
+		}
+	}, parentCtx);
+	carrier(req)[SPAN_KEY] = span;
+	return span;
+}
+function otelStartSpan(req, ctx) {
+	startRequestSpan(req, ctx);
+	return void 0;
+}
+function otelEndSpan(response, req) {
+	const span = carrier(req)[SPAN_KEY];
+	if (!span) return;
+	if (response) span.setAttribute(ATTR.HTTP_STATUS, response.status);
+	span.end();
+	carrier(req)[SPAN_KEY] = void 0;
+}
+function applyCors(response) {
+	if (!response) return response;
+	const headers = new Headers(response.headers);
+	headers.set(`access-control-allow-origin`, `*`);
+	headers.set(`access-control-allow-methods`, `GET, POST, PUT, PATCH, DELETE, OPTIONS`);
+	headers.set(`access-control-allow-headers`, [
+		`content-type`,
+		`authorization`,
+		`electric-claim-token`,
+		`electric-owner-entity`,
+		ELECTRIC_PRINCIPAL_HEADER,
+		`ngrok-skip-browser-warning`
+	].join(`, `));
+	headers.set(`access-control-expose-headers`, `*`);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+function preflightCors(req) {
+	if (req.method !== `OPTIONS`) return void 0;
+	return new Response(null, { status: 204 });
+}
+function errorMapper(err, req) {
+	const span = carrier(req)[SPAN_KEY];
+	if (err instanceof Error) {
+		span?.recordException(err);
+		span?.setStatus({
+			code: SpanStatusCode.ERROR,
+			message: err.message
+		});
+	}
+	if (err instanceof ElectricAgentsError) return apiError(err.status, err.code, err.message, err.details);
+	if (err instanceof ElectricProxyError) {
+		serverLog.warn(`[agent-server] Electric proxy rejected request (${err.code}): ${req.url}`);
+		return apiError(err.status, err.code, err.message);
+	}
+	serverLog.error(`[agent-server] Unhandled error:`, err);
+	return apiError(500, `INTERNAL_SERVER_ERROR`, `Internal server error`);
+}
+function rejectIfShuttingDown(req, ctx) {
 	if (!ctx.isShuttingDown()) return void 0;
 	const path$1 = new URL(req.url).pathname;
 	if (!path$1.startsWith(`/_electric/subscription-webhooks/`)) return void 0;
@@ -7333,7 +7803,7 @@ const wakeCallbackBodySchema = Type.Object({
 const DS_SUBSCRIPTION_CALLBACK_PREFIX = `ds-subscription:`;
 const internalRouter = Router({ base: `/_electric` });
 internalRouter.get(`/health`, () => json({ status: `ok` }));
-internalRouter.get(`/event-sources`, listEventSources);
+internalRouter.get(`/webhook-sources`, listWebhookSources);
 internalRouter.post(`/wake`, withSchema(wakeRegistrationBodySchema), registerWake);
 internalRouter.post(`/subscription-webhooks/:subscriptionId`, subscriptionWebhook);
 internalRouter.post(`/wake-callbacks/:consumerId`, wakeCallback);
@@ -7455,11 +7925,11 @@ async function registerWake(request, ctx) {
 	await ctx.entityManager.registerWake(opts);
 	return status(204);
 }
-async function listEventSources(_request, ctx) {
-	const eventSources = ctx.eventSources ? await ctx.eventSources.listEventSources() : [];
-	return json({ eventSources: eventSources.filter(isAgentVisibleEventSource) });
+async function listWebhookSources(_request, ctx) {
+	const webhookSources = ctx.webhookSources ? await ctx.webhookSources.listWebhookSources() : [];
+	return json({ webhookSources: webhookSources.filter(isAgentVisibleWebhookSource) });
 }
-function isAgentVisibleEventSource(source) {
+function isAgentVisibleWebhookSource(source) {
 	return source.agentVisible === true && source.status === `active`;
 }
 async function subscriptionWebhook(request, ctx) {
@@ -7770,7 +8240,7 @@ const ENTITY_SHAPE_COLUMNS = [
 	`created_at`,
 	`updated_at`
 ];
-function parseElectricOffset$1(offset) {
+function parseElectricOffset(offset) {
 	if (offset === `-1`) return offset;
 	return /^\d+_\d+$/.test(offset) ? offset : null;
 }
@@ -7862,7 +8332,7 @@ var EntityBridge = class {
 		});
 		await this.loadCurrentMembers();
 		if (this.initialShapeHandle && this.initialShapeOffset) {
-			const initialOffset = parseElectricOffset$1(this.initialShapeOffset);
+			const initialOffset = parseElectricOffset(this.initialShapeOffset);
 			if (initialOffset) {
 				this.startLiveStream(initialOffset, this.initialShapeHandle);
 				return;
@@ -8367,739 +8837,437 @@ function normalizeTask(row) {
 }
 var Scheduler = class {
 	claimExpiryMs;
-	safetyPollMs;
-	listenEnabled;
-	pgClient;
-	instanceId;
-	tenantId;
-	tenantIds;
-	running = false;
-	loopPromise = null;
-	currentSleepResolve = null;
-	currentSleepTimer = null;
-	listenerMeta = null;
-	constructor(options) {
-		this.options = options;
-		this.pgClient = options.pgClient;
-		this.instanceId = options.instanceId;
-		this.tenantId = options.tenantId === void 0 ? DEFAULT_TENANT_ID : options.tenantId;
-		this.tenantIds = options.tenantIds;
-		this.claimExpiryMs = options.claimExpiryMs ?? 3e4;
-		this.safetyPollMs = options.safetyPollMs ?? 1e4;
-		this.listenEnabled = options.listen !== false;
-	}
-	resolveTenantId(tenantId) {
-		if (tenantId) return tenantId;
-		if (this.tenantId) return this.tenantId;
-		throw new Error(`Scheduler tenantId is required in shared mode`);
-	}
-	async start() {
-		if (this.running) return;
-		this.running = true;
-		if (this.listenEnabled) this.listenerMeta = await this.pgClient.listen(`scheduled_tasks_wake`, () => {
-			this.wakeEarly();
-		});
-		this.loopPromise = this.runLoop().catch((err) => {
-			console.error(`[agent-server] scheduler loop failed:`, err);
-			this.running = false;
-			this.wakeEarly();
-		});
-	}
-	async stop() {
-		this.running = false;
-		this.wakeEarly();
-		if (this.loopPromise) {
-			await this.loopPromise;
-			this.loopPromise = null;
-		}
-		if (this.listenerMeta) {
-			await this.listenerMeta.unlisten();
-			this.listenerMeta = null;
-		}
-	}
-	wake() {
-		this.wakeEarly();
-	}
-	async enqueueDelayedSend(payload, fireAt, opts) {
-		const tenantId = this.resolveTenantId();
-		await this.pgClient`
-      insert into scheduled_tasks (
-        tenant_id,
-        kind,
-        payload,
-        fire_at,
-        owner_entity_url,
-        manifest_key
-      )
-      values (
-        ${tenantId},
-        'delayed_send',
-        ${JSON.stringify(payload)}::jsonb,
-        ${fireAt.toISOString()}::timestamptz,
-        ${opts?.ownerEntityUrl ?? null},
-        ${opts?.manifestKey ?? null}
-      )
-    `;
-		this.wakeEarly();
-	}
-	async syncManifestDelayedSend(ownerEntityUrl, manifestKey, payload, fireAt) {
-		const tenantId = this.resolveTenantId();
-		await this.pgClient.begin(async (sql$1) => {
-			await sql$1`
-        update scheduled_tasks
-        set completed_at = now(), claimed_at = null, claimed_by = null
-        where tenant_id = ${tenantId}
-          and kind = 'delayed_send'
-          and owner_entity_url = ${ownerEntityUrl}
-          and manifest_key = ${manifestKey}
-          and completed_at is null
-      `;
-			await sql$1`
-        insert into scheduled_tasks (
-          tenant_id,
-          kind,
-          payload,
-          fire_at,
-          owner_entity_url,
-          manifest_key
-        )
-        values (
-          ${tenantId},
-          'delayed_send',
-          ${JSON.stringify(payload)}::jsonb,
-          ${fireAt.toISOString()}::timestamptz,
-          ${ownerEntityUrl},
-          ${manifestKey}
-        )
-      `;
-		});
-		this.wakeEarly();
-	}
-	async cancelManifestDelayedSend(ownerEntityUrl, manifestKey) {
-		const tenantId = this.resolveTenantId();
-		await this.pgClient`
-      update scheduled_tasks
-      set completed_at = now(), claimed_at = null, claimed_by = null
-      where tenant_id = ${tenantId}
-        and kind = 'delayed_send'
-        and owner_entity_url = ${ownerEntityUrl}
-        and manifest_key = ${manifestKey}
-        and completed_at is null
-    `;
-		this.wakeEarly();
-	}
-	async enqueueCronTick(expression, timezone, tickNumber, streamPath, fireAt) {
-		const tenantId = this.resolveTenantId();
-		await this.pgClient`
-      insert into scheduled_tasks (
-        tenant_id,
-        kind,
-        payload,
-        fire_at,
-        cron_expression,
-        cron_timezone,
-        cron_tick_number
-      )
-      values (
-        ${tenantId},
-        'cron_tick',
-        ${JSON.stringify({ streamPath })}::jsonb,
-        ${fireAt.toISOString()}::timestamptz,
-        ${expression},
-        ${timezone},
-        ${tickNumber}
-      )
-      on conflict (tenant_id, cron_expression, cron_timezone, cron_tick_number) do nothing
-    `;
-		this.wakeEarly();
-	}
-	async runLoop() {
-		while (this.running) try {
-			await this.reclaimStaleClaims();
-			await this.fireReadyTasks();
-			const nextFireAt = await this.getNextFireAt();
-			const sleepTargetMs = nextFireAt ? Math.max(0, nextFireAt.getTime() - Date.now()) : this.safetyPollMs;
-			await this.sleepOrWake(Math.min(sleepTargetMs, this.safetyPollMs));
-		} catch (err) {
-			console.error(`[agent-server] scheduler iteration failed:`, err);
-			await this.sleepOrWake(this.safetyPollMs);
-		}
-	}
-	async reclaimStaleClaims() {
-		if (this.tenantId === null) {
-			const tenantIds = this.sharedTenantIds();
-			if (tenantIds && tenantIds.length === 0) return;
-			if (tenantIds) {
-				await this.pgClient`
-          update scheduled_tasks
-          set claimed_by = null, claimed_at = null
-          where tenant_id = any(${this.sharedTenantIdsParameter(tenantIds)})
-            and completed_at is null
-            and claimed_at < now() - (${this.claimExpiryMs} * interval '1 millisecond')
-        `;
-				return;
-			}
-			await this.pgClient`
-        update scheduled_tasks
-        set claimed_by = null, claimed_at = null
-        where completed_at is null
-          and claimed_at < now() - (${this.claimExpiryMs} * interval '1 millisecond')
-      `;
-			return;
-		}
-		await this.pgClient`
-      update scheduled_tasks
-      set claimed_by = null, claimed_at = null
-      where tenant_id = ${this.tenantId}
-        and completed_at is null
-        and claimed_at < now() - (${this.claimExpiryMs} * interval '1 millisecond')
-    `;
-	}
-	async fireReadyTasks() {
-		while (this.running) {
-			const tasks = await this.claimReadyTasks();
-			if (tasks.length === 0) return;
-			for (const task of tasks) await this.executeTask(task);
-		}
-	}
-	async claimReadyTasks() {
-		if (this.tenantId === null) {
-			const tenantIds = this.sharedTenantIds();
-			if (tenantIds && tenantIds.length === 0) return [];
-			if (tenantIds) {
-				const rows$2 = await this.pgClient`
-          update scheduled_tasks
-          set claimed_by = ${this.instanceId}, claimed_at = now()
-          where id in (
-            select id
-            from scheduled_tasks
-            where tenant_id = any(${this.sharedTenantIdsParameter(tenantIds)})
-              and completed_at is null
-              and claimed_at is null
-              and fire_at <= now()
-            order by fire_at, id
-            for update skip locked
-            limit 50
-          )
-          returning tenant_id, id, kind, payload, fire_at, cron_expression, cron_timezone, cron_tick_number
-            , owner_entity_url, manifest_key
-        `;
-				return rows$2.map(normalizeTask);
-			}
-			const rows$1 = await this.pgClient`
-        update scheduled_tasks
-        set claimed_by = ${this.instanceId}, claimed_at = now()
-        where id in (
-          select id
-          from scheduled_tasks
-          where completed_at is null
-            and claimed_at is null
-            and fire_at <= now()
-          order by fire_at, id
-          for update skip locked
-          limit 50
-        )
-        returning tenant_id, id, kind, payload, fire_at, cron_expression, cron_timezone, cron_tick_number
-          , owner_entity_url, manifest_key
-      `;
-			return rows$1.map(normalizeTask);
-		}
-		const rows = await this.pgClient`
-      update scheduled_tasks
-      set claimed_by = ${this.instanceId}, claimed_at = now()
-      where tenant_id = ${this.tenantId}
-        and id in (
-        select id
-        from scheduled_tasks
-        where tenant_id = ${this.tenantId}
-          and completed_at is null
-          and claimed_at is null
-          and fire_at <= now()
-        order by fire_at, id
-        for update skip locked
-        limit 50
-      )
-      returning tenant_id, id, kind, payload, fire_at, cron_expression, cron_timezone, cron_tick_number
-        , owner_entity_url, manifest_key
-    `;
-		return rows.map(normalizeTask);
+	safetyPollMs;
+	listenEnabled;
+	pgClient;
+	instanceId;
+	tenantId;
+	tenantIds;
+	running = false;
+	loopPromise = null;
+	currentSleepResolve = null;
+	currentSleepTimer = null;
+	listenerMeta = null;
+	constructor(options) {
+		this.options = options;
+		this.pgClient = options.pgClient;
+		this.instanceId = options.instanceId;
+		this.tenantId = options.tenantId === void 0 ? DEFAULT_TENANT_ID : options.tenantId;
+		this.tenantIds = options.tenantIds;
+		this.claimExpiryMs = options.claimExpiryMs ?? 3e4;
+		this.safetyPollMs = options.safetyPollMs ?? 1e4;
+		this.listenEnabled = options.listen !== false;
 	}
-	async executeTask(task) {
-		try {
-			if (task.kind === `delayed_send`) {
-				await this.options.executors.delayed_send(task.payload, task.id, task.tenantId);
-				await this.markTaskComplete(task.id, task.tenantId);
-				return;
-			}
-			const tickNumber = task.cronTickNumber;
-			if (tickNumber == null || !task.cronExpression || !task.cronTimezone) throw new Error(`cron task ${task.id} is missing cron metadata`);
-			await this.options.executors.cron_tick(task.payload, tickNumber, task.id, task.tenantId);
-			await this.completeAndRescheduleCron(task);
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			if (isUnregisteredTenantError(err)) {
-				await this.releaseClaim(task.id, message, task.tenantId);
-				serverLog.warn(`[scheduler] skipped ${task.kind} task ${task.id} for unregistered tenant "${task.tenantId}": ${message}`);
-				return;
-			}
-			if (isPermanentElectricAgentsError(err)) {
-				await this.markTaskPermanentFailure(task.id, message, task.tenantId);
-				return;
-			}
-			await this.releaseClaim(task.id, message, task.tenantId);
-		}
+	resolveTenantId(tenantId) {
+		if (tenantId) return tenantId;
+		if (this.tenantId) return this.tenantId;
+		throw new Error(`Scheduler tenantId is required in shared mode`);
 	}
-	async markTaskComplete(taskId, tenantId = this.resolveTenantId()) {
-		await this.pgClient`
-      update scheduled_tasks
-      set completed_at = now(), last_error = null
-      where tenant_id = ${tenantId}
-        and id = ${taskId}
-        and claimed_by = ${this.instanceId}
-        and completed_at is null
-    `;
+	async start() {
+		if (this.running) return;
+		this.running = true;
+		if (this.listenEnabled) this.listenerMeta = await this.pgClient.listen(`scheduled_tasks_wake`, () => {
+			this.wakeEarly();
+		});
+		this.loopPromise = this.runLoop().catch((err) => {
+			console.error(`[agent-server] scheduler loop failed:`, err);
+			this.running = false;
+			this.wakeEarly();
+		});
 	}
-	async markTaskPermanentFailure(taskId, message, tenantId = this.resolveTenantId()) {
-		await this.pgClient`
-      update scheduled_tasks
-      set completed_at = now(), last_error = ${message}
-      where tenant_id = ${tenantId}
-        and id = ${taskId}
-        and claimed_by = ${this.instanceId}
-        and completed_at is null
-    `;
+	async stop() {
+		this.running = false;
+		this.wakeEarly();
+		if (this.loopPromise) {
+			await this.loopPromise;
+			this.loopPromise = null;
+		}
+		if (this.listenerMeta) {
+			await this.listenerMeta.unlisten();
+			this.listenerMeta = null;
+		}
 	}
-	async releaseClaim(taskId, message, tenantId = this.resolveTenantId()) {
+	wake() {
+		this.wakeEarly();
+	}
+	async enqueueDelayedSend(payload, fireAt, opts) {
+		const tenantId = this.resolveTenantId();
 		await this.pgClient`
-      update scheduled_tasks
-      set claimed_at = null, claimed_by = null, last_error = ${message}
-      where tenant_id = ${tenantId}
-        and id = ${taskId}
-        and claimed_by = ${this.instanceId}
-        and completed_at is null
+      insert into scheduled_tasks (
+        tenant_id,
+        kind,
+        payload,
+        fire_at,
+        owner_entity_url,
+        manifest_key
+      )
+      values (
+        ${tenantId},
+        'delayed_send',
+        ${JSON.stringify(payload)}::jsonb,
+        ${fireAt.toISOString()}::timestamptz,
+        ${opts?.ownerEntityUrl ?? null},
+        ${opts?.manifestKey ?? null}
+      )
     `;
+		this.wakeEarly();
 	}
-	async completeAndRescheduleCron(task) {
-		const tenantId = task.tenantId ?? this.resolveTenantId();
+	async syncManifestDelayedSend(ownerEntityUrl, manifestKey, payload, fireAt) {
+		const tenantId = this.resolveTenantId();
 		await this.pgClient.begin(async (sql$1) => {
-			const completed = await sql$1`
+			await sql$1`
         update scheduled_tasks
-        set completed_at = now(), last_error = null
+        set completed_at = now(), claimed_at = null, claimed_by = null
         where tenant_id = ${tenantId}
-          and id = ${task.id}
-          and claimed_by = ${this.instanceId}
+          and kind = 'delayed_send'
+          and owner_entity_url = ${ownerEntityUrl}
+          and manifest_key = ${manifestKey}
           and completed_at is null
-        returning id
       `;
-			if (completed.length === 0) return;
-			const nextFireAt = getNextCronFireAt(task.cronExpression, task.cronTimezone, task.fireAt);
-			const streamPath = cronTaskStreamPath(task.payload);
-			const subscriberRows = streamPath ? await sql$1`
-            select 1 as exists
-            from wake_registrations
-            where tenant_id = ${tenantId}
-              and source_url = ${streamPath}
-            limit 1
-          ` : [];
-			if (subscriberRows.length === 0) return;
 			await sql$1`
         insert into scheduled_tasks (
           tenant_id,
           kind,
           payload,
           fire_at,
-          cron_expression,
-          cron_timezone,
-          cron_tick_number
+          owner_entity_url,
+          manifest_key
         )
         values (
           ${tenantId},
-          'cron_tick',
-          ${JSON.stringify(task.payload)}::jsonb,
-          ${nextFireAt.toISOString()}::timestamptz,
-          ${task.cronExpression},
-          ${task.cronTimezone},
-          ${task.cronTickNumber + 1}
+          'delayed_send',
+          ${JSON.stringify(payload)}::jsonb,
+          ${fireAt.toISOString()}::timestamptz,
+          ${ownerEntityUrl},
+          ${manifestKey}
         )
-        on conflict (tenant_id, cron_expression, cron_timezone, cron_tick_number) do nothing
       `;
 		});
+		this.wakeEarly();
 	}
-	async getNextFireAt() {
-		if (this.tenantId === null) {
-			const tenantIds = this.sharedTenantIds();
-			if (tenantIds && tenantIds.length === 0) return null;
-			if (tenantIds) {
-				const rows$2 = await this.pgClient`
-          select fire_at
-          from scheduled_tasks
-          where tenant_id = any(${this.sharedTenantIdsParameter(tenantIds)})
-            and completed_at is null
-            and claimed_at is null
-          order by fire_at, id
-          limit 1
-        `;
-				if (rows$2.length === 0) return null;
-				const fireAt$2 = rows$2[0].fire_at;
-				return fireAt$2 instanceof Date ? fireAt$2 : new Date(fireAt$2);
-			}
-			const rows$1 = await this.pgClient`
-        select fire_at
-        from scheduled_tasks
-        where completed_at is null
-          and claimed_at is null
-        order by fire_at, id
-        limit 1
-      `;
-			if (rows$1.length === 0) return null;
-			const fireAt$1 = rows$1[0].fire_at;
-			return fireAt$1 instanceof Date ? fireAt$1 : new Date(fireAt$1);
-		}
-		const rows = await this.pgClient`
-      select fire_at
-      from scheduled_tasks
-      where tenant_id = ${this.tenantId}
+	async cancelManifestDelayedSend(ownerEntityUrl, manifestKey) {
+		const tenantId = this.resolveTenantId();
+		await this.pgClient`
+      update scheduled_tasks
+      set completed_at = now(), claimed_at = null, claimed_by = null
+      where tenant_id = ${tenantId}
+        and kind = 'delayed_send'
+        and owner_entity_url = ${ownerEntityUrl}
+        and manifest_key = ${manifestKey}
         and completed_at is null
-        and claimed_at is null
-      order by fire_at, id
-      limit 1
     `;
-		if (rows.length === 0) return null;
-		const fireAt = rows[0].fire_at;
-		return fireAt instanceof Date ? fireAt : new Date(fireAt);
-	}
-	async sleepOrWake(durationMs) {
-		if (!this.running) return;
-		await new Promise((resolve$1) => {
-			const finish = () => {
-				if (this.currentSleepTimer) {
-					clearTimeout(this.currentSleepTimer);
-					this.currentSleepTimer = null;
-				}
-				this.currentSleepResolve = null;
-				resolve$1();
-			};
-			this.currentSleepResolve = finish;
-			this.currentSleepTimer = setTimeout(finish, Math.max(durationMs, 0));
-		});
-	}
-	wakeEarly() {
-		const resolve$1 = this.currentSleepResolve;
-		this.currentSleepResolve = null;
-		if (this.currentSleepTimer) {
-			clearTimeout(this.currentSleepTimer);
-			this.currentSleepTimer = null;
-		}
-		resolve$1?.();
-	}
-	sharedTenantIds() {
-		if (this.tenantId !== null || !this.tenantIds) return null;
-		return [...new Set(this.tenantIds())];
+		this.wakeEarly();
 	}
-	sharedTenantIdsParameter(tenantIds) {
-		return this.pgClient.array(tenantIds, POSTGRES_TEXT_OID);
+	async enqueueCronTick(expression, timezone, tickNumber, streamPath, fireAt) {
+		const tenantId = this.resolveTenantId();
+		await this.pgClient`
+      insert into scheduled_tasks (
+        tenant_id,
+        kind,
+        payload,
+        fire_at,
+        cron_expression,
+        cron_timezone,
+        cron_tick_number
+      )
+      values (
+        ${tenantId},
+        'cron_tick',
+        ${JSON.stringify({ streamPath })}::jsonb,
+        ${fireAt.toISOString()}::timestamptz,
+        ${expression},
+        ${timezone},
+        ${tickNumber}
+      )
+      on conflict (tenant_id, cron_expression, cron_timezone, cron_tick_number) do nothing
+    `;
+		this.wakeEarly();
 	}
-};
-
-//#endregion
-//#region src/pg-sync-bridge-manager.ts
-const PG_SYNC_ELECTRIC_SHAPE_URL = process.env.ELECTRIC_AGENTS_PG_SYNC_ELECTRIC_URL ?? `http://localhost:3000/v1/shape`;
-const DEFAULT_RETRY_INITIAL_DELAY_MS = 1e3;
-const DEFAULT_RETRY_MAX_DELAY_MS = 3e4;
-function buildElectricShapeParams(options) {
-	return {
-		table: options.table,
-		...options.columns !== void 0 ? { columns: [...options.columns] } : {},
-		...options.where !== void 0 ? { where: options.where } : {},
-		...options.params !== void 0 ? { params: Array.isArray(options.params) ? [...options.params] : { ...options.params } } : {},
-		...options.replica !== void 0 ? { replica: options.replica } : {},
-		...options.metadata?.tenantId ? { electric_agents_tenant_id: options.metadata.tenantId } : {},
-		...options.metadata?.principalKind ? { electric_agents_principal_kind: options.metadata.principalKind } : {},
-		...options.metadata?.principalId ? { electric_agents_principal_id: options.metadata.principalId } : {},
-		...options.metadata?.principalKey ? { electric_agents_principal_key: options.metadata.principalKey } : {},
-		...options.metadata?.principalUrl ? { electric_agents_principal_url: options.metadata.principalUrl } : {},
-		...options.metadata?.entityUrl ? { electric_agents_entity_url: options.metadata.entityUrl } : {},
-		...options.metadata?.entityType ? { electric_agents_entity_type: options.metadata.entityType } : {},
-		...options.metadata?.streamPath ? { electric_agents_stream_path: options.metadata.streamPath } : {},
-		...options.metadata?.runtimeConsumerId ? { electric_agents_runtime_consumer_id: options.metadata.runtimeConsumerId } : {},
-		...options.metadata?.wakeId ? { electric_agents_wake_id: options.metadata.wakeId } : {}
-	};
-}
-function jsonSafe(value) {
-	if (typeof value === `bigint`) return value.toString();
-	if (value === null || typeof value !== `object`) return value;
-	if (Array.isArray(value)) return value.map(jsonSafe);
-	return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, jsonSafe(item)]));
-}
-function stableJson(value) {
-	if (typeof value === `bigint`) return JSON.stringify(value.toString());
-	if (value === null || typeof value !== `object`) return JSON.stringify(value);
-	if (Array.isArray(value)) return `[${value.map(stableJson).join(`,`)}]`;
-	return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(`,`)}}`;
-}
-function parseElectricOffset(offset) {
-	if (offset === `-1`) return offset;
-	return /^\d+_\d+$/.test(offset) ? offset : null;
-}
-function rowKeyForMessage(message) {
-	const headers = message.headers;
-	const candidate = headers.key ?? headers.rowKey ?? message.value?.id ?? message.value?.key ?? message.old_value?.id ?? message.old_value?.key;
-	return candidate === void 0 ? void 0 : stableJson(candidate);
-}
-function pgSyncMessageToDurableEvent(message, optionsOrSourceRef) {
-	const operation = message.headers.operation;
-	if (operation !== `insert` && operation !== `update` && operation !== `delete`) return null;
-	const sourceRef = typeof optionsOrSourceRef === `string` ? optionsOrSourceRef : sourceRefForPgSync(optionsOrSourceRef);
-	const rowKey = rowKeyForMessage(message);
-	const offset = message.headers.offset;
-	if (typeof offset !== `string` || offset.length === 0) return null;
-	const messageKeyPart = offset;
-	const messageKey = `${sourceRef}:${operation}:${messageKeyPart}`;
-	const timestamp$1 = new Date().toISOString();
-	const oldValue = message.old_value;
-	const safeValue = jsonSafe(message.value);
-	const safeOldValue = jsonSafe(oldValue);
-	const safeHeaders = jsonSafe(message.headers);
-	return {
-		type: `pg_sync_change`,
-		key: messageKey,
-		value: {
-			key: messageKey,
-			table: typeof optionsOrSourceRef === `string` ? void 0 : optionsOrSourceRef.table,
-			operation,
-			...rowKey !== void 0 ? { rowKey } : {},
-			...message.value !== void 0 ? { value: safeValue } : {},
-			...oldValue !== void 0 ? { oldValue: safeOldValue } : {},
-			headers: safeHeaders,
-			...typeof offset === `string` ? { offset } : {},
-			receivedAt: timestamp$1
-		},
-		headers: {
-			operation,
-			timestamp: timestamp$1
+	async runLoop() {
+		while (this.running) try {
+			await this.reclaimStaleClaims();
+			await this.fireReadyTasks();
+			const nextFireAt = await this.getNextFireAt();
+			const sleepTargetMs = nextFireAt ? Math.max(0, nextFireAt.getTime() - Date.now()) : this.safetyPollMs;
+			await this.sleepOrWake(Math.min(sleepTargetMs, this.safetyPollMs));
+		} catch (err) {
+			console.error(`[agent-server] scheduler iteration failed:`, err);
+			await this.sleepOrWake(this.safetyPollMs);
 		}
-	};
-}
-function cursorFromRow(row) {
-	return row?.shapeHandle && row.shapeOffset ? {
-		handle: row.shapeHandle,
-		offset: row.shapeOffset,
-		initialSnapshotComplete: row.initialSnapshotComplete
-	} : void 0;
-}
-var PgSyncBridge = class {
-	producer = null;
-	unsubscribe = null;
-	abortController = null;
-	skipChangesUntilUpToDate = false;
-	recovering = false;
-	committedCursor;
-	retryAttempt = 0;
-	constructor(sourceRef, streamUrl, options, resolvedSource, retry, streamClient, registry, evaluateWakes, initialCursor) {
-		this.sourceRef = sourceRef;
-		this.streamUrl = streamUrl;
-		this.options = options;
-		this.resolvedSource = resolvedSource;
-		this.retry = retry;
-		this.streamClient = streamClient;
-		this.registry = registry;
-		this.evaluateWakes = evaluateWakes;
-		this.initialCursor = initialCursor;
-		this.committedCursor = initialCursor;
 	}
-	async start() {
-		if (!this.producer) this.producer = new IdempotentProducer(new DurableStream({
-			url: `${this.streamClient.baseUrl}${this.streamUrl}`,
-			contentType: `application/json`
-		}), `pg-sync-bridge-${this.sourceRef}`);
-		if (this.initialCursor) {
-			const offset = parseElectricOffset(this.initialCursor.offset);
-			if (offset) {
-				this.startStream(offset, this.initialCursor.handle, !this.initialCursor.initialSnapshotComplete);
+	async reclaimStaleClaims() {
+		if (this.tenantId === null) {
+			const tenantIds = this.sharedTenantIds();
+			if (tenantIds && tenantIds.length === 0) return;
+			if (tenantIds) {
+				await this.pgClient`
+          update scheduled_tasks
+          set claimed_by = null, claimed_at = null
+          where tenant_id = any(${this.sharedTenantIdsParameter(tenantIds)})
+            and completed_at is null
+            and claimed_at < now() - (${this.claimExpiryMs} * interval '1 millisecond')
+        `;
 				return;
 			}
+			await this.pgClient`
+        update scheduled_tasks
+        set claimed_by = null, claimed_at = null
+        where completed_at is null
+          and claimed_at < now() - (${this.claimExpiryMs} * interval '1 millisecond')
+      `;
+			return;
 		}
-		await this.registry?.clearPgSyncBridgeCursor(this.sourceRef);
-		this.startStream(`now`, void 0, true);
+		await this.pgClient`
+      update scheduled_tasks
+      set claimed_by = null, claimed_at = null
+      where tenant_id = ${this.tenantId}
+        and completed_at is null
+        and claimed_at < now() - (${this.claimExpiryMs} * interval '1 millisecond')
+    `;
 	}
-	async stop() {
-		this.unsubscribe?.();
-		this.abortController?.abort();
-		this.unsubscribe = null;
-		this.abortController = null;
-		try {
-			await this.producer?.flush();
-		} finally {
-			await this.producer?.detach();
-			this.producer = null;
+	async fireReadyTasks() {
+		while (this.running) {
+			const tasks = await this.claimReadyTasks();
+			if (tasks.length === 0) return;
+			for (const task of tasks) await this.executeTask(task);
 		}
 	}
-	startStream(offset, handle, skipChangesUntilUpToDate = false, log = offset === `now` ? `changes_only` : `full`) {
-		this.unsubscribe?.();
-		this.abortController?.abort();
-		this.skipChangesUntilUpToDate = skipChangesUntilUpToDate;
-		this.abortController = new AbortController();
-		const stream = new ShapeStream({
-			url: this.resolvedSource.url,
-			params: buildElectricShapeParams(this.options),
-			offset,
-			log,
-			...handle ? { handle } : {},
-			signal: this.abortController.signal
-		});
-		this.unsubscribe = stream.subscribe(async (messages) => {
-			try {
-				for (const message of messages) {
-					if (isControlMessage(message)) {
-						if (message.headers.control === `must-refetch`) {
-							await this.registry?.clearPgSyncBridgeCursor(this.sourceRef);
-							this.startStream(`now`, void 0, true);
-							return;
-						}
-						if (message.headers.control === `up-to-date`) {
-							this.skipChangesUntilUpToDate = false;
-							await this.persistCursor(stream, true);
-							continue;
-						}
-						await this.persistCursor(stream);
-						continue;
-					}
-					if (!isChangeMessage(message)) continue;
-					if (!this.skipChangesUntilUpToDate) {
-						const event = pgSyncMessageToDurableEvent(message, this.options);
-						if (event) {
-							if (!this.producer) throw new Error(`pg-sync producer is not started`);
-							await this.producer.append(JSON.stringify(event));
-							await this.producer.flush?.();
-							await this.evaluateWakes?.(this.streamUrl, event);
-						}
-					}
-					await this.persistCursor(stream);
-					this.retryAttempt = 0;
-				}
-			} catch (error) {
-				serverLog.warn(`[pg-sync-bridge] subscription callback failed for ${this.sourceRef}:`, error);
-				await this.recoverStream();
+	async claimReadyTasks() {
+		if (this.tenantId === null) {
+			const tenantIds = this.sharedTenantIds();
+			if (tenantIds && tenantIds.length === 0) return [];
+			if (tenantIds) {
+				const rows$2 = await this.pgClient`
+          update scheduled_tasks
+          set claimed_by = ${this.instanceId}, claimed_at = now()
+          where id in (
+            select id
+            from scheduled_tasks
+            where tenant_id = any(${this.sharedTenantIdsParameter(tenantIds)})
+              and completed_at is null
+              and claimed_at is null
+              and fire_at <= now()
+            order by fire_at, id
+            for update skip locked
+            limit 50
+          )
+          returning tenant_id, id, kind, payload, fire_at, cron_expression, cron_timezone, cron_tick_number
+            , owner_entity_url, manifest_key
+        `;
+				return rows$2.map(normalizeTask);
 			}
-		}, (error) => {
-			if (this.abortController?.signal.aborted) return;
-			serverLog.warn(`[pg-sync-bridge] subscription failed for ${this.sourceRef}:`, error);
-			this.recoverStream();
-		});
+			const rows$1 = await this.pgClient`
+        update scheduled_tasks
+        set claimed_by = ${this.instanceId}, claimed_at = now()
+        where id in (
+          select id
+          from scheduled_tasks
+          where completed_at is null
+            and claimed_at is null
+            and fire_at <= now()
+          order by fire_at, id
+          for update skip locked
+          limit 50
+        )
+        returning tenant_id, id, kind, payload, fire_at, cron_expression, cron_timezone, cron_tick_number
+          , owner_entity_url, manifest_key
+      `;
+			return rows$1.map(normalizeTask);
+		}
+		const rows = await this.pgClient`
+      update scheduled_tasks
+      set claimed_by = ${this.instanceId}, claimed_at = now()
+      where tenant_id = ${this.tenantId}
+        and id in (
+        select id
+        from scheduled_tasks
+        where tenant_id = ${this.tenantId}
+          and completed_at is null
+          and claimed_at is null
+          and fire_at <= now()
+        order by fire_at, id
+        for update skip locked
+        limit 50
+      )
+      returning tenant_id, id, kind, payload, fire_at, cron_expression, cron_timezone, cron_tick_number
+        , owner_entity_url, manifest_key
+    `;
+		return rows.map(normalizeTask);
 	}
-	async recoverStream() {
-		if (this.recovering) return;
-		this.recovering = true;
+	async executeTask(task) {
 		try {
-			const attempt = this.retryAttempt++;
-			const baseDelay = Math.min(this.retry.initialDelayMs * 2 ** attempt, this.retry.maxDelayMs);
-			const jitter = Math.floor(baseDelay * .2 * this.retry.random());
-			const delay = baseDelay + jitter;
-			if (delay > 0) await this.retry.sleep(delay);
-			const offset = this.committedCursor ? parseElectricOffset(this.committedCursor.offset) : null;
-			if (offset && this.committedCursor) this.startStream(offset, this.committedCursor.handle, !this.committedCursor.initialSnapshotComplete);
-			else {
-				await this.registry?.clearPgSyncBridgeCursor(this.sourceRef);
-				this.startStream(`now`, void 0, true);
+			if (task.kind === `delayed_send`) {
+				await this.options.executors.delayed_send(task.payload, task.id, task.tenantId);
+				await this.markTaskComplete(task.id, task.tenantId);
+				return;
 			}
-		} finally {
-			this.recovering = false;
+			const tickNumber = task.cronTickNumber;
+			if (tickNumber == null || !task.cronExpression || !task.cronTimezone) throw new Error(`cron task ${task.id} is missing cron metadata`);
+			await this.options.executors.cron_tick(task.payload, tickNumber, task.id, task.tenantId);
+			await this.completeAndRescheduleCron(task);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			if (isUnregisteredTenantError(err)) {
+				await this.releaseClaim(task.id, message, task.tenantId);
+				serverLog.warn(`[scheduler] skipped ${task.kind} task ${task.id} for unregistered tenant "${task.tenantId}": ${message}`);
+				return;
+			}
+			if (isPermanentElectricAgentsError(err)) {
+				await this.markTaskPermanentFailure(task.id, message, task.tenantId);
+				return;
+			}
+			await this.releaseClaim(task.id, message, task.tenantId);
 		}
 	}
-	async persistCursor(stream, initialSnapshotComplete = !this.skipChangesUntilUpToDate) {
-		const shapeHandle = stream.shapeHandle;
-		const shapeOffset = stream.lastOffset;
-		if (!shapeHandle || !shapeOffset || shapeOffset === `-1`) return;
-		await this.registry?.updatePgSyncBridgeCursor(this.sourceRef, shapeHandle, shapeOffset, initialSnapshotComplete);
-		this.committedCursor = {
-			handle: shapeHandle,
-			offset: shapeOffset,
-			initialSnapshotComplete
-		};
+	async markTaskComplete(taskId, tenantId = this.resolveTenantId()) {
+		await this.pgClient`
+      update scheduled_tasks
+      set completed_at = now(), last_error = null
+      where tenant_id = ${tenantId}
+        and id = ${taskId}
+        and claimed_by = ${this.instanceId}
+        and completed_at is null
+    `;
 	}
-};
-var PgSyncBridgeManager = class {
-	bridges = new Map();
-	starting = new Map();
-	url;
-	retry;
-	constructor(streamClient, evaluateWakes, registry, options = {}) {
-		this.streamClient = streamClient;
-		this.evaluateWakes = evaluateWakes;
-		this.registry = registry;
-		this.url = options.url ?? PG_SYNC_ELECTRIC_SHAPE_URL;
-		this.retry = {
-			initialDelayMs: options.retry?.initialDelayMs ?? DEFAULT_RETRY_INITIAL_DELAY_MS,
-			maxDelayMs: options.retry?.maxDelayMs ?? DEFAULT_RETRY_MAX_DELAY_MS,
-			random: options.retry?.random ?? Math.random,
-			sleep: options.retry?.sleep ?? ((ms) => new Promise((resolve$1) => setTimeout(resolve$1, ms)))
-		};
+	async markTaskPermanentFailure(taskId, message, tenantId = this.resolveTenantId()) {
+		await this.pgClient`
+      update scheduled_tasks
+      set completed_at = now(), last_error = ${message}
+      where tenant_id = ${tenantId}
+        and id = ${taskId}
+        and claimed_by = ${this.instanceId}
+        and completed_at is null
+    `;
 	}
-	async start() {
-		const rows = await this.registry?.listPgSyncBridges?.();
-		if (!rows) return;
-		await Promise.all(rows.map((row) => this.ensureBridge(row).catch((error) => {
-			serverLog.warn(`[pg-sync-bridge] failed to start ${row.sourceRef}:`, error);
-		})));
+	async releaseClaim(taskId, message, tenantId = this.resolveTenantId()) {
+		await this.pgClient`
+      update scheduled_tasks
+      set claimed_at = null, claimed_by = null, last_error = ${message}
+      where tenant_id = ${tenantId}
+        and id = ${taskId}
+        and claimed_by = ${this.instanceId}
+        and completed_at is null
+    `;
 	}
-	async register(options, metadata) {
-		const mergedMetadata = {
-			...options.metadata,
-			...metadata
-		};
-		const canonicalOptions = {
-			...canonicalPgSyncOptions(options),
-			...Object.keys(mergedMetadata).length > 0 ? { metadata: mergedMetadata } : {}
-		};
-		const resolvedSource = this.resolveSource(canonicalOptions);
-		const sourceRef = sourceRefForPgSync(canonicalOptions);
-		const streamUrl = getPgSyncStreamPath(sourceRef, this.registry?.tenantId);
-		const row = await this.registry?.upsertPgSyncBridge({
-			sourceRef,
-			options: canonicalOptions,
-			streamUrl
+	async completeAndRescheduleCron(task) {
+		const tenantId = task.tenantId ?? this.resolveTenantId();
+		await this.pgClient.begin(async (sql$1) => {
+			const completed = await sql$1`
+        update scheduled_tasks
+        set completed_at = now(), last_error = null
+        where tenant_id = ${tenantId}
+          and id = ${task.id}
+          and claimed_by = ${this.instanceId}
+          and completed_at is null
+        returning id
+      `;
+			if (completed.length === 0) return;
+			const nextFireAt = getNextCronFireAt(task.cronExpression, task.cronTimezone, task.fireAt);
+			const streamPath = cronTaskStreamPath(task.payload);
+			const subscriberRows = streamPath ? await sql$1`
+            select 1 as exists
+            from wake_registrations
+            where tenant_id = ${tenantId}
+              and source_url = ${streamPath}
+            limit 1
+          ` : [];
+			if (subscriberRows.length === 0) return;
+			await sql$1`
+        insert into scheduled_tasks (
+          tenant_id,
+          kind,
+          payload,
+          fire_at,
+          cron_expression,
+          cron_timezone,
+          cron_tick_number
+        )
+        values (
+          ${tenantId},
+          'cron_tick',
+          ${JSON.stringify(task.payload)}::jsonb,
+          ${nextFireAt.toISOString()}::timestamptz,
+          ${task.cronExpression},
+          ${task.cronTimezone},
+          ${task.cronTickNumber + 1}
+        )
+        on conflict (tenant_id, cron_expression, cron_timezone, cron_tick_number) do nothing
+      `;
 		});
-		await this.streamClient.ensure(streamUrl, { contentType: `application/json` });
-		if (!this.bridges.has(sourceRef)) {
-			let start = this.starting.get(sourceRef);
-			if (!start) {
-				start = (async () => {
-					const bridge = new PgSyncBridge(sourceRef, streamUrl, canonicalOptions, resolvedSource, this.retry, this.streamClient, this.registry, this.evaluateWakes, cursorFromRow(row));
-					await bridge.start();
-					this.bridges.set(sourceRef, bridge);
-				})().finally(() => this.starting.delete(sourceRef));
-				this.starting.set(sourceRef, start);
+	}
+	async getNextFireAt() {
+		if (this.tenantId === null) {
+			const tenantIds = this.sharedTenantIds();
+			if (tenantIds && tenantIds.length === 0) return null;
+			if (tenantIds) {
+				const rows$2 = await this.pgClient`
+          select fire_at
+          from scheduled_tasks
+          where tenant_id = any(${this.sharedTenantIdsParameter(tenantIds)})
+            and completed_at is null
+            and claimed_at is null
+          order by fire_at, id
+          limit 1
+        `;
+				if (rows$2.length === 0) return null;
+				const fireAt$2 = rows$2[0].fire_at;
+				return fireAt$2 instanceof Date ? fireAt$2 : new Date(fireAt$2);
 			}
-			await start;
+			const rows$1 = await this.pgClient`
+        select fire_at
+        from scheduled_tasks
+        where completed_at is null
+          and claimed_at is null
+        order by fire_at, id
+        limit 1
+      `;
+			if (rows$1.length === 0) return null;
+			const fireAt$1 = rows$1[0].fire_at;
+			return fireAt$1 instanceof Date ? fireAt$1 : new Date(fireAt$1);
 		}
-		return {
-			sourceRef,
-			streamUrl
-		};
+		const rows = await this.pgClient`
+      select fire_at
+      from scheduled_tasks
+      where tenant_id = ${this.tenantId}
+        and completed_at is null
+        and claimed_at is null
+      order by fire_at, id
+      limit 1
+    `;
+		if (rows.length === 0) return null;
+		const fireAt = rows[0].fire_at;
+		return fireAt instanceof Date ? fireAt : new Date(fireAt);
 	}
-	async ensureBridge(row) {
-		if (this.bridges.has(row.sourceRef)) return;
-		let start = this.starting.get(row.sourceRef);
-		if (!start) {
-			start = (async () => {
-				await this.streamClient.ensure(row.streamUrl, { contentType: `application/json` });
-				const canonicalOptions = canonicalPgSyncOptions(row.options);
-				const resolvedSource = this.resolveSource(canonicalOptions);
-				const bridge = new PgSyncBridge(row.sourceRef, row.streamUrl, canonicalOptions, resolvedSource, this.retry, this.streamClient, this.registry, this.evaluateWakes, cursorFromRow(row));
-				await bridge.start();
-				this.bridges.set(row.sourceRef, bridge);
-			})().finally(() => this.starting.delete(row.sourceRef));
-			this.starting.set(row.sourceRef, start);
+	async sleepOrWake(durationMs) {
+		if (!this.running) return;
+		await new Promise((resolve$1) => {
+			const finish = () => {
+				if (this.currentSleepTimer) {
+					clearTimeout(this.currentSleepTimer);
+					this.currentSleepTimer = null;
+				}
+				this.currentSleepResolve = null;
+				resolve$1();
+			};
+			this.currentSleepResolve = finish;
+			this.currentSleepTimer = setTimeout(finish, Math.max(durationMs, 0));
+		});
+	}
+	wakeEarly() {
+		const resolve$1 = this.currentSleepResolve;
+		this.currentSleepResolve = null;
+		if (this.currentSleepTimer) {
+			clearTimeout(this.currentSleepTimer);
+			this.currentSleepTimer = null;
 		}
-		await start;
+		resolve$1?.();
 	}
-	resolveSource(options) {
-		return { url: options.url ?? this.url };
+	sharedTenantIds() {
+		if (this.tenantId !== null || !this.tenantIds) return null;
+		return [...new Set(this.tenantIds())];
 	}
-	async stop() {
-		await Promise.allSettled(this.starting.values());
-		await Promise.all([...this.bridges.values()].map((bridge) => bridge.stop()));
-		this.bridges.clear();
+	sharedTenantIdsParameter(tenantIds) {
+		return this.pgClient.array(tenantIds, POSTGRES_TEXT_OID);
 	}
 };
 
@@ -10056,6 +10224,7 @@ var WakeRegistry = class {
 		};
 		if (value && `value` in value) change.value = value.value;
 		if (value && `oldValue` in value) change.oldValue = value.oldValue;
+		else if (value && `old_value` in value) change.oldValue = value.old_value;
 		if (eventType === `inbox`) {
 			if (typeof value?.from === `string`) change.from = value.from;
 			if (typeof value?.from_principal === `string`) change.from_principal = value.from_principal;
@@ -10418,8 +10587,8 @@ var ElectricAgentsServer = class {
 			runtime: this.standaloneRuntime.runtime,
 			entityBridgeManager: this.entityBridgeManager,
 			pgSyncBridgeManager: this.standaloneRuntime.runtime.pgSyncBridgeManager,
-			...this.options.eventSources ? { eventSources: this.options.eventSources } : {},
-			...this.options.ensureEventSourceWakeSource ? { ensureEventSourceWakeSource: this.options.ensureEventSourceWakeSource } : {},
+			...this.options.webhookSources ? { webhookSources: this.options.webhookSources } : {},
+			...this.options.ensureWebhookSourceWakeSource ? { ensureWebhookSourceWakeSource: this.options.ensureWebhookSourceWakeSource } : {},
 			...this.options.authorizeRequest ? { authorizeRequest: this.options.authorizeRequest } : {},
 			isShuttingDown: () => this.shuttingDown,
 			mockAgent: this.mockAgentBootstrap ? { runtime: this.mockAgentBootstrap.runtime } : void 0