jazz-tools 0.20.14 → 0.20.16

package/src/tools/coValues/interfaces.ts

@@ -31,6 +31,8 @@ import {
   coValueClassFromCoValueClassOrSchema,
   inspect,
   LocalValidationMode,
+  CoValueCursor,
+  LoadCoValueCursorOption,
 } from "../internal.js";
 import type {
   BranchDefinition,
@@ -78,6 +80,8 @@ export interface CoValue {
     isBranched: boolean;
     branchName: string | undefined;
     unstable_merge: () => void;
+    cursor: CoValueCursor | undefined;
+    createCursor: () => CoValueCursor;
   };
   /**
    * Whether the CoValue is loaded. Can be used to distinguish between loaded and {@link NotLoaded} CoValues.
@@ -167,16 +171,18 @@ export function loadCoValueWithoutMe<
     loadAs?: Account | AnonymousJazzAgent;
     skipRetry?: boolean;
     unstable_branch?: BranchDefinition;
+    cursor?: LoadCoValueCursorOption;
   },
 ): Promise<Settled<Resolved<V, R>>> {
   return loadCoValue(cls, id, {
     ...options,
     loadAs: options?.loadAs ?? activeAccountContext.get(),
     unstable_branch: options?.unstable_branch,
+    cursor: options?.cursor,
   });
 }
 
-export function loadCoValue<
+export async function loadCoValue<
   V extends CoValue,
   const R extends RefsToResolve<V>,
 >(
@@ -187,8 +193,46 @@ export function loadCoValue<
     loadAs: Account | AnonymousJazzAgent;
     skipRetry?: boolean;
     unstable_branch?: BranchDefinition;
+    cursor?: LoadCoValueCursorOption;
   },
 ): Promise<Settled<Resolved<V, R>>> {
+  let cursor: CoValueCursor | undefined;
+
+  if (options.cursor) {
+    if (typeof options.cursor === "string") {
+      cursor = options.cursor;
+    } else if (options.cursor.useCurrentCursor) {
+      const loadAs = options.loadAs ?? activeAccountContext.get();
+      const node = "node" in loadAs ? loadAs.node : loadAs.$jazz.localNode;
+
+      const resolve = options.resolve ?? true;
+
+      const rootNode = new SubscriptionScope<CoValue>(
+        node,
+        resolve as any,
+        id,
+        {
+          ref: coValueClassFromCoValueClassOrSchema(cls),
+          optional: false,
+        },
+        options.skipRetry,
+        false,
+        options.unstable_branch,
+        undefined,
+      );
+
+      try {
+        await rootNode.getPromise();
+        rootNode.destroy();
+      } catch (error) {
+        rootNode.destroy();
+        throw error;
+      }
+
+      cursor = rootNode.createCursor();
+    }
+  }
+
   return new Promise((resolve) => {
     subscribeToCoValue<V, R>(
       cls,
@@ -200,6 +244,7 @@ export function loadCoValue<
         skipRetry: options.skipRetry,
         onError: resolve,
         unstable_branch: options.unstable_branch,
+        cursor,
       },
       (value, unsubscribe) => {
         resolve(value);
@@ -218,6 +263,7 @@ export async function ensureCoValueLoaded<
     | {
         resolve?: RefsToResolveStrict<V, R>;
         unstable_branch?: BranchDefinition;
+        cursor?: LoadCoValueCursorOption;
       }
     | undefined,
 ): Promise<Resolved<V, R>> {
@@ -228,6 +274,7 @@ export async function ensureCoValueLoaded<
       loadAs: existing.$jazz.loadedAs,
       resolve: options?.resolve,
       unstable_branch: options?.unstable_branch,
+      cursor: options?.cursor,
     },
   );
 
@@ -261,6 +308,7 @@ export type SubscribeListenerOptions<
    */
   onUnavailable?: (value: NotLoaded<V>) => void;
   unstable_branch?: BranchDefinition;
+  cursor?: CoValueCursor;
 };
 
 export type SubscribeRestArgs<V extends CoValue, R extends RefsToResolve<V>> =
@@ -290,6 +338,7 @@ export function parseSubscribeRestArgs<
           onUnauthorized: args[0].onUnauthorized,
           onUnavailable: args[0].onUnavailable,
           unstable_branch: args[0].unstable_branch,
