@roster-lock/match-agent 0.1.0

package/src/handle-room/version-1/globals/Room/WebsocketRoom.ts

@@ -0,0 +1,118 @@
+import { createSimpleEmitter, JSON_Unknown, handleFetch, delay } from "@roster-lock/utils";
+import { IRoom } from "./room";
+import { WebSocket } from "ws";
+import { once } from "events";
+
+type RelayConfig = {
+  url: string,
+  roomId: string,
+};
+
+type UserConfig = {
+  timestamp: number,
+  publicKey: string,
+  signature: string,
+};
+
+
+type User = {
+  userId: string,
+  publicKey: string,
+  displayName: string,
+};
+
+type WebSocketRoomState = (
+  | { state: "connecting" }
+  | { state: "connected", websocket: WebSocket, users: Array<User> }
+  | { state: "destroyed" }
+)
+
+export class WebsocketRoom implements IRoom {
+  private state: WebSocketRoomState = { state: "connecting" };
+  private relayURL: URL;
+  private connectPromise: Promise<void>;
+  constructor(
+    private relayConfig: RelayConfig,
+    userConfig: UserConfig,
+  ){
+    const url = new URL(relayConfig.url);
+    url.searchParams.set("room", userConfig.signature);
+    url.searchParams.set("t", userConfig.timestamp.toString());
+    url.searchParams.set("pk", userConfig.publicKey);
+    url.searchParams.set("sig", userConfig.signature);
+    this.relayURL = url;
+    this.connectPromise = this.setup();
+  }
+
+  get readyPromise(){
+    return this.connectPromise;
+  }
+
+  private async setup(){
+    const { relayURL: url } = this;
+    const wsURL = new URL(url);
+    wsURL.protocol = url.protocol === "https:" ? "wss:" : "ws";
+    wsURL.pathname = "/" + this.relayConfig.roomId;
+    const websocket = new WebSocket(wsURL.href);
+
+    const abortController = new AbortController();
+    const httpURL = new URL(url);
+    httpURL.pathname = "/" + this.relayConfig.roomId + "/users";
+
+    try {
+      const [users] = await Promise.race([
+        Promise.all([
+          handleFetch<Array<User>>(fetch(httpURL.href, { signal: abortController.signal })),
+          once(websocket, 'open'),
+        ]),
+        Promise.resolve().then(async ()=>{
+          await delay(10_000);
+          throw new Error("Timeout");
+        })
+      ]);
+      this.state = { state: "connected", websocket, users };
+    }catch(e){
+      abortController.abort();
+      websocket.close();
+      this.state = { state: "destroyed" };
+      throw e;
+    }
+  }
+
+  get numberOfUsers(){
+    if(this.state.state !== "connected") throw new Error("Not Connected");
+    return this.state.users.length;
+  }
+  listen = createSimpleEmitter()
+  async broadcast(event: string, data: JSON_Unknown){
+    if(this.state.state !== "connected") throw new Error("Not Connected");
+    await this.sendMessage({
+      type: event,
+      payload: data,
+    });
+  }
+  disconnect = ()=>{
+    if(this.state.state === "destroyed") return;
+    if(this.state.state === "connecting"){
+      this.state = { state: "destroyed" };
+      return;
+    }
+    const { websocket } = this.state;
+    websocket.close();
+    this.state = { state: "destroyed" };
+  }
+
+  private sendMessage(message: any){
+    return new Promise<void>((resolve, reject)=>{
+      if(this.state.state !== "connected") return reject(new Error("Not Connected"));
+      this.state.websocket.send(JSON.stringify(message), (error) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+}
+

package/src/handle-room/version-1/globals/Room/index.ts

@@ -0,0 +1,3 @@
+
+export { IRoom } from "./room";
+export * from "./WebsocketRoom";

package/src/handle-room/version-1/globals/Room/room.ts

@@ -0,0 +1,8 @@
+import { JSON_Unknown, ISimpleEventEmitter } from "@roster-lock/utils";
+
+export interface IRoom {
+  numberOfUsers: number
+  listen: ISimpleEventEmitter<[playerId: string, event: string, data: JSON_Unknown]>
+  broadcast: (event: string, data: JSON_Unknown)=>Promise<void>
+  disconnect: ()=>void
+}

package/src/handle-room/version-1/globals/index.ts

@@ -0,0 +1,4 @@
+
+export * from "./types";
+export * from "./FolderDB";
+export * from "./Room";

package/src/handle-room/version-1/globals/types.ts

@@ -0,0 +1,7 @@
+
+import { IFolderDB } from "./FolderDB";
+import { PluginManager } from "@roster-lock/plugin-runtime";
+export type V1Env = {
+  fileDB: IFolderDB,
+  pluginRuntime: PluginManager,
+}

package/src/handle-room/version-1/handleDownloads/DownloadTracker.ts

@@ -0,0 +1,98 @@
+import { RosterLockV1Config, SelectedPiece, PieceType, PieceId } from "@roster-lock/types";
+import { IFolderDB } from "../globals/FolderDB";
+import { ProgressHandlers } from "./types";
+
+import { DownloadResultsMap, DownloadResult } from "./types";
+import { ROSTERLOCK_DOWNLOAD_STATE } from "@roster-lock/types";
+
+export class PieceDownloadTracker {
+  private pieceTypes = new Map<PieceId, Map<PieceType, Promise<DownloadResult>>>();
+
+  constructor(
+    public database: IFolderDB,
+    public lockConfig: RosterLockV1Config,
+    public progressHandlers: ProgressHandlers,
+  ){}
+
+  public tryToDownloadAndNested(pieceType: PieceType, piece: SelectedPiece){
+    if(!this.isDownloadQueued(pieceType, piece.id)){
+      this.addNewDownload(
+        pieceType, piece.id,
+        tryToDownloadAnySource(this.database, this.lockConfig, pieceType, piece, this.progressHandlers)
+      );
+    }
+    // We don't skip required as different pieces may have different required pieces
+    for(const [requiredPieceType, requiredPieces] of Object.entries(piece.required)){
+      for(const requiredPiece of requiredPieces.mandatory){
+        this.tryToDownloadAndNested(requiredPieceType, requiredPiece);
+      }
+      for(const requiredPiece of requiredPieces.selectable){
+        this.tryToDownloadAndNested(requiredPieceType, requiredPiece);
+      }
+    }
+  }
+
+  private isDownloadQueued(pieceType: PieceType, pieceId: PieceId){
+    const pieces = this.pieceTypes.get(pieceType);
+    if(!pieces) return false;
+    return pieces.has(pieceId);
+  }
+  addNewDownload(pieceType: PieceType, pieceId: PieceId, promise: Promise<DownloadResult>){
+    if(!this.pieceTypes.has(pieceType)){
+      this.pieceTypes.set(pieceType, new Map());
+    }
+    this.pieceTypes.get(pieceType)!.set(pieceId, promise);
+  }
+  getDownloadPromises(){
+    return Array.from(this.pieceTypes.values()).flatMap(r=>Array.from(r.values()));
+  }
+
+  static resultsToMap(results: DownloadResult[]): DownloadResultsMap{
+    const typeMap: DownloadResultsMap = {};
+    for(const result of results){
+      const pieceMap: DownloadResultsMap[PieceType] = (()=>{
+        const map = typeMap[result.pieceType];
+        if(map) return map;
+        const newMap = {};
+        typeMap[result.pieceType] = newMap;
+        return newMap;
+      })();
+      pieceMap[result.pieceId] = result;
+    }
+    return typeMap;
+  }
+  
+}
+
+async function tryToDownloadAnySource(
+  db: IFolderDB,
+  lockconfig: RosterLockV1Config,
+  pieceType: string,
+  selectedPiece: SelectedPiece,
+  progressHandlers: ProgressHandlers
+): Promise<DownloadResult>{
+  const pieces = lockconfig.rosters[pieceType];
+  if(!pieces){
+    throw new Error(`Missing Roster for piece type ${pieceType}`);
+  }
+  const piece = pieces.find(p=>p.id === selectedPiece.id);
+  if(!piece){
+    throw new Error(`Missing Piece ${selectedPiece.id} for piece type ${pieceType}`);
+  }
+
+  const pieceVersions = { logic: piece.version.logic, media: piece.version.media };
+  progressHandlers.onProgress({
+    type: ROSTERLOCK_DOWNLOAD_STATE.downloadStart,
+    pieceType,
+    pieceVersions,
+  });
+  const folder = await db.ensurePieceExists(
+    lockconfig.engine, pieceType, piece, progressHandlers
+  );
+  progressHandlers.onProgress({
+    type: ROSTERLOCK_DOWNLOAD_STATE.downloadFinished,
+    pieceType,
+    pieceVersions,
+  });
+  return { pieceType, pieceId: selectedPiece.id, pieceVersions, folder };
+}

package/src/handle-room/version-1/handleDownloads/index.ts

@@ -0,0 +1,41 @@
+import { FinalSelection, RosterLockV1Config } from "@roster-lock/types";
+
+import { PieceDownloadTracker } from "./DownloadTracker";
+import { ROSTERLOCK_DOWNLOAD_STATE } from "@roster-lock/types";
+import { IFolderDB } from "../globals/FolderDB";
+import { ProgressHandlers, DownloadResultsMap } from "./types";
+
+export async function handleDownloads(
+  db: IFolderDB,
+  lockConfig: RosterLockV1Config,
+  finalSelection: FinalSelection,
+  progressHandlers: ProgressHandlers,
+): Promise<DownloadResultsMap> {
+  try {
+    const downloadTracker = new PieceDownloadTracker(db, lockConfig, progressHandlers);
+    for(const [pieceType, selection] of Object.entries(finalSelection)){
+      if(selection.type === "shared"){
+        for(const piece of selection.value){
+          downloadTracker.tryToDownloadAndNested(pieceType, piece);
+        }
+      }
+      if(selection.type === "personal"){
+        for(const pieces of Object.values(selection.value)){
+          for(const piece of pieces){
+            downloadTracker.tryToDownloadAndNested(pieceType, piece);
+          }
+        }
+      }
+    }
+    const results = await Promise.all(downloadTracker.getDownloadPromises());
+    progressHandlers.onProgress({ type: ROSTERLOCK_DOWNLOAD_STATE.downloadAllComplete });
+    return PieceDownloadTracker.resultsToMap(results);
+  }catch(e){
+    progressHandlers.onProgress({
+      type: ROSTERLOCK_DOWNLOAD_STATE.downloadFullFailure,
+      error: (e as Error).message,
+    });
+    throw e;
+  }
+}
+

package/src/handle-room/version-1/handleDownloads/types.ts

@@ -0,0 +1,9 @@
+
+import { RosterLockDownloadUpdate } from "@roster-lock/types";
+
+export type ProgressHandlers = {
+  onProgress: (update: RosterLockDownloadUpdate) => void;
+  abortSignal: AbortSignal;
+}
+
+export { DownloadResult, DownloadResultsMap } from "@roster-lock/types";

package/src/handle-room/version-1/handleRoomSelections/encryption.ts

@@ -0,0 +1,29 @@
+
+import { JSON_Unknown, ENCRYPT_SYMMETRIC, SymmetricEncryptionKey } from "@roster-lock/utils";
+
+import { JSONSchemaType } from "ajv";
+
+export const encryptedSchema: JSONSchemaType<string> = {
+  type: "string",
+};
+
+
+export async function encryptJSON(
+  originalValue: JSON_Unknown
+): Promise<{ key: SymmetricEncryptionKey, encryptedValue: string }> {
+  const key = await ENCRYPT_SYMMETRIC.generateKey();
+  const encryptedValue = await ENCRYPT_SYMMETRIC.encryptValue(key, originalValue);
+  return {
+    key: key,
+    encryptedValue: encryptedValue
+  };
+}
+
+
+export async function decryptJSON(
+  keyString: string, encryptedValue: string
+): Promise<JSON_Unknown> {
+  return await ENCRYPT_SYMMETRIC.decryptValue(
+    keyString as SymmetricEncryptionKey, encryptedValue
+  ) as JSON_Unknown;
+}

package/src/handle-room/version-1/handleRoomSelections/random.ts

@@ -0,0 +1,9 @@
+
+export function createRandomSeed(){
+  const array = new Uint8Array(16); // 16 bytes = 128 bits = 32 hex characters
+  crypto.getRandomValues(array);
+  const randHex = Array.from(array)
+    .map(b => b.toString(16).padStart(2, "0"))
+    .join(""); // 32-character hex string
+  return randHex;
+}

package/src/handle-room/version-1/index.ts

@@ -0,0 +1,33 @@
+import { HTTPRouter } from "../../utils/http-router";
+import { WebSocketRouter } from "../../utils/websocket-router";
+
+import { wsHandler } from "./room-handler-bridge/ws-handler";
+import { httpHandler } from "./room-handler-bridge/http-handler";
+
+import { getFilesOfAsset, getPieceFileContents } from "./file-routes";
+import { ensurePieceDownloaded, ensurePieceDownloadedWs, listDownloadedPiecesDirect } from "./select";
+import { listAvailableSortPlugins, sortListPlugin, gameComplete } from "./piece-sort";
+import { IFolderDB, V1Env } from "./globals";
+import { PluginManager } from "@roster-lock/plugin-runtime";
+
+export const createV1Routers = (fileDB: IFolderDB, pluginRuntime: PluginManager)=>{
+  const env: V1Env = { fileDB, pluginRuntime };
+  const httpRouter = new HTTPRouter();
+  const wsRouter = new WebSocketRouter()
+
+  httpRouter.post("/sync-dl", httpHandler.bind(env));
+  httpRouter.put("/piece", ensurePieceDownloaded.bind(env))
+  httpRouter.post("/piece/asset-files", getFilesOfAsset.bind(env));
+  httpRouter.post("/piece/file-contents", getPieceFileContents.bind(env));
+  httpRouter.query("/piece/list-downloaded/direct", listDownloadedPiecesDirect.bind(env));
+  httpRouter.get("/piece/sort-list/available", listAvailableSortPlugins.bind(env));
+  httpRouter.post("/piece/sort-list/plugin/:pluginName", sortListPlugin.bind(env));
+  httpRouter.post("/game-complete", gameComplete.bind(env));
+
+
+  wsRouter.mount("/sync-dl", wsHandler.bind(env));
+  wsRouter.mount("/piece/ensure", ensurePieceDownloadedWs.bind(env));
+
+  return { httpRouter, wsRouter };
+}
+

package/src/handle-room/version-1/piece-sort.ts

@@ -0,0 +1,96 @@
+
+import { RosterLockV1Config, UserSelection } from "@roster-lock/types";
+import { ROSTERLOCK_V1_CASTER_JSONSCHEMA } from "@roster-lock/shared";
+import { jsonBody, HTTPRequestHandler, HTTPError } from "../../utils/http-router";
+import { UserSelectionSchema } from "./schema/selected";
+import { V1Env } from "./globals/types";
+import z, { ZodType } from "zod";
+
+function castLockConfig(uncasted: unknown): RosterLockV1Config {
+  const casted = ROSTERLOCK_V1_CASTER_JSONSCHEMA.safeCast(uncasted, true);
+  if(!casted.valid) throw new HTTPError(400, "Invalid lockConfig", casted.error);
+  return casted.value;
+}
+
+// The plugin only knows how to rank pieces it has stats for - it may return a
+// partial ranking (or none at all). This reorders the caller's own candidate
+// list to match that ranking, appending anything the plugin didn't rank (in
+// its original order) at the end, so the response always covers every id the
+// caller asked about.
+function reorderByRanking(candidateIds: Array<string>, ranked: Array<string>): Array<string> {
+  const candidateSet = new Set(candidateIds);
+  const rankedFiltered = ranked.filter((id)=>candidateSet.has(id));
+  const rankedSet = new Set(rankedFiltered);
+  const leftover = candidateIds.filter((id)=>!rankedSet.has(id));
+  return [...rankedFiltered, ...leftover];
+}
+
+export const listAvailableSortPlugins: HTTPRequestHandler = async function(
+  this: V1Env, { res }
+){
+  const available = await this.pluginRuntime.pieceSort.listAvailable();
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(available));
+}
+
+type SortListBody = {
+  lockConfig: unknown,
+  pieceType: string,
+  logicIds: Array<string>,
+}
+
+const sortListBodySchema: ZodType<SortListBody> = z.object({
+  lockConfig: z.unknown(),
+  pieceType: z.string(),
+  logicIds: z.array(z.string()),
+}).strict();
+
+export const sortListPlugin: HTTPRequestHandler = async function(
+  this: V1Env, { req, res }, routeInfo
+){
+  const pluginName = routeInfo.params.pluginName;
+  if(!pluginName) throw new HTTPError(400, "Missing pluginName");
+
+  const body = await jsonBody(req);
+  const parseResult = sortListBodySchema.safeParse(body);
+  if(!parseResult.success) throw new HTTPError(400, "Bad Form", parseResult.error);
+  const { pieceType, logicIds } = parseResult.data;
+  const lockConfig = castLockConfig(parseResult.data.lockConfig);
+
+  const ranked = await this.pluginRuntime.pieceSort.sortPieces(pluginName, { lockConfig, pieceType });
+  const result = reorderByRanking(logicIds, ranked);
+
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(result));
+}
+
+type GameCompleteBody = {
+  lockConfig: unknown,
+  localUsers: Array<string>,
+  userSelections: Record<string, UserSelection>,
+  winners: Array<string>,
+}
+
+const gameCompleteBodySchema: ZodType<GameCompleteBody> = z.object({
+  lockConfig: z.unknown(),
+  localUsers: z.array(z.string()),
+  userSelections: z.record(z.string(), UserSelectionSchema),
+  winners: z.array(z.string()),
+}).strict();
+
+export const gameComplete: HTTPRequestHandler = async function(
+  this: V1Env, { req, res }
+){
+  const body = await jsonBody(req);
+  const parseResult = gameCompleteBodySchema.safeParse(body);
+  if(!parseResult.success) throw new HTTPError(400, "Bad Form", parseResult.error);
+  const { localUsers, userSelections, winners } = parseResult.data;
+  const lockConfig = castLockConfig(parseResult.data.lockConfig);
+
+  await this.pluginRuntime.pieceSort.handleGameComplete({
+    lockConfig, localUsers, userSelections, winners,
+  });
+
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ ok: true }));
+}

