@onlineapps/mq-client-core 4.0.1 → 4.2.0

package/src/config/queueConfig.js

@@ -60,7 +60,13 @@ const SECTION_PREFIXES = Object.freeze({
   monitoring: 'monitoring',
   telemetry: 'telemetry',
   alerts: 'alert',
-  registry: 'registry'
+  registry: 'registry',
+  scheduler: 'scheduler',
+  // The one section whose names travel WITHOUT a prefix: `dlx` is the wire name every
+  // business queue dead-letters to (`x-dead-letter-exchange`), and renaming it would
+  // re-declare live topology. The empty prefix is a declared case, read explicitly by
+  // `queueName()`; a section absent from this map is still refused (d.902).
+  deadLetter: ''
 });
 
 /**
@@ -81,7 +87,8 @@ const INFRASTRUCTURE_PREFIX_LOOKUPS = Object.freeze({
   validation: 'getValidationQueueConfig',
   monitoring: 'getMonitoringQueueConfig',
   telemetry: 'getTelemetryQueueConfig',
-  delivery: 'getDeliveryQueueConfig'
+  delivery: 'getDeliveryQueueConfig',
+  scheduler: 'getSchedulerQueueConfig'
 });
 
 const INFRASTRUCTURE_PREFIXES = Object.freeze(Object.keys(INFRASTRUCTURE_PREFIX_LOOKUPS));
@@ -627,10 +634,17 @@ module.exports = {
     /**
      * monitoring.workflow - Unified workflow lifecycle monitoring
      * Bound to monitoring.workflow.fanout exchange (fanout).
-     * Delivery Dispatcher publishes 'completed'/'failed' events after processing workflow.completed/workflow.failed
-     * Business services publish 'progress' events during workflow step processing
-     * Message format includes event_type: 'completed' | 'failed' | 'progress'
-     * Includes full cookbook and context snapshots for trace storage
+     *
+     * WHO publishes onto that fanout: the Delivery Dispatcher after it processes a terminal
+     * workflow message, the in-process orchestrator during a run, and this client's own
+     * dead-letter hook. WHICH event_type each of them sends is not written here - the
+     * vocabulary has one owner and it grows, so a list copied into this comment would be a
+     * hand-written descriptive fact that ages in silence
+     * (`.claude/rules/doc-code-binding.md` §1).
+     *
+     * The message carries the cookbook and the context snapshot the trace store keeps.
+     *
+     * @see api/docs/biz/70-contracts/monitoring-events.md
      */
     'workflow': {
       durable: true,
@@ -644,15 +658,20 @@ module.exports = {
 
     /**
      * monitoring.services - Service lifecycle events monitoring
-     * Registry publishes service lifecycle events (registered, validation.completed, version.changed, status.changed)
-     * InfrastructureHealthTracker publishes service status changes
-     * Message format includes event_type: 'service.registered' | 'service.validation.completed' | 
-     *   'service.version.changed' | 'service.deregistered' | 'service.status.changed'
+     *
+     * WHO publishes here: the Registry, which owns the service lifecycle, and the
+     * InfrastructureHealthTracker with service status changes. WHICH event_type each of them
+     * sends is not written here — that vocabulary has one owner and it grows, and a list
+     * copied into this comment would be a hand-written descriptive fact that ages in silence
+     * (`.claude/rules/doc-code-binding.md` §1).
+     *
      * NOTE: Heartbeats are NOT published here - they are too frequent. The cadence
      *   is not a number this file owns: see the `heartbeatInterval` constructor option
      *   of RegistryClient (@onlineapps/conn-orch-registry), which ServiceWrapper feeds
      *   from BIZ_HEARTBEAT_INTERVAL_MS.
      * NOTE: Healthcheck messages go to infrastructure.health.events exchange
+     *
+     * @see api/docs/biz/70-contracts/monitoring-events.md
      */
     'services': {
       durable: true,
@@ -689,6 +708,33 @@ module.exports = {
       durable: true
     },
 
+    /**
+     * monitoring.resource - Topic exchange for resource-changed events
+     *
+     * The monitoring consumer's resource-changed watcher publishes here with a routing
+     * key of the shape `resource.changed.<resource_type>`; the delivery endpoint binds
+     * `delivery.resource.events` to it by the pattern `resource.changed.#` for WS push.
+     * Three sides of ONE wire — the publisher, this exchange and the bound queue — and
+     * until d.619 the name had an owner on none of them: a module constant on the
+     * publishing side and a required env key on the binding side, so an override or a
+     * typo on either side loses every event silently. That is the same reasoning d.270
+     * settled for the health-events fanout, and the reason the name lives here and is
+     * published by `src/index.js` § topology.
+     *
+     * `topic`, `durable`, no arguments: what the publisher asserts, and what the running
+     * broker answers for it. An exchange holds nothing to dead-letter, so — like every
+     * other exchange in this file — it carries no route, even though every QUEUE of this
+     * section routes to `monitoring.dlq`.
+     *
+     * @see api/infra/api_monitoring/src/consumer/watchers/resourceChangedPublisher.js
+     * @see api/docs/biz/70-contracts/resource-changed.md
+     */
+    resource: {
+      type: 'exchange',
+      exchangeType: 'topic',
+      durable: true
+    },
+
     /**
      * monitoring.infrastructure.health.events - the monitoring consumer's own copy of
      * the infrastructure health events, bound to the infrastructure.health.events
@@ -743,8 +789,8 @@ module.exports = {
    * Telemetry queue configurations
    *
    * The OpenTelemetry intake of the monitoring consumer: every service publishes
-   * logs, metrics and spans to `telemetry.exchange` with a routing key carrying its
-   * own name, and these three queues are bound to it
+   * logs, metrics and spans to the `telemetry.exchange` declared below, with a routing
+   * key carrying its own name, and these three queues are bound to it
    * (`docs/standards/monitoring-queues.md`, `docs/architecture/monitoring.md`).
    *
    * The TTL and the cap are the ones the queues are created with today; this config is
@@ -758,11 +804,50 @@ module.exports = {
    * @see api/docs/governance/confirmations/mq-consumer-contract.md 003
    */
   telemetry: {
+    /**
+     * telemetry.exchange - the topic exchange every telemetry producer on the platform
+     * publishes to, and the one the three queues below are bound to.
+     *
+     * The widest wire there is: every biz service through `@onlineapps/service-wrapper`,
+     * every infrastructure service through `@onlineapps/monitoring-core` (its logger and
+     * its OpenTelemetry exporter), and the monitoring consumer, which asserts the
+     * exchange, binds the three queues and drains them — and since I16 publishes its own
+     * lines onto it as well.
+     *
+     * Until d.708 the name appeared HERE only in the prose above, while the other three
+     * platform exchanges of this file (`infrastructure.health.events`,
+     * `monitoring.workflow.fanout`, `monitoring.resource`) each had a template. So one
+     * name had three owners — a module constant in the monitoring consumer
+     * (`infra/api_monitoring/src/consumer/topology.js`) and a config default in each of
+     * monitoring-core's two publishers — which is exactly the shape d.270 gave an owner
+     * for the health-events fanout and d.619 for the resource-changed topic
+     * (`change-discipline.md` § One rail per concern).
+     *
+     * `topic`, `durable`, no arguments: what all three of those sides assert today
+     * (`assertExchange(<name>, 'topic', { durable: true })`), measured before this entry
+     * was written. The broker compares an exchange's type and durability at EVERY
+     * declaration, so a value invented here would be `406 PRECONDITION-FAILED` for
+     * whichever side booted second. An exchange holds nothing to dead-letter, so — like
+     * every other exchange in this file — it carries no route, even though every QUEUE
+     * of this section routes to `telemetry.dlq`.
+     *
+     * Declaring it is not creating it: the exchange is brought into being by the service
+     * that asserts it, the same rule as `telemetry.dlq` below.
+     *
+     * @see api/infra/api_monitoring/src/consumer/index.js — assertMonitoringTopology()
+     * @see api/shared/monitoring/monitoring-core/src/exporters/rabbitmq.js
+     */
+    exchange: {
+      type: 'exchange',
+      exchangeType: 'topic',
+      durable: true
+    },
+
     /** telemetry.logs.queue - OpenTelemetry log records, drained into Loki. */
     'logs.queue': {
       durable: true,
       arguments: {
-        'x-message-ttl': 60000,       // 1 minute TTL for unprocessed messages
+        'x-message-ttl': 300000,      // 5 min — okno deploye bez konzumenta; conf telemetry-queue-ttl 001
         'x-max-length': 100000,       // Max 100k messages in queue
         'x-dead-letter-exchange': '',        // Default exchange: routing key IS the queue name
         'x-dead-letter-routing-key': 'telemetry.dlq'
@@ -773,7 +858,7 @@ module.exports = {
     'metrics.queue': {
       durable: true,
       arguments: {
-        'x-message-ttl': 60000,
+        'x-message-ttl': 300000, // 5 min — okno deploye bez konzumenta; conf telemetry-queue-ttl 001
         'x-max-length': 100000,
         'x-dead-letter-exchange': '',
         'x-dead-letter-routing-key': 'telemetry.dlq'
@@ -784,7 +869,7 @@ module.exports = {
     'traces.queue': {
       durable: true,
       arguments: {
-        'x-message-ttl': 60000,
+        'x-message-ttl': 300000, // 5 min — okno deploye bez konzumenta; conf telemetry-queue-ttl 001
         'x-max-length': 100000,
         'x-dead-letter-exchange': '',
         'x-dead-letter-routing-key': 'telemetry.dlq'
@@ -932,11 +1017,155 @@ module.exports = {
     },
 
     /**
-     * registry.changes - Registry event fanout exchange
-     * (This is an exchange, not a queue, but included for reference)
+     * registry.changes - the fanout exchange registry index changes travel on.
+     *
+     * One module is every side of this wire: `@onlineapps/conn-orch-registry`,
+     * `src/registryEventConsumer.js`. It holds the only spelling of the name (`:92`),
+     * it is the only party that ASSERTS the exchange (`:117`,
+     * `assertExchange(name, 'fanout', { durable: true })`), it binds each service's
+     * `{service}.registry.events` to it with the pattern `''` (`:133`), and it publishes
+     * the snapshot request onto it (`:331`, `routingKey: ''`). The publish path declares
+     * nothing since d.342, so there is no second founder.
+     *
+     * Until d.712 this was the ONE exchange of this file with no `exchangeType`, so the
+     * founder had to decide the kind on its own while the template only said "an
+     * exchange, durable". `type` is one of the two properties the broker compares at
+     * every declaration, which makes it exactly the half that cannot live somewhere
+     * else (`change-discipline.md` § One rail per concern; the same step d.619 made for
+     * `monitoring.resource` and d.708 for `telemetry.exchange`).
+     *
+     * `fanout`, `durable`, no arguments: measured on that founder, not chosen. The
+     * binding pattern `''` only routes on a fanout, so the type is load-bearing rather
+     * than decorative. An exchange holds nothing to dead-letter, so — like every other
+     * exchange in this file — it carries no route.
+     *
+     * Declaring it is not creating it: the exchange is brought into being by the service
+     * whose registry client subscribes to changes.
+     *
+     * @see api/shared/connector/conn-orch-registry/src/registryEventConsumer.js
      */
     changes: {
       type: 'exchange',
+      exchangeType: 'fanout',
+      durable: true
+    }
+  },
+
+  /**
+   * Scheduler queue configurations — the platform's one holder of time.
+   *
+   * The scheduler consumes requests for a run: a recurrence that came due, or a deferred
+   * request somebody filed. Both are published by other services and both are the ONLY
+   * record that the run was owed, so the family is shaped for loss-aversion rather than
+   * for freshness (`docs/governance/confirmations/scheduler.md` 001, 004).
+   *
+   * @see api/infra/api_scheduler/README.md
+   */
+  scheduler: {
+    /**
+     * scheduler.request - every request for a run, from every producer.
+     *
+     * NO `x-message-ttl`, deliberately, and it is the one property that differs from the
+     * shape of a workflow queue: a request that waited out a consumer outage is still the
+     * run that was due, and a TTL would turn that outage into runs which silently never
+     * happened. What bounds the queue is its length, and what catches a request the
+     * scheduler could not process is the family's dead-letter queue below — over the
+     * DEFAULT exchange, where the routing key IS the destination name, the same way every
+     * other infrastructure family here routes (the `dlx` exchange belongs to the business
+     * templates, whose queues one service owns).
+     *
+     * Without this declaration `consume()` refuses to attach a consumer at all — a queue
+     * with no declared route would have the broker DROP what the policy rejects
+     * (`docs/governance/confirmations/mq-consumer-contract.md` 002).
+     */
+    request: {
+      durable: true,
+      arguments: {
+        'x-max-length': 10000,
+        'x-dead-letter-exchange': '',        // Default exchange: routing key IS the queue name
+        'x-dead-letter-routing-key': 'scheduler.dlq'
+      }
+    },
+
+    /**
+     * scheduler.workflow.events - where the scheduler learns that a run it started ENDED.
+     *
+     * The third queue bound to `monitoring.workflow.fanout`, beside `monitoring.workflow`
+     * and `delivery.workflow.events`. The owner settled it in
+     * `docs/governance/confirmations/scheduler.md` 007: the terminal event of a run already
+     * travels on that exchange, so the scheduler reads it there rather than asking the
+     * observer over HTTP or reading a database that is not its own. No producer changes; the
+     * binding is the scheduler's own act at boot (the pattern
+     * `infra/api_delivery_endpoint/src/index.js:164` already uses), and this file only
+     * DECLARES what that queue is.
+     *
+     * WHICH event_type values those are is NOT written here: the vocabulary has one owner and
+     * it grows. A list copied into this comment would be a hand-written descriptive fact that
+     * ages in silence (`.claude/rules/doc-code-binding.md` §1).
+     *
+     * THE TTL IS STATED, NOT INHERITED, and it is a property of that decision rather than a
+     * default: a fanout cannot filter, so this queue receives EVERY workflow event of the
+     * platform and the scheduler discards most of them. 300 000 ms is what
+     * `monitoring.workflow` carries on the same exchange - the sibling whose readings this
+     * one follows. What an outage longer than the TTL costs is on record: those events are
+     * lost and the run is closed by the per-schedule timeout, which 007 keeps as the
+     * backstop rather than replacing it.
+     *
+     * The route goes over the DEFAULT exchange, like every other infrastructure family
+     * here, and ends in this family's own `scheduler.dlq`. Without a declared route
+     * `consume()` refuses to attach at all (`BaseClient.js`,
+     * `CONSUMER_DEAD_LETTER_ROUTE_MISSING`; `mq-consumer-contract` 002).
+     *
+     * @see api/docs/governance/confirmations/scheduler.md 007
+     * @see api/docs/biz/70-contracts/monitoring-events.md
+     */
+    'workflow.events': {
+      durable: true,
+      arguments: {
+        'x-message-ttl': 300000,      // Stated by confirmation 007, like monitoring.workflow
+        'x-max-length': 10000,
+        'x-dead-letter-exchange': '',        // Default exchange: routing key IS the queue name
+        'x-dead-letter-routing-key': 'scheduler.dlq'
+      }
+    },
+
+    /**
+     * scheduler.dlq - the END of this family's chain.
+     *
+     * Durable, capped higher, no TTL and no onward route — the three properties every
+     * dead-letter queue in this file carries, and the reason the operator's `*.dlq`
+     * dashboard finds it (`mq-consumer-contract` 003).
+     */
+    dlq: {
+      durable: true,
+      arguments: {
+        // No TTL for DLQ - messages should persist
+        'x-max-length': 50000         // Higher limit for DLQ
+      }
+    }
+  },
+
+  /**
+   * The platform's dead-letter exchange, DECLARED — name, type and durability.
+   *
+   * Every business template dead-letters here (`x-dead-letter-exchange`), and
+   * `@onlineapps/conn-infra-mq` `QueueManager.setupServiceQueues()` brings it into
+   * being as a durable `direct` exchange before binding `{service}.dlq` to it. The
+   * broker compares type and durability at EVERY `assertExchange`, so they belong to
+   * the declaration, where a second reader — `api/scripts/ci/declare-broker-exchanges.mjs`,
+   * which declares exchanges on a CI broker nobody's services booted against — finds
+   * them through the same loop as every other exchange of this file, instead of keeping
+   * a copy of the founder's line (TODO INFRA 349, d.902).
+   *
+   * Its wire name carries no prefix (`SECTION_PREFIXES.deadLetter` is `''`), and the key
+   * is the one constant at the top of this file, so the name has one spelling.
+   * An exchange holds nothing to dead-letter, so — like every other exchange here — it
+   * carries no route.
+   */
+  deadLetter: {
+    [DEAD_LETTER_EXCHANGE]: {
+      type: 'exchange',
+      exchangeType: 'direct',
       durable: true
     }
   },
@@ -950,9 +1179,13 @@ module.exports = {
    * a name this configuration does not declare would be asserted against the broker
    * by whoever imported it, which is how a typo becomes a second queue.
    *
+   * A section whose declared prefix is `''` (`deadLetter`) composes the bare key: its
+   * names travel without a prefix. That is a value of the map, not a default — a
+   * section missing from it is refused below.
+   *
    * @param {string} section - Section holding the entry (e.g. 'deliveryEvents').
    * @param {string} key - The entry's key within that section (e.g. 'health.events').
-   * @returns {string} The full name (e.g. 'delivery.health.events').
+   * @returns {string} The full name (e.g. 'delivery.health.events'; the bare key for 'deadLetter').
    * @throws {ValidationError} If the section composes no wire name, or the entry is undeclared.
    */
   queueName(section, key) {
@@ -974,7 +1207,7 @@ module.exports = {
       );
     }
 
-    return `${prefix}.${key}`;
+    return prefix === '' ? key : `${prefix}.${key}`;
   },
 
   /**
@@ -1219,6 +1452,23 @@ module.exports = {
     return this.getQueueConfig('infrastructure', name);
   },
 
+  /**
+   * Get scheduler queue configuration
+   * @param {string} queueName - Queue name (e.g., 'scheduler.request')
+   * @returns {Object} Queue configuration
+   * @throws {ValidationError} If the name carries another prefix, or nothing declares it.
+   */
+  getSchedulerQueueConfig(queueName) {
+    if (!queueName.startsWith('scheduler.')) {
+      throw new ValidationError(
+        `[queueConfig] Queue ${queueName} is not a scheduler queue - Expected: a name starting with "scheduler.". `
+          + 'Fix: call getInfrastructureQueueConfig(), which routes each prefix to the right lookup.'
+      );
+    }
+    const name = queueName.slice('scheduler.'.length);
+    return this.getQueueConfig('scheduler', name);
+  },
+
   /**
    * Get monitoring queue configuration
    * @param {string} queueName - Queue name (e.g., 'monitoring.workflow')
@@ -1428,11 +1678,12 @@ module.exports = {
    * Every business template routes here (`x-dead-letter-exchange`), and so does
    * `getDeadLetterRoute()` for a business queue. `@onlineapps/conn-infra-mq` binds
    * `<service>.dlq` to it and had to read the name back out of a queue's arguments
-   * for want of an export.
+   * for want of an export. Composed from the `deadLetter` entry, which also declares
+   * the exchange's type and durability — one declaration, not a name beside it.
    *
    * @returns {string}
    */
   deadLetterExchange() {
-    return DEAD_LETTER_EXCHANGE;
+    return this.queueName('deadLetter', DEAD_LETTER_EXCHANGE);
   }
 };

package/src/config/recurrencesSchema.js

@@ -0,0 +1,121 @@
+'use strict';
+
+/**
+ * recurrencesSchema.js
+ *
+ * JSON Schema used by Ajv (in `src/scheduler-request.js`) to validate the recurrences a service
+ * declares about itself.
+ *
+ * WHY THE SHAPE LIVES HERE. `docs/architecture/scheduler.md` §7 has the wrapper register a
+ * service's recurrences at boot — "idempotent, so every boot re-asserts the declared state" —
+ * and the service answers with them through ONE hook, platform ones as a constant list and
+ * tenant ones derived from its own data (confirmation `scheduler` 011). The shape of a record
+ * is the library's; where the record comes from is not. One owner of the shape means every service's file is the
+ * same file, and the wrapper reading it never has to guess.
+ *
+ * WHAT THE FILE DOES NOT CARRY, and why that is a rule rather than an omission:
+ *
+ *   - **`tenant_id` and `workspace_id`.** They travel beside the record, not in it: the
+ *     builder takes them as `tenantId` and `workspaceId`, and the caller supplies them with
+ *     every recurrence — the service knows them from its own data, and nothing reads them from
+ *     the environment or defaults them.
+ *     @see api/docs/governance/confirmations/scheduler.md 002, 010
+ *   - **`requested_by`.** It is the service that declared the record; the caller passes the name
+ *     it already knows, so a record cannot disagree with the service that answered it.
+ *
+ * `additionalProperties: false` at both levels, deliberately: the consumer's own contract
+ * (`api/infra/api_scheduler/contracts/scheduler.request.schema.json`) closes its keys the same
+ * way, so a key accepted here and refused there would turn a boot into a dead-lettered
+ * request nobody reads.
+ *
+ * @see ../scheduler-request.js — the shape check, the builders and the send
+ * @see api/docs/architecture/scheduler.md §4, §7
+ */
+
+/**
+ * Five whitespace-separated fields — the same expression the scheduler's contract takes
+ * (`recurrence.cron`, pattern `^\S+( \S+){4}$`). Whether those fields describe a reachable
+ * instant is the tick engine's answer, not this file's.
+ */
+const CRON_PATTERN = '^\\S+( \\S+){4}$';
+
+/**
+ * The id of one schedule: it becomes `idempotency_key`, so it is a name, not a sentence.
+ *
+ * As WIDE as the consumer's own rule and no wider: the scheduler takes any string of 1–255
+ * characters for that key, so this file refuses only what would make the key a sentence —
+ * whitespace. The narrower spelling this schema first carried (lower-case letters and dashes)
+ * was the library being stricter than the contract for no reason, and it refused the very
+ * convention the first caller uses: `<source_uuid>:<cookbook_ref>` (BIZ-ingest, 2026-09-23).
+ */
+const ID_PATTERN = '^\\S+$';
+
+const recurrencesSchema = {
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  $id: 'https://onlineapps.cz/schemas/mq-client-core/recurrences.v1.schema.json',
+  title: 'Service recurrence declaration',
+  description:
+    'What a service declares about its own recurring runs. The wrapper re-asserts every record '
+    + 'at boot as a `scheduler.request` of kind `recurring`.',
+  type: 'object',
+  additionalProperties: false,
+  required: ['recurrences'],
+  properties: {
+    recurrences: {
+      description:
+        'Every recurrence this service owns. An empty list is a valid declaration of nothing, '
+        + 'and a service with no recurrences may answer one.',
+      type: 'array',
+      items: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['id', 'cookbook_ref', 'cron', 'timezone'],
+        properties: {
+          id: {
+            description:
+              'Stable id of THIS schedule; it travels as `idempotency_key`, so re-registration '
+              + 'upserts instead of creating a second schedule.',
+            type: 'string',
+            minLength: 1,
+            maxLength: 255,
+            pattern: ID_PATTERN
+          },
+          cookbook_ref: {
+            description:
+              'Id of the cookbook to run. Its `triggers` must name this service and the kind '
+              + '`recurring`, or the scheduler refuses the request (confirmation scheduler 004).',
+            type: 'string',
+            minLength: 1,
+            maxLength: 255
+          },
+          cron: {
+            description: 'Cron expression, five fields.',
+            type: 'string',
+            pattern: CRON_PATTERN
+          },
+          timezone: {
+            description: 'IANA zone, explicit. No implicit zone exists (scheduler.md §4).',
+            type: 'string',
+            minLength: 1,
+            maxLength: 64
+          },
+          input: {
+            description:
+              'Input handed to the cookbook unchanged. Present only where the run needs one — '
+              + 'a scheduled import that writes says so here, while the same cookbook run by hand '
+              + 'can be given a different input.',
+            type: 'object'
+          },
+          catch_up: {
+            description:
+              'Whether a missed window runs once when the scheduler comes back. Absent means '
+              + 'false, and the scheduler materialises that default — this file does not.',
+            type: 'boolean'
+          }
+        }
+      }
+    }
+  }
+};
+
+module.exports = { recurrencesSchema, CRON_PATTERN, ID_PATTERN };

package/src/index.js

@@ -36,6 +36,19 @@ const {
   publishToMonitoringServices,
   isQueueUnavailableError,
 } = require('./monitoring-publish');
+const {
+  buildWorkflowInitiatedEvent,
+  publishWorkflowInitiated,
+} = require('./monitoring-initiated');
+const {
+  schedulerRequestQueue,
+  validateRecurrences,
+  buildRecurringRequest,
+  buildEventRequest,
+  buildCancelRequest,
+  publishSchedulerRequest,
+  createSchedulerPublisher,
+} = require('./scheduler-request');
 const queueConfig = require('./config/queueConfig');
 const deliveryPolicy = require('./config/deliveryPolicy');
 const { redactUrl, UNPARSEABLE_PLACEHOLDER } = require('@onlineapps/logger-contract');
@@ -84,6 +97,28 @@ module.exports.monitoring = {
   publishToMonitoringWorkflow,
   publishToMonitoringServices,
   isQueueUnavailableError,
+  // d.819 - the one builder of `workflow_initiated`, beside the transport half it uses
+  // (`docs/governance/confirmations/scheduler.md` 009). The gateway and the scheduler each
+  // built that event in their own words; two rails over one event is a defect by default.
+  buildWorkflowInitiatedEvent,
+  publishWorkflowInitiated,
+};
+/**
+ * The recurrences a service declares, and how one of them is registered (d.833).
+ *
+ * `docs/architecture/scheduler.md` §7 gives this library the shape of one declared recurrence
+ * and the wrapper the job of re-asserting what the service answers at every boot (one hook,
+ * confirmation `scheduler` 011). The queue name travels with them, so no caller composes
+ * `scheduler.request` itself.
+ */
+module.exports.scheduler = {
+  requestQueue: schedulerRequestQueue,
+  validateRecurrences,
+  buildRecurringRequest,
+  buildEventRequest,
+  buildCancelRequest,
+  publishSchedulerRequest,
+  createSchedulerPublisher,
 };
 /** The only public way to reach the central queue classification; `src/config/queueConfig` is an internal path, not a contract. */
 module.exports.queueConfig = queueConfig;
@@ -109,6 +144,18 @@ module.exports.topology = Object.freeze({
   monitoringInfrastructureHealthEventsQueue: queueConfig.queueName('monitoring', 'infrastructure.health.events'),
   /** The delivery endpoint's queue bound to that exchange, for WS push. */
   deliveryHealthEventsQueue: queueConfig.queueName('deliveryEvents', 'health.events'),
+  /**
+   * Topic exchange: the monitoring consumer's resource-changed watcher publishes here,
+   * with a routing key of the shape `resource.changed.<resource_type>`.
+   *
+   * Declared in `queueConfig` since d.619. Until then the name was a module constant on
+   * the publishing side and a required env key on the binding side
+   * (`MONITORING_RESOURCE_EXCHANGE`) — the third side of this wire with no owner, while
+   * the queue bound to it had one here since d.270.
+   *
+   * @see api/infra/api_monitoring/src/consumer/watchers/resourceChangedPublisher.js
+   */
+  monitoringResourceExchange: queueConfig.queueName('monitoring', 'resource'),
   /**
    * The delivery endpoint's queue for resource-changed events, bound to the
    * `monitoring.resource` exchange by the routing pattern `resource.changed.#`.