@toa.io/boot 1.0.0-alpha.273 → 1.0.0-alpha.277

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 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.277](https://github.com/toa-io/toa/compare/v1.0.0-alpha.276...v1.0.0-alpha.277) (2026-09-03)
+
+### Bug Fixes
+
+* read a manifest the way js-yaml read one before ([fcea1b2](https://github.com/toa-io/toa/commit/fcea1b21996d6efa6c3198acbfc9f70f1ce0c35c))
+* settle what the module loader made asynchronous ([d4ab9df](https://github.com/toa-io/toa/commit/d4ab9dfb09e382da311dba08f52214e7645f4a6c))
+* what the loader resolves, and what it will not ([1b8a02f](https://github.com/toa-io/toa/commit/1b8a02ff0a5e0f18ee62e3f71bc81116f86f9af1))
+
+
+# [1.0.0-alpha.274](https://github.com/toa-io/toa/compare/v1.0.0-alpha.273...v1.0.0-alpha.274) (2026-09-02)
+
+**Note:** Version bump only for package @toa.io/boot
+
+
+
+
+
 # [1.0.0-alpha.273](https://github.com/toa-io/toa/compare/v1.0.0-alpha.272...v1.0.0-alpha.273) (2026-09-02)
 
 **Note:** Version bump only for package @toa.io/boot

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@toa.io/boot",
-  "version": "1.0.0-alpha.273",
+  "version": "1.0.0-alpha.277",
+  "type": "module",
   "description": "Toa Boot",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -20,15 +21,14 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@toa.io/atomicity": "1.0.0-alpha.273",
-    "@toa.io/core": "1.0.0-alpha.273",
-    "@toa.io/generic": "1.0.0-alpha.273",
-    "@toa.io/norm": "1.0.0-alpha.273",
-    "@toa.io/schemas": "1.0.0-alpha.273",
+    "@toa.io/atomicity": "1.0.0-alpha.277",
+    "@toa.io/core": "1.0.0-alpha.277",
+    "@toa.io/generic": "1.0.0-alpha.277",
+    "@toa.io/norm": "1.0.0-alpha.277",
+    "@toa.io/schemas": "1.0.0-alpha.277",
     "clone-deep": "4.0.1",
-    "dotenv": "16.1.1",
-    "find-up": "5.0.0",
-    "openspan": "1.0.0-alpha.272"
+    "dotenv": "17.4.2",
+    "openspan": "1.0.0-alpha.277"
   },
-  "gitHead": "ad3284850ece95ffd5325fd0995707fc144c9c3d"
+  "gitHead": "0c0071418c2c56a44e621ba5ced5cdd23dff1738"
 }

package/src/atom.js

@@ -1,8 +1,6 @@
-'use strict'
+import { Connector } from '@toa.io/core'
 
-const { Connector } = require('@toa.io/core')
-
-const boot = require('./index')
+import * as boot from './index.js'
 
 /**
  * The atom as a system aspect. Every component has `context.atom`, with nothing declared in its
@@ -36,6 +34,4 @@ class Aspect extends Connector {
 }
 
 /** @param {string} group */
-const atom = (group) => new Aspect(boot.atomicity(group))
-
-exports.atom = atom
+export const atom = (group) => new Aspect(boot.atomicity(group))

package/src/atomicity.js

@@ -1,6 +1,4 @@
-'use strict'
-
-const { Factory } = require('@toa.io/atomicity')
+import { Factory } from '@toa.io/atomicity'
 
 /**
  * What the replicas of one group decide together. Every component has one, whether or not there
@@ -10,6 +8,4 @@ const { Factory } = require('@toa.io/atomicity')
  * @param {string} group
  * @returns {toa.core.atomicity.Atom}
  */
-const atomicity = (group) => new Factory().atom(group)
-
-exports.atomicity = atomicity
+export const atomicity = (group) => new Factory().atom(group)

package/src/bindings/broadcast.js

@@ -1,7 +1,4 @@
-'use strict'
+import { factory } from './factory.js'
 
-const { factory } = require('./factory')
-
-const broadcast = (channel, group, binding = '@toa.io/bindings.amqp') => factory(binding).broadcast(channel, group)
-
-exports.broadcast = broadcast
+export const broadcast = async (channel, group, binding = '@toa.io/bindings.amqp') =>
+  (await factory(binding)).broadcast(channel, group)

package/src/bindings/constants.js

@@ -1,3 +1 @@
-'use strict'
-
-exports.LOOP = '@toa.io/bindings.loop'
+export const LOOP = '@toa.io/bindings.loop'

package/src/bindings/consume.js

@@ -1,9 +1,6 @@
-'use strict'
+import { LOOP } from './constants.js'
+import { factory } from './factory.js'
 
-const { LOOP } = require('./constants')
-const { factory } = require('./factory')
-
-const consume = (locator, endpoint, bindings) =>
-  [LOOP].concat(bindings).map((binding) => factory(binding).consumer(locator, endpoint))
-
-exports.consume = consume
+export const consume = async (locator, endpoint, bindings) =>
+  await Promise.all([LOOP].concat(bindings).map(async (binding) =>
+    (await factory(binding)).consumer(locator, endpoint)))

package/src/bindings/emit.js

@@ -1,7 +1,4 @@
-'use strict'
+import { factory } from './factory.js'
 
-const { factory } = require('./factory')
-
-const emit = (binding, locator, label) => factory(binding).emitter(locator, label)
-
-exports.emit = emit
+export const emit = async (binding, locator, label) =>
+  (await factory(binding)).emitter(locator, label)

package/src/bindings/factory.js

@@ -1,15 +1,11 @@
-'use strict'
-
 let instances = {}
 
-const factory = (binding) => {
-  if (instances[binding] === undefined) instances[binding] = new (require(binding).Factory)()
+// the promise is what is remembered, so two components cannot each make a factory
+export const factory = async (binding) => {
+  instances[binding] ??= import(binding).then(({ Factory }) => new Factory())
 
-  return instances[binding]
+  return await instances[binding]
 }
 
 // for testing purposes
-const reset = () => (instances = {})
-
-exports.factory = factory
-exports.reset = reset
+export const reset = () => (instances = {})

package/src/bindings/index.js

@@ -1,13 +1,5 @@
-'use strict'
-
-const { broadcast } = require('./broadcast')
-const { consume } = require('./consume')
-const { emit } = require('./emit')
-const { produce } = require('./produce')
-const { receive } = require('./receive')
-
-exports.broadcast = broadcast
-exports.consume = consume
-exports.emit = emit
-exports.produce = produce
-exports.receive = receive
+export { broadcast } from './broadcast.js'
+export { consume } from './consume.js'
+export { emit } from './emit.js'
+export { produce } from './produce.js'
+export { receive } from './receive.js'

package/src/bindings/produce.js

@@ -1,25 +1,26 @@
-'use strict'
+import { LOOP } from './constants.js'
+import { factory } from './factory.js'
 
-const { LOOP } = require('./constants')
-const { factory } = require('./factory')
-
-const produce = (component, operations) => {
+export const produce = async (component, operations) => {
   const local = []
   const other = []
 
-  group(operations, (binding, endpoints) => {
-    const producer = factory(binding).producer(component.locator, endpoints, component)
+  for (const [binding, endpoints] of group(operations)) {
+    const made = await factory(binding)
+    const producer = made.producer(component.locator, endpoints, component)
+    const { properties } = await import(binding)
 
-    if (require(binding).properties.local === true)
+    if (properties.local === true)
       local.push(producer)
     else
       other.push(producer)
-  })
+  }
 
   return { local, other }
 }
 
-const group = (operations, callback) => {
+/** The endpoints each binding carries, as entries. */
+const group = (operations) => {
   const map = {}
 
   if (operations !== undefined)
@@ -36,8 +37,5 @@ const group = (operations, callback) => {
       }
     }
 
-  for (const [binding, endpoints] of Object.entries(map))
-    callback(binding, endpoints)
+  return Object.entries(map)
 }
-
-exports.produce = produce

package/src/bindings/receive.js

@@ -1,7 +1,4 @@
-'use strict'
+import { factory } from './factory.js'
 
-const { factory } = require('./factory')
-
-const receive = (binding, locator, label, group, receiver) => factory(binding).receiver(locator, label, group, receiver)
-
-exports.receive = receive
+export const receive = async (binding, locator, label, group, receiver) =>
+  (await factory(binding)).receiver(locator, label, group, receiver)

package/src/bridge.js

@@ -1,7 +1,5 @@
-'use strict'
-
-async function algorithm (bridge, path, endpoint, context) {
-  const factory = resolve(bridge)
+export async function algorithm (bridge, path, endpoint, context) {
+  const factory = await resolve(bridge)
   const algorithm = await factory.algorithm(path, endpoint, context)
 
   algorithm.depends(context)
@@ -9,12 +7,17 @@ async function algorithm (bridge, path, endpoint, context) {
   return algorithm
 }
 
-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)
+export const event = async (bridge, path, label, context) =>
+  (await resolve(bridge)).event(path, label, context)
+
+export const receiver = async (bridge, path, label) =>
+  (await resolve(bridge)).receiver(path, label)
+
+export const guard = async (bridge, path, label, context) =>
+  (await resolve(bridge)).guard(path, label, context)
 
-async function rc (bridge, path, context) {
-  const factory = resolve(bridge)
+export async function rc (bridge, path, context) {
+  const factory = await resolve(bridge)
 
   if (factory.rc === undefined)
     return
@@ -24,18 +27,9 @@ async function rc (bridge, path, context) {
 
 const factories = {}
 
-const resolve = (bridge) => {
-  if (factories[bridge] === undefined) {
-    const { Factory } = require(bridge)
+// the promise is what is remembered, so two boots cannot each make a factory
+const resolve = async (bridge) => {
+  factories[bridge] ??= import(bridge).then(({ Factory }) => new Factory())
 
-    factories[bridge] = new Factory()
-  }
-
-  return factories[bridge]
+  return await factories[bridge]
 }
-
-exports.algorithm = algorithm
-exports.event = event
-exports.receiver = receiver
-exports.guard = guard
-exports.rc = rc

package/src/call.js

@@ -1,16 +1,12 @@
-'use strict'
+import { Call, Transmission } from '@toa.io/core'
 
-const { Call, Transmission } = require('@toa.io/core')
-
-const boot = require('./index')
+import * as boot from './index.js'
 
 // eslint-disable-next-line max-params
-const call = (locator, endpoint, definition, entity, source) => {
-  const consumers = boot.bindings.consume(locator, endpoint, definition.bindings)
+export const call = async (locator, endpoint, definition, entity, source) => {
+  const consumers = await boot.bindings.consume(locator, endpoint, definition.bindings)
   const transmission = new Transmission(consumers)
   const contract = boot.contract.request(definition, entity)
 
   return new Call(transmission, contract, source)
 }
-
-exports.call = call

package/src/cascade.js

@@ -1,10 +1,8 @@
-'use strict'
+import { Cascade } from '@toa.io/core'
 
-const { Cascade } = require('@toa.io/core')
+import * as boot from './index.js'
 
-const boot = require('./index')
-
-async function cascade (manifest, endpoint, definition, context, preflight) {
+export async function cascade (manifest, endpoint, definition, context, preflight) {
   const bridges = []
 
   if (definition.forward) endpoint = definition.forward
@@ -29,5 +27,3 @@ async function cascade (manifest, endpoint, definition, context, preflight) {
 
   return new Cascade(bridges, preflight)
 }
-
-exports.cascade = cascade

package/src/component.js

@@ -1,25 +1,23 @@
-'use strict'
+import { Component, Locator, State, entities } from '@toa.io/core'
+import * as schemas from '@toa.io/schemas'
 
-const { Component, Locator, State, entities } = require('@toa.io/core')
-const schemas = require('@toa.io/schemas')
+import * as boot from './index.js'
+import { span } from './span.js'
 
-const boot = require('./index')
-const { span } = require('./span')
-
-const component = async (manifest) => {
+export 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)
+  await boot.extensions.load(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 storage = await boot.storage(manifest, events !== undefined)
   const context = await boot.context(manifest)
-  const emission = boot.emission(events, locator, context)
+  const emission = await boot.emission(events, locator, context)
   const outbox = boot.outbox(manifest, storage, emission)
 
   let state
@@ -72,5 +70,3 @@ async function bootOperations (manifest, context, state, preflight) {
 
   return operations
 }
-
-exports.component = component

package/src/composition.js

@@ -1,13 +1,11 @@
-'use strict'
+import { console } from 'openspan'
+import { Composition } from '@toa.io/core'
+import { version } from '@toa.io/runtime'
 
-const { console } = require('openspan')
-const { Composition } = require('@toa.io/core')
-const { version } = require('@toa.io/runtime/package.json')
+import * as boot from './index.js'
+import { span } from './span.js'
 
-const boot = require('./index')
-const { span } = require('./span')
-
-async function composition (paths, options) {
+export async function composition (paths, options) {
   options = Object.assign({}, options)
 
   return span('boot composition', async () => {
@@ -29,8 +27,8 @@ async function composition (paths, options) {
       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 groups = await Promise.all(components.map(async (component, index) =>
+        await boot.bindings.produce(component, manifests[index].operations)))
 
       const receivers = await span('create receivers',
         async () => await Promise.all(components.map((component, index) =>
@@ -89,5 +87,3 @@ async function composition (paths, options) {
     }
   })
 }
-
-exports.composition = composition

package/src/context.js

@@ -1,10 +1,8 @@
-'use strict'
+import { Context, Locator } from '@toa.io/core'
 
-const { Context, Locator } = require('@toa.io/core')
+import * as boot from './index.js'
 
-const boot = require('./index')
-
-const context = async (manifest) => {
+export const context = async (manifest) => {
   const local = await boot.remote(manifest.locator, undefined, manifest)
   const aspects = boot.extensions.aspects(manifest)
 
@@ -24,5 +22,3 @@ const context = async (manifest) => {
 
   return boot.extensions.context(context)
 }
-
-exports.context = context

package/src/contract.js

@@ -1,21 +1,18 @@
-'use strict'
+import { contract } from '@toa.io/core'
+import * as schemas from '@toa.io/schemas'
 
-const { contract: { Request, Reply } } = require('@toa.io/core')
-const schemas = require('@toa.io/schemas')
+const { Request, Reply } = contract
 
-const request = (definition, entity) => {
+export const request = (definition, entity) => {
   const request = Request.schema(definition, entity)
   const schema = schemas.schema(request, { removeAdditional: true })
 
   return new Request(schema, definition)
 }
 
-const reply = (output, errors) => {
+export const reply = (output, errors) => {
   const reply = Reply.schema(output, errors)
   const schema = schemas.schema(reply)
 
   return new Reply(schema)
 }
-
-exports.request = request
-exports.reply = reply

package/src/discovery.js

@@ -1,13 +1,11 @@
-'use strict'
+import { Discovery, Exposition } from '@toa.io/core'
 
-const { Discovery, Exposition } = require('@toa.io/core')
-
-const boot = require('./index')
+import * as boot from './index.js'
 
 let promise
 let instance = null
 
-const discovery = async () => {
+export const discovery = async () => {
   if (instance === null) {
     instance = new Discovery(lookup)
     promise = instance.connect()
@@ -19,17 +17,17 @@ const discovery = async () => {
 }
 
 const lookup = async (locator) => {
-  const call = boot.call(locator, ENDPOINT, { bindings: BINDINGS })
+  const call = await boot.call(locator, ENDPOINT, { bindings: BINDINGS })
 
   await call.connect()
 
   return call
 }
 
-const expose = async (manifest) => {
+export const expose = async (manifest) => {
   const exposition = new Exposition(manifest.locator, manifest)
   const operations = { [ENDPOINT]: { bindings: BINDINGS } }
-  const { local, other } = boot.bindings.produce(exposition, operations)
+  const { local, other } = await boot.bindings.produce(exposition, operations)
   const producers = local.concat(other)
 
   await Promise.all(producers.map((producer) => producer.connect()))
@@ -39,6 +37,3 @@ const expose = async (manifest) => {
 
 const BINDINGS = ['@toa.io/bindings.amqp']
 const ENDPOINT = '.lookup'
-
-exports.discovery = discovery
-exports.expose = expose

package/src/emission.js

@@ -1,22 +1,18 @@
-'use strict'
+import { Emission, Event } from '@toa.io/core'
 
-const { Emission, Event } = require('@toa.io/core')
+import * as boot from './index.js'
+import * as extensions from './extensions/index.js'
 
-const boot = require('./index')
-const extensions = require('./extensions')
-
-const emission = (definitions, locator, context) => {
+export const emission = async (definitions, locator, context) => {
   if (definitions === undefined) return
 
-  const events = Object.entries(definitions).map(([label, definition]) => {
-    const emitter = boot.bindings.emit(definition.binding, locator, label)
+  const events = await Promise.all(Object.entries(definitions).map(async ([label, definition]) => {
+    const emitter = await boot.bindings.emit(definition.binding, locator, label)
     const decorator = extensions.emitter(emitter, label, locator)
-    const bridge = boot.bridge.event(definition.bridge, definition.path, label, context)
+    const bridge = await boot.bridge.event(definition.bridge, definition.path, label, context)
 
     return new Event({ ...definition, label: `${locator.id}.${label}` }, decorator, bridge)
-  })
+  }))
 
   return new Emission(events)
 }
-
-exports.emission = emission

package/src/env.js

@@ -1,11 +1,10 @@
-'use strict'
-
-const findUp = require('find-up')
+import dotenv from 'dotenv'
+import { findUp } from '@toa.io/generic'
 
 async function setup () {
-  const path = await findUp('.env')
+  const path = findUp('.env')
 
-  if (path !== undefined) require('dotenv').config({ path })
+  if (path !== undefined) dotenv.config({ path })
 }
 
 if (!('TOA_ENV' in process.env)) {

package/src/events.js

@@ -1,5 +1,3 @@
-'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
@@ -11,7 +9,7 @@
  * @param {toa.norm.Component} manifest
  * @returns {toa.norm.Events | undefined}
  */
-const events = (manifest) => {
+export const events = (manifest) => {
   if (manifest.events === undefined) return
 
   const value = process.env[VARIABLE + manifest.locator.uppercase]
@@ -25,5 +23,3 @@ const events = (manifest) => {
 }
 
 const VARIABLE = 'TOA_EVENTS_'
-
-exports.events = events

package/src/exposition.js

@@ -1,10 +1,8 @@
-'use strict'
+import { Exposition, Locator } from '@toa.io/core'
 
-const { Exposition, Locator } = require('@toa.io/core')
+import * as boot from './index.js'
 
-const boot = require('./index')
-
-const exposition = async (manifest) => {
+export const exposition = async (manifest) => {
   const locator = new Locator('', '')
   const exposition = new Exposition(locator, manifest)
   const producers = boot.bindings.expose(exposition)
@@ -13,5 +11,3 @@ const exposition = async (manifest) => {
 
   return producers
 }
-
-exports.exposition = exposition

package/src/extensions/aspects.js

@@ -1,18 +1,16 @@
-'use strict'
-
-const { resolve } = require('./resolve')
+import { instance } from './resolve.js'
 
 /**
  * @param {toa.norm.Component} manifest
  * @returns {toa.core.extensions.Aspect[]}
  */
-const aspects = (manifest) => {
+export const aspects = (manifest) => {
   const aspects = []
 
   if (manifest.extensions === undefined) return aspects
 
   for (const [name, declaration] of Object.entries(manifest.extensions)) {
-    const factory = resolve(name, manifest.path)
+    const factory = instance(name, manifest.path)
 
     if (factory.aspect === undefined) continue
 
@@ -24,5 +22,3 @@ const aspects = (manifest) => {
 
   return aspects
 }
-
-exports.aspects = aspects

package/src/extensions/component.js

@@ -1,12 +1,10 @@
-'use strict'
-
-const { instances } = require('./instances')
+import { instances } from './instances.js'
 
 /**
  * @param {toa.core.Component} component
  * @returns {toa.core.Component}
  */
-const component = (component) => {
+export const component = (component) => {
   let decorated = component
 
   for (const factory of Object.values(instances)) {
@@ -15,5 +13,3 @@ const component = (component) => {
 
   return decorated
 }
-
-exports.component = component