@@ -10,7 +10,7 @@ import { validateRequest, routeAdminPath, wrapHandler } from '../core/admin.js';
 import { handlePreflight, jsonError, H_API_AUTH, H_API_ANON, H_API_SHARED, H_NOCACHE_AUTH, H_NOCACHE_ANON, isNotModifiedSince, lastModifiedHeader, syncAlignedCacheControl } from './http.js';
 import { isAuthSensitive } from './auth_scope.js';
 import { handleList, handleDetail, handleAsSet, handleCompare, handleNotImplemented } from './handlers/index.js';
-import { ensureSyncFreshness, getEntityVersion, handleStatus } from './sync_state.js';
+import { claimSyncPoll, runSyncPoll, getEntityVersion, handleStatus } from './sync_state.js';
 import { withD1Stats } from '../core/d1stats.js';
 import { ENTITY_TAGS, ENTITIES, validateFields, validateQuery, resolveImplicitFilters, dropUnknownFilters } from './entities.js';
 import { getCacheStats, purgeAllCaches } from './cache.js';
@@ -144,10 +144,7 @@ async function handleRequest(request, env, ctx) {
         return jsonError(404, "Not found");
     }
 
-    // O(1) hot-path hook: trigger background D1 poll if 15s have passed.
-    // Scoped to entity routes only — admin/health/status don't need it.
     const now = Date.now();
