@effindomv2/fui-as 0.1.0

package/browser/src/common-harness/managed-harness-file-payloads.ts

@@ -0,0 +1,143 @@
+import type { HarnessAppSession } from './managed-harness-session';
+import type { ExternalHarnessDropItem, StoredFileRecord } from './managed-harness-file-types';
+import { EXTERNAL_DROP_ITEM_KIND_FILE } from './managed-harness-file-types';
+
+const encoder = new TextEncoder();
+
+export function encodeLengthPrefixedText(value: string): Uint8Array {
+  return encoder.encode(value);
+}
+
+export function measureLengthPrefixedText(encoded: Uint8Array): number {
+  return 4 + encoded.length;
+}
+
+export function writeLengthPrefixedText(
+  memory: WebAssembly.Memory,
+  basePtr: number,
+  byteOffset: number,
+  encoded: Uint8Array,
+): number {
+  const view = new DataView(memory.buffer, basePtr, byteOffset + 4 + encoded.length);
+  view.setUint32(byteOffset, encoded.length >>> 0, true);
+  let nextOffset = byteOffset + 4;
+  if (encoded.length > 0) {
+    new Uint8Array(memory.buffer, basePtr + nextOffset, encoded.length).set(encoded);
+    nextOffset += encoded.length;
+  }
+  return nextOffset;
+}
+
+export function writeFileListPayload(session: HarnessAppSession, files: readonly StoredFileRecord[]): number {
+  let totalBytes = 4;
+  const encodedIds = new Array<Uint8Array>(files.length);
+  const encodedNames = new Array<Uint8Array>(files.length);
+  const encodedMimeTypes = new Array<Uint8Array>(files.length);
+  for (let index = 0; index < files.length; index += 1) {
+    const entry = files[index];
+    const encodedId = encodeLengthPrefixedText(entry?.id ?? '');
+    const encodedName = encodeLengthPrefixedText(entry?.file.name ?? '');
+    const encodedMimeType = encodeLengthPrefixedText(entry?.file.type ?? '');
+    encodedIds[index] = encodedId;
+    encodedNames[index] = encodedName;
+    encodedMimeTypes[index] = encodedMimeType;
+    totalBytes += measureLengthPrefixedText(encodedId) + 8 + 8 + measureLengthPrefixedText(encodedName) + measureLengthPrefixedText(encodedMimeType);
+  }
+  if (totalBytes > session.textBufferSize) {
+    throw new Error('File picker payload exceeds the shared AssemblyScript text buffer.');
+  }
+  const dataView = new DataView(session.memory.buffer, session.textBufferPtr, totalBytes);
+  let byteOffset = 0;
+  dataView.setUint32(byteOffset, files.length >>> 0, true);
+  byteOffset += 4;
+  for (let index = 0; index < files.length; index += 1) {
+    const entry = files[index];
+    const encodedId = encodedIds[index] ?? new Uint8Array();
+    const encodedName = encodedNames[index] ?? new Uint8Array();
+    const encodedMimeType = encodedMimeTypes[index] ?? new Uint8Array();
+    byteOffset = writeLengthPrefixedText(session.memory, session.textBufferPtr, byteOffset, encodedId);
+    dataView.setBigUint64(byteOffset, BigInt(entry?.file.size ?? 0), true);
+    byteOffset += 8;
+    dataView.setBigUint64(byteOffset, BigInt(Math.max(0, Math.trunc(entry?.file.lastModified ?? 0))), true);
+    byteOffset += 8;
+    byteOffset = writeLengthPrefixedText(session.memory, session.textBufferPtr, byteOffset, encodedName);
+    byteOffset = writeLengthPrefixedText(session.memory, session.textBufferPtr, byteOffset, encodedMimeType);
+  }
+  return totalBytes;
+}
+
+export function writeWriterPayload(
+  session: HarnessAppSession,
+  mode: number,
+  first: string,
+  second: string | null = null,
+): number {
+  const encodedFirst = encodeLengthPrefixedText(first);
+  const encodedSecond = second === null ? null : encodeLengthPrefixedText(second);
+  const totalBytes = 4 + measureLengthPrefixedText(encodedFirst) + (encodedSecond === null ? 0 : measureLengthPrefixedText(encodedSecond));
+  if (totalBytes > session.textBufferSize) {
+    throw new Error('File bridge metadata exceeds the shared AssemblyScript text buffer.');
+  }
+  const dataView = new DataView(session.memory.buffer, session.textBufferPtr, totalBytes);
+  let byteOffset = 0;
+  dataView.setUint32(byteOffset, mode >>> 0, true);
+  byteOffset += 4;
+  byteOffset = writeLengthPrefixedText(session.memory, session.textBufferPtr, byteOffset, encodedFirst);
+  if (encodedSecond !== null) {
+    byteOffset = writeLengthPrefixedText(session.memory, session.textBufferPtr, byteOffset, encodedSecond);
+  }
+  return totalBytes;
+}
+
+export function writeExternalDropPayload(session: HarnessAppSession, items: readonly ExternalHarnessDropItem[]): number {
+  let totalBytes = 4;
+  const encodedIds = new Array<Uint8Array>(items.length);
+  const encodedNames = new Array<Uint8Array>(items.length);
+  const encodedMimeTypes = new Array<Uint8Array>(items.length);
+  for (let index = 0; index < items.length; index += 1) {
+    const item = items[index];
+    const encodedId = encoder.encode(item?.id ?? '');
+    const encodedName = encoder.encode(item?.name ?? '');
+    const encodedMimeType = encoder.encode(item?.mimeType ?? '');
+    encodedIds[index] = encodedId;
+    encodedNames[index] = encodedName;
+    encodedMimeTypes[index] = encodedMimeType;
+    totalBytes += 4 + 8 + 4 + encodedId.length + 4 + encodedName.length + 4 + encodedMimeType.length;
+  }
+  if (totalBytes > session.textBufferSize) {
+    throw new Error('External drop payload exceeds the shared AssemblyScript text buffer.');
+  }
+  const dataView = new DataView(session.memory.buffer, session.textBufferPtr, totalBytes);
+  let byteOffset = 0;
+  dataView.setUint32(byteOffset, items.length >>> 0, true);
+  byteOffset += 4;
+  for (let index = 0; index < items.length; index += 1) {
+    const item = items[index];
+    const encodedId = encodedIds[index] ?? new Uint8Array();
+    const encodedName = encodedNames[index] ?? new Uint8Array();
+    const encodedMimeType = encodedMimeTypes[index] ?? new Uint8Array();
+    dataView.setUint32(byteOffset, (item?.kind ?? EXTERNAL_DROP_ITEM_KIND_FILE) >>> 0, true);
+    byteOffset += 4;
+    dataView.setFloat64(byteOffset, item?.sizeBytes ?? 0, true);
+    byteOffset += 8;
+    dataView.setUint32(byteOffset, encodedId.length >>> 0, true);
+    byteOffset += 4;
+    if (encodedId.length > 0) {
+      new Uint8Array(session.memory.buffer, session.textBufferPtr + byteOffset, encodedId.length).set(encodedId);
+      byteOffset += encodedId.length;
+    }
+    dataView.setUint32(byteOffset, encodedName.length >>> 0, true);
+    byteOffset += 4;
+    if (encodedName.length > 0) {
+      new Uint8Array(session.memory.buffer, session.textBufferPtr + byteOffset, encodedName.length).set(encodedName);
+      byteOffset += encodedName.length;
+    }
+    dataView.setUint32(byteOffset, encodedMimeType.length >>> 0, true);
+    byteOffset += 4;
+    if (encodedMimeType.length > 0) {
+      new Uint8Array(session.memory.buffer, session.textBufferPtr + byteOffset, encodedMimeType.length).set(encodedMimeType);
+      byteOffset += encodedMimeType.length;
+    }
+  }
+  return totalBytes;
+}

