@toa.io/operations 1.0.0-alpha.29 → 1.0.0-alpha.290

package/CHANGELOG.md

@@ -0,0 +1,42 @@
+# 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.290](https://github.com/toa-io/toa/compare/v1.0.0-alpha.289...v1.0.0-alpha.290) (2026-09-07)
+
+* fix(operations)!: an image starts as root again ([9eb0db7](https://github.com/toa-io/toa/commit/9eb0db75e3d02098fe75710280e8e15e63b73d57))
+* The runtime's environment is not a component's (#1070), closes [#1070](https://github.com/toa-io/toa/issues/1070)
+
+### BREAKING CHANGES
+
+* a component that read `process.env.TOA_*` reads `context` instead;
+  `echo(input)` no longer substitutes from the environment; a bash operation sees no
+  `TOA_*`; images no longer set `USER node` — see migrations/289.md.
+* an image built by alpha.289 runs its composition as `node` and
+  leaves the deployed environment readable under /proc; rebuild on 290. Nothing in
+  a context or a manifest changes.
+
+
+# [1.0.0-alpha.289](https://github.com/toa-io/toa/compare/v1.0.0-alpha.288...v1.0.0-alpha.289) (2026-09-07)
+
+* A deploy moves only what changed, and a component sees none of the runtime's environment (#1073) ([f38e3db](https://github.com/toa-io/toa/commit/f38e3db533f24db866c57bfa1ef294eff1eaf499)), closes [#1073](https://github.com/toa-io/toa/issues/1073) [#1064](https://github.com/toa-io/toa/issues/1064) [#1066](https://github.com/toa-io/toa/issues/1066) [#1067](https://github.com/toa-io/toa/issues/1067) [#1068](https://github.com/toa-io/toa/issues/1068) [#1069](https://github.com/toa-io/toa/issues/1069) [#1071](https://github.com/toa-io/toa/issues/1071) [#1070](https://github.com/toa-io/toa/issues/1070) [#1072](https://github.com/toa-io/toa/issues/1072)
+
+### BREAKING CHANGES
+
+* a component that read `process.env.TOA_*` reads `context` instead;
+  `echo(input)` no longer substitutes from the environment; a bash operation sees no
+  `TOA_*`; images no longer set `USER node` — see migrations/289.md.
+
+
+# [1.0.0-alpha.288](https://github.com/toa-io/toa/compare/v1.0.0-alpha.287...v1.0.0-alpha.288) (2026-09-06)
+
+**Note:** Version bump only for package @toa.io/operations
+
+
+
+
+
+# [1.0.0-alpha.287](https://github.com/toa-io/toa/compare/v1.0.0-alpha.286...v1.0.0-alpha.287) (2026-09-06)
+
+**Note:** Version bump only for package @toa.io/operations

package/image/runtime.Dockerfile

@@ -0,0 +1,4 @@
+FROM node:24.14.0-alpine3.22
+
+ARG VERSION
+RUN npm i -g @toa.io/runtime@${VERSION} --omit=dev

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@toa.io/operations",
-  "version": "1.0.0-alpha.29",
+  "version": "1.0.0-alpha.290",
+  "type": "module",
   "description": "Toa Deployment",
   "homepage": "https://toa.io",
   "author": {
@@ -16,23 +17,20 @@
     "url": "https://github.com/toa-io/toa/issues"
   },
   "engines": {
-    "node": ">= 18.0.0"
+    "node": ">= 24.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "main": "src/index.js",
-  "types": "types/index.d.ts",
+  "types": "types/index.ts",
   "scripts": {
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@toa.io/filesystem": "1.0.0-alpha.29",
-    "@toa.io/generic": "1.0.0-alpha.29",
-    "@toa.io/norm": "1.0.0-alpha.29",
-    "@toa.io/yaml": "1.0.0-alpha.29",
-    "execa": "5.1.1",
-    "fs-extra": "11.1.1"
+    "@toa.io/generic": "1.0.0-alpha.289",
+    "@toa.io/norm": "1.0.0-alpha.289",
+    "js-yaml": "5.4.1"
   },
-  "gitHead": "186d0e17c12a9016b8076edf925963cbb32b9219"
+  "gitHead": "c20cb1beb8d6e2bd3194385fbd57c71617a02bfb"
 }

package/readme.md

@@ -1,9 +1,102 @@
 # Toa Operations
 
+## Compositions
+
+A composition is deployed as one pod. Beside its components it may run extension services,
+which are otherwise each deployed on their own:
+
+```yaml
+# context.toa.yaml
+
+compositions:
+  - name: edge
+    components:
+      - todos.tasks
+    services:
+      - exposition
+```
+
+See [compositions](../documentation/compositions.md).
+
 ## Context
 
 ### Container Registry
 
+Deploy images default to `FROM ghcr.io/toa-io/runtime:<runtime.version>`
+(published with each Toa release). The base image already has `@toa.io/runtime`
+installed; composition/service Dockerfiles only install component dependencies.
+
+To use a custom base image, set `registry.build.image` (or `composition.image`).
+That image must provide the `toa` CLI, or install it via `registry.build.run`:
+
+```yaml
+# context.toa.yaml
+
+registry:
+  build:
+    image: node:24.14.0-alpine3.22
+    run: npm i -g @toa.io/runtime --omit=dev
+```
+
+#### Composition Images
+
+A composition is two images in one repository. `composition-<name>:deps-<hash>` is what its
+components depend on, installed on the base image: it is tagged by everything the install
+reads — the runtime version, the base image, the build options and each component's
+`package.json` (and `package-lock.json`, where there is one) — and is built only when one of
+those changes. `composition-<name>:<hash>` is the sources laid over it in a single linked
+layer, so a deploy that changes code alone builds and pushes that layer, and neither
+downloads nor uploads the dependencies again. The same holds for `mono`.
+
+A pushed image builds on the `toa` container builder, whose registry exporter is what lays
+an image over a base it never pulled; `toa build` loads on the daemon's own.
+
+A dependency named by a moving git ref is installed when the dependencies image is built and
+not again until its manifest changes, so pin such a dependency to a commit and bump it there.
+
+#### Extension Service Images
+
+`registry.services` says where an extension service's image comes from.
+
+`build`, the default, builds one per service into `registry.base`. Its tag carries the
+runtime version, so every Toa release rebuilds them all.
+
+`published` deploys the image the extension ships and builds nothing:
+
+```yaml
+# context.toa.yaml
+
+registry:
+  services: published
+```
+
+The images are tagged with the runtime version:
+
+```
+ghcr.io/toa-io/extension-exposition-gateway:1.0.0-alpha.285
+ghcr.io/toa-io/extension-realtime-streams:1.0.0-alpha.285
+ghcr.io/toa-io/extension-introspection-explorer:1.0.0-alpha.285
+ghcr.io/toa-io/extension-configuration-values:1.0.0-alpha.285
+```
+
+The cluster pulls them from `ghcr.io` rather than from `registry.base`. They are public and
+`registry.credentials` does not apply; a cluster that cannot reach `ghcr.io` needs `build`.
+
+The field is environment-scoped like the rest:
+
+```yaml
+# context.toa.yaml
+
+registry:
+  base@local: localhost:5000
+  base@production: registry.digitalocean.com/acme
+  services: published
+  services@local: build
+```
+
+An extension that states no image is built whatever this says, as is a service a
+composition runs in its own pod.
+
 #### Build Options
 
 ```yaml

package/src/deployment/.deployment/.describe/components.js

@@ -1,10 +1,8 @@
-'use strict'
-
 /**
  * @param {toa.deployment.Composition[]} compositions
  * @returns {string[]}
  */
-const components = (compositions) => {
+export const components = (compositions) => {
   /** @type {Set<string>} */
   const components = new Set()
 
@@ -16,5 +14,3 @@ const components = (compositions) => {
 
   return Array.from(components)
 }
-
-exports.components = components

package/src/deployment/.deployment/.describe/compositions.js

@@ -1,11 +1,30 @@
-'use strict'
+import { addVariables } from './variables.js'
+import { addMounts } from './mounts.js'
+import { fold } from './fold.js'
 
-const { addVariables } = require('./variables')
-
-function compositions (compositions, variables) {
+export function compositions(compositions, dependency) {
   for (const composition of compositions) {
-    addVariables(composition, variables)
+    const claimed = (dependency.services ?? []).filter(
+      (service) => service.workload?.includes(composition.name) === true
+    )
+
+    // a service brings components of its own — the identity components inside the gateway —
+    // and their variables are keyed by their own labels, not by the composition's
+    const keys = composition.components.concat(
+      ...claimed.map((service) => service.components ?? [])
+    )
+
+    addVariables(composition, dependency.variables, keys)
+    addMounts(composition, dependency.mounts, keys)
+
+    if (claimed.length > 0) {
+      // the label each hosted service's own Service selects on
+      composition.hosted = claimed.map((service) => service.name)
+
+      fold(composition, claimed, dependency)
+    }
+
+    if (dependency.probe !== undefined && dependency.probe !== false)
+      composition.probe ??= dependency.probe
   }
 }
-
-exports.compositions = compositions

package/src/deployment/.deployment/.describe/dependencies.js

@@ -1,10 +1,8 @@
-'use strict'
-
 /**
  * @param {toa.deployment.dependency.Reference[]} references
  * @returns {*}
  */
-const dependencies = (references) => {
+export const dependencies = (references) => {
   return references?.reduce((map, reference) => {
     const { name, alias, values } = reference
 
@@ -13,6 +11,3 @@ const dependencies = (references) => {
     return map
   }, {})
 }
-
-
-exports.dependencies = dependencies

package/src/deployment/.deployment/.describe/events.js

@@ -0,0 +1,63 @@
+/**
+ * Tells each component which of its events something consumes. An event nobody consumes gets
+ * no emitter, no exchange and no outbox row, and a component none of whose events are consumed
+ * gets no outbox at all.
+ *
+ * A component that declares events always gets the variable, empty when nothing is consumed —
+ * an absent variable means every event, which is what a run without a deployment gets.
+ *
+ * @param {toa.norm.Context} context
+ * @param {toa.deployment.Dependency} dependency
+ */
+export function events(context, dependency) {
+  const components = deployed(context)
+  const consumed = collect(components, context.events, dependency.events)
+
+  for (const { locator, events } of components) {
+    if (events === undefined) continue
+
+    const labels = Object.keys(events).filter((label) =>
+      consumed.has(locator.id + '.' + label)
+    )
+
+    dependency.variables[locator.label] ??= []
+
+    dependency.variables[locator.label].push({
+      name: VARIABLE + locator.uppercase,
+      value: labels.join(' ')
+    })
+  }
+}
+
+/**
+ * Every component this context deploys, its own and those its extensions bring. `components`
+ * holds only the former; the latter reach a deployment as instances of what they depend on,
+ * which is also how they are given the rest of their variables.
+ */
+function deployed(context) {
+  const components = new Map()
+
+  for (const instances of Object.values(context.dependencies ?? {}))
+    for (const { component } of instances) components.set(component.locator.id, component)
+
+  return [...components.values()]
+}
+
+/**
+ * Everything that consumes an event of this context: the receivers of its own components, what
+ * a dependency declares it consumes, and what the context says is consumed outside it.
+ */
+function collect(components, declared, contributed) {
+  const consumed = new Set(declared ?? [])
+
+  for (const label of contributed ?? []) consumed.add(label)
+
+  for (const { receivers } of components)
+    for (const [label, receiver] of Object.entries(receivers ?? {}))
+      // a receiver with a source consumes from a foreign broker, not from this context
+      if (receiver.source === undefined) consumed.add(label)
+
+  return consumed
+}
+
+const VARIABLE = 'TOA_EVENTS_'

package/src/deployment/.deployment/.describe/fold.js

@@ -0,0 +1,42 @@
+/**
+ * What a workload takes on by running services in its own pod: their variables, the ports
+ * they bind, and a readiness probe answered by one of them rather than by the workload.
+ *
+ * What it does *not* take on is how they are reached. A composition-hosted service keeps
+ * its own Service and Ingress — only the pods behind them change — so the ingress union
+ * belongs to `mono`, the one workload that fronts every service under a single name.
+ *
+ * @param {object} workload
+ * @param {toa.deployment.dependency.Service[]} services
+ * @param {toa.deployment.Dependency} dependency
+ */
+export function fold(workload, services, dependency) {
+  workload.variables ??= []
+
+  for (const service of services) {
+    if (service.variables !== undefined)
+      for (const variable of service.variables)
+        if (!workload.variables.some((item) => item.name === variable.name))
+          workload.variables.push(variable)
+
+    // every declared port is bound by the single process, none is primary
+    if (service.port !== undefined)
+      (workload.backends ??= []).push({
+        port: service.port,
+        path: service.ingress?.path ?? '/'
+      })
+
+    if (service.probe !== undefined && service.probe !== false)
+      workload.probe = service.probe
+  }
+
+  if (
+    workload.probe === undefined &&
+    dependency.probe !== undefined &&
+    dependency.probe !== false
+  )
+    workload.probe = dependency.probe
+
+  // the more specific prefix must come first, whatever the controller's tie-break
+  workload.backends?.sort((a, b) => b.path.length - a.path.length)
+}

package/src/deployment/.deployment/.describe/fold.test.js

@@ -0,0 +1,108 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { fold } from './fold.js'
+
+const service = (name, extra = {}) => ({ group: 'group', name, version: '0', ...extra })
+
+it('should collect the ports of every service', () => {
+  const workload = {}
+
+  fold(workload, [service('one', { port: 8000 }), service('two', { port: 8002 })], {})
+
+  assert.deepStrictEqual(workload.backends, [
+    { port: 8000, path: '/' },
+    { port: 8002, path: '/' }
+  ])
+})
+
+it('should take the path a service declares', () => {
+  const workload = {}
+
+  fold(workload, [service('one', { port: 8002, ingress: { path: '/explorer' } })], {})
+
+  assert.deepStrictEqual(workload.backends, [{ port: 8002, path: '/explorer' }])
+})
+
+it('should put the more specific prefix first', () => {
+  const workload = {}
+
+  fold(
+    workload,
+    [
+      service('one', { port: 8000, ingress: { path: '/' } }),
+      service('two', { port: 8002, ingress: { path: '/explorer' } })
+    ],
+    {}
+  )
+
+  assert.deepStrictEqual(
+    workload.backends.map((backend) => backend.path),
+    ['/explorer', '/']
+  )
+})
+
+it('should leave a service without a port out of the backends', () => {
+  const workload = {}
+
+  fold(workload, [service('one')], {})
+
+  assert.strictEqual(workload.backends, undefined)
+})
+
+describe('variables', () => {
+  it('should take those of every service', () => {
+    const workload = {}
+
+    fold(
+      workload,
+      [
+        service('one', { variables: [{ name: 'A', value: '1' }] }),
+        service('two', { variables: [{ name: 'B', value: '2' }] })
+      ],
+      {}
+    )
+
+    assert.deepStrictEqual(workload.variables, [
+      { name: 'A', value: '1' },
+      { name: 'B', value: '2' }
+    ])
+  })
+
+  it('should keep the first of a name', () => {
+    const workload = { variables: [{ name: 'A', value: 'own' }] }
+
+    fold(workload, [service('one', { variables: [{ name: 'A', value: 'theirs' }] })], {})
+
+    assert.deepStrictEqual(workload.variables, [{ name: 'A', value: 'own' }])
+  })
+})
+
+describe('probe', () => {
+  const probe = { path: '/.ready', port: 8004 }
+  const fallback = { path: '/.ready', port: 8001 }
+
+  it('should take the probe of a service over the default', () => {
+    const workload = {}
+
+    fold(workload, [service('one', { port: 8000, probe })], { probe: fallback })
+
+    assert.deepStrictEqual(workload.probe, probe)
+  })
+
+  it('should fall back to the default', () => {
+    const workload = {}
+
+    fold(workload, [service('one', { port: 8000 })], { probe: fallback })
+
+    assert.deepStrictEqual(workload.probe, fallback)
+  })
+
+  it('should ignore a disabled probe', () => {
+    const workload = {}
+
+    fold(workload, [service('one', { port: 8000, probe: false })], { probe: false })
+
+    assert.strictEqual(workload.probe, undefined)
+  })
+})

package/src/deployment/.deployment/.describe/index.js

@@ -1,13 +1,4 @@
-'use strict'
-
-const { dependencies } = require('./dependencies')
-const { components } = require('./components')
-const { compositions } = require('./compositions')
-const { variables } = require('./variables')
-const { services } = require('./services')
-
-exports.dependencies = dependencies
-exports.components = components
-exports.compositions = compositions
-exports.variables = variables
-exports.services = services
+export { dependencies } from './dependencies.js'
+export { components } from './components.js'
+export { compositions } from './compositions.js'
+export { services } from './services.js'

package/src/deployment/.deployment/.describe/mounts.js

@@ -0,0 +1,17 @@
+export function addMounts(composition, mounts, keys = composition.components) {
+  if (mounts === undefined) return
+
+  const used = new Set()
+
+  for (const [key, mount] of Object.entries(mounts)) {
+    if (key !== 'global' && !keys?.includes(key)) continue
+
+    for (const { name, path, claim } of mount) {
+      if (used.has(name)) continue
+
+      composition.mounts ??= []
+      composition.mounts.push({ name, path, claim })
+      used.add(name)
+    }
+  }
+}

package/src/deployment/.deployment/.describe/resources.js

@@ -0,0 +1,103 @@
+/**
+ * Every deployment states what it may take. One that states nothing is `BestEffort`: the
+ * first evicted under memory pressure and the last given CPU under contention — which on
+ * a busy node is slow enough for its own startup probe to kill it, in a loop, while the
+ * chart reports nothing wrong. That is not a thing to find out in production.
+ *
+ * A deployment takes its own declaration, or the context's `resources` where it has none.
+ * Deploying without any is a decision rather than an omission, and it is spelled
+ * `resources: null` — at either place.
+ */
+export function resources(context, values) {
+  for (const unit of units(values)) {
+    // `null` is an answer and `undefined` is not one, so the fallback reads only the latter
+    if (unit.deployment.resources === undefined)
+      unit.deployment.resources = context.resources
+
+    if (unit.deployment.resources === undefined)
+      throw new Error(
+        `${unit.subject} declares no resources. ` +
+          "Declare them on it or as the context's 'resources', " +
+          "or 'resources: null' to deploy it without any."
+      )
+
+    heap(unit.deployment)
+  }
+}
+
+/**
+ * The memory limit sizes the heap. Node reads the machine's memory rather than the
+ * container's, so without this the heap grows past the limit and the pod is killed instead
+ * of collected. What is left of the limit is the process itself: its code, its buffers and
+ * its threads. A deployment that states `NODE_OPTIONS` of its own keeps them.
+ */
+function heap(deployment) {
+  const limit = deployment.resources?.memory?.[1]
+
+  if (limit === undefined) return
+
+  deployment.variables ??= []
+
+  if (deployment.variables.some((variable) => variable.name === NODE_OPTIONS)) return
+
+  const megabytes = Math.floor((quantity(limit) * HEAP_SHARE) / 2 ** 20)
+
+  deployment.variables.push({
+    name: NODE_OPTIONS,
+    value: `--max-old-space-size=${megabytes}`
+  })
+}
+
+/**
+ * A Kubernetes quantity, in bytes.
+ *
+ * @param {string | number} value
+ * @returns {number}
+ */
+export function quantity(value) {
+  const match = String(value).match(/^(\d+(?:\.\d+)?)([KMGTPE]i?|[kmun])?$/)
+
+  if (match === null) throw new Error(`'${value}' is not a quantity`)
+
+  const [, number, suffix = ''] = match
+  const scale = SUFFIXES[suffix]
+
+  if (scale === undefined) throw new Error(`'${value}' is not a memory quantity`)
+
+  return Number(number) * scale
+}
+
+const NODE_OPTIONS = 'NODE_OPTIONS'
+const HEAP_SHARE = 0.75
+
+const SUFFIXES = {
+  '': 1,
+  K: 1e3,
+  M: 1e6,
+  G: 1e9,
+  T: 1e12,
+  P: 1e15,
+  E: 1e18,
+  Ki: 2 ** 10,
+  Mi: 2 ** 20,
+  Gi: 2 ** 30,
+  Ti: 2 ** 40,
+  Pi: 2 ** 50,
+  Ei: 2 ** 60
+}
+
+function* units(values) {
+  if (values.mono !== undefined)
+    yield { deployment: values.mono, subject: 'The mono deployment' }
+
+  for (const composition of values.compositions ?? [])
+    yield { deployment: composition, subject: `Composition '${composition.name}'` }
+
+  for (const service of values.services ?? []) {
+    // a service a composition runs has no deployment of its own to size; the composition
+    // it runs in states what the pod may take
+    if (service.workload !== undefined) continue
+
+    yield { deployment: service, subject: `Service '${service.name}'` }
+  }
+}