svelte-realtime 0.6.0-next.71 → 0.6.0-next.73

package/README.md

@@ -3613,6 +3613,7 @@ How it behaves:
 
 - **The local entity is predicted.** `view.command(cmd)` applies your function immediately, so `view.local` moves this frame, and transmits the command (frame-batched, fire-and-forget - loss is recovered by reconciliation, never retransmission). The server applies the same commands through the same function on its authoritative tick and acknowledges each owner with the resulting state. When the acknowledged state disagrees with the prediction, the simulation adopts the server's answer immediately and the *rendered* position eases over a short window (`smoothTimeMs`, default 100) - unless the divergence is below `errorThreshold` (default 1), where easing would smear precision for nothing and the correction snaps silently.
 - **Remote entities render slightly in the past.** Their positions interpolate between server updates on a server-synced clock, so a dropped or late frame is invisible. `interpolationMs: 'auto'` (the default) tracks twice the measured update interval and collapses toward its floor when updates arrive at display rate. State fields beyond `x`/`y` are latest-value.
+- **The wire cadence can drop below the tick rate** (`broadcastHz`): the simulation keeps ticking at `tickMs`, but entity updates go out every Nth tick, with the motion of skipped ticks coalesced into the next frame (each entity's *current* state, never a stale one) and the interpolation above covering the widened gap - a 60Hz simulation broadcasting at 20Hz cuts the fan-out bandwidth to a third, which is usually the scaling ceiling long before CPU. Acknowledgements, discrete events, and removals stay per-tick, so the owner's reconciliation and one-shot actions never lag, and the final rest state always flushes when motion stops. Off by default: every tick broadcasts.
 - **Echo suppression is on by default** (`noEcho`): broadcasts of an owner's own commanded updates skip that owner - the acknowledgement already carries the authoritative copy, so the echo would be wasted bytes that fight the prediction. `onMissing` motion produces no acknowledgement and broadcasts to the owner too.
 - **One entity per identity per topic**, keyed like presence rosters (`identify`-style user keys, or per-connection guest keys). A second tab takes ownership by constructing a view (its sync re-binds the entity); it never races commands against the first. Ownership is last-sync-wins: a dispossessed view's commands are silently ignored until its un-acked window overflows, and the overflow recovery resync re-takes ownership - so exactly one view per identity should be commanding at a time.
 - **Side effects in `apply` must guard on `ctx.firstTime`** - reconciliation replays commands, and the flag is true only on a command's first application. Randomness inside `apply` must come from `ctx.rng` (reseeded per command id, identical on prediction, replay, and the server); `Math.random()` there is the documented mistake that turns every random command into a misprediction. `ctx.key` names the entity whose command is being applied - the attribution handle for authoritative side effects (who fired the shot, whose action to log): the server sets it for every application, and the owner's own prediction reports the same key (null until the first sync reply announces the identity). Requires svelte-adapter-uws >= 0.6.0-next.50.
@@ -3623,7 +3624,7 @@ How it behaves:
 - **`view.now()`** is the estimated server wall-clock time, maintained from the server's frame stamps and the acknowledgement round trips. It is the right stamp for lag-compensated action arguments (see below).
 - **The wire is negotiated.** Binary frames engage per connection (`smooth.protocol:1`); everything degrades to JSON additively - old clients ignore the new events, and a server without the smooth plugin fails the first sync or command with an actionable version message, never a resolution crash.
 
-Knobs (all optional, on the server declaration: `tickMs` 50, `noEcho` true, `queueCap` 1024, `guard`, `onMissing`, `snapshot` false, `snapshotDebounceMs` 1000; on the client factory: `interpolationMs` 'auto', `extrapolateMs` 250, `snapGapMs` 500, `smoothTimeMs` 100, `errorThreshold` 1, `computeError`, `cmdRate` 60, `windowCap` 256, `windowMaxAgeMs` 3000). The tradeoff to know: larger `interpolationMs` survives more dropped frames but renders remote entities further in the past.
+Knobs (all optional, on the server declaration: `tickMs` 50, `broadcastHz` off, `noEcho` true, `queueCap` 1024, `guard`, `onMissing`, `snapshot` false, `snapshotDebounceMs` 1000; on the client factory: `interpolationMs` 'auto', `extrapolateMs` 250, `snapGapMs` 500, `smoothTimeMs` 100, `errorThreshold` 1, `computeError`, `cmdRate` 60, `windowCap` 256, `windowMaxAgeMs` 3000). The tradeoff to know: larger `interpolationMs` survives more dropped frames but renders remote entities further in the past.
 
 Requires Svelte 5 (the view is a rune class) and svelte-adapter-uws 0.6.0-next.26 or newer (`view.onEvent` needs the adapter's client-side event delivery; the prediction/reconciliation surface alone needs only next.24).
 

package/package.json

@@ -1,119 +1,119 @@
-{
-  "name": "svelte-realtime",
-  "version": "0.6.0-next.71",
-  "publishConfig": {
-    "tag": "next"
-  },
-  "description": "Realtime RPC and reactive subscriptions for SvelteKit, built on svelte-adapter-uws",
-  "author": "Kevin Radziszewski",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/lanteanio/svelte-realtime.git"
-  },
-  "homepage": "https://github.com/lanteanio/svelte-realtime#readme",
-  "bugs": {
-    "url": "https://github.com/lanteanio/svelte-realtime/issues"
-  },
-  "type": "module",
-  "bin": {
-    "svelte-realtime": "./src/cli.js"
-  },
-  "exports": {
-    ".": {
-      "types": "./src/server.d.ts",
-      "default": "./src/server.js"
-    },
-    "./server": {
-      "types": "./src/server.d.ts",
-      "default": "./src/server.js"
-    },
-    "./client": {
-      "types": "./src/client.d.ts",
-      "default": "./src/client.js"
-    },
-    "./multiplayer": {
-      "types": "./src/client-multiplayer.d.ts",
-      "default": "./src/client-multiplayer.svelte.js"
-    },
-    "./smooth": {
-      "types": "./src/client-smooth.d.ts",
-      "default": "./src/client-smooth.svelte.js"
-    },
-    "./doc": {
-      "types": "./src/client-doc.d.ts",
-      "default": "./src/client-doc.svelte.js"
-    },
-    "./rooms": {
-      "types": "./src/client-rooms.d.ts",
-      "default": "./src/client-rooms.svelte.js"
-    },
-    "./vite": {
-      "types": "./src/vite.d.ts",
-      "default": "./src/vite.js"
-    },
-    "./devtools": {
-      "types": "./src/devtools.d.ts",
-      "default": "./src/devtools.js"
-    },
-    "./testing": {
-      "types": "./src/testing.d.ts",
-      "default": "./src/testing.js"
-    },
-    "./testing/client": {
-      "types": "./src/testing-client.d.ts",
-      "default": "./src/testing-client.js"
-    },
-    "./hooks": {
-      "types": "./src/hooks.d.ts",
-      "default": "./src/hooks.js"
-    },
-    "./sim": {
-      "types": "./src/sim.d.ts",
-      "default": "./src/sim.js"
-    }
-  },
-  "files": [
-    "src",
-    "LICENSE",
-    "README.md",
-    "MIGRATION.md"
-  ],
-  "scripts": {
-    "check": "node scripts/check-types.js && node scripts/check-determinism.js && node scripts/check-slugs.js",
-    "pretest": "npm run check",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:e2e": "playwright test --config test/e2e/playwright.config.js",
-    "test:chaos": "playwright test --config test/chaos/playwright.config.js",
-    "test:fuzz": "node test/fuzz-wire.mjs"
-  },
-  "engines": {
-    "node": ">=22.0.0"
-  },
-  "dependencies": {
-    "@clack/prompts": "^0.10.1"
-  },
-  "peerDependencies": {
-    "@sveltejs/kit": "^2.0.0",
-    "svelte": "^4.0.0 || ^5.0.0",
-    "svelte-adapter-uws": "^0.6.0-next.60"
-  },
-  "devDependencies": {
-    "@playwright/test": "^1.59.1",
-    "fast-check": "^4.7.0",
-    "svelte-adapter-uws-extensions": "^0.6.0-next.20",
-    "vitest": "^4.0.18"
-  },
-  "keywords": [
-    "svelte",
-    "sveltekit",
-    "websocket",
-    "rpc",
-    "realtime",
-    "pubsub",
-    "uwebsockets",
-    "streams",
-    "live"
-  ]
-}
+{
+	"name": "svelte-realtime",
+	"version": "0.6.0-next.73",
+	"publishConfig": {
+		"tag": "next"
+	},
+	"description": "Realtime RPC and reactive subscriptions for SvelteKit, built on svelte-adapter-uws",
+	"author": "Kevin Radziszewski",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/lanteanio/svelte-realtime.git"
+	},
+	"homepage": "https://github.com/lanteanio/svelte-realtime#readme",
+	"bugs": {
+		"url": "https://github.com/lanteanio/svelte-realtime/issues"
+	},
+	"type": "module",
+	"bin": {
+		"svelte-realtime": "./src/cli.js"
+	},
+	"exports": {
+		".": {
+			"types": "./src/server.d.ts",
+			"default": "./src/server.js"
+		},
+		"./server": {
+			"types": "./src/server.d.ts",
+			"default": "./src/server.js"
+		},
+		"./client": {
+			"types": "./src/client.d.ts",
+			"default": "./src/client.js"
+		},
+		"./multiplayer": {
+			"types": "./src/client-multiplayer.d.ts",
+			"default": "./src/client-multiplayer.svelte.js"
+		},
+		"./smooth": {
+			"types": "./src/client-smooth.d.ts",
+			"default": "./src/client-smooth.svelte.js"
+		},
+		"./doc": {
+			"types": "./src/client-doc.d.ts",
+			"default": "./src/client-doc.svelte.js"
+		},
+		"./rooms": {
+			"types": "./src/client-rooms.d.ts",
+			"default": "./src/client-rooms.svelte.js"
+		},
+		"./vite": {
+			"types": "./src/vite.d.ts",
+			"default": "./src/vite.js"
+		},
+		"./devtools": {
+			"types": "./src/devtools.d.ts",
+			"default": "./src/devtools.js"
+		},
+		"./testing": {
+			"types": "./src/testing.d.ts",
+			"default": "./src/testing.js"
+		},
+		"./testing/client": {
+			"types": "./src/testing-client.d.ts",
+			"default": "./src/testing-client.js"
+		},
+		"./hooks": {
+			"types": "./src/hooks.d.ts",
+			"default": "./src/hooks.js"
+		},
+		"./sim": {
+			"types": "./src/sim.d.ts",
+			"default": "./src/sim.js"
+		}
+	},
+	"files": [
+		"src",
+		"LICENSE",
+		"README.md",
+		"MIGRATION.md"
+	],
+	"scripts": {
+		"check": "node scripts/check-types.js && node scripts/check-determinism.js && node scripts/check-slugs.js",
+		"pretest": "npm run check",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"test:e2e": "playwright test --config test/e2e/playwright.config.js",
+		"test:chaos": "playwright test --config test/chaos/playwright.config.js",
+		"test:fuzz": "node test/fuzz-wire.mjs"
+	},
+	"engines": {
+		"node": ">=22.0.0"
+	},
+	"dependencies": {
+		"@clack/prompts": "^0.10.1"
+	},
+	"peerDependencies": {
+		"@sveltejs/kit": "^2.0.0",
+		"svelte": "^4.0.0 || ^5.0.0",
+		"svelte-adapter-uws": "^0.6.0-next.61"
+	},
+	"devDependencies": {
+		"@playwright/test": "^1.59.1",
+		"fast-check": "^4.7.0",
+		"svelte-adapter-uws-extensions": "^0.6.0-next.20",
+		"vitest": "^4.0.18"
+	},
+	"keywords": [
+		"svelte",
+		"sveltekit",
+		"websocket",
+		"rpc",
+		"realtime",
+		"pubsub",
+		"uwebsockets",
+		"streams",
+		"live"
+	]
+}

