@effindomv2/fui-as 0.1.1 → 0.1.2

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,41 @@ 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" | "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 (!(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 +555,22 @@ export function startManagedHarness(options: ManagedHarnessOptions): void {
           }
           continue;
         }
+        if (type === "bytes" || type === "i32_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.`);
@@ -703,6 +767,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,9 @@ 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 "f64_array" ? Float64Array :
   T extends "void" ? void :
   number;
 
@@ -59,7 +62,15 @@ 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 === "f64" ||
+    type === "bytes" ||
+    type === "i32_array" ||
+    type === "f64_array"
+  ) {
     return;
   }
   throw new Error(`${context} uses unsupported host-event type "${type}".`);

package/browser/src/host-services.ts

@@ -1,8 +1,19 @@
-export type HostServiceTypeName = "string" | "bool" | "i32" | "f64" | "void";
+export type HostServiceTypeName =
+  | "string"
+  | "bool"
+  | "i32"
+  | "f64"
+  | "bytes"
+  | "i32_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 "f64_array" ? Float64Array :
   T extends "void" ? void :
   number;
 
@@ -33,6 +44,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 +76,16 @@ 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 === "f64" ||
+    type === "bytes" ||
+    type === "i32_array" ||
+    type === "f64_array" ||
+    type === "void"
+  ) {
     return;
   }
   throw new Error(`${context} uses unsupported host-service type "${type}".`);
@@ -126,6 +148,27 @@ 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 expectI32(value: unknown, context: string): number {
   const numberValue = expectNumber(value, context);
   if (!Number.isInteger(numberValue) || numberValue < -2147483648 || numberValue > 2147483647) {
@@ -134,6 +177,44 @@ function expectI32(value: unknown, context: string): number {
   return numberValue;
 }
 
+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 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 typedArrayBytes(value: Uint8Array | Int32Array | 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 === "f64_array" ? 2 : 1;
+  });
+  return count;
+}
+
 function decodeHostServiceArgs(
   method: NormalizedHostServiceMethod,
   rawArgs: readonly unknown[],
@@ -150,6 +231,29 @@ 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 === "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;
+    }
     const rawValue = rawArgs[index];
     if (type === "bool") {
       decodedArgs.push(expectNumber(rawValue, context) !== 0);
@@ -179,14 +283,29 @@ 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 === "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 === "bool") {
         return expectBoolean(result, resultContext) ? 1 : 0;
       }

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.2",
   "private": false,
   "license": "AGPL-3.0-only OR LicenseRef-EffinDom-Commercial",
   "description": "EffinDom v2 AssemblyScript frontend framework SDK and browser harness",

package/scripts/build-demo-as.sh

@@ -5,12 +5,13 @@ set -euo pipefail
 PACKAGE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 REPO_ROOT="$(cd "${PACKAGE_DIR}/../.." && pwd)"
 DEMO_OUT_DIR="${REPO_ROOT}/public/v2/fui-as/demo"
+MVC_OUT_DIR="${REPO_ROOT}/public/v2/fui-as/demo-mvc"
 HELLO_OUT_DIR="${REPO_ROOT}/public/v2/fui-as/demo-hello-world"
 HOST_SERVICE_GENERATOR_BUILD="${PACKAGE_DIR}/build/generate-host-services.mjs"
 HOST_EVENT_GENERATOR_BUILD="${PACKAGE_DIR}/build/generate-host-events.mjs"
 BUILD_TARGET="${1:-all}"
 
