typeferry 0.10.0 → 0.11.0

package/dist/native/index.d.ts

@@ -0,0 +1,76 @@
+import type { PluginListenerHandle } from '@capacitor/core';
+export interface NativeHTTPRequest {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+}
+export interface NativeHTTPResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+}
+export interface NativeAppState {
+    isActive: boolean;
+}
+/**
+ * Optional iOS bridge. Import only from native application entry points.
+ * Origins and callback schemes are pinned by generated native configuration;
+ * JavaScript cannot expand the native trust boundary.
+ */
+export interface TypeFerryNativePlugin {
+    request(options: NativeHTTPRequest): Promise<NativeHTTPResponse>;
+    getSession(): Promise<{
+        value: string | null;
+    }>;
+    setSession(options: {
+        value: string;
+    }): Promise<void>;
+    clearSession(): Promise<void>;
+    authenticate(options: {
+        url: string;
+        callbackScheme: string;
+    }): Promise<{
+        url: string;
+    }>;
+    acquireWakeLock(): Promise<{
+        id: string;
+    }>;
+    releaseWakeLock(options: {
+        id: string;
+    }): Promise<void>;
+    getState(): Promise<NativeAppState>;
+    addListener(eventName: 'appStateChange', listener: (state: NativeAppState) => void): Promise<PluginListenerHandle>;
+    beginFile(options: {
+        fileName: string;
+        size: number;
+    }): Promise<{
+        id: string;
+    }>;
+    appendFile(options: {
+        id: string;
+        offset: number;
+        base64: string;
+    }): Promise<void>;
+    finishFile(options: {
+        id: string;
+    }): Promise<{
+        completed: boolean;
+    }>;
+    cancelFile(options: {
+        id: string;
+    }): Promise<void>;
+    shareFile(options: {
+        url: string;
+        fileName: string;
+        headers?: Record<string, string>;
+    }): Promise<{
+        completed: boolean;
+    }>;
+}
+export declare const TypeFerryNative: TypeFerryNativePlugin;
+export { NATIVE_FILE_CHUNK_BYTES, NATIVE_FILE_MAX_BYTES, shareNativeFile } from './share-file.js';
+export type { ShareNativeFileOptions } from './share-file.js';
+export { acquireNativeWakeLock } from './wake-lock.js';
+export type { NativeWakeLock } from './wake-lock.js';

package/dist/native/index.js

@@ -0,0 +1,5 @@
+import { registerPlugin } from '@capacitor/core';
+export const TypeFerryNative = registerPlugin('TypeFerryNative');
+export { NATIVE_FILE_CHUNK_BYTES, NATIVE_FILE_MAX_BYTES, shareNativeFile } from './share-file.js';
+export { acquireNativeWakeLock } from './wake-lock.js';
+//# sourceMappingURL=index.js.map

package/dist/native/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/native/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AA2ChD,MAAM,CAAC,MAAM,eAAe,GAAG,cAAc,CAAwB,iBAAiB,CAAC,CAAA;AAEvF,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAG9F,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA"}

package/dist/native/share-file.d.ts

@@ -0,0 +1,18 @@
+export declare const NATIVE_FILE_MAX_BYTES: number;
+export declare const NATIVE_FILE_CHUNK_BYTES: number;
+export interface ShareNativeFileOptions {
+    signal?: AbortSignal;
+    /**
+     * Reports bytes staged on device; completion still requires the share sheet.
+     */
+    onProgress?: (bytes: number) => void;
+}
+/**
+ * Shares a local Blob without passing its entire contents over the native bridge.
+ * Native staging validates every offset and removes partial files after failure.
+ * Cancellation applies during staging; once presented, the system share sheet
+ * owns cancellation and returns completed=false when dismissed.
+ */
+export declare function shareNativeFile(file: Blob, fileName: string, options?: ShareNativeFileOptions): Promise<{
+    completed: boolean;
+}>;

package/dist/native/share-file.js