+          cursor: args[0].cursor,
         },
         listener: args[1],
       };
@@ -346,6 +395,7 @@ export function subscribeToCoValue<
     syncResolution?: boolean;
     skipRetry?: boolean;
     unstable_branch?: BranchDefinition;
+    cursor?: CoValueCursor;
   },
   listener: SubscribeListener<V, R>,
 ): () => void {
@@ -367,6 +417,7 @@ export function subscribeToCoValue<
     options.skipRetry,
     false,
     options.unstable_branch,
+    options.cursor,
   );
 
   // Track performance for API subscriptions
@@ -434,6 +485,7 @@ export function subscribeToExistingCoValue<
          */
         onUnauthorized?: (value: NotLoaded<V>) => void;
         unstable_branch?: BranchDefinition;
+        cursor?: CoValueCursor;
       }
     | undefined,
   listener: SubscribeListener<V, R>,
@@ -448,6 +500,7 @@ export function subscribeToExistingCoValue<
       onUnavailable: options?.onUnavailable,
       onUnauthorized: options?.onUnauthorized,
       unstable_branch: options?.unstable_branch,
+      cursor: options?.cursor,
     },
     listener,
   );
@@ -831,6 +884,7 @@ export async function exportCoValue<
     skipRetry?: boolean;
     bestEffortResolution?: boolean;
     unstable_branch?: BranchDefinition;
+    cursor?: CoValueCursor;
   },
 ) {
   const loadAs = options.loadAs ?? activeAccountContext.get();

package/src/tools/exports.ts

@@ -128,6 +128,8 @@ export {
   type CoreAccountSchema as AnyAccountSchema,
   type ResolveQuery,
   type ResolveQueryStrict,
+  type CoValueCursor,
+  type LoadCoValueCursorOption,
 } from "./internal.js";
 
 export {

package/src/tools/implementation/zodSchema/schemaTypes/CoDiscriminatedUnionSchema.ts

@@ -14,6 +14,8 @@ import {
   SubscribeCallback,
   SubscribeListenerOptions,
   coOptionalDefiner,
+  CoValueCursor,
+  LoadCoValueCursorOption,
 } from "../../../internal.js";
 import { z } from "../zodReExport.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
@@ -107,6 +109,7 @@ export class CoDiscriminatedUnionSchema<
       loadAs?: Account | AnonymousJazzAgent;
       skipRetry?: boolean;
       unstable_branch?: BranchDefinition;
+      cursor?: LoadCoValueCursorOption;
     },
   ): Promise<
     Settled<

package/src/tools/implementation/zodSchema/schemaTypes/CoFeedSchema.ts

@@ -17,6 +17,7 @@ import {
   withSchemaPermissions,
   type Schema,
   CoValueCreateOptions,
+  LoadCoValueCursorOption,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { CoFeedSchemaInit } from "../typeConverters/CoFieldSchemaInit.js";
@@ -124,6 +125,7 @@ export class CoFeedSchema<
       resolve?: RefsToResolveStrict<CoFeedInstanceCoValuesMaybeLoaded<T>, R>;
       loadAs?: Account | AnonymousJazzAgent;
       unstable_branch?: BranchDefinition;
+      cursor?: LoadCoValueCursorOption;
     },
   ): Promise<Settled<Resolved<CoFeedInstanceCoValuesMaybeLoaded<T>, R>>> {
     // @ts-expect-error

package/src/tools/implementation/zodSchema/schemaTypes/CoListSchema.ts

@@ -16,6 +16,7 @@ import {
   withSchemaPermissions,
   type Schema,
   CoValueCreateOptions,
+  LoadCoValueCursorOption,
 } from "../../../internal.js";
 import { CoValueUniqueness } from "cojson";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
@@ -121,6 +122,7 @@ export class CoListSchema<
       resolve?: RefsToResolveStrict<CoListInstanceCoValuesMaybeLoaded<T>, R>;
       loadAs?: Account | AnonymousJazzAgent;
       unstable_branch?: BranchDefinition;
+      cursor?: LoadCoValueCursorOption;
     },
   ): Promise<Settled<Resolved<CoListInstanceCoValuesMaybeLoaded<T>, R>>> {
     // @ts-expect-error

package/src/tools/implementation/zodSchema/schemaTypes/CoMapSchema.ts

@@ -13,7 +13,6 @@ import {
   Simplify,
   SubscribeCallback,
   SubscribeListenerOptions,
-  coMapDefiner,
   coOptionalDefiner,
   hydrateCoreCoValueSchema,
   isAnyCoValueSchema,
@@ -22,6 +21,8 @@ import {
   isCoValueSchema,
   type Schema,
   CoValueCreateOptions,
+  CoValueCursor,
+  LoadCoValueCursorOption,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { removeGetters, withSchemaResolveQuery } from "../../schemaUtils.js";
@@ -179,6 +180,7 @@ export class CoMapSchema<
       loadAs?: Account | AnonymousJazzAgent;
       skipRetry?: boolean;
       unstable_branch?: BranchDefinition;
+      cursor?: LoadCoValueCursorOption;
     },
   ): Promise<
     Settled<
@@ -394,14 +396,7 @@ export class CoMapSchema<
     return hydrateCoreCoValueSchema(schemaWithCatchAll);
   }
 
