@kairos-es/codec 1.0.0-alpha.0 → 1.0.0-alpha.2

package/dist/cjs/precondition.js

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unsafeAppend = exports.transact = exports.decideOnly = void 0;
+var _core = require("@kairos-es/core");
+var _effect = require("effect");
+var _decision = require("./decision.js");
+var _decisionModel = require("./decisionModel.js");
+var _readLedger = require("./readLedger.js");
+/**
+ * The DCB command cycle MINUS the append: read the decision model, decode, fold,
+ * decide, and RETURN the events for the bracket to append — or the decider's
+ * `Unchanged`, passed through as it came, for the bracket to append nothing.
+ *
+ * Bracket-only, and the refusal is STATIC — see the section below for the mechanism
+ * and, more importantly, for where the error actually lands, which is not where a
+ * reader first expects. Forced through anyway, being outside a bracket is a DEFECT
+ * rather than an error-channel value: it is not a data-dependent outcome a caller
+ * could handle, and the events produced would be dropped with nothing to append them.
+ *
+ * It is also what makes the nesting refusal liveable. A command runner inside a
+ * bracket is refused at the store, and this is the function a builder reaches for
+ * instead — one identifier away. A refusal is only affordable when the fix is that
+ * close.
+ *
+ * `modelAtHead` and NOT `buildDecisionModel`: this function must not derive a
+ * condition at all. The bracket owns that, and owning it in ONE place is what
+ * stops a caller appending under the last hop's condition alone.
+ *
+ * ## Bracket-only is a REQUIREMENT, so `tsc` refuses it rather than a run
+ *
+ * `ReadLedger` is named in the requirement channel and `transact` is the only thing
+ * that provides it, so a program that calls this outside a bracket cannot be RUN,
+ * and `tsc` is what says so — nothing has to execute for a caller to be told.
+ *
+ * ⚠ Measured, because the obvious stronger reading is wrong: the call site itself
+ * COMPILES. A bare `decideOnly(d, cmd)` outside a bracket is fine, and so is an
+ * exported helper over it; the requirement just propagates, as any unmet requirement
+ * does. What fails is the DISCHARGE — `Effect.provide`, `runPromise`, an annotation
+ * asking for `R = never` — possibly in another file. That is still a static refusal
+ * and it is the whole gain over the runtime defect this replaced. It is not a
+ * squiggle under the mistake.
+ *
+ * That is a PRESENCE check, and presence is the direction the type system can
+ * decide here — the same direction `transact`'s `Exclude<R, Id>` already spends on
+ * the precondition's output. ADR-0014's 2026-08-29 amendment carries the rule that
+ * follows: look for a presence check before reaching for a defect. This function
+ * shipped a defect first, and the check was available all along.
+ *
+ * ⚠ Two lines carry it and their JOBS differ. The RETURN ANNOTATION is the surface a
+ * consumer is judged against, and what the discharge above meets. The
+ * `yield* ReadLedger` keeps the requirement in the INFERRED type, so it survives the
+ * annotation being edited, and it dies at run time for the audience no type reaches
+ * — a JavaScript consumer runs no compile step — rather than handing back events
+ * with no bracket to append them. Nothing here READS the ledger; `modelAtHead` does
+ * the recording, ambiently, through `Effect.serviceOption`.
+ *
+ * ⚠ Do not try to write down which check catches which deletion. It was tried twice
+ * and was wrong twice, and `test/appendOwnership.test.ts` in the source repository
+ * says why the second failure means there should be no third attempt. Plant the
+ * mutation instead.
+ */
+const decideOnly = (decider, command) => _effect.Effect.gen(function* () {
+  yield* _readLedger.ReadLedger;
+  const {
+    state
+  } = yield* (0, _decisionModel.modelAtHead)(decider.projections(command));
+  return yield* decider.decide(state, command);
+});
+/**
+ * The sanctioned exception to the nesting refusal: append these events under NO
+ * condition, and say in the identifier and in a required `reason` why that is
+ * deliberate.
+ *
+ * It covers three cases and no others: deliberate narrowing, a genuinely
+ * unconditional creation, and a second append inside one bracket. The `reason` is
+ * ceremony on purpose, and ADR-0014 decision 6 owns why a hatch has to cost more
+ * than the safe path — that argument is a DECISION and belongs to the record that
+ * took it, so it is not restated here. How biome turns a required argument into a
+ * review signal is the source repository's `biome-plugins/unsafeAppendReported.grit`.
+ *
+ * ⚠ It BYPASSES the derived condition rather than composing with it. A caller who
+ * genuinely needs *the union, minus one event type* must restate the whole
+ * condition here. If that turns up in practice, a composing override is the
+ * additive answer and this hatch is not it.
+ *
+ * `Effect.mapInputContext` over
+ * `Context.omit(AppendIsOwned)` is what lets it through the store's ownership
+ * refusal — the one route, and `AppendIsOwned.ts` owns why removing the marker is
+ * the shape rather than a second tag or a sanctioning flag.
+ */
+exports.decideOnly = decideOnly;
+const unsafeAppend = (events,
+// Required by the signature and never read, which IS the mechanism: the value a
+// caller has to write is what a reviewer sees in the diff, and `tsc` refuses the
+// call that omits it. A lint rule asserting the same arity existed and was
+// deleted, on the ground that the type already refuses it — which made that
+// ground load-bearing, so `test/appendOwnership.test.ts` in the source repository
+// pins it. Reading the value here would give it a second job and a second place to
+// be wrong.
+//
+// NOT `_reason`, though it is unused. This name SHIPS — it is what a consumer's
+// editor offers and what the published `.d.ts` carries — and a leading underscore
+// is this ecosystem's way of saying "ignore me", which is the opposite of what a
+// required argument whose whole purpose is to be read by a human should say.
+// biome-ignore lint/correctness/noUnusedFunctionParameters: unread on purpose; this name ships in the .d.ts and an underscore would tell a consumer to ignore it
+reason) => _effect.Effect.flatMap(_core.DcbEventStore, store =>
+// ⛔ DO NOT SIMPLIFY THIS. The annotation reads as "map an empty context to an
+// empty context", and the types say nothing else — but `Context.omit` runs
+// against the RUNTIME context, which inside a bracket holds `AppendIsOwned`,
+// and removing it is the entire reason this function can append at all. That
+// marker is deliberately absent from every signature (it is read through
+// `Effect.serviceOption`, which is what keeps it out of `append`'s requirement
+// channel), so nothing here will fail to compile if this is deleted — what
+// catches it is `test/appendOwnership.test.ts` in the source repository, not the
+// type checker.
+_effect.Effect.mapInputContext(store.append(events), context => _effect.Context.omit(_core.AppendIsOwned)(context)));
+/**
+ * Open a bracket over ONE decision: evaluate the precondition inside it, hand its
+ * output to the body under the precondition's tag, and append what the body
+ * produced under the union of every read either of them performed.
+ *
+ * Curried so the precondition reads as the thing the command DECLARES and the body
+ * reads as the thing it DOES.
+ *
+ * The ownership marker is provided ALONGSIDE the ledger and to the body only, so
+ * any append inside the body — a nested bracket, a command runner, a raw
+ * `store.append` — is refused at the store as a defect, while the bracket's own
+ * closing append below runs outside that scope and is unaffected. That is why the
+ * refusal is on APPENDING rather than on opening a bracket: a command runner
+ * appends without opening one, and its events usually match the union the bracket
+ * is about to guard on, so the bracket's own close would be refused by a condition
+ * its own body invalidated.
+ *
+ * The body may succeed with `Unchanged` (see the module documentation), and the
+ * result is then `DecisionResult<O>`: `Position` for a body that cannot answer
+ * it, `Position | Unchanged` for one that can. `O` is last and defaulted, so an
+ * explicit `<E, R>` written against the narrower signature still means what it
+ * did.
+ */
+exports.unsafeAppend = unsafeAppend;
+const transact = precondition => body => _effect.Effect.gen(function* () {
+  const store = yield* _core.DcbEventStore;
+  const ledger = yield* _readLedger.makeReadLedger;
+  const output = yield* _effect.Effect.gen(function* () {
+    // ORDER IS THE DESIGN. The precondition runs first and runs HERE, with the
+    // ledger already in context, so its reads are hops in the very condition
+    // that will guard the body's write.
+    const proof = yield* precondition.evaluate;
+    return yield* body.pipe(_effect.Effect.provideService(precondition.tag, proof));
+  }).pipe(
+  // ONE layer, not two provisions, and it is the ANNOTATION above that makes
+  // that mandatory rather than tidy.
+  //
+  // TypeScript does not simplify a deferred conditional over an unresolved
+  // type variable, so `Exclude<Exclude<X, A>, B>` and
+  // `Exclude<X, A | B>` are unrelated types while `X` is still a parameter,
+  // and every provision here adds one level of nesting the annotation has to
+  // mirror EXACTLY. Both halves measured, each as a `TS2719` at the return
+  // annotation: two chained provisions refuse the flat
+  // `Exclude<PR, ReadLedger | AppendIsOwned>`, and even with this merge the
+  // flat `Exclude<R, Id | ReadLedger | AppendIsOwned>` is refused too,
+  // because the precondition's own tag is provided separately and further in.
+  // So `PR` is flat and `R` is one deep, and that asymmetry is the pipeline
+  // showing through rather than a slip.
+  //
+  // Merging says what is true anyway, which is why it is the fix rather than
+  // a cast: the ledger and the ownership marker have one lifetime and one
+  // meaning between them, and that meaning is *you are inside a bracket*.
+  _effect.Effect.provide(_effect.Layer.merge(ledger.layer, _effect.Layer.succeed(_core.AppendIsOwned, {
+    by: 'transact'
+  }))));
+  // "Already done": nothing to append, so no condition to derive and nothing
+  // for `NoReadsRecorded` to protect — that refusal guards a WRITE that would
+  // go out unguarded, and there is none. It must stay BEFORE the derivation,
+  // or an empty bracket answering `Unchanged` would be refused for a write it
+  // never asked for. The casts restate `DecisionResult<O>`, which the checker
+  // cannot relate to either branch while `O` is still a type variable.
+  if ((0, _decision.isUnchanged)(output)) {
+    return output;
+  }
+  const condition = (0, _readLedger.deriveLayeredCondition)(yield* ledger.hops);
+  if (condition === undefined) {
+    return yield* new _readLedger.NoReadsRecorded();
+  }
+  return yield* store.append(output, condition);
+});
+exports.transact = transact;
+//# sourceMappingURL=precondition.js.map

