Log level + onimportcss

Former-commit-id: 12ba9b9bc288573e3a5099adfa14c486c4cc980c

15 files changed, 2927 insertions, 2987 deletions

diff --git a/src/api/schema.d.ts b/src/api/schema.d.ts
index 39ba7fa82..666a0cbce 100644
--- a/src/api/schema.d.ts
+++ b/src/api/schema.d.ts
@@ -1,4 +1,4 @@
-import type { ByteBuffer } from "peechy";
+import type {ByteBuffer} from "peechy";
 
 type byte = number;
 type float = number;
@@ -12,661 +12,526 @@ type int32 = number;
 type float32 = number;
 type uint16 = number;
 type uint32 = number;
-export enum Loader {
-  jsx = 1,
-  js = 2,
-  ts = 3,
-  tsx = 4,
-  css = 5,
-  file = 6,
-  json = 7,
-}
-export const LoaderKeys = {
-  1: "jsx",
-  jsx: "jsx",
-  2: "js",
-  js: "js",
-  3: "ts",
-  ts: "ts",
-  4: "tsx",
-  tsx: "tsx",
-  5: "css",
-  css: "css",
-  6: "file",
-  file: "file",
-  7: "json",
-  json: "json",
-};
-export enum ResolveMode {
-  disable = 1,
-  lazy = 2,
-  dev = 3,
-  bundle = 4,
-}
-export const ResolveModeKeys = {
-  1: "disable",
-  disable: "disable",
-  2: "lazy",
-  lazy: "lazy",
-  3: "dev",
-  dev: "dev",
-  4: "bundle",
-  bundle: "bundle",
-};
-export enum Platform {
-  browser = 1,
-  node = 2,
-  bun = 3,
-}
-export const PlatformKeys = {
-  1: "browser",
-  browser: "browser",
-  2: "node",
-  node: "node",
-  3: "bun",
-  bun: "bun",
-};
-export enum JSXRuntime {
-  automatic = 1,
-  classic = 2,
-}
-export const JSXRuntimeKeys = {
-  1: "automatic",
-  automatic: "automatic",
-  2: "classic",
-  classic: "classic",
-};
-export enum ScanDependencyMode {
-  app = 1,
-  all = 2,
-}
-export const ScanDependencyModeKeys = {
-  1: "app",
-  app: "app",
-  2: "all",
-  all: "all",
-};
-export enum ModuleImportType {
-  import = 1,
-  require = 2,
-}
-export const ModuleImportTypeKeys = {
-  1: "import",
-  import: "import",
-  2: "require",
-  require: "require",
-};
-export enum DotEnvBehavior {
-  disable = 1,
-  prefix = 2,
-  load_all = 3,
-}
-export const DotEnvBehaviorKeys = {
-  1: "disable",
-  disable: "disable",
-  2: "prefix",
-  prefix: "prefix",
-  3: "load_all",
-  load_all: "load_all",
-};
-export enum TransformResponseStatus {
-  success = 1,
-  fail = 2,
-}
-export const TransformResponseStatusKeys = {
-  1: "success",
-  success: "success",
-  2: "fail",
-  fail: "fail",
-};
-export enum MessageKind {
-  err = 1,
-  warn = 2,
-  note = 3,
-  debug = 4,
-}
-export const MessageKindKeys = {
-  1: "err",
-  err: "err",
-  2: "warn",
-  warn: "warn",
-  3: "note",
-  note: "note",
-  4: "debug",
-  debug: "debug",
-};
-export enum Reloader {
-  disable = 1,
-  live = 2,
-  fast_refresh = 3,
-}
-export const ReloaderKeys = {
-  1: "disable",
-  disable: "disable",
-  2: "live",
-  live: "live",
-  3: "fast_refresh",
-  fast_refresh: "fast_refresh",
-};
-export enum WebsocketMessageKind {
-  welcome = 1,
-  file_change_notification = 2,
-  build_success = 3,
-  build_fail = 4,
-  manifest_success = 5,
-  manifest_fail = 6,
-}
-export const WebsocketMessageKindKeys = {
-  1: "welcome",
-  welcome: "welcome",
-  2: "file_change_notification",
-  file_change_notification: "file_change_notification",
-  3: "build_success",
-  build_success: "build_success",
-  4: "build_fail",
-  build_fail: "build_fail",
-  5: "manifest_success",
-  manifest_success: "manifest_success",
-  6: "manifest_fail",
-  manifest_fail: "manifest_fail",
-};
-export enum WebsocketCommandKind {
-  build = 1,
-  manifest = 2,
-}
-export const WebsocketCommandKindKeys = {
-  1: "build",
-  build: "build",
-  2: "manifest",
-  manifest: "manifest",
-};
-export interface JSX {
-  factory: string;
-  runtime: JSXRuntime;
-  fragment: string;
-  development: boolean;
-  import_source: string;
-  react_fast_refresh: boolean;
-}
-
-export interface StringPointer {
-  offset: uint32;
-  length: uint32;
-}
-
-export interface JavascriptBundledModule {
-  path: StringPointer;
-  code: StringPointer;
-  package_id: uint32;
-  id: uint32;
-  path_extname_length: byte;
-}
-
-export interface JavascriptBundledPackage {
-  name: StringPointer;
-  version: StringPointer;
-  hash: uint32;
-  modules_offset: uint32;
-  modules_length: uint32;
-}
-
-export interface JavascriptBundle {
-  modules: JavascriptBundledModule[];
-  packages: JavascriptBundledPackage[];
-  etag: Uint8Array;
-  generated_at: uint32;
-  app_package_json_dependencies_hash: Uint8Array;
-  import_from_name: Uint8Array;
-  manifest_string: Uint8Array;
-}
-
-export interface JavascriptBundleContainer {
-  bundle_format_version?: uint32;
-  bundle?: JavascriptBundle;
-  framework?: LoadedFramework;
-  routes?: LoadedRouteConfig;
-  code_length?: uint32;
-}
-
-export interface ModuleImportRecord {
-  kind: ModuleImportType;
-  path: string;
-  dynamic: boolean;
-}
-
-export interface Module {
-  path: string;
-  imports: ModuleImportRecord[];
-}
-
-export interface StringMap {
-  keys: string[];
-  values: string[];
-}
-
-export interface LoaderMap {
-  extensions: string[];
-  loaders: Loader[];
-}
-
-export interface EnvConfig {
-  prefix?: string;
-  defaults?: StringMap;
-}
-
-export interface LoadedEnvConfig {
-  dotenv: DotEnvBehavior;
-  defaults: StringMap;
-  prefix: string;
-}
-
-export interface FrameworkConfig {
-  package?: string;
-  client?: string;
-  server?: string;
-  development?: boolean;
-  client_env?: EnvConfig;
-  server_env?: EnvConfig;
-}
-
-export interface LoadedFramework {
-  entry_point: string;
-  package: string;
-  development: boolean;
-  client: boolean;
-  env: LoadedEnvConfig;
-}
-
-export interface LoadedRouteConfig {
-  dir: string;
-  extensions: string[];
-  static_dir: string;
-  asset_prefix: string;
-}
-
-export interface RouteConfig {
-  dir?: string[];
-  extensions?: string[];
-  static_dir?: string;
-  asset_prefix?: string;
-}
-
-export interface TransformOptions {
-  jsx?: JSX;
-  tsconfig_override?: string;
-  resolve?: ResolveMode;
-  origin?: string;
-  absolute_working_dir?: string;
-  define?: StringMap;
-  preserve_symlinks?: boolean;
-  entry_points?: string[];
-  write?: boolean;
-  inject?: string[];
-  output_dir?: string;
-  external?: string[];
-  loaders?: LoaderMap;
-  main_fields?: string[];
-  platform?: Platform;
-  serve?: boolean;
-  extension_order?: string[];
-  generate_node_module_bundle?: boolean;
-  node_modules_bundle_path?: string;
-  node_modules_bundle_path_server?: string;
-  framework?: FrameworkConfig;
-  router?: RouteConfig;
-}
-
-export interface FileHandle {
-  path: string;
-  size: uint;
-  fd: uint;
-}
-
-export interface Transform {
-  handle?: FileHandle;
-  path?: string;
-  contents?: Uint8Array;
-  loader?: Loader;
-  options?: TransformOptions;
-}
-
-export interface OutputFile {
-  data: Uint8Array;
-  path: string;
-}
-
-export interface TransformResponse {
-  status: TransformResponseStatus;
-  files: OutputFile[];
-  errors: Message[];
-}
-
-export interface Location {
-  file: string;
-  namespace: string;
-  line: int32;
-  column: int32;
-  line_text: string;
-  suggestion: string;
-  offset: uint;
-}
-
-export interface MessageData {
-  text?: string;
-  location?: Location;
-}
-
-export interface Message {
-  kind: MessageKind;
-  data: MessageData;
-  notes: MessageData[];
-}
-
-export interface Log {
-  warnings: uint32;
-  errors: uint32;
-  msgs: Message[];
-}
-
-export interface WebsocketMessage {
-  timestamp: uint32;
-  kind: WebsocketMessageKind;
-}
-
-export interface WebsocketMessageWelcome {
-  epoch: uint32;
-  javascriptReloader: Reloader;
-}
-
-export interface WebsocketMessageFileChangeNotification {
-  id: uint32;
-  loader: Loader;
-}
-
-export interface WebsocketCommand {
-  kind: WebsocketCommandKind;
-  timestamp: uint32;
-}
-
-export interface WebsocketCommandBuild {
-  id: uint32;
-}
-
-export interface WebsocketCommandManifest {
-  id: uint32;
-}
-
-export interface WebsocketMessageBuildSuccess {
-  id: uint32;
-  from_timestamp: uint32;
-  loader: Loader;
-  module_path: string;
-  blob_length: uint32;
-}
-
-export interface WebsocketMessageBuildFailure {
-  id: uint32;
-  from_timestamp: uint32;
-  loader: Loader;
-  module_path: string;
-  log: Log;
-}
-
-export interface DependencyManifest {
-  ids: Uint32Array;
-}
-
-export interface FileList {
-  ptrs: StringPointer[];
-  files: string;
-}
-
-export interface WebsocketMessageResolveIDs {
-  id: Uint32Array;
-  list: FileList;
-}
-
-export interface WebsocketCommandResolveIDs {
-  ptrs: StringPointer[];
-  files: string;
-}
-
-export interface WebsocketMessageManifestSuccess {
-  id: uint32;
-  module_path: string;
-  loader: Loader;
-  manifest: DependencyManifest;
-}
-
-export interface WebsocketMessageManifestFailure {
-  id: uint32;
-  from_timestamp: uint32;
-  loader: Loader;
-  log: Log;
-}
-
-export declare function encodeJSX(message: JSX, bb: ByteBuffer): void;
-export declare function decodeJSX(buffer: ByteBuffer): JSX;
-export declare function encodeStringPointer(
-  message: StringPointer,
-  bb: ByteBuffer
-): void;
-export declare function decodeStringPointer(buffer: ByteBuffer): StringPointer;
-export declare function encodeJavascriptBundledModule(
-  message: JavascriptBundledModule,
-  bb: ByteBuffer
-): void;
-export declare function decodeJavascriptBundledModule(
-  buffer: ByteBuffer
-): JavascriptBundledModule;
-export declare function encodeJavascriptBundledPackage(
-  message: JavascriptBundledPackage,
-  bb: ByteBuffer
-): void;
-export declare function decodeJavascriptBundledPackage(
-  buffer: ByteBuffer
-): JavascriptBundledPackage;
-export declare function encodeJavascriptBundle(
-  message: JavascriptBundle,
-  bb: ByteBuffer
-): void;
-export declare function decodeJavascriptBundle(
-  buffer: ByteBuffer
-): JavascriptBundle;
-export declare function encodeJavascriptBundleContainer(
-  message: JavascriptBundleContainer,
-  bb: ByteBuffer
-): void;
-export declare function decodeJavascriptBundleContainer(
-  buffer: ByteBuffer
-): JavascriptBundleContainer;
-export declare function encodeModuleImportRecord(
-  message: ModuleImportRecord,
-  bb: ByteBuffer
-): void;
-export declare function decodeModuleImportRecord(
-  buffer: ByteBuffer
-): ModuleImportRecord;
-export declare function encodeModule(message: Module, bb: ByteBuffer): void;
-export declare function decodeModule(buffer: ByteBuffer): Module;
-export declare function encodeStringMap(
-  message: StringMap,
-  bb: ByteBuffer
-): void;
-export declare function decodeStringMap(buffer: ByteBuffer): StringMap;
-export declare function encodeLoaderMap(
-  message: LoaderMap,
-  bb: ByteBuffer
-): void;
-export declare function decodeLoaderMap(buffer: ByteBuffer): LoaderMap;
-export declare function encodeEnvConfig(
-  message: EnvConfig,
-  bb: ByteBuffer
-): void;
-export declare function decodeEnvConfig(buffer: ByteBuffer): EnvConfig;
-export declare function encodeLoadedEnvConfig(
-  message: LoadedEnvConfig,
-  bb: ByteBuffer
-): void;
-export declare function decodeLoadedEnvConfig(
-  buffer: ByteBuffer
-): LoadedEnvConfig;
-export declare function encodeFrameworkConfig(
-  message: FrameworkConfig,
-  bb: ByteBuffer
-): void;
-export declare function decodeFrameworkConfig(
-  buffer: ByteBuffer
-): FrameworkConfig;
-export declare function encodeLoadedFramework(
-  message: LoadedFramework,
-  bb: ByteBuffer
-): void;
-export declare function decodeLoadedFramework(
-  buffer: ByteBuffer
-): LoadedFramework;
-export declare function encodeLoadedRouteConfig(
-  message: LoadedRouteConfig,
-  bb: ByteBuffer
-): void;
-export declare function decodeLoadedRouteConfig(
-  buffer: ByteBuffer
-): LoadedRouteConfig;
-export declare function encodeRouteConfig(
-  message: RouteConfig,
-  bb: ByteBuffer
-): void;
-export declare function decodeRouteConfig(buffer: ByteBuffer): RouteConfig;
-export declare function encodeTransformOptions(
-  message: TransformOptions,
-  bb: ByteBuffer
-): void;
-export declare function decodeTransformOptions(
-  buffer: ByteBuffer
-): TransformOptions;
-export declare function encodeFileHandle(
-  message: FileHandle,
-  bb: ByteBuffer
-): void;
-export declare function decodeFileHandle(buffer: ByteBuffer): FileHandle;
-export declare function encodeTransform(
-  message: Transform,
-  bb: ByteBuffer
-): void;
-export declare function decodeTransform(buffer: ByteBuffer): Transform;
-export declare function encodeOutputFile(
-  message: OutputFile,
-  bb: ByteBuffer
-): void;
-export declare function decodeOutputFile(buffer: ByteBuffer): OutputFile;
-export declare function encodeTransformResponse(
-  message: TransformResponse,
-  bb: ByteBuffer
-): void;
-export declare function decodeTransformResponse(
-  buffer: ByteBuffer
-): TransformResponse;
-export declare function encodeLocation(message: Location, bb: ByteBuffer): void;
-export declare function decodeLocation(buffer: ByteBuffer): Location;
-export declare function encodeMessageData(
-  message: MessageData,
-  bb: ByteBuffer
-): void;
-export declare function decodeMessageData(buffer: ByteBuffer): MessageData;
-export declare function encodeMessage(message: Message, bb: ByteBuffer): void;
-export declare function decodeMessage(buffer: ByteBuffer): Message;
-export declare function encodeLog(message: Log, bb: ByteBuffer): void;
-export declare function decodeLog(buffer: ByteBuffer): Log;
-export declare function encodeWebsocketMessage(
-  message: WebsocketMessage,
-  bb: ByteBuffer
-): void;
-export declare function decodeWebsocketMessage(
-  buffer: ByteBuffer
-): WebsocketMessage;
-export declare function encodeWebsocketMessageWelcome(
-  message: WebsocketMessageWelcome,
-  bb: ByteBuffer
-): void;
-export declare function decodeWebsocketMessageWelcome(
-  buffer: ByteBuffer
-): WebsocketMessageWelcome;
-export declare function encodeWebsocketMessageFileChangeNotification(
-  message: WebsocketMessageFileChangeNotification,
-  bb: ByteBuffer
-): void;
-export declare function decodeWebsocketMessageFileChangeNotification(
-  buffer: ByteBuffer
-): WebsocketMessageFileChangeNotification;
-export declare function encodeWebsocketCommand(
-  message: WebsocketCommand,
-  bb: ByteBuffer
-): void;
-export declare function decodeWebsocketCommand(
-  buffer: ByteBuffer
-): WebsocketCommand;
-export declare function encodeWebsocketCommandBuild(
-  message: WebsocketCommandBuild,
-  bb: ByteBuffer
-): void;
-export declare function decodeWebsocketCommandBuild(
-  buffer: ByteBuffer
-): WebsocketCommandBuild;
-export declare function encodeWebsocketCommandManifest(
-  message: WebsocketCommandManifest,
-  bb: ByteBuffer
-): void;
-export declare function decodeWebsocketCommandManifest(
-  buffer: ByteBuffer
-): WebsocketCommandManifest;
-export declare function encodeWebsocketMessageBuildSuccess(
-  message: WebsocketMessageBuildSuccess,
-  bb: ByteBuffer
-): void;
-export declare function decodeWebsocketMessageBuildSuccess(
-  buffer: ByteBuffer
-): WebsocketMessageBuildSuccess;
-export declare function encodeWebsocketMessageBuildFailure(
-  message: WebsocketMessageBuildFailure,
-  bb: ByteBuffer
-): void;
-export declare function decodeWebsocketMessageBuildFailure(
-  buffer: ByteBuffer
-): WebsocketMessageBuildFailure;
-export declare function encodeDependencyManifest(
-  message: DependencyManifest,
-  bb: ByteBuffer
-): void;
-export declare function decodeDependencyManifest(
-  buffer: ByteBuffer
-): DependencyManifest;
-export declare function encodeFileList(message: FileList, bb: ByteBuffer): void;
-export declare function decodeFileList(buffer: ByteBuffer): FileList;
-export declare function encodeWebsocketMessageResolveIDs(
-  message: WebsocketMessageResolveIDs,
-  bb: ByteBuffer
-): void;
-export declare function decodeWebsocketMessageResolveIDs(
-  buffer: ByteBuffer
-): WebsocketMessageResolveIDs;
-export declare function encodeWebsocketCommandResolveIDs(
-  message: WebsocketCommandResolveIDs,
-  bb: ByteBuffer
-): void;
-export declare function decodeWebsocketCommandResolveIDs(
-  buffer: ByteBuffer
-): WebsocketCommandResolveIDs;
-export declare function encodeWebsocketMessageManifestSuccess(
-  message: WebsocketMessageManifestSuccess,
-  bb: ByteBuffer
-): void;
-export declare function decodeWebsocketMessageManifestSuccess(
-  buffer: ByteBuffer
-): WebsocketMessageManifestSuccess;
-export declare function encodeWebsocketMessageManifestFailure(
-  message: WebsocketMessageManifestFailure,
-  bb: ByteBuffer
-): void;
-export declare function decodeWebsocketMessageManifestFailure(
-  buffer: ByteBuffer
-): WebsocketMessageManifestFailure;
+  export enum Loader {
+    jsx = 1,
+    js = 2,
+    ts = 3,
+    tsx = 4,
+    css = 5,
+    file = 6,
+    json = 7
+  }
+  export const LoaderKeys = {
+    1: "jsx",
+    jsx: "jsx",
+    2: "js",
+    js: "js",
+    3: "ts",
+    ts: "ts",
+    4: "tsx",
+    tsx: "tsx",
+    5: "css",
+    css: "css",
+    6: "file",
+    file: "file",
+    7: "json",
+    json: "json"
+  }
+  export enum ResolveMode {
+    disable = 1,
+    lazy = 2,
+    dev = 3,
+    bundle = 4
+  }
+  export const ResolveModeKeys = {
+    1: "disable",
+    disable: "disable",
+    2: "lazy",
+    lazy: "lazy",
+    3: "dev",
+    dev: "dev",
+    4: "bundle",
+    bundle: "bundle"
+  }
+  export enum Platform {
+    browser = 1,
+    node = 2,
+    bun = 3
+  }
+  export const PlatformKeys = {
+    1: "browser",
+    browser: "browser",
+    2: "node",
+    node: "node",
+    3: "bun",
+    bun: "bun"
+  }
+  export enum CSSInJSBehavior {
+    facade = 1,
+    facade_onimportcss = 2
+  }
+  export const CSSInJSBehaviorKeys = {
+    1: "facade",
+    facade: "facade",
+    2: "facade_onimportcss",
+    facade_onimportcss: "facade_onimportcss"
+  }
+  export enum JSXRuntime {
+    automatic = 1,
+    classic = 2
+  }
+  export const JSXRuntimeKeys = {
+    1: "automatic",
+    automatic: "automatic",
+    2: "classic",
+    classic: "classic"
+  }
+  export enum ScanDependencyMode {
+    app = 1,
+    all = 2
+  }
+  export const ScanDependencyModeKeys = {
+    1: "app",
+    app: "app",
+    2: "all",
+    all: "all"
+  }
+  export enum ModuleImportType {
+    import = 1,
+    require = 2
+  }
+  export const ModuleImportTypeKeys = {
+    1: "import",
+    import: "import",
+    2: "require",
+    require: "require"
+  }
+  export enum DotEnvBehavior {
+    disable = 1,
+    prefix = 2,
+    load_all = 3
+  }
+  export const DotEnvBehaviorKeys = {
+    1: "disable",
+    disable: "disable",
+    2: "prefix",
+    prefix: "prefix",
+    3: "load_all",
+    load_all: "load_all"
+  }
+  export enum TransformResponseStatus {
+    success = 1,
+    fail = 2
+  }
+  export const TransformResponseStatusKeys = {
+    1: "success",
+    success: "success",
+    2: "fail",
+    fail: "fail"
+  }
+  export enum MessageKind {
+    err = 1,
+    warn = 2,
+    note = 3,
+    debug = 4
+  }
+  export const MessageKindKeys = {
+    1: "err",
+    err: "err",
+    2: "warn",
+    warn: "warn",
+    3: "note",
+    note: "note",
+    4: "debug",
+    debug: "debug"
+  }
+  export enum Reloader {
+    disable = 1,
+    live = 2,
+    fast_refresh = 3
+  }
+  export const ReloaderKeys = {
+    1: "disable",
+    disable: "disable",
+    2: "live",
+    live: "live",
+    3: "fast_refresh",
+    fast_refresh: "fast_refresh"
+  }
+  export enum WebsocketMessageKind {
+    welcome = 1,
+    file_change_notification = 2,
+    build_success = 3,
+    build_fail = 4,
+    manifest_success = 5,
+    manifest_fail = 6
+  }
+  export const WebsocketMessageKindKeys = {
+    1: "welcome",
+    welcome: "welcome",
+    2: "file_change_notification",
+    file_change_notification: "file_change_notification",
+    3: "build_success",
+    build_success: "build_success",
+    4: "build_fail",
+    build_fail: "build_fail",
+    5: "manifest_success",
+    manifest_success: "manifest_success",
+    6: "manifest_fail",
+    manifest_fail: "manifest_fail"
+  }
+  export enum WebsocketCommandKind {
+    build = 1,
+    manifest = 2
+  }
+  export const WebsocketCommandKindKeys = {
+    1: "build",
+    build: "build",
+    2: "manifest",
+    manifest: "manifest"
+  }
+  export interface JSX {
+    factory: string;
+    runtime: JSXRuntime;
+    fragment: string;
+    development: boolean;
+    import_source: string;
+    react_fast_refresh: boolean;
+  }
+
+  export interface StringPointer {
+    offset: uint32;
+    length: uint32;
+  }
+
+  export interface JavascriptBundledModule {
+    path: StringPointer;
+    code: StringPointer;
+    package_id: uint32;
+    id: uint32;
+    path_extname_length: byte;
+  }
+
+  export interface JavascriptBundledPackage {
+    name: StringPointer;
+    version: StringPointer;
+    hash: uint32;
+    modules_offset: uint32;
+    modules_length: uint32;
+  }
+
+  export interface JavascriptBundle {
+    modules: JavascriptBundledModule[];
+    packages: JavascriptBundledPackage[];
+    etag: Uint8Array;
+    generated_at: uint32;
+    app_package_json_dependencies_hash: Uint8Array;
+    import_from_name: Uint8Array;
+    manifest_string: Uint8Array;
+  }
+
+  export interface JavascriptBundleContainer {
+    bundle_format_version?: uint32;
+    bundle?: JavascriptBundle;
+    framework?: LoadedFramework;
+    routes?: LoadedRouteConfig;
+    code_length?: uint32;
+  }
+
+  export interface ModuleImportRecord {
+    kind: ModuleImportType;
+    path: string;
+    dynamic: boolean;
+  }
+
+  export interface Module {
+    path: string;
+    imports: ModuleImportRecord[];
+  }
+
+  export interface StringMap {
+    keys: string[];
+    values: string[];
+  }
+
+  export interface LoaderMap {
+    extensions: string[];
+    loaders: Loader[];
+  }
+
+  export interface EnvConfig {
+    prefix?: string;
+    defaults?: StringMap;
+  }
+
+  export interface LoadedEnvConfig {
+    dotenv: DotEnvBehavior;
+    defaults: StringMap;
+    prefix: string;
+  }
+
+  export interface FrameworkConfig {
+    package?: string;
+    client?: string;
+    server?: string;
+    development?: boolean;
+    client_env?: EnvConfig;
+    server_env?: EnvConfig;
+    client_css_in_js?: CSSInJSBehavior;
+  }
+
+  export interface LoadedFramework {
+    entry_point: string;
+    package: string;
+    development: boolean;
+    client: boolean;
+    env: LoadedEnvConfig;
+    client_css_in_js: CSSInJSBehavior;
+  }
+
+  export interface LoadedRouteConfig {
+    dir: string;
+    extensions: string[];
+    static_dir: string;
+    asset_prefix: string;
+  }
+
+  export interface RouteConfig {
+    dir?: string[];
+    extensions?: string[];
+    static_dir?: string;
+    asset_prefix?: string;
+  }
+
+  export interface TransformOptions {
+    jsx?: JSX;
+    tsconfig_override?: string;
+    resolve?: ResolveMode;
+    origin?: string;
+    absolute_working_dir?: string;
+    define?: StringMap;
+    preserve_symlinks?: boolean;
+    entry_points?: string[];
+    write?: boolean;
+    inject?: string[];
+    output_dir?: string;
+    external?: string[];
+    loaders?: LoaderMap;
+    main_fields?: string[];
+    platform?: Platform;
+    serve?: boolean;
+    extension_order?: string[];
+    generate_node_module_bundle?: boolean;
+    node_modules_bundle_path?: string;
+    node_modules_bundle_path_server?: string;
+    framework?: FrameworkConfig;
+    router?: RouteConfig;
+  }
+
+  export interface FileHandle {
+    path: string;
+    size: uint;
+    fd: uint;
+  }
+
+  export interface Transform {
+    handle?: FileHandle;
+    path?: string;
+    contents?: Uint8Array;
+    loader?: Loader;
+    options?: TransformOptions;
+  }
+
+  export interface OutputFile {
+    data: Uint8Array;
+    path: string;
+  }
+
+  export interface TransformResponse {
+    status: TransformResponseStatus;
+    files: OutputFile[];
+    errors: Message[];
+  }
+
+  export interface Location {
+    file: string;
+    namespace: string;
+    line: int32;
+    column: int32;
+    line_text: string;
+    suggestion: string;
+    offset: uint;
+  }
+
+  export interface MessageData {
+    text?: string;
+    location?: Location;
+  }
+
+  export interface Message {
+    kind: MessageKind;
+    data: MessageData;
+    notes: MessageData[];
+  }
+
+  export interface Log {
+    warnings: uint32;
+    errors: uint32;
+    msgs: Message[];
+  }
+
+  export interface WebsocketMessage {
+    timestamp: uint32;
+    kind: WebsocketMessageKind;
+  }
+
+  export interface WebsocketMessageWelcome {
+    epoch: uint32;
+    javascriptReloader: Reloader;
+  }
+
+  export interface WebsocketMessageFileChangeNotification {
+    id: uint32;
+    loader: Loader;
+  }
+
+  export interface WebsocketCommand {
+    kind: WebsocketCommandKind;
+    timestamp: uint32;
+  }
+
+  export interface WebsocketCommandBuild {
+    id: uint32;
+  }
+
+  export interface WebsocketCommandManifest {
+    id: uint32;
+  }
+
+  export interface WebsocketMessageBuildSuccess {
+    id: uint32;
+    from_timestamp: uint32;
+    loader: Loader;
+    module_path: string;
+    blob_length: uint32;
+  }
+
+  export interface WebsocketMessageBuildFailure {
+    id: uint32;
+    from_timestamp: uint32;
+    loader: Loader;
+    module_path: string;
+    log: Log;
+  }
+
+  export interface DependencyManifest {
+    ids: Uint32Array;
+  }
+
+  export interface FileList {
+    ptrs: StringPointer[];
+    files: string;
+  }
+
+  export interface WebsocketMessageResolveIDs {
+    id: Uint32Array;
+    list: FileList;
+  }
+
+  export interface WebsocketCommandResolveIDs {
+    ptrs: StringPointer[];
+    files: string;
+  }
+
+  export interface WebsocketMessageManifestSuccess {
+    id: uint32;
+    module_path: string;
+    loader: Loader;
+    manifest: DependencyManifest;
+  }
+
+  export interface WebsocketMessageManifestFailure {
+    id: uint32;
+    from_timestamp: uint32;
+    loader: Loader;
+    log: Log;
+  }
+
+  export declare function  encodeJSX(message: JSX, bb: ByteBuffer): void;
+  export declare function decodeJSX(buffer: ByteBuffer): JSX;
+  export declare function  encodeStringPointer(message: StringPointer, bb: ByteBuffer): void;
+  export declare function decodeStringPointer(buffer: ByteBuffer): StringPointer;
+  export declare function  encodeJavascriptBundledModule(message: JavascriptBundledModule, bb: ByteBuffer): void;
+  export declare function decodeJavascriptBundledModule(buffer: ByteBuffer): JavascriptBundledModule;
+  export declare function  encodeJavascriptBundledPackage(message: JavascriptBundledPackage, bb: ByteBuffer): void;
+  export declare function decodeJavascriptBundledPackage(buffer: ByteBuffer): JavascriptBundledPackage;
+  export declare function  encodeJavascriptBundle(message: JavascriptBundle, bb: ByteBuffer): void;
+  export declare function decodeJavascriptBundle(buffer: ByteBuffer): JavascriptBundle;
+  export declare function  encodeJavascriptBundleContainer(message: JavascriptBundleContainer, bb: ByteBuffer): void;
+  export declare function decodeJavascriptBundleContainer(buffer: ByteBuffer): JavascriptBundleContainer;
+  export declare function  encodeModuleImportRecord(message: ModuleImportRecord, bb: ByteBuffer): void;
+  export declare function decodeModuleImportRecord(buffer: ByteBuffer): ModuleImportRecord;
+  export declare function  encodeModule(message: Module, bb: ByteBuffer): void;
+  export declare function decodeModule(buffer: ByteBuffer): Module;
+  export declare function  encodeStringMap(message: StringMap, bb: ByteBuffer): void;
+  export declare function decodeStringMap(buffer: ByteBuffer): StringMap;
+  export declare function  encodeLoaderMap(message: LoaderMap, bb: ByteBuffer): void;
+  export declare function decodeLoaderMap(buffer: ByteBuffer): LoaderMap;
+  export declare function  encodeEnvConfig(message: EnvConfig, bb: ByteBuffer): void;
+  export declare function decodeEnvConfig(buffer: ByteBuffer): EnvConfig;
+  export declare function  encodeLoadedEnvConfig(message: LoadedEnvConfig, bb: ByteBuffer): void;
+  export declare function decodeLoadedEnvConfig(buffer: ByteBuffer): LoadedEnvConfig;
+  export declare function  encodeFrameworkConfig(message: FrameworkConfig, bb: ByteBuffer): void;
+  export declare function decodeFrameworkConfig(buffer: ByteBuffer): FrameworkConfig;
+  export declare function  encodeLoadedFramework(message: LoadedFramework, bb: ByteBuffer): void;
+  export declare function decodeLoadedFramework(buffer: ByteBuffer): LoadedFramework;
+  export declare function  encodeLoadedRouteConfig(message: LoadedRouteConfig, bb: ByteBuffer): void;
+  export declare function decodeLoadedRouteConfig(buffer: ByteBuffer): LoadedRouteConfig;
+  export declare function  encodeRouteConfig(message: RouteConfig, bb: ByteBuffer): void;
+  export declare function decodeRouteConfig(buffer: ByteBuffer): RouteConfig;
+  export declare function  encodeTransformOptions(message: TransformOptions, bb: ByteBuffer): void;
+  export declare function decodeTransformOptions(buffer: ByteBuffer): TransformOptions;
+  export declare function  encodeFileHandle(message: FileHandle, bb: ByteBuffer): void;
+  export declare function decodeFileHandle(buffer: ByteBuffer): FileHandle;
+  export declare function  encodeTransform(message: Transform, bb: ByteBuffer): void;
+  export declare function decodeTransform(buffer: ByteBuffer): Transform;
+  export declare function  encodeOutputFile(message: OutputFile, bb: ByteBuffer): void;
+  export declare function decodeOutputFile(buffer: ByteBuffer): OutputFile;
+  export declare function  encodeTransformResponse(message: TransformResponse, bb: ByteBuffer): void;
+  export declare function decodeTransformResponse(buffer: ByteBuffer): TransformResponse;
+  export declare function  encodeLocation(message: Location, bb: ByteBuffer): void;
+  export declare function decodeLocation(buffer: ByteBuffer): Location;
+  export declare function  encodeMessageData(message: MessageData, bb: ByteBuffer): void;
+  export declare function decodeMessageData(buffer: ByteBuffer): MessageData;
+  export declare function  encodeMessage(message: Message, bb: ByteBuffer): void;
+  export declare function decodeMessage(buffer: ByteBuffer): Message;
+  export declare function  encodeLog(message: Log, bb: ByteBuffer): void;
+  export declare function decodeLog(buffer: ByteBuffer): Log;
+  export declare function  encodeWebsocketMessage(message: WebsocketMessage, bb: ByteBuffer): void;
+  export declare function decodeWebsocketMessage(buffer: ByteBuffer): WebsocketMessage;
+  export declare function  encodeWebsocketMessageWelcome(message: WebsocketMessageWelcome, bb: ByteBuffer): void;
+  export declare function decodeWebsocketMessageWelcome(buffer: ByteBuffer): WebsocketMessageWelcome;
+  export declare function  encodeWebsocketMessageFileChangeNotification(message: WebsocketMessageFileChangeNotification, bb: ByteBuffer): void;
+  export declare function decodeWebsocketMessageFileChangeNotification(buffer: ByteBuffer): WebsocketMessageFileChangeNotification;
+  export declare function  encodeWebsocketCommand(message: WebsocketCommand, bb: ByteBuffer): void;
+  export declare function decodeWebsocketCommand(buffer: ByteBuffer): WebsocketCommand;
+  export declare function  encodeWebsocketCommandBuild(message: WebsocketCommandBuild, bb: ByteBuffer): void;
+  export declare function decodeWebsocketCommandBuild(buffer: ByteBuffer): WebsocketCommandBuild;
+  export declare function  encodeWebsocketCommandManifest(message: WebsocketCommandManifest, bb: ByteBuffer): void;
+  export declare function decodeWebsocketCommandManifest(buffer: ByteBuffer): WebsocketCommandManifest;
+  export declare function  encodeWebsocketMessageBuildSuccess(message: WebsocketMessageBuildSuccess, bb: ByteBuffer): void;
+  export declare function decodeWebsocketMessageBuildSuccess(buffer: ByteBuffer): WebsocketMessageBuildSuccess;
+  export declare function  encodeWebsocketMessageBuildFailure(message: WebsocketMessageBuildFailure, bb: ByteBuffer): void;
+  export declare function decodeWebsocketMessageBuildFailure(buffer: ByteBuffer): WebsocketMessageBuildFailure;
+  export declare function  encodeDependencyManifest(message: DependencyManifest, bb: ByteBuffer): void;
+  export declare function decodeDependencyManifest(buffer: ByteBuffer): DependencyManifest;
+  export declare function  encodeFileList(message: FileList, bb: ByteBuffer): void;
+  export declare function decodeFileList(buffer: ByteBuffer): FileList;
+  export declare function  encodeWebsocketMessageResolveIDs(message: WebsocketMessageResolveIDs, bb: ByteBuffer): void;
+  export declare function decodeWebsocketMessageResolveIDs(buffer: ByteBuffer): WebsocketMessageResolveIDs;
+  export declare function  encodeWebsocketCommandResolveIDs(message: WebsocketCommandResolveIDs, bb: ByteBuffer): void;
+  export declare function decodeWebsocketCommandResolveIDs(buffer: ByteBuffer): WebsocketCommandResolveIDs;
+  export declare function  encodeWebsocketMessageManifestSuccess(message: WebsocketMessageManifestSuccess, bb: ByteBuffer): void;
+  export declare function decodeWebsocketMessageManifestSuccess(buffer: ByteBuffer): WebsocketMessageManifestSuccess;
+  export declare function  encodeWebsocketMessageManifestFailure(message: WebsocketMessageManifestFailure, bb: ByteBuffer): void;
+  export declare function decodeWebsocketMessageManifestFailure(buffer: ByteBuffer): WebsocketMessageManifestFailure;
diff --git a/src/api/schema.js b/src/api/schema.js
index b27266160..07f643a62 100644
--- a/src/api/schema.js
+++ b/src/api/schema.js
@@ -1,82 +1,94 @@
 const Loader = {
-  1: 1,
-  2: 2,
-  3: 3,
-  4: 4,
-  5: 5,
-  6: 6,
-  7: 7,
-  jsx: 1,
-  js: 2,
-  ts: 3,
-  tsx: 4,
-  css: 5,
-  file: 6,
-  json: 7,
+  "1": 1,
+  "2": 2,
+  "3": 3,
+  "4": 4,
+  "5": 5,
+  "6": 6,
+  "7": 7,
+  "jsx": 1,
+  "js": 2,
+  "ts": 3,
+  "tsx": 4,
+  "css": 5,
+  "file": 6,
+  "json": 7
 };
 const LoaderKeys = {
-  1: "jsx",
-  2: "js",
-  3: "ts",
-  4: "tsx",
-  5: "css",
-  6: "file",
-  7: "json",
-  jsx: "jsx",
-  js: "js",
-  ts: "ts",
-  tsx: "tsx",
-  css: "css",
-  file: "file",
-  json: "json",
+  "1": "jsx",
+  "2": "js",
+  "3": "ts",
+  "4": "tsx",
+  "5": "css",
+  "6": "file",
+  "7": "json",
+  "jsx": "jsx",
+  "js": "js",
+  "ts": "ts",
+  "tsx": "tsx",
+  "css": "css",
+  "file": "file",
+  "json": "json"
 };
 const ResolveMode = {
-  1: 1,
-  2: 2,
-  3: 3,
-  4: 4,
-  disable: 1,
-  lazy: 2,
-  dev: 3,
-  bundle: 4,
+  "1": 1,
+  "2": 2,
+  "3": 3,
+  "4": 4,
+  "disable": 1,
+  "lazy": 2,
+  "dev": 3,
+  "bundle": 4
 };
 const ResolveModeKeys = {
-  1: "disable",
-  2: "lazy",
-  3: "dev",
-  4: "bundle",
-  disable: "disable",
-  lazy: "lazy",
-  dev: "dev",
-  bundle: "bundle",
+  "1": "disable",
+  "2": "lazy",
+  "3": "dev",
+  "4": "bundle",
+  "disable": "disable",
+  "lazy": "lazy",
+  "dev": "dev",
+  "bundle": "bundle"
 };
 const Platform = {
-  1: 1,
-  2: 2,
-  3: 3,
-  browser: 1,
-  node: 2,
-  bun: 3,
+  "1": 1,
+  "2": 2,
+  "3": 3,
+  "browser": 1,
+  "node": 2,
+  "bun": 3
 };
 const PlatformKeys = {
-  1: "browser",
-  2: "node",
-  3: "bun",
-  browser: "browser",
-  node: "node",
-  bun: "bun",
+  "1": "browser",
+  "2": "node",
+  "3": "bun",
+  "browser": "browser",
+  "node": "node",
+  "bun": "bun"
+};
+const CSSInJSBehavior = {
+  "1": 1,
+  "2": 2,
+  "facade": 1,
+  "facade_onimportcss": 2
+};
+const CSSInJSBehaviorKeys = {
+  "1": "facade",
+  "2": "facade_onimportcss",
+  "facade": "facade",
+  "facade_onimportcss": "facade_onimportcss"
 };
 const JSXRuntime = {
-  1: 1,
-  2: 2,
-  automatic: 1,
-  classic: 2,
+  "1": 1,
+  "2": 2,
+  "automatic": 1,
+  "classic": 2
 };
 const JSXRuntimeKeys = {
-  1: "automatic",
-  2: "classic",
-  automatic: "automatic",
-  classic: "classic",
+  "1": "automatic",
+  "2": "classic",
+  "automatic": "automatic",
+  "classic": "classic"
 };
 
 function decodeJSX(bb) {
@@ -92,52 +104,51 @@ function decodeJSX(bb) {
 }
 
 function encodeJSX(message, bb) {
+
   var value = message["factory"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "factory"');
+    throw new Error("Missing required field \"factory\"");
   }
 
   var value = message["runtime"];
   if (value != null) {
     var encoded = JSXRuntime[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " + JSON.stringify(value) + ' for enum "JSXRuntime"'
-      );
-    bb.writeByte(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"JSXRuntime\"");
+bb.writeByte(encoded);
   } else {
-    throw new Error('Missing required field "runtime"');
+    throw new Error("Missing required field \"runtime\"");
   }
 
   var value = message["fragment"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "fragment"');
+    throw new Error("Missing required field \"fragment\"");
   }
 
   var value = message["development"];
   if (value != null) {
     bb.writeByte(value);
   } else {
-    throw new Error('Missing required field "development"');
+    throw new Error("Missing required field \"development\"");
   }
 
   var value = message["import_source"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "import_source"');
+    throw new Error("Missing required field \"import_source\"");
   }
 
   var value = message["react_fast_refresh"];
   if (value != null) {
     bb.writeByte(value);
   } else {
-    throw new Error('Missing required field "react_fast_refresh"');
+    throw new Error("Missing required field \"react_fast_refresh\"");
   }
+
 }
 
 function decodeStringPointer(bb) {
@@ -149,19 +160,21 @@ function decodeStringPointer(bb) {
 }
 
 function encodeStringPointer(message, bb) {
+
   var value = message["offset"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "offset"');
+    throw new Error("Missing required field \"offset\"");
   }
 
   var value = message["length"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "length"');
+    throw new Error("Missing required field \"length\"");
   }
+
 }
 
 function decodeJavascriptBundledModule(bb) {
@@ -176,40 +189,42 @@ function decodeJavascriptBundledModule(bb) {
 }
 
 function encodeJavascriptBundledModule(message, bb) {
+
   var value = message["path"];
   if (value != null) {
     encodeStringPointer(value, bb);
   } else {
-    throw new Error('Missing required field "path"');
+    throw new Error("Missing required field \"path\"");
   }
 
   var value = message["code"];
   if (value != null) {
     encodeStringPointer(value, bb);
   } else {
-    throw new Error('Missing required field "code"');
+    throw new Error("Missing required field \"code\"");
   }
 
   var value = message["package_id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "package_id"');
+    throw new Error("Missing required field \"package_id\"");
   }
 
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "id"');
+    throw new Error("Missing required field \"id\"");
   }
 
   var value = message["path_extname_length"];
   if (value != null) {
     bb.writeByte(value);
   } else {
-    throw new Error('Missing required field "path_extname_length"');
+    throw new Error("Missing required field \"path_extname_length\"");
   }
+
 }
 
 function decodeJavascriptBundledPackage(bb) {
@@ -224,53 +239,53 @@ function decodeJavascriptBundledPackage(bb) {
 }
 
 function encodeJavascriptBundledPackage(message, bb) {
+
   var value = message["name"];
   if (value != null) {
     encodeStringPointer(value, bb);
   } else {
-    throw new Error('Missing required field "name"');
+    throw new Error("Missing required field \"name\"");
   }
 
   var value = message["version"];
   if (value != null) {
     encodeStringPointer(value, bb);
   } else {
-    throw new Error('Missing required field "version"');
+    throw new Error("Missing required field \"version\"");
   }
 
   var value = message["hash"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "hash"');
+    throw new Error("Missing required field \"hash\"");
   }
 
   var value = message["modules_offset"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "modules_offset"');
+    throw new Error("Missing required field \"modules_offset\"");
   }
 
   var value = message["modules_length"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "modules_length"');
+    throw new Error("Missing required field \"modules_length\"");
   }
+
 }
 
 function decodeJavascriptBundle(bb) {
   var result = {};
 
   var length = bb.readVarUint();
-  var values = (result["modules"] = Array(length));
-  for (var i = 0; i < length; i++)
-    values[i] = decodeJavascriptBundledModule(bb);
+  var values = result["modules"] = Array(length);
+  for (var i = 0; i < length; i++) values[i] = decodeJavascriptBundledModule(bb);
   var length = bb.readVarUint();
-  var values = (result["packages"] = Array(length));
-  for (var i = 0; i < length; i++)
-    values[i] = decodeJavascriptBundledPackage(bb);
+  var values = result["packages"] = Array(length);
+  for (var i = 0; i < length; i++) values[i] = decodeJavascriptBundledPackage(bb);
   result["etag"] = bb.readByteArray();
   result["generated_at"] = bb.readUint32();
   result["app_package_json_dependencies_hash"] = bb.readByteArray();
@@ -280,68 +295,66 @@ function decodeJavascriptBundle(bb) {
 }
 
 function encodeJavascriptBundle(message, bb) {
+
   var value = message["modules"];
   if (value != null) {
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeJavascriptBundledModule(value, bb);
     }
   } else {
-    throw new Error('Missing required field "modules"');
+    throw new Error("Missing required field \"modules\"");
   }
 
   var value = message["packages"];
   if (value != null) {
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeJavascriptBundledPackage(value, bb);
     }
   } else {
-    throw new Error('Missing required field "packages"');
+    throw new Error("Missing required field \"packages\"");
   }
 
   var value = message["etag"];
   if (value != null) {
-    bb.writeByteArray(value);
+   bb.writeByteArray(value);
   } else {
-    throw new Error('Missing required field "etag"');
+    throw new Error("Missing required field \"etag\"");
   }
 
   var value = message["generated_at"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "generated_at"');
+    throw new Error("Missing required field \"generated_at\"");
   }
 
   var value = message["app_package_json_dependencies_hash"];
   if (value != null) {
-    bb.writeByteArray(value);
+   bb.writeByteArray(value);
   } else {
-    throw new Error(
-      'Missing required field "app_package_json_dependencies_hash"'
-    );
+    throw new Error("Missing required field \"app_package_json_dependencies_hash\"");
   }
 
   var value = message["import_from_name"];
   if (value != null) {
-    bb.writeByteArray(value);
+   bb.writeByteArray(value);
   } else {
-    throw new Error('Missing required field "import_from_name"');
+    throw new Error("Missing required field \"import_from_name\"");
   }
 
   var value = message["manifest_string"];
   if (value != null) {
-    bb.writeByteArray(value);
+   bb.writeByteArray(value);
   } else {
-    throw new Error('Missing required field "manifest_string"');
+    throw new Error("Missing required field \"manifest_string\"");
   }
+
 }
 
 function decodeJavascriptBundleContainer(bb) {
@@ -349,36 +362,37 @@ function decodeJavascriptBundleContainer(bb) {
 
   while (true) {
     switch (bb.readByte()) {
-      case 0:
-        return result;
+    case 0:
+      return result;
 
-      case 1:
-        result["bundle_format_version"] = bb.readUint32();
-        break;
+    case 1:
+      result["bundle_format_version"] = bb.readUint32();
+      break;
 
-      case 2:
-        result["bundle"] = decodeJavascriptBundle(bb);
-        break;
+    case 2:
+      result["bundle"] = decodeJavascriptBundle(bb);
+      break;
 
-      case 3:
-        result["framework"] = decodeLoadedFramework(bb);
-        break;
+    case 3:
+      result["framework"] = decodeLoadedFramework(bb);
+      break;
 
-      case 4:
-        result["routes"] = decodeLoadedRouteConfig(bb);
-        break;
+    case 4:
+      result["routes"] = decodeLoadedRouteConfig(bb);
+      break;
 
-      case 5:
-        result["code_length"] = bb.readUint32();
-        break;
+    case 5:
+      result["code_length"] = bb.readUint32();
+      break;
 
-      default:
-        throw new Error("Attempted to parse invalid message");
+    default:
+      throw new Error("Attempted to parse invalid message");
     }
   }
 }
 
 function encodeJavascriptBundleContainer(message, bb) {
+
   var value = message["bundle_format_version"];
   if (value != null) {
     bb.writeByte(1);
@@ -409,30 +423,31 @@ function encodeJavascriptBundleContainer(message, bb) {
     bb.writeUint32(value);
   }
   bb.writeByte(0);
+
 }
 const ScanDependencyMode = {
-  1: 1,
-  2: 2,
-  app: 1,
-  all: 2,
+  "1": 1,
+  "2": 2,
+  "app": 1,
+  "all": 2
 };
 const ScanDependencyModeKeys = {
-  1: "app",
-  2: "all",
-  app: "app",
-  all: "all",
+  "1": "app",
+  "2": "all",
+  "app": "app",
+  "all": "all"
 };
 const ModuleImportType = {
-  1: 1,
-  2: 2,
-  import: 1,
-  require: 2,
+  "1": 1,
+  "2": 2,
+  "import": 1,
+  "require": 2
 };
 const ModuleImportTypeKeys = {
-  1: "import",
-  2: "require",
-  import: "import",
-  require: "require",
+  "1": "import",
+  "2": "require",
+  "import": "import",
+  "require": "require"
 };
 
 function decodeModuleImportRecord(bb) {
@@ -445,33 +460,30 @@ function decodeModuleImportRecord(bb) {
 }
 
 function encodeModuleImportRecord(message, bb) {
+
   var value = message["kind"];
   if (value != null) {
     var encoded = ModuleImportType[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " +
-          JSON.stringify(value) +
-          ' for enum "ModuleImportType"'
-      );
-    bb.writeByte(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"ModuleImportType\"");
+bb.writeByte(encoded);
   } else {
-    throw new Error('Missing required field "kind"');
+    throw new Error("Missing required field \"kind\"");
   }
 
   var value = message["path"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "path"');
+    throw new Error("Missing required field \"path\"");
   }
 
   var value = message["dynamic"];
   if (value != null) {
     bb.writeByte(value);
   } else {
-    throw new Error('Missing required field "dynamic"');
+    throw new Error("Missing required field \"dynamic\"");
   }
+
 }
 
 function decodeModule(bb) {
@@ -479,132 +491,130 @@ function decodeModule(bb) {
 
   result["path"] = bb.readString();
   var length = bb.readVarUint();
-  var values = (result["imports"] = Array(length));
+  var values = result["imports"] = Array(length);
   for (var i = 0; i < length; i++) values[i] = decodeModuleImportRecord(bb);
   return result;
 }
 
 function encodeModule(message, bb) {
+
   var value = message["path"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "path"');
+    throw new Error("Missing required field \"path\"");
   }
 
   var value = message["imports"];
   if (value != null) {
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeModuleImportRecord(value, bb);
     }
   } else {
-    throw new Error('Missing required field "imports"');
+    throw new Error("Missing required field \"imports\"");
   }
+
 }
 
 function decodeStringMap(bb) {
   var result = {};
 
   var length = bb.readVarUint();
-  var values = (result["keys"] = Array(length));
+  var values = result["keys"] = Array(length);
   for (var i = 0; i < length; i++) values[i] = bb.readString();
   var length = bb.readVarUint();
-  var values = (result["values"] = Array(length));
+  var values = result["values"] = Array(length);
   for (var i = 0; i < length; i++) values[i] = bb.readString();
   return result;
 }
 
 function encodeStringMap(message, bb) {
+
   var value = message["keys"];
   if (value != null) {
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       bb.writeString(value);
     }
   } else {
-    throw new Error('Missing required field "keys"');
+    throw new Error("Missing required field \"keys\"");
   }
 
   var value = message["values"];
   if (value != null) {
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       bb.writeString(value);
     }
   } else {
-    throw new Error('Missing required field "values"');
+    throw new Error("Missing required field \"values\"");
   }
+
 }
 
 function decodeLoaderMap(bb) {
   var result = {};
 
   var length = bb.readVarUint();
-  var values = (result["extensions"] = Array(length));
+  var values = result["extensions"] = Array(length);
   for (var i = 0; i < length; i++) values[i] = bb.readString();
   var length = bb.readVarUint();
-  var values = (result["loaders"] = Array(length));
+  var values = result["loaders"] = Array(length);
   for (var i = 0; i < length; i++) values[i] = Loader[bb.readByte()];
   return result;
 }
 
 function encodeLoaderMap(message, bb) {
+
   var value = message["extensions"];
   if (value != null) {
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       bb.writeString(value);
     }
   } else {
-    throw new Error('Missing required field "extensions"');
+    throw new Error("Missing required field \"extensions\"");
   }
 
   var value = message["loaders"];
   if (value != null) {
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       var encoded = Loader[value];
-      if (encoded === void 0)
-        throw new Error(
-          "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
-        );
-      bb.writeByte(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Loader\"");
+bb.writeByte(encoded);
     }
   } else {
-    throw new Error('Missing required field "loaders"');
+    throw new Error("Missing required field \"loaders\"");
   }
+
 }
 const DotEnvBehavior = {
-  1: 1,
-  2: 2,
-  3: 3,
-  disable: 1,
-  prefix: 2,
-  load_all: 3,
+  "1": 1,
+  "2": 2,
+  "3": 3,
+  "disable": 1,
+  "prefix": 2,
+  "load_all": 3
 };
 const DotEnvBehaviorKeys = {
-  1: "disable",
-  2: "prefix",
-  3: "load_all",
-  disable: "disable",
-  prefix: "prefix",
-  load_all: "load_all",
+  "1": "disable",
+  "2": "prefix",
+  "3": "load_all",
+  "disable": "disable",
+  "prefix": "prefix",
+  "load_all": "load_all"
 };
 
 function decodeEnvConfig(bb) {
@@ -612,24 +622,25 @@ function decodeEnvConfig(bb) {
 
   while (true) {
     switch (bb.readByte()) {
-      case 0:
-        return result;
+    case 0:
+      return result;
 
-      case 1:
-        result["prefix"] = bb.readString();
-        break;
+    case 1:
+      result["prefix"] = bb.readString();
+      break;
 
-      case 2:
-        result["defaults"] = decodeStringMap(bb);
-        break;
+    case 2:
+      result["defaults"] = decodeStringMap(bb);
+      break;
 
-      default:
-        throw new Error("Attempted to parse invalid message");
+    default:
+      throw new Error("Attempted to parse invalid message");
     }
   }
 }
 
 function encodeEnvConfig(message, bb) {
+
   var value = message["prefix"];
   if (value != null) {
     bb.writeByte(1);
@@ -642,6 +653,7 @@ function encodeEnvConfig(message, bb) {
     encodeStringMap(value, bb);
   }
   bb.writeByte(0);
+
 }
 
 function decodeLoadedEnvConfig(bb) {
@@ -654,31 +666,30 @@ function decodeLoadedEnvConfig(bb) {
 }
 
 function encodeLoadedEnvConfig(message, bb) {
+
   var value = message["dotenv"];
   if (value != null) {
     var encoded = DotEnvBehavior[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " + JSON.stringify(value) + ' for enum "DotEnvBehavior"'
-      );
-    bb.writeVarUint(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"DotEnvBehavior\"");
+bb.writeVarUint(encoded);
   } else {
-    throw new Error('Missing required field "dotenv"');
+    throw new Error("Missing required field \"dotenv\"");
   }
 
   var value = message["defaults"];
   if (value != null) {
     encodeStringMap(value, bb);
   } else {
-    throw new Error('Missing required field "defaults"');
+    throw new Error("Missing required field \"defaults\"");
   }
 
   var value = message["prefix"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "prefix"');
+    throw new Error("Missing required field \"prefix\"");
   }
+
 }
 
 function decodeFrameworkConfig(bb) {
@@ -686,40 +697,45 @@ function decodeFrameworkConfig(bb) {
 
   while (true) {
     switch (bb.readByte()) {
-      case 0:
-        return result;
+    case 0:
+      return result;
+
+    case 1:
+      result["package"] = bb.readString();
+      break;
 
-      case 1:
-        result["package"] = bb.readString();
-        break;
+    case 2:
+      result["client"] = bb.readString();
+      break;
 
-      case 2:
-        result["client"] = bb.readString();
-        break;
+    case 3:
+      result["server"] = bb.readString();
+      break;
 
-      case 3:
-        result["server"] = bb.readString();
-        break;
+    case 4:
+      result["development"] = !!bb.readByte();
+      break;
 
-      case 4:
-        result["development"] = !!bb.readByte();
-        break;
+    case 5:
+      result["client_env"] = decodeEnvConfig(bb);
+      break;
 
-      case 5:
-        result["client_env"] = decodeEnvConfig(bb);
-        break;
+    case 6:
+      result["server_env"] = decodeEnvConfig(bb);
+      break;
 
-      case 6:
-        result["server_env"] = decodeEnvConfig(bb);
-        break;
+    case 7:
+      result["client_css_in_js"] = CSSInJSBehavior[bb.readByte()];
+      break;
 
-      default:
-        throw new Error("Attempted to parse invalid message");
+    default:
+      throw new Error("Attempted to parse invalid message");
     }
   }
 }
 
 function encodeFrameworkConfig(message, bb) {
+
   var value = message["package"];
   if (value != null) {
     bb.writeByte(1);
@@ -755,7 +771,16 @@ function encodeFrameworkConfig(message, bb) {
     bb.writeByte(6);
     encodeEnvConfig(value, bb);
   }
+
+  var value = message["client_css_in_js"];
+  if (value != null) {
+    bb.writeByte(7);
+    var encoded = CSSInJSBehavior[value];
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"CSSInJSBehavior\"");
+bb.writeByte(encoded);
+  }
   bb.writeByte(0);
+
 }
 
 function decodeLoadedFramework(bb) {
@@ -766,44 +791,56 @@ function decodeLoadedFramework(bb) {
   result["development"] = !!bb.readByte();
   result["client"] = !!bb.readByte();
   result["env"] = decodeLoadedEnvConfig(bb);
+  result["client_css_in_js"] = CSSInJSBehavior[bb.readByte()];
   return result;
 }
 
 function encodeLoadedFramework(message, bb) {
+
   var value = message["entry_point"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "entry_point"');
+    throw new Error("Missing required field \"entry_point\"");
   }
 
   var value = message["package"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "package"');
+    throw new Error("Missing required field \"package\"");
   }
 
   var value = message["development"];
   if (value != null) {
     bb.writeByte(value);
   } else {
-    throw new Error('Missing required field "development"');
+    throw new Error("Missing required field \"development\"");
   }
 
   var value = message["client"];
   if (value != null) {
     bb.writeByte(value);
   } else {
-    throw new Error('Missing required field "client"');
+    throw new Error("Missing required field \"client\"");
   }
 
   var value = message["env"];
   if (value != null) {
     encodeLoadedEnvConfig(value, bb);
   } else {
-    throw new Error('Missing required field "env"');
+    throw new Error("Missing required field \"env\"");
+  }
+
+  var value = message["client_css_in_js"];
+  if (value != null) {
+    var encoded = CSSInJSBehavior[value];
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"CSSInJSBehavior\"");
+bb.writeByte(encoded);
+  } else {
+    throw new Error("Missing required field \"client_css_in_js\"");
   }
+
 }
 
 function decodeLoadedRouteConfig(bb) {
@@ -811,7 +848,7 @@ function decodeLoadedRouteConfig(bb) {
 
   result["dir"] = bb.readString();
   var length = bb.readVarUint();
-  var values = (result["extensions"] = Array(length));
+  var values = result["extensions"] = Array(length);
   for (var i = 0; i < length; i++) values[i] = bb.readString();
   result["static_dir"] = bb.readString();
   result["asset_prefix"] = bb.readString();
@@ -819,39 +856,40 @@ function decodeLoadedRouteConfig(bb) {
 }
 
 function encodeLoadedRouteConfig(message, bb) {
+
   var value = message["dir"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "dir"');
+    throw new Error("Missing required field \"dir\"");
   }
 
   var value = message["extensions"];
   if (value != null) {
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       bb.writeString(value);
     }
   } else {
-    throw new Error('Missing required field "extensions"');
+    throw new Error("Missing required field \"extensions\"");
   }
 
   var value = message["static_dir"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "static_dir"');
+    throw new Error("Missing required field \"static_dir\"");
   }
 
   var value = message["asset_prefix"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "asset_prefix"');
+    throw new Error("Missing required field \"asset_prefix\"");
   }
+
 }
 
 function decodeRouteConfig(bb) {
@@ -859,41 +897,41 @@ function decodeRouteConfig(bb) {
 
   while (true) {
     switch (bb.readByte()) {
-      case 0:
-        return result;
-
-      case 1:
-        var length = bb.readVarUint();
-        var values = (result["dir"] = Array(length));
-        for (var i = 0; i < length; i++) values[i] = bb.readString();
-        break;
-
-      case 2:
-        var length = bb.readVarUint();
-        var values = (result["extensions"] = Array(length));
-        for (var i = 0; i < length; i++) values[i] = bb.readString();
-        break;
-
-      case 3:
-        result["static_dir"] = bb.readString();
-        break;
-
-      case 4:
-        result["asset_prefix"] = bb.readString();
-        break;
-
-      default:
-        throw new Error("Attempted to parse invalid message");
+    case 0:
+      return result;
+
+    case 1:
+      var length = bb.readVarUint();
+      var values = result["dir"] = Array(length);
+      for (var i = 0; i < length; i++) values[i] = bb.readString();
+      break;
+
+    case 2:
+      var length = bb.readVarUint();
+      var values = result["extensions"] = Array(length);
+      for (var i = 0; i < length; i++) values[i] = bb.readString();
+      break;
+
+    case 3:
+      result["static_dir"] = bb.readString();
+      break;
+
+    case 4:
+      result["asset_prefix"] = bb.readString();
+      break;
+
+    default:
+      throw new Error("Attempted to parse invalid message");
     }
   }
 }
 
 function encodeRouteConfig(message, bb) {
+
   var value = message["dir"];
   if (value != null) {
     bb.writeByte(1);
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
@@ -904,8 +942,7 @@ function encodeRouteConfig(message, bb) {
   var value = message["extensions"];
   if (value != null) {
     bb.writeByte(2);
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
@@ -925,6 +962,7 @@ function encodeRouteConfig(message, bb) {
     bb.writeString(value);
   }
   bb.writeByte(0);
+
 }
 
 function decodeTransformOptions(bb) {
@@ -932,114 +970,115 @@ function decodeTransformOptions(bb) {
 
   while (true) {
     switch (bb.readByte()) {
-      case 0:
-        return result;
-
-      case 1:
-        result["jsx"] = decodeJSX(bb);
-        break;
-
-      case 2:
-        result["tsconfig_override"] = bb.readString();
-        break;
-
-      case 3:
-        result["resolve"] = ResolveMode[bb.readByte()];
-        break;
-
-      case 4:
-        result["origin"] = bb.readString();
-        break;
-
-      case 5:
-        result["absolute_working_dir"] = bb.readString();
-        break;
-
-      case 6:
-        result["define"] = decodeStringMap(bb);
-        break;
-
-      case 7:
-        result["preserve_symlinks"] = !!bb.readByte();
-        break;
-
-      case 8:
-        var length = bb.readVarUint();
-        var values = (result["entry_points"] = Array(length));
-        for (var i = 0; i < length; i++) values[i] = bb.readString();
-        break;
-
-      case 9:
-        result["write"] = !!bb.readByte();
-        break;
-
-      case 10:
-        var length = bb.readVarUint();
-        var values = (result["inject"] = Array(length));
-        for (var i = 0; i < length; i++) values[i] = bb.readString();
-        break;
-
-      case 11:
-        result["output_dir"] = bb.readString();
-        break;
-
-      case 12:
-        var length = bb.readVarUint();
-        var values = (result["external"] = Array(length));
-        for (var i = 0; i < length; i++) values[i] = bb.readString();
-        break;
-
-      case 13:
-        result["loaders"] = decodeLoaderMap(bb);
-        break;
-
-      case 14:
-        var length = bb.readVarUint();
-        var values = (result["main_fields"] = Array(length));
-        for (var i = 0; i < length; i++) values[i] = bb.readString();
-        break;
-
-      case 15:
-        result["platform"] = Platform[bb.readByte()];
-        break;
-
-      case 16:
-        result["serve"] = !!bb.readByte();
-        break;
-
-      case 17:
-        var length = bb.readVarUint();
-        var values = (result["extension_order"] = Array(length));
-        for (var i = 0; i < length; i++) values[i] = bb.readString();
-        break;
-
-      case 18:
-        result["generate_node_module_bundle"] = !!bb.readByte();
-        break;
-
-      case 19:
-        result["node_modules_bundle_path"] = bb.readString();
-        break;
-
-      case 20:
-        result["node_modules_bundle_path_server"] = bb.readString();
-        break;
-
-      case 21:
-        result["framework"] = decodeFrameworkConfig(bb);
-        break;
-
-      case 22:
-        result["router"] = decodeRouteConfig(bb);
-        break;
-
-      default:
-        throw new Error("Attempted to parse invalid message");
+    case 0:
+      return result;
+
+    case 1:
+      result["jsx"] = decodeJSX(bb);
+      break;
+
+    case 2:
+      result["tsconfig_override"] = bb.readString();
+      break;
+
+    case 3:
+      result["resolve"] = ResolveMode[bb.readByte()];
+      break;
+
+    case 4:
+      result["origin"] = bb.readString();
+      break;
+
+    case 5:
+      result["absolute_working_dir"] = bb.readString();
+      break;
+
+    case 6:
+      result["define"] = decodeStringMap(bb);
+      break;
+
+    case 7:
+      result["preserve_symlinks"] = !!bb.readByte();
+      break;
+
+    case 8:
+      var length = bb.readVarUint();
+      var values = result["entry_points"] = Array(length);
+      for (var i = 0; i < length; i++) values[i] = bb.readString();
+      break;
+
+    case 9:
+      result["write"] = !!bb.readByte();
+      break;
+
+    case 10:
+      var length = bb.readVarUint();
+      var values = result["inject"] = Array(length);
+      for (var i = 0; i < length; i++) values[i] = bb.readString();
+      break;
+
+    case 11:
+      result["output_dir"] = bb.readString();
+      break;
+
+    case 12:
+      var length = bb.readVarUint();
+      var values = result["external"] = Array(length);
+      for (var i = 0; i < length; i++) values[i] = bb.readString();
+      break;
+
+    case 13:
+      result["loaders"] = decodeLoaderMap(bb);
+      break;
+
+    case 14:
+      var length = bb.readVarUint();
+      var values = result["main_fields"] = Array(length);
+      for (var i = 0; i < length; i++) values[i] = bb.readString();
+      break;
+
+    case 15:
+      result["platform"] = Platform[bb.readByte()];
+      break;
+
+    case 16:
+      result["serve"] = !!bb.readByte();
+      break;
+
+    case 17:
+      var length = bb.readVarUint();
+      var values = result["extension_order"] = Array(length);
+      for (var i = 0; i < length; i++) values[i] = bb.readString();
+      break;
+
+    case 18:
+      result["generate_node_module_bundle"] = !!bb.readByte();
+      break;
+
+    case 19:
+      result["node_modules_bundle_path"] = bb.readString();
+      break;
+
+    case 20:
+      result["node_modules_bundle_path_server"] = bb.readString();
+      break;
+
+    case 21:
+      result["framework"] = decodeFrameworkConfig(bb);
+      break;
+
+    case 22:
+      result["router"] = decodeRouteConfig(bb);
+      break;
+
+    default:
+      throw new Error("Attempted to parse invalid message");
     }
   }
 }
 
 function encodeTransformOptions(message, bb) {
+
   var value = message["jsx"];
   if (value != null) {
     bb.writeByte(1);
@@ -1056,11 +1095,8 @@ function encodeTransformOptions(message, bb) {
   if (value != null) {
     bb.writeByte(3);
     var encoded = ResolveMode[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " + JSON.stringify(value) + ' for enum "ResolveMode"'
-      );
-    bb.writeByte(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"ResolveMode\"");
+bb.writeByte(encoded);
   }
 
   var value = message["origin"];
@@ -1090,8 +1126,7 @@ function encodeTransformOptions(message, bb) {
   var value = message["entry_points"];
   if (value != null) {
     bb.writeByte(8);
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
@@ -1108,8 +1143,7 @@ function encodeTransformOptions(message, bb) {
   var value = message["inject"];
   if (value != null) {
     bb.writeByte(10);
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
@@ -1126,8 +1160,7 @@ function encodeTransformOptions(message, bb) {
   var value = message["external"];
   if (value != null) {
     bb.writeByte(12);
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
@@ -1144,8 +1177,7 @@ function encodeTransformOptions(message, bb) {
   var value = message["main_fields"];
   if (value != null) {
     bb.writeByte(14);
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
@@ -1157,11 +1189,8 @@ function encodeTransformOptions(message, bb) {
   if (value != null) {
     bb.writeByte(15);
     var encoded = Platform[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " + JSON.stringify(value) + ' for enum "Platform"'
-      );
-    bb.writeByte(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Platform\"");
+bb.writeByte(encoded);
   }
 
   var value = message["serve"];
@@ -1173,8 +1202,7 @@ function encodeTransformOptions(message, bb) {
   var value = message["extension_order"];
   if (value != null) {
     bb.writeByte(17);
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
@@ -1212,6 +1240,7 @@ function encodeTransformOptions(message, bb) {
     encodeRouteConfig(value, bb);
   }
   bb.writeByte(0);
+
 }
 
 function decodeFileHandle(bb) {
@@ -1224,26 +1253,28 @@ function decodeFileHandle(bb) {
 }
 
 function encodeFileHandle(message, bb) {
+
   var value = message["path"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "path"');
+    throw new Error("Missing required field \"path\"");
   }
 
   var value = message["size"];
   if (value != null) {
     bb.writeVarUint(value);
   } else {
-    throw new Error('Missing required field "size"');
+    throw new Error("Missing required field \"size\"");
   }
 
   var value = message["fd"];
   if (value != null) {
     bb.writeVarUint(value);
   } else {
-    throw new Error('Missing required field "fd"');
+    throw new Error("Missing required field \"fd\"");
   }
+
 }
 
 function decodeTransform(bb) {
@@ -1251,36 +1282,37 @@ function decodeTransform(bb) {
 
   while (true) {
     switch (bb.readByte()) {
-      case 0:
-        return result;
+    case 0:
+      return result;
 
-      case 1:
-        result["handle"] = decodeFileHandle(bb);
-        break;
+    case 1:
+      result["handle"] = decodeFileHandle(bb);
+      break;
 
-      case 2:
-        result["path"] = bb.readString();
-        break;
+    case 2:
+      result["path"] = bb.readString();
+      break;
 
-      case 3:
-        result["contents"] = bb.readByteArray();
-        break;
+    case 3:
+      result["contents"] = bb.readByteArray();
+      break;
 
-      case 4:
-        result["loader"] = Loader[bb.readByte()];
-        break;
+    case 4:
+      result["loader"] = Loader[bb.readByte()];
+      break;
 
-      case 5:
-        result["options"] = decodeTransformOptions(bb);
-        break;
+    case 5:
+      result["options"] = decodeTransformOptions(bb);
+      break;
 
-      default:
-        throw new Error("Attempted to parse invalid message");
+    default:
+      throw new Error("Attempted to parse invalid message");
     }
   }
 }
 
 function encodeTransform(message, bb) {
+
   var value = message["handle"];
   if (value != null) {
     bb.writeByte(1);
@@ -1296,18 +1328,15 @@ function encodeTransform(message, bb) {
   var value = message["contents"];
   if (value != null) {
     bb.writeByte(3);
-    bb.writeByteArray(value);
+   bb.writeByteArray(value);
   }
 
   var value = message["loader"];
   if (value != null) {
     bb.writeByte(4);
     var encoded = Loader[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
-      );
-    bb.writeByte(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Loader\"");
+bb.writeByte(encoded);
   }
 
   var value = message["options"];
@@ -1316,18 +1345,19 @@ function encodeTransform(message, bb) {
     encodeTransformOptions(value, bb);
   }
   bb.writeByte(0);
+
 }
 const TransformResponseStatus = {
-  1: 1,
-  2: 2,
-  success: 1,
-  fail: 2,
+  "1": 1,
+  "2": 2,
+  "success": 1,
+  "fail": 2
 };
 const TransformResponseStatusKeys = {
-  1: "success",
-  2: "fail",
-  success: "success",
-  fail: "fail",
+  "1": "success",
+  "2": "fail",
+  "success": "success",
+  "fail": "fail"
 };
 
 function decodeOutputFile(bb) {
@@ -1339,19 +1369,21 @@ function decodeOutputFile(bb) {
 }
 
 function encodeOutputFile(message, bb) {
+
   var value = message["data"];
   if (value != null) {
-    bb.writeByteArray(value);
+   bb.writeByteArray(value);
   } else {
-    throw new Error('Missing required field "data"');
+    throw new Error("Missing required field \"data\"");
   }
 
   var value = message["path"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "path"');
+    throw new Error("Missing required field \"path\"");
   }
+
 }
 
 function decodeTransformResponse(bb) {
@@ -1359,74 +1391,69 @@ function decodeTransformResponse(bb) {
 
   result["status"] = TransformResponseStatus[bb.readVarUint()];
   var length = bb.readVarUint();
-  var values = (result["files"] = Array(length));
+  var values = result["files"] = Array(length);
   for (var i = 0; i < length; i++) values[i] = decodeOutputFile(bb);
   var length = bb.readVarUint();
-  var values = (result["errors"] = Array(length));
+  var values = result["errors"] = Array(length);
   for (var i = 0; i < length; i++) values[i] = decodeMessage(bb);
   return result;
 }
 
 function encodeTransformResponse(message, bb) {
+
   var value = message["status"];
   if (value != null) {
     var encoded = TransformResponseStatus[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " +
-          JSON.stringify(value) +
-          ' for enum "TransformResponseStatus"'
-      );
-    bb.writeVarUint(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"TransformResponseStatus\"");
+bb.writeVarUint(encoded);
   } else {
-    throw new Error('Missing required field "status"');
+    throw new Error("Missing required field \"status\"");
   }
 
   var value = message["files"];
   if (value != null) {
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeOutputFile(value, bb);
     }
   } else {
-    throw new Error('Missing required field "files"');
+    throw new Error("Missing required field \"files\"");
   }
 
   var value = message["errors"];
   if (value != null) {
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeMessage(value, bb);
     }
   } else {
-    throw new Error('Missing required field "errors"');
+    throw new Error("Missing required field \"errors\"");
   }
+
 }
 const MessageKind = {
-  1: 1,
-  2: 2,
-  3: 3,
-  4: 4,
-  err: 1,
-  warn: 2,
-  note: 3,
-  debug: 4,
+  "1": 1,
+  "2": 2,
+  "3": 3,
+  "4": 4,
+  "err": 1,
+  "warn": 2,
+  "note": 3,
+  "debug": 4
 };
 const MessageKindKeys = {
-  1: "err",
-  2: "warn",
-  3: "note",
-  4: "debug",
-  err: "err",
-  warn: "warn",
-  note: "note",
-  debug: "debug",
+  "1": "err",
+  "2": "warn",
+  "3": "note",
+  "4": "debug",
+  "err": "err",
+  "warn": "warn",
+  "note": "note",
+  "debug": "debug"
 };
 
 function decodeLocation(bb) {
@@ -1443,54 +1470,56 @@ function decodeLocation(bb) {
 }
 
 function encodeLocation(message, bb) {
+
   var value = message["file"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "file"');
+    throw new Error("Missing required field \"file\"");
   }
 
   var value = message["namespace"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "namespace"');
+    throw new Error("Missing required field \"namespace\"");
   }
 
   var value = message["line"];
   if (value != null) {
     bb.writeInt32(value);
   } else {
-    throw new Error('Missing required field "line"');
+    throw new Error("Missing required field \"line\"");
   }
 
   var value = message["column"];
   if (value != null) {
     bb.writeInt32(value);
   } else {
-    throw new Error('Missing required field "column"');
+    throw new Error("Missing required field \"column\"");
   }
 
   var value = message["line_text"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "line_text"');
+    throw new Error("Missing required field \"line_text\"");
   }
 
   var value = message["suggestion"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "suggestion"');
+    throw new Error("Missing required field \"suggestion\"");
   }
 
   var value = message["offset"];
   if (value != null) {
     bb.writeVarUint(value);
   } else {
-    throw new Error('Missing required field "offset"');
+    throw new Error("Missing required field \"offset\"");
   }
+
 }
 
 function decodeMessageData(bb) {
@@ -1498,24 +1527,25 @@ function decodeMessageData(bb) {
 
   while (true) {
     switch (bb.readByte()) {
-      case 0:
-        return result;
+    case 0:
+      return result;
 
-      case 1:
-        result["text"] = bb.readString();
-        break;
+    case 1:
+      result["text"] = bb.readString();
+      break;
 
-      case 2:
-        result["location"] = decodeLocation(bb);
-        break;
+    case 2:
+      result["location"] = decodeLocation(bb);
+      break;
 
-      default:
-        throw new Error("Attempted to parse invalid message");
+    default:
+      throw new Error("Attempted to parse invalid message");
     }
   }
 }
 
 function encodeMessageData(message, bb) {
+
   var value = message["text"];
   if (value != null) {
     bb.writeByte(1);
@@ -1528,6 +1558,7 @@ function encodeMessageData(message, bb) {
     encodeLocation(value, bb);
   }
   bb.writeByte(0);
+
 }
 
 function decodeMessage(bb) {
@@ -1536,43 +1567,41 @@ function decodeMessage(bb) {
   result["kind"] = MessageKind[bb.readVarUint()];
   result["data"] = decodeMessageData(bb);
   var length = bb.readVarUint();
-  var values = (result["notes"] = Array(length));
+  var values = result["notes"] = Array(length);
   for (var i = 0; i < length; i++) values[i] = decodeMessageData(bb);
   return result;
 }
 
 function encodeMessage(message, bb) {
+
   var value = message["kind"];
   if (value != null) {
     var encoded = MessageKind[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " + JSON.stringify(value) + ' for enum "MessageKind"'
-      );
-    bb.writeVarUint(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"MessageKind\"");
+bb.writeVarUint(encoded);
   } else {
-    throw new Error('Missing required field "kind"');
+    throw new Error("Missing required field \"kind\"");
   }
 
   var value = message["data"];
   if (value != null) {
     encodeMessageData(value, bb);
   } else {
-    throw new Error('Missing required field "data"');
+    throw new Error("Missing required field \"data\"");
   }
 
   var value = message["notes"];
   if (value != null) {
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeMessageData(value, bb);
     }
   } else {
-    throw new Error('Missing required field "notes"');
+    throw new Error("Missing required field \"notes\"");
   }
+
 }
 
 function decodeLog(bb) {
@@ -1581,94 +1610,95 @@ function decodeLog(bb) {
   result["warnings"] = bb.readUint32();
   result["errors"] = bb.readUint32();
   var length = bb.readVarUint();
-  var values = (result["msgs"] = Array(length));
+  var values = result["msgs"] = Array(length);
   for (var i = 0; i < length; i++) values[i] = decodeMessage(bb);
   return result;
 }
 
 function encodeLog(message, bb) {
+
   var value = message["warnings"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "warnings"');
+    throw new Error("Missing required field \"warnings\"");
   }
 
   var value = message["errors"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "errors"');
+    throw new Error("Missing required field \"errors\"");
   }
 
   var value = message["msgs"];
   if (value != null) {
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeMessage(value, bb);
     }
   } else {
-    throw new Error('Missing required field "msgs"');
+    throw new Error("Missing required field \"msgs\"");
   }
+
 }
 const Reloader = {
-  1: 1,
-  2: 2,
-  3: 3,
-  disable: 1,
-  live: 2,
-  fast_refresh: 3,
+  "1": 1,
+  "2": 2,
+  "3": 3,
+  "disable": 1,
+  "live": 2,
+  "fast_refresh": 3
 };
 const ReloaderKeys = {
-  1: "disable",
-  2: "live",
-  3: "fast_refresh",
-  disable: "disable",
-  live: "live",
-  fast_refresh: "fast_refresh",
+  "1": "disable",
+  "2": "live",
+  "3": "fast_refresh",
+  "disable": "disable",
+  "live": "live",
+  "fast_refresh": "fast_refresh"
 };
 const WebsocketMessageKind = {
-  1: 1,
-  2: 2,
-  3: 3,
-  4: 4,
-  5: 5,
-  6: 6,
-  welcome: 1,
-  file_change_notification: 2,
-  build_success: 3,
-  build_fail: 4,
-  manifest_success: 5,
-  manifest_fail: 6,
+  "1": 1,
+  "2": 2,
+  "3": 3,
+  "4": 4,
+  "5": 5,
+  "6": 6,
+  "welcome": 1,
+  "file_change_notification": 2,
+  "build_success": 3,
+  "build_fail": 4,
+  "manifest_success": 5,
+  "manifest_fail": 6
 };
 const WebsocketMessageKindKeys = {
-  1: "welcome",
-  2: "file_change_notification",
-  3: "build_success",
-  4: "build_fail",
-  5: "manifest_success",
-  6: "manifest_fail",
-  welcome: "welcome",
-  file_change_notification: "file_change_notification",
-  build_success: "build_success",
-  build_fail: "build_fail",
-  manifest_success: "manifest_success",
-  manifest_fail: "manifest_fail",
+  "1": "welcome",
+  "2": "file_change_notification",
+  "3": "build_success",
+  "4": "build_fail",
+  "5": "manifest_success",
+  "6": "manifest_fail",
+  "welcome": "welcome",
+  "file_change_notification": "file_change_notification",
+  "build_success": "build_success",
+  "build_fail": "build_fail",
+  "manifest_success": "manifest_success",
+  "manifest_fail": "manifest_fail"
 };
 const WebsocketCommandKind = {
-  1: 1,
-  2: 2,
-  build: 1,
-  manifest: 2,
+  "1": 1,
+  "2": 2,
+  "build": 1,
+  "manifest": 2
 };
 const WebsocketCommandKindKeys = {
-  1: "build",
-  2: "manifest",
-  build: "build",
-  manifest: "manifest",
+  "1": "build",
+  "2": "manifest",
+  "build": "build",
+  "manifest": "manifest"
 };
 
 function decodeWebsocketMessage(bb) {
@@ -1680,26 +1710,23 @@ function decodeWebsocketMessage(bb) {
 }
 
 function encodeWebsocketMessage(message, bb) {
+
   var value = message["timestamp"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "timestamp"');
+    throw new Error("Missing required field \"timestamp\"");
   }
 
   var value = message["kind"];
   if (value != null) {
     var encoded = WebsocketMessageKind[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " +
-          JSON.stringify(value) +
-          ' for enum "WebsocketMessageKind"'
-      );
-    bb.writeByte(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"WebsocketMessageKind\"");
+bb.writeByte(encoded);
   } else {
-    throw new Error('Missing required field "kind"');
+    throw new Error("Missing required field \"kind\"");
   }
+
 }
 
 function decodeWebsocketMessageWelcome(bb) {
@@ -1711,24 +1738,23 @@ function decodeWebsocketMessageWelcome(bb) {
 }
 
 function encodeWebsocketMessageWelcome(message, bb) {
+
   var value = message["epoch"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "epoch"');
+    throw new Error("Missing required field \"epoch\"");
   }
 
   var value = message["javascriptReloader"];
   if (value != null) {
     var encoded = Reloader[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " + JSON.stringify(value) + ' for enum "Reloader"'
-      );
-    bb.writeByte(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Reloader\"");
+bb.writeByte(encoded);
   } else {
-    throw new Error('Missing required field "javascriptReloader"');
+    throw new Error("Missing required field \"javascriptReloader\"");
   }
+
 }
 
 function decodeWebsocketMessageFileChangeNotification(bb) {
@@ -1740,24 +1766,23 @@ function decodeWebsocketMessageFileChangeNotification(bb) {
 }
 
 function encodeWebsocketMessageFileChangeNotification(message, bb) {
+
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "id"');
+    throw new Error("Missing required field \"id\"");
   }
 
   var value = message["loader"];
   if (value != null) {
     var encoded = Loader[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
-      );
-    bb.writeByte(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Loader\"");
+bb.writeByte(encoded);
   } else {
-    throw new Error('Missing required field "loader"');
+    throw new Error("Missing required field \"loader\"");
   }
+
 }
 
 function decodeWebsocketCommand(bb) {
@@ -1769,26 +1794,23 @@ function decodeWebsocketCommand(bb) {
 }
 
 function encodeWebsocketCommand(message, bb) {
+
   var value = message["kind"];
   if (value != null) {
     var encoded = WebsocketCommandKind[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " +
-          JSON.stringify(value) +
-          ' for enum "WebsocketCommandKind"'
-      );
-    bb.writeByte(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"WebsocketCommandKind\"");
+bb.writeByte(encoded);
   } else {
-    throw new Error('Missing required field "kind"');
+    throw new Error("Missing required field \"kind\"");
   }
 
   var value = message["timestamp"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "timestamp"');
+    throw new Error("Missing required field \"timestamp\"");
   }
+
 }
 
 function decodeWebsocketCommandBuild(bb) {
@@ -1799,12 +1821,14 @@ function decodeWebsocketCommandBuild(bb) {
 }
 
 function encodeWebsocketCommandBuild(message, bb) {
+
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "id"');
+    throw new Error("Missing required field \"id\"");
   }
+
 }
 
 function decodeWebsocketCommandManifest(bb) {
@@ -1815,12 +1839,14 @@ function decodeWebsocketCommandManifest(bb) {
 }
 
 function encodeWebsocketCommandManifest(message, bb) {
+
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "id"');
+    throw new Error("Missing required field \"id\"");
   }
+
 }
 
 function decodeWebsocketMessageBuildSuccess(bb) {
@@ -1835,45 +1861,44 @@ function decodeWebsocketMessageBuildSuccess(bb) {
 }
 
 function encodeWebsocketMessageBuildSuccess(message, bb) {
+
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "id"');
+    throw new Error("Missing required field \"id\"");
   }
 
   var value = message["from_timestamp"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "from_timestamp"');
+    throw new Error("Missing required field \"from_timestamp\"");
   }
 
   var value = message["loader"];
   if (value != null) {
     var encoded = Loader[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
-      );
-    bb.writeByte(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Loader\"");
+bb.writeByte(encoded);
   } else {
-    throw new Error('Missing required field "loader"');
+    throw new Error("Missing required field \"loader\"");
   }
 
   var value = message["module_path"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "module_path"');
+    throw new Error("Missing required field \"module_path\"");
   }
 
   var value = message["blob_length"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "blob_length"');
+    throw new Error("Missing required field \"blob_length\"");
   }
+
 }
 
 function decodeWebsocketMessageBuildFailure(bb) {
@@ -1888,45 +1913,44 @@ function decodeWebsocketMessageBuildFailure(bb) {
 }
 
 function encodeWebsocketMessageBuildFailure(message, bb) {
+
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "id"');
+    throw new Error("Missing required field \"id\"");
   }
 
   var value = message["from_timestamp"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "from_timestamp"');
+    throw new Error("Missing required field \"from_timestamp\"");
   }
 
   var value = message["loader"];
   if (value != null) {
     var encoded = Loader[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
-      );
-    bb.writeByte(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Loader\"");
+bb.writeByte(encoded);
   } else {
-    throw new Error('Missing required field "loader"');
+    throw new Error("Missing required field \"loader\"");
   }
 
   var value = message["module_path"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "module_path"');
+    throw new Error("Missing required field \"module_path\"");
   }
 
   var value = message["log"];
   if (value != null) {
     encodeLog(value, bb);
   } else {
-    throw new Error('Missing required field "log"');
+    throw new Error("Missing required field \"log\"");
   }
+
 }
 
 function decodeDependencyManifest(bb) {
@@ -1937,44 +1961,47 @@ function decodeDependencyManifest(bb) {
 }
 
 function encodeDependencyManifest(message, bb) {
+
   var value = message["ids"];
   if (value != null) {
-    bb.writeUint32ByteArray(value);
+   bb.writeUint32ByteArray(value);
   } else {
-    throw new Error('Missing required field "ids"');
+    throw new Error("Missing required field \"ids\"");
   }
+
 }
 
 function decodeFileList(bb) {
   var result = {};
 
   var length = bb.readVarUint();
-  var values = (result["ptrs"] = Array(length));
+  var values = result["ptrs"] = Array(length);
   for (var i = 0; i < length; i++) values[i] = decodeStringPointer(bb);
   result["files"] = bb.readString();
   return result;
 }
 
 function encodeFileList(message, bb) {
+
   var value = message["ptrs"];
   if (value != null) {
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeStringPointer(value, bb);
     }
   } else {
-    throw new Error('Missing required field "ptrs"');
+    throw new Error("Missing required field \"ptrs\"");
   }
 
   var value = message["files"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "files"');
+    throw new Error("Missing required field \"files\"");
   }
+
 }
 
 function decodeWebsocketMessageResolveIDs(bb) {
@@ -1986,51 +2013,54 @@ function decodeWebsocketMessageResolveIDs(bb) {
 }
 
 function encodeWebsocketMessageResolveIDs(message, bb) {
+
   var value = message["id"];
   if (value != null) {
-    bb.writeUint32ByteArray(value);
+   bb.writeUint32ByteArray(value);
   } else {
-    throw new Error('Missing required field "id"');
+    throw new Error("Missing required field \"id\"");
   }
 
   var value = message["list"];
   if (value != null) {
     encodeFileList(value, bb);
   } else {
-    throw new Error('Missing required field "list"');
+    throw new Error("Missing required field \"list\"");
   }
+
 }
 
 function decodeWebsocketCommandResolveIDs(bb) {
   var result = {};
 
   var length = bb.readVarUint();
-  var values = (result["ptrs"] = Array(length));
+  var values = result["ptrs"] = Array(length);
   for (var i = 0; i < length; i++) values[i] = decodeStringPointer(bb);
   result["files"] = bb.readString();
   return result;
 }
 
 function encodeWebsocketCommandResolveIDs(message, bb) {
+
   var value = message["ptrs"];
   if (value != null) {
-    var values = value,
-      n = values.length;
+    var values = value, n = values.length;
     bb.writeVarUint(n);
     for (var i = 0; i < n; i++) {
       value = values[i];
       encodeStringPointer(value, bb);
     }
   } else {
-    throw new Error('Missing required field "ptrs"');
+    throw new Error("Missing required field \"ptrs\"");
   }
 
   var value = message["files"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "files"');
+    throw new Error("Missing required field \"files\"");
   }
+
 }
 
 function decodeWebsocketMessageManifestSuccess(bb) {
@@ -2044,38 +2074,37 @@ function decodeWebsocketMessageManifestSuccess(bb) {
 }
 
 function encodeWebsocketMessageManifestSuccess(message, bb) {
+
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "id"');
+    throw new Error("Missing required field \"id\"");
   }
 
   var value = message["module_path"];
   if (value != null) {
     bb.writeString(value);
   } else {
-    throw new Error('Missing required field "module_path"');
+    throw new Error("Missing required field \"module_path\"");
   }
 
   var value = message["loader"];
   if (value != null) {
     var encoded = Loader[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
-      );
-    bb.writeByte(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Loader\"");
+bb.writeByte(encoded);
   } else {
-    throw new Error('Missing required field "loader"');
+    throw new Error("Missing required field \"loader\"");
   }
 
   var value = message["manifest"];
   if (value != null) {
     encodeDependencyManifest(value, bb);
   } else {
-    throw new Error('Missing required field "manifest"');
+    throw new Error("Missing required field \"manifest\"");
   }
+
 }
 
 function decodeWebsocketMessageManifestFailure(bb) {
@@ -2089,139 +2118,140 @@ function decodeWebsocketMessageManifestFailure(bb) {
 }
 
 function encodeWebsocketMessageManifestFailure(message, bb) {
+
   var value = message["id"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "id"');
+    throw new Error("Missing required field \"id\"");
   }
 
   var value = message["from_timestamp"];
   if (value != null) {
     bb.writeUint32(value);
   } else {
-    throw new Error('Missing required field "from_timestamp"');
+    throw new Error("Missing required field \"from_timestamp\"");
   }
 
   var value = message["loader"];
   if (value != null) {
     var encoded = Loader[value];
-    if (encoded === void 0)
-      throw new Error(
-        "Invalid value " + JSON.stringify(value) + ' for enum "Loader"'
-      );
-    bb.writeByte(encoded);
+if (encoded === void 0) throw new Error("Invalid value " + JSON.stringify(value) + " for enum \"Loader\"");
+bb.writeByte(encoded);
   } else {
-    throw new Error('Missing required field "loader"');
+    throw new Error("Missing required field \"loader\"");
   }
 
   var value = message["log"];
   if (value != null) {
     encodeLog(value, bb);
   } else {
-    throw new Error('Missing required field "log"');
-  }
-}
-
-export { Loader };
-export { LoaderKeys };
-export { ResolveMode };
-export { ResolveModeKeys };
-export { Platform };
-export { PlatformKeys };
-export { JSXRuntime };
-export { JSXRuntimeKeys };
-export { decodeJSX };
-export { encodeJSX };
-export { decodeStringPointer };
-export { encodeStringPointer };
-export { decodeJavascriptBundledModule };
-export { encodeJavascriptBundledModule };
-export { decodeJavascriptBundledPackage };
-export { encodeJavascriptBundledPackage };
-export { decodeJavascriptBundle };
-export { encodeJavascriptBundle };
-export { decodeJavascriptBundleContainer };
-export { encodeJavascriptBundleContainer };
-export { ScanDependencyMode };
-export { ScanDependencyModeKeys };
-export { ModuleImportType };
-export { ModuleImportTypeKeys };
-export { decodeModuleImportRecord };
-export { encodeModuleImportRecord };
-export { decodeModule };
-export { encodeModule };
-export { decodeStringMap };
-export { encodeStringMap };
-export { decodeLoaderMap };
-export { encodeLoaderMap };
-export { DotEnvBehavior };
-export { DotEnvBehaviorKeys };
-export { decodeEnvConfig };
-export { encodeEnvConfig };
-export { decodeLoadedEnvConfig };
-export { encodeLoadedEnvConfig };
-export { decodeFrameworkConfig };
-export { encodeFrameworkConfig };
-export { decodeLoadedFramework };
-export { encodeLoadedFramework };
-export { decodeLoadedRouteConfig };
-export { encodeLoadedRouteConfig };
-export { decodeRouteConfig };
-export { encodeRouteConfig };
-export { decodeTransformOptions };
-export { encodeTransformOptions };
-export { decodeFileHandle };
-export { encodeFileHandle };
-export { decodeTransform };
-export { encodeTransform };
-export { TransformResponseStatus };
-export { TransformResponseStatusKeys };
-export { decodeOutputFile };
-export { encodeOutputFile };
-export { decodeTransformResponse };
-export { encodeTransformResponse };
-export { MessageKind };
-export { MessageKindKeys };
-export { decodeLocation };
-export { encodeLocation };
-export { decodeMessageData };
-export { encodeMessageData };
-export { decodeMessage };
-export { encodeMessage };
-export { decodeLog };
-export { encodeLog };
-export { Reloader };
-export { ReloaderKeys };
-export { WebsocketMessageKind };
-export { WebsocketMessageKindKeys };
-export { WebsocketCommandKind };
-export { WebsocketCommandKindKeys };
-export { decodeWebsocketMessage };
-export { encodeWebsocketMessage };
-export { decodeWebsocketMessageWelcome };
-export { encodeWebsocketMessageWelcome };
-export { decodeWebsocketMessageFileChangeNotification };
-export { encodeWebsocketMessageFileChangeNotification };
-export { decodeWebsocketCommand };
-export { encodeWebsocketCommand };
-export { decodeWebsocketCommandBuild };
-export { encodeWebsocketCommandBuild };
-export { decodeWebsocketCommandManifest };
-export { encodeWebsocketCommandManifest };
-export { decodeWebsocketMessageBuildSuccess };
-export { encodeWebsocketMessageBuildSuccess };
-export { decodeWebsocketMessageBuildFailure };
-export { encodeWebsocketMessageBuildFailure };
-export { decodeDependencyManifest };
-export { encodeDependencyManifest };
-export { decodeFileList };
-export { encodeFileList };
-export { decodeWebsocketMessageResolveIDs };
-export { encodeWebsocketMessageResolveIDs };
-export { decodeWebsocketCommandResolveIDs };
-export { encodeWebsocketCommandResolveIDs };
-export { decodeWebsocketMessageManifestSuccess };
-export { encodeWebsocketMessageManifestSuccess };
-export { decodeWebsocketMessageManifestFailure };
-export { encodeWebsocketMessageManifestFailure };
+    throw new Error("Missing required field \"log\"");
+  }
+
+}
+
+export { Loader }
+export { LoaderKeys }
+export { ResolveMode }
+export { ResolveModeKeys }
+export { Platform }
+export { PlatformKeys }
+export { CSSInJSBehavior }
+export { CSSInJSBehaviorKeys }
+export { JSXRuntime }
+export { JSXRuntimeKeys }
+export { decodeJSX }
+export { encodeJSX }
+export { decodeStringPointer }
+export { encodeStringPointer }
+export { decodeJavascriptBundledModule }
+export { encodeJavascriptBundledModule }
+export { decodeJavascriptBundledPackage }
+export { encodeJavascriptBundledPackage }
+export { decodeJavascriptBundle }
+export { encodeJavascriptBundle }
+export { decodeJavascriptBundleContainer }
+export { encodeJavascriptBundleContainer }
+export { ScanDependencyMode }
+export { ScanDependencyModeKeys }
+export { ModuleImportType }
+export { ModuleImportTypeKeys }
+export { decodeModuleImportRecord }
+export { encodeModuleImportRecord }
+export { decodeModule }
+export { encodeModule }
+export { decodeStringMap }
+export { encodeStringMap }
+export { decodeLoaderMap }
+export { encodeLoaderMap }
+export { DotEnvBehavior }
+export { DotEnvBehaviorKeys }
+export { decodeEnvConfig }
+export { encodeEnvConfig }
+export { decodeLoadedEnvConfig }
+export { encodeLoadedEnvConfig }
+export { decodeFrameworkConfig }
+export { encodeFrameworkConfig }
+export { decodeLoadedFramework }
+export { encodeLoadedFramework }
+export { decodeLoadedRouteConfig }
+export { encodeLoadedRouteConfig }
+export { decodeRouteConfig }
+export { encodeRouteConfig }
+export { decodeTransformOptions }
+export { encodeTransformOptions }
+export { decodeFileHandle }
+export { encodeFileHandle }
+export { decodeTransform }
+export { encodeTransform }
+export { TransformResponseStatus }
+export { TransformResponseStatusKeys }
+export { decodeOutputFile }
+export { encodeOutputFile }
+export { decodeTransformResponse }
+export { encodeTransformResponse }
+export { MessageKind }
+export { MessageKindKeys }
+export { decodeLocation }
+export { encodeLocation }
+export { decodeMessageData }
+export { encodeMessageData }
+export { decodeMessage }
+export { encodeMessage }
+export { decodeLog }
+export { encodeLog }
+export { Reloader }
+export { ReloaderKeys }
+export { WebsocketMessageKind }
+export { WebsocketMessageKindKeys }
+export { WebsocketCommandKind }
+export { WebsocketCommandKindKeys }
+export { decodeWebsocketMessage }
+export { encodeWebsocketMessage }
+export { decodeWebsocketMessageWelcome }
+export { encodeWebsocketMessageWelcome }
+export { decodeWebsocketMessageFileChangeNotification }
+export { encodeWebsocketMessageFileChangeNotification }
+export { decodeWebsocketCommand }
+export { encodeWebsocketCommand }
+export { decodeWebsocketCommandBuild }
+export { encodeWebsocketCommandBuild }
+export { decodeWebsocketCommandManifest }
+export { encodeWebsocketCommandManifest }
+export { decodeWebsocketMessageBuildSuccess }
+export { encodeWebsocketMessageBuildSuccess }
+export { decodeWebsocketMessageBuildFailure }
+export { encodeWebsocketMessageBuildFailure }
+export { decodeDependencyManifest }
+export { encodeDependencyManifest }
+export { decodeFileList }
+export { encodeFileList }
+export { decodeWebsocketMessageResolveIDs }
+export { encodeWebsocketMessageResolveIDs }
+export { decodeWebsocketCommandResolveIDs }
+export { encodeWebsocketCommandResolveIDs }
+export { decodeWebsocketMessageManifestSuccess }
+export { encodeWebsocketMessageManifestSuccess }
+export { decodeWebsocketMessageManifestFailure }
+export { encodeWebsocketMessageManifestFailure }
\ No newline at end of file
diff --git a/src/api/schema.peechy b/src/api/schema.peechy
index a40cacef1..63c8501b2 100644
--- a/src/api/schema.peechy
+++ b/src/api/schema.peechy
@@ -23,6 +23,11 @@ smol Platform {
   bun = 3;
 }
 
+smol CSSInJSBehavior {
+  facade = 1;
+  facade_onimportcss = 2;
+}
+
 smol JSXRuntime {
   automatic = 1;
   classic = 2;
@@ -31,7 +36,7 @@ smol JSXRuntime {
 struct JSX {
   string factory;
   JSXRuntime runtime;
-  string fragment;
+  string fragment;\
   bool development;
 
   // Probably react
@@ -160,6 +165,8 @@ message FrameworkConfig {
   bool development = 4;
   EnvConfig client_env = 5;
   EnvConfig server_env = 6;
+
+  CSSInJSBehavior client_css_in_js = 7;
 }
 
 struct LoadedFramework {
@@ -168,6 +175,8 @@ struct LoadedFramework {
   bool development;
   bool client;
   LoadedEnvConfig env;
+
+  CSSInJSBehavior client_css_in_js;
 }
 
 struct LoadedRouteConfig {
diff --git a/src/api/schema.zig b/src/api/schema.zig
index 69a77082a..9219bcaa7 100644
--- a/src/api/schema.zig
+++ b/src/api/schema.zig
@@ -1,4 +1,3 @@
-
 const std = @import("std");
 
 pub const Reader = struct {
@@ -282,1826 +281,1749 @@ pub fn Writer(comptime WritableStream: type) type {
 pub const ByteWriter = Writer(*std.io.FixedBufferStream([]u8));
 pub const FileWriter = Writer(std.fs.File);
 
+pub const Api = struct {
+    pub const Loader = enum(u8) {
+        _none,
+        /// jsx
+        jsx,
 
+        /// js
+        js,
 
+        /// ts
+        ts,
 
-pub const Api = struct { 
-
-pub const Loader = enum(u8) {
-
-_none,
-  /// jsx
-  jsx,
-
-  /// js
-  js,
-
-  /// ts
-  ts,
-
-  /// tsx
-  tsx,
-
-  /// css
-  css,
-
-  /// file
-  file,
-
-  /// json
-  json,
-
-_,
-
-                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-                    return try std.json.stringify(@tagName(self), opts, o);
-                }
-
-                
-};
-
-pub const ResolveMode = enum(u8) {
-
-_none,
-  /// disable
-  disable,
+        /// tsx
+        tsx,
 
-  /// lazy
-  lazy,
+        /// css
+        css,
 
-  /// dev
-  dev,
+        /// file
+        file,
 
-  /// bundle
-  bundle,
+        /// json
+        json,
 
-_,
+        _,
 
-                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-                    return try std.json.stringify(@tagName(self), opts, o);
-                }
-
-                
-};
-
-pub const Platform = enum(u8) {
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
 
-_none,
-  /// browser
-  browser,
+    pub const ResolveMode = enum(u8) {
+        _none,
+        /// disable
+        disable,
 
-  /// node
-  node,
+        /// lazy
+        lazy,
 
-  /// bun
-  bun,
+        /// dev
+        dev,
 
-_,
+        /// bundle
+        bundle,
 
-                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-                    return try std.json.stringify(@tagName(self), opts, o);
-                }
+        _,
 
-                
-};
-
-pub const JsxRuntime = enum(u8) {
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
 
-_none,
-  /// automatic
-  automatic,
+    pub const Platform = enum(u8) {
+        _none,
+        /// browser
+        browser,
 
-  /// classic
-  classic,
+        /// node
+        node,
 
-_,
+        /// bun
+        bun,
 
-                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-                    return try std.json.stringify(@tagName(self), opts, o);
-                }
+        _,
 
-                
-};
-
-pub const Jsx = struct {
-/// factory
-factory: []const u8,
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
 
-/// runtime
-runtime: JsxRuntime,
+    pub const CssInJsBehavior = enum(u8) {
+        _none,
+        /// facade
+        facade,
 
-/// fragment
-fragment: []const u8,
+        /// facade_onimportcss
+        facade_onimportcss,
 
-/// development
-development: bool = false,
+        _,
 
-/// import_source
-import_source: []const u8,
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
 
-/// react_fast_refresh
-react_fast_refresh: bool = false,
+    pub const JsxRuntime = enum(u8) {
+        _none,
+        /// automatic
+        automatic,
 
+        /// classic
+        classic,
 
-pub fn decode(reader: anytype) anyerror!Jsx {
-  var this = std.mem.zeroes(Jsx);
+        _,
 
-  this.factory = try reader.readValue([]const u8); 
-  this.runtime = try reader.readValue(JsxRuntime); 
-  this.fragment = try reader.readValue([]const u8); 
-  this.development = try reader.readValue(bool); 
-  this.import_source = try reader.readValue([]const u8); 
-  this.react_fast_refresh = try reader.readValue(bool); 
-   return this;
-}
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeValue(this.factory);
-   try writer.writeEnum(this.runtime);
-   try writer.writeValue(this.fragment);
-   try writer.writeInt(@intCast(u8, @boolToInt(this.development)));
-   try writer.writeValue(this.import_source);
-   try writer.writeInt(@intCast(u8, @boolToInt(this.react_fast_refresh)));
-}
+    pub const Jsx = struct {
+        /// factory
+        factory: []const u8,
 
-};
+        /// runtime
+        runtime: JsxRuntime,
 
-pub const StringPointer = packed struct {
-/// offset
-offset: u32 = 0,
+        /// fragment
+        fragment: []const u8,
 
-/// length
-length: u32 = 0,
+        /// development
+        development: bool = false,
 
+        /// import_source
+        import_source: []const u8,
 
-pub fn decode(reader: anytype) anyerror!StringPointer {
-  var this = std.mem.zeroes(StringPointer);
+        /// react_fast_refresh
+        react_fast_refresh: bool = false,
 
-  this.offset = try reader.readValue(u32); 
-  this.length = try reader.readValue(u32); 
-   return this;
-}
+        pub fn decode(reader: anytype) anyerror!Jsx {
+            var this = std.mem.zeroes(Jsx);
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeInt(this.offset);
-   try writer.writeInt(this.length);
-}
+            this.factory = try reader.readValue([]const u8);
+            this.runtime = try reader.readValue(JsxRuntime);
+            this.fragment = try reader.readValue([]const u8);
+            this.development = try reader.readValue(bool);
+            this.import_source = try reader.readValue([]const u8);
+            this.react_fast_refresh = try reader.readValue(bool);
+            return this;
+        }
 
-};
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeValue(this.factory);
+            try writer.writeEnum(this.runtime);
+            try writer.writeValue(this.fragment);
+            try writer.writeInt(@intCast(u8, @boolToInt(this.development)));
+            try writer.writeValue(this.import_source);
+            try writer.writeInt(@intCast(u8, @boolToInt(this.react_fast_refresh)));
+        }
+    };
 
-pub const JavascriptBundledModule = struct {
-/// path
-path: StringPointer,
+    pub const StringPointer = packed struct {
+        /// offset
+        offset: u32 = 0,
 
-/// code
-code: StringPointer,
+        /// length
+        length: u32 = 0,
 
-/// package_id
-package_id: u32 = 0,
+        pub fn decode(reader: anytype) anyerror!StringPointer {
+            var this = std.mem.zeroes(StringPointer);
 
-/// id
-id: u32 = 0,
+            this.offset = try reader.readValue(u32);
+            this.length = try reader.readValue(u32);
+            return this;
+        }
 
-/// path_extname_length
-path_extname_length: u8 = 0,
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeInt(this.offset);
+            try writer.writeInt(this.length);
+        }
+    };
 
+    pub const JavascriptBundledModule = struct {
+        /// path
+        path: StringPointer,
 
-pub fn decode(reader: anytype) anyerror!JavascriptBundledModule {
-  var this = std.mem.zeroes(JavascriptBundledModule);
+        /// code
+        code: StringPointer,
 
-  this.path = try reader.readValue(StringPointer); 
-  this.code = try reader.readValue(StringPointer); 
-  this.package_id = try reader.readValue(u32); 
-  this.id = try reader.readValue(u32); 
-  this.path_extname_length = try reader.readValue(u8); 
-   return this;
-}
+        /// package_id
+        package_id: u32 = 0,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeValue(this.path);
-   try writer.writeValue(this.code);
-   try writer.writeInt(this.package_id);
-   try writer.writeInt(this.id);
-   try writer.writeInt(this.path_extname_length);
-}
+        /// id
+        id: u32 = 0,
 
-};
+        /// path_extname_length
+        path_extname_length: u8 = 0,
 
-pub const JavascriptBundledPackage = struct {
-/// name
-name: StringPointer,
+        pub fn decode(reader: anytype) anyerror!JavascriptBundledModule {
+            var this = std.mem.zeroes(JavascriptBundledModule);
 
-/// version
-version: StringPointer,
+            this.path = try reader.readValue(StringPointer);
+            this.code = try reader.readValue(StringPointer);
+            this.package_id = try reader.readValue(u32);
+            this.id = try reader.readValue(u32);
+            this.path_extname_length = try reader.readValue(u8);
+            return this;
+        }
 
-/// hash
-hash: u32 = 0,
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeValue(this.path);
+            try writer.writeValue(this.code);
+            try writer.writeInt(this.package_id);
+            try writer.writeInt(this.id);
+            try writer.writeInt(this.path_extname_length);
+        }
+    };
 
-/// modules_offset
-modules_offset: u32 = 0,
+    pub const JavascriptBundledPackage = struct {
+        /// name
+        name: StringPointer,
 
-/// modules_length
-modules_length: u32 = 0,
+        /// version
+        version: StringPointer,
 
+        /// hash
+        hash: u32 = 0,
 
-pub fn decode(reader: anytype) anyerror!JavascriptBundledPackage {
-  var this = std.mem.zeroes(JavascriptBundledPackage);
+        /// modules_offset
+        modules_offset: u32 = 0,
 
-  this.name = try reader.readValue(StringPointer); 
-  this.version = try reader.readValue(StringPointer); 
-  this.hash = try reader.readValue(u32); 
-  this.modules_offset = try reader.readValue(u32); 
-  this.modules_length = try reader.readValue(u32); 
-   return this;
-}
+        /// modules_length
+        modules_length: u32 = 0,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeValue(this.name);
-   try writer.writeValue(this.version);
-   try writer.writeInt(this.hash);
-   try writer.writeInt(this.modules_offset);
-   try writer.writeInt(this.modules_length);
-}
+        pub fn decode(reader: anytype) anyerror!JavascriptBundledPackage {
+            var this = std.mem.zeroes(JavascriptBundledPackage);
 
-};
+            this.name = try reader.readValue(StringPointer);
+            this.version = try reader.readValue(StringPointer);
+            this.hash = try reader.readValue(u32);
+            this.modules_offset = try reader.readValue(u32);
+            this.modules_length = try reader.readValue(u32);
+            return this;
+        }
 
-pub const JavascriptBundle = struct {
-/// modules
-modules: []const JavascriptBundledModule,
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeValue(this.name);
+            try writer.writeValue(this.version);
+            try writer.writeInt(this.hash);
+            try writer.writeInt(this.modules_offset);
+            try writer.writeInt(this.modules_length);
+        }
+    };
 
-/// packages
-packages: []const JavascriptBundledPackage,
+    pub const JavascriptBundle = struct {
+        /// modules
+        modules: []const JavascriptBundledModule,
 
-/// etag
-etag: []const u8,
+        /// packages
+        packages: []const JavascriptBundledPackage,
 
-/// generated_at
-generated_at: u32 = 0,
+        /// etag
+        etag: []const u8,
 
-/// app_package_json_dependencies_hash
-app_package_json_dependencies_hash: []const u8,
+        /// generated_at
+        generated_at: u32 = 0,
 
-/// import_from_name
-import_from_name: []const u8,
+        /// app_package_json_dependencies_hash
+        app_package_json_dependencies_hash: []const u8,
 
-/// manifest_string
-manifest_string: []const u8,
+        /// import_from_name
+        import_from_name: []const u8,
 
+        /// manifest_string
+        manifest_string: []const u8,
 
-pub fn decode(reader: anytype) anyerror!JavascriptBundle {
-  var this = std.mem.zeroes(JavascriptBundle);
+        pub fn decode(reader: anytype) anyerror!JavascriptBundle {
+            var this = std.mem.zeroes(JavascriptBundle);
 
-  this.modules = try reader.readArray(JavascriptBundledModule); 
-  this.packages = try reader.readArray(JavascriptBundledPackage); 
-  this.etag = try reader.readArray(u8); 
-  this.generated_at = try reader.readValue(u32); 
-  this.app_package_json_dependencies_hash = try reader.readArray(u8); 
-  this.import_from_name = try reader.readArray(u8); 
-  this.manifest_string = try reader.readArray(u8); 
-   return this;
-}
+            this.modules = try reader.readArray(JavascriptBundledModule);
+            this.packages = try reader.readArray(JavascriptBundledPackage);
+            this.etag = try reader.readArray(u8);
+            this.generated_at = try reader.readValue(u32);
+            this.app_package_json_dependencies_hash = try reader.readArray(u8);
+            this.import_from_name = try reader.readArray(u8);
+            this.manifest_string = try reader.readArray(u8);
+            return this;
+        }
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeArray(JavascriptBundledModule, this.modules);
-   try writer.writeArray(JavascriptBundledPackage, this.packages);
-   try writer.writeArray(u8, this.etag);
-   try writer.writeInt(this.generated_at);
-   try writer.writeArray(u8, this.app_package_json_dependencies_hash);
-   try writer.writeArray(u8, this.import_from_name);
-   try writer.writeArray(u8, this.manifest_string);
-}
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeArray(JavascriptBundledModule, this.modules);
+            try writer.writeArray(JavascriptBundledPackage, this.packages);
+            try writer.writeArray(u8, this.etag);
+            try writer.writeInt(this.generated_at);
+            try writer.writeArray(u8, this.app_package_json_dependencies_hash);
+            try writer.writeArray(u8, this.import_from_name);
+            try writer.writeArray(u8, this.manifest_string);
+        }
+    };
 
-};
+    pub const JavascriptBundleContainer = struct {
+        /// bundle_format_version
+        bundle_format_version: ?u32 = null,
 
-pub const JavascriptBundleContainer = struct {
-/// bundle_format_version
-bundle_format_version: ?u32 = null,
-
-/// bundle
-bundle: ?JavascriptBundle = null,
-
-/// framework
-framework: ?LoadedFramework = null,
-
-/// routes
-routes: ?LoadedRouteConfig = null,
-
-/// code_length
-code_length: ?u32 = null,
-
-
-pub fn decode(reader: anytype) anyerror!JavascriptBundleContainer {
-  var this = std.mem.zeroes(JavascriptBundleContainer);
-
-  while(true) {
-    switch (try reader.readByte()) {
-      0 => { return this; },
-
-      1 => {
-        this.bundle_format_version = try reader.readValue(u32); 
-},
-      2 => {
-        this.bundle = try reader.readValue(JavascriptBundle); 
-},
-      3 => {
-        this.framework = try reader.readValue(LoadedFramework); 
-},
-      4 => {
-        this.routes = try reader.readValue(LoadedRouteConfig); 
-},
-      5 => {
-        this.code_length = try reader.readValue(u32); 
-},
-      else => {
-      return error.InvalidMessage;
-      },
-      }
-      }
-unreachable;
-}
+        /// bundle
+        bundle: ?JavascriptBundle = null,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-if (this.bundle_format_version) |bundle_format_version| {
-  try writer.writeFieldID(1);
-   try writer.writeInt(bundle_format_version);
-}
-if (this.bundle) |bundle| {
-  try writer.writeFieldID(2);
-   try writer.writeValue(bundle);
-}
-if (this.framework) |framework| {
-  try writer.writeFieldID(3);
-   try writer.writeValue(framework);
-}
-if (this.routes) |routes| {
-  try writer.writeFieldID(4);
-   try writer.writeValue(routes);
-}
-if (this.code_length) |code_length| {
-  try writer.writeFieldID(5);
-   try writer.writeInt(code_length);
-}
-try writer.endMessage();
-}
+        /// framework
+        framework: ?LoadedFramework = null,
 
-};
-
-pub const ScanDependencyMode = enum(u8) {
+        /// routes
+        routes: ?LoadedRouteConfig = null,
 
-_none,
-  /// app
-  app,
+        /// code_length
+        code_length: ?u32 = null,
 
-  /// all
-  all,
+        pub fn decode(reader: anytype) anyerror!JavascriptBundleContainer {
+            var this = std.mem.zeroes(JavascriptBundleContainer);
 
-_,
+            while (true) {
+                switch (try reader.readByte()) {
+                    0 => {
+                        return this;
+                    },
 
-                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-                    return try std.json.stringify(@tagName(self), opts, o);
+                    1 => {
+                        this.bundle_format_version = try reader.readValue(u32);
+                    },
+                    2 => {
+                        this.bundle = try reader.readValue(JavascriptBundle);
+                    },
+                    3 => {
+                        this.framework = try reader.readValue(LoadedFramework);
+                    },
+                    4 => {
+                        this.routes = try reader.readValue(LoadedRouteConfig);
+                    },
+                    5 => {
+                        this.code_length = try reader.readValue(u32);
+                    },
+                    else => {
+                        return error.InvalidMessage;
+                    },
                 }
+            }
+            unreachable;
+        }
 
-                
-};
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            if (this.bundle_format_version) |bundle_format_version| {
+                try writer.writeFieldID(1);
+                try writer.writeInt(bundle_format_version);
+            }
+            if (this.bundle) |bundle| {
+                try writer.writeFieldID(2);
+                try writer.writeValue(bundle);
+            }
+            if (this.framework) |framework| {
+                try writer.writeFieldID(3);
+                try writer.writeValue(framework);
+            }
+            if (this.routes) |routes| {
+                try writer.writeFieldID(4);
+                try writer.writeValue(routes);
+            }
+            if (this.code_length) |code_length| {
+                try writer.writeFieldID(5);
+                try writer.writeInt(code_length);
+            }
+            try writer.endMessage();
+        }
+    };
 
-pub const ModuleImportType = enum(u8) {
+    pub const ScanDependencyMode = enum(u8) {
+        _none,
+        /// app
+        app,
 
-_none,
-  /// import
-  import,
+        /// all
+        all,
 
-  /// require
-  require,
+        _,
 
-_,
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
 
-                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-                    return try std.json.stringify(@tagName(self), opts, o);
-                }
+    pub const ModuleImportType = enum(u8) {
+        _none,
+        /// import
+        import,
 
-                
-};
+        /// require
+        require,
 
-pub const ModuleImportRecord = struct {
-/// kind
-kind: ModuleImportType,
+        _,
 
-/// path
-path: []const u8,
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
 
-/// dynamic
-dynamic: bool = false,
+    pub const ModuleImportRecord = struct {
+        /// kind
+        kind: ModuleImportType,
 
+        /// path
+        path: []const u8,
 
-pub fn decode(reader: anytype) anyerror!ModuleImportRecord {
-  var this = std.mem.zeroes(ModuleImportRecord);
+        /// dynamic
+        dynamic: bool = false,
 
-  this.kind = try reader.readValue(ModuleImportType); 
-  this.path = try reader.readValue([]const u8); 
-  this.dynamic = try reader.readValue(bool); 
-   return this;
-}
+        pub fn decode(reader: anytype) anyerror!ModuleImportRecord {
+            var this = std.mem.zeroes(ModuleImportRecord);
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeEnum(this.kind);
-   try writer.writeValue(this.path);
-   try writer.writeInt(@intCast(u8, @boolToInt(this.dynamic)));
-}
+            this.kind = try reader.readValue(ModuleImportType);
+            this.path = try reader.readValue([]const u8);
+            this.dynamic = try reader.readValue(bool);
+            return this;
+        }
 
-};
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeEnum(this.kind);
+            try writer.writeValue(this.path);
+            try writer.writeInt(@intCast(u8, @boolToInt(this.dynamic)));
+        }
+    };
 
-pub const Module = struct {
-/// path
-path: []const u8,
+    pub const Module = struct {
+        /// path
+        path: []const u8,
 
-/// imports
-imports: []const ModuleImportRecord,
+        /// imports
+        imports: []const ModuleImportRecord,
 
+        pub fn decode(reader: anytype) anyerror!Module {
+            var this = std.mem.zeroes(Module);
 
-pub fn decode(reader: anytype) anyerror!Module {
-  var this = std.mem.zeroes(Module);
+            this.path = try reader.readValue([]const u8);
+            this.imports = try reader.readArray(ModuleImportRecord);
+            return this;
+        }
 
-  this.path = try reader.readValue([]const u8); 
-  this.imports = try reader.readArray(ModuleImportRecord); 
-   return this;
-}
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeValue(this.path);
+            try writer.writeArray(ModuleImportRecord, this.imports);
+        }
+    };
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeValue(this.path);
-   try writer.writeArray(ModuleImportRecord, this.imports);
-}
+    pub const StringMap = struct {
+        /// keys
+        keys: []const []const u8,
 
-};
+        /// values
+        values: []const []const u8,
 
-pub const StringMap = struct {
-/// keys
-keys: []const []const u8,
+        pub fn decode(reader: anytype) anyerror!StringMap {
+            var this = std.mem.zeroes(StringMap);
 
-/// values
-values: []const []const u8,
+            this.keys = try reader.readArray([]const u8);
+            this.values = try reader.readArray([]const u8);
+            return this;
+        }
 
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeArray([]const u8, this.keys);
+            try writer.writeArray([]const u8, this.values);
+        }
+    };
 
-pub fn decode(reader: anytype) anyerror!StringMap {
-  var this = std.mem.zeroes(StringMap);
+    pub const LoaderMap = struct {
+        /// extensions
+        extensions: []const []const u8,
 
-  this.keys = try reader.readArray([]const u8); 
-  this.values = try reader.readArray([]const u8); 
-   return this;
-}
+        /// loaders
+        loaders: []const Loader,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeArray([]const u8, this.keys);
-   try writer.writeArray([]const u8, this.values);
-}
+        pub fn decode(reader: anytype) anyerror!LoaderMap {
+            var this = std.mem.zeroes(LoaderMap);
 
-};
+            this.extensions = try reader.readArray([]const u8);
+            this.loaders = try reader.readArray(Loader);
+            return this;
+        }
 
-pub const LoaderMap = struct {
-/// extensions
-extensions: []const []const u8,
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeArray([]const u8, this.extensions);
+            try writer.writeArray(Loader, this.loaders);
+        }
+    };
 
-/// loaders
-loaders: []const Loader,
+    pub const DotEnvBehavior = enum(u32) {
+        _none,
+        /// disable
+        disable,
 
+        /// prefix
+        prefix,
 
-pub fn decode(reader: anytype) anyerror!LoaderMap {
-  var this = std.mem.zeroes(LoaderMap);
+        /// load_all
+        load_all,
 
-  this.extensions = try reader.readArray([]const u8); 
-  this.loaders = try reader.readArray(Loader); 
-   return this;
-}
+        _,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeArray([]const u8, this.extensions);
-   try writer.writeArray(Loader, this.loaders);
-}
-
-};
-
-pub const DotEnvBehavior = enum(u32) {
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
 
-_none,
-  /// disable
-  disable,
+    pub const EnvConfig = struct {
+        /// prefix
+        prefix: ?[]const u8 = null,
 
-  /// prefix
-  prefix,
+        /// defaults
+        defaults: ?StringMap = null,
 
-  /// load_all
-  load_all,
+        pub fn decode(reader: anytype) anyerror!EnvConfig {
+            var this = std.mem.zeroes(EnvConfig);
 
-_,
+            while (true) {
+                switch (try reader.readByte()) {
+                    0 => {
+                        return this;
+                    },
 
-                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-                    return try std.json.stringify(@tagName(self), opts, o);
+                    1 => {
+                        this.prefix = try reader.readValue([]const u8);
+                    },
+                    2 => {
+                        this.defaults = try reader.readValue(StringMap);
+                    },
+                    else => {
+                        return error.InvalidMessage;
+                    },
                 }
+            }
+            unreachable;
+        }
 
-                
-};
-
-pub const EnvConfig = struct {
-/// prefix
-prefix: ?[]const u8 = null,
-
-/// defaults
-defaults: ?StringMap = null,
-
-
-pub fn decode(reader: anytype) anyerror!EnvConfig {
-  var this = std.mem.zeroes(EnvConfig);
-
-  while(true) {
-    switch (try reader.readByte()) {
-      0 => { return this; },
-
-      1 => {
-        this.prefix = try reader.readValue([]const u8); 
-},
-      2 => {
-        this.defaults = try reader.readValue(StringMap); 
-},
-      else => {
-      return error.InvalidMessage;
-      },
-      }
-      }
-unreachable;
-}
-
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-if (this.prefix) |prefix| {
-  try writer.writeFieldID(1);
-   try writer.writeValue(prefix);
-}
-if (this.defaults) |defaults| {
-  try writer.writeFieldID(2);
-   try writer.writeValue(defaults);
-}
-try writer.endMessage();
-}
-
-};
-
-pub const LoadedEnvConfig = struct {
-/// dotenv
-dotenv: DotEnvBehavior,
-
-/// defaults
-defaults: StringMap,
-
-/// prefix
-prefix: []const u8,
-
-
-pub fn decode(reader: anytype) anyerror!LoadedEnvConfig {
-  var this = std.mem.zeroes(LoadedEnvConfig);
-
-  this.dotenv = try reader.readValue(DotEnvBehavior); 
-  this.defaults = try reader.readValue(StringMap); 
-  this.prefix = try reader.readValue([]const u8); 
-   return this;
-}
-
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeEnum(this.dotenv);
-   try writer.writeValue(this.defaults);
-   try writer.writeValue(this.prefix);
-}
-
-};
-
-pub const FrameworkConfig = struct {
-/// package
-package: ?[]const u8 = null,
-
-/// client
-client: ?[]const u8 = null,
-
-/// server
-server: ?[]const u8 = null,
-
-/// development
-development: ?bool = null,
-
-/// client_env
-client_env: ?EnvConfig = null,
-
-/// server_env
-server_env: ?EnvConfig = null,
-
-
-pub fn decode(reader: anytype) anyerror!FrameworkConfig {
-  var this = std.mem.zeroes(FrameworkConfig);
-
-  while(true) {
-    switch (try reader.readByte()) {
-      0 => { return this; },
-
-      1 => {
-        this.package = try reader.readValue([]const u8); 
-},
-      2 => {
-        this.client = try reader.readValue([]const u8); 
-},
-      3 => {
-        this.server = try reader.readValue([]const u8); 
-},
-      4 => {
-        this.development = try reader.readValue(bool); 
-},
-      5 => {
-        this.client_env = try reader.readValue(EnvConfig); 
-},
-      6 => {
-        this.server_env = try reader.readValue(EnvConfig); 
-},
-      else => {
-      return error.InvalidMessage;
-      },
-      }
-      }
-unreachable;
-}
-
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-if (this.package) |package| {
-  try writer.writeFieldID(1);
-   try writer.writeValue(package);
-}
-if (this.client) |client| {
-  try writer.writeFieldID(2);
-   try writer.writeValue(client);
-}
-if (this.server) |server| {
-  try writer.writeFieldID(3);
-   try writer.writeValue(server);
-}
-if (this.development) |development| {
-  try writer.writeFieldID(4);
-   try writer.writeInt(@intCast(u8, @boolToInt(development)));
-}
-if (this.client_env) |client_env| {
-  try writer.writeFieldID(5);
-   try writer.writeValue(client_env);
-}
-if (this.server_env) |server_env| {
-  try writer.writeFieldID(6);
-   try writer.writeValue(server_env);
-}
-try writer.endMessage();
-}
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            if (this.prefix) |prefix| {
+                try writer.writeFieldID(1);
+                try writer.writeValue(prefix);
+            }
+            if (this.defaults) |defaults| {
+                try writer.writeFieldID(2);
+                try writer.writeValue(defaults);
+            }
+            try writer.endMessage();
+        }
+    };
 
-};
+    pub const LoadedEnvConfig = struct {
+        /// dotenv
+        dotenv: DotEnvBehavior,
 
-pub const LoadedFramework = struct {
-/// entry_point
-entry_point: []const u8,
+        /// defaults
+        defaults: StringMap,
 
-/// package
-package: []const u8,
+        /// prefix
+        prefix: []const u8,
 
-/// development
-development: bool = false,
+        pub fn decode(reader: anytype) anyerror!LoadedEnvConfig {
+            var this = std.mem.zeroes(LoadedEnvConfig);
 
-/// client
-client: bool = false,
+            this.dotenv = try reader.readValue(DotEnvBehavior);
+            this.defaults = try reader.readValue(StringMap);
+            this.prefix = try reader.readValue([]const u8);
+            return this;
+        }
 
-/// env
-env: LoadedEnvConfig,
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeEnum(this.dotenv);
+            try writer.writeValue(this.defaults);
+            try writer.writeValue(this.prefix);
+        }
+    };
 
+    pub const FrameworkConfig = struct {
+        /// package
+        package: ?[]const u8 = null,
 
-pub fn decode(reader: anytype) anyerror!LoadedFramework {
-  var this = std.mem.zeroes(LoadedFramework);
+        /// client
+        client: ?[]const u8 = null,
 
-  this.entry_point = try reader.readValue([]const u8); 
-  this.package = try reader.readValue([]const u8); 
-  this.development = try reader.readValue(bool); 
-  this.client = try reader.readValue(bool); 
-  this.env = try reader.readValue(LoadedEnvConfig); 
-   return this;
-}
+        /// server
+        server: ?[]const u8 = null,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeValue(this.entry_point);
-   try writer.writeValue(this.package);
-   try writer.writeInt(@intCast(u8, @boolToInt(this.development)));
-   try writer.writeInt(@intCast(u8, @boolToInt(this.client)));
-   try writer.writeValue(this.env);
-}
+        /// development
+        development: ?bool = null,
 
-};
+        /// client_env
+        client_env: ?EnvConfig = null,
 
-pub const LoadedRouteConfig = struct {
-/// dir
-dir: []const u8,
+        /// server_env
+        server_env: ?EnvConfig = null,
 
-/// extensions
-extensions: []const []const u8,
+        /// client_css_in_js
+        client_css_in_js: ?CssInJsBehavior = null,
 
-/// static_dir
-static_dir: []const u8,
+        pub fn decode(reader: anytype) anyerror!FrameworkConfig {
+            var this = std.mem.zeroes(FrameworkConfig);
 
-/// asset_prefix
-asset_prefix: []const u8,
+            while (true) {
+                switch (try reader.readByte()) {
+                    0 => {
+                        return this;
+                    },
 
+                    1 => {
+                        this.package = try reader.readValue([]const u8);
+                    },
+                    2 => {
+                        this.client = try reader.readValue([]const u8);
+                    },
+                    3 => {
+                        this.server = try reader.readValue([]const u8);
+                    },
+                    4 => {
+                        this.development = try reader.readValue(bool);
+                    },
+                    5 => {
+                        this.client_env = try reader.readValue(EnvConfig);
+                    },
+                    6 => {
+                        this.server_env = try reader.readValue(EnvConfig);
+                    },
+                    7 => {
+                        this.client_css_in_js = try reader.readValue(CssInJsBehavior);
+                    },
+                    else => {
+                        return error.InvalidMessage;
+                    },
+                }
+            }
+            unreachable;
+        }
 
-pub fn decode(reader: anytype) anyerror!LoadedRouteConfig {
-  var this = std.mem.zeroes(LoadedRouteConfig);
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            if (this.package) |package| {
+                try writer.writeFieldID(1);
+                try writer.writeValue(package);
+            }
+            if (this.client) |client| {
+                try writer.writeFieldID(2);
+                try writer.writeValue(client);
+            }
+            if (this.server) |server| {
+                try writer.writeFieldID(3);
+                try writer.writeValue(server);
+            }
+            if (this.development) |development| {
+                try writer.writeFieldID(4);
+                try writer.writeInt(@intCast(u8, @boolToInt(development)));
+            }
+            if (this.client_env) |client_env| {
+                try writer.writeFieldID(5);
+                try writer.writeValue(client_env);
+            }
+            if (this.server_env) |server_env| {
+                try writer.writeFieldID(6);
+                try writer.writeValue(server_env);
+            }
+            if (this.client_css_in_js) |client_css_in_js| {
+                try writer.writeFieldID(7);
+                try writer.writeEnum(client_css_in_js);
+            }
+            try writer.endMessage();
+        }
+    };
 
-  this.dir = try reader.readValue([]const u8); 
-  this.extensions = try reader.readArray([]const u8); 
-  this.static_dir = try reader.readValue([]const u8); 
-  this.asset_prefix = try reader.readValue([]const u8); 
-   return this;
-}
+    pub const LoadedFramework = struct {
+        /// entry_point
+        entry_point: []const u8,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeValue(this.dir);
-   try writer.writeArray([]const u8, this.extensions);
-   try writer.writeValue(this.static_dir);
-   try writer.writeValue(this.asset_prefix);
-}
+        /// package
+        package: []const u8,
 
-};
+        /// development
+        development: bool = false,
 
-pub const RouteConfig = struct {
-/// dir
-dir: []const []const u8,
-
-/// extensions
-extensions: []const []const u8,
-
-/// static_dir
-static_dir: ?[]const u8 = null,
-
-/// asset_prefix
-asset_prefix: ?[]const u8 = null,
-
-
-pub fn decode(reader: anytype) anyerror!RouteConfig {
-  var this = std.mem.zeroes(RouteConfig);
-
-  while(true) {
-    switch (try reader.readByte()) {
-      0 => { return this; },
-
-      1 => {
-        this.dir = try reader.readArray([]const u8); 
-},
-      2 => {
-        this.extensions = try reader.readArray([]const u8); 
-},
-      3 => {
-        this.static_dir = try reader.readValue([]const u8); 
-},
-      4 => {
-        this.asset_prefix = try reader.readValue([]const u8); 
-},
-      else => {
-      return error.InvalidMessage;
-      },
-      }
-      }
-unreachable;
-}
+        /// client
+        client: bool = false,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-if (this.dir) |dir| {
-  try writer.writeFieldID(1);
-   try writer.writeArray([]const u8, dir);
-}
-if (this.extensions) |extensions| {
-  try writer.writeFieldID(2);
-   try writer.writeArray([]const u8, extensions);
-}
-if (this.static_dir) |static_dir| {
-  try writer.writeFieldID(3);
-   try writer.writeValue(static_dir);
-}
-if (this.asset_prefix) |asset_prefix| {
-  try writer.writeFieldID(4);
-   try writer.writeValue(asset_prefix);
-}
-try writer.endMessage();
-}
+        /// env
+        env: LoadedEnvConfig,
 
-};
+        /// client_css_in_js
+        client_css_in_js: CssInJsBehavior,
 
-pub const TransformOptions = struct {
-/// jsx
-jsx: ?Jsx = null,
+        pub fn decode(reader: anytype) anyerror!LoadedFramework {
+            var this = std.mem.zeroes(LoadedFramework);
 
-/// tsconfig_override
-tsconfig_override: ?[]const u8 = null,
-
-/// resolve
-resolve: ?ResolveMode = null,
-
-/// origin
-origin: ?[]const u8 = null,
-
-/// absolute_working_dir
-absolute_working_dir: ?[]const u8 = null,
-
-/// define
-define: ?StringMap = null,
-
-/// preserve_symlinks
-preserve_symlinks: ?bool = null,
-
-/// entry_points
-entry_points: []const []const u8,
-
-/// write
-write: ?bool = null,
-
-/// inject
-inject: []const []const u8,
-
-/// output_dir
-output_dir: ?[]const u8 = null,
-
-/// external
-external: []const []const u8,
-
-/// loaders
-loaders: ?LoaderMap = null,
-
-/// main_fields
-main_fields: []const []const u8,
-
-/// platform
-platform: ?Platform = null,
-
-/// serve
-serve: ?bool = null,
-
-/// extension_order
-extension_order: []const []const u8,
-
-/// generate_node_module_bundle
-generate_node_module_bundle: ?bool = null,
-
-/// node_modules_bundle_path
-node_modules_bundle_path: ?[]const u8 = null,
-
-/// node_modules_bundle_path_server
-node_modules_bundle_path_server: ?[]const u8 = null,
-
-/// framework
-framework: ?FrameworkConfig = null,
-
-/// router
-router: ?RouteConfig = null,
-
-
-pub fn decode(reader: anytype) anyerror!TransformOptions {
-  var this = std.mem.zeroes(TransformOptions);
-
-  while(true) {
-    switch (try reader.readByte()) {
-      0 => { return this; },
-
-      1 => {
-        this.jsx = try reader.readValue(Jsx); 
-},
-      2 => {
-        this.tsconfig_override = try reader.readValue([]const u8); 
-},
-      3 => {
-        this.resolve = try reader.readValue(ResolveMode); 
-},
-      4 => {
-        this.origin = try reader.readValue([]const u8); 
-},
-      5 => {
-        this.absolute_working_dir = try reader.readValue([]const u8); 
-},
-      6 => {
-        this.define = try reader.readValue(StringMap); 
-},
-      7 => {
-        this.preserve_symlinks = try reader.readValue(bool); 
-},
-      8 => {
-        this.entry_points = try reader.readArray([]const u8); 
-},
-      9 => {
-        this.write = try reader.readValue(bool); 
-},
-      10 => {
-        this.inject = try reader.readArray([]const u8); 
-},
-      11 => {
-        this.output_dir = try reader.readValue([]const u8); 
-},
-      12 => {
-        this.external = try reader.readArray([]const u8); 
-},
-      13 => {
-        this.loaders = try reader.readValue(LoaderMap); 
-},
-      14 => {
-        this.main_fields = try reader.readArray([]const u8); 
-},
-      15 => {
-        this.platform = try reader.readValue(Platform); 
-},
-      16 => {
-        this.serve = try reader.readValue(bool); 
-},
-      17 => {
-        this.extension_order = try reader.readArray([]const u8); 
-},
-      18 => {
-        this.generate_node_module_bundle = try reader.readValue(bool); 
-},
-      19 => {
-        this.node_modules_bundle_path = try reader.readValue([]const u8); 
-},
-      20 => {
-        this.node_modules_bundle_path_server = try reader.readValue([]const u8); 
-},
-      21 => {
-        this.framework = try reader.readValue(FrameworkConfig); 
-},
-      22 => {
-        this.router = try reader.readValue(RouteConfig); 
-},
-      else => {
-      return error.InvalidMessage;
-      },
-      }
-      }
-unreachable;
-}
+            this.entry_point = try reader.readValue([]const u8);
+            this.package = try reader.readValue([]const u8);
+            this.development = try reader.readValue(bool);
+            this.client = try reader.readValue(bool);
+            this.env = try reader.readValue(LoadedEnvConfig);
+            this.client_css_in_js = try reader.readValue(CssInJsBehavior);
+            return this;
+        }
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-if (this.jsx) |jsx| {
-  try writer.writeFieldID(1);
-   try writer.writeValue(jsx);
-}
-if (this.tsconfig_override) |tsconfig_override| {
-  try writer.writeFieldID(2);
-   try writer.writeValue(tsconfig_override);
-}
-if (this.resolve) |resolve| {
-  try writer.writeFieldID(3);
-   try writer.writeEnum(resolve);
-}
-if (this.origin) |origin| {
-  try writer.writeFieldID(4);
-   try writer.writeValue(origin);
-}
-if (this.absolute_working_dir) |absolute_working_dir| {
-  try writer.writeFieldID(5);
-   try writer.writeValue(absolute_working_dir);
-}
-if (this.define) |define| {
-  try writer.writeFieldID(6);
-   try writer.writeValue(define);
-}
-if (this.preserve_symlinks) |preserve_symlinks| {
-  try writer.writeFieldID(7);
-   try writer.writeInt(@intCast(u8, @boolToInt(preserve_symlinks)));
-}
-if (this.entry_points) |entry_points| {
-  try writer.writeFieldID(8);
-   try writer.writeArray([]const u8, entry_points);
-}
-if (this.write) |write| {
-  try writer.writeFieldID(9);
-   try writer.writeInt(@intCast(u8, @boolToInt(write)));
-}
-if (this.inject) |inject| {
-  try writer.writeFieldID(10);
-   try writer.writeArray([]const u8, inject);
-}
-if (this.output_dir) |output_dir| {
-  try writer.writeFieldID(11);
-   try writer.writeValue(output_dir);
-}
-if (this.external) |external| {
-  try writer.writeFieldID(12);
-   try writer.writeArray([]const u8, external);
-}
-if (this.loaders) |loaders| {
-  try writer.writeFieldID(13);
-   try writer.writeValue(loaders);
-}
-if (this.main_fields) |main_fields| {
-  try writer.writeFieldID(14);
-   try writer.writeArray([]const u8, main_fields);
-}
-if (this.platform) |platform| {
-  try writer.writeFieldID(15);
-   try writer.writeEnum(platform);
-}
-if (this.serve) |serve| {
-  try writer.writeFieldID(16);
-   try writer.writeInt(@intCast(u8, @boolToInt(serve)));
-}
-if (this.extension_order) |extension_order| {
-  try writer.writeFieldID(17);
-   try writer.writeArray([]const u8, extension_order);
-}
-if (this.generate_node_module_bundle) |generate_node_module_bundle| {
-  try writer.writeFieldID(18);
-   try writer.writeInt(@intCast(u8, @boolToInt(generate_node_module_bundle)));
-}
-if (this.node_modules_bundle_path) |node_modules_bundle_path| {
-  try writer.writeFieldID(19);
-   try writer.writeValue(node_modules_bundle_path);
-}
-if (this.node_modules_bundle_path_server) |node_modules_bundle_path_server| {
-  try writer.writeFieldID(20);
-   try writer.writeValue(node_modules_bundle_path_server);
-}
-if (this.framework) |framework| {
-  try writer.writeFieldID(21);
-   try writer.writeValue(framework);
-}
-if (this.router) |router| {
-  try writer.writeFieldID(22);
-   try writer.writeValue(router);
-}
-try writer.endMessage();
-}
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeValue(this.entry_point);
+            try writer.writeValue(this.package);
+            try writer.writeInt(@intCast(u8, @boolToInt(this.development)));
+            try writer.writeInt(@intCast(u8, @boolToInt(this.client)));
+            try writer.writeValue(this.env);
+            try writer.writeEnum(this.client_css_in_js);
+        }
+    };
 
-};
+    pub const LoadedRouteConfig = struct {
+        /// dir
+        dir: []const u8,
 
-pub const FileHandle = struct {
-/// path
-path: []const u8,
+        /// extensions
+        extensions: []const []const u8,
 
-/// size
-size: u32 = 0,
+        /// static_dir
+        static_dir: []const u8,
 
-/// fd
-fd: u32 = 0,
+        /// asset_prefix
+        asset_prefix: []const u8,
 
+        pub fn decode(reader: anytype) anyerror!LoadedRouteConfig {
+            var this = std.mem.zeroes(LoadedRouteConfig);
 
-pub fn decode(reader: anytype) anyerror!FileHandle {
-  var this = std.mem.zeroes(FileHandle);
+            this.dir = try reader.readValue([]const u8);
+            this.extensions = try reader.readArray([]const u8);
+            this.static_dir = try reader.readValue([]const u8);
+            this.asset_prefix = try reader.readValue([]const u8);
+            return this;
+        }
 
-  this.path = try reader.readValue([]const u8); 
-  this.size = try reader.readValue(u32); 
-  this.fd = try reader.readValue(u32); 
-   return this;
-}
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeValue(this.dir);
+            try writer.writeArray([]const u8, this.extensions);
+            try writer.writeValue(this.static_dir);
+            try writer.writeValue(this.asset_prefix);
+        }
+    };
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeValue(this.path);
-   try writer.writeInt(this.size);
-   try writer.writeInt(this.fd);
-}
+    pub const RouteConfig = struct {
+        /// dir
+        dir: []const []const u8,
 
-};
+        /// extensions
+        extensions: []const []const u8,
 
-pub const Transform = struct {
-/// handle
-handle: ?FileHandle = null,
-
-/// path
-path: ?[]const u8 = null,
-
-/// contents
-contents: []const u8,
-
-/// loader
-loader: ?Loader = null,
-
-/// options
-options: ?TransformOptions = null,
-
-
-pub fn decode(reader: anytype) anyerror!Transform {
-  var this = std.mem.zeroes(Transform);
-
-  while(true) {
-    switch (try reader.readByte()) {
-      0 => { return this; },
-
-      1 => {
-        this.handle = try reader.readValue(FileHandle); 
-},
-      2 => {
-        this.path = try reader.readValue([]const u8); 
-},
-      3 => {
-        this.contents = try reader.readArray(u8); 
-},
-      4 => {
-        this.loader = try reader.readValue(Loader); 
-},
-      5 => {
-        this.options = try reader.readValue(TransformOptions); 
-},
-      else => {
-      return error.InvalidMessage;
-      },
-      }
-      }
-unreachable;
-}
+        /// static_dir
+        static_dir: ?[]const u8 = null,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-if (this.handle) |handle| {
-  try writer.writeFieldID(1);
-   try writer.writeValue(handle);
-}
-if (this.path) |path| {
-  try writer.writeFieldID(2);
-   try writer.writeValue(path);
-}
-if (this.contents) |contents| {
-  try writer.writeFieldID(3);
-   try writer.writeArray(u8, contents);
-}
-if (this.loader) |loader| {
-  try writer.writeFieldID(4);
-   try writer.writeEnum(loader);
-}
-if (this.options) |options| {
-  try writer.writeFieldID(5);
-   try writer.writeValue(options);
-}
-try writer.endMessage();
-}
+        /// asset_prefix
+        asset_prefix: ?[]const u8 = null,
 
-};
+        pub fn decode(reader: anytype) anyerror!RouteConfig {
+            var this = std.mem.zeroes(RouteConfig);
 
-pub const TransformResponseStatus = enum(u32) {
+            while (true) {
+                switch (try reader.readByte()) {
+                    0 => {
+                        return this;
+                    },
 
-_none,
-  /// success
-  success,
+                    1 => {
+                        this.dir = try reader.readArray([]const u8);
+                    },
+                    2 => {
+                        this.extensions = try reader.readArray([]const u8);
+                    },
+                    3 => {
+                        this.static_dir = try reader.readValue([]const u8);
+                    },
+                    4 => {
+                        this.asset_prefix = try reader.readValue([]const u8);
+                    },
+                    else => {
+                        return error.InvalidMessage;
+                    },
+                }
+            }
+            unreachable;
+        }
 
-  /// fail
-  fail,
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            if (this.dir) |dir| {
+                try writer.writeFieldID(1);
+                try writer.writeArray([]const u8, dir);
+            }
+            if (this.extensions) |extensions| {
+                try writer.writeFieldID(2);
+                try writer.writeArray([]const u8, extensions);
+            }
+            if (this.static_dir) |static_dir| {
+                try writer.writeFieldID(3);
+                try writer.writeValue(static_dir);
+            }
+            if (this.asset_prefix) |asset_prefix| {
+                try writer.writeFieldID(4);
+                try writer.writeValue(asset_prefix);
+            }
+            try writer.endMessage();
+        }
+    };
 
-_,
+    pub const TransformOptions = struct {
+        /// jsx
+        jsx: ?Jsx = null,
 
-                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-                    return try std.json.stringify(@tagName(self), opts, o);
-                }
+        /// tsconfig_override
+        tsconfig_override: ?[]const u8 = null,
 
-                
-};
+        /// resolve
+        resolve: ?ResolveMode = null,
 
-pub const OutputFile = struct {
-/// data
-data: []const u8,
+        /// origin
+        origin: ?[]const u8 = null,
 
-/// path
-path: []const u8,
+        /// absolute_working_dir
+        absolute_working_dir: ?[]const u8 = null,
 
+        /// define
+        define: ?StringMap = null,
 
-pub fn decode(reader: anytype) anyerror!OutputFile {
-  var this = std.mem.zeroes(OutputFile);
+        /// preserve_symlinks
+        preserve_symlinks: ?bool = null,
 
-  this.data = try reader.readArray(u8); 
-  this.path = try reader.readValue([]const u8); 
-   return this;
-}
+        /// entry_points
+        entry_points: []const []const u8,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeArray(u8, this.data);
-   try writer.writeValue(this.path);
-}
+        /// write
+        write: ?bool = null,
 
-};
+        /// inject
+        inject: []const []const u8,
 
-pub const TransformResponse = struct {
-/// status
-status: TransformResponseStatus,
+        /// output_dir
+        output_dir: ?[]const u8 = null,
 
-/// files
-files: []const OutputFile,
+        /// external
+        external: []const []const u8,
 
-/// errors
-errors: []const Message,
+        /// loaders
+        loaders: ?LoaderMap = null,
 
+        /// main_fields
+        main_fields: []const []const u8,
 
-pub fn decode(reader: anytype) anyerror!TransformResponse {
-  var this = std.mem.zeroes(TransformResponse);
+        /// platform
+        platform: ?Platform = null,
 
-  this.status = try reader.readValue(TransformResponseStatus); 
-  this.files = try reader.readArray(OutputFile); 
-  this.errors = try reader.readArray(Message); 
-   return this;
-}
+        /// serve
+        serve: ?bool = null,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeEnum(this.status);
-   try writer.writeArray(OutputFile, this.files);
-   try writer.writeArray(Message, this.errors);
-}
+        /// extension_order
+        extension_order: []const []const u8,
 
-};
+        /// generate_node_module_bundle
+        generate_node_module_bundle: ?bool = null,
 
-pub const MessageKind = enum(u32) {
+        /// node_modules_bundle_path
+        node_modules_bundle_path: ?[]const u8 = null,
 
-_none,
-  /// err
-  err,
+        /// node_modules_bundle_path_server
+        node_modules_bundle_path_server: ?[]const u8 = null,
 
-  /// warn
-  warn,
+        /// framework
+        framework: ?FrameworkConfig = null,
 
-  /// note
-  note,
+        /// router
+        router: ?RouteConfig = null,
 
-  /// debug
-  debug,
+        pub fn decode(reader: anytype) anyerror!TransformOptions {
+            var this = std.mem.zeroes(TransformOptions);
 
-_,
+            while (true) {
+                switch (try reader.readByte()) {
+                    0 => {
+                        return this;
+                    },
 
-                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-                    return try std.json.stringify(@tagName(self), opts, o);
+                    1 => {
+                        this.jsx = try reader.readValue(Jsx);
+                    },
+                    2 => {
+                        this.tsconfig_override = try reader.readValue([]const u8);
+                    },
+                    3 => {
+                        this.resolve = try reader.readValue(ResolveMode);
+                    },
+                    4 => {
+                        this.origin = try reader.readValue([]const u8);
+                    },
+                    5 => {
+                        this.absolute_working_dir = try reader.readValue([]const u8);
+                    },
+                    6 => {
+                        this.define = try reader.readValue(StringMap);
+                    },
+                    7 => {
+                        this.preserve_symlinks = try reader.readValue(bool);
+                    },
+                    8 => {
+                        this.entry_points = try reader.readArray([]const u8);
+                    },
+                    9 => {
+                        this.write = try reader.readValue(bool);
+                    },
+                    10 => {
+                        this.inject = try reader.readArray([]const u8);
+                    },
+                    11 => {
+                        this.output_dir = try reader.readValue([]const u8);
+                    },
+                    12 => {
+                        this.external = try reader.readArray([]const u8);
+                    },
+                    13 => {
+                        this.loaders = try reader.readValue(LoaderMap);
+                    },
+                    14 => {
+                        this.main_fields = try reader.readArray([]const u8);
+                    },
+                    15 => {
+                        this.platform = try reader.readValue(Platform);
+                    },
+                    16 => {
+                        this.serve = try reader.readValue(bool);
+                    },
+                    17 => {
+                        this.extension_order = try reader.readArray([]const u8);
+                    },
+                    18 => {
+                        this.generate_node_module_bundle = try reader.readValue(bool);
+                    },
+                    19 => {
+                        this.node_modules_bundle_path = try reader.readValue([]const u8);
+                    },
+                    20 => {
+                        this.node_modules_bundle_path_server = try reader.readValue([]const u8);
+                    },
+                    21 => {
+                        this.framework = try reader.readValue(FrameworkConfig);
+                    },
+                    22 => {
+                        this.router = try reader.readValue(RouteConfig);
+                    },
+                    else => {
+                        return error.InvalidMessage;
+                    },
                 }
+            }
+            unreachable;
+        }
 
-                
-};
-
-pub const Location = struct {
-/// file
-file: []const u8,
-
-/// namespace
-namespace: []const u8,
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            if (this.jsx) |jsx| {
+                try writer.writeFieldID(1);
+                try writer.writeValue(jsx);
+            }
+            if (this.tsconfig_override) |tsconfig_override| {
+                try writer.writeFieldID(2);
+                try writer.writeValue(tsconfig_override);
+            }
+            if (this.resolve) |resolve| {
+                try writer.writeFieldID(3);
+                try writer.writeEnum(resolve);
+            }
+            if (this.origin) |origin| {
+                try writer.writeFieldID(4);
+                try writer.writeValue(origin);
+            }
+            if (this.absolute_working_dir) |absolute_working_dir| {
+                try writer.writeFieldID(5);
+                try writer.writeValue(absolute_working_dir);
+            }
+            if (this.define) |define| {
+                try writer.writeFieldID(6);
+                try writer.writeValue(define);
+            }
+            if (this.preserve_symlinks) |preserve_symlinks| {
+                try writer.writeFieldID(7);
+                try writer.writeInt(@intCast(u8, @boolToInt(preserve_symlinks)));
+            }
+            if (this.entry_points) |entry_points| {
+                try writer.writeFieldID(8);
+                try writer.writeArray([]const u8, entry_points);
+            }
+            if (this.write) |write| {
+                try writer.writeFieldID(9);
+                try writer.writeInt(@intCast(u8, @boolToInt(write)));
+            }
+            if (this.inject) |inject| {
+                try writer.writeFieldID(10);
+                try writer.writeArray([]const u8, inject);
+            }
+            if (this.output_dir) |output_dir| {
+                try writer.writeFieldID(11);
+                try writer.writeValue(output_dir);
+            }
+            if (this.external) |external| {
+                try writer.writeFieldID(12);
+                try writer.writeArray([]const u8, external);
+            }
+            if (this.loaders) |loaders| {
+                try writer.writeFieldID(13);
+                try writer.writeValue(loaders);
+            }
+            if (this.main_fields) |main_fields| {
+                try writer.writeFieldID(14);
+                try writer.writeArray([]const u8, main_fields);
+            }
+            if (this.platform) |platform| {
+                try writer.writeFieldID(15);
+                try writer.writeEnum(platform);
+            }
+            if (this.serve) |serve| {
+                try writer.writeFieldID(16);
+                try writer.writeInt(@intCast(u8, @boolToInt(serve)));
+            }
+            if (this.extension_order) |extension_order| {
+                try writer.writeFieldID(17);
+                try writer.writeArray([]const u8, extension_order);
+            }
+            if (this.generate_node_module_bundle) |generate_node_module_bundle| {
+                try writer.writeFieldID(18);
+                try writer.writeInt(@intCast(u8, @boolToInt(generate_node_module_bundle)));
+            }
+            if (this.node_modules_bundle_path) |node_modules_bundle_path| {
+                try writer.writeFieldID(19);
+                try writer.writeValue(node_modules_bundle_path);
+            }
+            if (this.node_modules_bundle_path_server) |node_modules_bundle_path_server| {
+                try writer.writeFieldID(20);
+                try writer.writeValue(node_modules_bundle_path_server);
+            }
+            if (this.framework) |framework| {
+                try writer.writeFieldID(21);
+                try writer.writeValue(framework);
+            }
+            if (this.router) |router| {
+                try writer.writeFieldID(22);
+                try writer.writeValue(router);
+            }
+            try writer.endMessage();
+        }
+    };
 
-/// line
-line: i32 = 0,
+    pub const FileHandle = struct {
+        /// path
+        path: []const u8,
 
-/// column
-column: i32 = 0,
+        /// size
+        size: u32 = 0,
 
-/// line_text
-line_text: []const u8,
+        /// fd
+        fd: u32 = 0,
 
-/// suggestion
-suggestion: []const u8,
+        pub fn decode(reader: anytype) anyerror!FileHandle {
+            var this = std.mem.zeroes(FileHandle);
 
-/// offset
-offset: u32 = 0,
+            this.path = try reader.readValue([]const u8);
+            this.size = try reader.readValue(u32);
+            this.fd = try reader.readValue(u32);
+            return this;
+        }
 
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeValue(this.path);
+            try writer.writeInt(this.size);
+            try writer.writeInt(this.fd);
+        }
+    };
 
-pub fn decode(reader: anytype) anyerror!Location {
-  var this = std.mem.zeroes(Location);
+    pub const Transform = struct {
+        /// handle
+        handle: ?FileHandle = null,
 
-  this.file = try reader.readValue([]const u8); 
-  this.namespace = try reader.readValue([]const u8); 
-  this.line = try reader.readValue(i32); 
-  this.column = try reader.readValue(i32); 
-  this.line_text = try reader.readValue([]const u8); 
-  this.suggestion = try reader.readValue([]const u8); 
-  this.offset = try reader.readValue(u32); 
-   return this;
-}
+        /// path
+        path: ?[]const u8 = null,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeValue(this.file);
-   try writer.writeValue(this.namespace);
-   try writer.writeInt(this.line);
-   try writer.writeInt(this.column);
-   try writer.writeValue(this.line_text);
-   try writer.writeValue(this.suggestion);
-   try writer.writeInt(this.offset);
-}
+        /// contents
+        contents: []const u8,
 
-};
+        /// loader
+        loader: ?Loader = null,
 
-pub const MessageData = struct {
-/// text
-text: ?[]const u8 = null,
-
-/// location
-location: ?Location = null,
-
-
-pub fn decode(reader: anytype) anyerror!MessageData {
-  var this = std.mem.zeroes(MessageData);
-
-  while(true) {
-    switch (try reader.readByte()) {
-      0 => { return this; },
-
-      1 => {
-        this.text = try reader.readValue([]const u8); 
-},
-      2 => {
-        this.location = try reader.readValue(Location); 
-},
-      else => {
-      return error.InvalidMessage;
-      },
-      }
-      }
-unreachable;
-}
+        /// options
+        options: ?TransformOptions = null,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-if (this.text) |text| {
-  try writer.writeFieldID(1);
-   try writer.writeValue(text);
-}
-if (this.location) |location| {
-  try writer.writeFieldID(2);
-   try writer.writeValue(location);
-}
-try writer.endMessage();
-}
+        pub fn decode(reader: anytype) anyerror!Transform {
+            var this = std.mem.zeroes(Transform);
 
-};
+            while (true) {
+                switch (try reader.readByte()) {
+                    0 => {
+                        return this;
+                    },
 
-pub const Message = struct {
-/// kind
-kind: MessageKind,
+                    1 => {
+                        this.handle = try reader.readValue(FileHandle);
+                    },
+                    2 => {
+                        this.path = try reader.readValue([]const u8);
+                    },
+                    3 => {
+                        this.contents = try reader.readArray(u8);
+                    },
+                    4 => {
+                        this.loader = try reader.readValue(Loader);
+                    },
+                    5 => {
+                        this.options = try reader.readValue(TransformOptions);
+                    },
+                    else => {
+                        return error.InvalidMessage;
+                    },
+                }
+            }
+            unreachable;
+        }
 
-/// data
-data: MessageData,
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            if (this.handle) |handle| {
+                try writer.writeFieldID(1);
+                try writer.writeValue(handle);
+            }
+            if (this.path) |path| {
+                try writer.writeFieldID(2);
+                try writer.writeValue(path);
+            }
+            if (this.contents) |contents| {
+                try writer.writeFieldID(3);
+                try writer.writeArray(u8, contents);
+            }
+            if (this.loader) |loader| {
+                try writer.writeFieldID(4);
+                try writer.writeEnum(loader);
+            }
+            if (this.options) |options| {
+                try writer.writeFieldID(5);
+                try writer.writeValue(options);
+            }
+            try writer.endMessage();
+        }
+    };
 
-/// notes
-notes: []const MessageData,
+    pub const TransformResponseStatus = enum(u32) {
+        _none,
+        /// success
+        success,
 
+        /// fail
+        fail,
 
-pub fn decode(reader: anytype) anyerror!Message {
-  var this = std.mem.zeroes(Message);
+        _,
 
-  this.kind = try reader.readValue(MessageKind); 
-  this.data = try reader.readValue(MessageData); 
-  this.notes = try reader.readArray(MessageData); 
-   return this;
-}
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeEnum(this.kind);
-   try writer.writeValue(this.data);
-   try writer.writeArray(MessageData, this.notes);
-}
+    pub const OutputFile = struct {
+        /// data
+        data: []const u8,
 
-};
+        /// path
+        path: []const u8,
 
-pub const Log = struct {
-/// warnings
-warnings: u32 = 0,
+        pub fn decode(reader: anytype) anyerror!OutputFile {
+            var this = std.mem.zeroes(OutputFile);
 
-/// errors
-errors: u32 = 0,
+            this.data = try reader.readArray(u8);
+            this.path = try reader.readValue([]const u8);
+            return this;
+        }
 
-/// msgs
-msgs: []const Message,
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeArray(u8, this.data);
+            try writer.writeValue(this.path);
+        }
+    };
 
+    pub const TransformResponse = struct {
+        /// status
+        status: TransformResponseStatus,
 
-pub fn decode(reader: anytype) anyerror!Log {
-  var this = std.mem.zeroes(Log);
+        /// files
+        files: []const OutputFile,
 
-  this.warnings = try reader.readValue(u32); 
-  this.errors = try reader.readValue(u32); 
-  this.msgs = try reader.readArray(Message); 
-   return this;
-}
+        /// errors
+        errors: []const Message,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeInt(this.warnings);
-   try writer.writeInt(this.errors);
-   try writer.writeArray(Message, this.msgs);
-}
+        pub fn decode(reader: anytype) anyerror!TransformResponse {
+            var this = std.mem.zeroes(TransformResponse);
 
-};
+            this.status = try reader.readValue(TransformResponseStatus);
+            this.files = try reader.readArray(OutputFile);
+            this.errors = try reader.readArray(Message);
+            return this;
+        }
 
-pub const Reloader = enum(u8) {
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeEnum(this.status);
+            try writer.writeArray(OutputFile, this.files);
+            try writer.writeArray(Message, this.errors);
+        }
+    };
 
-_none,
-  /// disable
-  disable,
+    pub const MessageKind = enum(u32) {
+        _none,
+        /// err
+        err,
 
-  /// live
-  live,
+        /// warn
+        warn,
 
-  /// fast_refresh
-  fast_refresh,
+        /// note
+        note,
 
-_,
+        /// debug
+        debug,
 
-                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-                    return try std.json.stringify(@tagName(self), opts, o);
-                }
+        _,
 
-                
-};
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
 