package/src/server/sim-smooth.js

@@ -291,7 +291,7 @@ export async function runSmoothSim(config = {}) {
 				const relSet = relevancy ? relevancy.get(identity) : undefined;
 				let delivered = false;
 				if (relSet) for (const key of relSet) if (key !== identity) { delivered = true; break; }
-				if (delivered) rec.interest.noteSend(identity, wall, rec.tickMs);
+				if (delivered) rec.interest.noteSend(identity, wall, rec.tickMs * rec.broadcastEvery);
 			}
 			rec.lagComp.record(catalog, rec.monoClock.mono(wall));
 		}

package/src/server/smooth.js

@@ -340,6 +340,18 @@ export function _smoothRecord(name, cfg, platform, rt) {
 			codec: rt.createSmoothWireCodec(),
 			platform,
 			tickMs: cfg.tickMs,
+			// Broadcast cadence gate (broadcastHz): entity updates go on the wire
+			// every Nth tick instead of every tick, the client interpolation covering
+			// the widened gap. 1 (the default) is the byte-identical every-tick path.
+			// `pendingWire` accumulates the movers of skipped ticks (key -> the LAST
+			// tick's commanded flag, which decides the owner-echo exclusion at flush);
+			// the send tick re-reads each mover's CURRENT authoritative state, so
+			// skipped motion is coalesced, never lost.
+			broadcastEvery: cfg.broadcastHz
+				? Math.max(1, Math.round(1000 / cfg.tickMs / cfg.broadcastHz))
+				: 1,
+			tickNo: 0,
+			pendingWire: new Map(),
 			noEcho: cfg.noEcho,
 			timer: null,
 			// Cluster bookkeeping (unused on the single-instance path). `cfg` is
@@ -1019,7 +1031,10 @@ function _smoothDeliverCulled(rec, relevancy, catalogByKey, moved, t) {
 				if (key !== identity) delivered = true;
 			}
 		}
