@jay-framework/secure 0.5.0

package/dist/index.js

@@ -0,0 +1,1027 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { createJayContext, currentConstructionContext, withContext, childComp, useContext, GetTrapProxy, EVENT_TRAP, BaseReferencesManager, ManagedRefType, ComponentCollectionRefImpl, ComponentRefsImpl, normalizeUpdates, saveContext, restoreContext } from "@jay-framework/runtime";
+import { makeJayComponent, createSignal, useReactive, COMPONENT_CONTEXT } from "@jay-framework/component";
+import { deserialize, serialize } from "@jay-framework/serialization";
+let _mainPort;
+function setMainPort(port) {
+  _mainPort = port;
+}
+function useMainPort() {
+  return _mainPort;
+}
+let _workerPort;
+function setWorkerPort(port) {
+  _workerPort = port;
+}
+function useWorkerPort() {
+  return _workerPort;
+}
+class JayPort {
+  constructor(channel, logger) {
+    __publicField(this, "messages", []);
+    __publicField(this, "endpoints", /* @__PURE__ */ new Map());
+    __publicField(this, "futureEndpointMessages", /* @__PURE__ */ new Map());
+    __publicField(this, "inBatch", false);
+    __publicField(this, "comps", /* @__PURE__ */ new Map());
+    __publicField(this, "lastCompId", 0);
+    __publicField(this, "newCompIdMessages", []);
+    __publicField(this, "isAutoFlushScheduled", false);
+    __publicField(this, "autoFlushTimeout");
+    __publicField(this, "getCompId", (parentCompId, coordinate) => {
+      let fullId = `${parentCompId}-${coordinate}`;
+      if (!this.comps.has(fullId)) {
+        let compId = Math.max(this.lastCompId, parentCompId) + 1;
+        this.lastCompId = compId;
+        this.comps.set(fullId, compId);
+        this.newCompIdMessages.push([fullId, compId]);
+      }
+      return this.comps.get(fullId);
+    });
+    this.channel = channel;
+    this.logger = logger;
+    channel.onMessages(
+      (messages, newCompIdMessages) => this.invoke(messages, newCompIdMessages)
+    );
+  }
+  getEndpoint(parentCompId, parentCoordinate) {
+    let compId = this.getCompId(parentCompId, parentCoordinate);
+    if (this.endpoints.has(compId))
+      return this.endpoints.get(compId);
+    let ep = new JayEndpoint(compId, this);
+    this.endpoints.set(compId, ep);
+    ep.setInitMessages(this.futureEndpointMessages.get(compId) || []);
+    this.futureEndpointMessages.delete(compId);
+    return ep;
+  }
+  getRootEndpoint() {
+    return this.getEndpoint(-1, [""]);
+  }
+  post(compId, outMessage) {
+    if (this.logger)
+      this.logger.logPost(compId, outMessage);
+    this.messages.push([compId, outMessage]);
+    if (!this.inBatch)
+      this.scheduleFlush();
+  }
+  batch(handler) {
+    if (this.inBatch)
+      return handler();
+    this.inBatch = true;
+    try {
+      return handler();
+    } finally {
+      if (this.messages.length > 0)
+        this.flush();
+      this.inBatch = false;
+    }
+  }
+  invoke(messages, newCompIdMessages) {
+    newCompIdMessages.forEach(([fullId, compId]) => {
+      this.comps.set(fullId, compId);
+      this.lastCompId = Math.max(this.lastCompId, compId);
+    });
+    this.batch(() => {
+      messages.forEach(([compId, message]) => {
+        let endpoint = this.endpoints.get(compId);
+        if (this.logger)
+          this.logger.logInvoke(compId, message, !!endpoint);
+        if (endpoint)
+          endpoint.invoke(message);
+        else {
+          if (!this.futureEndpointMessages.has(compId))
+            this.futureEndpointMessages.set(compId, [message]);
+          else
+            this.futureEndpointMessages.get(compId).push(message);
+        }
+      });
+    });
+  }
+  flush() {
+    this.channel.postMessages(this.messages, this.newCompIdMessages);
+    this.messages = [];
+    this.newCompIdMessages = [];
+    if (this.isAutoFlushScheduled) {
+      this.isAutoFlushScheduled = false;
+      clearTimeout(this.autoFlushTimeout);
+    }
+  }
+  scheduleFlush() {
+    this.isAutoFlushScheduled = true;
+    this.autoFlushTimeout = setTimeout(() => {
+      this.autoFlushTimeout = void 0;
+      this.isAutoFlushScheduled = false;
+      this.flush();
+    });
+  }
+}
+class JayEndpoint {
+  constructor(compId, port) {
+    __publicField(this, "handler");
+    __publicField(this, "initMessages", []);
+    this.compId = compId;
+    this.port = port;
+  }
+  post(outMessage) {
+    this.port.post(this.compId, outMessage);
+  }
+  onUpdate(handler) {
+    this.handler = handler;
+    this.initMessages.forEach((message) => handler(message));
+    this.initMessages = [];
+  }
+  invoke(inMessage) {
+    this?.handler(inMessage);
+  }
+  setInitMessages(initMessages) {
+    this.initMessages = initMessages;
+  }
+}
+class JayPortLoggerConsole {
+  logPost(compId, message) {
+    console.log("[port] post", compId, message);
+  }
+  logInvoke(compId, message, endpointFound) {
+    console.log("[port] invoke", compId, message);
+  }
+}
+const SYN = "SYN";
+const ACK = "ACK";
+class HandshakeMessageJayChannel {
+  constructor(worker) {
+    __publicField(this, "handler");
+    __publicField(this, "worker");
+    __publicField(this, "handshakeComplete", false);
+    __publicField(this, "pendingMessages", []);
+    __publicField(this, "workerOnMessage", (ev) => {
+      if (ev.data === SYN || ev.data === ACK) {
+        if (!this.handshakeComplete) {
+          if (ev.data === SYN)
+            this.worker.postMessage(ACK);
+          this.handshakeComplete = true;
+          this.pendingMessages.forEach((message) => this.worker.postMessage(message));
+          this.pendingMessages = [];
+        }
+      } else {
+        let { messages, newCompIdMessages } = ev.data;
+        if (this.handler)
+          this.handler(messages, newCompIdMessages);
+      }
+    });
+    worker.addEventListener("message", this.workerOnMessage);
+    this.worker = worker;
+    this.worker.postMessage(SYN);
+  }
+  onMessages(handler) {
+    this.handler = handler;
+  }
+  postMessages(messages, newCompIdMessages) {
+    if (!this.handshakeComplete)
+      this.pendingMessages.push({ messages, newCompIdMessages });
+    else
+      this.worker.postMessage({ messages, newCompIdMessages });
+  }
+}
+const SECURE_COMPONENT_MARKER = createJayContext();
+const SECURE_COORDINATE_MARKER = createJayContext();
+function secureChildComp(compCreator, getProps, ref) {
+  currentConstructionContext();
+  let coordinate = ref.coordinate;
+  return withContext(SECURE_COORDINATE_MARKER, { coordinate }, () => {
+    return childComp(compCreator, getProps, ref);
+  });
+}
+var JayPortMessageType = /* @__PURE__ */ ((JayPortMessageType2) => {
+  JayPortMessageType2[JayPortMessageType2["render"] = 0] = "render";
+  JayPortMessageType2[JayPortMessageType2["addEventListener"] = 1] = "addEventListener";
+  JayPortMessageType2[JayPortMessageType2["root"] = 2] = "root";
+  JayPortMessageType2[JayPortMessageType2["eventInvocation"] = 3] = "eventInvocation";
+  JayPortMessageType2[JayPortMessageType2["removeEventListener"] = 4] = "removeEventListener";
+  JayPortMessageType2[JayPortMessageType2["nativeExec"] = 5] = "nativeExec";
+  JayPortMessageType2[JayPortMessageType2["nativeExecResult"] = 6] = "nativeExecResult";
+  JayPortMessageType2[JayPortMessageType2["rootApiInvoke"] = 7] = "rootApiInvoke";
+  JayPortMessageType2[JayPortMessageType2["rootApiReturns"] = 8] = "rootApiReturns";
+  return JayPortMessageType2;
+})(JayPortMessageType || {});
+function rootApiReturns(callId, returns, error) {
+  return {
+    callId,
+    returns,
+    error,
+    type: 8
+    /* rootApiReturns */
+  };
+}
+function renderMessage(patch) {
+  return {
+    patch,
+    type: 0
+    /* render */
+  };
+}
+function addEventListenerMessage(refName, eventType, nativeId) {
+  return {
+    refName,
+    eventType,
+    nativeId,
+    type: 1
+    /* addEventListener */
+  };
+}
+function removeEventListenerMessage(refName, eventType) {
+  return {
+    refName,
+    eventType,
+    type: 4
+    /* removeEventListener */
+  };
+}
+function eventInvocationMessage(eventType, coordinate, eventData) {
+  return {
+    coordinate,
+    eventType,
+    eventData,
+    type: 3
+    /* eventInvocation */
+  };
+}
+function rootComponentViewState(patch) {
+  return {
+    patch,
+    type: 2
+    /* root */
+  };
+}
+function nativeExec(nativeId, correlationId, refName, coordinate) {
+  return {
+    refName,
+    nativeId,
+    correlationId,
+    coordinate,
+    type: 5
+    /* nativeExec */
+  };
+}
+function nativeExecResult(correlationId, result, error, refName) {
+  return {
+    refName,
+    result,
+    correlationId,
+    error,
+    type: 6
+    /* nativeExecResult */
+  };
+}
+function rootApiInvoke(apiName, callId, params) {
+  return {
+    apiName,
+    callId,
+    params,
+    type: 7
+    /* rootApiInvoke */
+  };
+}
+function makeComponentBridgeConstructor(props, refs) {
+  let [viewState, setViewState] = createSignal({});
+  let reactive = useReactive();
+  let { endpoint, port, funcRepository } = useContext(SECURE_COMPONENT_MARKER);
+  let ongoingAPICalls = {};
+  let eventHandlers = {};
+  let deserializedViewState, nextDeserialize = deserialize;
+  endpoint.onUpdate((message) => {
+    switch (message.type) {
+      case JayPortMessageType.render:
+        reactive.batchReactions(() => {
+          [deserializedViewState, nextDeserialize] = nextDeserialize(message.patch);
+          setViewState(deserializedViewState);
+        });
+        break;
+      case JayPortMessageType.addEventListener:
+        {
+          let { eventType, nativeId } = message;
+          refs[message.refName].addEventListener(
+            eventType,
+            (event) => {
+              port.batch(() => {
+                if (message.nativeId) {
+                  let eventData = funcRepository[nativeId](event);
+                  endpoint.post(
+                    eventInvocationMessage(
+                      eventType,
+                      event.coordinate,
+                      eventData
+                    )
+                  );
+                } else
+                  endpoint.post(
+                    eventInvocationMessage(eventType, event.coordinate)
+                  );
+              });
+            }
+          );
+        }
+        break;
+      case JayPortMessageType.rootApiReturns:
+        let { callId, error, returns } = message;
+        if (ongoingAPICalls[callId]) {
+          if (error)
+            ongoingAPICalls[callId][1](error);
+          else
+            ongoingAPICalls[callId][0](returns);
+          delete ongoingAPICalls[callId];
+        }
+        break;
+      case JayPortMessageType.eventInvocation: {
+        let { eventType, eventData } = message;
+        eventHandlers[eventType]({ event: eventData, coordinate: [""], viewState: null });
+        break;
+      }
+      case JayPortMessageType.nativeExec: {
+        let { nativeId, refName, coordinate, correlationId } = message;
+        let ref = refs[refName];
+        port.batch(async () => {
+          try {
+            let result = ref.find ? await ref.find(
+              (vs, c) => c.length === coordinate.length && coordinate.reduce(
+                (acc, el1, i) => acc && c[i] === el1,
+                true
+              )
+            ).exec$(
+              (elem, vs) => funcRepository[nativeId](elem, vs)
+            ) : await ref.exec$(
+              (elem, vs) => funcRepository[nativeId](
+                elem,
+                vs
+              )
+            );
+            endpoint.post(nativeExecResult(correlationId, result, void 0, refName));
+          } catch (err) {
+            endpoint.post(
+              nativeExecResult(correlationId, void 0, err.message, refName)
+            );
+          }
+        });
+      }
+    }
+  });
+  let nextCallId = 0;
+  let invokeAPI = (functionName, args) => {
+    let callId = nextCallId++;
+    port.batch(() => {
+      endpoint.post(rootApiInvoke(functionName, callId, args));
+    });
+    return new Promise((resolve, reject) => {
+      ongoingAPICalls[callId] = [resolve, reject];
+    });
+  };
+  let registerEvent = (eventType, handler) => {
+    eventHandlers[eventType] = handler;
+    port.batch(() => {
+      endpoint.post(addEventListenerMessage("", eventType));
+    });
+  };
+  return {
+    render: viewState,
+    invokeAPI,
+    registerEvent
+  };
+}
+function defineCompPublicAPI(comp, endpoint, options) {
+  if (options?.events)
+    comp["addEventListener"] = (eventType, handler) => comp.registerEvent(eventType, handler);
+  options?.functions?.forEach((functionName) => {
+    comp[functionName] = (...args) => {
+      return comp.invokeAPI(functionName, args);
+    };
+  });
+}
+function makeJayComponentBridge(render, options) {
+  let component = makeJayComponent(render, makeComponentBridgeConstructor);
+  return (props) => {
+    let { compId, port } = useContext(SECURE_COMPONENT_MARKER);
+    let { coordinate } = useContext(SECURE_COORDINATE_MARKER);
+    let endpoint = port.getEndpoint(compId, coordinate);
+    let newSecureComponentContext = {
+      endpoint,
+      compId: endpoint.compId,
+      port,
+      funcRepository: options?.funcRepository
+    };
+    return withContext(SECURE_COMPONENT_MARKER, newSecureComponentContext, () => {
+      let comp = component(props);
+      defineCompPublicAPI(comp, endpoint, options);
+      return comp;
+    });
+  };
+}
+function mainRoot(viewState, elementConstructor, funcRepository) {
+  let port = useMainPort();
+  let endpoint = port.getRootEndpoint();
+  let context = { compId: endpoint.compId, endpoint, port, funcRepository };
+  endpoint.onUpdate(async (message) => {
+    switch (message.type) {
+      case JayPortMessageType.nativeExec: {
+        let { nativeId, correlationId } = message;
+        try {
+          let result = await funcRepository[nativeId]();
+          port.batch(async () => {
+            endpoint.post(nativeExecResult(correlationId, result, void 0));
+          });
+        } catch (err) {
+          port.batch(async () => {
+            endpoint.post(nativeExecResult(correlationId, void 0, err.message));
+          });
+        }
+        break;
+      }
+    }
+  });
+  return withContext(SECURE_COMPONENT_MARKER, context, () => {
+    let patch, nextSerialize;
+    let element = port.batch(() => {
+      [patch, nextSerialize] = serialize(viewState);
+      endpoint.post(rootComponentViewState(patch));
+      return elementConstructor();
+    });
+    return {
+      dom: element.dom,
+      mount: element.mount,
+      unmount: element.unmount,
+      update: (newData) => {
+        element.update(newData);
+        port.batch(() => {
+          [patch, nextSerialize] = nextSerialize(newData);
+          endpoint.post(rootComponentViewState(patch));
+        });
+      }
+    };
+  });
+}
+function nativeExecId(id) {
+  let fn = () => null;
+  fn.id = id;
+  return fn;
+}
+function handler$(id) {
+  return nativeExecId(id);
+}
+function func$(id) {
+  return nativeExecId(id);
+}
+function funcGlobal$(id) {
+  return nativeExecId(id);
+}
+let nextCorrelationId = 0;
+let promises$ = /* @__PURE__ */ new Map();
+function correlatedPromise() {
+  let correlationId = nextCorrelationId++;
+  let resolve, reject;
+  let execPromise$ = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  let corrPromise = { correlationId, execPromise$, resolve, reject };
+  promises$.set(correlationId, corrPromise);
+  return corrPromise;
+}
+function completeCorrelatedPromise(message) {
+  if (message.error)
+    promises$.get(message.correlationId)?.reject(message.error);
+  else
+    promises$.get(message.correlationId)?.resolve(message.result);
+  promises$.delete(message.correlationId);
+}
+const SANDBOX_BRIDGE_CONTEXT = createJayContext();
+const SANDBOX_CREATION_CONTEXT = createJayContext();
+class SecureReferencesManager extends BaseReferencesManager {
+  constructor(ep, eventWrapper) {
+    super(eventWrapper);
+    this.ep = ep;
+    this.eventWrapper = eventWrapper;
+  }
+  mkManagedRef(refType, refName) {
+    switch (refType) {
+      case ManagedRefType.element:
+        return new SecureHTMLElementRefsImpl(refName, this.ep);
+      case ManagedRefType.elementCollection:
+        return new SecureHTMLElementCollectionRefsImpl(refName, this.ep);
+      case ManagedRefType.component:
+        return new ComponentRefsImpl();
+      case ManagedRefType.componentCollection:
+        return new ComponentCollectionRefImpl();
+    }
+  }
+  currentContext() {
+    let { viewState, dataIds } = useContext(SANDBOX_CREATION_CONTEXT);
+    return { currData: viewState, coordinate: (refName) => [...dataIds, refName] };
+  }
+  static for(endpoint, eventWrapper, elem, elemCollection, comp, compCollection, childRefManagers) {
+    const refManager = new SecureReferencesManager(endpoint, eventWrapper);
+    return [
+      refManager,
+      refManager.mkRefs(elem, elemCollection, comp, compCollection, childRefManagers)
+    ];
+  }
+  static forElement(elem, elemCollection, comp, compCollection, childRefManagers) {
+    const parentComponentContext = useContext(SANDBOX_BRIDGE_CONTEXT);
+    const { reactive, getComponentInstance } = useContext(COMPONENT_CONTEXT);
+    const thisComponentEndpoint = parentComponentContext.port.getEndpoint(
+      parentComponentContext.compId,
+      parentComponentContext.coordinate
+    );
+    return SecureReferencesManager.for(
+      thisComponentEndpoint,
+      (orig, event) => {
+        return reactive.batchReactions(() => orig(event));
+      },
+      elem,
+      elemCollection,
+      comp,
+      compCollection,
+      childRefManagers
+    );
+  }
+  static forSandboxRoot(elem, elemCollection, comp, compCollection, childRefManagers) {
+    const { endpoint } = useContext(SANDBOX_CREATION_CONTEXT);
+    return SecureReferencesManager.for(
+      endpoint,
+      void 0,
+      elem,
+      elemCollection,
+      comp,
+      compCollection,
+      childRefManagers
+    );
+  }
+}
+class SecurePrivateRefs {
+  constructor(ref, ep) {
+    __publicField(this, "listeners", /* @__PURE__ */ new Map());
+    __publicField(this, "items", /* @__PURE__ */ new Map());
+    __publicField(this, "invoke", (type, coordinate, eventData) => {
+      let listener = this.listeners.get(type);
+      if (listener) {
+        let item = this.items.get(coordinate.toString());
+        if (item)
+          listener({
+            event: eventData,
+            viewState: item.viewState,
+            coordinate: item.coordinate
+          });
+      }
+    });
+    this.ref = ref;
+    this.ep = ep;
+  }
+  addEventListener(type, listener, options, nativeId) {
+    this.ep.post(addEventListenerMessage(this.ref, type, nativeId));
+    this.listeners.set(type, listener);
+  }
+  removeEventListener(type, listener, options) {
+    this.ep.post(removeEventListenerMessage(this.ref, type));
+    this.listeners.delete(type);
+  }
+  addRef(ref) {
+    let key = ref.coordinate.toString();
+    if (!this.items.has(key)) {
+      this.items.set(key, ref);
+    }
+  }
+  removeRef(ref) {
+    this.items.delete(ref.coordinate.toString());
+  }
+}
+class SecureHTMLElementRefImpl {
+  constructor(ref, ep, viewState, coordinate, parentCollection) {
+    __publicField(this, "listeners", /* @__PURE__ */ new Map());
+    __publicField(this, "invoke", (type, coordinate, eventData) => {
+      let listener = this.listeners.get(type);
+      if (listener)
+        listener({
+          event: eventData,
+          viewState: this.viewState,
+          coordinate
+        });
+    });
+    __publicField(this, "update", (newViewState) => {
+      this.viewState = newViewState;
+    });
+    this.ref = ref;
+    this.ep = ep;
+    this.viewState = viewState;
+    this.coordinate = coordinate;
+    this.parentCollection = parentCollection;
+    this.parentCollection?.addRef(this);
+  }
+  addEventListener(type, listener, options, nativeId) {
+    this.ep.post(addEventListenerMessage(this.ref, type, nativeId));
+    this.listeners.set(type, listener);
+  }
+  removeEventListener(type, listener, options) {
+    this.ep.post(removeEventListenerMessage(this.ref, type));
+    this.listeners.delete(type);
+  }
+  exec$(handler) {
+    let { execPromise$, correlationId } = correlatedPromise();
+    this.ep.post(
+      nativeExec(
+        handler.id,
+        correlationId,
+        this.ref,
+        this.coordinate
+      )
+    );
+    return execPromise$;
+  }
+  mount() {
+    this.parentCollection?.addRef(this);
+  }
+  unmount() {
+    this.parentCollection?.removeRef(this);
+  }
+  getPublicAPI() {
+    return newSecureHTMLElementPublicApiProxy(this);
+  }
+}
+class SecureHTMLElementRefsImpl extends SecurePrivateRefs {
+  mkManagedRef(currData, coordinate, eventWrapper) {
+    return new SecureHTMLElementRefImpl(this.ref, this.ep, currData, coordinate, this);
+  }
+  getPublicAPI() {
+    return newSecureHTMLElementPublicApiProxy(this);
+  }
+  exec$(handler) {
+    return [...this.items][0][1].exec$(handler);
+  }
+}
+class SecureHTMLElementCollectionRefsImpl extends SecurePrivateRefs {
+  mkManagedRef(currData, coordinate, eventWrapper) {
+    return new SecureHTMLElementRefImpl(this.ref, this.ep, currData, coordinate, this);
+  }
+  getPublicAPI() {
+    return newSecureHTMLElementPublicApiProxy(this);
+  }
+  find(predicate) {
+    for (const [, item] of this.items)
+      if (predicate(item.viewState, item.coordinate)) {
+        return item.getPublicAPI();
+      }
+  }
+  map(handler) {
+    let promises = [];
+    for (const [, item] of this.items) {
+      const handlerResponse = handler(item.getPublicAPI(), item.viewState, item.coordinate);
+      if (handlerResponse)
+        promises.push(handlerResponse);
+    }
+    return promises;
+  }
+}
+const SECURE_EVENT$_TRAP = (target, prop) => {
+  if (typeof prop === "string") {
+    if (prop.indexOf("on") === 0 && prop.at(-1) === "$") {
+      let eventName = prop.slice(2, -1);
+      return (func$2) => {
+        let regularHandler;
+        const handler = ({ event, viewState, coordinate }) => {
+          if (regularHandler)
+            regularHandler({ event, viewState, coordinate });
+        };
+        target.addEventListener(eventName, handler, void 0, func$2.id);
+        return {
+          then: (handler2) => {
+            regularHandler = handler2;
+          }
+        };
+      };
+    }
+  }
+  return false;
+};
+const SecureHTMLElementRefProxy = GetTrapProxy([SECURE_EVENT$_TRAP, EVENT_TRAP]);
+function newSecureHTMLElementPublicApiProxy(ref) {
+  return new Proxy(ref, SecureHTMLElementRefProxy);
+}
+function mkBridgeElement(viewState, sandboxElements, endpoint, reactive, refManager, getComponentInstance, arraySerializationContext) {
+  let events = {};
+  let port = endpoint.port;
+  return withContext(
+    SANDBOX_CREATION_CONTEXT,
+    {
+      endpoint,
+      viewState,
+      dataIds: [],
+      isDynamic: false,
+      parentComponentReactive: reactive
+    },
+    () => {
+      let elements = sandboxElements();
+      let patch, nextSerialize = serialize;
+      let postUpdateMessage = (newViewState) => {
+        [patch, nextSerialize] = nextSerialize(newViewState, arraySerializationContext);
+        if (patch.length)
+          endpoint.post(renderMessage(patch));
+      };
+      let update = normalizeUpdates([postUpdateMessage, ...elements.map((el) => el.update)]);
+      update(viewState);
+      endpoint.onUpdate(async (inMessage) => {
+        switch (inMessage.type) {
+          case JayPortMessageType.eventInvocation: {
+            reactive.batchReactions(() => {
+              refManager.get(
+                inMessage.coordinate.slice(-1)[0]
+              ).invoke(
+                inMessage.eventType,
+                inMessage.coordinate,
+                inMessage.eventData
+              );
+            });
+            break;
+          }
+          case JayPortMessageType.nativeExecResult: {
+            reactive.batchReactions(() => {
+              completeCorrelatedPromise(inMessage);
+            });
+            break;
+          }
+          case JayPortMessageType.rootApiInvoke: {
+            let message = inMessage;
+            let returns, error;
+            try {
+              returns = await getComponentInstance()[message.apiName](message.params);
+            } catch (err) {
+              error = err;
+            }
+            port.batch(() => {
+              endpoint.post(rootApiReturns(message.callId, returns, error));
+            });
+            break;
+          }
+          case JayPortMessageType.addEventListener: {
+            let handler = ({ event, coordinate }) => {
+              port.batch(() => {
+                endpoint.post(
+                  eventInvocationMessage(inMessage.eventType, coordinate, event)
+                );
+              });
+            };
+            events[inMessage.eventType] = handler;
+            getComponentInstance().addEventListener(inMessage.eventType, handler);
+            break;
+          }
+          case JayPortMessageType.removeEventListener: {
+            getComponentInstance().removeEventListener(
+              inMessage.eventType,
+              events[inMessage.eventType]
+            );
+            delete events[inMessage.eventType];
+          }
+        }
+      });
+      const mount = () => elements.forEach((_) => _.mount());
+      const unmount = () => elements.forEach((_) => _.unmount());
+      mount();
+      return refManager.applyToElement({
+        dom: void 0,
+        update,
+        mount,
+        unmount
+      });
+    }
+  );
+}
+function elementBridge(viewState, refManager, sandboxElements, arraySerializationContext = []) {
+  const parentComponentContext = useContext(SANDBOX_BRIDGE_CONTEXT);
+  const { reactive, getComponentInstance } = useContext(COMPONENT_CONTEXT);
+  const thisComponentEndpoint = parentComponentContext.port.getEndpoint(
+    parentComponentContext.compId,
+    parentComponentContext.coordinate
+  );
+  return mkBridgeElement(
+    viewState,
+    sandboxElements,
+    thisComponentEndpoint,
+    reactive,
+    refManager,
+    getComponentInstance,
+    arraySerializationContext
+  );
+}
+function sandboxElement(ref) {
+  return ref;
+}
+function sandboxChildComp(compCreator, getProps, ref) {
+  let { viewState, endpoint } = useContext(SANDBOX_CREATION_CONTEXT);
+  let coordinate = ref.coordinate;
+  let context = { compId: endpoint.compId, coordinate, port: endpoint.port };
+  let childComp2 = withContext(SANDBOX_BRIDGE_CONTEXT, context, () => {
+    return compCreator(getProps(viewState));
+  });
+  ref.set(childComp2);
+  ref.mount();
+  return {
+    update: (newViewState) => {
+      ref.update(newViewState);
+      childComp2.update(getProps(newViewState));
+    },
+    mount: () => {
+      ref.mount();
+      childComp2.mount();
+    },
+    unmount: () => {
+      ref.unmount();
+      childComp2.unmount();
+    }
+  };
+}
+function compareLists(oldList, newList, matchBy) {
+  let removedItems = [];
+  let addedItems = [];
+  let itemsToUpdate = [];
+  let newListIds = new Set(newList.map((item) => item[matchBy]));
+  let oldListIdsMap = new Map(oldList.map((item) => [item[matchBy], item]));
+  oldList.forEach((oldItem) => {
+    if (!newListIds.has(oldItem[matchBy]))
+      removedItems.push(oldItem);
+  });
+  newList.forEach((newItem) => {
+    if (!oldListIdsMap.has(newItem[matchBy]))
+      addedItems.push(newItem);
+    else {
+      let oldItem = oldListIdsMap.get(newItem[matchBy]);
+      let isModified = newItem !== oldItem;
+      if (isModified)
+        itemsToUpdate.push(newItem);
+    }
+  });
+  return { removedItems, addedItems, itemsToUpdate };
+}
+function sandboxForEach(getItems, matchBy, children) {
+  const { viewState, endpoint, dataIds, parentComponentReactive } = useContext(SANDBOX_CREATION_CONTEXT);
+  let lastItems = [];
+  let childElementsMap = /* @__PURE__ */ new Map();
+  let savedContext = saveContext();
+  let update = (viewState2) => {
+    let newItems = getItems(viewState2) || [];
+    let isModified = newItems !== lastItems;
+    if (isModified) {
+      let { removedItems, addedItems, itemsToUpdate } = compareLists(
+        lastItems,
+        newItems,
+        matchBy
+      );
+      addedItems.forEach((item) => {
+        let childElements = restoreContext(
+          savedContext,
+          () => withContext(
+            SANDBOX_CREATION_CONTEXT,
+            {
+              endpoint,
+              viewState: item,
+              dataIds: [...dataIds, item[matchBy]],
+              isDynamic: true,
+              parentComponentReactive
+            },
+            children
+          )
+        );
+        childElements.forEach((childElement) => childElement.mount());
+        childElementsMap.set(item[matchBy], childElements);
+      });
+      removedItems.forEach((item) => {
+        let childElements = childElementsMap.get(item[matchBy]);
+        childElements.forEach((childElement) => childElement.unmount());
+        childElementsMap.delete(item[matchBy]);
+      });
+      itemsToUpdate.forEach((item) => {
+        childElementsMap.get(item[matchBy]).forEach((childElement) => {
+          childElement.update(item);
+        });
+      });
+      lastItems = newItems;
+    }
+  };
+  let mountUnmount = (op) => () => {
+    childElementsMap.forEach(
+      (childElements) => childElements.forEach((childElement) => childElement[op]())
+    );
+  };
+  let mount = mountUnmount("mount");
+  let unmount = mountUnmount("unmount");
+  update(viewState);
+  return {
+    update,
+    mount,
+    unmount
+  };
+}
+function sandboxCondition(condition, children) {
+  let { viewState } = useContext(SANDBOX_CREATION_CONTEXT);
+  let state = condition(viewState);
+  let mounted = true;
+  let childMounted = true;
+  const updateChild = () => {
+    let newState = condition(viewState);
+    if (mounted) {
+      if (newState !== state || childMounted !== newState) {
+        newState ? children.forEach((_) => _.mount()) : children.forEach((_) => _.unmount());
+        childMounted = newState;
+      }
+    } else {
+      if (childMounted)
+        children.forEach((_) => _.unmount());
+      childMounted = false;
+    }
+  };
+  updateChild();
+  const update = (newViewState) => {
+    viewState = newViewState;
+    children.forEach((_) => _.update(newViewState));
+    updateChild();
+  };
+  const mount = () => {
+    mounted = true;
+    updateChild();
+  };
+  const unmount = () => {
+    mounted = false;
+    updateChild();
+  };
+  return { update, mount, unmount };
+}
+function sandboxRoot(sandboxElements) {
+  let port = useWorkerPort();
+  let endpoint = port.getRootEndpoint();
+  let elements;
+  let viewState, nextDeserialize = deserialize;
+  endpoint.onUpdate((inMessage) => {
+    switch (inMessage.type) {
+      case JayPortMessageType.root: {
+        [viewState, nextDeserialize] = nextDeserialize(inMessage.patch);
+        if (!elements) {
+          let context = {
+            viewState,
+            endpoint,
+            isDynamic: false,
+            dataIds: []
+          };
+          elements = withContext(SANDBOX_CREATION_CONTEXT, context, () => {
+            return sandboxElements();
+          });
+        } else {
+          [viewState, nextDeserialize] = nextDeserialize(inMessage.patch);
+          elements.forEach((element) => element.update(viewState));
+        }
+        break;
+      }
+      case JayPortMessageType.nativeExecResult: {
+        completeCorrelatedPromise(inMessage);
+        break;
+      }
+    }
+  });
+}
+function exec$(handler) {
+  let port = useWorkerPort();
+  let { execPromise$, correlationId } = correlatedPromise();
+  port.getRootEndpoint().post(
+    nativeExec(handler.id, correlationId)
+  );
+  return execPromise$;
+}
+export {
+  HandshakeMessageJayChannel,
+  JayEndpoint,
+  JayPort,
+  JayPortLoggerConsole,
+  SECURE_COORDINATE_MARKER,
+  SecureHTMLElementCollectionRefsImpl,
+  SecureHTMLElementRefImpl,
+  SecurePrivateRefs,
+  SecureReferencesManager,
+  completeCorrelatedPromise,
+  correlatedPromise,
+  elementBridge,
+  exec$,
+  func$,
+  funcGlobal$,
+  handler$,
+  mainRoot,
+  makeJayComponentBridge,
+  mkBridgeElement,
+  newSecureHTMLElementPublicApiProxy,
+  sandboxChildComp,
+  sandboxCondition,
+  sandboxElement,
+  sandboxForEach,
+  sandboxRoot,
+  secureChildComp,
+  setMainPort,
+  setWorkerPort,
+  useMainPort,
+  useWorkerPort
+};