@effindomv2/fui-as 0.1.2 → 0.1.3

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

@@ -498,7 +498,7 @@ export function startManagedHarness(options: ManagedHarnessOptions): void {
       }
 
       function encodeTypedArrayArg(
-        type: "bytes" | "i32_array" | "f64_array",
+        type: "bytes" | "i32_array" | "u32_array" | "i64_array" | "u64_array" | "f64_array",
         arg: unknown,
         context: string,
       ): { bytes: Uint8Array; elementCount: number; alignment: number } {
@@ -518,6 +518,36 @@ export function startManagedHarness(options: ManagedHarnessOptions): void {
             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.`);
         }
@@ -555,7 +585,7 @@ export function startManagedHarness(options: ManagedHarnessOptions): void {
           }
           continue;
         }
-        if (type === "bytes" || type === "i32_array" || type === "f64_array") {
+        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);
@@ -578,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.`);
         }
@@ -585,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);
       }

package/browser/src/host-events.ts

@@ -5,7 +5,11 @@ type HostEventTypeValue<T extends HostServiceTypeName> =
   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;
 
@@ -66,9 +70,15 @@ function validateEventType(type: string, context: string): asserts type is HostS
     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;

package/browser/src/host-services.ts

@@ -2,9 +2,15 @@ export type HostServiceTypeName =
   | "string"
   | "bool"
   | "i32"
+  | "u32"
+  | "i64"
+  | "u64"
   | "f64"
   | "bytes"
   | "i32_array"
+  | "u32_array"
+  | "i64_array"
+  | "u64_array"
   | "f64_array"
   | "void";
 
@@ -13,7 +19,11 @@ type HostServiceTypeValue<T extends HostServiceTypeName> =
   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;
 
@@ -25,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>;
@@ -80,9 +91,15 @@ function validateServiceType(type: string, context: string): asserts type is Hos
     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"
   ) {
@@ -101,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}".`);
       }