-		if (delivered && rec.lagComp !== null) rec.interest.noteSend(identity, t, rec.tickMs);
+		// The cadence seed is the WIRE interval (tickMs widened by the broadcast
+		// gate), not the sim interval - the estimator's cold-start guess must
+		// match what a subscriber actually receives.
+		if (delivered && rec.lagComp !== null) rec.interest.noteSend(identity, t, rec.tickMs * rec.broadcastEvery);
 	}
 }
 
@@ -1116,6 +1131,41 @@ function _smoothTick(rec) {
 	// in the catalog taken below, so they broadcast, ring-record, and cull
 	// atomically with the drain.
 	const worldRun = rec.world !== null ? rec.world.run(updates, acks, t) : null;
+	// Broadcast cadence gate (broadcastHz): the simulation keeps ticking at
+	// tickMs - commands drain, acknowledgements return, events fire, the
+	// lag-compensation ring records - but continuous entity updates go on the
+	// wire only every broadcastEvery-th tick. The drain reports PER-TICK deltas,
+	// so a skipped tick's movers are accumulated into `pendingWire` rather than
+	// dropped, and the send tick re-reads each mover's CURRENT authoritative
+	// state - motion across skipped ticks is coalesced into one frame, never
+	// lost. The stored flag is the LAST tick's `commanded`: a trailing commanded
+	// change was acknowledged with the final state (the owner already holds it,
+	// so the echo exclusion may apply), a trailing onMissing/injected change was
+	// not (the owner must receive the broadcast). An idle drain with pending
+	// motion flushes immediately: the single-instance tick stops re-arming at
+	// idle, and the final rest state must reach the viewers before it does. A
+	// mover removed between accumulation and flush is skipped - its departure
+	// was already broadcast by the remove path. Everything below the gate
+	// consumes `wireUpdates`; on the default path it IS the drain's updates
+	// array, so the every-tick behavior is byte-identical.
+	let wireUpdates = updates;
+	if (rec.broadcastEvery > 1) {
+		for (let i = 0; i < updates.length; i++) {
+			rec.pendingWire.set(updates[i].key, updates[i].commanded);
+		}
+		rec.tickNo++;
+		if (rec.pendingWire.size > 0 && (rec.tickNo % rec.broadcastEvery === 0 || idle)) {
+			wireUpdates = [];
+			for (const [key, commanded] of rec.pendingWire) {
+				const e = rec.authority.get(key);
+				if (e === undefined) continue;
+				wireUpdates.push({ key, state: e.state, ws: e.ws, commanded });
+			}
+			rec.pendingWire.clear();
+		} else {
+			wireUpdates = [];
+		}
+	}
 	// Area-of-interest: when this topic opted into interest, build the relevancy
 	// for THIS instance's local subscribers once per tick from the drained catalog
 	// (which on a cluster owner spans every entity cluster-wide, local and remote
@@ -1142,7 +1192,7 @@ function _smoothTick(rec) {
 	// either wants it (one allocation when both are on), but compute relevancy only
 	// on the interest cadence (so the interest LOD counter is unchanged when the
 	// catalog was taken solely for lag compensation).
-	const wantInterest = rec.interest !== null && (updates.length > 0 || rec.interestDirty);
+	const wantInterest = rec.interest !== null && (wireUpdates.length > 0 || rec.interestDirty);
 	const catalog = (rec.lagComp !== null || wantInterest) ? rec.authority.catalog() : null;
 	const relevancy = wantInterest
 		? rec.interest.compute(catalog, rec.registry.keys(), rec.interestTick++)
@@ -1155,8 +1205,8 @@ function _smoothTick(rec) {
 		if (!idle || (worldRun !== null && worldRun.dirty)) rec.lagCompLastActive = t;
 	}
 	rec.interestDirty = false;
-	for (let i = 0; i < updates.length; i++) {
-		const u = updates[i];
+	for (let i = 0; i < wireUpdates.length; i++) {
+		const u = wireUpdates[i];
 		// Cells mode: route each changed entity to its cell topic (native shared
 		// fan-out), not the per-subscriber walk or the base broadcast. Egress is
 		// O(cells), not O(subscribers). The mover's own cell subscription follows it
@@ -1225,8 +1275,8 @@ function _smoothTick(rec) {
 		// remote frame advances the lag-comp send-cadence estimator (the client discards
 		// its own entity frame before measuring its interpolation delay).
 		const moved = new Map();
-		for (let i = 0; i < updates.length; i++) {
-			const u = updates[i];
+		for (let i = 0; i < wireUpdates.length; i++) {
+			const u = wireUpdates[i];
 			moved.set(u.key, { state: u.state, exclude: rec.noEcho && u.commanded ? u.key : undefined });
 		}
 		_smoothDeliverCulled(rec, relevancy, catalogByKey, moved, t);
@@ -2262,8 +2312,10 @@ export function _smoothEdgeMeasure(rec, ctx, payload, shooterKey, now) {
 		}
 		// Favor-the-shooter reach width = measured uplink (max-of-recent) + the
 		// client's interpolation delay; both server-measured, clamped to the cap.
+		// The interpolation seed is the WIRE interval (tickMs widened by the
+		// broadcast gate) - the client renders behind the cadence it receives.
 		const maxUp = st ? st.tracker.maxUplink() : null;
-		const serverInterp = rec.aoi.interpDelayMs(shooterKey, rec.tickMs, now);
+		const serverInterp = rec.aoi.interpDelayMs(shooterKey, rec.tickMs * rec.broadcastEvery, now);
 		reach = maxUp === null ? ht.maxRewindMs : Math.min(ht.maxRewindMs, maxUp + serverInterp);
 		// The rewind age is a pure duration the owner applies to its own present.
 		rewindAge = Math.max(0, now - rtStamp);
@@ -2481,7 +2533,14 @@ export async function _smoothResolveShot(rec, name, shooterKey, shooterEntity, c
  * shared step), `initial` (starting state, or `(key) => state`), `guard?`
  * (auth check, same shape as room guards), `onMissing?` (per-tick
  * continuation for command-less entities; omitted = hold position),
- * `tickMs?` (authoritative tick interval, default 50), `noEcho?` (suppress
+ * `tickMs?` (authoritative tick interval, default 50), `broadcastHz?` (wire
+ * broadcast rate: entity updates are sent every Nth tick - N derived from
+ * tickMs - instead of every tick, with the motion of skipped ticks coalesced
+ * into the next frame (an entity's CURRENT state, never a stale one) and the
+ * client interpolation covering the widened gap. Acknowledgements, discrete
+ * events, and removals stay per-tick, so the owner's reconciliation and
+ * one-shot actions never lag. The final rest state always flushes when motion
+ * stops. Default: broadcast every tick, byte-identical), `noEcho?` (suppress
  * echoing an owner's own commanded updates in broadcasts, default true - the
  * acknowledgement carries the owner's copy; onMissing motion has no
  * acknowledgement and always broadcasts to the owner too), `queueCap?`
@@ -2522,7 +2581,7 @@ export async function _smoothResolveShot(rec, name, shooterKey, shooterEntity, c
  * module, like `apply`; requires svelte-adapter-uws >= 0.6.0-next.49 for the
  * client-side unpack). Default off, byte-identical wire).
  *
- * @param {{ topic: string | Function, apply: Function, initial: any, guard?: Function, onMissing?: Function, tickMs?: number, noEcho?: boolean, queueCap?: number, snapshot?: boolean, snapshotDebounceMs?: number, topicArgs?: number, interest?: { radius: number, position: (state: any) => ({ x: number, y: number } | null), lod?: Array<{ within: number, rate: number }>, cell?: number, budget?: number }, wire?: { state?: { pack: (state: any) => any, unpack: (packed: any) => any }, command?: { pack: (cmd: any) => any, unpack: (packed: any) => any } } }} config
+ * @param {{ topic: string | Function, apply: Function, initial: any, guard?: Function, onMissing?: Function, tickMs?: number, broadcastHz?: number, noEcho?: boolean, queueCap?: number, snapshot?: boolean, snapshotDebounceMs?: number, topicArgs?: number, interest?: { radius: number, position: (state: any) => ({ x: number, y: number } | null), lod?: Array<{ within: number, rate: number }>, cell?: number, budget?: number }, wire?: { state?: { pack: (state: any) => any, unpack: (packed: any) => any }, command?: { pack: (cmd: any) => any, unpack: (packed: any) => any } } }} config
  */
 export const _smoothRegister = function smooth(config) {
 	if (!config || typeof config !== 'object') {
@@ -2545,6 +2604,9 @@ export const _smoothRegister = function smooth(config) {
 	if (!(typeof tickMs === 'number' && Number.isFinite(tickMs) && tickMs > 0)) {
 		throw new Error('[svelte-realtime] live.smooth() tickMs must be a positive number');
 	}
+	if (config.broadcastHz !== undefined && !(typeof config.broadcastHz === 'number' && Number.isFinite(config.broadcastHz) && config.broadcastHz > 0)) {
+		throw new Error('[svelte-realtime] live.smooth() broadcastHz must be a positive number');
+	}
 	if (config.queueCap !== undefined && !(typeof config.queueCap === 'number' && Number.isInteger(config.queueCap) && config.queueCap >= 1)) {
 		throw new Error('[svelte-realtime] live.smooth() queueCap must be an integer of at least 1');
 	}
@@ -2567,6 +2629,7 @@ export const _smoothRegister = function smooth(config) {
 		onMissing: config.onMissing,
 		queueCap: config.queueCap,
 		tickMs,
+		broadcastHz: config.broadcastHz,
 		noEcho: config.noEcho !== false,
 		snapshot: config.snapshot === true,
 		snapshotDebounceMs,

package/src/server/state.js

@@ -342,6 +342,12 @@ export const state = {
 	/** @type {any} Dead-letter store for undeliverable outbound webhooks (null = capture off). */
 	webhookDeadLetter: null,
 
+	/** @type {any} Retry budget for outbound webhooks (null = unrationed). */
+	webhookBudget: null,
+
+	/** @type {any} Endpoint-ejection breaker for outbound webhooks (null = no ejection). */
+	webhookBreaker: null,
+
 	/** @type {import('svelte-adapter-uws').Platform | null} Captured platform for dynamic derived recomputation */
 	derivedPlatform: null,
 

package/src/server/webhook-out.js

@@ -11,6 +11,21 @@ import { _IS_DEV } from './env.js';
 /** Re-exported for the registration-time SSRF validation message in webhooks.js. */
 export { redactUrl as _redactUrl };
 
+/**
+ * Assemble the optional delivery-control hooks for one webhook entry: the
+ * configured retry budget + endpoint-ejection breaker (wired via
+ * `configureWebhooks` / `realtime({ webhooks })`), keyed by the webhook's
+ * registration id so one endpoint's failures cannot trip or starve another.
+ * Returns undefined when neither is configured, so an unconfigured delivery is
+ * byte-identical to the bare call.
+ */
+function _webhookHooks(entry) {
+	const budget = state.webhookBudget;
+	const breaker = state.webhookBreaker;
+	if (!budget && !breaker) return undefined;
+	return { budget: budget || undefined, breaker: breaker || undefined, key: entry.id };
+}
+
 function _reportWebhookOutFailure(config, err, event, data, attempts) {
 	if (config.onFailure) {
 		try {
@@ -26,7 +41,7 @@ function _reportWebhookOutFailure(config, err, event, data, attempts) {
 
 export async function _fireWebhookOut(entry, topic, event, data, platform) {
 	void platform; // accepted for call-site parity; delivery reads entry.config
-	const r = await deliverWebhook(entry.config, topic, event, data);
+	const r = await deliverWebhook(entry.config, topic, event, data, _webhookHooks(entry));
 	if (r.ok) return;
 	_reportWebhookOutFailure(entry.config, r.err, event, data, r.attempts);
 	const store = state.webhookDeadLetter;
@@ -47,7 +62,7 @@ export async function _fireWebhookOut(entry, topic, event, data, platform) {
 }
 
 export async function _replayWebhookOut(entry, topic, event, data) {
-	const r = await deliverWebhook(entry.config, topic, event, data);
+	const r = await deliverWebhook(entry.config, topic, event, data, _webhookHooks(entry));
 	if (r.ok) return { ok: true };
 	return { ok: false, error: String((r.err && r.err.message) || r.err || 'unknown') };
 }

package/src/server/webhooks.js

@@ -1,5 +1,6 @@
 // @ts-check
 import { checkUrl } from 'svelte-adapter-uws/safe-url';
+import { createRetryBudget, createWebhookBreaker } from 'svelte-adapter-uws/plugins/webhooks';
 import { _redactUrl, _replayWebhookOut } from './webhook-out.js';
 import { state, _webhookOutById } from './state.js';
 import { createDeadLetterStore } from './dead-letter.js';
@@ -114,17 +115,29 @@ export const _webhooksOutboundRegister = function outbound(sources, config) {
 };
 
 /**
- * Configure the outbound-webhook plane. `deadLetter` enables the dead-letter
- * store that retains UNDELIVERABLE outbound-webhook events (retry-exhausted,
- * SSRF-blocked, etc.) for admin inspection + replay, instead of reporting then
- * dropping them. Off by default - a DLQ retains attacker-influenced event data,
- * so it is opt-in.
+ * Configure the outbound-webhook plane.
  *
- * Pass `true` for the default in-memory store, a store instance (e.g. a
- * Redis/Postgres store for a cluster) for shared durability, or `false`/`null`
- * to disable. Also wired from `realtime({ webhooks: { deadLetter } })`.
+ * `deadLetter` enables the dead-letter store that retains UNDELIVERABLE
+ * outbound-webhook events (retry-exhausted, SSRF-blocked, etc.) for admin
+ * inspection + replay, instead of reporting then dropping them. Off by default -
+ * a DLQ retains attacker-influenced event data, so it is opt-in.
  *
- * @param {{ deadLetter?: boolean | object | null }} [config]
+ * `budget` rations retry AMPLIFICATION so a storm of failing deliveries to one
+ * endpoint cannot launch unbounded retry work (the first attempt of each
+ * delivery always proceeds). `breaker` ejects a persistently-failing endpoint:
+ * an open circuit fast-fails to the dead-letter store without touching the
+ * network, and heals after a probe succeeds. Both are keyed by the webhook's
+ * registration id, so one endpoint cannot trip or starve another. Off by
+ * default.
+ *
+ * Each option takes `true` for the built-in single-instance default (an
+ * in-memory store / an in-process token bucket / an in-process breaker), an
+ * instance for a cluster (e.g. a Redis dead-letter store, or a shared
+ * budget/breaker coordinator) for cross-instance durability, or `false`/`null`
+ * to disable. Also wired from `realtime({ webhooks: { deadLetter, budget,
+ * breaker } })`.
+ *
+ * @param {{ deadLetter?: boolean | object | null, budget?: boolean | object | null, breaker?: boolean | object | null }} [config]
  */
 export function configureWebhooks(config = {}) {
 	if (config.deadLetter !== undefined) {
@@ -136,6 +149,31 @@ export function configureWebhooks(config = {}) {
 			state.webhookDeadLetter = null;
 		}
 	}
+	if (config.budget !== undefined) {
+		if (config.budget === true) {
+			if (!state.webhookBudget) state.webhookBudget = createRetryBudget();
+		} else if (config.budget && typeof config.budget === 'object') {
+			if (typeof config.budget.take !== 'function') {
+				throw new Error('[svelte-realtime] configureWebhooks({ budget }): a budget must have a take(key) method (or pass true for the built-in)');
+			}
+			state.webhookBudget = config.budget;
+		} else {
+			state.webhookBudget = null;
+		}
+	}
+	if (config.breaker !== undefined) {
+		if (config.breaker === true) {
+			if (!state.webhookBreaker) state.webhookBreaker = createWebhookBreaker();
+		} else if (config.breaker && typeof config.breaker === 'object') {
+			const b = config.breaker;
+			if (typeof b.guard !== 'function' || typeof b.success !== 'function' || typeof b.failure !== 'function') {
+				throw new Error('[svelte-realtime] configureWebhooks({ breaker }): a breaker must have guard(key), success(key), and failure(err, key) methods (or pass true for the built-in)');
+			}
+			state.webhookBreaker = b;
+		} else {
+			state.webhookBreaker = null;
+		}
+	}
 }
 
 /**

package/src/server.d.ts

@@ -3061,6 +3061,18 @@ export interface SmoothConfig {
 	onMissing?: (state: any, lastCommand: any) => any;
 	/** Authoritative tick interval in milliseconds. @default 50 */
 	tickMs?: number;
+	/**
+	 * Wire broadcast rate in Hz: entity updates are sent every Nth tick (N
+	 * derived from `tickMs`) instead of every tick, with the motion of skipped
+	 * ticks coalesced into the next frame (each entity's CURRENT state, never a
+	 * stale one) and the client interpolation covering the widened gap - the
+	 * simulation keeps ticking at `tickMs`, only the on-wire cadence drops.
+	 * Acknowledgements, discrete events, and removals stay per-tick, so the
+	 * owner's reconciliation and one-shot actions never lag, and the final rest
+	 * state always flushes when motion stops. Off by default: every tick
+	 * broadcasts, byte-identical.
+	 */
+	broadcastHz?: number;
 	/**
 	 * Suppress echoing an owner's own commanded updates in broadcasts - the
 	 * acknowledgement carries the owner's copy. `onMissing` motion has no
@@ -4263,11 +4275,18 @@ export interface RealtimeConfig {
 	 * that retains UNDELIVERABLE outbound-webhook events (retry-exhausted,
 	 * SSRF-blocked, etc.) for admin inspection and replay, instead of reporting
 	 * then dropping them. Off by default (a DLQ retains attacker-influenced event
-	 * data). `true` uses the default in-memory store; a store instance gives a
-	 * cluster shared durable store; `false`/`null` disables. Equivalent to
-	 * `configureWebhooks({ deadLetter })`.
-	 */
-	webhooks?: { deadLetter?: boolean | DeadLetterStore | null } | null;
+	 * data). `webhooks.budget` rations retry amplification and `webhooks.breaker`
+	 * ejects a persistently-failing endpoint (fast-fail to the DLQ, healing after
+	 * a probe succeeds), both keyed by the webhook's registration id. Each takes
+	 * `true` for the built-in single-instance default, an instance for a cluster
+	 * (a shared store / budget / breaker), or `false`/`null` to disable.
+	 * Equivalent to `configureWebhooks({ deadLetter, budget, breaker })`.
+	 */
+	webhooks?: {
+		deadLetter?: boolean | DeadLetterStore | null;
+		budget?: boolean | import('svelte-adapter-uws/plugins/webhooks').RetryBudget | null;
+		breaker?: boolean | import('svelte-adapter-uws/plugins/webhooks').WebhookBreaker | null;
+	} | null;
 	/**
 	 * Opt-in protocol/contract version, an integer the app bumps only on a BREAKING
 	 * wire/contract change. Declare it identically here and in client `configure({
@@ -4344,12 +4363,19 @@ export interface DeadLetterStore {
 export function createDeadLetterStore(options?: { max?: number; ttlMs?: number }): DeadLetterStore;
 
 /**
- * Configure the outbound-webhook plane. `deadLetter: true` enables the default
- * in-memory dead-letter store; a store instance wires a custom/cluster store;
- * `false`/`null` disables capture (the default). Also wired from
+ * Configure the outbound-webhook plane. `deadLetter` captures undeliverable
+ * events; `budget` rations retry amplification; `breaker` ejects a
+ * persistently-failing endpoint (fast-fail to the DLQ, healing after a probe
+ * succeeds), keyed by the webhook's registration id. Each takes `true` for the
+ * built-in single-instance default, an instance for a cluster (a shared store /
+ * budget / breaker), or `false`/`null` to disable (the default). Also wired from
  * `realtime({ webhooks })`.
  */
-export function configureWebhooks(config?: { deadLetter?: boolean | DeadLetterStore | null }): void;
+export function configureWebhooks(config?: {
+	deadLetter?: boolean | DeadLetterStore | null;
+	budget?: boolean | import('svelte-adapter-uws/plugins/webhooks').RetryBudget | null;
+	breaker?: boolean | import('svelte-adapter-uws/plugins/webhooks').WebhookBreaker | null;
+}): void;
 
 /** The configured dead-letter store, or `null` when capture is off. */
 export function getDeadLetter(): DeadLetterStore | null;

package/src/server.js

@@ -3536,8 +3536,9 @@ export function realtime(config) {
 
 	if (bus !== undefined) _setBus(bus);
 	if (leader !== undefined) configureCron({ leader });
-	// Outbound-webhook plane: `webhooks.deadLetter` enables the dead-letter store
-	// (retain + admin-replay undeliverable webhook events). Off unless configured.
+	// Outbound-webhook plane: `webhooks.deadLetter` retains + admin-replays
+	// undeliverable events; `webhooks.budget`/`webhooks.breaker` ration retries
+	// and eject a failing endpoint. Off unless configured.
 	if (webhooks !== undefined) configureWebhooks(webhooks);
 	// Multi-tenancy opt-in: a resolver mapping the server-trusted authenticated
 	// user (ws.getUserData()) to a tenant id auto-scopes every topic and key.