@readymadeit/mcp 0.0.0-stage → 0.1.0

package/bundle/hkp-node/src/services/sql-dump.ts

@@ -0,0 +1,192 @@
+/**
+ * SQL text that moves a database between runtimes: writing a dump of one, and
+ * deciding whether a dump may be run against another.
+ *
+ * Kept identical in hkp-frontend (src/runtime/browser/services/sql-dump.ts) and
+ * hkp-node (src/services/sql-dump.ts): a dump written by either runtime's `sql`
+ * is read by the other's, so the two must agree on the format. Change both.
+ *
+ * The format is an ordinary SQLite dump — what `sqlite3 file .dump` writes, and
+ * what `sqlite3 file < dump.sql` reads — with one difference: every CREATE
+ * says IF NOT EXISTS, so a dump loads into a database whose board has already
+ * created its (empty) tables from its schema.
+ */
+
+/** What a dump needs of a database: the rows of a statement. */
+export type DumpSource = {
+  query(sql: string): Record<string, unknown>[];
+};
+
+/** A name as an SQL identifier: `we"ird` becomes `"we""ird"`. */
+export function quoteIdentifier(name: string): string {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+
+/** Text as an SQL string literal: `it's` becomes `'it''s'`. */
+function quoteText(text: string): string {
+  return `'${text.replace(/'/g, "''")}'`;
+}
+
+/**
+ * A stored CREATE statement that tolerates what it creates already existing.
+ *
+ * SQLite keeps each CREATE as it was written, minus any IF NOT EXISTS, with
+ * its leading keywords normalised — so the prefix is always one of these.
+ */
+function ifNotExists(sql: string): string {
+  return sql.replace(
+    /^CREATE (TABLE|UNIQUE INDEX|INDEX|TRIGGER|VIEW) /,
+    (prefix) => `${prefix}IF NOT EXISTS `,
+  );
+}
+
+/**
+ * The whole database as SQL: its tables with their rows, then its indexes,
+ * triggers and views, in one transaction — so loading it either brings in
+ * everything or, on a conflict, nothing.
+ *
+ * Rows are written by SQLite itself (`quote()`), so every value comes back
+ * exactly: text with its quotes and newlines, blobs as X'…', reals to the last
+ * digit. Columns are named in each INSERT, which is what lets a table with
+ * generated columns load.
+ *
+ * Throws on a virtual table: its contents live in tables of the module's
+ * own, and a dump that recreated both would load the rows twice.
+ */
+export function dumpDatabase(db: DumpSource): string {
+  const lines = ["PRAGMA foreign_keys=OFF;", "BEGIN TRANSACTION;"];
+
+  const tables = db.query(
+    "SELECT name, sql FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY rowid",
+  ) as { name: string; sql: string }[];
+
+  for (const { name, sql } of tables) {
+    if (/^CREATE VIRTUAL TABLE/i.test(sql)) {
+      throw new Error(
+        `'${name}' is a virtual table, which a dump cannot carry`,
+      );
+    }
+    lines.push(`${ifNotExists(sql)};`);
+    lines.push(...insertsFor(db, name));
+  }
+
+  const sequence = db.query(
+    "SELECT 1 FROM sqlite_schema WHERE type = 'table' AND name = 'sqlite_sequence'",
+  );
+  if (sequence.length > 0) {
+    // Where AUTOINCREMENT counts from, which a table's rows do not say: a row
+    // deleted before the dump still used its id up.
+    lines.push("DELETE FROM sqlite_sequence;");
+    lines.push(...insertsFor(db, "sqlite_sequence"));
+  }
+
+  const rest = db.query(
+    "SELECT sql FROM sqlite_schema WHERE type IN ('index', 'trigger', 'view') AND sql IS NOT NULL AND name NOT LIKE 'sqlite_%' ORDER BY rowid",
+  ) as { sql: string }[];
+  for (const { sql } of rest) {
+    lines.push(`${ifNotExists(sql)};`);
+  }
+
+  lines.push("COMMIT;");
+  return `${lines.join("\n")}\n`;
+}
+
+/** One INSERT per row of a table, as SQLite quotes its values. */
+function insertsFor(db: DumpSource, table: string): string[] {
+  const columns = (
+    db.query(`SELECT name FROM pragma_table_info(${quoteText(table)})`) as {
+      name: string;
+    }[]
+  ).map((column) => column.name);
+  if (columns.length === 0) {
+    return [];
+  }
+  const head = `INSERT INTO ${quoteIdentifier(table)}(${columns
+    .map(quoteIdentifier)
+    .join(",")}) VALUES(`;
+  const values = columns
+    .map((column) => `quote(${quoteIdentifier(column)})`)
+    .join(" || ',' || ");
+  const rows = db.query(
+    `SELECT ${quoteText(head)} || ${values} || ');' AS line FROM ${quoteIdentifier(table)}`,
+  ) as { line: string }[];
+  return rows.map((row) => row.line);
+}
+
+/**
+ * The statement with its string literals, quoted identifiers and comments
+ * blanked out, so what remains is what SQLite reads as code.
+ *
+ * One pass, left to right, because the order decides what is what: a quote
+ * inside a comment opens nothing, and `--` inside a string comments nothing
+ * out. Blanking each kind separately gets that wrong — `-- don't` followed by
+ * a statement and a later quote would blank the statement as if it were text.
+ */
+export function codeOf(sql: string): string {
+  let out = "";
+  let i = 0;
+  const skipTo = (end: string, from: number): number => {
+    const at = sql.indexOf(end, from);
+    return at === -1 ? sql.length : at + end.length;
+  };
+  while (i < sql.length) {
+    const c = sql[i];
+    const next = sql[i + 1];
+    if (c === "'" || c === '"' || c === "`") {
+      // Closed by the same character, which doubled stands for itself.
+      let j = i + 1;
+      while (j < sql.length) {
+        if (sql[j] === c) {
+          if (sql[j + 1] === c) {
+            j += 2;
+            continue;
+          }
+          break;
+        }
+        j += 1;
+      }
+      i = j + 1;
+      out += " ";
+    } else if (c === "[") {
+      i = skipTo("]", i + 1);
+      out += " ";
+    } else if (c === "-" && next === "-") {
+      i = skipTo("\n", i + 2);
+      out += " ";
+    } else if (c === "/" && next === "*") {
+      i = skipTo("*/", i + 2);
+      out += " ";
+    } else {
+      out += c;
+      i += 1;
+    }
+  }
+  return out;
+}
+
+/**
+ * Why SQL text may not be imported, or null when it may.
+ *
+ * An import runs text that arrived as data — on hkp-node possibly from a
+ * mounted endpoint nobody signed in to — so it is held to what a dump needs.
+ * A database is isolated by being its own file, and these are the statements
+ * that reach past that file: ATTACH opens any other file the process can
+ * read, VACUUM INTO writes one anywhere, load_extension runs native code, and
+ * a PRAGMA other than foreign_keys changes how the connection behaves for
+ * every statement after it.
+ */
+export function refuseImport(sql: string): string | null {
+  const code = codeOf(sql);
+  const reaching = code.match(/\b(ATTACH|DETACH|VACUUM|load_extension)\b/i);
+  if (reaching) {
+    return `an import may not use ${reaching[1].toUpperCase()}`;
+  }
+  for (const pragma of code.matchAll(
+    /\bPRAGMA\s+(?:[A-Za-z_]\w*\s*\.\s*)?([A-Za-z_]\w*)/gi,
+  )) {
+    if (pragma[1].toLowerCase() !== "foreign_keys") {
+      return `an import may not set PRAGMA ${pragma[1]}`;
+    }
+  }
+  return null;
+}

package/bundle/hkp-node/src/services/sql.ts

@@ -0,0 +1,429 @@
+/**
+ * Service Documentation
+ * Service ID: sql
+ * Service Name: SQL
+ * Runtime: hkp-node
+ * Modes: query | run | exec | databases | export | import
+ * Key Config: statement, schema, mode, database, format
+ * IO: in=JSON (the statement's named parameters) -> out=JSON
+ *     query     -> { rows, count }
+ *     run       -> { changes, lastInsertRowid }
+ *     exec      -> { executed: true }
+ *     databases -> { rows: [{ name, bytes }], count }   (in: ignored)
+ *     export    -> the database as SQL text, or with     (in: ignored)
+ *                  format "sqlite" as an SQLite file (bytes)
+ *     import    -> { executed: true }                   (in: SQL text)
+ *
+ * The generic half of the pair: it knows SQL and nothing else. Tables, columns
+ * and meaning all belong to the board, which is what makes it usable for a
+ * workflow this service has never heard of. A service that understands one
+ * domain — conversations, say — is a second service over the same module
+ * (`database.ts`), not a mode of this one.
+ *
+ * The tenant is the board's, and comes from the runtime's scope rather than
+ * from configuration: no board can reach another owner's tables by asking.
+ *
+ * Which file inside that tenant is the board's to say. `database` names it,
+ * and two services naming the same file share its tables — within one board,
+ * which is the ordinary case, or deliberately across boards, which is
+ * occasionally the point. Left empty the name is derived from the board's
+ * title, which is what every board did before the field existed: convenient,
+ * and the reason two boards that happen to share a title also share their
+ * tables. A board that means to be alone with its data says so.
+ *
+ * **Parameters come from the input, named by the statement.** A statement
+ * mentioning `$conversationId` is given the input's `conversationId`, and a
+ * board writes no parameter list at all. Values are always bound, never
+ * interpolated — a subject line containing a quote is a subject line, not a
+ * syntax error, and not an injection.
+ *
+ * **Who is calling is bound by the service, never by the input.** Five
+ * names are reserved — `$caller_email`, `$caller_name`, `$caller_sub`,
+ * `$caller_role` and `$actor_kind` — and
+ * are given the caller of the run in progress: whoever the server that began
+ * it verified. Each is `NULL` when the run has no caller or the caller has no
+ * such value, and an input field of the same name is ignored. Reserved here
+ * rather than stamped onto the input by a service placed in front, because a
+ * stamp can be walked around: a process call that enters the pipeline *at*
+ * this service never passes the one before it.
+ *
+ * **A database can leave as SQL and arrive as SQL.** `export` hands on the
+ * whole database as an SQLite dump and `import` runs one arriving as input —
+ * the same format the browser's `sql` writes and reads (`sql-dump.ts`), which
+ * is how tables built in a browser continue here. An import is text from
+ * outside, possibly from a mount nobody signed in to, so it is refused
+ * anything that reaches past the database's own file. `databases` lists the
+ * owner's named databases. With `format: "sqlite"`, `export` hands on the
+ * database file itself instead, for a person keeping their data rather than
+ * another runtime: any SQLite tool opens it.
+ *
+ * **What it hands onward is separate from what it did.** By default the result
+ * travels, which is what a service asked a question wants. `emit: "input"`
+ * passes the input through untouched instead, so several statements can act on
+ * one request in turn: each names its parameters out of the same object, and
+ * the last service in the chain still sees what the first was given. Without it
+ * a second statement would be handed the first one's row count and find none of
+ * the parameters it asked for. The result is still reported either way —
+ * what a service says about itself is not what it passes on.
+ */
+import {
+  Caller,
+  HostedService,
+  JsonRecord,
+  RuntimeHost,
+  RuntimeScope,
+  ServiceConfiguration,
+  ServiceRegistryEntry,
+} from "../types";
+import { Database, DatabaseStore, SqlValue } from "./database";
+import { codeOf, dumpDatabase, refuseImport } from "./sql-dump";
+
+export const sqlDescriptor: ServiceRegistryEntry = {
+  serviceId: "sql",
+  serviceName: "SQL",
+  version: "v1",
+  capabilities: [],
+};
+
+type SqlMode = "query" | "run" | "exec" | "databases" | "export" | "import";
+
+const MODES: SqlMode[] = ["query", "run", "exec", "databases", "export", "import"];
+
+/** The modes that run the configured statement, and need one. */
+const STATEMENT_MODES: SqlMode[] = ["query", "run", "exec"];
+
+/** Whether the statement's result travels onward, or the input it ran on. */
+type SqlEmit = "result" | "input";
+
+const EMITS: SqlEmit[] = ["result", "input"];
+
+/** What `export` hands on: SQL text that recreates the database, or the
+ *  SQLite file itself. */
+type SqlFormat = "sql" | "sqlite";
+
+const FORMATS: SqlFormat[] = ["sql", "sqlite"];
+
+/** `$name`, `:name` and `@name` are all named parameters to SQLite. */
+const NAMED_PARAMETER = /[$:@]([A-Za-z_][A-Za-z0-9_]*)/g;
+
+/**
+ * The parameter names a statement is given the run's caller under, and what of
+ * the caller each one is. Whatever the prefix — `$`, `:` or `@`.
+ */
+const CALLER_PARAMETERS: Record<string, keyof Caller> = {
+  caller_email: "email",
+  caller_name: "name",
+  caller_sub: "sub",
+  caller_role: "role",
+};
+
+type Notify = (payload: unknown, instanceId?: string) => void;
+
+/**
+ * A value SQLite can store.
+ *
+ * Booleans and objects have no column type, and a board should not have to
+ * convert them by hand on the way in — a JSON field arriving as an object is
+ * far more often meant to be kept than to be an error.
+ */
+function bindable(value: unknown): SqlValue {
+  if (value === undefined || value === null) {
+    return null;
+  }
+  if (typeof value === "boolean") {
+    return value ? 1 : 0;
+  }
+  if (typeof value === "number" || typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+
+/**
+ * Runs SQL text that arrived as input — a dump, typically — against the
+ * database, once `refuseImport` has agreed to it.
+ *
+ * A dump is one transaction, and a failure part way leaves it open, so it is
+ * rolled back here: nothing of a dump that did not load stays behind. The dump
+ * also turns foreign keys off for the connection, and every other statement
+ * expects them on.
+ */
+function importInto(db: Database, input: unknown): void {
+  const text =
+    typeof input === "string"
+      ? input
+      : input instanceof Uint8Array
+        ? new TextDecoder().decode(input)
+        : null;
+  if (text === null || !text.trim()) {
+    throw new Error("an import needs SQL text as its input");
+  }
+  const refused = refuseImport(text);
+  if (refused) {
+    throw new Error(refused);
+  }
+  try {
+    db.exec(text);
+  } catch (err) {
+    try {
+      db.exec("ROLLBACK");
+    } catch {
+      // No transaction was open: the text did not begin one.
+    }
+    throw err;
+  } finally {
+    db.exec("PRAGMA foreign_keys = ON");
+  }
+}
+
+export class SqlService implements HostedService {
+  readonly serviceId = sqlDescriptor.serviceId;
+  readonly serviceName = sqlDescriptor.serviceName;
+  readonly version = sqlDescriptor.version;
+  readonly capabilities = sqlDescriptor.capabilities;
+  readonly uuid: string;
+
+  private host: RuntimeHost | null = null;
+  private mode: SqlMode = "query";
+  private statement = "";
+  private schema = "";
+  private lastCount = 0;
+  private lastError = "";
+  /** Boards whose schema this instance has already applied. */
+  private prepared = new Set<string>();
+  /** The file this board keeps its tables in. Empty derives one; see docs. */
+  private database = "";
+  /** What travels onward: the statement's result, or the input it ran on. */
+  private emit: SqlEmit = "result";
+  /** What `export` hands on. */
+  private format: SqlFormat = "sql";
+
+  constructor(
+    config: ServiceConfiguration,
+    private readonly databases: DatabaseStore,
+  ) {
+    this.uuid = config.uuid;
+    if (config.state) {
+      this.configure(config.state);
+    }
+  }
+
+  setHost(host: RuntimeHost): void {
+    this.host = host;
+  }
+
+  getState(): JsonRecord {
+    return {
+      mode: this.mode,
+      emit: this.emit,
+      format: this.format,
+      database: this.database,
+      statement: this.statement,
+      schema: this.schema,
+      lastCount: this.lastCount,
+      error: this.lastError,
+    };
+  }
+
+  configure(config: JsonRecord): JsonRecord {
+    if (typeof config.mode === "string" && MODES.includes(config.mode as SqlMode)) {
+      this.mode = config.mode as SqlMode;
+    }
+    if (typeof config.emit === "string" && EMITS.includes(config.emit as SqlEmit)) {
+      this.emit = config.emit as SqlEmit;
+    }
+    if (typeof config.format === "string" && FORMATS.includes(config.format as SqlFormat)) {
+      this.format = config.format as SqlFormat;
+    }
+    if (typeof config.statement === "string") {
+      this.statement = config.statement;
+    }
+    if (typeof config.schema === "string" && config.schema !== this.schema) {
+      this.schema = config.schema;
+      // A changed schema is a different set of tables to bring into being.
+      this.prepared.clear();
+    }
+    if (typeof config.database === "string" && config.database !== this.database) {
+      this.database = config.database.trim();
+      // Another file is another set of tables, whatever this one already made.
+      this.prepared.clear();
+    }
+    return this.getState();
+  }
+
+  /**
+   * Runs the statement and hands onward whatever `emit` says travels.
+   *
+   * Unlike `store`, this returns rather than pushing: SQLite answers in the
+   * same call, so there is nothing to wait for and no reason to stop the
+   * pipeline and re-enter it.
+   */
+  process(input: unknown, notify: Notify): unknown {
+    const scope = this.host?.scope();
+    if (!scope) {
+      return this.fail(notify, "sql has no runtime to scope its database to");
+    }
+    if (!this.statement.trim() && STATEMENT_MODES.includes(this.mode)) {
+      return this.fail(notify, "sql has no statement to run");
+    }
+
+    if (this.mode === "databases") {
+      // Opens nothing: listing the databases is not a reason to create one.
+      try {
+        const rows = this.databases.list(scope.owner);
+        const result = { rows, count: rows.length };
+        this.lastCount = rows.length;
+        this.lastError = "";
+        notify(result);
+        return this.emit === "input" ? input : result;
+      } catch (err) {
+        return this.fail(notify, `databases failed: ${reason(err)}`);
+      }
+    }
+
+    let db: Database;
+    try {
+      db = this.database
+        ? this.databases.openNamed(scope.owner, this.database)
+        : this.databases.open(scope);
+      this.applySchema(db, scope);
+    } catch (err) {
+      return this.fail(notify, `could not open the board's database: ${reason(err)}`);
+    }
+
+    try {
+      if (this.mode === "export") {
+        const exported = this.format === "sqlite" ? db.file() : dumpDatabase(db);
+        this.lastError = "";
+        // Reported as what was exported, not as the export itself: it
+        // travels to the next service, and a panel has no use for a copy.
+        notify({
+          exported: this.database || scope.boardName,
+          format: this.format,
+          bytes: exported.length,
+        });
+        return this.emit === "input" ? input : exported;
+      }
+      const result = this.execute(db, input);
+      this.lastError = "";
+      // What the statement did, for the board's log: how many rows, never
+      // which — the parameters are the caller's data, and the log keeps none.
+      this.host?.log("info", `sql.${this.mode}`, summaryOf(this.mode, result));
+      // Reported either way: what the statement did is this service's own news,
+      // and a panel showing it does not depend on the board choosing to pass it
+      // on. Only what travels to the next service is `emit`'s to decide.
+      notify(result);
+      return this.emit === "input" ? input : result;
+    } catch (err) {
+      return this.fail(notify, `${this.mode} failed: ${reason(err)}`);
+    }
+  }
+
+  destroy(): void {
+    this.host = null;
+  }
+
+  // ── Private ───────────────────────────────────────────────────────────────
+
+  /**
+   * Creates the board's tables, once, before anything reads them.
+   *
+   * Not on configure: a service's first `configure` runs in its constructor,
+   * before the runtime hands it a host — so at that moment there is no scope,
+   * and no way to know which board's database the tables belong in.
+   */
+  private applySchema(db: Database, scope: RuntimeScope): void {
+    const key = `${scope.owner} ${this.database || scope.boardName}`;
+    if (!this.schema.trim() || this.prepared.has(key)) {
+      return;
+    }
+    db.exec(this.schema);
+    this.prepared.add(key);
+  }
+
+  private execute(db: Database, input: unknown): JsonRecord {
+    if (this.mode === "exec") {
+      db.exec(this.statement);
+      this.lastCount = 0;
+      return { executed: true };
+    }
+    if (this.mode === "import") {
+      importInto(db, input);
+      this.lastCount = 0;
+      return { executed: true };
+    }
+
+    const params = this.parameters(input);
+    if (this.mode === "run") {
+      const { changes, lastInsertRowid } = db.run(this.statement, params);
+      this.lastCount = changes;
+      return { changes, lastInsertRowid };
+    }
+
+    const rows = db.query(this.statement, params);
+    this.lastCount = rows.length;
+    return { rows, count: rows.length };
+  }
+
+  /**
+   * The values the statement asks for, taken from the input by name.
+   *
+   * Only the names the statement mentions are bound: SQLite rejects a
+   * parameter it was not asked for, so handing it a whole input object would
+   * fail on every field the statement happens not to use.
+   *
+   * The reserved caller names are the exception to "from the input": they are
+   * bound from the run in progress.
+   */
+  private parameters(input: unknown): Record<string, SqlValue> {
+    const record =
+      input && typeof input === "object" && !Array.isArray(input)
+        ? (input as JsonRecord)
+        : {};
+    const context = this.host?.currentContext();
+    const caller = context?.actor.kind === "person" ? context.actor : undefined;
+    const params: Record<string, SqlValue> = {};
+    for (const match of codeOf(this.statement).matchAll(NAMED_PARAMETER)) {
+      const name = match[1];
+      const reserved = CALLER_PARAMETERS[name];
+      // Never the input's to supply, present or not: a caller the run does
+      // not have is NULL, not whatever the payload claims.
+      params[name] =
+        name === "actor_kind"
+          ? bindable(context?.actor.kind ?? "board")
+          : reserved
+            ? bindable(caller?.[reserved])
+            : bindable(record[name]);
+    }
+    return params;
+  }
+
+  /** Reports a failure and produces nothing, so the pipeline stops here. */
+  private fail(notify: Notify, error: string): null {
+    this.lastError = error;
+    this.host?.log("error", "service.failed", { message: error });
+    notify({ error });
+    return null;
+  }
+}
+
+/** A statement's outcome as counts only. */
+function summaryOf(mode: SqlMode, result: JsonRecord): JsonRecord {
+  if (mode === "run") {
+    return { changes: result.changes };
+  }
+  if (mode === "query") {
+    return { count: result.count };
+  }
+  return {};
+}
+
+function reason(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}

package/bundle/hkp-node/src/services/stopper.ts

@@ -0,0 +1,69 @@
+/**
+ * Service Documentation
+ * Service ID: stopper
+ * Service Name: Stopper
+ * Runtime: hkp-node
+ * Modes: none
+ * Key Config: none
+ * IO: in=anything -> out=null (nothing is forwarded)
+ *
+ * Returns null on every call, which the runtime reads as "nothing to pass on":
+ * the services after it are not called, and the runtime emits no result, so the
+ * next runtime in the chain is not driven either.
+ *
+ * That last part is the reason to reach for it on a board with several
+ * runtimes. Runtimes are chained — the result of one becomes the input of the
+ * next — so a runtime whose work is a side effect rather than a value should
+ * end here, instead of feeding whatever it happened to produce into the next
+ * runtime. Mirrors the browser runtime's `hookup.to/service/stopper`.
+ */
+import {
+  HostedService,
+  JsonRecord,
+  ServiceConfiguration,
+  ServiceRegistryEntry,
+} from "../types";
+
+export const stopperDescriptor: ServiceRegistryEntry = {
+  serviceId: "stopper",
+  serviceName: "Stopper",
+  version: "v1",
+  capabilities: [],
+};
+
+export class StopperService implements HostedService {
+  readonly serviceId = stopperDescriptor.serviceId;
+  readonly serviceName = stopperDescriptor.serviceName;
+  readonly version = stopperDescriptor.version;
+  readonly capabilities = stopperDescriptor.capabilities;
+  readonly uuid: string;
+
+  private bypass = false;
+
+  constructor(config: ServiceConfiguration) {
+    this.uuid = config.uuid;
+    if (config.state) {
+      this.configure(config.state);
+    }
+  }
+
+  getState(): JsonRecord {
+    return { bypass: this.bypass };
+  }
+
+  configure(config: JsonRecord): JsonRecord {
+    // Bypass is the only setting worth having: it turns the dead end back into
+    // a passthrough, so a chain can be opened up without moving services around.
+    if (typeof config.bypass === "boolean") {
+      this.bypass = config.bypass;
+    }
+    return this.getState();
+  }
+
+  process(
+    input: unknown,
+    _notify: (payload: unknown, instanceId?: string) => void,
+  ): unknown {
+    return this.bypass ? input : null;
+  }
+}