@@ -0,0 +1,41 @@
+import { TypeFerryNative } from './index.js';
+export const NATIVE_FILE_MAX_BYTES = 128 * 1024 * 1024;
+export const NATIVE_FILE_CHUNK_BYTES = 48 * 1024;
+const ENCODING_BLOCK_BYTES = 8192;
+function encode(bytes) {
+    const blocks = [];
+    for (let index = 0; index < bytes.length; index += ENCODING_BLOCK_BYTES) {
+        blocks.push(String.fromCharCode(...bytes.subarray(index, index + ENCODING_BLOCK_BYTES)));
+    }
+    return btoa(blocks.join(''));
+}
+/**
+ * Shares a local Blob without passing its entire contents over the native bridge.
+ * Native staging validates every offset and removes partial files after failure.
+ * Cancellation applies during staging; once presented, the system share sheet
+ * owns cancellation and returns completed=false when dismissed.
+ */
+export async function shareNativeFile(file, fileName, options = {}) {
+    if (!Number.isSafeInteger(file.size) || file.size < 0 || file.size > NATIVE_FILE_MAX_BYTES) {
+        throw new Error('Native file sharing supports files up to 128 MiB.');
+    }
+    options.signal?.throwIfAborted();
+    const { id } = await TypeFerryNative.beginFile({ fileName, size: file.size });
+    try {
+        for (let offset = 0; offset < file.size; offset += NATIVE_FILE_CHUNK_BYTES) {
+            options.signal?.throwIfAborted();
+            const bytes = new Uint8Array(await file.slice(offset, offset + NATIVE_FILE_CHUNK_BYTES).arrayBuffer());
+            options.signal?.throwIfAborted();
+            await TypeFerryNative.appendFile({ id, offset, base64: encode(bytes) });
+            options.onProgress?.(offset + bytes.length);
+        }
+        options.signal?.throwIfAborted();
+        return await TypeFerryNative.finishFile({ id });
+    }
+    catch (error) {
+        // Cleanup failure must not hide the original failure; native staging also expires.
+        await TypeFerryNative.cancelFile({ id }).catch(() => undefined);
+        throw error;
+    }
+}
+//# sourceMappingURL=share-file.js.map

package/dist/native/share-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"share-file.js","sourceRoot":"","sources":["../../src/native/share-file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAEzC,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,CAAA;AACtD,MAAM,CAAC,MAAM,uBAAuB,GAAG,EAAE,GAAG,IAAI,CAAA;AAChD,MAAM,oBAAoB,GAAG,IAAI,CAAA;AAUjC,SAAS,MAAM,CAAC,KAAiB;IAC/B,MAAM,MAAM,GAAa,EAAE,CAAA;IAE3B,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,IAAI,oBAAoB,EAAE,CAAC;QACxE,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAA;IAC1F,CAAC;IAED,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAA;AAC9B,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,IAAU,EAAE,QAAgB,EAAE,UAAkC,EAAE;IACtG,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,GAAG,CAAC,IAAI,IAAI,CAAC,IAAI,GAAG,qBAAqB,EAAE,CAAC;QAC3F,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAA;IACtE,CAAC;IAED,OAAO,CAAC,MAAM,EAAE,cAAc,EAAE,CAAA;IAEhC,MAAM,EAAE,EAAE,EAAE,GAAG,MAAM,eAAe,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAA;IAE7E,IAAI,CAAC;QACH,KAAK,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC,IAAI,EAAE,MAAM,IAAI,uBAAuB,EAAE,CAAC;YAC3E,OAAO,CAAC,MAAM,EAAE,cAAc,EAAE,CAAA;YAEhC,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,uBAAuB,CAAC,CAAC,WAAW,EAAE,CAAC,CAAA;YAEtG,OAAO,CAAC,MAAM,EAAE,cAAc,EAAE,CAAA;YAChC,MAAM,eAAe,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;YACvE,OAAO,CAAC,UAAU,EAAE,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAA;QAC7C,CAAC;QAED,OAAO,CAAC,MAAM,EAAE,cAAc,EAAE,CAAA;QAEhC,OAAO,MAAM,eAAe,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC,CAAA;IACjD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,mFAAmF;QACnF,MAAM,eAAe,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAA;QAC/D,MAAM,KAAK,CAAA;IACb,CAAC;AACH,CAAC"}

