@start.dev/container 0.0.1

package/dist/index.js

@@ -0,0 +1,1805 @@
+// ../fs/src/index.ts
+var now = () => Date.now();
+var clean = (path) => {
+  const parts = [];
+  for (const part of path.replace(/\\+/g, "/").split("/")) {
+    if (!part || part === ".")
+      continue;
+    if (part === "..") {
+      parts.pop();
+      continue;
+    }
+    parts.push(part);
+  }
+  return `/${parts.join("/")}`;
+};
+var basename = (path) => clean(path).split("/").pop() ?? "";
+var dirname = (path) => clean(path).split("/").slice(0, -1).join("/") || "/";
+var bytesToBase64 = (bytes) => {
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary);
+};
+var base64ToBytes = (content) => {
+  const binary = atob(content);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i += 1)
+    bytes[i] = binary.charCodeAt(i);
+  return bytes;
+};
+var isPlainRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+class MemoryFS {
+  root = { kind: "dir", children: new Map, mtime: now() };
+  watchers = new Set;
+  suppressWatchEvents = false;
+  pendingWatchEvents = new Map;
+  watchFlushQueued = false;
+  constructor(seed = {}) {
+    for (const [p, c] of Object.entries(seed))
+      this.writeFile(p, c);
+  }
+  walk(path, create = false, followFinal = true, seen = new Set) {
+    const requestedPath = clean(path);
+    const parts = requestedPath.split("/").filter(Boolean);
+    let cur = this.root;
+    let currentPath = "";
+    for (let index = 0;index < parts.length; index += 1) {
+      const part = parts[index];
+      currentPath = `${currentPath}/${part}`;
+      if (cur.kind !== "dir")
+        throw new Error(`ENOTDIR: ${requestedPath}`);
+      let next = cur.children.get(part);
+      if (!next) {
+        if (!create)
+          throw new Error(`ENOENT: ${requestedPath}`);
+        next = { kind: "dir", children: new Map, mtime: now() };
+        cur.children.set(part, next);
+      }
+      const isFinal = index === parts.length - 1;
+      if (next.kind === "symlink" && (followFinal || !isFinal)) {
+        if (seen.has(currentPath))
+          throw new Error(`ELOOP: ${requestedPath}`);
+        seen.add(currentPath);
+        const remaining = parts.slice(index + 1).join("/");
+        const target = this.resolveSymlinkTarget(dirname(currentPath), next.target);
+        return this.walk(remaining ? `${target}/${remaining}` : target, false, followFinal, seen);
+      }
+      cur = next;
+    }
+    return cur;
+  }
+  mkdirp(path) {
+    const p = clean(path);
+    const parts = p.split("/").filter(Boolean);
+    let currentPath = "";
+    for (const part of parts) {
+      currentPath = `${currentPath}/${part}`;
+      const existed = this.exists(currentPath);
+      this.walk(currentPath, true);
+      if (!existed)
+        this.emitWatch(currentPath, "rename");
+    }
+  }
+  writeFile(path, content) {
+    const p = clean(path);
+    const dirs = p.split("/").slice(0, -1).join("/") || "/";
+    const name = p.split("/").pop();
+    const existed = this.exists(p);
+    if (!this.exists(dirs))
+      this.mkdirp(dirs);
+    const dir = this.walk(dirs);
+    if (dir.kind !== "dir")
+      throw new Error(`ENOTDIR: ${dirs}`);
+    const current = dir.children.get(name);
+    if (current?.kind === "dir")
+      throw new Error(`EISDIR: ${p}`);
+    dir.children.set(name, { kind: "file", content: this.cloneContent(content), mtime: now() });
+    this.emitWatch(p, existed ? "change" : "rename");
+  }
+  symlink(target, path) {
+    const p = clean(path);
+    const dirs = dirname(p);
+    const name = basename(p);
+    if (!this.exists(dirs))
+      this.mkdirp(dirs);
+    const dir = this.walk(dirs);
+    if (dir.kind !== "dir")
+      throw new Error(`ENOTDIR: ${dirs}`);
+    if (dir.children.has(name))
+      throw new Error(`EEXIST: ${p}`);
+    dir.children.set(name, { kind: "symlink", target, mtime: now() });
+    dir.mtime = now();
+    this.emitWatch(p, "rename");
+  }
+  readlink(path) {
+    const entry = this.walk(path, false, false);
+    if (entry.kind !== "symlink")
+      throw new Error(`EINVAL: ${path}`);
+    return entry.target;
+  }
+  chmod(path, _mode) {
+    this.walk(path, false, false);
+    throw new Error(`ERR_WC_FS_PERMISSIONS_UNSUPPORTED: chmod(${clean(path)}) is not implemented by MemoryFS. Mode bits, ownership, ACLs, executable bits, umask, and POSIX permission enforcement remain unsupported; this guard prevents claiming Node/POSIX filesystem parity.`);
+  }
+  chown(path, _uid, _gid) {
+    this.walk(path, false, false);
+    throw new Error(`ERR_WC_FS_PERMISSIONS_UNSUPPORTED: chown(${clean(path)}) is not implemented by MemoryFS. uid/gid ownership, groups, ACLs, and POSIX permission enforcement remain unsupported; this guard prevents claiming Node/POSIX filesystem parity.`);
+  }
+  lstat(path) {
+    const entry = this.walk(path, false, false);
+    return { kind: entry.kind, mtime: entry.mtime };
+  }
+  mount(path, files) {
+    const mountPath = clean(path);
+    const normalizedFiles = new Map;
+    for (const [relativePath, content] of Object.entries(files)) {
+      const normalizedPath = this.normalizeMountRelativePath(relativePath);
+      if (normalizedFiles.has(normalizedPath)) {
+        throw new Error(`EINVAL: duplicate mount path after normalization: ${relativePath}`);
+      }
+      normalizedFiles.set(normalizedPath, content);
+    }
+    const existingMountEntry = this.getEntryNoFollow(mountPath);
+    if (existingMountEntry?.kind === "symlink") {
+      throw new Error(`ERR_WC_FS_MOUNT_SYMLINK_UNSUPPORTED: mounting onto a symlink is not implemented by MemoryFS: ${mountPath}. The current mount evidence only covers replacing concrete file/directory entries at the mount path; realpath resolution, mount namespaces, bind mounts, symlink overwrite semantics, and full Node/POSIX filesystem parity remain unsupported, so mount is rejected before mutating the tree.`);
+    }
+    const symlinkComponent = this.findSymlinkPathComponent(mountPath);
+    if (symlinkComponent) {
+      throw new Error(`ERR_WC_FS_MOUNT_SYMLINK_COMPONENT_UNSUPPORTED: mount paths containing symlink components are not implemented by MemoryFS: ${mountPath} crosses ${symlinkComponent}. The current mount evidence only covers concrete virtual directory components; realpath traversal, bind mounts, symlink component resolution, host filesystem semantics, and full Node/POSIX filesystem parity remain unsupported, so mount is rejected before mutating the tree.`);
+    }
+    if (existingMountEntry) {
+      if (existingMountEntry.kind === "dir")
+        this.rmdir(mountPath);
+      else
+        this.unlink(mountPath);
+    }
+    this.mkdirp(mountPath);
+    for (const [relativePath, content] of normalizedFiles) {
+      this.writeFile(`${mountPath}/${relativePath}`, content);
+    }
+  }
+  unmount(path) {
+    this.rmdir(path);
+  }
+  readFile(path) {
+    const e = this.walk(path);
+    if (e.kind !== "file")
+      throw new Error(`EISDIR: ${path}`);
+    const content = e.content ?? "";
+    return typeof content === "string" ? content : new TextDecoder().decode(content);
+  }
+  readFileBuffer(path) {
+    const e = this.walk(path);
+    if (e.kind !== "file")
+      throw new Error(`EISDIR: ${path}`);
+    const content = e.content ?? "";
+    return typeof content === "string" ? new TextEncoder().encode(content) : new Uint8Array(content);
+  }
+  unlink(path) {
+    const p = clean(path);
+    const dirs = p.split("/").slice(0, -1).join("/") || "/";
+    const name = p.split("/").pop();
+    const dir = this.walk(dirs);
+    if (dir.kind !== "dir")
+      throw new Error(`ENOTDIR: ${dirs}`);
+    const entry = dir.children.get(name);
+    if (!entry)
+      throw new Error(`ENOENT: ${path}`);
+    if (entry.kind === "dir")
+      throw new Error(`EISDIR: ${path}`);
+    dir.children.delete(name);
+    dir.mtime = now();
+    this.emitWatch(p, "rename");
+    this.closeDeletedPathWatchers(p);
+  }
+  rmdir(path) {
+    const p = clean(path);
+    if (p === "/")
+      throw new Error("EBUSY: /");
+    const dirs = p.split("/").slice(0, -1).join("/") || "/";
+    const name = p.split("/").pop();
+    const dir = this.walk(dirs);
+    if (dir.kind !== "dir")
+      throw new Error(`ENOTDIR: ${dirs}`);
+    const entry = dir.children.get(name);
+    if (!entry)
+      throw new Error(`ENOENT: ${path}`);
+    if (entry.kind !== "dir")
+      throw new Error(`ENOTDIR: ${path}`);
+    const removedPaths = this.entryPaths(entry);
+    dir.children.delete(name);
+    dir.mtime = now();
+    for (const suffix of removedPaths)
+      this.emitWatch(`${p}${suffix}`, "rename");
+    this.closeDeletedPathWatchers(p);
+  }
+  rename(from, to) {
+    const src = clean(from);
+    const dest = clean(to);
+    if (src === "/" || dest === "/")
+      throw new Error("EBUSY: /");
+    const srcDirPath = dirname(src);
+    const srcName = basename(src);
+    const destDirPath = dirname(dest);
+    const destName = basename(dest);
+    const srcDir = this.walk(srcDirPath);
+    if (srcDir.kind !== "dir")
+      throw new Error(`ENOTDIR: ${srcDirPath}`);
+    const entry = srcDir.children.get(srcName);
+    if (!entry)
+      throw new Error(`ENOENT: ${from}`);
+    if (entry.kind === "dir" && this.isDescendant(src, dest))
+      throw new Error(`EINVAL: ${src} -> ${dest}`);
+    const destDir = this.walk(destDirPath);
+    if (destDir.kind !== "dir")
+      throw new Error(`ENOTDIR: ${destDirPath}`);
+    const existingDest = destDir.children.get(destName);
+    if (existingDest && existingDest.kind !== entry.kind)
+      throw new Error(`${existingDest.kind === "dir" ? "EISDIR" : "ENOTDIR"}: ${dest}`);
+    if (existingDest?.kind === "dir" && existingDest.children.size > 0)
+      throw new Error(`ENOTEMPTY: ${dest}`);
+    const renamedPaths = this.entryPaths(entry);
+    srcDir.children.delete(srcName);
+    srcDir.mtime = now();
+    destDir.children.set(destName, entry);
+    destDir.mtime = now();
+    entry.mtime = now();
+    for (const suffix of renamedPaths)
+      this.emitWatch(`${src}${suffix}`, "rename");
+    this.closeDeletedPathWatchers(src);
+    for (const suffix of renamedPaths)
+      this.emitWatch(`${dest}${suffix}`, "rename");
+  }
+  exists(path) {
+    try {
+      this.walk(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  list(path = "/") {
+    const e = this.walk(path);
+    if (e.kind !== "dir")
+      throw new Error(`ENOTDIR: ${path}`);
+    return [...e.children.entries()].map(([name, entry]) => ({ name, kind: entry.kind, mtime: entry.mtime })).sort((a, b) => a.name.localeCompare(b.name));
+  }
+  snapshot() {
+    const files = {};
+    const dirs = [];
+    const symlinks = {};
+    const visit = (path, e) => {
+      if (e.kind === "file") {
+        const content = e.content ?? "";
+        files[path] = typeof content === "string" ? content : { encoding: "base64", content: bytesToBase64(content) };
+      } else if (e.kind === "symlink") {
+        symlinks[path] = e.target;
+      } else {
+        dirs.push(path);
+        for (const [n, c] of e.children)
+          visit(path === "/" ? `/${n}` : `${path}/${n}`, c);
+      }
+    };
+    visit("/", this.root);
+    return { version: 1, files, dirs, symlinks };
+  }
+  restore(s) {
+    this.assertSupportedSnapshot(s);
+    const before = this.snapshot();
+    this.suppressWatchEvents = true;
+    try {
+      this.root = { kind: "dir", children: new Map, mtime: now() };
+      for (const d of s.dirs)
+        this.mkdirp(d);
+      for (const [p, c] of Object.entries(s.files))
+        this.writeFile(p, typeof c === "string" ? c : base64ToBytes(c.content));
+      for (const [p, target] of Object.entries(s.symlinks ?? {}))
+        this.symlink(target, p);
+    } finally {
+      this.suppressWatchEvents = false;
+    }
+    this.emitSnapshotRestoreWatchEvents(before, s);
+  }
+  watch(path, optionsOrListener, maybeListener) {
+    const options = typeof optionsOrListener === "function" ? {} : optionsOrListener;
+    const listener = typeof optionsOrListener === "function" ? optionsOrListener : maybeListener;
+    if (!listener)
+      throw new Error("watch listener is required");
+    if (options.encoding && options.encoding !== "utf8") {
+      throw new Error(`ENOTSUP: fs.watch encoding ${options.encoding} is not supported`);
+    }
+    const watchPath = clean(path);
+    const watchedEntryNoFollow = this.walk(watchPath, false, false);
+    const watchedEntry = this.walk(watchPath);
+    if (options.recursive === true && watchedEntryNoFollow.kind === "symlink") {
+      throw new Error(`ERR_WC_FS_RECURSIVE_SYMLINK_WATCH_UNSUPPORTED: recursive fs.watch through symlink targets has no automated evidence in MemoryFS: ${watchPath}. Symlink target traversal, target-vs-link event path identity, symlink retargeting/deletion lifecycle, platform-specific Node fs.watch behavior, POSIX/Linux filesystem behavior, and full Node fs.watch parity remain unsupported, so no watcher is registered.`);
+    }
+    if (watchedEntryNoFollow.kind === "symlink") {
+      throw new Error(`ERR_WC_FS_SYMLINK_WATCH_UNSUPPORTED: fs.watch through symlink targets has no automated evidence in MemoryFS: ${watchPath}. target-vs-link event path identity, symlink retargeting/deletion lifecycle, symlink traversal, platform-specific Node fs.watch behavior, POSIX/Linux filesystem behavior, and full Node fs.watch parity remain unsupported, so no watcher is registered.`);
+    }
+    if (options.recursive === true && watchedEntry.kind !== "dir") {
+      throw new Error(`ERR_WC_FS_RECURSIVE_FILE_WATCH_UNSUPPORTED: recursive fs.watch only has automated evidence for directory trees; ${watchPath} is a ${watchedEntry.kind}. Recursive file-target semantics, platform-specific Node fs.watch behavior, symlink target traversal, and polling watcher parity remain unsupported, so no watcher is registered.`);
+    }
+    const watcher = { path: watchPath, listener, recursive: options.recursive === true, signal: options.signal };
+    if (options.signal?.aborted)
+      return { close: () => {} };
+    this.watchers.add(watcher);
+    watcher.abortHandler = () => this.closeWatcher(watcher);
+    options.signal?.addEventListener("abort", watcher.abortHandler, { once: true });
+    return { close: watcher.abortHandler };
+  }
+  watchFile(path, optionsOrListener, maybeListener) {
+    const listener = typeof optionsOrListener === "function" ? optionsOrListener : maybeListener;
+    if (!listener)
+      throw new Error("watchFile listener is required");
+    this.walk(path, false, false);
+    throw new Error(`ERR_WC_FS_WATCHFILE_UNSUPPORTED: fs.watchFile(${clean(path)}) is not implemented by MemoryFS. The runtime currently supports event-driven fs.watch only for a narrow virtual filesystem subset; polling stat watchers, curr/prev Stats snapshots, interval scheduling, persistent handles, and Node fs.watchFile parity remain unsupported. This guard prevents fake polling watchers or broad Node fs parity claims.`);
+  }
+  unwatchFile(path, _listener) {
+    throw new Error(`ERR_WC_FS_WATCHFILE_UNSUPPORTED: fs.unwatchFile(${clean(path)}) is not implemented by MemoryFS because fs.watchFile polling registrations are unsupported. Polling watcher bookkeeping, listener-specific removal, curr/prev Stats snapshots, and Node fs.watchFile/unwatchFile parity remain unsupported.`);
+  }
+  emitWatch(path, eventType) {
+    if (this.suppressWatchEvents)
+      return;
+    const p = clean(path);
+    const matchingWatchers = new Set([...this.watchers].filter((watcher) => this.watchMatches(watcher, p)));
+    if (matchingWatchers.size === 0)
+      return;
+    const key = `${p}\x00${eventType}`;
+    const pending = this.pendingWatchEvents.get(key);
+    if (pending) {
+      for (const watcher of matchingWatchers)
+        pending.watchers.add(watcher);
+    } else {
+      this.pendingWatchEvents.set(key, { path: p, eventType, watchers: matchingWatchers });
+    }
+    if (this.watchFlushQueued)
+      return;
+    this.watchFlushQueued = true;
+    queueMicrotask(() => {
+      const events = [...this.pendingWatchEvents.values()];
+      this.pendingWatchEvents.clear();
+      this.watchFlushQueued = false;
+      for (const { path: eventPath, eventType: pendingEventType, watchers } of events) {
+        for (const watcher of watchers) {
+          watcher.listener(pendingEventType, this.watchFilename(watcher.path, eventPath));
+        }
+      }
+    });
+  }
+  watchMatches(watcher, eventPath) {
+    return watcher.path === eventPath || watcher.path === dirname(eventPath) || watcher.recursive && this.isDescendant(watcher.path, eventPath);
+  }
+  closeWatcher(watcher) {
+    this.watchers.delete(watcher);
+    if (watcher.abortHandler)
+      watcher.signal?.removeEventListener("abort", watcher.abortHandler);
+  }
+  closeDeletedPathWatchers(deletedPath) {
+    for (const watcher of [...this.watchers]) {
+      if (watcher.path === deletedPath || this.isDescendant(deletedPath, watcher.path))
+        this.closeWatcher(watcher);
+    }
+  }
+  watchFilename(watchPath, eventPath) {
+    if (watchPath === dirname(eventPath) || watchPath === eventPath)
+      return basename(eventPath);
+    return eventPath.slice(watchPath === "/" ? 1 : watchPath.length + 1);
+  }
+  emitSnapshotRestoreWatchEvents(before, after) {
+    const beforeEntries = this.snapshotEntries(before);
+    const afterEntries = this.snapshotEntries(after);
+    const paths = [...new Set([...beforeEntries.keys(), ...afterEntries.keys()])].filter((path) => path !== "/").sort((a, b) => a.localeCompare(b));
+    const deletedPaths = [];
+    for (const path of paths) {
+      const previous = beforeEntries.get(path);
+      const next = afterEntries.get(path);
+      if (!previous && next) {
+        this.emitWatch(path, "rename");
+      } else if (previous && !next) {
+        this.emitWatch(path, "rename");
+        deletedPaths.push(path);
+      } else if (previous && next && previous !== next) {
+        this.emitWatch(path, previous.split("\x00", 1)[0] === next.split("\x00", 1)[0] ? "change" : "rename");
+      }
+    }
+    for (const path of deletedPaths)
+      this.closeDeletedPathWatchers(path);
+  }
+  snapshotEntries(snapshot) {
+    const entries = new Map;
+    for (const dir of snapshot.dirs)
+      entries.set(dir, "dir");
+    for (const [path, file] of Object.entries(snapshot.files)) {
+      entries.set(path, `file\x00${typeof file === "string" ? `text\x00${file}` : `base64\x00${file.content}`}`);
+    }
+    for (const [path, target] of Object.entries(snapshot.symlinks ?? {}))
+      entries.set(path, `symlink\x00${target}`);
+    return entries;
+  }
+  entryPaths(entry, prefix = "") {
+    if (entry.kind === "file" || entry.kind === "symlink")
+      return [prefix];
+    const paths = [prefix];
+    for (const [name, child] of entry.children) {
+      paths.push(...this.entryPaths(child, `${prefix}/${name}`));
+    }
+    return paths;
+  }
+  isDescendant(parentPath, childPath) {
+    return parentPath !== childPath && childPath.startsWith(parentPath === "/" ? "/" : `${parentPath}/`);
+  }
+  getEntryNoFollow(path) {
+    try {
+      return this.walk(path, false, false);
+    } catch {
+      return;
+    }
+  }
+  findSymlinkPathComponent(path) {
+    const parts = clean(path).split("/").filter(Boolean);
+    let currentPath = "";
+    for (let index = 0;index < parts.length - 1; index += 1) {
+      currentPath = `${currentPath}/${parts[index]}`;
+      const entry = this.getEntryNoFollow(currentPath);
+      if (entry?.kind === "symlink")
+        return currentPath;
+    }
+    return;
+  }
+  normalizeMountRelativePath(path) {
+    const parts = [];
+    for (const part of path.replace(/\\+/g, "/").split("/")) {
+      if (!part || part === ".")
+        continue;
+      if (part === "..")
+        throw new Error(`EINVAL: mount paths must stay within the mount root: ${path}`);
+      parts.push(part);
+    }
+    if (parts.length === 0)
+      throw new Error(`EINVAL: mount path must name a file: ${path}`);
+    return parts.join("/");
+  }
+  assertSupportedSnapshot(snapshot) {
+    if (!snapshot || snapshot.version !== 1) {
+      const version = snapshot && typeof snapshot === "object" && "version" in snapshot ? String(snapshot.version) : "missing";
+      throw new Error(`ERR_WC_SNAPSHOT_VERSION_UNSUPPORTED: MemoryFS cannot restore snapshot version ${version}; only MemoryFS snapshot version 1 has automated restore evidence. Snapshot migration, inode metadata, hardlink identity, permissions/mode bits, and durable persistence parity remain unsupported, so restore is rejected before mutating the existing filesystem tree.`);
+    }
+    const candidate = snapshot;
+    if (!isPlainRecord(candidate.files)) {
+      throw this.snapshotMetadataError("snapshot files metadata is missing or not an object");
+    }
+    if (!Array.isArray(candidate.dirs)) {
+      throw this.snapshotMetadataError("snapshot dirs metadata must be an array of paths");
+    }
+    for (const [index, dir] of candidate.dirs.entries()) {
+      if (typeof dir !== "string") {
+        throw this.snapshotDirMetadataError(index);
+      }
+      this.assertCanonicalSnapshotPath(dir, "dir");
+    }
+    const pathKinds = new Map;
+    for (const dir of candidate.dirs)
+      pathKinds.set(dir, "dir");
+    for (const [path, file] of Object.entries(candidate.files)) {
+      this.assertCanonicalSnapshotPath(path, "file");
+      this.assertSnapshotPathKind(pathKinds, path, "file");
+      const validText = typeof file === "string";
+      const validBinary = isPlainRecord(file) && file.encoding === "base64" && typeof file.content === "string";
+      if (!validText && !validBinary) {
+        throw this.snapshotMetadataError(`snapshot file metadata for ${path} is not a supported version-1 text or base64 binary payload`);
+      }
+      if (validBinary) {
+        this.assertValidSnapshotBase64(path, file.content);
+      }
+    }
+    if (candidate.symlinks !== undefined) {
+      if (!isPlainRecord(candidate.symlinks)) {
+        throw this.snapshotMetadataError("snapshot symlinks metadata must be an object when present");
+      }
+      for (const [path, target] of Object.entries(candidate.symlinks)) {
+        this.assertCanonicalSnapshotPath(path, "symlink");
+        this.assertSnapshotPathKind(pathKinds, path, "symlink");
+        if (typeof target !== "string") {
+          throw this.snapshotMetadataError(`snapshot symlink metadata for ${path} must be a string target`);
+        }
+      }
+    }
+    for (const dir of candidate.dirs)
+      this.assertSnapshotParents(pathKinds, dir, "dir");
+    for (const path of Object.keys(candidate.files))
+      this.assertSnapshotParents(pathKinds, path, "file");
+    for (const path of Object.keys(candidate.symlinks ?? {}))
+      this.assertSnapshotParents(pathKinds, path, "symlink");
+  }
+  assertCanonicalSnapshotPath(path, kind) {
+    if (!path.startsWith("/") || clean(path) !== path) {
+      throw this.snapshotMetadataError(`snapshot ${kind} path ${path} must be an absolute canonical virtual path`);
+    }
+  }
+  assertSnapshotPathKind(pathKinds, path, kind) {
+    const existingKind = pathKinds.get(path);
+    if (existingKind && existingKind !== kind) {
+      throw this.snapshotKindCollisionError(path, existingKind, kind);
+    }
+    pathKinds.set(path, kind);
+  }
+  assertSnapshotParents(pathKinds, path, kind) {
+    if (path === "/")
+      return;
+    const parts = path.split("/").filter(Boolean);
+    let parent = "";
+    for (let index = 0;index < parts.length - 1; index += 1) {
+      parent = `${parent}/${parts[index]}`;
+      if (pathKinds.get(parent) !== "dir")
+        throw this.snapshotMissingParentError(path, kind, parent);
+    }
+    if (pathKinds.get("/") !== "dir")
+      throw this.snapshotMissingParentError(path, kind, "/");
+  }
+  assertValidSnapshotBase64(path, content) {
+    try {
+      base64ToBytes(content);
+    } catch {
+      throw this.snapshotMetadataError(`snapshot binary payload for ${path} is not valid base64`);
+    }
+  }
+  snapshotMetadataError(detail) {
+    return new Error(`ERR_WC_SNAPSHOT_METADATA_UNSUPPORTED: ${detail}; restore is rejected before mutating the existing filesystem tree. Only MemoryFS snapshot version 1 with absolute canonical virtual paths, string text files, { encoding: 'base64', content: string } binary files, string directory paths, and string symlink targets has automated restore evidence. Snapshot path normalization/repair, host filesystem path interpretation, realpath resolution, and durable persistence migration remain unsupported; Snapshot metadata repair, migration, inode/mode-bit metadata, and hardlink identity remain unsupported.`);
+  }
+  snapshotKindCollisionError(path, existingKind, kind) {
+    return new Error(`ERR_WC_SNAPSHOT_METADATA_UNSUPPORTED: snapshot path ${path} is recorded as both ${existingKind} and ${kind} metadata; restore is rejected before mutating the existing filesystem tree. Only MemoryFS snapshot version 1 with one entry kind per absolute canonical virtual path has automated restore evidence. Snapshot kind-collision repair, inode/mode-bit metadata reconciliation, hardlink identity, and durable persistence migration remain unsupported; POSIX/Linux filesystem parity and full Node fs metadata parity remain unsupported.`);
+  }
+  snapshotMissingParentError(path, kind, parent) {
+    return new Error(`ERR_WC_SNAPSHOT_METADATA_UNSUPPORTED: snapshot ${kind} path ${path} is missing parent dir metadata for ${parent}; restore is rejected before mutating the existing filesystem tree. Only MemoryFS snapshot version 1 with explicit directory metadata for every virtual parent path has automated restore evidence. Implicit parent directory reconstruction, snapshot repair, path normalization, and durable persistence migration remain unsupported; POSIX/Linux filesystem parity and full Node fs metadata parity remain unsupported.`);
+  }
+  snapshotDirMetadataError(index) {
+    return new Error(`ERR_WC_SNAPSHOT_METADATA_UNSUPPORTED: snapshot dir metadata at index ${index} is not a supported version-1 string path; restore is rejected before mutating the existing filesystem tree. Only MemoryFS snapshot version 1 stores dirs as absolute canonical virtual path strings. Directory mtimes, inode/device metadata, mode bits, xattrs, and snapshot metadata migration remain unsupported; host filesystem path interpretation, durable persistence migration, POSIX/Linux filesystem parity, and full Node fs metadata parity remain unsupported.`);
+  }
+  cloneContent(content) {
+    return typeof content === "string" ? content : new Uint8Array(content);
+  }
+  resolveSymlinkTarget(linkParentPath, target) {
+    return target.startsWith("/") ? clean(target) : clean(`${linkParentPath}/${target}`);
+  }
+}
+
+// ../kernel/src/protocol.ts
+var FS_OP = {
+  ReadFile: 1,
+  WriteFile: 2,
+  Readdir: 3,
+  Stat: 4,
+  Exists: 5,
+  Mkdirp: 6,
+  Unlink: 7,
+  Readlink: 8,
+  Rename: 9
+};
+var HEADER_LEN_BYTES = 4;
+var encoder = new TextEncoder;
+var decoder = new TextDecoder;
+function decodeFrame(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const headerLen = view.getUint32(0, true);
+  const headerStart = HEADER_LEN_BYTES;
+  const headerEnd = headerStart + headerLen;
+  const meta = headerLen === 0 ? {} : JSON.parse(decoder.decode(bytes.subarray(headerStart, headerEnd)));
+  const tail = bytes.subarray(headerEnd);
+  return { meta, tail };
+}
+function encodeText(text) {
+  return encoder.encode(text);
+}
+// ../syscall/src/index.ts
+var SLOT_STATE = 0;
+var SLOT_OPCODE = 1;
+var SLOT_REQ_LEN = 2;
+var SLOT_RES_LEN = 3;
+var SLOT_RES_STATUS = 4;
+var CONTROL_SLOTS = 8;
+var CONTROL_BYTES = CONTROL_SLOTS * 4;
+var STATE_REQUEST = 1;
+var STATE_RESPONSE = 2;
+var STATUS_OK = 0;
+var STATUS_ERROR = 1;
+var DEFAULT_DATA_BYTES = 1 << 20;
+function createSyscallRing(dataBytes = DEFAULT_DATA_BYTES) {
+  return new SharedArrayBuffer(CONTROL_BYTES + dataBytes);
+}
+function ringViews(sab) {
+  const control = new Int32Array(sab, 0, CONTROL_SLOTS);
+  const data = new Uint8Array(sab, CONTROL_BYTES);
+  return { control, data };
+}
+class SyscallServicer {
+  handler;
+  control;
+  data;
+  constructor(sab, handler) {
+    this.handler = handler;
+    const v = ringViews(sab);
+    this.control = v.control;
+    this.data = v.data;
+  }
+  async serviceOnce() {
+    if (Atomics.load(this.control, SLOT_STATE) !== STATE_REQUEST)
+      return false;
+    const opcode = Atomics.load(this.control, SLOT_OPCODE);
+    const reqLen = Atomics.load(this.control, SLOT_REQ_LEN);
+    const request = this.data.slice(0, reqLen);
+    try {
+      const result = await this.handler(opcode, request);
+      this.writeResponse(result.status, result.bytes);
+    } catch (err) {
+      const message = new TextEncoder().encode(err instanceof Error ? err.message : String(err));
+      this.writeResponse(STATUS_ERROR, message);
+    }
+    return true;
+  }
+  writeResponse(status, bytes) {
+    if (bytes.byteLength > this.data.byteLength) {
+      const message = new TextEncoder().encode(`syscall response of ${bytes.byteLength} bytes exceeds ring capacity ` + `${this.data.byteLength}; payload chunking is not implemented yet`);
+      this.data.set(message, 0);
+      Atomics.store(this.control, SLOT_RES_LEN, message.byteLength);
+      Atomics.store(this.control, SLOT_RES_STATUS, STATUS_ERROR);
+    } else {
+      this.data.set(bytes, 0);
+      Atomics.store(this.control, SLOT_RES_LEN, bytes.byteLength);
+      Atomics.store(this.control, SLOT_RES_STATUS, status);
+    }
+    Atomics.store(this.control, SLOT_STATE, STATE_RESPONSE);
+    Atomics.notify(this.control, SLOT_STATE);
+  }
+}
+
+// ../kernel/src/fs-servicer.ts
+var EMPTY = new Uint8Array(0);
+var ok = (bytes) => ({ status: STATUS_OK, bytes });
+var fail = (message) => ({ status: STATUS_ERROR, bytes: encodeText(message) });
+function createFsHandler(fs) {
+  return (opcode, request) => {
+    const { meta, tail } = decodeFrame(request);
+    try {
+      switch (opcode) {
+        case FS_OP.ReadFile:
+          return ok(fs.readFileBuffer(meta.path));
+        case FS_OP.WriteFile:
+          fs.writeFile(meta.path, tail);
+          return ok(EMPTY);
+        case FS_OP.Readdir:
+          return ok(encodeText(JSON.stringify(fs.list(meta.path).map((entry) => entry.name))));
+        case FS_OP.Stat: {
+          const stat = fs.lstat(meta.path);
+          let size = 0;
+          if (stat.kind === "file")
+            size = fs.readFileBuffer(meta.path).byteLength;
+          const wire = { kind: stat.kind, size, mtimeMs: stat.mtime };
+          return ok(encodeText(JSON.stringify(wire)));
+        }
+        case FS_OP.Exists:
+          return ok(encodeText(JSON.stringify(fs.exists(meta.path))));
+        case FS_OP.Mkdirp:
+          fs.mkdirp(meta.path);
+          return ok(EMPTY);
+        case FS_OP.Unlink:
+          fs.unlink(meta.path);
+          return ok(EMPTY);
+        case FS_OP.Readlink:
+          return ok(encodeText(fs.readlink(meta.path)));
+        case FS_OP.Rename:
+          fs.rename(meta.from, meta.to);
+          return ok(EMPTY);
+        default:
+          return fail(`EINVAL: unknown fs opcode ${opcode}`);
+      }
+    } catch (err) {
+      return fail(err instanceof Error ? err.message : String(err));
+    }
+  };
+}
+// ../kernel/src/syscall-memfs.ts
+var encoder2 = new TextEncoder;
+// ../kernel/src/streaming-spawn.ts
+function spawnStreamingNodeProcess(fs, opts) {
+  const sab = createSyscallRing(opts.ringBytes);
+  const servicer = new SyscallServicer(sab, createFsHandler(fs));
+  const WorkerCtor = globalThis.Worker;
+  const worker = new WorkerCtor(opts.workerUrl, { type: "module" });
+  let resolveExit;
+  const exit = new Promise((resolve) => {
+    resolveExit = resolve;
+  });
+  let settled = false;
+  const settle = (code) => {
+    if (settled)
+      return;
+    settled = true;
+    try {
+      worker.terminate();
+    } catch {}
+    resolveExit(code);
+  };
+  worker.onerror = (event) => {
+    opts.onStderr?.((event?.message ?? "worker error") + `
+`);
+    settle(1);
+  };
+  worker.onmessage = (event) => {
+    const msg = event.data;
+    if (!msg)
+      return;
+    if (msg.type === "doorbell") {
+      servicer.serviceOnce();
+      return;
+    }
+    if (msg.type === "stdout") {
+      opts.onStdout?.(msg.chunk);
+      return;
+    }
+    if (msg.type === "stderr") {
+      opts.onStderr?.(msg.chunk);
+      return;
+    }
+    if (msg.type === "exit") {
+      settle(msg.code);
+      return;
+    }
+  };
+  worker.postMessage({
+    type: "init",
+    sab,
+    projectRoot: opts.projectRoot,
+    entry: opts.entry,
+    argv: opts.argv ?? [],
+    env: opts.env ?? {}
+  });
+  return {
+    exit,
+    writeStdin(chunk) {
+      try {
+        worker.postMessage({ type: "stdin", data: chunk });
+      } catch {}
+    },
+    kill() {
+      settle(143);
+    }
+  };
+}
+// ../kernel/src/shell-spawn.ts
+function spawnShellProcess(fs, opts) {
+  const WorkerCtor = globalThis.Worker;
+  const worker = new WorkerCtor(opts.workerUrl, { type: "module" });
+  let resolveExit;
+  const exit = new Promise((resolve) => {
+    resolveExit = resolve;
+  });
+  let settled = false;
+  const settle = (code) => {
+    if (settled)
+      return;
+    settled = true;
+    try {
+      worker.terminate();
+    } catch {}
+    resolveExit(code);
+  };
+  worker.onerror = (event) => {
+    opts.onStderr?.((event?.message ?? "shell worker error") + `
+`);
+    settle(1);
+  };
+  worker.onmessage = (event) => {
+    const msg = event.data;
+    if (!msg)
+      return;
+    if (msg.type === "stdout") {
+      opts.onStdout?.(msg.chunk);
+      return;
+    }
+    if (msg.type === "stderr") {
+      opts.onStderr?.(msg.chunk);
+      return;
+    }
+    if (msg.type === "exit") {
+      try {
+        if (msg.snapshot)
+          fs.restore(msg.snapshot);
+      } catch {}
+      settle(msg.code);
+      return;
+    }
+  };
+  worker.postMessage({
+    type: "init",
+    snapshot: fs.snapshot(),
+    commandLine: opts.commandLine,
+    cwd: opts.cwd,
+    env: opts.env ?? {}
+  });
+  return {
+    exit,
+    writeStdin() {},
+    kill() {
+      settle(143);
+    }
+  };
+}
+// ../network/src/index.ts
+class VirtualNetwork {
+  handlers = new Map;
+  listen(port, handler) {
+    if (this.handlers.has(port))
+      throw new Error(`EADDRINUSE: ${port}`);
+    this.handlers.set(port, handler);
+    return { port, close: () => this.handlers.delete(port), url: `http://localhost:${port}` };
+  }
+  async fetch(url, init) {
+    const u = new URL(url);
+    const h = this.handlers.get(Number(u.port || 80));
+    if (!h)
+      throw new Error(`ECONNREFUSED: ${u.port}`);
+    return h(new Request(url, init));
+  }
+  ports() {
+    return [...this.handlers.keys()].sort((a, b) => a - b);
+  }
+}
+var LOOPBACK_HOSTS = new Set([
+  "localhost",
+  "127.0.0.1",
+  "0.0.0.0",
+  "::1",
+  "[::1]",
+  "[::ffff:127.0.0.1]"
+]);
+var RELAY_PROXY_PATH = "/__wc_relay_proxy";
+
+// src/command-resolver.ts
+var NOT_IMPLEMENTED = "ERR_WC_NOT_IMPLEMENTED";
+function cleanPath(p) {
+  const parts = [];
+  for (const part of p.replace(/\\+/g, "/").split("/")) {
+    if (!part || part === ".")
+      continue;
+    if (part === "..") {
+      parts.pop();
+      continue;
+    }
+    parts.push(part);
+  }
+  return `/${parts.join("/")}`;
+}
+function resolvePath(base, p) {
+  if (p.startsWith("/"))
+    return cleanPath(p);
+  return cleanPath(`${base}/${p}`);
+}
+var DEV_SCRIPT_HINTS = new Set(["dev", "start:dev", "serve"]);
+function isDevServerCommand(command, args) {
+  if (command === "vite" && args.length === 0)
+    return true;
+  if ((command === "npm" || command === "pnpm" || command === "yarn") && (args[0] === "dev" || args[0] === "run" && args[1] === "dev")) {
+    return true;
+  }
+  if (command === "pnpm" && args[0] === "dev")
+    return true;
+  return false;
+}
+function readScripts(fs, cwd) {
+  const pkgPath = `${cwd}/package.json`;
+  if (!fs.exists(pkgPath))
+    return {};
+  try {
+    const pkg = JSON.parse(fs.readFile(pkgPath));
+    return pkg.scripts ?? {};
+  } catch {
+    return {};
+  }
+}
+function tokenize(commandLine) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  let has = false;
+  for (let i = 0;i < commandLine.length; i += 1) {
+    const ch = commandLine[i];
+    if (quote) {
+      if (ch === quote)
+        quote = null;
+      else
+        current += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      has = true;
+      continue;
+    }
+    if (ch === " " || ch === "\t") {
+      if (has) {
+        tokens.push(current);
+        current = "";
+        has = false;
+      }
+      continue;
+    }
+    if ("|&;<>".includes(ch)) {
+      throw new Error(`${NOT_IMPLEMENTED}: the script command line ${JSON.stringify(commandLine)} uses a shell control operator (${ch}); ` + `the resolver runs a single command + args directly (no pipelines/redirections/chaining yet). ` + `Run it through spawn('jsh', ['-c', <line>]) — the real @wc/shell (just-bash) — for full shell semantics.`);
+    }
+    current += ch;
+    has = true;
+  }
+  if (has)
+    tokens.push(current);
+  return tokens;
+}
+function splitEnvPrefix(tokens) {
+  const env = {};
+  let i = 0;
+  for (;i < tokens.length; i += 1) {
+    const m = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/.exec(tokens[i]);
+    if (!m)
+      break;
+    env[m[1]] = m[2];
+  }
+  return { env, rest: tokens.slice(i) };
+}
+function resolveBin(fs, cwd, cmd) {
+  let dir = cleanPath(cwd);
+  for (;; ) {
+    const binLink = `${dir}/node_modules/.bin/${cmd}`;
+    if (fs.exists(binLink)) {
+      let target = binLink;
+      try {
+        if (fs.lstat(binLink).kind === "symlink") {
+          const link = fs.readlink(binLink);
+          target = resolvePath(`${dir}/node_modules/.bin`, link);
+        }
+      } catch {}
+      if (fs.exists(target) && fs.lstat(target).kind === "file")
+        return target;
+    }
+    const pkgJson = `${dir}/node_modules/${cmd}/package.json`;
+    if (fs.exists(pkgJson)) {
+      try {
+        const pkg = JSON.parse(fs.readFile(pkgJson));
+        let rel;
+        if (typeof pkg.bin === "string")
+          rel = pkg.bin;
+        else if (pkg.bin && typeof pkg.bin === "object")
+          rel = pkg.bin[cmd] ?? Object.values(pkg.bin)[0];
+        if (rel) {
+          const entry = resolvePath(`${dir}/node_modules/${cmd}`, rel);
+          if (fs.exists(entry))
+            return entry;
+        }
+      } catch {}
+    }
+    const parent = dir.split("/").slice(0, -1).join("/") || "/";
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return;
+}
+function resolveSpawn(fs, cwd, command, args) {
+  const base = cleanPath(cwd);
+  if (isDevServerCommand(command, args)) {
+    return { kind: "dev-server", label: `${command} ${args.join(" ")}`.trim() };
+  }
+  if (command === "jsh" || command === "bash" || command === "sh") {
+    if (args[0] === "-c" && typeof args[1] === "string") {
+      return { kind: "shell", commandLine: args[1], cwd: base, label: `${command} -c` };
+    }
+    if (args.length === 0) {
+      return { kind: "shell", cwd: base, label: command };
+    }
+    const scriptPath = resolvePath(base, args[0]);
+    if (fs.exists(scriptPath)) {
+      return { kind: "shell", commandLine: fs.readFile(scriptPath), cwd: base, label: `${command} ${args[0]}` };
+    }
+    return { kind: "shell", commandLine: [command, ...args].join(" "), cwd: base, label: `${command} ${args.join(" ")}` };
+  }
+  if (command === "node") {
+    const file = args[0];
+    if (!file) {
+      return {
+        kind: "unsupported",
+        message: `${NOT_IMPLEMENTED}: spawn('node') with no entry (a Node REPL) is not supported in the browser runtime. Pass a file: spawn('node', ['script.js']).`
+      };
+    }
+    const entry = resolvePath(base, file);
+    if (!fs.exists(entry)) {
+      return {
+        kind: "unsupported",
+        message: `ERR_WC_ENOENT: node entry ${JSON.stringify(file)} resolves to ${entry}, which does not exist in the mounted filesystem.`
+      };
+    }
+    return { kind: "node", entry, args: args.slice(1), cwd: base, label: `node ${file}` };
+  }
+  if (command === "npm" || command === "pnpm" || command === "yarn") {
+    const sub = args[0] ?? "";
+    if (sub === "install" || sub === "i" || sub === "ci" || sub === "add") {
+      return {
+        kind: "unsupported",
+        message: `${NOT_IMPLEMENTED}: spawn('${command}', ['${sub}', …]) is an honest stub. Dependencies are pre-vendored into the mounted closure (the host page mounts the package closure); a real in-browser installer is a separate workstream (@wc/package-manager / WS5). This never fabricates a fake install.`
+      };
+    }
+    let scriptName;
+    let scriptArgs = [];
+    if (sub === "run" || command !== "npm" && sub !== "test" && sub !== "start" && args.length > 0 && !sub.startsWith("-")) {
+      scriptName = sub === "run" ? args[1] : sub;
+      scriptArgs = sub === "run" ? args.slice(2) : args.slice(1);
+    } else if (sub === "test") {
+      scriptName = "test";
+      scriptArgs = args.slice(1);
+    } else if (sub === "start") {
+      scriptName = "start";
+      scriptArgs = args.slice(1);
+    }
+    if (!scriptName) {
+      return {
+        kind: "unsupported",
+        message: `${NOT_IMPLEMENTED}: spawn('${command}', ${JSON.stringify(args)}) is not supported. The resolver handles 'run <script>', 'test', 'start', and 'dev' (real dev server); 'install' is an honest stub.`
+      };
+    }
+    const scripts = readScripts(fs, base);
+    const scriptLine = scripts[scriptName];
+    if (scriptLine === undefined) {
+      return {
+        kind: "unsupported",
+        message: `ERR_WC_NO_SCRIPT: package.json at ${base}/package.json has no "${scriptName}" script. Mounted scripts: ${JSON.stringify(Object.keys(scripts))}.`
+      };
+    }
+    let tokens;
+    try {
+      tokens = tokenize(scriptLine);
+    } catch (err) {
+      return { kind: "unsupported", message: err instanceof Error ? err.message : String(err) };
+    }
+    const { rest } = splitEnvPrefix(tokens);
+    if (rest.length === 0) {
+      return { kind: "unsupported", message: `ERR_WC_EMPTY_SCRIPT: the "${scriptName}" script is empty.` };
+    }
+    const innerCmd = rest[0];
+    const innerArgs = [...rest.slice(1), ...scriptArgs];
+    if (isDevServerCommand(innerCmd, innerArgs) || DEV_SCRIPT_HINTS.has(scriptName) && innerCmd === "vite") {
+      return { kind: "dev-server", label: `${command} run ${scriptName} → ${scriptLine}` };
+    }
+    const inner = resolveSpawn(fs, base, innerCmd, innerArgs);
+    if (inner.kind === "node")
+      return { ...inner, label: `${command} run ${scriptName} → ${inner.label}` };
+    if (inner.kind === "dev-server")
+      return { ...inner, label: `${command} run ${scriptName} → ${inner.label}` };
+    if (inner.kind === "shell")
+      return inner;
+    return inner;
+  }
+  if (command === "npx") {
+    const bin = args[0];
+    if (!bin) {
+      return { kind: "unsupported", message: `${NOT_IMPLEMENTED}: spawn('npx') with no command. Pass a bin: spawn('npx', ['vite']).` };
+    }
+    if (bin === "node") {
+      return resolveSpawn(fs, base, "node", args.slice(1));
+    }
+    const entry = resolveBin(fs, base, bin);
+    if (!entry) {
+      return {
+        kind: "unsupported",
+        message: `ERR_WC_BIN_NOT_FOUND: npx could not resolve "${bin}" to node_modules/.bin/${bin} or a package bin field under ${base}. ` + `Dependencies are pre-vendored; remote-fetch of an uninstalled bin (npx's download path) is not supported in the browser runtime.`
+      };
+    }
+    return { kind: "node", entry, args: args.slice(1), cwd: base, label: `npx ${bin}` };
+  }
+  const direct = resolveBin(fs, base, command);
+  if (direct) {
+    return { kind: "node", entry: direct, args, cwd: base, label: `${command} ${args.join(" ")}`.trim() };
+  }
+  return {
+    kind: "unsupported",
+    message: `${NOT_IMPLEMENTED}: spawn(${JSON.stringify(command)}, ${JSON.stringify(args)}) could not be resolved. ` + `Supported: node <file>, npm/pnpm/yarn run|test|start (real scripts), npm run dev / vite (real dev server), npx <bin> and direct local bins (node_modules/.bin resolution), jsh/bash/sh (real @wc/shell). ` + `npm install is an honest stub. No output is ever faked.`
+  };
+}
+// src/index.ts
+function createSameOriginRelayTransport(fetchImpl = globalThis.fetch.bind(globalThis), proxyPath = RELAY_PROXY_PATH) {
+  return {
+    async send(request) {
+      const res = await fetchImpl(proxyPath, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(request)
+      });
+      return await res.json();
+    }
+  };
+}
+var MAX_FILE_BYTES = 1024 * 1024;
+var NOT_IMPLEMENTED2 = "ERR_WC_NOT_IMPLEMENTED";
+var PreviewMessageType;
+((PreviewMessageType2) => {
+  PreviewMessageType2["UncaughtException"] = "PREVIEW_UNCAUGHT_EXCEPTION";
+  PreviewMessageType2["UnhandledRejection"] = "PREVIEW_UNHANDLED_REJECTION";
+  PreviewMessageType2["ConsoleError"] = "PREVIEW_CONSOLE_ERROR";
+})(PreviewMessageType ||= {});
+var PREVIEW_MESSAGE_TYPES = new Set(Object.values(PreviewMessageType));
+function isPreviewMessage(data) {
+  return typeof data === "object" && data !== null && "type" in data && typeof data.type === "string" && PREVIEW_MESSAGE_TYPES.has(data.type);
+}
+async function reloadPreview(preview, hardnessMs = 200) {
+  if (!preview || typeof preview !== "object" || !("src" in preview)) {
+    throw new TypeError("reloadPreview(preview): preview must be an HTMLIFrameElement");
+  }
+  const src = preview.src;
+  preview.src = src;
+  if (hardnessMs > 0) {
+    await new Promise((resolve) => setTimeout(resolve, hardnessMs));
+  }
+}
+var AUTH_UNSUPPORTED = "ERR_WC_AUTH_UNSUPPORTED: @start.dev/container is an unhosted, pure-browser runtime; it has no StackBlitz " + "account/editor-origin auth model. The `auth` namespace exists for drop-in import compatibility but " + "does not implement a real session — this is an honest stub, not a fake login.";
+var auth = {
+  init() {
+    throw new Error(AUTH_UNSUPPORTED);
+  },
+  startAuthFlow() {
+    throw new Error(AUTH_UNSUPPORTED);
+  },
+  logout() {
+    throw new Error(AUTH_UNSUPPORTED);
+  },
+  loggedIn() {
+    return Promise.reject(new Error(AUTH_UNSUPPORTED));
+  },
+  on() {
+    return () => {};
+  }
+};
+function configureAPIKey(_apiKey) {}
+var textEncoder = new TextEncoder;
+var textDecoder = new TextDecoder;
+function cleanPath2(p) {
+  const parts = [];
+  for (const part of p.replace(/\\+/g, "/").split("/")) {
+    if (!part || part === ".")
+      continue;
+    if (part === "..") {
+      parts.pop();
+      continue;
+    }
+    parts.push(part);
+  }
+  return `/${parts.join("/")}`;
+}
+function resolvePath2(base, p) {
+  if (p.startsWith("/"))
+    return cleanPath2(p);
+  return cleanPath2(`${base}/${p}`);
+}
+
+class FileSystemFacade {
+  fs;
+  workdir;
+  onMutate;
+  trackWatcher;
+  constructor(fs, workdir, onMutate, trackWatcher) {
+    this.fs = fs;
+    this.workdir = workdir;
+    this.onMutate = onMutate;
+    this.trackWatcher = trackWatcher;
+  }
+  resolve(p) {
+    return resolvePath2(this.workdir(), p);
+  }
+  async readFile(path, encoding) {
+    const abs = this.resolve(path);
+    if (encoding === "utf8" || encoding === "utf-8")
+      return this.fs.readFile(abs);
+    return this.fs.readFileBuffer(abs);
+  }
+  async writeFile(path, data, options) {
+    const abs = this.resolve(path);
+    const byteLength = typeof data === "string" ? textEncoder.encode(data).byteLength : data.byteLength;
+    if (byteLength > MAX_FILE_BYTES) {
+      throw new Error(`ERR_WC_FS_FILE_TOO_LARGE: ${abs} is ${byteLength} bytes, exceeding the runtime's ${MAX_FILE_BYTES}-byte (1 MiB) per-file limit. ` + `The write is rejected rather than silently truncated; split the file or raise the limit when large-file persistence is proven.`);
+    }
+    this.fs.writeFile(abs, data);
+    this.onMutate(abs, typeof data === "string" ? data : textDecoder.decode(data));
+  }
+  async readdir(path, options) {
+    const abs = this.resolve(path);
+    const entries = this.fs.list(abs);
+    if (options?.withFileTypes) {
+      return entries.map((e) => ({
+        name: e.name,
+        isFile: () => e.kind === "file",
+        isDirectory: () => e.kind === "dir"
+      }));
+    }
+    return entries.map((e) => e.name);
+  }
+  async mkdir(path, options) {
+    const abs = this.resolve(path);
+    if (options?.recursive) {
+      this.fs.mkdirp(abs);
+      return;
+    }
+    const parent = abs.split("/").slice(0, -1).join("/") || "/";
+    if (!this.fs.exists(parent))
+      throw new Error(`ENOENT: ${abs}`);
+    if (this.fs.exists(abs))
+      throw new Error(`EEXIST: ${abs}`);
+    this.fs.mkdirp(abs);
+  }
+  async rm(path, options) {
+    const abs = this.resolve(path);
+    if (!this.fs.exists(abs)) {
+      if (options?.force)
+        return;
+      throw new Error(`ENOENT: ${abs}`);
+    }
+    const stat = this.fs.lstat(abs);
+    if (stat.kind === "dir") {
+      if (!options?.recursive)
+        throw new Error(`EISDIR: ${abs} (use { recursive: true } to remove a directory)`);
+      this.fs.rmdir(abs);
+      return;
+    }
+    this.fs.unlink(abs);
+  }
+  async rename(oldPath, newPath) {
+    const to = this.resolve(newPath);
+    this.fs.rename(this.resolve(oldPath), to);
+    if (this.fs.exists(to) && this.fs.lstat(to).kind === "file") {
+      this.onMutate(to, this.fs.readFile(to));
+    }
+  }
+  watch(path, optionsOrListener, maybeListener) {
+    const abs = this.resolve(path);
+    if (typeof optionsOrListener === "function") {
+      const watcher2 = this.fs.watch(abs, optionsOrListener);
+      this.trackWatcher(watcher2);
+      return watcher2;
+    }
+    const options = optionsOrListener ?? {};
+    if (maybeListener) {
+      const watcher2 = this.fs.watch(abs, options, maybeListener);
+      this.trackWatcher(watcher2);
+      return watcher2;
+    }
+    const watcher = this.fs.watch(abs, options, () => {});
+    this.trackWatcher(watcher);
+    return watcher;
+  }
+}
+
+class Emitter {
+  listeners = new Map;
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = new Set;
+      this.listeners.set(event, set);
+    }
+    set.add(listener);
+    return () => set.delete(listener);
+  }
+  emit(event, ...args) {
+    const set = this.listeners.get(event);
+    if (!set)
+      return;
+    for (const listener of Array.from(set)) {
+      try {
+        listener(...args);
+      } catch (err) {
+        if (typeof console !== "undefined")
+          console.error("[wc:container] listener threw:", err);
+      }
+    }
+  }
+  clear() {
+    this.listeners.clear();
+  }
+}
+var DEV_SERVER_PORT = 5173;
+function makeWorker(url) {
+  const Ctor = globalThis.Worker;
+  if (typeof Ctor !== "function") {
+    throw new Error(`${NOT_IMPLEMENTED2}: @start.dev/container requires a browser Worker. No global Worker constructor is available in this context.`);
+  }
+  return new Ctor(url, { type: "module" });
+}
+
+class DevServerProcess {
+  output;
+  input;
+  exit;
+  #worker;
+  #outputController;
+  #resolveExit;
+  #killed = false;
+  constructor(worker) {
+    this.#worker = worker;
+    this.output = new ReadableStream({
+      start: (controller) => {
+        this.#outputController = controller;
+      }
+    });
+    this.input = new WritableStream({
+      write: (chunk) => {
+        try {
+          this.#worker.postMessage({ type: "stdin", data: chunk });
+        } catch {}
+      }
+    });
+    this.exit = new Promise((resolve) => {
+      this.#resolveExit = resolve;
+    });
+  }
+  pushOutput(line) {
+    try {
+      this.#outputController.enqueue(line);
+    } catch {}
+  }
+  resize() {}
+  kill() {
+    if (this.#killed)
+      return;
+    this.#killed = true;
+    try {
+      this.#worker.terminate();
+    } catch {}
+    try {
+      this.#outputController.close();
+    } catch {}
+    this.#resolveExit(0);
+  }
+}
+
+class StreamingWebContainerProcess {
+  output;
+  input;
+  exit;
+  #outputController;
+  #handle;
+  #closed = false;
+  constructor() {
+    this.output = new ReadableStream({
+      start: (controller) => {
+        this.#outputController = controller;
+      }
+    });
+    this.input = new WritableStream({
+      write: (chunk) => {
+        this.#handle?.writeStdin(chunk);
+      }
+    });
+    this.exit = new Promise((resolve) => {
+      this.#resolveExit = resolve;
+    });
+  }
+  #resolveExit;
+  push(chunk) {
+    if (this.#closed)
+      return;
+    try {
+      this.#outputController.enqueue(chunk);
+    } catch {}
+  }
+  attach(handle) {
+    this.#handle = handle;
+    handle.exit.then((code) => {
+      this.#close();
+      this.#resolveExit(code);
+    });
+  }
+  #close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    try {
+      this.#outputController.close();
+    } catch {}
+  }
+  resize() {}
+  kill() {
+    this.#handle?.kill();
+    this.#close();
+  }
+}
+var liveContainer;
+
+class WebContainer {
+  workdir;
+  fs;
+  routes = {};
+  #memfs;
+  #runtime;
+  #emitter = new Emitter;
+  #devServer;
+  #worker;
+  #serviceWorkerRegistration;
+  #pageMessageHandler;
+  #pendingHttp = new Map;
+  #httpSeq = 0;
+  #torn = false;
+  #fsWatchers = new Set;
+  constructor(workdir, memfs, runtime) {
+    this.workdir = workdir;
+    this.#memfs = memfs;
+    this.#runtime = runtime;
+    this.fs = new FileSystemFacade(memfs, () => this.workdir, (abs, contents) => this.#forwardFsMutation(abs, contents), (watcher) => this.#fsWatchers.add(watcher));
+  }
+  #forwardFsMutation(absPath, contents) {
+    if (!this.#worker || this.#torn || contents === undefined)
+      return;
+    this.#worker.postMessage({ type: "hmr-edit", path: absPath, contents });
+  }
+  static async boot(options = {}) {
+    if (liveContainer) {
+      throw new Error("ERR_WC_ALREADY_BOOTED: a WebContainer is already running in this page. " + "@start.dev/container is a singleton (like @webcontainer/api): call teardown() on the live " + "instance before booting another.");
+    }
+    if (typeof crossOriginIsolated !== "undefined" && crossOriginIsolated === false) {
+      throw new Error("ERR_WC_NOT_CROSS_ORIGIN_ISOLATED: WebContainer.boot() requires crossOriginIsolated === true " + "(serve the host page with COOP: same-origin + COEP: credentialless|require-corp). " + "SharedArrayBuffer + Atomics.wait — which the kernel needs — are unavailable otherwise.");
+    }
+    const runtime = options.runtime;
+    if (!runtime) {
+      throw new Error("ERR_WC_MISSING_RUNTIME_WIRING: WebContainer.boot({ runtime }) requires the browser-runtime wiring " + "(viteWorkerUrl, serviceWorkerUrl, previewBase, the WASM URLs/sources, and the dependencyClosure). " + "The host page builds these (mountPackageClosure is a Node-side op) and serves them; the facade stays browser-pure.");
+    }
+    const workdirName = options.workdirName ?? "proj";
+    const workdir = cleanPath2(`/${workdirName}`);
+    const memfs = new MemoryFS;
+    memfs.mkdirp(workdir);
+    const container = new WebContainer(workdir, memfs, runtime);
+    liveContainer = container;
+    try {
+      await container.#registerServiceWorker();
+    } catch (err) {
+      liveContainer = undefined;
+      throw err;
+    }
+    return container;
+  }
+  async mount(tree, options = {}) {
+    this.#assertLive();
+    const root = options.mountPoint ? cleanPath2(options.mountPoint) : this.workdir;
+    this.#memfs.mkdirp(root);
+    this.#writeTree(tree, root);
+  }
+  #writeTree(tree, dir) {
+    for (const [name, node] of Object.entries(tree)) {
+      const childPath = `${dir}/${name}`;
+      if ("directory" in node) {
+        this.#memfs.mkdirp(childPath);
+        this.#writeTree(node.directory, childPath);
+      } else if ("file" in node) {
+        if ("symlink" in node.file) {
+          throw new Error(`${NOT_IMPLEMENTED2}: symlink nodes in a FileSystemTree are not yet materialized by @start.dev/container ` + `(at ${childPath} -> ${node.file.symlink}). The current mount path writes regular files + directories only; ` + `symlink mount is a documented seam, not faked.`);
+        }
+        const contents = node.file.contents;
+        const byteLength = typeof contents === "string" ? textEncoder.encode(contents).byteLength : contents.byteLength;
+        if (byteLength > MAX_FILE_BYTES) {
+          throw new Error(`ERR_WC_FS_FILE_TOO_LARGE: mounted file ${childPath} is ${byteLength} bytes, exceeding the ${MAX_FILE_BYTES}-byte (1 MiB) limit. ` + `The mount is rejected rather than silently truncated.`);
+        }
+        this.#memfs.writeFile(childPath, contents);
+      } else {
+        throw new Error(`EINVAL: FileSystemTree node at ${childPath} is neither a file nor a directory node.`);
+      }
+    }
+  }
+  async spawn(command, args = [], options = {}) {
+    this.#assertLive();
+    const cwd = options.cwd ? cleanPath2(resolvePath2(this.workdir, options.cwd)) : this.workdir;
+    const plan = resolveSpawn(this.#memfs, cwd, command, args);
+    if (plan.kind === "unsupported") {
+      throw new Error(plan.message);
+    }
+    if (plan.kind === "dev-server") {
+      if (this.#devServer) {
+        throw new Error("ERR_WC_DEV_SERVER_ALREADY_RUNNING: a dev server is already running in this WebContainer. " + "Multiple concurrent dev servers are not yet supported; kill the existing one first.");
+      }
+      return this.#startDevServer(options);
+    }
+    if (plan.kind === "node") {
+      return this.#startNodeProcess(plan, options);
+    }
+    return this.#startShellProcess(plan, options);
+  }
+  on(event, listener) {
+    return this.#emitter.on(event, listener);
+  }
+  teardown() {
+    if (this.#torn)
+      return;
+    this.#torn = true;
+    if (this.#devServer) {
+      try {
+        this.#devServer.kill();
+      } catch {}
+      this.#devServer = undefined;
+    }
+    if (this.#worker) {
+      try {
+        this.#worker.terminate();
+      } catch {}
+      this.#worker = undefined;
+    }
+    if (this.#pageMessageHandler && typeof removeEventListener === "function") {
+      removeEventListener("message", this.#pageMessageHandler);
+      this.#pageMessageHandler = undefined;
+    }
+    if (this.#serviceWorkerRegistration) {
+      this.#serviceWorkerRegistration.unregister().catch(() => {});
+      this.#serviceWorkerRegistration = undefined;
+    }
+    for (const key of Object.keys(this.routes))
+      delete this.routes[Number(key)];
+    for (const watcher of this.#fsWatchers) {
+      try {
+        watcher.close();
+      } catch {}
+    }
+    this.#fsWatchers.clear();
+    this.#emitter.clear();
+    if (liveContainer === this)
+      liveContainer = undefined;
+  }
+  export() {
+    throw new Error(`${NOT_IMPLEMENTED2}: WebContainer.export() is not yet implemented by @start.dev/container. ` + `MemoryFS.snapshot() exists but the @webcontainer/api export format/options are not yet mapped (WS-future).`);
+  }
+  #assertLive() {
+    if (this.#torn)
+      throw new Error("ERR_WC_TORN_DOWN: this WebContainer has been torn down.");
+  }
+  get #previewUrl() {
+    const base = this.#runtime.previewBase;
+    const origin = typeof location !== "undefined" ? location.origin : "";
+    return `${origin}${base}`;
+  }
+  async#registerServiceWorker() {
+    const sw = navigator?.serviceWorker;
+    if (!sw) {
+      throw new Error("ERR_WC_NO_SERVICE_WORKER: navigator.serviceWorker is unavailable; the preview pipeline requires a Service Worker.");
+    }
+    const base = this.#runtime.previewBase;
+    const reg = await sw.register(this.#runtime.serviceWorkerUrl, {
+      type: "module",
+      scope: base,
+      updateViaCache: "none"
+    });
+    this.#serviceWorkerRegistration = reg;
+    await new Promise((resolve) => {
+      const poll = setInterval(() => {
+        if (reg.active && reg.active.state === "activated") {
+          clearInterval(poll);
+          resolve();
+        }
+      }, 50);
+    });
+  }
+  async#startDevServer(options) {
+    const runtime = this.#runtime;
+    const worker = makeWorker(runtime.viteWorkerUrl);
+    this.#worker = worker;
+    const proc = new DevServerProcess(worker);
+    this.#devServer = proc;
+    const depFiles = { ...this.#runtime.dependencyClosure };
+    const appFiles = this.#collectProjectFiles(this.workdir);
+    worker.addEventListener("message", (event) => {
+      const msg = event.data;
+      if (!msg || typeof msg !== "object")
+        return;
+      if (msg.type === "httpResponse") {
+        const resolve = this.#pendingHttp.get(msg.id);
+        if (resolve) {
+          this.#pendingHttp.delete(msg.id);
+          resolve(msg);
+        }
+        return;
+      }
+      if (msg.type === "hmr-server-message") {
+        const data = typeof msg.payload === "string" ? msg.payload : JSON.stringify(msg.payload);
+        this.#broadcastToPreviewFrames({ type: "hmr-to-iframe", data });
+        if (typeof postMessage === "function") {
+          try {
+            postMessage({ type: "hmr-to-iframe", data }, "*");
+          } catch {}
+        }
+        return;
+      }
+      if (msg.type === "progress") {
+        proc.pushOutput(`[vite] ${msg.stage}${msg.error ? `: ${msg.error}` : ""}`);
+        return;
+      }
+    });
+    worker.onerror = (event) => {
+      const message = event.message ?? "vite worker error";
+      this.#emitter.emit("error", { message });
+      proc.pushOutput(`[vite:error] ${message}`);
+    };
+    this.#installPageMessageHandler(worker, proc);
+    const ready = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error("vite preview boot timed out (180s)")), 180000);
+      const onReady = (event) => {
+        const m = event.data;
+        if (m && m.type === "ready") {
+          clearTimeout(timer);
+          resolve(m);
+        }
+      };
+      worker.addEventListener("message", onReady);
+      worker.addEventListener("error", (e) => {
+        clearTimeout(timer);
+        reject(new Error("vite worker error: " + (e.message ?? "unknown")));
+      });
+      worker.postMessage({
+        type: "init",
+        mode: "preview",
+        base: runtime.previewBase,
+        files: depFiles,
+        appFiles,
+        pluginReact: true,
+        esbuildWasmUrl: runtime.esbuildWasmUrl,
+        rollupWasmUrl: runtime.rollupWasmUrl,
+        rollupBindingsSource: runtime.rollupBindingsSource,
+        rollupParseAstSharedSource: runtime.rollupParseAstSharedSource
+      });
+    });
+    if (!ready.ok) {
+      throw new Error("vite preview boot failed: " + (ready.error ?? "unknown"));
+    }
+    proc.pushOutput(`[vite] dev server ready (esbuild ${ready.esbuildVersion ?? "?"})`);
+    const port = DEV_SERVER_PORT;
+    const url = this.#previewUrl;
+    this.routes[port] = url;
+    this.#emitter.emit("port", port, "open", url);
+    this.#emitter.emit("server-ready", port, url);
+    return proc;
+  }
+  async#startNodeProcess(plan, options) {
+    const workerUrl = this.#runtime.processWorkerUrl;
+    if (!workerUrl) {
+      throw new Error(`${NOT_IMPLEMENTED2}: spawn resolved "${plan.label}" to a real Node process, but BootOptions.runtime.processWorkerUrl ` + `was not provided. The host page must serve the bundled streaming-process-host worker and pass its URL so the ` + `facade can run real node/npx/bin commands. (The dev-server path uses viteWorkerUrl and is unaffected.)`);
+    }
+    const env = this.#mergeEnv(options.env);
+    const proc = new StreamingWebContainerProcess;
+    const handle = spawnStreamingNodeProcess(this.#memfs, {
+      workerUrl,
+      projectRoot: this.workdir,
+      entry: plan.entry,
+      argv: plan.args,
+      env,
+      onStdout: (chunk) => proc.push(chunk),
+      onStderr: (chunk) => proc.push(chunk)
+    });
+    proc.attach(handle);
+    return proc;
+  }
+  async#startShellProcess(plan, options) {
+    const workerUrl = this.#runtime.shellWorkerUrl;
+    if (!workerUrl) {
+      throw new Error(`${NOT_IMPLEMENTED2}: spawn resolved "${plan.label}" to the real shell, but BootOptions.runtime.shellWorkerUrl ` + `was not provided. The host page must serve the bundled shell-host worker (real @wc/shell / just-bash) and pass its URL.`);
+    }
+    const env = this.#mergeEnv(options.env);
+    const proc = new StreamingWebContainerProcess;
+    const handle = spawnShellProcess(this.#memfs, {
+      workerUrl,
+      commandLine: plan.commandLine,
+      cwd: plan.cwd,
+      env,
+      onStdout: (chunk) => proc.push(chunk),
+      onStderr: (chunk) => proc.push(chunk)
+    });
+    proc.attach(handle);
+    return proc;
+  }
+  #mergeEnv(env) {
+    const out = {};
+    if (env) {
+      for (const [k, v] of Object.entries(env))
+        out[k] = String(v);
+    }
+    return out;
+  }
+  #collectProjectFiles(dir) {
+    const out = {};
+    const walk = (d) => {
+      for (const entry of this.#memfs.list(d)) {
+        const p = `${d}/${entry.name}`;
+        if (entry.kind === "dir")
+          walk(p);
+        else if (entry.kind === "file")
+          out[p] = this.#memfs.readFile(p);
+      }
+    };
+    if (this.#memfs.exists(dir))
+      walk(dir);
+    return out;
+  }
+  #viteDispatch(req) {
+    return new Promise((resolve) => {
+      const id = "h" + ++this.#httpSeq;
+      this.#pendingHttp.set(id, resolve);
+      this.#worker.postMessage({ type: "httpRequest", id, method: req.method, url: req.url, headers: req.headers });
+    });
+  }
+  #broadcastToPreviewFrames(message) {
+    if (typeof document === "undefined")
+      return;
+    const frames = document.querySelectorAll("iframe");
+    const base = this.#runtime.previewBase;
+    frames.forEach((frame) => {
+      const el = frame;
+      if (el.src && (el.src.endsWith(base) || el.src.includes(`${base}index.html`))) {
+        el.contentWindow?.postMessage(message, "*");
+      }
+    });
+  }
+  #frameForSource(source) {
+    if (!source || typeof document === "undefined")
+      return;
+    const frames = document.querySelectorAll("iframe");
+    for (const frame of Array.from(frames)) {
+      const el = frame;
+      if (el.contentWindow === source)
+        return el;
+    }
+    return;
+  }
+  #installPageMessageHandler(worker, proc) {
+    const base = this.#runtime.previewBase;
+    const handler = (event) => {
+      const msg = event.data;
+      if (!msg || typeof msg !== "object")
+        return;
+      const frame = this.#frameForSource(event.source);
+      if (msg.type === "preview-dispatch") {
+        this.#respondToFrame(frame, msg);
+        return;
+      }
+      if (msg.type === "hmr-from-iframe") {
+        worker.postMessage({ type: "hmr-client-message", data: msg.data });
+        return;
+      }
+      if (msg.type === "hmr-iframe-open") {
+        worker.postMessage({ type: "hmr-client-open" });
+        return;
+      }
+    };
+    this.#pageMessageHandler = handler;
+    if (typeof addEventListener === "function")
+      addEventListener("message", handler);
+  }
+  async#respondToFrame(frame, msg) {
+    let path = msg.url;
+    try {
+      const u = new URL(msg.url);
+      path = u.pathname + u.search;
+    } catch {}
+    const headers = Object.assign({}, msg.headers, { host: `localhost:${DEV_SERVER_PORT}` });
+    const res = await this.#viteDispatch({ method: msg.method, url: path, headers });
+    const outHeaders = [];
+    const incoming = res.headers ?? {};
+    for (const k of Object.keys(incoming)) {
+      const lk = k.toLowerCase();
+      if (lk === "set-cookie" || lk === "cross-origin-resource-policy")
+        continue;
+      outHeaders.push([k, String(incoming[k])]);
+    }
+    outHeaders.push(["cross-origin-resource-policy", "same-origin"]);
+    const body = res.body instanceof ArrayBuffer ? res.body : null;
+    frame?.contentWindow?.postMessage({ type: "preview-response", rid: msg.rid, status: res.status, statusText: res.statusText, headers: outHeaders, body }, "*", body ? [body] : []);
+  }
+}
+export {
+  reloadPreview,
+  isPreviewMessage,
+  createSameOriginRelayTransport,
+  configureAPIKey,
+  auth,
+  WebContainer,
+  RELAY_PROXY_PATH,
+  PreviewMessageType,
+  MAX_FILE_BYTES
+};