@playcademy/vite-plugin 0.1.25 → 0.1.26-alpha.1

package/dist/lib/backend/hot-reload.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Hot reload callbacks for backend server
+ */
+import type { ResolvedConfig } from 'vite';
+/**
+ * Creates hot reload callbacks for logging backend updates.
+ */
+export declare function createHotReloadCallbacks(viteConfig: ResolvedConfig): {
+    onSuccess: (changedPath?: string) => void;
+    onError: (error: unknown) => void;
+};

package/dist/lib/backend/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Backend server management
+ */
+export { setupCliDevServer } from './server';
+export { createHotReloadCallbacks } from './hot-reload';

package/dist/lib/{cli-server.d.ts → backend/server.d.ts}

@@ -1,4 +1,4 @@
-import type { CliDevServerOptions, CliServerManager } from '../types';
+import type { CliDevServerOptions, CliServerManager } from '../../types';
 /**
  * Sets up the CLI dev server with hot reload enabled.
  * Loads config, checks if backend is needed, and starts server if appropriate.

package/dist/lib/build/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Build-time utilities
+ */
+export { generatePlaycademyManifest, createOutputZipArchive, performPlaycademyLogging, } from './manifest';

package/dist/lib/{manifest.d.ts → build/manifest.d.ts}

@@ -2,7 +2,7 @@
  * Manifest generation and build output functionality
  */
 import type { ResolvedConfig } from 'vite';
-import type { ManifestOptions, PlaycademyOutputData } from '../types';
-export declare function generatePlaycademyManifest(config: ResolvedConfig, options: ManifestOptions, outDir: string, buildOutputs: PlaycademyOutputData): Promise<void>;
+import type { PlaycademyOutputData } from '../../types';
+export declare function generatePlaycademyManifest(config: ResolvedConfig, outDir: string, buildOutputs: PlaycademyOutputData): Promise<void>;
 export declare function createOutputZipArchive(config: ResolvedConfig, outDir: string, buildOutputs: PlaycademyOutputData): Promise<void>;
 export declare function performPlaycademyLogging(config: ResolvedConfig, buildOutputs: PlaycademyOutputData): void;

package/dist/lib/logging/adapter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Logger adapter for vite plugin
+ *
+ * Provides a logger interface that can be passed to sandbox and CLI dev server
+ * to ensure consistent Vite-style logging when servers are started by the plugin.
+ */
+/**
+ * Simple logger interface that sandbox and backend can accept
+ */
+export interface PluginLogger {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+}
+/**
+ * Creates a logger adapter that formats logs in Vite's style with [playcademy] prefix
+ * @param prefix - Prefix to add to all logs (e.g., 'backend', 'sandbox')
+ */
+export declare function createLoggerAdapter(prefix: string): PluginLogger;

package/dist/lib/logging/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Logging utilities
+ */
+export { createLoggerAdapter } from './adapter';
+export type { PluginLogger } from './adapter';
+export { log, printBanner } from './utils';

package/dist/lib/{logging.d.ts → logging/utils.d.ts}

@@ -1,5 +1,5 @@
 import type { ResolvedConfig } from 'vite';
-import type { ProjectInfo } from '../types';
+import type { ProjectInfo } from '../../types';
 /**
  * Centralized logging utilities for the Vite plugin.
  * Provides clear, prefixed, and color-coded output for multiple servers.
@@ -15,9 +15,9 @@ export declare const log: {
  * @param viteConfig - Vite resolved configuration
  * @param servers - Object containing port numbers for each server
  * @param projectInfo - Project information
- * @param sandboxVersion - Sandbox version string
+ * @param pluginVersion - Vite plugin version string
  */
 export declare function printBanner(viteConfig: ResolvedConfig, servers: {
     sandbox: number;
     backend?: number;
-}, projectInfo: ProjectInfo, sandboxVersion: string): void;
+}, projectInfo: ProjectInfo, pluginVersion: string): void;

package/dist/lib/sandbox/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sandbox server management
+ */
+export { startSandbox } from './server';
+export { extractProjectInfo } from './project-info';
+export { detectTimebackOptions } from './timeback';

