@effindomv2/fui-as 0.1.1 → 0.1.3

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

@@ -255,6 +255,19 @@ export function startManagedHarness(options: ManagedHarnessOptions): void {
       return textBridge.writeAppUtf8(ptr, capacity, text, context);
     }
 
+    function writeAppBytes(ptr: number, capacity: number, bytes: Uint8Array, context: string): number {
+      if (capacity < 0) {
+        throw new Error(`${context} has invalid buffer capacity ${String(capacity)}.`);
+      }
+      if (bytes.length > capacity) {
+        throw new Error(`${context} returned ${String(bytes.length)} bytes but the shared result buffer only holds ${String(capacity)}.`);
+      }
+      if (bytes.length > 0) {
+        new Uint8Array(getCurrentMemory().buffer, ptr, bytes.length).set(bytes);
+      }
+      return bytes.length;
+    }
+
     function withUiUtf8(
       text: string,
       callback: (ptr: WasmHandleLike | number, len: number) => void,
@@ -480,6 +493,71 @@ export function startManagedHarness(options: ManagedHarnessOptions): void {
       method: NormalizedHostEventMethod,
       args: readonly unknown[],
     ): Array<unknown> {
+      function alignOffset(value: number, alignment: number): number {
+        return alignment <= 1 ? value : (value + alignment - 1) & ~(alignment - 1);
+      }
+
+      function encodeTypedArrayArg(
+        type: "bytes" | "i32_array" | "u32_array" | "i64_array" | "u64_array" | "f64_array",
+        arg: unknown,
+        context: string,
+      ): { bytes: Uint8Array; elementCount: number; alignment: number } {
+        if (type === "bytes") {
+          if (!(arg instanceof Uint8Array)) {
+            throw new Error(`${context} must be a Uint8Array.`);
+          }
+          return { bytes: arg, elementCount: arg.length, alignment: 1 };
+        }
+        if (type === "i32_array") {
+          if (!(arg instanceof Int32Array)) {
+            throw new Error(`${context} must be an Int32Array.`);
+          }
+          return {
+            bytes: new Uint8Array(arg.buffer, arg.byteOffset, arg.byteLength),
+            elementCount: arg.length,
+            alignment: 4,
+          };
+        }
+        if (type === "u32_array") {
+          if (!(arg instanceof Uint32Array)) {
+            throw new Error(`${context} must be a Uint32Array.`);
+          }
+          return {
+            bytes: new Uint8Array(arg.buffer, arg.byteOffset, arg.byteLength),
+            elementCount: arg.length,
+            alignment: 4,
+          };
+        }
+        if (type === "i64_array") {
+          if (!(arg instanceof BigInt64Array)) {
+            throw new Error(`${context} must be a BigInt64Array.`);
+          }
+          return {
+            bytes: new Uint8Array(arg.buffer, arg.byteOffset, arg.byteLength),
+            elementCount: arg.length,
+            alignment: 8,
+          };
+        }
+        if (type === "u64_array") {
+          if (!(arg instanceof BigUint64Array)) {
+            throw new Error(`${context} must be a BigUint64Array.`);
+          }
+          return {
+            bytes: new Uint8Array(arg.buffer, arg.byteOffset, arg.byteLength),
+            elementCount: arg.length,
+            alignment: 8,
+          };
+        }
+        if (!(arg instanceof Float64Array)) {
+          throw new Error(`${context} must be a Float64Array.`);
+        }
+        return {
+          bytes: new Uint8Array(arg.buffer, arg.byteOffset, arg.byteLength),
+          elementCount: arg.length,
+          alignment: 8,
+        };
+      }
+
       if (args.length != method.args.length) {
         throw new Error(`Host event ${method.serviceName}.${method.methodName} expected ${String(method.args.length)} args but received ${String(args.length)}.`);
       }
@@ -507,6 +585,22 @@ export function startManagedHarness(options: ManagedHarnessOptions): void {
           }
           continue;
         }
+        if (type === "bytes" || type === "i32_array" || type === "u32_array" || type === "i64_array" || type === "u64_array" || type === "f64_array") {
+          const payload = encodeTypedArrayArg(type, arg, context);
+          if (payload.bytes.length > 0) {
+            const alignedOffset = alignOffset(byteOffset, payload.alignment);
+            if (session.textBufferPtr === 0 || alignedOffset + payload.bytes.length > session.textBufferSize) {
+              throw new Error(`${context} exceeds the shared AssemblyScript text buffer.`);
+            }
+            const memory = new Uint8Array(session.memory.buffer, session.textBufferPtr + alignedOffset, payload.bytes.length);
+            memory.set(payload.bytes);
+            callArgs.push(session.textBufferPtr + alignedOffset, payload.elementCount);
+            byteOffset = alignedOffset + payload.bytes.length;
+          } else {
+            callArgs.push(0, 0);
+          }
+          continue;
+        }
         if (type === 'bool') {
           if (typeof arg !== 'boolean') {
             throw new Error(`${context} must be a boolean.`);
@@ -514,6 +608,19 @@ export function startManagedHarness(options: ManagedHarnessOptions): void {
           callArgs.push(arg ? 1 : 0);
           continue;
         }
+        if (type === "i64" || type === "u64") {
+          if (typeof arg !== "bigint") {
+            throw new Error(`${context} must be a bigint.`);
+          }
+          if (type === "i64" && (arg < -9223372036854775808n || arg > 9223372036854775807n)) {
+            throw new Error(`${context} must be a signed 64-bit integer.`);
+          }
+          if (type === "u64" && (arg < 0n || arg > 18446744073709551615n)) {
+            throw new Error(`${context} must be an unsigned 64-bit integer.`);
+          }
+          callArgs.push(arg);
+          continue;
+        }
         if (typeof arg !== 'number' || Number.isNaN(arg)) {
           throw new Error(`${context} must be a number.`);
         }
@@ -521,6 +628,10 @@ export function startManagedHarness(options: ManagedHarnessOptions): void {
           if (!Number.isInteger(arg) || arg < -2147483648 || arg > 2147483647) {
             throw new Error(`${context} must be a signed 32-bit integer.`);
           }
+        } else if (type === "u32") {
+          if (!Number.isInteger(arg) || arg < 0 || arg > 4294967295) {
+            throw new Error(`${context} must be an unsigned 32-bit integer.`);
+          }
         }
         callArgs.push(arg);
       }
@@ -703,6 +814,8 @@ export function startManagedHarness(options: ManagedHarnessOptions): void {
       const hostServiceImports = createHostServiceImportModule(hostServices, {
         readString: readAppUtf8,
         writeString: writeAppUtf8,
+        readBytes: readAppBytes,
+        writeBytes: writeAppBytes,
       });
       return {
         effindom_v2_ui: createUiImportModule({

package/browser/src/host-events.ts

@@ -3,6 +3,13 @@ import type { HostServiceTypeName } from "./host-services";
 type HostEventTypeValue<T extends HostServiceTypeName> =
   T extends "string" ? string :
   T extends "bool" ? boolean :
+  T extends "bytes" ? Uint8Array :
+  T extends "i32_array" ? Int32Array :
+  T extends "u32_array" ? Uint32Array :
+  T extends "i64_array" ? BigInt64Array :
+  T extends "u64_array" ? BigUint64Array :
+  T extends "f64_array" ? Float64Array :
+  T extends "i64" | "u64" ? bigint :
   T extends "void" ? void :
   number;
 
@@ -59,7 +66,21 @@ function buildExportName(eventName: string): string {
 }
 
 function validateEventType(type: string, context: string): asserts type is HostServiceTypeName {
-  if (type === "string" || type === "bool" || type === "i32" || type === "f64") {
+  if (
+    type === "string" ||
+    type === "bool" ||
+    type === "i32" ||
+    type === "u32" ||
+    type === "i64" ||
+    type === "u64" ||
+    type === "f64" ||
+    type === "bytes" ||
+    type === "i32_array" ||
+    type === "u32_array" ||
+    type === "i64_array" ||
+    type === "u64_array" ||
+    type === "f64_array"
+  ) {
     return;
   }
   throw new Error(`${context} uses unsupported host-event type "${type}".`);

package/browser/src/host-services.ts

@@ -1,8 +1,29 @@
-export type HostServiceTypeName = "string" | "bool" | "i32" | "f64" | "void";
+export type HostServiceTypeName =
+  | "string"
+  | "bool"
+  | "i32"
+  | "u32"
+  | "i64"
+  | "u64"
+  | "f64"
+  | "bytes"
+  | "i32_array"
+  | "u32_array"
+  | "i64_array"
+  | "u64_array"
+  | "f64_array"
+  | "void";
 
 type HostServiceTypeValue<T extends HostServiceTypeName> =
   T extends "string" ? string :
   T extends "bool" ? boolean :
+  T extends "bytes" ? Uint8Array :
+  T extends "i32_array" ? Int32Array :
+  T extends "u32_array" ? Uint32Array :
+  T extends "i64_array" ? BigInt64Array :
+  T extends "u64_array" ? BigUint64Array :
+  T extends "f64_array" ? Float64Array :
+  T extends "i64" | "u64" ? bigint :
   T extends "void" ? void :
   number;
 
@@ -14,6 +35,7 @@ export interface HostServiceMethodDefinition<
   TArgs extends readonly HostServiceTypeName[] = readonly HostServiceTypeName[],
   TResult extends HostServiceTypeName = HostServiceTypeName,
 > {
+  readonly importName?: string;
   readonly args: TArgs;
   readonly returns: TResult;
   readonly implementation: (...args: HostServiceArgsValues<TArgs>) => HostServiceTypeValue<TResult>;
@@ -33,6 +55,8 @@ export interface NormalizedHostServiceMethod {
 export interface HostServiceImportIo {
   readString(ptr: number, len: number): string;
   writeString(ptr: number, capacity: number, text: string, context: string): number;
+  readBytes(ptr: number, len: number): Uint8Array;
+  writeBytes(ptr: number, capacity: number, bytes: Uint8Array, context: string): number;
 }
 
 const IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -63,7 +87,22 @@ function buildImportName(serviceName: string, methodName: string): string {
 }
 
 function validateServiceType(type: string, context: string): asserts type is HostServiceTypeName {
-  if (type === "string" || type === "bool" || type === "i32" || type === "f64" || type === "void") {
+  if (
+    type === "string" ||
+    type === "bool" ||
+    type === "i32" ||
+    type === "u32" ||
+    type === "i64" ||
+    type === "u64" ||
+    type === "f64" ||
+    type === "bytes" ||
+    type === "i32_array" ||
+    type === "u32_array" ||
+    type === "i64_array" ||
+    type === "u64_array" ||
+    type === "f64_array" ||
+    type === "void"
+  ) {
     return;
   }
   throw new Error(`${context} uses unsupported host-service type "${type}".`);
@@ -79,7 +118,8 @@ export function listHostServiceMethods(services: HostServicesDefinition | undefi
     assertIdentifier(serviceName, "Host service");
     for (const [methodName, definition] of Object.entries(serviceMethods)) {
       assertIdentifier(methodName, `Host service ${serviceName} method`);
-      const importName = buildImportName(serviceName, methodName);
+      const importName = definition.importName ?? buildImportName(serviceName, methodName);
+      assertIdentifier(importName, `Host service ${serviceName}.${methodName} import`);
       if (seenImports.has(importName)) {
         throw new Error(`Duplicate host-service import name "${importName}".`);
       }
@@ -126,6 +166,48 @@ function expectString(value: unknown, context: string): string {
   return value;
 }
 
+function expectBytes(value: unknown, context: string): Uint8Array {
+  if (!(value instanceof Uint8Array)) {
+    throw new Error(`${context} must be a Uint8Array.`);
+  }
+  return value;
+}
+
+function expectInt32Array(value: unknown, context: string): Int32Array {
+  if (!(value instanceof Int32Array)) {
+    throw new Error(`${context} must be an Int32Array.`);
+  }
+  return value;
+}
+
+function expectFloat64Array(value: unknown, context: string): Float64Array {
+  if (!(value instanceof Float64Array)) {
+    throw new Error(`${context} must be a Float64Array.`);
+  }
+  return value;
+}
+
+function expectBigInt64Array(value: unknown, context: string): BigInt64Array {
+  if (!(value instanceof BigInt64Array)) {
+    throw new Error(`${context} must be a BigInt64Array.`);
+  }
+  return value;
+}
+
+function expectBigUint64Array(value: unknown, context: string): BigUint64Array {
+  if (!(value instanceof BigUint64Array)) {
+    throw new Error(`${context} must be a BigUint64Array.`);
+  }
+  return value;
+}
+
+function expectUint32Array(value: unknown, context: string): Uint32Array {
+  if (!(value instanceof Uint32Array)) {
+    throw new Error(`${context} must be a Uint32Array.`);
+  }
+  return value;
+}
+
 function expectI32(value: unknown, context: string): number {
   const numberValue = expectNumber(value, context);
   if (!Number.isInteger(numberValue) || numberValue < -2147483648 || numberValue > 2147483647) {
@@ -134,6 +216,109 @@ function expectI32(value: unknown, context: string): number {
   return numberValue;
 }
 
+function expectU32(value: unknown, context: string): number {
+  const numberValue = expectNumber(value, context);
+  if (!Number.isInteger(numberValue) || numberValue < 0 || numberValue > 4294967295) {
+    throw new Error(`${context} must be an unsigned 32-bit integer.`);
+  }
+  return numberValue;
+}
+
+function expectI64(value: unknown, context: string): bigint {
+  if (typeof value !== "bigint") {
+    throw new Error(`${context} must be a bigint.`);
+  }
+  if (value < -9223372036854775808n || value > 9223372036854775807n) {
+    throw new Error(`${context} must be a signed 64-bit integer.`);
+  }
+  return value;
+}
+
+function expectU64(value: unknown, context: string): bigint {
+  if (typeof value !== "bigint") {
+    throw new Error(`${context} must be a bigint.`);
+  }
+  if (value < 0n || value > 18446744073709551615n) {
+    throw new Error(`${context} must be an unsigned 64-bit integer.`);
+  }
+  return value;
+}
+
+function expectLength(value: unknown, context: string): number {
+  const length = expectNumber(value, context);
+  if (!Number.isInteger(length) || length < 0) {
+    throw new Error(`${context} must be a non-negative integer.`);
+  }
+  return length;
+}
+
+function bytesToI32Array(bytes: Uint8Array, context: string): Int32Array {
+  if ((bytes.byteLength & 3) !== 0) {
+    throw new Error(`${context} payload length must be divisible by 4.`);
+  }
+  const values = new Int32Array(bytes.byteLength >>> 2);
+  new Uint8Array(values.buffer).set(bytes);
+  return values;
+}
+
+function bytesToU32Array(bytes: Uint8Array, context: string): Uint32Array {
+  if ((bytes.byteLength & 3) !== 0) {
+    throw new Error(`${context} payload length must be divisible by 4.`);
+  }
+  const values = new Uint32Array(bytes.byteLength >>> 2);
+  new Uint8Array(values.buffer).set(bytes);
+  return values;
+}
+
+function bytesToF64Array(bytes: Uint8Array, context: string): Float64Array {
+  if ((bytes.byteLength & 7) !== 0) {
+    throw new Error(`${context} payload length must be divisible by 8.`);
+  }
+  const values = new Float64Array(bytes.byteLength >>> 3);
+  new Uint8Array(values.buffer).set(bytes);
+  return values;
+}
+
+function bytesToI64Array(bytes: Uint8Array, context: string): BigInt64Array {
+  if ((bytes.byteLength & 7) !== 0) {
+    throw new Error(`${context} payload length must be divisible by 8.`);
+  }
+  const values = new BigInt64Array(bytes.byteLength >>> 3);
+  new Uint8Array(values.buffer).set(bytes);
+  return values;
+}
+
+function bytesToU64Array(bytes: Uint8Array, context: string): BigUint64Array {
+  if ((bytes.byteLength & 7) !== 0) {
+    throw new Error(`${context} payload length must be divisible by 8.`);
+  }
+  const values = new BigUint64Array(bytes.byteLength >>> 3);
+  new Uint8Array(values.buffer).set(bytes);
+  return values;
+}
+
+function typedArrayBytes(
+  value: Uint8Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array | Float64Array,
+): Uint8Array {
+  return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+}
+
+function consumedRawArgCount(method: NormalizedHostServiceMethod): number {
+  let count = 0;
+  method.args.forEach((type) => {
+    count += type === "string" ||
+      type === "bytes" ||
+      type === "i32_array" ||
+      type === "u32_array" ||
+      type === "i64_array" ||
+      type === "u64_array" ||
+      type === "f64_array"
+      ? 2
+      : 1;
+  });
+  return count;
+}
+
 function decodeHostServiceArgs(
   method: NormalizedHostServiceMethod,
   rawArgs: readonly unknown[],
@@ -150,11 +335,64 @@ function decodeHostServiceArgs(
       index += 2;
       return;
     }
+    if (type === "bytes") {
+      const ptr = expectNumber(rawArgs[index], `${context} ptr`);
+      const len = expectLength(rawArgs[index + 1], `${context} len`);
+      decodedArgs.push(len <= 0 ? new Uint8Array(0) : io.readBytes(ptr, len));
+      index += 2;
+      return;
+    }
+    if (type === "i32_array") {
+      const ptr = expectNumber(rawArgs[index], `${context} ptr`);
+      const len = expectLength(rawArgs[index + 1], `${context} len`);
+      const payload = len <= 0 ? new Uint8Array(0) : io.readBytes(ptr, len << 2);
+      decodedArgs.push(bytesToI32Array(payload, context));
+      index += 2;
+      return;
+    }
+    if (type === "u32_array") {
+      const ptr = expectNumber(rawArgs[index], `${context} ptr`);
+      const len = expectLength(rawArgs[index + 1], `${context} len`);
+      const payload = len <= 0 ? new Uint8Array(0) : io.readBytes(ptr, len << 2);
+      decodedArgs.push(bytesToU32Array(payload, context));
+      index += 2;
+      return;
+    }
+    if (type === "f64_array") {
+      const ptr = expectNumber(rawArgs[index], `${context} ptr`);
+      const len = expectLength(rawArgs[index + 1], `${context} len`);
+      const payload = len <= 0 ? new Uint8Array(0) : io.readBytes(ptr, len << 3);
+      decodedArgs.push(bytesToF64Array(payload, context));
+      index += 2;
+      return;
+    }
+    if (type === "i64_array") {
+      const ptr = expectNumber(rawArgs[index], `${context} ptr`);
+      const len = expectLength(rawArgs[index + 1], `${context} len`);
+      const payload = len <= 0 ? new Uint8Array(0) : io.readBytes(ptr, len << 3);
+      decodedArgs.push(bytesToI64Array(payload, context));
+      index += 2;
+      return;
+    }
+    if (type === "u64_array") {
+      const ptr = expectNumber(rawArgs[index], `${context} ptr`);
+      const len = expectLength(rawArgs[index + 1], `${context} len`);
+      const payload = len <= 0 ? new Uint8Array(0) : io.readBytes(ptr, len << 3);
+      decodedArgs.push(bytesToU64Array(payload, context));
+      index += 2;
+      return;
+    }
     const rawValue = rawArgs[index];
     if (type === "bool") {
       decodedArgs.push(expectNumber(rawValue, context) !== 0);
     } else if (type === "i32") {
       decodedArgs.push(expectI32(rawValue, context));
+    } else if (type === "u32") {
+      decodedArgs.push(expectU32(rawValue, context));
+    } else if (type === "i64") {
+      decodedArgs.push(expectI64(rawValue, context));
+    } else if (type === "u64") {
+      decodedArgs.push(expectU64(rawValue, context));
     } else if (type === "f64") {
       decodedArgs.push(expectNumber(rawValue, context));
     } else {
@@ -168,10 +406,10 @@ function decodeHostServiceArgs(
 export function createHostServiceImportModule(
   services: HostServicesDefinition | undefined,
   io: HostServiceImportIo,
-): Record<string, (...rawArgs: Array<unknown>) => number | void> {
-  const module: Record<string, (...rawArgs: Array<unknown>) => number | void> = {};
+): Record<string, (...rawArgs: Array<unknown>) => number | bigint | void> {
+  const module: Record<string, (...rawArgs: Array<unknown>) => number | bigint | void> = {};
   for (const method of listHostServiceMethods(services)) {
-    module[method.importName] = (...rawArgs: Array<unknown>): number | void => {
+    module[method.importName] = (...rawArgs: Array<unknown>): number | bigint | void => {
       const decodedArgs = decodeHostServiceArgs(method, rawArgs, io);
       const result = method.implementation(...decodedArgs);
       const resultContext = `Host service ${method.serviceName}.${method.methodName} result`;
@@ -179,20 +417,62 @@ export function createHostServiceImportModule(
         return;
       }
       if (method.returns === "string") {
-        let outputIndex = 0;
-        method.args.forEach((type) => {
-          outputIndex += type === "string" ? 2 : 1;
-        });
+        const outputIndex = consumedRawArgCount(method);
         const ptr = expectNumber(rawArgs[outputIndex], `${resultContext} ptr`);
         const capacity = expectNumber(rawArgs[outputIndex + 1], `${resultContext} capacity`);
         return io.writeString(ptr, capacity, expectString(result, resultContext), resultContext);
       }
+      if (method.returns === "bytes") {
+        const outputIndex = consumedRawArgCount(method);
+        const ptr = expectNumber(rawArgs[outputIndex], `${resultContext} ptr`);
+        const capacity = expectNumber(rawArgs[outputIndex + 1], `${resultContext} capacity`);
+        return io.writeBytes(ptr, capacity, expectBytes(result, resultContext), resultContext);
+      }
+      if (method.returns === "i32_array") {
+        const outputIndex = consumedRawArgCount(method);
+        const ptr = expectNumber(rawArgs[outputIndex], `${resultContext} ptr`);
+        const capacity = expectNumber(rawArgs[outputIndex + 1], `${resultContext} capacity`);
+        return io.writeBytes(ptr, capacity, typedArrayBytes(expectInt32Array(result, resultContext)), resultContext);
+      }
+      if (method.returns === "u32_array") {
+        const outputIndex = consumedRawArgCount(method);
+        const ptr = expectNumber(rawArgs[outputIndex], `${resultContext} ptr`);
+        const capacity = expectNumber(rawArgs[outputIndex + 1], `${resultContext} capacity`);
+        return io.writeBytes(ptr, capacity, typedArrayBytes(expectUint32Array(result, resultContext)), resultContext);
+      }
+      if (method.returns === "f64_array") {
+        const outputIndex = consumedRawArgCount(method);
+        const ptr = expectNumber(rawArgs[outputIndex], `${resultContext} ptr`);
+        const capacity = expectNumber(rawArgs[outputIndex + 1], `${resultContext} capacity`);
+        return io.writeBytes(ptr, capacity, typedArrayBytes(expectFloat64Array(result, resultContext)), resultContext);
+      }
+      if (method.returns === "i64_array") {
+        const outputIndex = consumedRawArgCount(method);
+        const ptr = expectNumber(rawArgs[outputIndex], `${resultContext} ptr`);
+        const capacity = expectNumber(rawArgs[outputIndex + 1], `${resultContext} capacity`);
+        return io.writeBytes(ptr, capacity, typedArrayBytes(expectBigInt64Array(result, resultContext)), resultContext);
+      }
+      if (method.returns === "u64_array") {
+        const outputIndex = consumedRawArgCount(method);
+        const ptr = expectNumber(rawArgs[outputIndex], `${resultContext} ptr`);
+        const capacity = expectNumber(rawArgs[outputIndex + 1], `${resultContext} capacity`);
+        return io.writeBytes(ptr, capacity, typedArrayBytes(expectBigUint64Array(result, resultContext)), resultContext);
+      }
       if (method.returns === "bool") {
         return expectBoolean(result, resultContext) ? 1 : 0;
       }
       if (method.returns === "i32") {
         return expectI32(result, resultContext);
       }
+      if (method.returns === "u32") {
+        return expectU32(result, resultContext);
+      }
+      if (method.returns === "i64") {
+        return expectI64(result, resultContext);
+      }
+      if (method.returns === "u64") {
+        return expectU64(result, resultContext);
+      }
       if (method.returns === "f64") {
         return expectNumber(result, resultContext);
       }

package/browser/src/worker-bootstrap.ts

@@ -106,6 +106,31 @@ function writeUtf8(memory: WebAssembly.Memory | null, ptr: number, capacity: num
   return encoded.length;
 }
 
+function readBytes(memory: WebAssembly.Memory | null, ptr: number, len: number): Uint8Array {
+  if (memory === null || len <= 0) {
+    return new Uint8Array(0);
+  }
+  const bytes = new Uint8Array(len);
+  bytes.set(new Uint8Array(memory.buffer, ptr, len));
+  return bytes;
+}
+
+function writeBytes(memory: WebAssembly.Memory | null, ptr: number, capacity: number, bytes: Uint8Array, context: string): number {
+  if (memory === null) {
+    throw new Error(`${context} requires worker memory.`);
+  }
+  if (capacity < 0) {
+    throw new Error(`${context} has invalid worker host-service buffer capacity.`);
+  }
+  if (bytes.length > capacity) {
+    throw new Error(`${context} exceeds the worker host-service result buffer.`);
+  }
+  if (bytes.length > 0) {
+    new Uint8Array(memory.buffer, ptr, bytes.length).set(bytes);
+  }
+  return bytes.length;
+}
+
 function encodeTextPartsPayload(values: readonly string[]): Uint8Array {
   const encodedValues = values.map((value) => encoder.encode(value));
   let totalBytes = 4;
@@ -277,6 +302,8 @@ async function startWorker(message: WorkerBootstrapStartMessage): Promise<void>
       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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effindomv2/fui-as",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": false,
   "license": "AGPL-3.0-only OR LicenseRef-EffinDom-Commercial",
   "description": "EffinDom v2 AssemblyScript frontend framework SDK and browser harness",