@effindomv2/fui-as 0.1.27 → 0.1.30

package/browser/src/worker-bootstrap.ts

@@ -1,4 +1,5 @@
 import type {
+  WorkerBootstrapFileProcessStartMessage,
   WorkerBootstrapInboundMessage,
   WorkerBootstrapOutboundMessage,
   WorkerHostServicesBundleConfig,
@@ -22,10 +23,13 @@ const encoder = new TextEncoder();
 let activeWorkerId: number | null = null;
 let activeCancellationRequested = false;
 let pendingCancellationRequested = false;
+let activeFile: File | null = null;
 
 const allowedWorkerHostImports = new Set([
   'fui_fetch_start',
   'fui_fetch_cancel',
+  'fui_file_read_chunk',
+  'fui_file_worker_write_chunk',
   'fui_worker_input_length',
   'fui_worker_copy_input',
   'fui_worker_report_progress',
@@ -369,6 +373,45 @@ async function startWorker(message: WorkerBootstrapStartMessage): Promise<void>
           yieldRequested = true;
           requestedYieldDelayMs = Number.isFinite(delayMs) && delayMs > 0 ? Math.floor(delayMs) : 0;
         },
+        fui_file_read_chunk(offsetLow: number, offsetHigh: number, length: number): number {
+          if (activeFile === null) {
+            return 0;
+          }
+          const offset = Number(BigInt(offsetLow >>> 0) | (BigInt(offsetHigh >>> 0) << 32n));
+          const safeLength = Math.max(0, length | 0);
+          if (offset >= activeFile.size || safeLength <= 0) {
+            return 0;
+          }
+          const blob = activeFile.slice(offset, Math.min(offset + safeLength, activeFile.size));
+          const reader = new FileReaderSync();
+          const buffer = reader.readAsArrayBuffer(blob);
+          const bytes = new Uint8Array(buffer);
+          const written = bytes.length;
+          if (written <= 0) {
+            return 0;
+          }
+          if (memory === null || callbackBufferSize <= 0) {
+            return 0;
+          }
+          if (written > callbackBufferSize) {
+            throw new Error('File chunk exceeds the worker callback buffer.');
+          }
+          new Uint8Array(memory.buffer, callbackBufferPtr, written).set(bytes);
+          return written;
+        },
+        fui_file_worker_write_chunk(ptr: number, len: number): void {
+          if (memory === null || len <= 0) {
+            return;
+          }
+          const bytes = new Uint8Array(len);
+          bytes.set(new Uint8Array(memory.buffer, ptr, len));
+          const buffer = bytes.buffer.slice(0, bytes.byteLength) as ArrayBuffer;
+          workerScope.postMessage({
+            type: 'file-process-chunk',
+            workerId: message.workerId,
+            bytes: buffer,
+          }, [buffer]);
+        },
       },
       fui_fetch_host: {
         fui_fetch_start(
@@ -494,12 +537,375 @@ async function startWorker(message: WorkerBootstrapStartMessage): Promise<void>
   }
 }
 
+async function startFileProcessWorker(message: WorkerBootstrapFileProcessStartMessage): Promise<void> {
+  let memory: WebAssembly.Memory | null = null;
+  let terminalSent = false;
+  let callbackBufferPtr = 0;
+  let callbackBufferSize = 0;
+  let wasmExports: (Record<string, unknown> & {
+    memory?: WebAssembly.Memory;
+    __fui_worker_text_buffer?: () => number;
+    __fui_worker_text_buffer_size?: () => number;
+  }) | null = null;
+  const activeFetchRequests = new Map<number, AbortController>();
+  let entry: (() => void) | null = null;
+  activeWorkerId = message.workerId;
+  activeCancellationRequested = pendingCancellationRequested;
+  activeFile = message.file;
+  pendingCancellationRequested = false;
+
+  function readCancelFlag(): boolean {
+    return activeWorkerId === message.workerId && activeCancellationRequested;
+  }
+
+  function cancelAllFetchRequests(): void {
+    for (const controller of activeFetchRequests.values()) {
+      controller.abort();
+    }
+    activeFetchRequests.clear();
+  }
+
+  function writeCallbackBytes(bytes: Uint8Array, context: string): { ptr: number; len: number } {
+    if (callbackBufferSize <= 0) {
+      throw new Error(`${context} requires the worker callback buffer.`);
+    }
+    if (bytes.length > callbackBufferSize) {
+      throw new Error(`${context} exceeds the worker callback buffer.`);
+    }
+    if (memory === null) {
+      throw new Error(`${context} requires worker memory.`);
+    }
+    if (bytes.length > 0) {
+      new Uint8Array(memory.buffer, callbackBufferPtr, bytes.length).set(bytes);
+    }
+    return {
+      ptr: bytes.length > 0 ? callbackBufferPtr : 0,
+      len: bytes.length,
+    };
+  }
+
+  function emitFetchComplete(
+    requestId: number,
+    ok: boolean,
+    status: number,
+    statusText: string,
+    url: string,
+    exports: Record<string, unknown>,
+  ): void {
+    const callback = exports.__fui_on_fetch_complete;
+    if (typeof callback !== 'function') {
+      throw new Error('Worker module is missing __fui_on_fetch_complete.');
+    }
+    const payload = writeCallbackBytes(encodeTextPartsPayload([statusText, url]), 'Worker fetch completion payload');
+    (callback as (requestId: number, ok: boolean, status: number, payloadPtr: number, payloadLen: number) => void)(
+      requestId,
+      ok,
+      status,
+      payload.ptr,
+      payload.len,
+    );
+  }
+
+  function emitFetchError(
+    requestId: number,
+    message: string,
+    exports: Record<string, unknown>,
+  ): void {
+    const callback = exports.__fui_on_fetch_error;
+    if (typeof callback !== 'function') {
+      throw new Error('Worker module is missing __fui_on_fetch_error.');
+    }
+    const payload = writeCallbackBytes(encoder.encode(message), 'Worker fetch failure payload');
+    (callback as (requestId: number, payloadPtr: number, payloadLen: number) => void)(
+      requestId,
+      payload.ptr,
+      payload.len,
+    );
+  }
+
+  function runEntry(): void {
+    if (entry === null || wasmExports === null) {
+      return;
+    }
+    try {
+      entry();
+    } catch (error: unknown) {
+      if (terminalSent) {
+        return;
+      }
+      terminalSent = true;
+      cancelAllFetchRequests();
+      activeWorkerId = null;
+      activeCancellationRequested = false;
+      activeFile = null;
+      workerScope.postMessage({
+        type: 'error',
+        workerId: message.workerId,
+        text: describeError(error),
+      });
+      return;
+    }
+    if (terminalSent) {
+      return;
+    }
+  }
+
+  function cleanupTerminal(): void {
+    terminalSent = true;
+    cancelAllFetchRequests();
+    activeWorkerId = null;
+    activeCancellationRequested = false;
+  }
+  try {
+    const response = await fetch(message.wasmUrl, {
+      cache: 'no-store',
+      credentials: 'same-origin',
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to load worker wasm from ${message.wasmUrl}.`);
+    }
+    const bytes = await response.arrayBuffer();
+    const module = await WebAssembly.compile(bytes);
+    const hostServices = loadWorkerHostServices(message.workerHostServices);
+    validateWorkerImports(module, hostServices);
+    const instance = await WebAssembly.instantiate(module, {
+      env: {
+        abort(_message?: number, _fileName?: number, line?: number, column?: number): never {
+          throw new Error(`Worker aborted at ${String(line ?? 0)}:${String(column ?? 0)}.`);
+        },
+      },
+      fui_host_service: createHostServiceImportModule(hostServices, {
+        readString: (ptr, len) => readUtf8(memory, ptr, len),
+        writeString: (ptr, capacity, text, context) => writeUtf8(memory, ptr, capacity, text, context),
+        readBytes: (ptr, len) => readBytes(memory, ptr, len),
+        writeBytes: (ptr, capacity, bytes, context) => writeBytes(memory, ptr, capacity, bytes, context),
+      }),
+      fui_worker_host: {
+        fui_worker_input_length(): number {
+          return 0;
+        },
+        fui_worker_copy_input(_ptr: number, _capacity: number): number {
+          return 0;
+        },
+        fui_worker_report_progress(ptr: number, len: number): void {
+          if (terminalSent) {
+            return;
+          }
+          workerScope.postMessage({
+            type: 'progress',
+            workerId: message.workerId,
+            text: readUtf8(memory, ptr, len),
+          });
+        },
+        fui_worker_complete_string(ptr: number, len: number): void {
+          if (terminalSent) {
+            return;
+          }
+          cleanupTerminal();
+          activeFile = null;
+          workerScope.postMessage({
+            type: 'complete',
+            workerId: message.workerId,
+            text: readUtf8(memory, ptr, len),
+          });
+        },
+        fui_worker_fail(ptr: number, len: number): void {
+          if (terminalSent) {
+            return;
+          }
+          cleanupTerminal();
+          activeFile = null;
+          workerScope.postMessage({
+            type: 'error',
+            workerId: message.workerId,
+            text: readUtf8(memory, ptr, len),
+          });
+        },
+        fui_worker_is_cancelled(): number {
+          return readCancelFlag() ? 1 : 0;
+        },
+        fui_worker_request_yield(): void {
+          // File processing is synchronous — yield is a no-op.
+        },
+        fui_worker_request_yield_delay(_delayMs: number): void {
+          // File processing is synchronous — yield is a no-op.
+        },
+        fui_file_read_chunk(offsetLow: number, offsetHigh: number, length: number): number {
+          if (activeFile === null) {
+            return 0;
+          }
+          const offset = Number(BigInt(offsetLow >>> 0) | (BigInt(offsetHigh >>> 0) << 32n));
+          const safeLength = Math.max(0, length | 0);
+          if (offset >= activeFile.size || safeLength <= 0) {
+            return 0;
+          }
+          const blob = activeFile.slice(offset, Math.min(offset + safeLength, activeFile.size));
+          const reader = new FileReaderSync();
+          const buffer = reader.readAsArrayBuffer(blob);
+          const readBytes = new Uint8Array(buffer);
+          const written = readBytes.length;
+          if (written <= 0) {
+            return 0;
+          }
+          if (memory === null || callbackBufferSize <= 0) {
+            return 0;
+          }
+          if (written > callbackBufferSize) {
+            throw new Error('File chunk exceeds the worker callback buffer.');
+          }
+          new Uint8Array(memory.buffer, callbackBufferPtr, written).set(readBytes);
+          return written;
+        },
+        fui_file_worker_write_chunk(ptr: number, len: number): void {
+          if (memory === null || len <= 0) {
+            return;
+          }
+          const chunkBytes = new Uint8Array(len);
+          chunkBytes.set(new Uint8Array(memory.buffer, ptr, len));
+          const buffer = chunkBytes.buffer.slice(0, chunkBytes.byteLength) as ArrayBuffer;
+          workerScope.postMessage({
+            type: 'file-process-chunk',
+            workerId: message.workerId,
+            bytes: buffer,
+          }, [buffer]);
+        },
+      },
+      fui_fetch_host: {
+        fui_fetch_start(
+          requestId: number,
+          methodPtr: number,
+          methodLen: number,
+          urlPtr: number,
+          urlLen: number,
+          headersPtr: number,
+          headersLen: number,
+          bodyPtr: number,
+          bodyLen: number,
+        ): void {
+          const controller = new AbortController();
+          const method = readUtf8(memory, methodPtr, methodLen);
+          const url = readUtf8(memory, urlPtr, urlLen);
+          const headerBytes = memory === null || headersLen <= 0
+            ? new Uint8Array(0)
+            : new Uint8Array(memory.buffer.slice(headersPtr, headersPtr + headersLen));
+          if (headerBytes.byteLength < 4 && headersLen > 0) {
+            throw new Error('Worker fetch header payload was truncated.');
+          }
+          const headers = new Headers();
+          if (headerBytes.byteLength >= 4) {
+            const dataView = new DataView(headerBytes.buffer, headerBytes.byteOffset, headerBytes.byteLength);
+            let byteOffset = 0;
+            const count = dataView.getUint32(byteOffset, true);
+            byteOffset += 4;
+            const values: string[] = [];
+            for (let index = 0; index < count; index += 1) {
+              if (byteOffset + 4 > headerBytes.byteLength) {
+                throw new Error('Worker fetch header length was truncated.');
+              }
+              const partLen = dataView.getUint32(byteOffset, true);
+              byteOffset += 4;
+              if (byteOffset + partLen > headerBytes.byteLength) {
+                throw new Error('Worker fetch header value was truncated.');
+              }
+              values.push(partLen > 0 ? decoder.decode(headerBytes.subarray(byteOffset, byteOffset + partLen)) : '');
+              byteOffset += partLen;
+            }
+            if ((values.length & 1) != 0) {
+              throw new Error('Worker fetch headers were malformed.');
+            }
+            for (let index = 0; index < values.length; index += 2) {
+              headers.append(values[index] ?? '', values[index + 1] ?? '');
+            }
+          }
+          const bodyBytes = memory === null || bodyLen <= 0
+            ? new Uint8Array(0)
+            : new Uint8Array(memory.buffer, bodyPtr, bodyLen);
+          const body = bodyBytes.length > 0 ? bodyBytes : undefined;
+          activeFetchRequests.set(requestId, controller);
+          void fetch(url, {
+            method,
+            headers,
+            body,
+            signal: controller.signal,
+          }).then((response) => {
+            const active = activeFetchRequests.get(requestId);
+            if (active === undefined || active !== controller || terminalSent) {
+              return;
+            }
+            activeFetchRequests.delete(requestId);
+            if (wasmExports === null) {
+              throw new Error('Worker fetch completed before wasm exports were ready.');
+            }
+            emitFetchComplete(requestId, response.ok, response.status, response.statusText, response.url, wasmExports);
+          }).catch((error: unknown) => {
+            const active = activeFetchRequests.get(requestId);
+            if (active === undefined || active !== controller) {
+              return;
+            }
+            activeFetchRequests.delete(requestId);
+            if (controller.signal.aborted || terminalSent) {
+              return;
+            }
+            if (wasmExports === null) {
+              throw new Error('Worker fetch failed before wasm exports were ready.');
+            }
+            emitFetchError(requestId, describeError(error), wasmExports);
+          });
+        },
+        fui_fetch_cancel(requestId: number): void {
+          const controller = activeFetchRequests.get(requestId);
+          if (controller === undefined) {
+            return;
+          }
+          activeFetchRequests.delete(requestId);
+          controller.abort();
+        },
+      },
+    });
+    const exports = instance.exports as Record<string, unknown> & {
+      memory?: WebAssembly.Memory;
+      __fui_worker_text_buffer?: () => number;
+      __fui_worker_text_buffer_size?: () => number;
+    };
+    wasmExports = exports;
+    if (!(exports.memory instanceof WebAssembly.Memory)) {
+      throw new Error('Worker module did not export memory.');
+    }
+    memory = exports.memory;
+    if (typeof exports.__fui_worker_text_buffer !== 'function' || typeof exports.__fui_worker_text_buffer_size !== 'function') {
+      throw new Error('Worker module did not export the fetch callback buffer.');
+    }
+    callbackBufferPtr = exports.__fui_worker_text_buffer();
+    callbackBufferSize = exports.__fui_worker_text_buffer_size();
+    const exportedEntry = exports[message.entryName];
+    if (typeof exportedEntry !== 'function') {
+      throw new Error(`Worker export "${message.entryName}" is missing.`);
+    }
+    entry = exportedEntry as () => void;
+    runEntry();
+  } catch (error: unknown) {
+    cancelAllFetchRequests();
+    activeWorkerId = null;
+    activeCancellationRequested = false;
+    activeFile = null;
+    workerScope.postMessage({
+      type: 'error',
+      workerId: message.workerId,
+      text: describeError(error),
+    });
+  }
+}
+
 workerScope.onmessage = (event: MessageEvent<WorkerBootstrapInboundMessage>) => {
   const message = event.data;
   if (message.type === 'start') {
     void startWorker(message);
     return;
   }
+  if (message.type === 'start-file-process') {
+    void startFileProcessWorker(message);
+    return;
+  }
   if (message.type === 'cancel') {
     if (activeWorkerId === message.workerId) {
       activeCancellationRequested = true;

package/browser/src/worker-manager.ts

@@ -121,6 +121,10 @@ export function createWorkerManager(options: WorkerManagerOptions): WorkerManage
       finishWorker(workerId);
       return;
     }
+    // File-process chunk messages are routed through the file host, not the worker manager.
+    if (message.type === 'file-process-chunk') {
+      return;
+    }
     emitToSession(workerId, 'error', message.text);
     finishWorker(workerId);
   }

package/browser/src/worker-types.ts

@@ -17,6 +17,16 @@ export interface WorkerBootstrapStartMessage {
   readonly workerHostServices?: WorkerHostServicesBundleConfig;
 }
 
+export interface WorkerBootstrapFileProcessStartMessage {
+  readonly type: "start-file-process";
+  readonly workerId: number;
+  readonly file: File;
+  readonly wasmUrl: string;
+  readonly entryName: string;
+  readonly chunkSize: number;
+  readonly workerHostServices?: WorkerHostServicesBundleConfig;
+}
+
 export interface WorkerBootstrapCancelMessage {
   readonly type: "cancel";
   readonly workerId: number;
@@ -24,6 +34,7 @@ export interface WorkerBootstrapCancelMessage {
 
 export type WorkerBootstrapInboundMessage =
   | WorkerBootstrapStartMessage
+  | WorkerBootstrapFileProcessStartMessage
   | WorkerBootstrapCancelMessage;
 
 export interface WorkerBootstrapProgressMessage {
@@ -38,6 +49,12 @@ export interface WorkerBootstrapCompleteMessage {
   readonly text: string;
 }
 
+export interface WorkerBootstrapFileProcessChunkMessage {
+  readonly type: "file-process-chunk";
+  readonly workerId: number;
+  readonly bytes: ArrayBuffer;
+}
+
 export interface WorkerBootstrapErrorMessage {
   readonly type: "error";
   readonly workerId: number;
@@ -47,4 +64,5 @@ export interface WorkerBootstrapErrorMessage {
 export type WorkerBootstrapOutboundMessage =
   | WorkerBootstrapProgressMessage
   | WorkerBootstrapCompleteMessage
+  | WorkerBootstrapFileProcessChunkMessage
   | WorkerBootstrapErrorMessage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effindomv2/fui-as",
-  "version": "0.1.27",
+  "version": "0.1.30",
   "private": false,
   "license": "AGPL-3.0-only OR LicenseRef-EffinDom-Commercial",
   "description": "EffinDom v2 AssemblyScript frontend framework SDK and browser harness",
@@ -86,7 +86,8 @@
   },
   "dependencies": {
     "@assemblyscript/loader": "^0.28.17",
-    "@effindomv2/runtime": "0.1.10"
+    "@devcycle/assemblyscript-json": "^2.0.0",
+    "@effindomv2/runtime": "0.1.13"
   },
   "devDependencies": {
     "@as-pect/assembly": "8.1.0",

package/src/Fui.ts

@@ -138,6 +138,7 @@ export { frameTimeSignal, viewportHeightSignal, viewportWidthSignal } from "./co
 export {
   AntiSelectionArea,
   Button,
+  ButtonColors,
   ButtonPresenter,
   ButtonTemplate,
   ButtonVisualState,

package/src/FuiWorker.ts

@@ -1,3 +1,7 @@
 export { Fetch, FetchRequest, FetchResponse } from "./core/Fetch";
-export { Worker as WorkerRuntime } from "./worker/Worker";
+export { Worker, Worker as WorkerRuntime } from "./worker/Worker";
 export { WorkerJob } from "./worker/WorkerJob";
+export {
+  fui_file_read_chunk,
+  fui_file_worker_write_chunk,
+} from "./worker/ffi";

package/src/controls/Button.ts

@@ -20,6 +20,7 @@ import { Signal } from "../core/Signal";
 import { Theme, activeTheme } from "../core/Theme";
 import { FontFamily, FontStyle, FontWeight } from "../core/Typography";
 import { FlexBox, TextCore } from "../nodes";
+import { ButtonColors } from "./ButtonColors";
 import { getControlTemplates } from "./ControlTemplateSet";
 import {
   ButtonPresenter,
@@ -119,6 +120,7 @@ export class Button extends FlexBox {
   private shadowOffsetYValue: f32 = 0.0;
   private shadowBlurValue: f32 = 0.0;
   private shadowSpreadValue: f32 = 0.0;
+  private colorsValue: ButtonColors | null = null;
   private templateValue: ButtonTemplate | null = null;
   private presenterNeedsRefresh: bool = false;
 
@@ -203,6 +205,12 @@ export class Button extends FlexBox {
     return this;
   }
 
+  colors(colors: ButtonColors | null): this {
+    this.colorsValue = colors;
+    this.handleThemeSignalChanged();
+    return this;
+  }
+
   bgColor(color: u32): this {
     this.backgroundOverridden = true;
     this.normalBackgroundColorValue = color;
@@ -499,14 +507,31 @@ export class Button extends FlexBox {
   }
 
   private syncThemeState(theme: Theme): void {
+    const colors = this.colorsValue;
     if (!this.backgroundOverridden) {
-      this.normalBackgroundColorValue = theme.colors.accent;
+      this.normalBackgroundColorValue = colors !== null && colors.hasBackground
+        ? colors.backgroundColor
+        : theme.colors.accent;
     }
     if (!this.hoverBackgroundOverridden) {
-      this.hoverBackgroundColorValue = theme.colors.accentHovered;
+      if (colors !== null && colors.hasBackgroundHover) {
+        this.hoverBackgroundColorValue = colors.backgroundHoverColor;
+      } else if (colors !== null && colors.hasBackground) {
+        this.hoverBackgroundColorValue = colors.backgroundColor;
+      } else {
+        this.hoverBackgroundColorValue = theme.colors.accentHovered;
+      }
     }
     if (!this.pressedBackgroundOverridden) {
-      this.pressedBackgroundColorValue = theme.colors.accentPressed;
+      if (colors !== null && colors.hasBackgroundPressed) {
+        this.pressedBackgroundColorValue = colors.backgroundPressedColor;
+      } else if (colors !== null && colors.hasBackgroundHover) {
+        this.pressedBackgroundColorValue = colors.backgroundHoverColor;
+      } else if (colors !== null && colors.hasBackground) {
+        this.pressedBackgroundColorValue = colors.backgroundColor;
+      } else {
+        this.pressedBackgroundColorValue = theme.colors.accentPressed;
+      }
     }
     if (!this.cornerRadiusOverridden) {
       this.focusCornerTopLeft = theme.spacing.sm;
@@ -516,7 +541,9 @@ export class Button extends FlexBox {
     }
     if (!this.borderOverridden) {
       this.borderWidthValue = 1.0;
-      this.borderColorValue = theme.colors.border;
+      this.borderColorValue = colors !== null && colors.hasBorder
+        ? colors.borderColor
+        : theme.colors.border;
       this.borderStyleValue = BorderStyle.Solid;
       this.borderDashedValue = false;
     }
@@ -543,7 +570,13 @@ export class Button extends FlexBox {
       this.fontSizeValue = theme.fonts.sizeBody;
     }
     if (!this.textColorOverridden) {
-      this.textColorValue = theme.colors.textOnAccent;
+      if (!this.isEnabled && colors !== null && colors.hasTextMuted) {
+        this.textColorValue = colors.textMutedColor;
+      } else if (colors !== null && colors.hasTextPrimary) {
+        this.textColorValue = colors.textPrimaryColor;
+      } else {
+        this.textColorValue = theme.colors.textOnAccent;
+      }
     }
     const presenterHostState = new ButtonPresenterHostState(
       this.backgroundOverridden,
@@ -572,7 +605,7 @@ export class Button extends FlexBox {
       this.paddingRightValue,
       this.paddingBottomValue,
     );
-    this.presenter.apply(theme, this.createVisualState());
+    this.presenter.apply(theme, this.createVisualState(), this.colorsValue);
     this.backgroundOverridden = presenterHostState.backgroundOverridden;
     this.normalBackgroundColorValue = presenterHostState.normalBackgroundColorValue;
     this.cornerRadiusOverridden = presenterHostState.cornerRadiusOverridden;