-  withMigration(
-    migration: (
-      value: Resolved<
-        Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap,
-        true
-      >,
-    ) => undefined,
-  ): this {
+  withMigration(migration: CoMapMigration<Shape>): this {
     // @ts-expect-error avoid exposing 'migrate' at the type level
     this.coValueClass.prototype.migrate = migration;
     return this;
@@ -417,6 +412,7 @@ export class CoMapSchema<
 
   /**
    * Creates a new CoMap schema by picking the specified keys from the original schema.
+   * The new CoMap will **not** inherit any configurations (migration, catchall, permissions, default resolve query)
    *
    * @param keys - The keys to pick from the original schema.
    * @returns A new CoMap schema with the picked keys.
@@ -433,12 +429,51 @@ export class CoMapSchema<
       }
     }
 
-    // @ts-expect-error the picked shape contains all required keys
-    return coMapDefiner(pickedShape);
+    return this.copy(
+      {
+        shape: pickedShape as Pick<Shape, Keys>,
+        permissions: DEFAULT_SCHEMA_PERMISSIONS,
+        resolveQuery: true,
+      },
+      {
+        shouldCopyCatchAll: false,
+        shouldCopyMigration: false,
+      },
+    );
+  }
+
+  /**
+   * Creates a new CoMap schema by omitting the specified keys from the original schema.
+   * The new CoMap will **not** inherit any configurations (migration, catchall, permissions, default resolve query)
+   *
+   * @param keys - The keys to omit from the original schema.
+   * @returns A new CoMap schema with the omitted keys.
+   */
+  omit<Keys extends keyof Shape>(
+    keys: { [key in Keys]: true },
+  ): CoMapSchema<Simplify<Omit<Shape, Keys>>, unknown, Owner> {
+    const newShape: Record<string, AnyZodOrCoValueSchema> = { ...this.shape };
+
+    for (const key in keys) {
+      delete newShape[key];
+    }
+
+    return this.copy(
+      {
+        shape: newShape as Omit<Shape, Keys>,
+        permissions: DEFAULT_SCHEMA_PERMISSIONS,
+        resolveQuery: true,
+      },
+      {
+        shouldCopyCatchAll: false,
+        shouldCopyMigration: false,
+      },
+    );
   }
 
   /**
    * Creates a new CoMap schema by making all fields optional.
+   * The new CoMap will **not** inherit any configurations (migration, permissions, default resolve query) except catchall
    *
    * @returns A new CoMap schema with all fields optional.
    */
@@ -462,15 +497,64 @@ export class CoMapSchema<
       }
     }
 
