@haiyue/native 0.1.0

package/bridge/rewards/controller.ts

@@ -0,0 +1,163 @@
+/** SDK-independent daily allowances and durable, idempotent rewarded credits.
+ * One controller per namespaced storage key. Never share a key between games. */
+export type RewardPhase = 'ready' | 'loading' | 'earned' | 'cancelled' | 'unavailable' | 'offline' | 'error' | 'limit';
+export interface RewardSnapshot {
+  unlimited: boolean; free: number; credits: number; adsRemaining: number;
+  busy: boolean; phase: RewardPhase; privacyRequired: boolean;
+  initializing: boolean; presenting: boolean; operation: 'ad' | 'privacy' | 'consent' | null;
+}
+export interface RewardPresentation { prepare(): Promise<boolean>; closed(): void; }
+export interface RewardGateway {
+  initialize?(presentForm: boolean, beforePresent: () => Promise<boolean>): Promise<void>;
+  show(earned: () => void, presentation: RewardPresentation): Promise<void>;
+  privacy(presentation: RewardPresentation): Promise<void>;
+  privacyRequired(): boolean;
+  dispose(): void;
+}
+export interface RewardStorage { read(): string | null; write(value: string): void; }
+interface Wallet { version: 1; day: string; used: number; ads: number; credits: number; sequence: number; rewarded: number; hints: string[]; }
+export class RewardController {
+  private wallet!: Wallet;
+  private phase: RewardPhase = 'ready';
+  private busy = false;
+  private disposed = false;
+  private broken = false;
+  private listeners = new Set<() => void>();
+  private initialization?: Promise<void>;
+  private initializing: boolean;
+  private presenting = false;
+  private operation: RewardSnapshot['operation'] = null;
+  constructor(private readonly options: {
+    storage: RewardStorage; gateway: RewardGateway; entitled: () => boolean;
+    dailyFree: number; dailyAds: number; pause: () => (() => void) | Promise<() => void>; now?: () => Date;
+  }) {
+    this.initializing = !!options.gateway.initialize;
+    if (![options.dailyFree, options.dailyAds].every(n => Number.isSafeInteger(n) && n >= 0)) throw Error('Invalid daily allowance');
+    try {
+      const raw = options.storage.read();
+      const data = raw === null ? this.empty() : JSON.parse(raw);
+      if (data.version !== 1 || !/^\d{4}-\d{2}-\d{2}$/.test(data.day) ||
+        !['used','ads','credits','sequence','rewarded'].every(k => Number.isSafeInteger(data[k]) && data[k] >= 0) ||
+        data.rewarded > data.sequence || !Array.isArray(data.hints) || !data.hints.every((k: unknown) => typeof k === 'string')) throw Error('Invalid wallet');
+      this.wallet = data;
+      this.rollover();
+    } catch { this.broken = true; this.phase = 'error'; this.wallet ??= this.empty(); }
+  }
+  private day(): string {
+    const date = this.options.now?.() ?? new Date();
+    return `${date.getFullYear()}-${String(date.getMonth()+1).padStart(2,'0')}-${String(date.getDate()).padStart(2,'0')}`;
+  }
+  private empty(): Wallet { return { version:1, day:this.day(), used:0, ads:0, credits:0, sequence:0, rewarded:0, hints:[] }; }
+  private save(next: Wallet): boolean {
+    try { this.options.storage.write(JSON.stringify(next)); this.wallet = next; return true; }
+    catch { this.broken = true; this.phase = 'error'; return false; }
+  }
+  private rollover(): void {
+    const day = this.day();
+    // Moving the clock backwards cannot refill an already used day.
+    if (!this.broken && day > this.wallet.day && this.save({ ...this.wallet, day, used:0, ads:0, hints:[] }) && !this.busy) this.phase = 'ready';
+  }
+  snapshot(): RewardSnapshot {
+    this.rollover();
+    return { unlimited:this.options.entitled(), free:this.broken ? 0 : Math.max(0,this.options.dailyFree-this.wallet.used),
+      credits:this.broken ? 0 : this.wallet.credits, adsRemaining:this.broken ? 0 : Math.max(0,this.options.dailyAds-this.wallet.ads),
+      busy:this.busy, phase:this.phase, privacyRequired:this.options.gateway.privacyRequired(),
+      initializing:this.initializing, presenting:this.presenting, operation:this.operation };
+  }
+  subscribe(listener: () => void): () => void { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; }
+  refresh(): void { this.rollover(); this.emit(); }
+  /** Startup failure must leave normal play and the wallet intact. */
+  initialize(): Promise<void> {
+    if (this.disposed || !this.options.gateway.initialize) return Promise.resolve();
+    return this.initialization ??= this.initializeConsent();
+  }
+  private async initializeConsent(): Promise<void> {
+    if (this.busy) { this.initializing = false; this.emit(); return; }
+    let presenting = false;
+    let resume = () => {};
+    try {
+      await this.options.gateway.initialize!(!this.options.entitled(), async () => {
+        // A silent network refresh must not stop calendar, paywall or puzzle input.
+        // Explicit ad/privacy work takes precedence and will collect consent itself.
+        if (this.disposed || this.busy || this.options.entitled()) return false;
+        presenting = true; this.busy = true; this.operation = 'consent'; this.presenting = true; this.emit();
+        const pause = this.options.pause();
+        resume = typeof pause === 'function' ? pause : await pause;
+        return !this.disposed;
+      });
+    } catch { /* Retry through the next explicit ad/privacy request. */ }
+    finally {
+      this.initializing = false;
+      if (presenting) { this.busy = false; this.presenting = false; this.operation = null; resume(); }
+      this.emit();
+    }
+  }
+  private presentation(): { hooks: RewardPresentation; release(): void } {
+    let active = true, resume: (() => void) | undefined;
+    let preparing: Promise<boolean> | undefined;
+    const close = () => {
+      preparing = undefined;
+      this.presenting = false;
+      const release = resume; resume = undefined; release?.(); this.emit();
+    };
+    return {
+      hooks: {
+        prepare: () => preparing ??= (async () => {
+          if (!active || this.disposed) return false;
+          this.presenting = true; this.emit();
+          const release = await this.options.pause();
+          if (!active || this.disposed) { release(); return false; }
+          resume = release; return true;
+        })(),
+        closed: close,
+      },
+      release: () => { active = false; close(); },
+    };
+  }
+  private emit(): void { if (!this.disposed) for (const listener of this.listeners) listener(); }
+  /** Call only once a useful result is ready. The same result key is free to redisplay. */
+  consume(key: string): boolean {
+    if (this.disposed || !key) return false;
+    if (this.options.entitled()) return true;
+    const state = this.snapshot();
+    if (this.broken || this.busy) return false;
+    if (this.wallet.hints.includes(key)) return true;
+    if (!state.free && !state.credits) return false;
+    const ok = this.save({ ...this.wallet, used:this.wallet.used + (state.free ? 1 : 0), credits:this.wallet.credits - (state.free ? 0 : 1), hints:[...this.wallet.hints, key] });
+    this.emit(); return ok;
+  }
+  async watch(): Promise<void> {
+    if (this.disposed || this.busy || this.options.entitled() || this.broken) return;
+    if (!this.snapshot().adsRemaining) { this.phase = 'limit'; this.emit(); return; }
+    const sequence = this.wallet.sequence + 1;
+    if (!this.save({ ...this.wallet, sequence })) { this.emit(); return; }
+    this.busy = true; this.operation = 'ad'; this.phase = 'loading'; this.emit();
+    const presentation = this.presentation();
+    let earned = false, ended = false;
+    try {
+      if (this.disposed) return;
+      await this.options.gateway.show(() => {
+        // Google-earned events precede dismissal. Stale/duplicate callbacks never mint credits.
+        if (ended || earned || this.wallet.rewarded >= sequence) return;
+        this.rollover();
+        earned = this.save({ ...this.wallet, rewarded:sequence, credits:this.wallet.credits+1, ads:this.wallet.ads+1 });
+        this.phase = earned ? 'earned' : 'error'; this.emit();
+      }, presentation.hooks);
+      if (!this.broken) this.phase = earned ? 'earned' : 'cancelled';
+    } catch (error) {
+      if (!earned && !this.broken) this.phase = error instanceof Error && ['offline','unavailable'].includes(error.message) ? error.message as RewardPhase : 'error';
+    } finally { ended = true; this.busy = false; this.operation = null; presentation.release(); this.emit(); }
+  }
+  async privacy(): Promise<void> {
+    if (this.disposed || this.busy) return;
+    this.busy = true; this.operation = 'privacy'; this.phase = 'loading'; this.emit();
+    const presentation = this.presentation();
+    try {
+      if (this.disposed) return;
+      await this.options.gateway.privacy(presentation.hooks); this.phase = 'ready';
+    }
+    catch { this.phase = 'error'; }
+    finally { this.busy = false; this.operation = null; presentation.release(); this.emit(); }
+  }
+  dispose(): void { this.disposed = true; this.listeners.clear(); this.options.gateway.dispose(); }
+}