package/dist/lib/sandbox/project-info.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Project information extraction for sandbox initialization
+ */
+import type { ResolvedConfig } from 'vite';
+import type { ProjectInfo } from '../../types';
+/**
+ * Extracts project information from playcademy.config and package.json
+ * Used to initialize sandbox with correct project metadata
+ */
+export declare function extractProjectInfo(viteConfig: ResolvedConfig): Promise<ProjectInfo>;

package/dist/lib/{sandbox.d.ts → sandbox/server.d.ts}

@@ -1,7 +1,8 @@
 import type { ResolvedConfig } from 'vite';
-import type { SandboxManager } from '../types';
+import type { SandboxManager } from '../../types';
 export declare function startSandbox(viteConfig: ResolvedConfig, autoStart?: boolean, options?: {
     verbose?: boolean;
     customUrl?: string;
     quiet?: boolean;
+    recreateDb?: boolean;
 }): Promise<SandboxManager>;

package/dist/lib/sandbox/timeback.d.ts

@@ -0,0 +1,11 @@
+/**
+ * TimeBack configuration detection from environment variables
+ */
+import type { TimebackConfig } from '@playcademy/sandbox/config';
+/**
+ * Auto-detect TimeBack configuration from environment variables
+ *
+ * Checks for local or remote TimeBack setup and returns appropriate config.
+ * Returns undefined if no TimeBack configuration is detected.
+ */
+export declare function detectTimebackOptions(): Partial<TimebackConfig> | undefined;

package/dist/plugin.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Main plugin factory
+ * Orchestrates all plugin hooks and manages plugin context
+ */
+import type { Plugin } from 'vite';
+import type { PlaycademyPluginOptions } from './types/options';
+/**
+ * Playcademy Vite Plugin
+ *
+ * Provides:
+ * - Auto-starting sandbox server during development
+ * - Hijacking dev server to serve Playcademy loader environment
+ * - Build-time manifest generation and optional zip packaging
+ */
+export declare function playcademy(options?: PlaycademyPluginOptions): Plugin;

package/dist/server/cleanup.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Server cleanup utilities
+ */
+/**
+ * Cleanup servers without exiting process (for Vite restarts)
+ */
+export declare function cleanupServers(): Promise<void>;

package/dist/server/lifecycle.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Process lifecycle management (SIGINT/SIGTERM handlers)
+ */
+/**
+ * Setup cleanup handlers for graceful process shutdown (SIGINT/SIGTERM)
+ * Only registers handlers once at module scope to avoid duplicates
+ */
+export declare function setupProcessShutdownHandlers(): void;

package/dist/server/platform-mode.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Platform mode server configuration
+ * Full Playcademy platform: sandbox + backend + shell wrapper
+ */
+import type { ResolvedConfig, ViteDevServer } from 'vite';
+export interface PlatformModeOptions {
+    startSandbox: boolean;
+    verbose: boolean;
+    sandboxUrl: string;
+    recreateDb: boolean;
+    showBadge: boolean;
+    preferredBackendPort: number;
+}
+/**
+ * Configure server in platform mode (sandbox + backend + shell)
+ */
+export declare function configurePlatformMode(server: ViteDevServer, viteConfig: ResolvedConfig, options: PlatformModeOptions): Promise<void>;

package/dist/server/standalone-mode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Standalone mode server configuration
+ * Backend only, no sandbox or shell wrapper
+ */
+import type { ResolvedConfig, ViteDevServer } from 'vite';
+/**
+ * Configure server in standalone mode (backend only, no sandbox or shell)
+ */
+export declare function configureStandaloneMode(server: ViteDevServer, viteConfig: ResolvedConfig, preferredPort: number): Promise<void>;

