@playcademy/vite-plugin 0.0.1-beta.8 → 0.0.1-beta.9

package/dist/index.js

@@ -94242,8 +94242,8 @@ var DEMO_USER = {
   email: "demo@playcademy.com",
   emailVerified: true,
   image: null,
-  role: "player",
-  developerStatus: "none",
+  role: "developer",
+  developerStatus: "approved",
   createdAt: now,
   updatedAt: now
 };
@@ -113959,6 +113959,8 @@ __export(exports_schemas, {
   verification: () => verification,
   users: () => users,
   userRoleEnum: () => userRoleEnum,
+  userLevelsRelations: () => userLevelsRelations,
+  userLevels: () => userLevels,
   shopListingsRelations: () => shopListingsRelations,
   shopListings: () => shopListings,
   sessions: () => sessions,
@@ -113966,6 +113968,7 @@ __export(exports_schemas, {
   maps: () => maps,
   mapElementsRelations: () => mapElementsRelations,
   mapElements: () => mapElements,
+  levelConfigs: () => levelConfigs,
   itemsRelations: () => itemsRelations,
   items: () => items,
   itemTypeEnum: () => itemTypeEnum,
@@ -113982,11 +113985,14 @@ __export(exports_schemas, {
   currenciesRelations: () => currenciesRelations,
   currencies: () => currencies,
   accounts: () => accounts,
+  XPActionInputSchema: () => XPActionInputSchema,
   VersionSchema: () => VersionSchema,
   UpsertGameMetadataSchema: () => UpsertGameMetadataSchema,
   UpdateUserSchema: () => UpdateUserSchema,
+  UpdateUserLevelSchema: () => UpdateUserLevelSchema,
   UpdateShopListingSchema: () => UpdateShopListingSchema,
   UpdateMapElementSchema: () => UpdateMapElementSchema,
+  UpdateLevelConfigSchema: () => UpdateLevelConfigSchema,
   UpdateItemSchema: () => UpdateItemSchema,
   UpdateInventoryItemSchema: () => UpdateInventoryItemSchema,
   UpdateGameStateSchema: () => UpdateGameStateSchema,
@@ -113997,10 +114003,12 @@ __export(exports_schemas, {
   StartSessionInputSchema: () => StartSessionInputSchema,
   SelectVerificationSchema: () => SelectVerificationSchema,
   SelectUserSchema: () => SelectUserSchema,
+  SelectUserLevelSchema: () => SelectUserLevelSchema,
   SelectShopListingSchema: () => SelectShopListingSchema,
   SelectSessionSchema: () => SelectSessionSchema,
   SelectMapSchema: () => SelectMapSchema,
   SelectMapElementSchema: () => SelectMapElementSchema,
+  SelectLevelConfigSchema: () => SelectLevelConfigSchema,
   SelectItemSchema: () => SelectItemSchema,
   SelectInventoryItemSchema: () => SelectInventoryItemSchema,
   SelectGameStateSchema: () => SelectGameStateSchema,
@@ -114012,13 +114020,16 @@ __export(exports_schemas, {
   ProcessZipSchema: () => ProcessZipSchema,
   MapElementMetadataZodSchema: () => MapElementMetadataZodSchema,
   ManifestV1Schema: () => ManifestV1Schema,
+  MAX_LEVEL: () => MAX_LEVEL,
   ItemMetadataSchema: () => ItemMetadataSchema,
   InventoryActionInputSchema: () => InventoryActionInputSchema,
   InsertVerificationSchema: () => InsertVerificationSchema,
   InsertUserSchema: () => InsertUserSchema,
+  InsertUserLevelSchema: () => InsertUserLevelSchema,
   InsertShopListingSchema: () => InsertShopListingSchema,
   InsertSessionSchema: () => InsertSessionSchema,
   InsertMapElementSchema: () => InsertMapElementSchema,
+  InsertLevelConfigSchema: () => InsertLevelConfigSchema,
   InsertItemSchema: () => InsertItemSchema,
   InsertInventoryItemSchema: () => InsertInventoryItemSchema,
   InsertGameStateSchema: () => InsertGameStateSchema,
@@ -118773,6 +118784,53 @@ var InsertShopListingSchema = createInsertSchema(shopListings, {
 }).omit({ id: true, createdAt: true, updatedAt: true });
 var SelectShopListingSchema = createSelectSchema(shopListings);
 var UpdateShopListingSchema = InsertShopListingSchema.partial().extend({});
+var MAX_LEVEL = 100;
+var userLevels = pgTable("user_levels", {
+  userId: text("user_id").primaryKey().references(() => users.id, { onDelete: "cascade" }),
+  currentLevel: integer("current_level").notNull().default(1),
+  currentXp: integer("current_xp").notNull().default(0),
+  totalXpEarned: integer("total_xp_earned").notNull().default(0),
+  lastLevelUpAt: timestamp("last_level_up_at", { withTimezone: true }),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
+});
+var levelConfigs = pgTable("level_configs", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  level: integer("level").notNull().unique(),
+  xpRequired: integer("xp_required").notNull(),
+  creditsReward: integer("credits_reward").notNull().default(0),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table6) => [uniqueIndex("unique_level_config_idx").on(table6.level)]);
+var userLevelsRelations = relations(userLevels, ({ one }) => ({
+  user: one(users, {
+    fields: [userLevels.userId],
+    references: [users.id]
+  })
+}));
+var InsertUserLevelSchema = createInsertSchema(userLevels, {
+  userId: exports_external.string().min(1, "User ID is required"),
+  currentLevel: exports_external.number().int().min(1, "Level must be at least 1").default(1),
+  currentXp: exports_external.number().int().min(0, "XP cannot be negative").default(0),
+  totalXpEarned: exports_external.number().int().min(0, "Total XP earned cannot be negative").default(0)
+}).omit({ createdAt: true, updatedAt: true });
+var SelectUserLevelSchema = createSelectSchema(userLevels);
+var UpdateUserLevelSchema = createUpdateSchema(userLevels).omit({
+  userId: true,
+  createdAt: true
+});
+var InsertLevelConfigSchema = createInsertSchema(levelConfigs, {
+  level: exports_external.number().int().min(1, "Level must be at least 1"),
+  xpRequired: exports_external.number().int().min(0, "XP required cannot be negative"),
+  creditsReward: exports_external.number().int().min(0, "Credits reward cannot be negative").default(0)
+}).omit({ id: true, createdAt: true });
+var SelectLevelConfigSchema = createSelectSchema(levelConfigs);
+var UpdateLevelConfigSchema = createUpdateSchema(levelConfigs).omit({
+  id: true,
+  createdAt: true
+});
+var XPActionInputSchema = exports_external.object({
+  amount: exports_external.number().int("XP amount must be an integer").positive("XP amount must be positive")
+});
 
 class DatabasePathManager {
   static DEFAULT_DB_SUBPATH = join2("@playcademy", "vite-plugin", "node_modules", ".playcademy", "sandbox.db");
@@ -118845,12 +118903,35 @@ async function seedDemoData(db) {
     for (const inventory2 of SAMPLE_INVENTORY) {
       await db.insert(inventoryItems).values(inventory2);
     }
+    const levelConfigsData = generateLevelConfigs();
+    for (const config of levelConfigsData) {
+      await db.insert(levelConfigs).values(config);
+    }
   } catch (error2) {
     console.error("❌ Error seeding demo data:", error2);
     throw error2;
   }
   return DEMO_USER;
 }
+function generateLevelConfigs() {
+  const configs = [];
+  for (let level = 1;level <= 100; level++) {
+    const xpRequired = level === 1 ? 0 : Math.floor(50 * Math.pow(level - 1, 1.7));
+    let creditsReward = 0;
+    if (level > 1) {
+      creditsReward = 25 + level * 25;
+      if (level % 10 === 1 && level > 1) {
+        creditsReward += 75;
+      }
+    }
+    configs.push({
+      level,
+      xpRequired,
+      creditsReward
+    });
+  }
+  return configs;
+}
 async function seedCurrentProjectGame(db, project) {
   const now2 = new Date;
   try {
@@ -118984,6 +119065,267 @@ async function getUserMe(ctx) {
     throw ApiError.internal("Internal server error", error2);
   }
 }
+var levelConfigCache = null;
+async function getLevelConfig(db, level) {
+  if (level < 1) {
+    throw ApiError.badRequest("Level must be at least 1");
+  }
+  if (levelConfigCache?.has(level)) {
+    return levelConfigCache.get(level) || null;
+  }
+  try {
+    const [config] = await db.select().from(levelConfigs).where(eq(levelConfigs.level, level)).limit(1);
+    if (levelConfigCache && config) {
+      levelConfigCache.set(level, config);
+    }
+    return config || null;
+  } catch (error2) {
+    logger2.error(`Error fetching level config for level ${level}:`, error2);
+    throw ApiError.internal("Internal server error", error2);
+  }
+}
+async function calculateXPToNextLevel(db, currentLevel, currentXp) {
+  try {
+    const nextLevelConfig = await getLevelConfig(db, currentLevel + 1);
+    if (!nextLevelConfig) {
+      return 0;
+    }
+    return Math.max(0, nextLevelConfig.xpRequired - currentXp);
+  } catch (error2) {
+    logger2.error(`Error calculating XP to next level:`, error2);
+    throw ApiError.internal("Internal server error", error2);
+  }
+}
+async function checkLevelUp(tx, currentLevel, newXp) {
+  let level = currentLevel;
+  let remainingXp = newXp;
+  let totalCreditsAwarded = 0;
+  let leveledUp = false;
+  while (true) {
+    if (level >= MAX_LEVEL) {
+      break;
+    }
+    const nextLevelConfig2 = await tx.select().from(levelConfigs).where(eq(levelConfigs.level, level + 1)).limit(1);
+    const [nextLevel2] = nextLevelConfig2;
+    if (!nextLevel2) {
+      break;
+    }
+    if (remainingXp >= nextLevel2.xpRequired) {
+      level += 1;
+      remainingXp -= nextLevel2.xpRequired;
+      totalCreditsAwarded += nextLevel2.creditsReward;
+      leveledUp = true;
+    } else {
+      break;
+    }
+  }
+  const nextLevelConfig = await tx.select().from(levelConfigs).where(eq(levelConfigs.level, level + 1)).limit(1);
+  const [nextLevel] = nextLevelConfig;
+  const xpToNextLevel = nextLevel ? Math.max(0, nextLevel.xpRequired - remainingXp) : 0;
+  return {
+    newLevel: level,
+    remainingXp,
+    leveledUp,
+    creditsAwarded: totalCreditsAwarded,
+    xpToNextLevel
+  };
+}
+function formatValidationErrors(error2) {
+  const flattened = error2.flatten();
+  const fieldErrors = Object.entries(flattened.fieldErrors).map(([field, errors2]) => `${field}: ${errors2?.join(", ") || "Invalid"}`).join("; ");
+  const formErrors = flattened.formErrors.join("; ");
+  const allErrors = [fieldErrors, formErrors].filter(Boolean).join("; ");
+  return allErrors || "Validation failed";
+}
+var AddXPSchema = XPActionInputSchema;
+async function getUserLevel(ctx) {
+  const user = ctx.user;
+  if (!user) {
+    throw ApiError.unauthorized("Valid session or bearer token required");
+  }
+  try {
+    const db = getDatabase();
+    let [userLevel] = await db.select().from(userLevels).where(eq(userLevels.userId, user.id)).limit(1);
+    if (!userLevel) {
+      const [newUserLevel] = await db.insert(userLevels).values({
+        userId: user.id,
+        currentLevel: 1,
+        currentXp: 0,
+        totalXpEarned: 0
+      }).returning();
+      if (!newUserLevel) {
+        throw ApiError.internal("Failed to create user level record");
+      }
+      userLevel = newUserLevel;
+    }
+    return userLevel;
+  } catch (error2) {
+    if (error2 instanceof ApiError) {
+      throw error2;
+    }
+    logger2.error(`Error fetching user level for user ${user.id}:`, error2);
+    throw ApiError.internal("Internal server error", error2);
+  }
+}
+async function addXP(ctx, amount) {
+  const user = ctx.user;
+  if (!user) {
+    throw ApiError.unauthorized("Valid session or bearer token required");
+  }
+  if (user.role !== "developer") {
+    throw ApiError.forbidden("Only developers can award XP to users");
+  }
+  if (amount <= 0) {
+    throw ApiError.badRequest("XP amount must be positive");
+  }
+  try {
+    const db = getDatabase();
+    const result = await db.transaction(async (tx) => {
+      let [userLevel] = await tx.select().from(userLevels).where(eq(userLevels.userId, user.id)).limit(1);
+      if (!userLevel) {
+        const [newUserLevel] = await tx.insert(userLevels).values({
+          userId: user.id,
+          currentLevel: 1,
+          currentXp: 0,
+          totalXpEarned: 0
+        }).returning();
+        if (!newUserLevel) {
+          throw ApiError.internal("Failed to create user level record");
+        }
+        userLevel = newUserLevel;
+      }
+      const newCurrentXp = userLevel.currentXp + amount;
+      const newTotalXpEarned = userLevel.totalXpEarned + amount;
+      const levelUpResult = await checkLevelUp(tx, userLevel.currentLevel, newCurrentXp);
+      const [updatedUserLevel] = await tx.update(userLevels).set({
+        currentLevel: levelUpResult.newLevel,
+        currentXp: levelUpResult.remainingXp,
+        totalXpEarned: newTotalXpEarned,
+        lastLevelUpAt: levelUpResult.leveledUp ? new Date : userLevel.lastLevelUpAt
+      }).where(eq(userLevels.userId, user.id)).returning();
+      if (!updatedUserLevel) {
+        throw ApiError.internal("Failed to update user level");
+      }
+      let creditsAwarded = 0;
+      if (levelUpResult.leveledUp) {
+        const creditsToAward = levelUpResult.creditsAwarded;
+        logger2.debug("User leveled up", {
+          userId: user.id,
+          oldLevel: userLevel.currentLevel,
+          newLevel: levelUpResult.newLevel,
+          xpAdded: amount,
+          totalXpEarned: newTotalXpEarned,
+          creditsAwarded: creditsToAward
+        });
+        if (creditsToAward > 0) {
+          const [creditsItem] = await tx.select({ id: items.id }).from(items).where(eq(items.internalName, "PLAYCADEMY_CREDITS")).limit(1);
+          if (!creditsItem) {
+            throw ApiError.internal("PLAYCADEMY_CREDITS item not found");
+          }
+          await tx.insert(inventoryItems).values({
+            userId: user.id,
+            itemId: creditsItem.id,
+            quantity: creditsToAward
+          }).onConflictDoUpdate({
+            target: [
+              inventoryItems.userId,
+              inventoryItems.itemId
+            ],
+            set: {
+              quantity: sql`${inventoryItems.quantity} + ${creditsToAward}`
+            }
+          });
+        }
+        creditsAwarded = creditsToAward;
+      } else {
+        logger2.debug("XP added to user", {
+          userId: user.id,
+          level: userLevel.currentLevel,
+          xpAdded: amount,
+          totalXpEarned: newTotalXpEarned
+        });
+      }
+      return {
+        totalXpEarned: newTotalXpEarned,
+        newLevel: levelUpResult.newLevel,
+        leveledUp: levelUpResult.leveledUp,
+        creditsAwarded,
+        xpToNextLevel: levelUpResult.xpToNextLevel
+      };
+    });
+    return result;
+  } catch (error2) {
+    if (error2 instanceof ApiError) {
+      throw error2;
+    }
+    logger2.error(`Error adding XP for user ${user.id}:`, error2);
+    throw ApiError.internal("Internal server error", error2);
+  }
+}
+async function addXPFromRequest(ctx) {
+  let amount;
+  try {
+    const requestBody = await ctx.request.json();
+    const parsed = AddXPSchema.parse(requestBody);
+    amount = parsed.amount;
+  } catch (error2) {
+    if (error2 instanceof ZodError) {
+      throw ApiError.badRequest(`Validation failed: ${formatValidationErrors(error2)}`);
+    }
+    logger2.error("Failed to parse request body:", error2);
+    throw ApiError.badRequest("Invalid JSON body");
+  }
+  return await addXP(ctx, amount);
+}
+async function getAllLevelConfigs(_ctx) {
+  try {
+    const db = getDatabase();
+    const configs = await db.select().from(levelConfigs).orderBy(levelConfigs.level);
+    return configs;
+  } catch (error2) {
+    logger2.error("Error fetching all level configs:", error2);
+    throw ApiError.internal("Internal server error", error2);
+  }
+}
+async function getUserLevelProgress(ctx) {
+  const userLevel = await getUserLevel(ctx);
+  try {
+    const db = getDatabase();
+    const xpToNextLevel = await calculateXPToNextLevel(db, userLevel.currentLevel, userLevel.currentXp);
+    return {
+      level: userLevel.currentLevel,
+      currentXp: userLevel.currentXp,
+      xpToNextLevel,
+      totalXpEarned: userLevel.totalXpEarned
+    };
+  } catch (error2) {
+    if (error2 instanceof ApiError) {
+      throw error2;
+    }
+    logger2.error(`Error fetching user level progress:`, error2);
+    throw ApiError.internal("Internal server error", error2);
+  }
+}
+async function getLevelConfigByPath(ctx) {
+  const levelParam = ctx.params.level;
+  if (!levelParam) {
+    throw ApiError.badRequest("Level parameter is required");
+  }
+  const level = parseInt(levelParam, 10);
+  if (isNaN(level) || level < 1) {
+    throw ApiError.badRequest("Level must be a positive integer");
+  }
+  try {
+    const db = getDatabase();
+    return await getLevelConfig(db, level);
+  } catch (error2) {
+    if (error2 instanceof ApiError) {
+      throw error2;
+    }
+    logger2.error(`Error fetching level config for level ${level}:`, error2);
+    throw ApiError.internal("Internal server error", error2);
+  }
+}
 var usersRouter = new Hono2;
 usersRouter.get("/me", async (c2) => {
   const ctx = {
@@ -119004,15 +119346,65 @@ usersRouter.get("/me", async (c2) => {
     return c2.json({ error: message }, 500);
   }
 });
+usersRouter.get("/level", async (c2) => {
+  const ctx = {
+    user: c2.get("user"),
+    params: {},
+    url: new URL(c2.req.url),
+    request: c2.req.raw
+  };
+  try {
+    const levelData = await getUserLevel(ctx);
+    return c2.json(levelData);
+  } catch (error2) {
+    if (error2 instanceof ApiError) {
+      return c2.json({ error: error2.message }, error2.statusCode);
+    }
+    console.error("Error in getUserLevel:", error2);
+    const message = error2 instanceof Error ? error2.message : "Internal server error";
+    return c2.json({ error: message }, 500);
+  }
+});
+usersRouter.get("/level/progress", async (c2) => {
+  const ctx = {
+    user: c2.get("user"),
+    params: {},
+    url: new URL(c2.req.url),
+    request: c2.req.raw
+  };
+  try {
+    const progressData = await getUserLevelProgress(ctx);
+    return c2.json(progressData);
+  } catch (error2) {
+    if (error2 instanceof ApiError) {
+      return c2.json({ error: error2.message }, error2.statusCode);
+    }
+    console.error("Error in getUserLevelProgress:", error2);
+    const message = error2 instanceof Error ? error2.message : "Internal server error";
+    return c2.json({ error: message }, 500);
+  }
+});
+usersRouter.post("/xp/add", async (c2) => {
+  const ctx = {
+    user: c2.get("user"),
+    params: {},
+    url: new URL(c2.req.url),
+    request: c2.req.raw
+  };
+  try {
+    const result = await addXPFromRequest(ctx);
+    return c2.json(result);
+  } catch (error2) {
+    if (error2 instanceof ApiError) {
+      return c2.json({ error: error2.message }, error2.statusCode);
+    }
+    console.error("Error in addXPFromRequest:", error2);
+    const message = error2 instanceof Error ? error2.message : "Internal server error";
+    return c2.json({ error: message }, 500);
+  }
+});
 var healthRouter = new Hono2;
 healthRouter.get("/", (c2) => c2.json({ status: "ok", timestamp: new Date().toISOString() }));
-function formatValidationErrors(error2) {
-  const flattened = error2.flatten();
-  const fieldErrors = Object.entries(flattened.fieldErrors).map(([field, errors2]) => `${field}: ${errors2?.join(", ") || "Invalid"}`).join("; ");
-  const formErrors = flattened.formErrors.join("; ");
-  const allErrors = [fieldErrors, formErrors].filter(Boolean).join("; ");
-  return allErrors || "Validation failed";
-}
 async function getUserInventory(ctx) {
   const user = ctx.user;
   if (!user) {
@@ -123133,6 +123525,45 @@ devRouter.delete("/keys/:keyId", async (c2) => {
     return c2.json({ error: message2 }, 500);
   }
 });
+var levelsRouter = new Hono2;
+levelsRouter.get("/config", async (c2) => {
+  const ctx = {
+    user: c2.get("user"),
+    params: {},
+    url: new URL(c2.req.url),
+    request: c2.req.raw
+  };
+  try {
+    const configs = await getAllLevelConfigs(ctx);
+    return c2.json(configs);
+  } catch (error2) {
+    if (error2 instanceof ApiError) {
+      return c2.json({ error: error2.message }, error2.statusCode);
+    }
+    console.error("Error in getAllLevelConfigs:", error2);
+    const message2 = error2 instanceof Error ? error2.message : "Internal server error";
+    return c2.json({ error: message2 }, 500);
+  }
+});
+levelsRouter.get("/config/:level", async (c2) => {
+  const ctx = {
+    user: c2.get("user"),
+    params: { level: c2.req.param("level") },
+    url: new URL(c2.req.url),
+    request: c2.req.raw
+  };
+  try {
+    const config = await getLevelConfigByPath(ctx);
+    return c2.json(config);
+  } catch (error2) {
+    if (error2 instanceof ApiError) {
+      return c2.json({ error: error2.message }, error2.statusCode);
+    }
+    console.error("Error in getLevelConfigByPath:", error2);
+    const message2 = error2 instanceof Error ? error2.message : "Internal server error";
+    return c2.json({ error: message2 }, 500);
+  }
+});
 async function startServer(options) {
   const { port, verbose, project } = options;
   configureLogger(verbose ? "debug" : "error");
@@ -123158,6 +123589,7 @@ async function startServer(options) {
   app.route("/api/maps", mapsRouter);
   app.route("/api/shop-listings", shopListingsRouter);
   app.route("/api/dev", devRouter);
+  app.route("/api/levels", levelsRouter);
   return serve({ fetch: app.fetch, port });
 }
 var version3 = package_default.version;
@@ -123225,10 +123657,10 @@ function printSandboxInfo(viteConfig, availablePort, projectInfo) {
   viteConfig.logger.info(`  ${import_picocolors.default.green("➜")}  ${import_picocolors.default.bold("Sandbox:")} ${import_picocolors.default.cyan(`http://localhost:${import_picocolors.default.bold(availablePort.toString())}/api`)}`);
   viteConfig.logger.info("");
 }
-async function startSandbox(viteConfig, autoStart = true, verbose = false) {
+async function startSandbox(viteConfig, autoStart = true, verbose = false, customUrl) {
   if (!autoStart || viteConfig.command !== "serve") {
     return {
-      url: "http://localhost:4321/api",
+      url: customUrl ?? "http://localhost:4321/api",
       project: null,
       cleanup: () => {}
     };
@@ -123609,7 +124041,7 @@ function playcademy(options = {}) {
     platform: exportOptions.platform ?? "web",
     autoZip: exportOptions.autoZip ?? false,
     sandboxUrl: sandboxOptions.url ?? "http://localhost:4321/api",
-    startSandbox: sandboxOptions.autoStart ?? true,
+    startSandbox: sandboxOptions.url ? false : sandboxOptions.autoStart ?? true,
     verbose: sandboxOptions.verbose ?? false
   };
   return {
@@ -123622,7 +124054,7 @@ function playcademy(options = {}) {
       currentBuildOutputs = {};
     },
     async configureServer(server) {
-      const sandbox = await startSandbox(viteConfig, _options.startSandbox, _options.verbose);
+      const sandbox = await startSandbox(viteConfig, _options.startSandbox, _options.verbose, _options.sandboxUrl);
       sandboxCleanup = sandbox.cleanup;
       if (sandbox.project) {
         devServerMiddleware(server, sandbox.url, sandbox.project);

package/dist/lib/sandbox.d.ts

@@ -5,5 +5,5 @@ interface SandboxManager {
     project: ProjectInfo | null;
     cleanup: () => void;
 }
-export declare function startSandbox(viteConfig: ResolvedConfig, autoStart?: boolean, verbose?: boolean): Promise<SandboxManager>;
+export declare function startSandbox(viteConfig: ResolvedConfig, autoStart?: boolean, verbose?: boolean, customUrl?: string): Promise<SandboxManager>;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@playcademy/vite-plugin",
     "type": "module",
-    "version": "0.0.1-beta.8",
+    "version": "0.0.1-beta.9",
     "main": "dist/index.js",
     "module": "dist/index.js",
     "exports": {