@pellux/goodvibes-tui 0.24.1 → 0.26.0

package/src/daemon/handlers/routing/index.ts

@@ -0,0 +1,261 @@
+// ---------------------------------------------------------------------------
+// Channel routing surface — HANDLERS for the SDK-defined methods
+//   - channels.routing.list   (read-only)
+//   - channels.routing.assign (admin, confirmation-gated)
+//   - channels.routing.delete (admin, dangerous, confirmation-gated)
+//
+// The SDK's GatewayMethodCatalog already registered the canonical descriptors
+// (id, input/output schema, access, scopes, dangerous) for these three method
+// ids with `handler: undefined`. This module NEVER re-declares an id, schema,
+// or descriptor: it looks each one up by id and attaches a typed handler via
+// `registerCatalogHandlers`, flipping the builtin method from HTTP-fallback to
+// in-process execution. Handler outputs match the SDK output schemas exactly.
+//
+// Confirmation posture (per the daemon handoff, Responsibility 2): assign and
+// delete are control-plane mutations that require explicit user confirmation
+// (the SDK marks assign access:admin + 'Requires explicit confirmation', and
+// delete dangerous:true). Both pass `{ confirm: true }` so the register wrapper
+// enforces `body.confirm === true` AND `context.explicitUserRequest === true`.
+// list is read-only and ungated.
+// ---------------------------------------------------------------------------
+
+import type { HandlerContext } from '../context.ts';
+import type { RoutingRegistration as FoundationRoutingRegistration } from '../index.ts';
+import {
+  registerCatalogHandlers,
+  type CatalogHandlerEntry,
+  type TypedHandler,
+  type Unregister,
+} from '../register.ts';
+import {
+  buildChannelId,
+  parseChannelId,
+  RouteStore,
+  toRouteListItem,
+  type RoutingChannelRoute,
+  type RoutingRouteListItem,
+} from './route-store.ts';
+import { createRoutingResolver, type RoutingResolver } from './routing-resolver.ts';
+
+export { createInboxRouteResolver, type RouteResolver, type RouteResolverInput } from './inbox-bridge.ts';
+export {
+  buildChannelId,
+  parseChannelId,
+  RouteStore,
+  toRouteListItem,
+  type RoutingChannelRoute,
+  type RoutingRouteListItem,
+} from './route-store.ts';
+export {
+  createRoutingResolver,
+  resolveProfile,
+  WILDCARD_SURFACE,
+  type RoutingResolver,
+} from './routing-resolver.ts';
+
+// ---------------------------------------------------------------------------
+// Wire shapes (derived from the SDK contracts; NOT re-declared schemas).
+//
+// list   in : { profileId?, surfaceKind?, limit? }
+//         out: { routes: [{ id, createdAt, updatedAt, surfaceKind, routeId?,
+//                           profileId, label? }], total }   (SDK route-item shape)
+// assign in : { channelId?, surfaceKind, routeId?, profileId, label? }
+//             out: { assignmentId, channelId?, surfaceKind, routeId?, profileId, label?, createdAt, updatedAt }
+// delete in : { assignmentId }                        out: { deleted, assignmentId }
+// ---------------------------------------------------------------------------
+
+interface RoutingListBody {
+  profileId?: unknown;
+  surfaceKind?: unknown;
+  limit?: unknown;
+}
+interface RoutingListResult {
+  routes: RoutingRouteListItem[];
+  total: number;
+}
+
+interface RoutingAssignBody {
+  channelId?: unknown;
+  surfaceKind?: unknown;
+  routeId?: unknown;
+  profileId?: unknown;
+  label?: unknown;
+}
+interface RoutingAssignResult {
+  assignmentId: string;
+  channelId: string;
+  surfaceKind: string;
+  routeId?: string;
+  profileId: string;
+  label?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface RoutingDeleteBody {
+  assignmentId?: unknown;
+}
+interface RoutingDeleteResult {
+  deleted: boolean;
+  assignmentId: string;
+}
+
+const LIST_METHOD = 'channels.routing.list';
+const ASSIGN_METHOD = 'channels.routing.assign';
+const DELETE_METHOD = 'channels.routing.delete';
+
+function optionalString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+
+function clampLimit(value: unknown): number | undefined {
+  if (value === undefined || value === null || value === '') return undefined;
+  const n = typeof value === 'number' ? value : Number(value);
+  if (!Number.isFinite(n)) return undefined;
+  return Math.max(1, Math.floor(n));
+}
+
+/**
+ * Routing surface handle. Satisfies the foundation `RoutingRegistration`
+ * (`{ unregister, resolveProfileId }`) and additionally exposes the live
+ * {@link RoutingResolver} and {@link RouteStore} so the inbox surface and tests
+ * can reuse routing resolution without going through the catalog.
+ */
+export interface RoutingRegistration extends FoundationRoutingRegistration {
+  readonly resolver: RoutingResolver;
+  readonly store: RouteStore;
+}
+
+/**
+ * Attach the channel-routing handlers to the SDK gateway catalog held by `ctx`.
+ *
+ * The {@link RouteStore} is lazily initialized on first invocation (the
+ * register contract is synchronous) so registration never blocks on disk I/O.
+ * Returns the teardown plus the resolver/store handles.
+ */
+export function registerRoutingMethods(ctx: HandlerContext): RoutingRegistration {
+  const store = new RouteStore({ workingDirectory: ctx.workingDirectory });
+  const resolver = createRoutingResolver(store);
+
+  let initPromise: Promise<void> | null = null;
+  const ensureInit = async (): Promise<void> => {
+    if (!initPromise) {
+      initPromise = store.init().catch((error) => {
+        // Allow a later invocation to retry initialization.
+        initPromise = null;
+        throw error;
+      });
+    }
+    await initPromise;
+  };
+
+  const listHandler: TypedHandler<RoutingListBody, RoutingListResult> = async ({ body }) => {
+    await ensureInit();
+    const routes = store.list({
+      profileId: optionalString(body.profileId),
+      surfaceKind: optionalString(body.surfaceKind),
+    });
+    const limit = clampLimit(body.limit);
+    const limited = limit !== undefined ? routes.slice(0, limit) : routes;
+    // Project to the SDK `channels.routing.list` item shape: emit `id`
+    // (= assignmentId) and drop the daemon-internal `channelId`/`assignmentId`,
+    // which additionalProperties:false forbids.
+    const items = limited.map(toRouteListItem);
+    return { routes: items, total: items.length };
+  };
+
+  const assignHandler: TypedHandler<RoutingAssignBody, RoutingAssignResult> = async ({ body, context }) => {
+    await ensureInit();
+    const profileId = optionalString(body.profileId);
+    if (profileId === undefined) {
+      throw new Error('profileId is required');
+    }
+    // The SDK contract accepts either a composite `channelId` or the
+    // `surfaceKind` (+ optional `routeId`) parts. Prefer an explicit
+    // channelId; otherwise build one from the parts.
+    const explicitChannelId = optionalString(body.channelId);
+    const surfaceKind = optionalString(body.surfaceKind);
+    const routeId = optionalString(body.routeId);
+    const channelId = explicitChannelId ?? (
+      surfaceKind !== undefined ? buildChannelId(surfaceKind, routeId) : undefined
+    );
+    if (channelId === undefined) {
+      throw new Error('surfaceKind (or channelId) is required');
+    }
+    const { route, created } = await store.upsert({
+      channelId,
+      profileId,
+      label: optionalString(body.label),
+    });
+    ctx.logger.info('channels.routing.assign', {
+      assignmentId: route.assignmentId,
+      channelId: route.channelId,
+      surfaceKind: route.surfaceKind,
+      profileId: route.profileId,
+      created,
+      principalId: context.principalId,
+    });
+    const result: RoutingAssignResult = {
+      assignmentId: route.assignmentId,
+      channelId: route.channelId,
+      surfaceKind: route.surfaceKind,
+      profileId: route.profileId,
+      createdAt: route.createdAt,
+      updatedAt: route.updatedAt,
+    };
+    if (route.routeId !== undefined) result.routeId = route.routeId;
+    if (route.label !== undefined) result.label = route.label;
+    return result;
+  };
+
+  const deleteHandler: TypedHandler<RoutingDeleteBody, RoutingDeleteResult> = async ({ body, context }) => {
+    await ensureInit();
+    const assignmentId = optionalString(body.assignmentId);
+    if (assignmentId === undefined) {
+      throw new Error('assignmentId is required');
+    }
+    const deleted = await store.delete(assignmentId);
+    ctx.logger.info('channels.routing.delete', {
+      assignmentId,
+      deleted,
+      principalId: context.principalId,
+    });
+    return { deleted, assignmentId };
+  };
+
+  const entries: CatalogHandlerEntry[] = [
+    { id: LIST_METHOD, handler: listHandler as TypedHandler<unknown, unknown> },
+    {
+      id: ASSIGN_METHOD,
+      handler: assignHandler as TypedHandler<unknown, unknown>,
+      options: { confirm: true },
+    },
+    {
+      id: DELETE_METHOD,
+      handler: deleteHandler as TypedHandler<unknown, unknown>,
+      options: { confirm: true },
+    },
+  ];
+
+  const teardownHandlers = registerCatalogHandlers(ctx.catalog, entries);
+
+  const unregister: Unregister = () => {
+    teardownHandlers();
+    store.close();
+  };
+
+  return {
+    unregister,
+    resolveProfileId: (surfaceKind: string, routeId?: string) =>
+      resolver.getProfileForChannel(surfaceKind, routeId),
+    resolver,
+    store,
+  };
+}
+
+/**
+ * Provider entry point consumed by `registerDaemonHandlers`
+ * (`DaemonHandlerSurfaceProviders.registerRouting`).
+ */
+export const registerRouting = (ctx: HandlerContext): RoutingRegistration =>
+  registerRoutingMethods(ctx);

package/src/daemon/handlers/routing/route-store.ts

@@ -0,0 +1,319 @@
+import { randomUUID } from 'node:crypto';
+import { HandlerSqliteStore } from '../sqlite-store.ts';
+import { HandlerError } from '../errors.ts';
+
+/**
+ * A persisted channel-to-profile routing assignment, in the exact shape the
+ * `channels.routing.*` methods serve. Keyed on a composite `channelId`
+ * (`surfaceKind` or `surfaceKind:routeId`). The SDK output schemas require
+ * `surfaceKind`, `profileId`, `createdAt`, and `updatedAt`; `channelId`,
+ * `routeId`, and `label` are carried through as optional refinements.
+ */
+export interface RoutingChannelRoute {
+  assignmentId: string;
+  /** Composite key: `surfaceKind` or `surfaceKind:routeId`. */
+  channelId: string;
+  surfaceKind: string;
+  routeId?: string;
+  profileId: string;
+  label?: string;
+  createdAt: string; // ISO-8601
+  updatedAt: string; // ISO-8601
+}
+
+/**
+ * Per-route item shape emitted by `channels.routing.list`, matching the SDK
+ * `CHANNEL_ROUTING_RULE_SCHEMA` exactly: properties
+ * {id, createdAt, updatedAt, surfaceKind, routeId, profileId, label},
+ * required [id, createdAt, updatedAt, surfaceKind, profileId], and
+ * additionalProperties:false. The store's `assignmentId` is projected to `id`,
+ * and the daemon-internal `channelId` is dropped (it is forbidden by the
+ * schema's additionalProperties:false).
+ */
+export interface RoutingRouteListItem {
+  id: string;
+  createdAt: string; // ISO-8601
+  updatedAt: string; // ISO-8601
+  surfaceKind: string;
+  routeId?: string;
+  profileId: string;
+  label?: string;
+}
+
+/**
+ * Project a stored route to the SDK `channels.routing.list` item shape. Pure;
+ * only includes optional `routeId`/`label` when present so the payload never
+ * carries `undefined`-valued or schema-forbidden keys.
+ */
+export function toRouteListItem(route: RoutingChannelRoute): RoutingRouteListItem {
+  const item: RoutingRouteListItem = {
+    id: route.assignmentId,
+    createdAt: route.createdAt,
+    updatedAt: route.updatedAt,
+    surfaceKind: route.surfaceKind,
+    profileId: route.profileId,
+  };
+  if (route.routeId !== undefined) {
+    item.routeId = route.routeId;
+  }
+  if (route.label !== undefined) {
+    item.label = route.label;
+  }
+  return item;
+}
+
+/** Parsed components of a composite channelId. */
+export interface ParsedChannelId {
+  surfaceKind: string;
+  routeId?: string;
+}
+
+export interface RouteUpsertInput {
+  channelId: string;
+  profileId: string;
+  label?: string;
+}
+
+export interface RouteUpsertResult {
+  route: RoutingChannelRoute;
+  created: boolean;
+}
+
+export interface RouteListFilter {
+  profileId?: string;
+  surfaceKind?: string;
+}
+
+const SCHEMA: string[] = [
+  `CREATE TABLE IF NOT EXISTS routes (
+    assignmentId TEXT PRIMARY KEY,
+    channelId TEXT NOT NULL,
+    surfaceKind TEXT NOT NULL,
+    routeId TEXT,
+    profileId TEXT NOT NULL,
+    label TEXT,
+    createdAt TEXT NOT NULL,
+    updatedAt TEXT NOT NULL
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_routes_surface_route ON routes (surfaceKind, routeId)`,
+  // Enforce one assignment per channel — the upsert path relies on this.
+  `CREATE UNIQUE INDEX IF NOT EXISTS idx_routes_channel ON routes (channelId)`,
+];
+
+interface RouteRow {
+  assignmentId: string;
+  channelId: string;
+  surfaceKind: string;
+  routeId: string | null;
+  profileId: string;
+  label: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/**
+ * Parse a composite channelId into its `surfaceKind` and optional `routeId`.
+ *
+ * The channelId format is `surfaceKind` (surface-only / wildcard) or
+ * `surfaceKind:routeId`. Everything after the FIRST colon is the routeId, so
+ * route IDs may themselves contain colons (e.g. `slack:C123:thread`).
+ */
+export function parseChannelId(channelId: string): ParsedChannelId {
+  const raw = typeof channelId === 'string' ? channelId.trim() : '';
+  if (raw.length === 0) {
+    throw new HandlerError('channelId is required', 'ROUTING_INVALID_CHANNEL_ID', 400);
+  }
+  const separator = raw.indexOf(':');
+  if (separator === -1) {
+    return { surfaceKind: raw };
+  }
+  const surfaceKind = raw.slice(0, separator).trim();
+  const routeId = raw.slice(separator + 1).trim();
+  if (surfaceKind.length === 0) {
+    throw new HandlerError('channelId is missing a surfaceKind', 'ROUTING_INVALID_CHANNEL_ID', 400);
+  }
+  // A trailing colon with no routeId collapses to a surface-only assignment.
+  return routeId.length === 0 ? { surfaceKind } : { surfaceKind, routeId };
+}
+
+/** Build a canonical composite channelId from its parts. */
+export function buildChannelId(surfaceKind: string, routeId?: string): string {
+  return routeId === undefined || routeId === '' ? surfaceKind : `${surfaceKind}:${routeId}`;
+}
+
+function rowToRoute(row: RouteRow): RoutingChannelRoute {
+  const route: RoutingChannelRoute = {
+    assignmentId: row.assignmentId,
+    channelId: row.channelId,
+    surfaceKind: row.surfaceKind,
+    profileId: row.profileId,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+  if (row.routeId !== null && row.routeId !== '') route.routeId = row.routeId;
+  if (row.label !== null && row.label !== '') route.label = row.label;
+  return route;
+}
+
+/**
+ * SQLite-backed store for channel-to-profile routing assignments.
+ *
+ * Wraps {@link HandlerSqliteStore} (file `channel-routes.sqlite`) and persists
+ * after every mutation. The store owns the composite-key parsing so callers only
+ * ever deal with `channelId` strings.
+ */
+export class RouteStore {
+  private readonly store: HandlerSqliteStore;
+  private initialized = false;
+
+  constructor(options: { workingDirectory: string }) {
+    this.store = new HandlerSqliteStore({
+      workingDirectory: options.workingDirectory,
+      fileName: 'channel-routes.sqlite',
+      schema: SCHEMA,
+    });
+  }
+
+  get dbPath(): string {
+    return this.store.dbPath;
+  }
+
+  async init(): Promise<void> {
+    if (this.initialized) return;
+    await this.store.init();
+    this.initialized = true;
+  }
+
+  close(): void {
+    this.store.close();
+    this.initialized = false;
+  }
+
+  private requireInit(): void {
+    if (!this.initialized) {
+      throw new HandlerError('RouteStore not initialized', 'ROUTING_STORE_UNINITIALIZED', 500);
+    }
+  }
+
+  /** All assignments, ordered most-recently-updated first. */
+  listAll(): RoutingChannelRoute[] {
+    this.requireInit();
+    const rows = this.store.all<RouteRow>(
+      `SELECT assignmentId, channelId, surfaceKind, routeId, profileId, label, createdAt, updatedAt
+       FROM routes ORDER BY updatedAt DESC, assignmentId ASC`,
+    );
+    return rows.map(rowToRoute);
+  }
+
+  /** Assignments filtered by optional profileId and/or surfaceKind. */
+  list(filter: RouteListFilter = {}): RoutingChannelRoute[] {
+    this.requireInit();
+    const clauses: string[] = [];
+    const params: (string | number)[] = [];
+    if (filter.profileId !== undefined && filter.profileId !== '') {
+      clauses.push('profileId = ?');
+      params.push(filter.profileId);
+    }
+    if (filter.surfaceKind !== undefined && filter.surfaceKind !== '') {
+      clauses.push('surfaceKind = ?');
+      params.push(filter.surfaceKind);
+    }
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(' AND ')}` : '';
+    const rows = this.store.all<RouteRow>(
+      `SELECT assignmentId, channelId, surfaceKind, routeId, profileId, label, createdAt, updatedAt
+       FROM routes ${where} ORDER BY updatedAt DESC, assignmentId ASC`,
+      params,
+    );
+    return rows.map(rowToRoute);
+  }
+
+  /** Lookup a single assignment by its composite channelId. */
+  findByChannelId(channelId: string): RoutingChannelRoute | null {
+    this.requireInit();
+    const row = this.store.get<RouteRow>(
+      `SELECT assignmentId, channelId, surfaceKind, routeId, profileId, label, createdAt, updatedAt
+       FROM routes WHERE channelId = ?`,
+      [channelId],
+    );
+    return row ? rowToRoute(row) : null;
+  }
+
+  /** Lookup a single assignment by its assignmentId. */
+  findById(assignmentId: string): RoutingChannelRoute | null {
+    this.requireInit();
+    const row = this.store.get<RouteRow>(
+      `SELECT assignmentId, channelId, surfaceKind, routeId, profileId, label, createdAt, updatedAt
+       FROM routes WHERE assignmentId = ?`,
+      [assignmentId],
+    );
+    return row ? rowToRoute(row) : null;
+  }
+
+  /**
+   * Create or update the assignment for a channel.
+   *
+   * `created` is true when no prior assignment existed for the channelId, false
+   * when an existing row was updated. The assignmentId is stable across updates
+   * (it is preserved from the existing row). Persists to disk after the write.
+   */
+  async upsert(input: RouteUpsertInput): Promise<RouteUpsertResult> {
+    this.requireInit();
+    const profileId = typeof input.profileId === 'string' ? input.profileId.trim() : '';
+    if (profileId.length === 0) {
+      throw new HandlerError('profileId is required', 'ROUTING_INVALID_PROFILE_ID', 400);
+    }
+    const { surfaceKind, routeId } = parseChannelId(input.channelId);
+    const channelId = buildChannelId(surfaceKind, routeId);
+    const label = typeof input.label === 'string' && input.label.trim().length > 0
+      ? input.label.trim()
+      : null;
+    const now = new Date().toISOString();
+
+    const existing = this.findByChannelId(channelId);
+    if (existing) {
+      this.store.run(
+        `UPDATE routes
+         SET profileId = ?, label = ?, surfaceKind = ?, routeId = ?, updatedAt = ?
+         WHERE assignmentId = ?`,
+        [profileId, label, surfaceKind, routeId ?? null, now, existing.assignmentId],
+      );
+      await this.store.save();
+      const route = this.findById(existing.assignmentId);
+      if (!route) {
+        throw new HandlerError('Failed to read back updated route', 'ROUTING_WRITE_FAILED', 500);
+      }
+      return { route, created: false };
+    }
+
+    const assignmentId = randomUUID();
+    this.store.run(
+      `INSERT INTO routes
+        (assignmentId, channelId, surfaceKind, routeId, profileId, label, createdAt, updatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [assignmentId, channelId, surfaceKind, routeId ?? null, profileId, label, now, now],
+    );
+    await this.store.save();
+    const route = this.findById(assignmentId);
+    if (!route) {
+      throw new HandlerError('Failed to read back inserted route', 'ROUTING_WRITE_FAILED', 500);
+    }
+    return { route, created: true };
+  }
+
+  /**
+   * Delete an assignment by assignmentId. Returns true when a row was removed,
+   * false when no matching assignment existed. Persists to disk after a delete.
+   */
+  async delete(assignmentId: string): Promise<boolean> {
+    this.requireInit();
+    const id = typeof assignmentId === 'string' ? assignmentId.trim() : '';
+    if (id.length === 0) {
+      throw new HandlerError('assignmentId is required', 'ROUTING_INVALID_ASSIGNMENT_ID', 400);
+    }
+    const existing = this.findById(id);
+    if (!existing) return false;
+    this.store.run('DELETE FROM routes WHERE assignmentId = ?', [id]);
+    await this.store.save();
+    return true;
+  }
+}

package/src/daemon/handlers/routing/routing-resolver.ts

@@ -0,0 +1,75 @@
+import type { RoutingChannelRoute } from './route-store.ts';
+import type { RouteStore } from './route-store.ts';
+
+/** Wildcard surfaceKind that matches any surface as a last resort. */
+export const WILDCARD_SURFACE = 'any';
+
+/**
+ * Pure resolution of a profileId from a set of routes, applying the EXACT same
+ * order as the agent-side `getProfileForChannel()` so offline and online
+ * routing produce identical results:
+ *
+ *   1. exact match    — surfaceKind AND routeId both match
+ *   2. surface-only   — surfaceKind matches, route has no routeId
+ *   3. wildcard       — a route with surfaceKind === 'any' (no routeId)
+ *
+ * Returns the matching profileId, or `null` when nothing matches.
+ */
+export function resolveProfile(
+  routes: readonly RoutingChannelRoute[],
+  surfaceKind: string,
+  routeId?: string,
+): string | null {
+  const surface = typeof surfaceKind === 'string' ? surfaceKind.trim() : '';
+  if (surface.length === 0) return null;
+  const route = typeof routeId === 'string' && routeId.trim().length > 0 ? routeId.trim() : undefined;
+
+  // 1. Exact match (surfaceKind + routeId). Only attempted when a routeId is
+  //    supplied by the caller.
+  if (route !== undefined) {
+    const exact = routes.find(
+      (entry) => entry.surfaceKind === surface && entry.routeId === route,
+    );
+    if (exact) return exact.profileId;
+  }
+
+  // 2. Surface-only match (surfaceKind, no routeId on the route).
+  const surfaceOnly = routes.find(
+    (entry) => entry.surfaceKind === surface && (entry.routeId === undefined || entry.routeId === ''),
+  );
+  if (surfaceOnly) return surfaceOnly.profileId;
+
+  // 3. Wildcard match (surfaceKind === 'any', no routeId).
+  const wildcard = routes.find(
+    (entry) => entry.surfaceKind === WILDCARD_SURFACE && (entry.routeId === undefined || entry.routeId === ''),
+  );
+  if (wildcard) return wildcard.profileId;
+
+  return null;
+}
+
+/** Resolver bound to a live {@link RouteStore}. */
+export interface RoutingResolver {
+  /**
+   * Resolve the profileId that should handle an inbound message on the given
+   * surface/route, applying the agent resolution order. Returns null when no
+   * assignment matches (caller falls back to the default session).
+   */
+  getProfileForChannel(surfaceKind: string, routeId?: string): string | null;
+  /** Alias of {@link getProfileForChannel}, exported for inbox surface reuse. */
+  resolveProfile(surfaceKind: string, routeId?: string): string | null;
+}
+
+/**
+ * Create a resolver backed by a {@link RouteStore}. The store must already be
+ * initialized; each call reads the current route set so assignments take effect
+ * immediately after a mutation.
+ */
+export function createRoutingResolver(store: RouteStore): RoutingResolver {
+  const resolve = (surfaceKind: string, routeId?: string): string | null =>
+    resolveProfile(store.listAll(), surfaceKind, routeId);
+  return {
+    getProfileForChannel: resolve,
+    resolveProfile: resolve,
+  };
+}