-pub const WebsocketMessageKind = enum(u8) {
+    pub const Location = struct {
+        /// file
+        file: []const u8,
 
-_none,
-  /// welcome
-  welcome,
+        /// namespace
+        namespace: []const u8,
 
-  /// file_change_notification
-  file_change_notification,
+        /// line
+        line: i32 = 0,
 
-  /// build_success
-  build_success,
+        /// column
+        column: i32 = 0,
 
-  /// build_fail
-  build_fail,
+        /// line_text
+        line_text: []const u8,
 
-  /// manifest_success
-  manifest_success,
+        /// suggestion
+        suggestion: []const u8,
 
-  /// manifest_fail
-  manifest_fail,
+        /// offset
+        offset: u32 = 0,
 
-_,
+        pub fn decode(reader: anytype) anyerror!Location {
+            var this = std.mem.zeroes(Location);
 
-                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-                    return try std.json.stringify(@tagName(self), opts, o);
-                }
+            this.file = try reader.readValue([]const u8);
+            this.namespace = try reader.readValue([]const u8);
+            this.line = try reader.readValue(i32);
+            this.column = try reader.readValue(i32);
+            this.line_text = try reader.readValue([]const u8);
+            this.suggestion = try reader.readValue([]const u8);
+            this.offset = try reader.readValue(u32);
+            return this;
+        }
 
-                
-};
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeValue(this.file);
+            try writer.writeValue(this.namespace);
+            try writer.writeInt(this.line);
+            try writer.writeInt(this.column);
+            try writer.writeValue(this.line_text);
+            try writer.writeValue(this.suggestion);
+            try writer.writeInt(this.offset);
+        }
+    };
 