-mkdir -p "${PACKAGE_DIR}/build" "${DEMO_OUT_DIR}" "${HELLO_OUT_DIR}"
+mkdir -p "${PACKAGE_DIR}/build" "${DEMO_OUT_DIR}" "${MVC_OUT_DIR}" "${HELLO_OUT_DIR}" "${PACKAGE_DIR}/templates/demo-mvc/src/generated" "${PACKAGE_DIR}/templates/demo-hello-world/src/generated"
 cd "${PACKAGE_DIR}"
 
 build_demo_app() {
@@ -28,6 +29,7 @@ generate_host_services() {
   local definition_file="$1"
   local export_name="$2"
   local output_file="$3"
+  local primitives_import="${4:-}"
 
   npx esbuild "${PACKAGE_DIR}/scripts/generate-host-services.ts" \
     --bundle \
@@ -37,13 +39,18 @@ generate_host_services() {
     --packages=external \
     --outfile="${HOST_SERVICE_GENERATOR_BUILD}"
 
-  node "${HOST_SERVICE_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}"
+  if [ -n "${primitives_import}" ]; then
+    node "${HOST_SERVICE_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}" "${primitives_import}"
+  else
+    node "${HOST_SERVICE_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}"
+  fi
 }
 
 generate_host_events() {
   local definition_file="$1"
   local export_name="$2"
   local output_file="$3"
+  local primitives_import="${4:-}"
 
   npx esbuild "${PACKAGE_DIR}/scripts/generate-host-events.ts" \
     --bundle \
@@ -53,12 +60,20 @@ generate_host_events() {
     --packages=external \
     --outfile="${HOST_EVENT_GENERATOR_BUILD}"
 
-  node "${HOST_EVENT_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}"
+  if [ -n "${primitives_import}" ]; then
+    node "${HOST_EVENT_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}" "${primitives_import}"
+  else
+    node "${HOST_EVENT_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}"
+  fi
 }
 
 generate_host_services "demo/src/host-services.ts" "demoHostServices" "demo/src/generated/HostServices.ts"
 generate_host_events "demo/src/host-events.ts" "demoHostEvents" "demo/src/generated/HostEvents.ts"
 generate_host_services "demo/src/worker-host-services.ts" "demoWorkerHostServices" "demo/src/generated/WorkerHostServices.ts"
+generate_host_services "templates/demo-hello-world/src/host/host-services.ts" "appHostServices" "templates/demo-hello-world/src/generated/HostServices.ts" "../FuiPrimitives"
+generate_host_events "templates/demo-hello-world/src/host/host-events.ts" "appHostEvents" "templates/demo-hello-world/src/generated/HostEvents.ts" "../FuiPrimitives"
+generate_host_services "templates/demo-mvc/src/host/host-services.ts" "appHostServices" "templates/demo-mvc/src/generated/HostServices.ts" "../FuiPrimitives"
+generate_host_events "templates/demo-mvc/src/host/host-events.ts" "appHostEvents" "templates/demo-mvc/src/generated/HostEvents.ts" "../FuiPrimitives"
 
 case "${BUILD_TARGET}" in
   all)
@@ -66,7 +81,9 @@ case "${BUILD_TARGET}" in
     build_demo_app "demo/src/routes/demo_home.ts" "${DEMO_OUT_DIR}/home.wasm"
     build_demo_app "demo/src/routes/demo_advanced_controls.ts" "${DEMO_OUT_DIR}/advanced-controls.wasm"
     build_demo_app "demo/src/routes/templated-controls.ts" "${DEMO_OUT_DIR}/templated-controls.wasm"
-    build_demo_app "demo-hello-world/src/App.ts" "${HELLO_OUT_DIR}/app.wasm"
+    build_demo_app "templates/demo-mvc/src/routes/mvc_home.ts" "${MVC_OUT_DIR}/mvc-home.wasm"
+    build_demo_app "templates/demo-mvc/src/routes/mvc_settings.ts" "${MVC_OUT_DIR}/mvc-settings.wasm"
+    build_demo_app "templates/demo-hello-world/src/App.ts" "${HELLO_OUT_DIR}/app.wasm"
     ;;
   dashboard)
     build_demo_app "demo/src/dashboard.ts" "${DEMO_OUT_DIR}/demo.wasm"
@@ -80,12 +97,18 @@ case "${BUILD_TARGET}" in
   templated-controls|templated)
     build_demo_app "demo/src/routes/templated-controls.ts" "${DEMO_OUT_DIR}/templated-controls.wasm"
     ;;
+  mvc-home|mvc-home-page)
+    build_demo_app "templates/demo-mvc/src/routes/mvc_home.ts" "${MVC_OUT_DIR}/mvc-home.wasm"
+    ;;
+  mvc-settings|mvc-settings-page)
+    build_demo_app "templates/demo-mvc/src/routes/mvc_settings.ts" "${MVC_OUT_DIR}/mvc-settings.wasm"
+    ;;
   hello-world|hello)
-    build_demo_app "demo-hello-world/src/App.ts" "${HELLO_OUT_DIR}/app.wasm"
+    build_demo_app "templates/demo-hello-world/src/App.ts" "${HELLO_OUT_DIR}/app.wasm"
     ;;
   *)
     echo "Unknown build target: ${BUILD_TARGET}" >&2
