jazz-tools 0.8.21 → 0.8.27

package/src/coValues/{coStream.ts → coFeed.ts}

@@ -38,11 +38,17 @@ import {
   subscribeToExistingCoValue,
 } from "../internal.js";
 
-export type CoStreamEntry<Item> = SingleCoStreamEntry<Item> & {
-  all: IterableIterator<SingleCoStreamEntry<Item>>;
+/** @deprecated Use CoFeedEntry instead */
+export type CoStreamEntry<Item> = CoFeedEntry<Item>;
+
+export type CoFeedEntry<Item> = SingleCoFeedEntry<Item> & {
+  all: IterableIterator<SingleCoFeedEntry<Item>>;
 };
 
-export type SingleCoStreamEntry<Item> = {
+/** @deprecated Use SingleCoFeedEntry instead */
+export type SingleCoStreamEntry<Item> = SingleCoFeedEntry<Item>;
+
+export type SingleCoFeedEntry<Item> = {
   value: NonNullable<Item> extends CoValue ? NonNullable<Item> | null : Item;
   ref: NonNullable<Item> extends CoValue ? Ref<NonNullable<Item>> : never;
   by?: Account | null;
@@ -50,11 +56,14 @@ export type SingleCoStreamEntry<Item> = {
   tx: CojsonInternalTypes.TransactionID;
 };
 
+/** @deprecated Use CoFeed instead */
+export { CoFeed as CoStream };
+
 /** @category CoValues */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export class CoStream<Item = any> extends CoValueBase implements CoValue {
-  static Of<Item>(item: IfCo<Item, Item>): typeof CoStream<Item> {
-    return class CoStreamOf extends CoStream<Item> {
+export class CoFeed<Item = any> extends CoValueBase implements CoValue {
+  static Of<Item>(item: IfCo<Item, Item>): typeof CoFeed<Item> {
+    return class CoFeedOf extends CoFeed<Item> {
       [co.items] = item;
     };
   }
@@ -73,12 +82,12 @@ export class CoStream<Item = any> extends CoValueBase implements CoValue {
   get _schema(): {
     [ItemsSym]: SchemaFor<Item>;
   } {
-    return (this.constructor as typeof CoStream)._schema;
+    return (this.constructor as typeof CoFeed)._schema;
   }
 
-  [key: ID<Account>]: CoStreamEntry<Item>;
+  [key: ID<Account>]: CoFeedEntry<Item>;
 
-  get byMe(): CoStreamEntry<Item> | undefined {
+  get byMe(): CoFeedEntry<Item> | undefined {
     if (this._loadedAs._type === "Account") {
       return this[this._loadedAs.id];
     } else {
@@ -86,9 +95,9 @@ export class CoStream<Item = any> extends CoValueBase implements CoValue {
     }
   }
   perSession!: {
-    [key: SessionID]: CoStreamEntry<Item>;
+    [key: SessionID]: CoFeedEntry<Item>;
   };
-  get inCurrentSession(): CoStreamEntry<Item> | undefined {
+  get inCurrentSession(): CoFeedEntry<Item> | undefined {
     if (this._loadedAs._type === "Account") {
       return this.perSession[this._loadedAs.sessionID!];
     } else {
@@ -116,9 +125,9 @@ export class CoStream<Item = any> extends CoValueBase implements CoValue {
     return new Proxy(this, CoStreamProxyHandler as ProxyHandler<this>);
   }
 
-  static create<S extends CoStream>(
+  static create<S extends CoFeed>(
     this: CoValueClass<S>,
-    init: S extends CoStream<infer Item> ? UnCo<Item>[] : never,
+    init: S extends CoFeed<infer Item> ? UnCo<Item>[] : never,
     options: { owner: Account | Group },
   ) {
     const instance = new this({ init, owner: options.owner });
@@ -197,9 +206,9 @@ export class CoStream<Item = any> extends CoValueBase implements CoValue {
     return this.toJSON();
   }
 
-  static schema<V extends CoStream>(
+  static schema<V extends CoFeed>(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    this: { new (...args: any): V } & typeof CoStream,
+    this: { new (...args: any): V } & typeof CoFeed,
     def: { [ItemsSym]: V["_schema"][ItemsSym] },
   ) {
     this._schema ||= {};
@@ -207,7 +216,7 @@ export class CoStream<Item = any> extends CoValueBase implements CoValue {
   }
 
   /** @category Subscription & Loading */
-  static load<S extends CoStream, Depth>(
+  static load<S extends CoFeed, Depth>(
     this: CoValueClass<S>,
     id: ID<S>,
     as: Account,
@@ -217,7 +226,7 @@ export class CoStream<Item = any> extends CoValueBase implements CoValue {
   }
 
   /** @category Subscription & Loading */
-  static subscribe<S extends CoStream, Depth>(
+  static subscribe<S extends CoFeed, Depth>(
     this: CoValueClass<S>,
     id: ID<S>,
     as: Account,
@@ -228,7 +237,7 @@ export class CoStream<Item = any> extends CoValueBase implements CoValue {
   }
 
   /** @category Subscription & Loading */
-  ensureLoaded<S extends CoStream, Depth>(
+  ensureLoaded<S extends CoFeed, Depth>(
     this: S,
     depth: Depth & DepthsIn<S>,
   ): Promise<DeeplyLoaded<S, Depth> | undefined> {
@@ -236,7 +245,7 @@ export class CoStream<Item = any> extends CoValueBase implements CoValue {
   }
 
   /** @category Subscription & Loading */
-  subscribe<S extends CoStream, Depth>(
+  subscribe<S extends CoFeed, Depth>(
     this: S,
     depth: Depth & DepthsIn<S>,
     listener: (value: DeeplyLoaded<S, Depth>) => void,
@@ -256,7 +265,7 @@ function entryFromRawEntry<Item>(
   loadedAs: Account | AnonymousJazzAgent,
   accountID: ID<Account> | undefined,
   itemField: Schema,
-): Omit<CoStreamEntry<Item>, "all"> {
+): Omit<CoFeedEntry<Item>, "all"> {
   return {
     get value(): NonNullable<Item> extends CoValue
       ? (CoValue & Item) | null
@@ -307,7 +316,7 @@ function entryFromRawEntry<Item>(
   };
 }
 
-export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
+export const CoStreamProxyHandler: ProxyHandler<CoFeed> = {
   get(target, key, receiver) {
     if (typeof key === "string" && key.startsWith("co_")) {
       const rawEntry = target._raw.lastItemBy(key as RawAccountID);
@@ -337,7 +346,7 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
               );
             }
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          })() satisfies IterableIterator<SingleCoStreamEntry<any>>;
+          })() satisfies IterableIterator<SingleCoFeedEntry<any>>;
         },
       });
 
@@ -350,8 +359,8 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
   },
   set(target, key, value, receiver) {
     if (key === ItemsSym && typeof value === "object" && SchemaInit in value) {
-      (target.constructor as typeof CoStream)._schema ||= {};
-      (target.constructor as typeof CoStream)._schema[ItemsSym] =
+      (target.constructor as typeof CoFeed)._schema ||= {};
+      (target.constructor as typeof CoFeed)._schema[ItemsSym] =
         value[SchemaInit];
       return true;
     } else {
@@ -365,8 +374,8 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
       typeof descriptor.value === "object" &&
       SchemaInit in descriptor.value
     ) {
-      (target.constructor as typeof CoStream)._schema ||= {};
-      (target.constructor as typeof CoStream)._schema[ItemsSym] =
+      (target.constructor as typeof CoFeed)._schema ||= {};
+      (target.constructor as typeof CoFeed)._schema[ItemsSym] =
         descriptor.value[SchemaInit];
       return true;
     } else {
@@ -396,8 +405,8 @@ export const CoStreamProxyHandler: ProxyHandler<CoStream> = {
 };
 
 const CoStreamPerSessionProxyHandler = (
-  innerTarget: CoStream,
-  accessFrom: CoStream,
+  innerTarget: CoFeed,
+  accessFrom: CoFeed,
 ): ProxyHandler<Record<string, never>> => ({
   get(_target, key, receiver) {
     if (typeof key === "string" && key.includes("session")) {
@@ -435,7 +444,7 @@ const CoStreamPerSessionProxyHandler = (
               );
             }
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          })() satisfies IterableIterator<SingleCoStreamEntry<any>>;
+          })() satisfies IterableIterator<SingleCoFeedEntry<any>>;
         },
       });
 
@@ -460,8 +469,11 @@ const CoStreamPerSessionProxyHandler = (
   },
 });
 
+/** @deprecated Use CoFeed instead */
+export { FileStream as BinaryCoStream };
+
 /** @category CoValues */
-export class BinaryCoStream extends CoValueBase implements CoValue {
+export class FileStream extends CoValueBase implements CoValue {
   declare id: ID<this>;
   declare _type: "BinaryCoStream";
   declare _raw: RawBinaryCoStream;
@@ -496,7 +508,7 @@ export class BinaryCoStream extends CoValueBase implements CoValue {
     });
   }
 
-  static create<S extends BinaryCoStream>(
+  static create<S extends FileStream>(
     this: CoValueClass<S>,
     options: { owner: Account | Group },
   ) {
@@ -541,7 +553,7 @@ export class BinaryCoStream extends CoValueBase implements CoValue {
   }
 
   static async loadAsBlob(
-    id: ID<BinaryCoStream>,
+    id: ID<FileStream>,
     as: Account,
     options?: {
       allowUnfinished?: boolean;
@@ -554,7 +566,7 @@ export class BinaryCoStream extends CoValueBase implements CoValue {
      * stream isn't complete wait for the stream download before progressing
      */
     if (!options?.allowUnfinished && !stream?.isBinaryStreamEnded()) {
-      stream = await new Promise<BinaryCoStream>((resolve) => {
+      stream = await new Promise<FileStream>((resolve) => {
         const unsubscribe = subscribeToCoValue(this, id, as, [], (value) => {
           if (value.isBinaryStreamEnded()) {
             unsubscribe();
@@ -575,7 +587,7 @@ export class BinaryCoStream extends CoValueBase implements CoValue {
       owner: Group | Account;
       onProgress?: (progress: number) => void;
     },
-  ): Promise<BinaryCoStream> {
+  ): Promise<FileStream> {
     const stream = this.create({ owner: options.owner });
 
     const start = Date.now();
@@ -635,7 +647,7 @@ export class BinaryCoStream extends CoValueBase implements CoValue {
   }
 
   /** @category Subscription & Loading */
-  static load<B extends BinaryCoStream, Depth>(
+  static load<B extends FileStream, Depth>(
     this: CoValueClass<B>,
     id: ID<B>,
     as: Account,
@@ -645,7 +657,7 @@ export class BinaryCoStream extends CoValueBase implements CoValue {
   }
 
   /** @category Subscription & Loading */
-  static subscribe<B extends BinaryCoStream, Depth>(
+  static subscribe<B extends FileStream, Depth>(
     this: CoValueClass<B>,
     id: ID<B>,
     as: Account,
@@ -656,7 +668,7 @@ export class BinaryCoStream extends CoValueBase implements CoValue {
   }
 
   /** @category Subscription & Loading */
-  ensureLoaded<B extends BinaryCoStream, Depth>(
+  ensureLoaded<B extends FileStream, Depth>(
     this: B,
     depth: Depth & DepthsIn<B>,
   ): Promise<DeeplyLoaded<B, Depth> | undefined> {
@@ -664,7 +676,7 @@ export class BinaryCoStream extends CoValueBase implements CoValue {
   }
 
   /** @category Subscription & Loading */
-  subscribe<B extends BinaryCoStream, Depth>(
+  subscribe<B extends FileStream, Depth>(
     this: B,
     depth: Depth & DepthsIn<B>,
     listener: (value: DeeplyLoaded<B, Depth>) => void,

package/src/coValues/coList.ts

@@ -339,7 +339,7 @@ export class CoList<Item = any> extends Array<Item> implements CoValue {
    *
    * You can pass `[]` or for shallowly loading only this CoList, or `[itemDepth]` for recursively loading referenced CoValues.
    *
-   * Check out the `load` methods on `CoMap`/`CoList`/`CoStream`/`Group`/`Account` to see which depth structures are valid to nest.
+   * Check out the `load` methods on `CoMap`/`CoList`/`CoFeed`/`Group`/`Account` to see which depth structures are valid to nest.
    *
    * @example
    * ```ts
@@ -372,7 +372,7 @@ export class CoList<Item = any> extends Array<Item> implements CoValue {
    *
    * You can pass `[]` or for shallowly loading only this CoList, or `[itemDepth]` for recursively loading referenced CoValues.
    *
-   * Check out the `load` methods on `CoMap`/`CoList`/`CoStream`/`Group`/`Account` to see which depth structures are valid to nest.
+   * Check out the `load` methods on `CoMap`/`CoList`/`CoFeed`/`Group`/`Account` to see which depth structures are valid to nest.
    *
    * Returns an unsubscribe function that you should call when you no longer need updates.
    *

package/src/coValues/coMap.ts

@@ -366,7 +366,7 @@ export class CoMap extends CoValueBase implements CoValue {
    *
    * You can pass `[]` or `{}` for shallowly loading only this CoMap, or `{ fieldA: depthA, fieldB: depthB }` for recursively loading referenced CoValues.
    *
-   * Check out the `load` methods on `CoMap`/`CoList`/`CoStream`/`Group`/`Account` to see which depth structures are valid to nest.
+   * Check out the `load` methods on `CoMap`/`CoList`/`CoFeed`/`Group`/`Account` to see which depth structures are valid to nest.
    *
    * @example
    * ```ts
@@ -398,7 +398,7 @@ export class CoMap extends CoValueBase implements CoValue {
    *
    * You can pass `[]` or `{}` for shallowly loading only this CoMap, or `{ fieldA: depthA, fieldB: depthB }` for recursively loading referenced CoValues.
    *
-   * Check out the `load` methods on `CoMap`/`CoList`/`CoStream`/`Group`/`Account` to see which depth structures are valid to nest.
+   * Check out the `load` methods on `CoMap`/`CoList`/`CoFeed`/`Group`/`Account` to see which depth structures are valid to nest.
    *
    * Returns an unsubscribe function that you should call when you no longer need updates.
    *

package/src/coValues/deepLoading.ts

@@ -1,9 +1,9 @@
 import { SessionID } from "cojson";
 import {
   Account,
+  CoFeed,
+  CoFeedEntry,
   CoList,
-  CoStream,
-  CoStreamEntry,
   ItemsSym,
   Ref,
   RefEncoded,
@@ -66,10 +66,10 @@ export function fulfillsDepth(depth: any, value: CoValue): boolean {
       return true;
     } else {
       const itemDepth = depth[0];
-      return Object.values((value as CoStream).perSession).every((entry) =>
+      return Object.values((value as CoFeed).perSession).every((entry) =>
         entry.ref
           ? entry.value && fulfillsDepth(itemDepth, entry.value)
-          : ((value as CoStream)._schema[ItemsSym] as RefEncoded<CoValue>)
+          : ((value as CoFeed)._schema[ItemsSym] as RefEncoded<CoValue>)
               .optional,
       );
     }
@@ -121,7 +121,7 @@ export type DepthsIn<
               | never[]
           : V extends {
                 _type: "CoStream";
-                byMe: CoStreamEntry<infer Item> | undefined;
+                byMe: CoFeedEntry<infer Item> | undefined;
               }
             ?
                 | [
@@ -192,7 +192,7 @@ export type DeeplyLoaded<
       : [V] extends [
             {
               _type: "CoStream";
-              byMe: CoStreamEntry<infer Item> | undefined;
+              byMe: CoFeedEntry<infer Item> | undefined;
             },
           ]
         ? Depth extends never[]

package/src/coValues/extensions/imageDef.ts

@@ -1,21 +1,16 @@
-import {
-  BinaryCoStream,
-  CoMap,
-  co,
-  subscriptionsScopes,
-} from "../../internal.js";
+import { CoMap, FileStream, co, subscriptionsScopes } from "../../internal.js";
 
 /** @category Media */
 export class ImageDefinition extends CoMap {
   originalSize = co.json<[number, number]>();
   placeholderDataURL? = co.string;
 
-  [co.items] = co.ref(BinaryCoStream);
-  [res: `${number}x${number}`]: co<BinaryCoStream | null>;
+  [co.items] = co.ref(FileStream);
+  [res: `${number}x${number}`]: co<FileStream | null>;
 
   highestResAvailable(options?: {
     maxWidth?: number;
-  }): { res: `${number}x${number}`; stream: BinaryCoStream } | undefined {
+  }): { res: `${number}x${number}`; stream: FileStream } | undefined {
     if (!subscriptionsScopes.get(this)) {
       console.warn(
         "highestResAvailable() only makes sense when used within a subscription.",

package/src/coValues/schemaUnion.ts

@@ -0,0 +1,108 @@
+import {
+  CoValue,
+  CoValueBase,
+  CoValueClass,
+  CoValueFromRaw,
+} from "../internal.js";
+
+/**
+ * SchemaUnion allows you to create union types of CoValues that can be discriminated at runtime.
+ *
+ * @categoryDescription Declaration
+ * Declare your union types by extending `SchemaUnion.Of(...)` and passing a discriminator function
+ * that determines which concrete type to use based on the raw data.
+ *
+ * @example
+ * ```ts
+ * import { SchemaUnion, CoMap } from "jazz-tools";
+ *
+ * class BaseWidget extends CoMap {
+ *   type = co.string;
+ * }
+ *
+ * class ButtonWidget extends BaseWidget {
+ *   type = co.literal("button");
+ *   label = co.string;
+ * }
+ *
+ * class SliderWidget extends BaseWidget {
+ *   type = co.literal("slider");
+ *   min = co.number;
+ *   max = co.number;
+ * }
+ *
+ * const WidgetUnion = SchemaUnion.Of<BaseWidget>((raw) => {
+ *   switch (raw.get("type")) {
+ *     case "button": return ButtonWidget;
+ *     case "slider": return SliderWidget;
+ *     default: throw new Error("Unknown widget type");
+ *   }
+ * });
+ * ```
+ *
+ * @categoryDescription Loading
+ * When loading a SchemaUnion, the correct subclass will be instantiated based on the discriminator.
+ * You can narrow the returned instance to a subclass by using `instanceof` like so:
+ *
+ * @example
+ * ```ts
+ * const widget = await loadCoValue(WidgetUnion, id, me, {});
+ * if (widget instanceof ButtonWidget) {
+ *   console.log(widget.label);
+ * } else if (widget instanceof SliderWidget) {
+ *   console.log(widget.min, widget.max);
+ * }
+ * ```
+ *
+ * @category CoValues
+ */
+export abstract class SchemaUnion extends CoValueBase implements CoValue {
+  /**
+   * Create a new union type from a discriminator function.
+   *
+   * The discriminator function receives the raw data and should return the appropriate
+   * concrete class to use for that data.
+   *
+   * @param discriminator - Function that determines which concrete type to use
+   * @returns A new class that can create/load instances of the union type
+   *
+   * @example
+   * ```ts
+   * const WidgetUnion = SchemaUnion.Of<BaseWidget>((raw) => {
+   *   switch (raw.get("type")) {
+   *     case "button": return ButtonWidget;
+   *     case "slider": return SliderWidget;
+   *     default: throw new Error("Unknown widget type");
+   *   }
+   * });
+   * ```
+   *
+   * @category Creation
+   */
+  static Of<V extends CoValue>(
+    discriminator: (raw: V["_raw"]) => CoValueClass<V> & CoValueFromRaw<V>,
+  ): CoValueClass<V> & typeof SchemaUnion {
+    return class SchemaUnionClass extends SchemaUnion {
+      static override fromRaw<T extends CoValue>(
+        this: CoValueClass<T> & CoValueFromRaw<T>,
+        raw: T["_raw"],
+      ): T {
+        const ResolvedClass = discriminator(
+          raw as V["_raw"],
+        ) as unknown as CoValueClass<T> & CoValueFromRaw<T>;
+        return ResolvedClass.fromRaw(raw);
+      }
+    } as unknown as CoValueClass<V> & typeof SchemaUnion;
+  }
+
+  /**
+   * Create an instance from raw data. This is called internally and should not be used directly.
+   * Use {@link SchemaUnion.Of} to create a union type instead.
+   *
+   * @internal
+   */
+  // @ts-ignore
+  static fromRaw<V extends CoValue>(this: CoValueClass<V>, raw: V["_raw"]): V {
+    throw new Error("Not implemented");
+  }
+}

package/src/exports.ts

@@ -14,15 +14,18 @@ export { Encoders, co } from "./internal.js";
 
 export {
   Account,
+  FileStream,
   BinaryCoStream,
   CoList,
   CoMap,
+  CoFeed,
   CoStream,
   CoValueBase,
   Group,
   ImageDefinition,
   Profile,
   isControlledAccount,
+  SchemaUnion,
   type AccountClass,
   type CoMapInit,
   type CoValueClass,

package/src/internal.ts

@@ -5,7 +5,8 @@ export * from "./coValues/interfaces.js";
 export * from "./coValues/coMap.js";
 export * from "./coValues/account.js";
 export * from "./coValues/coList.js";
-export * from "./coValues/coStream.js";
+export * from "./coValues/coFeed.js";
+export * from "./coValues/schemaUnion.js";
 export * from "./coValues/group.js";
 
 export * from "./implementation/errors.js";

package/src/tests/{coStream.test.ts → coFeed.test.ts}

@@ -2,8 +2,8 @@ import { connectedPeers } from "cojson/src/streamUtils.ts";
 import { describe, expect, test } from "vitest";
 import {
   Account,
-  BinaryCoStream,
-  CoStream,
+  CoFeed,
+  FileStream,
   ID,
   WasmCrypto,
   co,
@@ -16,7 +16,7 @@ import { randomSessionProvider } from "../internal.js";
 
 const Crypto = await WasmCrypto.create();
 
-describe("Simple CoStream operations", async () => {
+describe("Simple CoFeed operations", async () => {
   const me = await Account.create({
     creationProps: { name: "Hermes Puggington" },
     crypto: Crypto,
@@ -24,7 +24,7 @@ describe("Simple CoStream operations", async () => {
   if (!isControlledAccount(me)) {
     throw "me is not a controlled account";
   }
-  class TestStream extends CoStream.Of(co.string) {}
+  class TestStream extends CoFeed.Of(co.string) {}
 
   const stream = TestStream.create(["milk"], { owner: me });
 
@@ -46,16 +46,16 @@ describe("Simple CoStream operations", async () => {
   });
 });
 
-describe("CoStream resolution", async () => {
-  class TwiceNestedStream extends CoStream.Of(co.string) {
+describe("CoFeed resolution", async () => {
+  class TwiceNestedStream extends CoFeed.Of(co.string) {
     fancyValueOf(account: ID<Account>) {
       return "Sir " + this[account]?.value;
     }
   }
 
-  class NestedStream extends CoStream.Of(co.ref(TwiceNestedStream)) {}
+  class NestedStream extends CoFeed.Of(co.ref(TwiceNestedStream)) {}
 
-  class TestStream extends CoStream.Of(co.ref(NestedStream)) {}
+  class TestStream extends CoFeed.Of(co.ref(NestedStream)) {}
 
   const initNodeAndStream = async () => {
     const me = await Account.create({
@@ -242,13 +242,13 @@ describe("CoStream resolution", async () => {
   });
 });
 
-describe("Simple BinaryCoStream operations", async () => {
+describe("Simple FileStream operations", async () => {
   const me = await Account.create({
     creationProps: { name: "Hermes Puggington" },
     crypto: Crypto,
   });
 
-  const stream = BinaryCoStream.create({ owner: me });
+  const stream = FileStream.create({ owner: me });
 
   test("Construction", () => {
     expect(stream.getChunks()).toBe(undefined);
@@ -270,14 +270,14 @@ describe("Simple BinaryCoStream operations", async () => {
   });
 });
 
-describe("BinaryCoStream loading & Subscription", async () => {
+describe("FileStream loading & Subscription", async () => {
   const initNodeAndStream = async () => {
     const me = await Account.create({
       creationProps: { name: "Hermes Puggington" },
       crypto: Crypto,
     });
 
-    const stream = BinaryCoStream.create({ owner: me });
+    const stream = FileStream.create({ owner: me });
 
     stream.start({ mimeType: "text/plain" });
     stream.push(new Uint8Array([1, 2, 3]));
@@ -316,11 +316,7 @@ describe("BinaryCoStream loading & Subscription", async () => {
       crypto: Crypto,
     });
 
-    const loadedStream = await BinaryCoStream.load(
-      stream.id,
-      meOnSecondPeer,
-      [],
-    );
+    const loadedStream = await FileStream.load(stream.id, meOnSecondPeer, []);
 
     expect(loadedStream?.getChunks()).toEqual({
       mimeType: "text/plain",
@@ -331,7 +327,7 @@ describe("BinaryCoStream loading & Subscription", async () => {
 
   test("Subscription", async () => {
     const { me } = await initNodeAndStream();
-    const stream = BinaryCoStream.create({ owner: me });
+    const stream = FileStream.create({ owner: me });
 
     const [initialAsPeer, secondAsPeer] = connectedPeers("initial", "second", {
       peer1role: "server",
@@ -353,14 +349,9 @@ describe("BinaryCoStream loading & Subscription", async () => {
 
     const queue = new cojsonInternals.Channel();
 
-    BinaryCoStream.subscribe(
-      stream.id,
-      meOnSecondPeer,
-      [],
-      (subscribedStream) => {
-        void queue.push(subscribedStream);
-      },
-    );
+    FileStream.subscribe(stream.id, meOnSecondPeer, [], (subscribedStream) => {
+      void queue.push(subscribedStream);
+    });
 
     const update1 = (await queue.next()).value;
     expect(update1.getChunks()).toBe(undefined);
@@ -411,14 +402,14 @@ describe("BinaryCoStream loading & Subscription", async () => {
   });
 });
 
-describe("BinaryCoStream.loadAsBlob", async () => {
+describe("FileStream.loadAsBlob", async () => {
   async function setup() {
     const me = await Account.create({
       creationProps: { name: "Hermes Puggington" },
       crypto: Crypto,
     });
 
-    const stream = BinaryCoStream.create({ owner: me });
+    const stream = FileStream.create({ owner: me });
 
     stream.start({ mimeType: "text/plain" });
 
@@ -429,7 +420,7 @@ describe("BinaryCoStream.loadAsBlob", async () => {
     const { stream, me } = await setup();
     stream.push(new Uint8Array([1]));
 
-    const promise = BinaryCoStream.loadAsBlob(stream.id, me);
+    const promise = FileStream.loadAsBlob(stream.id, me);
 
     await stream.ensureLoaded([]);
 
@@ -447,7 +438,7 @@ describe("BinaryCoStream.loadAsBlob", async () => {
     const { stream, me } = await setup();
     stream.push(new Uint8Array([1]));
 
-    const promise = BinaryCoStream.loadAsBlob(stream.id, me, {
+    const promise = FileStream.loadAsBlob(stream.id, me, {
       allowUnfinished: true,
     });