-pub const WebsocketCommandKind = enum(u8) {
+    pub const MessageData = struct {
+        /// text
+        text: ?[]const u8 = null,
 
-_none,
-  /// build
-  build,
+        /// location
+        location: ?Location = null,
 
-  /// manifest
-  manifest,
+        pub fn decode(reader: anytype) anyerror!MessageData {
+            var this = std.mem.zeroes(MessageData);
 
-_,
+            while (true) {
+                switch (try reader.readByte()) {
+                    0 => {
+                        return this;
+                    },
 
-                pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
-                    return try std.json.stringify(@tagName(self), opts, o);
+                    1 => {
+                        this.text = try reader.readValue([]const u8);
+                    },
+                    2 => {
+                        this.location = try reader.readValue(Location);
+                    },
+                    else => {
+                        return error.InvalidMessage;
+                    },
                 }
+            }
+            unreachable;
+        }
 
-                
-};
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            if (this.text) |text| {
+                try writer.writeFieldID(1);
+                try writer.writeValue(text);
+            }
+            if (this.location) |location| {
+                try writer.writeFieldID(2);
+                try writer.writeValue(location);
+            }
+            try writer.endMessage();
+        }
+    };
 
-pub const WebsocketMessage = struct {
-/// timestamp
-timestamp: u32 = 0,
+    pub const Message = struct {
+        /// kind
+        kind: MessageKind,
 
-/// kind
-kind: WebsocketMessageKind,
+        /// data
+        data: MessageData,
 
+        /// notes
+        notes: []const MessageData,
 
-pub fn decode(reader: anytype) anyerror!WebsocketMessage {
-  var this = std.mem.zeroes(WebsocketMessage);
+        pub fn decode(reader: anytype) anyerror!Message {
+            var this = std.mem.zeroes(Message);
 
-  this.timestamp = try reader.readValue(u32); 
-  this.kind = try reader.readValue(WebsocketMessageKind); 
-   return this;
-}
-
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeInt(this.timestamp);
-   try writer.writeEnum(this.kind);
-}
+            this.kind = try reader.readValue(MessageKind);
+            this.data = try reader.readValue(MessageData);
+            this.notes = try reader.readArray(MessageData);
+            return this;
+        }
 
-};
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeEnum(this.kind);
+            try writer.writeValue(this.data);
+            try writer.writeArray(MessageData, this.notes);
+        }
+    };
 
