@kairos-es/read 0.0.0

package/dist/esm/runProjection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runProjection.js","names":["Effect","Layer","buildAndFork","prepareProjection","resolveProjection","runProjection","readModel","options","gen","view","store","resolved","prepared","slices","cursorIdentity","key","projection","partition","query","decode","apply","projectionLayer","scopedDiscard"],"sources":["../../src/runProjection.ts"],"sourcesContent":[null],"mappings":"AAuCA,SAA4BA,MAAM,EAAEC,KAAK,QAAoB,QAAQ;AAErE,SACEC,YAAY,EAGZC,iBAAiB,EACjBC,iBAAiB,QACZ,uBAAoB;AAuF3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,OAAO,MAAMC,aAAa,GAAGA,CAC3BC,SAA6B,EAC7BC,OAAiC,KAWjCP,MAAM,CAACQ,GAAG,CAAC,aAAS;EAClB;EACA;EACA;EACA;EACA;EACA,MAAMC,IAAI,GAAGH,SAAS,CAACI,KAAK;EAC5B,MAAMC,QAAQ,GAAGP,iBAAiB,CAACK,IAAI,EAAEF,OAAO,CAAC;EAEjD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAMK,QAAQ,GAAG,OAAOT,iBAAiB,CACvCG,SAAS,CAACO,MAAM,EAChB,CAAC;IAAE,GAAGF,QAAQ;IAAEG,cAAc,EAAEL;EAAI,CAAE,CAAC,EACvC,+CAA+C,GAC7C,IAAIE,QAAQ,CAACI,GAAG,CAACC,UAAU,eAAe,GAC1C,IAAIL,QAAQ,CAACI,GAAG,CAACE,SAAS,IAAI,CACjC;EAED;EACA,OAAO,OAAOf,YAAY,CAACS,QAAQ,EAAE;IACnCO,KAAK,EAAEN,QAAQ,CAACM,KAAK;IACrBC,MAAM,EAAEP,QAAQ,CAACO,MAAM;IACvBC,KAAK,EAAEd,SAAS,CAACc,KAAK;IACtBb;GACD,CAAC;AACJ,CAAC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,OAAO,MAAMc,eAAe,GAAGA,CAK7Bf,SAA6B,EAC7BC,OAAiC,KAK9BN,KAAK,CAACqB,aAAa,CAACjB,aAAa,CAACC,SAAS,EAAEC,OAAO,CAAC,CAAC","ignoreList":[]}

package/dist/esm/runProjections.js

