@hyperfrontend/features 0.1.0 → 0.2.0

package/hostee/index.esm.js

@@ -2,13 +2,14 @@ import { createBroker } from '../_dependencies/@hyperfrontend/nexus/index.esm.js
 import { isArray } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.esm.js';
 import { createError } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.esm.js';
 import '../_dependencies/@hyperfrontend/json-utils/index.esm.js';
-import { freeze } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.esm.js';
-import { createPromise } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/promise/index.esm.js';
-import { clearInterval, setInterval } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/timers/index.esm.js';
+import { freeze, values } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.esm.js';
+import { createPromise, promiseResolve, promiseReject } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/promise/index.esm.js';
+import { clearTimeout, setTimeout, clearInterval, setInterval } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/timers/index.esm.js';
 import { onElementResize } from '../_dependencies/@hyperfrontend/ui-utils/element/index.esm.js';
 import { addStylesheet } from '../_dependencies/@hyperfrontend/ui-utils/style/index.esm.js';
-import { ControlType, withControlContract } from '../_shared/shared/control/index.esm.js';
+import { ControlType, isControlType, withControlContract } from '../_shared/shared/control/index.esm.js';
 import { createEventEmitter } from '../_shared/shared/event-emitter/index.esm.js';
+import { createRequestPeer } from '../_shared/shared/request/index.esm.js';
 
 // note: Runtime validation shared by the host/hostee factories and the config loader.
 /**
@@ -43,6 +44,31 @@ function collectActionListIssues(actions, field, issues) {
         if (typeof action['type'] !== 'string' || action['type'].length === 0) {
             issues.push(`"${field}[${index}]" must have a non-empty string "type".`);
         }
+        if (action['respondsWith'] !== undefined && (typeof action['respondsWith'] !== 'string' || action['respondsWith'].length === 0)) {
+            issues.push(`"${field}[${index}]" has a "respondsWith" that must be a non-empty string.`);
+        }
+    });
+}
+/**
+ * Collects every `respondsWith` reference that does not name an action in the other direction.
+ *
+ * A request emitted by one side is answered by an action the same side accepts (and
+ * vice versa), so each `respondsWith` must resolve across the contract's directions.
+ *
+ * @param actions - The already well-formed action list to check.
+ * @param field - The field name of `actions`, used to locate problems in messages.
+ * @param other - The action list of the opposite direction.
+ * @param otherField - The field name of `other`, used in messages.
+ * @param issues - The running list of human-readable problems, appended to in place.
+ */
+function collectRespondsWithIssues(actions, field, other, otherField, issues) {
+    actions.forEach((action, index) => {
+        if (action.respondsWith === undefined) {
+            return;
+        }
+        if (!other.some((candidate) => candidate.type === action.respondsWith)) {
+            issues.push(`"${field}[${index}]" responds with "${action.respondsWith}", but "${otherField}" has no action of that type.`);
+        }
     });
 }
 /**
@@ -68,7 +94,7 @@ function describeType(value) {
  *
  * @param contract - The candidate contract, typically parsed from disk.
  * @returns The validated contract, typed.
- * @throws {Error} When the value is not an object, or any action is malformed.
+ * @throws {Error} When the value is not an object, any action is malformed, or a `respondsWith` names no action in the other direction.
  *
  * @example Validating a parsed contract file
  * ```typescript
@@ -83,6 +109,12 @@ function validateContract(contract) {
     const issues = [];
     collectActionListIssues(contract['emitted'], 'emitted', issues);
     collectActionListIssues(contract['accepted'], 'accepted', issues);
+    if (issues.length === 0) {
+        const emitted = contract['emitted'];
+        const accepted = contract['accepted'];
+        collectRespondsWithIssues(emitted, 'emitted', accepted, 'accepted', issues);
+        collectRespondsWithIssues(accepted, 'accepted', emitted, 'emitted', issues);
+    }
     if (issues.length > 0) {
         throw createError(`Invalid contract:\n${issues.map((issue) => `  - ${issue}`).join('\n')}`);
     }
@@ -205,6 +237,7 @@ function resolveHostWindow(win) {
 function createFeatureHandle(broker, hostWindow, emitter) {
     let channel = null;
     let opened = false;
+    const requests = createRequestPeer('feature', (type, data) => channel?.send(type, data));
     if (hostWindow) {
         const activeChannel = broker.addChannel('host', hostWindow);
         channel = activeChannel;
@@ -221,14 +254,26 @@ function createFeatureHandle(broker, hostWindow, emitter) {
             emitter.emit('close');
             heartbeat.stop();
             announcer.stop();
+            requests.rejectAll('The host channel closed before the host responded.');
         });
         activeChannel.on('deny', (data) => emitter.emit('error', data));
         activeChannel.on('invalid', (data) => emitter.emit('error', data));
-        activeChannel.onMessage((message) => emitter.emit(message.type, message.data));
+        activeChannel.onMessage((message) => {
+            // why: Control traffic (heartbeat/size echoes, request/response envelopes) is SDK-internal; forwarding it would leak reserved __hf: types into consumer handlers.
+            if (isControlType(message.type)) {
+                requests.dispatch(message.type, message.data);
+                return;
+            }
+            emitter.emit(message.type, message.data);
+        });
         activeChannel.connect();
     }
     return freeze({
         send: (type, data) => channel?.send(type, data),
+        request: (type, data, options) => channel
+            ? requests.request(type, data, options)
+            : promiseReject(createError(`Cannot send request '${type}': the feature is not connected to a host.`)),
+        handle: requests.handle,
         on: emitter.on,
         ready: () => createPromise((resolve) => {
             if (opened) {

package/hostee/lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../../../../libs/features/src/hostee/lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAA2B,MAAM,sBAAsB,CAAA;AACjF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAQ5C;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQ5D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,EAAE,YAAY,GAAG,aAAa,CAwCzH"}
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../../../../libs/features/src/hostee/lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAA2B,MAAM,sBAAsB,CAAA;AACjF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAE3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAW5C;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQ5D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,EAAE,YAAY,GAAG,aAAa,CAsDzH"}

package/hostee/types.d.ts

@@ -1,4 +1,5 @@
 import type { EventHandler } from '../shared/event-emitter';
+import type { RequestHandler, RequestOptions } from '../shared/request';
 /**
  * Public handle returned by the hostee-side feature factory.
  */
