[psteinroe]

What

Under a set test clock (createTestClock, db.client.setFakeTime), event waits never received events emitted after them. Dispatch requires source.created_at > subscription.created_at, and _private_current_time() returned the frozen fake_now as-is, so the subscription and the later event got the same timestamp and the event was dropped. This affected ctx.waitForEvent(), ctx.subscribe() + ctx.waitForAny(), and anything else that waits on events while the clock is set. waitForAny also picked the wrong winner: it orders resolved branches by step created_at, so ties fell back to branch order.

Fix: fake time keeps running

Production code and schema are unchanged; only fake time changes.

• _private_current_time() returns clock_timestamp() + pgconductor.fake_offset when the setting is set. It replaces the pgconductor.fake_now setting.
• createTestClock: set(date) stores date - clock_timestamp() as the offset, advance(d) adds d to it, and reset() clears it. now() applies the same offset to Date.now(), rounded up to whole milliseconds so it never reads before the time set, so database and worker time run on together (the worker's sampled offset stays ~0). The offset is computed once in a materialized CTE. Without that, Postgres inlines the subquery and advance reads the setting it just wrote.
• db.client.setFakeTime() / clearFakeTime() use the same setting.

I first pushed a fix that added a sequence (_private_event_seq, with seq columns on subscriptions and steps, and in the dispatch payload). I dropped it: it changed the production schema for a problem that only exists in tests.

Behaviour change (test clock)

Fake time no longer stands still. After clock.set(date) or advance(), time keeps running from that point like real time. Tests that compare exact timestamps after setting the clock need bounds instead (toBeGreaterThanOrEqual). I updated the docs (api/testing.md, crafting-tasks/testing.md) and AGENTS.md.

Tests updated for this change:

• testing.test.ts: exact completedAt and current_setting('pgconductor.fake_now') checks now use bounds; added "fake time keeps running from the time it was set to"
• orchestrator-cleanup.test.ts, window-execution.test.ts, dead-letter.test.ts: exact timestamp checks now use bounds
• batch-processing.test.ts: the batch sleep test advanced exactly 1s past a 1s sleep; it now uses 2s steps
• wait-deadlines.test.ts (from fix(waits): enforce wait deadlines, fail empty races and memoize child timeouts #99): the exact ctx.sleep deadline check now uses bounds

Verification

• New wait-for-event tests, each run with fake time and with real time:
  • waitForEvent receives an event emitted after it
  • subscribe + waitForAny receive an event emitted after subscribe
  • waitForAny prefers the branch stored first
  • an event emitted before the wait, and held back so it is dispatched only after the subscription exists, is ignored
• The fake-time versions failed before the fix (the event was never delivered); the real-time versions passed.
• just lint, just format, pnpm typecheck, pnpm test (612 tests) pass.

Follow-ups / notes

• With real time, the "after the subscription" check still relies on clock_timestamp() being monotonic, so a wall-clock step (NTP) could misorder an event and a subscription. That was already the case before this PR.
• The index idx_custom_event_subscription_wait_match (event_key, created_at, expires_at, id) does not seem to be used by any query (dispatch joins subscriptions by id).
• throttle-debounce "debounce with partition keys" failed once in CI on Postgres 15. It uses real time (no fake clock), and two invokes can fall into different 60s debounce slots. It looks like an existing flake, unrelated to this PR.