@@ -169,6 +187,27 @@ function expectFloat64Array(value: unknown, context: string): 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) {
@@ -177,6 +216,34 @@ 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) {
@@ -194,6 +261,15 @@ function bytesToI32Array(bytes: Uint8Array, context: string): Int32Array {
   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.`);
@@ -203,14 +279,42 @@ function bytesToF64Array(bytes: Uint8Array, context: string): Float64Array {
   return values;
 }
 
-function typedArrayBytes(value: Uint8Array | Int32Array | Float64Array): Uint8Array {
+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 === "f64_array" ? 2 : 1;
+    count += type === "string" ||
+      type === "bytes" ||
+      type === "i32_array" ||
+      type === "u32_array" ||
+      type === "i64_array" ||
+      type === "u64_array" ||
+      type === "f64_array"
+      ? 2
+      : 1;
   });
   return count;
 }
@@ -246,6 +350,14 @@ function decodeHostServiceArgs(
       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`);
@@ -254,11 +366,33 @@ function decodeHostServiceArgs(
       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 {
@@ -272,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`;
@@ -300,18 +434,45 @@ export function createHostServiceImportModule(
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effindomv2/fui-as",
-  "version": "0.1.2",
+  "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",

package/scripts/build-demo-as.sh

@@ -11,7 +11,7 @@ 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}" "${MVC_OUT_DIR}" "${HELLO_OUT_DIR}" "${PACKAGE_DIR}/templates/demo-mvc/src/generated" "${PACKAGE_DIR}/templates/demo-hello-world/src/generated"
+mkdir -p "${PACKAGE_DIR}/build" "${DEMO_OUT_DIR}" "${MVC_OUT_DIR}" "${HELLO_OUT_DIR}" "${PACKAGE_DIR}/templates/demo-mvc/src/host/generated" "${PACKAGE_DIR}/templates/demo-hello-world/src/host/generated"
 cd "${PACKAGE_DIR}"
 
 build_demo_app() {
@@ -30,6 +30,7 @@ generate_host_services() {
   local export_name="$2"
   local output_file="$3"
   local primitives_import="${4:-}"
+  local host_import_module="${5:-}"
 
   npx esbuild "${PACKAGE_DIR}/scripts/generate-host-services.ts" \
     --bundle \
@@ -39,8 +40,13 @@ generate_host_services() {
     --packages=external \
     --outfile="${HOST_SERVICE_GENERATOR_BUILD}"
 
-  if [ -n "${primitives_import}" ]; then
+  if [ -n "${primitives_import}" ] && [ -n "${host_import_module}" ]; then
+    node "${HOST_SERVICE_GENERATOR_BUILD}" \
+      "${definition_file}" "${export_name}" "${output_file}" "${primitives_import}" "${host_import_module}"
+  elif [ -n "${primitives_import}" ]; then
     node "${HOST_SERVICE_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}" "${primitives_import}"
+  elif [ -n "${host_import_module}" ]; then
+    node "${HOST_SERVICE_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}" "" "${host_import_module}"
   else
     node "${HOST_SERVICE_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}"
   fi
@@ -70,10 +76,11 @@ generate_host_events() {
 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"
+generate_host_services "scripts/framework-host-services.ts" "frameworkHostServices" "src/core/generated/FrameworkHostServices.ts" "" "fui_host"
+generate_host_services "templates/demo-hello-world/src/host/host-services.ts" "appHostServices" "templates/demo-hello-world/src/host/generated/HostServices.ts" "../../fui/FuiPrimitives"
+generate_host_events "templates/demo-hello-world/src/host/host-events.ts" "appHostEvents" "templates/demo-hello-world/src/host/generated/HostEvents.ts" "../../fui/FuiPrimitives"
+generate_host_services "templates/demo-mvc/src/host/host-services.ts" "appHostServices" "templates/demo-mvc/src/host/generated/HostServices.ts" "../../fui/FuiPrimitives"
+generate_host_events "templates/demo-mvc/src/host/host-events.ts" "appHostEvents" "templates/demo-mvc/src/host/generated/HostEvents.ts" "../../fui/FuiPrimitives"
 
 case "${BUILD_TARGET}" in
   all)

package/scripts/build.sh

@@ -24,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}" "${MVC_OUT_DIR}" "${HELLO_OUT_DIR}" "${WORKER_BUILD_DIR}" "${PACKAGE_DIR}/templates/demo-mvc/src/generated" "${PACKAGE_DIR}/templates/demo-hello-world/src/generated"
+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/host/generated" "${PACKAGE_DIR}/templates/demo-hello-world/src/host/generated"
 
 cd "${PACKAGE_DIR}"
 
@@ -66,6 +66,7 @@ generate_host_services() {
   local export_name="$2"
   local output_file="$3"
   local primitives_import="${4:-}"
+  local host_import_module="${5:-}"
 
   npx esbuild "${PACKAGE_DIR}/scripts/generate-host-services.ts" \
     --bundle \
@@ -75,8 +76,13 @@ generate_host_services() {
     --packages=external \
     --outfile="${HOST_SERVICE_GENERATOR_BUILD}"
 
-  if [ -n "${primitives_import}" ]; then
+  if [ -n "${primitives_import}" ] && [ -n "${host_import_module}" ]; then
+    node "${HOST_SERVICE_GENERATOR_BUILD}" \
+      "${definition_file}" "${export_name}" "${output_file}" "${primitives_import}" "${host_import_module}"
+  elif [ -n "${primitives_import}" ]; then
     node "${HOST_SERVICE_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}" "${primitives_import}"
+  elif [ -n "${host_import_module}" ]; then
+    node "${HOST_SERVICE_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}" "" "${host_import_module}"
   else
     node "${HOST_SERVICE_GENERATOR_BUILD}" "${definition_file}" "${export_name}" "${output_file}"
   fi
@@ -246,10 +252,11 @@ 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"
+generate_host_services "scripts/framework-host-services.ts" "frameworkHostServices" "src/core/generated/FrameworkHostServices.ts" "" "fui_host"
+generate_host_services "templates/demo-hello-world/src/host/host-services.ts" "appHostServices" "templates/demo-hello-world/src/host/generated/HostServices.ts" "../../fui/FuiPrimitives"
+generate_host_events "templates/demo-hello-world/src/host/host-events.ts" "appHostEvents" "templates/demo-hello-world/src/host/generated/HostEvents.ts" "../../fui/FuiPrimitives"
+generate_host_services "templates/demo-mvc/src/host/host-services.ts" "appHostServices" "templates/demo-mvc/src/host/generated/HostServices.ts" "../../fui/FuiPrimitives"
+generate_host_events "templates/demo-mvc/src/host/host-events.ts" "appHostEvents" "templates/demo-mvc/src/host/generated/HostEvents.ts" "../../fui/FuiPrimitives"
 
 build_app "tests/fixtures/smoke/app.ts" "${OUT_DIR}/app.wasm"
 build_app "demo/src/dashboard.ts" "${DEMO_OUT_DIR}/demo.wasm"

package/scripts/framework-host-services.ts

@@ -0,0 +1,40 @@
+import { defineHostServices, hostService } from "../browser/src/host-services";
+
+function unsupported(): never {
+  throw new Error("Framework host service definitions are generator metadata only.");
+}
+
+export const frameworkHostServices = defineHostServices({
+  frameworkHost: {
+    nowMs: hostService({
+      importName: "fui_now_ms",
+      args: [] as const,
+      returns: "f64",
+      implementation: () => unsupported(),
+    }),
+    isDarkMode: hostService({
+      importName: "fui_is_dark_mode",
+      args: [] as const,
+      returns: "bool",
+      implementation: () => unsupported(),
+    }),
+    accentColor: hostService({
+      importName: "fui_get_accent_color",
+      args: [] as const,
+      returns: "u32",
+      implementation: () => unsupported(),
+    }),
+    platformFamily: hostService({
+      importName: "fui_get_platform_family",
+      args: [] as const,
+      returns: "u32",
+      implementation: () => unsupported(),
+    }),
+    isCoarsePointer: hostService({
+      importName: "fui_is_coarse_pointer",
+      args: [] as const,
+      returns: "bool",
+      implementation: () => unsupported(),
+    }),
+  },
+});

package/scripts/generate-host-events.ts

@@ -22,6 +22,11 @@ function relativeImport(fromFile: string, targetFile: string): string {
   return toPosix(relative);
 }
 
+function sourcePathForHeader(sourceModulePath: string): string {
+  const relative = path.relative(process.cwd(), sourceModulePath);
+  return toPosix(relative.startsWith(".") ? relative : `./${relative}`);
+}
+
 function asTypeName(type: HostServiceTypeName): string {
   switch (type) {
     case "string":
@@ -30,12 +35,24 @@ function asTypeName(type: HostServiceTypeName): string {
       return "bool";
     case "i32":
       return "i32";
+    case "u32":
+      return "u32";
+    case "i64":
+      return "i64";
+    case "u64":
+      return "u64";
     case "f64":
       return "f64";
     case "bytes":
       return "Uint8Array";
     case "i32_array":
       return "Int32Array";
+    case "u32_array":
+      return "Uint32Array";
+    case "i64_array":
+      return "Int64Array";
+    case "u64_array":
+      return "Uint64Array";
     case "f64_array":
       return "Float64Array";
     case "void":
@@ -59,7 +76,15 @@ function callbackTypeFor(method: NormalizedHostEventMethod): string {
 function emitExportArgs(method: NormalizedHostEventMethod): string {
   const parts: Array<string> = [];
   method.args.forEach((type, index) => {
-    if (type === "string" || type === "bytes" || type === "i32_array" || type === "f64_array") {
+    if (
+      type === "string" ||
+      type === "bytes" ||
+      type === "i32_array" ||
+      type === "u32_array" ||
+      type === "i64_array" ||
+      type === "u64_array" ||
+      type === "f64_array"
+    ) {
       parts.push(`arg${String(index)}Ptr: usize`, `arg${String(index)}Len: u32`);
       return;
     }
@@ -91,6 +116,27 @@ function emitDecodedArgs(method: NormalizedHostEventMethod): Array<string> {
         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;
+      }
+      if (type === "u32_array") {
+        lines.push(`  const arg${String(index)} = new Uint32Array(<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 === "i64_array") {
+        lines.push(`  const arg${String(index)} = new Int64Array(<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;
+      }
+      if (type === "u64_array") {
+        lines.push(`  const arg${String(index)} = new Uint64Array(<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;
     }
@@ -171,7 +217,7 @@ function emitBindingsFile(
 ): string {
   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}.`,
+    `// Generated by scripts/generate-host-events.ts from ${sourcePathForHeader(sourceModulePath)}#${exportName}.`,
     `import { Callback0, Callback1, Callback2 } from "${callbackImport}";`,
     "",
   ];

package/scripts/generate-host-services.ts

@@ -21,6 +21,11 @@ function relativeImport(fromFile: string, targetFile: string): string {
   return toPosix(relative);
 }
 
+function sourcePathForHeader(sourceModulePath: string): string {
+  const relative = path.relative(process.cwd(), sourceModulePath);
+  return toPosix(relative.startsWith(".") ? relative : `./${relative}`);
+}
+
 function asTypeName(type: HostServiceTypeName): string {
   switch (type) {
     case "string":
@@ -29,12 +34,24 @@ function asTypeName(type: HostServiceTypeName): string {
       return "bool";
     case "i32":
       return "i32";
+    case "u32":
+      return "u32";
+    case "i64":
+      return "i64";
+    case "u64":
+      return "u64";
     case "f64":
       return "f64";
     case "bytes":
       return "Uint8Array";
     case "i32_array":
       return "Int32Array";
+    case "u32_array":
+      return "Uint32Array";
+    case "i64_array":
+      return "Int64Array";
+    case "u64_array":
+      return "Uint64Array";
     case "f64_array":
       return "Float64Array";
     case "void":
@@ -43,14 +60,31 @@ function asTypeName(type: HostServiceTypeName): string {
 }
 
 function isPointerLengthType(type: HostServiceTypeName): boolean {
-  return type === "string" || type === "bytes" || type === "i32_array" || type === "f64_array";
+  return type === "string" ||
+    type === "bytes" ||
+    type === "i32_array" ||
+    type === "u32_array" ||
+    type === "i64_array" ||
+    type === "u64_array" ||
+    type === "f64_array";
 }
 
 function returnsBufferType(type: HostServiceTypeName): boolean {
-  return type === "string" || type === "bytes" || type === "i32_array" || type === "f64_array";
+  return type === "string" ||
+    type === "bytes" ||
+    type === "i32_array" ||
+    type === "u32_array" ||
+    type === "i64_array" ||
+    type === "u64_array" ||
+    type === "f64_array";
 }
 
-function emitExternalSignature(importName: string, args: readonly HostServiceTypeName[], returns: HostServiceTypeName): string {
+function emitExternalSignature(
+  importName: string,
+  args: readonly HostServiceTypeName[],
+  returns: HostServiceTypeName,
+  moduleName: string,
+): string {
   const signatureParts: Array<string> = [];
   args.forEach((type, index) => {
     if (isPointerLengthType(type)) {
@@ -64,7 +98,7 @@ function emitExternalSignature(importName: string, args: readonly HostServiceTyp
   }
   const returnType = returnsBufferType(returns) ? "u32" : asTypeName(returns);
   return [
-    `@external("fui_host_service", "${importName}")`,
+    `@external("${moduleName}", "${importName}")`,
     `declare function __host_${importName}(${signatureParts.join(", ")}): ${returnType};`,
   ].join("\n");
 }
@@ -77,7 +111,7 @@ function emitWrapper(importName: string, args: readonly HostServiceTypeName[], r
       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") {
+    if (type === "bytes" || type === "i32_array" || type === "u32_array" || type === "i64_array" || type === "u64_array" || type === "f64_array") {
       lines.push(`  const arg${String(index)}Bytes = arg${String(index)};`);
     }
   });
@@ -93,7 +127,7 @@ function emitWrapper(importName: string, args: readonly HostServiceTypeName[], r
       callArgs.push(`<u32>arg${String(index)}Bytes.length`);
       return;
     }
-    if (type === "i32_array" || type === "f64_array") {
+    if (type === "i32_array" || type === "u32_array" || type === "i64_array" || type === "u64_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;
@@ -111,6 +145,12 @@ function emitWrapper(importName: string, args: readonly HostServiceTypeName[], r
       lines.push(`  return decodeHostServiceBytesResult(resultPtr, resultLen, "${importName}");`);
     } else if (returns === "i32_array") {
       lines.push(`  return decodeHostServiceI32ArrayResult(resultPtr, resultLen, "${importName}");`);
+    } else if (returns === "u32_array") {
+      lines.push(`  return decodeHostServiceU32ArrayResult(resultPtr, resultLen, "${importName}");`);
+    } else if (returns === "i64_array") {
+      lines.push(`  return decodeHostServiceI64ArrayResult(resultPtr, resultLen, "${importName}");`);
+    } else if (returns === "u64_array") {
+      lines.push(`  return decodeHostServiceU64ArrayResult(resultPtr, resultLen, "${importName}");`);
     } else {
       lines.push(`  return decodeHostServiceF64ArrayResult(resultPtr, resultLen, "${importName}");`);
     }
@@ -155,10 +195,11 @@ function emitBindingsFile(
   outputPath: string,
   methods: ReturnType<typeof listHostServiceMethods>,
   primitivesImportOverride: string | undefined,
+  moduleName: string,
 ): string {
   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}.`,
+    `// Generated by scripts/generate-host-services.ts from ${sourcePathForHeader(sourceModulePath)}#${exportName}.`,
   ];
   if (methods.some((method) => returnsBufferType(method.returns))) {
     const helpers = [
@@ -178,6 +219,15 @@ function emitBindingsFile(
             if (type === "i32_array") {
               return "decodeHostServiceI32ArrayResult";
             }
+            if (type === "u32_array") {
+              return "decodeHostServiceU32ArrayResult";
+            }
+            if (type === "i64_array") {
+              return "decodeHostServiceI64ArrayResult";
+            }
+            if (type === "u64_array") {
+              return "decodeHostServiceU64ArrayResult";
+            }
             return "decodeHostServiceF64ArrayResult";
           }),
       ),
@@ -188,7 +238,7 @@ function emitBindingsFile(
     blocks.push("");
   }
   methods.forEach((method, index) => {
-    blocks.push(emitExternalSignature(method.importName, method.args, method.returns));
+    blocks.push(emitExternalSignature(method.importName, method.args, method.returns, moduleName));
     blocks.push("");
     blocks.push(emitWrapper(method.importName, method.args, method.returns));
     if (index + 1 < methods.length) {
@@ -199,15 +249,24 @@ function emitBindingsFile(
 }
 
 async function main(): Promise<void> {
-  const [moduleArg, exportName, outputArg, primitivesImportArg] = process.argv.slice(2);
+  const [moduleArg, exportName, outputArg, primitivesImportArg, hostModuleArg] = process.argv.slice(2);
   if (moduleArg === undefined || exportName === undefined || outputArg === undefined) {
-    throw new Error("Usage: generate-host-services <module-path> <export-name> <output-path> [primitives-import]");
+    throw new Error(
+      "Usage: generate-host-services <module-path> <export-name> <output-path> [primitives-import] [host-import-module]",
+    );
   }
   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, primitivesImportArg);
+  const content = emitBindingsFile(
+    modulePath,
+    exportName,
+    outputPath,
+    methods,
+    primitivesImportArg,
+    hostModuleArg ?? "fui_host_service",
+  );
   await fs.mkdir(path.dirname(outputPath), { recursive: true });
   await fs.writeFile(outputPath, content, "utf8");
 }

package/src/FuiPrimitives.ts

@@ -15,8 +15,11 @@ export { clearCurrentSelection, tryGetBounds } from "./bindings/ui";
 export {
   decodeHostServiceBytesResult,
   decodeHostServiceF64ArrayResult,
+  decodeHostServiceI64ArrayResult,
   decodeHostServiceI32ArrayResult,
   decodeHostServiceStringResult,
+  decodeHostServiceU64ArrayResult,
+  decodeHostServiceU32ArrayResult,
   hostServiceResultBufferPtr,
   hostServiceResultBufferSize,
 } from "./host-services/runtime";

package/src/core/ffi.ts

@@ -1,3 +1,11 @@
+export {
+  fui_get_accent_color,
+  fui_get_platform_family,
+  fui_is_coarse_pointer,
+  fui_is_dark_mode,
+  fui_now_ms,
+} from "./generated/FrameworkHostServices";
+
 export enum HandleValue {
   Invalid = 0,
 }
@@ -569,24 +577,9 @@ export declare function fui_start_timer(timerId: u32, delayMs: i32): void;
 @external("fui_host", "fui_cancel_timer")
 export declare function fui_cancel_timer(timerId: u32): void;
 
-@external("fui_host", "fui_now_ms")
-export declare function fui_now_ms(): f64;
-
 @external("fui_host", "fui_set_cursor")
 export declare function fui_set_cursor(style: u32): void;
 
-@external("fui_host", "fui_is_dark_mode")
-export declare function fui_is_dark_mode(): bool;
-
-@external("fui_host", "fui_get_accent_color")
-export declare function fui_get_accent_color(): u32;
-
-@external("fui_host", "fui_get_platform_family")
-export declare function fui_get_platform_family(): u32;
-
-@external("fui_host", "fui_is_coarse_pointer")
-export declare function fui_is_coarse_pointer(): bool;
-
 @external("fui_host", "fui_show_url_preview")
 export declare function fui_show_url_preview(ptr: usize, len: u32): void;
 

package/src/core/generated/FrameworkHostServices.ts

@@ -0,0 +1,36 @@
+// Generated by scripts/generate-host-services.ts from ./scripts/framework-host-services.ts#frameworkHostServices.
+
+@external("fui_host", "fui_get_accent_color")
+declare function __host_fui_get_accent_color(): u32;
+
+export function fui_get_accent_color(): u32 {
+  return __host_fui_get_accent_color();
+}
+
+@external("fui_host", "fui_get_platform_family")
+declare function __host_fui_get_platform_family(): u32;
+
+export function fui_get_platform_family(): u32 {
+  return __host_fui_get_platform_family();
+}
+
+@external("fui_host", "fui_is_coarse_pointer")
+declare function __host_fui_is_coarse_pointer(): bool;
+
+export function fui_is_coarse_pointer(): bool {
+  return __host_fui_is_coarse_pointer();
+}
+
+@external("fui_host", "fui_is_dark_mode")
+declare function __host_fui_is_dark_mode(): bool;
+
+export function fui_is_dark_mode(): bool {
+  return __host_fui_is_dark_mode();
+}
+
+@external("fui_host", "fui_now_ms")
+declare function __host_fui_now_ms(): f64;
+
+export function fui_now_ms(): f64 {
+  return __host_fui_now_ms();
+}

package/src/host-services/runtime.ts

@@ -49,6 +49,42 @@ export function decodeHostServiceI32ArrayResult(resultPtr: usize, resultLen: u32
   return values;
 }
 
+export function decodeHostServiceU32ArrayResult(resultPtr: usize, resultLen: u32, importName: string): Uint32Array {
+  assertResultByteLength(resultLen, importName);
+  if ((resultLen & 3) != 0) {
+    throw new Error("Host service " + importName + " returned misaligned Uint32Array byte length.");
+  }
+  const values = new Uint32Array(<i32>(resultLen >> 2));
+  if (resultLen > 0) {
+    memory.copy(values.dataStart, resultPtr, <usize>resultLen);
+  }
+  return values;
+}
+
+export function decodeHostServiceI64ArrayResult(resultPtr: usize, resultLen: u32, importName: string): Int64Array {
+  assertResultByteLength(resultLen, importName);
+  if ((resultLen & 7) != 0) {
+    throw new Error("Host service " + importName + " returned misaligned Int64Array byte length.");
+  }
+  const values = new Int64Array(<i32>(resultLen >> 3));
+  if (resultLen > 0) {
+    memory.copy(values.dataStart, resultPtr, <usize>resultLen);
+  }
+  return values;
+}
+
+export function decodeHostServiceU64ArrayResult(resultPtr: usize, resultLen: u32, importName: string): Uint64Array {
+  assertResultByteLength(resultLen, importName);
+  if ((resultLen & 7) != 0) {
+    throw new Error("Host service " + importName + " returned misaligned Uint64Array byte length.");
+  }
+  const values = new Uint64Array(<i32>(resultLen >> 3));
+  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) {