@replit/river 0.200.0-rc.1 → 0.200.0-rc.3

package/dist/{chunk-45HIR2AS.js → chunk-UIYGPURD.js}

@@ -1,15 +1,19 @@
 import {
   ControlMessageCloseSchema,
   ControlMessagePayloadSchema,
+  abortMessage,
+  closeStreamMessage,
   coerceErrorString,
   createHandlerSpan,
   createProcTelemetryInfo,
+  generateId,
   getPropagationContext,
   isStreamAbort,
   isStreamClose,
   isStreamCloseRequest,
-  isStreamOpen
-} from "./chunk-XLXRFSRB.js";
+  isStreamOpen,
+  requestCloseStreamMessage
+} from "./chunk-3CCOX55A.js";
 
 // router/services.ts
 import { Type } from "@sinclair/typebox";
@@ -213,468 +217,6 @@ var ServiceScaffold = class {
   }
 };
 
-// router/diff.ts
-function diffServerSchema(oldServer, newServer, options) {
-  const allServices = /* @__PURE__ */ new Set([
-    ...Object.keys(oldServer.services),
-    ...Object.keys(newServer.services)
-  ]);
-  const breakages = {};
-  for (const serviceName of allServices) {
-    const oldService = oldServer.services[serviceName];
-    const newService = newServer.services[serviceName];
-    const breakage = diffService(oldService, newService, options);
-    if (breakage) {
-      breakages[serviceName] = breakage;
-    }
-  }
-  if (Object.keys(breakages).length) {
-    return { serviceBreakages: breakages };
-  }
-  return null;
-}
-function diffService(oldService, newService, options) {
-  if (!newService) {
-    return options?.allowServiceRemoval ? null : { reason: "removed" };
-  }
-  if (!oldService) {
-    return null;
-  }
-  const allProcedures = /* @__PURE__ */ new Set([
-    ...Object.keys(oldService.procedures),
-    ...Object.keys(newService.procedures)
-  ]);
-  const breakages = {};
-  for (const procedureName of allProcedures) {
-    const aProcedure = oldService.procedures[procedureName];
-    const bProcedure = newService.procedures[procedureName];
-    const breakage = diffProcedure(aProcedure, bProcedure, options);
-    if (breakage) {
-      breakages[procedureName] = breakage;
-    }
-  }
-  if (Object.keys(breakages).length) {
-    return { reason: "modified", procedureBreakages: breakages };
-  }
-  return null;
-}
-function diffProcedure(oldProcedure, newProcedure, options) {
-  if (!newProcedure) {
-    return options?.allowProcedureRemoval ? null : { reason: "removed" };
-  }
-  if (!oldProcedure) {
-    return null;
-  }
-  if (oldProcedure.type !== newProcedure.type) {
-    return {
-      reason: "type-changed",
-      oldType: oldProcedure.type,
-      newType: newProcedure.type
-    };
-  }
-  const inputBreakage = diffProcedureField(
-    oldProcedure.input,
-    newProcedure.input,
-    "client"
-  );
-  const initBreakage = diffProcedureField(
-    oldProcedure.init,
-    newProcedure.init,
-    "client"
-  );
-  const outputBreakage = diffProcedureField(
-    oldProcedure.output,
-    newProcedure.output,
-    "server"
-  );
-  if (inputBreakage ?? initBreakage ?? outputBreakage) {
-    const result = {
-      reason: "modified"
-    };
-    if (inputBreakage) {
-      result.input = inputBreakage;
-    }
-    if (initBreakage) {
-      result.init = initBreakage;
-    }
-    if (outputBreakage) {
-      result.output = outputBreakage;
-    }
-    return result;
-  }
-  return null;
-}
-function diffProcedureField(oldSchema, newSchema, origin) {
-  if (!oldSchema && !newSchema) {
-    return null;
-  }
-  const diffBreakage = diffRequired(oldSchema, newSchema, origin, false, false);
-  if (diffBreakage) {
-    return diffBreakage;
-  }
-  if (!oldSchema || !newSchema) {
-    throw new Error("Appease typescript, this should never happen");
-  }
-  return diffJSONSchema(oldSchema, newSchema, origin);
-}
-function diffRequired(oldSchema, newSchema, origin, oldRequired, newRequired) {
-  if (!newSchema && !oldSchema) {
-    throw new Error("Both old and new schema are undefined");
-  }
-  if (!newSchema) {
-    if (!oldRequired && origin == "server") {
-      return null;
-    }
-    return { reason: "removed-required" };
-  }
-  if (!oldSchema) {
-    if (newRequired && origin === "client") {
-      return { reason: "new-required" };
-    }
-    return null;
-  }
-  if (origin === "client" && !oldRequired && newRequired) {
-    return { reason: "new-required" };
-  }
-  if (origin === "server" && oldRequired && !newRequired) {
-    return { reason: "removed-required" };
-  }
-  return null;
-}
-function diffJSONSchema(oldSchema, newSchema, origin) {
-  if (oldSchema.type !== newSchema.type) {
-    return {
-      reason: "type-changed",
-      oldType: getReportingType(oldSchema),
-      newType: getReportingType(newSchema)
-    };
-  }
-  if (getReportingType(oldSchema) !== getReportingType(newSchema)) {
-    return {
-      reason: "type-changed",
-      oldType: getReportingType(oldSchema),
-      newType: getReportingType(newSchema)
-    };
-  }
-  if ("const" in oldSchema && "const" in newSchema && oldSchema.const !== newSchema.const) {
-    return {
-      reason: "type-changed",
-      oldType: `${getReportingType(oldSchema)}-const-${oldSchema.const}`,
-      newType: `${getReportingType(newSchema)}-const-${newSchema.const}`
-    };
-  }
-  if ("const" in oldSchema && !("const" in newSchema) && origin === "server") {
-    return {
-      reason: "type-changed",
-      oldType: `${getReportingType(oldSchema)}-const-${oldSchema.const}`,
-      newType: getReportingType(newSchema)
-    };
-  }
-  if ("const" in newSchema && !("const" in oldSchema) && origin === "client") {
-    return {
-      reason: "type-changed",
-      oldType: getReportingType(oldSchema),
-      newType: `${getReportingType(newSchema)}-const-${newSchema.const}`
-    };
-  }
-  const breakages = {};
-  if ("$ref" in newSchema) {
-    if (newSchema.$ref !== oldSchema.$ref) {
-      return {
-        reason: "type-changed",
-        oldType: getReportingType(oldSchema),
-        newType: getReportingType(newSchema)
-      };
-    }
-  } else if ("not" in newSchema) {
-    const notBreakage = diffJSONSchema(
-      oldSchema.not,
-      newSchema.not,
-      origin
-    );
-    if (notBreakage) {
-      breakages.not = notBreakage;
-    }
-  } else if ("anyOf" in newSchema) {
-    const oldAnyOfStringified = oldSchema.anyOf.map((el) => JSON.stringify(el)).sort();
-    const newAnyOfStringified = newSchema.anyOf.map((el) => JSON.stringify(el)).sort();
-    const anyOfBreakages = {};
-    for (let i = 0; i < oldAnyOfStringified.length; i++) {
-      if (newAnyOfStringified.includes(oldAnyOfStringified[i])) {
-        continue;
-      }
-      if (!newAnyOfStringified[i]) {
-        if (origin === "server") {
-          continue;
-        }
-        anyOfBreakages[`old-${i}`] = { reason: "removed-required" };
-      } else {
-        const breakage = diffJSONSchema(
-          JSON.parse(oldAnyOfStringified[i]),
-          JSON.parse(newAnyOfStringified[i]),
-          origin
-        );
-        if (breakage) {
-          anyOfBreakages[`old-${i}`] = breakage;
-        }
-      }
-    }
-    for (let i = 0; i < newAnyOfStringified.length; i++) {
-      if (oldAnyOfStringified.includes(newAnyOfStringified[i])) {
-        continue;
-      }
-      if (!oldAnyOfStringified[i]) {
-        if (origin === "client") {
-          continue;
-        }
-        anyOfBreakages[`new-${i}`] = { reason: "new-required" };
-      } else {
-        const breakage = diffJSONSchema(
-          JSON.parse(oldAnyOfStringified[i]),
-          JSON.parse(newAnyOfStringified[i]),
-          origin
-        );
-        if (breakage) {
-          anyOfBreakages[`new-${i}`] = breakage;
-        }
-      }
-    }
-    if (Object.keys(anyOfBreakages).length > 0) {
-      breakages.anyOf = {
-        reason: "field-breakage",
-        fieldBreakages: anyOfBreakages
-      };
-    }
-  } else if ("oneOf" in newSchema) {
-    throw new Error("oneOf is not supported, typebox does not emit it");
-  } else if ("allOf" in newSchema) {
-    if (newSchema.allOf.length !== oldSchema.allOf.length) {
-      breakages.allOf = {
-        reason: "type-changed",
-        oldType: `${oldSchema.allOf}`,
-        newType: `${newSchema.allOf}`
-      };
-    } else {
-      for (let i = 0; i < newSchema.allOf.length; i++) {
-        const breakage = diffJSONSchema(
-          oldSchema.allOf[i],
-          newSchema.allOf[i],
-          origin
-        );
-        if (breakage) {
-          breakages.allOf = breakage;
-          break;
-        }
-      }
-    }
-  } else if (newSchema.type === "array") {
-    const itemsBreakages = diffJSONSchema(
-      oldSchema.items,
-      newSchema.items,
-      origin
-    );
-    if (itemsBreakages) {
-      breakages.items = itemsBreakages;
-    }
-    if (oldSchema.minItems < newSchema.minItems) {
-      if (origin === "client") {
-        breakages.minItems = {
-          reason: "type-changed",
-          oldType: `${oldSchema.minItems}`,
-          newType: `${newSchema.minItems}`
-        };
-      }
-    } else if (oldSchema.minItems > newSchema.minItems) {
-      if (origin === "server") {
-        breakages.minItems = {
-          reason: "type-changed",
-          oldType: `${oldSchema.minItems}`,
-          newType: `${newSchema.minItems}`
-        };
-      }
-    }
-    if (oldSchema.maxItems < newSchema.maxItems) {
-      if (origin === "server") {
-        breakages.maxItems = {
-          reason: "type-changed",
-          oldType: `${oldSchema.maxItems}`,
-          newType: `${newSchema.maxItems}`
-        };
-      }
-    } else if (oldSchema.maxItems > newSchema.maxItems) {
-      if (origin === "client") {
-        breakages.maxItems = {
-          reason: "type-changed",
-          oldType: `${oldSchema.maxItems}`,
-          newType: `${newSchema.maxItems}`
-        };
-      }
-    }
-    if (!oldSchema.uniqueItems && newSchema.uniqueItems && origin === "client") {
-      breakages.uniqueItems = {
-        reason: "type-changed",
-        oldType: `${!!oldSchema.uniqueItems}`,
-        newType: `${!!newSchema.uniqueItems}`
-      };
-    }
-    if ("contains" in newSchema !== "contains" in oldSchema) {
-      if ("contains" in newSchema && !("contains" in oldSchema) && origin === "client") {
-        breakages.contains = {
-          reason: "type-changed",
-          oldType: "no-contains",
-          newType: "contains"
-        };
-      }
-    } else if ("contains" in newSchema) {
-      const containsBreakage = diffJSONSchema(
-        oldSchema.contains,
-        newSchema.contains,
-        origin
-      );
-      if (containsBreakage) {
-        breakages.contains = containsBreakage;
-      }
-    }
-    if (oldSchema.minContains < newSchema.minContains) {
-      if (origin === "client") {
-        breakages.minContains = {
-          reason: "type-changed",
-          oldType: `${oldSchema.minContains}`,
-          newType: `${newSchema.minContains}`
-        };
-      }
-    } else if (oldSchema.minContains > newSchema.minContains) {
-      if (origin === "server") {
-        breakages.minContains = {
-          reason: "type-changed",
-          oldType: `${oldSchema.minContains}`,
-          newType: `${newSchema.minContains}`
-        };
-      }
-    }
-    if (oldSchema.maxContains < newSchema.maxContains) {
-      if (origin === "server") {
-        breakages.maxContains = {
-          reason: "type-changed",
-          oldType: `${oldSchema.maxContains}`,
-          newType: `${newSchema.maxContains}`
-        };
-      }
-    } else if (oldSchema.maxContains > newSchema.maxContains) {
-      if (origin === "client") {
-        breakages.maxContains = {
-          reason: "type-changed",
-          oldType: `${oldSchema.maxContains}`,
-          newType: `${newSchema.maxContains}`
-        };
-      }
-    }
-  } else if (newSchema.type === "object") {
-    if ("properties" in newSchema !== "properties" in oldSchema) {
-      return {
-        reason: "type-changed",
-        oldType: "properties" in oldSchema ? "probably-object" : "probably-record",
-        newType: "properties" in newSchema ? "probably-object" : "probably-record"
-      };
-    }
-    if ("properties" in newSchema) {
-      const propertiesBreakages = diffObjectProperties(
-        oldSchema.properties,
-        newSchema.properties,
-        origin,
-        oldSchema.required,
-        newSchema.required
-      );
-      if (Object.keys(propertiesBreakages).length) {
-        breakages.properties = {
-          reason: "field-breakage",
-          fieldBreakages: propertiesBreakages
-        };
-      }
-    }
-    if ("patternProperties" in newSchema) {
-      const patternPropertiesBreakages = diffObjectProperties(
-        oldSchema.patternProperties,
-        newSchema.patternProperties,
-        origin,
-        oldSchema.required,
-        newSchema.required
-      );
-      if (Object.keys(patternPropertiesBreakages).length) {
-        breakages.patternProperties = {
-          reason: "field-breakage",
-          fieldBreakages: patternPropertiesBreakages
-        };
-      }
-    }
-    if ("additionalProperties" in newSchema || "additionalProperties" in oldSchema) {
-      throw new Error("additionalProperties is not supported");
-    }
-    if ("minProperties" in newSchema || "minProperties" in oldSchema) {
-      throw new Error("minProperties is not supported");
-    }
-    if ("maxProperties" in newSchema || "maxProperties" in oldSchema) {
-      throw new Error("maxProperties is not supported");
-    }
-  }
-  if (Object.keys(breakages).length) {
-    return {
-      reason: "field-breakage",
-      fieldBreakages: breakages
-    };
-  }
-  return null;
-}
-function diffObjectProperties(oldProperties, newProperties, origin, oldRequiredProperties = [], newRequiredProperties = []) {
-  const allProperties = /* @__PURE__ */ new Set([
-    ...Object.keys(oldProperties),
-    ...Object.keys(newProperties)
-  ]);
-  const breakages = {};
-  for (const propertyName of allProperties) {
-    const requiredBreakage = diffRequired(
-      oldProperties[propertyName],
-      newProperties[propertyName],
-      origin,
-      oldRequiredProperties.includes(propertyName),
-      newRequiredProperties.includes(propertyName)
-    );
-    if (requiredBreakage) {
-      breakages[propertyName] = requiredBreakage;
-    } else if (oldProperties[propertyName] && newProperties[propertyName]) {
-      const propertyBreakage = diffJSONSchema(
-        oldProperties[propertyName],
-        newProperties[propertyName],
-        origin
-      );
-      if (propertyBreakage) {
-        breakages[propertyName] = propertyBreakage;
-      }
-    }
-  }
-  return breakages;
-}
-function getReportingType(schema) {
-  if ("not" in schema) {
-    return "not";
-  }
-  if ("anyOf" in schema) {
-    return "anyOf";
-  }
-  if ("allOf" in schema) {
-    return "allOf";
-  }
-  if ("$ref" in schema) {
-    return "$ref";
-  }
-  if (schema.type && typeof schema.type === "string") {
-    return schema.type;
-  }
-  throw new Error(
-    "Subschema not supported, probably a conditional subschema. Check logs."
-  );
-}
-
 // router/result.ts
 import {
   Type as Type2
@@ -900,26 +442,26 @@ var WriteStreamImpl = class {
    * Passed via constructor to pass on write requests
    */
   writeCb;
-  /**
-   * Passed via constructor to pass on close requests
-   */
-  closeCb;
   /**
    * Whether the stream is closed.
    */
   closed = false;
+  /**
+   * A list of listeners that will be called when the stream is closed.
+   */
+  onCloseListeners;
   /**
    * Whether the reader has requested to close the stream.
    */
   closeRequested = false;
   /**
-   * A list of listeners that will be called when the stream is closed.
+   * A list of listeners that will be called when a close request is triggered.
    */
-  onCloseListeners;
-  constructor(writeCb, closeCb) {
+  onCloseRequestListeners;
+  constructor(writeCb) {
     this.writeCb = writeCb;
-    this.closeCb = closeCb;
     this.onCloseListeners = /* @__PURE__ */ new Set();
+    this.onCloseRequestListeners = /* @__PURE__ */ new Set();
   }
   write(value) {
     if (this.isClosed()) {
@@ -927,12 +469,26 @@ var WriteStreamImpl = class {
     }
     this.writeCb(value);
   }
+  isClosed() {
+    return this.closed;
+  }
+  onClose(cb) {
+    if (this.isClosed()) {
+      cb();
+      return () => void 0;
+    }
+    this.onCloseListeners.add(cb);
+    return () => this.onCloseListeners.delete(cb);
+  }
   close() {
     if (this.isClosed()) {
       return;
     }
     this.closed = true;
-    this.closeCb();
+    this.onCloseListeners.forEach((cb) => cb());
+    this.onCloseListeners.clear();
+    this.onCloseRequestListeners.clear();
+    this.writeCb = () => void 0;
   }
   isCloseRequested() {
     return this.closeRequested;
@@ -941,11 +497,12 @@ var WriteStreamImpl = class {
     if (this.isClosed()) {
       throw new Error("Stream is already closed");
     }
-    this.onCloseListeners.add(cb);
-    return () => this.onCloseListeners.delete(cb);
-  }
-  isClosed() {
-    return this.closed;
+    if (this.isCloseRequested()) {
+      cb();
+      return () => void 0;
+    }
+    this.onCloseRequestListeners.add(cb);
+    return () => this.onCloseRequestListeners.delete(cb);
   }
   /**
    * @internal meant for use within river, not exposed as a public API
@@ -960,8 +517,8 @@ var WriteStreamImpl = class {
       throw new Error("Cannot trigger close request on closed stream");
     }
     this.closeRequested = true;
-    this.onCloseListeners.forEach((cb) => cb());
-    this.onCloseListeners.clear();
+    this.onCloseRequestListeners.forEach((cb) => cb());
+    this.onCloseRequestListeners.clear();
   }
 };
 
@@ -1067,7 +624,6 @@ var Procedure = {
 };
 
 // router/client.ts
-import { nanoid } from "nanoid";
 import { Value } from "@sinclair/typebox/value";
 var OutputErrResultSchema = ErrResultSchema(OutputReaderErrorSchema);
 var noop = () => {
@@ -1100,7 +656,7 @@ function createClient(transport, serverId, providedClientOptions = {}) {
   }
   const clientOptions = { ...defaultClientOptions, ...providedClientOptions };
   if (clientOptions.eagerlyConnect) {
-    void transport.connect(serverId);
+    transport.connect(serverId);
   }
   return _createRecursiveProxy((opts) => {
     const [serviceName, procName, procMethod] = [...opts.path];
@@ -1110,8 +666,8 @@ function createClient(transport, serverId, providedClientOptions = {}) {
       );
     }
     const [init, callOptions] = opts.args;
-    if (clientOptions.connectOnInvoke && !transport.connections.has(serverId)) {
-      void transport.connect(serverId);
+    if (clientOptions.connectOnInvoke && !transport.sessions.has(serverId)) {
+      transport.connect(serverId);
     }
     if (procMethod !== "rpc" && procMethod !== "subscribe" && procMethod !== "stream" && procMethod !== "upload") {
       throw new Error(
@@ -1131,7 +687,7 @@ function createClient(transport, serverId, providedClientOptions = {}) {
 }
 function handleProc(procType, transport, serverId, init, serviceName, procedureName, abortSignal) {
   const procClosesWithInit = procType === "rpc" || procType === "subscription";
-  const streamId = nanoid();
+  const streamId = generateId();
   const { span, ctx } = createProcTelemetryInfo(
     transport,
     procType,
@@ -1140,27 +696,25 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
     streamId
   );
   let cleanClose = true;
-  const inputWriter = new WriteStreamImpl(
-    (rawIn) => {
-      transport.send(serverId, {
-        streamId,
-        payload: rawIn,
-        controlFlags: 0,
-        tracing: getPropagationContext(ctx)
-      });
-    },
-    () => {
-      span.addEvent("inputWriter closed");
-      if (!procClosesWithInit && cleanClose) {
-        transport.sendCloseControl(serverId, streamId);
-      }
-      if (outputReader.isClosed()) {
-        cleanup();
-      }
+  const inputWriter = new WriteStreamImpl((rawIn) => {
+    transport.send(serverId, {
+      streamId,
+      payload: rawIn,
+      controlFlags: 0,
+      tracing: getPropagationContext(ctx)
+    });
+  });
+  inputWriter.onClose(() => {
+    span.addEvent("inputWriter closed");
+    if (!procClosesWithInit && cleanClose) {
+      transport.send(serverId, closeStreamMessage(streamId));
     }
-  );
+    if (outputReader.isClosed()) {
+      cleanup();
+    }
+  });
   const outputReader = new ReadStreamImpl(() => {
-    transport.sendRequestCloseControl(serverId, streamId);
+    transport.send(serverId, requestCloseStreamMessage(streamId));
   });
   outputReader.onClose(() => {
     span.addEvent("outputReader closed");
@@ -1190,13 +744,15 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
       outputReader.triggerClose();
     }
     inputWriter.close();
-    transport.sendAbort(
+    transport.send(
       serverId,
-      streamId,
-      Err({
-        code: ABORT_CODE,
-        message: "Aborted by client"
-      })
+      abortMessage(
+        streamId,
+        Err({
+          code: ABORT_CODE,
+          message: "Aborted by client"
+        })
+      )
     );
   }
   function onMessage(msg) {
@@ -1425,6 +981,7 @@ var RiverServer = class {
     controlFlags,
     initPayload,
     from,
+    sessionId,
     tracingCtx
   }) {
     this.openStreams.add(streamId);
@@ -1575,7 +1132,7 @@ var RiverServer = class {
       onFinishedCallbacks.length = 0;
     };
     const inputReader = new ReadStreamImpl(() => {
-      this.transport.sendRequestCloseControl(from, streamId);
+      this.transport.send(from, requestCloseStreamMessage(streamId));
     });
     inputReader.onClose(() => {
       if (outputWriter.isClosed()) {
@@ -1583,23 +1140,21 @@ var RiverServer = class {
       }
     });
     const procClosesWithResponse = procedure.type === "rpc" || procedure.type === "upload";
-    const outputWriter = new WriteStreamImpl(
-      (response) => {
-        this.transport.send(from, {
-          streamId,
-          controlFlags: procClosesWithResponse ? 8 /* StreamClosedBit */ : 0,
-          payload: response
-        });
-      },
-      () => {
-        if (!procClosesWithResponse && cleanClose) {
-          this.transport.sendCloseControl(from, streamId);
-        }
-        if (inputReader.isClosed()) {
-          cleanup();
-        }
+    const outputWriter = new WriteStreamImpl((response) => {
+      this.transport.send(from, {
+        streamId,
+        controlFlags: procClosesWithResponse ? 8 /* StreamClosedBit */ : 0,
+        payload: response
+      });
+    });
+    outputWriter.onClose(() => {
+      if (!procClosesWithResponse && cleanClose) {
+        this.transport.send(from, closeStreamMessage(streamId));
       }
-    );
+      if (inputReader.isClosed()) {
+        cleanup();
+      }
+    });
     const onHandlerError = (err, span) => {
       const errorMsg = coerceErrorString(err);
       span.recordException(err instanceof Error ? err : new Error(errorMsg));
@@ -1622,6 +1177,7 @@ var RiverServer = class {
     const serviceContextWithTransportInfo = {
       ...this.getContext(service, serviceName),
       from,
+      sessionId,
       metadata: sessionMetadata,
       abortController: handlerAbortController,
       clientAbortSignal: clientAbortController.signal,
@@ -1777,7 +1333,9 @@ var RiverServer = class {
       );
       return null;
     }
-    const sessionMetadata = this.transport.sessionHandshakeMetadata.get(session);
+    const sessionMetadata = this.transport.sessionHandshakeMetadata.get(
+      session.to
+    );
     if (!sessionMetadata) {
       const errMessage = `session doesn't have handshake metadata`;
       this.log?.error(errMessage, {
@@ -1918,7 +1476,8 @@ var RiverServer = class {
       controlFlags: initMessage.controlFlags,
       tracingCtx: initMessage.tracing,
       initPayload: initMessage.payload,
-      from: initMessage.from
+      from: initMessage.from,
+      sessionId: session.id
     };
   }
   abortStream(to, streamId, payload) {
@@ -1928,7 +1487,7 @@ var RiverServer = class {
       this.serverAbortedStreams.set(to, abortedForSession);
     }
     abortedForSession.add(streamId);
-    this.transport.sendAbort(to, streamId, payload);
+    this.transport.send(to, abortMessage(streamId, payload));
   }
 };
 var LRUSet = class {
@@ -1974,7 +1533,6 @@ function createServerHandshakeOptions(schema, validate) {
 export {
   serializeSchema,
   ServiceSchema,
-  diffServerSchema,
   Ok,
   Err,
   ReadStreamImpl,
@@ -1990,4 +1548,4 @@ export {
   createClientHandshakeOptions,
   createServerHandshakeOptions
 };
-//# sourceMappingURL=chunk-45HIR2AS.js.map
+//# sourceMappingURL=chunk-UIYGPURD.js.map