package/bridge/rewards/native/android/org/haiyue/rewards/HYRewardedAds.java

@@ -0,0 +1,116 @@
+package org.haiyue.rewards;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import com.google.android.gms.ads.*;
+import com.google.android.gms.ads.rewarded.*;
+import com.google.ads.mediation.admob.AdMobAdapter;
+import com.google.android.ump.*;
+
+/** Reusable AdMob adapter. No mediation: Google's reward callback precedes dismissal. */
+public final class HYRewardedAds {
+    public interface Events { void onEvent(String event); }
+    private final Handler handler = new Handler(Looper.getMainLooper());
+    private ConsentInformation consent;
+    private Events events;
+    private RewardedAd ad;
+    private boolean busy, disposed, loading;
+    private int generation;
+    public boolean privacyRequired(android.content.Context context) {
+        consent = UserMessagingPlatform.getConsentInformation(context);
+        return consent != null && consent.getPrivacyOptionsRequirementStatus() == ConsentInformation.PrivacyOptionsRequirementStatus.REQUIRED;
+    }
+    private Runnable pendingPresentation;
+    private boolean active(int token) { return !disposed && busy && token == generation; }
+    private void emit(String value) { if (events != null) events.onEvent(value); }
+    private void end(String value) {
+        loading = false; busy = false; ++generation; pendingPresentation = null;
+        Events callback = events; events = null; ad = null;
+        if (callback != null) callback.onEvent(value);
+    }
+    private void deadline(int token, long milliseconds) {
+        loading = true;
+        handler.postDelayed(() -> { if (loading && token == generation) end("error:unavailable"); }, milliseconds);
+    }
+    private void preparePresentation(Activity activity, int token, Runnable show) {
+        if (!active(token) || activity.isFinishing() || activity.isDestroyed()) { end("error:unavailable"); return; }
+        loading = false;
+        pendingPresentation = () -> {
+            if (!active(token) || activity.isFinishing() || activity.isDestroyed()) { end("error:unavailable"); return; }
+            show.run();
+        };
+        emit("presenting");
+    }
+    public void continuePresentation(boolean ready) {
+        handler.post(() -> {
+            Runnable show = pendingPresentation; pendingPresentation = null;
+            if (show == null) return;
+            if (!ready || disposed) { end("error:unavailable"); return; }
+            show.run();
+        });
+    }
+    public void perform(Activity activity, String action, String unit, Events callback) {
+        activity.runOnUiThread(() -> {
+            if (disposed || busy || activity.isFinishing() || activity.isDestroyed()) { callback.onEvent("error:unavailable"); return; }
+            busy = true; events = callback; final int token = ++generation;
+            consent = UserMessagingPlatform.getConsentInformation(activity);
+            deadline(token, 20000);
+            consent.requestConsentInfoUpdate(activity, new ConsentRequestParameters.Builder().build(), () -> {
+                if (!active(token)) return;
+                if (action.equals("privacy")) {
+                    if (!privacyRequired(activity)) { end("closed"); return; }
+                    preparePresentation(activity, token, () -> UserMessagingPlatform.showPrivacyOptionsForm(activity,
+                        error -> { if (token == generation) end(error == null ? "closed" : "error:unavailable"); }));
+                } else if (consent.getConsentStatus() == ConsentInformation.ConsentStatus.REQUIRED) {
+                    UserMessagingPlatform.loadConsentForm(activity, form -> {
+                        if (!active(token)) return;
+                        preparePresentation(activity, token, () -> form.show(activity, error -> {
+                            if (token != generation) return;
+                            emit("presentation-closed");
+                            if (error != null || disposed || !consent.canRequestAds()) { end("error:unavailable"); return; }
+                            initialize(activity, unit, token);
+                        }));
+                    }, error -> { if (active(token)) end("error:unavailable"); });
+                } else if (consent.canRequestAds()) initialize(activity, unit, token);
+                else end("error:unavailable");
+            }, error -> {
+                if (!active(token)) return;
+                if (!action.equals("privacy") && consent.canRequestAds()) initialize(activity, unit, token);
+                else end("error:unavailable");
+            });
+        });
+    }
+    private void initialize(Activity activity, String unit, int token) {
+        if (!active(token)) return;
+        // New phase invalidates the consent deadline without invalidating callbacks.
+        loading = false;
+        final int adToken = ++generation;
+        deadline(adToken, 45000);
+        MobileAds.initialize(activity.getApplicationContext(), status -> handler.post(() -> {
+            if (!active(adToken)) return;
+            Bundle extras = new Bundle(); extras.putString("npa", "1");
+            AdRequest request = new AdRequest.Builder().addNetworkExtrasBundle(AdMobAdapter.class, extras).build();
+            RewardedAd.load(activity, unit, request, new RewardedAdLoadCallback() {
+                @Override public void onAdFailedToLoad(LoadAdError error) {
+                    if (active(adToken)) end(error.getCode() == AdRequest.ERROR_CODE_NETWORK_ERROR ? "error:offline" : "error:unavailable");
+                }
+                @Override public void onAdLoaded(RewardedAd loaded) {
+                    if (!active(adToken)) return;
+                    ad = loaded;
+                    ad.setFullScreenContentCallback(new FullScreenContentCallback() {
+                        @Override public void onAdDismissedFullScreenContent() { if (adToken == generation) end("closed"); }
+                        @Override public void onAdFailedToShowFullScreenContent(AdError error) { if (adToken == generation) end("error:unavailable"); }
+                    });
+                    preparePresentation(activity, adToken, () -> ad.show(activity, reward -> { if (adToken == generation) emit("earned"); }));
+                }
+            });
+        }));
+    }
+    public void dispose() {
+        disposed = true;
+        // Keep earned/dismiss callbacks alive if an ad is already on screen.
+        if (loading || pendingPresentation != null) end("error:unavailable");
+    }
+}

