@toa.io/boot 1.0.0-alpha.283 → 1.0.0-alpha.286

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/boot",
-  "version": "1.0.0-alpha.283",
+  "version": "1.0.0-alpha.286",
   "type": "module",
   "description": "Toa Boot",
   "author": "temich <tema.gurtovoy@gmail.com>",
@@ -21,14 +21,14 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@toa.io/atomicity": "1.0.0-alpha.283",
-    "@toa.io/core": "1.0.0-alpha.283",
-    "@toa.io/generic": "1.0.0-alpha.283",
-    "@toa.io/norm": "1.0.0-alpha.283",
-    "@toa.io/schemas": "1.0.0-alpha.283",
+    "@toa.io/atomicity": "1.0.0-alpha.286",
+    "@toa.io/core": "1.0.0-alpha.286",
+    "@toa.io/generic": "1.0.0-alpha.286",
+    "@toa.io/norm": "1.0.0-alpha.286",
+    "@toa.io/schemas": "1.0.0-alpha.286",
     "clone-deep": "4.0.1",
     "dotenv": "17.4.2",
-    "openspan": "1.0.0-alpha.277"
+    "openspan": "1.0.0-alpha.286"
   },
-  "gitHead": "2f52b023bed0ccb2ecdb2b82fe59fbe38bf282e1"
+  "gitHead": "81f3d0688f17668b902be336d1749cc715edcdb6"
 }

package/src/atom.js

@@ -6,14 +6,14 @@ import * as boot from './index.js'
  * 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}