package/dist/native/templates/bridge-view-controller.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Keeps Capacitor's existing UI delegate intact except for media permission decisions.
+ */
+export declare const BRIDGE_VIEW_CONTROLLER_SWIFT: string;

package/dist/native/templates/bridge-view-controller.js

@@ -0,0 +1,86 @@
+/**
+ * Keeps Capacitor's existing UI delegate intact except for media permission decisions.
+ */
+export const BRIDGE_VIEW_CONTROLLER_SWIFT = String.raw `import AVFoundation
+import Capacitor
+import WebKit
+
+@objc(TypeFerryBridgeViewController)
+class TypeFerryBridgeViewController: CAPBridgeViewController {
+    private var mediaDelegate: TypeFerryMediaDelegate?
+
+    override func capacitorDidLoad() {
+        bridge?.registerPluginInstance(TypeFerryNativePlugin())
+        guard let webView = webView, let bridge = bridge else { return }
+        let delegate = TypeFerryMediaDelegate(original: webView.uiDelegate, localURL: bridge.config.localURL)
+        mediaDelegate = delegate
+        webView.uiDelegate = delegate
+    }
+}
+
+private final class TypeFerryMediaDelegate: NSObject, WKUIDelegate {
+    private weak var original: WKUIDelegate?
+    private let localURL: URL
+
+    init(original: WKUIDelegate?, localURL: URL) {
+        self.original = original
+        self.localURL = localURL
+        super.init()
+    }
+
+    override func responds(to selector: Selector!) -> Bool {
+        super.responds(to: selector) || (original?.responds(to: selector) ?? false)
+    }
+
+    override func forwardingTarget(for selector: Selector!) -> Any? {
+        if original?.responds(to: selector) == true { return original }
+        return super.forwardingTarget(for: selector)
+    }
+
+    func webView(_ webView: WKWebView, requestMediaCapturePermissionFor origin: WKSecurityOrigin,
+                 initiatedByFrame frame: WKFrameInfo, type: WKMediaCaptureType,
+                 decisionHandler: @escaping (WKPermissionDecision) -> Void) {
+        guard let requestURL = frame.request.url,
+              TypeFerryMediaPolicy.isTrusted(localURL: localURL, requestURL: requestURL, isMainFrame: frame.isMainFrame),
+              origin.protocol == localURL.scheme, origin.host == localURL.host,
+              origin.port == (localURL.port ?? 0),
+              webView.url.map({ TypeFerryMediaPolicy.isTrusted(localURL: localURL, requestURL: $0, isMainFrame: true) }) == true
+        else { decisionHandler(.deny); return }
+
+        let devices: [AVMediaType]
+        switch type {
+        case .camera: devices = [.video]
+        case .microphone: devices = [.audio]
+        case .cameraAndMicrophone: devices = [.video, .audio]
+        @unknown default: decisionHandler(.deny); return
+        }
+        authorize(devices[...]) { [weak webView] decision in
+            // A permission prompt can outlive navigation; never grant to a replacement page.
+            guard let currentURL = webView?.url,
+                  TypeFerryMediaPolicy.isTrusted(localURL: self.localURL, requestURL: currentURL, isMainFrame: true)
+            else { decisionHandler(.deny); return }
+            decisionHandler(decision)
+        }
+    }
+
+    private func authorize(_ devices: ArraySlice<AVMediaType>, completion: @escaping (WKPermissionDecision) -> Void) {
+        guard let device = devices.first else { completion(.grant); return }
+        let usageKey = device == .video ? "NSCameraUsageDescription" : "NSMicrophoneUsageDescription"
+        guard let explanation = Bundle.main.object(forInfoDictionaryKey: usageKey) as? String, !explanation.isEmpty
+        else { completion(.deny); return }
+
+        switch AVCaptureDevice.authorizationStatus(for: device) {
+        case .authorized: authorize(devices.dropFirst(), completion: completion)
+        case .notDetermined:
+            AVCaptureDevice.requestAccess(for: device) { [weak self] granted in
+                DispatchQueue.main.async {
+                    guard granted, let self = self else { completion(.deny); return }
+                    self.authorize(devices.dropFirst(), completion: completion)
+                }
+            }
+        default: completion(.deny)
+        }
+    }
+}
+`;
+//# sourceMappingURL=bridge-view-controller.js.map

