craft-native 0.0.228 → 0.0.231

package/dist/android/src/index.d.ts

@@ -4,9 +4,16 @@
  * Generates native Android apps from web content using WebView.
  */
 export { runKotlinFixture } from './testing.js';
+/** Package custom fonts and their licenses; removed fonts cannot linger in the app. */
+export declare function syncNativeFonts(fonts: CraftAndroidConfig['nativeFonts'], output: string): string[];
 /** Oldest Android API level supported by the generated Kotlin runtime. */
 export declare const ANDROID_MIN_SDK = 26;
 export interface CraftAndroidConfig {
+    /** Bundled font files keyed by their PostScript font name, used as native fontFamily. */
+    nativeFonts?: Record<string, {
+        src: string;
+        license?: string;
+    }>;
     appName: string;
     packageName: string;
     renderer?: 'web' | 'native';

package/dist/android/src/index.js

@@ -134,6 +134,35 @@ tasks.register('runFixture', JavaExec) {
 }
 
 // ../android/src/index.ts
+function syncNativeFonts(fonts, output) {
+  const destination = join2(output, "app/src/main/assets/NativeFonts");
+  const names = new Set;
+  const files = Object.entries(fonts ?? {}).map(([family, entry]) => {
+    if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(family))
+      throw new Error(`Invalid native font PostScript name: ${family}`);
+    if (names.has(family.toLowerCase()))
+      throw new Error(`Duplicate native font name: ${family}`);
+    names.add(family.toLowerCase());
+    if ([entry.src, entry.license].some((file) => file && resolve(file).startsWith(resolve(destination) + sep)))
+      throw new Error("Native font sources must be outside the generated NativeFonts directory");
+    const extension = extname(entry.src).toLowerCase();
+    if (![".ttf", ".otf"].includes(extension) || !existsSync(entry.src) || !statSync(entry.src).isFile())
+      throw new Error(`Native font ${family} must reference an existing TTF or OTF file: ${entry.src}`);
+    if (entry.license && (!existsSync(entry.license) || !statSync(entry.license).isFile()))
+      throw new Error(`Native font license not found: ${entry.license}`);
+    return { family, ...entry, filename: `${family}${extension}` };
+  });
+  rmSync(destination, { recursive: true, force: true });
+  if (!files.length)
+    return [];
+  mkdirSync(destination, { recursive: true });
+  for (const file of files) {
+    cpSync(file.src, join2(destination, file.filename));
+    if (file.license)
+      cpSync(file.license, join2(destination, `${file.family}.LICENSE.txt`));
+  }
+  return files.map((file) => `NativeFonts/${file.filename}`);
+}
 var TEMPLATES_DIR = join2(dirname2(import.meta.dir), "templates");
 function resolveCraftAndroidVersion(startDir = import.meta.dir) {
   let directory = resolve(startDir);
@@ -884,6 +913,7 @@ zipStorePath=wrapper/dists
 </androidx.coordinatorlayout.widget.CoordinatorLayout>
 `;
   writeFileSync(join2(output, "app/src/main/res/layout/activity_main.xml"), activityMainXml);
+  syncNativeFonts(config.nativeFonts, output);
   const placeholderHtml = `<!DOCTYPE html>
 <html>
 <head>
@@ -995,6 +1025,7 @@ async function build(options) {
     writeAndroidConfig(output, config);
     console.log(`   Synced: ${htmlPath} \u2192 assets/`);
   }
+  syncNativeFonts(config.nativeFonts, output);
   if (!compile)
     return;
   const gradlewPath = join2(output, "gradlew");
@@ -1066,6 +1097,7 @@ async function run(options) {
   }
 }
 export {
+  syncNativeFonts,
   syncAndroidWebAssets,
   runKotlinFixture,
   run,

package/dist/android/templates/MainActivityNative.kt.template

@@ -3810,6 +3810,11 @@ class MainActivity : AppCompatActivity() {
     private val imageCache by lazy { CraftNativeImageCache(File(cacheDir, "craft-native-images")) }
     /** Lays out each isolate's prelude (the synchronous stores) off the main thread. */
     private val preludeExecutor = Executors.newSingleThreadExecutor()
+    private val bundledFonts: Map<String, Typeface> by lazy {
+        (assets.list("NativeFonts") ?: emptyArray()).filter { it.endsWith(".ttf") || it.endsWith(".otf") }
+            .associate { filename -> filename.substringBeforeLast('.') to Typeface.createFromAsset(assets, "NativeFonts/$filename") }
+    }
+
     private val imageSources = mutableMapOf<ImageView, String>()
     private val imageJobs = mutableMapOf<ImageView, Future<*>>()
     private val imageErrors = mutableMapOf<ImageView, String>()
@@ -6351,9 +6356,10 @@ class MainActivity : AppCompatActivity() {
         }
         val italic = craftNativeOptionalString(style.opt("fontStyle")) == "italic"
         val family = craftNativeOptionalString(style.opt("fontFamily"))?.takeIf { it.isNotBlank() }
+        val base = family?.let { bundledFonts[it] } ?: Typeface.create(family, Typeface.NORMAL)
         view.typeface = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-            Typeface.create(Typeface.create(family, Typeface.NORMAL), weight, italic)
-        } else Typeface.create(family, (if (weight >= 600) Typeface.BOLD else Typeface.NORMAL) or
+            Typeface.create(base, weight, italic)
+        } else Typeface.create(base, (if (weight >= 600) Typeface.BOLD else Typeface.NORMAL) or
             (if (italic) Typeface.ITALIC else Typeface.NORMAL))
         val textAlign = craftNativeOptionalString(style.opt("textAlign"))
         view.textAlignment = when (textAlign) {

package/dist/cli.js

@@ -3424,7 +3424,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.228";
+var version = "0.0.231";
 
 // bin/cli.ts
 var spawnedFrom = process6.env[CRAFT_CLI_SPAWN_MARKER];

package/dist/index.cjs

@@ -309,7 +309,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.228";
+var version = "0.0.231";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/index.js

@@ -57,7 +57,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.228";
+var version = "0.0.231";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/ios/src/index.d.ts

@@ -3,10 +3,17 @@
  *
  * Generates native iOS apps from web content using WKWebView.
  */
+/** Package custom fonts and their licenses; removed fonts cannot linger in the app. */
+export declare function syncNativeFonts(fonts: CraftConfig['nativeFonts'], output: string): string[];
 /** This package's version, which the app names in its user agent (`Craft/<version>`). */
 export declare function resolveCraftVersion(startDir?: string): string;
 export type CraftAppearance = 'light' | 'dark' | 'system';
 export interface CraftConfig {
+    /** Bundled font files keyed by their PostScript font name, used as native fontFamily. */
+    nativeFonts?: Record<string, {
+        src: string;
+        license?: string;
+    }>;
     appName: string;
     bundleId: string;
     /** Opt in to UIKit + JavaScriptCore instead of the default WebView. */
@@ -563,4 +570,4 @@ export declare function bootSimulator(device: SimulatorDevice): Promise<void>;
 export declare function showSimulator(): Promise<void>;
 export declare function run(options: RunOptions): Promise<void>;
 export { createNativeMutationValidator, initSimulatorDriver, serializeSimulatorSteps } from './testing.js';
-export type { NativeMutationValidator, NativeValidationResult, SimulatorDriverOptions, SimulatorStep } from './testing.js';
+export type { NativeMutationValidator, NativeValidationResult, SimulatorDriverOptions, SimulatorStep, TimedTouchPoint } from './testing.js';

package/dist/ios/src/index.js

@@ -1,7 +1,7 @@
 // @bun
 // ../ios/src/index.ts
 import { cpSync, existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, rmSync as rmSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, join as join3, resolve } from "path";
+import { dirname as dirname2, extname, join as join3, resolve, sep as sep2 } from "path";
 var {$ } = globalThis.Bun;
 
 // ../ios/src/source-audit.ts
@@ -90,6 +90,8 @@ function initSimulatorDriver(options) {
   for (const [source, destination] of [
     ["HostApp.swift", "Host/HostApp.swift"],
     ["DriverTests.swift.template", "UITests/DriverTests.swift"],
+    ["CraftTimedInput.h", "UITests/CraftTimedInput.h"],
+    ["CraftTimedInput.m", "UITests/CraftTimedInput.m"],
     ["project.yml.template", "project.yml"]
   ]) {
     const path = join2(output, destination);
@@ -127,7 +129,23 @@ function serializeSimulatorSteps(steps) {
   };
   const line = (step) => {
     let arg = "";
-    if ("step" in step)
+    if ("paths" in step) {
+      if (!step.paths.length || step.paths.length > 64)
+        throw new Error("Expected 1\u201364 touch paths");
+      for (const path of step.paths) {
+        if (path.length < 2 || path.length > 64)
+          throw new Error("Expected 2\u201364 points per touch");
+        let previous = -1;
+        for (const point of path) {
+          if ("tab" in point ? !point.tab.trim() || /[\r\n]/.test(point.tab) : number(point.x) > 1 || number(point.y) > 1)
+            throw new Error("Touch targets must be tab names or normalized coordinates");
+          if (number(point.at) > 12 || point.at <= previous)
+            throw new Error("Touch coordinates must be normalized and times strictly increase within 12 seconds");
+          previous = point.at;
+        }
+      }
+      arg = JSON.stringify(step.paths);
+    } else if ("step" in step)
       arg = `${token(step.id)} ${line(step.step)}`;
     else if ("seconds" in step && !("text" in step))
       arg = String(number(step.seconds));
@@ -215,6 +233,35 @@ function createNativeMutationValidator() {
 }
 
 // ../ios/src/index.ts
+function syncNativeFonts(fonts, output) {
+  const destination = join3(output, "NativeFonts");
+  const names = new Set;
+  const files = Object.entries(fonts ?? {}).map(([family, entry]) => {
+    if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(family))
+      throw new Error(`Invalid native font PostScript name: ${family}`);
+    if (names.has(family.toLowerCase()))
+      throw new Error(`Duplicate native font name: ${family}`);
+    names.add(family.toLowerCase());
+    if ([entry.src, entry.license].some((file) => file && resolve(file).startsWith(resolve(destination) + sep2)))
+      throw new Error("Native font sources must be outside the generated NativeFonts directory");
+    const extension = extname(entry.src).toLowerCase();
+    if (![".ttf", ".otf"].includes(extension) || !existsSync(entry.src) || !statSync(entry.src).isFile())
+      throw new Error(`Native font ${family} must reference an existing TTF or OTF file: ${entry.src}`);
+    if (entry.license && (!existsSync(entry.license) || !statSync(entry.license).isFile()))
+      throw new Error(`Native font license not found: ${entry.license}`);
+    return { family, ...entry, filename: `${family}${extension}` };
+  });
+  rmSync2(destination, { recursive: true, force: true });
+  if (!files.length)
+    return [];
+  mkdirSync2(destination, { recursive: true });
+  for (const file of files) {
+    cpSync(file.src, join3(destination, file.filename));
+    if (file.license)
+      cpSync(file.license, join3(destination, `${file.family}.LICENSE.txt`));
+  }
+  return files.map((file) => `NativeFonts/${file.filename}`);
+}
 var TEMPLATES_DIR = join3(dirname2(import.meta.dir), "templates");
 function resolveCraftVersion(startDir = import.meta.dir) {
   let directory = resolve(startDir);
@@ -1088,8 +1135,12 @@ async function init(options) {
     config.enableSecureStorage = true;
   writeFileSync2(join3(output, "craft.config.json"), JSON.stringify(config, null, 2));
   writeShell(output, config);
+  const nativeFontFiles = syncNativeFonts(config.nativeFonts, output);
   const infoPlistTemplate = readFileSync2(join3(TEMPLATES_DIR, "Info.plist.template"), "utf-8");
-  const infoPlist = infoPlistTemplate.replace(/\{\{APP_NAME\}\}/g, xmlEscape(displayName)).replace(/\{\{BUNDLE_ID\}\}/g, finalBundleId).replace(/\{\{VERSION\}\}/g, config.version || "1.0.0").replace(/\{\{BUILD_NUMBER\}\}/g, config.buildNumber || "1").replace(/\{\{UI_STYLE\}\}/g, renderAppearance(config).interfaceStyle).replace(/\{\{STATUS_BAR_STYLE\}\}/g, renderAppearance(config).statusBarStyle).replace(/\{\{ORIENTATIONS\}\}/g, renderOrientations(config)).replace(/\{\{USAGE_DESCRIPTIONS\}\}/g, renderUsageDescriptions(config)).replace(/\{\{URL_TYPES\}\}/g, renderUrlTypes(config)).replace(/\{\{APP_BOUND_DOMAINS\}\}/g, renderAppBoundDomains(config)).replace(/\{\{BACKGROUND_MODES\}\}/g, renderBackgroundModes(config)).replace(/\{\{BACKGROUND_TASK_IDENTIFIERS\}\}/g, renderBackgroundTaskIdentifiers(config)).replace(/\{\{LAUNCH_SCREEN\}\}/g, renderLaunchScreen(config)).replace(/\{\{NON_EXEMPT_ENCRYPTION\}\}/g, config.usesNonExemptEncryption ? "true" : "false").replace(/\{\{LIVE_ACTIVITY_SUPPORT\}\}/g, config.enableLiveActivities ? `    <key>NSSupportsLiveActivities</key>
+  const infoPlist = infoPlistTemplate.replace(/\{\{APP_NAME\}\}/g, xmlEscape(displayName)).replace(/\{\{BUNDLE_ID\}\}/g, finalBundleId).replace(/\{\{VERSION\}\}/g, config.version || "1.0.0").replace(/\{\{BUILD_NUMBER\}\}/g, config.buildNumber || "1").replace(/\{\{UI_STYLE\}\}/g, renderAppearance(config).interfaceStyle).replace(/\{\{STATUS_BAR_STYLE\}\}/g, renderAppearance(config).statusBarStyle).replace(/\{\{ORIENTATIONS\}\}/g, renderOrientations(config)).replace(/\{\{USAGE_DESCRIPTIONS\}\}/g, renderUsageDescriptions(config)).replace(/\{\{URL_TYPES\}\}/g, renderUrlTypes(config)).replace(/\{\{APP_BOUND_DOMAINS\}\}/g, renderAppBoundDomains(config)).replace(/\{\{BACKGROUND_MODES\}\}/g, renderBackgroundModes(config)).replace(/\{\{BACKGROUND_TASK_IDENTIFIERS\}\}/g, renderBackgroundTaskIdentifiers(config)).replace(/\{\{LAUNCH_SCREEN\}\}/g, renderLaunchScreen(config)).replace(/\{\{NATIVE_FONTS\}\}/g, nativeFontFiles.length ? `    <key>UIAppFonts</key>
+    <array>
+${plistArray(nativeFontFiles, 2)}
+    </array>` : "").replace(/\{\{NON_EXEMPT_ENCRYPTION\}\}/g, config.usesNonExemptEncryption ? "true" : "false").replace(/\{\{LIVE_ACTIVITY_SUPPORT\}\}/g, config.enableLiveActivities ? `    <key>NSSupportsLiveActivities</key>
     <true/>
     <key>NSSupportsLiveActivitiesFrequentUpdates</key>
     <true/>` : "");
@@ -1156,7 +1207,9 @@ async function init(options) {
   } else {
     rmSync2(join3(output, "Runtime"), { recursive: true, force: true });
   }
-  const projectYml = projectYmlTemplate.replace(/\{\{CRAFT_RUNTIME_SETTINGS\}\}/g, hasRuntime ? renderRuntimeSettings() : "").replace(/\{\{FEATURE_SETTINGS\}\}/g, renderFeatureSettings(config)).replace(/\{\{APP_NAME\}\}/g, name).replace(/\{\{BUNDLE_ID\}\}/g, finalBundleId).replace(/\{\{BUNDLE_ID_PREFIX\}\}/g, bundleIdPrefix).replace(/\{\{VERSION\}\}/g, config.version || "1.0.0").replace(/\{\{BUILD_NUMBER\}\}/g, config.buildNumber || "1").replace(/\{\{IOS_VERSION\}\}/g, config.iosVersion || "15.0").replace(/\{\{DEVICE_FAMILIES\}\}/g, renderDeviceFamilies(config)).replace(/\{\{TEAM_ID\}\}/g, teamId || "").replace(/\{\{NATIVE_DEPENDENCIES\}\}/g, nativeDependencies.length ? `    dependencies:
+  const projectYml = projectYmlTemplate.replace(/\{\{NATIVE_FONT_RESOURCES\}\}/g, nativeFontFiles.length ? `      - path: NativeFonts
+        type: folder
+        buildPhase: resources` : "").replace(/\{\{CRAFT_RUNTIME_SETTINGS\}\}/g, hasRuntime ? renderRuntimeSettings() : "").replace(/\{\{FEATURE_SETTINGS\}\}/g, renderFeatureSettings(config)).replace(/\{\{APP_NAME\}\}/g, name).replace(/\{\{BUNDLE_ID\}\}/g, finalBundleId).replace(/\{\{BUNDLE_ID_PREFIX\}\}/g, bundleIdPrefix).replace(/\{\{VERSION\}\}/g, config.version || "1.0.0").replace(/\{\{BUILD_NUMBER\}\}/g, config.buildNumber || "1").replace(/\{\{IOS_VERSION\}\}/g, config.iosVersion || "15.0").replace(/\{\{DEVICE_FAMILIES\}\}/g, renderDeviceFamilies(config)).replace(/\{\{TEAM_ID\}\}/g, teamId || "").replace(/\{\{NATIVE_DEPENDENCIES\}\}/g, nativeDependencies.length ? `    dependencies:
 ${nativeDependencies.join(`
 `)}` : "").replace(/\{\{NATIVE_TARGETS\}\}/g, nativeTargets.join(`
 `));
@@ -1387,6 +1440,7 @@ async function run(options) {
 export {
   usesNativeBundle,
   syncWebAssets,
+  syncNativeFonts,
   showSimulator,
   serializeSimulatorSteps,
   run,

package/dist/ios/src/testing.d.ts

@@ -12,6 +12,14 @@ export interface SimulatorDriverOptions {
 }
 /** Generate the reusable XCUITest shell from package templates. No app-owned Swift. */
 export declare function initSimulatorDriver(options: SimulatorDriverOptions): void;
+export type TimedTouchPoint = {
+    x: number;
+    y: number;
+    at: number;
+} | {
+    tab: string;
+    at: number;
+};
 export type SimulatorStep = {
     command: 'launch' | 'activate' | 'terminate' | 'home' | 'back' | 'return' | 'unlabelled' | 'notifications';
 } | {
@@ -46,6 +54,11 @@ export type SimulatorStep = {
     command: 'tapxy';
     x: number;
     y: number;
+}
+/** One native event record, without quiescence between paths. Times are seconds. */
+ | {
+    command: 'touches';
+    paths: TimedTouchPoint[][];
 } | {
     command: 'field';
     index: number;

package/dist/ios/templates/Info.plist.template

@@ -26,6 +26,7 @@
     <true/>
     <key>ITSAppUsesNonExemptEncryption</key>
     <{{NON_EXEMPT_ENCRYPTION}}/>
+{{NATIVE_FONTS}}
     <key>UILaunchScreen</key>
     <dict>
 {{LAUNCH_SCREEN}}

package/dist/ios/templates/project.yml.template

@@ -27,6 +27,7 @@ targets:
       - path: craft.config.json
         optional: true
         buildPhase: resources
+{{NATIVE_FONT_RESOURCES}}
       - path: Assets.xcassets
         buildPhase: resources
       - path: PrivacyInfo.xcprivacy

package/dist/ios/templates/testing/CraftTimedInput.h

@@ -0,0 +1,11 @@
+#import <Foundation/Foundation.h>
+#import <CoreGraphics/CoreGraphics.h>
+
+NS_ASSUME_NONNULL_BEGIN
+/// Test-runner-only native events. Never linked into a shipped application.
+@interface CraftTimedInput : NSObject
++ (BOOL)synthesizePaths:(NSArray<NSArray<NSDictionary<NSString *, NSNumber *> *> *> *)paths
+                 frame:(CGRect)frame
+                 error:(NSError * _Nullable * _Nullable)error NS_SWIFT_NAME(synthesize(paths:frame:));
+@end
+NS_ASSUME_NONNULL_END

package/dist/ios/templates/testing/CraftTimedInput.m

@@ -0,0 +1,75 @@
+#import "CraftTimedInput.h"
+#import <UIKit/UIKit.h>
+#import <math.h>
+
+// XCTest's own touch-record API is private. Look up classes and check every
+// selector at runtime; unsupported Xcode versions fail rather than skipping or
+// falling back to serialized taps. These declarations create no class linkage.
+@interface NSObject (CraftTestingTouchRecords)
+- (id)initForTouchAtPoint:(CGPoint)point offset:(double)offset;
+- (void)moveToPoint:(CGPoint)point atOffset:(double)offset;
+- (void)liftUpAtOffset:(double)offset;
+- (id)initWithName:(NSString *)name interfaceOrientation:(NSInteger)orientation;
+- (void)addPointerEventPath:(id)path;
+- (BOOL)synthesizeWithError:(NSError **)error;
+@end
+
+@implementation CraftTimedInput
++ (BOOL)fail:(NSString *)message error:(NSError **)error {
+    if (error) *error = [NSError errorWithDomain:@"CraftTimedInput" code:1
+                                      userInfo:@{NSLocalizedDescriptionKey: message}];
+    return NO;
+}
+
++ (BOOL)synthesizePaths:(NSArray *)paths frame:(CGRect)frame error:(NSError **)error {
+    if (![paths isKindOfClass:NSArray.class] || paths.count == 0 || paths.count > 64
+        || CGRectIsEmpty(frame) || !isfinite(frame.size.width) || !isfinite(frame.size.height))
+        return [self fail:@"Expected 1–64 timed touch paths and a visible app frame" error:error];
+    // Validate the entire record before any native event is submitted.
+    for (id path in paths) {
+        if (![path isKindOfClass:NSArray.class] || [path count] < 2 || [path count] > 64)
+            return [self fail:@"Each touch needs 2–64 points" error:error];
+        double previous = -1;
+        for (id point in path) {
+            if (![point isKindOfClass:NSDictionary.class]) return [self fail:@"Invalid touch point" error:error];
+            for (NSString *key in @[@"x", @"y", @"at"]) {
+                id value = point[key];
+                if (![value isKindOfClass:NSNumber.class] || !isfinite([value doubleValue]))
+                    return [self fail:@"Touch coordinates and times must be finite numbers" error:error];
+            }
+            double x = [point[@"x"] doubleValue], y = [point[@"y"] doubleValue], at = [point[@"at"] doubleValue];
+            if (x < 0 || x > 1 || y < 0 || y > 1 || at < 0 || at > 12 || at <= previous)
+                return [self fail:@"Touch coordinates must be normalized; times must increase within 12 seconds" error:error];
+            previous = at;
+        }
+    }
+    Class recordClass = NSClassFromString(@"XCSynthesizedEventRecord");
+    Class pathClass = NSClassFromString(@"XCPointerEventPath");
+    for (NSString *name in @[@"initWithName:interfaceOrientation:", @"addPointerEventPath:", @"synthesizeWithError:"])
+        if (![recordClass instancesRespondToSelector:NSSelectorFromString(name)])
+            return [self fail:@"XCTest does not support timed native event records" error:error];
+    for (NSString *name in @[@"initForTouchAtPoint:offset:", @"moveToPoint:atOffset:", @"liftUpAtOffset:"])
+        if (![pathClass instancesRespondToSelector:NSSelectorFromString(name)])
+            return [self fail:@"XCTest does not support timed native touch paths" error:error];
+    id record = [[recordClass alloc] initWithName:@"Craft timed native input" interfaceOrientation:UIInterfaceOrientationPortrait];
+    if (!record) return [self fail:@"XCTest refused a native event record" error:error];
+    for (NSArray *points in paths) {
+        NSDictionary *first = points.firstObject;
+        CGPoint start = CGPointMake(frame.origin.x + [first[@"x"] doubleValue] * frame.size.width,
+                                    frame.origin.y + [first[@"y"] doubleValue] * frame.size.height);
+        id path = [[pathClass alloc] initForTouchAtPoint:start offset:[first[@"at"] doubleValue]];
+        if (!path) return [self fail:@"XCTest refused a native touch path" error:error];
+        for (NSUInteger index = 1; index < points.count; index++) {
+            NSDictionary *point = points[index];
+            CGPoint location = CGPointMake(frame.origin.x + [point[@"x"] doubleValue] * frame.size.width,
+                                           frame.origin.y + [point[@"y"] doubleValue] * frame.size.height);
+            [path moveToPoint:location atOffset:[point[@"at"] doubleValue]];
+        }
+        [path liftUpAtOffset:[points.lastObject[@"at"] doubleValue]];
+        [record addPointerEventPath:path];
+    }
+    // One dispatch retains the native offsets between different fingers/taps.
+    // Individual XCUICoordinate.tap() calls would wait for app quiescence.
+    return [record synthesizeWithError:error];
+}
+@end

package/dist/ios/templates/testing/DriverTests.swift.template

@@ -1,4 +1,5 @@
 import XCTest
+import Darwin
 
 /// Drives the installed app from a script the Mac serves (netswitch.ts
 /// `/script`), one command a line:
@@ -20,6 +21,7 @@ import XCTest
 ///   tap <text>            first hittable element whose label contains text
 ///   tapif <text>          tap it when it is on screen, else carry on (the big timer's "Show the controls")
 ///   tapid <identifier>
+///   touches <JSON>       timed normalized touch paths in one native dispatch
 ///   tapxy <x> <y>         normalised 0…1 of the screen
 ///   tapexact <label>      a button whose label is exactly this
 ///   back                  the navigation bar's back button, else an edge swipe
@@ -288,6 +290,52 @@ final class DriverTests: XCTestCase {
             let target = identified(arg)
             if target.waitForExistence(timeout: 10) { press(target); note("tapid \(arg): ok") }
             else { XCTFail("Element not found"); note("FAIL tapid \(arg): NOT FOUND") }
+        case "touches":
+            do {
+                guard let data = arg.data(using: .utf8),
+                      let rawPaths = try JSONSerialization.jsonObject(with: data) as? [[[String: Any]]] else {
+                    check(false, "touches requires JSON arrays of x/y/at or tab/at points")
+                    return
+                }
+                let frame = app.frame
+                var tabLocations: [String: CGPoint] = [:]
+                var paths: [[[String: NSNumber]]] = []
+                for rawPath in rawPaths {
+                    var path: [[String: NSNumber]] = []
+                    for rawPoint in rawPath {
+                        var point = rawPoint
+                        if let name = point.removeValue(forKey: "tab") as? String {
+                            if tabLocations[name] == nil {
+                                guard let button = tabButton(name), frame.width > 0, frame.height > 0 else {
+                                    check(false, "Timed native input cannot find tab \(name)")
+                                    return
+                                }
+                                let rect = button.frame
+                                tabLocations[name] = CGPoint(x: (rect.midX - frame.minX) / frame.width,
+                                                             y: (rect.midY - frame.minY) / frame.height)
+                            }
+                            point["x"] = tabLocations[name]!.x
+                            point["y"] = tabLocations[name]!.y
+                        }
+                        guard let numbers = point as? [String: NSNumber] else {
+                            check(false, "Timed touch points must contain numeric coordinates and times")
+                            return
+                        }
+                        path.append(numbers)
+                    }
+                    paths.append(path)
+                }
+                let scheduled = try JSONSerialization.data(withJSONObject: paths, options: [.sortedKeys])
+                let started = ProcessInfo.processInfo.systemUptime
+                if (paths.flatMap { $0 }.compactMap { $0["at"]?.doubleValue }.max() ?? 0) >= 2 {
+                    note("BEGIN held timed native input")
+                    fflush(nil)
+                }
+                try CraftTimedInput.synthesize(paths: paths, frame: frame)
+                let elapsed = ProcessInfo.processInfo.systemUptime - started
+                post("/save?name=timed-input-\(Int(started * 1000)).json", scheduled)
+                check(true, "timed native input: \(paths.count) paths, \(elapsed)s wall time")
+            } catch { check(false, "timed native input: \(error)") }
         case "tapxy":
             let xy = arg.split(separator: " ").compactMap { Double($0) }
             if xy.count == 2 && xy.allSatisfy({ $0 >= 0 && $0 <= 1 }) {

package/dist/ios/templates/testing/project.yml.template

@@ -19,6 +19,7 @@ targets:
     platform: iOS
     sources: [UITests]
     settings:
+      SWIFT_OBJC_BRIDGING_HEADER: UITests/CraftTimedInput.h
       TEST_TARGET_NAME: {{PROJECT_NAME}}Host
       PRODUCT_BUNDLE_IDENTIFIER: {{BUNDLE_PREFIX}}.uitests
       GENERATE_INFOPLIST_FILE: YES

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "craft-native",
-  "version": "0.0.228",
+  "version": "0.0.231",
   "type": "module",
   "description": "Build desktop apps with web languages - TypeScript SDK for Craft",
   "author": "Chris Breuer <chris@stacksjs.org>",