dispatch: typed handlers, respond/defer/error, automatic ErrorResponse, watchdog

src/dispatcher.ts routes a directive to capability.on(name | "*"), device.onDirective() or
device.onReportState(), with the payload checked by the descriptor of the interface. The
DirectiveContext answers with respond/report/defer/error; respond() and report() start from
device.state(). A handler or 1.x listener that throws or rejects is answered with INTERNAL_ERROR
(an AlexaError with itself) and reported through "error", never as an unhandled rejection.
Undeclared interface, unknown directive, AdjustMode on an unordered mode and a missing handler
get INVALID_DIRECTIVE, a bad payload INVALID_VALUE; a device with an "Event" or "ReportState"
listener keeps the answer to itself. Every answer passes the dispatcher: the first one per
correlationToken is published, a second is refused. No answer within answerWithinMs (6500,
0 = off, unref'd timer) sends INTERNAL_ERROR and emits "unanswered". A messageId that arrived
in the last 60 s is dropped. New: "unknownEndpoint", options answerUnknownEndpoints, publisher,
timers, and bridge.receive() to run a bridge without a broker. 168 tests pass (18 new).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

src/device/Capability.ts

@@ -1,4 +1,7 @@
+import type { DirectiveHandler } from "../dispatcher.js";
 import { s } from "../registry/schema.js";
+import type { Infer } from "../registry/schema.js";
+import { DeclarationError } from "../registry/types.js";
 import type {
   Declared, Directives, InterfaceDescriptor, Label, Properties, Semantics,
 } from "../registry/types.js";
@@ -66,6 +69,7 @@ export class Capability<P extends Properties = Properties, D extends Directives
   options: O;
   /** What the bridge logs about the declaration, once, when it answers a discovery. */
   readonly notes: string[] = [];
+  private readonly handlers = new Map<string, DirectiveHandler<any>>();
 
   constructor(readonly descriptor: InterfaceDescriptor<P, D, O, boolean>, declared: CommonOptions & { options: O }) {
     this.instance = declared.instance ?? "";
@@ -80,6 +84,33 @@ export class Capability<P extends Properties = Properties, D extends Directives
     return this.descriptor.namespace;
   }
 
+  /**
+   * What the device does on a directive of the interface:
+   *
+   *   lift.on("SetRangeValue", async (ctx) => { await motor.moveTo(ctx.payload.rangeValue); return ctx.respond(); });
+   *
+   * "*" is the handler of every directive that has none of its own. A handler that throws answers the directive
+   * with an ErrorResponse: the AlexaError it threw, INTERNAL_ERROR for anything else. Throws a DeclarationError
+   * for a name that is not a directive of the interface.
+   */
+  on<K extends keyof D & string>(name: K, handler: DirectiveHandler<Infer<D[K]["payload"]>>): this;
+  on(name: "*", handler: DirectiveHandler): this;
+  on(name: string, handler: DirectiveHandler<any>): this {
+    const names = Object.keys(this.descriptor.directives);
+    // An interface the library only names (tier 3) describes no directive: any name is taken
+    if (name !== "*" && this.descriptor.tier !== 3 && !names.includes(name)) {
+      throw new DeclarationError(this, `${name} is not a directive of the interface, which has ${names.join(", ") || "none"}`);
+    }
+    if (typeof handler !== "function") throw new DeclarationError(this, `the handler of ${name} is a function`);
+    this.handlers.set(name, handler);
+    return this;
+  }
+
+  /** The handler on(name) registered, or the one of "*". */
+  handlerFor(name: string): DirectiveHandler<any> | undefined {
+    return this.handlers.get(name) ?? this.handlers.get("*");
+  }
+
   /** Mappings of "open", "close", "raise", "lower" and of states, when the declaration has any. */
   get semantics(): Semantics | undefined {
     const { semantics } = this.options as { semantics?: Semantics };