@kairos-es/read 0.0.0

package/dist/esm/ProjectionRunner.js

@@ -0,0 +1,468 @@
+import { decodeSlices } from '@kairos-es/codec';
+import { composeProjections, DcbEventStore } from '@kairos-es/core';
+import { Array as Arr, Chunk, Data, Effect, Ref, Schema, Stream } from 'effect';
+import { EventLogDurability } from "./EventLogDurability.js";
+import { projectionWiringFault } from "./projectionWiringFault.js";
+import { DEFAULT_RESTART_MAX_DELAY, DEFAULT_RESTART_MIN_DELAY, DEFAULT_RESTART_RESET_AFTER, superviseOnProgress } from "./superviseOnProgress.js";
+/**
+ * Maximum events per commit: a branded POSITIVE integer.
+ *
+ * Branded because `batchSize` is the tuning figure whose invalid values are
+ * absorbed most quietly. `Stream.groupedWithin(0, window)` does not throw and
+ * does not merely under-batch: it emits EMPTY chunks in a tight loop without
+ * ever pulling the subscription, so a projection wired with `batchSize: 0`
+ * spins a CPU for ever, commits nothing, stays at `ORIGIN`, never fails, never
+ * restarts and logs nothing — the exact silent-stall class the supervisor below
+ * exists to make loud, arriving by a route the supervisor cannot see (the
+ * breaker only counts RESTARTS, and a spinning stream never ends a run). A
+ * fractional or `NaN` size is the same mistake by a different route.
+ *
+ * The SHAPE mirrors core's `ReadLimit` — `Schema.Int`, a bound, a brand, the
+ * same fail-at-the-boundary discipline — but deliberately NOT `ReadLimit`
+ * itself, which is `>= 0`. Zero is the whole difference between the two: a
+ * `read` capped at zero events is a meaningful (if useless) request, whereas a
+ * COMMIT of zero events is not a request at all. Reusing `ReadLimit` here would
+ * import the one value that has to be rejected.
+ *
+ * A distinct brand from `MaxNoProgressRestarts` despite the identical
+ * refinement, because the two are still writable side by side in one flat
+ * options literal, are both bare integers, and differ by an order of magnitude
+ * in meaning — nominality is what makes a transposition fail to typecheck rather
+ * than silently retune the runner. That the two now tune different mechanisms
+ * (this one the pipeline, that one the supervisor) is a second reason for the
+ * distinction, not a replacement for the first.
+ *
+ * Construct with `BatchSize.make(n)`, which throws a `ParseError` at the call
+ * site rather than deferring the mistake to the first stream pull.
+ */
+export const BatchSize = /*#__PURE__*/Schema.Int.pipe(/*#__PURE__*/Schema.positive(), /*#__PURE__*/Schema.brand('BatchSize'));
+/**
+ * Half the store's `catchUpPageSize` default (512), so a commit transaction stays
+ * comfortably smaller than one catch-up page while still amortising the
+ * round-trip across a couple of hundred events.
+ */
+const DEFAULT_BATCH_SIZE = /*#__PURE__*/BatchSize.make(256);
+/**
+ * An order of magnitude under the store's 1-second `pollInterval` — the live
+ * tail's own latency floor — so the batching window never dominates end-to-end
+ * lag.
+ */
+const DEFAULT_BATCH_WINDOW = '50 millis';
+/**
+ * RESOLVE: apply every default and read both call-independent facts off the bound
+ * view, so the gate can judge exactly the figures the pipeline will run.
+ *
+ * A PURE function — no `Effect`, no context, no clock — which is what lets BOTH
+ * runner entry points share one resolution site. That is the whole reason it exists
+ * as a function rather than as a paragraph of `runProjection`'s body: the gate is
+ * only as good as the argument it is handed, and two resolution sites are free to
+ * drift into approving a figure the pipeline does not use. One site, and the figure
+ * that was judged cannot differ from the figure that runs, for one wiring and for N
+ * of them alike.
+ *
+ * The five `??` defaults are resolved HERE and ONCE. `batchSize` and `batchWindow`
+ * go into the pipeline, the three restart durations into the supervision options,
+ * where `superviseOnProgress` requires all three for exactly that reason.
+ *
+ * `maxNoProgressRestarts` is deliberately absent, as it is from the gate: it is
+ * BRANDED, so its boundary was the caller's own `.make(...)`, nothing here has to
+ * resolve it, and its default stays where its wall-clock arithmetic is documented.
+ *
+ * It takes the BOUND view rather than the unbound port because `key` and
+ * `viewDurability` are its two reads and both are on the bound façade. The UNBOUND
+ * store is still the only thing that can answer "are these two entries the same
+ * store?" — `forKey` deliberately does not expose what it closed over — so the gate
+ * takes that identity as a field of its own, from whichever caller holds one.
+ */
+export const resolveProjection = (view, options) => ({
+  view,
+  key: view.key,
+  viewDurability: view.durability,
+  batchSize: options?.batchSize ?? DEFAULT_BATCH_SIZE,
+  batchWindow: options?.batchWindow ?? DEFAULT_BATCH_WINDOW,
+  restartMinDelay: options?.restartMinDelay ?? DEFAULT_RESTART_MIN_DELAY,
+  restartMaxDelay: options?.restartMaxDelay ?? DEFAULT_RESTART_MAX_DELAY,
+  restartResetAfter: options?.restartResetAfter ?? DEFAULT_RESTART_RESET_AFTER
+});
+/**
+ * A defect surfaced from the drain, converted into a value the supervisor can act
+ * on.
+ *
+ * **Why the conversion exists.** `DcbEventStore.subscribe` is `E = never` by
+ * contract (ADR-0002: infrastructure faults are defects, not channel values), so a
+ * store whose live tail fails beyond its own retry budget DIES rather than failing.
+ * Converting that death into a typed error at the runner's boundary is what makes
+ * it actionable: a defect can only be caught, whereas a value can be counted,
+ * logged, matched on, and fed to a supervisor that decides between backoff and
+ * give-up.
+ *
+ * **Why the boundary is DRAIN-WIDE**, which is what the name reports. The
+ * conversion sits outside the whole `runDrain`, so what arrives is a defect from
+ * any stage of it: the subscription's own death, the codec's decode, the read
+ * model's `apply`, or a `ProjectionStore` implementation that dies where the port
+ * says it should fail. They all end the run identically, and the progress-keyed
+ * breaker is the right arbiter for all of them, since it restarts while the
+ * checkpoint moves and gives up with a logged `ProjectionStalled` when it does
+ * not. Narrowing the conversion to the subscription stage would instead let an
+ * `apply` defect escape `Effect.retry` — which sees failures, never defects — and
+ * kill the daemon fibre outright: no restart, no `ProjectionStalled`, no logged
+ * give-up, and since `runProjection` is infallible, no route to an operator at
+ * all. The boundary must equally not WIDEN to `catchAllCause`; the comment at the
+ * conversion site sets out why.
+ *
+ * `defect` is `unknown` because it is somebody else's defect and the runner must
+ * not pretend to know its shape.
+ */
+export class PipelineDied extends /*#__PURE__*/Data.TaggedError('PipelineDied') {
+  /**
+   * Why this class fills `message` at all: so the fault renders ITSELF.
+   *
+   * `Data.TaggedError` sets `name` to the tag and leaves `message` empty, so an
+   * unfilled tagged error stringifies to its bare tag — "the pipeline died", with
+   * no hint of what killed it, and `PipelineDied: ECONNRESET` is not the same log
+   * line. Filled, `Error.prototype.toString` yields `name: message`, so
+   * `String(fault)`, `Cause.pretty` (which reads `message` off anything
+   * `instanceof Error`) and every log line built from either report the field that
+   * says WHY — and no table of tag-to-label outside the class has to be kept in
+   * step with the fields inside it.
+   *
+   * `String(this.defect)` rather than anything cleverer, for exactly the reason
+   * `defect` is `unknown` above: plucking a `.message`, sniffing a `_tag` or
+   * `JSON.stringify`-ing it would each be the runner pretending to know the shape
+   * of somebody else's defect, and the last of them THROWS on a `bigint`.
+   *
+   * A GETTER rather than a `message` field, which keeps `defect` the single
+   * declaration of the fact. Why a prototype accessor is safe here, how far filling
+   * the field reaches and the structured `toJSON` shape it deliberately leaves
+   * untouched are set out once for all four of these getters on
+   * `ProjectionStoreError` in `ProjectionStore.ts`.
+   */
+  get message() {
+    return String(this.defect);
+  }
+}
+/**
+ * PREPARE: the whole middle of a projection call — the log's durability, the merged
+ * query, the construction gate's verdict and the decode stage — between the
+ * per-entry RESOLVE above and the per-entry BUILD below.
+ *
+ * ## Why it is a phase of its own
+ *
+ * Everything in it is a function of the CALL rather than of any one materialisation,
+ * and both entry points ran these same five steps in this same order before it
+ * existed. `runProjection` is the N = 1 case: it hands over a singleton entry list
+ * and its own preamble and gets back the pair `runProjections` gets back for N.
+ *
+ * ## What the ONE body is FOR: the gate is consulted before the codec
+ *
+ * This is worth more than the duplication it removes. `decodeSlices` refuses a slice
+ * record carrying two DISTINCT `Schema`s under one event type, and refuses it by
+ * THROWING — which inside this `Effect.gen` is a defect, exactly as the gate's
+ * verdict is. A record wrong in BOTH ways therefore has two sentences available and
+ * nothing but the ORDER of two statements decides which one its author reads. The
+ * gate's is the right one: it is the read side's own rule about the wiring in front
+ * of that author, where the codec's is about a merge the write path shares and
+ * `decode.ts` owns.
+ *
+ * That order is now a property of ONE body — the gate call above, the `decodeSlices`
+ * call below — for both entry points at once. It used to be a claim two function
+ * bodies each made in prose, free to drift, and pinned for only one of them. It is
+ * pinned for both now: `test/runProjections.test.ts`'s "the GATE is consulted before
+ * the codec" case and `test/runner.construction.test.ts`'s sibling each drive a
+ * record breaking both rules and assert which sentence comes back. Neither RULE is
+ * under test in either — `packages/codec`'s decode suite and
+ * `projectionWiringFault.test.ts` own those.
+ *
+ * ## What the caller keeps
+ *
+ * The PREAMBLE, and only the preamble: `runProjection` names the projection and its
+ * partition, `runProjections` the projection alone, and this function joins whichever
+ * it was to the gate's sentence about the RULE with one `': '`. That is the division
+ * `projectionWiringFault`'s doc fixes — the gate knows the rule, the entry point
+ * knows whose wiring it is — and moving the single `Effect.die` here changes only
+ * WHERE the two halves meet, never which half writes which. It is built eagerly, one
+ * interpolation per construction, rather than as a thunk: a call that is about to
+ * subscribe to an event log does not need that deferred, and a thunk reads worse at
+ * both call sites.
+ *
+ * ## Why both derivations happen HERE
+ *
+ * The runner needs only the merged QUERY from the composition — the fold is the read
+ * model's own `apply` — but it must be the SAME merge a fold would use, so it comes
+ * from `core`'s `composeProjections` rather than a local query union that could drift
+ * from it. It is also the gate's input, and the gate can only judge it at
+ * construction because the union is a pure function of the slices.
+ *
+ * Both derivations run ONCE per call rather than once per entry or once per restart,
+ * so N subscriptions share a single `Query` object and N pipelines a single merged
+ * `type -> Schema` table. Sharing the decode stage is safe because the `Serializer`
+ * is read from context INSIDE it, per stream, so one stage does not freeze one
+ * serialiser across entries. `DecodeStage`'s own doc says which references to that
+ * alias hold the inference up, and which do not.
+ *
+ * The cast erases each slice's own state and event types down to `AnyProjection`. It
+ * is sound because `composeProjections` only ever folds a slice through its OWN
+ * `evolve`, never across two, so the per-slice pairing the erasure hides is the one
+ * thing it cannot violate — and `T`'s precise shape is recovered on the way out, in
+ * `CompositeState<T>`. It is unavoidable rather than merely convenient: a slice
+ * record is keyed by a caller's literal union, and no signature in `core` is generic
+ * over that union AND over each member's state, so the variance has to be discharged
+ * somewhere. Once, now, rather than at each entry point.
+ *
+ * ## Why `EventLogDurability` is read from CONTEXT here
+ *
+ * Because it is R2's log half, and one log is ONE fact —
+ * `EventLogDurability.ts` argues why it is a service declared beside the store layer
+ * rather than a field per read model. Reading it once for the CALL is what that
+ * argument already wanted, and it is deliberately not part of `resolveProjection`,
+ * which is per ENTRY and pure. It is this function's only requirement, and through it
+ * the reason both entry points declare one.
+ */
+export const prepareProjection = (slices, materialisations, preamble) => Effect.gen(function* () {
+  // The LOG's half of R2, from CONTEXT rather than from any read model. Each
+  // entry's VIEW half already rode in on the resolved wiring.
+  const eventLogDurability = yield* EventLogDurability;
+  const composite = composeProjections(slices);
+  // ## ASSERT — one gate, one verdict, one `Effect.die`
+  //
+  // Five rules over four vocabularies, in the order `projectionWiringFault`
+  // declares and argues; this function supplies the values and classifies the
+  // verdict, and its caller supplied the preamble that says WHOSE wiring is wrong.
+  // Both entry points reach this before they fork anything, so a rejected wiring
+  // has read no checkpoint and opened no subscription.
+  const fault = projectionWiringFault({
+    eventLogDurability,
+    query: composite.query,
+    slices,
+    materialisations
+  });
+  if (fault !== undefined) {
+    return yield* Effect.die(new Error(`${preamble}: ${fault}`));
+  }
+  // BELOW the gate, and that is the ordering this phase exists to own.
+  // `decodeSlices` carries the CODEC's own construction refusal — two DISTINCT
+  // `Schema`s under one event type — and it THROWS, which here is a second defect;
+  // a record wrong in both ways must meet the gate's sentence first. Moving this
+  // call above the gate would still die with nothing forked, only with the wrong
+  // sentence, which is why the doc above names the two suites that pin it.
+  //
+  // It takes the RECORD rather than a pre-merged schema table for the same reason
+  // the query is composed here: the decode lookup and the subscription query
+  // cannot then come from different records.
+  const decode = decodeSlices(slices);
+  return {
+    query: composite.query,
+    decode
+  };
+});
+/**
+ * BUILD and FORK: one resolved wiring plus the three shared derivations in, one
+ * supervised daemon out.
+ *
+ * This is everything the two runner entry points have in common from the gate's
+ * verdict onwards — the subscription, the decode, the micro-batching, the guarded
+ * commit, the supervisor and the `forkScoped`. It is package-internal and takes no
+ * `ReadModel`, so `runProjections` reaches it directly rather than by re-entering
+ * `runProjection` per entry, which is what lets one call resolve, judge and derive
+ * ONCE and still run N identical pipelines. `read-postgres`'s
+ * `test/courseRosterGraduation.test.ts` rests on the two callers running literally
+ * the same pipeline, so this function staying the only build step is load-bearing.
+ *
+ * It requires no `EventLogDurability`. That service is read by `prepareProjection`
+ * above — the one place it is read at all — for the gate, and has no part in what
+ * runs; the two public entry points DECLARE it only because they run that phase.
+ *
+ * `query` and `decode` arrive as ARGUMENTS rather than being derived here from a
+ * slice record, which is a structural gain rather than a cost: the build step holds
+ * no slice record at all, so there is no second record it could derive a different
+ * query or a different decode table from. It is the same move `decodeSlices` itself
+ * made when it collapsed a two-step protocol into one call.
+ */
+export const buildAndFork = (resolved, build) => Effect.gen(function* () {
+  const {
+    view,
+    key,
+    batchSize,
+    batchWindow,
+    restartMinDelay,
+    restartMaxDelay,
+    restartResetAfter
+  } = resolved;
+  const store = yield* DcbEventStore;
+  /**
+   * One run of the pipeline: resolve the resume point, subscribe from it, and
+   * drain until the stream ends, is interrupted, or dies.
+   *
+   * `Effect.scoped` per RUN, not per runner, so a restart releases the previous
+   * subscription's resources (the store's listener, its poll fibre) before the
+   * next one acquires them — otherwise every restart would leak a subscription
+   * into the runner's outer scope.
+   */
+  const runOnce = Effect.gen(function* () {
+    // Re-read on EVERY attempt. This is the resynchronisation: after a lost
+    // checkpoint guard the stored position is whatever the winner advanced it
+    // to, and the restart picks that up instead of resuming from a stale
+    // expectation.
+    const stored = yield* view.readCheckpoint;
+    // The expectation for the next guarded advance, threaded through the run.
+    // A `Ref` rather than a fold accumulator because the batch committer is a
+    // `Stream.mapEffect` callback; correctness rests on the single-writer
+    // property (concurrency 1), so there is exactly one fibre reading and
+    // writing this.
+    const expected = yield* Ref.make(stored);
+    const commitBatch = batch => Effect.gen(function* () {
+      const events = Chunk.toReadonlyArray(batch);
+      // Total on the empty chunk. `groupedWithin` is `aggregateWithin` over a
+      // `collectAllN` sink on a `spaced` schedule, so a window that elapses
+      // with nothing buffered has an empty collection to emit; even if a
+      // given version suppressed that, resting the runner's correctness on an
+      // undocumented internal would be a bug waiting for an upgrade. There is
+      // nothing to apply and no last position, and committing `expected` onto
+      // itself would be a pointless write that could lose its guard to a
+      // legitimate winner and restart the pipeline for nothing.
+      if (!Arr.isNonEmptyReadonlyArray(events)) {
+        return;
+      }
+      // The last event's position, AS IS. Never `expected + 1` and never any
+      // other arithmetic: positions are strictly increasing but NOT gapless
+      // (a rolled-back append burns ids), so the gap between two delivered
+      // events is normal and an increment would invent a position that either
+      // never existed or belongs to an event this query does not match.
+      const next = Arr.lastNonEmpty(events).sequenced.position;
+      const from = yield* Ref.get(expected);
+      // The port owns the bracket: the view writes go IN, so the checkpoint
+      // advance cannot happen outside the transaction that carries them. A
+      // lost guard fails here, which aborts the whole commit and restarts the
+      // run — `expected` is deliberately NOT advanced on a failure. There is
+      // no `key` argument: the store is bound to one, so the batch cannot be
+      // committed against a cursor other than the one it was read from.
+      yield* view.commit({
+        expected: from,
+        next,
+        viewWrites: build.apply(events)
+      });
+      yield* Ref.set(expected, next);
+    });
+    yield* store.subscribe(build.query, stored).pipe(build.decode, Stream.groupedWithin(batchSize, batchWindow), Stream.mapEffect(commitBatch, {
+      concurrency: 1
+    }), Stream.runDrain,
+    // `catchAllDefect`, NOT `catchAllCause`. The subscription's failure mode
+    // is a DEFECT (`subscribe` is `E = never`) and that is what the
+    // supervisor needs as a value — but the OTHER way this drain ends is
+    // INTERRUPTION, when the enclosing `Scope` closes at shutdown.
+    // `catchAllCause` would swallow that too, turning a graceful teardown
+    // into a `PipelineDied` that the supervisor would dutifully retry —
+    // restarting a subscription inside a scope that is being torn down.
+    // `catchAllDefect` re-fails any cause carrying no defect, so interruption
+    // propagates untouched and the fibre dies when it is told to.
+    //
+    // Placed outside the WHOLE drain, so it converts a defect from any stage
+    // — decode, `apply`, a store implementation that dies — and not only the
+    // subscription's own death; the fault says PIPELINE for that reason.
+    // `PipelineDied`'s doc carries the reasoning (in short: they all end the
+    // run identically, and a narrower conversion would let an `apply` defect
+    // bypass the supervisor entirely).
+    Effect.catchAllDefect(defect => new PipelineDied({
+      key,
+      defect
+    })));
+  }).pipe(Effect.scoped);
+  // ## SUPERVISE — one attempt in, a supervised daemon out
+  //
+  // What goes with it is the whole of what supervision knows about this runner:
+  // the key it reports under, the bound store's `readCheckpoint` as the progress
+  // signal, whatever the caller wrote in the UNRESOLVED half of its supervision
+  // options, and the three restart durations RESOLVED above.
+  //
+  // What DOES the work is that those three were resolved ONCE, in
+  // `resolveProjection`, so the supervisor receives exactly the figures the gate
+  // judged — the argument is on `SuperviseOnProgressOptions` in
+  // `superviseOnProgress.ts`, which requires all three for exactly that reason.
+  //
+  // WHICH FIELDS travel is carried by the TYPES, not by an enumeration of the
+  // forwardable ones. `UnresolvedSupervisionOptions` — the type
+  // `SuperviseOnProgressOptions` is built from — is `ProjectionSupervisionOptions`
+  // MINUS the resolved three, so a new OPTIONAL supervision field lands in it and
+  // travels through this call with no edit here, while a new RESOLVED figure lands
+  // in `ResolvedSupervisionTuning` instead and leaves the literal below missing a
+  // required property. Neither direction rests on a comment or on a test
+  // remembering to be extended, which is what the enumeration this replaced could
+  // not say.
+  //
+  // The REST-DESTRUCTURE is the other half, and it is about the OBJECT rather than
+  // its type. `build.options` is the caller's own FLAT record, so a raw
+  // `restartMinDelay` it wrote is copied by a spread whatever the spread's static
+  // type says it holds; discarded here, it is not in the object to be copied at
+  // all. Without it the resolved figure would stay on top only while it was written
+  // LAST in the literal, and a transposition of two adjacent lines would typecheck
+  // and then run the unjudged figure — a rule that has to be remembered is one an
+  // edit reading as pure tidying can break.
+  //
+  // The three discards are the one place a resolved field is named twice, and they
+  // cannot silently fall out of step: a fourth resolved figure stops the literal
+  // below compiling until it is named there, and its author is then one line from
+  // this destructure.
+  //
+  // The caller's two PIPELINE figures ride along in the copy and are inert: the
+  // supervisor reads its options by name and has no field either could reach.
+  // Excluding them would be two more discards for nothing.
+  //
+  // What is destructured is the OPTIONS and not `resolved`: that record is flat and
+  // also carries `view`, `viewDurability`, `batchSize` and `batchWindow`, so
+  // spreading it wholesale would ride four dead fields into a supervisor's options
+  // object — the hazard `runProjections.ts` names where it builds its entry literal
+  // explicitly.
+  //
+  // `?? {}` rather than the conditional spreads this replaced.
+  // `exactOptionalPropertyTypes` bars setting an optional key to an explicit
+  // `undefined`, and this sets none: spreading an object contributes only the keys
+  // it has, and an absent whole options object contributes none at all.
+  //
+  // The progress signal goes in as a VALUE, so nothing has been read from the
+  // view store yet: a runner rejected above still has not touched it.
+  //
+  // Nothing is handed in for RENDERING the runner's faults on the supervisor's
+  // log lines. All four set `message`, so `String(fault)` is
+  // `Error.prototype.toString` — `'ProjectionStoreError: ECONNRESET'` — and each
+  // fault labels itself wherever it is reported, from the field that says why.
+  // `CheckpointSuperseded`'s is the interesting one and its own doc carries the
+  // argument: its `expected` is a `bigint`, but a `bigint` interpolated into a
+  // `string` is digits, so the value class the log reduction below keeps away from
+  // a serialiser never reaches one through `message`.
+  //
+  // The residual error is `ProjectionStalled` and nothing else: the schedule
+  // never terminates on its own, so the only way out with a failure is the
+  // breaker giving up. `superviseOnProgress` carries that reasoning.
+  const {
+    restartMinDelay: _rawMinDelay,
+    restartMaxDelay: _rawMaxDelay,
+    restartResetAfter: _rawResetAfter,
+    ...supervisionOverrides
+  } = build.options ?? {};
+  const daemon = superviseOnProgress(runOnce, {
+    key,
+    progress: view.readCheckpoint,
+    ...supervisionOverrides,
+    restartMinDelay,
+    restartMaxDelay,
+    restartResetAfter
+  });
+  // ## FORK
+  //
+  // `forkScoped`, so the daemon's lifetime IS the caller's scope: no manual
+  // shutdown handle to forget, and scope close interrupts and awaits the fibre
+  // deterministically. A plain `Effect.fork` would tie it to the calling
+  // fibre's lifetime, which for a wiring effect that returns immediately would
+  // kill the daemon on the spot.
+  const fibre = yield* Effect.forkScoped(daemon);
+  // The BOUND view goes back with the fibre, which is what lets a returned handle
+  // name its own cursor. It is the same object the pipeline above commits through,
+  // not a re-binding: `runProjections` resolved it from a store its caller never
+  // bound, and equal keys across N entries leave it as the only discriminator.
+  return {
+    key,
+    store: view,
+    fibre
+  };
+});
+//# sourceMappingURL=ProjectionRunner.js.map