-    const partialCoMapSchema = coMapDefiner(partialShape);
-    if (this.catchAll) {
-      // @ts-expect-error the partial shape contains all required keys
-      return partialCoMapSchema.catchall(
-        this.catchAll as unknown as AnyZodOrCoValueSchema,
-      );
-    }
-    // @ts-expect-error the partial shape contains all required keys
-    return partialCoMapSchema;
+    return this.copy(
+      {
+        shape: partialShape as PartialShape<Shape, Keys>,
+        permissions: DEFAULT_SCHEMA_PERMISSIONS,
+        resolveQuery: true,
+      },
+      {
+        shouldCopyMigration: false,
+      },
+    );
+  }
+
+  /**
+   * Creates a new CoMap schema by extending the current schema with additional fields.
+   * The new CoMap **will** inherit all configurations (migration, catchall, permissions, default resolve query)
+   *
+   * @param shape - The shape object with additional fields to add to the schema.
+   * @returns A new CoMap schema with the additional fields.
+   */
+  extend<ExtendShape extends z.core.$ZodLooseShape>(
+    shape: ExtendShape,
+  ): CoMapSchema<
+    z.core.util.Extend<Shape, ExtendShape>,
+    CatchAll,
+    Owner,
+    DefaultResolveQuery
+  > {
+    return this.copy({
+      shape: {
+        ...this.shape,
+        ...shape,
+      } as z.core.util.Extend<Shape, ExtendShape>,
+    });
+  }
+
+  /**
+   * Creates a new CoMap schema by extending the current schema with additional fields,
+   * while also making sure that no existing fields are accidentally overridden.
+   * The new CoMap **will** inherit all configurations (migration, catchall, permissions, default resolve query)
+   *
+   * @param shape - The shape object with additional fields to add to the schema.
+   * @returns A new CoMap schema with the additional fields.
+   */
+  safeExtend<ExtendShape extends z.core.$ZodLooseShape>(
+    shape: SafeExtendShape<Shape, ExtendShape> &
+      Partial<Record<keyof Shape, AnyZodOrCoValueSchema>>,
+  ): CoMapSchema<
+    z.core.util.Extend<Shape, ExtendShape>,
+    CatchAll,
+    Owner,
+    DefaultResolveQuery
+  > {
+    return this.copy({
+      shape: {
+        ...this.shape,
+        ...shape,
+      } as z.core.util.Extend<Shape, ExtendShape>,
+    });
   }
 
   /**
@@ -502,22 +586,45 @@ export class CoMapSchema<
   /**
    * Creates a copy of this schema, preserving all previous configuration
    */
-  private copy<ResolveQuery extends CoreResolveQuery = DefaultResolveQuery>({
-    permissions,
-    resolveQuery,
-  }: {
-    permissions?: SchemaPermissions;
-    resolveQuery?: ResolveQuery;
-  }): CoMapSchema<Shape, CatchAll, Owner, ResolveQuery> {
-    const coreSchema = createCoreCoMapSchema(this.shape, this.catchAll);
-    // @ts-expect-error
-    const copy: CoMapSchema<Shape, CatchAll, Owner, ResolveQuery> =
-      hydrateCoreCoValueSchema(coreSchema);
-    // @ts-expect-error avoid exposing 'migrate' at the type level
-    copy.coValueClass.prototype.migrate = this.coValueClass.prototype.migrate;
-    // @ts-expect-error TS cannot infer that the resolveQuery type is valid
-    copy.resolveQuery = resolveQuery ?? this.resolveQuery;
+  private copy<
+    ShapeOverride extends z.core.$ZodLooseShape = Shape,
+    ResolveQuery extends CoreResolveQuery = DefaultResolveQuery,
+  >(
+    {
+      shape,
+      permissions,
+      resolveQuery,
+    }: {
+      shape?: ShapeOverride;
+      permissions?: SchemaPermissions;
+      resolveQuery?: ResolveQuery;
+    },
+    options: {
+      shouldCopyCatchAll?: boolean;
+      shouldCopyMigration?: boolean;
+    } = {},
+  ): CoMapSchema<ShapeOverride, CatchAll, Owner, ResolveQuery> {
+    const { shouldCopyCatchAll = true, shouldCopyMigration = true } = options;
+
+    const coreSchema = createCoreCoMapSchema(
+      shape ?? this.shape,
+      shouldCopyCatchAll ? this.catchAll : (undefined as unknown),
+    );
+
+    const copy = hydrateCoreCoValueSchema(coreSchema) as CoMapSchema<
+      ShapeOverride,
+      CatchAll,
+      Owner,
+      ResolveQuery
+    >;
+
+    if (shouldCopyMigration) {
+      // @ts-expect-error avoid exposing 'migrate' at the type level
+      copy.coValueClass.prototype.migrate = this.coValueClass.prototype.migrate;
+    }
+
     copy.#permissions = permissions ?? this.#permissions;
+    copy.resolveQuery = (resolveQuery ?? this.resolveQuery) as ResolveQuery;
     return copy;
   }
 }