-pub const WebsocketMessageWelcome = struct {
-/// epoch
-epoch: u32 = 0,
+    pub const Log = struct {
+        /// warnings
+        warnings: u32 = 0,
 
-/// javascriptReloader
-javascript_reloader: Reloader,
+        /// errors
+        errors: u32 = 0,
 
+        /// msgs
+        msgs: []const Message,
 
-pub fn decode(reader: anytype) anyerror!WebsocketMessageWelcome {
-  var this = std.mem.zeroes(WebsocketMessageWelcome);
+        pub fn decode(reader: anytype) anyerror!Log {
+            var this = std.mem.zeroes(Log);
 
-  this.epoch = try reader.readValue(u32); 
-  this.javascript_reloader = try reader.readValue(Reloader); 
-   return this;
-}
+            this.warnings = try reader.readValue(u32);
+            this.errors = try reader.readValue(u32);
+            this.msgs = try reader.readArray(Message);
+            return this;
+        }
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeInt(this.epoch);
-   try writer.writeEnum(this.javascript_reloader);
-}
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeInt(this.warnings);
+            try writer.writeInt(this.errors);
+            try writer.writeArray(Message, this.msgs);
+        }
+    };
 
-};
+    pub const Reloader = enum(u8) {
+        _none,
+        /// disable
+        disable,
 
-pub const WebsocketMessageFileChangeNotification = struct {
-/// id
-id: u32 = 0,
+        /// live
+        live,
 
-/// loader
-loader: Loader,
+        /// fast_refresh
+        fast_refresh,
 
+        _,
 
-pub fn decode(reader: anytype) anyerror!WebsocketMessageFileChangeNotification {
-  var this = std.mem.zeroes(WebsocketMessageFileChangeNotification);
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
 
-  this.id = try reader.readValue(u32); 
-  this.loader = try reader.readValue(Loader); 
-   return this;
-}
+    pub const WebsocketMessageKind = enum(u8) {
+        _none,
+        /// welcome
+        welcome,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeInt(this.id);
-   try writer.writeEnum(this.loader);
-}
+        /// file_change_notification
+        file_change_notification,
 
-};
+        /// build_success
+        build_success,
 
-pub const WebsocketCommand = struct {
-/// kind
-kind: WebsocketCommandKind,
+        /// build_fail
+        build_fail,
 
-/// timestamp
-timestamp: u32 = 0,
+        /// manifest_success
+        manifest_success,
 
+        /// manifest_fail
+        manifest_fail,
 
-pub fn decode(reader: anytype) anyerror!WebsocketCommand {
-  var this = std.mem.zeroes(WebsocketCommand);
+        _,
 
-  this.kind = try reader.readValue(WebsocketCommandKind); 
-  this.timestamp = try reader.readValue(u32); 
-   return this;
-}
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeEnum(this.kind);
-   try writer.writeInt(this.timestamp);
-}
+    pub const WebsocketCommandKind = enum(u8) {
+        _none,
+        /// build
+        build,
 
-};
+        /// manifest
+        manifest,
 
-pub const WebsocketCommandBuild = packed struct {
-/// id
-id: u32 = 0,
+        _,
 
+        pub fn jsonStringify(self: *const @This(), opts: anytype, o: anytype) !void {
+            return try std.json.stringify(@tagName(self), opts, o);
+        }
+    };
 
-pub fn decode(reader: anytype) anyerror!WebsocketCommandBuild {
-  var this = std.mem.zeroes(WebsocketCommandBuild);
+    pub const WebsocketMessage = struct {
+        /// timestamp
+        timestamp: u32 = 0,
 
-  this.id = try reader.readValue(u32); 
-   return this;
-}
+        /// kind
+        kind: WebsocketMessageKind,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeInt(this.id);
-}
+        pub fn decode(reader: anytype) anyerror!WebsocketMessage {
+            var this = std.mem.zeroes(WebsocketMessage);
 
-};
+            this.timestamp = try reader.readValue(u32);
+            this.kind = try reader.readValue(WebsocketMessageKind);
+            return this;
+        }
 