package/dist/esm/ProjectionRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProjectionRunner.js","names":["decodeSlices","composeProjections","DcbEventStore","Array","Arr","Chunk","Data","Effect","Ref","Schema","Stream","EventLogDurability","projectionWiringFault","DEFAULT_RESTART_MAX_DELAY","DEFAULT_RESTART_MIN_DELAY","DEFAULT_RESTART_RESET_AFTER","superviseOnProgress","BatchSize","Int","pipe","positive","brand","DEFAULT_BATCH_SIZE","make","DEFAULT_BATCH_WINDOW","resolveProjection","view","options","key","viewDurability","durability","batchSize","batchWindow","restartMinDelay","restartMaxDelay","restartResetAfter","PipelineDied","TaggedError","message","String","defect","prepareProjection","slices","materialisations","preamble","gen","eventLogDurability","composite","fault","query","undefined","die","Error","decode","buildAndFork","resolved","build","store","runOnce","stored","readCheckpoint","expected","commitBatch","batch","events","toReadonlyArray","isNonEmptyReadonlyArray","next","lastNonEmpty","sequenced","position","from","get","commit","viewWrites","apply","set","subscribe","groupedWithin","mapEffect","concurrency","runDrain","catchAllDefect","scoped","_rawMinDelay","_rawMaxDelay","_rawResetAfter","supervisionOverrides","daemon","progress","fibre","forkScoped"],"sources":["../../src/ProjectionRunner.ts"],"sourcesContent":[null],"mappings":"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A;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAM;IACJlD,eAAe,EAAEmD,YAAY;IAC7BlD,eAAe,EAAEmD,YAAY;IAC7BlD,iBAAiB,EAAEmD,cAAc;IACjC,GAAGC;EAAoB,CACxB,GAA4B/B,KAAK,CAAC7B,OAAO,IAAI,EAAE;EAEhD,MAAM6D,MAAM,GAIRxE,mBAAmB,CAAC0C,OAAO,EAAE;IAC/B9B,GAAG;IACH6D,QAAQ,EAAE/D,IAAI,CAACkC,cAAc;IAC7B,GAAG2B,oBAAoB;IACvBtD,eAAe;IACfC,eAAe;IACfC;GACD,CAAC;EAEF;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAMuD,KAAK,GAAG,OAAOnF,MAAM,CAACoF,UAAU,CAACH,MAAM,CAAC;EAE9C;EACA;EACA;EACA;EACA,OAAO;IAAE5D,GAAG;IAAE6B,KAAK,EAAE/B,IAAI;IAAEgE;EAAK,CAAE;AACpC,CAAC,CAAC","ignoreList":[]}