package/dist/server/state.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Module-level server state management
+ *
+ * Server references persist across Vite config reloads.
+ * When Vite restarts due to config changes, it creates a new plugin instance,
+ * but the servers continue running in the same Node process. We maintain
+ * these references at module scope to properly clean them up on restart.
+ */
+import type { CliServerManager, SandboxManager } from '../types';
+/**
+ * Module-level server references
+ */
+export declare const serverState: {
+    sandbox: SandboxManager | null;
+    backend: CliServerManager | null;
+};
+/**
+ * Get sandbox server reference
+ */
+export declare function getSandboxRef(): SandboxManager | null;
+/**
+ * Set sandbox server reference
+ */
+export declare function setSandboxRef(sandbox: SandboxManager | null): void;
+/**
+ * Get backend server reference
+ */
+export declare function getBackendRef(): CliServerManager | null;
+/**
+ * Set backend server reference
+ */
+export declare function setBackendRef(backend: CliServerManager | null): void;
+/**
+ * Check if any servers are currently running
+ */
+export declare function hasActiveServers(): boolean;

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Type exports for the Playcademy Vite Plugin
+ */
+export type { PlaycademyExportOptions, PlaycademySandboxOptions, PlaycademyShellOptions, PlaycademyPluginOptions, PlaycademyMode, } from './options';
+export type { ResolvedPluginOptions, PluginContext, PlaycademyOutputData, ProjectInfo, SandboxManager, CliServerManager, CliDevServerOptions, } from './internal';

package/dist/types/internal.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Internal plugin state and context types
+ */
+import type { ResolvedConfig } from 'vite';
+import type { PlaycademyMode } from './options';
+/**
+ * Internal resolved plugin options
+ */
+export interface ResolvedPluginOptions {
+    mode: PlaycademyMode;
+    autoZip: boolean;
+    sandboxUrl: string;
+    startSandbox: boolean;
+    verbose: boolean;
+    recreateDb: boolean;
+    showBadge: boolean;
+}
+/**
+ * Plugin context shared across hooks
+ */
+export interface PluginContext {
+    options: ResolvedPluginOptions;
+    viteConfig: ResolvedConfig | null;
+    backendPort: number | null;
+    buildOutputs: PlaycademyOutputData;
+}
+/**
+ * Build output data for logging and tracking
+ */
+export interface PlaycademyOutputData {
+    manifestPath?: string;
+    manifestSizeKb?: string;
+    zipPath?: string;
+    zipSizeKb?: string;
+}
+/**
+ * Project information extracted from package.json and directory structure
+ */
+export interface ProjectInfo {
+    slug: string;
+    displayName: string;
+    version: string;
+    description?: string;
+}
+/**
+ * Sandbox manager interface for controlling sandbox lifecycle
+ */
+export interface SandboxManager {
+    baseUrl: string;
+    realtimeUrl: string;
+    port: number;
+    project: ProjectInfo | null;
+    cleanup: () => void;
+}
+/**
+ * CLI server manager interface for controlling backend server lifecycle
+ */
+export interface CliServerManager {
+    server: {
+        dispose: () => Promise<void>;
+    };
+    port: number;
+    stopHotReload: () => void;
+    cleanup: () => void;
+}
+/**
+ * Options for setting up the CLI dev server
+ */
+export interface CliDevServerOptions {
+    preferredPort: number;
+    viteConfig: ResolvedConfig;
+    platformUrl?: string;
+}

package/dist/types/options.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Plugin configuration options
+ */
+/**
+ * Plugin operation mode
+ * - 'platform': Full Playcademy platform with sandbox + backend + shell wrapper (default)
+ * - 'standalone': Backend only, no sandbox or shell (for testing integrations)
+ */
+export type PlaycademyMode = 'platform' | 'standalone';
+/**
+ * Configuration options for exporting Playcademy games
+ */
+export interface PlaycademyExportOptions {
+    autoZip?: boolean;
+}
+/**
+ * Configuration options for the Playcademy sandbox server
+ */
+export interface PlaycademySandboxOptions {
+    autoStart?: boolean;
+    url?: string;
+    verbose?: boolean;
+    /**
+     * Recreate the sandbox database on each start
+     * @default false
+     */
+    recreateDb?: boolean;
+}
+/**
+ * Configuration options for the development shell wrapper
+ */
+export interface PlaycademyShellOptions {
+    /**
+     * Show the Playcademy badge in the corner during development
+     * @default true
+     */
+    showBadge?: boolean;
+}
+/**
+ * Main plugin configuration options
+ */
+export interface PlaycademyPluginOptions {
+    /**
+     * Plugin operation mode
+     * @default 'platform'
+     */
+    mode?: PlaycademyMode;
+    export?: PlaycademyExportOptions;
+    sandbox?: PlaycademySandboxOptions;
+    shell?: PlaycademyShellOptions;
+}

