@blastlauncher/web 0.0.0-stage → 3.0.0-alpha.2

package/assets/almostnode.mjs

@@ -0,0 +1,735 @@
+// .cache/browser-demo/deps/node_modules/almostnode/src/sandbox-runtime.ts
+class SandboxRuntime {
+  iframe;
+  sandboxOrigin;
+  vfs;
+  options;
+  initialized;
+  pending = new Map;
+  messageId = 0;
+  changeListener = null;
+  deleteListener = null;
+  messageHandler = null;
+  constructor(sandboxUrl, vfs, options = {}) {
+    this.sandboxOrigin = new URL(sandboxUrl).origin;
+    this.vfs = vfs;
+    this.options = options;
+    this.iframe = document.createElement("iframe");
+    this.iframe.src = sandboxUrl;
+    this.iframe.style.display = "none";
+    this.iframe.credentialless = true;
+    this.iframe.setAttribute("credentialless", "");
+    document.body.appendChild(this.iframe);
+    this.setupMessageHandler();
+    this.initialized = this.waitForReady().then(() => this.initSandbox());
+    this.setupVFSListeners();
+  }
+  setupMessageHandler() {
+    this.messageHandler = (event) => {
+      if (event.origin !== this.sandboxOrigin)
+        return;
+      const message = event.data;
+      if (message.type === "result" && message.id) {
+        const pending = this.pending.get(message.id);
+        if (pending && message.result) {
+          pending.resolve(message.result);
+          this.pending.delete(message.id);
+        }
+      } else if (message.type === "error" && message.id) {
+        const pending = this.pending.get(message.id);
+        if (pending) {
+          pending.reject(new Error(message.error || "Unknown sandbox error"));
+          this.pending.delete(message.id);
+        }
+      } else if (message.type === "console" && this.options.onConsole) {
+        this.options.onConsole(message.consoleMethod || "log", message.consoleArgs || []);
+      }
+    };
+    window.addEventListener("message", this.messageHandler);
+  }
+  waitForReady() {
+    return new Promise((resolve) => {
+      const handler = (event) => {
+        if (event.origin !== this.sandboxOrigin)
+          return;
+        const message = event.data;
+        if (message.type === "ready") {
+          window.removeEventListener("message", handler);
+          resolve();
+        }
+      };
+      window.addEventListener("message", handler);
+    });
+  }
+  async initSandbox() {
+    const snapshot = this.vfs.toSnapshot();
+    const message = {
+      type: "init",
+      vfsSnapshot: snapshot,
+      options: {
+        cwd: this.options.cwd,
+        env: this.options.env
+      }
+    };
+    this.iframe.contentWindow?.postMessage(message, this.sandboxOrigin);
+    console.log("[SandboxRuntime] Sandbox initialized");
+  }
+  setupVFSListeners() {
+    this.changeListener = (path, content) => {
+      const message = {
+        type: "syncFile",
+        path,
+        content
+      };
+      this.iframe.contentWindow?.postMessage(message, this.sandboxOrigin);
+    };
+    this.vfs.on("change", this.changeListener);
+    this.deleteListener = (path) => {
+      const message = {
+        type: "syncFile",
+        path,
+        content: null
+      };
+      this.iframe.contentWindow?.postMessage(message, this.sandboxOrigin);
+    };
+    this.vfs.on("delete", this.deleteListener);
+  }
+  sendAndWait(message) {
+    return new Promise((resolve, reject) => {
+      const id = String(this.messageId++);
+      this.pending.set(id, { resolve, reject });
+      this.iframe.contentWindow?.postMessage({ ...message, id }, this.sandboxOrigin);
+      setTimeout(() => {
+        if (this.pending.has(id)) {
+          this.pending.delete(id);
+          reject(new Error("Sandbox execution timeout"));
+        }
+      }, 60000);
+    });
+  }
+  async execute(code, filename) {
+    await this.initialized;
+    return this.sendAndWait({
+      type: "execute",
+      code,
+      filename
+    });
+  }
+  async runFile(filename) {
+    await this.initialized;
+    return this.sendAndWait({
+      type: "runFile",
+      filename
+    });
+  }
+  clearCache() {
+    const message = { type: "clearCache" };
+    this.iframe.contentWindow?.postMessage(message, this.sandboxOrigin);
+  }
+  getVFS() {
+    return this.vfs;
+  }
+  terminate() {
+    if (this.changeListener) {
+      this.vfs.off("change", this.changeListener);
+    }
+    if (this.deleteListener) {
+      this.vfs.off("delete", this.deleteListener);
+    }
+    if (this.messageHandler) {
+      window.removeEventListener("message", this.messageHandler);
+    }
+    this.iframe.remove();
+    for (const [id, { reject }] of this.pending) {
+      reject(new Error("Sandbox terminated"));
+      this.pending.delete(id);
+    }
+    console.log("[SandboxRuntime] Sandbox terminated");
+  }
+}
+
+// .cache/browser-demo/deps/node_modules/almostnode/src/utils/binary-encoding.ts
+var CHUNK = 8192;
+function uint8ToBase64(bytes) {
+  const parts = [];
+  for (let i = 0;i < bytes.length; i += CHUNK) {
+    parts.push(String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + CHUNK))));
+  }
+  return btoa(parts.join(""));
+}
+function base64ToUint8(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+// .cache/browser-demo/deps/node_modules/almostnode/src/virtual-fs.ts
+function createNodeError(code, syscall, path, message) {
+  const errno = {
+    ENOENT: -2,
+    ENOTDIR: -20,
+    EISDIR: -21,
+    EEXIST: -17,
+    ENOTEMPTY: -39
+  };
+  const messages = {
+    ENOENT: "no such file or directory",
+    ENOTDIR: "not a directory",
+    EISDIR: "is a directory",
+    EEXIST: "file already exists",
+    ENOTEMPTY: "directory not empty"
+  };
+  const err = new Error(message || `${code}: ${messages[code]}, ${syscall} '${path}'`);
+  err.code = code;
+  err.errno = errno[code];
+  err.syscall = syscall;
+  err.path = path;
+  return err;
+}
+
+class VirtualFS {
+  root;
+  encoder = new TextEncoder;
+  decoder = new TextDecoder;
+  watchers = new Map;
+  eventListeners = new Map;
+  constructor() {
+    this.root = {
+      type: "directory",
+      children: new Map,
+      mtime: Date.now()
+    };
+  }
+  on(event, listener) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, new Set);
+    }
+    this.eventListeners.get(event).add(listener);
+    return this;
+  }
+  off(event, listener) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      listeners.delete(listener);
+    }
+    return this;
+  }
+  emit(event, ...args) {
+    const listeners = this.eventListeners.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(...args);
+        } catch (err) {
+          console.error("Error in VFS event listener:", err);
+        }
+      }
+    }
+  }
+  toSnapshot() {
+    const files = [];
+    this.serializeNode("/", this.root, files);
+    return { files };
+  }
+  serializeNode(path, node, files) {
+    if (node.type === "file") {
+      let content = "";
+      if (node.content && node.content.length > 0) {
+        content = uint8ToBase64(node.content);
+      }
+      files.push({ path, type: "file", content });
+    } else if (node.type === "directory") {
+      files.push({ path, type: "directory" });
+      if (node.children) {
+        for (const [name, child] of node.children) {
+          const childPath = path === "/" ? `/${name}` : `${path}/${name}`;
+          this.serializeNode(childPath, child, files);
+        }
+      }
+    }
+  }
+  static fromSnapshot(snapshot) {
+    const vfs = new VirtualFS;
+    const sortedFiles = snapshot.files.map((entry, i) => ({ entry, depth: entry.path.split("/").length, i })).sort((a, b) => a.depth - b.depth || a.i - b.i).map((x) => x.entry);
+    for (const entry of sortedFiles) {
+      if (entry.path === "/")
+        continue;
+      if (entry.type === "directory") {
+        vfs.mkdirSync(entry.path, { recursive: true });
+      } else if (entry.type === "file") {
+        let content;
+        if (entry.content) {
+          content = base64ToUint8(entry.content);
+        } else {
+          content = new Uint8Array(0);
+        }
+        const parentPath = entry.path.substring(0, entry.path.lastIndexOf("/")) || "/";
+        if (parentPath !== "/" && !vfs.existsSync(parentPath)) {
+          vfs.mkdirSync(parentPath, { recursive: true });
+        }
+        vfs.writeFileSyncInternal(entry.path, content, false);
+      }
+    }
+    return vfs;
+  }
+  writeFileSyncInternal(path, data, emitEvent) {
+    const normalized = this.normalizePath(path);
+    const parentPath = this.getParentPath(normalized);
+    const basename = this.getBasename(normalized);
+    if (!basename) {
+      throw new Error(`EISDIR: illegal operation on a directory, '${path}'`);
+    }
+    const parent = this.ensureDirectory(parentPath);
+    const existed = parent.children.has(basename);
+    const content = typeof data === "string" ? this.encoder.encode(data) : data;
+    parent.children.set(basename, {
+      type: "file",
+      content,
+      mtime: Date.now()
+    });
+    if (emitEvent) {
+      this.notifyWatchers(normalized, existed ? "change" : "rename");
+      this.emit("change", normalized, typeof data === "string" ? data : this.decoder.decode(data));
+    }
+  }
+  normalizePath(path) {
+    if (!path.startsWith("/")) {
+      path = "/" + path;
+    }
+    const parts = path.split("/").filter(Boolean);
+    const resolved = [];
+    for (const part of parts) {
+      if (part === "..") {
+        resolved.pop();
+      } else if (part !== ".") {
+        resolved.push(part);
+      }
+    }
+    return "/" + resolved.join("/");
+  }
+  getPathSegments(path) {
+    return this.normalizePath(path).split("/").filter(Boolean);
+  }
+  getParentPath(path) {
+    const normalized = this.normalizePath(path);
+    const lastSlash = normalized.lastIndexOf("/");
+    return lastSlash <= 0 ? "/" : normalized.slice(0, lastSlash);
+  }
+  getBasename(path) {
+    const normalized = this.normalizePath(path);
+    const lastSlash = normalized.lastIndexOf("/");
+    return normalized.slice(lastSlash + 1);
+  }
+  getNode(path) {
+    const segments = this.getPathSegments(path);
+    let current = this.root;
+    for (const segment of segments) {
+      if (current.type !== "directory" || !current.children) {
+        return;
+      }
+      const child = current.children.get(segment);
+      if (!child) {
+        return;
+      }
+      current = child;
+    }
+    return current;
+  }
+  ensureDirectory(path) {
+    const segments = this.getPathSegments(path);
+    let current = this.root;
+    for (const segment of segments) {
+      if (!current.children) {
+        current.children = new Map;
+      }
+      let child = current.children.get(segment);
+      if (!child) {
+        child = { type: "directory", children: new Map, mtime: Date.now() };
+        current.children.set(segment, child);
+      } else if (child.type !== "directory") {
+        throw new Error(`ENOTDIR: not a directory, '${path}'`);
+      }
+      current = child;
+    }
+    return current;
+  }
+  existsSync(path) {
+    return this.getNode(path) !== undefined;
+  }
+  statSync(path) {
+    const node = this.getNode(path);
+    if (!node) {
+      throw createNodeError("ENOENT", "stat", path);
+    }
+    const size = node.type === "file" ? node.content?.length || 0 : 0;
+    const mtime = node.mtime;
+    return {
+      isFile: () => node.type === "file",
+      isDirectory: () => node.type === "directory",
+      isSymbolicLink: () => false,
+      isBlockDevice: () => false,
+      isCharacterDevice: () => false,
+      isFIFO: () => false,
+      isSocket: () => false,
+      size,
+      mode: node.type === "directory" ? 493 : 420,
+      mtime: new Date(mtime),
+      atime: new Date(mtime),
+      ctime: new Date(mtime),
+      birthtime: new Date(mtime),
+      mtimeMs: mtime,
+      atimeMs: mtime,
+      ctimeMs: mtime,
+      birthtimeMs: mtime,
+      nlink: 1,
+      uid: 1000,
+      gid: 1000,
+      dev: 0,
+      ino: 0,
+      rdev: 0,
+      blksize: 4096,
+      blocks: Math.ceil(size / 512)
+    };
+  }
+  lstatSync(path) {
+    return this.statSync(path);
+  }
+  readFileSync(path, encoding) {
+    const node = this.getNode(path);
+    if (!node) {
+      throw createNodeError("ENOENT", "open", path);
+    }
+    if (node.type !== "file") {
+      throw createNodeError("EISDIR", "read", path);
+    }
+    const content = node.content || new Uint8Array(0);
+    if (encoding === "utf8" || encoding === "utf-8") {
+      return this.decoder.decode(content);
+    }
+    return content;
+  }
+  writeFileSync(path, data) {
+    this.writeFileSyncInternal(path, data, true);
+  }
+  mkdirSync(path, options) {
+    const normalized = this.normalizePath(path);
+    if (options?.recursive) {
+      this.ensureDirectory(normalized);
+      return;
+    }
+    const parentPath = this.getParentPath(normalized);
+    const basename = this.getBasename(normalized);
+    if (!basename) {
+      return;
+    }
+    const parent = this.getNode(parentPath);
+    if (!parent) {
+      throw createNodeError("ENOENT", "mkdir", parentPath);
+    }
+    if (parent.type !== "directory") {
+      throw createNodeError("ENOTDIR", "mkdir", parentPath);
+    }
+    if (parent.children.has(basename)) {
+      throw createNodeError("EEXIST", "mkdir", path);
+    }
+    parent.children.set(basename, {
+      type: "directory",
+      children: new Map,
+      mtime: Date.now()
+    });
+  }
+  readdirSync(path) {
+    const node = this.getNode(path);
+    if (!node) {
+      throw createNodeError("ENOENT", "scandir", path);
+    }
+    if (node.type !== "directory") {
+      throw createNodeError("ENOTDIR", "scandir", path);
+    }
+    return Array.from(node.children.keys());
+  }
+  unlinkSync(path) {
+    const normalized = this.normalizePath(path);
+    const parentPath = this.getParentPath(normalized);
+    const basename = this.getBasename(normalized);
+    const parent = this.getNode(parentPath);
+    if (!parent || parent.type !== "directory") {
+      throw createNodeError("ENOENT", "unlink", path);
+    }
+    const node = parent.children.get(basename);
+    if (!node) {
+      throw createNodeError("ENOENT", "unlink", path);
+    }
+    if (node.type !== "file") {
+      throw createNodeError("EISDIR", "unlink", path);
+    }
+    parent.children.delete(basename);
+    this.notifyWatchers(normalized, "rename");
+    this.emit("delete", normalized);
+  }
+  rmdirSync(path) {
+    const normalized = this.normalizePath(path);
+    const parentPath = this.getParentPath(normalized);
+    const basename = this.getBasename(normalized);
+    if (!basename) {
+      throw new Error(`EPERM: operation not permitted, '${path}'`);
+    }
+    const parent = this.getNode(parentPath);
+    if (!parent || parent.type !== "directory") {
+      throw createNodeError("ENOENT", "rmdir", path);
+    }
+    const node = parent.children.get(basename);
+    if (!node) {
+      throw createNodeError("ENOENT", "rmdir", path);
+    }
+    if (node.type !== "directory") {
+      throw createNodeError("ENOTDIR", "rmdir", path);
+    }
+    if (node.children.size > 0) {
+      throw createNodeError("ENOTEMPTY", "rmdir", path);
+    }
+    parent.children.delete(basename);
+  }
+  renameSync(oldPath, newPath) {
+    const normalizedOld = this.normalizePath(oldPath);
+    const normalizedNew = this.normalizePath(newPath);
+    const oldParentPath = this.getParentPath(normalizedOld);
+    const oldBasename = this.getBasename(normalizedOld);
+    const newParentPath = this.getParentPath(normalizedNew);
+    const newBasename = this.getBasename(normalizedNew);
+    const oldParent = this.getNode(oldParentPath);
+    if (!oldParent || oldParent.type !== "directory") {
+      throw createNodeError("ENOENT", "rename", oldPath);
+    }
+    const node = oldParent.children.get(oldBasename);
+    if (!node) {
+      throw createNodeError("ENOENT", "rename", oldPath);
+    }
+    const newParent = this.ensureDirectory(newParentPath);
+    oldParent.children.delete(oldBasename);
+    newParent.children.set(newBasename, node);
+    this.notifyWatchers(normalizedOld, "rename");
+    this.notifyWatchers(normalizedNew, "rename");
+  }
+  readFile(path, optionsOrCallback, callback) {
+    const actualCallback = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    const options = typeof optionsOrCallback === "object" ? optionsOrCallback : undefined;
+    try {
+      const data = options?.encoding ? this.readFileSync(path, options.encoding) : this.readFileSync(path);
+      if (actualCallback) {
+        setTimeout(() => actualCallback(null, data), 0);
+      }
+    } catch (err) {
+      if (actualCallback) {
+        setTimeout(() => actualCallback(err), 0);
+      }
+    }
+  }
+  stat(path, callback) {
+    try {
+      const stats = this.statSync(path);
+      setTimeout(() => callback(null, stats), 0);
+    } catch (err) {
+      setTimeout(() => callback(err), 0);
+    }
+  }
+  lstat(path, callback) {
+    this.stat(path, callback);
+  }
+  readdir(path, optionsOrCallback, callback) {
+    const actualCallback = typeof optionsOrCallback === "function" ? optionsOrCallback : callback;
+    try {
+      const files = this.readdirSync(path);
+      if (actualCallback) {
+        setTimeout(() => actualCallback(null, files), 0);
+      }
+    } catch (err) {
+      if (actualCallback) {
+        setTimeout(() => actualCallback(err), 0);
+      }
+    }
+  }
+  realpath(path, callback) {
+    try {
+      const resolved = this.realpathSync(path);
+      setTimeout(() => callback(null, resolved), 0);
+    } catch (err) {
+      setTimeout(() => callback(err), 0);
+    }
+  }
+  realpathSync(path) {
+    const normalized = this.normalizePath(path);
+    if (!this.existsSync(normalized)) {
+      throw createNodeError("ENOENT", "realpath", path);
+    }
+    return normalized;
+  }
+  watch(filename, optionsOrListener, listener) {
+    const normalized = this.normalizePath(filename);
+    let options = {};
+    let actualListener;
+    if (typeof optionsOrListener === "function") {
+      actualListener = optionsOrListener;
+    } else if (optionsOrListener) {
+      options = optionsOrListener;
+      actualListener = listener;
+    } else {
+      actualListener = listener;
+    }
+    const entry = {
+      listener: actualListener || (() => {}),
+      recursive: options.recursive || false,
+      closed: false
+    };
+    if (!this.watchers.has(normalized)) {
+      this.watchers.set(normalized, new Set);
+    }
+    this.watchers.get(normalized).add(entry);
+    const watcher = {
+      close: () => {
+        entry.closed = true;
+        const watcherSet = this.watchers.get(normalized);
+        if (watcherSet) {
+          watcherSet.delete(entry);
+          if (watcherSet.size === 0) {
+            this.watchers.delete(normalized);
+          }
+        }
+      },
+      ref: () => watcher,
+      unref: () => watcher
+    };
+    return watcher;
+  }
+  notifyWatchers(path, eventType) {
+    const normalized = this.normalizePath(path);
+    const basename = this.getBasename(normalized);
+    const directWatchers = this.watchers.get(normalized);
+    if (directWatchers) {
+      for (const entry of directWatchers) {
+        if (!entry.closed) {
+          try {
+            entry.listener(eventType, basename);
+          } catch (err) {
+            console.error("Error in file watcher:", err);
+          }
+        }
+      }
+    }
+    let currentPath = this.getParentPath(normalized);
+    let relativePath = basename;
+    while (currentPath) {
+      const parentWatchers = this.watchers.get(currentPath);
+      if (parentWatchers) {
+        for (const entry of parentWatchers) {
+          if (!entry.closed) {
+            const isDirectChild = this.getParentPath(normalized) === currentPath;
+            if (entry.recursive || isDirectChild) {
+              try {
+                entry.listener(eventType, relativePath);
+              } catch (err) {
+                console.error("Error in file watcher:", err);
+              }
+            }
+          }
+        }
+      }
+      if (currentPath === "/")
+        break;
+      relativePath = this.getBasename(currentPath) + "/" + relativePath;
+      currentPath = this.getParentPath(currentPath);
+    }
+  }
+  accessSync(path, mode) {
+    if (!this.existsSync(path)) {
+      throw createNodeError("ENOENT", "access", path);
+    }
+  }
+  access(path, modeOrCallback, callback) {
+    const actualCallback = typeof modeOrCallback === "function" ? modeOrCallback : callback;
+    try {
+      this.accessSync(path);
+      if (actualCallback)
+        setTimeout(() => actualCallback(null), 0);
+    } catch (err) {
+      if (actualCallback)
+        setTimeout(() => actualCallback(err), 0);
+    }
+  }
+  copyFileSync(src, dest) {
+    const content = this.readFileSync(src);
+    this.writeFileSync(dest, content);
+  }
+  createReadStream(path) {
+    const self = this;
+    const listeners = {};
+    const stream = {
+      on(event, cb) {
+        if (!listeners[event])
+          listeners[event] = [];
+        listeners[event].push(cb);
+        return stream;
+      },
+      pipe(dest) {
+        return dest;
+      }
+    };
+    setTimeout(() => {
+      try {
+        const data = self.readFileSync(path);
+        listeners["data"]?.forEach((cb) => cb(data));
+        listeners["end"]?.forEach((cb) => cb());
+      } catch (err) {
+        listeners["error"]?.forEach((cb) => cb(err));
+      }
+    }, 0);
+    return stream;
+  }
+  createWriteStream(path) {
+    const self = this;
+    const chunks = [];
+    const listeners = {};
+    const encoder = new TextEncoder;
+    return {
+      write(data) {
+        const chunk = typeof data === "string" ? encoder.encode(data) : data;
+        chunks.push(chunk);
+        return true;
+      },
+      end(data) {
+        if (data) {
+          const chunk = typeof data === "string" ? encoder.encode(data) : data;
+          chunks.push(chunk);
+        }
+        const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const combined = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+          combined.set(chunk, offset);
+          offset += chunk.length;
+        }
+        self.writeFileSync(path, combined);
+        listeners["finish"]?.forEach((cb) => cb());
+        listeners["close"]?.forEach((cb) => cb());
+      },
+      on(event, cb) {
+        if (!listeners[event])
+          listeners[event] = [];
+        listeners[event].push(cb);
+        return this;
+      }
+    };
+  }
+}
+
+// .cache/browser-demo/host.ts
+async function createRuntime(vfs, options) {
+  return new SandboxRuntime(options.sandbox, vfs);
+}
+export {
+  VirtualFS,
+  createRuntime
+};