@kairos-es/read 0.0.0

package/dist/cjs/ProjectionStore.js

@@ -0,0 +1,233 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.forKey = exports.checkpointKey = exports.ProjectionStoreError = exports.ProjectionId = exports.PartitionId = exports.DEFAULT_PARTITION = exports.CheckpointSuperseded = void 0;
+var _effect = require("effect");
+/**
+ * The name of a read model, as a branded non-empty string.
+ *
+ * Branded rather than a bare `string` for the same reason every other kairos-es
+ * identifier is (`Position`, `Tag`, `EventType`): the projection name and the
+ * partition name are both non-empty strings with identical shape, so an
+ * unbranded pair is trivially transposable at a call site and the mistake would
+ * surface only as a projection silently reading somebody else's checkpoint.
+ * Construct with `ProjectionId.make(...)`.
+ */
+const ProjectionId = exports.ProjectionId = /*#__PURE__*/_effect.Schema.String.pipe(/*#__PURE__*/_effect.Schema.nonEmptyString(), /*#__PURE__*/_effect.Schema.brand('ProjectionId'));
+/**
+ * The partition of a read model's checkpoint, as a branded non-empty string.
+ *
+ * `DEFAULT_PARTITION` is the single value the RUNNER uses, because stream
+ * sharding is deliberately not offered: DCB events carry a tag matrix, so two
+ * shards can own rows for the same tag while each holds its own checkpoint —
+ * both guarded compare-and-sets then succeed and the lost update goes undetected
+ * (the guard arbitrates cursor progress, not row ownership). Nothing on this port
+ * restricts the value, and a `ProjectionStore` must keep every distinct
+ * `(projection, partition)` pair independent — the shared contract suite commits
+ * to a second partition precisely to prove that. The dimension is in the KEY so
+ * that a restricted, opt-in sharding capability — for read models that provably
+ * need no cross-tag ordering and whose every row is owned by one partition value
+ * — could be added later with no migration of the checkpoint's shape or storage.
+ */
+const PartitionId = exports.PartitionId = /*#__PURE__*/_effect.Schema.String.pipe(/*#__PURE__*/_effect.Schema.nonEmptyString(), /*#__PURE__*/_effect.Schema.brand('PartitionId'));
+/** The partition value every runner uses while sharding is cut (ADR-0007). */
+const DEFAULT_PARTITION = exports.DEFAULT_PARTITION = /*#__PURE__*/PartitionId.make('default');
+/**
+ * Build a `CheckpointKey`, defaulting the partition — the constructor nearly
+ * every call site wants, so that the sharding dimension stays in the key shape
+ * without appearing in ordinary wiring code.
+ */
+const checkpointKey = (projection, partition = DEFAULT_PARTITION) => ({
+  projection,
+  partition
+});
+/**
+ * An infrastructure fault from a view store — a connection dropped, a statement
+ * failed, the checkpoint table is missing.
+ *
+ * This is a value on the ERROR channel rather than a defect, which inverts the
+ * store contract's rule (`DcbEventStore` dies on infrastructure faults, ADR-0002)
+ * and does so on purpose: the read side has a supervisor above it, and the
+ * supervisor's whole job is to tell "retry the subscription with backoff" from
+ * "give up and report a stalled projection". A defect carries no such
+ * distinction. `cause` is exact-optional — only set when there is one.
+ */
+exports.checkpointKey = checkpointKey;
+class ProjectionStoreError extends /*#__PURE__*/_effect.Data.TaggedError('ProjectionStoreError') {
+  /**
+   * `reason` again, as the `Error` field that says why — so the fault renders
+   * ITSELF.
+   *
+   * `Data.TaggedError` sets `name` to the tag and leaves `message` empty, so
+   * without this a `ProjectionStoreError` stringifies to `'ProjectionStoreError'`
+   * and the sentence explaining the fault reaches a log line only where something
+   * OUTSIDE the class knows to go and fetch `reason`. With it,
+   * `Error.prototype.toString` yields `'ProjectionStoreError: <reason>'`, and
+   * `String(fault)`, `Cause.pretty` (which reads `message` off anything `instanceof
+   * Error`) and the projection supervisor's `reason` annotation all take it from the
+   * one place it is declared. That matters most for exactly the audience this error
+   * exists for: the supervisor above the read side, whose log line is what an
+   * operator sees when a view store starts refusing to answer.
+   *
+   * ## What filling `message` reaches — and what it deliberately leaves alone
+   *
+   * Not the supervisor's two log lines: `message` is the field `Cause.pretty` reads
+   * off anything `instanceof Error`, so this changes how a `ProjectionStoreError`
+   * prints EVERYWHERE it is reported — a failed fibre's `cause` annotation on all
+   * three shipped loggers, `Effect.logError(message, cause)`, an unhandled
+   * failure's report, and any reporter or test runner that reads `.message`. That
+   * blast radius is the point of doing it on the class instead of at one call site:
+   * one declaration improves every reader at once, and none of them has to know
+   * this class's field names.
+   *
+   * What it does NOT change is the STRUCTURED shape. `Data.Error` overrides
+   * `YieldableError`'s `toJSON` with `{ ...plainArgs, ...this }` — own enumerables
+   * plus the constructor args, and a prototype accessor is neither — so
+   * `JSON.stringify(fault)` and an `Effect.logError(fault)` that JSON-encodes its
+   * object message emit exactly the `reason`/`_tag` they always did. The humane
+   * rendering gains a sentence; the machine-parsed one is untouched.
+   *
+   * A GETTER rather than a second field, so `reason` stays the single declaration
+   * and the two cannot disagree. Safe as a prototype accessor because
+   * `Data.TaggedError`'s constructor is `super(args?.message, …)` followed by
+   * `Object.assign(this, args)` (verified against `effect@3.22`'s `Data.ts`) and
+   * `message` is not among the fields above, so nothing shadows it with an own
+   * property.
+   *
+   * Both mechanics — that accessor safety and the `toJSON` shape above it — are
+   * argued HERE and nowhere else, for every read-side fault that fills the field:
+   * `CheckpointSuperseded` below, `PipelineDied` in `ProjectionRunner.ts` and
+   * `ProjectionStalled` in `superviseOnProgress.ts` each point back rather than
+   * re-derive, and none of the four declares a `message` field for that
+   * `Object.assign` to shadow its accessor with. One version pin to re-verify on an
+   * `effect` bump, not four.
+   */
+  get message() {
+    return this.reason;
+  }
+}
+/**
+ * The guarded compare-and-set lost: the stored checkpoint no longer equals
+ * `expected`, so somebody else advanced this key.
+ *
+ * A tagged ERROR, never a returned outcome value. A returned
+ * `Advanced | Superseded` only rolls the view writes back if the caller remembers
+ * to convert it into a failure, and forgetting is silent corruption — the view
+ * commits while the checkpoint stays put, and the next pass double-applies the
+ * batch. On the error channel the abort is automatic and cannot be ignored.
+ *
+ * It carries the key and the expectation but deliberately NOT the stored
+ * position, mirroring `AppendConditionFailed` (ADR-0002) for the same reason: the
+ * recovery path re-reads the checkpoint, so a carried position would already be
+ * stale by the time anything acted on it, and carrying one would invite exactly
+ * the resume-from-the-conflict-point bug that omitting it prevents.
+ *
+ * Like its sibling `ProjectionStoreError` it fills `message`, from the expectation
+ * it already carries. The getter below says what the field reaches, and also
+ * records the reasoning it REPLACED — this class once left `message` empty on a
+ * ground that could not be true, and that is worth being able to recognise again.
+ */
+exports.ProjectionStoreError = ProjectionStoreError;
+class CheckpointSuperseded extends /*#__PURE__*/_effect.Data.TaggedError('CheckpointSuperseded') {
+  /**
+   * The sentence this class's own first paragraph writes, plus the expectation the
+   * guard turned on — as the `Error` field that says why, so the fault renders
+   * ITSELF.
+   *
+   * `Data.TaggedError` sets `name` to the tag and leaves `message` empty, and
+   * `Cause.pretty` substitutes its own `'An error has occurred'` for an empty one,
+   * so unfilled this fault printed through a `Cause` reads
+   * `'CheckpointSuperseded: An error has occurred'` — a line naming neither a guard,
+   * nor a checkpoint, nor an expectation. Filled, `Error.prototype.toString` yields
+   * the tag followed by the sentence, everywhere the fault is reported. How far that
+   * reaches and what it deliberately leaves alone is set out on
+   * `ProjectionStoreError` above; the argument is identical for every fault that
+   * fills the field, so it is made once, on the one an operator meets most.
+   *
+   * ## Why this field was once left EMPTY, and why that reason was wrong
+   *
+   * Recorded rather than quietly deleted, because a rationale that cannot be true is
+   * worse than a missing one and the shape of this mistake is easy to repeat. The
+   * argument ran: `expected` is a `bigint`; a `bigint` is not JSON-serialisable, and
+   * `effect@3.22`'s `Logger.json` throws outright on one nested in an annotation
+   * value and loses the whole line with it; therefore filling `message` would push
+   * that value class into the field every renderer reaches for first.
+   *
+   * The measurement is true and stays load-bearing. The inference from it is a
+   * category error. `message` is typed `string`, and TEMPLATE INTERPOLATION of a
+   * `bigint` yields its decimal digits, so nothing downstream of this getter can see
+   * a `bigint` through it. The hazard is about the values handed to a LOGGER as
+   * ANNOTATIONS — which is exactly where the projection supervisor applies it, in
+   * `shouldRestart`, whose `position` annotation is `String(stored)` — and it says
+   * nothing whatever about a string rendered from one. Nor was the substitute the
+   * old argument offered a substitute: the supervisor's `position` annotation is the
+   * progress signal it RE-READ after the failure, not this expectation. Meanwhile
+   * the cost of the omission was real and was being paid on every `Cause.pretty` of
+   * a superseded commit.
+   *
+   * What the correction does NOT touch is the other ground this class states, which
+   * stands unchanged: no STORED position is carried, because the recovery path
+   * re-reads and a carried one would already be stale. That decision is about a
+   * RECOVERY INPUT — what a caller might wrongly resume from. This getter is a
+   * human-readable label over a field the class already carries, and `expected` is
+   * exactly as stale in the label as it is in the payload: a reader is being told
+   * what the guard expected, never what to resume from.
+   *
+   * A GETTER rather than a `message` field, so `expected` stays the single
+   * declaration. Why a prototype accessor is safe here, and why a structured log of
+   * this fault still emits the same `key`/`expected`/`_tag` it always did, are set
+   * out once for all four of these getters on `ProjectionStoreError` above.
+   */
+  get message() {
+    return `the stored checkpoint no longer equals the expectation (${this.expected})`;
+  }
+}
+/**
+ * Bind a `ProjectionStore` to one `CheckpointKey`, producing the surface a read
+ * model is actually given.
+ *
+ * A FREE FUNCTION rather than a method on `ProjectionStore`, decided that way for
+ * two reasons beyond the obvious one (a single implementation, which every present
+ * and future backend then gets for nothing rather than re-deriving — and could
+ * re-derive WRONGLY, since a `forKey` that closed over the wrong key would be
+ * invisible until two read models started trading cursors).
+ *
+ * The sharper reason is DECORATORS. Wrapping a store is an established move here —
+ * a test's never-committing view store, a durability override — and every one of
+ * them is written `{ ...inner, commit: … }`. Were `forKey` a method, that spread
+ * would copy the INNER store's own `forKey`, whose closure still points at the
+ * inner store, so `forKey(decorated, key)` would silently route straight past the
+ * decoration. As a free function it reads `store.commit` off the value it is
+ * handed, so a decorated store decorates.
+ *
+ * The second reason is the port's implementation burden: `ProjectionStore` stays
+ * three methods, which is what a backend has to get right, and no implementation
+ * can drift on a member that is pure derivation.
+ *
+ * `Effect.suspend` on the two no-argument members preserves the port's per-call
+ * construction timing exactly: an implementation is entitled to build its effect
+ * when its method is called (the SQL store binds parameters there), so suspending
+ * keeps `yield* view.readCheckpoint` indistinguishable from
+ * `yield* store.readCheckpoint(key)` rather than freezing one construction for the
+ * store's lifetime.
+ */
+exports.CheckpointSuperseded = CheckpointSuperseded;
+const forKey = (store, key) => ({
+  key,
+  durability: store.durability,
+  readCheckpoint: _effect.Effect.suspend(() => store.readCheckpoint(key)),
+  // Spelled out field by field rather than `{ key, ...args }`: the bound key is
+  // then the ONLY key in the call, which is the whole claim this façade makes, and
+  // no spread order or stray property can put a different one there.
+  commit: args => store.commit({
+    key,
+    expected: args.expected,
+    next: args.next,
+    viewWrites: args.viewWrites
+  }),
+  resetCheckpoint: _effect.Effect.suspend(() => store.resetCheckpoint(key))
+});
+exports.forKey = forKey;
+//# sourceMappingURL=ProjectionStore.js.map