package/dist/native/templates/bridge-view-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge-view-controller.js","sourceRoot":"","sources":["../../../src/native/templates/bridge-view-controller.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiFrD,CAAA"}

package/dist/native/templates/file-staging.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Bounded, sequential native file staging independent of Capacitor and UIKit.
+ */
+export declare const FILE_STAGING_SWIFT: string;

package/dist/native/templates/file-staging.js

@@ -0,0 +1,77 @@
+/**
+ * Bounded, sequential native file staging independent of Capacitor and UIKit.
+ */
+export const FILE_STAGING_SWIFT = String.raw `import Foundation
+
+final class TypeFerryFileStaging {
+    static let maximumBytes = 128 * 1024 * 1024
+    static let chunkBytes = 48 * 1024
+    private struct Pending {
+        let id: String
+        let url: URL
+        let name: String
+        let size: Int
+        let handle: FileHandle
+        var offset: Int
+    }
+    private var pending: Pending?
+
+    deinit {
+        if let id = pending?.id { cancel(id: id) }
+    }
+
+    func contains(id: String) -> Bool { pending?.id == id }
+
+    func begin(fileName: String, size: Int) throws -> String {
+        guard pending == nil else { throw failure("Another file is already being prepared.") }
+        guard size >= 0, size <= Self.maximumBytes else { throw failure("Files must be at most 128 MiB.") }
+        guard !fileName.isEmpty, fileName.utf8.count <= 255,
+              fileName == URL(fileURLWithPath: fileName).lastPathComponent,
+              ![".", ".."].contains(fileName), !fileName.contains("\\"), !fileName.contains("\0")
+        else { throw failure("A safe file name is required.") }
+
+        let id = UUID().uuidString
+        let url = FileManager.default.temporaryDirectory.appendingPathComponent("typeferry-share-" + id)
+        guard FileManager.default.createFile(atPath: url.path, contents: nil) else { throw failure("Unable to create a temporary file.") }
+        do {
+            let handle = try FileHandle(forWritingTo: url)
+            pending = Pending(id: id, url: url, name: fileName, size: size, handle: handle, offset: 0)
+            return id
+        } catch {
+            try? FileManager.default.removeItem(at: url)
+            throw error
+        }
+    }
+
+    func append(id: String, offset: Int, base64: String) throws {
+        guard var current = pending, current.id == id else { throw failure("The pending file is unavailable.") }
+        guard offset == current.offset, base64.utf8.count <= Self.chunkBytes / 3 * 4,
+              let data = Data(base64Encoded: base64), !data.isEmpty, data.count <= Self.chunkBytes,
+              data.count <= current.size - current.offset else { throw failure("Invalid file chunk or offset.") }
+        try current.handle.write(contentsOf: data)
+        current.offset += data.count
+        pending = current
+    }
+
+    func finish(id: String) throws -> (url: URL, fileName: String) {
+        guard let current = pending, current.id == id, current.offset == current.size else {
+            throw failure("The pending file is incomplete.")
+        }
+        try current.handle.close()
+        pending = nil
+        return (current.url, current.name)
+    }
+
+    func cancel(id: String) {
+        guard let current = pending, current.id == id else { return }
+        pending = nil
+        try? current.handle.close()
+        try? FileManager.default.removeItem(at: current.url)
+    }
+
+    private func failure(_ message: String) -> NSError {
+        NSError(domain: "TypeFerryFileStaging", code: 1, userInfo: [NSLocalizedDescriptionKey: message])
+    }
+}
+`;
+//# sourceMappingURL=file-staging.js.map

package/dist/native/templates/file-staging.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-staging.js","sourceRoot":"","sources":["../../../src/native/templates/file-staging.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwE3C,CAAA"}