-pub const WebsocketCommandManifest = packed struct {
-/// id
-id: u32 = 0,
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeInt(this.timestamp);
+            try writer.writeEnum(this.kind);
+        }
+    };
 
+    pub const WebsocketMessageWelcome = struct {
+        /// epoch
+        epoch: u32 = 0,
 
-pub fn decode(reader: anytype) anyerror!WebsocketCommandManifest {
-  var this = std.mem.zeroes(WebsocketCommandManifest);
+        /// javascriptReloader
+        javascript_reloader: Reloader,
 
-  this.id = try reader.readValue(u32); 
-   return this;
-}
+        pub fn decode(reader: anytype) anyerror!WebsocketMessageWelcome {
+            var this = std.mem.zeroes(WebsocketMessageWelcome);
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeInt(this.id);
-}
+            this.epoch = try reader.readValue(u32);
+            this.javascript_reloader = try reader.readValue(Reloader);
+            return this;
+        }
 
-};
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeInt(this.epoch);
+            try writer.writeEnum(this.javascript_reloader);
+        }
+    };
 
-pub const WebsocketMessageBuildSuccess = struct {
-/// id
-id: u32 = 0,
+    pub const WebsocketMessageFileChangeNotification = struct {
+        /// id
+        id: u32 = 0,
 
-/// from_timestamp
-from_timestamp: u32 = 0,
+        /// loader
+        loader: Loader,
 
-/// loader
-loader: Loader,
+        pub fn decode(reader: anytype) anyerror!WebsocketMessageFileChangeNotification {
+            var this = std.mem.zeroes(WebsocketMessageFileChangeNotification);
 
-/// module_path
-module_path: []const u8,
+            this.id = try reader.readValue(u32);
+            this.loader = try reader.readValue(Loader);
+            return this;
+        }
 
-/// blob_length
-blob_length: u32 = 0,
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeInt(this.id);
+            try writer.writeEnum(this.loader);
+        }
+    };
 
