akanjs 3.1.0-rc.2 → 3.1.0-rc.21

package/server/migration/migrationTable.ts

@@ -0,0 +1,258 @@
+import type { PromiseOrObject } from "akanjs/base";
+import { sanitizeJson } from "akanjs/document";
+import {
+  descriptorHash,
+  RawDocumentTable,
+  type RawFilter,
+  type RawFindOptions,
+  type TransferRow,
+} from "akanjs/service";
+import { DocPath, type DocSlot } from "./docPath";
+import type { MigrationChange } from "./migrationChangeLog";
+import { MigrationScope } from "./migrationScope";
+
+/** A path to its new value; `undefined` removes the path. */
+export type MigrationPatch = Record<string, unknown>;
+
+export interface MigrationRewriteOption {
+  where?: RawFilter;
+  /** Removed rows are rewritten too unless this is `false`. */
+  withRemoved?: boolean;
+  batchSize?: number;
+}
+
+/** Why a logged change was left as it is; `reverted` means it was undone. */
+export type MigrationRevertOutcome = "reverted" | "changed" | "missing";
+
+/**
+ * A model's rows as stored, whatever the model declares now. Every write records what it changed in the run's change
+ * log, in the same transaction, and leaves `updatedAt` alone: a migration reshapes data, it does not edit it.
+ */
+export class MigrationTable {
+  static readonly #baseColumns = new Set(["id", "createdAt", "updatedAt", "removedAt"]);
+  readonly name: string;
+  readonly #raw: RawDocumentTable;
+  readonly #scope: MigrationScope;
+
+  constructor(name: string, scope: MigrationScope) {
+    this.name = name;
+    this.#scope = scope;
+    this.#raw = new RawDocumentTable(name, () => scope.connection(), scope.dialect);
+  }
+
+  async find(where?: RawFilter, options?: RawFindOptions) {
+    await this.#scope.beat();
+    return await this.#raw.find(where, options);
+  }
+
+  async get(id: string) {
+    await this.#scope.beat();
+    return await this.#raw.get(id);
+  }
+
+  async count(where?: RawFilter, options?: Omit<RawFindOptions, "limit">) {
+    await this.#scope.beat();
+    return await this.#raw.count(where, options);
+  }
+
+  /** Returns whether anything changed: a value equal to the stored one is no change and is not logged. */
+  async set(id: string, patch: MigrationPatch) {
+    return await this.#write(id, (row) => this.#update(row, patch));
+  }
+
+  async unset(id: string, paths: string[]) {
+    return await this.set(id, Object.fromEntries(paths.map((path) => [path, undefined])));
+  }
+
+  /** A soft removal, as the model's own `remove` makes. */
+  async remove(id: string) {
+    return await this.#write(id, (row) => (row.removedAt === null ? this.#update(row, {}, this.#scope.now()) : false));
+  }
+
+  async restore(id: string) {
+    return await this.#write(id, (row) => (row.removedAt === null ? false : this.#update(row, {}, null)));
+  }
+
+  /** A new row; `doc` is its `_doc`, so `id` and the timestamps are not fields of it. */
+  async insert(
+    doc: Record<string, unknown>,
+    { id, removedAt = null }: { id?: string; removedAt?: number | null } = {},
+  ) {
+    this.#assertWritable();
+    const base = Object.keys(doc).find((key) => MigrationTable.#baseColumns.has(key));
+    if (base) throw new Error(`"${base}" is a column of ${this.name}, not a field of its _doc`);
+    return await this.#transaction(async () => await this.#insert(doc, id ?? this.#scope.createId(), removedAt));
+  }
+
+  /** A new row holding the source's `_doc` with `patch` applied, removed if the source is. */
+  async copy(id: string, patch: MigrationPatch = {}) {
+    this.#assertWritable();
+    return await this.#transaction(async () => {
+      const source = await this.#raw.get(id);
+      if (!source) throw new Error(`${this.name} ${id} does not exist`);
+      const doc = structuredClone(source._doc);
+      MigrationTable.#apply(doc, patch);
+      return await this.#insert(doc, this.#scope.createId(), source.removedAt);
+    });
+  }
+
+  /**
+   * `fn` sees each row in id order and returns a patch, or nothing to leave the row be. Outside a transaction every
+   * batch commits with where it got to, so a run cut short resumes there; `fn` must still skip rows it already fixed.
+   */
+  async rewrite(
+    fn: (row: TransferRow) => PromiseOrObject<MigrationPatch | null | undefined | false>,
+    { where, withRemoved = true, batchSize = this.#scope.batchSize }: MigrationRewriteOption = {},
+  ) {
+    this.#assertWritable();
+    MigrationScope.assertBatchSize(batchSize);
+    const signature = await descriptorHash({ where: where ?? null, withRemoved, fn: fn.toString() });
+    const { key, after: resumed } = this.#scope.nextRewrite(this.name, signature.slice(0, 12));
+    let after = resumed;
+    let scanned = 0;
+    let changed = 0;
+    for (;;) {
+      const rows = await this.#transaction(async () => {
+        const batch = await this.#raw.find(where, { after, limit: batchSize, withRemoved, lock: true });
+        for (const row of batch) {
+          scanned++;
+          const patch = await fn(structuredClone(row));
+          if (patch && (await this.#update(row, patch))) changed++;
+        }
+        const last = batch.at(-1);
+        if (last) await this.#scope.reach(key, last.id);
+        await this.#scope.beat();
+        return batch;
+      });
+      after = rows.at(-1)?.id ?? after;
+      if (rows.length < batchSize) break;
+    }
+    return { scanned, changed };
+  }
+
+  /**
+   * Undoes one logged change if the row still holds what the change wrote; a row already back where the change found
+   * it counts as undone, so a rollback cut short can run again.
+   */
+  async revert(change: MigrationChange): Promise<MigrationRevertOutcome> {
+    this.#assertWritable();
+    if (change.op === "delete") throw new Error("A rollback's own deletes are final; restore a backup to undo them");
+    return await this.#transaction(async () => {
+      const row = await this.#raw.get(change.id, { lock: true });
+      if (change.op === "insert") {
+        if (!row) return "reverted";
+        if (!MigrationTable.#holds(row, change.after)) return "changed";
+        await this.#raw.delete(row.id);
+        await this.#scope.log?.append({
+          table: this.name,
+          id: row.id,
+          op: "delete",
+          before: { $doc: [row._doc], $removedAt: [row.removedAt] },
+          after: {},
+        });
+        return "reverted";
+      }
+      if (!row) return "missing";
+      if (MigrationTable.#holds(row, change.before)) return "reverted";
+      if (!MigrationTable.#holds(row, change.after)) return "changed";
+      const { $removedAt, ...docSlots } = change.before;
+      const removedSlot: DocSlot | undefined = $removedAt;
+      const patch = Object.fromEntries(
+        Object.entries(docSlots).map(([path, slot]) => [path, slot.length ? slot[0] : undefined]),
+      );
+      try {
+        MigrationTable.#apply(structuredClone(row._doc), patch);
+      } catch {
+        return "changed";
+      }
+      await this.#update(row, patch, removedSlot ? ((removedSlot[0] ?? null) as number | null) : undefined);
+      return "reverted";
+    });
+  }
+
+  async #transaction<T>(fn: () => Promise<T>) {
+    await this.#scope.beat();
+    return await this.#scope.transaction(fn);
+  }
+
+  async #write(id: string, fn: (row: TransferRow) => Promise<boolean> | boolean) {
+    this.#assertWritable();
+    return await this.#transaction(async () => {
+      const row = await this.#raw.get(id, { lock: true });
+      if (!row) throw new Error(`${this.name} ${id} does not exist`);
+      return await fn(row);
+    });
+  }
+
+  async #update(row: TransferRow, patch: MigrationPatch, removedAt?: number | null) {
+    const paths = Object.keys(patch);
+    for (const path of paths) MigrationTable.#assertField(path);
+    DocPath.assertDisjoint(paths);
+    const doc = structuredClone(row._doc);
+    MigrationTable.#apply(doc, patch);
+    const before: Record<string, DocSlot> = {};
+    const after: Record<string, DocSlot> = {};
+    for (const anchor of DocPath.anchors(row._doc, paths)) {
+      const previous = DocPath.read(row._doc, anchor);
+      const next = DocPath.read(doc, anchor);
+      if (DocPath.same(previous, next)) continue;
+      before[anchor] = previous;
+      after[anchor] = next;
+    }
+    const nextRemovedAt = removedAt === undefined ? row.removedAt : removedAt;
+    if (nextRemovedAt !== row.removedAt) {
+      before.$removedAt = [row.removedAt];
+      after.$removedAt = [nextRemovedAt];
+    }
+    if (!Object.keys(after).length) return false;
+    await this.#raw.write(row.id, { _doc: doc, removedAt: nextRemovedAt });
+    await this.#scope.log?.append({ table: this.name, id: row.id, op: "update", before, after });
+    return true;
+  }
+
+  async #insert(doc: Record<string, unknown>, id: string, removedAt: number | null) {
+    const now = this.#scope.now();
+    const stored = (sanitizeJson(doc) ?? {}) as Record<string, unknown>;
+    await this.#raw.insert({ id, createdAt: now, updatedAt: now, removedAt, _doc: stored });
+    await this.#scope.log?.append({
+      table: this.name,
+      id,
+      op: "insert",
+      before: {},
+      after: { $doc: [stored], $removedAt: [removedAt] },
+    });
+    return id;
+  }
+
+  #assertWritable() {
+    if (this.#scope.readOnly) throw new Error(`plan and verify only read; ${this.name} is written in apply`);
+  }
+
+  static #apply(doc: Record<string, unknown>, patch: MigrationPatch) {
+    for (const [path, value] of Object.entries(patch)) {
+      MigrationTable.#assertField(path);
+      if (value === undefined) DocPath.remove(doc, path);
+      else DocPath.write(doc, path, value);
+    }
+  }
+
+  static #holds(row: TransferRow, slots: Record<string, DocSlot>) {
+    return Object.entries(slots).every(
+      ([path, slot]) =>
+        DocPath.same(MigrationTable.#slot(row, path), slot) &&
+        (slot.length > 0 || path.startsWith("$") || DocPath.hasParent(row._doc, path)),
+    );
+  }
+
+  static #slot(row: TransferRow, path: string): DocSlot {
+    if (path === "$removedAt") return [row.removedAt];
+    if (path === "$doc") return [row._doc];
+    return DocPath.read(row._doc, path);
+  }
+
+  static #assertField(path: string) {
+    const root = path.split(".")[0] ?? "";
+    if (MigrationTable.#baseColumns.has(root) || root.startsWith("$"))
+      throw new Error(`"${path}" is not a field of _doc; remove and restore set removedAt`);
+  }
+}