+ * @implements {import('@toa.io/core/types').extensions.Aspect}
  */
 class Aspect extends Connector {
   name = 'atom'
 
   #atom
 
-  constructor (atom) {
+  constructor(atom) {
     super()
 
     this.#atom = atom
@@ -23,12 +23,16 @@ class Aspect extends Connector {
 
   // the methods are named rather than forwarded, so that the connector's lifecycle is not
   // reachable from an algorithm
-  invoke (method, ...args) {
+  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`)
+      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`)
     }
   }
 }

package/src/atomicity.js

@@ -6,6 +6,6 @@ import { Factory } from '@toa.io/atomicity'
  * see the connector's readme.
  *
  * @param {string} group
- * @returns {toa.core.atomicity.Atom}
+ * @returns {import('@toa.io/core/types').atomicity.Atom}
  */
 export const atomicity = (group) => new Factory().atom(group)

package/src/bindings/consume.js

@@ -2,5 +2,8 @@ import { LOOP } from './constants.js'
 import { factory } from './factory.js'
 
 export const consume = async (locator, endpoint, bindings) =>
-  await Promise.all([LOOP].concat(bindings).map(async (binding) =>
-    (await factory(binding)).consumer(locator, endpoint)))
+  await Promise.all(
+    [LOOP]
+      .concat(bindings)
+      .map(async (binding) => (await factory(binding)).consumer(locator, endpoint))
+  )

package/src/bindings/produce.js

@@ -10,10 +10,8 @@ export const produce = async (component, operations) => {
     const producer = made.producer(component.locator, endpoints, component)
     const { properties } = await import(binding)
 
-    if (properties.local === true)
-      local.push(producer)
-    else
-      other.push(producer)
+    if (properties.local === true) local.push(producer)
+    else other.push(producer)
   }
 
   return { local, other }

package/src/bridge.js

@@ -1,4 +1,4 @@
-export async function algorithm (bridge, path, endpoint, context) {
+export async function algorithm(bridge, path, endpoint, context) {
   const factory = await resolve(bridge)
   const algorithm = await factory.algorithm(path, endpoint, context)
 
@@ -16,11 +16,10 @@ export const receiver = async (bridge, path, label) =>
 export const guard = async (bridge, path, label, context) =>
   (await resolve(bridge)).guard(path, label, context)
 
-export async function rc (bridge, path, context) {
+export async function rc(bridge, path, context) {
   const factory = await resolve(bridge)
 
-  if (factory.rc === undefined)
-    return
+  if (factory.rc === undefined) return
 
   return factory.rc(path, context)
 }

package/src/cascade.js

@@ -2,13 +2,18 @@ import { Cascade } from '@toa.io/core'
 
 import * as boot from './index.js'
 
-export 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
 
   if (definition.bridge) {
-    const bridge = await boot.bridge.algorithm(definition.bridge, manifest.path, endpoint, context)
+    const bridge = await boot.bridge.algorithm(
+      definition.bridge,
+      manifest.path,
+      endpoint,
+      context
+    )
 
     bridges.unshift(bridge)
   }
@@ -20,7 +25,12 @@ export async function cascade (manifest, endpoint, definition, context, prefligh
 
     if (operation === undefined) continue
 
-    const bridge = await boot.bridge.algorithm(operation.bridge, prototype.path, endpoint, context)
+    const bridge = await boot.bridge.algorithm(
+      operation.bridge,
+      prototype.path,
+      endpoint,
+      context
+    )
 
     bridges.unshift(bridge)
   }

package/src/component.js

@@ -1,5 +1,6 @@
 import { Component, Locator, State, entities } from '@toa.io/core'
-import * as schemas from '@toa.io/schemas'
+import { entity as declaration } from '@toa.io/norm'
+import { schema as compileSchema } from '@toa.io/schemas'
 
 import * as boot from './index.js'
 import { span } from './span.js'
@@ -23,11 +24,23 @@ const create = async (manifest, locator) => {
   let state
 
   if (manifest.entity !== undefined) {
-    const schema = schemas.schema(manifest.entity.schema)
+    const schemas = compile(manifest.entity)
     const guards = await boot.guards(manifest, context)
-    const entity = new entities.Factory(schema, guards)
+    const blank = manifest.entity.blank ?? {}
 
-    state = new State(storage, entity, outbox, manifest.entity.associated)
+    // fitted here rather than where the first record is written, so a component that
+    // declares a blank nothing can hold does not boot
+    const error = schemas.changeset.fit(blank)
+
+    if (error !== null)
+      throw new Error(`Component '${locator.id}' entity blank: ${error.message}`)
+
+    state = new State(
+      storage,
+      new entities.Factory(schemas, blank, guards),
+      outbox,
+      manifest.entity.associated
+    )
   }
 
   const phases = await boot.rc(manifest, context)
@@ -42,31 +55,36 @@ const create = async (manifest, locator) => {
 
   const decorated = boot.extensions.component(component)
 
-  if (phases?.settle !== undefined)
-    decorated.settle = phases.settle
+  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)
+  if (phases?.dispose !== undefined) decorated.depends(phases.dispose)
 
   return decorated
 }
 
-async function bootOperations (manifest, context, state, preflight) {
-  if (manifest.operations === undefined)
-    return {}
+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 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]
+  for (let i = 0; i < entries.length; i++) operations[entries[i][0]] = booted[i]
 
   return operations
 }
+
+/** What a stored record must fit, and what a changeset may. */
+const compile = (entity) => ({
+  entity: compileSchema(declaration.schema(entity)),
+  changeset: compileSchema(declaration.changeset(entity))
+})

package/src/composition.js

@@ -5,34 +5,52 @@ import { version } from '@toa.io/runtime'
 import * as boot from './index.js'
 import { span } from './span.js'
 
-export async function composition (paths, options) {
+export async function composition(paths, options) {
   options = Object.assign({}, options)
 
   return span('boot composition', async () => {
-    const manifests = await span('load manifests',
-      async () => await Promise.all(paths.map((path) => boot.manifest(path, options))))
+    const manifests = await span(
+      'load manifests',
+      async () => await Promise.all(paths.map((path) => boot.manifest(path, options)))
+    )
 
     console.info('Starting composition', {
       runtime: version,
       components: manifests.map((manifest) => manifest.locator.id)
     })
 
-    const tenants = await span('create tenants',
-      async () => await Promise.all(manifests.map(boot.extensions.tenants)))
+    const tenants = await span(
+      'create tenants',
+      async () => await Promise.all(manifests.map(boot.extensions.tenants))
+    )
 
-    const expositions = await span('expose discovery',
-      async () => await Promise.all(manifests.map(boot.discovery.expose)))
+    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 = 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) =>
-          boot.receivers(manifests[index], component))))
+      const components = await span(
+        'create components',
+        async () => await Promise.all(manifests.map(boot.component))
+      )
+
+      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) =>
+              boot.receivers(manifests[index], component)
+            )
+          )
+      )
 
       const producers = []
       const settles = []