@@ -611,6 +718,13 @@ export interface CoreCoMapSchema<
   getDefinition: () => CoMapSchemaDefinition;
 }
 
+type CoMapMigration<Shape extends z.core.$ZodLooseShape> = (
+  value: Resolved<
+    Simplify<CoMapInstanceCoValuesMaybeLoaded<Shape>> & CoMap,
+    true
+  >,
+) => undefined;
+
 export type CoMapInstanceShape<
   Shape extends z.core.$ZodLooseShape,
   CatchAll extends AnyZodOrCoValueSchema | unknown = unknown,
@@ -642,3 +756,29 @@ export type PartialShape<
         : never
     : Shape[key];
 }>;
+
+export type SafeExtendShape<
+  Base extends z.core.$ZodLooseShape,
+  Ext extends z.core.$ZodLooseShape,
+> = {
+  [K in keyof Ext]: K extends keyof Base
+    ? Base[K] extends z.core.SomeType
+      ? Ext[K] extends z.core.SomeType
+        ? InstanceOrPrimitiveOfSchema<
+            Ext[K]
+          > extends InstanceOrPrimitiveOfSchema<Base[K]>
+          ? z.core.input<Ext[K]> extends z.core.input<Base[K]>
+            ? Ext[K]
+            : never
+          : never
+        : never
+      : Ext[K] extends z.core.SomeType
+        ? never
+        : // both are CoValue schemas
+          InstanceOrPrimitiveOfSchema<
+              Ext[K]
+            > extends InstanceOrPrimitiveOfSchema<Base[K]>
+          ? Ext[K]
+          : never
+    : Ext[K];
+};

package/src/tools/implementation/zodSchema/schemaTypes/CoRecordSchema.ts

@@ -13,6 +13,7 @@ import {
   Simplify,
   SubscribeListenerOptions,
   LocalValidationMode,
+  LoadCoValueCursorOption,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { CoFieldSchemaInit } from "../typeConverters/CoFieldSchemaInit.js";
@@ -75,6 +76,7 @@ export interface CoRecordSchema<
       >;
       loadAs?: Account | AnonymousJazzAgent;
       unstable_branch?: BranchDefinition;
+      cursor?: LoadCoValueCursorOption;
     },
   ): Promise<Settled<Resolved<CoRecordInstanceCoValuesMaybeLoaded<K, V>, R>>>;
 

package/src/tools/implementation/zodSchema/schemaTypes/PlainTextSchema.ts