package/dist/cjs/precondition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"precondition.js","names":["_core","require","_effect","_decision","_decisionModel","_readLedger","decideOnly","decider","command","Effect","gen","ReadLedger","state","modelAtHead","projections","decide","exports","unsafeAppend","events","reason","flatMap","DcbEventStore","store","mapInputContext","append","context","Context","omit","AppendIsOwned","transact","precondition","body","ledger","makeReadLedger","output","proof","evaluate","pipe","provideService","tag","provide","Layer","merge","layer","succeed","by","isUnchanged","condition","deriveLayeredCondition","hops","undefined","NoReadsRecorded"],"sources":["../../src/precondition.ts"],"sourcesContent":[null],"mappings":";;;;;;AAwGA,IAAAA,KAAA,GAAAC,OAAA;AAEA,IAAAC,OAAA,GAAAD,OAAA;AAEA,IAAAE,SAAA,GAAAF,OAAA;AAKA,IAAAG,cAAA,GAAAH,OAAA;AAGA,IAAAI,WAAA,GAAAJ,OAAA;AAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDO,MAAMK,UAAU,GAAGA,CAOxBC,OAAqC,EACrCC,OAAgB,KAMhBC,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,OAAOC,sBAAU;EAEjB,MAAM;IAAEC;EAAK,CAAE,GAAG,OAAO,IAAAC,0BAAW,EAACN,OAAO,CAACO,WAAW,CAACN,OAAO,CAAC,CAAC;EAClE,OAAO,OAAOD,OAAO,CAACQ,MAAM,CAACH,KAAK,EAAEJ,OAAO,CAAC;AAC9C,CAAC,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;AAAAQ,OAAA,CAAAV,UAAA,GAAAA,UAAA;AAsBO,MAAMW,YAAY,GAAGA,CAC1BC,MAA2C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAC,MAAc,KAEdV,cAAM,CAACW,OAAO,CAACC,mBAAa,EAAGC,KAAK;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAb,cAAM,CAACc,eAAe,CACpBD,KAAK,CAACE,MAAM,CAACN,MAAM,CAAC,EACnBO,OAA+B,IAAKC,eAAO,CAACC,IAAI,CAACC,mBAAa,CAAC,CAACH,OAAO,CAAC,CAC1E,CACF;AAEH;;;;;;;;;;;;;;;;;;;;;;;AAAAT,OAAA,CAAAC,YAAA,GAAAA,YAAA;AAuBO,MAAMY,QAAQ,GACGC,YAA+C,IAEnEC,IAA4B,IAQ5BtB,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,MAAMY,KAAK,GAAG,OAAOD,mBAAa;EAClC,MAAMW,MAAM,GAAG,OAAOC,0BAAc;EAEpC,MAAMC,MAAM,GAAmB,OAAOzB,cAAM,CAACC,GAAG,CAAC,aAAS;IACxD;IACA;IACA;IACA,MAAMyB,KAAK,GAAG,OAAOL,YAAY,CAACM,QAAQ;IAC1C,OAAO,OAAOL,IAAI,CAACM,IAAI,CAAC5B,cAAM,CAAC6B,cAAc,CAACR,YAAY,CAACS,GAAG,EAAEJ,KAAK,CAAC,CAAC;EACzE,CAAC,CAAC,CAACE,IAAI;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA5B,cAAM,CAAC+B,OAAO,CACZC,aAAK,CAACC,KAAK,CACTV,MAAM,CAACW,KAAK,EACZF,aAAK,CAACG,OAAO,CAAChB,mBAAa,EAAE;IAAEiB,EAAE,EAAE;EAAU,CAAE,CAAC,CACjD,CACF,CACF;EAED;EACA;EACA;EACA;EACA;EACA;EACA,IAAI,IAAAC,qBAAW,EAACZ,MAAM,CAAC,EAAE;IACvB,OAAOA,MAA2B;EACpC;EAEA,MAAMa,SAAS,GAAG,IAAAC,kCAAsB,EAAC,OAAOhB,MAAM,CAACiB,IAAI,CAAC;EAC5D,IAAIF,SAAS,KAAKG,SAAS,EAAE;IAC3B,OAAO,OAAO,IAAIC,2BAAe,EAAE;EACrC;EAEA,OAAQ,OAAO7B,KAAK,CAACE,MAAM,CAACU,MAAM,EAAEa,SAAS,CAAC;AAChD,CAAC,CAAC;AAAA/B,OAAA,CAAAa,QAAA,GAAAA,QAAA","ignoreList":[]}

