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

package/CHANGELOG.md

@@ -0,0 +1,136 @@
+# Change Log
+
+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)
+
+
+### Performance Improvements
+
+* **boot:** stop paying for what a composition does not need to start ([1619c27](https://github.com/toa-io/toa/commit/1619c2743072f4706939ce72f3074e615d26a91e))
+* **openspan:** create a span only when something records it ([a6efb0e](https://github.com/toa-io/toa/commit/a6efb0eed38393f4c169b067f23d7447f0169bca))
+
+
+
+
+
+# [1.0.0-alpha.266](https://github.com/toa-io/toa/compare/v1.0.0-alpha.265...v1.0.0-alpha.266) (2026-08-29)
+
+**Note:** Version bump only for package @toa.io/boot
+
+
+
+
+
+# [1.0.0-alpha.265](https://github.com/toa-io/toa/compare/v1.0.0-alpha.264...v1.0.0-alpha.265) (2026-08-29)
+
+
+### Features
+
+* **bridges.node:** add the dispose run command phase ([00df715](https://github.com/toa-io/toa/commit/00df7158f638b976ab09d4007102a4ead3c696c3))
+
+
+
+
+
+# [1.0.0-alpha.264](https://github.com/toa-io/toa/compare/v1.0.0-alpha.263...v1.0.0-alpha.264) (2026-08-29)
+
+**Note:** Version bump only for package @toa.io/boot
+
+
+
+
+
+# [1.0.0-alpha.263](https://github.com/toa-io/toa/compare/v1.0.0-alpha.262...v1.0.0-alpha.263) (2026-08-29)
+
+**Note:** Version bump only for package @toa.io/boot
+
+
+
+
+
+# [1.0.0-alpha.262](https://github.com/toa-io/toa/compare/v1.0.0-alpha.261...v1.0.0-alpha.262) (2026-08-28)
+
+
+### Bug Fixes
+
+* **boot:** let the composition own the process discovery ([2201e88](https://github.com/toa-io/toa/commit/2201e8852517fd1d2822c775c9b126eb60399580))
+
+
+### Features
+
+* **core:** identify the origin of a call with `request.source` ([9da6b66](https://github.com/toa-io/toa/commit/9da6b66df852690351a1e82c7b8cc176fd89774a))
+
+
+
+
+
+# [1.0.0-alpha.259](https://github.com/toa-io/toa/compare/v1.0.0-alpha.258...v1.0.0-alpha.259) (2026-08-24)
+
+
+### Features
+
+* **runtime:** split component RC into preflight and settle ([0d648b3](https://github.com/toa-io/toa/commit/0d648b314e4aac226c254bf01a86affa04b59b34))
+
+
+
+
+
+# [1.0.0-alpha.257](https://github.com/toa-io/toa/compare/v1.0.0-alpha.256...v1.0.0-alpha.257) (2026-08-24)
+
+**Note:** Version bump only for package @toa.io/boot
+
+
+
+
+
+# [1.0.0-alpha.256](https://github.com/toa-io/toa/compare/v1.0.0-alpha.255...v1.0.0-alpha.256) (2026-08-23)
+
+**Note:** Version bump only for package @toa.io/boot

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/boot",
-  "version": "1.0.0-alpha.27",
+  "version": "1.0.0-alpha.272",
   "description": "Toa Boot",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -20,13 +20,15 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@toa.io/core": "1.0.0-alpha.27",
-    "@toa.io/filesystem": "1.0.0-alpha.27",
-    "@toa.io/generic": "1.0.0-alpha.27",
-    "@toa.io/norm": "1.0.0-alpha.27",
-    "@toa.io/schema": "1.0.0-alpha.27",
+    "@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"
+    "dotenv": "16.1.1",
+    "openspan": "1.0.0-alpha.272"
   },
-  "gitHead": "9bc4bdb919688c5272791020746f70d51a520750"
+  "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/bindings/produce.js

@@ -3,26 +3,41 @@
 const { LOOP } = require('./constants')
 const { factory } = require('./factory')
 
-const produce = (component, operations) => group(operations, (factory, endpoints) =>
-  factory.producer(component.locator, endpoints, component))
+const produce = (component, operations) => {
+  const local = []
+  const other = []
+
+  group(operations, (binding, endpoints) => {
+    const producer = factory(binding).producer(component.locator, endpoints, component)
+
+    if (require(binding).properties.local === true)
+      local.push(producer)
+    else
+      other.push(producer)
+  })
+
+  return { local, other }
+}
 
 const group = (operations, callback) => {
   const map = {}
 
-  for (const [endpoint, operation] of Object.entries(operations)) {
-    // noinspection JSUnresolvedVariable
-    const bindings = global.TOA_INTEGRATION_BINDINGS_LOOP_DISABLED
-      ? operation.bindings
-      : [LOOP].concat(operation.bindings)
+  if (operations !== undefined)
+    for (const [endpoint, operation] of Object.entries(operations)) {
+      // noinspection JSUnresolvedVariable
+      const bindings = global.TOA_INTEGRATION_BINDINGS_LOOP_DISABLED
+        ? operation.bindings
+        : [LOOP].concat(operation.bindings)
 
-    for (const binding of bindings) {
-      if (!map[binding]) map[binding] = []
+      for (const binding of bindings) {
+        if (!map[binding]) map[binding] = []
 
-      map[binding].push(endpoint)
+        map[binding].push(endpoint)
+      }
     }
-  }
 
-  return Object.entries(map).map(([binding, endpoints]) => callback(factory(binding), endpoints))
+  for (const [binding, endpoints] of Object.entries(map))
+    callback(binding, endpoints)
 }
 
 exports.produce = produce

package/src/bridge.js

@@ -1,7 +1,8 @@
 'use strict'
 
-const algorithm = (bridge, path, endpoint, context) => {
-  const algorithm = resolve(bridge).algorithm(path, endpoint, context)
+async function algorithm (bridge, path, endpoint, context) {
+  const factory = resolve(bridge)
+  const algorithm = await factory.algorithm(path, endpoint, context)
 
   algorithm.depends(context)
 
@@ -10,6 +11,16 @@ const algorithm = (bridge, path, endpoint, context) => {
 
 const event = (bridge, path, label, context) => resolve(bridge).event(path, label, context)
 const receiver = (bridge, path, label) => resolve(bridge).receiver(path, label)
+const guard = (bridge, path, label, context) => resolve(bridge).guard(path, label, context)
+
+async function rc (bridge, path, context) {
+  const factory = resolve(bridge)
+
+  if (factory.rc === undefined)
+    return
+
+  return factory.rc(path, context)
+}
 
 const factories = {}
 
@@ -26,3 +37,5 @@ const resolve = (bridge) => {
 exports.algorithm = algorithm
 exports.event = event
 exports.receiver = receiver
+exports.guard = guard
+exports.rc = rc

package/src/call.js

@@ -4,12 +4,13 @@ const { Call, Transmission } = require('@toa.io/core')
 
 const boot = require('./index')
 
-const call = (locator, endpoint, definition, entity) => {
+// eslint-disable-next-line max-params
+const call = (locator, endpoint, definition, entity, source) => {
   const consumers = boot.bindings.consume(locator, endpoint, definition.bindings)
   const transmission = new Transmission(consumers)
   const contract = boot.contract.request(definition, entity)
 
-  return new Call(transmission, contract)
+  return new Call(transmission, contract, source)
 }
 
 exports.call = call

package/src/cascade.js

@@ -4,13 +4,13 @@ const { Cascade } = require('@toa.io/core')
 
 const boot = require('./index')
 
-const cascade = (manifest, endpoint, definition, context) => {
+async function cascade (manifest, endpoint, definition, context, preflight) {
   const bridges = []
 
   if (definition.forward) endpoint = definition.forward
 
   if (definition.bridge) {
-    const bridge = boot.bridge.algorithm(definition.bridge, manifest.path, endpoint, context)
+    const bridge = await boot.bridge.algorithm(definition.bridge, manifest.path, endpoint, context)
 
     bridges.unshift(bridge)
   }
@@ -22,12 +22,12 @@ const cascade = (manifest, endpoint, definition, context) => {
 
     if (operation === undefined) continue
 
-    const bridge = boot.bridge.algorithm(operation.bridge, prototype.path, endpoint, context)
+    const bridge = await boot.bridge.algorithm(operation.bridge, prototype.path, endpoint, context)
 
     bridges.unshift(bridge)
   }
 
-  return new Cascade(bridges)
+  return new Cascade(bridges, preflight)
 }
 
 exports.cascade = cascade

package/src/component.js

@@ -1,48 +1,76 @@
 'use strict'
 
-const { remap } = require('@toa.io/generic')
-const {
-  Component,
-  Locator,
-  State,
-  entities
-} = require('@toa.io/core')
-const { Schema } = require('@toa.io/schema')
+const { Component, Locator, State, entities } = require('@toa.io/core')
+const schemas = require('@toa.io/schemas')
 
 const boot = require('./index')
+const { span } = require('./span')
 
-/**
- * @param {toa.norm.Component} manifest
- * @returns {Promise<toa.core.Component>}
- */
 const component = async (manifest) => {
+  const locator = new Locator(manifest.name, manifest.namespace)
+
+  return span(`component ${locator.id}`, () => create(manifest, locator))
+}
+
+const create = async (manifest, locator) => {
   boot.extensions.load(manifest)
 
-  const locator = new Locator(manifest.name, manifest.namespace)
-  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
 
   if (manifest.entity !== undefined) {
-    const schema = new Schema(manifest.entity.schema)
-    const entity = new entities.Factory(schema)
+    const schema = schemas.schema(manifest.entity.schema)
+    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 operations = manifest.operations === undefined
-    ? {}
-    : remap(manifest.operations, (definition, endpoint) =>
-      boot.operation(manifest, endpoint, definition, context, state))
-
+  const phases = await boot.rc(manifest, context)
+  const operations = await bootOperations(manifest, context, state, phases?.preflight)
   const component = new Component(locator, operations)
 
   if (storage) component.depends(storage)
-  if (emission) component.depends(emission)
 
-  return boot.extensions.component(component)
+  // 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)
+
+  if (phases?.settle !== undefined)
+    decorated.settle = phases.settle
+
+  // a dependency closes after its dependant, so the component is already closed
+  // when the RC releases what it opened
+  if (phases?.dispose !== undefined)
+    decorated.depends(phases.dispose)
+
+  return decorated
+}
+
+async function bootOperations (manifest, context, state, preflight) {
+  if (manifest.operations === undefined)
+    return {}
+
+  const entries = Object.entries(manifest.operations)
+
+  // each one loads its algorithm from disk and compiles its contracts
+  const booted = await Promise.all(entries.map(([endpoint, definition]) =>
+    boot.operation(manifest, endpoint, definition, context, state, preflight)))
+
+  const operations = {}
+
+  for (let i = 0; i < entries.length; i++)
+    operations[entries[i][0]] = booted[i]
+
+  return operations
 }
 
 exports.component = component

package/src/composition.js

@@ -1,24 +1,93 @@
 'use strict'
 
+const { console } = require('openspan')
 const { Composition } = require('@toa.io/core')
+const { version } = require('@toa.io/runtime/package.json')
 
 const boot = require('./index')
+const { span } = require('./span')
 
 async function composition (paths, options) {
   options = Object.assign({}, options)
 
-  const manifests = await Promise.all(paths.map((path) => boot.manifest(path, options)))
-  const tenants = await Promise.all(manifests.map(boot.extensions.tenants))
-  const expositions = await Promise.all(manifests.map(boot.discovery.expose))
-  const components = await Promise.all(manifests.map(boot.component))
+  return span('boot composition', async () => {
+    const manifests = await span('load manifests',
+      async () => await Promise.all(paths.map((path) => boot.manifest(path, options))))
 
-  const producers = components.map((component, index) =>
-    boot.bindings.produce(component, manifests[index].operations))
+    console.info('Starting composition', {
+      runtime: version,
+      components: manifests.map((manifest) => manifest.locator.id)
+    })
 
-  const receivers = await Promise.all(components.map((component, index) =>
-    boot.receivers(manifests[index], component)))
+    const tenants = await span('create tenants',
+      async () => await Promise.all(manifests.map(boot.extensions.tenants)))
 
-  return new Composition(expositions.flat(), producers.flat(), receivers.flat(), tenants.flat())
+    const expositions = await span('expose discovery',
+      async () => await Promise.all(manifests.map(boot.discovery.expose)))
+
+    try {
+      const components = await span('create components',
+        async () => await Promise.all(manifests.map(boot.component)))
+
+      const groups = components.map((component, index) =>
+        boot.bindings.produce(component, manifests[index].operations))
+
+      const receivers = await span('create receivers',
+        async () => await Promise.all(components.map((component, index) =>
+          boot.receivers(manifests[index], component))))
+
+      const producers = []
+      const settles = []
+
+      for (let i = 0; i < components.length; i++) {
+        const { local, other } = groups[i]
+        const settle = components[i].settle
+        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
+
+        if (local.length > 0)
+          settle.depends(local)
+
+        for (const producer of other)
+          producer.depends(settle)
+
+        for (const receiver of receivers[i])
+          receiver.depends(settle)
+
+        settles.push(settle)
+      }
+
+      const composition = new Composition(expositions.flat(), producers.concat(settles), receivers.flat(), tenants.flat())
+
+      /*
+       * A lookup that is never answered holds a connection open, and whoever
+       * awaits it has nothing to disconnect — the remote it would belong to does
+       * not exist yet. The composition owns the process's discovery instead, so
+       * an unanswered lookup cannot outlive it.
+       */
+      composition.depends(await boot.discovery.discovery())
+
+      return boot.extensions.manage(composition)
+    } catch (exception) {
+      await Promise.all(expositions.flat().map((connector) => connector.disconnect(true)))
+      throw exception
+    }
+  })
 }
 
 exports.composition = composition

package/src/context.js

@@ -5,9 +5,12 @@ const { Context, Locator } = require('@toa.io/core')
 const boot = require('./index')
 
 const context = async (manifest) => {
-  const local = await boot.remote(manifest.locator, 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/contract.js

@@ -1,18 +1,18 @@
 'use strict'
 
 const { contract: { Request, Reply } } = require('@toa.io/core')
-const { Schema } = require('@toa.io/schema')
+const schemas = require('@toa.io/schemas')
 
 const request = (definition, entity) => {
   const request = Request.schema(definition, entity)
-  const schema = new Schema(request, { removeAdditional: true }) // soft inputs
+  const schema = schemas.schema(request, { removeAdditional: true })
 
-  return new Request(schema)
+  return new Request(schema, definition)
 }
 
-const reply = (output, error) => {
-  const reply = Reply.schema(output, error)
-  const schema = new Schema(reply) // outputs strict
+const reply = (output, errors) => {
+  const reply = Reply.schema(output, errors)
+  const schema = schemas.schema(reply)
 
   return new Reply(schema)
 }

package/src/discovery.js

@@ -29,7 +29,8 @@ const lookup = async (locator) => {
 const expose = async (manifest) => {
   const exposition = new Exposition(manifest.locator, manifest)
   const operations = { [ENDPOINT]: { bindings: BINDINGS } }
-  const producers = boot.bindings.produce(exposition, operations)
+  const { local, other } = boot.bindings.produce(exposition, operations)
+  const producers = local.concat(other)
 
   await Promise.all(producers.map((producer) => producer.connect()))
 

package/src/emission.js

@@ -10,10 +10,10 @@ const emission = (definitions, locator, context) => {
 
   const events = Object.entries(definitions).map(([label, definition]) => {
     const emitter = boot.bindings.emit(definition.binding, locator, label)
-    const decorator = extensions.emitter(emitter, label)
+    const decorator = extensions.emitter(emitter, label, locator)
     const bridge = boot.bridge.event(definition.bridge, definition.path, label, context)
 
-    return new Event(definition, decorator, bridge)
+    return new Event({ ...definition, label: `${locator.id}.${label}` }, decorator, bridge)
   })
 
   return new Emission(events)

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/extensions/emitter.js

@@ -5,13 +5,14 @@ const { instances } = require('./instances')
 /**
  * @param {toa.core.bindings.Emitter} emitter
  * @param {string} label
+ * @param {toa.core.Locator} locator
  * @returns {toa.core.bindings.Emitter}
  */
-const emitter = (emitter, label) => {
+const emitter = (emitter, label, locator) => {
   let decorated = emitter
 
   for (const factory of Object.values(instances)) {
-    if (factory.emitter !== undefined) decorated = factory.emitter(decorated, label)
+    if (factory.emitter !== undefined) decorated = factory.emitter(decorated, label, locator)
   }
 
   return decorated

package/src/extensions/index.js

@@ -5,6 +5,7 @@ const { component } = require('./component')
 const { context } = require('./context')
 const { emitter } = require('./emitter')
 const { load } = require('./load')
+const { manage } = require('./manage')
 const { receiver } = require('./receiver')
 const { storage } = require('./storage')
 const { tenants } = require('./tenants')
@@ -14,6 +15,7 @@ exports.component = component
 exports.context = context
 exports.emitter = emitter
 exports.load = load
+exports.manage = manage
 exports.receiver = receiver
 exports.storage = storage
 exports.tenants = tenants

package/src/extensions/load.js

@@ -6,9 +6,11 @@ const { resolve } = require('./resolve')
  * @param {toa.norm.Component} manifest
  */
 const load = (manifest) => {
-  if (manifest.extensions === undefined) return
+  if (manifest.extensions === undefined)
+    return
 
-  for (const name of Object.keys(manifest.extensions)) resolve(name, manifest.path)
+  for (const name of Object.keys(manifest.extensions))
+    resolve(name, manifest.path)
 }
 
 exports.load = load

package/src/extensions/manage.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const { instances } = require('./instances')
+
+/**
+ * @param {toa.core.Connector} composition
+ * @returns {toa.core.Connector}
+ */
+const manage = (composition) => {
+  let managed = composition
+
+  for (const factory of Object.values(instances)) {
+    if (factory.manage !== undefined)
+      managed = factory.manage(managed)
+  }
+
+  return managed
+}
+
+exports.manage = manage

package/src/extensions/receiver.js

@@ -11,7 +11,8 @@ const receiver = (receiver, locator) => {
   let decorated = receiver
 
   for (const factory of Object.values(instances)) {
-    if (factory.receiver !== undefined) decorated = factory.receiver(decorated, locator)
+    if (factory.receiver !== undefined)
+      decorated = factory.receiver(decorated, locator)
   }
 
   return decorated

package/src/extensions/tenants.js

@@ -16,7 +16,7 @@ const tenants = (manifest) => {
 
     if (factory.tenant === undefined) continue
 
-    const tenant = factory.tenant(manifest.locator, declaration)
+    const tenant = factory.tenant(manifest.locator, declaration, manifest)
 
     tenants.push(tenant)
   }

package/src/guards.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const { Guard } = require('@toa.io/core')
+const boot = require('./index')
+
+async function guards(manifest, context) {
+  if (manifest.guards === undefined)
+    return 
+
+  const entries = Object.entries(manifest.guards)
+
+  return await Promise.all(entries.map(async ([name, guard]) => {
+    const bridge = await load(guard, name, context)
+
+    return new Guard(name, bridge)
+  }))
+}
+
+async function load(guard, name, context) {
+  return await boot.bridge.guard(guard.bridge, guard.path, name, context)
+}
+
+exports.guards = guards

package/src/index.js

@@ -8,12 +8,18 @@ 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')
 const { receivers, receive } = require('./receivers')
 const { remote } = require('./remote')
 const { storage } = require('./storage')
+const { guards } = require('./guards')
+const { rc } = require('./rc')
 
 exports.bindings = require('./bindings')
 exports.bridge = require('./bridge')
@@ -27,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
@@ -34,3 +44,5 @@ exports.receivers = receivers
 exports.receive = receive
 exports.remote = remote
 exports.storage = storage
+exports.guards = guards
+exports.rc = rc

package/src/manifest.js

@@ -1,17 +1,18 @@
 'use strict'
 
 const clone = require('clone-deep')
+const { basename } = require('node:path')
 const { merge } = require('@toa.io/generic')
 const { component: load } = require('@toa.io/norm')
 const { Locator } = require('@toa.io/core')
 
-/**
- * @type {toa.boot.Manifest}
- */
+const { span } = require('./span')
+
 const manifest = async (path, options = {}) => {
   options = merge(clone(options), DEFAULTS)
 
-  const manifest = await load(path)
+  const manifest = await span({ name: `manifest ${basename(path)}`, attributes: { path } },
+    async () => await load(path))
 
   if (options?.bindings !== undefined) {
     if ('operations' in manifest) {

package/src/operation.js

@@ -1,15 +1,24 @@
 'use strict'
 
-const { Transition, Observation, Assignment, Operation, Query } = require('@toa.io/core')
+const {
+  Transition,
+  Observation,
+  Assignment,
+  Operation,
+  Query,
+  Effect,
+  Unmanaged
+} = require('@toa.io/core')
 
 const boot = require('./index')
 
-const operation = (manifest, endpoint, definition, context, scope) => {
-  const cascade = boot.cascade(manifest, endpoint, definition, context)
+async function operation (manifest, endpoint, definition, context, scope, preflight) {
+  const cascade = await boot.cascade(manifest, endpoint, definition, context, preflight)
   const reply = boot.contract.reply(definition.output, definition.error)
   const input = definition.input
   const request = boot.contract.request({ input }, manifest.entity)
   const contracts = { reply, request }
+
   const query = manifest.entity === undefined
     ? undefined
     : new Query(manifest.entity.schema.properties)
@@ -24,7 +33,8 @@ const TYPES = {
   observation: Observation,
   assignment: Assignment,
   computation: Operation,
-  effect: Operation
+  effect: Effect,
+  unmanaged: Unmanaged
 }
 
 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/rc.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const boot = require('./index')
+
+async function rc (manifest, context) {
+  return boot.bridge.rc(manifest.bridge, manifest.path, context)
+}
+
+exports.rc = rc

package/src/receivers.js

@@ -5,23 +5,29 @@ const { Receiver, Locator } = require('@toa.io/core')
 const boot = require('./index')
 const extensions = require('./extensions')
 
-const receivers = async (manifest, runtime) => {
+const receivers = async (manifest, component) => {
   if (manifest.receivers === undefined) return []
 
   const receivers = []
-  const local = await boot.remote(manifest.locator, manifest)
+  const local = await boot.remote(manifest.locator, undefined, manifest)
 
   for (const [label, definition] of Object.entries(manifest.receivers)) {
+    const locator = Locator.parse(label)
+    const source = definition.source ? Locator.parse(definition.source) : locator
+    const event = label.split('.').pop()
+    const destination = `${source.id}.${event}`
+
+    // the origin of the calls this receiver makes to its local operation
+    const origin = { namespace: source.namespace, component: source.name, event }
+
     const bridge = definition.bridge !== undefined ? boot.bridge.receiver(definition.bridge, manifest.path, label) : undefined
-    const receiver = new Receiver(definition, local, bridge)
+    const receiver = new Receiver({ ...definition, label, destination, origin }, local, bridge)
     const decorator = extensions.receiver(receiver, manifest.locator)
 
-    const locator = Locator.parse(label)
     const transport = definition.binding ?? await resolveBinding(locator, label)
-    const source = definition.source ? Locator.parse(definition.source) : locator
     const binding = boot.bindings.receive(transport, source, label, manifest.locator.id, decorator)
 
-    binding.depends(runtime)
+    binding.depends(component)
     receivers.push(binding)
   }
 

package/src/remote.js

@@ -1,23 +1,36 @@
 'use strict'
 
+const { console } = require('openspan')
 const { Remote } = require('@toa.io/core')
 const { remap } = require('@toa.io/generic')
 
 const boot = require('./index')
 
-const remote = async (locator, manifest = undefined) => {
-  const discovery = await boot.discovery.discovery()
+/**
+ * @param {toa.core.Locator} locator
+ * @param {toa.core.Source} [source] the origin stamped on every call made through this remote
+ * @param {toa.norm.Component} [manifest] skips discovery when the manifest is already known
+ */
+const remote = async (locator, source, manifest) => {
+  let discovery
 
-  if (manifest === undefined) manifest = await discovery.lookup(locator)
+  if (manifest === undefined) {
+    console.debug('Lookup', { locator: locator.id })
+
+    discovery = await boot.discovery.discovery(locator)
+    manifest = await discovery.lookup(locator)
+  }
 
   const calls = manifest.operations === undefined
     ? {}
-    : remap(manifest.operations, (definition, endpoint) => boot.call(locator, endpoint, definition, manifest.entity))
+    : remap(manifest.operations,
+      (definition, endpoint) => boot.call(locator, endpoint, definition, manifest.entity, source))
 
   const remote = new Remote(locator, calls)
 
   // ensure discovery shutdown
-  remote.depends(discovery)
+  if (discovery !== undefined)
+    remote.depends(discovery)
 
   return remote
 }

package/src/span.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const { console, traces } = require('openspan')
+
+const enabled = process.env.TOA_BOOT_TRACE === '1'
+
+// Tracing is off until an exporter is configured, and the CLI opens its own span before
+// any extension gets to configure one — so asking for a boot trace turns the console
+// exporter on here. Extensions keep it: see `development()` in the telemetry factory.
+if (enabled) traces({ exporters: { console: {} } })
+
+/**
+ * Creates a span if boot tracing is enabled (TOA_BOOT_TRACE=1), otherwise just runs the task
+ *
+ * @param {string | object} options
+ * @param {() => Promise<any>} task
+ * @returns {Promise<any>}
+ */
+const span = async (options, task) => enabled ? console.span(options, task) : task()
+
+exports.span = span

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)
 }

package/types/index.d.ts

@@ -5,17 +5,17 @@ export * as bindings from './bindings'
 
 export async function composition (paths: string[], options?: composition.Options): Promise<core.Connector>
 
-export async function remote (locator: core.Locator): Promise<core.Component>
+export async function remote (locator: core.Locator, source?: core.Source): Promise<core.Remote>
 
 export async function receive<T = any> (
   label: string,
-  receiver: Receiver,
+  receiver: Receiver
 ): Promise<core.Connector>
 
 export async function receive<T = any> (
   label: string,
   group: string | undefined,
-  receiver: Receiver,
+  receiver: Receiver
 ): Promise<core.Connector>
 
 type Receiver = { receive: (message: core.Message<T>) => void | Promise<void> }