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.jsonindex 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.mjsnew file mode 100644index 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.tsindex 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.mnew file mode 100644index 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.hnew file mode 100644index 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.hnew file mode 100644index 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.hnew file mode 100644index 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.hnew file mode 100644index 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.tsxindex 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><TooltipTriggerdiff --git a/apps/web/src/components/sidebar-left/project-menu/index.tsx b/apps/web/src/components/sidebar-left/project-menu/index.tsxindex 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.tsxindex 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"><inputtype="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.cssindex 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.tsxindex 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"><divclass="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()}>