@@ -10,6 +11,45 @@ export interface FeatureHandle {
      * @param data - Optional payload for the action.
      */
     send(type: string, data?: unknown): void;
+    /**
+     * Sends a request to the host and resolves with its response.
+     *
+     * The host answers through a handler it registered with its own
+     * `handle(type, handler)`. The promise rejects when the host's handler
+     * throws, when the host has no handler for the type, when no response
+     * arrives within the timeout (30 seconds by default), when the feature is
+     * not connected to a host, or when the host channel closes while the
+     * request is pending.
+     *
+     * @param type - Request action type, drawn from the feature contract.
+     * @param data - Optional payload for the request.
+     * @param options - Per-request settings such as `timeoutMs`.
+     * @returns A promise settling with the host's response payload.
+     *
+     * @example Asking the host for its settings
+     * ```typescript
+     * const settings = await feature.request('getSettings', undefined, { timeoutMs: 5000 })
+     * ```
+     */
+    request(type: string, data?: unknown, options?: RequestOptions): Promise<unknown>;
+    /**
+     * Registers the handler that answers host requests of a given type.
+     *
+     * One handler per type: registering a second handler for a type that already
+     * has one throws. The handler may return the response value directly or a
+     * promise of it; a thrown error or rejected promise reaches the host as a
+     * failed response carrying the error's message.
+     *
+     * @param type - Request type to answer.
+     * @param handler - Receives the request payload and returns the response.
+     * @returns A function that unregisters this handler.
+     *
+     * @example Answering the host's request for the feature's state
+     * ```typescript
+     * feature.handle('getTime', (data) => formatTime(data))
+     * ```
+     */
+    handle(type: string, handler: RequestHandler): () => void;
     /**
      * Subscribes to host messages or lifecycle events (`open`, `close`, `error`).
      *

package/hostee/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../libs/features/src/hostee/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAE3D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;IACxC;;;;;;OAMG;IACH,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,MAAM,IAAI,CAAA;IACpD;;;;OAIG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB;;OAEG;IACH,KAAK,IAAI,IAAI,CAAA;CACd"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../libs/features/src/hostee/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvE;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;IACxC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IACjF;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM,IAAI,CAAA;IACzD;;;;;;OAMG;IACH,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,MAAM,IAAI,CAAA;IACpD;;;;OAIG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACtB;;OAEG;IACH,KAAK,IAAI,IAAI,CAAA;CACd"}

package/index.cjs.js

@@ -39,6 +39,31 @@ function collectActionListIssues(actions, field, issues) {
         if (typeof action['type'] !== 'string' || action['type'].length === 0) {
             issues.push(`"${field}[${index}]" must have a non-empty string "type".`);
         }
+        if (action['respondsWith'] !== undefined && (typeof action['respondsWith'] !== 'string' || action['respondsWith'].length === 0)) {
+            issues.push(`"${field}[${index}]" has a "respondsWith" that must be a non-empty string.`);
+        }
+    });
+}
+/**
+ * Collects every `respondsWith` reference that does not name an action in the other direction.
+ *
+ * A request emitted by one side is answered by an action the same side accepts (and
+ * vice versa), so each `respondsWith` must resolve across the contract's directions.
+ *
+ * @param actions - The already well-formed action list to check.
+ * @param field - The field name of `actions`, used to locate problems in messages.
+ * @param other - The action list of the opposite direction.
+ * @param otherField - The field name of `other`, used in messages.
+ * @param issues - The running list of human-readable problems, appended to in place.
+ */
+function collectRespondsWithIssues(actions, field, other, otherField, issues) {
+    actions.forEach((action, index) => {
+        if (action.respondsWith === undefined) {
+            return;
+        }
+        if (!other.some((candidate) => candidate.type === action.respondsWith)) {
+            issues.push(`"${field}[${index}]" responds with "${action.respondsWith}", but "${otherField}" has no action of that type.`);
+        }
     });
 }
 /**
@@ -64,7 +89,7 @@ function describeType(value) {
  *
  * @param contract - The candidate contract, typically parsed from disk.
  * @returns The validated contract, typed.
- * @throws {Error} When the value is not an object, or any action is malformed.
+ * @throws {Error} When the value is not an object, any action is malformed, or a `respondsWith` names no action in the other direction.
  *
  * @example Validating a parsed contract file
  * ```typescript
@@ -79,6 +104,12 @@ function validateContract(contract) {
     const issues = [];
     collectActionListIssues(contract['emitted'], 'emitted', issues);
     collectActionListIssues(contract['accepted'], 'accepted', issues);
+    if (issues.length === 0) {
+        const emitted = contract['emitted'];
+        const accepted = contract['accepted'];
+        collectRespondsWithIssues(emitted, 'emitted', accepted, 'accepted', issues);
+        collectRespondsWithIssues(accepted, 'accepted', emitted, 'emitted', issues);
+    }
     if (issues.length > 0) {
         throw index_cjs_js.createError(`Invalid contract:\n${issues.map((issue) => `  - ${issue}`).join('\n')}`);
     }

package/index.d.ts

@@ -1,5 +1,20 @@
 import { ValidationResult } from './_dependencies/@hyperfrontend/json-utils/index.js';
 
+/**
+ * Per-request settings accepted by `request`.
+ */
+interface RequestOptions {
+    /** Milliseconds to wait for the response before rejecting; defaults to 30000. */
+    timeoutMs?: number;
+}
+/**
+ * Answers one request type; may return the response value directly or a promise of it.
+ *
+ * @param data - The request payload sent by the other side.
+ * @returns The response value, or a promise that resolves to it.
+ */
+type RequestHandler = (data: unknown) => unknown;
+
 /**
  * Supported ways a host can surface an embedded feature.
  *
@@ -65,6 +80,8 @@ interface ActionDescription {
     description?: string;
     /** Optional JSON-schema-like shape describing the action payload. */
     schema?: object;
+    /** When this action is used as a request, the type of the action in the other direction that answers it. */
+    respondsWith?: string;
 }
 /**
  * The set of actions a feature emits to, and accepts from, its counterpart.
@@ -78,6 +95,66 @@ interface FeatureContract {
     /** Actions this side handles from the other side. */
     accepted: ActionDescription[];
 }