package/dist/cjs/ProjectionStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectionStore.js","names":["_effect","require","ProjectionId","exports","Schema","String","pipe","nonEmptyString","brand","PartitionId","DEFAULT_PARTITION","make","checkpointKey","projection","partition","ProjectionStoreError","Data","TaggedError","message","reason","CheckpointSuperseded","expected","forKey","store","key","durability","readCheckpoint","Effect","suspend","commit","args","next","viewWrites","resetCheckpoint"],"sources":["../../src/ProjectionStore.ts"],"sourcesContent":[null],"mappings":";;;;;;AAsCA,IAAAA,OAAA,GAAAC,OAAA;AAEA;;;;;;;;;;AAUO,MAAMC,YAAY,GAAAC,OAAA,CAAAD,YAAA,gBAAGE,cAAM,CAACC,MAAM,CAACC,IAAI,cAC5CF,cAAM,CAACG,cAAc,EAAE,eACvBH,cAAM,CAACI,KAAK,CAAC,cAAc,CAAC,CAC7B;AAGD;;;;;;;;;;;;;;;AAeO,MAAMC,WAAW,GAAAN,OAAA,CAAAM,WAAA,gBAAGL,cAAM,CAACC,MAAM,CAACC,IAAI,cAC3CF,cAAM,CAACG,cAAc,EAAE,eACvBH,cAAM,CAACI,KAAK,CAAC,aAAa,CAAC,CAC5B;AAGD;AACO,MAAME,iBAAiB,GAAAP,OAAA,CAAAO,iBAAA,gBAAgBD,WAAW,CAACE,IAAI,CAAC,SAAS,CAAC;AA8BzE;;;;;AAKO,MAAMC,aAAa,GAAGA,CAC3BC,UAAwB,EACxBC,SAAA,GAAyBJ,iBAAiB,MACvB;EAAEG,UAAU;EAAEC;AAAS,CAAE,CAAC;AAc/C;;;;;;;;;;;AAAAX,OAAA,CAAAS,aAAA,GAAAA,aAAA;AAWM,MAAOG,oBAAqB,sBAAQC,YAAI,CAACC,WAAW,CACxD,sBAAsB,CAItB;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDA,IAAaC,OAAOA,CAAA;IAClB,OAAO,IAAI,CAACC,MAAM;EACpB;;AAGF;;;;;;;;;;;;;;;;;;;;;AAAAhB,OAAA,CAAAY,oBAAA,GAAAA,oBAAA;AAqBM,MAAOK,oBAAqB,sBAAQJ,YAAI,CAACC,WAAW,CACxD,sBAAsB,CAItB;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiDA,IAAaC,OAAOA,CAAA;IAClB,OAAO,2DAA2D,IAAI,CAACG,QAAQ,GAAG;EACpF;;AAsMF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAAlB,OAAA,CAAAiB,oBAAA,GAAAA,oBAAA;AA6BO,MAAME,MAAM,GAAGA,CACpBC,KAAsB,EACtBC,GAAkB,MACQ;EAC1BA,GAAG;EACHC,UAAU,EAAEF,KAAK,CAACE,UAAU;EAC5BC,cAAc,EAAEC,cAAM,CAACC,OAAO,CAAC,MAAML,KAAK,CAACG,cAAc,CAACF,GAAG,CAAC,CAAC;EAC/D;EACA;EACA;EACAK,MAAM,EAASC,IAId,IACCP,KAAK,CAACM,MAAM,CAAC;IACXL,GAAG;IACHH,QAAQ,EAAES,IAAI,CAACT,QAAQ;IACvBU,IAAI,EAAED,IAAI,CAACC,IAAI;IACfC,UAAU,EAAEF,IAAI,CAACE;GAClB,CAAC;EACJC,eAAe,EAAEN,cAAM,CAACC,OAAO,CAAC,MAAML,KAAK,CAACU,eAAe,CAACT,GAAG,CAAC;CACjE,CAAC;AAAArB,OAAA,CAAAmB,MAAA,GAAAA,MAAA","ignoreList":[]}

