craft-native 0.0.420 → 0.0.424

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

@@ -15,6 +15,8 @@ export interface AndroidEmulatorOptions {
     /** Requested guest CPU count, 1–8; defaults to 2. */
     virtualCpus?: number;
     env?: Record<string, string | undefined>;
+    /** Cancels provisioning, boot and the owned session without touching other devices. */
+    signal?: AbortSignal;
 }
 export interface AndroidEmulatorSession {
     serial: string;
@@ -22,6 +24,8 @@ export interface AndroidEmulatorSession {
     env: Record<string, string | undefined>;
     /** Stops only this session's process and removes only its disposable AVD. */
     dispose: () => Promise<void>;
+    /** First disposal result, including cancellation. A failure stays recorded even if dispose() later retries successfully. */
+    closed: Promise<void>;
 }
 /** Provision and own a real Android emulator on a macOS or Linux SDK host. */
 export declare function createAndroidEmulator(options: AndroidEmulatorOptions): Promise<AndroidEmulatorSession>;

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

@@ -58,6 +58,10 @@ export interface CraftAndroidConfig {
     enableCamera?: boolean;
     enableBiometric?: boolean;
     enablePushNotifications?: boolean;
+    /** Enable native SQLite queries and transactions. Disabled unless explicitly true. */
+    enableLocalDatabase?: boolean;
+    /** Enable native AlarmManager local notification scheduling. Disabled unless explicitly true. */
+    enableLocalNotifications?: boolean;
     enableSecureStorage?: boolean;
     enableGeolocation?: boolean;
     enableBackgroundLocation?: boolean;

package/dist/android/src/index.js

@@ -182,7 +182,9 @@ tasks.register('runFixture', JavaExec) {
 import { appendFileSync, closeSync, mkdirSync, mkdtempSync, openSync, rmSync } from "fs";
 import { availableParallelism, cpus, tmpdir as tmpdir2, totalmem } from "os";
 import { basename, isAbsolute, join as join2, resolve } from "path";
+import { setTimeout as delay } from "timers/promises";
 async function createAndroidEmulator(options) {
+  options.signal?.throwIfAborted();
   if (!["darwin", "linux"].includes(process.platform))
     throw new Error("Android emulator sessions require macOS or Linux");
   if (!["hardware", "software"].includes(options.acceleration))
@@ -238,6 +240,14 @@ async function createAndroidEmulator(options) {
   let cpuStart = 0;
   let idleStart = 0;
   let identity;
+  const processes = new Set;
+  let resolveClosed;
+  let rejectClosed;
+  const closed = new Promise((resolve, reject) => {
+    resolveClosed = resolve;
+    rejectClosed = reject;
+  });
+  closed.catch(() => {});
   async function recordBootResult(status, endedAt = Date.now()) {
     if (!identity)
       return;
@@ -253,31 +263,165 @@ async function createAndroidEmulator(options) {
     }, null, 2) + `
 `);
   }
-  async function run(args, input, timeout = 900000, allowFailure = false) {
-    const startedAt = new Date().toISOString();
-    const command = Bun.spawn(args, { env, stdin: input === undefined ? "ignore" : new TextEncoder().encode(input), stdout: "pipe", stderr: "pipe", signal: AbortSignal.timeout(timeout) });
-    const [code, stdout, stderr] = await Promise.all([command.exited, new Response(command.stdout).text(), new Response(command.stderr).text()]);
-    appendFileSync(join2(artifacts, "device-commands.jsonl"), JSON.stringify({ sequence: ++sequence, startedAt, finishedAt: new Date().toISOString(), args, code, stdout, stderr }) + `
-`);
-    if (code !== 0 && !allowFailure)
-      throw new Error(`${basename(args[0])} failed with exit ${code}; inspect ${artifacts}`);
-    return { code, stdout };
+  function groupExists(pid) {
+    try {
+      process.kill(-pid, 0);
+      return true;
+    } catch (error) {
+      if (error.code === "ESRCH")
+        return false;
+      if (error.code === "EPERM")
+        return true;
+      throw error;
+    }
+  }
+  function signalGroup(pid, signal) {
+    try {
+      process.kill(-pid, signal);
+    } catch (error) {
+      if (error.code !== "ESRCH")
+        throw error;
+    }
   }
-  const dispose = () => disposal ??= (async () => {
+  async function disposeGroup(pid, graceMs) {
+    const errors = [];
+    if (!groupExists(pid))
+      return errors;
+    let termSent = false;
     try {
-      if (child && child.exitCode === null) {
-        child.kill("SIGTERM");
-        await Promise.race([child.exited, Bun.sleep(1e4)]);
-        if (child.exitCode === null)
-          child.kill("SIGKILL");
-        await child.exited;
+      signalGroup(pid, "SIGTERM");
+      termSent = true;
+    } catch (error) {
+      errors.push(error);
+    }
+    if (termSent) {
+      const grace = performance.now() + graceMs;
+      while (groupExists(pid) && performance.now() < grace)
+        await Bun.sleep(10);
+    }
+    if (!groupExists(pid))
+      return errors;
+    try {
+      signalGroup(pid, "SIGKILL");
+    } catch (error) {
+      errors.push(error);
+    }
+    const deadline = performance.now() + 1000;
+    while (groupExists(pid) && performance.now() < deadline)
+      await Bun.sleep(10);
+    if (groupExists(pid))
+      throw new AggregateError([...errors, new Error(`Owned Android process group ${pid} remained after disposal`)], `Android cleanup failed; private registry retained at ${owned}`);
+    return errors;
+  }
+  function closeProcess(record) {
+    if (record.closing)
+      return record.closing;
+    const attempt = (async () => {
+      const errors = await disposeGroup(record.process.pid, record.graceMs);
+      await record.process.exited;
+      if (record.output) {
+        let timer;
+        try {
+          const output = await Promise.race([
+            record.output,
+            new Promise((resolve) => {
+              timer = setTimeout(() => resolve(null), 1000);
+            })
+          ]);
+          if (!output)
+            throw new Error(`Owned Android command pipes did not close; private registry retained at ${owned}`);
+          for (const stream of output)
+            if (stream.status === "rejected")
+              errors.push(stream.reason);
+          record.stdout = output[0]?.status === "fulfilled" ? output[0].value : "";
+        } finally {
+          if (timer)
+            clearTimeout(timer);
+        }
       }
+      processes.delete(record);
+      if (errors.length)
+        throw new AggregateError(errors, "Owned Android process cleanup encountered an error");
+    })();
+    record.closing = attempt;
+    attempt.catch(() => {
+      if (record.closing === attempt)
+        record.closing = undefined;
+    });
+    return attempt;
+  }
+  async function run(args, input, timeout = 900000, allowFailure = false) {
+    options.signal?.throwIfAborted();
+    const startedAt = new Date().toISOString();
+    const command = Bun.spawn(args, { env, detached: true, stdin: input === undefined ? "ignore" : new TextEncoder().encode(input), stdout: "pipe", stderr: "pipe" });
+    const record = { process: command, graceMs: 250, output: Promise.allSettled([new Response(command.stdout).text(), new Response(command.stderr).text()]) };
+    processes.add(record);
+    let stop;
+    const stopping = new Promise((resolve) => {
+      stop = resolve;
+    });
+    const onCommandAbort = () => stop("aborted");
+    const timer = setTimeout(() => stop("timeout"), timeout);
+    options.signal?.addEventListener("abort", onCommandAbort, { once: true });
+    try {
+      if (options.signal?.aborted)
+        stop("aborted");
+      const result = await Promise.race([command.exited, stopping]);
+      await closeProcess(record);
+      const code = await command.exited;
+      const output = await record.output;
+      const stdout = record.stdout ?? "";
+      const stderr = output[1]?.status === "fulfilled" ? output[1].value : "";
+      const timedOut = result === "timeout";
+      appendFileSync(join2(artifacts, "device-commands.jsonl"), JSON.stringify({ sequence: ++sequence, startedAt, finishedAt: new Date().toISOString(), args, code, stdout, stderr, timedOut, commandGroupDisposed: true }) + `
+`);
+      options.signal?.throwIfAborted();
+      if (timedOut && !allowFailure)
+        throw new Error(`${basename(args[0])} timed out; inspect ${artifacts}`);
+      if (code !== 0 && !allowFailure)
+        throw new Error(`${basename(args[0])} failed with exit ${code}; inspect ${artifacts}`);
+      return { code: timedOut ? code || 1 : code, stdout };
     } finally {
-      if (log !== undefined)
-        closeSync(log);
-      rmSync(owned, { recursive: true, force: true });
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onCommandAbort);
     }
-  })();
+  }
+  const dispose = () => {
+    if (disposal)
+      return disposal;
+    const attempt = (async () => {
+      const results = await Promise.allSettled([...processes].map(closeProcess));
+      const errors = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+      try {
+        if (!processes.size) {
+          options.signal?.removeEventListener("abort", onAbort);
+          if (log !== undefined) {
+            closeSync(log);
+            log = undefined;
+          }
+          rmSync(owned, { recursive: true, force: true });
+        } else
+          errors.push(new Error(`Owned Android processes remain; private registry retained at ${owned}`));
+      } catch (error) {
+        errors.push(error);
+      }
+      if (errors.length)
+        throw new AggregateError(errors, `Android emulator disposal failed; inspect ${artifacts}`);
+    })().then(resolveClosed, (error) => {
+      rejectClosed(error);
+      throw error;
+    });
+    disposal = attempt;
+    attempt.catch(() => {
+      if (disposal === attempt)
+        disposal = undefined;
+    });
+    return attempt;
+  };
+  const onAbort = () => {
+    dispose().catch(() => {});
+  };
+  options.signal?.addEventListener("abort", onAbort, { once: true });
   try {
     mkdirSync(env.ANDROID_AVD_HOME, { recursive: true });
     mkdirSync(env.ANDROID_USER_HOME, { recursive: true });
@@ -302,7 +446,10 @@ async function createAndroidEmulator(options) {
     const hostCpus = cpus();
     cpuStart = hostCpus.reduce((total, cpu) => total + Object.values(cpu.times).reduce((sum, value) => sum + value, 0), 0);
     idleStart = hostCpus.reduce((total, cpu) => total + cpu.times.idle, 0);
-    child = Bun.spawn([executable, "-avd", name, "-port", String(port), "-no-window", "-no-snapshot", "-no-audio", "-no-boot-anim", "-gpu", "software", "-memory", String(memoryMb), "-cores", String(virtualCpus), "-accel", options.acceleration === "software" ? "off" : "on"], { env, stdout: log, stderr: log });
+    child = Bun.spawn([executable, "-avd", name, "-port", String(port), "-no-window", "-no-snapshot", "-no-audio", "-no-boot-anim", "-gpu", "software", "-memory", String(memoryMb), "-cores", String(virtualCpus), "-accel", options.acceleration === "software" ? "off" : "on"], { env, detached: true, stdout: log, stderr: log });
+    processes.add({ process: child, graceMs: 1e4 });
+    if (options.signal?.aborted)
+      onAbort();
     identity = {
       image: options.image,
       acceleration: options.acceleration,
@@ -323,6 +470,7 @@ async function createAndroidEmulator(options) {
     let connected = false;
     let lastReconnectAt = 0;
     while (Date.now() < deadline && child.exitCode === null) {
+      options.signal?.throwIfAborted();
       let booted = false;
       const connection = await run([adb, "devices"], undefined, probeTimeout(), true);
       const state = connection.stdout.split(/\r?\n/).find((line) => line.startsWith(`${serial}	`))?.split(/\s+/)[1];
@@ -352,14 +500,18 @@ async function createAndroidEmulator(options) {
       const checkedAt = Date.now();
       if (booted && checkedAt <= deadline) {
         await recordBootResult("booted", checkedAt);
-        return { serial, adb, env, dispose };
+        options.signal?.throwIfAborted();
+        return { serial, adb, env, dispose, closed };
       }
-      await Bun.sleep(Math.min(2000, Math.max(0, deadline - Date.now())));
+      await delay(Math.min(2000, Math.max(0, deadline - Date.now())), undefined, { signal: options.signal });
     }
+    options.signal?.throwIfAborted();
     if (child.exitCode !== null)
       throw new Error(`The owned Android emulator exited with code ${child.exitCode} before boot; inspect ${join2(artifacts, "emulator.log")}`);
     throw new Error(`The owned Android emulator did not boot within ${bootTimeoutMs}ms; inspect ${artifacts}`);
   } catch (error) {
+    const timerAborted = options.signal?.aborted && error instanceof Error && error.name === "AbortError" && error.cause === options.signal.reason;
+    const failure = timerAborted ? options.signal.reason : options.signal?.aborted && error !== options.signal.reason ? new AggregateError([options.signal.reason, error], `Android emulator setup failed: ${String(options.signal.reason)}`) : error;
     if (child) {
       try {
         await recordBootResult("failed");
@@ -375,9 +527,9 @@ async function createAndroidEmulator(options) {
     try {
       await dispose();
     } catch (cleanup) {
-      throw new AggregateError([error, cleanup], "Android emulator setup and cleanup failed");
+      throw new AggregateError([failure, cleanup], "Android emulator setup and cleanup failed");
     }
-    throw error;
+    throw failure;
   }
 }
 

package/dist/cli.js

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

package/dist/index.cjs

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

package/dist/index.js

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

package/dist/macos/src/index.js

@@ -43,7 +43,7 @@ import process from "process";
 var macosToolchain = {
   zig: "0.18.0-dev.252+86dc5ce25",
   sources: {
-    "zig-js": { repository: "zig-utils/zig-js", revision: "fef92e7f6c5e110102df15e73bbea4a6be7493b5", paths: ["src", "include", "tests", "tools", "docs", "bench", "conformance"] },
+    "zig-js": { repository: "zig-utils/zig-js", revision: "a6739721273ae0f13d36fb3422052a588c5079a8", paths: ["src", "include", "tests", "tools", "docs", "bench", "conformance"] },
     "zig-regex": { repository: "zig-utils/zig-regex", revision: "fdd9c2e333ea6ac2fd06d080d939ef7f11d61b1b", paths: ["src"] },
     "zig-gc": { repository: "zig-utils/zig-gc", revision: "0285ef801dd221a4ae8e88b31a09ae31627657a3", paths: ["src"] }
   }

package/dist/macos/src/toolchain.d.ts

@@ -9,7 +9,7 @@ export declare const macosToolchain: {
     readonly sources: {
         readonly 'zig-js': {
             readonly repository: 'zig-utils/zig-js';
-            readonly revision: 'fef92e7f6c5e110102df15e73bbea4a6be7493b5';
+            readonly revision: 'a6739721273ae0f13d36fb3422052a588c5079a8';
             readonly paths: readonly ['src', 'include', 'tests', 'tools', 'docs', 'bench', 'conformance'];
         };
         readonly 'zig-regex': {

package/dist/macos/templates/CraftMacRenderer.swift

@@ -277,6 +277,18 @@ final class CraftMacBox: NSView, NSTextFieldDelegate, NSTextViewDelegate, NSDrag
     var lastDropPosition = ""
     var acceptsDrops = false
     var wantedFocus = false
+    /// Measurements are pure in a box's subtree (its style, props, text and children) and the size
+    /// offered, but a flex pass asks for the same ones over and over: a column measures its children
+    /// twice, a row measures them again at their final widths, and each child's own layout measures its
+    /// subtree once more. Unremembered, that repeats exponentially with nesting depth (a browser window
+    /// spent most of its first render here). Every change to a box (its style, props, text, visibility
+    /// or children) arrives through `render`, which starts a new generation and so forgets every measurement.
+    static var measureGeneration = 0
+    /// Measurements computed rather than remembered; the layout checks hold it to the size of the tree.
+    static var measuredCount = 0
+    private struct MeasureKey: Hashable { let width: CGFloat, stretch: Bool }
+    private var measured: [MeasureKey: CGSize] = [:]
+    private var measuredGeneration = -1
     var componentRoot: CraftMacBox? { props["data-stx-component-wrapper"] != nil && flow?.boxes.count == 1 && flow?.boxes.first?.kind != "Modal" ? flow?.boxes.first : nil }
     var layoutStyle: [String: Any] {
         guard let child = componentRoot else { return style }
@@ -705,6 +717,15 @@ final class CraftMacBox: NSView, NSTextFieldDelegate, NSTextViewDelegate, NSDrag
         return NSEdgeInsets(top: number(style["paddingTop"]) ?? vertical, left: number(style["paddingLeft"]) ?? horizontal, bottom: number(style["paddingBottom"]) ?? vertical, right: number(style["paddingRight"]) ?? horizontal)
     }
     func measure(width: CGFloat, stretch: Bool = false) -> CGSize {
+        if measuredGeneration != CraftMacBox.measureGeneration || measured.count > 64 { measured.removeAll(keepingCapacity: true); measuredGeneration = CraftMacBox.measureGeneration }
+        let key = MeasureKey(width: width, stretch: stretch)
+        if let size = measured[key] { return size }
+        let size = measureSubtree(width: width, stretch: stretch)
+        measured[key] = size
+        return size
+    }
+    private func measureSubtree(width: CGFloat, stretch: Bool) -> CGSize {
+        CraftMacBox.measuredCount &+= 1
         if isHidden { return .zero }
         if let child = componentRoot { return child.measure(width: width, stretch: stretch) }
         let specifiedWidth = dimension(style["width"], base: width)
@@ -966,6 +987,8 @@ final class CraftMacRenderer {
             return box
         }
         let box = reconcile(document)
+        // Boxes were reconfigured and children replaced: nothing measured before now holds.
+        CraftMacBox.measureGeneration &+= 1
         for (id, box) in boxes where !retained.contains(id) {
             box.imageTask?.cancel(); box.removeFromSuperview(); boxes.removeValue(forKey: id)
             if let sheet = sheets.removeValue(forKey: id) { window?.endSheet(sheet); sheet.close() }

package/dist/macos/templates/CraftMacWebView.swift

@@ -334,11 +334,20 @@ final class CraftMacContentRules {
 /// an isolated world the page's scripts cannot see; `world: 'page'` runs one in the page's own world,
 /// for a script that must wrap the page's `fetch` before the site does. CSS lands at document start,
 /// JS at document end unless `at: 'start'`.
-final class CraftMacUserScripts {
+final class CraftMacUserScripts: NSObject, WKScriptMessageHandlerWithReply {
     static let shared = CraftMacUserScripts()
     private var scripts: [WKUserScript] = []
+    /// Message handlers the scripts post to (`bridge`), each in its script's content world.
+    private var bridges: [(name: String, world: WKContentWorld)] = []
 
     func set(_ entries: [[String: Any]]) {
+        var named: [(name: String, world: WKContentWorld)] = []
+        for entry in entries {
+            guard let name = entry["bridge"] as? String, !name.isEmpty else { continue }
+            let world: WKContentWorld = entry["world"] as? String == "page" ? .page : .defaultClient
+            if !named.contains(where: { $0.name == name && $0.world == world }) { named.append((name, world)) }
+        }
+        bridges = named
         scripts = entries.flatMap { entry -> [WKUserScript] in
             let hosts = (entry["hosts"] as? [String] ?? []).map { $0.lowercased() }.filter { !$0.isEmpty }
             let everySite = hosts.isEmpty || hosts.contains("*")
@@ -365,6 +374,25 @@ final class CraftMacUserScripts {
     func apply(to controller: WKUserContentController) {
         controller.removeAllUserScripts()
         scripts.forEach(controller.addUserScript)
+        controller.removeAllScriptMessageHandlers()
+        for bridge in bridges { controller.addScriptMessageHandler(self, contentWorld: bridge.world, name: bridge.name) }
+    }
+
+    /// A bridged script posted to its handler (`webkit.messageHandlers[name].postMessage(body)`).
+    /// The tab's screen answers with `answerBridge`; the script's promise resolves to that answer,
+    /// or rejects with its error. A tab no screen hears, or one that does not answer within 30
+    /// seconds, is answered with an error, so the page never waits forever.
+    func userContentController(_ controller: WKUserContentController, didReceive message: WKScriptMessage, replyHandler: @escaping (Any?, String?) -> Void) {
+        guard let tab = CraftMacWebTabs.shared.tabs.values.first(where: { $0.view === message.webView }), tab.owner != nil else {
+            replyHandler(nil, "No screen is listening to this tab"); return
+        }
+        // A body WebKit can carry but JSON cannot (a Date) never reaches the screen.
+        guard JSONSerialization.isValidJSONObject(["body": message.body]) else { replyHandler(nil, "The message is not JSON"); return }
+        let request = CraftMacWebTabs.shared.awaitBridge(tab: tab, reply: replyHandler)
+        tab.emit("bridge", [
+            "request": request, "handler": message.name, "body": message.body,
+            "url": message.frameInfo.request.url?.absoluteString ?? "", "mainFrame": message.frameInfo.isMainFrame,
+        ])
     }
 }
 
@@ -478,8 +506,24 @@ final class CraftMacWebTabs {
         waiting.decide(decision); return true
     }
 
+    /// Bridge messages waiting for the screen, by request id.
+    private var bridgeReplies: [String: (tab: String, reply: (Any?, String?) -> Void)] = [:]
+    func awaitBridge(tab: CraftMacTab, reply: @escaping (Any?, String?) -> Void) -> String {
+        let request = UUID().uuidString
+        bridgeReplies[request] = (tab.id, reply)
+        DispatchQueue.main.asyncAfter(deadline: .now() + 30) { [weak self] in self?.answerBridge(request, nil, error: "The app did not answer") }
+        return request
+    }
+    @discardableResult
+    func answerBridge(_ request: String, _ value: Any?, error: String?) -> Bool {
+        guard let waiting = bridgeReplies.removeValue(forKey: request) else { return false }
+        // JSON's null crosses as NSNull, which a reply carries as the page's `null`.
+        waiting.reply(error == nil ? (value is NSNull ? nil : value) : nil, error); return true
+    }
+
     func close(_ id: String) {
         for (request, waiting) in pending where waiting.tab == id { answer(request, .deny) }
+        for (request, waiting) in bridgeReplies where waiting.tab == id { answerBridge(request, nil, error: "The tab closed") }
         tabs.removeValue(forKey: id)?.close()
     }
 
@@ -568,6 +612,10 @@ final class CraftMacWebTabs {
         case "answerPermission":
             let decision: WKPermissionDecision = { switch args.dropFirst().first as? String { case "grant": return .grant; case "prompt": return .prompt; default: return .deny } }()
             answer(self.answer(args.first as? String ?? "", decision)); return
+        case "answerBridge":
+            // [request, value] answers; [request, null, error] rejects the page's promise with `error`.
+            let error = args.dropFirst(2).first as? String
+            answer(answerBridge(args.first as? String ?? "", args.dropFirst().first, error: error)); return
         case "clearData": clearData(options, answer: answer); return
         case "setCookies": setCookies(options, answer: answer); return
         case "cancelDownload": answer(CraftMacDownloads.shared.cancel(args.first as? String ?? "")); return

package/package.json

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