package/src/handle-room/version-1/room-handler-bridge/exchange-and-download-selections.ts

@@ -0,0 +1,125 @@
+
+import { WebSocket } from "ws";
+import { MessageBridge, handleFetch } from "@roster-lock/utils";
+import { bindStepsToBridge, ProgressListeners } from "./steps";
+import { RosterLockV1Config, RosterLockV1SyncDLRequestClientToAgent } from "@roster-lock/types";
+import { ROSTERLOCK_V1_CASTER_JSONSCHEMA } from "@roster-lock/shared";
+import { UserSelectionSchema } from "../schema/selected";
+import { IFolderDB } from "../globals/FolderDB";
+import { once } from "events";
+import z, { ZodType } from "zod";
+import { PluginManager } from "@roster-lock/plugin-runtime";
+
+const RequestCaster: ZodType<(
+  & RosterLockV1SyncDLRequestClientToAgent
+  & { rosterConfig: any }
+)> = z.object({
+  relay: z.object({
+    url: z.string(),
+    roomId: z.string(),
+  }),
+  machine: z.object({
+    timestamp: z.number(),
+    publicKey: z.string(),
+    signature: z.string(),
+  }),
+  rosterConfig: z.any(),
+  // Record<number, UserSelection> at the type level, but JSON object keys
+  // are always strings on the wire - validate them as such.
+  playerSelections: z.record(z.string(), UserSelectionSchema),
+}).strict();
+
+export function castRoomRequest(uncasted: unknown): RosterLockV1SyncDLRequestClientToAgent {
+  const parsed = RequestCaster.safeParse(uncasted);
+  if(!parsed.success) throw new Error("Invalid request");
+  const roomRequest = parsed.data;
+  const config = ROSTERLOCK_V1_CASTER_JSONSCHEMA.cast(roomRequest.rosterConfig, true);
+  const casted = {
+    ...roomRequest,
+    rosterConfig: config,
+  };
+  return casted;
+}
+
+type Machine = {
+  userId: string,
+  publicKey: string,
+  displayName: string,
+  playerCount: number,
+};
+
+export async function exchangeAndDownloadSelections(
+  fileDB: IFolderDB,
+  pluginRuntime: PluginManager,
+  roomRequest: RosterLockV1SyncDLRequestClientToAgent,
+  progressListeners: ProgressListeners = {}
+){
+  const roomURL = prepareRelayURL(roomRequest);
+
+  const httpURL = new URL(roomURL);
+  httpURL.pathname = "/api/v1/room/" + roomRequest.relay.roomId + "/machines";
+  const machines = await handleFetch<Array<Machine>>(fetch(httpURL.href));
+
+  const wsURL = new URL(roomURL);
+  wsURL.protocol = roomURL.protocol === "https:" ? "wss:" : "ws:";
+  wsURL.pathname = "/api/v1/room/" + roomRequest.relay.roomId;
+  // perMessageDeflate disabled: workerd's hibernatable WebSocket (relay-server,
+  // local wrangler dev) mishandles fragmented/compressed frames for larger
+  // messages, corrupting frame parsing on the "ws" client (surfaces as
+  // "Invalid WebSocket frame: invalid payload length").
+  const roomWebSocket = new WebSocket(wsURL.href, { perMessageDeflate: false });
+  const roomBridge = new MessageBridge((message)=>roomWebSocket.send(JSON.stringify(message)));
+  roomWebSocket.on("message", (message)=>{
+    roomBridge.handleMessage(JSON.parse(message.toString()));
+  });
+  roomWebSocket.on("error", (err)=>{
+    // An unhandled "error" event on an EventEmitter throws and crashes the
+    // whole process - and one match-agent process serves many concurrent
+    // games, so a single room's socket hiccup must not take the rest down.
+    console.error("room websocket error", err);
+  });
+
+  const roomPromise = bindStepsToBridge({
+    bridge: roomBridge,
+    fileDB,
+    pluginRuntime,
+    machines: machines.map(machine=>({ publicKey: machine.publicKey, playerCount: machine.playerCount })),
+    ownMachinePublicKey: roomRequest.machine.publicKey,
+    ownSelections: roomRequest.playerSelections,
+    lockConfig: roomRequest.rosterConfig,
+    gameControlledSelections: {},
+  }, progressListeners);
+
+  // The relay closes the room websocket with a close reason as soon as it fails
+  // a room (e.g. a download failure on the other user's leg), but never sends a
+  // bridge-level "error" event - so without this, bindStepsToBridge's onEvent("error")
+  // handler never fires and the room hangs until its own 30s heartbeat times out,
+  // surfacing a misleading "Heartbeat Timeout" instead of the real failure reason.
+  const closedEarly = new Promise<never>((_, reject)=>{
+    roomWebSocket.on("close", (code, reason)=>{
+      const reasonText = reason.toString();
+      reject(new Error(reasonText || `Room websocket closed unexpectedly (code ${code})`));
+    });
+  });
+  // roomPromise usually wins the race (success or a bridge-level "error" event),
+  // in which case this rejection is never observed - swallow it here so that
+  // doesn't crash the process as an unhandled rejection.
+  closedEarly.catch(()=>{});
+
+  try {
+    await once(roomWebSocket, 'open')
+    return await Promise.race([roomPromise, closedEarly]);
+  } finally {
+    roomWebSocket.close();
+  }
+}
+
+function prepareRelayURL({ relay, machine }: RosterLockV1SyncDLRequestClientToAgent){
+  const url = new URL(relay.url);
+  url.searchParams.set("room", relay.roomId);
+  url.searchParams.set("t", machine.timestamp.toString());
+  url.searchParams.set("pk", machine.publicKey);
+  url.searchParams.set("sig", machine.signature);
+  return url;
+}
+

package/src/handle-room/version-1/room-handler-bridge/http-handler.ts

@@ -0,0 +1,16 @@
+
+import { jsonBody, HTTPRequestHandler } from "../../../utils/http-router";
+import { castRoomRequest, exchangeAndDownloadSelections } from "./exchange-and-download-selections";
+import { V1Env } from "../globals/types";
+
+export const httpHandler: HTTPRequestHandler = async function(this: V1Env, { req, res }, params, next){
+  try {
+    const body = await jsonBody(req);
+    const roomRequest = castRoomRequest(body);
+    const results = await exchangeAndDownloadSelections(this.fileDB, this.pluginRuntime, roomRequest);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(results));
+  }catch(e){
+    next(e);
+  }
+}