package/dist/cjs/readLedger.js

@@ -0,0 +1,224 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.recordQuery = exports.makeReadLedger = exports.deriveLayeredCondition = exports.assertServableAddition = exports.ambientLayeredCondition = exports.TaglessSliceInLedger = exports.ReadLedger = exports.NoReadsRecorded = void 0;
+var _core = require("@kairos-es/core");
+var _effect = require("effect");
+/**
+ * The ambient ledger, present only inside a bracket.
+ *
+ * ⚠ A RECORDING path reads it with `Effect.serviceOption` and never
+ * `yield* ReadLedger`: its absence is the normal case there, and costing the
+ * requirement channel nothing is exactly what makes this change additive.
+ * `modelAtHead` is that path and is why the rule exists.
+ *
+ * A BRACKET-ONLY function is the opposite case and yields the tag deliberately.
+ * `decideOnly` does, and naming the requirement is what turns *"call me inside a
+ * bracket"* from a runtime defect into a compile error — presence being the one
+ * direction the type system can decide here. So the test is what the function
+ * means outside a bracket: nothing (record ambiently), or nothing sensible
+ * (require it).
+ *
+ * Recording is two-phase, and `record`'s own doc below owns why and what shape the
+ * second phase takes.
+ */
+class ReadLedger extends /*#__PURE__*/_effect.Context.Tag('@kairos-es/codec/ReadLedger')() {}
+/**
+ * Raised when a bracket closes having recorded no read at all.
+ *
+ * On the ERROR channel and deliberately split from the nested-append DEFECT,
+ * because the two are different mistakes. An empty bracket can arise from a
+ * data-dependent branch that produces events without reading — a genuinely
+ * unconditional creation, written inside a bracket by mistake — where a nested
+ * append is always a wiring fault. An error-channel value lets a caller decide
+ * which it is.
+ *
+ * Its job is narrower than it looks, and the narrowing is worth stating because
+ * the wider reading is the tempting one. Once a bracket's guard is itself a fold,
+ * a body that reads nothing still has a hop, so this cannot fire — it is the guard
+ * against an unguarded UNCONDITIONAL bracket, not against an unguarded bracket. A
+ * bracket that looks guarded and is not is NOT what this catches and never was,
+ * and nothing else catches it either — `precondition.ts` owns that gap and the
+ * rule a reader has to keep in its place. A refusal taken BEFORE reading is not
+ * this case either: it short-circuits and surfaces as the refusal.
+ */
+exports.ReadLedger = ReadLedger;
+class NoReadsRecorded extends /*#__PURE__*/_effect.Data.TaggedError('NoReadsRecorded') {
+  /**
+   * The sentence, as the `Error` field that says why — so the fault renders
+   * ITSELF, exactly as this package's other two errors do (`errors.ts` owns the
+   * argument for the mechanism and it is not restated here).
+   *
+   * A getter over a constant rather than a constructor field, because there is no
+   * datum to vary: every raise of this error means one thing.
+   */
+  get message() {
+    return 'the bracket closed having recorded no read, so there is no append condition ' + 'to derive. A decision that reads nothing is unconditional — say so with the ' + 'escape hatch, which takes a reason, rather than by opening a bracket.';
+  }
+}
+/**
+ * Raised when recording a hop would leave the bracket's accumulated union
+ * unservable.
+ *
+ * The store refuses a multi-item query in which any item is tagless, and it
+ * refuses it by THROWING inside the append decorator, which becomes a defect:
+ * uncatchable, one call and one layer away from the `build()` that chose no tags.
+ * A slice built without tags defaults to none, so it is perfectly servable alone
+ * and kills the append the moment it is unioned. This moves that failure onto the
+ * error channel, to the read that caused it, naming the record entry to fix.
+ *
+ * It refuses an unservable UNION and not every tagless hop, which is the easy
+ * mistake to make in the other direction: one tagless slice read on its own is
+ * servable and must keep working. Two cases reach it — a tagless hop unioned with
+ * another, and a single hop whose own RECORD holds two tagless slices, which
+ * composes to a multi-item query with no second hop needed.
+ */
+exports.NoReadsRecorded = NoReadsRecorded;
+class TaglessSliceInLedger extends /*#__PURE__*/_effect.Data.TaggedError('TaglessSliceInLedger') {
+  /** The offending slice and the remedy, in one sentence. */
+  get message() {
+    return `slice '${this.sliceKey}' was built with no tags, and this bracket now reads ` + 'more than one slice. A layered append condition unions every query it ' + 'recorded, and the store refuses a multi-item query if any item is tagless. ' + 'Pass `build({ tags: [...] })` for this slice.';
+  }
+}
+/**
+ * The ONE derivation: the union of every query walked, at the earliest head
+ * observed. Package-internal, for the reason the module doc gives.
+ *
+ * The union goes through core's own `unionQueries` — the merge
+ * `composeProjections` folds a record through, reached without one — and never a
+ * spread of `items`, because a wildcard hop (`items: []`) is ABSORBING under OR
+ * while a spread of an empty list contributes nothing, so hand-rolling the union
+ * narrows a match-everything hop to its sibling, silently and in the unsafe
+ * direction. A
+ * repeated or overlapping hop is harmless because this derives ONCE from a merged
+ * set and matching is idempotent over an OR; that property belongs to deriving
+ * once and would be lost by a refactor to per-hop evaluation.
+ *
+ * ## When any hop is headless the floor is `ORIGIN`, and the alternative is unsound
+ *
+ * The earliest head that actually ARRIVED is refused, and is named here as refused
+ * rather than merely not chosen, because it is what a reader writes by accident
+ * when told to take the earliest head. With one headless hop among completed hops
+ * the union looks right and the floor betrays it, sitting already above the
+ * invalidating event.
+ *
+ * `ORIGIN`'s cost is measured rather than described: it refuses every append to
+ * any identity that already has history, so it is not a conservative default but a
+ * hard stop. It is affordable only because conflict retry wraps the bracket from
+ * OUTSIDE and re-reads, which is the rule the whole shape depends on.
+ */
+exports.TaglessSliceInLedger = TaglessSliceInLedger;
+const deriveLayeredCondition = hops => {
+  if (hops.length === 0) {
+    return undefined;
+  }
+  const merged = (0, _core.unionQueries)(hops.map(hop => hop.query));
+  const arrived = hops.flatMap(hop => hop.head === undefined ? [] : [hop.head]);
+  // A headless hop widens the guard to the whole log. Unioning its query is the
+  // half that is not in dispute; the floor is where the two readings diverge.
+  const after = arrived.length === hops.length ? arrived.reduce((a, b) => b < a ? b : a) : _core.ORIGIN;
+  return {
+    failIfEventsMatch: merged,
+    after
+  };
+};
+/**
+ * A fresh ledger and the `Layer` providing it: a `Ref` of hops behind the two-phase
+ * `record` the service declares.
+ *
+ * The hops effect is handed back beside the layer because the bracket reads them
+ * AFTER the body has run and the layer is out of scope, which is the same moment it
+ * stops being able to reach the service.
+ */
+exports.deriveLayeredCondition = deriveLayeredCondition;
+const makeReadLedger = exports.makeReadLedger = /*#__PURE__*/_effect.Effect.gen(function* () {
+  const ref = yield* _effect.Ref.make([]);
+  return {
+    layer: _effect.Layer.succeed(ReadLedger, {
+      record: query => _effect.Ref.modify(ref, hops => [
+      // The close effect closes over the slot this hop just took, so the slot
+      // never becomes a value anything else has to carry or interpret.
+      head => _effect.Ref.update(ref, current => current.map((hop, index) => index === hops.length ? {
+        query: hop.query,
+        head
+      } : hop)), [...hops, {
+        query
+      }]]),
+      hops: _effect.Ref.get(ref)
+    }),
+    // The same effect the service exposes, reachable AFTER the layer is out of
+    // scope — which is exactly when the bracket derives.
+    hops: _effect.Ref.get(ref)
+  };
+});
+/**
+ * Run `f` against the ambient ledger, or answer `absent` when there is none.
+ *
+ * "Outside a bracket this is a no-op" is ONE fact stated once, rather than one
+ * per consumer free to drift from the others. Every ambient lookup in this module
+ * goes through here, which is also what keeps `Effect.serviceOption` — the reason
+ * nothing enters the requirement channel — from being a detail each caller has to
+ * remember.
+ */
+const withLedger = (absent, f) => _effect.Effect.flatMap(_effect.Effect.serviceOption(ReadLedger), ledger => _effect.Option.isNone(ledger) ? _effect.Effect.succeed(absent) : f(ledger.value));
+/** A close effect that does nothing: what a read outside a bracket gets back. */
+const NO_CLOSE = () => _effect.Effect.void;
+/**
+ * File a query into the ambient ledger if there is one, and hand back the effect
+ * that completes it. Outside a bracket the whole thing is a no-op, and the caller
+ * still writes one line rather than a conditional.
+ */
+const recordQuery = query => withLedger(NO_CLOSE, ledger => ledger.record(query));
+/** The tagless slice keys in a record, in declaration order. */
+exports.recordQuery = recordQuery;
+const taglessKeys = projections => Object.entries(projections).filter(([, projection]) => projection.query.items.some(item => item.tags.length === 0)).map(([key]) => key);
+/** Would recording this record's query leave the accumulated union unservable? */
+const unionWouldBeUnservable = (existing, incoming) => (0, _core.servableQueryFault)((0, _core.unionQueries)([...existing.map(h => h.query), incoming])) !== undefined;
+/**
+ * Refuse a read that would leave the bracket's accumulated union unservable,
+ * BEFORE the read is paid for.
+ *
+ * Servability is answerable from the queries alone, so the check runs when a hop is
+ * recorded rather than at append time — the eager half of the eager/lazy split doing
+ * one more job. Outside a bracket nothing is unioned and nothing is unservable, so
+ * the ordinary single-hop caller is untaxed.
+ *
+ * It judges the PROSPECTIVE UNION and asks core for the verdict, which is what makes
+ * both failing shapes one case rather than two. An earlier version tested each
+ * recorded query separately and treated a FIRST hop as unconditionally fine — but a
+ * hop is a RECORD, and a record of two tagless slices composes to a multi-item query
+ * that is unservable on its own. That read died at the store, uncatchably, on the
+ * exact path this error exists to keep off the defect channel. A grammar with two
+ * homes drifts at the shapes neither author had in mind, so there is one home and it
+ * is `servableQueryFault`'s.
+ *
+ * Where the OFFENDING slice is THIS record's the ledger can name its key; where it
+ * belongs to an earlier hop it can only say so, a recorded hop keeping its query
+ * rather than the key it was composed from. That asymmetry is diagnostic-only and is
+ * why the message is built from a key that may be a placeholder.
+ */
+const assertServableAddition = projections => withLedger(undefined, ledger => _effect.Effect.flatMap(ledger.hops, existing => {
+  const incoming = (0, _core.composeProjections)(projections).query;
+  if (!unionWouldBeUnservable(existing, incoming)) {
+    return _effect.Effect.void;
+  }
+  // The offending key where the tagless slice is THIS record's, and a
+  // placeholder where it belongs to an earlier hop — a recorded hop keeps its
+  // query rather than the key it was composed from.
+  const offending = taglessKeys(projections)[0] ?? '<an earlier hop>';
+  return new TaglessSliceInLedger({
+    sliceKey: offending
+  });
+}));
+/**
+ * The condition the ambient ledger derives right now, or `None` outside a bracket.
+ *
+ * This is what makes `buildDecisionModel` correct inside a bracket: the call whose
+ * current behaviour is the hazard derives from every hop the bracket walked rather
+ * than from its own single read.
+ */
+exports.assertServableAddition = assertServableAddition;
+const ambientLayeredCondition = exports.ambientLayeredCondition = /*#__PURE__*/withLedger(/*#__PURE__*/_effect.Option.none(), ledger => _effect.Effect.map(ledger.hops, hops => _effect.Option.fromNullable(deriveLayeredCondition(hops))));
+//# sourceMappingURL=readLedger.js.map