+/**
+ * Context handed to an {@link ExperiencePlugin} around a feature's mount lifecycle.
+ */
+interface ExperiencePluginContext {
+    /**
+     * The in-document root the display mode mounted: the iframe for `embedded`,
+     * the dialog container for `dialog`, and `null` for `popup` and
+     * `standalone`, which open a separate window with no in-document element.
+     */
+    element: HTMLElement | null;
+    /** The display mode the feature was surfaced in. */
+    displayMode: DisplayMode;
+}
+/**
+ * Opt-in extension that decorates a feature's mount lifecycle (e.g. transitions, animations).
+ *
+ * Register plugins through {@link ShellOptions.plugins}. After each successful
+ * mount the shell calls `onMount` on every plugin in registration order; before
+ * each unmount it calls `onUnmount` one plugin at a time in reverse
+ * registration order, awaiting any returned promise, then runs the teardowns
+ * returned by `onMount` (also in reverse registration order) and finally
+ * removes the feature. The SDK ships no built-in plugins.
+ *
+ * @example Registering a fade-out plugin on a shell
+ * ```typescript
+ * const shell = createShell({
+ *   container: '#shell',
+ *   plugins: [
+ *     {
+ *       name: 'fade',
+ *       onUnmount: ({ element }) => (element ? animateFadeOut(element) : undefined),
+ *     },
+ *   ],
+ * })
+ * ```
+ */
+interface ExperiencePlugin {
+    /** Unique plugin name, surfaced in debug logs. */
+    name: string;
+    /**
+     * Runs after the feature mounts; may animate it in and return a teardown.
+     *
+     * A thrown error surfaces as an `error` event on the shell and does not
+     * stop the remaining plugins from mounting.
+     *
+     * @param context - The mounted element and its display mode.
+     * @returns An optional teardown invoked on unmount, after every `onUnmount` has settled.
+     */
+    onMount?(context: ExperiencePluginContext): void | (() => void);
+    /**
+     * Runs before the feature unmounts; may return a promise to defer teardown until an exit animation finishes.
+     *
+     * A rejected promise (or thrown error) surfaces as an `error` event on the
+     * shell and teardown continues with the remaining plugins.
+     *
+     * @param context - The mounted element and its display mode.
+     * @returns Optionally a promise the shell awaits before tearing down.
+     */
+    onUnmount?(context: ExperiencePluginContext): void | Promise<void>;
+}
 /**
  * Options accepted by the host-side {@link FeatureContract} consumer when
  * creating or opening a shell.
@@ -87,7 +164,12 @@ interface ShellOptions {
     container: string | HTMLElement;
     /** Stable identifier for the feature; seeds the broker name surfaced in debug logs. */
     name?: string;