package/server/migration/migrations.ts

@@ -0,0 +1,57 @@
+import { Logger } from "akanjs/common";
+import { DatabaseAdaptorRole } from "akanjs/service";
+import type { AkanServer } from "../akanServer";
+import { AppInfo } from "../ops/appInfo";
+import {
+  type MigrationAction,
+  type MigrationArgs,
+  MigrationCommand,
+  type MigrationCommandResult,
+} from "./migrationCommand";
+import { MigrationError } from "./migrationError";
+import { type MigrationEntry, MigrationRunner } from "./migrationRunner";
+
+/** The migrations one build carries, as the generated `server.ts` lists them. */
+export class Migrations {
+  readonly entries: MigrationEntry[];
+
+  constructor(entries: MigrationEntry[]) {
+    this.entries = [...entries].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+  }
+
+  /** On a started server: the runner writes through its database adaptor. */
+  runner(server: AkanServer) {
+    return new MigrationRunner(this.entries, {
+      database: server.get(DatabaseAdaptorRole),
+      get: server.get.bind(server),
+      buildId: AppInfo.build().buildId,
+    });
+  }
+
+  /** Boots `server` with no listener or schedule, runs one action, and prints its result last. Returns the exit code. */
+  async command(server: AkanServer, argv: string[], invokedAs?: string) {
+    let json = MigrationCommand.jsonOf(argv);
+    let action: MigrationAction | null = null;
+    let result: MigrationCommandResult;
+    try {
+      const args = MigrationCommand.parse(argv, invokedAs);
+      ({ json, action } = args);
+      result = await this.#run(server, args);
+    } catch (error) {
+      result = MigrationCommand.failure(action, error);
+    }
+    return await MigrationCommand.print(result, json);
+  }
+
+  async #run(server: AkanServer, args: MigrationArgs) {
+    await server.start({ listen: false, web: false, schedules: false });
+    try {
+      return await MigrationCommand.run(this.runner(server), args);
+    } finally {
+      
+      await server.stop().catch((error: unknown) => {
+        new Logger("Migrations").error(`The server did not stop cleanly: ${MigrationError.messageOf(error)}`);
+      });
+    }
+  }
+}