-    echo "Usage: bash scripts/build-demo-as.sh [all|dashboard|home|advanced-controls|templated-controls|hello-world]" >&2
+    echo "Usage: bash scripts/build-demo-as.sh [all|dashboard|home|advanced-controls|templated-controls|mvc-home|mvc-settings|hello-world]" >&2
     exit 1
     ;;
 esac

package/scripts/build.sh

@@ -8,6 +8,7 @@ BROWSER_SRC_DIR="${PACKAGE_DIR}/browser/src"
 SMOKE_FIXTURE_DIR="${PACKAGE_DIR}/tests/fixtures/smoke"
 OUT_DIR="${REPO_ROOT}/public/v2/fui-as"
 DEMO_OUT_DIR="${OUT_DIR}/demo"
+MVC_OUT_DIR="${OUT_DIR}/demo-mvc"
 HELLO_OUT_DIR="${OUT_DIR}/demo-hello-world"
 WORKER_BUILD_DIR="${PACKAGE_DIR}/build/workers"
 WORKER_BOOTSTRAP_BUILD="${PACKAGE_DIR}/build/worker-bootstrap.js"
@@ -23,7 +24,7 @@ RUNTIME_CONFIG_FILE="effindom-runtime-config.js"
 DEFAULT_MANIFEST_PATH="./runtime/dist/effindom.v2.manifest.json"
 
 rm -rf "${OUT_DIR}"
-mkdir -p "${PACKAGE_DIR}/build" "${OUT_DIR}" "${DEMO_OUT_DIR}" "${HELLO_OUT_DIR}" "${WORKER_BUILD_DIR}"
+mkdir -p "${PACKAGE_DIR}/build" "${OUT_DIR}" "${DEMO_OUT_DIR}" "${MVC_OUT_DIR}" "${HELLO_OUT_DIR}" "${WORKER_BUILD_DIR}" "${PACKAGE_DIR}/templates/demo-mvc/src/generated" "${PACKAGE_DIR}/templates/demo-hello-world/src/generated"
 
 cd "${PACKAGE_DIR}"
 