-    /** Contract describing the feature's actions; replaces the generic default when provided. */
+    /**
+     * The feature's contract exactly as the feature authored it (`emitted` = what
+     * the feature sends, `accepted` = what the feature handles). The shell
+     * derives the host-side orientation itself — hand it the feature's contract,
+     * never a pre-swapped copy. Replaces the generic default when provided.
+     */
     contract?: FeatureContract;
     /** How the feature should be surfaced; defaults to {@link DisplayMode.Embedded}. */
     displayMode?: DisplayMode;
@@ -109,6 +191,8 @@ interface ShellOptions {
     protocol?: SecurityProtocol;
     /** Pre-shared key used by the `v2` protocol. */
     sharedKey?: string;
+    /** Experience plugins wrapped around each mount/unmount; `onMount` runs in registration order, `onUnmount` in reverse. */
+    plugins?: readonly ExperiencePlugin[];
 }
 /**
  * Options accepted by the hostee-side feature factory.
@@ -163,6 +247,8 @@ interface ResolvedFeatureConfig extends FeatureConfig {
     url: string;
     /** Default display options baked into the connector as the feature's defaults. */
     display?: DisplayDefaults;
+    /** Security envelope the build resolved; baked into the generated connector as its default. */
+    protocol?: SecurityProtocol;
 }
 /**
  * A single feature app entry served by the dev server.
@@ -230,7 +316,7 @@ declare const defineDevConfig: (config: DevConfig) => DevConfig;
  *
  * @param contract - The candidate contract, typically parsed from disk.
  * @returns The validated contract, typed.
- * @throws {Error} When the value is not an object, or any action is malformed.
+ * @throws {Error} When the value is not an object, any action is malformed, or a `respondsWith` names no action in the other direction.
  *
  * @example Validating a parsed contract file
  * ```typescript
@@ -279,4 +365,4 @@ declare const sdkInfo: {
 };
 
 export { DisplayMode, defineConfig, defineDevConfig, sdkInfo, validateContract, validateFeatureConfig, validatePayload };
-export type { ActionDescription, DevConfig, DisplayDefaults, EmbedSizing, FeatureConfig, FeatureContract, FeatureOptions, ResolvedFeatureConfig, SecurityProtocol, ShellOptions, UnresponsiveInfo, UnresponsivePolicy };
+export type { ActionDescription, DevConfig, DisplayDefaults, EmbedSizing, ExperiencePlugin, ExperiencePluginContext, FeatureConfig, FeatureContract, FeatureOptions, RequestHandler, RequestOptions, ResolvedFeatureConfig, SecurityProtocol, ShellOptions, UnresponsiveInfo, UnresponsivePolicy };

package/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../libs/features/src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,YAAY,EACV,iBAAiB,EACjB,SAAS,EACT,eAAe,EACf,WAAW,EACX,aAAa,EACb,eAAe,EACf,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAC5F,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAC3C,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../libs/features/src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACtE,YAAY,EACV,iBAAiB,EACjB,SAAS,EACT,eAAe,EACf,WAAW,EACX,gBAAgB,EAChB,uBAAuB,EACvB,aAAa,EACb,eAAe,EACf,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAC5F,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAC3C,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA"}

package/index.esm.js

@@ -37,6 +37,31 @@ function collectActionListIssues(actions, field, issues) {
         if (typeof action['type'] !== 'string' || action['type'].length === 0) {
             issues.push(`"${field}[${index}]" must have a non-empty string "type".`);
         }
+        if (action['respondsWith'] !== undefined && (typeof action['respondsWith'] !== 'string' || action['respondsWith'].length === 0)) {
+            issues.push(`"${field}[${index}]" has a "respondsWith" that must be a non-empty string.`);
+        }
+    });
+}
+/**
+ * Collects every `respondsWith` reference that does not name an action in the other direction.
+ *
+ * A request emitted by one side is answered by an action the same side accepts (and
+ * vice versa), so each `respondsWith` must resolve across the contract's directions.
+ *
+ * @param actions - The already well-formed action list to check.
+ * @param field - The field name of `actions`, used to locate problems in messages.
+ * @param other - The action list of the opposite direction.
+ * @param otherField - The field name of `other`, used in messages.
+ * @param issues - The running list of human-readable problems, appended to in place.
+ */
+function collectRespondsWithIssues(actions, field, other, otherField, issues) {
+    actions.forEach((action, index) => {
+        if (action.respondsWith === undefined) {
+            return;
+        }
+        if (!other.some((candidate) => candidate.type === action.respondsWith)) {
+            issues.push(`"${field}[${index}]" responds with "${action.respondsWith}", but "${otherField}" has no action of that type.`);
+        }
     });
 }
 /**
@@ -62,7 +87,7 @@ function describeType(value) {
  *
  * @param contract - The candidate contract, typically parsed from disk.
  * @returns The validated contract, typed.
- * @throws {Error} When the value is not an object, or any action is malformed.
+ * @throws {Error} When the value is not an object, any action is malformed, or a `respondsWith` names no action in the other direction.
  *
  * @example Validating a parsed contract file
  * ```typescript
@@ -77,6 +102,12 @@ function validateContract(contract) {
     const issues = [];
     collectActionListIssues(contract['emitted'], 'emitted', issues);
     collectActionListIssues(contract['accepted'], 'accepted', issues);
+    if (issues.length === 0) {
+        const emitted = contract['emitted'];
+        const accepted = contract['accepted'];
+        collectRespondsWithIssues(emitted, 'emitted', accepted, 'accepted', issues);
+        collectRespondsWithIssues(accepted, 'accepted', emitted, 'emitted', issues);
+    }
     if (issues.length > 0) {
         throw createError(`Invalid contract:\n${issues.map((issue) => `  - ${issue}`).join('\n')}`);
     }