package/bridge/rewards/native/ios/HYRewardedAds.swift

@@ -0,0 +1,169 @@
+import UIKit
+import GoogleMobileAds
+import UserMessagingPlatform
+
+@MainActor @objc(HYRewardedAds) public final class HYRewardedAds: NSObject, FullScreenContentDelegate {
+    private var events: ((String) -> Void)?
+    private var ad: RewardedAd?
+    private var disposed = false
+    private var generation = 0
+    private var timeout: Task<Void, Never>?
+    private var presentation: CheckedContinuation<Bool, Never>?
+    private var startedAt = ProcessInfo.processInfo.systemUptime
+    @objc public var privacyRequired: Bool { ConsentInformation.shared.privacyOptionsRequirementStatus == .required }
+    @objc public var consentRequired: Bool { ConsentInformation.shared.consentStatus == .required }
+    private var development: Bool { Bundle.main.object(forInfoDictionaryKey: "HYBuildConfiguration") as? String == "Debug" }
+    private func log(_ text: String) { if development { NSLog("[haiyue-consent] %@", text) } }
+    private var simulator: Bool {
+        #if targetEnvironment(simulator)
+        return true
+        #else
+        return false
+        #endif
+    }
+    private func logState(_ stage: String) {
+        guard development else { return }
+        let info = ConsentInformation.shared
+        let elapsed = Int((ProcessInfo.processInfo.systemUptime - startedAt) * 1000)
+        log("\(stage) elapsedMs=\(elapsed) consent=\(info.consentStatus) status=\(info.consentStatus.rawValue) form=\(info.formStatus) formStatus=\(info.formStatus.rawValue) privacyStatus=\(info.privacyOptionsRequirementStatus.rawValue) canRequestAds=\(info.canRequestAds) appState=\(UIApplication.shared.applicationState.rawValue)")
+    }
+    private func logError(_ stage: String, _ error: Error) {
+        guard development else { return }
+        let failure = error as NSError
+        // Do not dump userInfo, consent strings, identifiers or network payloads.
+        log("\(stage) domain=\(failure.domain) code=\(failure.code) description=\(failure.localizedDescription)")
+        if let underlying = failure.userInfo[NSUnderlyingErrorKey] as? NSError {
+            log("\(stage) underlyingDomain=\(underlying.domain) underlyingCode=\(underlying.code) description=\(underlying.localizedDescription)")
+        }
+        logState("\(stage) state")
+    }
+    private func root() -> UIViewController? {
+        let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+        var controller = scenes.flatMap { $0.windows }.first { $0.isKeyWindow }?.rootViewController
+        while let presented = controller?.presentedViewController { controller = presented }
+        return controller
+    }
+    private func active(_ token: Int) -> Bool { !disposed && events != nil && token == generation }
+    private func end(_ event: String) {
+        logState("end event=\(event)")
+        timeout?.cancel(); timeout = nil; generation += 1
+        let pending = presentation; presentation = nil; pending?.resume(returning: false)
+        let callback = events; events = nil; ad = nil; callback?(event)
+    }
+    @objc public func continuePresentation(_ ready: Bool) {
+        let pending = presentation; presentation = nil
+        pending?.resume(returning: ready && !disposed && UIApplication.shared.applicationState == .active)
+    }
+    private func preparePresentation(_ token: Int) async -> Bool {
+        guard active(token) else { return false }
+        return await withCheckedContinuation { continuation in
+            presentation = continuation
+            events?("presenting")
+        }
+    }
+    private func deadline(_ seconds: UInt64, token: Int) {
+        timeout?.cancel()
+        timeout = Task { @MainActor [weak self] in
+            do { try await Task.sleep(nanoseconds: seconds * 1_000_000_000) } catch { return }
+            guard let self, self.active(token) else { return }
+            self.log("network timeout"); self.end("error:unavailable")
+        }
+    }
+    private func parameters() -> RequestParameters {
+        let parameters = RequestParameters()
+        // Explicit device-scoped diagnostics only; never applied in a Release binary.
+        let device = ProcessInfo.processInfo.environment["HY_UMP_TEST_DEVICE_ID"] ?? ""
+        if development && (simulator || !device.isEmpty) {
+            let debug = DebugSettings()
+            debug.testDeviceIdentifiers = device.isEmpty ? [] : [device]
+            if ProcessInfo.processInfo.environment["HY_UMP_EEA"] == "1" { debug.geography = .EEA }
+            parameters.debugSettings = debug
+        }
+        log("parameters simulator=\(simulator) registeredTestDeviceCount=\(parameters.debugSettings?.testDeviceIdentifiers?.count ?? 0) geography=\(parameters.debugSettings?.geography.rawValue ?? 0) underAge=\(parameters.isTaggedForUnderAgeOfConsent)")
+        return parameters
+    }
+    @objc(perform:unit:events:) public func perform(_ action: String, unit: String, events callback: @escaping (String) -> Void) {
+        guard !disposed, events == nil, let controller = root() else { callback("error:unavailable"); return }
+        guard ["consent", "refreshPrivacy", "presentConsent", "privacy", "show"].contains(action) else { callback("error:unavailable"); return }
+        events = callback; generation += 1
+        startedAt = ProcessInfo.processInfo.systemUptime
+        let token = generation
+        if development && ["consent", "refreshPrivacy"].contains(action) && ProcessInfo.processInfo.environment["HY_UMP_RESET"] == "1" {
+            ConsentInformation.shared.reset()
+            log("reset test consent")
+        }
+        Task { @MainActor in
+            let appID = Bundle.main.object(forInfoDictionaryKey: "GADApplicationIdentifier") as? String ?? "missing"
+            let adsVersion = MobileAds.shared.versionNumber
+            log("begin \(action) bundle=\(Bundle.main.bundleIdentifier ?? "missing") appID=\(appID) ump=\(UserMessagingPlatform.Version) gma=\(adsVersion.majorVersion).\(adsVersion.minorVersion).\(adsVersion.patchVersion) simulator=\(simulator)")
+            logState("before update")
+            // Startup already refreshed consent with input active. Do not repeat
+            // that network request after acquiring the form-presentation pause.
+            if action != "presentConsent" {
+                deadline(20, token: token)
+                do {
+                    try await ConsentInformation.shared.requestConsentInfoUpdate(with: parameters())
+                } catch {
+                    logError("update failed", error)
+                    guard active(token) else { return }
+                    // Only the ad path may fall back to a still-valid previous consent state.
+                    if action != "show" || !ConsentInformation.shared.canRequestAds { end("error:unavailable"); return }
+                }
+            }
+            guard active(token) else { return }
+            timeout?.cancel(); timeout = nil
+            logState("updated")
+            if action == "refreshPrivacy" { end("closed"); return }
+            guard UIApplication.shared.applicationState == .active else { end("error:unavailable"); return }
+            do {
+                // No timeout while a user is reading or interacting with the consent form.
+                if action == "privacy" {
+                    guard privacyRequired else { end("closed"); return }
+                    guard await preparePresentation(token), active(token) else { if active(token) { end("error:unavailable") }; return }
+                    try await ConsentForm.presentPrivacyOptionsForm(from: controller)
+                    events?("presentation-closed")
+                } else if consentRequired {
+                    // Load while the game's loading indicator is still animating.
+                    deadline(20, token: token)
+                    let form = try await ConsentForm.load()
+                    guard active(token) else { return }
+                    timeout?.cancel(); timeout = nil
+                    guard await preparePresentation(token), active(token) else { if active(token) { end("error:unavailable") }; return }
+                    try await form.present(from: controller)
+                    events?("presentation-closed")
+                }
+            } catch {
+                logError("form failed", error)
+                guard active(token) else { return }
+                end("error:unavailable"); return
+            }
+            guard active(token) else { return }
+            logState("completed \(action)")
+            if action != "show" { end("closed"); return }
+            guard ConsentInformation.shared.canRequestAds else { end("error:unavailable"); return }
+            deadline(45, token: token)
+            await MobileAds.shared.start()
+            guard active(token) else { return }
+            do {
+                let request = Request()
+                let extras = Extras(); extras.additionalParameters = ["npa": "1"]; request.register(extras)
+                let loaded = try await RewardedAd.load(with: unit, request: request)
+                guard active(token) else { return }
+                timeout?.cancel(); timeout = nil
+                ad = loaded; loaded.fullScreenContentDelegate = self
+                guard UIApplication.shared.applicationState == .active else { end("error:unavailable"); return }
+                guard await preparePresentation(token), active(token) else { if active(token) { end("error:unavailable") }; return }
+                loaded.present(from: controller) { [weak self] in
+                    guard let self, self.active(token) else { return }
+                    self.events?("earned")
+                }
+            } catch {
+                logError("ad failed", error)
+                if active(token) { end((error as NSError).code == 2 ? "error:offline" : "error:unavailable") }
+            }
+        }
+    }
+    public func adDidDismissFullScreenContent(_ ad: FullScreenPresentingAd) { end("closed") }
+    public func ad(_ ad: FullScreenPresentingAd, didFailToPresentFullScreenContentWithError error: Error) { end("error:unavailable") }
+    @objc public func dispose() { disposed = true; end("error:unavailable") }
+}