+    pub const WebsocketCommand = struct {
+        /// kind
+        kind: WebsocketCommandKind,
 
-pub fn decode(reader: anytype) anyerror!WebsocketMessageBuildSuccess {
-  var this = std.mem.zeroes(WebsocketMessageBuildSuccess);
+        /// timestamp
+        timestamp: u32 = 0,
 
-  this.id = try reader.readValue(u32); 
-  this.from_timestamp = try reader.readValue(u32); 
-  this.loader = try reader.readValue(Loader); 
-  this.module_path = try reader.readValue([]const u8); 
-  this.blob_length = try reader.readValue(u32); 
-   return this;
-}
+        pub fn decode(reader: anytype) anyerror!WebsocketCommand {
+            var this = std.mem.zeroes(WebsocketCommand);
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeInt(this.id);
-   try writer.writeInt(this.from_timestamp);
-   try writer.writeEnum(this.loader);
-   try writer.writeValue(this.module_path);
-   try writer.writeInt(this.blob_length);
-}
+            this.kind = try reader.readValue(WebsocketCommandKind);
+            this.timestamp = try reader.readValue(u32);
+            return this;
+        }
 
-};
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeEnum(this.kind);
+            try writer.writeInt(this.timestamp);
+        }
+    };
 
-pub const WebsocketMessageBuildFailure = struct {
-/// id
-id: u32 = 0,
+    pub const WebsocketCommandBuild = packed struct {
+        /// id
+        id: u32 = 0,
 
-/// from_timestamp
-from_timestamp: u32 = 0,
+        pub fn decode(reader: anytype) anyerror!WebsocketCommandBuild {
+            var this = std.mem.zeroes(WebsocketCommandBuild);
 
-/// loader
-loader: Loader,
+            this.id = try reader.readValue(u32);
+            return this;
+        }
 
-/// module_path
-module_path: []const u8,
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeInt(this.id);
+        }
+    };
 