package/dist/cjs/foldIntoRef.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.foldIntoRef = void 0;
+var _core = require("@kairos-es/core");
+var _effect = require("effect");
+/**
+ * Build the per-batch `apply` for a read model whose whole view is `view`.
+ *
+ * `slices` must be the SAME record the read model's subscription query is derived
+ * from, so the events the runner delivers are exactly the events these folds
+ * expect; `composeProjections` gates each slice on its own query before
+ * dispatching, so a slice never sees an event it did not ask for.
+ *
+ * The returned effect is infallible (`E = never`) and requirement-free
+ * (`R = never`), which is the whole point: handed to `ProjectionStore.commit` as
+ * `viewWrites`, it adds nothing to the commit's error or requirement channels, so
+ * the ONLY way that commit can fail is the checkpoint guard.
+ */
+const foldIntoRef = (slices, view) => {
+  // Composed ONCE, at wiring time, not per batch: the composition is pure and
+  // derives the merged query and the dispatch table, so rebuilding it on every
+  // batch would only burn allocations.
+  const composite = (0, _core.composeProjections)(slices);
+  return batch =>
+  // One `Ref.update`, folding the whole batch inside the update function. Not a
+  // fold of `Ref.update`s: N updates are N observable states, so an interrupt or
+  // a concurrent reader could see the view half-way through a batch, and on a
+  // lost checkpoint guard a partly-applied batch would already be visible. One
+  // update makes the batch atomic in the same sense the checkpoint advance is.
+  _effect.Ref.update(view, state => batch.reduce((acc, decoded) => composite.evolve(acc, decoded), state));
+};
+exports.foldIntoRef = foldIntoRef;
+//# sourceMappingURL=foldIntoRef.js.map