package/dist/cjs/readLedger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readLedger.js","names":["_core","require","_effect","ReadLedger","Context","Tag","exports","NoReadsRecorded","Data","TaggedError","message","TaglessSliceInLedger","sliceKey","deriveLayeredCondition","hops","length","undefined","merged","unionQueries","map","hop","query","arrived","flatMap","head","after","reduce","a","b","ORIGIN","failIfEventsMatch","makeReadLedger","Effect","gen","ref","Ref","make","layer","Layer","succeed","record","modify","update","current","index","get","withLedger","absent","f","serviceOption","ledger","Option","isNone","value","NO_CLOSE","void","recordQuery","taglessKeys","projections","Object","entries","filter","projection","items","some","item","tags","key","unionWouldBeUnservable","existing","incoming","servableQueryFault","h","assertServableAddition","composeProjections","offending","ambientLayeredCondition","none","fromNullable"],"sources":["../../src/readLedger.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/dts/decider.d.ts

@@ -52,14 +52,27 @@
  * boundary, and decode may fail with `CodecError`. All surface on the error
  * channel, so a caller handles all three the same way — and
  * `@kairos-es/testing`'s `.thenError(tag)` can assert any of them.
+ *
+ * `decide` may also answer `Unchanged` — "already done, nothing to append" — but
+ * only where its type says so: `Decider`'s fifth type parameter `O` defaults to
+ * the non-empty batch, and `runDecider` returns `DecisionResult<O>`, which is
+ * plain `Position` unless `O` admits `Unchanged`. So a decider that cannot say
+ * "already done" keeps exactly the result type it always had — an untyped one
+ * and one built in a wrapper generic in its success type included — and one
+ * that can makes its caller handle `Position | Unchanged`. `runDecider` returns an
+ * `Unchanged` without calling `append`, so `append`'s refusal of an empty batch
+ * is untouched and never met. `decision.ts` owns why it is a success rather than
+ * an error or an empty batch, and why it is recognised by a type id.
  */