package/bridge/storage/clone-runtime.ts

@@ -0,0 +1,6 @@
+/** Supply the structured clone operation used by Engine's save service on older native runtimes. */
+export function installNativeSaveRuntime(clone: typeof structuredClone): void {
+  if (typeof globalThis.structuredClone !== 'function') {
+    Object.defineProperty(globalThis, 'structuredClone', { configurable: true, writable: true, value: clone });
+  }
+}

package/bridge/storage/settings-storage.ts

@@ -0,0 +1,12 @@
+import * as settings from '@nativescript/core/application-settings';
+/** Scoped persistent Storage port for Engine's injectable LocalStorageSaveBackend. */
+export class NativeSettingsStorage implements Storage {
+  constructor(private readonly prefix = 'haiyue-game:') {}
+  private keys(): string[] { return settings.getAllKeys().filter(key => key.startsWith(this.prefix)).sort(); }
+  get length(): number { return this.keys().length; }
+  key(index: number): string | null { return this.keys()[index]?.slice(this.prefix.length) ?? null; }
+  getItem(key: string): string | null { return settings.hasKey(this.prefix + key) ? settings.getString(this.prefix + key) : null; }
+  setItem(key: string, value: string): void { settings.setString(this.prefix + key, String(value)); settings.flush(); }
+  removeItem(key: string): void { settings.remove(this.prefix + key); settings.flush(); }
+  clear(): void { for (const key of this.keys()) settings.remove(key); settings.flush(); }
+}