package/dist/cjs/foldIntoRef.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"foldIntoRef.js","names":["_core","require","_effect","foldIntoRef","slices","view","composite","composeProjections","batch","Ref","update","state","reduce","acc","decoded","evolve","exports"],"sources":["../../src/foldIntoRef.ts"],"sourcesContent":[null],"mappings":";;;;;;AAqBA,IAAAA,KAAA,GAAAC,OAAA;AAMA,IAAAC,OAAA,GAAAD,OAAA;AAEA;;;;;;;;;;;;;AAaO,MAAME,WAAW,GAAGA,CACzBC,MAAS,EACTC,IAAgC,KAGN;EAC1B;EACA;EACA;EACA,MAAMC,SAAS,GAAG,IAAAC,wBAAkB,EAACH,MAAM,CAAC;EAE5C,OAAQI,KAAK;EACX;EACA;EACA;EACA;EACA;EACAC,WAAG,CAACC,MAAM,CAACL,IAAI,EAAGM,KAAK,IACrBH,KAAK,CAACI,MAAM,CAAC,CAACC,GAAG,EAAEC,OAAO,KAAKR,SAAS,CAACS,MAAM,CAACF,GAAG,EAAEC,OAAO,CAAC,EAAEH,KAAK,CAAC,CACtE;AACL,CAAC;AAAAK,OAAA,CAAAb,WAAA,GAAAA,WAAA","ignoreList":[]}