-import type { AppendConditionFailed, CompositeState, DcbEvent, Position } from '@kairos-es/core';
+import type { AppendConditionFailed, CompositeState, DcbEvent } from '@kairos-es/core';
 import { DcbEventStore } from '@kairos-es/core';
 import type { Array as Arr } from 'effect';
 import { Effect } from 'effect';
+import { type DecisionOutput, type DecisionResult } from './decision.js';
 import { type RequirementOf } from './decisionModel.js';
 import type { CodecError } from './errors.js';
 import type { SliceProjection } from './projection.js';
+import type { TaglessSliceInLedger } from './readLedger.js';
 import type { Serializer } from './Serializer.js';
 import type { Uuid } from './Uuid.js';
 /**
@@ -76,10 +89,17 @@ import type { Uuid } from './Uuid.js';
  * schema-backed, state-erased bound for a heterogeneous record); the
  * precise per-key state is recovered by core's shared `CompositeState`. The
  * requirement `R` is the union carried by the record's slices' schemas.
+ *
+ * `O` is what `decide` may succeed with. It defaults to the non-empty batch, and
+ * a decider that can answer "already done" widens it to `DecisionOutput`
+ * (`NonEmptyReadonlyArray<DcbEvent> | Unchanged`). It is LAST and DEFAULTED so
+ * that every `Decider<P, Command, E, R>` already written means exactly what it
+ * meant. Its bound is `DecisionOutput`, which still excludes a possibly-empty
+ * array — the widening adds an answer and removes no guarantee.
  */