package/package.json

@@ -1,15 +1,11 @@
 {
     "name": "@playcademy/vite-plugin",
-    "version": "0.1.25",
+    "version": "0.1.26-alpha.1",
     "type": "module",
     "exports": {
         ".": {
             "import": "./dist/index.js",
             "types": "./dist/index.d.ts"
-        },
-        "./types": {
-            "import": "./dist/types.js",
-            "types": "./dist/types.d.ts"
         }
     },
     "main": "dist/index.js",
@@ -25,14 +21,13 @@
     "dependencies": {
         "archiver": "^7.0.1",
         "picocolors": "^1.1.1",
-        "playcademy": "0.14.2"
+        "playcademy": "0.14.3"
     },
     "devDependencies": {
         "@inquirer/prompts": "^7.8.6",
         "@playcademy/sandbox": "0.1.9",
         "@types/archiver": "^6.0.3",
-        "@types/bun": "latest",
-        "yocto-spinner": "^0.2.2"
+        "@types/bun": "latest"
     },
     "peerDependencies": {
         "typescript": "^5",

package/dist/types.d.ts

@@ -1,97 +0,0 @@
-/**
- * Type definitions for the Playcademy Vite Plugin
- */
-import type { ResolvedConfig } from 'vite';
-import type { ManifestV1 } from '@playcademy/data/types';
-/**
- * Project information extracted from package.json and directory structure
- */
-export interface ProjectInfo {
-    slug: string;
-    displayName: string;
-    version: string;
-    description?: string;
-}
-/**
- * Configuration options for exporting Playcademy games
- */
-export interface PlaycademyExportOptions {
-    bootMode?: ManifestV1['bootMode'];
-    entryPoint?: string;
-    styles?: string[];
-    platform?: ManifestV1['platform'];
-    autoZip?: boolean;
-}
-/**
- * Configuration options for the Playcademy sandbox server
- */
-export interface PlaycademySandboxOptions {
-    autoStart?: boolean;
-    url?: string;
-    verbose?: boolean;
-}
-/**
- * Configuration options for the dev server shell
- */
-export interface PlaycademyDevOptions {
-    /**
-     * Show the Playcademy badge in the corner during development
-     * @default true
-     */
-    showBadge?: boolean;
-}
-/**
- * Main plugin configuration options
- */
-export interface PlaycademyPluginOptions {
-    export?: PlaycademyExportOptions;
-    sandbox?: PlaycademySandboxOptions;
-    dev?: PlaycademyDevOptions;
-}
-/**
- * Build output data for logging and tracking
- */
-export interface PlaycademyOutputData {
-    manifestPath?: string;
-    manifestSizeKb?: string;
-    zipPath?: string;
-    zipSizeKb?: string;
-}
-/**
- * Options for manifest generation
- */
-export interface ManifestOptions {
-    bootMode: ManifestV1['bootMode'];
-    entryPoint: string;
-    styles: string[];
-    platform: ManifestV1['platform'];
-}
-/**
- * Sandbox manager interface for controlling sandbox lifecycle
- */
-export interface SandboxManager {
-    baseUrl: string;
-    realtimeUrl: string;
-    port: number;
-    project: ProjectInfo | null;
-    cleanup: () => void;
-}
-/**
- * CLI server manager interface for controlling backend server lifecycle
- */
-export interface CliServerManager {
-    server: {
-        dispose: () => Promise<void>;
-    };
-    port: number;
-    stopHotReload: () => void;
-    cleanup: () => void;
-}
-/**
- * Options for setting up the CLI dev server
- */
-export interface CliDevServerOptions {
-    preferredPort: number;
-    viteConfig: ResolvedConfig;
-    platformUrl?: string;
-}

package/dist/utils.d.ts

@@ -1,7 +0,0 @@
-/**
- * Utility functions for the Playcademy Vite plugin
- */
-import type { ResolvedConfig } from 'vite';
-import type { ProjectInfo } from './types';
-export declare function extractProjectInfo(viteConfig: ResolvedConfig): ProjectInfo;
-export declare function formatNumberWithCommas(numStr: string): string;