@gasboost/vite 0.1.1 → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 gasboost
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,8 +1,11 @@
 # @gasboost/vite
 
-`@gasboost/app` で構築したアプリケーションを Google Apps Script 向けにビルドするための Vite プラグインです。
+`@gasboost/app` で構築した Google Apps Script アプリケーションを、Vite でビルド・ローカル開発するためのプラグインです。
 
-アプリケーションの entry file を静的解析し、`AppsScript` に登録されたハンドラを検出して、Google Apps Script が認識するためのグローバル関数宣言を生成します。
+`@gasboost/vite` は用途ごとに2つの Vite Plugin を提供します。
+
+- `build` — Google Apps Script 向けの production build
+- `dev` — ローカル開発時の RPC 実行
 
 ## インストール
 
@@ -18,119 +21,175 @@ npm install @gasboost/app
 npm install -D @gasboost/vite vite
 ```
 
-## 使い方
+## Quick Start
 
-まず通常の Gasboost アプリケーションを作成します。
+まず `@gasboost/app` でバックエンドを定義します。
 
 ```ts
-// src/main.ts
+// src/server.ts
 
 import { AppsScript } from "@gasboost/app";
 
 const app = new AppsScript()
-  .get((request) => {
+  .get(() => {
     return HtmlService.createHtmlOutput("Hello");
   })
   .post((request) => {
     return ContentService.createTextOutput(request.text());
   })
-  .call("sum", (a: number, b: number) => a + b);
+  .call("sum", (a: number, b: number) => a + b)
+  .call("getUser", async (id: string) => ({
+    id,
+    name: "Taro",
+  }));
 
 export default app;
 ```
 
-Vite を設定します。
+`gasboost()` から `build` と `dev` を取得し、1つの `vite.config.ts` の中で mode に応じて使い分けます。
+
+frontend と backend は成果物と build graph が異なるため、同時に1つの Vite build へ混在させません。
 
 ```ts
 // vite.config.ts
 
+import react from "@vitejs/plugin-react";
 import { defineConfig } from "vite";
+import { viteSingleFile } from "vite-plugin-singlefile";
 import { gasboost } from "@gasboost/vite";
 
-export default defineConfig({
-  plugins: [
-    gasboost({
-      entry: "src/main.ts",
-    }),
-  ],
+const { build, dev } = gasboost({
+  entry: "src/server.ts",
+  envDir: ".env",
 });
-```
 
-通常通りビルドできます。
+export default defineConfig(({ mode }) => {
+  if (mode === "server") {
+    return {
+      plugins: [build],
+      build: {
+        outDir: "dist",
+        emptyOutDir: false,
+      },
+    };
+  }
+
+  return {
+    plugins: [react(), viteSingleFile(), dev],
+    build: {
+      outDir: "dist",
+    },
+  };
+});
+```
 
-```bash
-vite build
+この例では、frontend build と backend build を mode で分離します。
+
+```json
+{
+  "scripts": {
+    "dev": "vite",
+    "build:client": "vite build --mode client",
+    "build:server": "vite build --mode server",
+    "build": "pnpm build:client && pnpm build:server"
+  }
+}
 ```
 
-## オプション
+```text
+vite
+  ↓
+gasboost:dev
 
-### `entry`
+vite build --mode client
+  ↓
+frontend build
 
-必須です。
+vite build --mode server
+  ↓
+gasboost:build
+```
+
+frontend 側の React、single-file 化などの設定は利用側プロジェクトの責務です。
 
-`AppsScript` アプリケーションを定義している entry file のパスを指定します。
+## gasboost()
 
 ```ts
-gasboost({
-  entry: "src/main.ts",
+const { build, dev } = gasboost({
+  entry: "src/server.ts",
+  envDir: "config",
 });
 ```
 
-entry file には1つの `AppsScript` インスタンスを定義し、そのインスタンスを default export する必要があります。
+戻り値:
 
 ```ts
-const app = new AppsScript();
-
-export default app;
+{
+  build: Plugin;
+  dev: Plugin;
+}
 ```
 
-チェーン形式の登録に対応しています。
-
-```ts
-const app = new AppsScript()
-  .get(...)
-  .post(...)
-  .call("getUser", ...);
+### `entry`
 
-export default app;
-```
+必須です。
 
-インスタンス生成後に登録する形式にも対応しています。
+`AppsScript` を定義して default export している entry file を指定します。
 
 ```ts
-const app = new AppsScript();
-
-app.get(...);
-app.call("getUser", ...);
-
-export default app;
+gasboost({
+  entry: "src/server.ts",
+});
 ```
 
 ### `envDir`
 
 任意です。
 
-Vite が環境変数ファイルを読み込むディレクトリを指定します。
+build 時に Vite が環境変数ファイルを読み込むディレクトリを指定します。
 
 ```ts
 gasboost({
-  entry: "src/main.ts",
+  entry: "src/server.ts",
   envDir: "config",
 });
 ```
 
-例えば以下の構成を利用できます。
+---
 
-```text
-config/
-├── .env
-├── .env.development
-└── .env.production
+# Build Plugin
+
+`build` は `vite build` のときだけ動作し、GAS backend build を担当します。
+
+frontend / backend を同じ `vite.config.ts` で扱う場合は、server 用 mode のときだけ `plugins` に含めてください。
+
+```ts
+const { build } = gasboost({
+  entry: "src/server.ts",
+});
+
+export default defineConfig(({ mode }) => {
+  if (mode === "server") {
+    return {
+      plugins: [build],
+    };
+  }
+
+  return {
+    plugins: [],
+  };
+});
 ```
 
-## 生成されるグローバル関数
+`build` plugin は次の処理を担当します。
 
-Google Apps Script はトップレベルのグローバル関数を entry point として認識します。
+- entry file の静的解析
+- `AppsScript` に登録された GET / POST / RPC の検出
+- GAS が認識するグローバル関数宣言の生成
+- GAS 向け Vite build configuration
+- 環境変数の読み込み
+
+## グローバル関数の生成
 
 例えば次のアプリケーションを定義した場合:
 
@@ -144,7 +203,7 @@ const app = new AppsScript()
 export default app;
 ```
 
-ビルド結果には以下に対応するグローバル関数宣言が生成されます。
+build plugin は GAS が認識するためのグローバル関数宣言を生成します。
 
 ```js
 function doGet() {}
@@ -153,56 +212,51 @@ function getUser() {}
 function sum() {}
 ```
 
-これらの宣言は Google Apps Script に関数名を認識させるためのものです。
-
-実際の dispatch 処理は行いません。
-
-ハンドラの実体は `@gasboost/app` がランタイム上で登録します。
+これらは関数名を Google Apps Script に認識させるための宣言です。
 
-責務は次のように分離されています。
+実際のハンドラ登録と dispatch は `@gasboost/app` がランタイム上で行います。
 
 ```text
-@gasboost/app
-  runtime registration
-  handler dispatch
-  globalThis implementation
-
 @gasboost/vite
   static analysis
-  GAS build configuration
   global function declarations
+        ↓
+@gasboost/app
+  runtime registration
+  dispatch
 ```
 
 ## 静的解析
 
-プラグインは指定された entry file を静的解析します。
-
-対象となる `AppsScript` インスタンスに対する登録を検出します。
+entry file には1つの `AppsScript` インスタンスを定義し、default export します。
 
 ```ts
+const app = new AppsScript();
+
 app.get(...);
-app.post(...);
 app.call("getUser", ...);
+
+export default app;
 ```
 
-別オブジェクトの同名メソッドは無視されます。
+チェーン形式にも対応しています。
 
 ```ts
-other.get(...);
-other.call("something", ...);
-```
+const app = new AppsScript()
+  .get(...)
+  .post(...)
+  .call("getUser", ...);
 
-### RPC 名
+export default app;
+```
 
 RPC 名は文字列リテラルで指定する必要があります。
 
-対応:
-
 ```ts
 app.call("getUser", handler);
 ```
 
-非対応:
+次のような動的な名前は静的解析の対象外です。
 
 ```ts
 const name = "getUser";
@@ -210,123 +264,442 @@ const name = "getUser";
 app.call(name, handler);
 ```
 
-ビルド時に生成する GAS グローバル関数名を静的に確定するため、この制約があります。
+build 時に GAS のグローバル関数名を確定する必要があるためです。
 
-### 重複登録
+## 検証
 
-以下の曖昧な登録はエラーになります。
+静的解析時には、曖昧なアプリケーション定義をエラーとして扱います。
 
 - GET ハンドラの重複
 - POST ハンドラの重複
 - RPC 名の重複
-- entry 内に複数の `AppsScript` インスタンスが存在する場合
-
-`AppsScript` インスタンスは default export されている必要があります。
+- entry 内の複数 `AppsScript` インスタンス
+- default export されていない `AppsScript`
 
-## GAS 向けビルド設定
+## GAS 向け build configuration
 
-`gasboost()` が Google Apps Script 向けの Vite build configuration を提供します。
-
-現在は以下の設定を利用します。
+現在の build 設定:
 
 - target: ECMAScript 2019
 - output format: CommonJS
 - output directory: `dist`
-- `entry` で指定されたファイルを build input として利用
-
-利用側の Vite config で GAS 固有の build setting を重複して定義する必要はありません。
+- `entry` を build input として利用
 
 ## 環境変数
 
-環境変数は Vite 標準の仕組みを利用します。
-
-例えば:
+Vite 標準の環境変数機構を利用します。
 
 ```text
-config/.env
+config/
+├── .env
+├── .env.development
+└── .env.production
 ```
 
-```env
-VITE_API_URL=https://example.com
+```ts
+const { build } = gasboost({
+  entry: "src/server.ts",
+  envDir: "config",
+});
 ```
 
-`envDir` を設定します。
+アプリケーションでは通常の Vite と同様に参照できます。
 
 ```ts
-gasboost({
-  entry: "src/main.ts",
-  envDir: "config",
+const apiUrl = import.meta.env.VITE_API_URL;
+```
+
+---
+
+# Dev Plugin
+
+`dev` は Vite Dev Server 上でのみ動作します。
+
+frontend の開発用 Vite config に追加して利用します。
+
+```ts
+const { dev } = gasboost({
+  entry: "src/server.ts",
+});
+
+export default defineConfig({
+  plugins: [dev],
 });
 ```
 
-アプリケーションから通常通り参照できます。
+`dev` plugin は、GAS にデプロイしなくてもローカル環境から `AppsScript` の RPC を実行できるエンドポイントを Vite Dev Server に追加します。
+
+## Local RPC
+
+ローカル RPC のエンドポイントは次の形式です。
+
+```text
+POST /__gasboost/{rpcName}
+```
+
+例えば、
 
 ```ts
-const apiUrl = import.meta.env.VITE_API_URL;
+const app = new AppsScript().call("sum", (a: number, b: number) => a + b);
+
+export default app;
 ```
 
-mode ごとの環境変数ファイルにも対応します。
+に対して、
 
-```bash
-vite build --mode production
+```http
+POST /__gasboost/sum
+Content-Type: application/json
+```
+
+```json
+{
+  "args": [1, 2]
+}
+```
+
+を送信すると、内部では次の dispatch が実行されます。
+
+```ts
+app.dispatch("sum", 1, 2);
+```
+
+レスポンス:
+
+```json
+3
+```
+
+## RPC Request
+
+Request Body は次の形式です。
+
+```ts
+{
+  args: unknown[];
+}
+```
+
+例えば複数の引数を持つ RPC:
+
+```ts
+app.call(
+  "example",
+  (id: number, name: string, active: boolean, options: { value: number }) => {
+    // ...
+  },
+);
+```
+
+に対して、
+
+```json
+{
+  "args": [
+    1,
+    "Taro",
+    true,
+    {
+      "value": 4
+    }
+  ]
+}
+```
+
+のように送信できます。
+
+### 引数なし RPC
+
+Request Body が空の場合は、引数なし RPC として扱われます。
+
+```http
+POST /__gasboost/noArgs
+```
+
+内部では次のように dispatch されます。
+
+```ts
+app.dispatch("noArgs");
+```
+
+明示的に送る場合は次でも構いません。
+
+```json
+{
+  "args": []
+}
+```
+
+## RPC Response
+
+`@gasboost/app` の `dispatch()` が返す `AppsScriptResponse.contents` を、そのまま HTTP Response Body として返します。
+
+例えば、
+
+```ts
+app.call("getUser", () => ({
+  id: 1,
+  name: "Taro",
+}));
+```
+
+に対するレスポンスは:
+
+```json
+{
+  "id": 1,
+  "name": "Taro"
+}
+```
+
+となります。
+
+Response の Content-Type は:
+
+```text
+application/json; charset=utf-8
+```
+
+です。
+
+## Async RPC
+
+非同期 RPC にも対応しています。
+
+```ts
+app.call("loadUser", async (id: string) => {
+  const user = await loadUser(id);
+
+  return user;
+});
+```
+
+dev plugin は `dispatch()` の完了を待ってからレスポンスを返します。
+
+## 開発中の module loading
+
+RPC リクエストごとに、指定された `entry` を Vite の `ssrLoadModule()` で読み込みます。
+
+```text
+POST /__gasboost/sum
+        ↓
+ssrLoadModule("src/server.ts")
+        ↓
+AppsScript.dispatch("sum", ...)
+```
+
+そのため、Vite Dev Server 上の最新のサーバーコードを利用して RPC を実行できます。
+
+## Error Response
+
+### 不正な Request Body
+
+JSON として不正な body や、`args` が配列でない body は `400` を返します。
+
+```json
+{
+  "args": "invalid"
+}
+```
+
+レスポンス例:
+
+```json
+{
+  "error": {
+    "name": "InvalidRpcRequestError",
+    "message": "Invalid RPC request body. Expected { args: unknown[] }."
+  }
+}
+```
+
+JSON 自体が不正な場合も `400` です。
+
+### POST 以外
+
+Local RPC endpoint は POST のみ受け付けます。
+
+```http
+GET /__gasboost/sum
+```
+
+は `405` になります。
+
+```json
+{
+  "error": {
+    "name": "MethodNotAllowedError",
+    "message": "Only POST is allowed."
+  }
+}
 ```
 
-`envDir: "config"` の場合、例えば以下が読み込まれます。
+### 未登録 RPC
+
+存在しない RPC を呼び出した場合は `500` を返します。
 
 ```text
-config/.env.production
+POST /__gasboost/unknown
 ```
 
-## 責務
+```json
+{
+  "error": {
+    "name": "Error",
+    "message": "Function unknown is not registered."
+  }
+}
+```
 
-`@gasboost/vite` はビルド時の処理のみを担当します。
+### Handler Error
 
-主な責務:
+RPC handler 内で例外が発生した場合も `500` として JSON で返されます。
 
-- `AppsScript` 登録内容の静的解析
-- Google Apps Script 向け Vite configuration
-- GAS グローバル関数宣言の生成
-- Vite 環境変数との統合
+```json
+{
+  "error": {
+    "name": "TypeError",
+    "message": "handler failed"
+  }
+}
+```
+
+## Local RPC の対象 path
 
-以下は担当しません。
+次の形式だけを RPC として扱います。
 
-- GET ハンドラの実行
-- POST ハンドラの実行
-- RPC dispatch
-- ハンドラ実体のランタイム登録
-- Google Apps Script API 自体の抽象化
+```text
+/__gasboost/{rpcName}
+```
+
+例えば以下は対象です。
+
+```text
+/__gasboost/getUser
+/__gasboost/sum
+```
+
+一方、次のような path は RPC として扱いません。
+
+```text
+/__gasboost/
+/__gasboost/foo/bar
+/api/users
+```
+
+通常の Vite middleware chain に処理を渡します。
+
+query string が付いていても RPC 名は正しく解決されます。
+
+```text
+/__gasboost/hello?foo=bar
+```
+
+URL encoded な RPC 名も decode されます。
+
+```text
+/__gasboost/hello%20world
+```
 
-これらの runtime responsibility は `@gasboost/app` が担当します。
+---
 
-## 現在の制約
+# build と dev の責務
 
-Analyzer は、意図的にシンプルな entry file 構造のみを対象としています。
+```text
+gasboost()
+   │
+   ├─ build
+   │    ├─ AppsScript の静的解析
+   │    ├─ GAS グローバル関数生成
+   │    ├─ GAS 向け build config
+   │    └─ backend production build
+   │
+   └─ dev
+        ├─ Vite Dev Server middleware
+        ├─ Local RPC endpoint
+        ├─ entry の ssrLoadModule
+        └─ AppsScript.dispatch
+```
 
-以下のような alias を介した default export は現在対象外です。
+frontend と backend を1つの `vite.config.ts` で扱う場合は、mode で分岐します。
 
 ```ts
-const app = new AppsScript();
-const exported = app;
+const { build, dev } = gasboost({
+  entry: "src/server.ts",
+});
 
-export default exported;
+export default defineConfig(({ mode }) => {
+  if (mode === "server") {
+    return {
+      plugins: [build],
+    };
+  }
+
+  return {
+    plugins: [dev],
+  };
+});
 ```
 
-別関数の内部に登録処理を隠す形式も対象外です。
+`build` を通常の frontend build に含めると、server entry が Vite の build input になるため、frontend と backend の build は分離してください。
+
+---
+
+## GAS ランタイム
+
+`@gasboost/vite` は、build 時と local RPC 実行時に server entry を実際に評価します。
+
+一般的な GAS API は、デフォルトのローカルランタイムから提供されます。
 
 ```ts
-registerHandlers(app);
+import { gasboost } from "@gasboost/vite";
+
+export default gasboost({
+  entry: "./src/server.ts",
+});
 ```
 
-別ファイルに登録処理を分散する形式も現在対象外です。
+entry の初期化時に追加の GAS API が必要な場合は、`runtime` から差し込めます。
 
 ```ts
-import { registerHandlers } from "./handlers";
+import { SpreadsheetAppStub } from "@gasboost/sheetorm";
+import { gasboost } from "@gasboost/vite";
 
-registerHandlers(app);
+export default gasboost({
+  entry: "./src/server.ts",
+  runtime: {
+    SpreadsheetApp: SpreadsheetAppStub,
+  },
+});
 ```
 
-登録内容を entry file から静的に確定できるようにすることで、生成する GAS グローバル関数を決定的にしています。
+`runtime` に渡した値は、デフォルトのローカルランタイムを上書きします。
+
+このランタイムは build 時の entry 評価と、local RPC 実行時の両方で利用されます。
+
+基本的には、module 初期化時に必要な API だけを差し込み、実際の GAS API 呼び出しは handler 実行時まで遅延させることを推奨します。
+
+## ランタイム解析
+
+GET / POST / RPC の登録状態は、entry ファイルを静的解析するのではなく、実際に評価された `AppsScript` インスタンスから取得します。
+
+そのため、import 先、ヘルパー関数、loop、`AppsScript.calls()` 経由の登録にも対応できます。
+
+```ts
+const app = new AppsScript();
+
+for (const [name, handler] of Object.entries(handlers)) {
+  app.call(name, handler);
+}
+
+export default app;
+```
 
 ## 関連パッケージ
 
-アプリケーションの runtime と handler registration には `@gasboost/app` を利用してください。
+- `@gasboost/app` — GAS バックエンドランタイムと RPC 定義
+- `@gasboost/client` — フロントエンド側の型安全 RPC クライアント
+
+## License
+
+MIT

package/dist/build.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "vite";
+import type { GasboostOptions } from "./gasboost";
+export declare function createBuildPlugin(options: GasboostOptions): Plugin;

package/dist/dev.d.ts

@@ -0,0 +1,3 @@
+import { type Plugin } from "vite";
+import type { GasboostOptions } from "./gasboost";
+export declare function createDevPlugin(options: GasboostOptions): Plugin;

package/dist/gasboost.d.ts

@@ -1,6 +1,11 @@
 import type { Plugin } from "vite";
+export type GasRuntime = Readonly<Record<string, unknown>>;
 export interface GasboostOptions {
     entry: string;
     envDir?: string;
+    runtime?: GasRuntime;
 }
-export declare function gasboost(options: GasboostOptions): Plugin;
+export declare function gasboost(options: GasboostOptions): {
+    build: Plugin;
+    dev: Plugin;
+};

package/dist/globals.d.ts

@@ -1,2 +1,2 @@
-import type { AppsScriptAnalysis } from "./analyzer";
-export declare function createGlobalCode(analysis: AppsScriptAnalysis): string;
+import type { AppsScriptDescription } from "@gasboost/app";
+export declare function createGlobalCode(analysis: AppsScriptDescription): string;

package/dist/index.js

@@ -1,91 +1,12 @@
-import e from "node:fs";
-import t from "node:path";
-import { isCallExpression as n, isIdentifier as r, isNewExpression as i, isPropertyAccessExpression as a, isStringLiteral as o, isVariableDeclaration as s } from "typescript/unstable/ast/is";
-import { createVirtualFileSystem as c } from "typescript/unstable/fs";
-import { API as l } from "typescript/unstable/sync";
-//#region src/analyzer.ts
-function u(r) {
-	let i = t.resolve(r);
-	if (!e.existsSync(i)) throw Error(`Entry file not found: ${i}`);
-	let s = d(i, e.readFileSync(i, "utf8")), c = f(s);
-	if (c.length === 0) throw Error("AppsScript instance not found.");
-	if (c.length > 1) throw Error("Multiple AppsScript instances found in entry.");
-	let l = c[0];
-	g(s, l);
-	let u = {
-		hasGet: !1,
-		hasPost: !1,
-		calls: []
-	}, p = /* @__PURE__ */ new Set();
-	function m(e) {
-		if (!a(e.expression)) return;
-		let t = e.expression, n = t.name.text;
-		if (!h(t.expression, l)) return;
-		if (n === "get") {
-			if (u.hasGet) throw Error("Duplicate GET handler registration.");
-			u.hasGet = !0;
-			return;
-		}
-		if (n === "post") {
-			if (u.hasPost) throw Error("Duplicate POST handler registration.");
-			u.hasPost = !0;
-			return;
-		}
-		if (n !== "call") return;
-		let r = e.arguments[0];
-		if (!r) throw Error(".call() requires a function name.");
-		if (!o(r)) throw Error(".call() function name must be a string literal.");
-		if (p.has(r.text)) throw Error(`Duplicate RPC registration: "${r.text}".`);
-		p.add(r.text), u.calls.unshift(r.text);
-	}
-	function _(e) {
-		n(e) && m(e), e.forEachChild(_);
-	}
-	return _(s), u;
-}
-function d(e, t) {
-	let n = "/entry.ts", r = "/tsconfig.json", i = c({
-		[r]: JSON.stringify({ files: [n] }),
-		[n]: t
-	}), a = new l({
-		cwd: "/",
-		fs: i
-	}).updateSnapshot({ openProject: r }).getProject(r);
-	if (!a) throw Error("Failed to create TypeScript project.");
-	let o = a.program.getSourceFile(n);
-	if (!o) throw Error(`Failed to parse entry: ${e}`);
-	return o;
-}
-function f(e) {
-	let t = [];
-	function n(e) {
-		s(e) && p(e) && t.push(e.name.text), e.forEachChild(n);
-	}
-	return n(e), t;
-}
-function p(e) {
-	return !r(e.name) || !e.initializer ? !1 : m(e.initializer);
-}
-function m(e) {
-	return i(e) && r(e.expression) && e.expression.text === "AppsScript" ? !0 : n(e) && a(e.expression) ? m(e.expression.expression) : !1;
-}
-function h(e, t) {
-	return r(e) && e.text === t || i(e) && r(e.expression) && e.expression.text === "AppsScript" ? !0 : n(e) && a(e.expression) ? h(e.expression.expression, t) : !1;
-}
-function g(e, t) {
-	let n = !1;
-	for (let r of e.statements) if (r.getText() === `export default ${t};`) {
-		n = !0;
-		break;
-	}
-	if (!n) throw Error("AppsScript instance must be default exported.");
-}
-//#endregion
+import e from "node:path";
+import { createServer as t, isRunnableDevEnvironment as n } from "vite";
+import { InMemoryCacheService as r, InMemoryContext as i, InMemoryPropertiesService as a, InMemorySession as o, SecurityPolicy as s } from "@gasboost/fake-core";
+import { NodeUtilities as c } from "@gasboost/fake-node";
 //#region src/config.ts
-function _(e) {
-	let n = t.resolve(e.entry);
+function l(t) {
+	let n = e.resolve(t.entry);
 	return {
-		envDir: e.envDir,
+		envDir: t.envDir,
 		build: {
 			target: "es2019",
 			outDir: "dist",
@@ -94,7 +15,7 @@ function _(e) {
 				input: n,
 				output: {
 					format: "cjs",
-					entryFileNames: t.basename(n, t.extname(n)) + ".js"
+					entryFileNames: e.basename(n, e.extname(n)) + ".js"
 				}
 			}
 		}
@@ -102,34 +23,169 @@ function _(e) {
 }
 //#endregion
 //#region src/globals.ts
-var v = /* @__PURE__ */ new Set(["doGet", "doPost"]);
-function y(e) {
-	if (v.has(e)) throw Error(`RPC name "${e}" is reserved by Google Apps Script.`);
+var u = /* @__PURE__ */ new Set(["doGet", "doPost"]);
+function d(e) {
+	if (u.has(e)) throw Error(`RPC name "${e}" is reserved by Google Apps Script.`);
 	if (!/^[$A-Z_a-z][$\w]*$/u.test(e)) throw Error(`RPC name "${e}" is not a valid JavaScript identifier.`);
 }
-function b(e) {
+function f(e) {
 	let t = [];
 	e.hasGet && t.push("function doGet() {}"), e.hasPost && t.push("function doPost() {}");
-	for (let n of e.calls) y(n), t.push(`function ${n}() {}`);
+	for (let n of e.calls) d(n), t.push(`function ${n}() {}`);
 	return t.join("\n");
 }
 //#endregion
-//#region src/gasboost.ts
-function x(e) {
-	let t;
+//#region src/runtime.ts
+var p = new i("", "", {
+	type: "WEB_APP",
+	executeAs: "USER"
+}, new s([]), "en", "UTC"), m = {
+	CacheService: new r(),
+	PropertiesService: new a(),
+	Session: new o(p),
+	Utilities: new c()
+};
+function h(e = {}) {
+	Object.assign(globalThis, {
+		...m,
+		...e
+	});
+}
+//#endregion
+//#region src/loadAppsScript.ts
+async function g(e, r) {
+	h(e.runtime);
+	let i = await t({
+		configFile: !1,
+		root: r.root,
+		mode: r.mode,
+		envDir: e.envDir,
+		appType: "custom",
+		ssr: { external: ["@gasboost/app"] },
+		server: {
+			middlewareMode: !0,
+			hmr: !1
+		}
+	});
+	try {
+		let t = i.environments.ssr;
+		if (!n(t)) throw Error("Vite SSR environment is not runnable.");
+		let r = await t.runner.import(e.entry);
+		if (!r.default) throw Error("AppsScript entry must have a default export.");
+		return r.default.describe();
+	} finally {
+		await i.close();
+	}
+}
+//#endregion
+//#region src/build.ts
+function _(e) {
+	let t, n;
 	return {
-		name: "gasboost",
+		name: "gasboost:build",
+		apply: "build",
 		config() {
-			return _(e);
+			return l(e);
+		},
+		configResolved(e) {
+			t = e;
 		},
-		buildStart() {
-			t = u(e.entry);
+		async buildStart() {
+			n = await g(e, t);
 		},
-		generateBundle(e, n) {
-			let r = b(t);
-			for (let e of Object.values(n)) e.type === "chunk" && e.isEntry && (e.code = `${r}\n\n${e.code}`);
+		generateBundle(e, t) {
+			let r = f(n);
+			for (let e of Object.values(t)) e.type === "chunk" && e.isEntry && (e.code = `${r}\n\n${e.code}`);
 		}
 	};
 }
 //#endregion
+//#region src/dev.ts
+var v = class extends Error {
+	constructor(e) {
+		super(e), this.name = "InvalidRpcRequestError";
+	}
+};
+function y(e) {
+	let { runtime: t } = e;
+	return {
+		name: "gasboost:dev",
+		apply: "serve",
+		configureServer(r) {
+			h(t), r.middlewares.use(async (t, i, a) => {
+				if (!t.url) {
+					a();
+					return;
+				}
+				let o = t.url.split("?")[0];
+				if (!o.startsWith("/__gasboost/")) {
+					a();
+					return;
+				}
+				let s = o.slice(12);
+				if (!s || s.includes("/")) {
+					a();
+					return;
+				}
+				if (t.method !== "POST") {
+					i.statusCode = 405, i.setHeader("Content-Type", "application/json; charset=utf-8"), i.end(JSON.stringify({ error: {
+						name: "MethodNotAllowedError",
+						message: "Only POST is allowed."
+					} }));
+					return;
+				}
+				try {
+					let { args: a } = await b(t), o = r.environments.ssr;
+					if (!n(o)) throw Error("Vite SSR environment is not runnable.");
+					let c = await (await o.runner.import(e.entry)).default.dispatch(decodeURIComponent(s), ...a);
+					i.statusCode = 200, i.setHeader("Content-Type", "application/json; charset=utf-8"), i.end(c.contents);
+				} catch (e) {
+					i.statusCode = e instanceof v ? 400 : 500, i.setHeader("Content-Type", "application/json; charset=utf-8"), i.end(JSON.stringify({ error: e instanceof Error ? {
+						name: e.name,
+						message: e.message,
+						stack: e.stack
+					} : {
+						name: "UnknownError",
+						message: String(e)
+					} }));
+				}
+			});
+		}
+	};
+}
+function b(e) {
+	return new Promise((t, n) => {
+		let r = [];
+		e.on("data", (e) => {
+			r.push(typeof e == "string" ? Buffer.from(e) : e);
+		}), e.on("error", n), e.on("end", () => {
+			let e = Buffer.concat(r).toString("utf-8");
+			if (!e) {
+				t({ args: [] });
+				return;
+			}
+			let i;
+			try {
+				i = JSON.parse(e);
+			} catch {
+				n(new v("Invalid RPC request body. Expected valid JSON."));
+				return;
+			}
+			if (typeof i != "object" || !i || !("args" in i) || !Array.isArray(i.args)) {
+				n(new v("Invalid RPC request body. Expected { args: unknown[] }."));
+				return;
+			}
+			t({ args: i.args });
+		});
+	});
+}
+//#endregion
+//#region src/gasboost.ts
+function x(e) {
+	return {
+		build: _(e),
+		dev: y(e)
+	};
+}
+//#endregion
 export { x as gasboost };

package/dist/loadAppsScript.d.ts

@@ -0,0 +1,4 @@
+import type { AppsScriptDescription } from "@gasboost/app";
+import { type ResolvedConfig } from "vite";
+import type { GasboostOptions } from "./gasboost";
+export declare function loadAppsScript(options: GasboostOptions, config: ResolvedConfig): Promise<AppsScriptDescription>;

package/dist/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { GasRuntime } from "./gasboost";
+export declare const defaultGasRuntime: GasRuntime;
+export declare function installGasRuntime(runtime?: GasRuntime): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gasboost/vite",
-  "version": "0.1.1",
+  "version": "1.1.0",
   "description": "A Vite plugin for building @gasboost/app applications for Google Apps Script.",
   "keywords": [
     "google-apps-script",
@@ -33,10 +33,14 @@
   },
   "type": "module",
   "devDependencies": {
+    "@types/google-apps-script": "^2.0.12",
     "vite": "^8.2.2"
   },
   "dependencies": {
-    "typescript": "^7.0.2"
+    "@gasboost/fake-core": "^0.1.2",
+    "@gasboost/fake-node": "^0.1.2",
+    "typescript": "^7.0.2",
+    "@gasboost/app": "1.3.0"
   },
   "publishConfig": {
     "access": "public"

package/dist/analyzer.d.ts

@@ -1,6 +0,0 @@
-export interface AppsScriptAnalysis {
-    hasGet: boolean;
-    hasPost: boolean;
-    calls: string[];
-}
-export declare function analyzeAppsScript(entry: string): AppsScriptAnalysis;