@toa.io/boot 1.0.0-alpha.270 → 1.0.0-alpha.272

package/CHANGELOG.md

@@ -3,6 +3,52 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.0.0-alpha.272](https://github.com/toa-io/toa/compare/v1.0.0-alpha.271...v1.0.0-alpha.272) (2026-09-01)
+
+
+### Bug Fixes
+
+* **amqp:** keep a receiver apart from the producers it delivers into ([4c2f43e](https://github.com/toa-io/toa/commit/4c2f43ebde68ba76a1fd277fe2a3305be1b622ef))
+* **amqp:** tear a receiver down before its producers, and drop the split ([e6c1154](https://github.com/toa-io/toa/commit/e6c1154024df22f7a470c47c1a79bd170fe7e3b2))
+
+
+* refactor(atomicity)!: take the lock manager from the stash ([4fd91eb](https://github.com/toa-io/toa/commit/4fd91eb2fdb68f7b87aaf16d182794bbc567ba57))
+* refactor(atomicity)!: make the connector a family, not a partitioner ([06fd63a](https://github.com/toa-io/toa/commit/06fd63ad6296b724ef83afccf4e4e25d0bcaf080))
+* refactor(atomicity)!: rename the connector and free it of the outbox ([21f1a41](https://github.com/toa-io/toa/commit/21f1a41aceafcfd35c7620014062fe46b54afa95))
+* feat(core)!: commit events with the state that produced them ([1eb68cc](https://github.com/toa-io/toa/commit/1eb68cc435dbfa03faa16009fceb866693d22e1a)), closes [#20](https://github.com/toa-io/toa/issues/20)
+
+
+### Features
+
+* **core:** give every component an atom aspect ([b501b9c](https://github.com/toa-io/toa/commit/b501b9cd3d5f5408d9faa71213e953fe2792cf9f))
+
+
+### BREAKING CHANGES
+
+* `context.stash.lock` is gone; lock through `context.atom` instead.
+A stash pointer resolving to several addresses now uses the first.
+
+Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
+* `Factory.partition(group)` is `Factory.atom(group)`, and the
+`Partition` it returned is an `Atom`. `slots(total)` is unchanged.
+
+Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
+* `@toa.io/partitions.redis` is now `@toa.io/atomicity`, and its
+`lanes(total)` is `slots(total)`. Redis is declared as `atomicity` in the context
+rather than `outbox.redis`, and read from `TOA_ATOMICITY_REDIS`.
+`TOA_OUTBOX_PARTITION_INTERVAL` is `TOA_ATOMICITY_INTERVAL`.
+
+Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
+* `event.changeset` is removed; use `origin` and `state`. `State`
+takes an `Outbox` in place of an `Emission`. `difference` is dropped from
+`@toa.io/generic` along with its last caller.
+
+Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
+
+
+
+
+
 # [1.0.0-alpha.270](https://github.com/toa-io/toa/compare/v1.0.0-alpha.269...v1.0.0-alpha.270) (2026-08-31)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/boot",
-  "version": "1.0.0-alpha.270",
+  "version": "1.0.0-alpha.272",
   "description": "Toa Boot",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -20,14 +20,15 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@toa.io/core": "1.0.0-alpha.270",
-    "@toa.io/filesystem": "1.0.0-alpha.254",
-    "@toa.io/generic": "1.0.0-alpha.254",
-    "@toa.io/norm": "1.0.0-alpha.270",
-    "@toa.io/schemas": "1.0.0-alpha.270",
+    "@toa.io/atomicity": "1.0.0-alpha.272",
+    "@toa.io/core": "1.0.0-alpha.272",
+    "@toa.io/filesystem": "1.0.0-alpha.272",
+    "@toa.io/generic": "1.0.0-alpha.272",
+    "@toa.io/norm": "1.0.0-alpha.272",
+    "@toa.io/schemas": "1.0.0-alpha.272",
     "clone-deep": "4.0.1",
     "dotenv": "16.1.1",
-    "openspan": "1.0.0-alpha.270"
+    "openspan": "1.0.0-alpha.272"
   },
-  "gitHead": "94400bdd411b4c25074ffcf58184580ddd060268"
+  "gitHead": "1a451755445935c04cf5b373bcc73942cac0bb10"
 }

package/src/atom.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const { Connector } = require('@toa.io/core')
+
+const boot = require('./index')
+
+/**
+ * The atom as a system aspect. Every component has `context.atom`, with nothing declared in its
+ * manifest and nothing of its own to configure.
+ *
+ * @implements {toa.core.extensions.Aspect}
+ */
+class Aspect extends Connector {
+  name = 'atom'
+
+  #atom
+
+  constructor (atom) {
+    super()
+
+    this.#atom = atom
+
+    this.depends(atom)
+  }
+
+  // the methods are named rather than forwarded, so that the connector's lifecycle is not
+  // reachable from an algorithm
+  invoke (method, ...args) {
+    switch (method) {
+      case 'slots': return this.#atom.slots(...args)
+      case 'meter': return this.#atom.meter(...args)
+      case 'lock': return this.#atom.lock(...args)
+      default: throw new Error(`Atom aspect has no '${method}' method`)
+    }
+  }
+}
+
+/** @param {string} group */
+const atom = (group) => new Aspect(boot.atomicity(group))
+
+exports.atom = atom

package/src/atomicity.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const { Factory } = require('@toa.io/atomicity')
+
+/**
+ * What the replicas of one group decide together. Every component has one, whether or not there
+ * is anything to coordinate through: without a Redis nothing is owned and nothing is metered —
+ * see the connector's readme.
+ *
+ * @param {string} group
+ * @returns {toa.core.atomicity.Atom}
+ */
+const atomicity = (group) => new Factory().atom(group)
+
+exports.atomicity = atomicity

package/src/component.js

@@ -14,9 +14,13 @@ const component = async (manifest) => {
 
 const create = async (manifest, locator) => {
   boot.extensions.load(manifest)
-  const storage = boot.storage(manifest)
+
+  // the storage is told whether there will be an outbox, so the events come first
+  const events = boot.events(manifest)
+  const storage = boot.storage(manifest, events !== undefined)
   const context = await boot.context(manifest)
-  const emission = boot.emission(manifest.events, locator, context)
+  const emission = boot.emission(events, locator, context)
+  const outbox = boot.outbox(manifest, storage, emission)
 
   let state
 
@@ -25,7 +29,7 @@ const create = async (manifest, locator) => {
     const guards = await boot.guards(manifest, context)
     const entity = new entities.Factory(schema, guards)
 
-    state = new State(storage, entity, emission, manifest.entity.associated)
+    state = new State(storage, entity, outbox, manifest.entity.associated)
   }
 
   const phases = await boot.rc(manifest, context)
@@ -33,7 +37,10 @@ const create = async (manifest, locator) => {
   const component = new Component(locator, operations)
 
   if (storage) component.depends(storage)
-  if (emission) component.depends(emission)
+
+  // the outbox owns the emission and the storage, so it drains before either goes down
+  if (outbox) component.depends(outbox)
+  else if (emission) component.depends(emission)
 
   const decorated = boot.extensions.component(component)
 

package/src/composition.js

@@ -42,8 +42,20 @@ async function composition (paths, options) {
       for (let i = 0; i < components.length; i++) {
         const { local, other } = groups[i]
         const settle = components[i].settle
-
-        producers.push(...local, ...other)
+        const serving = [...local, ...other]
+
+        producers.push(...serving)
+
+        /*
+         * A receiver turns an event into a call to an operation of its own component, and
+         * that call is served by these — the loop producer first, the broker's if it has
+         * already gone. They are siblings under the composition otherwise, so a receiver
+         * still draining a delivery would be left calling something already torn down.
+         */
+        // one at a time: `depends` given an array links the group it makes rather than its
+        // members, and it is the members whose teardown has to wait for this one
+        for (const receiver of receivers[i])
+          for (const producer of serving) receiver.depends(producer)
 
         if (settle === undefined)
           continue

package/src/context.js

@@ -8,6 +8,9 @@ const context = async (manifest) => {
   const local = await boot.remote(manifest.locator, undefined, manifest)
   const aspects = boot.extensions.aspects(manifest)
 
+  // a system aspect: it is there in every component, declared by none of them
+  aspects.push(boot.atom(manifest.locator.id))
+
   const lookup = async (namespace, name) => {
     const locator = new Locator(name, namespace)
     const remote = await boot.remote(locator)

package/src/events.js

@@ -0,0 +1,29 @@
+'use strict'
+
+/**
+ * The events of this component that something consumes. An event nobody consumes is not
+ * published, so it gets no emitter and no exchange, and a component none of whose events are
+ * consumed gets no emission — and therefore no outbox and no transaction.
+ *
+ * The deployment computes this from the whole context. Without one — a local run, `toa mono`,
+ * a composition booted in a test — the variable is absent and every event is published.
+ *
+ * @param {toa.norm.Component} manifest
+ * @returns {toa.norm.Events | undefined}
+ */
+const events = (manifest) => {
+  if (manifest.events === undefined) return
+
+  const value = process.env[VARIABLE + manifest.locator.uppercase]
+
+  if (value === undefined) return manifest.events
+
+  const consumed = new Set(value.split(' ').filter(Boolean))
+  const entries = Object.entries(manifest.events).filter(([label]) => consumed.has(label))
+
+  return entries.length === 0 ? undefined : Object.fromEntries(entries)
+}
+
+const VARIABLE = 'TOA_EVENTS_'
+
+exports.events = events

package/src/index.js

@@ -8,6 +8,10 @@ const { component } = require('./component')
 const { composition } = require('./composition')
 const { context } = require('./context')
 const { emission } = require('./emission')
+const { events } = require('./events')
+const { outbox } = require('./outbox')
+const { atomicity } = require('./atomicity')
+const { atom } = require('./atom')
 const { exposition } = require('./exposition')
 const { manifest } = require('./manifest')
 const { operation } = require('./operation')
@@ -29,6 +33,10 @@ exports.component = component
 exports.composition = composition
 exports.context = context
 exports.emission = emission
+exports.events = events
+exports.outbox = outbox
+exports.atomicity = atomicity
+exports.atom = atom
 exports.exposition = exposition
 exports.manifest = manifest
 exports.operation = operation

package/src/outbox.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const { Outbox } = require('@toa.io/core')
+
+const boot = require('./index')
+
+/**
+ * A component with no declared events has nothing to publish and therefore no outbox — the
+ * static check that keeps the common case free of a transaction.
+ *
+ * @param {toa.norm.Component} manifest
+ * @param {toa.core.Storage} [storage]
+ * @param {toa.core.Emission} [emission]
+ */
+const outbox = (manifest, storage, emission) => {
+  if (emission === undefined) return
+
+  return new Outbox(emission, storage, boot.atomicity(manifest.locator.id), {})
+}
+
+exports.outbox = outbox

package/src/storage.js

@@ -3,14 +3,19 @@
 const { join } = require('node:path')
 const extensions = require('./extensions')
 
-const storage = (manifest) => {
+/**
+ * @param {toa.norm.Component} manifest
+ * @param {boolean} outbox whether this component publishes anything, and so needs a place to
+ *   commit it with the entity
+ */
+const storage = (manifest, outbox) => {
   if (manifest.entity === undefined) return
 
   const Factory = load(manifest)
 
   /** @type {toa.core.storages.Factory} */
   const factory = new Factory()
-  const storage = factory.storage(manifest.locator, manifest.entity)
+  const storage = factory.storage(manifest.locator, manifest.entity, { outbox })
 
   return extensions.storage(storage)
 }