@@ -64,6 +65,7 @@ generate_host_services() {
   local definition_file="$1"
   local export_name="$2"
   local output_file="$3"
+  local primitives_import="${4:-}"
 
   npx esbuild "${PACKAGE_DIR}/scripts/generate-host-services.ts" \
     --bundle \
@@ -73,13 +75,18 @@ generate_host_services() {
     --packages=external \
     --outfile="${HOST_SERVICE_GENERATOR_BUILD}"
 
-  node "${HOST_SERVICE_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}"
+  if [ -n "${primitives_import}" ]; then
+    node "${HOST_SERVICE_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}" "${primitives_import}"
+  else
+    node "${HOST_SERVICE_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}"
+  fi
 }
 
 generate_host_events() {
   local definition_file="$1"
   local export_name="$2"
   local output_file="$3"
+  local primitives_import="${4:-}"
 
   npx esbuild "${PACKAGE_DIR}/scripts/generate-host-events.ts" \
     --bundle \
@@ -89,7 +96,11 @@ generate_host_events() {
     --packages=external \
     --outfile="${HOST_EVENT_GENERATOR_BUILD}"
 
-  node "${HOST_EVENT_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}"
+  if [ -n "${primitives_import}" ]; then
+    node "${HOST_EVENT_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}" "${primitives_import}"
+  else
+    node "${HOST_EVENT_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}"
+  fi
 }
 
 find_worker_entries() {
@@ -162,6 +173,10 @@ copy_runtime_assets() {
     cp "${RUNTIME_DIST_DIR}/icu-asset.json" "${destination}/runtime/dist/icu-asset.json"
   fi
   cp -R "${RUNTIME_DIST_DIR}/runtime" "${destination}/runtime/dist/runtime"
+  if [ -d "${RUNTIME_DIST_DIR}/fonts" ]; then
+    mkdir -p "${destination}/runtime"
+    cp -R "${RUNTIME_DIST_DIR}/fonts" "${destination}/runtime/fonts"
+  fi
 }
 
 build_workers() {
@@ -231,13 +246,19 @@ copy_worker_assets() {
 generate_host_services "demo/src/host-services.ts" "demoHostServices" "demo/src/generated/HostServices.ts"
 generate_host_events "demo/src/host-events.ts" "demoHostEvents" "demo/src/generated/HostEvents.ts"
 generate_host_services "demo/src/worker-host-services.ts" "demoWorkerHostServices" "demo/src/generated/WorkerHostServices.ts"
+generate_host_services "templates/demo-hello-world/src/host/host-services.ts" "appHostServices" "templates/demo-hello-world/src/generated/HostServices.ts" "../FuiPrimitives"
+generate_host_events "templates/demo-hello-world/src/host/host-events.ts" "appHostEvents" "templates/demo-hello-world/src/generated/HostEvents.ts" "../FuiPrimitives"
+generate_host_services "templates/demo-mvc/src/host/host-services.ts" "appHostServices" "templates/demo-mvc/src/generated/HostServices.ts" "../FuiPrimitives"
+generate_host_events "templates/demo-mvc/src/host/host-events.ts" "appHostEvents" "templates/demo-mvc/src/generated/HostEvents.ts" "../FuiPrimitives"
 
 build_app "tests/fixtures/smoke/app.ts" "${OUT_DIR}/app.wasm"
 build_app "demo/src/dashboard.ts" "${DEMO_OUT_DIR}/demo.wasm"
 build_app "demo/src/routes/demo_home.ts" "${DEMO_OUT_DIR}/home.wasm"
 build_app "demo/src/routes/demo_advanced_controls.ts" "${DEMO_OUT_DIR}/advanced-controls.wasm"
 build_app "demo/src/routes/templated-controls.ts" "${DEMO_OUT_DIR}/templated-controls.wasm"
-build_app "demo-hello-world/src/App.ts" "${HELLO_OUT_DIR}/app.wasm"
+build_app "templates/demo-mvc/src/routes/mvc_home.ts" "${MVC_OUT_DIR}/mvc-home.wasm"
+build_app "templates/demo-mvc/src/routes/mvc_settings.ts" "${MVC_OUT_DIR}/mvc-settings.wasm"
+build_app "templates/demo-hello-world/src/App.ts" "${HELLO_OUT_DIR}/app.wasm"
 build_workers
 write_worker_manifest
 
@@ -259,7 +280,16 @@ npx esbuild "${PACKAGE_DIR}/demo/harness.ts" \
   --outfile="${DEMO_OUT_DIR}/harness.js" \
   --sourcemap
 
-npx esbuild "${PACKAGE_DIR}/demo-hello-world/harness.ts" \
+npx esbuild "${PACKAGE_DIR}/templates/demo-mvc/harness.ts" \
+  --bundle \
+  --format=esm \
+  --platform=browser \
+  --target=es2020 \
+  --minify \
+  --outfile="${MVC_OUT_DIR}/harness.js" \
+  --sourcemap
+
+npx esbuild "${PACKAGE_DIR}/templates/demo-hello-world/harness.ts" \
   --bundle \
   --format=esm \
   --platform=browser \
@@ -281,6 +311,8 @@ cp "${FILE_PROCESSING_WORKER_BUILD}" "${OUT_DIR}/file-processing-worker.js"
 cp "${FILE_PROCESSING_WORKER_MAP_BUILD}" "${OUT_DIR}/file-processing-worker.js.map"
 cp "${FILE_PROCESSING_WORKER_BUILD}" "${DEMO_OUT_DIR}/file-processing-worker.js"
 cp "${FILE_PROCESSING_WORKER_MAP_BUILD}" "${DEMO_OUT_DIR}/file-processing-worker.js.map"
+cp "${FILE_PROCESSING_WORKER_BUILD}" "${MVC_OUT_DIR}/file-processing-worker.js"
+cp "${FILE_PROCESSING_WORKER_MAP_BUILD}" "${MVC_OUT_DIR}/file-processing-worker.js.map"
 cp "${FILE_PROCESSING_WORKER_BUILD}" "${HELLO_OUT_DIR}/file-processing-worker.js"
 cp "${FILE_PROCESSING_WORKER_MAP_BUILD}" "${HELLO_OUT_DIR}/file-processing-worker.js.map"
 
@@ -304,22 +336,43 @@ npx esbuild "${PACKAGE_DIR}/demo/worker-host-services.ts" \
 
 cp "${SMOKE_FIXTURE_DIR}/index.html" "${OUT_DIR}/index.html"
 cp "${PACKAGE_DIR}/demo/index.html" "${DEMO_OUT_DIR}/index.html"
-cp "${PACKAGE_DIR}/demo-hello-world/index.html" "${HELLO_OUT_DIR}/index.html"
+cp "${PACKAGE_DIR}/templates/demo-hello-world/index.html" "${HELLO_OUT_DIR}/index.html"
 cp "${PACKAGE_DIR}/demo/demo-texture.png" "${DEMO_OUT_DIR}/demo-texture.png"
 cp "${PACKAGE_DIR}/demo/demo-secondary-texture.png" "${DEMO_OUT_DIR}/demo-secondary-texture.png"
 
 mkdir -p "${DEMO_OUT_DIR}/advanced-controls" "${DEMO_OUT_DIR}/templated-controls"
 cp "${PACKAGE_DIR}/demo/route-shell.html" "${DEMO_OUT_DIR}/advanced-controls/index.html"
 cp "${PACKAGE_DIR}/demo/route-shell.html" "${DEMO_OUT_DIR}/templated-controls/index.html"
+mkdir -p "${MVC_OUT_DIR}/mvc-home" "${MVC_OUT_DIR}/mvc-settings"
+cp "${PACKAGE_DIR}/templates/demo-mvc/route-shell.html" "${MVC_OUT_DIR}/mvc-home/index.html"
+cp "${PACKAGE_DIR}/templates/demo-mvc/route-shell.html" "${MVC_OUT_DIR}/mvc-settings/index.html"
+cat > "${MVC_OUT_DIR}/index.html" <<'EOF'
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta http-equiv="refresh" content="0; url=./mvc-home/" />
+  <title>FUI-AS MVC Demo</title>
+</head>
+<body>
+  <p>Redirecting to <a href="./mvc-home/">MVC Home</a>…</p>
+</body>
+</html>
+EOF
 
 copy_runtime_assets "${OUT_DIR}"
 copy_runtime_assets "${DEMO_OUT_DIR}"
+copy_runtime_assets "${MVC_OUT_DIR}"
 copy_runtime_assets "${HELLO_OUT_DIR}"
 copy_worker_assets "${OUT_DIR}"
 copy_worker_assets "${DEMO_OUT_DIR}"
+copy_worker_assets "${MVC_OUT_DIR}"
 copy_worker_assets "${HELLO_OUT_DIR}"
 write_runtime_config "${OUT_DIR}" "${DEFAULT_MANIFEST_PATH}"
 write_runtime_config "${DEMO_OUT_DIR}" "${DEFAULT_MANIFEST_PATH}"
+write_runtime_config "${MVC_OUT_DIR}" "${DEFAULT_MANIFEST_PATH}"
 write_runtime_config "${HELLO_OUT_DIR}" "${DEFAULT_MANIFEST_PATH}"
 write_runtime_config "${DEMO_OUT_DIR}/advanced-controls" "../runtime/dist/effindom.v2.manifest.json"
 write_runtime_config "${DEMO_OUT_DIR}/templated-controls" "../runtime/dist/effindom.v2.manifest.json"
+write_runtime_config "${MVC_OUT_DIR}/mvc-home" "../runtime/dist/effindom.v2.manifest.json"
+write_runtime_config "${MVC_OUT_DIR}/mvc-settings" "../runtime/dist/effindom.v2.manifest.json"

package/scripts/generate-host-events.ts

@@ -32,6 +32,12 @@ function asTypeName(type: HostServiceTypeName): string {
       return "i32";
     case "f64":
       return "f64";
+    case "bytes":
+      return "Uint8Array";
+    case "i32_array":
+      return "Int32Array";
+    case "f64_array":
+      return "Float64Array";
     case "void":
       return "void";
   }
@@ -53,7 +59,7 @@ function callbackTypeFor(method: NormalizedHostEventMethod): string {
 function emitExportArgs(method: NormalizedHostEventMethod): string {
   const parts: Array<string> = [];
   method.args.forEach((type, index) => {
-    if (type === "string") {
+    if (type === "string" || type === "bytes" || type === "i32_array" || type === "f64_array") {
       parts.push(`arg${String(index)}Ptr: usize`, `arg${String(index)}Len: u32`);
       return;
     }
@@ -66,6 +72,26 @@ function emitDecodedArgs(method: NormalizedHostEventMethod): Array<string> {
   const lines: Array<string> = [];
   method.args.forEach((type, index) => {
     if (type !== "string") {
+      if (type === "bytes") {
+        lines.push(`  const arg${String(index)} = new Uint8Array(<i32>arg${String(index)}Len);`);
+        lines.push(`  if (arg${String(index)}Len > 0) {`);
+        lines.push(`    memory.copy(arg${String(index)}.dataStart, arg${String(index)}Ptr, <usize>arg${String(index)}Len);`);
+        lines.push("  }");
+        return;
+      }
+      if (type === "i32_array") {
+        lines.push(`  const arg${String(index)} = new Int32Array(<i32>arg${String(index)}Len);`);
+        lines.push(`  if (arg${String(index)}Len > 0) {`);
+        lines.push(`    memory.copy(arg${String(index)}.dataStart, arg${String(index)}Ptr, <usize>arg${String(index)}Len << 2);`);
+        lines.push("  }");
+        return;
+      }
+      if (type === "f64_array") {
+        lines.push(`  const arg${String(index)} = new Float64Array(<i32>arg${String(index)}Len);`);
+        lines.push(`  if (arg${String(index)}Len > 0) {`);
+        lines.push(`    memory.copy(arg${String(index)}.dataStart, arg${String(index)}Ptr, <usize>arg${String(index)}Len << 3);`);
+        lines.push("  }");
+      }
       return;
     }
     lines.push(
@@ -141,8 +167,9 @@ function emitBindingsFile(
   exportName: string,
   outputPath: string,
   methods: ReturnType<typeof listHostEventMethods>,
+  primitivesImportOverride: string | undefined,
 ): string {
-  const callbackImport = relativeImport(outputPath, path.resolve(PACKAGE_DIR, "src/FuiPrimitives.ts"));
+  const callbackImport = primitivesImportOverride ?? relativeImport(outputPath, path.resolve(PACKAGE_DIR, "src/FuiPrimitives.ts"));
   const blocks: Array<string> = [
     `// Generated by scripts/generate-host-events.ts from ${toPosix(sourceModulePath)}#${exportName}.`,
     `import { Callback0, Callback1, Callback2 } from "${callbackImport}";`,
@@ -159,15 +186,15 @@ function emitBindingsFile(
 }
 
 async function main(): Promise<void> {
-  const [moduleArg, exportName, outputArg] = process.argv.slice(2);
+  const [moduleArg, exportName, outputArg, primitivesImportArg] = process.argv.slice(2);
   if (moduleArg === undefined || exportName === undefined || outputArg === undefined) {
-    throw new Error("Usage: generate-host-events <module-path> <export-name> <output-path>");
+    throw new Error("Usage: generate-host-events <module-path> <export-name> <output-path> [primitives-import]");
   }
   const modulePath = path.resolve(process.cwd(), moduleArg);
   const outputPath = path.resolve(process.cwd(), outputArg);
   const registry = await loadHostEvents(modulePath, exportName);
   const methods = listHostEventMethods(registry as never);
-  const content = emitBindingsFile(modulePath, exportName, outputPath, methods);
+  const content = emitBindingsFile(modulePath, exportName, outputPath, methods, primitivesImportArg);
   await fs.mkdir(path.dirname(outputPath), { recursive: true });
   await fs.writeFile(outputPath, content, "utf8");
 }

package/scripts/generate-host-services.ts

@@ -31,24 +31,38 @@ function asTypeName(type: HostServiceTypeName): string {
       return "i32";
     case "f64":
       return "f64";
+    case "bytes":
+      return "Uint8Array";
+    case "i32_array":
+      return "Int32Array";
+    case "f64_array":
+      return "Float64Array";
     case "void":
       return "void";
   }
 }
 
+function isPointerLengthType(type: HostServiceTypeName): boolean {
+  return type === "string" || type === "bytes" || type === "i32_array" || type === "f64_array";
+}
+
+function returnsBufferType(type: HostServiceTypeName): boolean {
+  return type === "string" || type === "bytes" || type === "i32_array" || type === "f64_array";
+}
+
 function emitExternalSignature(importName: string, args: readonly HostServiceTypeName[], returns: HostServiceTypeName): string {
   const signatureParts: Array<string> = [];
   args.forEach((type, index) => {
-    if (type === "string") {
+    if (isPointerLengthType(type)) {
       signatureParts.push(`arg${String(index)}Ptr: usize`, `arg${String(index)}Len: u32`);
       return;
     }
     signatureParts.push(`arg${String(index)}: ${asTypeName(type)}`);
   });
-  if (returns === "string") {
+  if (returnsBufferType(returns)) {
     signatureParts.push("resultPtr: usize", "resultCap: u32");
   }
-  const returnType = returns === "string" ? "u32" : asTypeName(returns);
+  const returnType = returnsBufferType(returns) ? "u32" : asTypeName(returns);
   return [
     `@external("fui_host_service", "${importName}")`,
     `declare function __host_${importName}(${signatureParts.join(", ")}): ${returnType};`,
@@ -61,6 +75,10 @@ function emitWrapper(importName: string, args: readonly HostServiceTypeName[], r
   args.forEach((type, index) => {
     if (type === "string") {
       lines.push(`  const arg${String(index)}Bytes = Uint8Array.wrap(String.UTF8.encode(arg${String(index)}, false));`);
+      return;
+    }
+    if (type === "bytes" || type === "i32_array" || type === "f64_array") {
+      lines.push(`  const arg${String(index)}Bytes = arg${String(index)};`);
     }
   });
   const callArgs: Array<string> = [];
@@ -70,14 +88,32 @@ function emitWrapper(importName: string, args: readonly HostServiceTypeName[], r
       callArgs.push(`<u32>arg${String(index)}Bytes.length`);
       return;
     }
+    if (type === "bytes") {
+      callArgs.push(`arg${String(index)}Bytes.length > 0 ? arg${String(index)}Bytes.dataStart : 0`);
+      callArgs.push(`<u32>arg${String(index)}Bytes.length`);
+      return;
+    }
+    if (type === "i32_array" || type === "f64_array") {
+      callArgs.push(`arg${String(index)}Bytes.length > 0 ? arg${String(index)}Bytes.dataStart : 0`);
+      callArgs.push(`<u32>arg${String(index)}Bytes.length`);
+      return;
+    }
     callArgs.push(`arg${String(index)}`);
   });
-  if (returns === "string") {
+  if (returnsBufferType(returns)) {
     lines.push("  const resultPtr = hostServiceResultBufferPtr();");
     lines.push("  const resultCap = hostServiceResultBufferSize();");
     callArgs.push("resultPtr", "resultCap");
     lines.push(`  const resultLen = __host_${importName}(${callArgs.join(", ")});`);
-    lines.push(`  return decodeHostServiceStringResult(resultPtr, resultLen, "${importName}");`);
+    if (returns === "string") {
+      lines.push(`  return decodeHostServiceStringResult(resultPtr, resultLen, "${importName}");`);
+    } else if (returns === "bytes") {
+      lines.push(`  return decodeHostServiceBytesResult(resultPtr, resultLen, "${importName}");`);
+    } else if (returns === "i32_array") {
+      lines.push(`  return decodeHostServiceI32ArrayResult(resultPtr, resultLen, "${importName}");`);
+    } else {
+      lines.push(`  return decodeHostServiceF64ArrayResult(resultPtr, resultLen, "${importName}");`);
+    }
   } else if (returns === "void") {
     lines.push(`  __host_${importName}(${callArgs.join(", ")});`);
   } else {
@@ -118,13 +154,35 @@ function emitBindingsFile(
   exportName: string,
   outputPath: string,
   methods: ReturnType<typeof listHostServiceMethods>,
+  primitivesImportOverride: string | undefined,
 ): string {
-  const runtimeImport = relativeImport(outputPath, path.resolve(PACKAGE_DIR, "src/FuiPrimitives.ts"));
+  const runtimeImport = primitivesImportOverride ?? relativeImport(outputPath, path.resolve(PACKAGE_DIR, "src/FuiPrimitives.ts"));
   const blocks: Array<string> = [
     `// Generated by scripts/generate-host-services.ts from ${toPosix(sourceModulePath)}#${exportName}.`,
   ];
-  if (methods.some((method) => method.returns === "string")) {
-    blocks.push(`import { decodeHostServiceStringResult, hostServiceResultBufferPtr, hostServiceResultBufferSize } from "${runtimeImport}";`);
+  if (methods.some((method) => returnsBufferType(method.returns))) {
+    const helpers = [
+      "hostServiceResultBufferPtr",
+      "hostServiceResultBufferSize",
+      ...new Set(
+        methods
+          .map((method) => method.returns)
+          .filter((type) => returnsBufferType(type))
+          .map((type) => {
+            if (type === "string") {
+              return "decodeHostServiceStringResult";
+            }
+            if (type === "bytes") {
+              return "decodeHostServiceBytesResult";
+            }
+            if (type === "i32_array") {
+              return "decodeHostServiceI32ArrayResult";
+            }
+            return "decodeHostServiceF64ArrayResult";
+          }),
+      ),
+    ];
+    blocks.push(`import { ${helpers.join(", ")} } from "${runtimeImport}";`);
     blocks.push("");
   } else {
     blocks.push("");
@@ -141,15 +199,15 @@ function emitBindingsFile(
 }
 
 async function main(): Promise<void> {
-  const [moduleArg, exportName, outputArg] = process.argv.slice(2);
+  const [moduleArg, exportName, outputArg, primitivesImportArg] = process.argv.slice(2);
   if (moduleArg === undefined || exportName === undefined || outputArg === undefined) {
-    throw new Error("Usage: generate-host-services <module-path> <export-name> <output-path>");
+    throw new Error("Usage: generate-host-services <module-path> <export-name> <output-path> [primitives-import]");
   }
   const modulePath = path.resolve(process.cwd(), moduleArg);
   const outputPath = path.resolve(process.cwd(), outputArg);
   const registry = await loadHostServices(modulePath, exportName);
   const methods = listHostServiceMethods(registry as never);
-  const content = emitBindingsFile(modulePath, exportName, outputPath, methods);
+  const content = emitBindingsFile(modulePath, exportName, outputPath, methods, primitivesImportArg);
   await fs.mkdir(path.dirname(outputPath), { recursive: true });
   await fs.writeFile(outputPath, content, "utf8");
 }

package/src/FuiPrimitives.ts

@@ -12,4 +12,11 @@ export {
 } from "./core/BoundCallback";
 export { bind0, bind1, bind2, bindResult0, bindResult1 } from "./core/bind";
 export { clearCurrentSelection, tryGetBounds } from "./bindings/ui";
-export { decodeHostServiceStringResult, hostServiceResultBufferPtr, hostServiceResultBufferSize } from "./host-services/runtime";
+export {
+  decodeHostServiceBytesResult,
+  decodeHostServiceF64ArrayResult,
+  decodeHostServiceI32ArrayResult,
+  decodeHostServiceStringResult,
+  hostServiceResultBufferPtr,
+  hostServiceResultBufferSize,
+} from "./host-services/runtime";

package/src/host-services/runtime.ts

@@ -8,7 +8,7 @@ export function hostServiceResultBufferSize(): u32 {
   return __fui_text_buffer_size();
 }
 
-export function decodeHostServiceStringResult(resultPtr: usize, resultLen: u32, importName: string): string {
+function assertResultByteLength(resultLen: u32, importName: string): void {
   const capacity = __fui_text_buffer_size();
   if (resultLen > capacity) {
     throw new Error(
@@ -21,5 +21,42 @@ export function decodeHostServiceStringResult(resultPtr: usize, resultLen: u32,
       ".",
     );
   }
+}
+
+export function decodeHostServiceStringResult(resultPtr: usize, resultLen: u32, importName: string): string {
+  assertResultByteLength(resultLen, importName);
   return resultLen == 0 ? "" : String.UTF8.decodeUnsafe(resultPtr, <usize>resultLen, false);
 }
+
+export function decodeHostServiceBytesResult(resultPtr: usize, resultLen: u32, importName: string): Uint8Array {
+  assertResultByteLength(resultLen, importName);
+  const bytes = new Uint8Array(<i32>resultLen);
+  if (resultLen > 0) {
+    memory.copy(bytes.dataStart, resultPtr, <usize>resultLen);
+  }
+  return bytes;
+}
+
+export function decodeHostServiceI32ArrayResult(resultPtr: usize, resultLen: u32, importName: string): Int32Array {
+  assertResultByteLength(resultLen, importName);
+  if ((resultLen & 3) != 0) {
+    throw new Error("Host service " + importName + " returned misaligned Int32Array byte length.");
+  }
+  const values = new Int32Array(<i32>(resultLen >> 2));
+  if (resultLen > 0) {
+    memory.copy(values.dataStart, resultPtr, <usize>resultLen);
+  }
+  return values;
+}
+
+export function decodeHostServiceF64ArrayResult(resultPtr: usize, resultLen: u32, importName: string): Float64Array {
+  assertResultByteLength(resultLen, importName);
+  if ((resultLen & 7) != 0) {
+    throw new Error("Host service " + importName + " returned misaligned Float64Array byte length.");
+  }
+  const values = new Float64Array(<i32>(resultLen >> 3));
+  if (resultLen > 0) {
+    memory.copy(values.dataStart, resultPtr, <usize>resultLen);
+  }
+  return values;
+}