package/dist/cjs/inMemoryProjectionStore.js

@@ -0,0 +1,138 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeInMemoryProjectionStore = void 0;
+var _core = require("@kairos-es/core");
+var _effect = require("effect");
+var _ProjectionStore = require("./ProjectionStore.js");
+/**
+ * The in-memory `ProjectionStore`: a `Ref` of checkpoints plus the exclusive
+ * critical section that makes the guarded advance atomic.
+ *
+ * This is NOT merely a test double. It is load-bearing for the in-process
+ * supervision restart, where the subscription dies (the event store's poll retry
+ * exhausted) but the process and its in-memory view survive: the restart must
+ * resume from the checkpoint rather than replay from `ORIGIN` into an
+ * already-populated view, and an ephemeral checkpoint stored beside an ephemeral
+ * view is exactly what makes that resume correct. It is also the whole
+ * all-in-memory permutation — tests, prototypes, client-side use — and the
+ * durable-log-with-in-memory-view mode's view store (dev, admin and in-flux
+ * slices, rebuilt from `ORIGIN` each boot).
+ *
+ * A factory `Effect`, deliberately not a `Layer`: the view store is selected PER
+ * MATERIALISATION — so a slice may start in memory and GRADUATE to Postgres, which
+ * `ReadModel.store` owns the claim about — and it is therefore a value handed to a
+ * read model, not a context tag that one store could claim process-wide.
+ *
+ * That selection is a FLOOR rather than a ceiling, and this store is on the common
+ * side of it: the two variants above are also available AT ONCE, an in-memory
+ * materialisation of a slice record beside a durable one from the SAME record —
+ * a Postgres table somebody queries with SQL, and an in-process view of the same
+ * slices holding one aggregate's hot figures with no round trip to reach them. That
+ * is `runProjections`, and every call of this factory is an independent store, so
+ * two materialisations wired that way share nothing but their slices. What they do
+ * not share is their FOLDS: each `apply` re-expresses one, so agreement between
+ * their figures is something a test demonstrates rather than something the wiring
+ * gives.
+ *
+ * The critical-section design mirrors `core`'s in-memory event store: one
+ * `Effect.makeSemaphore(1)` serialises the guarded advance, exactly as that store
+ * serialises check-then-append, and for the same reason — the check and the write
+ * must not be separable, and that atomicity IS the concurrency guarantee.
+ */
+
+/**
+ * Flatten a `CheckpointKey` into a map key.
+ *
+ * The separator is NUL. A `ProjectionId`/`PartitionId` is any non-empty string,
+ * so a printable separator (`:`, `/`, `|`) could be forged inside either half and
+ * two distinct keys would collide onto one checkpoint — one read model silently
+ * reading and advancing another's cursor. NUL cannot appear in a name any human
+ * or config file produces, so the flattening stays injective in practice without
+ * narrowing the id grammar.
+ *
+ * The other route to that same failure is a WIRING rather than a forged id: two
+ * materialisations handed this one store under equal keys, which would be two
+ * runners over one cursor. That one is caught before anything is forked, by the
+ * set-level collision rung of the construction gate in `projectionWiringFault.ts`,
+ * and its sentence names the two fixes. Nothing here can catch it — a store sees
+ * keys, never who is holding it.
+ */
+const mapKey = key => `${key.projection}\u0000${key.partition}`;
+/**
+ * Build an in-memory `ProjectionStore`.
+ *
+ * Every call is an independent store with its own checkpoints and its own
+ * semaphore, so two read models wired to two calls of this factory cannot
+ * interfere — and a test needing a fresh store just calls it again.
+ */
+const makeInMemoryProjectionStore = exports.makeInMemoryProjectionStore = /*#__PURE__*/_effect.Effect.gen(function* () {
+  const checkpoints = yield* _effect.Ref.make(new Map());
+  const mutex = yield* _effect.Effect.makeSemaphore(1);
+  /** The stored position, or `ORIGIN` for a key never committed. */
+  const positionOf = (stored, key) => stored.get(mapKey(key)) ?? _core.ORIGIN;
+  const readCheckpoint = key =>
+  // No lock needed: `Ref.get` is a single atomic read, and the guard that
+  // actually protects a commit is re-checked INSIDE the critical section
+  // below — a value read here is only ever an expectation to be guarded on,
+  // never a licence to write.
+  _effect.Effect.map(_effect.Ref.get(checkpoints), stored => positionOf(stored, key));
+  const commit = args =>
+  // The permit is acquired INTERRUPTIBLY (a fibre waiting its turn can still
+  // be torn down), and only the section itself is uninterruptible.
+  mutex.withPermits(1)(_effect.Effect.uninterruptible(_effect.Effect.gen(function* () {
+    const stored = positionOf(yield* _effect.Ref.get(checkpoints), args.key);
+    // The guard is checked FIRST, before the view writes run. There is no
+    // transaction here to roll anything back, so the ONLY way a lost
+    // guard can leave the view untouched is to lose before touching it.
+    // Check-then-act is safe despite `viewWrites` suspending in between,
+    // because the section is exclusive: no other fibre can observe or
+    // advance this checkpoint until the permit is released, so the value
+    // read here cannot go stale within the section.
+    //
+    // On a lost guard `viewWrites` was NEVER RUN, which is observably
+    // identical to the SQL store's rollback — the port's abort contract
+    // is met by omission rather than by undo. (The one case omission
+    // cannot cover is a `viewWrites` that fails part-way, which is why
+    // the port requires a non-transactional store's per-batch write to be
+    // a single atomic effect; see `ProjectionStore` and `foldIntoRef`.)
+    if (stored !== args.expected) {
+      return yield* new _ProjectionStore.CheckpointSuperseded({
+        key: args.key,
+        expected: args.expected
+      });
+    }
+    yield* args.viewWrites;
+    // Uninterruptibility earns its keep here: an interrupt landing
+    // between the view writes and this advance would commit the batch's
+    // effects with the cursor left behind, and the next run would apply
+    // the same batch a second time. Copy-on-write so a concurrent reader
+    // holding the previous map sees a consistent snapshot.
+    yield* _effect.Ref.update(checkpoints, current => new Map(current).set(mapKey(args.key), args.next));
+  })));
+  const resetCheckpoint = key =>
+  // Under the same permit as `commit`, so a reset can never interleave with a
+  // guarded advance and leave the map half-updated relative to the view.
+  // Deleting rather than storing `ORIGIN` keeps "never committed" and "reset"
+  // one state, which is what the port promises the read-back is.
+  mutex.withPermits(1)(_effect.Ref.update(checkpoints, current => {
+    const next = new Map(current);
+    next.delete(mapKey(key));
+    return next;
+  }));
+  // Annotated at the definition site rather than only through the exported
+  // signature, per the rule on `ProjectionStore` itself.
+  const store = {
+    // Dies with the process, which is the R2 input: an ephemeral view is legal
+    // over either an ephemeral or a durable log (it just re-catches-up), so
+    // this value never trips the durability-ordering check.
+    durability: 'ephemeral',
+    readCheckpoint,
+    commit,
+    resetCheckpoint
+  };
+  return store;
+});
+//# sourceMappingURL=inMemoryProjectionStore.js.map