-    ensureSyncFreshness(session, ctx, now);
 
     // Write methods on API paths → 501 Not Implemented
     if (WRITE_METHODS.has(request.method)) {
@@ -268,9 +265,17 @@ async function handleRequest(request, env, ctx) {
     // header dict, avoiding a second Response + Headers allocation.
     /** @type {HandlerContext} */
     const hc = { request, db, d1, ctx, entityTag, filters, opts, rawPath: cachePath, queryString, authenticated, hApi: hEntity, entityVersionMs, userId: shared ? null : userId, paging, authMs };
+    // Sync freshness poll (every 15 s per isolate): rides along the
+    // request's first D1 call in the same batch — no extra round trip, and
+    // no separate query racing the request's own. A request that never
+    // reaches D1 (L1/L2 hit) runs it after the response instead.
+    const poll = claimSyncPoll(now);
+    if (poll) db.carry(poll);
     const response = id > 0
         ? await handleDetail(hc, id)
         : await handleList(hc);
+    const unsent = db.takeRider();
+    if (unsent) ctx.waitUntil(runSyncPoll(session, unsent));
     recordCacheTier(env, hc, response.status, shared, since > 0);
     return response;
 }
 
@@ -30,5 +30,7 @@ const _sync = createSyncState({
 });
 
 export const ensureSyncFreshness = _sync.ensureSyncFreshness;
+export const claimSyncPoll = _sync.claimPoll;
+export const runSyncPoll = _sync.runPoll;
 export const handleStatus = _sync.handleStatus;
 export const getEntityVersion = _sync.getEntityVersion;
@@ -10,10 +10,18 @@
  * `.first()` returns no meta, so the wrapper serves it through `.all()`:
  * same single call, same data (D1's first() fetches the result set and
  * returns the first row).
+ *
+ * Riders: `carry(rider)` attaches one extra read statement (the sync
+ * freshness poll) to the request's FIRST D1 call — sent in the same batch,
+ * so it costs no round trip; its results go to `rider.apply`, not to the
+ * caller, and its meta does not count toward the request's stats. If the
+ * request makes no D1 call, `takeRider()` hands it back for the caller to
+ * run separately.
  */
 
 /**
  * @typedef {{ calls: number, sqlMs: number, rowsRead: number }} D1Stats
+ * @typedef {{ sql: string, apply: (results: Record<string, any>[]) => void }} Rider
  */
 
 /**
@@ -32,19 +40,41 @@ export function withD1Stats(db) {
         if (Number.isFinite(meta.rows_read)) stats.rowsRead += meta.rows_read;
     };
 
+    /** @type {Rider|null} */
+    let rider = null;
+
+    /** @param {Rider} r @param {any} result */
+    const deliver = (r, result) => {
+        try { r.apply(result?.results || []); } catch (err) { console.error('[d1] rider apply failed:', err); }
+    };
+
+    /**
+     * Executes one statement's all(), sending the pending rider (if any) in
+     * the same batch.
+     * @param {any} st
+     */
+    const allWithRider = async (st) => {
+        const r = rider;
+        if (!r) return st.all();
+        rider = null;
+        const [main, extra] = await db.batch([st, db.prepare(r.sql)]);
+        deliver(r, extra);
+        return main;
+    };
+
     /** @param {any} st */
     const wrap = (st) => ({
         __inner: st,
         bind: (/** @type {any[]} */ ...args) => wrap(st.bind(...args)),
         all: async () => {
             stats.calls++;
-            const r = await st.all();
+            const r = await allWithRider(st);
             record(r?.meta);
             return r;
         },
         first: async (/** @type {string} */ col) => {
             stats.calls++;
-            const r = await st.all();
+            const r = await allWithRider(st);
             record(r?.meta);
             const row = r?.results?.[0] ?? null;
             if (col === undefined) return row;
@@ -63,10 +93,19 @@ export function withD1Stats(db) {
         prepare: (/** @type {string} */ sql) => wrap(db.prepare(sql)),
         batch: async (/** @type {any[]} */ stmts) => {
             stats.calls++;
-            const results = await db.batch(stmts.map(s => s?.__inner ?? s)); // ap-ok: cold path, one map per batch
-            for (const r of results) record(r?.meta);
+            const inner = stmts.map(s => s?.__inner ?? s); // ap-ok: cold path, one map per batch
+            const r = rider;
+            rider = null;
+            if (r) inner.push(db.prepare(r.sql));
+            const results = await db.batch(inner);
+            if (r) deliver(r, results.pop());
+            for (const res of results) record(res?.meta);
             return results;
         },
+        /** Attaches a read statement to the next D1 call (see file overview). @param {Rider} r */
+        carry: (r) => { rider = r; },
+        /** The rider, if no D1 call took it (then cleared). @returns {Rider|null} */
+        takeRider: () => { const r = rider; rider = null; return r; },
         withSession: () => session,
         getBookmark: () => db.getBookmark?.() ?? null,
     };
 
@@ -18,6 +18,9 @@
  *
  * Factory returns:
  *   ensureSyncFreshness(db, ctx, now) — O(1) hot-path hook
+ *   claimPoll(now) → {sql, apply} | null — the due poll as a statement + result
+ *                     step, to send with a query the request makes anyway
+ *   runPoll(db, poll)                 — run a claimed poll on its own
  *   handleStatus(request, db, ctx)    — pre-encoded /status handler (needs statusHeaders)
  *   getEntityVersion(tag)             — returns last_modified_at for L2 key versioning
  *   refresh(db)                       — force a synchronous poll (cold boot / tests)
@@ -40,6 +43,8 @@ import { encoder, jsonError } from './http.js';
  * @returns {{
  *   refresh: (db: D1Session) => Promise<void>,
  *   ensureSyncFreshness: (db: D1Session, ctx: ExecutionContext, now: number) => void,
+ *   claimPoll: (now: number) => ({ sql: string, apply: (results: Record<string, any>[]) => void } | null),
+ *   runPoll: (db: D1Session, poll: { sql: string, apply: (results: Record<string, any>[]) => void }) => Promise<void>,
  *   handleStatus: (request: Request, db: D1Session, ctx: ExecutionContext) => Promise<Response>,
  *   getEntityVersion: (tag: string) => number,
  * }}
@@ -61,11 +66,12 @@ export function createSyncState({ entityTags, onEntityChange, statusHeaders, che
     /** Pre-encoded JSON response for /status. @type {Uint8Array|null} */
     let statusPayload = null;
 
+    /** The poll statement (tiny: one row per entity). */
+    const POLL_SQL = 'SELECT entity, last_sync, row_count, updated_at, last_modified_at FROM "_sync_meta" ORDER BY entity';
+
     /**
-     * Background task: queries _sync_meta via D1 read-replication.
-     * Compares each entity's last_modified_at against the in-memory snapshot
-     * and calls onEntityChange for the ones that moved. Rebuilds the
-     * pre-encoded /status payload when statusHeaders is configured.
+     * Background task: queries _sync_meta via D1 read-replication and
+     * applies the result (see applyPoll).
      *
      * Runs inside ctx.waitUntil() — allocations here do not affect the
      * response path.
@@ -75,17 +81,30 @@ export function createSyncState({ entityTags, onEntityChange, statusHeaders, che
      */
     async function refresh(db) {
         try {
-            const rows = await db.prepare(
-                'SELECT entity, last_sync, row_count, updated_at, last_modified_at FROM "_sync_meta" ORDER BY entity'
-            ).all();
-
-            if (!rows || !rows.results) return;
+            const rows = await db.prepare(POLL_SQL).all();
+            if (rows && rows.results) applyPoll(rows.results);
+        } catch (err) {
+            // Background D1 errors must not crash the isolate.
+            // The previous statusPayload and knownModifiedAt remain valid.
+            console.error('[sync] background poll failed:', err);
+        }
+    }
 
+    /**
+     * Applies a _sync_meta result: compares each entity's last_modified_at
+     * against the in-memory snapshot and calls onEntityChange for the ones
+     * that moved; rebuilds the pre-encoded /status payload when statusHeaders
+     * is configured.
+     *
+     * @param {Record<string, any>[]} results - _sync_meta rows.
+     */
+    function applyPoll(results) {
+        try {
             // Build a lookup from the D1 results for fast access.
             // Use a Map to avoid dynamic-key objects.
             /** @type {Map<string, {last_sync: number, row_count: number, updated_at: string, last_modified_at: number}>} */
             const dbState = new Map();
-            for (const row of rows.results) {
+            for (const row of results) {
                 dbState.set(
                     /** @type {string} */ (row.entity),
                     {
@@ -133,8 +152,38 @@ export function createSyncState({ entityTags, onEntityChange, statusHeaders, che
             }
 
         } catch (err) {
-            // Background D1 errors must not crash the isolate.
-            // The previous statusPayload and knownModifiedAt remain valid.
+            // A malformed result must not crash the isolate.
+            console.error('[sync] applying poll result failed:', err);
+        }
+    }
+
+    /**
+     * Claims the poll if checkIntervalMs has elapsed (and marks it taken):
+     * the statement and its result step, for the caller to send in the same
+     * D1 call as a query it makes anyway — no extra round trip. null when
+     * not due. A claimed poll the caller never sends must go to runPoll.
+     *
+     * @param {number} now
+     * @returns {{ sql: string, apply: (results: Record<string, any>[]) => void } | null}
+     */
+    function claimPoll(now) {
+        if (now - lastCheck <= checkIntervalMs) return null;
+        lastCheck = now;
+        return { sql: POLL_SQL, apply: applyPoll };
+    }
+
+    /**
+     * Runs a claimed poll on its own (when the request made no D1 call).
+     *
+     * @param {D1Session} db
+     * @param {{ sql: string, apply: (results: Record<string, any>[]) => void }} poll
+     * @returns {Promise<void>}
+     */
+    async function runPoll(db, poll) {
+        try {
+            const rows = await db.prepare(poll.sql).all();
+            if (rows && rows.results) poll.apply(rows.results);
+        } catch (err) {
             console.error('[sync] background poll failed:', err);
         }
     }
@@ -206,5 +255,5 @@ export function createSyncState({ entityTags, onEntityChange, statusHeaders, che
         return knownModifiedAt.get(tag) || 0;
     }
 
-    return { refresh, ensureSyncFreshness, handleStatus, getEntityVersion };
+    return { refresh, ensureSyncFreshness, claimPoll, runPoll, handleStatus, getEntityVersion };
 }
@@ -106,7 +106,9 @@ export function createSqliteD1({ maxValueBytes = Infinity, oversizeError = 'toob
                     return { success: true, meta: { changes: Number(info.changes) }, results: [] };
                 },
                 // D1 batch semantics: reads return rows, writes return meta.changes.
-                exec: async () => (isRead
+                // Batched reads count like all()/first() (requests may batch their
+                // main query with the freshness poll, core/d1stats.js riders).
+                exec: async () => (isRead && (stats.queries++, isPayload && stats.payloadQueries++, true)
                     ? { success: true, meta: {}, results: stmt.all(...args) }
                     : { success: true, meta: { changes: Number(stmt.run(...args).changes) }, results: [] }),
             };
 
@@ -0,0 +1,73 @@
+/**
+ * @fileoverview The sync freshness poll rides along a request's first D1
+ * call (same batch, no extra round trip); a request that makes no D1 call
+ * runs it separately after the response.
+ */
+import { describe, it, before, after, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import { createSqliteD1, registerAssetLoader, envFor, mockCtx } from '../../lib/sqlite_d1.js';
+
+registerAssetLoader();
+const { default: apiWorker } = await import('../../../api/index.js');
+
+const TS = '2026-01-01T00:00:00Z';
+/** @type {any} */ let env;
+/** @type {string[][]} */ const batches = [];
+/** @type {string[]} */ const direct = [];
+
+before(() => {
+    mock.timers.enable({ apis: ['Date'], now: Date.parse('2026-10-10T12:00:00Z') });
+    const { sqlite, db } = createSqliteD1();
+    sqlite.exec(`INSERT INTO "peeringdb_organization" (id, name, social_media, status, created, updated) VALUES (1, 'Org', '[]', 'ok', '${TS}', '${TS}')`);
+    const net = sqlite.prepare(`INSERT INTO "peeringdb_network" (id, org_id, name, asn, social_media, info_types, ixp_update_exclude, status, created, updated) VALUES (?, 1, ?, ?, '[]', '[]', '[]', 'ok', '${TS}', '${TS}')`);
+    net.run(100, 'Net 100', 64100); net.run(101, 'Net 101', 64101);
+    env = envFor({
+        ...db,
+        withSession() { return this; },
+        batch: async (/** @type {any[]} */ stmts) => { batches.push(stmts.map((s) => s.__sql)); return db.batch(stmts); },
+        prepare: (/** @type {string} */ sql) => {
+            const wrap = (/** @type {any} */ st) => ({
+                ...st, __sql: sql,
+                bind: (/** @type {any[]} */ ...a) => wrap(st.bind(...a)),
+                all: async () => { direct.push(sql); return st.all(); },
+                first: async () => { direct.push(sql); return st.first(); },
+            });
+            return wrap(db.prepare(sql));
+        },
+    });
+});
+after(() => mock.timers.reset());
+
+const reset = () => { batches.length = 0; direct.length = 0; };
+const get = async (/** @type {string} */ path) => {
+    const res = await apiWorker.fetch(new Request(`https://api.pdbfe.dev/api/${path}`), env, mockCtx);
+    assert.equal(res.status, 200);
+    return res;
+};
+const isPoll = (/** @type {string} */ sql) => sql.includes('_sync_meta');
+
+describe('sync freshness poll', () => {
+    it('due + the request queries D1: one batch carries both, no separate poll query', async () => {
+        reset();
+        await get('net/100');
+        assert.equal(batches.length, 1);
+        assert.equal(batches[0].length, 2);
+        assert.ok(batches[0].some(isPoll), 'poll in the batch');
+        assert.equal(direct.filter(isPoll).length, 0);
+    });
+
+    it('not due (within 15 s): no poll at all', async () => {
+        reset();
+        mock.timers.tick(5_000);
+        await get('net/101');
+        assert.equal([...batches.flat(), ...direct].filter(isPoll).length, 0);
+    });
+
+    it('due + an L1 hit (no D1 call): the poll runs on its own after the response', async () => {
+        reset();
+        mock.timers.tick(16_000);
+        await get('net/100'); // cached by the first test
+        assert.equal(batches.length, 0, 'no batch: the request itself made no D1 call');
+        assert.equal(direct.filter(isPoll).length, 1, 'poll sent separately');
+    });
+});