package/index.ts

@@ -0,0 +1,17 @@
+export { NativeRenderHost, type NativeRenderHostOptions, type NativeHostInput } from './bridge/lifecycle/host';
+export { NativeSurface, NativeSurfaceUnavailableError, type NativeCanvasInput } from './bridge/render/surface';
+export { NativeTouchInput, type NativeTouchSample } from './bridge/input/native-touch';
+export { NativeDeviceMotion, type NativeDeviceMotionOptions, type NativeMotionSample, type MotionScreenRotation } from './bridge/motion/device-motion';
+export { NativeHaptics, type NativeImpact } from './bridge/feedback/haptics';
+export { NativePcmAudioBank, type NativePcmSound, type NativePcmPlay } from './bridge/audio/pcm-bank';
+export { NativeOrientationController } from './bridge/display/orientation';
+export { type OrientationPolicy } from './bridge/display/orientation-policy';
+export { NativeCanvasTextures } from './bridge/render/canvas-textures';
+export { NativeSettingsStorage } from './bridge/storage/settings-storage';
+export { installNativeSaveRuntime } from './bridge/storage/clone-runtime';
+export { readNativeBytes } from './bridge/files/read-bytes';
+export { savePhoto } from './bridge/media/save-photo';
+export { NativeEngineLaunchPage } from './bridge/branding/launch-page';
+export { NativeEngineSplash, type NativeEngineSplashOptions } from './bridge/branding/engine-splash';
+export { NativeDemandFrames } from './bridge/lifecycle/demand-frames';
+export { PresentationPause } from './bridge/lifecycle/presentation-pause';

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@haiyue/native",
+  "version": "0.1.0",
+  "description": "NativeScript iOS and Android adapters for Haiyue WebGPU rendering, input, motion, haptics and lifecycle",
+  "license": "MIT",
+  "type": "module",
+  "main": "index.ts",
+  "types": "index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./motion": {
+      "types": "./bridge/motion/device-motion.ts",
+      "default": "./bridge/motion/device-motion"
+    },
+    "./feedback": {
+      "types": "./bridge/feedback/haptics.ts",
+      "default": "./bridge/feedback/haptics"
+    },
+    "./audio": {
+      "types": "./bridge/audio/pcm-bank.ts",
+      "default": "./bridge/audio/pcm-bank"
+    },
+    "./orientation": {
+      "types": "./bridge/display/orientation.ts",
+      "default": "./bridge/display/orientation"
+    },
+    "./media": {
+      "types": "./bridge/media/save-photo.ts",
+      "default": "./bridge/media/save-photo"
+    },
+    "./branding": "./bridge/branding/launch-page.ts",
+    "./branding/webpack": "./bridge/branding/webpack.cjs",
+    "./rewards": "./bridge/rewards/controller.ts",
+    "./rewards/admob": "./bridge/rewards/admob.ts",
+    "./bridge/*": "./bridge/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.ts",
+    "bridge/**/*.ts",
+    "bridge/branding/webpack.cjs",
+    "bridge/branding/assets/haiyue-moon.png",
+    "bridge/rewards/native/",
+    "provenance.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HaiyueStudio/Native.git",
+    "directory": "npm"
+  },
+  "homepage": "https://github.com/HaiyueStudio/Native/tree/main/npm",
+  "bugs": {
+    "url": "https://github.com/HaiyueStudio/Native/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "peerDependencies": {
+    "@haiyue/engine": "0.1.0",
+    "@nativescript/canvas": "2.1.18",
+    "@nativescript/core": "9.1.1"
+  },
+  "devDependencies": {
+    "@nativescript/types": "9.0.0",
+    "@nativescript/webpack": "5.0.38",
+    "@webgpu/types": "0.1.64",
+    "typescript": "5.7.3"
+  },
+  "scripts": {
+    "build": "node pack.mjs",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test test/*.test.mjs"
+  },
+  "keywords": [
+    "webgpu",
+    "nativescript",
+    "ios",
+    "android",
+    "haiyue"
+  ]
+}

package/provenance.json

@@ -0,0 +1,66 @@
+{
+  "name": "@haiyue/native",
+  "version": "0.1.0",
+  "sourceTag": "native-v0.1.0",
+  "sourceCommit": "609d5669bee2a758e2beafffb87d01682232bb8f",
+  "manifestSha256": "f4fa432c6140b7d49ad05b49dceabf36dc3477c24242e628f3e41d814ef5e8a9",
+  "files": {
+    "bridge/audio/pcm-bank.android.ts": "7be6c930c68d3965bf8d5effffbb9aa7186e72e6141b6b1e69fcd4d35fe141dd",
+    "bridge/audio/pcm-bank.ios.ts": "c2fb941f0e3d65ca77f85e32b6cd07884fef77ac73b8d328eb5651aa9f40e829",
+    "bridge/audio/pcm-bank.ts": "9e3d10e8179e2c23cfec5e03f9dffd675aaea8dd34a986b56072fcac1913407d",
+    "bridge/branding/assets/haiyue-moon.png": "697577528fcc8585f9c452bb0579c077f8f0b8c3588e358864d5b21ead7b3f10",
+    "bridge/branding/engine-splash.ts": "8ddffedf5ad150886d926054b861e63f7d6dcd3ecaa6907cc20a1af61d628d54",
+    "bridge/branding/launch-page.ts": "fa530dd1b96dadbb7ab1aadd0667e407901aacd5f4dab44e159b49d3264af16e",
+    "bridge/branding/webpack.cjs": "5747a09607b5aac51b334cac28e1642d9c504e6ab982182c90ba203e940f841d",
+    "bridge/display/orientation-policy.ts": "6e876797b48e186bcab6b2b62d20ad015974c1af1ef982bfd8beaf8db5bad46e",
+    "bridge/display/orientation.android.ts": "f883b739001e0f13c11f84fac8f4ad4d74d200b63e57e85798ae6613d693882b",
+    "bridge/display/orientation.ios.ts": "f5f77f34b22f15f59f877eb5e958a416e4b5619242ecbc085ede2f03518b3f92",
+    "bridge/display/orientation.ts": "101805765d6019fdf8e92427b46f9d7c2c7358d58e85b1699d8d30f498e64f6b",
+    "bridge/feedback/haptics.android.ts": "662c2b687c8da0732b18a48c1ae70984fdd974255c497a83758f51c8946875cf",
+    "bridge/feedback/haptics.ios.ts": "90da0bb50ecae2f5827acf558fab182cec9a23026aabe707bbda29990ad6402a",
+    "bridge/feedback/haptics.ts": "66fe8338e9db018a9c7988624fac9521a6b6fdc57f9775fe6016fd01b2a053d6",
+    "bridge/files/read-bytes.ts": "44b1af3eb85eff39038ea3d44e86a05875b8c4b35269f0af6ab9334014696c03",
+    "bridge/input/native-touch.android.ts": "a64d6c0346bafc5e355393ac8da958baa0c6c9cbf3da96be392778ea7f6b9f4d",
+    "bridge/input/native-touch.ios.ts": "b9f4642773627e8b7a0a6fd53c69c10c016623f6497a2deba1a5e360d17f461a",
+    "bridge/input/native-touch.ts": "1ff46fd8e391e3ab08d665201e866f5810d3c6cc9228559a59465252684832f5",
+    "bridge/input/pointer-target.ts": "a0372f870e60bbf4167c37bbfe301407544cd62c699ec725f38af450c7d8aafa",
+    "bridge/input/touch-identity.ts": "98174d6df6e9e9b2d4c15004f3e741394acfe89546ac2bb5602abd7f7f8e56f5",
+    "bridge/lifecycle/demand-frames.ts": "dc0dabdeb91357c9596e2bd3998e5c4f1890056238bac9ca729ab22318115eeb",
+    "bridge/lifecycle/frame-performance.ts": "6051bd3ad1ea25accfcfc7ac740f0b56dab60557191e95c7f7e7d03fc7d4bcf1",
+    "bridge/lifecycle/frame-scheduler.ts": "24eba67e040495c7d11e37f6abf69339db089871391d175e1cacb09a6f646ff8",
+    "bridge/lifecycle/host.ts": "63694646aabd874fc4844e4661abac33b96829abfb603763fa2177e03562c90f",
+    "bridge/lifecycle/launch-flags.ts": "c271d26843b7f8fc2790358a9effe7f291839f6332dcb9d08355aa51e46ebe9a",
+    "bridge/lifecycle/presentation-pause.ts": "abf5c76a06f228eb3f811a53d5c5fcce716a83f1966f972b48d62dd5589d14ff",
+    "bridge/lifecycle/runtime.ts": "80fdf306f37ce725c34ea1f32a4efb270019d115d64664f452a2ceddce48e2d1",
+    "bridge/media/save-photo.android.ts": "774710166005503b3cdbbd82ccd2d8441f72eca8fff46cd030aa6b94b9949507",
+    "bridge/media/save-photo.ios.ts": "197bd8178509bc553ef359e9fa9ef333c20102af2cba6abd459631aa942ae334",
+    "bridge/media/save-photo.ts": "ed7ea4e23ac3028f5be8e6d866ac809a5ecc32d9f799329623d6457094faf479",
+    "bridge/motion/android-reading.ts": "b63543f70f9ab2b9e0fd33a9c5da0de8eeffffe19f6e046f04450e79a95b474d",
+    "bridge/motion/device-motion.android.ts": "81e2eee84f1a55c0166a2628ea1375a1e62c79593083cdf80474ddf05569ef09",
+    "bridge/motion/device-motion.ios.ts": "ff16f0e6d23a05e36d0a909d990d7507c0c0c6fadcf17df23d35d6ef44332d00",
+    "bridge/motion/device-motion.ts": "f2806d66f328e5b2a090ad8a49c50348f90c334efb873e4627c2845d9b9f9d37",
+    "bridge/motion/motion-sample.ts": "0308435ec6e2f3a0ebaa6ab7b63110fe7a9eed25e75b18b8873a719ed996339e",
+    "bridge/render/canvas-textures.ios.ts": "3bf00a5d2df470c5e658b7067b80c572160a915ef35e5421555c1cdfd066f695",
+    "bridge/render/canvas-textures.ts": "bf5723aef9abd87ef6335d8eb81bb9605d25f325edbc4512dfdf04bd65859e3b",
+    "bridge/render/device-descriptor.ts": "4c5afc4e61a778224f3e0db06573c6e0dfe86adc6fce7bf0f2a23f4a2991226f",
+    "bridge/render/frame-capture.android.ts": "1373a9494b6392d81f52f3da59e8e5246cc1f6049328e1beac8a7f175bfb2edd",
+    "bridge/render/frame-capture.ios.ts": "933bf4dca2a1797d2b95c5318d56a5e48c1fe68932998869ac833bcc75096825",
+    "bridge/render/frame-capture.ts": "c8656c56c5cbc982e5927067ea84344832ab0f2f1ca48c21628cda5bf02d8c57",
+    "bridge/render/queue-fence.android.ts": "a1100c6382c5875a6d2e7019838c0dc6dd2dd2a769d4920195d507e66a5735f5",
+    "bridge/render/queue-fence.ts": "2b29e9159e4a3f4b2610224e4f90c66c5c47d32ee2d283f1cd63baae50aed460",
+    "bridge/render/surface.ts": "4f7f06d3c00aa48b21bf4572d8d100487dc964f658ff85a16509339bed531adb",
+    "bridge/render/view-capture.android.ts": "44c0ac5a339d27b9e6b2f6f50c52f255fa442a16a0677c615c84b0e4a3b073de",
+    "bridge/render/view-capture.ios.ts": "1467288df2683ebbb09a3354f0b69862e7d7aa32ed09aeb4426144c2831fc8a8",
+    "bridge/render/view-capture.ts": "e757b53a2d9aa9813df4a10df5fecd084cba0b130dbd5571285451f055b83ef7",
+    "bridge/render/view-rect.android.ts": "314fa775526945e71ef9441ae073d9a5e24844bd686b50e23ab682dd582e35d9",
+    "bridge/render/view-rect.ios.ts": "ae1186afde51d4053e3e609feb64aba1da585984696dfa57e90a9aa821a6d7ed",
+    "bridge/render/view-rect.ts": "b92b7bb11c7cdd8395f51fe1a1b243e9147ab401788c16a7068f10e405332150",
+    "bridge/render/webgpu-constants.ts": "279bafa27ac5c7ddb320c2e14440e6db25f9cb6ca79ea3cf21fd2a49f5266426",
+    "bridge/rewards/admob.ts": "dbbc95ed922e71d33ff89afa6759252316c0f8caf64c1cad13ea55f2863d40ab",
+    "bridge/rewards/controller.ts": "2b28e742d2f10df0930145db765a561a47ba32a98bf97a8fd187bb4ad3dfa9d2",
+    "bridge/rewards/native/android/org/haiyue/rewards/HYRewardedAds.java": "d29fd1e0b30af7b1b3211fe84c8dba7763905cb8a47429a44bbbdd9f792f9dc3",
+    "bridge/rewards/native/ios/HYRewardedAds.swift": "4d081876cbc60c19321cf61df98ae83232969bd9d75c558e32764e57daf2c2a1",
+    "bridge/storage/clone-runtime.ts": "9bbd3693444c26473dac2b8060d107bd2bd54a455a91c163c391bfdc4dd66abb",
+    "bridge/storage/settings-storage.ts": "cdf89d04154304911553c3e0b21591a95d551b2f92a9926cb0ffba057e9b975a"
+  }
+}