package/dist/cjs/inMemoryProjectionStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inMemoryProjectionStore.js","names":["_core","require","_effect","_ProjectionStore","mapKey","key","projection","partition","makeInMemoryProjectionStore","exports","Effect","gen","checkpoints","Ref","make","Map","mutex","makeSemaphore","positionOf","stored","get","ORIGIN","readCheckpoint","map","commit","args","withPermits","uninterruptible","expected","CheckpointSuperseded","viewWrites","update","current","set","next","resetCheckpoint","delete","store","durability"],"sources":["../../src/inMemoryProjectionStore.ts"],"sourcesContent":[null],"mappings":";;;;;;AAmCA,IAAAA,KAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAEA,IAAAE,gBAAA,GAAAF,OAAA;AAtCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA;;;;;;;;;;;;;;;;;AAiBA,MAAMG,MAAM,GAAIC,GAAkB,IAChC,GAAGA,GAAG,CAACC,UAAU,SAASD,GAAG,CAACE,SAAS,EAAE;AAE3C;;;;;;;AAOO,MAAMC,2BAA2B,GAAAC,OAAA,CAAAD,2BAAA,gBACtCE,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,MAAMC,WAAW,GAAG,OAAOC,WAAG,CAACC,IAAI,CACjC,IAAIC,GAAG,EAAE,CACV;EACD,MAAMC,KAAK,GAAG,OAAON,cAAM,CAACO,aAAa,CAAC,CAAC,CAAC;EAE5C;EACA,MAAMC,UAAU,GAAGA,CACjBC,MAAqC,EACrCd,GAAkB,KACLc,MAAM,CAACC,GAAG,CAAChB,MAAM,CAACC,GAAG,CAAC,CAAC,IAAIgB,YAAM;EAEhD,MAAMC,cAAc,GAClBjB,GAAkB;EAElB;EACA;EACA;EACA;EACAK,cAAM,CAACa,GAAG,CAACV,WAAG,CAACO,GAAG,CAACR,WAAW,CAAC,EAAGO,MAAM,IAAKD,UAAU,CAACC,MAAM,EAAEd,GAAG,CAAC,CAAC;EAEvE,MAAMmB,MAAM,GAAUC,IAKrB;EACC;EACA;EACAT,KAAK,CAACU,WAAW,CAAC,CAAC,CAAC,CAClBhB,cAAM,CAACiB,eAAe,CACpBjB,cAAM,CAACC,GAAG,CAAC,aAAS;IAClB,MAAMQ,MAAM,GAAGD,UAAU,CAAC,OAAOL,WAAG,CAACO,GAAG,CAACR,WAAW,CAAC,EAAEa,IAAI,CAACpB,GAAG,CAAC;IAEhE;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,IAAIc,MAAM,KAAKM,IAAI,CAACG,QAAQ,EAAE;MAC5B,OAAO,OAAO,IAAIC,qCAAoB,CAAC;QACrCxB,GAAG,EAAEoB,IAAI,CAACpB,GAAG;QACbuB,QAAQ,EAAEH,IAAI,CAACG;OAChB,CAAC;IACJ;IAEA,OAAOH,IAAI,CAACK,UAAU;IAEtB;IACA;IACA;IACA;IACA;IACA,OAAOjB,WAAG,CAACkB,MAAM,CAACnB,WAAW,EAAGoB,OAAO,IACrC,IAAIjB,GAAG,CAACiB,OAAO,CAAC,CAACC,GAAG,CAAC7B,MAAM,CAACqB,IAAI,CAACpB,GAAG,CAAC,EAAEoB,IAAI,CAACS,IAAI,CAAC,CAClD;EACH,CAAC,CAAC,CACH,CACF;EAEH,MAAMC,eAAe,GAAI9B,GAAkB;EACzC;EACA;EACA;EACA;EACAW,KAAK,CAACU,WAAW,CAAC,CAAC,CAAC,CAClBb,WAAG,CAACkB,MAAM,CAACnB,WAAW,EAAGoB,OAAO,IAAI;IAClC,MAAME,IAAI,GAAG,IAAInB,GAAG,CAACiB,OAAO,CAAC;IAC7BE,IAAI,CAACE,MAAM,CAAChC,MAAM,CAACC,GAAG,CAAC,CAAC;IACxB,OAAO6B,IAAI;EACb,CAAC,CAAC,CACH;EAEH;EACA;EACA,MAAMG,KAAK,GAAoB;IAC7B;IACA;IACA;IACAC,UAAU,EAAE,WAAW;IACvBhB,cAAc;IACdE,MAAM;IACNW;GACD;EACD,OAAOE,KAAK;AACd,CAAC,CAAC","ignoreList":[]}