@@ -55,22 +73,23 @@ export async function composition (paths, options) {
         for (const receiver of receivers[i])
           for (const producer of serving) receiver.depends(producer)
 
-        if (settle === undefined)
-          continue
+        if (settle === undefined) continue
 
-        if (local.length > 0)
-          settle.depends(local)
+        if (local.length > 0) settle.depends(local)
 
-        for (const producer of other)
-          producer.depends(settle)
+        for (const producer of other) producer.depends(settle)
 
-        for (const receiver of receivers[i])
-          receiver.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())
+      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

package/src/contract.js

@@ -5,7 +5,7 @@ const { Request, Reply } = contract
 
 export const request = (definition, entity) => {
   const request = Request.schema(definition, entity)
-  const schema = schemas.schema(request, { removeAdditional: true })
+  const schema = schemas.schema(request)
 
   return new Request(schema, definition)
 }
@@ -13,9 +13,8 @@ export const request = (definition, entity) => {
 export const reply = (output, errors) => {
   const reply = Reply.schema(output, errors)
 
-  // a reply is read, not shaped: what the operation returned is what the caller gets,
-  // and a value that only fits once coerced does not fit
-  const schema = schemas.schema(reply, { coerceTypes: false, useDefaults: false })
+  // a reply is read, not shaped: a value that only fits once coerced does not fit
+  const schema = schemas.schema(reply, { coerceTypes: false })
 
   return new Reply(schema)
 }

package/src/emission.js

@@ -6,13 +6,24 @@ import * as extensions from './extensions/index.js'
 export const emission = async (definitions, locator, context) => {
   if (definitions === undefined) return
 
-  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 = await boot.bridge.event(definition.bridge, definition.path, label, context)
+  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 = await boot.bridge.event(
+        definition.bridge,
+        definition.path,
+        label,
+        context
+      )
 
-    return new Event({ ...definition, label: `${locator.id}.${label}` }, decorator, bridge)
-  }))
+      return new Event(
+        { ...definition, label: `${locator.id}.${label}` },
+        decorator,
+        bridge
+      )
+    })
+  )
 
   return new Emission(events)
 }

package/src/extensions/aspects.js