-/// log
-log: Log,
+    pub const WebsocketCommandManifest = packed struct {
+        /// id
+        id: u32 = 0,
 
+        pub fn decode(reader: anytype) anyerror!WebsocketCommandManifest {
+            var this = std.mem.zeroes(WebsocketCommandManifest);
 
-pub fn decode(reader: anytype) anyerror!WebsocketMessageBuildFailure {
-  var this = std.mem.zeroes(WebsocketMessageBuildFailure);
+            this.id = try reader.readValue(u32);
+            return this;
+        }
 
-  this.id = try reader.readValue(u32); 
-  this.from_timestamp = try reader.readValue(u32); 
-  this.loader = try reader.readValue(Loader); 
-  this.module_path = try reader.readValue([]const u8); 
-  this.log = try reader.readValue(Log); 
-   return this;
-}
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeInt(this.id);
+        }
+    };
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeInt(this.id);
-   try writer.writeInt(this.from_timestamp);
-   try writer.writeEnum(this.loader);
-   try writer.writeValue(this.module_path);
-   try writer.writeValue(this.log);
-}
+    pub const WebsocketMessageBuildSuccess = struct {
+        /// id
+        id: u32 = 0,
 
-};
+        /// from_timestamp
+        from_timestamp: u32 = 0,
 
-pub const DependencyManifest = struct {
-/// ids
-ids: []const u32,
+        /// loader
+        loader: Loader,
 
+        /// module_path
+        module_path: []const u8,
 
-pub fn decode(reader: anytype) anyerror!DependencyManifest {
-  var this = std.mem.zeroes(DependencyManifest);
+        /// blob_length
+        blob_length: u32 = 0,
 
-  this.ids = try reader.readArray(u32); 
-   return this;
-}
+        pub fn decode(reader: anytype) anyerror!WebsocketMessageBuildSuccess {
+            var this = std.mem.zeroes(WebsocketMessageBuildSuccess);
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeArray(u32, this.ids);
-}
+            this.id = try reader.readValue(u32);
+            this.from_timestamp = try reader.readValue(u32);
+            this.loader = try reader.readValue(Loader);
+            this.module_path = try reader.readValue([]const u8);
+            this.blob_length = try reader.readValue(u32);
+            return this;
+        }
 
-};
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeInt(this.id);
+            try writer.writeInt(this.from_timestamp);
+            try writer.writeEnum(this.loader);
+            try writer.writeValue(this.module_path);
+            try writer.writeInt(this.blob_length);
+        }
+    };
 
-pub const FileList = struct {
-/// ptrs
-ptrs: []const StringPointer,
+    pub const WebsocketMessageBuildFailure = struct {
+        /// id
+        id: u32 = 0,
 
-/// files
-files: []const u8,
+        /// from_timestamp
+        from_timestamp: u32 = 0,
 
+        /// loader
+        loader: Loader,
 
-pub fn decode(reader: anytype) anyerror!FileList {
-  var this = std.mem.zeroes(FileList);
+        /// module_path
+        module_path: []const u8,
 
-  this.ptrs = try reader.readArray(StringPointer); 
-  this.files = try reader.readValue([]const u8); 
-   return this;
-}
+        /// log
+        log: Log,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeArray(StringPointer, this.ptrs);
-   try writer.writeValue(this.files);
-}
+        pub fn decode(reader: anytype) anyerror!WebsocketMessageBuildFailure {
+            var this = std.mem.zeroes(WebsocketMessageBuildFailure);
 
-};
+            this.id = try reader.readValue(u32);
+            this.from_timestamp = try reader.readValue(u32);
+            this.loader = try reader.readValue(Loader);
+            this.module_path = try reader.readValue([]const u8);
+            this.log = try reader.readValue(Log);
+            return this;
+        }
 
-pub const WebsocketMessageResolveIDs = struct {
-/// id
-id: []const u32,
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeInt(this.id);
+            try writer.writeInt(this.from_timestamp);
+            try writer.writeEnum(this.loader);
+            try writer.writeValue(this.module_path);
+            try writer.writeValue(this.log);
+        }
+    };
 
-/// list
-list: FileList,
+    pub const DependencyManifest = struct {
+        /// ids
+        ids: []const u32,
 
+        pub fn decode(reader: anytype) anyerror!DependencyManifest {
+            var this = std.mem.zeroes(DependencyManifest);
 
-pub fn decode(reader: anytype) anyerror!WebsocketMessageResolveIDs {
-  var this = std.mem.zeroes(WebsocketMessageResolveIDs);
+            this.ids = try reader.readArray(u32);
+            return this;
+        }
 
-  this.id = try reader.readArray(u32); 
-  this.list = try reader.readValue(FileList); 
-   return this;
-}
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeArray(u32, this.ids);
+        }
+    };
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeArray(u32, this.id);
-   try writer.writeValue(this.list);
-}
+    pub const FileList = struct {
+        /// ptrs
+        ptrs: []const StringPointer,
 
-};
+        /// files
+        files: []const u8,
 
-pub const WebsocketCommandResolveIDs = struct {
-/// ptrs
-ptrs: []const StringPointer,
+        pub fn decode(reader: anytype) anyerror!FileList {
+            var this = std.mem.zeroes(FileList);
 
-/// files
-files: []const u8,
+            this.ptrs = try reader.readArray(StringPointer);
+            this.files = try reader.readValue([]const u8);
+            return this;
+        }
 
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeArray(StringPointer, this.ptrs);
+            try writer.writeValue(this.files);
+        }
+    };
 
-pub fn decode(reader: anytype) anyerror!WebsocketCommandResolveIDs {
-  var this = std.mem.zeroes(WebsocketCommandResolveIDs);
+    pub const WebsocketMessageResolveIDs = struct {
+        /// id
+        id: []const u32,
 
-  this.ptrs = try reader.readArray(StringPointer); 
-  this.files = try reader.readValue([]const u8); 
-   return this;
-}
+        /// list
+        list: FileList,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeArray(StringPointer, this.ptrs);
-   try writer.writeValue(this.files);
-}
+        pub fn decode(reader: anytype) anyerror!WebsocketMessageResolveIDs {
+            var this = std.mem.zeroes(WebsocketMessageResolveIDs);
 
-};
+            this.id = try reader.readArray(u32);
+            this.list = try reader.readValue(FileList);
+            return this;
+        }
 
-pub const WebsocketMessageManifestSuccess = struct {
-/// id
-id: u32 = 0,
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeArray(u32, this.id);
+            try writer.writeValue(this.list);
+        }
+    };
 
-/// module_path
-module_path: []const u8,
+    pub const WebsocketCommandResolveIDs = struct {
+        /// ptrs
+        ptrs: []const StringPointer,
 
-/// loader
-loader: Loader,
+        /// files
+        files: []const u8,
 
-/// manifest
-manifest: DependencyManifest,
+        pub fn decode(reader: anytype) anyerror!WebsocketCommandResolveIDs {
+            var this = std.mem.zeroes(WebsocketCommandResolveIDs);
 
+            this.ptrs = try reader.readArray(StringPointer);
+            this.files = try reader.readValue([]const u8);
+            return this;
+        }
 
-pub fn decode(reader: anytype) anyerror!WebsocketMessageManifestSuccess {
-  var this = std.mem.zeroes(WebsocketMessageManifestSuccess);
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeArray(StringPointer, this.ptrs);
+            try writer.writeValue(this.files);
+        }
+    };
 
-  this.id = try reader.readValue(u32); 
-  this.module_path = try reader.readValue([]const u8); 
-  this.loader = try reader.readValue(Loader); 
-  this.manifest = try reader.readValue(DependencyManifest); 
-   return this;
-}
+    pub const WebsocketMessageManifestSuccess = struct {
+        /// id
+        id: u32 = 0,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeInt(this.id);
-   try writer.writeValue(this.module_path);
-   try writer.writeEnum(this.loader);
-   try writer.writeValue(this.manifest);
-}
+        /// module_path
+        module_path: []const u8,
 
-};
+        /// loader
+        loader: Loader,
 
-pub const WebsocketMessageManifestFailure = struct {
-/// id
-id: u32 = 0,
+        /// manifest
+        manifest: DependencyManifest,
 
-/// from_timestamp
-from_timestamp: u32 = 0,
+        pub fn decode(reader: anytype) anyerror!WebsocketMessageManifestSuccess {
+            var this = std.mem.zeroes(WebsocketMessageManifestSuccess);
 
-/// loader
-loader: Loader,
+            this.id = try reader.readValue(u32);
+            this.module_path = try reader.readValue([]const u8);
+            this.loader = try reader.readValue(Loader);
+            this.manifest = try reader.readValue(DependencyManifest);
+            return this;
+        }
 
-/// log
-log: Log,
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeInt(this.id);
+            try writer.writeValue(this.module_path);
+            try writer.writeEnum(this.loader);
+            try writer.writeValue(this.manifest);
+        }
+    };
 
+    pub const WebsocketMessageManifestFailure = struct {
+        /// id
+        id: u32 = 0,
 
-pub fn decode(reader: anytype) anyerror!WebsocketMessageManifestFailure {
-  var this = std.mem.zeroes(WebsocketMessageManifestFailure);
+        /// from_timestamp
+        from_timestamp: u32 = 0,
 
-  this.id = try reader.readValue(u32); 
-  this.from_timestamp = try reader.readValue(u32); 
-  this.loader = try reader.readValue(Loader); 
-  this.log = try reader.readValue(Log); 
-   return this;
-}
+        /// loader
+        loader: Loader,
 
-pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
-   try writer.writeInt(this.id);
-   try writer.writeInt(this.from_timestamp);
-   try writer.writeEnum(this.loader);
-   try writer.writeValue(this.log);
-}
+        /// log
+        log: Log,
 
-};
+        pub fn decode(reader: anytype) anyerror!WebsocketMessageManifestFailure {
+            var this = std.mem.zeroes(WebsocketMessageManifestFailure);
 
+            this.id = try reader.readValue(u32);
+            this.from_timestamp = try reader.readValue(u32);
+            this.loader = try reader.readValue(Loader);
+            this.log = try reader.readValue(Log);
+            return this;
+        }
 
+        pub fn encode(this: *const @This(), writer: anytype) anyerror!void {
+            try writer.writeInt(this.id);
+            try writer.writeInt(this.from_timestamp);
+            try writer.writeEnum(this.loader);
+            try writer.writeValue(this.log);
+        }
+    };
 };
 
