Skip to content

The VS Code of video editing, built for agents.

TypeScript

Enhance macOS support and update UI styling

konstantin-paulus05f1f53f290b
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index 6de246e4..994ec3f4 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -11,7 +11,8 @@
"scripts": {
"build:preload": "esbuild src/preload.ts --bundle --platform=node --format=cjs --external:electron --outfile=dist/preload.js",
"build:main": "esbuild src/main.ts --bundle --platform=node --format=cjs --external:electron --outfile=dist/main.js",
- "build": "npm run check && npm run build:main && npm run build:preload",
+ "build:native": "node scripts/build-native.mjs",
+ "build": "npm run check && npm run build:main && npm run build:preload && npm run build:native",
"build:web": "npm --prefix ../web run build:desktop",
"stage:cli": "npm --prefix ../cli run build && node scripts/stage-cli.mjs",
"check": "tsc --noEmit",
diff --git a/apps/desktop/scripts/build-native.mjs b/apps/desktop/scripts/build-native.mjs
new file mode 100644
index 00000000..c213021f
--- /dev/null
+++ b/apps/desktop/scripts/build-native.mjs
@@ -0,0 +1,38 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Compiles the macOS corner-radius addon (src/native/corner_radius.m) into
+// dist/corner_radius.node. Node-API is ABI-stable, so a plain clang build
+// works across Electron versions; node_api symbols resolve from the Electron
+// binary at load time via -undefined dynamic_lookup.
+
+import { execFileSync } from 'node:child_process';
+import { mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+if (process.platform !== 'darwin') process.exit(0);
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..');
+mkdirSync(join(root, 'dist'), { recursive: true });
+
+execFileSync(
+ 'clang',
+ [
+ join(root, 'src', 'native', 'corner_radius.m'),
+ '-o', join(root, 'dist', 'corner_radius.node'),
+ '-dynamiclib',
+ '-undefined', 'dynamic_lookup',
+ '-fobjc-arc',
+ '-framework', 'AppKit',
+ '-framework', 'QuartzCore',
+ '-arch', 'arm64',
+ '-arch', 'x86_64',
+ '-mmacosx-version-min=11.0',
+ '-DNAPI_VERSION=8',
+ '-Wall',
+ '-Werror',
+ ],
+ { stdio: 'inherit' },
+);
diff --git a/apps/desktop/src/main.ts b/apps/desktop/src/main.ts
index 6982c2dd..3d51cefe 100644
--- a/apps/desktop/src/main.ts
+++ b/apps/desktop/src/main.ts
@@ -15,6 +15,30 @@ import { MAIN_CHANNELS } from "./main-channels";
const DEV_URL = "http://localhost:5173";
const AUTH_PROTOCOL = "diffusion";
+const MACOS_CORNER_RADIUS = 16;
+const MACOS_BACKDROP = { blur: 80, red: 0.07, green: 0.07, blue: 0.07, alpha: 0.9 };
+
+let setNativeCornerRadius: ((handle: Buffer, radius: number) => void) | null = null;
+let setNativeBackdrop:
+ | ((handle: Buffer, blur: number, r: number, g: number, b: number, a: number) => void)
+ | null = null;
+
+if (process.platform === "darwin") {
+ ({ setCornerRadius: setNativeCornerRadius, setBackdrop: setNativeBackdrop } = require(
+ join(app.getAppPath(), "dist", "corner_radius.node"),
+ ));
+}
+
+function applyCornerRadius(radius: number) {
+ if (!setNativeCornerRadius || !mainWindow || mainWindow.isDestroyed()) return;
+ setNativeCornerRadius(mainWindow.getNativeWindowHandle(), radius);
+}
+
+function applyBackdrop() {
+ if (!setNativeBackdrop || !mainWindow || mainWindow.isDestroyed()) return;
+ const { blur, red, green, blue, alpha } = MACOS_BACKDROP;
+ setNativeBackdrop(mainWindow.getNativeWindowHandle(), blur, red, green, blue, alpha);
+}
if (app.isPackaged && !process.argv.includes("--hidden")) {
updateElectronApp({ repo: "diffusionstudio/editor" });
@@ -62,7 +86,7 @@ async function setFileInputFiles(selector: string, absolutePath: string) {
function createWindow(show = true) {
mainWindow = new BrowserWindow({
- show,
+ show: false,
width: 1200,
height: 800,
titleBarStyle: "hiddenInset",
@@ -82,10 +106,29 @@ function createWindow(show = true) {
pendingAuthUrl = null;
});
+ applyCornerRadius(MACOS_CORNER_RADIUS);
+ applyBackdrop();
+
+ mainWindow.once("ready-to-show", () => {
+ applyCornerRadius(MACOS_CORNER_RADIUS);
+ applyBackdrop();
+
+ if (show) {
+ mainWindow?.show();
+ }
+ });
+
+ mainWindow.on("show", () => {
+ applyCornerRadius(MACOS_CORNER_RADIUS);
+ applyBackdrop();
+ });
+
mainWindow.on("enter-full-screen", () => {
+ applyCornerRadius(0);
mainBridge.emit(mainWindow, MAIN_CHANNELS.WINDOW_FULLSCREEN_CHANGE, { fullscreen: true });
});
mainWindow.on("leave-full-screen", () => {
+ applyCornerRadius(MACOS_CORNER_RADIUS);
mainBridge.emit(mainWindow, MAIN_CHANNELS.WINDOW_FULLSCREEN_CHANGE, { fullscreen: false });
});
mainWindow.on("closed", () => {
diff --git a/apps/desktop/src/native/corner_radius.m b/apps/desktop/src/native/corner_radius.m
new file mode 100644
index 00000000..b1ce4b2e
--- /dev/null
+++ b/apps/desktop/src/native/corner_radius.m
@@ -0,0 +1,266 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Node-API addon that gives the Electron BrowserWindow a custom corner radius
+// while keeping the STANDARD window: native traffic lights, OS drop shadow,
+// vibrancy, and live resize all survive. Electron only exposes the fixed
+// system radius, hence the private-API work below.
+//
+// Mechanism (after github.com/makalin/CornerFix and lin-outliner#58):
+// - macOS 26 "Tahoe" shapes the frame + shadow from the private radius
+// getters (_cornerRadius / _effectiveCornerRadius / _topCornerRadius /
+// _bottomCornerRadius), so those are swizzled on the window's real
+// dispatch class to return a per-window radius stored as an associated
+// object. The system re-reads them on every relayout, so the value
+// persists without re-applying.
+// - macOS < 26 still honors _cornerMask, so that is overridden too.
+// - The vibrancy frost is rounded via NSVisualEffectView.maskImage (public
+// API) — masking an ancestor layer instead would kill behind-window
+// blending and leave AppKit's border stroke at the system radius.
+// Because this rides Apple's own corner + default shadow path, it avoids the
+// WindowServer GPU cost that made Electron drop its _cornerMask override
+// (electron/electron#48376).
+//
+// Built by scripts/build-native.mjs; loaded from dist/ at runtime.
+
+#import <AppKit/AppKit.h>
+#import <objc/message.h>
+#import <objc/runtime.h>
+#include "vendor/node_api.h"
+
+// Per-window desired radius (NSNumber) and corner mask (NSImage), read back
+// by the swizzled getters. nil => fall back to the OS default corner.
+static const void* kRadiusKey = &kRadiusKey;
+static const void* kMaskKey = &kMaskKey;
+
+// Captured originals, the per-window fallback so windows with no radius set
+// keep the OS default.
+static IMP g_origCornerMask = NULL;
+static IMP g_origCornerRadius = NULL;
+static IMP g_origEffectiveCornerRadius = NULL;
+static IMP g_origTopCornerRadius = NULL;
+static IMP g_origBottomCornerRadius = NULL;
+
+// Resizable rounded-rect mask: opaque inside, transparent corners; capInsets
+// keep the corners crisp while the centre stretches with the window.
+static NSImage* RoundedMaskImage(CGFloat radius) {
+ CGFloat side = radius * 2 + 1;
+ NSImage* image = [[NSImage alloc] initWithSize:NSMakeSize(side, side)];
+ [image lockFocus];
+ [[NSColor blackColor] setFill];
+ [[NSBezierPath bezierPathWithRoundedRect:NSMakeRect(0, 0, side, side)
+ xRadius:radius
+ yRadius:radius] fill];
+ [image unlockFocus];
+ image.capInsets = NSEdgeInsetsMake(radius, radius, radius, radius);
+ image.resizingMode = NSImageResizingModeStretch;
+ return image;
+}
+
+static void RoundEffectViews(NSView* view, NSImage* mask) {
+ if ([view isKindOfClass:[NSVisualEffectView class]]) {
+ ((NSVisualEffectView*)view).maskImage = mask;
+ }
+ for (NSView* sub in view.subviews) RoundEffectViews(sub, mask);
+}
+
+static NSImage* ds_cornerMask(id self, SEL _cmd) {
+ NSImage* mask = objc_getAssociatedObject(self, kMaskKey);
+ if (mask != nil) return mask;
+ if (g_origCornerMask != NULL) {
+ return ((NSImage* (*)(id, SEL))g_origCornerMask)(self, _cmd);
+ }
+ return nil;
+}
+
+// One replacement for every radius getter: return this window's stored
+// radius, else defer to the captured original for that selector.
+static CGFloat ds_radius(id self, SEL _cmd) {
+ NSNumber* r = objc_getAssociatedObject(self, kRadiusKey);
+ if (r != nil) return (CGFloat)r.doubleValue;
+ IMP orig = NULL;
+ if (sel_isEqual(_cmd, @selector(_cornerRadius))) orig = g_origCornerRadius;
+ else if (sel_isEqual(_cmd, @selector(_effectiveCornerRadius))) orig = g_origEffectiveCornerRadius;
+ else if (sel_isEqual(_cmd, @selector(_topCornerRadius))) orig = g_origTopCornerRadius;
+ else if (sel_isEqual(_cmd, @selector(_bottomCornerRadius))) orig = g_origBottomCornerRadius;
+ if (orig != NULL) return ((CGFloat (*)(id, SEL))orig)(self, _cmd);
+ return 0;
+}
+
+// Swizzle one getter on the real dispatch class, capturing the original once.
+// No-op when the selector does not exist on this OS version.
+static void SwizzleRadiusGetter(Class cls, SEL sel, IMP* origStore) {
+ Method m = class_getInstanceMethod(cls, sel);
+ if (m == NULL) return;
+ if (*origStore == NULL) *origStore = method_getImplementation(m);
+ if (class_getMethodImplementation(cls, sel) != (IMP)ds_radius) {
+ class_replaceMethod(cls, sel, (IMP)ds_radius, "d@:");
+ }
+}
+
+static void CallRadiusSetter(NSWindow* window, SEL sel, CGFloat radius) {
+ if (![window respondsToSelector:sel]) return;
+ ((void (*)(id, SEL, CGFloat))objc_msgSend)(window, sel, radius);
+}
+
+// setCornerRadius(handle: Buffer, radius: number) — handle is the Buffer
+// returned by BrowserWindow.getNativeWindowHandle(), which on macOS holds an
+// NSView*. A radius of 0 restores the OS default corner (used in fullscreen).
+static napi_value SetCornerRadius(napi_env env, napi_callback_info info) {
+ size_t argc = 2;
+ napi_value argv[2];
+ napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+ if (argc < 2) {
+ napi_throw_error(env, NULL, "expected (handle: Buffer, radius: number)");
+ return NULL;
+ }
+
+ void* data = NULL;
+ size_t length = 0;
+ if (napi_get_buffer_info(env, argv[0], &data, &length) != napi_ok ||
+ length < sizeof(NSView*)) {
+ napi_throw_error(env, NULL, "handle must be the getNativeWindowHandle() Buffer");
+ return NULL;
+ }
+ double radius = 0;
+ napi_get_value_double(env, argv[1], &radius);
+
+ NSView* view = *(NSView* __unsafe_unretained*)data;
+ NSWindow* window = view.window;
+ if (!window) return NULL;
+
+ Class realCls = object_getClass(window);
+ NSImage* mask = radius > 0 ? RoundedMaskImage((CGFloat)radius) : nil;
+
+ RoundEffectViews(window.contentView, mask);
+
+ objc_setAssociatedObject(window, kRadiusKey,
+ radius > 0 ? @(radius) : nil,
+ OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+ objc_setAssociatedObject(window, kMaskKey, mask,
+ OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+
+ // Swizzle on the real dispatch class — a KVO-observed window's actual class
+ // is a dynamic NSKVONotifying_* subclass, not [window class].
+ SwizzleRadiusGetter(realCls, @selector(_cornerRadius), &g_origCornerRadius);
+ SwizzleRadiusGetter(realCls, @selector(_effectiveCornerRadius), &g_origEffectiveCornerRadius);
+ SwizzleRadiusGetter(realCls, @selector(_topCornerRadius), &g_origTopCornerRadius);
+ SwizzleRadiusGetter(realCls, @selector(_bottomCornerRadius), &g_origBottomCornerRadius);
+ if (g_origCornerMask == NULL) {
+ Method base = class_getInstanceMethod([NSWindow class], @selector(_cornerMask));
+ if (base != NULL) g_origCornerMask = method_getImplementation(base);
+ }
+ if (class_getMethodImplementation(realCls, @selector(_cornerMask)) != (IMP)ds_cornerMask) {
+ class_replaceMethod(realCls, @selector(_cornerMask), (IMP)ds_cornerMask, "@@:");
+ }
+
+ // Push the value through the setters once so any cached backing field
+ // updates immediately, then nudge a recompute + shadow refresh.
+ CallRadiusSetter(window, @selector(_setCornerRadius:), (CGFloat)radius);
+ CallRadiusSetter(window, @selector(_setEffectiveCornerRadius:), (CGFloat)radius);
+ if ([window respondsToSelector:@selector(_updateCornerMask)]) {
+ ((void (*)(id, SEL))objc_msgSend)(window, @selector(_updateCornerMask));
+ }
+ [window invalidateShadow];
+ return NULL;
+}
+
+static NSVisualEffectView* FindEffectView(NSView* view) {
+ if ([view isKindOfClass:[NSVisualEffectView class]]) return (NSVisualEffectView*)view;
+ for (NSView* sub in view.subviews) {
+ NSVisualEffectView* found = FindEffectView(sub);
+ if (found) return found;
+ }
+ return nil;
+}
+
+static CALayer* FindBackdropLayer(CALayer* layer) {
+ if ([NSStringFromClass(layer.class) isEqualToString:@"CABackdropLayer"]) return layer;
+ for (CALayer* sub in layer.sublayers) {
+ CALayer* found = FindBackdropLayer(sub);
+ if (found) return found;
+ }
+ return nil;
+}
+
+// setBackdrop(handle: Buffer, blur: number, r, g, b, a: number) — replaces
+// the vibrancy material's recipe (fixed blur + tint stack) with a plain
+// gaussian blur of the given radius under a single solid tint. Keeps the
+// NSVisualEffectView itself so behind-window compositing stays intact.
+static napi_value SetBackdrop(napi_env env, napi_callback_info info) {
+ size_t argc = 6;
+ napi_value argv[6];
+ napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+ if (argc < 6) {
+ napi_throw_error(env, NULL, "expected (handle, blur, r, g, b, a)");
+ return NULL;
+ }
+
+ void* data = NULL;
+ size_t length = 0;
+ if (napi_get_buffer_info(env, argv[0], &data, &length) != napi_ok ||
+ length < sizeof(NSView*)) {
+ napi_throw_error(env, NULL, "handle must be the getNativeWindowHandle() Buffer");
+ return NULL;
+ }
+ double blur = 0, r = 0, g = 0, b = 0, a = 0;
+ napi_get_value_double(env, argv[1], &blur);
+ napi_get_value_double(env, argv[2], &r);
+ napi_get_value_double(env, argv[3], &g);
+ napi_get_value_double(env, argv[4], &b);
+ napi_get_value_double(env, argv[5], &a);
+
+ NSView* view = *(NSView* __unsafe_unretained*)data;
+ NSWindow* window = view.window;
+ if (!window) return NULL;
+
+ NSVisualEffectView* effectView = FindEffectView(window.contentView);
+ if (!effectView) return NULL;
+
+ // Pin the material to its active look so AppKit doesn't rebuild the recipe
+ // (and revert our layers) when the window resigns key.
+ effectView.state = NSVisualEffectStateActive;
+
+ CALayer* backdrop = effectView.layer ? FindBackdropLayer(effectView.layer) : nil;
+ if (!backdrop) return NULL;
+
+ id filter = ((id (*)(id, SEL, id))objc_msgSend)(
+ NSClassFromString(@"CAFilter"), NSSelectorFromString(@"filterWithType:"),
+ @"gaussianBlur");
+ [filter setValue:@(blur) forKey:@"inputRadius"];
+ [filter setValue:@YES forKey:@"inputNormalizeEdges"];
+ backdrop.filters = filter ? @[ filter ] : @[];
+
+ // The material recipe stacks tint/frost layers next to the backdrop; hide
+ // them and keep a single solid tint of our own above the blur.
+ CALayer* parent = backdrop.superlayer;
+ CALayer* tint = nil;
+ for (CALayer* sub in parent.sublayers) {
+ if ([sub.name isEqualToString:@"ds-tint"]) tint = sub;
+ else if (sub != backdrop) sub.hidden = YES;
+ }
+ if (!tint) {
+ tint = [CALayer layer];
+ tint.name = @"ds-tint";
+ tint.frame = parent.bounds;
+ tint.autoresizingMask = kCALayerWidthSizable | kCALayerHeightSizable;
+ [parent insertSublayer:tint above:backdrop];
+ }
+ tint.backgroundColor =
+ [NSColor colorWithSRGBRed:(CGFloat)r green:(CGFloat)g blue:(CGFloat)b
+ alpha:(CGFloat)a].CGColor;
+ return NULL;
+}
+
+static napi_value Init(napi_env env, napi_value exports) {
+ napi_value fn;
+ napi_create_function(env, "setCornerRadius", NAPI_AUTO_LENGTH, SetCornerRadius,
+ NULL, &fn);
+ napi_set_named_property(env, exports, "setCornerRadius", fn);
+ napi_create_function(env, "setBackdrop", NAPI_AUTO_LENGTH, SetBackdrop, NULL, &fn);
+ napi_set_named_property(env, exports, "setBackdrop", fn);
+ return exports;
+}
+
+NAPI_MODULE(corner_radius, Init)
diff --git a/apps/desktop/src/native/vendor/js_native_api.h b/apps/desktop/src/native/vendor/js_native_api.h
new file mode 100644
index 00000000..07e3df13
--- /dev/null
+++ b/apps/desktop/src/native/vendor/js_native_api.h
@@ -0,0 +1,619 @@
+#ifndef SRC_JS_NATIVE_API_H_
+#define SRC_JS_NATIVE_API_H_
+
+// This file needs to be compatible with C compilers.
+#include <stdbool.h> // NOLINT(modernize-deprecated-headers)
+#include <stddef.h> // NOLINT(modernize-deprecated-headers)
+
+// Use INT_MAX, this should only be consumed by the pre-processor anyway.
+#define NAPI_VERSION_EXPERIMENTAL 2147483647
+#ifndef NAPI_VERSION
+#ifdef NAPI_EXPERIMENTAL
+#define NAPI_VERSION NAPI_VERSION_EXPERIMENTAL
+#else
+// The baseline version for N-API.
+// The NAPI_VERSION controls which version will be used by default when
+// compilling a native addon. If the addon developer specifically wants to use
+// functions available in a new version of N-API that is not yet ported in all
+// LTS versions, they can set NAPI_VERSION knowing that they have specifically
+// depended on that version.
+#define NAPI_VERSION 8
+#endif
+#endif
+
+#include "js_native_api_types.h"
+
+// If you need __declspec(dllimport), either include <node_api.h> instead, or
+// define NAPI_EXTERN as __declspec(dllimport) on the compiler's command line.
+#ifndef NAPI_EXTERN
+#ifdef _WIN32
+#define NAPI_EXTERN __declspec(dllexport)
+#elif defined(__wasm__)
+#define NAPI_EXTERN \
+ __attribute__((visibility("default"))) \
+ __attribute__((__import_module__("napi")))
+#else
+#define NAPI_EXTERN __attribute__((visibility("default")))
+#endif
+#endif
+
+#define NAPI_AUTO_LENGTH SIZE_MAX
+
+#ifdef __cplusplus
+#define EXTERN_C_START extern "C" {
+#define EXTERN_C_END }
+#else
+#define EXTERN_C_START
+#define EXTERN_C_END
+#endif
+
+EXTERN_C_START
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_last_error_info(
+ node_api_basic_env env, const napi_extended_error_info** result);
+
+// Getters for defined singletons
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_undefined(napi_env env,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_null(napi_env env,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_global(napi_env env,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_boolean(napi_env env,
+ bool value,
+ napi_value* result);
+
+// Methods to create Primitive types/Objects
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_object(napi_env env,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_array(napi_env env,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_create_array_with_length(napi_env env, size_t length, napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_double(napi_env env,
+ double value,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_int32(napi_env env,
+ int32_t value,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_uint32(napi_env env,
+ uint32_t value,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_int64(napi_env env,
+ int64_t value,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_latin1(
+ napi_env env, const char* str, size_t length, napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_utf8(napi_env env,
+ const char* str,
+ size_t length,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_utf16(napi_env env,
+ const char16_t* str,
+ size_t length,
+ napi_value* result);
+#ifdef NAPI_EXPERIMENTAL
+#define NODE_API_EXPERIMENTAL_HAS_EXTERNAL_STRINGS
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_external_string_latin1(
+ napi_env env,
+ char* str,
+ size_t length,
+ node_api_basic_finalize finalize_callback,
+ void* finalize_hint,
+ napi_value* result,
+ bool* copied);
+NAPI_EXTERN napi_status NAPI_CDECL
+node_api_create_external_string_utf16(napi_env env,
+ char16_t* str,
+ size_t length,
+ node_api_basic_finalize finalize_callback,
+ void* finalize_hint,
+ napi_value* result,
+ bool* copied);
+#endif // NAPI_EXPERIMENTAL
+
+#ifdef NAPI_EXPERIMENTAL
+#define NODE_API_EXPERIMENTAL_HAS_PROPERTY_KEYS
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_latin1(
+ napi_env env, const char* str, size_t length, napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_utf8(
+ napi_env env, const char* str, size_t length, napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_property_key_utf16(
+ napi_env env, const char16_t* str, size_t length, napi_value* result);
+#endif // NAPI_EXPERIMENTAL
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_symbol(napi_env env,
+ napi_value description,
+ napi_value* result);
+#if NAPI_VERSION >= 9
+NAPI_EXTERN napi_status NAPI_CDECL
+node_api_symbol_for(napi_env env,
+ const char* utf8description,
+ size_t length,
+ napi_value* result);
+#endif // NAPI_VERSION >= 9
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_function(napi_env env,
+ const char* utf8name,
+ size_t length,
+ napi_callback cb,
+ void* data,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_error(napi_env env,
+ napi_value code,
+ napi_value msg,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_type_error(napi_env env,
+ napi_value code,
+ napi_value msg,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_range_error(napi_env env,
+ napi_value code,
+ napi_value msg,
+ napi_value* result);
+#if NAPI_VERSION >= 9
+NAPI_EXTERN napi_status NAPI_CDECL node_api_create_syntax_error(
+ napi_env env, napi_value code, napi_value msg, napi_value* result);
+#endif // NAPI_VERSION >= 9
+
+// Methods to get the native napi_value from Primitive type
+NAPI_EXTERN napi_status NAPI_CDECL napi_typeof(napi_env env,
+ napi_value value,
+ napi_valuetype* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_double(napi_env env,
+ napi_value value,
+ double* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_int32(napi_env env,
+ napi_value value,
+ int32_t* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_uint32(napi_env env,
+ napi_value value,
+ uint32_t* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_int64(napi_env env,
+ napi_value value,
+ int64_t* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_bool(napi_env env,
+ napi_value value,
+ bool* result);
+
+// Copies LATIN-1 encoded bytes from a string into a buffer.
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_string_latin1(
+ napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result);
+
+// Copies UTF-8 encoded bytes from a string into a buffer.
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_string_utf8(
+ napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result);
+
+// Copies UTF-16 encoded bytes from a string into a buffer.
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_string_utf16(napi_env env,
+ napi_value value,
+ char16_t* buf,
+ size_t bufsize,
+ size_t* result);
+
+// Methods to coerce values
+// These APIs may execute user scripts
+NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_bool(napi_env env,
+ napi_value value,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_number(napi_env env,
+ napi_value value,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_object(napi_env env,
+ napi_value value,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_string(napi_env env,
+ napi_value value,
+ napi_value* result);
+
+// Methods to work with Objects
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_prototype(napi_env env,
+ napi_value object,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_property_names(napi_env env,
+ napi_value object,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_set_property(napi_env env,
+ napi_value object,
+ napi_value key,
+ napi_value value);
+NAPI_EXTERN napi_status NAPI_CDECL napi_has_property(napi_env env,
+ napi_value object,
+ napi_value key,
+ bool* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_property(napi_env env,
+ napi_value object,
+ napi_value key,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_delete_property(napi_env env,
+ napi_value object,
+ napi_value key,
+ bool* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_has_own_property(napi_env env,
+ napi_value object,
+ napi_value key,
+ bool* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_set_named_property(napi_env env,
+ napi_value object,
+ const char* utf8name,
+ napi_value value);
+NAPI_EXTERN napi_status NAPI_CDECL napi_has_named_property(napi_env env,
+ napi_value object,
+ const char* utf8name,
+ bool* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_named_property(napi_env env,
+ napi_value object,
+ const char* utf8name,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_set_element(napi_env env,
+ napi_value object,
+ uint32_t index,
+ napi_value value);
+NAPI_EXTERN napi_status NAPI_CDECL napi_has_element(napi_env env,
+ napi_value object,
+ uint32_t index,
+ bool* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_element(napi_env env,
+ napi_value object,
+ uint32_t index,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_delete_element(napi_env env,
+ napi_value object,
+ uint32_t index,
+ bool* result);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_define_properties(napi_env env,
+ napi_value object,
+ size_t property_count,
+ const napi_property_descriptor* properties);
+
+// Methods to work with Arrays
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_array(napi_env env,
+ napi_value value,
+ bool* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_array_length(napi_env env,
+ napi_value value,
+ uint32_t* result);
+
+// Methods to compare values
+NAPI_EXTERN napi_status NAPI_CDECL napi_strict_equals(napi_env env,
+ napi_value lhs,
+ napi_value rhs,
+ bool* result);
+
+// Methods to work with Functions
+NAPI_EXTERN napi_status NAPI_CDECL napi_call_function(napi_env env,
+ napi_value recv,
+ napi_value func,
+ size_t argc,
+ const napi_value* argv,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_new_instance(napi_env env,
+ napi_value constructor,
+ size_t argc,
+ const napi_value* argv,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_instanceof(napi_env env,
+ napi_value object,
+ napi_value constructor,
+ bool* result);
+
+// Methods to work with napi_callbacks
+
+// Gets all callback info in a single call. (Ugly, but faster.)
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_cb_info(
+ napi_env env, // [in] Node-API environment handle
+ napi_callback_info cbinfo, // [in] Opaque callback-info handle
+ size_t* argc, // [in-out] Specifies the size of the provided argv array
+ // and receives the actual count of args.
+ napi_value* argv, // [out] Array of values
+ napi_value* this_arg, // [out] Receives the JS 'this' arg for the call
+ void** data); // [out] Receives the data pointer for the callback.
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_new_target(
+ napi_env env, napi_callback_info cbinfo, napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_define_class(napi_env env,
+ const char* utf8name,
+ size_t length,
+ napi_callback constructor,
+ void* data,
+ size_t property_count,
+ const napi_property_descriptor* properties,
+ napi_value* result);
+
+// Methods to work with external data objects
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_wrap(napi_env env,
+ napi_value js_object,
+ void* native_object,
+ node_api_basic_finalize finalize_cb,
+ void* finalize_hint,
+ napi_ref* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_unwrap(napi_env env,
+ napi_value js_object,
+ void** result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_remove_wrap(napi_env env,
+ napi_value js_object,
+ void** result);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_create_external(napi_env env,
+ void* data,
+ node_api_basic_finalize finalize_cb,
+ void* finalize_hint,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_external(napi_env env,
+ napi_value value,
+ void** result);
+
+// Methods to control object lifespan
+
+// Set initial_refcount to 0 for a weak reference, >0 for a strong reference.
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_create_reference(napi_env env,
+ napi_value value,
+ uint32_t initial_refcount,
+ napi_ref* result);
+
+// Deletes a reference. The referenced value is released, and may
+// be GC'd unless there are other references to it.
+NAPI_EXTERN napi_status NAPI_CDECL napi_delete_reference(napi_env env,
+ napi_ref ref);
+
+// Increments the reference count, optionally returning the resulting count.
+// After this call the reference will be a strong reference because its
+// refcount is >0, and the referenced object is effectively "pinned".
+// Calling this when the refcount is 0 and the object is unavailable
+// results in an error.
+NAPI_EXTERN napi_status NAPI_CDECL napi_reference_ref(napi_env env,
+ napi_ref ref,
+ uint32_t* result);
+
+// Decrements the reference count, optionally returning the resulting count.
+// If the result is 0 the reference is now weak and the object may be GC'd
+// at any time if there are no other references. Calling this when the
+// refcount is already 0 results in an error.
+NAPI_EXTERN napi_status NAPI_CDECL napi_reference_unref(napi_env env,
+ napi_ref ref,
+ uint32_t* result);
+
+// Attempts to get a referenced value. If the reference is weak,
+// the value might no longer be available, in that case the call
+// is still successful but the result is NULL.
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_reference_value(napi_env env,
+ napi_ref ref,
+ napi_value* result);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_open_handle_scope(napi_env env, napi_handle_scope* result);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_close_handle_scope(napi_env env, napi_handle_scope scope);
+NAPI_EXTERN napi_status NAPI_CDECL napi_open_escapable_handle_scope(
+ napi_env env, napi_escapable_handle_scope* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_close_escapable_handle_scope(
+ napi_env env, napi_escapable_handle_scope scope);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_escape_handle(napi_env env,
+ napi_escapable_handle_scope scope,
+ napi_value escapee,
+ napi_value* result);
+
+// Methods to support error handling
+NAPI_EXTERN napi_status NAPI_CDECL napi_throw(napi_env env, napi_value error);
+NAPI_EXTERN napi_status NAPI_CDECL napi_throw_error(napi_env env,
+ const char* code,
+ const char* msg);
+NAPI_EXTERN napi_status NAPI_CDECL napi_throw_type_error(napi_env env,
+ const char* code,
+ const char* msg);
+NAPI_EXTERN napi_status NAPI_CDECL napi_throw_range_error(napi_env env,
+ const char* code,
+ const char* msg);
+#if NAPI_VERSION >= 9
+NAPI_EXTERN napi_status NAPI_CDECL node_api_throw_syntax_error(napi_env env,
+ const char* code,
+ const char* msg);
+#endif // NAPI_VERSION >= 9
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_error(napi_env env,
+ napi_value value,
+ bool* result);
+
+// Methods to support catching exceptions
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_exception_pending(napi_env env,
+ bool* result);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_get_and_clear_last_exception(napi_env env, napi_value* result);
+
+// Methods to work with array buffers and typed arrays
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_arraybuffer(napi_env env,
+ napi_value value,
+ bool* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_arraybuffer(napi_env env,
+ size_t byte_length,
+ void** data,
+ napi_value* result);
+#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_create_external_arraybuffer(napi_env env,
+ void* external_data,
+ size_t byte_length,
+ node_api_basic_finalize finalize_cb,
+ void* finalize_hint,
+ napi_value* result);
+#endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_arraybuffer_info(
+ napi_env env, napi_value arraybuffer, void** data, size_t* byte_length);
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_typedarray(napi_env env,
+ napi_value value,
+ bool* result);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_create_typedarray(napi_env env,
+ napi_typedarray_type type,
+ size_t length,
+ napi_value arraybuffer,
+ size_t byte_offset,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_get_typedarray_info(napi_env env,
+ napi_value typedarray,
+ napi_typedarray_type* type,
+ size_t* length,
+ void** data,
+ napi_value* arraybuffer,
+ size_t* byte_offset);
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_dataview(napi_env env,
+ size_t length,
+ napi_value arraybuffer,
+ size_t byte_offset,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_dataview(napi_env env,
+ napi_value value,
+ bool* result);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_get_dataview_info(napi_env env,
+ napi_value dataview,
+ size_t* bytelength,
+ void** data,
+ napi_value* arraybuffer,
+ size_t* byte_offset);
+
+// version management
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_version(node_api_basic_env env,
+ uint32_t* result);
+
+// Promises
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_promise(napi_env env,
+ napi_deferred* deferred,
+ napi_value* promise);
+NAPI_EXTERN napi_status NAPI_CDECL napi_resolve_deferred(napi_env env,
+ napi_deferred deferred,
+ napi_value resolution);
+NAPI_EXTERN napi_status NAPI_CDECL napi_reject_deferred(napi_env env,
+ napi_deferred deferred,
+ napi_value rejection);
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_promise(napi_env env,
+ napi_value value,
+ bool* is_promise);
+
+// Running a script
+NAPI_EXTERN napi_status NAPI_CDECL napi_run_script(napi_env env,
+ napi_value script,
+ napi_value* result);
+
+// Memory management
+NAPI_EXTERN napi_status NAPI_CDECL napi_adjust_external_memory(
+ node_api_basic_env env, int64_t change_in_bytes, int64_t* adjusted_value);
+
+#if NAPI_VERSION >= 5
+
+// Dates
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_date(napi_env env,
+ double time,
+ napi_value* result);
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_date(napi_env env,
+ napi_value value,
+ bool* is_date);
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_date_value(napi_env env,
+ napi_value value,
+ double* result);
+
+// Add finalizer for pointer
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_add_finalizer(napi_env env,
+ napi_value js_object,
+ void* finalize_data,
+ node_api_basic_finalize finalize_cb,
+ void* finalize_hint,
+ napi_ref* result);
+
+#endif // NAPI_VERSION >= 5
+
+#ifdef NAPI_EXPERIMENTAL
+#define NODE_API_EXPERIMENTAL_HAS_POST_FINALIZER
+
+NAPI_EXTERN napi_status NAPI_CDECL
+node_api_post_finalizer(node_api_basic_env env,
+ napi_finalize finalize_cb,
+ void* finalize_data,
+ void* finalize_hint);
+
+#endif // NAPI_EXPERIMENTAL
+
+#if NAPI_VERSION >= 6
+
+// BigInt
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_bigint_int64(napi_env env,
+ int64_t value,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_create_bigint_uint64(napi_env env, uint64_t value, napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_create_bigint_words(napi_env env,
+ int sign_bit,
+ size_t word_count,
+ const uint64_t* words,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_bigint_int64(napi_env env,
+ napi_value value,
+ int64_t* result,
+ bool* lossless);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_bigint_uint64(
+ napi_env env, napi_value value, uint64_t* result, bool* lossless);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_get_value_bigint_words(napi_env env,
+ napi_value value,
+ int* sign_bit,
+ size_t* word_count,
+ uint64_t* words);
+
+// Object
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_get_all_property_names(napi_env env,
+ napi_value object,
+ napi_key_collection_mode key_mode,
+ napi_key_filter key_filter,
+ napi_key_conversion key_conversion,
+ napi_value* result);
+
+// Instance data
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_set_instance_data(node_api_basic_env env,
+ void* data,
+ napi_finalize finalize_cb,
+ void* finalize_hint);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_get_instance_data(node_api_basic_env env, void** data);
+#endif // NAPI_VERSION >= 6
+
+#if NAPI_VERSION >= 7
+// ArrayBuffer detaching
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_detach_arraybuffer(napi_env env, napi_value arraybuffer);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_is_detached_arraybuffer(napi_env env, napi_value value, bool* result);
+#endif // NAPI_VERSION >= 7
+
+#if NAPI_VERSION >= 8
+// Type tagging
+NAPI_EXTERN napi_status NAPI_CDECL napi_type_tag_object(
+ napi_env env, napi_value value, const napi_type_tag* type_tag);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_check_object_type_tag(napi_env env,
+ napi_value value,
+ const napi_type_tag* type_tag,
+ bool* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_object_freeze(napi_env env,
+ napi_value object);
+NAPI_EXTERN napi_status NAPI_CDECL napi_object_seal(napi_env env,
+ napi_value object);
+#endif // NAPI_VERSION >= 8
+
+EXTERN_C_END
+
+#endif // SRC_JS_NATIVE_API_H_
diff --git a/apps/desktop/src/native/vendor/js_native_api_types.h b/apps/desktop/src/native/vendor/js_native_api_types.h
new file mode 100644
index 00000000..43e7bb77
--- /dev/null
+++ b/apps/desktop/src/native/vendor/js_native_api_types.h
@@ -0,0 +1,211 @@
+#ifndef SRC_JS_NATIVE_API_TYPES_H_
+#define SRC_JS_NATIVE_API_TYPES_H_
+
+// This file needs to be compatible with C compilers.
+// This is a public include file, and these includes have essentially
+// became part of it's API.
+#include <stddef.h> // NOLINT(modernize-deprecated-headers)
+#include <stdint.h> // NOLINT(modernize-deprecated-headers)
+
+#if !defined __cplusplus || (defined(_MSC_VER) && _MSC_VER < 1900)
+typedef uint16_t char16_t;
+#endif
+
+#ifndef NAPI_CDECL
+#ifdef _WIN32
+#define NAPI_CDECL __cdecl
+#else
+#define NAPI_CDECL
+#endif
+#endif
+
+// JSVM API types are all opaque pointers for ABI stability
+// typedef undefined structs instead of void* for compile time type safety
+typedef struct napi_env__* napi_env;
+
+// We need to mark APIs which can be called during garbage collection (GC),
+// meaning that they do not affect the state of the JS engine, and can
+// therefore be called synchronously from a finalizer that itself runs
+// synchronously during GC. Such APIs can receive either a `napi_env` or a
+// `node_api_basic_env` as their first parameter, because we should be able to
+// also call them during normal, non-garbage-collecting operations, whereas
+// APIs that affect the state of the JS engine can only receive a `napi_env` as
+// their first parameter, because we must not call them during GC. In lieu of
+// inheritance, we use the properties of the const qualifier to accomplish
+// this, because both a const and a non-const value can be passed to an API
+// expecting a const value, but only a non-const value can be passed to an API
+// expecting a non-const value.
+//
+// In conjunction with appropriate CFLAGS to warn us if we're passing a const
+// (basic) environment into an API that expects a non-const environment, and
+// the definition of basic finalizer function pointer types below, which
+// receive a basic environment as their first parameter, and can thus only call
+// basic APIs (unless the user explicitly casts the environment), we achieve
+// the ability to ensure at compile time that we do not call APIs that affect
+// the state of the JS engine from a synchronous (basic) finalizer.
+#if !defined(NAPI_EXPERIMENTAL) || \
+ (defined(NAPI_EXPERIMENTAL) && \
+ (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) || \
+ defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT)))
+typedef struct napi_env__* node_api_nogc_env;
+#else
+typedef const struct napi_env__* node_api_nogc_env;
+#endif
+typedef node_api_nogc_env node_api_basic_env;
+
+typedef struct napi_value__* napi_value;
+typedef struct napi_ref__* napi_ref;
+typedef struct napi_handle_scope__* napi_handle_scope;
+typedef struct napi_escapable_handle_scope__* napi_escapable_handle_scope;
+typedef struct napi_callback_info__* napi_callback_info;
+typedef struct napi_deferred__* napi_deferred;
+
+typedef enum {
+ napi_default = 0,
+ napi_writable = 1 << 0,
+ napi_enumerable = 1 << 1,
+ napi_configurable = 1 << 2,
+
+ // Used with napi_define_class to distinguish static properties
+ // from instance properties. Ignored by napi_define_properties.
+ napi_static = 1 << 10,
+
+#if NAPI_VERSION >= 8
+ // Default for class methods.
+ napi_default_method = napi_writable | napi_configurable,
+
+ // Default for object properties, like in JS obj[prop].
+ napi_default_jsproperty = napi_writable | napi_enumerable | napi_configurable,
+#endif // NAPI_VERSION >= 8
+} napi_property_attributes;
+
+typedef enum {
+ // ES6 types (corresponds to typeof)
+ napi_undefined,
+ napi_null,
+ napi_boolean,
+ napi_number,
+ napi_string,
+ napi_symbol,
+ napi_object,
+ napi_function,
+ napi_external,
+ napi_bigint,
+} napi_valuetype;
+
+typedef enum {
+ napi_int8_array,
+ napi_uint8_array,
+ napi_uint8_clamped_array,
+ napi_int16_array,
+ napi_uint16_array,
+ napi_int32_array,
+ napi_uint32_array,
+ napi_float32_array,
+ napi_float64_array,
+ napi_bigint64_array,
+ napi_biguint64_array,
+} napi_typedarray_type;
+
+typedef enum {
+ napi_ok,
+ napi_invalid_arg,
+ napi_object_expected,
+ napi_string_expected,
+ napi_name_expected,
+ napi_function_expected,
+ napi_number_expected,
+ napi_boolean_expected,
+ napi_array_expected,
+ napi_generic_failure,
+ napi_pending_exception,
+ napi_cancelled,
+ napi_escape_called_twice,
+ napi_handle_scope_mismatch,
+ napi_callback_scope_mismatch,
+ napi_queue_full,
+ napi_closing,
+ napi_bigint_expected,
+ napi_date_expected,
+ napi_arraybuffer_expected,
+ napi_detachable_arraybuffer_expected,
+ napi_would_deadlock, // unused
+ napi_no_external_buffers_allowed,
+ napi_cannot_run_js,
+} napi_status;
+// Note: when adding a new enum value to `napi_status`, please also update
+// * `const int last_status` in the definition of `napi_get_last_error_info()'
+// in file js_native_api_v8.cc.
+// * `const char* error_messages[]` in file js_native_api_v8.cc with a brief
+// message explaining the error.
+// * the definition of `napi_status` in doc/api/n-api.md to reflect the newly
+// added value(s).
+
+typedef napi_value(NAPI_CDECL* napi_callback)(napi_env env,
+ napi_callback_info info);
+typedef void(NAPI_CDECL* napi_finalize)(napi_env env,
+ void* finalize_data,
+ void* finalize_hint);
+
+#if !defined(NAPI_EXPERIMENTAL) || \
+ (defined(NAPI_EXPERIMENTAL) && \
+ (defined(NODE_API_EXPERIMENTAL_NOGC_ENV_OPT_OUT) || \
+ defined(NODE_API_EXPERIMENTAL_BASIC_ENV_OPT_OUT)))
+typedef napi_finalize node_api_nogc_finalize;
+#else
+typedef void(NAPI_CDECL* node_api_nogc_finalize)(node_api_nogc_env env,
+ void* finalize_data,
+ void* finalize_hint);
+#endif
+typedef node_api_nogc_finalize node_api_basic_finalize;
+
+typedef struct {
+ // One of utf8name or name should be NULL.
+ const char* utf8name;
+ napi_value name;
+
+ napi_callback method;
+ napi_callback getter;
+ napi_callback setter;
+ napi_value value;
+
+ napi_property_attributes attributes;
+ void* data;
+} napi_property_descriptor;
+
+typedef struct {
+ const char* error_message;
+ void* engine_reserved;
+ uint32_t engine_error_code;
+ napi_status error_code;
+} napi_extended_error_info;
+
+#if NAPI_VERSION >= 6
+typedef enum {
+ napi_key_include_prototypes,
+ napi_key_own_only
+} napi_key_collection_mode;
+
+typedef enum {
+ napi_key_all_properties = 0,
+ napi_key_writable = 1,
+ napi_key_enumerable = 1 << 1,
+ napi_key_configurable = 1 << 2,
+ napi_key_skip_strings = 1 << 3,
+ napi_key_skip_symbols = 1 << 4
+} napi_key_filter;
+
+typedef enum {
+ napi_key_keep_numbers,
+ napi_key_numbers_to_strings
+} napi_key_conversion;
+#endif // NAPI_VERSION >= 6
+
+#if NAPI_VERSION >= 8
+typedef struct {
+ uint64_t lower;
+ uint64_t upper;
+} napi_type_tag;
+#endif // NAPI_VERSION >= 8
+
+#endif // SRC_JS_NATIVE_API_TYPES_H_
diff --git a/apps/desktop/src/native/vendor/node_api.h b/apps/desktop/src/native/vendor/node_api.h
new file mode 100644
index 00000000..0fd99a96
--- /dev/null
+++ b/apps/desktop/src/native/vendor/node_api.h
@@ -0,0 +1,258 @@
+#ifndef SRC_NODE_API_H_
+#define SRC_NODE_API_H_
+
+#if defined(BUILDING_NODE_EXTENSION) && !defined(NAPI_EXTERN)
+#ifdef _WIN32
+// Building native addon against node
+#define NAPI_EXTERN __declspec(dllimport)
+#elif defined(__wasm__)
+#define NAPI_EXTERN __attribute__((__import_module__("napi")))
+#endif
+#endif
+#include "js_native_api.h"
+#include "node_api_types.h"
+
+struct uv_loop_s; // Forward declaration.
+
+#ifdef _WIN32
+#define NAPI_MODULE_EXPORT __declspec(dllexport)
+#else
+#ifdef __EMSCRIPTEN__
+#define NAPI_MODULE_EXPORT \
+ __attribute__((visibility("default"))) __attribute__((used))
+#else
+#define NAPI_MODULE_EXPORT __attribute__((visibility("default")))
+#endif
+#endif
+
+#if defined(__GNUC__)
+#define NAPI_NO_RETURN __attribute__((noreturn))
+#elif defined(_WIN32)
+#define NAPI_NO_RETURN __declspec(noreturn)
+#else
+#define NAPI_NO_RETURN
+#endif
+
+typedef napi_value(NAPI_CDECL* napi_addon_register_func)(napi_env env,
+ napi_value exports);
+typedef int32_t(NAPI_CDECL* node_api_addon_get_api_version_func)(void);
+
+// Used by deprecated registration method napi_module_register.
+typedef struct napi_module {
+ int nm_version;
+ unsigned int nm_flags;
+ const char* nm_filename;
+ napi_addon_register_func nm_register_func;
+ const char* nm_modname;
+ void* nm_priv;
+ void* reserved[4];
+} napi_module;
+
+#define NAPI_MODULE_VERSION 1
+
+#define NAPI_MODULE_INITIALIZER_X(base, version) \
+ NAPI_MODULE_INITIALIZER_X_HELPER(base, version)
+#define NAPI_MODULE_INITIALIZER_X_HELPER(base, version) base##version
+
+#ifdef __wasm__
+#define NAPI_MODULE_INITIALIZER_BASE napi_register_wasm_v
+#else
+#define NAPI_MODULE_INITIALIZER_BASE napi_register_module_v
+#endif
+
+#define NODE_API_MODULE_GET_API_VERSION_BASE node_api_module_get_api_version_v
+
+#define NAPI_MODULE_INITIALIZER \
+ NAPI_MODULE_INITIALIZER_X(NAPI_MODULE_INITIALIZER_BASE, NAPI_MODULE_VERSION)
+
+#define NODE_API_MODULE_GET_API_VERSION \
+ NAPI_MODULE_INITIALIZER_X(NODE_API_MODULE_GET_API_VERSION_BASE, \
+ NAPI_MODULE_VERSION)
+
+#define NAPI_MODULE_INIT() \
+ EXTERN_C_START \
+ NAPI_MODULE_EXPORT int32_t NODE_API_MODULE_GET_API_VERSION(void) { \
+ return NAPI_VERSION; \
+ } \
+ NAPI_MODULE_EXPORT napi_value NAPI_MODULE_INITIALIZER(napi_env env, \
+ napi_value exports); \
+ EXTERN_C_END \
+ napi_value NAPI_MODULE_INITIALIZER(napi_env env, napi_value exports)
+
+#define NAPI_MODULE(modname, regfunc) \
+ NAPI_MODULE_INIT() { return regfunc(env, exports); }
+
+// Deprecated. Use NAPI_MODULE.
+#define NAPI_MODULE_X(modname, regfunc, priv, flags) \
+ NAPI_MODULE(modname, regfunc)
+
+EXTERN_C_START
+
+// Deprecated. Replaced by symbol-based registration defined by NAPI_MODULE
+// and NAPI_MODULE_INIT macros.
+NAPI_EXTERN void NAPI_CDECL
+napi_module_register(napi_module* mod);
+
+NAPI_EXTERN NAPI_NO_RETURN void NAPI_CDECL
+napi_fatal_error(const char* location,
+ size_t location_len,
+ const char* message,
+ size_t message_len);
+
+// Methods for custom handling of async operations
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_async_init(napi_env env,
+ napi_value async_resource,
+ napi_value async_resource_name,
+ napi_async_context* result);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_async_destroy(napi_env env, napi_async_context async_context);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_make_callback(napi_env env,
+ napi_async_context async_context,
+ napi_value recv,
+ napi_value func,
+ size_t argc,
+ const napi_value* argv,
+ napi_value* result);
+
+// Methods to provide node::Buffer functionality with napi types
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_buffer(napi_env env,
+ size_t length,
+ void** data,
+ napi_value* result);
+#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_create_external_buffer(napi_env env,
+ size_t length,
+ void* data,
+ node_api_basic_finalize finalize_cb,
+ void* finalize_hint,
+ napi_value* result);
+#endif // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+NAPI_EXTERN napi_status NAPI_CDECL napi_create_buffer_copy(napi_env env,
+ size_t length,
+ const void* data,
+ void** result_data,
+ napi_value* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_is_buffer(napi_env env,
+ napi_value value,
+ bool* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_buffer_info(napi_env env,
+ napi_value value,
+ void** data,
+ size_t* length);
+
+// Methods to manage simple async operations
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_create_async_work(napi_env env,
+ napi_value async_resource,
+ napi_value async_resource_name,
+ napi_async_execute_callback execute,
+ napi_async_complete_callback complete,
+ void* data,
+ napi_async_work* result);
+NAPI_EXTERN napi_status NAPI_CDECL napi_delete_async_work(napi_env env,
+ napi_async_work work);
+NAPI_EXTERN napi_status NAPI_CDECL napi_queue_async_work(node_api_basic_env env,
+ napi_async_work work);
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_cancel_async_work(node_api_basic_env env, napi_async_work work);
+
+// version management
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_node_version(
+ node_api_basic_env env, const napi_node_version** version);
+
+#if NAPI_VERSION >= 2
+
+// Return the current libuv event loop for a given environment
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_get_uv_event_loop(node_api_basic_env env, struct uv_loop_s** loop);
+
+#endif // NAPI_VERSION >= 2
+
+#if NAPI_VERSION >= 3
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_fatal_exception(napi_env env,
+ napi_value err);
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_add_env_cleanup_hook(
+ node_api_basic_env env, napi_cleanup_hook fun, void* arg);
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_remove_env_cleanup_hook(
+ node_api_basic_env env, napi_cleanup_hook fun, void* arg);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_open_callback_scope(napi_env env,
+ napi_value resource_object,
+ napi_async_context context,
+ napi_callback_scope* result);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_close_callback_scope(napi_env env, napi_callback_scope scope);
+
+#endif // NAPI_VERSION >= 3
+
+#if NAPI_VERSION >= 4
+
+// Calling into JS from other threads
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_create_threadsafe_function(napi_env env,
+ napi_value func,
+ napi_value async_resource,
+ napi_value async_resource_name,
+ size_t max_queue_size,
+ size_t initial_thread_count,
+ void* thread_finalize_data,
+ napi_finalize thread_finalize_cb,
+ void* context,
+ napi_threadsafe_function_call_js call_js_cb,
+ napi_threadsafe_function* result);
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_get_threadsafe_function_context(
+ napi_threadsafe_function func, void** result);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_call_threadsafe_function(napi_threadsafe_function func,
+ void* data,
+ napi_threadsafe_function_call_mode is_blocking);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_acquire_threadsafe_function(napi_threadsafe_function func);
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_release_threadsafe_function(
+ napi_threadsafe_function func, napi_threadsafe_function_release_mode mode);
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_unref_threadsafe_function(
+ node_api_basic_env env, napi_threadsafe_function func);
+
+NAPI_EXTERN napi_status NAPI_CDECL napi_ref_threadsafe_function(
+ node_api_basic_env env, napi_threadsafe_function func);
+
+#endif // NAPI_VERSION >= 4
+
+#if NAPI_VERSION >= 8
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_add_async_cleanup_hook(node_api_basic_env env,
+ napi_async_cleanup_hook hook,
+ void* arg,
+ napi_async_cleanup_hook_handle* remove_handle);
+
+NAPI_EXTERN napi_status NAPI_CDECL
+napi_remove_async_cleanup_hook(napi_async_cleanup_hook_handle remove_handle);
+
+#endif // NAPI_VERSION >= 8
+
+#if NAPI_VERSION >= 9
+
+NAPI_EXTERN napi_status NAPI_CDECL
+node_api_get_module_file_name(node_api_basic_env env, const char** result);
+
+#endif // NAPI_VERSION >= 9
+
+EXTERN_C_END
+
+#endif // SRC_NODE_API_H_
diff --git a/apps/desktop/src/native/vendor/node_api_types.h b/apps/desktop/src/native/vendor/node_api_types.h
new file mode 100644
index 00000000..9c2f03f4
--- /dev/null
+++ b/apps/desktop/src/native/vendor/node_api_types.h
@@ -0,0 +1,52 @@
+#ifndef SRC_NODE_API_TYPES_H_
+#define SRC_NODE_API_TYPES_H_
+
+#include "js_native_api_types.h"
+
+typedef struct napi_callback_scope__* napi_callback_scope;
+typedef struct napi_async_context__* napi_async_context;
+typedef struct napi_async_work__* napi_async_work;
+
+#if NAPI_VERSION >= 3
+typedef void(NAPI_CDECL* napi_cleanup_hook)(void* arg);
+#endif // NAPI_VERSION >= 3
+
+#if NAPI_VERSION >= 4
+typedef struct napi_threadsafe_function__* napi_threadsafe_function;
+#endif // NAPI_VERSION >= 4
+
+#if NAPI_VERSION >= 4
+typedef enum {
+ napi_tsfn_release,
+ napi_tsfn_abort
+} napi_threadsafe_function_release_mode;
+
+typedef enum {
+ napi_tsfn_nonblocking,
+ napi_tsfn_blocking
+} napi_threadsafe_function_call_mode;
+#endif // NAPI_VERSION >= 4
+
+typedef void(NAPI_CDECL* napi_async_execute_callback)(napi_env env, void* data);
+typedef void(NAPI_CDECL* napi_async_complete_callback)(napi_env env,
+ napi_status status,
+ void* data);
+#if NAPI_VERSION >= 4
+typedef void(NAPI_CDECL* napi_threadsafe_function_call_js)(
+ napi_env env, napi_value js_callback, void* context, void* data);
+#endif // NAPI_VERSION >= 4
+
+typedef struct {
+ uint32_t major;
+ uint32_t minor;
+ uint32_t patch;
+ const char* release;
+} napi_node_version;
+
+#if NAPI_VERSION >= 8
+typedef struct napi_async_cleanup_hook_handle__* napi_async_cleanup_hook_handle;
+typedef void(NAPI_CDECL* napi_async_cleanup_hook)(
+ napi_async_cleanup_hook_handle handle, void* data);
+#endif // NAPI_VERSION >= 8
+
+#endif // SRC_NODE_API_TYPES_H_
diff --git a/apps/web/src/components/canvas/toolbar.tsx b/apps/web/src/components/canvas/toolbar.tsx
index 21b7669e..0a5354ce 100644
--- a/apps/web/src/components/canvas/toolbar.tsx
+++ b/apps/web/src/components/canvas/toolbar.tsx
@@ -39,7 +39,7 @@ export function Toolbar() {
<Show when={!promptInputOpen()}>
<ActionBar openPromptInput={openPromptInput} />
</Show>
- <div class="absolute bottom-4 left-1/2 -translate-x-1/2 rounded-xl p-1.5 bg-background border border-border flex gap-2 items-center z-10">
+ <div class="absolute bottom-4 left-1/2 -translate-x-1/2 rounded-xl p-1.5 bg-background border border-border-strong flex gap-2 items-center z-10">
<div class="flex gap-1">
<Tooltip>
<TooltipTrigger
diff --git a/apps/web/src/components/sidebar-left/project-menu/index.tsx b/apps/web/src/components/sidebar-left/project-menu/index.tsx
index c76ba6cf..96c36551 100644
--- a/apps/web/src/components/sidebar-left/project-menu/index.tsx
+++ b/apps/web/src/components/sidebar-left/project-menu/index.tsx
@@ -45,7 +45,9 @@ export function ProjectMenu() {
class="flex items-center gap-0 h-7 rounded-md text-muted-foreground outline-none focus-ring hover:text-foreground data-expanded:text-foreground"
>
<Icon name="diffusion-logo" class="size-6" />
- <Icon name="chevron-down" class="size-6" />
+ <div class="flex items-center justify-center overflow-clip h-6 w-4">
+ <Icon name="chevron-down" class="size-6" />
+ </div>
</DropdownMenuTrigger>
<DropdownMenuPortal>
<DropdownMenuContent class="w-[188px]">
diff --git a/apps/web/src/components/sidebar-left/sidebar-left.tsx b/apps/web/src/components/sidebar-left/sidebar-left.tsx
index 503f3270..8095a08b 100644
--- a/apps/web/src/components/sidebar-left/sidebar-left.tsx
+++ b/apps/web/src/components/sidebar-left/sidebar-left.tsx
@@ -12,7 +12,6 @@ import { ProjectMenu } from "./project-menu";
import { useProjectId } from "@/hooks/use-project-id";
import { getProjectName, setProjectName } from "../engine/db";
import { createResource } from "solid-js";
-import { Separator } from "@/components/ui/separator";
import { cx } from "@/lib/cva";
export function SidebarLeft() {
@@ -91,9 +90,8 @@ export function ProjectHeader(props: ProjectHeaderProps) {
};
return (
- <div class={cx("h-12 shrink-0 flex items-center gap-2 pr-4 pl-2.5", props.class)}>
+ <div class={cx("h-12 shrink-0 flex items-center gap-1 pr-4 pl-2.5", props.class)}>
<ProjectMenu />
- <Separator orientation="vertical" class="h-6 max-h-6" />
<div class="flex items-center w-full">
<input
type="text"
@@ -103,7 +101,7 @@ export function ProjectHeader(props: ProjectHeaderProps) {
onBlur={handleBlurNameInput}
onKeyDown={handleKeyDownNameInput}
placeholder="Project name"
- class="w-full bg-transparent focus-ring px-1 h-5 ml-1 rounded text-xs text-muted-foreground font-strong outline-none"
+ class="w-full bg-transparent focus-ring px-1 h-5 ml-1 rounded text-xs text-muted-foreground font-450 outline-none"
/>
</div>
</div>
diff --git a/apps/web/src/index.css b/apps/web/src/index.css
index 2029955d..aa5e0f53 100644
--- a/apps/web/src/index.css
+++ b/apps/web/src/index.css
@@ -76,6 +76,7 @@
--color-success-accent: var(--success-accent);
--color-success-accent-foreground: var(--success-accent-foreground);
--color-border: var(--border);
+ --color-border-strong: var(--border-strong);
--color-input: var(--input);
--color-ring: var(--ring);
--color-surface: var(--surface);
@@ -149,6 +150,7 @@
--success-accent: hsla(162, 66%, 29%, 0.24);
--success-accent-foreground: hsla(162, 84%, 89%, 1);
--border: hsla(0, 0%, 91%, 1);
+ --border-strong: hsla(0, 0%, 100%, 0.06);
--border-input: hsla(0, 0%, 88%, 1);
--border-darker: hsla(0, 0%, 95%, 1);
--input: hsla(0, 0%, 95%, 1);
@@ -168,10 +170,10 @@
[data-kb-theme="dark"] {
--canvas: hsla(0, 0%, 9%, 1);
- --background: hsla(0, 0%, 11%, 1);
+ --background: hsla(0, 0%, 7%, 1);
--sidebar: hsla(0, 0%, 0%, 1);
--foreground: hsla(0, 0%, 95%, 1);
- --card: hsla(0, 0%, 11%, 1);
+ --card: hsla(0, 0%, 7%, 1);
--card-foreground: hsla(0, 0%, 95%, 1);
--popover: hsla(0, 0%, 9%, 1);
--popover-foreground: hsla(0, 0%, 95%, 1);
@@ -179,7 +181,7 @@
--primary-foreground: hsla(0, 0%, 95%, 1);
--primary-hover: hsla(207, 98%, 29%, 1);
--primary-pressing: hsla(207, 99%, 22%, 1);
- --secondary: hsla(0, 0%, 16%, 1);
+ --secondary: hsla(0, 0%, 100%, 0.06);
--secondary-foreground: hsla(0, 0%, 95%, 1);
--secondary-hover: hsla(0, 0%, 25%, 1);
--secondary-pressing: hsla(0, 0%, 40%, 1);
@@ -188,10 +190,10 @@
--tertiary-hover: hsla(207, 80%, 17%, 1);
--tertiary-pressing: hsla(207, 80%, 14%, 1);
--muted: hsla(0, 0%, 25%, 1);
- --muted-foreground: hsla(0, 0%, 62%, 1);
+ --muted-foreground: hsla(0, 0%, 95%, 0.64);
--disabled-foreground: hsla(0, 0%, 40%, 1);
- --accent: hsla(0, 0%, 16%, 1);
- --accent-foreground: hsla(0, 0%, 62%, 1);
+ --accent: hsla(0, 0%, 100%, 0.06);
+ --accent-foreground: hsla(0, 0%, 95%, 0.64);
--destructive: hsla(0, 79%, 54%, 1);
--destructive-foreground: hsla(0, 0%, 100%, 1);
--destructive-hover: hsla(0, 60%, 40%, 1);
@@ -200,17 +202,18 @@
--destructive-accent-foreground: hsla(0, 78%, 95%, 1);
--success-accent: hsla(162, 66%, 29%, 0.24);
--success-accent-foreground: hsla(162, 84%, 89%, 1);
- --border: hsla(0, 0%, 15%, 1);
+ --border: hsla(0, 0%, 100%, 0.03);
+ --border-strong: hsla(0, 0%, 100%, 0.06);
--border-input: hsla(0, 0%, 25%, 1);
- --border-darker: hsla(0, 0%, 11%, 1);
- --input: hsla(0, 0%, 16%, 1);
+ --border-darker: hsla(0, 0%, 7%, 1);
+ --input: hsla(0, 0%, 100%, 0.06);
--ring: hsla(207, 100%, 50%, 1);
--canvas: hsla(0, 0%, 9%, 1);
--overlay: hsla(0, 0%, 9%, 0.7);
--overlay-soft: hsla(0, 0%, 9%, 0.4);
--selection: hsla(207, 99%, 22%, 1);
--selection-foreground: hsla(207, 100%, 90%, 1);
- --selection-muted-foreground: hsla(0, 0%, 16%, 1);
+ --selection-muted-foreground: hsla(0, 0%, 100%, 0.06);
--inset: hsla(0, 0%, 25%, 1);
--meter-green: hsla(125, 85%, 57%, 1);
--meter-yellow: hsla(46, 90%, 62%, 1);
@@ -226,11 +229,7 @@
}
[data-platform="darwin"] {
- --sidebar: hsla(0, 0%, 98%, 0.6);
-}
-
-[data-platform="darwin"][data-kb-theme="dark"] {
- --sidebar: hsla(0, 0%, 2%, 0.4);
+ --sidebar: hsla(0, 0%, 0%, 0);
}
@layer base {
diff --git a/apps/web/src/pages/editor.tsx b/apps/web/src/pages/editor.tsx
index e90d9296..b6695fef 100644
--- a/apps/web/src/pages/editor.tsx
+++ b/apps/web/src/pages/editor.tsx
@@ -67,15 +67,15 @@ export function EditorPage() {
</Show>
<Show when={sidebarsVisible()}>
<SidebarLeft />
- <div class="bg-border" />
+ <div class="bg-border-strong" />
</Show>
<Canvas />
<Show when={sidebarsVisible()}>
- <div class="bg-border" />
+ <div class="bg-border-strong" />
<Inspector />
</Show>
<Show when={timelineVisible()}>
- <div class="col-span-full bg-border relative">
+ <div class="col-span-full bg-border-strong relative">
<div
class="absolute left-0 right-0 -top-px h-[3px] z-10 cursor-ns-resize group"
onPointerDown={handleResizeStart}
@@ -89,13 +89,13 @@ export function EditorPage() {
</Show>
<Show when={timelineVisible()}>
<Layers />
- <div class="bg-border" />
+ <div class="bg-border-strong" />
</Show>
<Show when={timelineVisible()}>
<Timeline />
</Show>
<Show when={timelineVisible()}>
- <div class="bg-border" />
+ <div class="bg-border-strong" />
<Soundboard />
</Show>
<Show when={!sidebarsVisible()}>