-export interface Decider<P extends Record<string, SliceProjection>, Command, E = never, R = never> {
+export interface Decider<P extends Record<string, SliceProjection>, Command, E = never, R = never, O extends DecisionOutput = Arr.NonEmptyReadonlyArray<DcbEvent>> {
     readonly projections: (command: Command) => P;
-    readonly decide: (state: CompositeState<P>, command: Command) => Effect.Effect<Arr.NonEmptyReadonlyArray<DcbEvent>, E, Serializer | Uuid | R>;
+    readonly decide: (state: CompositeState<P>, command: Command) => Effect.Effect<O, E, Serializer | Uuid | R>;
 }
 /**
  * Build a `Decider` with all four of its type arguments INFERRED: the slice
@@ -128,6 +148,22 @@ export interface Decider<P extends Record<string, SliceProjection>, Command, E =
  * Effect.Error<Eff>, …>`. The value is the two functions it was handed, so
  * there is nothing for the cast to be wrong about.
  *
+ * The success channel is how a decider opts into `Unchanged` without writing a
+ * fifth type argument, and it is why this function is declared TWICE. The first
+ * declaration bounds `Eff` by the non-empty batch and returns a `Decider` with
+ * the DEFAULT `O`; the second bounds it by `DecisionOutput` and returns one whose
+ * `O` is `DecisionOutput`. A `decide` with a branch returning
+ * `Decision.unchanged(…)` fails the first bound and lands on the second, and one
+ * with no such branch keeps the default. Either way `O` is one of the two a
+ * caller ever writes, never the inferred success type passed through: inference
+ * is more precise than anyone writes — the produce path's one-element tuple, say
+ * — and a `Decider<…, readonly [DcbEvent]>` would not be the
+ * `Decider<P, Command, E, R>` its caller spells, though it behaves identically.
+ * Asking by ASSIGNABILITY rather than by a conditional over `Eff`'s success is
+ * what keeps an untyped (`any`) success, and a success that is a type variable
+ * bounded by the batch, on the default; `decision.ts` owns that argument, and
+ * the one type query the pair cannot answer as before.
+ *
  * `R` excludes `Serializer | Uuid` because that is what `R` MEANS on `Decider`:
  * the interface writes decide's requirement as `Serializer | Uuid | R`, so `R`
  * is what the produce side needs BEYOND the codec's own two services. Leaving
@@ -139,19 +175,32 @@ export interface Decider<P extends Record<string, SliceProjection>, Command, E =
  * `@kairos-es/codec/Serializer` matches — and a tag under that key IS that
  * service, context being keyed by the same string at runtime.
  */
-export declare const decider: <P extends Record<string, SliceProjection>, Command, Eff extends Effect.Effect<Arr.NonEmptyReadonlyArray<DcbEvent>, unknown, unknown>>(projections: (command: Command) => P, decide: (state: CompositeState<P>, command: Command) => Eff) => Decider<P, Command, Effect.Effect.Error<Eff>, Exclude<Effect.Effect.Context<Eff>, Serializer | Uuid>>;
+export declare function decider<P extends Record<string, SliceProjection>, Command, Eff extends Effect.Effect<Arr.NonEmptyReadonlyArray<DcbEvent>, unknown, unknown>>(projections: (command: Command) => P, decide: (state: CompositeState<P>, command: Command) => Eff): Decider<P, Command, Effect.Effect.Error<Eff>, Exclude<Effect.Effect.Context<Eff>, Serializer | Uuid>>;
+export declare function decider<P extends Record<string, SliceProjection>, Command, Eff extends Effect.Effect<DecisionOutput, unknown, unknown>>(projections: (command: Command) => P, decide: (state: CompositeState<P>, command: Command) => Eff): Decider<P, Command, Effect.Effect.Error<Eff>, Exclude<Effect.Effect.Context<Eff>, Serializer | Uuid>, DecisionOutput>;
 /**
  * Run the full DCB command cycle for a decider against the ambient
  * `DcbEventStore`: build the decision model (real read + decode + fold), decide,
- * and append under the read's append condition. Returns the last new position.
+ * and append under the read's append condition. Returns the last new position —
+ * or, when `decide` answered `Unchanged`, that `Unchanged`, having appended
+ * nothing. The result type is `DecisionResult<O>`, so it is plain `Position` for
+ * every decider that cannot answer `Unchanged`, including one whose `O` is still
+ * a type variable bounded by the batch. ONE signature, deliberately:
+ * `decision.ts` says why that alias, and not an overload, is what carries it.
  *
  * The requirement is `DcbEventStore | Serializer | Uuid | R |
  * RequirementOf<P>`: `Serializer` enters through both the decode
  * (`buildDecisionModel`) and produce (`toEvent`) sides, `Uuid` through produce,
  * the slices' `RequirementOf<P>` through decode, and `R` through produce. (For a
  * def whose `Schema` carries a requirement, `RequirementOf<P>` and `R` are the
- * same tag.) Any `decide` failure, a decode `CodecError`, or an
- * `AppendConditionFailed` propagates on the error channel unchanged.
+ * same tag.) Any `decide` failure, a decode `CodecError`, an
+ * `AppendConditionFailed`, or the read's own `TaglessSliceInLedger` propagates on
+ * the error channel unchanged.
+ *
+ * ⚠ INSIDE a bracket this function is REFUSED, as a defect, at the store's shared
+ * append decorator, and `decideOnly` is what a body reaches for instead.
+ * `index.ts` states that pair, why each refuses exactly where the other is the
+ * answer, and why neither can be expressed over the other. Read it before
+ * changing either signature; this file does not restate the argument.
  */
-export declare const runDecider: <P extends Record<string, SliceProjection>, Command, E, R>(decider: Decider<P, Command, E, R>, command: Command) => Effect.Effect<Position, E | CodecError | AppendConditionFailed, DcbEventStore | Serializer | Uuid | R | RequirementOf<P>>;
+export declare const runDecider: <P extends Record<string, SliceProjection>, Command, E, R, O extends DecisionOutput = Arr.NonEmptyReadonlyArray<DcbEvent>>(decider: Decider<P, Command, E, R, O>, command: Command) => Effect.Effect<DecisionResult<O>, E | CodecError | AppendConditionFailed | TaglessSliceInLedger, DcbEventStore | Serializer | Uuid | R | RequirementOf<P>>;
 //# sourceMappingURL=decider.d.ts.map

package/dist/dts/decider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decider.d.ts","sourceRoot":"","sources":["../../src/decider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,KAAK,EACV,qBAAqB,EACrB,cAAc,EACd,QAAQ,EACR,QAAQ,EACT,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,KAAK,EAAE,KAAK,IAAI,GAAG,EAAE,MAAM,QAAQ,CAAA;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AACxE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAElC;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,OAAO,CACtB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EACzC,OAAO,EACP,CAAC,GAAG,KAAK,EACT,CAAC,GAAG,KAAK;IAET,QAAQ,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,CAAC,CAAA;IAC7C,QAAQ,CAAC,MAAM,EAAE,CACf,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,EACxB,OAAO,EAAE,OAAO,KACb,MAAM,CAAC,MAAM,CAChB,GAAG,CAAC,qBAAqB,CAAC,QAAQ,CAAC,EACnC,CAAC,EACD,UAAU,GAAG,IAAI,GAAG,CAAC,CACtB,CAAA;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,OAAO,GAClB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EACzC,OAAO,EACP,GAAG,SAAS,MAAM,CAAC,MAAM,CACvB,GAAG,CAAC,qBAAqB,CAAC,QAAQ,CAAC,EACnC,OAAO,EACP,OAAO,CACR,EAED,aAAa,CAAC,OAAO,EAAE,OAAO,KAAK,CAAC,EACpC,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,KAAK,GAAG,KAC1D,OAAO,CACR,CAAC,EACD,OAAO,EACP,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EACxB,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC,CAOrD,CAAA;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,GACrB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,EACzC,OAAO,EACP,CAAC,EACD,CAAC,EAED,SAAS,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,EAClC,SAAS,OAAO,KACf,MAAM,CAAC,MAAM,CACd,QAAQ,EACR,CAAC,GAAG,UAAU,GAAG,qBAAqB,EACtC,aAAa,GAAG,UAAU,GAAG,IAAI,GAAG,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAStD,CAAA"}
+{"version":3,"file":"decider.d.ts","sourceRoot":"","sources":["../../src/decider.ts"],"names":[],"mappings":"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"}