experimental-a2 0.2.0 → 0.3.0

package/dist/log-sqlite.js

@@ -1,7 +1,7 @@
 import { t as A2Error } from "./errors-BJRMd-h6.js";
 import { t as idempotentReplay } from "./idempotent-replay-BMyHrP0L.js";
 import { n as SYSTEM_CLOCK, t as RANDOM_IDS } from "./log-yJbXUf72.js";
-import { t as pollingStream } from "./log-polling-6COoN60V.js";
+import { n as pollingStream } from "./log-polling-DZ1MiKLg.js";
 import { mkdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";

package/dist/recovery-vercel.js

@@ -1,4 +1,4 @@
-import { i as serverInternals, t as DRAIN_TIMINGS } from "./internal-D6wNxTck.js";
+import { a as serverInternals, t as DRAIN_TIMINGS } from "./internal-gCd5qMry.js";
 import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
 import { n as SYSTEM_CLOCK } from "./log-yJbXUf72.js";
 //#region src/recovery-vercel.ts

package/dist/{server-DJgD2YWP.js → server-BcLa4RFL.js}

@@ -1,6 +1,6 @@
 import { n as validateSync } from "./validate-XKT4FSNn.js";
 import { n as asLogUnavailable, t as A2Error } from "./errors-BJRMd-h6.js";
-import { i as serverInternals, t as DRAIN_TIMINGS } from "./internal-D6wNxTck.js";
+import { a as serverInternals, t as DRAIN_TIMINGS } from "./internal-gCd5qMry.js";
 import { n as serverInspection } from "./inspection-E7qbD0Xj.js";
 import { t as retryableLazy } from "./retryable-lazy-DZWmHpii.js";
 //#region src/deterministic-id.ts

package/dist/server.js

@@ -1,2 +1,2 @@
-import { t as createServer } from "./server-DJgD2YWP.js";
+import { t as createServer } from "./server-BcLa4RFL.js";
 export { createServer };

package/docs/01-quickstart.mdx

@@ -20,8 +20,7 @@ npm i experimental-a2 zod
 A contract is a name plus the events it understands: each key an event
 name, each value a schema. Zod here, though any
 [Standard Schema](https://standardschema.dev) validator works, and
-that's the entire upfront declaration. No state list, no transition
-table.
+that's the contract's complete declaration.
 
 ```ts server/orders.ts
 import { z } from 'zod'

package/docs/concepts/01-contracts.mdx

@@ -41,10 +41,9 @@ schemas and their type helpers. The server implements it,
 [reducers](/concepts/state) derive from it, and the browser types its pushes
 off it. One artifact, shared by every side of the wire.
 
-And that's the entire declaration. No states, no transition table. What
-happens on each event is defined where the contract is served; what
-things look like right now is defined by [reducers](/concepts/state). The
-contract just names the vocabulary.
+The contract names the complete vocabulary. What happens on each event is
+defined where the contract is served. [Reducers](/concepts/state) define what
+things look like right now.
 
 :::tip
 Events are facts, so name them in past tense: `created`, `expired`,

package/docs/concepts/03-durability.mdx

@@ -43,10 +43,9 @@ processed marker says what finished. The watchdog says when to look again.
 +-------------+   +-------------------+
 ```
 
-A queue message names a session. It carries no event index or continuation
-state. Every wakeup runs the same drain, and the log decides what remains.
-Recovery and explicit `server.drain()` inspect the full session. Reads never
-dispatch handlers.
+A queue message identifies a session. Every wakeup runs the same drain, and
+the log decides what remains. Recovery and explicit `server.drain()` inspect
+the full session. Reads never dispatch handlers.
 
 :::note[Recovery is not an event]
 A2 does not append `recovered` or `continued`. Recovery retries the same event.
@@ -239,11 +238,9 @@ Four eight-second handlers returned one after another do not fit together in a
 | t29 | Handler 3 finishes; handler 4 starts | Events 1 through 3 processed |
 | t37 | Handler 4 finishes | Session settled |
 
-The retry restarts handler 3; it does not resume its old call.
-
-One handler that always exceeds a fresh invocation cannot finish this way. A2
-cannot checkpoint arbitrary async code. Split the work into smaller events or
-increase the function duration.
+The retry starts handler 3 again from its entry point. Keep each handler within
+a fresh invocation. Split longer work into smaller events or increase the
+function duration.
 
 ## Crash around a returned batch
 

package/docs/guides/01-timers.mdx

@@ -1,17 +1,12 @@
 ---
 title: Timers and delays
-description: There is no sleep(). A delayed action is an event, delivered later, by anything that can make an HTTP call.
+description: A delayed action is an event delivered later by anything that can make an HTTP call.
 ---
 
-## There is no `sleep()`
+## Schedule delayed events
 
-Workflow engines let you sleep inside a function, then perform heroics to
-make that survive a serverless platform. A2 doesn't. If something should
-happen in five days, then in five days, something should append an event.
-That's scheduling.
-
-The scheduled thing is data (a session id and an event), not a suspended
-function. No closure has to survive the gap.
+If something should happen in five days, schedule an HTTP call that appends
+the event then. The scheduler stores the session id and event until delivery.
 
 ## Schedule an event
 

package/docs/guides/05-production.mdx

@@ -40,6 +40,19 @@ box; transaction-mode poolers included, which is exactly why polling
 is the default. `pg` is an optional peer dependency; pass
 `connectionString`, or inject your own pool as `client`.
 
+Prefer Redis? `redis({ url })` from `experimental-a2/log-redis` stores each
+session as a Redis Stream and streams push-natively: writes to watched
+sessions publish a disposable wake-up (sessions nobody watches cost no extra
+command), one shared subscriber connection per process serves every connected
+viewer, and a safety re-read covers a lost wake-up within ten seconds.
+Connections scale with your processes, not with your audience.
+`ioredis` is an optional peer dependency; pass `url`, or inject a client.
+Works on single instances and non-cluster providers such as Upstash, where
+durability is on by default. When only a REST API is available,
+`redisHttp({ url, token })` from `experimental-a2/log-redis-http` speaks the
+same storage over `fetch`, holds no connections at all, and polls on the same
+adaptive cadence as Postgres.
+
 This configures storage for A2's session logs. It does not connect A2 to your
 application tables or make them part of the append transaction. See
 [A2 and your database](/guides/application-data) for that boundary.
@@ -115,8 +128,7 @@ so they do not create an independent stream of watchdog callbacks.
 Events appended or returned by handlers ride their current execution window
 and add no recovery operation of their own.
 
-No cron, no sweep, no notification bookkeeping. The queue message is
-the recovery state, and the log is the only thing it consults.
+The queue message carries the recovery state, and recovery consults the log.
 
 ### Dispatch in a fresh invocation
 

package/docs/index.mdx

@@ -14,8 +14,8 @@ Handlers react to them, and usually return the next one. The browser follows
 the same log and folds the same state as the server. That's the whole model;
 the rest of this page is it happening.
 
-There is no declared state machine. Events record facts, reducers compute the
-current view, and handlers perform the reactions.
+Events record facts, reducers compute the current view, and handlers perform
+the reactions.
 
 ## Define a contract
 
@@ -39,8 +39,7 @@ export const orders = a2.contract({
 
 ## React to events
 
-Handlers are plain async functions: no determinism rules, no replay, no
-wrappers around side effects. Each one reacts to a fact and usually
+Handlers are plain async functions. Each one reacts to a fact and usually
 returns the next one.
 
 ```ts server/orders.ts
@@ -178,32 +177,6 @@ twenty lines; [Live UI](/guides/react) wires it end to end.
 
 ## FAQ
 
-<details>
-<summary>Why not a workflow engine?</summary>
-
-Workflow engines replay your code from the top on every wake-up. So the
-code has to be deterministic, so every side effect gets wrapped in a step
-function, and `sleep()` becomes something magical instead of something
-you'd never call in a serverless function.
-
-A2's answer is older and simpler: write everything down. Every meaningful
-thing that happens is an event in a log. Handlers are stateless functions
-that react to one event at a time. State isn't stored. It's computed, by
-folding over the log whenever you need it. There's no orchestrator to
-operate.
-
-</details>
-
-<details>
-<summary>Isn't this just event sourcing?</summary>
-
-It's the useful core of it. A log of facts, state as a fold: the idea is
-decades old, and it's a good one. A2 cuts the ceremony that made it a big
-commitment. No command bus, no projection cluster, no upcasting
-framework. A contract, a log, handlers, reducers.
-
-</details>
-
 <details>
 <summary>Can I use A2 without handlers?</summary>
 
@@ -217,12 +190,11 @@ See [Events without handlers](/concepts/handlers#events-without-handlers).
 </details>
 
 <details>
-<summary>How do I wait five days?</summary>
+<summary>How do I schedule an event for later?</summary>
 
-You don't sleep. You schedule an event. Anything that can deliver an
-HTTP call later (QStash, a cron, a payment provider's webhook) hits a
-route that appends. The scheduled thing is data, a session id plus an
-event, not a suspended function. See [Timers](/guides/timers).
+Anything that can deliver an HTTP call later (QStash, a cron, a payment
+provider's webhook) can hit a route that appends. Schedule the session id and
+event as the request payload. See [Timers](/guides/timers).
 
 </details>
 

package/docs/reference/01-api.mdx

@@ -860,6 +860,7 @@ dashboard returns 501 for those logs.
 | `experimental-a2/http`            | route-side transport helpers       | none            |
 | `experimental-a2/log-postgres`    | `postgres`: Postgres log backend   | `pg` (or inject a client) |
 | `experimental-a2/log-redis`       | `redis`: Redis Streams log backend, push-native streaming | `ioredis` (or inject a client) |
+| `experimental-a2/log-redis-http`  | `redisHttp`: the same Redis log over provider REST APIs (Upstash) | none |
 | `experimental-a2/log-sqlite`      | SQLite log backend                 | none            |
 | `experimental-a2/log-memory`      | in-memory log backend              | none            |
 | `experimental-a2/recovery-vercel` | `vercelQueues` recovery            | `@vercel/queue` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "experimental-a2",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Durable sync and reactions for things with a lifecycle: one event log, derived state, and live client per session.",
   "license": "MIT",
   "type": "module",
@@ -40,6 +40,7 @@
     "./log-sqlite": "./dist/log-sqlite.js",
     "./log-postgres": "./dist/log-postgres.js",
     "./log-redis": "./dist/log-redis.js",
+    "./log-redis-http": "./dist/log-redis-http.js",
     "./recovery-vercel": "./dist/recovery-vercel.js",
     "./cache-indexeddb": "./dist/cache-indexeddb.js",
     "./otel": "./dist/otel.js",