@@ -0,0 +1,137 @@
+import { Array as Arr, Effect } from 'effect';
+import { buildAndFork, prepareProjection, resolveProjection } from "./ProjectionRunner.js";
+import { checkpointKey, forKey } from "./ProjectionStore.js";
+/**
+ * Start one daemon per materialisation, all forked into the caller's `Scope`.
+ *
+ * The returned effect is INFALLIBLE for the reason `runProjection`'s is: starting a
+ * projection cannot fail, because everything that can go wrong once one is running
+ * belongs to its own supervisor and lives on its own fibre's error channel. The
+ * runners come back in ENTRY ORDER, so `runners[i]` is `materialisations[i]`'s.
+ *
+ * Each runner carries the store THIS call bound for its entry, so `runners[i].store`
+ * is that materialisation's cursor and a caller observing one re-derives no binding
+ * it never wrote. It is also what tells the N handles apart: under one `ProjectionId`
+ * the keys are equal wherever no entry named a partition, so a runner carrying only a
+ * key could not name which of the N views it maintains.
+ *
+ * ## N = 1 is legal and carries nothing inert
+ *
+ * One entry is `runProjection` with the `forKey` binding done for you, and every
+ * field means the same thing it means at N = 3. The two run the identical phases —
+ * one `resolveProjection`, one `prepareProjection`, one `buildAndFork` — rather than
+ * merely offering the same surface, so there is no threshold at which a caller should
+ * switch functions: a read model that grows a second materialisation adds an entry.
+ *
+ * ## Every rule is judged before ANY entry is forked
+ *
+ * The construction gate takes the whole call — the shared log, query and slice
+ * record, plus the N resolved wirings — and this call reaches it ONCE, through
+ * `prepareProjection`, above the `Effect.forEach` below. So a call refused for ANY
+ * reason has forked NOTHING,
+ * not even the entries that were sound: not the collision, which is a property of
+ * the set, and not a degenerate `batchWindow` or an R2 violation on the last entry
+ * either. Half a call running is a worse state than none of it, and the pairing of N
+ * materialisations is one wiring decision.
+ *
+ * Two consequences of the gate judging a SET are worth stating rather than leaving
+ * to be met.
+ *
+ * A per-entry rung names its ENTRY. The gate prefixes its verdict with
+ * `materialisations[i]` where there is more than one entry, in the vocabulary the
+ * collision sentence already uses; this function's preamble names the PROJECTION and
+ * no partition, because under one `ProjectionId` the N keys are equal wherever no
+ * entry named a partition, so a partition never discriminated them.
+ *
+ * And the order is over RULES, not over entries. Where two entries break two
+ * DIFFERENT rules the earlier RULE wins whatever entry it is in — entry 0's
+ * degenerate `batchWindow` beside entry 1's illegal durability pairing reports entry
+ * 1's R2 fault, because R2 is the wider mistake wherever it sits. The gate's module
+ * doc argues that, and it is why the rules are judged rule-major rather than by
+ * walking the entries.
+ */
+export const runProjections = spec => Effect.gen(function* () {
+  // ## RESOLVE — everything the gate has to judge, and every figure that runs
+  //
+  // Each entry's key and its five defaulted figures, through the same pure
+  // `resolveProjection` a single wiring goes through. Resolved here and carried,
+  // rather than derived twice: the gate below judges these values and the pipelines
+  // further down run from these same values, so what was checked cannot differ from
+  // what runs.
+  //
+  // Built as an EXPLICIT literal rather than by spreading the `Materialisation`,
+  // so every field on an entry has exactly one meaning and nothing dead rides
+  // along. A spread would carry the caller's `store` and `partition` into a record
+  // that already holds the BOUND view (from the resolve step) and the UNBOUND port
+  // under `cursorIdentity` — two names for one reference, one name for a different
+  // one, and a `partition` nothing downstream reads because `key` has absorbed it.
+  // That is a near-miss of the very hazard `cursorIdentity` was renamed to close.
+  //
+  // `cursorIdentity` is the UNBOUND port here, which is the last surface at which
+  // sameness is askable — `forKey` returns a fresh literal per call and does not
+  // expose what it closed over, so two bound views are never equal even over one
+  // store. `runProjection` passes its bound view instead, which is free at an arity
+  // where the rung cannot fire. `MaterialisationWiring`'s doc owns that argument.
+  const entries = Arr.map(spec.materialisations, materialisation => {
+    const key = checkpointKey(spec.projection, materialisation.partition);
+    return {
+      ...resolveProjection(forKey(materialisation.store, key), materialisation.options),
+      cursorIdentity: materialisation.store,
+      apply: materialisation.apply,
+      options: materialisation.options
+    };
+  });
+  // ## PREPARE — the log's durability, the merged query, the gate, the decode
+  //
+  // The shared middle, and the same call `runProjection` makes with a singleton.
+  // It reads the LOG's half of R2 from context — once for the call, because it IS
+  // one fact about one log — composes the ONE query the N subscriptions share,
+  // judges all five rungs over the whole entry list, and only then builds the ONE
+  // decode stage the N pipelines share. All of it above the `Effect.forEach` below,
+  // so a refused call has forked nothing.
+  //
+  // The order of the last two steps is `prepareProjection`'s to own, and it is why
+  // `decodeSlices` is not simply hoisted beside the composition: a record wrong in
+  // the codec's way AND in one of the gate's must meet the gate's sentence.
+  //
+  // The preamble is this function's own half of the defect message: the PROJECTION
+  // and no partition, because under one `ProjectionId` the N keys are equal wherever
+  // no entry named one, so a partition never discriminated them. The gate prefixes
+  // the entry index itself, where there is a set to index into.
+  const prepared = yield* prepareProjection(spec.slices, entries, `runProjections: invalid wiring for projection '${spec.projection}'`);
+  // ## FORK — one runner per entry, SEQUENTIALLY
+  //
+  // No `concurrency` option, deliberately. `buildAndFork` returns as soon as its
+  // daemon is forked into this scope, so it does no waiting for a concurrent pass
+  // to overlap: concurrency would buy nothing and would cost the returned ORDER,
+  // which is what lets a caller pair a runner with the entry it maintains. The
+  // daemons themselves run concurrently regardless — that is what forking them is.
+  //
+  // A runner naming its own bound cursor does not make that order redundant. The
+  // entry hands over an UNBOUND port and `forKey` deliberately does not expose what
+  // it closed over, so nothing a caller still holds can be compared against
+  // `runners[i].store` to recover which entry it came from. The order is the only
+  // statement of that pairing, and it is why this fold stays sequential.
+  //
+  // Each entry reaches the SAME build step a single wiring reaches, with the same
+  // shared query and the same shared decode stage, so the N pipelines differ in
+  // nothing but their store, their `apply` and their tuning.
+  return yield* Effect.forEach(entries, entry => buildAndFork(entry, {
+    query: prepared.query,
+    decode: prepared.decode,
+    // THE one assertion in this function, and the reason the requirement
+    // channel declared above is checked rather than wished for. Inside the
+    // body an entry is known only by its constraint, so this `apply` reads as
+    // `Effect<void, unknown, unknown>`; naming the alias the return type
+    // already names is what carries the entries' real requirement through
+    // `buildAndFork`, where a wildcard bound would instead absorb the lot and
+    // leave every member of that union unverified. It is narrow on purpose —
+    // `entry.apply` alone, to one expression written in one other place —
+    // and it cannot be dropped: without it the module does not compile.
+    // `MaterialisationAny` owns the mechanic, `MaterialisedProjection` what
+    // the compiler is being asked to take on trust.
+    apply: entry.apply,
+    options: entry.options
+  }));
+});
+//# sourceMappingURL=runProjections.js.map