-
 const ExamplePackedStruct = packed struct {
     len: u32 = 0,
     offset: u32 = 0,
diff --git a/src/bundler.zig b/src/bundler.zig
index ac340a15b..410db7cc3 100644
--- a/src/bundler.zig
+++ b/src/bundler.zig
@@ -597,7 +597,7 @@ pub fn NewBundler(cache_files: bool) type {
             // 0x00000000\n
             // That uint32 denotes the byte offset in the file where the code for the bundle ends
             //     - If the value is 0, that means the file did not finish writing or there are no modules
-            //     - This imposes a maximum bundle size of around 4,294,967,295 bytes. If your JS is more than 4 GB, you probably should fix that...
+            //     - This imposes a maximum bundle size of around 4,294,967,295 bytes. If your JS is more than 4 GB, you're a
             // The raw JavaScript is encoded as a UTF-8 string starting from the current position + 1 until the above byte offset.
             // This uint32 is useful for HTTP servers to separate:
             // - Which part of the bundle is the JS code?
@@ -1734,6 +1734,7 @@ pub fn NewBundler(cache_files: bool) type {
                         .externals = ast.externals,
                         .runtime_imports = ast.runtime_imports,
                         .require_ref = ast.require_ref,
+                        .css_import_behavior = bundler.options.cssImportBehavior(),
                     },
                     Linker,
                     &bundler.linker,
@@ -1750,6 +1751,8 @@ pub fn NewBundler(cache_files: bool) type {
                         .externals = ast.externals,
                         .runtime_imports = ast.runtime_imports,
                         .require_ref = ast.require_ref,
+
+                        .css_import_behavior = bundler.options.cssImportBehavior(),
                     },
                     Linker,
                     &bundler.linker,
@@ -1867,6 +1870,7 @@ pub fn NewBundler(cache_files: bool) type {
             defer bundler.resolver.log = original_resolver_logger;
             bundler.log = log;
             bundler.linker.allocator = allocator;
+
             bundler.resolver.log = log;
 
             if (strings.eqlComptime(relative_path, "__runtime.js")) {
diff --git a/src/feature_flags.zig b/src/feature_flags.zig
index 5918f0f80..3fdc8cb29 100644
--- a/src/feature_flags.zig
+++ b/src/feature_flags.zig
@@ -17,7 +17,7 @@ pub const store_file_descriptors = !env.isWindows and !env.isBrowser;
 // This doesn't really seem to do anything for us
 pub const disable_filesystem_cache = false and std.Target.current.os.tag == .macos;
 
-pub const css_in_js_import_behavior = CSSModulePolyfill.facade;
+pub const css_in_js_import_behavior = CSSInJSImportBehavior.facade;
 
 pub const only_output_esm = true;
 
@@ -47,10 +47,11 @@ pub const react_specific_warnings = true;
 // It only happens 1 out of every N times, probably like 50.
 pub const parallel_bun = false;
 
-pub const CSSModulePolyfill = enum {
+pub const CSSInJSImportBehavior = enum {
     // When you import a .css file and you reference the import in JavaScript
     // Just return whatever the property key they referenced was
     facade,
+    facade_onimportcss,
 };
 
 // having issues compiling WebKit with this enabled
diff --git a/src/http.zig b/src/http.zig
index 83c2f8935..9869322c3 100644
--- a/src/http.zig
+++ b/src/http.zig
@@ -376,8 +376,8 @@ pub const RequestContext = struct {
             .request = req,
             .arena = arena,
             .bundler = bundler_,
-            .url = URLPath.parse(req.path),
             .log = undefined,
+            .url = URLPath.parse(req.path),
             .conn = conn,
             .allocator = undefined,
             .method = Method.which(req.method) orelse return error.InvalidMethod,
@@ -927,7 +927,7 @@ pub const RequestContext = struct {
             clone.conn = ctx.conn.*;
             clone.message_buffer = try MutableString.init(server.allocator, 0);
             clone.ctx.conn = &clone.conn;
-
+            clone.ctx.log = logger.Log.init(server.allocator);
             var printer_writer = try js_printer.BufferWriter.init(server.allocator);
 
             clone.builder = WatchBuilder{
@@ -1298,22 +1298,6 @@ pub const RequestContext = struct {
         _ = try std.Thread.spawn(.{}, WebsocketHandler.handle, .{handler});
     }
 
-    pub fn auto500(ctx: *RequestContext) void {
-        if (ctx.has_called_done) {
-            return;
-        }
-
-        defer ctx.done();
-
-        if (ctx.status == null) {
-            ctx.writeStatus(500) catch {};
-        }
-
-        if (!ctx.has_written_last_header) {
-            ctx.flushHeaders() catch {};
-        }
-    }
-
     threadlocal var client_entry_point: bundler.ClientEntryPoint = undefined;
 
     pub fn renderServeResult(ctx: *RequestContext, result: bundler.ServeResult) !void {
@@ -1321,7 +1305,7 @@ pub const RequestContext = struct {
             ctx.appendHeader("Connection", "keep-alive");
         }
 
-        if (std.meta.activeTag(result.file.value) == .noop) {
+        if (result.file.value == .noop) {
             return try ctx.sendNotFound();
         }
 
@@ -1616,9 +1600,6 @@ pub const RequestContext = struct {
     }
 
     pub fn handleGet(ctx: *RequestContext) !void {
-
-        // errdefer ctx.auto500();
-
         const result = brk: {
             if (ctx.bundler.options.isFrontendFrameworkEnabled()) {
                 break :brk try ctx.bundler.buildFile(
@@ -1859,11 +1840,7 @@ pub const Server = struct {
 
         var request_arena = std.heap.ArenaAllocator.init(server.allocator);
         var req_ctx: RequestContext = undefined;
-        defer {
-            if (!req_ctx.controlled) {
-                req_ctx.arena.deinit();
-            }
-        }
+
         req_ctx = RequestContext.init(
             req,
             request_arena,
@@ -1877,8 +1854,72 @@ pub const Server = struct {
             return;
         };
 
+        defer {
+            if (!req_ctx.controlled) {
+                req_ctx.arena.deinit();
+            }
+        }
+
         req_ctx.allocator = &req_ctx.arena.allocator;
         req_ctx.log = logger.Log.init(req_ctx.allocator);
+        var log = &req_ctx.log;
+
+        req_ctx.bundler.log = log;
+        req_ctx.bundler.linker.log = log;
+        req_ctx.bundler.resolver.log = log;
+        req_ctx.bundler.options.log = log;
+
+        var did_print: bool = false;
+
+        defer {
+            if (!req_ctx.controlled) {
+                if (!req_ctx.has_called_done) {
+                    if (comptime isDebug) {
+                        if (@errorReturnTrace()) |trace| {
+                            std.debug.dumpStackTrace(trace.*);
+                            Output.printError("\n", .{});
+                        }
+                    }
+
+                    req_ctx.sendInternalError(error.InternalError) catch {};
+                }
+                const status = req_ctx.status orelse @intCast(HTTPStatusCode, 500);
+
+                if (log.msgs.items.len == 0) {
+                    if (!did_print) {
+                        switch (status) {
+                            101, 199...399 => {
+                                Output.prettyln("<r><green>{d}<r><d> {s} <r>{s}<d> as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value });
+                            },
+                            400...499 => {
+                                Output.prettyln("<r><yellow>{d}<r><d> {s} <r>{s}<d> as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value });
+                            },
+                            else => {
+                                Output.prettyln("<r><red>{d}<r><d> {s} <r>{s}<d> as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value });
+                            },
+                        }
+                    }
+                } else {
+                    defer Output.flush();
+                    defer log.deinit();
+                    log.printForLogLevel(Output.errorWriter()) catch {};
+
+                    if (!did_print) {
+                        switch (status) {
+                            101, 199...399 => {
+                                Output.prettyln("<r><green>{d}<r><d> <r>{s}<d> {s} as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value });
+                            },
+                            400...499 => {
+                                Output.prettyln("<r><yellow>{d}<r><d> <r>{s}<d> {s} as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value });
+                            },
+                            else => {
+                                Output.prettyln("<r><red>{d}<r><d> <r>{s}<d> {s} as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value });
+                            },
+                        }
+                    }
+                }
+            }
+        }
 
         if (comptime FeatureFlags.keep_alive) {
             if (req_ctx.header("Connection")) |connection| {
@@ -1892,6 +1933,7 @@ pub const Server = struct {
 
         var finished = req_ctx.handleReservedRoutes(server) catch |err| {
             Output.printErrorln("FAIL [{s}] - {s}: {s}", .{ @errorName(err), req.method, req.path });
+            did_print = true;
             return;
         };
 
@@ -1901,6 +1943,7 @@ pub const Server = struct {
                     finished = true;
                     req_ctx.renderServeResult(result) catch |err| {
                         Output.printErrorln("FAIL [{s}] - {s}: {s}", .{ @errorName(err), req.method, req.path });
+                        did_print = true;
                         return;
                     };
                 }
@@ -1914,6 +1957,7 @@ pub const Server = struct {
                         },
                         else => {
                             Output.printErrorln("FAIL [{s}] - {s}: {s}", .{ @errorName(err), req.method, req.path });
+                            did_print = true;
                             return;
                         },
                     }
@@ -1925,6 +1969,7 @@ pub const Server = struct {
                     finished = true;
                     req_ctx.renderServeResult(result) catch |err| {
                         Output.printErrorln("FAIL [{s}] - {s}: {s}", .{ @errorName(err), req.method, req.path });
+                        did_print = true;
                         return;
                     };
                 }
@@ -1938,6 +1983,7 @@ pub const Server = struct {
                         },
                         else => {
                             Output.printErrorln("FAIL [{s}] - {s}: {s}", .{ @errorName(err), req.method, req.path });
+                            did_print = true;
                             return;
                         },
                     }
@@ -1952,6 +1998,7 @@ pub const Server = struct {
                         },
                         else => {
                             Output.printErrorln("FAIL [{s}] - {s}: {s}", .{ @errorName(err), req.method, req.path });
+                            did_print = true;
                             return;
                         },
                     }
@@ -1966,47 +2013,13 @@ pub const Server = struct {
                         },
                         else => {
                             Output.printErrorln("FAIL [{s}] - {s}: {s}", .{ @errorName(err), req.method, req.path });
+                            did_print = true;
                             return;
                         },
                     }
                 };
             }
         }
-
-        if (!req_ctx.controlled) {
-            const status = req_ctx.status orelse @intCast(HTTPStatusCode, 500);
-
-            if (req_ctx.log.msgs.items.len == 0) {
-                switch (status) {
-                    101, 199...399 => {
-                        Output.prettyln("<r><green>{d}<r><d> {s} <r>{s}<d> as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value });
-                    },
-                    400...499 => {
-                        Output.prettyln("<r><yellow>{d}<r><d> {s} <r>{s}<d> as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value });
-                    },
-                    else => {
-                        Output.prettyln("<r><red>{d}<r><d> {s} <r>{s}<d> as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value });
-                    },
-                }
-            } else {
-                switch (status) {
-                    101, 199...399 => {
-                        Output.prettyln("<r><green>{d}<r><d> <r>{s}<d> {s} as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value });
-                    },
-                    400...499 => {
-                        Output.prettyln("<r><yellow>{d}<r><d> <r>{s}<d> {s} as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value });
-                    },
-                    else => {
-                        Output.prettyln("<r><red>{d}<r><d> <r>{s}<d> {s} as {s}<r>", .{ status, @tagName(req_ctx.method), req.path, req_ctx.mime_type.value });
-                    },
-                }
-
-                for (req_ctx.log.msgs.items) |msg| {
-                    msg.writeFormat(Output.errorWriter()) catch continue;
-                }
-                req_ctx.log.deinit();
-            }
-        }
     }
 
     pub fn initWatcher(server: *Server) !void {
diff --git a/src/javascript/jsc/javascript.zig b/src/javascript/jsc/javascript.zig
index a462515b7..dc545ae87 100644
--- a/src/javascript/jsc/javascript.zig
+++ b/src/javascript/jsc/javascript.zig
@@ -294,6 +294,7 @@ pub const VirtualMachine = struct {
             log = __log;
         } else {
             log = try allocator.create(logger.Log);
+            log.* = logger.Log.init(allocator);
         }
 
         VirtualMachine.vm = try allocator.create(VirtualMachine);
diff --git a/src/js_parser/js_parser.zig b/src/js_parser/js_parser.zig
index 889da4c2e..9d37230cd 100644
--- a/src/js_parser/js_parser.zig
+++ b/src/js_parser/js_parser.zig
@@ -8359,7 +8359,6 @@ pub fn NewParser(
             var left = _left;
             var loc = p.lexer.loc();
             var optional_chain: ?js_ast.OptionalChain = null;
-
             while (true) {
                 if (p.lexer.loc().start == p.after_arrow_body_loc.start) {
                     while (true) {
@@ -9115,11 +9114,12 @@ pub fn NewParser(
         }
 
         pub fn panic(p: *P, comptime str: string, args: anytype) noreturn {
+            @setCold(true);
             var panic_buffer = p.allocator.alloc(u8, 32 * 1024) catch unreachable;
             var panic_stream = std.io.fixedBufferStream(panic_buffer);
             p.log.addRangeErrorFmt(p.source, p.lexer.range(), p.allocator, str, args) catch unreachable;
             p.log.print(panic_stream.writer()) catch unreachable;
-            Global.panic("{s}", .{panic_buffer});
+            Global.panic("{s}", .{panic_buffer[0..panic_stream.pos]});
         }
 
         pub fn _parsePrefix(p: *P, level: Level, errors: *DeferredErrors, flags: Expr.EFlags) anyerror!Expr {
@@ -9293,7 +9293,7 @@ pub fn NewParser(
                         _ = p.pushScopeForParsePass(.function_args, loc) catch unreachable;
                         defer p.popScope();
                         // Output.print("HANDLE START ", .{});
-                        return p.e(p.parseArrowBody(args, p.m(FnOrArrowDataParse{})) catch unreachable, loc);
+                        return p.e(try p.parseArrowBody(args, p.m(FnOrArrowDataParse{})), loc);
                     }
 
                     const ref = p.storeNameInRef(name) catch unreachable;
@@ -9680,14 +9680,14 @@ pub fn NewParser(
                         if (is_ts_arrow_fn) {
                             try p.skipTypeScriptTypeParameters();
                             try p.lexer.expect(.t_open_paren);
-                            return p.parseParenExpr(loc, level, ParenExprOpts{ .force_arrow_fn = true }) catch unreachable;
+                            return try p.parseParenExpr(loc, level, ParenExprOpts{ .force_arrow_fn = true });
                         }
                     }
 
                     if (is_jsx_enabled) {
                         // Use NextInsideJSXElement() instead of Next() so we parse "<<" as "<"
                         try p.lexer.nextInsideJSXElement();
-                        const element = p.parseJSXElement(loc) catch unreachable;
+                        const element = try p.parseJSXElement(loc);
 
                         // The call to parseJSXElement() above doesn't consume the last
                         // TGreaterThan because the caller knows what Next() function to call.
@@ -9704,7 +9704,7 @@ pub fn NewParser(
                         // "<T>(x) => {}"
                         if (p.trySkipTypeScriptTypeParametersThenOpenParenWithBacktracking()) {
                             try p.lexer.expect(.t_open_paren);
-                            return p.parseParenExpr(loc, level, ParenExprOpts{}) catch unreachable;
+                            return p.parseParenExpr(loc, level, ParenExprOpts{});
                         }
 
                         // "<T>x"
@@ -9795,7 +9795,7 @@ pub fn NewParser(
             range: logger.Range,
             name: string = "",
 
-            pub fn parse(p: *P) !JSXTag {
+            pub fn parse(p: *P) anyerror!JSXTag {
                 const loc = p.lexer.loc();
 
                 // A missing tag is a fragment
@@ -9838,7 +9838,7 @@ pub fn NewParser(
 
                     if (strings.indexOfChar(member, '-')) |index| {
                         try p.log.addError(p.source, logger.Loc{ .start = member_range.loc.start + @intCast(i32, index) }, "Unexpected \"-\"");
-                        p.panic("", .{});
+                        return error.SyntaxError;
                     }
 
                     var _name = try p.allocator.alloc(u8, name.len + 1 + member.len);
@@ -9872,7 +9872,7 @@ pub fn NewParser(
             }
         }
 
-        pub fn parseJSXElement(p: *P, loc: logger.Loc) !Expr {
+        pub fn parseJSXElement(p: *P, loc: logger.Loc) anyerror!Expr {
             if (only_scan_imports_and_do_not_visit) {
                 p.needs_jsx_import = true;
             }
@@ -10032,7 +10032,7 @@ pub fn NewParser(
 
                         if (p.lexer.token != .t_slash) {
                             // This is a child element
-                            children.append(p.parseJSXElement(less_than_loc) catch unreachable) catch unreachable;
+                            children.append(try p.parseJSXElement(less_than_loc)) catch unreachable;
 
                             // The call to parseJSXElement() above doesn't consume the last
                             // TGreaterThan because the caller knows what Next() function to call.
@@ -10047,10 +10047,10 @@ pub fn NewParser(
                         const end_tag = try JSXTag.parse(p);
                         if (!strings.eql(end_tag.name, tag.name)) {
                             try p.log.addRangeErrorFmt(p.source, end_tag.range, p.allocator, "Expected closing tag </{s}> to match opening tag <{s}>", .{
-                                tag.name,
                                 end_tag.name,
+                                tag.name,
                             });
-                            p.panic("", .{});
+                            return error.SyntaxError;
                         }
 
                         if (p.lexer.token != .t_greater_than) {
diff --git a/src/js_printer.zig b/src/js_printer.zig
index 9e26029f3..1fd6463da 100644
--- a/src/js_printer.zig
+++ b/src/js_printer.zig
@@ -8,6 +8,7 @@ const alloc = @import("alloc.zig");
 const rename = @import("renamer.zig");
 const runtime = @import("runtime.zig");
 
+const Api = @import("./api/schema.zig").Api;
 const fs = @import("fs.zig");
 usingnamespace @import("global.zig");
 usingnamespace @import("ast/base.zig");
@@ -81,6 +82,8 @@ pub const Options = struct {
     bundle_export_ref: ?js_ast.Ref = null,
     rewrite_require_resolve: bool = true,
 
+    css_import_behavior: Api.CssInJsBehavior = Api.CssInJsBehavior.facade,
+
     // TODO: remove this
     // The reason for this is:
     // 1. You're bundling a React component
@@ -2869,26 +2872,46 @@ pub fn NewPrinter(
                     p.needs_semicolon = false;
                 },
                 .s_import => |s| {
-                    if (FeatureFlags.css_in_js_import_behavior == .facade) {
-                        // TODO: check loader instead
-                        if (strings.eqlComptime(p.import_records[s.import_record_index].path.name.ext, ".css")) {
-                            // This comment exists to let tooling authors know which files CSS originated from
-                            // To parse this, you just look for a line that starts with //@import url("
-                            p.print("//@import url(\"");
-                            // We do not URL escape here.
-                            p.print(p.import_records[s.import_record_index].path.text);
-
-                            // If they actually use the code, then we emit a facade that just echos whatever they write
-                            if (s.default_name) |name| {
-                                p.print("\"); css-module-facade\nvar ");
-                                p.printSymbol(name.ref.?);
-                                p.print(" = new Proxy({}, {get(_,className,__){return className;}});\n");
-                            } else {
-                                p.print("\"); css-import-facade\n");
-                            }
 
-                            return;
+                    // TODO: check loader instead
+                    if (strings.eqlComptime(p.import_records[s.import_record_index].path.name.ext, ".css")) {
+                        switch (p.options.css_import_behavior) {
+                            .facade => {
+
+                                // This comment exists to let tooling authors know which files CSS originated from
+                                // To parse this, you just look for a line that starts with //@import url("
+                                p.print("//@import url(\"");
+                                // We do not URL escape here.
+                                p.print(p.import_records[s.import_record_index].path.text);
+
+                                // If they actually use the code, then we emit a facade that just echos whatever they write
+                                if (s.default_name) |name| {
+                                    p.print("\"); css-module-facade\nvar ");
+                                    p.printSymbol(name.ref.?);
+                                    p.print(" = new Proxy({}, {get(_,className,__){return className;}});\n");
+                                } else {
+                                    p.print("\"); css-import-facade\n");
+                                }
+
+                                return;
+                            },
+
+                            .facade_onimportcss => {
+                                p.print("globalThis.document?.dispatchEvent(new CustomEvent(\"onimportcss\", {detail: \"");
+                                p.print(p.import_records[s.import_record_index].path.text);
+                                p.print("\"}));\n");
+
+                                // If they actually use the code, then we emit a facade that just echos whatever they write
+                                if (s.default_name) |name| {
+                                    p.print("var ");
+                                    p.printSymbol(name.ref.?);
+                                    p.print(" = new Proxy({}, {get(_,className,__){return className;}});\n");
+                                }
+                            },
+                            else => {},
                         }
+
+                        return;
                     }
 
                     const record = p.import_records[s.import_record_index];
diff --git a/src/logger.zig b/src/logger.zig
index 8904ee1e1..cf9fb6960 100644
--- a/src/logger.zig
+++ b/src/logger.zig
@@ -19,10 +19,21 @@ pub const Kind = enum(i8) {
     verbose,
 
     pub inline fn shouldPrint(this: Kind, other: Log.Level) bool {
-        return @enumToInt(this) - @enumToInt(other) >= 0;
+        return switch (other) {
+            .err => switch (this) {
+                .err, .note => true,
+                else => false,
+            },
+            .warn => switch (this) {
+                .err, .warn, .note => true,
+                else => false,
+            },
+            .info, .debug => this != .verbose,
+            .verbose => true,
+        };
     }
 
-    pub fn string(self: Kind) string {
+    pub inline fn string(self: Kind) string {
         return switch (self) {
             .err => "error",
             .warn => "warn",
@@ -32,7 +43,7 @@ pub const Kind = enum(i8) {
         };
     }
 
-    pub fn toAPI(kind: Kind) Api.MessageKind {
+    pub inline fn toAPI(kind: Kind) Api.MessageKind {
         return switch (kind) {
             .err => err,
             .warn => warn,
@@ -46,23 +57,23 @@ pub const Kind = enum(i8) {
 pub const Loc = packed struct {
     start: i32 = -1,
 
-    pub fn toNullable(loc: *Loc) ?Loc {
+    pub inline fn toNullable(loc: *Loc) ?Loc {
         return if (loc.start == -1) null else loc.*;
     }
 
     // TODO: remove this stupidity
-    pub fn toUsize(self: *const Loc) usize {
+    pub inline fn toUsize(self: *const Loc) usize {
         return @intCast(usize, self.start);
     }
 
     // TODO: remove this stupidity
-    pub fn i(self: *const Loc) usize {
+    pub inline fn i(self: *const Loc) usize {
         return @intCast(usize, self.start);
     }
 
     pub const Empty = Loc{ .start = -1 };
 
-    pub fn eql(loc: *Loc, other: Loc) bool {
+    pub inline fn eql(loc: *Loc, other: Loc) bool {
         return loc.start == other.start;
     }
 
@@ -327,7 +338,7 @@ pub const Log = struct {
     warnings: usize = 0,
     errors: usize = 0,
     msgs: ArrayList(Msg),
-    level: Level = Level.info,
+    level: Level = if (isDebug) Level.info else Level.warn,
 
     pub fn toAPI(this: *const Log, allocator: *std.mem.Allocator) !Api.Log {
         return Api.Log{
@@ -366,21 +377,27 @@ pub const Log = struct {
     }
 
     pub fn appendToMaybeRecycled(self: *Log, other: *Log, source: *const Source) !void {
+        try other.msgs.appendSlice(self.msgs.items);
+        other.warnings += self.warnings;
+        other.errors += self.errors;
+
         if (source.contents_is_recycled) {
-            for (self.msgs.items) |*_msg| {
-                var msg: *Msg = _msg;
-                if (msg.data.location) |*location| {
+            var i: usize = 0;
+            var j: usize = other.msgs.items.len - self.msgs.items.len;
+
+            while (i < self.msgs.items.len) : ({
+                i += 1;
+                j += 1;
+            }) {
+                const msg = self.msgs.items[i];
+                if (msg.data.location) |location| {
                     if (location.line_text) |line_text| {
-                        location.line_text = try other.msgs.allocator.dupe(u8, line_text);
+                        other.msgs.items[j].data.location.?.line_text = try other.msgs.allocator.dupe(u8, line_text);
                     }
                 }
             }
         }
 
-        try other.msgs.appendSlice(self.msgs.items);
-        other.warnings += self.warnings;
-        other.errors += self.errors;
-
         self.msgs.deinit();
     }
 
@@ -389,6 +406,8 @@ pub const Log = struct {
     }
 
     pub fn addVerboseWithNotes(log: *Log, source: ?*const Source, loc: Loc, text: string, notes: []Data) !void {
+        if (!Kind.shouldPrint(.verbose, log.level)) return;
+
         try log.addMsg(Msg{
             .kind = .verbose,
             .data = rangeData(source, Range{ .loc = loc }, text),
@@ -456,6 +475,7 @@ pub const Log = struct {
     }
 
     pub fn addRangeWarning(log: *Log, source: ?*const Source, r: Range, text: string) !void {
+        if (!Kind.shouldPrint(.warn, log.level)) return;
         log.warnings += 1;
         try log.addMsg(Msg{
             .kind = .warn,
@@ -464,6 +484,7 @@ pub const Log = struct {
     }
 
     pub fn addWarningFmt(log: *Log, source: ?*const Source, l: Loc, allocator: *std.mem.Allocator, comptime text: string, args: anytype) !void {
+        if (!Kind.shouldPrint(.warn, log.level)) return;
         log.warnings += 1;
         try log.addMsg(Msg{
             .kind = .warn,
@@ -472,6 +493,7 @@ pub const Log = struct {
     }
 
     pub fn addRangeWarningFmt(log: *Log, source: ?*const Source, r: Range, allocator: *std.mem.Allocator, comptime text: string, args: anytype) !void {
+        if (!Kind.shouldPrint(.warn, log.level)) return;
         log.warnings += 1;
         try log.addMsg(Msg{
             .kind = .warn,
@@ -480,6 +502,7 @@ pub const Log = struct {
     }
 
     pub fn addWarning(log: *Log, source: ?*const Source, l: Loc, text: string) !void {
+        if (!Kind.shouldPrint(.warn, log.level)) return;
         log.warnings += 1;
         try log.addMsg(Msg{
             .kind = .warn,
@@ -488,6 +511,7 @@ pub const Log = struct {
     }
 
     pub fn addRangeDebug(log: *Log, source: ?*const Source, r: Range, text: string) !void {
+        if (!Kind.shouldPrint(.debug, log.level)) return;
         try log.addMsg(Msg{
             .kind = .debug,
             .data = rangeData(source, r, text),
@@ -495,6 +519,7 @@ pub const Log = struct {
     }
 
     pub fn addRangeDebugWithNotes(log: *Log, source: ?*const Source, r: Range, text: string, notes: []Data) !void {
+        if (!Kind.shouldPrint(.debug, log.level)) return;
         // log.de += 1;
         try log.addMsg(Msg{
             .kind = Kind.debug,
@@ -513,6 +538,7 @@ pub const Log = struct {
     }
 
     pub fn addRangeWarningWithNotes(log: *Log, source: ?*const Source, r: Range, text: string, notes: []Data) !void {
+        if (!Kind.shouldPrint(.warn, log.level)) return;
         log.warnings += 1;
         try log.addMsg(Msg{
             .kind = .warning,
@@ -540,11 +566,15 @@ pub const Log = struct {
     }
 
     pub fn printForLogLevel(self: *Log, to: anytype) !void {
+        var printed = false;
         for (self.msgs.items) |msg| {
             if (msg.kind.shouldPrint(self.level)) {
                 try msg.writeFormat(to);
+                printed = true;
             }
         }
+
+        if (printed) _ = try to.write("\n");
     }
 
     pub fn toZigException(this: *const Log, allocator: *std.mem.Allocator) *js.ZigException.Holder {
diff --git a/src/options.zig b/src/options.zig
index c989e32f2..1fc07191d 100644
--- a/src/options.zig
+++ b/src/options.zig
@@ -716,6 +716,19 @@ pub const BundleOptions = struct {
     env: Env = Env{},
     transform_options: Api.TransformOptions,
 
+    pub inline fn cssImportBehavior(this: *const BundleOptions) Api.CssInJsBehavior {
+        switch (this.platform) {
+            .neutral, .browser => {
+                if (this.framework) |framework| {
+                    return framework.client_css_in_js;
+                }
+
+                return .facade;
+            },
+            else => return .facade,
+        }
+    }
+
     pub fn areDefinesUnset(this: *const BundleOptions) bool {
         return !this.defines_loaded;
     }
@@ -1382,6 +1395,8 @@ pub const Framework = struct {
     client_env: Env = Env{},
     server_env: Env = Env{},
 
+    client_css_in_js: Api.CssInJsBehavior = .facade,
+
     fn normalizedPath(allocator: *std.mem.Allocator, toplevel_path: string, path: string) !string {
         std.debug.assert(std.fs.path.isAbsolute(path));
         var str = path;
@@ -1412,6 +1427,7 @@ pub const Framework = struct {
             .package = loaded.package,
             .development = loaded.development,
             .from_bundle = true,
+            .client_css_in_js = loaded.client_css_in_js,
         };
 
         if (loaded.client) {
@@ -1432,6 +1448,7 @@ pub const Framework = struct {
                     .development = this.development,
                     .client = true,
                     .env = this.client_env.toAPI(),
+                    .client_css_in_js = this.client_css_in_js,
                 };
             }
         } else {
@@ -1442,6 +1459,7 @@ pub const Framework = struct {
                     .development = this.development,
                     .client = false,
                     .env = this.server_env.toAPI(),
+                    .client_css_in_js = this.client_css_in_js,
                 };
             }
         }
@@ -1462,6 +1480,10 @@ pub const Framework = struct {
             .package = transform.package orelse "",
             .development = transform.development orelse true,
             .resolved = false,
+            .client_css_in_js = switch (transform.client_css_in_js orelse .facade) {
+                .facade_onimportcss => .facade_onimportcss,
+                else => .facade,
+            },
         };
     }
 };
diff --git a/src/resolver/package_json.zig b/src/resolver/package_json.zig
index 45f5c3e48..fea7fef8a 100644
--- a/src/resolver/package_json.zig
+++ b/src/resolver/package_json.zig
@@ -153,6 +153,16 @@ pub const PackageJSON = struct {
             }
         }
 
+        if (json.asProperty("css")) |css_prop| {
+            if (css_prop.expr.asString(allocator)) |str| {
+                if (strings.eqlComptime(str, "onimportcss")) {
+                    framework.client_css_in_js = .facade_onimportcss;
+                } else {
+                    framework.client_css_in_js = .facade;
+                }
+            }
+        }
+
         if (comptime read_define) {
             if (json.asProperty("define")) |defines| {
                 if (defines.expr.asProperty("client")) |client| {
diff --git a/src/router.zig b/src/router.zig
index ca2ac462e..fb561fcf3 100644
--- a/src/router.zig
+++ b/src/router.zig
@@ -151,7 +151,7 @@ pub fn loadRoutes(
                             dir_info,
                             ResolverType,
                             resolver,
-                            route.children.offset,
+                            route.children.offset - 1,
                             false,
                         );
 
@@ -437,10 +437,20 @@ pub const RouteMap = struct {
                     for (this.segments[0..segment_i]) |segment| {
                         segment_offset += @truncate(u16, segment.len);
                     }
+                    var total_offset: u16 = 0;
+
+                    var current_i: u16 = head.parent;
+                    const slices = this.map.routes;
+                    const names = slices.items(.name);
+                    const parents = slices.items(.parent);
+                    while (current_i != Route.top_level_parent) : (current_i = parents[current_i]) {
+                        total_offset += @truncate(u16, names[current_i].len);
+                    }
+
                     this.params.append(
                         this.allocator,
                         Param{
-                            .key = .{ .offset = head.part.name.offset, .len = head.part.name.len },
+                            .key = .{ .offset = head.part.name.offset + total_offset + segment_i, .len = head.part.name.len },
                             .value = .{ .offset = segment_offset, .len = @truncate(u16, this.segments[segment_i].len) },
                             .kind = head.part.tag,
                         },
diff --git a/src/runtime.js b/src/runtime.js
index bbc8dddab..d3416cbe4 100644
--- a/src/runtime.js
+++ b/src/runtime.js
@@ -41,7 +41,7 @@ export var __commonJS = (cb, name) => {
   var has_run = false;
 
   return {
-    [`#init_${name}`]() {
+    [`[load] ${name}`]() {
       if (has_run) {
         return mod.exports;
       }
@@ -84,7 +84,7 @@ export var __commonJS = (cb, name) => {
 
       return mod.exports;
     },
-  }[`#init_${name}`];
+  }[`[load] ${name}`];
 };
 
 var require_cache = new WeakMap();