@@ -8,6 +8,8 @@ import {
   coOptionalDefiner,
   unstable_mergeBranchWithResolve,
   withSchemaPermissions,
+  CoValueCursor,
+  LoadCoValueCursorOption,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
@@ -85,6 +87,7 @@ export class PlainTextSchema implements CorePlainTextSchema {
     options: {
       loadAs: Account | AnonymousJazzAgent;
       unstable_branch?: BranchDefinition;
+      cursor?: LoadCoValueCursorOption;
     },
   ): Promise<Settled<CoPlainText>> {
     return this.coValueClass.load(id, options);
@@ -95,6 +98,7 @@ export class PlainTextSchema implements CorePlainTextSchema {
     options: {
       loadAs: Account | AnonymousJazzAgent;
       unstable_branch?: BranchDefinition;
+      cursor?: CoValueCursor;
     },
     listener: (value: CoPlainText, unsubscribe: () => void) => void,
   ): () => void;

package/src/tools/implementation/zodSchema/schemaTypes/RichTextSchema.ts

@@ -7,6 +7,8 @@ import {
   coOptionalDefiner,
   unstable_mergeBranchWithResolve,
   withSchemaPermissions,
+  CoValueCursor,
+  LoadCoValueCursorOption,
 } from "../../../internal.js";
 import { AnonymousJazzAgent } from "../../anonymousJazzAgent.js";
 import { CoOptionalSchema } from "./CoOptionalSchema.js";
@@ -84,6 +86,7 @@ export class RichTextSchema implements CoreRichTextSchema {
     options: {
       loadAs: Account | AnonymousJazzAgent;
       unstable_branch?: BranchDefinition;
+      cursor?: LoadCoValueCursorOption;
     },
   ): Promise<Settled<CoRichText>> {
     return this.coValueClass.load(id, options);
@@ -94,6 +97,7 @@ export class RichTextSchema implements CoreRichTextSchema {
     options: {
       loadAs: Account | AnonymousJazzAgent;
       unstable_branch?: BranchDefinition;
+      cursor?: CoValueCursor;
     },
     listener: (value: CoRichText, unsubscribe: () => void) => void,
   ): () => void;

package/src/tools/implementation/zodSchema/typeConverters/TypeOfZodSchema.ts

@@ -48,9 +48,9 @@ export type TypeOfZodSchema<S extends z.core.$ZodType> =
                     infer Key,
                     infer Value extends z.core.$ZodType
                   >
-                ? {
-                    [key in z.output<Key>]: TypeOfZodSchema<Value>;
-                  }
+                ? Key extends z.core.$partial
+                  ? Partial<Record<z.output<Key>, TypeOfZodSchema<Value>>>
+                  : Record<z.output<Key>, TypeOfZodSchema<Value>>
                 : S extends z.core.$ZodArray<infer Item extends z.core.$ZodType>
                   ? TypeOfZodSchema<Item>[]
                   : S extends z.core.$ZodTuple<

package/src/tools/implementation/zodSchema/zodReExport.ts

@@ -33,6 +33,7 @@ export {
   union,
   discriminatedUnion,
   record,
+  partialRecord,
   intersection,
   int,
   codec,

package/src/tools/subscribe/CoValueCoreSubscription.ts

@@ -1,12 +1,13 @@
 import {
   cojsonInternals,
   CoValueCore,
+  CoValueFrontier,
   isRawCoID,
   LocalNode,
   RawCoID,
   RawCoValue,
 } from "cojson";
-import type { BranchDefinition } from "./types.js";
+import type { BranchDefinition, DecodedCoValueCursor } from "./types.js";
 import { CoValueLoadingState } from "./types.js";
 
 /**
@@ -27,6 +28,7 @@ export class CoValueCoreSubscription {
     value: RawCoValue | typeof CoValueLoadingState.UNAVAILABLE,
   ) => void;
   private skipRetry?: boolean;
+  private frontier?: CoValueFrontier | typeof CoValueLoadingState.UNAVAILABLE;
 
   constructor(
     localNode: LocalNode,
@@ -36,6 +38,7 @@ export class CoValueCoreSubscription {
     ) => void,
     skipRetry?: boolean,
     branch?: BranchDefinition,
+    decodedCursor?: DecodedCoValueCursor,
   ) {
     this.localNode = localNode;
     this.listener = listener;
@@ -44,6 +47,12 @@ export class CoValueCoreSubscription {
     this.branchOwnerId = branch?.owner?.$jazz.raw.id;
     this.source = localNode.getCoValue(id as RawCoID);
 
+    if (decodedCursor) {
+      this.frontier =
+        decodedCursor.frontiers[id as RawCoID] ??
+        CoValueLoadingState.UNAVAILABLE;
+    }
+
     this.initializeSubscription();
   }
 
@@ -188,7 +197,17 @@ export class CoValueCoreSubscription {
     if (value === CoValueLoadingState.UNAVAILABLE) {
       this.listener(CoValueLoadingState.UNAVAILABLE);
     } else if (isCompletelyDownloaded(value)) {
-      this.listener(value.getCurrentContent());
+      const currentContent = value.getCurrentContent();
+
+      if (this.frontier) {
+        this.listener(
+          this.frontier === CoValueLoadingState.UNAVAILABLE
+            ? CoValueLoadingState.UNAVAILABLE
+            : currentContent.atFrontier(this.frontier),
+        );
+      } else {
+        this.listener(currentContent);
+      }
     }
   }