package/dist/cjs/index.js

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BatchSize", {
+  enumerable: true,
+  get: function () {
+    return _ProjectionRunner.BatchSize;
+  }
+});
+Object.defineProperty(exports, "CheckpointSuperseded", {
+  enumerable: true,
+  get: function () {
+    return _ProjectionStore.CheckpointSuperseded;
+  }
+});
+Object.defineProperty(exports, "DEFAULT_PARTITION", {
+  enumerable: true,
+  get: function () {
+    return _ProjectionStore.DEFAULT_PARTITION;
+  }
+});
+Object.defineProperty(exports, "DurableEventLog", {
+  enumerable: true,
+  get: function () {
+    return _EventLogDurability.DurableEventLog;
+  }
+});
+Object.defineProperty(exports, "EphemeralEventLog", {
+  enumerable: true,
+  get: function () {
+    return _EventLogDurability.EphemeralEventLog;
+  }
+});
+Object.defineProperty(exports, "EventLogDurability", {
+  enumerable: true,
+  get: function () {
+    return _EventLogDurability.EventLogDurability;
+  }
+});
+Object.defineProperty(exports, "MaxNoProgressRestarts", {
+  enumerable: true,
+  get: function () {
+    return _superviseOnProgress.MaxNoProgressRestarts;
+  }
+});
+Object.defineProperty(exports, "PartitionId", {
+  enumerable: true,
+  get: function () {
+    return _ProjectionStore.PartitionId;
+  }
+});
+Object.defineProperty(exports, "PipelineDied", {
+  enumerable: true,
+  get: function () {
+    return _ProjectionRunner.PipelineDied;
+  }
+});
+Object.defineProperty(exports, "ProjectionId", {
+  enumerable: true,
+  get: function () {
+    return _ProjectionStore.ProjectionId;
+  }
+});
+Object.defineProperty(exports, "ProjectionStalled", {
+  enumerable: true,
+  get: function () {
+    return _superviseOnProgress.ProjectionStalled;
+  }
+});
+Object.defineProperty(exports, "ProjectionStoreError", {
+  enumerable: true,
+  get: function () {
+    return _ProjectionStore.ProjectionStoreError;
+  }
+});
+Object.defineProperty(exports, "checkpointKey", {
+  enumerable: true,
+  get: function () {
+    return _ProjectionStore.checkpointKey;
+  }
+});
+Object.defineProperty(exports, "foldIntoRef", {
+  enumerable: true,
+  get: function () {
+    return _foldIntoRef.foldIntoRef;
+  }
+});
+Object.defineProperty(exports, "forKey", {
+  enumerable: true,
+  get: function () {
+    return _ProjectionStore.forKey;
+  }
+});
+Object.defineProperty(exports, "makeInMemoryProjectionStore", {
+  enumerable: true,
+  get: function () {
+    return _inMemoryProjectionStore.makeInMemoryProjectionStore;
+  }
+});
+Object.defineProperty(exports, "projectionLayer", {
+  enumerable: true,
+  get: function () {
+    return _runProjection.projectionLayer;
+  }
+});
+Object.defineProperty(exports, "runProjection", {
+  enumerable: true,
+  get: function () {
+    return _runProjection.runProjection;
+  }
+});
+Object.defineProperty(exports, "runProjections", {
+  enumerable: true,
+  get: function () {
+    return _runProjections.runProjections;
+  }
+});
+var _EventLogDurability = require("./EventLogDurability.js");
+var _foldIntoRef = require("./foldIntoRef.js");
+var _inMemoryProjectionStore = require("./inMemoryProjectionStore.js");
+var _ProjectionRunner = require("./ProjectionRunner.js");
+var _ProjectionStore = require("./ProjectionStore.js");
+var _runProjection = require("./runProjection.js");
+var _runProjections = require("./runProjections.js");
+var _superviseOnProgress = require("./superviseOnProgress.js");
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_EventLogDurability","require","_foldIntoRef","_inMemoryProjectionStore","_ProjectionRunner","_ProjectionStore","_runProjection","_runProjections","_superviseOnProgress"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgLA,IAAAA,mBAAA,GAAAC,OAAA;AAKA,IAAAC,YAAA,GAAAD,OAAA;AACA,IAAAE,wBAAA,GAAAF,OAAA;AACA,IAAAG,iBAAA,GAAAH,OAAA;AAOA,IAAAI,gBAAA,GAAAJ,OAAA;AAaA,IAAAK,cAAA,GAAAL,OAAA;AAKA,IAAAM,eAAA,GAAAN,OAAA;AAKA,IAAAO,oBAAA,GAAAP,OAAA","ignoreList":[]}