fullstacked 1.0.0-alpha.1748 → 1.0.0-alpha.1753

package/index.js

@@ -159,8 +159,8 @@ async function BridgeNodeInit() {
       async Async(payload) {
         const dataView = new DataView(payload);
         const id = dataView.getUint8(1);
-        return new Promise((resolve2) => {
-          asyncResponsePromises3.set(id, resolve2);
+        return new Promise((resolve3) => {
+          asyncResponsePromises3.set(id, resolve3);
           globalThis.postMessage(payload);
         });
       }
@@ -182,6 +182,12 @@ async function BridgeNodeInit() {
     ws.onopen = res;
   });
   await webSocketForCallback;
+  globalThis.fullstacked.open = function(ctx2) {
+    return globalThis.fullstacked.fetch("/open", {
+      method: "POST",
+      body: new Uint8Array([ctx2])
+    });
+  };
   globalThis.fullstacked.exit = function() {
     ws.close();
     if (window.opener || window.history && window.history.length === 1) {
@@ -250,6 +256,7 @@ async function BridgeAppleInit() {
     };
   } else {
     globalThis.fullstacked.exit = () => globalThis.webkit.messageHandlers.exit.postMessage("");
+    globalThis.fullstacked.open = (ctx2) => globalThis.webkit.messageHandlers.open.postMessage(ctx2);
     if (globalThis.webkit.messageHandlers.clipboard) {
       const td2 = new TextDecoder();
       globalThis.fullstacked.clipboard.respondPaste = (id, responseBase64) => {
@@ -259,8 +266,8 @@ async function BridgeAppleInit() {
       };
       globalThis.fullstacked.clipboard.paste = () => {
         const id = Math.floor(Math.random() * 1e6);
-        return new Promise((resolve2) => {
-          clipboardResponsePromises.set(id, resolve2);
+        return new Promise((resolve3) => {
+          clipboardResponsePromises.set(id, resolve3);
           globalThis.webkit.messageHandlers.clipboard.postMessage(
             id.toString()
           );
@@ -276,15 +283,15 @@ async function BridgeAppleInit() {
     if (globalThis.webkit.messageHandlers.resize) {
       const resizeResponsePromises = [];
       globalThis.fullstacked.window.respondGetSize = function(response) {
-        const resolve2 = resizeResponsePromises.shift();
-        resolve2?.(response);
+        const resolve3 = resizeResponsePromises.shift();
+        resolve3?.(response);
       };
       globalThis.fullstacked.window.resize = function(size) {
         globalThis.webkit.messageHandlers.resize.postMessage(size);
       };
       globalThis.fullstacked.window.getSize = function() {
-        return new Promise((resolve2) => {
-          resizeResponsePromises.push(resolve2);
+        return new Promise((resolve3) => {
+          resizeResponsePromises.push(resolve3);
           globalThis.webkit.messageHandlers.resize.postMessage("get");
         });
       };
@@ -295,8 +302,8 @@ async function BridgeAppleInit() {
     async Async(payload) {
       const dataView = new DataView(payload);
       const id = dataView.getUint8(1);
-      return new Promise((resolve2) => {
-        asyncResponsePromises.set(id, resolve2);
+      return new Promise((resolve3) => {
+        asyncResponsePromises.set(id, resolve3);
         if (isWorker) {
           globalThis.postMessage(payload, {
             targetOrigin: "bridge"
@@ -362,6 +369,7 @@ async function BridgeWindowsInit() {
     };
   } else {
     globalThis.fullstacked.exit = () => globalThis.fullstacked.fetch("/exit");
+    globalThis.fullstacked.open = (ctx2) => globalThis.fullstacked.fetch(`/open?ctx=${ctx2}`);
     globalThis.fullstacked.window.getSize = () => globalThis.fullstacked.fetch("/resize").then((r) => r.text());
     globalThis.fullstacked.window.resize = function(size) {
       globalThis.fullstacked.fetch(`/resize?size=${size}`);
@@ -372,8 +380,8 @@ async function BridgeWindowsInit() {
     async Async(payload) {
       const dataView = new DataView(payload);
       const id = dataView.getUint8(1);
-      return new Promise((resolve2) => {
-        asyncResponsePromises2.set(id, resolve2);
+      return new Promise((resolve3) => {
+        asyncResponsePromises2.set(id, resolve3);
         if (isWorker) {
           globalThis.postMessage(payload, {
             targetOrigin: "bridge"
@@ -449,7 +457,7 @@ var init_platform = __esm({
     } else {
       globalThis.global = globalThis;
       platformBridge = {
-        ready: new Promise(async (resolve2, reject) => {
+        ready: new Promise(async (resolve3, reject) => {
           if (isWorker) {
             await new Promise((workerReady) => {
               self.onmessage = () => workerReady();
@@ -479,7 +487,7 @@ var init_platform = __esm({
               platformBridge.bridge = await BridgeWindowsInit();
               break;
           }
-          resolve2();
+          resolve3();
         })
       };
     }
@@ -495,6 +503,7 @@ var Path = 4;
 var Os = 5;
 var Fetch = 8;
 var Bundle = 9;
+var Packages = 12;
 var Plugin = 14;
 var CoreResponseError = 0;
 var CoreResponseData = 1;
@@ -927,8 +936,8 @@ function createDuplex(id) {
     return duplex.opening;
   };
   const read = () => {
-    return new Promise((resolve2, reject) => {
-      duplex.asyncRead.promise = { resolve: resolve2, reject };
+    return new Promise((resolve3, reject) => {
+      duplex.asyncRead.promise = { resolve: resolve3, reject };
     });
   };
   const next = async () => {
@@ -1029,10 +1038,10 @@ function createDuplex(id) {
     if (duplex.done) {
       return res;
     }
-    await new Promise((resolve2) => {
+    await new Promise((resolve3) => {
       const onClose = () => {
         duplex.listeners.close.delete(onClose);
-        resolve2();
+        resolve3();
       };
       duplex.listeners.close.add(onClose);
     });
@@ -1137,7 +1146,7 @@ async function fetchCore(request, init2) {
     signal.addEventListener("abort", onAbort, { once: true });
   }
   try {
-    responseHead = await new Promise(async (resolve2, reject) => {
+    responseHead = await new Promise(async (resolve3, reject) => {
       rejectHead = reject;
       responseHeadEE = (await globalThis.fullstacked.bridge({
         mod: Fetch,
@@ -1145,7 +1154,7 @@ async function fetchCore(request, init2) {
         data: [requestHead, new Uint8Array(requestBody)]
       })).eventEmitter();
       responseHeadEE.on("response", (responseHead2) => {
-        resolve2(responseHead2);
+        resolve3(responseHead2);
       });
       responseHeadEE.on("error", (error) => {
         reject(error);
@@ -1287,8 +1296,8 @@ var Exit = 5;
 // ../../core/internal/bundle/lib/process/index.ts
 init_isWorker();
 
-// ../../core/internal/bundle/lib/process/version.json with { type: 'json' }
-var version_default = { major: "1", minor: "0", patch: "0-alpha", branch: "v1", build: "1748", hash: "7c960ea337e7106b199163dff256a67ddd78f29d" };
+// ../../core/internal/bundle/lib/process/version.json
+var version_default = { major: "1", minor: "0", patch: "0-alpha", branch: "v1", build: "1753", hash: "8e2b475d51b7c4ecbbd84a6a76174572246a7169" };
 
 // ../../core/internal/bundle/lib/timers/index.ts
 var setTimeout2 = globalThis.setTimeout.bind(globalThis);
@@ -1634,8 +1643,8 @@ var constants = {
     return sep;
   }
 };
-function isAbsolute(path6) {
-  return path6.startsWith("/") || path6.startsWith("\\") || /^[a-zA-Z]:[/\\]/.test(path6);
+function isAbsolute(path3) {
+  return path3.startsWith("/") || path3.startsWith("\\") || /^[a-zA-Z]:[/\\]/.test(path3);
 }
 function resolve(...paths) {
   if (paths[0].startsWith("build:")) {
@@ -1662,34 +1671,34 @@ function join(...paths) {
     true
   );
 }
-function normalize(path6) {
+function normalize(path3) {
   return globalThis.fullstacked.bridge(
     {
       mod: Path,
       fn: Normalize,
-      data: [path6]
+      data: [path3]
     },
     true
   );
 }
-function parse(path6) {
+function parse(path3) {
   return globalThis.fullstacked.bridge(
     {
       mod: Path,
       fn: Parse,
-      data: [path6]
+      data: [path3]
     },
     true
   );
 }
-function extname(path6) {
-  return parse(path6).ext;
+function extname(path3) {
+  return parse(path3).ext;
 }
-function dirname(path6) {
-  return parse(path6).dir;
+function dirname(path3) {
+  return parse(path3).dir;
 }
-function basename(path6, suffix) {
-  const base = parse(path6).base;
+function basename(path3, suffix) {
+  const base = parse(path3).base;
   if (suffix && base.endsWith(suffix)) {
     return base.slice(0, 0 - suffix.length);
   }
@@ -1723,8 +1732,8 @@ var path_default = mod;
 
 // ../../core/internal/bundle/lib/fs/common.ts
 init_base64();
-function formatPathLike(path6) {
-  const pathStr = path6 instanceof URL ? path6.pathname : path6.toString();
+function formatPathLike(path3) {
+  const pathStr = path3 instanceof URL ? path3.pathname : path3.toString();
   return pathStr;
 }
 function decodeStringData(data, options) {
@@ -1776,16 +1785,16 @@ function convertGoFileInfo(baseDir, items, withFileTypes) {
 }
 
 // ../../core/internal/bundle/lib/fs/promises.ts
-async function readFile(path6, options) {
+async function readFile(path3, options) {
   const data = await globalThis.fullstacked.bridge({
     mod: Fs,
     fn: ReadFile,
-    data: [formatPathLike(path6)]
+    data: [formatPathLike(path3)]
   });
   return decodeStringData(data, options);
 }
-async function readdir(path6, options) {
-  const baseDir = formatPathLike(path6);
+async function readdir(path3, options) {
+  const baseDir = formatPathLike(path3);
   const items = await globalThis.fullstacked.bridge({
     mod: Fs,
     fn: ReadDir,
@@ -1793,54 +1802,54 @@ async function readdir(path6, options) {
   });
   return convertGoFileInfo(baseDir, items, options?.withFileTypes);
 }
-async function stat(path6, options) {
+async function stat(path3, options) {
   const fileInfo = await globalThis.fullstacked.bridge({
     mod: Fs,
     fn: Stats,
-    data: [formatPathLike(path6)]
+    data: [formatPathLike(path3)]
   });
   return fileInfoToStat(fileInfo);
 }
-function writeFile(path6, data) {
+function writeFile(path3, data) {
   return globalThis.fullstacked.bridge({
     mod: Fs,
     fn: WriteFile,
-    data: [formatPathLike(path6), data]
+    data: [formatPathLike(path3), data]
   });
 }
-function appendFile(path6, data) {
+function appendFile(path3, data) {
   return globalThis.fullstacked.bridge({
     mod: Fs,
     fn: AppendFile,
-    data: [formatPathLike(path6), data]
+    data: [formatPathLike(path3), data]
   });
 }
-function mkdir(path6) {
+function mkdir(path3) {
   return globalThis.fullstacked.bridge({
     mod: Fs,
     fn: Mkdir,
-    data: [formatPathLike(path6)]
+    data: [formatPathLike(path3)]
   });
 }
-function rm(path6) {
+function rm(path3) {
   return globalThis.fullstacked.bridge({
     mod: Fs,
     fn: Rm,
-    data: [formatPathLike(path6)]
+    data: [formatPathLike(path3)]
   });
 }
-function unlink(path6) {
+function unlink(path3) {
   return globalThis.fullstacked.bridge({
     mod: Fs,
     fn: Rm,
-    data: [formatPathLike(path6)]
+    data: [formatPathLike(path3)]
   });
 }
-function rename(path6, path22) {
+function rename(path3, path22) {
   return globalThis.fullstacked.bridge({
     mod: Fs,
     fn: Rename,
-    data: [formatPathLike(path6), formatPathLike(path22)]
+    data: [formatPathLike(path3), formatPathLike(path22)]
   });
 }
 function cp(src, dst) {
@@ -1864,50 +1873,50 @@ var promises_default = {
 };
 
 // ../../core/internal/bundle/lib/fs/index.ts
-function existsSync(path6) {
+function existsSync(path3) {
   return globalThis.fullstacked.bridge(
     {
       mod: Fs,
       fn: Exists,
-      data: [formatPathLike(path6)]
+      data: [formatPathLike(path3)]
     },
     true
   );
 }
-function statSync(path6, options) {
+function statSync(path3, options) {
   const fileInfo = globalThis.fullstacked.bridge(
     {
       mod: Fs,
       fn: Stats,
-      data: [formatPathLike(path6)]
+      data: [formatPathLike(path3)]
     },
     true
   );
   return fileInfoToStat(fileInfo);
 }
-function stat2(path6, options, callback) {
+function stat2(path3, options, callback) {
   const cb = typeof options === "function" ? options : callback;
   const opts = typeof options === "function" ? null : options;
-  promises_default.stat(formatPathLike(path6), opts).then((stats) => cb(null, stats)).catch((e) => cb(e, null));
+  promises_default.stat(formatPathLike(path3), opts).then((stats) => cb(null, stats)).catch((e) => cb(e, null));
 }
-function readFileSync(path6, options) {
+function readFileSync(path3, options) {
   const data = globalThis.fullstacked.bridge(
     {
       mod: Fs,
       fn: ReadFile,
-      data: [formatPathLike(path6)]
+      data: [formatPathLike(path3)]
     },
     true
   );
   return decodeStringData(data, options);
 }
-function readFile2(path6, options, callback) {
+function readFile2(path3, options, callback) {
   const cb = typeof options === "function" ? options : callback;
   const opts = typeof options === "function" ? null : options;
-  promises_default.readFile(formatPathLike(path6), opts).then((data) => cb(null, data)).catch((e) => cb(e, null));
+  promises_default.readFile(formatPathLike(path3), opts).then((data) => cb(null, data)).catch((e) => cb(e, null));
 }
-function readdirSync(path6, options) {
-  const baseDir = formatPathLike(path6);
+function readdirSync(path3, options) {
+  const baseDir = formatPathLike(path3);
   const items = globalThis.fullstacked.bridge(
     {
       mod: Fs,
@@ -1918,10 +1927,10 @@ function readdirSync(path6, options) {
   );
   return convertGoFileInfo(baseDir, items, options?.withFileTypes);
 }
-function readdir2(path6, options, callback) {
+function readdir2(path3, options, callback) {
   const cb = typeof options === "function" ? options : callback;
   const opts = typeof options === "function" ? {} : options;
-  const baseDir = formatPathLike(path6);
+  const baseDir = formatPathLike(path3);
   globalThis.fullstacked.bridge({
     mod: Fs,
     fn: ReadDir,
@@ -1933,86 +1942,86 @@ function readdir2(path6, options, callback) {
     )
   ).catch((e) => cb(e, null));
 }
-function mkdirSync(path6) {
+function mkdirSync(path3) {
   return globalThis.fullstacked.bridge(
     {
       mod: Fs,
       fn: Mkdir,
-      data: [formatPathLike(path6)]
+      data: [formatPathLike(path3)]
     },
     true
   );
 }
-async function mkdir2(path6, callback) {
-  promises_default.mkdir(path6).then(() => callback(null)).catch((e) => callback(e));
+async function mkdir2(path3, callback) {
+  promises_default.mkdir(path3).then(() => callback(null)).catch((e) => callback(e));
 }
-function rmSync(path6) {
+function rmSync(path3) {
   return globalThis.fullstacked.bridge(
     {
       mod: Fs,
       fn: Rm,
-      data: [formatPathLike(path6)]
+      data: [formatPathLike(path3)]
     },
     true
   );
 }
-async function rm2(path6, callback) {
-  promises_default.rm(path6).then(() => callback(null)).catch((e) => callback(e));
+async function rm2(path3, callback) {
+  promises_default.rm(path3).then(() => callback(null)).catch((e) => callback(e));
 }
-function unlinkSync(path6) {
+function unlinkSync(path3) {
   return globalThis.fullstacked.bridge(
     {
       mod: Fs,
       fn: Rm,
-      data: [formatPathLike(path6)]
+      data: [formatPathLike(path3)]
     },
     true
   );
 }
-async function unlink2(path6, callback) {
-  promises_default.unlink(path6).then(() => callback(null)).catch((e) => callback(e));
+async function unlink2(path3, callback) {
+  promises_default.unlink(path3).then(() => callback(null)).catch((e) => callback(e));
 }
-function writeFileSync(path6, data) {
+function writeFileSync(path3, data) {
   return globalThis.fullstacked.bridge(
     {
       mod: Fs,
       fn: WriteFile,
-      data: [formatPathLike(path6), data]
+      data: [formatPathLike(path3), data]
     },
     true
   );
 }
-function writeFile2(path6, data, callback) {
-  promises_default.writeFile(path6, data).then(() => callback(null)).catch((e) => callback(e));
+function writeFile2(path3, data, callback) {
+  promises_default.writeFile(path3, data).then(() => callback(null)).catch((e) => callback(e));
 }
-function appendFileSync(path6, data) {
+function appendFileSync(path3, data) {
   return globalThis.fullstacked.bridge(
     {
       mod: Fs,
       fn: AppendFile,
-      data: [formatPathLike(path6), data]
+      data: [formatPathLike(path3), data]
     },
     true
   );
 }
-function appendFile2(path6, data, callback) {
-  promises_default.appendFile(path6, data).then(() => callback(null)).catch((e) => callback(e));
+function appendFile2(path3, data, callback) {
+  promises_default.appendFile(path3, data).then(() => callback(null)).catch((e) => callback(e));
 }
-function renameSync(path6, path22) {
+function renameSync(path3, path22) {
   return globalThis.fullstacked.bridge(
     {
       mod: Fs,
       fn: Rename,
-      data: [formatPathLike(path6), formatPathLike(path22)]
+      data: [formatPathLike(path3), formatPathLike(path22)]
     },
     true
   );
 }
-function rename2(path6, path22, callback) {
-  promises_default.rename(path6, path22).then(() => callback(null)).catch((e) => callback(e));
+function rename2(path3, path22, callback) {
+  promises_default.rename(path3, path22).then(() => callback(null)).catch((e) => callback(e));
 }
-function realpathSync(path6) {
-  return resolve(formatPathLike(path6));
+function realpathSync(path3) {
+  return resolve(formatPathLike(path3));
 }
 function cpSync(src, dst) {
   return globalThis.fullstacked.bridge(
@@ -2030,12 +2039,12 @@ function cp2(src, dst, callback) {
 var WriteStream = class extends Writable {
   duplex = null;
   eventEmitter = null;
-  constructor(path6, options) {
+  constructor(path3, options) {
     super(options);
     globalThis.fullstacked.bridge({
       mod: Fs,
       fn: CreateWriteStream,
-      data: [formatPathLike(path6)]
+      data: [formatPathLike(path3)]
     }).then((d) => {
       this.duplex = d;
       this.eventEmitter = d.eventEmitter();
@@ -2075,8 +2084,8 @@ var WriteStream = class extends Writable {
     }
   }
 };
-function createWriteStream(path6, options) {
-  return new WriteStream(formatPathLike(path6), options);
+function createWriteStream(path3, options) {
+  return new WriteStream(formatPathLike(path3), options);
 }
 var fs_default = {
   existsSync,
@@ -2221,7 +2230,7 @@ async function init() {
       }
       return response;
     }
-    return new Promise(async (resolve2, reject) => {
+    return new Promise(async (resolve3, reject) => {
       const payload = preparePayload();
       const responseBuffer = await platformBridge2.bridge.Async(
         payload.buffer
@@ -2230,7 +2239,7 @@ async function init() {
       if (response instanceof Error) {
         reject(response);
       } else {
-        resolve2(response);
+        resolve3(response);
       }
     });
   };
@@ -2270,327 +2279,323 @@ function processResponse(buffer) {
   throw new Error("don't know how to process response from core");
 }
 
-// src/index.ts
-import path5 from "node:path";
-
-// src/core.ts
-import path2 from "node:path";
-import { createRequire } from "node:module";
+// ../../core/internal/bundle/lib/@types/bundle.ts
+var BundleDir = 1;
+var BundleFile = 2;
 
-// utils.ts
-import os from "node:os";
-import path from "node:path";
-import url from "node:url";
-import fs from "node:fs";
-var platform2 = os.platform();
-var archArgIndex = process.argv.indexOf("--arch");
-var arch2 = archArgIndex === -1 ? os.arch() : process.argv.at(archArgIndex + 1);
-var environment = `${platform2}-${arch2}`;
-var binExtension = platform2 === "win32" ? "dll" : "so";
-var binBasename = `fullstacked.${binExtension}`;
-var bindingBasename = "binding.node";
-var currentDirectory = path.dirname(
-  url.fileURLToPath(import.meta.url)
-);
-var packageJson = JSON.parse(
-  fs.readFileSync(path.resolve(currentDirectory, "package.json"), "utf-8")
-);
-var binLocations = [
-  // flattened dependencies when installed in project
-  path.resolve(currentDirectory, "..", "@fullstacked", environment),
-  // when installed globally
-  path.resolve(currentDirectory, "node_modules", "@fullstacked", environment)
-];
+// ../../core/internal/bundle/lib/bundle/index.ts
+function bundle(entryPoint) {
+  const resolved = path_default.resolve(entryPoint ?? ".");
+  return new Promise(async (resolve3) => {
+    const ee = (await globalThis.fullstacked.bridge({
+      mod: Bundle,
+      fn: BundleDir,
+      data: [resolved]
+    })).eventEmitter();
+    ee.on("result", resolve3);
+  });
+}
+function bundleFile(entryPoint) {
+  const resolved = path_default.resolve(entryPoint);
+  return globalThis.fullstacked.bridge({
+    mod: Bundle,
+    fn: BundleFile,
+    data: [resolved]
+  });
+}
 
-// src/core.ts
-import fs2 from "node:fs";
-globalThis.require = createRequire(import.meta.url);
-var core;
-function findBinLocation() {
-  for (const binLocation of binLocations) {
-    if (fs2.existsSync(binLocation)) {
-      return binLocation;
-    }
-  }
-  return void 0;
+// ../../core/internal/bundle/lib/run/index.ts
+async function run(directoryOrOptions) {
+  const directory = typeof directoryOrOptions === "string" ? directoryOrOptions : directoryOrOptions?.directory;
+  const env2 = typeof directoryOrOptions === "object" ? directoryOrOptions.env : void 0;
+  const resolved = path_default.resolve(directory ?? ".");
+  const newCtx = await globalThis.fullstacked.bridge({
+    mod: Core,
+    fn: Run,
+    data: [resolved, env2]
+  });
+  return newCtx;
 }
-function verifyVersion(binLocation) {
-  const packageJsonFileBin = path2.resolve(binLocation, "package.json");
-  try {
-    const packageJsonBin = JSON.parse(
-      fs2.readFileSync(packageJsonFileBin, { encoding: "utf-8" })
-    );
-    return packageJsonBin.version === packageJson.version;
-  } catch (e) {
-    return false;
+var run_default = run;
+
+// ../../core/internal/bundle/lib/@types/plugin.ts
+var StartPluginStream = 0;
+var Register = 1;
+var Unregister = 2;
+
+// ../../core/internal/bundle/lib/plugin/index.ts
+var plugins = /* @__PURE__ */ new Map();
+var duplexStream = null;
+var eventEmitter = null;
+var connectionPromise = null;
+var te3 = new TextEncoder();
+async function connect() {
+  if (duplexStream) {
+    return;
   }
+  const duplex = await globalThis.fullstacked.bridge({
+    mod: Plugin,
+    fn: StartPluginStream
+  });
+  const emitter = duplex.eventEmitter();
+  const readyPromise = new Promise((resolve3) => {
+    emitter.on("ready", function onReady() {
+      emitter.off("ready", onReady);
+      resolve3();
+    });
+  });
+  await duplex.open();
+  await readyPromise;
+  duplexStream = duplex;
+  eventEmitter = emitter;
+  eventEmitter.on(
+    "plugin-call",
+    async (pluginId, requestId, ...args2) => {
+      let result = null;
+      let errorMsg = null;
+      try {
+        const registeredPlugin = plugins.get(pluginId);
+        if (registeredPlugin) {
+          result = await registeredPlugin.callback(...args2);
+          if (registeredPlugin.type === PluginTypeBuild) {
+            const remappedResult = [];
+            result.forEach(({ outputName, contents }) => {
+              contents = typeof contents === "string" ? te3.encode(contents) : contents;
+              remappedResult.push(outputName, contents);
+            });
+            result = remappedResult;
+          }
+        } else {
+          throw new Error(
+            `No registered plugin found for id: ${pluginId}`
+          );
+        }
+      } catch (err) {
+        errorMsg = err.message || String(err);
+      }
+      if (Array.isArray(result)) {
+        eventEmitter.writeEvent(
+          "plugin-response",
+          pluginId,
+          requestId,
+          errorMsg,
+          ...result
+        );
+      } else {
+        eventEmitter.writeEvent(
+          "plugin-response",
+          pluginId,
+          requestId,
+          errorMsg,
+          result
+        );
+      }
+    }
+  );
 }
-async function load(onStreamData2) {
-  const binLocation = findBinLocation();
-  if (!binLocation) {
-    throw `Cannot find core library. Tried:
-${binLocations.join("\n")}`;
-  }
-  if (!verifyVersion(binLocation)) {
-    throw `Core library version mismatch. Retry installing fullstacked.`;
+async function register(type2, plugin2) {
+  if (!connectionPromise) {
+    connectionPromise = connect();
   }
-  const libPath = path2.resolve(binLocation, binBasename);
-  const bindingPath = path2.resolve(binLocation, bindingBasename);
-  core = __require(bindingPath);
-  core.load(libPath);
-  core.setOnStreamData(onStreamData2);
-  return core;
+  await connectionPromise;
+  const { name, ...pluginData } = plugin2.data || {};
+  const id = await globalThis.fullstacked.bridge({
+    mod: Plugin,
+    fn: Register,
+    data: [type2, name || "plugin-" + type2, pluginData]
+  });
+  plugins.set(id, { type: type2, callback: plugin2.callback });
+  return {
+    unregister: async () => {
+      plugins.delete(id);
+      await globalThis.fullstacked.bridge({
+        mod: Plugin,
+        fn: Unregister,
+        data: [id]
+      });
+    }
+  };
 }
+var plugin = {
+  register
+};
+var plugin_default = plugin;
 
-// src/webview.ts
-import http from "node:http";
-import net from "node:net";
-import open from "open";
-import { WebSocketServer } from "ws";
-init_base64();
-var args = process.argv;
-var portIndex = args.findIndex((arg) => arg === "-p" || arg === "--port");
-var mainPort = 9e3;
-if (portIndex !== -1 && args[portIndex + 1]) {
-  mainPort = parseInt(args[portIndex + 1]);
-  if (isNaN(mainPort)) {
-    mainPort = 9e3;
-  }
+// ../../core/internal/bundle/lib/@types/packages.ts
+var Install = 0;
+var Uninstall = 1;
+var Audit = 2;
+var ResolvePackages = 3;
+var AddResolveNodePath = 4;
+
+// ../../core/internal/bundle/lib/packages/index.ts
+async function install(directory, saveDev, ...packages2) {
+  return (await globalThis.fullstacked.bridge({
+    mod: Packages,
+    fn: Install,
+    data: [directory, saveDev, ...packages2 || []]
+  })).eventEmitter();
+}
+async function uninstall(directory, ...packages2) {
+  return (await globalThis.fullstacked.bridge({
+    mod: Packages,
+    fn: Uninstall,
+    data: [directory, ...packages2 || []]
+  })).eventEmitter();
+}
+function audit(directory) {
+  return globalThis.fullstacked.bridge({
+    mod: Packages,
+    fn: Audit,
+    data: [directory]
+  });
 }
-var te3 = new TextEncoder();
-async function createWebView(core3, ctx, opts) {
-  const port = await getNextAvailablePort(mainPort);
-  const server = http.createServer(createHandler(core3, ctx));
-  const close = () => {
-    core3.stop(ctx);
-    server.close();
-    opts.didClose?.();
-  };
-  const webSockets = createWebSocketServer(core3, ctx, server, close);
-  const callback = (id, buffer) => {
-    const payload = new Uint8Array(buffer.byteLength + 1);
-    payload[0] = id;
-    payload.set(new Uint8Array(buffer), 1);
-    webSockets.forEach((ws) => ws.send(payload));
-  };
-  server.listen(port);
-  if (!opts.quiet) {
-    console.log(`Listening at http://localhost:${port}`);
-  }
-  if (opts.openBrowser) {
-    open(`http://localhost:${port}`);
-  }
+function resolve2(moduleName, startDir) {
+  return globalThis.fullstacked.bridge({
+    mod: Packages,
+    fn: ResolvePackages,
+    data: [moduleName, startDir ?? ""]
+  });
+}
+function addNodePath(inputPath) {
+  return globalThis.fullstacked.bridge({
+    mod: Packages,
+    fn: AddResolveNodePath,
+    data: [inputPath]
+  });
+}
+var packages = {
+  install,
+  uninstall,
+  audit,
+  resolve: resolve2,
+  addNodePath
+};
+var packages_default = packages;
+
+// ../../core/internal/bundle/lib/fullstacked/index.ts
+function createConsoleStream(consoleFn) {
+  let buffer = "";
   return {
-    close,
-    port,
-    callback
+    write(chunk) {
+      const str = typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+      buffer += str;
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        consoleFn(line);
+      }
+    },
+    writeln(msg) {
+      if (buffer) {
+        consoleFn(buffer + msg);
+        buffer = "";
+      } else {
+        consoleFn(msg);
+      }
+    }
   };
 }
-var nextCallId = 0;
-async function coreCall(core3, req) {
-  const payload = await readBody(req);
-  if (payload.length >= 2) {
-    nextCallId = nextCallId % 255 + 1;
-    payload[1] = nextCallId;
+function getWriter(stream) {
+  if (!stream) return (msg) => console.log(msg);
+  if (typeof stream.writeln === "function") {
+    return (msg) => stream.writeln(msg);
   }
-  const data = core3.call(payload.buffer);
-  return new Uint8Array(data);
-}
-var platform3 = te3.encode("node");
-function createHandler(core3, ctx) {
-  return async (req, res) => {
-    let [pathname] = req.url.split("?");
-    pathname = decodeURI(pathname);
-    if (pathname === "/platform") {
-      res.writeHead(200, {
-        "content-type": "text/plain",
-        "content-length": platform3.length
-      });
-      return res.end(platform3);
-    } else if (pathname === "/ctx") {
-      const ctxStr = ctx.toString();
-      res.writeHead(200, {
-        "content-type": "text/plain",
-        "content-length": ctxStr.length
-      });
-      return res.end(ctxStr);
-    } else if (pathname === "/call") {
-      const payload = await coreCall(core3, req);
-      res.writeHead(200, {
-        "content-type": "application/octet-stream",
-        "content-length": payload.byteLength,
-        "cache-control": "no-cache"
-      });
-      return res.end(payload);
-    } else if (pathname === "/sync") {
-      const payload = await coreCall(core3, req);
-      const b64 = fromByteArray(payload);
-      res.writeHead(200, {
-        "content-type": "application/octet-stream",
-        "content-length": b64.length,
-        "cache-control": "no-cache"
-      });
-      return res.end(b64);
-    }
-    const staticFile = coreStaticFile(core3, ctx, pathname);
-    res.writeHead(staticFile.found ? 200 : 400, {
-      "content-type": staticFile.mimeType,
-      "content-length": staticFile.data.byteLength,
-      "cache-control": "no-cache"
-    });
-    res.end(staticFile.data);
-  };
-}
-function coreStaticFile(core3, ctx, pathname) {
-  const pathnameData = te3.encode(pathname);
-  const payload = new Uint8Array([
-    ctx,
-    0,
-    // id
-    Core,
-    // Module
-    StaticFile,
-    // Fn
-    0,
-    // Async
-    STRING,
-    ...numberToUint4Bytes(pathnameData.length),
-    // arg length
-    ...pathnameData
-  ]);
-  const responseData = core3.call(payload.buffer);
-  const response = deserialize(
-    responseData.slice(1)
-  );
-  if (response.data.byteLength === 0) {
-    return {
-      found: false,
-      mimeType: "text/plain",
-      data: te3.encode("not found")
-    };
+  if (typeof stream.write === "function") {
+    return (msg) => stream.write(
+      typeof msg === "string" && !msg.endsWith("\n") ? msg + "\n" : msg
+    );
   }
-  const [mimeType, data] = deserializeAll(response.data.buffer);
-  return {
-    found: true,
-    mimeType,
-    data
-  };
-}
-function readBody(req) {
-  return new Promise((resolve2) => {
-    const contentLengthStr = req.headers["content-length"] || "0";
-    const contentLength = parseInt(contentLengthStr);
-    if (!contentLength) {
-      return resolve2(new Uint8Array());
-    }
-    const body = new Uint8Array(contentLength);
-    let i = 0;
-    req.on("data", (chunk) => {
-      for (let j = 0; j < chunk.byteLength; j++) {
-        body[j + i] = chunk[j];
+  return (msg) => console.log(msg);
+}
+function formatMessage(msg, isWarning = false) {
+  const color = isWarning ? "\x1B[33m" : "\x1B[31m";
+  const label = isWarning ? "WARNING" : "ERROR";
+  if (typeof msg === "string") {
+    return `${color}${msg}\x1B[0m
+`;
+  }
+  const text = msg.Text || msg.text;
+  if (text) {
+    let out = `\x1B[1m${color}[${label}]\x1B[0m \x1B[1m${text}\x1B[0m`;
+    const loc = msg.Location || msg.location;
+    if (loc) {
+      const file = loc.File || loc.file;
+      const line = loc.Line || loc.line;
+      const col = loc.Column || loc.column;
+      if (file) {
+        out += `
+  \x1B[90mat ${file}${line !== void 0 ? `:${line}` : ""}${col !== void 0 ? `:${col}` : ""}\x1B[0m`;
       }
-      i += chunk.length;
-    });
-    req.on("end", () => resolve2(body));
-  });
-}
-function getNextAvailablePort(port = 9e3, host = "0.0.0.0") {
-  return new Promise((resolve2, reject) => {
-    const socket = new net.Socket();
-    const timeout = () => {
-      resolve2(port);
-      socket.destroy();
-    };
-    const next = () => {
-      socket.destroy();
-      resolve2(getNextAvailablePort(++port));
-    };
-    setTimeout(timeout, 200);
-    socket.on("timeout", timeout);
-    socket.on("connect", function() {
-      next();
-    });
-    socket.on("error", function(exception) {
-      if (exception.code !== "ECONNREFUSED") {
-        reject(exception);
-      } else {
-        timeout();
+      const lineText = loc.LineText || loc.lineText;
+      if (lineText) {
+        out += `
+    ${lineText}`;
+        if (typeof col === "number" && col > 0) {
+          out += `
+    ${" ".repeat(col - 1)}\x1B[32m^\x1B[0m`;
+        }
       }
-    });
-    socket.connect(port, host);
-  });
-}
-function createWebSocketServer(core3, ctx, server, close) {
-  const webSockets = /* @__PURE__ */ new Set();
-  const wss = new WebSocketServer({ noServer: true });
-  let closeTimeout;
-  const onClose = (ws) => {
-    webSockets.delete(ws);
-    if (!core3.check(ctx)) {
-      close();
-    } else if (webSockets.size === 0) {
-      closeTimeout = setTimeout(close, 5e3);
     }
-  };
-  const handleUpgrade = (ws) => {
-    if (closeTimeout) {
-      clearTimeout(closeTimeout);
-      closeTimeout = void 0;
+    const notes = msg.Notes || msg.notes;
+    if (Array.isArray(notes)) {
+      notes.forEach((note) => {
+        const noteText = note.Text || note.text;
+        if (noteText) {
+          out += `
+  \x1B[36mNote:\x1B[0m ${noteText}`;
+        }
+      });
     }
-    webSockets.add(ws);
-    ws.on("close", () => onClose(ws));
-  };
-  const onUpgrade = (...args2) => {
-    wss.handleUpgrade(...args2, handleUpgrade);
-  };
-  server.on("upgrade", onUpgrade);
-  return webSockets;
+    return out + "\n";
+  }
+  return JSON.stringify(msg, null, 2) + "\n";
 }
-
-// ../../core/internal/bundle/lib/process/version.json
-var version_default2 = { major: "1", minor: "0", patch: "0-alpha", branch: "v1", build: "1748", hash: "7c960ea337e7106b199163dff256a67ddd78f29d" };
-
-// src/args.ts
-function findArg(aliases, hasValueOrArgs, customArgs) {
-  const hasValue = typeof hasValueOrArgs === "boolean" ? hasValueOrArgs : false;
-  const args2 = Array.isArray(hasValueOrArgs) ? hasValueOrArgs : customArgs || process.argv.slice(2);
+function findArgValues(aliases, args2) {
   const values = [];
-  let present = false;
   for (let i = 0; i < args2.length; i++) {
     const arg = args2[i];
     if (aliases.includes(arg)) {
-      present = true;
-      if (hasValue) {
-        const next = args2[i + 1];
-        if (next !== void 0 && !next.startsWith("-")) {
-          values.push(next);
-          i++;
-        } else {
-          values.push("");
-        }
+      const next = args2[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        values.push(next);
+        i++;
+      } else {
+        values.push("");
       }
-    } else if (hasValue) {
+    } else {
       for (const alias of aliases) {
         if (arg.startsWith(alias + "=")) {
           values.push(arg.slice(alias.length + 1));
-          present = true;
           break;
         }
       }
     }
   }
-  return hasValue ? values : present;
+  return values;
+}
+function hasArgFlag(aliases, args2) {
+  for (const arg of args2) {
+    if (aliases.includes(arg)) return true;
+    for (const alias of aliases) {
+      if (arg.startsWith(alias + "=")) return true;
+    }
+  }
+  return false;
 }
-function getPositionalArgs(args2 = process.argv.slice(2)) {
-  const positional = [];
+function getPositionalArgs(args2) {
+  const positionals = [];
   const valueFlags = [
     ["-e", "--env"],
-    ["-p", "--port"]
+    ["-p", "--port"],
+    ["-p", "--plugin"],
+    ["-f", "--file"]
   ];
   const booleanFlags = [
     ["-h", "--help"],
     ["-v", "--version"],
     ["-o", "--open"],
+    ["-n", "--no-open"],
     ["-b", "--build"]
   ];
   for (let i = 0; i < args2.length; i++) {
@@ -2620,279 +2625,536 @@ function getPositionalArgs(args2 = process.argv.slice(2)) {
         break;
       }
     }
-    if (isValueFlag) {
-      continue;
-    }
-    if (arg.startsWith("-")) {
-      continue;
-    }
-    positional.push(arg);
+    if (isValueFlag) continue;
+    if (arg.startsWith("-")) continue;
+    positionals.push(arg);
   }
-  return positional;
-}
-
-// src/run/file.ts
-import path3 from "node:path";
-import fs3 from "node:fs";
-import { pathToFileURL } from "node:url";
-
-// ../../core/internal/bundle/lib/@types/bundle.ts
-var BundleDir = 1;
-var BundleFile = 2;
-
-// ../../core/internal/bundle/lib/bundle/index.ts
-function bundle(entryPoint) {
-  const resolved = path_default.resolve(entryPoint ?? ".");
-  return new Promise(async (resolve2) => {
-    const ee = (await globalThis.fullstacked.bridge({
-      mod: Bundle,
-      fn: BundleDir,
-      data: [resolved]
-    })).eventEmitter();
-    ee.on("result", resolve2);
-  });
-}
-function bundleFile(entryPoint) {
-  const resolved = path_default.resolve(entryPoint);
-  return globalThis.fullstacked.bridge({
-    mod: Bundle,
-    fn: BundleFile,
-    data: [resolved]
-  });
+  return positionals;
 }
-
-// src/run/file.ts
-async function runFile(positionalArgs2, end2) {
-  if (positionalArgs2.length === 0) {
-    console.error("Error: no file specified.");
-    end2(1);
-  }
-  const scriptFile = positionalArgs2[0];
-  const targetFilePath = path3.resolve(scriptFile);
-  if (!fs3.existsSync(targetFilePath)) {
-    console.error(`Error: file not found: ${scriptFile}`);
-    end2(1);
+async function bundleAndImportFile(file, startDir, writeErr) {
+  if (!file || file.trim() === "") {
+    writeErr(formatMessage("Error: no file specified.", false));
+    return null;
+  }
+  let resolvedPath;
+  try {
+    resolvedPath = await packages_default.resolve(file, startDir);
+  } catch {
+    resolvedPath = file;
   }
+  const targetFilePath = path_default.resolve(resolvedPath);
+  let fileExists = false;
   try {
-    const result = await bundleFile(
-      path3.relative(process.cwd(), targetFilePath)
+    await fs_default.promises.stat(targetFilePath);
+    fileExists = true;
+  } catch {
+  }
+  if (!fileExists) {
+    writeErr(formatMessage(`Error: file not found: ${file}`, false));
+    return null;
+  }
+  const result = await bundleFile(targetFilePath);
+  if (result.Errors?.length > 0) {
+    result.Errors.forEach((e) => writeErr(formatMessage(e, false)));
+    return null;
+  }
+  const outputFile = result.OutputFiles?.at(0);
+  if (!outputFile) {
+    writeErr(
+      formatMessage(
+        `Error: bundling ${file} produced no output files.`,
+        false
+      )
     );
-    if (result.Errors?.length > 0) {
-      result.Errors.forEach((e) => {
-        if (e.text) {
-          let out = e.text;
-          if (e.location) {
-            out += `
-    at ${e.location.file}:${e.location.line}:${e.location.column}`;
-          }
-          console.error(out);
-        } else {
-          console.error(e);
-        }
-      });
-      end2(1);
-    }
-    const outputFile = result.OutputFiles?.at(0);
-    if (!outputFile) {
-      console.error("Error: no output file generated.");
-      end2(1);
+    return null;
+  }
+  let absoluteOutputFile = path_default.resolve(process.cwd(), outputFile);
+  if (os_default.platform() === "win32") {
+    absoluteOutputFile = absoluteOutputFile.replaceAll("\\", "/");
+    absoluteOutputFile = absoluteOutputFile.at(1) === ":" ? absoluteOutputFile.slice(2) : absoluteOutputFile;
+  }
+  const cleanup = async () => {
+    await fs_default.promises.rm(absoluteOutputFile).catch(() => {
+    });
+  };
+  try {
+    const module = await import(absoluteOutputFile);
+    return { module, outputFile: absoluteOutputFile, cleanup };
+  } catch (e) {
+    writeErr(formatMessage(e.stack || e.message || String(e), false));
+    await cleanup();
+    return null;
+  }
+}
+async function runFile(file, writeOut, writeErr) {
+  const res = await bundleAndImportFile(file, process.cwd(), writeErr);
+  if (!res) return 1;
+  await res.cleanup();
+  return 0;
+}
+async function runDirectory(positionals, pluginsArgs, buildOnly, noOpen, env2, writeOut, writeErr) {
+  const targetDirectory = path_default.resolve(positionals.at(-1) || ".");
+  const buildPlugins = [];
+  const tempPluginFiles = [];
+  const cleanupPlugins = async () => {
+    for (const bp of buildPlugins) {
+      try {
+        await bp.unregister();
+      } catch {
+      }
     }
-    const absoluteOutputFile = path3.resolve(outputFile);
-    const cleanup = () => {
+    for (const tempFile of tempPluginFiles) {
       try {
-        const resolved = __require.resolve(absoluteOutputFile);
-        delete __require.cache[resolved];
+        await fs_default.promises.rm(tempFile).catch(() => {
+        });
       } catch {
       }
-      return fs3.promises.rm(absoluteOutputFile).catch(() => {
-      });
-    };
-    process.argv = [
-      process.argv[0],
-      targetFilePath,
-      ...positionalArgs2.slice(1)
-    ];
+    }
+  };
+  for (const pluginName of pluginsArgs) {
+    if (!pluginName) continue;
+    const res = await bundleAndImportFile(
+      pluginName,
+      targetDirectory,
+      writeErr
+    );
+    if (!res) {
+      await cleanupPlugins();
+      return 1;
+    }
+    tempPluginFiles.push(res.outputFile);
     try {
-      await import(pathToFileURL(absoluteOutputFile).href);
+      const pluginModule = res.module.default || res.module;
+      const registeredPlugin = await plugin_default.register(
+        "build",
+        pluginModule
+      );
+      if (registeredPlugin) {
+        buildPlugins.push(registeredPlugin);
+      }
     } catch (e) {
-      console.error(e.stack || e.message || String(e));
-      await cleanup();
-      end2(1);
+      writeErr(
+        formatMessage(
+          `Error loading plugin ${pluginName}: ${e.message}`,
+          false
+        )
+      );
+      await cleanupPlugins();
+      return 1;
     }
-    await cleanup();
-    end2(0);
-  } catch (e) {
-    console.error(`Error: ${e.message}`);
-    end2(1);
   }
+  const result = await bundle(targetDirectory);
+  if (result.Warnings?.length) {
+    result.Warnings.forEach((w) => writeErr(formatMessage(w, true)));
+  }
+  if (result.Errors?.length) {
+    result.Errors.forEach((e) => writeErr(formatMessage(e)));
+    await cleanupPlugins();
+    return 1;
+  }
+  if (buildOnly) {
+    writeOut("Build complete.");
+    await cleanupPlugins();
+    return 0;
+  }
+  const newCtx = await run_default({ directory: targetDirectory, env: env2 });
+  if (!noOpen && typeof newCtx === "number") {
+    globalThis.fullstacked.open?.(newCtx);
+  }
+  await cleanupPlugins();
+  return 0;
 }
+function validateCommand(command) {
+  let tokens = [];
+  if (typeof command === "string") {
+    tokens = command.trim().split(/\s+/).filter(Boolean);
+  } else if (Array.isArray(command)) {
+    tokens = [...command];
+  }
+  let fullstackedIndex = -1;
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    const base = token.split(/[/\\]/).pop() || token;
+    if (token === "fullstacked" || base === "fullstacked") {
+      fullstackedIndex = i;
+      break;
+    }
+  }
+  if (fullstackedIndex === -1) {
+    return null;
+  }
+  return tokens.slice(fullstackedIndex);
+}
+async function execute(command, opts) {
+  const stdoutStream = opts?.stdio?.at(1) || createConsoleStream(console.log);
+  const stderrStream = opts?.stdio?.at(2) || createConsoleStream(console.error);
+  const writeOut = getWriter(stdoutStream);
+  const writeErr = getWriter(stderrStream);
+  const tokens = validateCommand(command);
+  if (!tokens) {
+    writeErr(
+      formatMessage(
+        "Error: 'fullstacked' command not found in input.",
+        false
+      )
+    );
+    return 1;
+  }
+  const args2 = tokens.slice(1);
+  const showVersion = hasArgFlag(["-v", "--version"], args2);
+  const showHelp = hasArgFlag(["-h", "--help"], args2);
+  if (showVersion) {
+    writeOut(
+      `FullStacked v${version_default.major}.${version_default.minor}.${version_default.patch} (build ${version_default.build}), branch ${version_default.branch}, hash ${version_default.hash.slice(0, 8)}`
+    );
+    return 0;
+  }
+  if (showHelp) {
+    writeOut(`
+Usage: 
+  fullstacked [options] [directory]
 
-// src/run/directory.ts
-import path4 from "node:path";
-import { createRequire as createRequire2 } from "node:module";
-import { pathToFileURL as pathToFileURL2 } from "node:url";
+Description:
+  This CLI compiles and runs projects designed for the FullStacked runtime.
+  Unlike traditional JS/TS projects with separate frontend and backend layers:
+  - NodeJS and Browser APIs are available seamlessly within the same files.
+  - ES module syntax.
+  - TypeScript support.
+  - No HTML files.
+  - Start with an entrypoint: index.js(x) or index.ts(x).
 
-// ../../core/internal/bundle/lib/run/index.ts
-function run(directoryOrOptions) {
-  const directory2 = typeof directoryOrOptions === "string" ? directoryOrOptions : directoryOrOptions?.directory;
-  const env3 = typeof directoryOrOptions === "object" ? directoryOrOptions.env : void 0;
-  const resolved = path_default.resolve(directory2 ?? ".");
-  return globalThis.fullstacked.bridge({
-    mod: Core,
-    fn: Run,
-    data: [resolved, env3]
-  });
+Options:
+  -v, --version Display the current version
+  -p, --port    Define the main starting port (defaults to 9000)
+  -p, --plugin  Specify a plugin for the build process (can be used multiple times)
+  -e, --env     Define environment variables in KEY=VALUE format (can be used multiple times)
+  -o, --open    Directly open the browser
+  -b, --build   Only bundle the project, don't run it afterward
+  -f, --file    Bundle and execute a single script file
+  -h, --help    Display this help message
+
+Directory:
+  The directory to bundle (defaults to ".")
+        `);
+    return 0;
+  }
+  const fileFlags = findArgValues(["-f", "--file"], args2);
+  const file = fileFlags.length > 0 ? fileFlags[0] : void 0;
+  const buildOnly = hasArgFlag(["-b", "--build"], args2);
+  const noOpen = hasArgFlag(["-n", "--no-open"], args2);
+  const envArgs = findArgValues(["-e", "--env"], args2);
+  const pluginsArgs = findArgValues(["-p", "--plugin"], args2);
+  const positionals = getPositionalArgs(args2);
+  const env2 = {};
+  for (const val of envArgs) {
+    const index = val.indexOf("=");
+    if (index !== -1) {
+      env2[val.slice(0, index)] = val.slice(index + 1);
+    } else if (val) {
+      env2[val] = "";
+    }
+  }
+  if (file) {
+    return runFile(file, writeOut, writeErr);
+  }
+  return runDirectory(
+    positionals,
+    pluginsArgs,
+    buildOnly,
+    noOpen,
+    env2,
+    writeOut,
+    writeErr
+  );
 }
+var fullstacked = {
+  execute,
+  validateCommand
+};
+var fullstacked_default = fullstacked;
 
-// ../../core/internal/bundle/lib/@types/plugin.ts
-var StartPluginStream = 0;
-var Register = 1;
-var Unregister = 2;
+// src/core.ts
+import path2 from "node:path";
+import { createRequire } from "node:module";
 
-// ../../core/internal/bundle/lib/plugin/index.ts
-var plugins = /* @__PURE__ */ new Map();
-var duplexStream = null;
-var eventEmitter = null;
-var connectionPromise = null;
-var te4 = new TextEncoder();
-async function connect() {
-  if (duplexStream) {
-    return;
-  }
-  const duplex = await globalThis.fullstacked.bridge({
-    mod: Plugin,
-    fn: StartPluginStream
-  });
-  const emitter = duplex.eventEmitter();
-  const readyPromise = new Promise((resolve2) => {
-    emitter.on("ready", function onReady() {
-      emitter.off("ready", onReady);
-      resolve2();
-    });
-  });
-  await duplex.open();
-  await readyPromise;
-  duplexStream = duplex;
-  eventEmitter = emitter;
-  eventEmitter.on(
-    "plugin-call",
-    async (pluginId, requestId, ...args2) => {
-      let result = null;
-      let errorMsg = null;
-      try {
-        const registeredPlugin = plugins.get(pluginId);
-        if (registeredPlugin) {
-          result = await registeredPlugin.callback(...args2);
-          if (registeredPlugin.type === PluginTypeBuild) {
-            const remappedResult = [];
-            result.forEach(({ outputName, contents }) => {
-              contents = typeof contents === "string" ? te4.encode(contents) : contents;
-              remappedResult.push(outputName, contents);
-            });
-            result = remappedResult;
-          }
-        } else {
-          throw new Error(
-            `No registered plugin found for id: ${pluginId}`
-          );
-        }
-      } catch (err) {
-        errorMsg = err.message || String(err);
-      }
-      if (Array.isArray(result)) {
-        eventEmitter.writeEvent(
-          "plugin-response",
-          pluginId,
-          requestId,
-          errorMsg,
-          ...result
-        );
-      } else {
-        eventEmitter.writeEvent(
-          "plugin-response",
-          pluginId,
-          requestId,
-          errorMsg,
-          result
-        );
-      }
+// utils.ts
+import os from "node:os";
+import path from "node:path";
+import url from "node:url";
+import fs from "node:fs";
+var platform2 = os.platform();
+var archArgIndex = process.argv.indexOf("--arch");
+var arch2 = archArgIndex === -1 ? os.arch() : process.argv.at(archArgIndex + 1);
+var environment = `${platform2}-${arch2}`;
+var binExtension = platform2 === "win32" ? "dll" : "so";
+var binBasename = `fullstacked.${binExtension}`;
+var bindingBasename = "binding.node";
+var currentDirectory = path.dirname(
+  url.fileURLToPath(import.meta.url)
+);
+var packageJson = JSON.parse(
+  fs.readFileSync(path.resolve(currentDirectory, "package.json"), "utf-8")
+);
+var binLocations = [
+  // flattened dependencies when installed in project
+  path.resolve(currentDirectory, "..", "@fullstacked", environment),
+  // when installed globally
+  path.resolve(currentDirectory, "node_modules", "@fullstacked", environment)
+];
+
+// src/core.ts
+import fs2 from "node:fs";
+globalThis.require = createRequire(import.meta.url);
+var core;
+function findBinLocation() {
+  for (const binLocation of binLocations) {
+    if (fs2.existsSync(binLocation)) {
+      return binLocation;
     }
-  );
+  }
+  return void 0;
 }
-async function register(type2, plugin2) {
-  if (!connectionPromise) {
-    connectionPromise = connect();
+function verifyVersion(binLocation) {
+  const packageJsonFileBin = path2.resolve(binLocation, "package.json");
+  try {
+    const packageJsonBin = JSON.parse(
+      fs2.readFileSync(packageJsonFileBin, { encoding: "utf-8" })
+    );
+    return packageJsonBin.version === packageJson.version;
+  } catch (e) {
+    return false;
+  }
+}
+async function load(onStreamData2) {
+  const binLocation = findBinLocation();
+  if (!binLocation) {
+    throw `Cannot find core library. Tried:
+${binLocations.join("\n")}`;
+  }
+  if (!verifyVersion(binLocation)) {
+    throw `Core library version mismatch. Retry installing fullstacked.`;
+  }
+  const libPath = path2.resolve(binLocation, binBasename);
+  const bindingPath = path2.resolve(binLocation, bindingBasename);
+  core = __require(bindingPath);
+  core.load(libPath);
+  core.setOnStreamData(onStreamData2);
+  return core;
+}
+
+// src/webview.ts
+import http from "node:http";
+import net from "node:net";
+import open from "open";
+import { WebSocketServer } from "ws";
+init_base64();
+var args = process.argv;
+var portIndex = args.findIndex((arg) => arg === "-p" || arg === "--port");
+var mainPort = 9e3;
+if (portIndex !== -1 && args[portIndex + 1]) {
+  mainPort = parseInt(args[portIndex + 1]);
+  if (isNaN(mainPort)) {
+    mainPort = 9e3;
+  }
+}
+var te4 = new TextEncoder();
+async function createWebView(core3, ctx, opts) {
+  const port = await getNextAvailablePort(mainPort);
+  const server = http.createServer(createHandler(core3, ctx));
+  const close = () => {
+    core3.stop(ctx);
+    server.close();
+    opts.didClose?.();
+  };
+  const webSockets = createWebSocketServer(core3, ctx, server, close);
+  const callback = (id, buffer) => {
+    const payload = new Uint8Array(buffer.byteLength + 1);
+    payload[0] = id;
+    payload.set(new Uint8Array(buffer), 1);
+    webSockets.forEach((ws) => ws.send(payload));
+  };
+  server.listen(port);
+  if (!opts.quiet) {
+    console.log(`Listening at http://localhost:${port}`);
+  }
+  if (!process.env.TEST) {
+    open(`http://localhost:${port}`);
   }
-  await connectionPromise;
-  const { name, ...pluginData } = plugin2.data || {};
-  const id = await globalThis.fullstacked.bridge({
-    mod: Plugin,
-    fn: Register,
-    data: [type2, name || "plugin-" + type2, pluginData]
-  });
-  plugins.set(id, { type: type2, callback: plugin2.callback });
   return {
-    unregister: async () => {
-      plugins.delete(id);
-      await globalThis.fullstacked.bridge({
-        mod: Plugin,
-        fn: Unregister,
-        data: [id]
-      });
-    }
+    close,
+    port,
+    callback
   };
 }
-var plugin = {
-  register
-};
-var plugin_default = plugin;
-
-// src/run/directory.ts
-async function importPlugin(p) {
-  if (p.startsWith(".") || path4.isAbsolute(p)) {
-    return (await import(pathToFileURL2(path4.resolve(p)).href)).default;
+var nextCallId = 0;
+async function coreCall(core3, req) {
+  const payload = await readBody(req);
+  if (payload.length >= 2) {
+    nextCallId = nextCallId % 255 + 1;
+    payload[1] = nextCallId;
   }
-  try {
-    const requireFromCwd = createRequire2(
-      path4.join(process.cwd(), "index.js")
-    );
-    const resolved = requireFromCwd.resolve(p);
-    return (await import(pathToFileURL2(resolved).href)).default;
-  } catch {
-    try {
-      const requireFromModule = createRequire2(import.meta.url);
-      const resolved = requireFromModule.resolve(p);
-      return (await import(pathToFileURL2(resolved).href)).default;
-    } catch {
-      return (await import(p)).default;
+  const data = core3.call(payload.buffer);
+  return new Uint8Array(data);
+}
+var platform3 = te4.encode("node");
+function createHandler(core3, ctx) {
+  return async (req, res) => {
+    let [pathname] = req.url.split("?");
+    pathname = decodeURI(pathname);
+    if (pathname === "/platform") {
+      res.writeHead(200, {
+        "content-type": "text/plain",
+        "content-length": platform3.length
+      });
+      return res.end(platform3);
+    } else if (pathname === "/ctx") {
+      const ctxStr = ctx.toString();
+      res.writeHead(200, {
+        "content-type": "text/plain",
+        "content-length": ctxStr.length
+      });
+      return res.end(ctxStr);
+    } else if (pathname === "/open") {
+      const newCtx = await readBody(req);
+      globalThis.fullstacked.open(newCtx[0]);
+      return res.end();
+    } else if (pathname === "/call") {
+      const payload = await coreCall(core3, req);
+      res.writeHead(200, {
+        "content-type": "application/octet-stream",
+        "content-length": payload.byteLength,
+        "cache-control": "no-cache"
+      });
+      return res.end(payload);
+    } else if (pathname === "/sync") {
+      const payload = await coreCall(core3, req);
+      const b64 = fromByteArray(payload);
+      res.writeHead(200, {
+        "content-type": "application/octet-stream",
+        "content-length": b64.length,
+        "cache-control": "no-cache"
+      });
+      return res.end(b64);
     }
-  }
+    const staticFile = coreStaticFile(core3, ctx, pathname);
+    res.writeHead(staticFile.found ? 200 : 400, {
+      "content-type": staticFile.mimeType,
+      "content-length": staticFile.data.byteLength,
+      "cache-control": "no-cache"
+    });
+    res.end(staticFile.data);
+  };
 }
-async function runDirectory(pluginsArgs2, buildOnly2, env3, end2) {
-  await Promise.all(
-    pluginsArgs2.map(
-      async (p) => plugin_default.register("build", await importPlugin(p))
-    )
+function coreStaticFile(core3, ctx, pathname) {
+  const pathnameData = te4.encode(pathname);
+  const payload = new Uint8Array([
+    ctx,
+    0,
+    // id
+    Core,
+    // Module
+    StaticFile,
+    // Fn
+    0,
+    // Async
+    STRING,
+    ...numberToUint4Bytes(pathnameData.length),
+    // arg length
+    ...pathnameData
+  ]);
+  const responseData = core3.call(payload.buffer);
+  const response = deserialize(
+    responseData.slice(1)
   );
-  const result = await bundle();
-  if (result.Warnings?.length) {
-    console.warn("Warnings:", result.Warnings);
-  }
-  if (result.Errors?.length) {
-    console.error("Errors:", result.Errors);
-    end2(1);
-  } else if (!buildOnly2) {
-    run({ env: env3 });
-  } else {
-    console.log("Build complete.");
-    end2(0);
+  if (response.data.byteLength === 0) {
+    return {
+      found: false,
+      mimeType: "text/plain",
+      data: te4.encode("not found")
+    };
   }
+  const [mimeType, data] = deserializeAll(response.data.buffer);
+  return {
+    found: true,
+    mimeType,
+    data
+  };
+}
+function readBody(req) {
+  return new Promise((resolve3) => {
+    const contentLengthStr = req.headers["content-length"] || "0";
+    const contentLength = parseInt(contentLengthStr);
+    if (!contentLength) {
+      return resolve3(new Uint8Array());
+    }
+    const body = new Uint8Array(contentLength);
+    let i = 0;
+    req.on("data", (chunk) => {
+      for (let j = 0; j < chunk.byteLength; j++) {
+        body[j + i] = chunk[j];
+      }
+      i += chunk.length;
+    });
+    req.on("end", () => resolve3(body));
+  });
+}
+function getNextAvailablePort(port = 9e3, host = "0.0.0.0") {
+  return new Promise((resolve3, reject) => {
+    const socket = new net.Socket();
+    const timeout = () => {
+      resolve3(port);
+      socket.destroy();
+    };
+    const next = () => {
+      socket.destroy();
+      resolve3(getNextAvailablePort(++port));
+    };
+    setTimeout(timeout, 200);
+    socket.on("timeout", timeout);
+    socket.on("connect", function() {
+      next();
+    });
+    socket.on("error", function(exception) {
+      if (exception.code !== "ECONNREFUSED") {
+        reject(exception);
+      } else {
+        timeout();
+      }
+    });
+    socket.connect(port, host);
+  });
+}
+function createWebSocketServer(core3, ctx, server, close) {
+  const webSockets = /* @__PURE__ */ new Set();
+  const wss = new WebSocketServer({ noServer: true });
+  let closeTimeout;
+  const onClose = (ws) => {
+    webSockets.delete(ws);
+    if (!core3.check(ctx)) {
+      close();
+    } else if (webSockets.size === 0) {
+      closeTimeout = setTimeout(close, 5e3);
+    }
+  };
+  const handleUpgrade = (ws) => {
+    if (closeTimeout) {
+      clearTimeout(closeTimeout);
+      closeTimeout = void 0;
+    }
+    webSockets.add(ws);
+    ws.on("close", () => onClose(ws));
+  };
+  const onUpgrade = (...args2) => {
+    wss.handleUpgrade(...args2, handleUpgrade);
+  };
+  server.on("upgrade", onUpgrade);
+  return webSockets;
 }
 
 // src/index.ts
-var end = (code2) => {
+var end = (code3) => {
   core2.end();
-  process.exit(code2);
+  process.exit(code3);
 };
 ["SIGINT", "SIGTERM", "SIGQUIT"].forEach(
   (signal) => process.on(signal, () => end(0))
@@ -2909,93 +3171,30 @@ var core2 = await load(
       webview.callback(streamId, buffer);
       return;
     }
-    createWebView(core2, ctx, {
-      openBrowser: openBrowser || webviews.size >= 1,
-      didClose: () => {
-        webviews.delete(ctx);
-      }
-    }).then((webview2) => {
-      webviews.set(ctx, webview2);
-    });
+    throw new Error(`Unknown context: ${ctx}`);
   }
 );
-var help = findArg(["-h", "--help"]);
-var showVersion = findArg(["-v", "--version"]);
-var openBrowser = findArg(["-o", "--open"]);
-var buildOnly = findArg(["-b", "--build"]);
-var envArgs = findArg(["-e", "--env"], true);
-var pluginsArgs = findArg(["-p", "--plugin"], true);
-var fileFlag = findArg(["-f", "--file"]);
-var env2 = {};
-for (const val of envArgs) {
-  const index = val.indexOf("=");
-  if (index !== -1) {
-    const key = val.slice(0, index);
-    const value = val.slice(index + 1);
-    env2[key] = value;
-  } else if (val) {
-    env2[val] = "";
-  }
-}
-var positionalArgs = getPositionalArgs();
-var directory = fileFlag ? process.cwd() : path5.resolve(positionalArgs.at(-1) || ".");
-if (showVersion) {
-  console.log(
-    `FullStacked v${version_default2.major}.${version_default2.minor}.${version_default2.patch} (build ${version_default2.build}), branch ${version_default2.branch}, hash ${version_default2.hash.slice(0, 8)}`
-  );
-  process.exit(0);
-}
-if (help) {
-  console.log(`
-Usage: 
-  fullstacked [options] [directory]
-
-Description:
-  This CLI compiles and runs projects designed for the FullStacked runtime.
-  Unlike traditional JS/TS projects with separate frontend and backend layers:
-  - NodeJS and Browser APIs are available seamlessly within the same files.
-  - ES module syntax.
-  - TypeScript support.
-  - No HTML files.
-  - Start with an entrypoint: index.js(x) or index.ts(x).
-
-Example:
-  // index.jsx
-  import React from "react";
-  import { createRoot } from "react-dom/client";
-  import fs from "node:fs";
-
-  const div = document.createElement("div");
-  document.body.append(div);
-
-  const root = createRoot(div);
-  root.render(<h1>{await fs.promises.readFile("hello-world.txt")}</h1>);
-
-Options:
-  -v, --version Display the current version
-  -p, --port    Define the main starting port (defaults to 9000)
-  -p, --plugin  Specify a plugin for the build process (can be used multiple times)
-  -e, --env     Define environment variables in KEY=VALUE format (can be used multiple times)
-  -o, --open    Directly open the browser
-  -b, --build   Only bundle the project, don't run it afterward
-  -f, --file    Bundle and execute a single script file
-  -h, --help    Display this help message
-
-Directory:
-  The directory to bundle (defaults to ".")
-    `);
-  process.exit(0);
-}
-process.chdir(directory);
-var mainCtx = core2.start(directory, directory);
+var mainCtx = core2.start(process.cwd(), process.cwd());
 globalThis.ctxId = mainCtx;
 globalThis.bridges = {
   ctxId: mainCtx,
   Sync: (payload) => core2.call(payload),
   Async: async (payload) => core2.call(payload)
 };
-if (fileFlag) {
-  await runFile(positionalArgs, end);
-} else {
-  await runDirectory(pluginsArgs, buildOnly, env2, end);
+globalThis.fullstacked.open = (ctx) => {
+  createWebView(core2, ctx, {
+    didClose: () => {
+      webviews.delete(ctx);
+    }
+  }).then((webview) => {
+    webviews.set(ctx, webview);
+  });
+};
+var code2 = await fullstacked_default.execute(process.argv);
+var argsThatExits = ["-b", "--build", "-f", "--file"];
+var shouldExit = !!process.argv.find(
+  (arg) => argsThatExits.find((exitArg) => arg.startsWith(exitArg))
+);
+if (typeof code2 === "number" && code2 !== 0 || shouldExit) {
+  end(code2);
 }