package/dist/native/templates/http-session.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Same-origin native transport, with a private cookie jar persisted in Keychain.
+ */
+export declare const HTTP_SESSION_SWIFT: string;

package/dist/native/templates/http-session.js

@@ -0,0 +1,117 @@
+/**
+ * Same-origin native transport, with a private cookie jar persisted in Keychain.
+ */
+export const HTTP_SESSION_SWIFT = String.raw `import Foundation
+
+final class TypeFerryHTTPSession: NSObject, URLSessionTaskDelegate {
+    let backendURL: URL
+    private let cookieAccount: String
+    private var session: URLSession!
+    private let cookieLock = NSLock()
+    private var generation = 0
+
+    init(backendURL: URL) throws {
+        self.backendURL = backendURL
+        cookieAccount = "cookies:" + backendURL.absoluteString
+        super.init()
+
+        let configuration = Self.makeConfiguration()
+        if let data = try TypeFerryKeychain.read(cookieAccount),
+           let rows = try PropertyListSerialization.propertyList(from: data, format: nil) as? [[String: Any]] {
+            for row in rows {
+                let properties = Dictionary(uniqueKeysWithValues: row.map { (HTTPCookiePropertyKey($0.key), $0.value) })
+                if let cookie = HTTPCookie(properties: properties),
+                   cookie.expiresDate.map({ $0 > Date() }) ?? true {
+                    configuration.httpCookieStorage?.setCookie(cookie)
+                }
+            }
+        }
+        session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
+    }
+
+    func accepts(_ url: URL) -> Bool {
+        TypeFerryMediaPolicy.isTrusted(localURL: backendURL, requestURL: url, isMainFrame: true)
+    }
+
+    func request(_ request: URLRequest, completion: @escaping (Result<(Data, HTTPURLResponse), Error>) -> Void) {
+        guard let url = request.url, accepts(url) else { completion(.failure(Self.failure("Untrusted backend URL."))); return }
+        let (requestSession, requestGeneration) = snapshot()
+        requestSession.dataTask(with: request) { [weak self] data, response, error in
+            if let error = error { completion(.failure(error)); return }
+            guard let self = self, let response = response as? HTTPURLResponse, let data = data else {
+                completion(.failure(Self.failure("The backend returned no response."))); return
+            }
+            do {
+                try self.persistCookies(session: requestSession, generation: requestGeneration)
+                completion(.success((data, response)))
+            } catch { completion(.failure(error)) }
+        }.resume()
+    }
+
+    func download(_ request: URLRequest, completion: @escaping (Result<URL, Error>) -> Void) {
+        guard let url = request.url, accepts(url) else { completion(.failure(Self.failure("Untrusted download URL."))); return }
+        let (requestSession, requestGeneration) = snapshot()
+        requestSession.downloadTask(with: request) { [weak self] location, response, error in
+            if let error = error { completion(.failure(error)); return }
+            guard let self = self, let location = location, let response = response as? HTTPURLResponse,
+                  (200..<300).contains(response.statusCode) else {
+                completion(.failure(Self.failure("The download failed."))); return
+            }
+            do {
+                try self.persistCookies(session: requestSession, generation: requestGeneration)
+                let retained = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
+                try FileManager.default.moveItem(at: location, to: retained)
+                completion(.success(retained))
+            } catch { completion(.failure(error)) }
+        }.resume()
+    }
+
+    func clearCookies() throws {
+        cookieLock.lock()
+        defer { cookieLock.unlock() }
+        let previous = session
+        generation += 1
+        // A fresh cookie jar prevents in-flight Set-Cookie from resurrecting logout.
+        session = URLSession(configuration: Self.makeConfiguration(), delegate: self, delegateQueue: nil)
+        previous?.invalidateAndCancel()
+        try TypeFerryKeychain.delete(cookieAccount)
+    }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, willPerformHTTPRedirection response: HTTPURLResponse,
+                    newRequest request: URLRequest, completionHandler: @escaping (URLRequest?) -> Void) {
+        guard let url = request.url, accepts(url) else { completionHandler(nil); return }
+        completionHandler(request)
+    }
+
+    private func snapshot() -> (URLSession, Int) {
+        cookieLock.lock()
+        defer { cookieLock.unlock() }
+        return (session, generation)
+    }
+
+    private static func makeConfiguration() -> URLSessionConfiguration {
+        let configuration = URLSessionConfiguration.ephemeral
+        configuration.httpShouldSetCookies = true
+        configuration.timeoutIntervalForRequest = 60
+        configuration.timeoutIntervalForResource = 300
+        return configuration
+    }
+
+    private func persistCookies(session: URLSession, generation: Int) throws {
+        cookieLock.lock()
+        defer { cookieLock.unlock() }
+        guard generation == self.generation else { throw Self.failure("The native session was cleared.") }
+        let rows = (session.configuration.httpCookieStorage?.cookies ?? []).compactMap { cookie -> [String: Any]? in
+            guard let properties = cookie.properties else { return nil }
+            return Dictionary(uniqueKeysWithValues: properties.map { ($0.key.rawValue, $0.value) })
+        }
+        let data = try PropertyListSerialization.data(fromPropertyList: rows, format: .binary, options: 0)
+        try TypeFerryKeychain.write(cookieAccount, data: data)
+    }
+
+    static func failure(_ message: String) -> NSError {
+        NSError(domain: "TypeFerryNative", code: 1, userInfo: [NSLocalizedDescriptionKey: message])
+    }
+}
+`;
+//# sourceMappingURL=http-session.js.map