package/browser/src/common-harness/managed-harness-file-types.ts

@@ -0,0 +1,106 @@
+import type { HarnessAppSession } from './managed-harness-session';
+
+export const EXTERNAL_DRAG_EVENT_ENTER = 1;
+export const EXTERNAL_DRAG_EVENT_OVER = 2;
+export const EXTERNAL_DRAG_EVENT_LEAVE = 3;
+export const EXTERNAL_DRAG_EVENT_DROP = 4;
+export const EXTERNAL_DROP_ITEM_KIND_FILE = 1;
+export const FILE_STATUS_SUCCESS = 1;
+export const FILE_STATUS_CANCELLED = 2;
+export const FILE_STATUS_ERROR = 3;
+export const FILE_SAVE_MODE_DOWNLOAD = 1;
+export const FILE_SAVE_MODE_NATIVE_PICKER = 2;
+export const FILE_CAPABILITY_OPEN = 1 << 0;
+export const FILE_CAPABILITY_READ = 1 << 1;
+export const FILE_CAPABILITY_SAVE = 1 << 2;
+export const FILE_CAPABILITY_CHUNKED_READ = 1 << 3;
+export const FILE_CAPABILITY_CHUNKED_WRITE = 1 << 4;
+export const FILE_CAPABILITY_NATIVE_SAVE_PICKER = 1 << 5;
+export const FILE_CAPABILITY_PROCESS_WORKER_SAVE = 1 << 6;
+
+export interface ExternalHarnessDropItem {
+  readonly id: string;
+  readonly kind: number;
+  readonly name: string;
+  readonly mimeType: string | null;
+  readonly sizeBytes: number;
+}
+
+export interface WritableFileStreamLike {
+  write(data: BufferSource | Blob | string): Promise<void>;
+  close(): Promise<void>;
+  abort?(reason?: unknown): Promise<void>;
+}
+
+export interface SaveFileHandleLike {
+  readonly name?: string;
+  createWritable(): Promise<WritableFileStreamLike>;
+}
+
+export interface SavePickerWindow extends Window {
+  showSaveFilePicker?: (options?: {
+    suggestedName?: string;
+  }) => Promise<SaveFileHandleLike>;
+}
+
+export interface StoredFileRecord {
+  readonly id: string;
+  readonly file: File;
+}
+
+export interface ActiveFileWriterRecord {
+  readonly id: string;
+  readonly session: HarnessAppSession;
+  readonly fileName: string;
+  readonly mode: number;
+  readonly stream: WritableFileStreamLike;
+  writtenBytes: number;
+}
+
+export interface FileProcessingWorkerStartMessage {
+  readonly type: 'start';
+  readonly file: File;
+  readonly chunkSize: number;
+}
+
+export interface FileProcessingWorkerNextMessage {
+  readonly type: 'next';
+}
+
+export interface FileProcessingWorkerCancelMessage {
+  readonly type: 'cancel';
+}
+
+export type FileProcessingWorkerInboundMessage =
+  | FileProcessingWorkerStartMessage
+  | FileProcessingWorkerNextMessage
+  | FileProcessingWorkerCancelMessage;
+
+export interface FileProcessingWorkerChunkMessage {
+  readonly type: 'chunk';
+  readonly offsetBytes: number;
+  readonly bytes: ArrayBuffer;
+  readonly copiedBytes: number;
+  readonly totalBytes: number;
+}
+
+export interface FileProcessingWorkerErrorMessage {
+  readonly type: 'error';
+  readonly message: string;
+}
+
+export type FileProcessingWorkerOutboundMessage =
+  | FileProcessingWorkerChunkMessage
+  | FileProcessingWorkerErrorMessage;
+
+export interface ActiveFileProcessingRecord {
+  readonly requestId: number;
+  readonly session: HarnessAppSession;
+  readonly sourceFileName: string;
+  readonly targetFileName: string | null;
+  readonly totalBytes: number;
+  readonly worker: Worker;
+  readonly stream: WritableFileStreamLike | null;
+  readonly saveToPickedFile: boolean;
+  cancelled: boolean;
+}

package/browser/src/common-harness/managed-harness-session.ts

@@ -0,0 +1,15 @@
+import type { WorkerHostServicesBundleConfig } from '../worker-types';
+
+import type { HarnessExports, HarnessState } from './types';
+
+export interface HarnessAppSession {
+  readonly exports: HarnessExports;
+  readonly memory: WebAssembly.Memory;
+  readonly keyBufferPtr: number;
+  readonly textBufferPtr: number;
+  readonly textBufferSize: number;
+  readonly hostEventDisposers: Array<() => void>;
+  readonly workerHostServices?: WorkerHostServicesBundleConfig;
+  readonly onStateUpdated?: (state: HarnessState) => void;
+  readonly onDispose?: (exports: HarnessExports) => void;
+}