@skipruntime/core 0.0.15 → 0.0.17

package/dist/src/index.js

@@ -7,7 +7,7 @@ import { deepFreeze, SkManaged, checkOrCloneParam, } from "../skiplang-json/inde
 import { sknative } from "../skiplang-std/index.js";
 import {} from "./api.js";
 import { SkipClassNameError, SkipError, SkipNonUniqueValueError, SkipResourceInstanceInUseError, SkipUnknownCollectionError, } from "./errors.js";
-import { ResourceBuilder, } from "./binding.js";
+import {} from "./binding.js";
 export * from "./api.js";
 export * from "./errors.js";
 function instantiateUserObject(what, ctor, params) {
@@ -17,7 +17,93 @@ function instantiateUserObject(what, ctor, params) {
     if (!obj.constructor.name) {
         throw new SkipClassNameError(`${what} classes must be defined at top-level.`);
     }
-    return obj;
+    return {
+        object: obj,
+        name: obj.constructor.name,
+        params: checkedParams,
+    };
+}
+export var LoadStatus;
+(function (LoadStatus) {
+    LoadStatus[LoadStatus["Incompatible"] = 0] = "Incompatible";
+    LoadStatus[LoadStatus["Changed"] = 1] = "Changed";
+    LoadStatus[LoadStatus["Same"] = 2] = "Same";
+})(LoadStatus || (LoadStatus = {}));
+export class ServiceDefinition {
+    constructor(service, externals = new Map()) {
+        this.service = service;
+        this.externals = externals;
+    }
+    buildResource(name, parameters) {
+        const builder = this.service.resources[name];
+        if (!builder)
+            throw new Error(`Resource '${name}' not exist.`);
+        return new builder(parameters);
+    }
+    inputs() {
+        return this.service.initialData
+            ? Object.keys(this.service.initialData)
+            : [];
+    }
+    resources() {
+        return Object.keys(this.service.resources);
+    }
+    initialData(name) {
+        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, context) {
+        return this.service.createGraph(inputCollections, context);
+    }
+    subscribe(external, writer, instance, resource, params) {
+        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, instance) {
+        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() {
+        const promises = [];
+        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) {
+        return new ServiceDefinition(service, new Map(this.externals));
+    }
 }
 class Handles {
     constructor() {
@@ -61,15 +147,6 @@ export class Stack {
         this.stack.pop();
     }
 }
-export class Refs {
-    constructor(binding, skjson, handles, needGC, runWithGC) {
-        this.binding = binding;
-        this.skjson = skjson;
-        this.handles = handles;
-        this.needGC = needGC;
-        this.runWithGC = runWithGC;
-    }
-}
 class LazyCollectionImpl extends SkManaged {
     constructor(lazyCollection, refs) {
         super();
@@ -78,7 +155,9 @@ class LazyCollectionImpl extends SkManaged {
         Object.freeze(this);
     }
     getArray(key) {
-        return this.refs.skjson.importJSON(this.refs.binding.SkipRuntime_LazyCollection__getArray(this.lazyCollection, this.refs.skjson.exportJSON(key)));
+        return this.refs
+            .json()
+            .importJSON(this.refs.binding.SkipRuntime_LazyCollection__getArray(this.lazyCollection, this.refs.json().exportJSON(key)));
     }
     getUnique(key, _default) {
         const values = this.getArray(key);
@@ -107,7 +186,9 @@ class EagerCollectionImpl extends SkManaged {
         Object.freeze(this);
     }
     getArray(key) {
-        return this.refs.skjson.importJSON(this.refs.binding.SkipRuntime_Collection__getArray(this.collection, this.refs.skjson.exportJSON(key)));
+        return this.refs
+            .json()
+            .importJSON(this.refs.binding.SkipRuntime_Collection__getArray(this.collection, this.refs.json().exportJSON(key)));
     }
     getUnique(key, _default) {
         const values = this.getArray(key);
@@ -128,7 +209,7 @@ class EagerCollectionImpl extends SkManaged {
         return this.slices([start, end]);
     }
     slices(...ranges) {
-        const skcollection = this.refs.binding.SkipRuntime_Collection__slice(this.collection, this.refs.skjson.exportJSON(ranges));
+        const skcollection = this.refs.binding.SkipRuntime_Collection__slice(this.collection, this.refs.json().exportJSON(ranges));
         return this.derive(skcollection);
     }
     take(limit) {
@@ -146,28 +227,30 @@ class EagerCollectionImpl extends SkManaged {
             const mapperObj = instantiateUserObject("Mapper", mapper, mapperParams);
             const reducerObj = instantiateUserObject("Reducer", reducer, reducerParams);
             const skmapper = this.refs.binding.SkipRuntime_createMapper(this.refs.handles.register(mapperObj));
-            if (sknative in reducerObj && typeof reducerObj[sknative] == "string") {
-                return this.derive(this.refs.binding.SkipRuntime_Collection__nativeMapReduce(this.collection, skmapper, reducerObj[sknative]));
+            if (sknative in reducerObj.object &&
+                typeof reducerObj.object[sknative] == "string") {
+                return this.derive(this.refs.binding.SkipRuntime_Collection__nativeMapReduce(this.collection, skmapper, reducerObj.object[sknative]));
             }
             else {
-                const skreducer = this.refs.binding.SkipRuntime_createReducer(this.refs.handles.register(reducerObj), this.refs.skjson.exportJSON(reducerObj.initial));
+                const skreducer = this.refs.binding.SkipRuntime_createReducer(this.refs.handles.register(reducerObj));
                 return this.derive(this.refs.binding.SkipRuntime_Collection__mapReduce(this.collection, skmapper, skreducer));
             }
         };
     }
     reduce(reducer, ...params) {
         const reducerObj = instantiateUserObject("Reducer", reducer, params);
-        if (sknative in reducerObj && typeof reducerObj[sknative] == "string") {
-            return this.derive(this.refs.binding.SkipRuntime_Collection__nativeReduce(this.collection, reducerObj[sknative]));
+        if (sknative in reducerObj.object &&
+            typeof reducerObj.object[sknative] == "string") {
+            return this.derive(this.refs.binding.SkipRuntime_Collection__nativeReduce(this.collection, reducerObj.object[sknative]));
         }
         else {
-            const skreducer = this.refs.binding.SkipRuntime_createReducer(this.refs.handles.register(reducerObj), this.refs.skjson.exportJSON(reducerObj.initial));
+            const skreducer = this.refs.binding.SkipRuntime_createReducer(this.refs.handles.register(reducerObj));
             return this.derive(this.refs.binding.SkipRuntime_Collection__reduce(this.collection, skreducer));
         }
     }
     merge(...others) {
         const otherNames = others.map((other) => EagerCollectionImpl.getName(other));
-        const mapped = this.refs.binding.SkipRuntime_Collection__merge(this.collection, this.refs.skjson.exportJSON(otherNames));
+        const mapped = this.refs.binding.SkipRuntime_Collection__merge(this.collection, this.refs.json().exportJSON(otherNames));
         return this.derive(mapped);
     }
     derive(collection) {
@@ -178,59 +261,61 @@ class EagerCollectionImpl extends SkManaged {
     }
 }
 class CollectionWriter {
-    constructor(collection, refs) {
+    constructor(collection, refs, forkName) {
         this.collection = collection;
         this.refs = refs;
+        this.forkName = forkName;
     }
     async update(values, isInit) {
-        await new Promise((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) => 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));
-        });
-    }
-    error(error) {
-        if (!this.refs.needGC()) {
-            throw new SkipError("CollectionWriter.update cannot be performed.");
+        this.refs.setFork(this.forkName);
+        const uuid = crypto.randomUUID();
+        const fork = this.fork(uuid);
+        try {
+            await fork.update_(values, isInit);
+            fork.merge();
+        }
+        catch (ex) {
+            fork.abortFork();
+            throw ex;
         }
-        const errorHdl = this.refs.runWithGC(() => this.refs.binding.SkipRuntime_CollectionWriter__error(this.collection, this.refs.skjson.exportJSON(this.toJSONError(error))));
-        if (errorHdl)
-            throw this.refs.handles.deleteHandle(errorHdl);
     }
-    initialized(error) {
+    update_(values, isInit) {
+        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__initialized(this.collection, this.refs.skjson.exportJSON(error ? this.toJSONError(error) : null)));
-        if (errorHdl)
-            throw this.refs.handles.deleteHandle(errorHdl);
-    }
-    toJSONError(error) {
-        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)));
+        return this.refs.runAsync(() => this.refs.binding.SkipRuntime_CollectionWriter__update(this.collection, this.refs.json().exportJSON(values), isInit));
+    }
+    fork(name) {
+        this.refs.setFork(this.forkName);
+        this.refs.fork(name);
+        return new CollectionWriter(this.collection, this.refs, name);
+    }
+    merge() {
+        if (!this.forkName)
+            throw new Error("Unable to merge fork on main.");
+        this.refs.setFork(this.forkName);
+        this.refs.merge();
+    }
+    abortFork() {
+        if (!this.forkName)
+            throw new Error("Unable to abord fork on main.");
+        this.refs.setFork(this.forkName);
+        this.refs.abortFork();
+    }
+    getForkName() {
+        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 extends SkManaged {
+class ContextImpl {
     constructor(refs) {
-        super();
         this.refs = refs;
-        Object.freeze(this);
     }
     createLazyCollection(compute, ...params) {
         const computeObj = instantiateUserObject("LazyCompute", compute, params);
@@ -239,11 +324,12 @@ class ContextImpl extends SkManaged {
         return new LazyCollectionImpl(lazyCollection, this.refs);
     }
     useExternalResource(resource) {
-        const collection = this.refs.binding.SkipRuntime_Context__useExternalResource(resource.service, resource.identifier, this.refs.skjson.exportJSON(resource.params ?? {}));
+        const collection = this.refs.binding.SkipRuntime_Context__useExternalResource(resource.service, resource.identifier, this.refs.json().exportJSON(resource.params ?? {}));
         return new EagerCollectionImpl(collection, this.refs);
     }
     jsonExtract(value, pattern) {
-        return this.refs.skjson.importJSON(this.refs.binding.SkipRuntime_Context__jsonExtract(this.refs.skjson.exportJSON(value), pattern));
+        const skjson = this.refs.json();
+        return skjson.importJSON(this.refs.binding.SkipRuntime_Context__jsonExtract(skjson.exportJSON(value), pattern));
     }
 }
 export class ServiceInstanceFactory {
@@ -259,27 +345,21 @@ export class ServiceInstanceFactory {
  * and operations to manage subscriptions and the service itself.
  */
 export class ServiceInstance {
-    constructor(refs) {
+    constructor(refs, forkName, definition) {
         this.refs = refs;
+        this.forkName = forkName;
+        this.definition = definition;
     }
     /**
      * 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, resource, params) {
-        return new Promise((resolve, reject) => {
-            const errorHdl = this.refs.runWithGC(() => {
-                const exHdl = this.refs.handles.register({
-                    resolve,
-                    reject: (ex) => 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)));
     }
     /**
      * Creates if not exists and get all current values of specified resource
@@ -291,15 +371,15 @@ 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);
-            const info = result;
-            if (info.errors.length > 0)
-                throw new SkipError(JSON.stringify(info.errors));
-            return info.payload;
+            return result;
         }
         finally {
             this.closeResourceInstance(uuid);
@@ -316,15 +396,14 @@ 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(this.refs.binding.SkipRuntime_Runtime__getForKey(resource, this.refs.skjson.exportJSON(params), this.refs.skjson.exportJSON(key)), true);
+                return skjson.importJSON(this.refs.binding.SkipRuntime_Runtime__getForKey(resource, skjson.exportJSON(params), skjson.exportJSON(key)), true);
             });
             if (typeof result == "number")
                 throw this.refs.handles.deleteHandle(result);
-            const info = result;
-            if (info.errors.length > 0)
-                throw new SkipError(JSON.stringify(info.errors));
-            return info.payload;
+            return result;
         }
         finally {
             this.closeResourceInstance(uuid);
@@ -335,6 +414,7 @@ export class ServiceInstance {
      * @param resourceInstanceId - The resource identifier
      */
     closeResourceInstance(resourceInstanceId) {
+        this.refs.setFork(this.forkName);
         const errorHdl = this.refs.runWithGC(() => {
             return this.refs.binding.SkipRuntime_Runtime__closeResource(resourceInstanceId);
         });
@@ -352,6 +432,7 @@ export class ServiceInstance {
      * @returns A subscription identifier
      */
     subscribe(resourceInstanceId, notifier, watermark) {
+        this.refs.setFork(this.forkName);
         const session = this.refs.runWithGC(() => {
             const sknotifier = this.refs.binding.SkipRuntime_createNotifier(this.refs.handles.register(notifier));
             return this.refs.binding.SkipRuntime_Runtime__subscribe(resourceInstanceId, sknotifier, watermark ?? null);
@@ -365,13 +446,14 @@ export class ServiceInstance {
         else if (session < 0n) {
             throw this.refs.handles.deleteHandle(Number(-session));
         }
-        return session;
+        return resourceInstanceId;
     }
     /**
      * Terminate a client's subscription to a reactive resource instance
      * @param id - The subscription identifier returned by a call to `subscribe`
      */
     unsubscribe(id) {
+        this.refs.setFork(this.forkName);
         const errorHdl = this.refs.runWithGC(() => {
             return this.refs.binding.SkipRuntime_Runtime__unsubscribe(id);
         });
@@ -384,18 +466,34 @@ export class ServiceInstance {
      * @param collection - the name of the input collection to update
      * @param entries - entries to update in the collection.
      */
-    update(collection, entries) {
-        return new Promise((resolve, reject) => {
-            const errorHdl = this.refs.runWithGC(() => {
-                const exHdl = this.refs.handles.register({
-                    resolve,
-                    reject: (ex) => reject(ex),
-                });
-                return 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));
+    async update(collection, entries) {
+        this.refs.setFork(this.forkName);
+        const uuid = crypto.randomUUID();
+        const fork = this.fork(uuid);
+        try {
+            await fork.update_(collection, entries);
+            fork.merge([]);
+        }
+        catch (ex) {
+            fork.abortFork();
+            throw ex;
+        }
+    }
+    async update_(collection, entries) {
+        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.json().exportJSON(entries)), true);
         });
+        if (Array.isArray(result)) {
+            const handles = result;
+            const promises = handles.map((h) => this.refs.handles.deleteHandle(h));
+            await Promise.all(promises);
+        }
+        else {
+            const errorHdl = result;
+            throw this.refs.handles.deleteHandle(errorHdl);
+        }
     }
     /**
      * Close all resources and shut down the service.
@@ -403,19 +501,95 @@ export class ServiceInstance {
      * @returns The promise of externals services shutdowns
      */
     close() {
+        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);
+        }
+        else {
+            const errorHdl = -result;
+            return Promise.reject(this.refs.handles.deleteHandle(errorHdl));
+        }
+    }
+    async reload(service, changes) {
+        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) {
+            console.error(ex);
+            if (!merged)
+                fork.abortFork();
+            throw ex;
+        }
+    }
+    async _reload(definition, changes) {
+        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;
+            const [handles, res] = result;
             const promises = handles.map((h) => this.refs.handles.deleteHandle(h));
-            return Promise.all(promises);
+            await Promise.all(promises);
+            return res;
         }
         else {
             const errorHdl = result;
-            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
+     */
+    fork(name) {
+        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);
+    }
+    merge(ignore) {
+        if (!this.forkName)
+            throw new Error("Unable to merge fork on main.");
+        this.refs.setFork(this.forkName);
+        this.refs.merge(ignore);
+    }
+    abortFork() {
+        if (!this.forkName)
+            throw new Error("Unable to abord fork on main.");
+        this.refs.setFork(this.forkName);
+        this.refs.abortFork();
+    }
+    closeResourceStreams(streams) {
+        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 {
     constructor(skjson, binding, pointer) {
@@ -486,6 +660,8 @@ export class ToBinding {
         this.getError = getError;
         this.stack = new Stack();
         this.handles = new Handles();
+        this.forkName = null;
+        this.changes = null;
     }
     register(v) {
         return this.handles.register(v);
@@ -505,14 +681,33 @@ export class ToBinding {
     SkipRuntime_getContext() {
         return this.stack.get();
     }
+    SkipRuntime_getFork() {
+        return this.forkName;
+    }
+    SkipRuntime_getChangeManager() {
+        return this.changes ?? 0;
+    }
+    setFork(name) {
+        this.forkName = name;
+    }
     // Mapper
     SkipRuntime_Mapper__mapEntry(skmapper, key, values) {
         const skjson = this.getJsonConverter();
         const mapper = this.handles.get(skmapper);
-        const context = new ContextImpl(this.refs());
-        const result = mapper.mapEntry(skjson.importJSON(key), new ValuesImpl(skjson, this.binding, values), context);
+        const context = new ContextImpl(this);
+        const result = mapper.object.mapEntry(skjson.importJSON(key), new ValuesImpl(skjson, this.binding, values), context);
         return skjson.exportJSON(Array.from(result));
     }
+    SkipRuntime_Mapper__getInfo(skmapper) {
+        return this.getInfo(skmapper);
+    }
+    SkipRuntime_Mapper__isEquals(mapper, other) {
+        const object = this.handles.get(mapper);
+        if (this.getChanges()?.needMapperReload(object.name)) {
+            return 0;
+        }
+        return this.isEquals(mapper, other);
+    }
     SkipRuntime_deleteMapper(mapper) {
         this.handles.deleteHandle(mapper);
     }
@@ -520,9 +715,20 @@ export class ToBinding {
     SkipRuntime_LazyCompute__compute(sklazyCompute, self, skkey) {
         const skjson = this.getJsonConverter();
         const lazyCompute = this.handles.get(sklazyCompute);
-        const result = lazyCompute.compute(new LazyCollectionImpl(self, this.refs()), skjson.importJSON(skkey));
+        const context = new ContextImpl(this);
+        const result = lazyCompute.object.compute(new LazyCollectionImpl(self, this), skjson.importJSON(skkey), context);
         return skjson.exportJSON(Array.from(result));
     }
+    SkipRuntime_LazyCompute__getInfo(lazyCompute) {
+        return this.getInfo(lazyCompute);
+    }
+    SkipRuntime_LazyCompute__isEquals(lazyCompute, other) {
+        const object = this.handles.get(lazyCompute);
+        if (this.getChanges()?.needLazyComputeReload(object.name)) {
+            return 0;
+        }
+        return this.isEquals(lazyCompute, other);
+    }
     SkipRuntime_deleteLazyCompute(lazyCompute) {
         this.handles.deleteHandle(lazyCompute);
     }
@@ -532,46 +738,83 @@ export class ToBinding {
         const resource = this.handles.get(skresource);
         const collections = {};
         const keysIds = skjson.importJSON(skcollections);
-        const refs = this.refs();
         for (const [key, name] of Object.entries(keysIds)) {
-            collections[key] = new EagerCollectionImpl(name, refs);
+            collections[key] = new EagerCollectionImpl(name, this);
         }
-        const collection = resource.instantiate(collections, new ContextImpl(refs));
+        const collection = resource.instantiate(collections, new ContextImpl(this));
         return EagerCollectionImpl.getName(collection);
     }
     SkipRuntime_deleteResource(resource) {
         this.handles.deleteHandle(resource);
     }
-    // ResourceBuilder
-    SkipRuntime_ResourceBuilder__build(skbuilder, skparams) {
-        const skjson = this.getJsonConverter();
-        const builder = this.handles.get(skbuilder);
-        const resource = builder.build(skjson.importJSON(skparams));
-        return this.binding.SkipRuntime_createResource(this.handles.register(resource));
-    }
-    SkipRuntime_deleteResourceBuilder(builder) {
-        this.handles.deleteHandle(builder);
-    }
-    // Service
-    SkipRuntime_Service__createGraph(skservice, skcollections) {
+    // ServiceDefinition
+    SkipRuntime_ServiceDefinition__createGraph(skservice, skcollections) {
         const skjson = this.getJsonConverter();
         const service = this.handles.get(skservice);
         const collections = {};
         const keysIds = skjson.importJSON(skcollections);
-        const refs = this.refs();
         for (const [key, name] of Object.entries(keysIds)) {
-            collections[key] = new EagerCollectionImpl(name, refs);
+            collections[key] = new EagerCollectionImpl(name, this);
         }
-        const result = service.createGraph(collections, new ContextImpl(refs));
+        const result = service.createGraph(collections, new ContextImpl(this));
         const collectionsNames = {};
         for (const [name, collection] of Object.entries(result)) {
             collectionsNames[name] = EagerCollectionImpl.getName(collection);
         }
         return skjson.exportJSON(collectionsNames);
     }
+    SkipRuntime_ServiceDefinition__inputs(skservice) {
+        const skjson = this.getJsonConverter();
+        const service = this.handles.get(skservice);
+        return skjson.exportJSON(service.inputs());
+    }
+    SkipRuntime_ServiceDefinition__resources(skservice) {
+        const skjson = this.getJsonConverter();
+        const service = this.handles.get(skservice);
+        return skjson.exportJSON(service.resources());
+    }
+    SkipRuntime_ServiceDefinition__initialData(skservice, name) {
+        const skjson = this.getJsonConverter();
+        const service = this.handles.get(skservice);
+        return skjson.exportJSON(service.initialData(name));
+    }
+    SkipRuntime_ServiceDefinition__buildResource(skservice, name, skparams) {
+        const skjson = this.getJsonConverter();
+        const service = this.handles.get(skservice);
+        const resource = service.buildResource(name, skjson.importJSON(skparams));
+        return this.binding.SkipRuntime_createResource(this.handles.register(resource));
+    }
+    SkipRuntime_ServiceDefinition__subscribe(skservice, external, writerId, instance, resource, skparams) {
+        const skjson = this.getJsonConverter();
+        const service = this.handles.get(skservice);
+        const writer = new CollectionWriter(writerId, this, this.forkName);
+        const params = skjson.importJSON(skparams, true);
+        return this.handles.register(service.subscribe(external, writer, instance, resource, params));
+    }
+    SkipRuntime_ServiceDefinition__unsubscribe(skservice, external, instance) {
+        const service = this.handles.get(skservice);
+        service.unsubscribe(external, instance);
+    }
+    SkipRuntime_ServiceDefinition__shutdown(skservice) {
+        const service = this.handles.get(skservice);
+        return this.handles.register(service.shutdown());
+    }
     SkipRuntime_deleteService(service) {
         this.handles.deleteHandle(service);
     }
+    // Change manager
+    SkipRuntime_ChangeManager__needInputReload(skmanager, name) {
+        const manager = this.handles.get(skmanager);
+        return manager.needInputReload(name) ? 1 : 0;
+    }
+    SkipRuntime_ChangeManager__needResourceReload(skmanager, name) {
+        const manager = this.handles.get(skmanager);
+        return manager.needResourceReload(name);
+    }
+    SkipRuntime_ChangeManager__needExternalServiceReload(skmanager, name, resource) {
+        const manager = this.handles.get(skmanager);
+        return manager.needExternalServiceReload(name, resource) ? 1 : 0;
+    }
     // Notifier
     SkipRuntime_Notifier__subscribed(sknotifier) {
         const notifier = this.handles.get(sknotifier);
@@ -596,88 +839,57 @@ export class ToBinding {
         this.handles.deleteHandle(notifier);
     }
     // Reducer
-    SkipRuntime_Reducer__add(skreducer, skacc, skvalue) {
+    SkipRuntime_Reducer__init(skreducer) {
         const skjson = this.getJsonConverter();
         const reducer = this.handles.get(skreducer);
-        return skjson.exportJSON(reducer.add(skacc ? skjson.importJSON(skacc) : null, skjson.importJSON(skvalue)));
+        return skjson.exportJSON(reducer.object.initial);
     }
-    SkipRuntime_Reducer__remove(skreducer, skacc, skvalue) {
+    SkipRuntime_Reducer__add(skreducer, skacc, skvalue) {
         const skjson = this.getJsonConverter();
         const reducer = this.handles.get(skreducer);
-        return skjson.exportJSON(reducer.remove(skjson.importJSON(skacc), skjson.importJSON(skvalue)));
+        return skjson.exportJSON(reducer.object.add(skacc ? skjson.importJSON(skacc) : null, skjson.importJSON(skvalue)));
     }
-    SkipRuntime_deleteReducer(reducer) {
-        this.handles.deleteHandle(reducer);
-    }
-    // ExternalService
-    SkipRuntime_ExternalService__subscribe(sksupplier, writerId, instance, resource, skparams) {
+    SkipRuntime_Reducer__remove(skreducer, skacc, skvalue) {
         const skjson = this.getJsonConverter();
-        const supplier = this.handles.get(sksupplier);
-        const writer = new CollectionWriter(writerId, this.refs());
-        const params = skjson.importJSON(skparams, true);
-        // 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) => writer.initialized(e instanceof Error
-                ? e.message
-                : JSON.stringify(e, Object.getOwnPropertyNames(e))));
-        }, 0);
-    }
-    SkipRuntime_ExternalService__unsubscribe(sksupplier, instance) {
-        const supplier = this.handles.get(sksupplier);
-        supplier.unsubscribe(instance);
-    }
-    SkipRuntime_ExternalService__shutdown(sksupplier) {
-        const supplier = this.handles.get(sksupplier);
-        return this.handles.register(supplier.shutdown());
+        const reducer = this.handles.get(skreducer);
+        return skjson.exportJSON(reducer.object.remove(skjson.importJSON(skacc), skjson.importJSON(skvalue)));
     }
-    SkipRuntime_deleteExternalService(supplier) {
-        this.handles.deleteHandle(supplier);
+    SkipRuntime_Reducer__isEquals(reducer, other) {
+        const object = this.handles.get(reducer);
+        if (this.getChanges()?.needReducerReload(object.name)) {
+            return 0;
+        }
+        return this.isEquals(reducer, other);
     }
-    // Executor
-    SkipRuntime_Executor__resolve(skexecutor) {
-        const checker = this.handles.get(skexecutor);
-        checker.resolve();
+    SkipRuntime_Reducer__getInfo(reducer) {
+        return this.getInfo(reducer);
     }
-    SkipRuntime_Executor__reject(skexecutor, error) {
-        const checker = this.handles.get(skexecutor);
-        checker.reject(this.handles.deleteHandle(error));
+    SkipRuntime_deleteReducer(reducer) {
+        this.handles.deleteHandle(reducer);
     }
-    SkipRuntime_deleteExecutor(executor) {
-        this.handles.deleteHandle(executor);
+    async initService(service) {
+        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) {
+            this.setFork(uuid);
+            this.abortFork();
+            throw ex;
+        }
     }
-    initService(service) {
-        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) => reject(ex),
-                });
-                return refs.binding.SkipRuntime_initService(skservice, refs.binding.SkipRuntime_createExecutor(exHdl));
-            });
-            if (errorHdl)
-                reject(refs.handles.deleteHandle(errorHdl));
+    initService_(definition) {
+        return this.runAsync(() => {
+            const skservicehHdl = this.handles.register(definition);
+            const skservice = this.binding.SkipRuntime_createService(skservicehHdl);
+            return this.binding.SkipRuntime_initService(skservice);
         });
     }
     //
@@ -690,8 +902,132 @@ export class ToBinding {
     needGC() {
         return this.SkipRuntime_getContext() == null;
     }
-    refs() {
-        return new Refs(this.binding, this.getConverter(), this.handles, this.needGC.bind(this), this.runWithGC);
+    json() {
+        return this.getJsonConverter();
+    }
+    fork(name) {
+        const errorHdl = this.runWithGC(() => this.binding.SkipRuntime_Runtime__fork(name));
+        if (errorHdl)
+            throw this.handles.deleteHandle(errorHdl);
+    }
+    merge(ignore = []) {
+        const errorHdl = this.runWithGC(() => this.binding.SkipRuntime_Runtime__merge(this.json().exportJSON(ignore)));
+        if (errorHdl)
+            throw this.handles.deleteHandle(errorHdl);
+    }
+    abortFork() {
+        const errorHdl = this.runWithGC(() => this.binding.SkipRuntime_Runtime__abortFork());
+        if (errorHdl)
+            throw this.handles.deleteHandle(errorHdl);
+    }
+    async runAsync(fn) {
+        const result = this.runWithGC(() => {
+            return this.json().importJSON(fn(), true);
+        });
+        if (Array.isArray(result)) {
+            const handles = result;
+            const promises = handles.map((h) => this.handles.deleteHandle(h));
+            await Promise.all(promises);
+        }
+        else {
+            const errorHdl = result;
+            throw this.handles.deleteHandle(errorHdl);
+        }
+    }
+    deepEquals(a, b) {
+        // 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;
+        }
+        // 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;
+    }
+    getInfo(skmapper) {
+        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 };
+        });
+        return skjson.exportJSON({ name, parameters });
+    }
+    isEquals(mapper, other) {
+        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, oparam)) {
+                return 0;
+            }
+        }
+        return 1;
+    }
+    getChanges() {
+        return this.changes ? this.handles.get(this.changes) : null;
     }
 }
 //# sourceMappingURL=index.js.map