package/dist/native/templates/http-session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-session.js","sourceRoot":"","sources":["../../../src/native/templates/http-session.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgH3C,CAAA"}

package/dist/native/templates/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Framework-owned Swift source files installed explicitly by the iOS scaffold.
+ */
+export declare const IOS_NATIVE_TEMPLATES: Readonly<Record<string, string>>;

package/dist/native/templates/index.js

@@ -0,0 +1,20 @@
+import { BRIDGE_VIEW_CONTROLLER_SWIFT } from './bridge-view-controller.js';
+import { FILE_STAGING_SWIFT } from './file-staging.js';
+import { HTTP_SESSION_SWIFT } from './http-session.js';
+import { KEYCHAIN_SWIFT } from './keychain.js';
+import { MEDIA_PERMISSION_POLICY_SWIFT } from './media-permission-policy.js';
+import { NATIVE_PLUGIN_SWIFT } from './plugin.js';
+import { WAKE_LOCKS_SWIFT } from './wake-locks.js';
+/**
+ * Framework-owned Swift source files installed explicitly by the iOS scaffold.
+ */
+export const IOS_NATIVE_TEMPLATES = {
+    'TypeFerryBridgeViewController.swift': BRIDGE_VIEW_CONTROLLER_SWIFT,
+    'TypeFerryMediaPolicy.swift': MEDIA_PERMISSION_POLICY_SWIFT,
+    'TypeFerryWakeLocks.swift': WAKE_LOCKS_SWIFT,
+    'TypeFerryFileStaging.swift': FILE_STAGING_SWIFT,
+    'TypeFerryKeychain.swift': KEYCHAIN_SWIFT,
+    'TypeFerryHTTPSession.swift': HTTP_SESSION_SWIFT,
+    'TypeFerryNativePlugin.swift': NATIVE_PLUGIN_SWIFT,
+};
+//# sourceMappingURL=index.js.map

package/dist/native/templates/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/native/templates/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,0BAA0B,CAAA;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAC3C,OAAO,EAAE,6BAA6B,EAAE,MAAM,2BAA2B,CAAA;AACzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAE/C;;GAEG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAqC;IACpE,qCAAqC,EAAE,4BAA4B;IACnE,4BAA4B,EAAE,6BAA6B;IAC3D,0BAA0B,EAAE,gBAAgB;IAC5C,4BAA4B,EAAE,kBAAkB;IAChD,yBAAyB,EAAE,cAAc;IACzC,4BAA4B,EAAE,kBAAkB;IAChD,6BAA6B,EAAE,mBAAmB;CACnD,CAAA"}