package/dist/esm/runProjections.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runProjections.js","names":["Array","Arr","Effect","buildAndFork","prepareProjection","resolveProjection","checkpointKey","forKey","runProjections","spec","gen","entries","map","materialisations","materialisation","key","projection","partition","store","options","cursorIdentity","apply","prepared","slices","forEach","entry","query","decode"],"sources":["../../src/runProjections.ts"],"sourcesContent":[null],"mappings":"AA8FA,SAASA,KAAK,IAAIC,GAAG,EAAEC,MAAM,QAAoB,QAAQ;AAEzD,SACEC,YAAY,EAGZC,iBAAiB,EACjBC,iBAAiB,QACZ,uBAAoB;AAC3B,SACEC,aAAa,EACbC,MAAM,QAID,sBAAmB;AAiW1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,OAAO,MAAMC,cAAc,GAIzBC,IAAmC,IAWnCP,MAAM,CAACQ,GAAG,CAAC,aAAS;EAClB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAMC,OAAO,GAAGV,GAAG,CAACW,GAAG,CAACH,IAAI,CAACI,gBAAgB,EAAGC,eAAe,IAAI;IACjE,MAAMC,GAAG,GAAGT,aAAa,CAACG,IAAI,CAACO,UAAU,EAAEF,eAAe,CAACG,SAAS,CAAC;IACrE,OAAO;MACL,GAAGZ,iBAAiB,CAClBE,MAAM,CAACO,eAAe,CAACI,KAAK,EAAEH,GAAG,CAAC,EAClCD,eAAe,CAACK,OAAO,CACxB;MACDC,cAAc,EAAEN,eAAe,CAACI,KAAK;MACrCG,KAAK,EAAEP,eAAe,CAACO,KAAK;MAC5BF,OAAO,EAAEL,eAAe,CAACK;KAC1B;EACH,CAAC,CAAC;EAEF;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAMG,QAAQ,GAAG,OAAOlB,iBAAiB,CACvCK,IAAI,CAACc,MAAM,EACXZ,OAAO,EACP,kDAAkDF,IAAI,CAACO,UAAU,GAAG,CACrE;EAED;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,OAAO,OAAOd,MAAM,CAACsB,OAAO,CAACb,OAAO,EAAGc,KAAK,IAC1CtB,YAAY,CAACsB,KAAK,EAAE;IAClBC,KAAK,EAAEJ,QAAQ,CAACI,KAAK;IACrBC,MAAM,EAAEL,QAAQ,CAACK,MAAM;IACvB;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACAN,KAAK,EAAEI,KAAK,CAACJ,KAEgD;IAC7DF,OAAO,EAAEM,KAAK,CAACN;GAChB,CAAC,CACH;AACH,CAAC,CAAC","ignoreList":[]}