package/server/ops/opsCommand.ts

@@ -1,23 +1,33 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { parseArgs } from "node:util";
+import type { AkanServer } from "../akanServer";
+import { MigrationCommand } from "../migration/migrationCommand";
+import type { Migrations } from "../migration/migrations";
 import { SnapshotRestore } from "./snapshotRestore";
 import type { SnapshotSources } from "./snapshotTypes";
 import { SqliteFiles } from "./sqliteFiles";
 import { SqliteSnapshot } from "./sqliteSnapshot";
 
+/** What `main.js` lends a command that needs the app itself: its server module, imported with a replica's env. */
+export interface OpsHost {
+  importServer(): Promise<{ server?: AkanServer; migrations?: Migrations }>;
+}
+
 export class OpsCommand {
   static readonly usage = [
     "Usage:",
     "  bun main.js ops snapshot [--id <id>] [--out <dir>] [--include-solid] [--db <file>] [--solid-db <file>] [--json]",
     "  bun main.js ops restore <manifest.json> [--identity <file>] [--db <file>] [--solid-db <file>] [--force]",
+    "  bun main.js ops migrate [list|plan|apply|verify|rollback] [<id>] [--param <name>=<value>]... [--expect <planHash>] [--items <n>] [--actor <id>] [--json]",
   ].join("\n");
 
-  static async run(argv: string[]): Promise<number> {
+  static async run(argv: string[], host?: OpsHost): Promise<number> {
     const [command, ...rest] = argv;
     try {
       if (command === "snapshot") return await OpsCommand.#snapshot(rest);
       if (command === "restore") return await OpsCommand.#restore(rest);
+      if (command === "migrate") return await OpsCommand.#migrate(rest, host);
       process.stderr.write(`${OpsCommand.usage}\n`);
       return 2;
     } catch (error) {
@@ -78,6 +88,25 @@ export class OpsCommand {
     return 0;
   }
 
+  static async #migrate(argv: string[], host?: OpsHost) {
+    let app: { server: AkanServer; migrations: Migrations };
+    try {
+      app = await OpsCommand.#migratingApp(host);
+    } catch (error) {
+      
+      return await MigrationCommand.print(MigrationCommand.failure(null, error), MigrationCommand.jsonOf(argv));
+    }
+    return await app.migrations.command(app.server, argv);
+  }
+
+  static async #migratingApp(host?: OpsHost) {
+    if (!host) throw new Error("migrate boots the app's server, so it runs through main.js");
+    const { server, migrations } = await host.importServer();
+    if (!server?.start) throw new Error("server.js must export server");
+    if (!migrations) throw new Error("this build lists no migrations; build it with an akan that writes the manifest");
+    return { server, migrations };
+  }
+
   static #sources(db?: string, solidDb?: string): SnapshotSources {
     const fromEnv = SqliteFiles.fromEnv();
     return {

package/server/resolver/CascadeRunner.ts

@@ -85,7 +85,7 @@ export class CascadeRunner {
 
   async #removeRef(edge: RefEdge, doc: Record<string, unknown>, seen: Set<string>) {
     const value = doc[edge.key];
-    const ids = (Array.isArray(value) ? value : [value]).filter(
+    const ids = [...new Set(Array.isArray(value) ? value : [value])].filter(
       (item): item is string => typeof item === "string" && !seen.has(`${edge.refName}:${item}`),
     );
     if (!ids.length) return;
@@ -94,8 +94,20 @@ export class CascadeRunner {
       await service.__removeMany({ id: documentQueryHelper.oneOf(ids) });
       return;
     }
+
+    const live = new Set<string>();
+    for (let start = 0; start < ids.length; start += drainSize) {
+      const chunk = ids.slice(start, start + drainSize);
+      for (const id of await service.__listIds({ id: documentQueryHelper.oneOf(chunk) })) live.add(id);
+    }
     
-    for (const id of ids) await service.__remove(id);
+    for (const id of ids) {
+      if (!live.has(id)) continue;
+      
+      if (seen.has(`${edge.refName}:${id}`)) continue;
+      seen.add(`${edge.refName}:${id}`);
+      await service.__remove(id);
+    }
   }
 
   async #removeWith(edge: WithEdge, ownerRef: string, ownerId: string, seen: Set<string>) {
@@ -112,6 +124,7 @@ export class CascadeRunner {
       let removed = 0;
       for (const id of ids) {
         if (seen.has(`${edge.refName}:${id}`)) continue;
+        seen.add(`${edge.refName}:${id}`);
         await service.__remove(id);
         removed += 1;
       }

package/server/resolver/signal.resolver.ts

@@ -10,11 +10,10 @@ import {
   ID,
   INTERNAL_META,
   Int,
-  PrimitiveRegistry,
   type PromiseOrObject,
   SLICE_META,
 } from "akanjs/base";
-import { capitalize, cookieHeaderHasAuthToken, Logger } from "akanjs/common";
+import { capitalize, Logger } from "akanjs/common";
 import {
   type ConstantField,
   deserialize,
@@ -23,8 +22,10 @@ import {
   resolvePageSkip,
   serialize,
 } from "akanjs/constant";
+import { DictionaryRegistry } from "akanjs/dictionary";
 import { baseDocumentColumns, documentQueryHelper, getFilterSortByKey, type QueryFieldMap } from "akanjs/document";
 import {
+  type AdaptorCls,
   type AkanJob,
   type AkanJobOptions,
   type DocumentStore,
@@ -36,8 +37,8 @@ import {
 } from "akanjs/service";
 import { websocketRoomContract } from "../../common/websocketContract";
 import { type Endpoint, type EndpointCls, sliceEndpoint } from "../../signal/endpoint";
+import { EndpointErrorContract } from "../../signal/endpointErrorContract";
 import type { EndpointInfo } from "../../signal/endpointInfo";
-import { EndpointRateLimit } from "../../signal/endpointRateLimit";
 import type { Internal, InternalCls } from "../../signal/internal";
 import { Machine } from "../../signal/internalArg";
 import type { InternalInfo } from "../../signal/internalInfo";
@@ -78,6 +79,7 @@ export class SignalResolver {
   static readonly #coalescingRooms = new Set<string>();
   static readonly #liveRoutes = new Map<string, { store: DocumentStore; route: LiveRoute }>();
   static readonly #everyRowAsked = new Set<string>();
+  static readonly #websockets = new WeakMap<InjectRegistry, { key: AdaptorCls; websocket: WebsocketAdaptor }>();
 
   static coalescesRoom(roomId: string): boolean {
     const separator = roomId.indexOf("-");
@@ -645,6 +647,7 @@ export class SignalResolver {
     const defaultPrefix = endpointCls.srv.cnst?.refName;
     SignalResolver.#warnUnguarded(endpointMeta);
     SignalResolver.#warnMachineKeyless(endpointMeta);
+    SignalResolver.#warnUndefinedErrors(endpointMeta);
     Object.entries(endpointMeta).forEach(([key, endpointInfo]) => {
       const path = endpointInfo.getRoutePath(key, defaultPrefix);
       if (endpointInfo.signalOption.globalPrefix !== undefined) {
@@ -669,32 +672,7 @@ export class SignalResolver {
         );
       switch (endpointInfo.type) {
         case "query":
-          SignalResolver.#mountHttpRoute(
-            routes,
-            path,
-            SignalResolver.#canUsePrimitiveQueryFastPath(key, endpointInfo, middleware)
-              ? {
-                  GET: async (req) => {
-                    if (req.headers.get("authorization") || cookieHeaderHasAuthToken(req.headers.get("cookie")))
-                      return await normalHttpHandler(req);
-                    
-                    return await SignalContext.try(
-                      endpoint,
-                      endpointInfo,
-                      key,
-                      async () => {
-                        const result = await endpointInfo.execFn?.call(endpoint);
-                        return result instanceof Response ? result : Response.json(result);
-                      },
-                      { trace: false },
-                    );
-                  },
-                }
-              : {
-                  GET: normalHttpHandler,
-                },
-            key,
-          );
+          SignalResolver.#mountHttpRoute(routes, path, { GET: normalHttpHandler }, key);
           break;
         case "mutation":
           SignalResolver.#mountHttpRoute(
@@ -826,6 +804,20 @@ export class SignalResolver {
       `${open.join(", ")} declare${open.length === 1 ? "s" : ""} no guards, so anyone can call ${open.length === 1 ? "it" : "them"} over HTTP and WebSocket. Name the guards, or \`guards: [Public]\` to keep one open on purpose.`,
     );
   }
+
+  static #warnUndefinedErrors(endpointMeta: { [key: string]: EndpointInfo }) {
+    const declared = Object.entries(endpointMeta).flatMap(([key, endpointInfo]) =>
+      EndpointErrorContract.keysOf(endpointInfo.signalOption.errors).map((errorKey) => `${key} → ${errorKey}`),
+    );
+    if (!declared.length) return;
+    const known = new Set(DictionaryRegistry.getKeys());
+    if (!known.size) return;
+    const undefinedKeys = declared.filter((entry) => !known.has(entry.split(" → ")[1] ?? ""));
+    if (!undefinedKeys.length) return;
+    SignalResolver.logger.warn(
+      `${undefinedKeys.join(", ")}: declared in \`errors\`, defined in no dictionary's \`.error({})\`. Add the key, or drop it from the declaration.`,
+    );
+  }
   static #warnMachineKeyless(endpointMeta: { [key: string]: EndpointInfo }) {
     if (MachineToken.canVerify()) return;
     const machineOnly = Object.entries(endpointMeta)
@@ -847,24 +839,6 @@ export class SignalResolver {
     return select;
   }
 
-  static #canUsePrimitiveQueryFastPath(
-    key: string,
-    endpointInfo: EndpointInfo,
-    middleware: Map<string, MiddlewareCls>,
-  ) {
-    return (
-      process.env.AKAN_TRACE !== "1" &&
-      !EndpointRateLimit.budgetOf(key, endpointInfo) &&
-      endpointInfo.args.length === 0 &&
-      endpointInfo.internalArgs.length === 0 &&
-      (endpointInfo.signalOption.guards?.length ?? 0) === 0 &&
-      (endpointInfo.signalOption.middlewares?.length ?? 0) === 0 &&
-      [...middleware.values()].every((MiddlewareCls) => MiddlewareCls.refName === "AccountMiddleware") &&
-      endpointInfo.returns.arrDepth === 0 &&
-      PrimitiveRegistry.has(endpointInfo.returns.returnRef as Cls)
-    );
-  }
-
   static async revalidateWsRooms(
     ws: Bun.ServerWebSocket<any>,
     registry: InjectRegistry,
@@ -912,17 +886,23 @@ export class SignalResolver {
     if ((live?.syncHub.roomCount ?? 0) < liveRooms) SignalResolver.#roomReplay?.forget(roomId);
     else SignalResolver.#roomReplay?.left(roomId);
   }
+
   static #getWebsocket(registry: InjectRegistry): WebsocketAdaptor {
+    const found = SignalResolver.#websockets.get(registry);
+    if (found && registry.adaptor.get(found.key) === (found.websocket as unknown)) return found.websocket;
+    const key = SignalResolver.#websocketKey(registry);
+    const websocket = key ? (registry.adaptor.get(key) as WebsocketAdaptor | undefined) : undefined;
+    if (!key || !websocket) throw new Error("WebSocket adaptor is not registered");
+    SignalResolver.#websockets.set(registry, { key, websocket });
+    return websocket;
+  }
+
+  static #websocketKey(registry: InjectRegistry): AdaptorCls | undefined {
+    if (registry.adaptor.has(WebsocketAdaptorRole)) return WebsocketAdaptorRole;
     const roleProvider = [...registry.adaptorRole.entries()].find(
       ([role]) => role.refName === WebsocketAdaptorRole.refName,
     )?.[1];
-    const websocket =
-      (registry.adaptor.get(WebsocketAdaptorRole) as WebsocketAdaptor | undefined) ??
-      (roleProvider ? (registry.adaptor.get(roleProvider) as WebsocketAdaptor | undefined) : undefined) ??
-      ([...registry.adaptor.entries()].find(([adaptorCls]) =>
-        ["solidPubsub", "wsRedis"].includes(adaptorCls.refName),
-      )?.[1] as WebsocketAdaptor | undefined);
-    if (!websocket) throw new Error("WebSocket adaptor is not registered");
-    return websocket;
+    if (roleProvider && registry.adaptor.has(roleProvider)) return roleProvider;
+    return [...registry.adaptor.keys()].find((adaptorCls) => ["solidPubsub", "wsRedis"].includes(adaptorCls.refName));
   }
 }

package/server/routeState.ts

@@ -27,8 +27,6 @@ export interface AkanRouterStateV1 {
   href: string;
   routeId: string;
   segments: AkanRouteSegmentState[];
-  /** The route's `.config({ transition })`, which the browser plays as a view transition on the way in and out. */
-  transition?: string;
 }
 
 export type AkanHeadSnapshotTag = "title" | "meta" | "link";
@@ -134,7 +132,6 @@ export function isAkanRouterStateV1(value: unknown): value is AkanRouterStateV1
     (state.buildId === undefined || typeof state.buildId === "number") &&
     typeof state.href === "string" &&
     typeof state.routeId === "string" &&
-    (state.transition === undefined || typeof state.transition === "string") &&
     Array.isArray(state.segments) &&
     state.segments.every(isSegmentState)
   );
@@ -210,12 +207,10 @@ export function createAkanRouterState({
   pathRoute,
   href,
   buildId,
-  transition,
 }: {
   pathRoute: PathRoute;
   href: string;
   buildId?: number;
-  transition?: string;
 }): AkanRouterStateV1 {
   return {
     version: AKAN_RSC_STATE_VERSION,
@@ -223,7 +218,6 @@ export function createAkanRouterState({
     href,
     routeId: pathRoute.path,
     segments: createAkanRouteSegments(pathRoute),
-    ...(transition && transition !== "none" ? { transition } : {}),
   };
 }