@skipruntime/core 0.0.16 → 0.0.17

package/src/index.ts

@@ -26,7 +26,6 @@ import {
   type Context,
   type EagerCollection,
   type Entry,
-  type ExternalService,
   type LazyCollection,
   type LazyCompute,
   type Mapper,
@@ -37,6 +36,7 @@ import {
   type Resource,
   type SkipService,
   type Watermark,
+  type ExternalService,
 } from "./api.js";
 
 import {
@@ -46,25 +46,26 @@ import {
   SkipResourceInstanceInUseError,
   SkipUnknownCollectionError,
 } from "./errors.js";
-import {
-  ResourceBuilder,
-  type Notifier,
-  type Executor,
-  type Handle,
-  type FromBinding,
-} from "./binding.js";
+import { type Notifier, type Handle, type FromBinding } from "./binding.js";
 
 export * from "./api.js";
 export * from "./errors.js";
 
 export type JSONMapper = Mapper<Json, Json, Json, Json>;
 export type JSONLazyCompute = LazyCompute<Json, Json>;
+export type JSONOperator = JSONMapper | JSONLazyCompute | Reducer<Json, Json>;
+
+export type HandlerInfo<P> = {
+  object: P;
+  name: string;
+  params: DepSafe[];
+};
 
 function instantiateUserObject<Params extends DepSafe[], Result extends object>(
   what: string,
   ctor: new (...params: Params) => Result,
   params: Params,
-): Result {
+): HandlerInfo<Result> {
   const checkedParams = params.map(checkOrCloneParam) as Params;
   const obj = new ctor(...checkedParams);
   Object.freeze(obj);
@@ -73,7 +74,118 @@ function instantiateUserObject<Params extends DepSafe[], Result extends object>(
       `${what} classes must be defined at top-level.`,
     );
   }
-  return obj;
+  return {
+    object: obj,
+    name: obj.constructor.name,
+    params: checkedParams,
+  };
+}
+
+export enum LoadStatus {
+  Incompatible,
+  Changed,
+  Same,
+}
+
+export interface ChangeManager {
+  needInputReload(name: string): boolean;
+  needResourceReload(name: string): LoadStatus;
+  needExternalServiceReload(name: string, resource: string): boolean;
+  needMapperReload(name: string): boolean;
+  needReducerReload(name: string): boolean;
+  needLazyComputeReload(name: string): boolean;
+}
+
+export class ServiceDefinition {
+  constructor(
+    private service: SkipService,
+    private readonly externals: Map<string, ExternalService> = new Map(),
+  ) {}
+
+  buildResource(name: string, parameters: Json): Resource {
+    const builder = this.service.resources[name];
+    if (!builder) throw new Error(`Resource '${name}' not exist.`);
+    return new builder(parameters);
+  }
+
+  inputs(): string[] {
+    return this.service.initialData
+      ? Object.keys(this.service.initialData)
+      : [];
+  }
+
+  resources(): string[] {
+    return Object.keys(this.service.resources);
+  }
+
+  initialData(name: string): Entry<Json, Json>[] {
+    if (!this.service.initialData) throw new Error(`No initial data defined.`);
+    const data = this.service.initialData[name];
+    if (!data) throw new Error(`Initial data '${name}' not exist.`);
+    return data;
+  }
+
+  createGraph(
+    inputCollections: NamedCollections,
+    context: Context,
+  ): NamedCollections {
+    return this.service.createGraph(inputCollections, context);
+  }
+
+  subscribe(
+    external: string,
+    writer: CollectionWriter<Json, Json>,
+    instance: string,
+    resource: string,
+    params: Json,
+  ): Promise<void> {
+    if (!this.service.externalServices)
+      throw new Error(`No external services defined.`);
+    const supplier = this.service.externalServices[external];
+    if (!supplier)
+      throw new Error(`External services '${external}' not exist.`);
+    this.externals.set(`${external}/${instance}`, supplier);
+    // Ensure notification is made outside the current context update
+    return new Promise((resolve, reject) => {
+      setTimeout(() => {
+        supplier
+          .subscribe(instance, resource, params, {
+            update: writer.update.bind(writer),
+            error: (_) => {},
+          })
+          .then(resolve)
+          .catch(reject);
+      }, 0);
+    });
+  }
+
+  unsubscribe(external: string, instance: string) {
+    if (!this.service.externalServices)
+      throw new Error(`No external services defined.`);
+    const supplier = this.externals.get(`${external}/${instance}`);
+    if (!supplier)
+      throw new Error(`External services '${external}/${instance}' not exist.`);
+    supplier.unsubscribe(instance);
+    this.externals.delete(`${external}/${instance}`);
+  }
+
+  async shutdown(): Promise<void> {
+    const promises: Promise<void>[] = [];
+    const uniqueServices = new Set(this.externals.values());
+    if (this.service.externalServices) {
+      for (const es of Object.values(this.service.externalServices)) {
+        uniqueServices.add(es);
+      }
+    }
+    for (const es of uniqueServices) {
+      promises.push(es.shutdown());
+    }
+    await Promise.all(promises);
+  }
+
+  derive(service: SkipService): ServiceDefinition {
+    return new ServiceDefinition(service, new Map(this.externals));
+  }
 }
 
 class Handles {
@@ -122,35 +234,27 @@ export class Stack {
   }
 }
 
-export class Refs {
-  constructor(
-    public readonly binding: FromBinding,
-    public readonly skjson: JsonConverter,
-    public readonly handles: Handles,
-    public readonly needGC: () => boolean,
-    public readonly runWithGC: <T>(fn: () => T) => T,
-  ) {}
-}
-
 class LazyCollectionImpl<K extends Json, V extends Json>
   extends SkManaged
   implements LazyCollection<K, V>
 {
   constructor(
-    private readonly lazyCollection: string,
-    private readonly refs: Refs,
+    readonly lazyCollection: string,
+    private readonly refs: ToBinding,
   ) {
     super();
     Object.freeze(this);
   }
 
   getArray(key: K): (V & DepSafe)[] {
-    return this.refs.skjson.importJSON(
-      this.refs.binding.SkipRuntime_LazyCollection__getArray(
-        this.lazyCollection,
-        this.refs.skjson.exportJSON(key),
-      ),
-    ) as (V & DepSafe)[];
+    return this.refs
+      .json()
+      .importJSON(
+        this.refs.binding.SkipRuntime_LazyCollection__getArray(
+          this.lazyCollection,
+          this.refs.json().exportJSON(key),
+        ),
+      ) as (V & DepSafe)[];
   }
 
   getUnique(key: K, _default?: { ifNone?: V; ifMany?: V }): V & DepSafe {
@@ -174,19 +278,21 @@ class EagerCollectionImpl<K extends Json, V extends Json>
 {
   constructor(
     public readonly collection: string,
-    private readonly refs: Refs,
+    private readonly refs: ToBinding,
   ) {
     super();
     Object.freeze(this);
   }
 
   getArray(key: K): (V & DepSafe)[] {
-    return this.refs.skjson.importJSON(
-      this.refs.binding.SkipRuntime_Collection__getArray(
-        this.collection,
-        this.refs.skjson.exportJSON(key),
-      ),
-    ) as (V & DepSafe)[];
+    return this.refs
+      .json()
+      .importJSON(
+        this.refs.binding.SkipRuntime_Collection__getArray(
+          this.collection,
+          this.refs.json().exportJSON(key),
+        ),
+      ) as (V & DepSafe)[];
   }
 
   getUnique(key: K, _default?: { ifNone?: V; ifMany?: V }): V & DepSafe {
@@ -216,7 +322,7 @@ class EagerCollectionImpl<K extends Json, V extends Json>
   slices(...ranges: [K, K][]): EagerCollection<K, V> {
     const skcollection = this.refs.binding.SkipRuntime_Collection__slice(
       this.collection,
-      this.refs.skjson.exportJSON(ranges),
+      this.refs.json().exportJSON(ranges),
     );
     return this.derive<K, V>(skcollection);
   }
@@ -263,18 +369,20 @@ class EagerCollectionImpl<K extends Json, V extends Json>
         this.refs.handles.register(mapperObj),
       );
 
-      if (sknative in reducerObj && typeof reducerObj[sknative] == "string") {
+      if (
+        sknative in reducerObj.object &&
+        typeof reducerObj.object[sknative] == "string"
+      ) {
         return this.derive<K2, Accum>(
           this.refs.binding.SkipRuntime_Collection__nativeMapReduce(
             this.collection,
             skmapper,
-            reducerObj[sknative],
+            reducerObj.object[sknative],
           ),
         );
       } else {
         const skreducer = this.refs.binding.SkipRuntime_createReducer(
           this.refs.handles.register(reducerObj),
-          this.refs.skjson.exportJSON(reducerObj.initial),
         );
         return this.derive<K2, Accum>(
           this.refs.binding.SkipRuntime_Collection__mapReduce(
@@ -292,17 +400,19 @@ class EagerCollectionImpl<K extends Json, V extends Json>
     ...params: Params
   ): EagerCollection<K, Accum> {
     const reducerObj = instantiateUserObject("Reducer", reducer, params);
-    if (sknative in reducerObj && typeof reducerObj[sknative] == "string") {
+    if (
+      sknative in reducerObj.object &&
+      typeof reducerObj.object[sknative] == "string"
+    ) {
       return this.derive<K, Accum>(
         this.refs.binding.SkipRuntime_Collection__nativeReduce(
           this.collection,
-          reducerObj[sknative],
+          reducerObj.object[sknative],
         ),
       );
     } else {
       const skreducer = this.refs.binding.SkipRuntime_createReducer(
         this.refs.handles.register(reducerObj),
-        this.refs.skjson.exportJSON(reducerObj.initial),
       );
       return this.derive<K, Accum>(
         this.refs.binding.SkipRuntime_Collection__reduce(
@@ -319,7 +429,7 @@ class EagerCollectionImpl<K extends Json, V extends Json>
     );
     const mapped = this.refs.binding.SkipRuntime_Collection__merge(
       this.collection,
-      this.refs.skjson.exportJSON(otherNames),
+      this.refs.json().exportJSON(otherNames),
     );
     return this.derive<K, V>(mapped);
   }
@@ -340,72 +450,71 @@ class EagerCollectionImpl<K extends Json, V extends Json>
 class CollectionWriter<K extends Json, V extends Json> {
   constructor(
     public readonly collection: string,
-    private readonly refs: Refs,
+    private readonly refs: ToBinding,
+    private forkName: Nullable<string>,
   ) {}
 
   async update(values: Entry<K, V>[], isInit: boolean): Promise<void> {
-    await new Promise<void>((resolve, reject) => {
-      if (!this.refs.needGC()) {
-        reject(new SkipError("CollectionWriter.update cannot be performed."));
-      }
-      const errorHdl = this.refs.runWithGC(() => {
-        const exHdl = this.refs.handles.register({
-          resolve,
-          reject: (ex: Error) => reject(ex),
-        });
-        return this.refs.binding.SkipRuntime_CollectionWriter__update(
-          this.collection,
-          this.refs.skjson.exportJSON(values),
-          isInit,
-          this.refs.binding.SkipRuntime_createExecutor(exHdl),
-        );
-      });
-      if (errorHdl) reject(this.refs.handles.deleteHandle(errorHdl));
-    });
+    this.refs.setFork(this.forkName);
+    const uuid = crypto.randomUUID();
+    const fork = this.fork(uuid);
+    try {
+      await fork.update_(values, isInit);
+      fork.merge();
+    } catch (ex: unknown) {
+      fork.abortFork();
+      throw ex;
+    }
   }
 
-  error(error: unknown): void {
+  private update_(values: Entry<K, V>[], isInit: boolean): Promise<void> {
+    this.refs.setFork(this.getForkName());
     if (!this.refs.needGC()) {
       throw new SkipError("CollectionWriter.update cannot be performed.");
     }
-    const errorHdl = this.refs.runWithGC(() =>
-      this.refs.binding.SkipRuntime_CollectionWriter__error(
+    return this.refs.runAsync(() =>
+      this.refs.binding.SkipRuntime_CollectionWriter__update(
         this.collection,
-        this.refs.skjson.exportJSON(this.toJSONError(error)),
+        this.refs.json().exportJSON(values),
+        isInit,
       ),
     );
-    if (errorHdl) throw this.refs.handles.deleteHandle(errorHdl);
   }
 
-  initialized(error?: unknown): void {
-    if (!this.refs.needGC()) {
-      throw new SkipError("CollectionWriter.update cannot be performed.");
-    }
-    const errorHdl = this.refs.runWithGC(() =>
-      this.refs.binding.SkipRuntime_CollectionWriter__initialized(
-        this.collection,
-        this.refs.skjson.exportJSON(error ? this.toJSONError(error) : null),
-      ),
-    );
-    if (errorHdl) throw this.refs.handles.deleteHandle(errorHdl);
+  private fork(name: string): CollectionWriter<K, V> {
+    this.refs.setFork(this.forkName);
+    this.refs.fork(name);
+    return new CollectionWriter(this.collection, this.refs, name);
   }
 
-  private toJSONError(error: unknown): Json {
-    if (error instanceof Error) return error.message;
-    if (typeof error == "number") return error;
-    if (typeof error == "boolean") return error;
-    if (typeof error == "string") return error;
-    return JSON.parse(
-      JSON.stringify(error, Object.getOwnPropertyNames(error)),
-    ) as Json;
+  private merge(): void {
+    if (!this.forkName) throw new Error("Unable to merge fork on main.");
+    this.refs.setFork(this.forkName);
+    this.refs.merge();
   }
-}
 
-class ContextImpl extends SkManaged implements Context {
-  constructor(private readonly refs: Refs) {
-    super();
-    Object.freeze(this);
+  private abortFork(): void {
+    if (!this.forkName) throw new Error("Unable to abord fork on main.");
+    this.refs.setFork(this.forkName);
+    this.refs.abortFork();
+  }
+
+  private getForkName(): Nullable<string> {
+    const forkName = this.forkName;
+    if (!forkName) return null;
+    if (
+      !this.refs.runWithGC(() =>
+        this.refs.binding.SkipRuntime_Runtime__forkExists(forkName),
+      )
+    ) {
+      this.forkName = null;
+    }
+    return this.forkName;
   }
+}
+
+class ContextImpl implements Context {
+  constructor(private readonly refs: ToBinding) {}
 
   createLazyCollection<
     K extends Json,
@@ -433,15 +542,16 @@ class ContextImpl extends SkManaged implements Context {
       this.refs.binding.SkipRuntime_Context__useExternalResource(
         resource.service,
         resource.identifier,
-        this.refs.skjson.exportJSON(resource.params ?? {}),
+        this.refs.json().exportJSON(resource.params ?? {}),
       );
     return new EagerCollectionImpl<K, V>(collection, this.refs);
   }
 
   jsonExtract(value: JsonObject, pattern: string): Json[] {
-    return this.refs.skjson.importJSON(
+    const skjson = this.refs.json();
+    return skjson.importJSON(
       this.refs.binding.SkipRuntime_Context__jsonExtract(
-        this.refs.skjson.exportJSON(value),
+        skjson.exportJSON(value),
         pattern,
       ),
     ) as Json[];
@@ -456,46 +566,39 @@ export class ServiceInstanceFactory {
   }
 }
 
-type GetResult<T> = {
-  payload: T;
-  errors: Json[];
-};
-
-export type SubscriptionID = Opaque<bigint, "subscription">;
+export type SubscriptionID = Opaque<string, "subscription">;
 
 /**
  * A `ServiceInstance` is a running instance of a `SkipService`, providing access to its resources
  * and operations to manage subscriptions and the service itself.
  */
 export class ServiceInstance {
-  constructor(private readonly refs: Refs) {}
+  constructor(
+    private readonly refs: ToBinding,
+    readonly forkName: Nullable<string>,
+    private definition: ServiceDefinition,
+  ) {}
 
   /**
    * Instantiate a resource with some parameters and client session authentication token
    * @param identifier - The resource instance identifier
    * @param resource - A resource name, which must correspond to a key in this `SkipService`'s `resources` field
    * @param params - Resource parameters, which will be passed to the resource constructor specified in this `SkipService`'s `resources` field
+   * @returns The resulting promise
    */
   instantiateResource(
     identifier: string,
     resource: string,
     params: Json,
   ): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const errorHdl = this.refs.runWithGC(() => {
-        const exHdl = this.refs.handles.register({
-          resolve,
-          reject: (ex: Error) => reject(ex),
-        });
-        return this.refs.binding.SkipRuntime_Runtime__createResource(
-          identifier,
-          resource,
-          this.refs.skjson.exportJSON(params),
-          this.refs.binding.SkipRuntime_createExecutor(exHdl),
-        );
-      });
-      if (errorHdl) reject(this.refs.handles.deleteHandle(errorHdl));
-    });
+    this.refs.setFork(this.forkName);
+    return this.refs.runAsync(() =>
+      this.refs.binding.SkipRuntime_Runtime__createResource(
+        identifier,
+        resource,
+        this.refs.json().exportJSON(params),
+      ),
+    );
   }
 
   /**
@@ -511,21 +614,21 @@ export class ServiceInstance {
     const uuid = crypto.randomUUID();
     await this.instantiateResource(uuid, resource, params);
     try {
+      this.refs.setFork(this.forkName);
       const result = this.refs.runWithGC(() => {
-        return this.refs.skjson.importJSON(
-          this.refs.binding.SkipRuntime_Runtime__getAll(
-            resource,
-            this.refs.skjson.exportJSON(params),
-          ),
-          true,
-        );
+        return this.refs
+          .json()
+          .importJSON(
+            this.refs.binding.SkipRuntime_Runtime__getAll(
+              resource,
+              this.refs.json().exportJSON(params),
+            ),
+            true,
+          );
       });
       if (typeof result == "number")
         throw this.refs.handles.deleteHandle(result as Handle<Error>);
-      const info = result as GetResult<Entry<K, V>[]>;
-      if (info.errors.length > 0)
-        throw new SkipError(JSON.stringify(info.errors));
-      return info.payload;
+      return result as Entry<K, V>[];
     } finally {
       this.closeResourceInstance(uuid);
     }
@@ -546,22 +649,21 @@ export class ServiceInstance {
     const uuid = crypto.randomUUID();
     await this.instantiateResource(uuid, resource, params);
     try {
+      this.refs.setFork(this.forkName);
+      const skjson = this.refs.json();
       const result = this.refs.runWithGC(() => {
-        return this.refs.skjson.importJSON(
+        return skjson.importJSON(
           this.refs.binding.SkipRuntime_Runtime__getForKey(
             resource,
-            this.refs.skjson.exportJSON(params),
-            this.refs.skjson.exportJSON(key),
+            skjson.exportJSON(params),
+            skjson.exportJSON(key),
           ),
           true,
         );
       });
       if (typeof result == "number")
         throw this.refs.handles.deleteHandle(result as Handle<Error>);
-      const info = result as GetResult<V[]>;
-      if (info.errors.length > 0)
-        throw new SkipError(JSON.stringify(info.errors));
-      return info.payload;
+      return result as V[];
     } finally {
       this.closeResourceInstance(uuid);
     }
@@ -572,6 +674,7 @@ export class ServiceInstance {
    * @param resourceInstanceId - The resource identifier
    */
   closeResourceInstance(resourceInstanceId: string): void {
+    this.refs.setFork(this.forkName);
     const errorHdl = this.refs.runWithGC(() => {
       return this.refs.binding.SkipRuntime_Runtime__closeResource(
         resourceInstanceId,
@@ -599,6 +702,7 @@ export class ServiceInstance {
     },
     watermark?: string,
   ): SubscriptionID {
+    this.refs.setFork(this.forkName);
     const session = this.refs.runWithGC(() => {
       const sknotifier = this.refs.binding.SkipRuntime_createNotifier(
         this.refs.handles.register(notifier),
@@ -620,7 +724,7 @@ export class ServiceInstance {
     } else if (session < 0n) {
       throw this.refs.handles.deleteHandle(Number(-session) as Handle<Error>);
     }
-    return session as SubscriptionID;
+    return resourceInstanceId as SubscriptionID;
   }
 
   /**
@@ -628,6 +732,7 @@ export class ServiceInstance {
    * @param id - The subscription identifier returned by a call to `subscribe`
    */
   unsubscribe(id: SubscriptionID): void {
+    this.refs.setFork(this.forkName);
     const errorHdl = this.refs.runWithGC(() => {
       return this.refs.binding.SkipRuntime_Runtime__unsubscribe(id);
     });
@@ -641,24 +746,45 @@ export class ServiceInstance {
    * @param collection - the name of the input collection to update
    * @param entries - entries to update in the collection.
    */
-  update<K extends Json, V extends Json>(
+  async update<K extends Json, V extends Json>(
     collection: string,
     entries: Entry<K, V>[],
   ): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const errorHdl = this.refs.runWithGC(() => {
-        const exHdl = this.refs.handles.register({
-          resolve,
-          reject: (ex: Error) => reject(ex),
-        });
-        return this.refs.binding.SkipRuntime_Runtime__update(
+    this.refs.setFork(this.forkName);
+    const uuid = crypto.randomUUID();
+    const fork = this.fork(uuid);
+    try {
+      await fork.update_(collection, entries);
+      fork.merge([]);
+    } catch (ex: unknown) {
+      fork.abortFork();
+      throw ex;
+    }
+  }
+
+  private async update_<K extends Json, V extends Json>(
+    collection: string,
+    entries: Entry<K, V>[],
+  ): Promise<void> {
+    this.refs.setFork(this.forkName);
+    const result = this.refs.runWithGC(() => {
+      const json = this.refs.json();
+      return json.importJSON(
+        this.refs.binding.SkipRuntime_Runtime__update(
           collection,
-          this.refs.skjson.exportJSON(entries),
-          this.refs.binding.SkipRuntime_createExecutor(exHdl),
-        );
-      });
-      if (errorHdl) reject(this.refs.handles.deleteHandle(errorHdl));
+          this.refs.json().exportJSON(entries),
+        ),
+        true,
+      );
     });
+    if (Array.isArray(result)) {
+      const handles = result as Handle<Promise<void>>[];
+      const promises = handles.map((h) => this.refs.handles.deleteHandle(h));
+      await Promise.all(promises);
+    } else {
+      const errorHdl = result as Handle<Error>;
+      throw this.refs.handles.deleteHandle(errorHdl);
+    }
   }
 
   /**
@@ -667,21 +793,99 @@ export class ServiceInstance {
    * @returns The promise of externals services shutdowns
    */
   close(): Promise<unknown> {
+    this.refs.setFork(this.forkName);
     const result = this.refs.runWithGC(() => {
-      return this.refs.skjson.importJSON(
-        this.refs.binding.SkipRuntime_closeService(),
-        true,
-      );
+      return this.refs.binding.SkipRuntime_closeService();
+    });
+    if (result >= 0) {
+      return this.refs.handles.deleteHandle(result as Handle<Promise<unknown>>);
+    } else {
+      const errorHdl = -(result as number) as Handle<Error>;
+      return Promise.reject(this.refs.handles.deleteHandle(errorHdl));
+    }
+  }
+
+  async reload(service: SkipService, changes: ChangeManager): Promise<void> {
+    if (this.forkName) {
+      throw new SkipError("Reload cannot be called in transaction.");
+    }
+    const definition = this.definition.derive(service);
+    this.refs.setFork(this.forkName);
+    const uuid = crypto.randomUUID();
+    const fork = this.fork(uuid);
+    let merged = false;
+    try {
+      const streamsToClose = await fork._reload(definition, changes);
+      fork.merge(streamsToClose);
+      merged = true;
+      this.closeResourceStreams(streamsToClose);
+      this.definition = definition;
+    } catch (ex: unknown) {
+      console.error(ex);
+      if (!merged) fork.abortFork();
+      throw ex;
+    }
+  }
+
+  private async _reload(
+    definition: ServiceDefinition,
+    changes: ChangeManager,
+  ): Promise<string[]> {
+    this.refs.setFork(this.forkName);
+    const result = this.refs.runWithGC(() => {
+      this.refs.changes = this.refs.handles.register(changes);
+      const skservicehHdl = this.refs.handles.register(definition);
+      const skservice =
+        this.refs.binding.SkipRuntime_createService(skservicehHdl);
+      const res = this.refs.binding.SkipRuntime_Runtime__reload(skservice);
+      this.refs.handles.deleteHandle(this.refs.changes);
+      this.refs.changes = null;
+      return this.refs.json().importJSON(res, true);
     });
     if (Array.isArray(result)) {
-      const handles = result as Handle<Promise<void>>[];
+      const [handles, res] = result as [Handle<Promise<void>>[], string[]];
       const promises = handles.map((h) => this.refs.handles.deleteHandle(h));
-      return Promise.all(promises);
+      await Promise.all(promises);
+      return res;
     } else {
       const errorHdl = result as Handle<Error>;
-      return Promise.reject(this.refs.handles.deleteHandle(errorHdl));
+      throw this.refs.handles.deleteHandle(errorHdl);
     }
   }
+
+  /**
+   * Fork the service with current specified name.
+   * @param name - the name of the fork.
+   * @returns The forked ServiceInstance
+   */
+  private fork(name: string): ServiceInstance {
+    if (this.forkName) throw new Error(`Unable to fork ${this.forkName}.`);
+    this.refs.setFork(this.forkName);
+    this.refs.fork(name);
+    return new ServiceInstance(this.refs, name, this.definition);
+  }
+
+  private merge(ignore: string[]): void {
+    if (!this.forkName) throw new Error("Unable to merge fork on main.");
+    this.refs.setFork(this.forkName);
+    this.refs.merge(ignore);
+  }
+
+  private abortFork(): void {
+    if (!this.forkName) throw new Error("Unable to abord fork on main.");
+    this.refs.setFork(this.forkName);
+    this.refs.abortFork();
+  }
+
+  private closeResourceStreams(streams: string[]): void {
+    this.refs.setFork(this.forkName);
+    const errorHdl = this.refs.runWithGC(() => {
+      return this.refs.binding.SkipRuntime_Runtime__closeResourceStreams(
+        this.refs.json().exportJSON(streams),
+      );
+    });
+    if (errorHdl) throw this.refs.handles.deleteHandle(errorHdl);
+  }
 }
 
 class ValuesImpl<T> implements Values<T> {
@@ -758,17 +962,21 @@ class ValuesImpl<T> implements Values<T> {
 
 export class ToBinding {
   private readonly stack: Stack;
-  private readonly handles: Handles;
   private skjson?: JsonConverter;
+  private forkName: Nullable<string>;
+  readonly handles: Handles;
+  changes: Nullable<Handle<ChangeManager>>;
 
   constructor(
-    private binding: FromBinding,
-    private runWithGC: <T>(fn: () => T) => T,
+    public binding: FromBinding,
+    public runWithGC: <T>(fn: () => T) => T,
     private getConverter: () => JsonConverter,
     private getError: (skExc: Pointer<Internal.Exception>) => Error,
   ) {
     this.stack = new Stack();
     this.handles = new Handles();
+    this.forkName = null;
+    this.changes = null;
   }
 
   register<T>(v: T): Handle<T> {
@@ -795,17 +1003,29 @@ export class ToBinding {
     return this.stack.get();
   }
 
+  SkipRuntime_getFork(): Nullable<string> {
+    return this.forkName;
+  }
+
+  SkipRuntime_getChangeManager(): number {
+    return this.changes ?? 0;
+  }
+
+  setFork(name: Nullable<string>): void {
+    this.forkName = name;
+  }
+
   // Mapper
 
   SkipRuntime_Mapper__mapEntry(
-    skmapper: Handle<JSONMapper>,
+    skmapper: Handle<HandlerInfo<JSONMapper>>,
     key: Pointer<Internal.CJSON>,
     values: Pointer<Internal.NonEmptyIterator>,
   ): Pointer<Internal.CJArray> {
     const skjson = this.getJsonConverter();
     const mapper = this.handles.get(skmapper);
-    const context = new ContextImpl(this.refs());
-    const result = mapper.mapEntry(
+    const context = new ContextImpl(this);
+    const result = mapper.object.mapEntry(
       skjson.importJSON(key) as Json,
       new ValuesImpl<Json>(skjson, this.binding, values),
       context,
@@ -813,27 +1033,65 @@ export class ToBinding {
     return skjson.exportJSON(Array.from(result));
   }
 
-  SkipRuntime_deleteMapper(mapper: Handle<JSONMapper>): void {
+  SkipRuntime_Mapper__getInfo(
+    skmapper: Handle<HandlerInfo<JSONMapper>>,
+  ): Pointer<Internal.CJObject> {
+    return this.getInfo(skmapper);
+  }
+
+  SkipRuntime_Mapper__isEquals(
+    mapper: Handle<HandlerInfo<JSONMapper>>,
+    other: Handle<HandlerInfo<JSONMapper>>,
+  ): number {
+    const object = this.handles.get(mapper);
+    if (this.getChanges()?.needMapperReload(object.name)) {
+      return 0;
+    }
+    return this.isEquals(mapper, other);
+  }
+
+  SkipRuntime_deleteMapper(mapper: Handle<HandlerInfo<JSONMapper>>): void {
     this.handles.deleteHandle(mapper);
   }
 
   // LazyCompute
 
   SkipRuntime_LazyCompute__compute(
-    sklazyCompute: Handle<JSONLazyCompute>,
+    sklazyCompute: Handle<HandlerInfo<JSONLazyCompute>>,
     self: string,
     skkey: Pointer<Internal.CJSON>,
   ): Pointer<Internal.CJArray> {
     const skjson = this.getJsonConverter();
     const lazyCompute = this.handles.get(sklazyCompute);
-    const result = lazyCompute.compute(
-      new LazyCollectionImpl<Json, Json>(self, this.refs()),
+    const context = new ContextImpl(this);
+    const result = lazyCompute.object.compute(
+      new LazyCollectionImpl<Json, Json>(self, this),
       skjson.importJSON(skkey) as Json,
+      context,
     );
     return skjson.exportJSON(Array.from(result));
   }
 
-  SkipRuntime_deleteLazyCompute(lazyCompute: Handle<JSONLazyCompute>): void {
+  SkipRuntime_LazyCompute__getInfo(
+    lazyCompute: Handle<HandlerInfo<JSONLazyCompute>>,
+  ): Pointer<Internal.CJObject> {
+    return this.getInfo(lazyCompute);
+  }
+
+  SkipRuntime_LazyCompute__isEquals(
+    lazyCompute: Handle<HandlerInfo<JSONLazyCompute>>,
+    other: Handle<HandlerInfo<JSONLazyCompute>>,
+  ): number {
+    const object = this.handles.get(lazyCompute);
+    if (this.getChanges()?.needLazyComputeReload(object.name)) {
+      return 0;
+    }
+    return this.isEquals(lazyCompute, other);
+  }
+
+  SkipRuntime_deleteLazyCompute(
+    lazyCompute: Handle<HandlerInfo<JSONLazyCompute>>,
+  ): void {
     this.handles.deleteHandle(lazyCompute);
   }
 
@@ -849,11 +1107,10 @@ export class ToBinding {
     const keysIds = skjson.importJSON(skcollections) as {
       [key: string]: string;
     };
-    const refs = this.refs();
     for (const [key, name] of Object.entries(keysIds)) {
-      collections[key] = new EagerCollectionImpl<Json, Json>(name, refs);
+      collections[key] = new EagerCollectionImpl<Json, Json>(name, this);
     }
-    const collection = resource.instantiate(collections, new ContextImpl(refs));
+    const collection = resource.instantiate(collections, new ContextImpl(this));
     return EagerCollectionImpl.getName(collection);
   }
 
@@ -861,28 +1118,10 @@ export class ToBinding {
     this.handles.deleteHandle(resource);
   }
 
-  // ResourceBuilder
+  // ServiceDefinition
 
-  SkipRuntime_ResourceBuilder__build(
-    skbuilder: Handle<ResourceBuilder>,
-    skparams: Pointer<Internal.CJObject>,
-  ): Pointer<Internal.Resource> {
-    const skjson = this.getJsonConverter();
-    const builder = this.handles.get(skbuilder);
-    const resource = builder.build(skjson.importJSON(skparams) as Json);
-    return this.binding.SkipRuntime_createResource(
-      this.handles.register(resource),
-    );
-  }
-
-  SkipRuntime_deleteResourceBuilder(builder: Handle<ResourceBuilder>): void {
-    this.handles.deleteHandle(builder);
-  }
-
-  // Service
-
-  SkipRuntime_Service__createGraph(
-    skservice: Handle<SkipService>,
+  SkipRuntime_ServiceDefinition__createGraph(
+    skservice: Handle<ServiceDefinition>,
     skcollections: Pointer<Internal.CJObject>,
   ): Pointer<Internal.CJObject> {
     const skjson = this.getJsonConverter();
@@ -891,11 +1130,10 @@ export class ToBinding {
     const keysIds = skjson.importJSON(skcollections) as {
       [key: string]: string;
     };
-    const refs = this.refs();
     for (const [key, name] of Object.entries(keysIds)) {
-      collections[key] = new EagerCollectionImpl<Json, Json>(name, refs);
+      collections[key] = new EagerCollectionImpl<Json, Json>(name, this);
     }
-    const result = service.createGraph(collections, new ContextImpl(refs));
+    const result = service.createGraph(collections, new ContextImpl(this));
     const collectionsNames: { [name: string]: string } = {};
     for (const [name, collection] of Object.entries(result)) {
       collectionsNames[name] = EagerCollectionImpl.getName(collection);
@@ -903,10 +1141,111 @@ export class ToBinding {
     return skjson.exportJSON(collectionsNames);
   }
 
-  SkipRuntime_deleteService(service: Handle<SkipService>): void {
+  SkipRuntime_ServiceDefinition__inputs(
+    skservice: Handle<ServiceDefinition>,
+  ): Pointer<Internal.CJArray<Internal.CJSON>> {
+    const skjson = this.getJsonConverter();
+    const service = this.handles.get(skservice);
+    return skjson.exportJSON(service.inputs());
+  }
+
+  SkipRuntime_ServiceDefinition__resources(
+    skservice: Handle<ServiceDefinition>,
+  ): Pointer<Internal.CJArray<Internal.CJSON>> {
+    const skjson = this.getJsonConverter();
+    const service = this.handles.get(skservice);
+    return skjson.exportJSON(service.resources());
+  }
+
+  SkipRuntime_ServiceDefinition__initialData(
+    skservice: Handle<ServiceDefinition>,
+    name: string,
+  ): Pointer<Internal.CJArray<Internal.CJSON>> {
+    const skjson = this.getJsonConverter();
+    const service = this.handles.get(skservice);
+    return skjson.exportJSON(service.initialData(name));
+  }
+
+  SkipRuntime_ServiceDefinition__buildResource(
+    skservice: Handle<ServiceDefinition>,
+    name: string,
+    skparams: Pointer<Internal.CJObject>,
+  ): Pointer<Internal.Resource> {
+    const skjson = this.getJsonConverter();
+    const service = this.handles.get(skservice);
+    const resource = service.buildResource(
+      name,
+      skjson.importJSON(skparams) as Json,
+    );
+    return this.binding.SkipRuntime_createResource(
+      this.handles.register(resource),
+    );
+  }
+
+  SkipRuntime_ServiceDefinition__subscribe(
+    skservice: Handle<ServiceDefinition>,
+    external: string,
+    writerId: string,
+    instance: string,
+    resource: string,
+    skparams: Pointer<Internal.CJObject>,
+  ): Handle<Promise<void>> {
+    const skjson = this.getJsonConverter();
+    const service = this.handles.get(skservice);
+    const writer = new CollectionWriter(writerId, this, this.forkName);
+    const params = skjson.importJSON(skparams, true) as Json;
+    return this.handles.register(
+      service.subscribe(external, writer, instance, resource, params),
+    );
+  }
+
+  SkipRuntime_ServiceDefinition__unsubscribe(
+    skservice: Handle<ServiceDefinition>,
+    external: string,
+    instance: string,
+  ): void {
+    const service = this.handles.get(skservice);
+    service.unsubscribe(external, instance);
+  }
+
+  SkipRuntime_ServiceDefinition__shutdown(
+    skservice: Handle<ServiceDefinition>,
+  ): Handle<Promise<unknown>> {
+    const service = this.handles.get(skservice);
+    return this.handles.register(service.shutdown());
+  }
+
+  SkipRuntime_deleteService(service: Handle<ServiceDefinition>): void {
     this.handles.deleteHandle(service);
   }
 
+  // Change manager
+
+  SkipRuntime_ChangeManager__needInputReload(
+    skmanager: Handle<ChangeManager>,
+    name: string,
+  ): number {
+    const manager = this.handles.get(skmanager);
+    return manager.needInputReload(name) ? 1 : 0;
+  }
+
+  SkipRuntime_ChangeManager__needResourceReload(
+    skmanager: Handle<ChangeManager>,
+    name: string,
+  ): number {
+    const manager = this.handles.get(skmanager);
+    return manager.needResourceReload(name);
+  }
+
+  SkipRuntime_ChangeManager__needExternalServiceReload(
+    skmanager: Handle<ChangeManager>,
+    name: string,
+    resource: string,
+  ): number {
+    const manager = this.handles.get(skmanager);
+    return manager.needExternalServiceReload(name, resource) ? 1 : 0;
+  }
+
   // Notifier
 
   SkipRuntime_Notifier__subscribed<K extends Json, V extends Json>(
@@ -948,15 +1287,23 @@ export class ToBinding {
 
   // Reducer
 
+  SkipRuntime_Reducer__init(
+    skreducer: Handle<HandlerInfo<Reducer<Json, Json>>>,
+  ): Pointer<Internal.CJSON> {
+    const skjson = this.getJsonConverter();
+    const reducer = this.handles.get(skreducer);
+    return skjson.exportJSON(reducer.object.initial);
+  }
+
   SkipRuntime_Reducer__add(
-    skreducer: Handle<Reducer<Json, Json>>,
+    skreducer: Handle<HandlerInfo<Reducer<Json, Json>>>,
     skacc: Nullable<Pointer<Internal.CJSON>>,
     skvalue: Pointer<Internal.CJSON>,
   ): Pointer<Internal.CJSON> {
     const skjson = this.getJsonConverter();
     const reducer = this.handles.get(skreducer);
     return skjson.exportJSON(
-      reducer.add(
+      reducer.object.add(
         skacc ? (skjson.importJSON(skacc) as Json) : null,
         skjson.importJSON(skvalue) as Json & DepSafe,
       ),
@@ -964,165 +1311,216 @@ export class ToBinding {
   }
 
   SkipRuntime_Reducer__remove(
-    skreducer: Handle<Reducer<Json, Json>>,
+    skreducer: Handle<HandlerInfo<Reducer<Json, Json>>>,
     skacc: Pointer<Internal.CJSON>,
     skvalue: Pointer<Internal.CJSON>,
   ): Nullable<Pointer<Internal.CJSON>> {
     const skjson = this.getJsonConverter();
     const reducer = this.handles.get(skreducer);
     return skjson.exportJSON(
-      reducer.remove(
+      reducer.object.remove(
         skjson.importJSON(skacc) as Json,
         skjson.importJSON(skvalue) as Json & DepSafe,
       ),
     );
   }
 
-  SkipRuntime_deleteReducer(reducer: Handle<Reducer<Json, Json>>): void {
-    this.handles.deleteHandle(reducer);
+  SkipRuntime_Reducer__isEquals(
+    reducer: Handle<HandlerInfo<Reducer<Json, Json>>>,
+    other: Handle<HandlerInfo<Reducer<Json, Json>>>,
+  ): number {
+    const object = this.handles.get(reducer);
+    if (this.getChanges()?.needReducerReload(object.name)) {
+      return 0;
+    }
+    return this.isEquals(reducer, other);
   }
 
-  // ExternalService
+  SkipRuntime_Reducer__getInfo(
+    reducer: Handle<HandlerInfo<Reducer<Json, Json>>>,
+  ): Pointer<Internal.CJObject> {
+    return this.getInfo(reducer);
+  }
 
-  SkipRuntime_ExternalService__subscribe(
-    sksupplier: Handle<ExternalService>,
-    writerId: string,
-    instance: string,
-    resource: string,
-    skparams: Pointer<Internal.CJObject>,
+  SkipRuntime_deleteReducer(
+    reducer: Handle<HandlerInfo<Reducer<Json, Json>>>,
   ): void {
-    const skjson = this.getJsonConverter();
-    const supplier = this.handles.get(sksupplier);
-    const writer = new CollectionWriter(writerId, this.refs());
-    const params = skjson.importJSON(skparams, true) as Json;
-    // Ensure notification is made outside the current context update
-    setTimeout(() => {
-      supplier
-        .subscribe(instance, resource, params, {
-          update: writer.update.bind(writer),
-          error: writer.error.bind(writer),
-        })
-        .then(() => writer.initialized())
-        .catch((e: unknown) =>
-          writer.initialized(
-            e instanceof Error
-              ? e.message
-              : JSON.stringify(e, Object.getOwnPropertyNames(e)),
-          ),
-        );
-    }, 0);
+    this.handles.deleteHandle(reducer);
   }
 
-  SkipRuntime_ExternalService__unsubscribe(
-    sksupplier: Handle<ExternalService>,
-    instance: string,
-  ): void {
-    const supplier = this.handles.get(sksupplier);
-    supplier.unsubscribe(instance);
+  async initService(service: SkipService): Promise<ServiceInstance> {
+    this.setFork(null);
+    const uuid = crypto.randomUUID();
+    this.fork(uuid);
+    try {
+      this.setFork(uuid);
+      const definition = new ServiceDefinition(service);
+      await this.initService_(definition);
+      this.setFork(uuid);
+      this.merge();
+      return new ServiceInstance(this, null, definition);
+    } catch (ex: unknown) {
+      this.setFork(uuid);
+      this.abortFork();
+      throw ex;
+    }
   }
 
-  SkipRuntime_ExternalService__shutdown(
-    sksupplier: Handle<ExternalService>,
-  ): Handle<Promise<void>> {
-    const supplier = this.handles.get(sksupplier);
-    return this.handles.register(supplier.shutdown());
+  private initService_(definition: ServiceDefinition): Promise<void> {
+    return this.runAsync(() => {
+      const skservicehHdl = this.handles.register(definition);
+      const skservice = this.binding.SkipRuntime_createService(skservicehHdl);
+      return this.binding.SkipRuntime_initService(skservice);
+    });
   }
 
-  SkipRuntime_deleteExternalService(supplier: Handle<ExternalService>): void {
-    this.handles.deleteHandle(supplier);
+  //
+  public getJsonConverter() {
+    if (this.skjson == undefined) {
+      this.skjson = this.getConverter();
+    }
+    return this.skjson;
   }
 
-  // Executor
+  public needGC() {
+    return this.SkipRuntime_getContext() == null;
+  }
 
-  SkipRuntime_Executor__resolve(skexecutor: Handle<Executor>): void {
-    const checker = this.handles.get(skexecutor);
-    checker.resolve();
+  public json() {
+    return this.getJsonConverter();
   }
 
-  SkipRuntime_Executor__reject(
-    skexecutor: Handle<Executor>,
-    error: Handle<Error>,
-  ): void {
-    const checker = this.handles.get(skexecutor);
-    checker.reject(this.handles.deleteHandle(error));
+  fork(name: string): void {
+    const errorHdl = this.runWithGC(() =>
+      this.binding.SkipRuntime_Runtime__fork(name),
+    );
+    if (errorHdl) throw this.handles.deleteHandle(errorHdl);
   }
 
-  SkipRuntime_deleteExecutor(executor: Handle<Executor>): void {
-    this.handles.deleteHandle(executor);
+  merge(ignore: string[] = []): void {
+    const errorHdl = this.runWithGC(() =>
+      this.binding.SkipRuntime_Runtime__merge(this.json().exportJSON(ignore)),
+    );
+    if (errorHdl) throw this.handles.deleteHandle(errorHdl);
   }
 
-  initService(service: SkipService): Promise<ServiceInstance> {
-    return new Promise((resolve, reject) => {
-      const refs = this.refs();
-      const errorHdl = refs.runWithGC(() => {
-        const skExternalServices =
-          refs.binding.SkipRuntime_ExternalServiceMap__create();
-        if (service.externalServices) {
-          for (const [name, remote] of Object.entries(
-            service.externalServices,
-          )) {
-            const skremote = refs.binding.SkipRuntime_createExternalService(
-              refs.handles.register(remote),
-            );
-            refs.binding.SkipRuntime_ExternalServiceMap__add(
-              skExternalServices,
-              name,
-              skremote,
-            );
-          }
-        }
-        const skresources =
-          refs.binding.SkipRuntime_ResourceBuilderMap__create();
-        for (const [name, builder] of Object.entries(service.resources)) {
-          const skbuilder = refs.binding.SkipRuntime_createResourceBuilder(
-            refs.handles.register(new ResourceBuilder(builder)),
-          );
-          refs.binding.SkipRuntime_ResourceBuilderMap__add(
-            skresources,
-            name,
-            skbuilder,
-          );
-        }
-        const skservice = refs.binding.SkipRuntime_createService(
-          refs.handles.register(service),
-          refs.skjson.exportJSON(service.initialData ?? {}),
-          skresources,
-          skExternalServices,
-        );
-        const exHdl = refs.handles.register({
-          resolve: () => {
-            resolve(new ServiceInstance(refs));
-          },
-          reject: (ex: Error) => reject(ex),
-        });
-        return refs.binding.SkipRuntime_initService(
-          skservice,
-          refs.binding.SkipRuntime_createExecutor(exHdl),
-        );
-      });
-      if (errorHdl) reject(refs.handles.deleteHandle(errorHdl));
+  abortFork(): void {
+    const errorHdl = this.runWithGC(() =>
+      this.binding.SkipRuntime_Runtime__abortFork(),
+    );
+    if (errorHdl) throw this.handles.deleteHandle(errorHdl);
+  }
+
+  async runAsync(fn: () => Pointer<Internal.CJSON>): Promise<void> {
+    const result = this.runWithGC(() => {
+      return this.json().importJSON(fn(), true);
     });
+    if (Array.isArray(result)) {
+      const handles = result as Handle<Promise<void>>[];
+      const promises = handles.map((h) => this.handles.deleteHandle(h));
+      await Promise.all(promises);
+    } else {
+      const errorHdl = result as Handle<Error>;
+      throw this.handles.deleteHandle(errorHdl);
+    }
   }
 
-  //
-  private getJsonConverter() {
-    if (this.skjson == undefined) {
-      this.skjson = this.getConverter();
+  private deepEquals(a: Nullable<Json>, b: Nullable<Json>) {
+    // Same reference or both NaN
+    if (a === b) return true;
+    if (a !== a && b !== b) return true; // NaN check
+
+    // Different types or one is null
+    if (typeof a !== typeof b || a === null || b === null) return false;
+
+    // Primitives already checked by ===
+    if (typeof a !== "object" || typeof b !== "object") return false;
+
+    // Arrays
+    if (Array.isArray(a)) {
+      if (!Array.isArray(b) || a.length !== b.length) return false;
+      for (let i = 0; i < a.length; i++) {
+        if (!this.deepEquals(a[i]!, b[i]!)) return false;
+      }
+      return true;
     }
-    return this.skjson;
+
+    // Different array status
+    if (Array.isArray(b)) return false;
+
+    // Objects
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+
+    if (keysA.length !== keysB.length) return false;
+
+    for (const key of keysA) {
+      if (
+        !Object.prototype.hasOwnProperty.call(b, key) ||
+        !this.deepEquals(a[key]!, b[key]!)
+      )
+        return false;
+    }
+
+    return true;
   }
 
-  private needGC() {
-    return this.SkipRuntime_getContext() == null;
+  private getInfo<T>(
+    skmapper: Handle<HandlerInfo<T>>,
+  ): Pointer<Internal.CJObject> {
+    const skjson = this.getJsonConverter();
+    const object = this.handles.get(skmapper);
+    const name = object.name;
+    const parameters = object.params.map((v) => {
+      if (v instanceof EagerCollectionImpl) {
+        return {
+          type: "collection",
+          value: v.collection,
+        };
+      }
+      if (v instanceof LazyCollectionImpl) {
+        return {
+          type: "collection",
+          value: v.lazyCollection,
+        };
+      }
+      return { type: "data", value: v as Json };
+    });
+    return skjson.exportJSON({ name, parameters });
   }
 
-  private refs(): Refs {
-    return new Refs(
-      this.binding,
-      this.getConverter(),
-      this.handles,
-      this.needGC.bind(this),
-      this.runWithGC,
-    );
+  private isEquals<T extends JSONOperator>(
+    mapper: Handle<HandlerInfo<T>>,
+    other: Handle<HandlerInfo<T>>,
+  ): number {
+    const object = this.handles.get(mapper);
+    const oobject = this.handles.get(other);
+    if (object.object.constructor != oobject.object.constructor) {
+      return 0;
+    }
+    if (object.params.length != oobject.params.length) return 0;
+    for (const [i, param] of object.params.entries()) {
+      const oparam = oobject.params[i];
+      if (param instanceof EagerCollectionImpl) {
+        if (oparam instanceof EagerCollectionImpl) {
+          if (param.collection != oparam.collection) return 0;
+        } else {
+          return 0;
+        }
+      } else if (param instanceof LazyCollectionImpl) {
+        if (oparam instanceof LazyCollectionImpl) {
+          if (param.lazyCollection != oparam.lazyCollection) return 0;
+        } else {
+          return 0;
+        }
+      } else if (!this.deepEquals(param as Json, oparam as Json)) {
+        return 0;
+      }
+    }
+    return 1;
+  }
+
+  private getChanges(): Nullable<ChangeManager> {
+    return this.changes ? this.handles.get(this.changes) : null;
   }
 }