@@ -2,7 +2,7 @@ import { instance } from './resolve.js'
 
 /**
  * @param {toa.norm.Component} manifest
- * @returns {toa.core.extensions.Aspect[]}
+ * @returns {import('@toa.io/core/types').extensions.Aspect[]}
  */
 export const aspects = (manifest) => {
   const aspects = []

package/src/extensions/component.js

@@ -1,8 +1,8 @@
 import { instances } from './instances.js'
 
 /**
- * @param {toa.core.Component} component
- * @returns {toa.core.Component}
+ * @param {import('@toa.io/core').Component} component
+ * @returns {import('@toa.io/core').Component}
  */
 export const component = (component) => {
   let decorated = component

package/src/extensions/context.js

@@ -1,8 +1,8 @@
 import { instances } from './instances.js'
 
 /**
- * @param {toa.core.Context} component
- * @returns {toa.core.Context}
+ * @param {import('@toa.io/core').Context} component
+ * @returns {import('@toa.io/core').Context}
  */
 export const context = (component) => {
   let decorated = component

package/src/extensions/emitter.js

@@ -1,16 +1,17 @@
 import { instances } from './instances.js'
 
 /**
- * @param {toa.core.bindings.Emitter} emitter
+ * @param {import('@toa.io/core/types').bindings.Emitter} emitter
  * @param {string} label
- * @param {toa.core.Locator} locator
- * @returns {toa.core.bindings.Emitter}
+ * @param {import('@toa.io/core').Locator} locator
+ * @returns {import('@toa.io/core/types').bindings.Emitter}
  */
 export const emitter = (emitter, label, locator) => {
   let decorated = emitter
 
   for (const factory of Object.values(instances)) {
-    if (factory.emitter !== undefined) decorated = factory.emitter(decorated, label, locator)
+    if (factory.emitter !== undefined)
+      decorated = factory.emitter(decorated, label, locator)
   }
 
   return decorated

package/src/extensions/instances.js

@@ -1,4 +1,4 @@
 /**
- * @type {{ [key: string]: toa.core.extensions.Factory}}
+ * @type {{ [key: string]: import('@toa.io/core/types').extensions.Factory}}
  */
 export const instances = {}

package/src/extensions/load.js

@@ -4,9 +4,11 @@ import { resolve } from './resolve.js'
  * @param {toa.norm.Component} manifest
  */
 export const load = async (manifest) => {
-  if (manifest.extensions === undefined)
-    return
+  if (manifest.extensions === undefined) return
 
-  await Promise.all(Object.keys(manifest.extensions)
-    .map(async (name) => await resolve(name, manifest.path)))
+  await Promise.all(
+    Object.keys(manifest.extensions).map(
+      async (name) => await resolve(name, manifest.path)
+    )
+  )
 }

package/src/extensions/manage.js

@@ -1,15 +1,14 @@
 import { instances } from './instances.js'
 
 /**
- * @param {toa.core.Connector} composition
- * @returns {toa.core.Connector}
+ * @param {import('@toa.io/core').Connector} composition
+ * @returns {import('@toa.io/core').Connector}
  */
 export const manage = (composition) => {
   let managed = composition
 
   for (const factory of Object.values(instances)) {
-    if (factory.manage !== undefined)
-      managed = factory.manage(managed)
+    if (factory.manage !== undefined) managed = factory.manage(managed)
   }
 
   return managed

package/src/extensions/receiver.js

@@ -1,16 +1,15 @@
 import { instances } from './instances.js'
 
 /**
- * @param {toa.core.Receiver} receiver
- * @param {toa.core.Locator} locator
- * @returns {toa.core.Receiver}
+ * @param {import('@toa.io/core/types').Receiver} receiver
+ * @param {import('@toa.io/core').Locator} locator
+ * @returns {import('@toa.io/core/types').Receiver}
  */
 export 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/resolve.js

@@ -17,7 +17,7 @@ const loading = {}
  *
  * @param {string} reference
  * @param {string} base
- * @returns {Promise<toa.core.extensions.Factory>}
+ * @returns {Promise<import('@toa.io/core/types').extensions.Factory>}
  */
 export const resolve = async (reference, base = process.cwd()) => {
   const path = find(reference, base)
@@ -35,7 +35,7 @@ export const resolve = async (reference, base = process.cwd()) => {
  *
  * @param {string} reference
  * @param {string} base
- * @returns {toa.core.extensions.Factory}
+ * @returns {import('@toa.io/core/types').extensions.Factory}
  */
 export const instance = (reference, base = process.cwd()) => {
   const factory = instances[find(reference, base)]

package/src/extensions/storage.js

@@ -1,8 +1,8 @@
 import { instances } from './instances.js'
 
 /**
- * @param {toa.core.Storage} storage
- * @returns {toa.core.Storage}
+ * @param {import('@toa.io/core/types').storages.Storage} storage
+ * @returns {import('@toa.io/core/types').storages.Storage}
  */
 export const storage = (storage) => {
   let decorated = storage

package/src/extensions/tenants.js

@@ -2,7 +2,7 @@ import { resolve } from './resolve.js'
 
 /**
  * @param {toa.norm.Component} manifest
- * @returns {toa.core.Connector[]}
+ * @returns {import('@toa.io/core').Connector[]}
  */
 export const tenants = async (manifest) => {
   const tenants = []

package/src/guards.js

@@ -2,16 +2,17 @@ import { Guard } from '@toa.io/core'
 import * as boot from './index.js'
 
 export async function guards(manifest, context) {
-  if (manifest.guards === undefined)
-    return 
+  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 await Promise.all(
+    entries.map(async ([name, guard]) => {
+      const bridge = await load(guard, name, context)
 
-    return new Guard(name, bridge)
-  }))
+      return new Guard(name, bridge)
+    })
+  )
 }
 
 async function load(guard, name, context) {

package/src/host.js

@@ -4,7 +4,7 @@ import * as boot from './index.js'
  * What the process hosting an extension provides to it. The counterpart of a component's
  * context: an extension reaches the core through this and through nothing else.
  *
- * @returns {toa.core.extensions.Host}
+ * @returns {import('@toa.io/core/types').extensions.Host}
  */
 export const host = () => ({
   remote: boot.remote,

package/src/index.js

@@ -1,4 +1,5 @@
 // the environment is read at module scope elsewhere, so it is loaded first
+// oxlint-disable-next-line import/no-unassigned-import
 import './env.js'
 
 import * as bindings from './bindings/index.js'
@@ -17,7 +18,6 @@ import { events } from './events.js'
 import { outbox } from './outbox.js'
 import { atomicity } from './atomicity.js'
 import { atom } from './atom.js'
-import { exposition } from './exposition.js'
 import { manifest } from './manifest.js'
 import { operation } from './operation.js'
 import { receivers, receive } from './receivers.js'
@@ -27,6 +27,26 @@ import { guards } from './guards.js'
 import { host } from './host.js'
 import { rc } from './rc.js'
 
-export { call, cascade, component, composition, context, emission, events, outbox, atomicity, atom, exposition, host, manifest, operation, receivers, receive, remote, storage, guards, rc }
+export {
+  call,
+  cascade,
+  component,
+  composition,
+  context,
+  emission,
+  events,
+  outbox,
+  atomicity,
+  atom,
+  host,
+  manifest,
+  operation,
+  receivers,
+  receive,
+  remote,
+  storage,
+  guards,
+  rc
+}
 
 export { bindings, bridge, contract, discovery, extensions }

package/src/manifest.js

@@ -9,8 +9,10 @@ import { span } from './span.js'
 export const manifest = async (path, options = {}) => {
   options = merge(clone(options), DEFAULTS)
 
-  const manifest = await span({ name: `manifest ${basename(path)}`, attributes: { path } },
-    async () => 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) {
@@ -30,7 +32,8 @@ export const manifest = async (path, options = {}) => {
       }
     }
 
-    if (asyncBinding === undefined) throw new Error('Bindings override must contain at least one async binding')
+    if (asyncBinding === undefined)
+      throw new Error('Bindings override must contain at least one async binding')
 
     if ('events' in manifest) {
       for (const event of Object.values(manifest.events)) event.binding = asyncBinding
@@ -51,7 +54,8 @@ export const manifest = async (path, options = {}) => {
     }
   }
 
-  if ('storage' in options && 'entity' in manifest) manifest.entity.storage = options.storage
+  if ('storage' in options && 'entity' in manifest)
+    manifest.entity.storage = options.storage
 
   manifest.locator = new Locator(manifest.name, manifest.namespace)
 

package/src/manifest.test.js

@@ -7,7 +7,6 @@ mock.module('@toa.io/norm', { namedExports: { component: () => mockComponent() }
 
 const { manifest } = await import('./manifest.js')
 
-
 const path = generate()
 
 it('should not modify options', async () => {
@@ -18,6 +17,6 @@ it('should not modify options', async () => {
   assert.deepStrictEqual(options.extensions.length, 2)
 })
 
-function mockComponent () {
+function mockComponent() {
   return { name: generate(), namespace: generate() }
 }

package/src/operation.js

@@ -1,17 +1,31 @@
-import { Transition, Observation, Assignment, Operation, Query, Effect, Unmanaged } from '@toa.io/core'
+import {
+  Transition,
+  Observation,
+  Assignment,
+  Operation,
+  Query,
+  Effect,
+  Unmanaged
+} from '@toa.io/core'
 
 import * as boot from './index.js'
 
-export async function operation (manifest, endpoint, definition, context, scope, preflight) {
+export 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.errors)
   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)
+  const query =
+    manifest.entity === undefined ? undefined : new Query(manifest.entity.properties)
 
   const Type = TYPES[definition.type]
 

package/src/outbox.js

@@ -7,8 +7,8 @@ import * as boot from './index.js'
  * 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]
+ * @param {import('@toa.io/core/types').storages.Storage} [storage]
+ * @param {import('@toa.io/core').Emission} [emission]
  */
 export const outbox = (manifest, storage, emission) => {
   if (emission === undefined) return

package/src/rc.js

@@ -1,5 +1,5 @@
 import * as boot from './index.js'
 
-export async function rc (manifest, context) {
+export async function rc(manifest, context) {
   return boot.bridge.rc(manifest.bridge, manifest.path, context)
 }

package/src/receivers.js

@@ -18,14 +18,25 @@ export const receivers = async (manifest, component) => {
     // 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
-      ? await boot.bridge.receiver(definition.bridge, manifest.path, label)
-      : undefined
-    const receiver = new Receiver({ ...definition, label, destination, origin }, local, bridge)
+    const bridge =
+      definition.bridge !== undefined
+        ? await boot.bridge.receiver(definition.bridge, manifest.path, label)
+        : undefined
+    const receiver = new Receiver(
+      { ...definition, label, destination, origin },
+      local,
+      bridge
+    )
     const decorator = extensions.receiver(receiver, manifest.locator)
 
-    const transport = definition.binding ?? await resolveBinding(locator, label)
-    const binding = await boot.bindings.receive(transport, source, label, manifest.locator.id, decorator)
+    const transport = definition.binding ?? (await resolveBinding(locator, label))
+    const binding = await boot.bindings.receive(
+      transport,
+      source,
+      label,
+      manifest.locator.id,
+      decorator
+    )
 
     binding.depends(component)
     receivers.push(binding)
@@ -34,7 +45,7 @@ export const receivers = async (manifest, component) => {
   return receivers
 }
 
-export async function receive (label, group, callback) {
+export async function receive(label, group, callback) {
   if (callback === undefined) {
     callback = group
     group = undefined
@@ -47,11 +58,11 @@ export async function receive (label, group, callback) {
 }
 
 /**
- * @param {toa.core.Locator} locator
+ * @param {import('@toa.io/core').Locator} locator
  * @param {string} label
  * @return {Promise<string>}
  */
-async function resolveBinding (locator, label) {
+async function resolveBinding(locator, label) {
   const event = label.split('.').pop()
   const discovery = await boot.discovery.discovery()
   const { events } = await discovery.lookup(locator)

package/src/remote.js

@@ -5,8 +5,8 @@ import { remap } from '@toa.io/generic'
 import * as boot from './index.js'
 
 /**
- * @param {toa.core.Locator} locator
- * @param {toa.core.Source} [source] the origin stamped on every call made through this remote
+ * @param {import('@toa.io/core').Locator} locator
+ * @param {import('@toa.io/core/types').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
  */
 export const remote = async (locator, source, manifest) => {
@@ -20,22 +20,25 @@ export const remote = async (locator, source, manifest) => {
   }
 
   // a call binds its consumers, which are loaded rather than required
-  const calls = manifest.operations === undefined
-    ? {}
-    : await settle(remap(manifest.operations,
-      (definition, endpoint) => boot.call(locator, endpoint, definition, manifest.entity, source)))
+  const calls =
+    manifest.operations === undefined
+      ? {}
+      : await settle(
+          remap(manifest.operations, (definition, endpoint) =>
+            boot.call(locator, endpoint, definition, manifest.entity, source)
+          )
+        )
 
   const remote = new Remote(locator, calls)
 
   // ensure discovery shutdown
-  if (discovery !== undefined)
-    remote.depends(discovery)
+  if (discovery !== undefined) remote.depends(discovery)
 
   return remote
 }
 
 /** An object whose values are promises, as an object of what they resolve to. */
-async function settle (object) {
+async function settle(object) {
   const entries = Object.entries(object)
   const values = await Promise.all(entries.map(([, promise]) => promise))
 

package/src/span.js

@@ -14,4 +14,5 @@ if (enabled) traces({ exporters: { console: {} } })
  * @param {() => Promise<any>} task
  * @returns {Promise<any>}
  */
-export const span = async (options, task) => enabled ? console.span(options, task) : task()
+export const span = async (options, task) =>
+  enabled ? console.span(options, task) : task()

package/src/storage.js

@@ -16,16 +16,25 @@ export const storage = async (manifest, outbox) => {
 
   const Factory = await load(manifest)
 
-  /** @type {toa.core.storages.Factory} */
+  /** @type {import('@toa.io/core/types').storages.Factory} */
   const factory = new Factory()
   const storage = factory.storage(manifest.locator, manifest.entity, { outbox })
 
+  // a component whose structure nothing will make must not start with the structure it lacks
+  if (manifest.entity.migrations?.length > 0 && storage.migrates !== true)
+    throw new Error(
+      `Component '${manifest.locator.id}' declares migrations, ` +
+        `which storage '${manifest.entity.storage}' does not apply`
+    )
+
   return extensions.storage(storage)
 }
 
-async function load (component) {
+async function load(component) {
   const reference = component.entity.storage
-  const path = require.resolve(reference, { paths: [component.path, import.meta.dirname] })
+  const path = require.resolve(reference, {
+    paths: [component.path, import.meta.dirname]
+  })
   const { Factory } = await import(pathToFileURL(path).href)
 
   return Factory

package/src/storage.test.js

@@ -0,0 +1,47 @@
+import { it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { Locator } from '@toa.io/core'
+
+import { storage } from './storage.js'
+
+const manifest = (entity) => ({
+  locator: new Locator('one', 'test'),
+  path: import.meta.dirname,
+  entity
+})
+
+const schema = { properties: {} }
+
+it('should not create a storage for a component that stores nothing', async () => {
+  assert.equal(await storage(manifest(undefined), false), undefined)
+})
+
+it('should refuse migrations a storage does not apply', async () => {
+  const entity = {
+    schema,
+    storage: '@toa.io/storages.null',
+    migrations: [{ id: '0001', steps: [] }]
+  }
+
+  await assert.rejects(
+    storage(manifest(entity), false),
+    /declares migrations, which storage '@toa.io\/storages.null' does not apply/
+  )
+})
+
+it('should accept a storage with no migrations', async () => {
+  const entity = { schema, storage: '@toa.io/storages.null' }
+
+  assert.notEqual(await storage(manifest(entity), false), undefined)
+})
+
+it('should accept migrations a storage applies', async () => {
+  const entity = {
+    schema,
+    storage: '@toa.io/storages.mongodb',
+    migrations: [{ id: '0001', steps: [] }]
+  }
+
+  assert.notEqual(await storage(manifest(entity), false), undefined)
+})

package/types/bindings.d.ts

@@ -1,3 +1,7 @@
-import type { bindings } from '@toa.io/core'
+import type { bindings } from '@toa.io/core/types'
 
-export function broadcast<T> (name: string, group?: string, binding?: string): bindings.Broadcast<T>
+export function broadcast<T>(
+  name: string,
+  group?: string,
+  binding?: string
+): bindings.Broadcast<T>

package/types/index.d.ts

@@ -1,23 +1,30 @@
-import * as core from '@toa.io/core'
+import type * as core from '@toa.io/core'
+import type * as types from '@toa.io/core/types'
 import * as composition from './composition.js'
 
 export * as bindings from './bindings.js'
 
-export async function composition (paths: string[], options?: composition.Options): Promise<core.Connector>
+export async function composition(
+  paths: string[],
+  options?: composition.Options
+): Promise<core.Connector>
 
-export async function remote (locator: core.Locator, source?: core.Source): Promise<core.Remote>
+export async function remote(
+  locator: core.Locator,
+  source?: types.Source
+): Promise<core.Remote>
 
-export async function receive<T = any> (
+export async function receive<T = any>(
   label: string,
   receiver: Receiver
 ): Promise<core.Connector>
 
-export async function receive<T = any> (
+export async function receive<T = any>(
   label: string,
   group: string | undefined,
   receiver: Receiver
 ): Promise<core.Connector>
 
-type Receiver = { receive: (message: core.Message<T>) => void | Promise<void> }
+type Receiver = { receive: (message: types.Message<T>) => void | Promise<void> }
 
-export function host (): core.extensions.Host
+export function host(): types.extensions.Host

package/types/manifest.d.ts

@@ -2,7 +2,8 @@ import * as _norm from '@toa.io/norm/types'
 import * as _composition from './composition.js'
 
 declare namespace toa.boot {
-
-  type Manifest = (path: string, options?: _composition.Options) => Promise<_norm.Component>
-
+  type Manifest = (
+    path: string,
+    options?: _composition.Options
+  ) => Promise<_norm.Component>
 }

package/CHANGELOG.md

@@ -1,188 +0,0 @@
-# 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.283](https://github.com/toa-io/toa/compare/v1.0.0-alpha.282...v1.0.0-alpha.283) (2026-09-04)
-
-### Bug Fixes
-
-* **core:** an operation returns the errors it declares, and nothing else ([1c2b819](https://github.com/toa-io/toa/commit/1c2b8193ae7fbe86bc1a25053a6044ee4dd16a4a))
-* **exposition:** declare the errors the built-in components return ([27200c3](https://github.com/toa-io/toa/commit/27200c348ab09068d58c52c3e83208cb29cd7290))
-
-
-# [1.0.0-alpha.282](https://github.com/toa-io/toa/compare/v1.0.0-alpha.281...v1.0.0-alpha.282) (2026-09-03)
-
-### Bug Fixes
-
-* **boot:** declare host, and build extensions with it in the step definitions ([915d957](https://github.com/toa-io/toa/commit/915d9571823358f8fca6fe19ef3aabd1b62e5605))
-
-### Features
-
-* **core:** a Host for extensions ([6315eac](https://github.com/toa-io/toa/commit/6315eac1e9fb05be472272de06385c54ad5934ce))
-
-
-# [1.0.0-alpha.278](https://github.com/toa-io/toa/compare/v1.0.0-alpha.277...v1.0.0-alpha.278) (2026-09-03)
-
-**Note:** Version bump only for package @toa.io/boot
-
-
-
-
-
-# [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
-
-
-
-
-
-# [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/src/exposition.js

@@ -1,13 +0,0 @@
-import { Exposition, Locator } from '@toa.io/core'
-
-import * as boot from './index.js'
-
-export const exposition = async (manifest) => {
-  const locator = new Locator('', '')
-  const exposition = new Exposition(locator, manifest)
-  const producers = boot.bindings.expose(exposition)
-
-  await Promise.all(producers.map((producer) => producer.connect()))
-
-  return producers
-}