package/dist/native/templates/keychain.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Native-only secrets survive application upgrades without entering web storage.
+ */
+export declare const KEYCHAIN_SWIFT: string;

package/dist/native/templates/keychain.js

@@ -0,0 +1,48 @@
+/**
+ * Native-only secrets survive application upgrades without entering web storage.
+ */
+export const KEYCHAIN_SWIFT = String.raw `import Foundation
+import Security
+
+struct TypeFerryKeychain {
+    static func read(_ account: String) throws -> Data? {
+        var query = baseQuery(account)
+        query[kSecReturnData] = true
+        query[kSecMatchLimit] = kSecMatchLimitOne
+        var result: CFTypeRef?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        if status == errSecItemNotFound { return nil }
+        guard status == errSecSuccess else { throw failure(status) }
+        return result as? Data
+    }
+
+    static func write(_ account: String, data: Data) throws {
+        let query = baseQuery(account)
+        let updates: [CFString: Any] = [kSecValueData: data]
+        let status = SecItemUpdate(query as CFDictionary, updates as CFDictionary)
+        if status == errSecItemNotFound {
+            var insertion = query
+            insertion[kSecValueData] = data
+            insertion[kSecAttrAccessible] = kSecAttrAccessibleWhenUnlockedThisDeviceOnly
+            let insertStatus = SecItemAdd(insertion as CFDictionary, nil)
+            guard insertStatus == errSecSuccess else { throw failure(insertStatus) }
+        } else if status != errSecSuccess { throw failure(status) }
+    }
+
+    static func delete(_ account: String) throws {
+        let status = SecItemDelete(baseQuery(account) as CFDictionary)
+        guard status == errSecSuccess || status == errSecItemNotFound else { throw failure(status) }
+    }
+
+    private static func baseQuery(_ account: String) -> [CFString: Any] {
+        [kSecClass: kSecClassGenericPassword,
+         kSecAttrService: (Bundle.main.bundleIdentifier ?? "typeferry") + ".typeferry",
+         kSecAttrAccount: account]
+    }
+
+    private static func failure(_ status: OSStatus) -> NSError {
+        NSError(domain: NSOSStatusErrorDomain, code: Int(status), userInfo: [NSLocalizedDescriptionKey: "Secure session storage is unavailable."])
+    }
+}
+`;
+//# sourceMappingURL=keychain.js.map

package/dist/native/templates/keychain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keychain.js","sourceRoot":"","sources":["../../../src/native/templates/keychain.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CvC,CAAA"}

package/dist/native/templates/media-permission-policy.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Foundation-only origin policy, also executed by the native security tests.
+ */
+export declare const MEDIA_PERMISSION_POLICY_SWIFT: string;

package/dist/native/templates/media-permission-policy.js

@@ -0,0 +1,24 @@
+/**
+ * Foundation-only origin policy, also executed by the native security tests.
+ */
+export const MEDIA_PERMISSION_POLICY_SWIFT = String.raw `import Foundation
+
+struct TypeFerryMediaPolicy {
+    static func isTrusted(localURL: URL, requestURL: URL, isMainFrame: Bool) -> Bool {
+        guard isMainFrame, requestURL.user == nil, requestURL.password == nil else { return false }
+        return localURL.scheme?.lowercased() == requestURL.scheme?.lowercased()
+            && localURL.host?.lowercased() == requestURL.host?.lowercased()
+            && effectivePort(localURL) == effectivePort(requestURL)
+    }
+
+    private static func effectivePort(_ url: URL) -> Int? {
+        if let port = url.port { return port }
+        switch url.scheme?.lowercased() {
+        case "https": return 443
+        case "http": return 80
+        default: return nil
+        }
+    }
+}
+`;
+//# sourceMappingURL=media-permission-policy.js.map

package/dist/native/templates/media-permission-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-permission-policy.js","sourceRoot":"","sources":["../../../src/native/templates/media-permission-policy.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;CAmBtD,CAAA"}

package/dist/native/templates/plugin.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Narrow Capacitor bridge: pinned backend requests, Keychain, system auth and sharing.
+ */
+export declare const NATIVE_PLUGIN_SWIFT: string;