@absolutejs/absolute 0.20.0-beta.0 → 0.20.0-beta.10

package/dist/src/mobile/client.d.ts

@@ -1,6 +1,9 @@
 import { type AbsoluteMobilePageResult, type AbsoluteMobileUpgradeRequiredResult } from './pageProtocol';
 type AbsoluteMobileClientTarget = {
+    __ABSOLUTE_PAGE_DISPOSE__?: () => Promise<void> | void;
+    __ABSOLUTE_PAGE_READY__?: Promise<unknown>;
     __ABSOLUTE_PAGE_RENDER_MODE__?: 'client' | 'hydrate';
+    __ABS_ANGULAR_REQUEST_CONTEXT__?: Record<string, unknown>;
     __INITIAL_PROPS__?: Record<string, unknown>;
 };
 export type AbsoluteMobilePageLoader = (input: {
@@ -12,7 +15,7 @@ export type AbsoluteMobilePageActivation = {
     contract: string;
     pageId: string;
 } | AbsoluteMobileUpgradeRequiredResult;
-type AbsoluteMobilePageActivationOptions = {
+export type AbsoluteMobilePageActivationOptions = {
     loadPage: AbsoluteMobilePageLoader;
     target?: AbsoluteMobileClientTarget;
 };
@@ -20,6 +23,7 @@ export declare class AbsoluteMobilePageProtocolError extends Error {
     readonly code: 'invalid-envelope' | 'invalid-props' | 'server-error' | 'server-rejected-request';
     constructor(code: AbsoluteMobilePageProtocolError['code'], message: string);
 }
+export declare const disposeAbsoluteMobilePage: (target?: AbsoluteMobileClientTarget) => Promise<void>;
 export declare const activateAbsoluteMobilePage: (value: unknown, options: AbsoluteMobilePageActivationOptions) => Promise<AbsoluteMobileUpgradeRequiredResult | {
     contract: string;
     kind: "rendered";

package/dist/src/mobile/config.d.ts

@@ -0,0 +1,17 @@
+import type { MobileConfig, MobilePlatform } from '../../types/build';
+export type NormalizedAbsoluteMobileConfig = {
+    appId: string;
+    appName: string;
+    androidCertificateFingerprints: string[];
+    appleAppIdPrefix?: string;
+    bundleDirectory: string;
+    deepLinkHosts: string[];
+    deepLinkScheme?: string;
+    engine: 'capacitor';
+    entry: string;
+    iosVersion?: string;
+    nativeProjectDirectory: string;
+    platforms: MobilePlatform[];
+    productionOrigin: string;
+};
+export declare const normalizeAbsoluteMobileConfig: (config: MobileConfig, projectRoot: string) => NormalizedAbsoluteMobileConfig;

package/dist/src/mobile/emulatorDoctor.d.ts

@@ -0,0 +1,25 @@
+export type AbsoluteMobileHost = 'macos' | 'windows' | 'linux' | 'wsl';
+export type AbsoluteMobileDoctorStatus = 'pass' | 'warn' | 'fail' | 'skip';
+export declare const ABSOLUTE_ANDROID_AVD_NAME = "AbsoluteJS_API_36";
+export type AbsoluteMobileDoctorCheck = {
+    id: string;
+    label: string;
+    path?: string;
+    platform: 'host' | 'android' | 'ios';
+    remediation?: string;
+    status: AbsoluteMobileDoctorStatus;
+};
+export type InspectAbsoluteMobileToolchainOptions = {
+    androidRoot?: string | null;
+    capture?: (command: string[]) => {
+        exitCode: number;
+        stdout: string;
+    };
+    env?: Record<string, string | undefined>;
+    exists?: (path: string) => Promise<boolean>;
+    host?: AbsoluteMobileHost;
+    which?: (command: string) => string | null;
+};
+export declare const absoluteManagedAndroidSdkRoot: (host: AbsoluteMobileHost, env?: Record<string, string | undefined>) => string;
+export declare const detectAbsoluteMobileHost: (platform?: NodeJS.Platform, wsl?: boolean) => "linux" | "macos" | "windows" | "wsl";
+export declare const inspectAbsoluteMobileToolchain: (input?: InspectAbsoluteMobileToolchainOptions) => Promise<AbsoluteMobileDoctorCheck[]>;

package/dist/src/mobile/emulatorInstaller.d.ts

@@ -0,0 +1,41 @@
+import { type AbsoluteMobileDoctorCheck, type AbsoluteMobileHost } from './emulatorDoctor';
+export type AbsoluteMobileInstallStep = {
+    detail: string;
+    id: string;
+    label: string;
+};
+export type AbsoluteMobileInstallPlan = {
+    androidRoot: string;
+    host: AbsoluteMobileHost;
+    platform: 'android' | 'ios';
+    steps: AbsoluteMobileInstallStep[];
+};
+export type AbsoluteMobileInstallResult = {
+    checks: AbsoluteMobileDoctorCheck[];
+    completed: string[];
+    plan: AbsoluteMobileInstallPlan;
+};
+type RunOptions = {
+    env?: Record<string, string | undefined>;
+    input?: string;
+};
+type CaptureResult = {
+    exitCode: number;
+    stdout: string;
+};
+type AbsoluteMobileInstallerDependencies = {
+    arch?: string;
+    capture?: (command: string[], options?: RunOptions) => CaptureResult;
+    download?: (url: string) => Promise<Uint8Array>;
+    env?: Record<string, string | undefined>;
+    exists?: (path: string) => Promise<boolean>;
+    host?: AbsoluteMobileHost;
+    log?: (message: string) => void;
+    run?: (command: string[], options?: RunOptions) => Promise<number>;
+    which?: (command: string) => string | null;
+};
+export declare const planAbsoluteMobileEmulatorInstall: (platform: "android" | "ios", input?: AbsoluteMobileInstallerDependencies) => AbsoluteMobileInstallPlan;
+export declare const fixAbsoluteMobileEmulatorToolchain: (platform: "android" | "ios", options?: AbsoluteMobileInstallerDependencies & {
+    acceptLicenses?: boolean;
+}) => Promise<AbsoluteMobileInstallResult>;
+export {};

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

@@ -1,7 +1,26 @@
 export * from './artifactStore';
+export * from './androidRelease';
+export * from './iosRelease';
+export * from './iosConformance';
+export * from './iosSimulatorController';
+export * from './iosNativeWatcher';
+export * from './remoteMacProtocol';
+export * from './associationFiles';
+export * from './buildMetadata';
+export * from './buildPipeline';
+export * from './buildRelease';
+export * from './capacitorBundle';
+export * from './capacitorProject';
+export * from './config';
 export * from './client';
 export * from './compatibilityDispatcher';
 export * from './materializedBundle';
+export * from './nativeDeepLinks';
+export * from './nativeAuth';
 export * from './pageProtocol';
 export * from './producerContext';
 export * from './releaseArtifact';
+export * from './releasePublisher';
+export * from './routeMetadataTransform';
+export * from './routeMatcher';
+export * from './transport';

package/dist/src/mobile/iosConformance.d.ts

@@ -0,0 +1,15 @@
+export type AbsoluteIosHmrApply = {
+    clientMs?: number;
+    duration: number;
+    line: string;
+    outcome: 'applied' | 'failed' | 'reloaded';
+    serverMs?: number;
+};
+export declare const parseAbsoluteIosHmrLog: (line: string) => AbsoluteIosHmrApply | null;
+export declare const waitForAbsoluteIosHmrLog: (options: {
+    logPath: string;
+    signal?: AbortSignal;
+    sleep?: (milliseconds: number) => Promise<void>;
+    startOffset?: number;
+    timeoutMs?: number;
+}) => Promise<AbsoluteIosHmrApply>;

package/dist/src/mobile/iosNativeWatcher.d.ts

@@ -0,0 +1,19 @@
+import { type AbsoluteIosDevProject } from './iosSimulatorController';
+export type AbsoluteIosNativeChange = {
+    afterFingerprint: string;
+    beforeFingerprint: string;
+    paths: string[];
+    rootInputChanged: boolean;
+};
+export type AbsoluteIosNativeWatcher = {
+    close: () => void;
+};
+export type AbsoluteIosNativeWatcherOptions = {
+    debounceMs?: number;
+    onChange: (change: AbsoluteIosNativeChange) => Promise<void>;
+    onError?: (error: unknown) => void;
+    project: AbsoluteIosDevProject;
+    signal?: AbortSignal;
+};
+export declare const createAbsoluteIosNativeWatcher: (options: AbsoluteIosNativeWatcherOptions) => Promise<AbsoluteIosNativeWatcher>;
+export declare const isAbsoluteIosNativeRootInput: (path: string) => boolean;

package/dist/src/mobile/iosRelease.d.ts

@@ -0,0 +1,61 @@
+import type { NormalizedAbsoluteMobileConfig } from './config';
+import { type AbsoluteMobileHost } from './emulatorDoctor';
+export declare const ABSOLUTE_IOS_RELEASE_FORMAT: 1;
+export type AbsoluteIosReleaseMetadata = {
+    appBuild: string;
+    appId: string;
+    artifact: 'App.ipa';
+    buildNumber?: number;
+    bytes: number;
+    engine: 'capacitor';
+    format: typeof ABSOLUTE_IOS_RELEASE_FORMAT;
+    marketingVersion: string;
+    platform: 'ios';
+    releaseId: string;
+    runtime: string;
+    sha256: string;
+    signed: boolean;
+    type: 'ipa';
+};
+type CommandOptions = {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+};
+type CommandResult = {
+    exitCode: number;
+    stderr: string;
+    stdout: string;
+};
+export type BuildAbsoluteIosReleaseOptions = {
+    allowUnsigned?: boolean;
+    capture?: (command: string[], options?: CommandOptions) => CommandResult;
+    config: NormalizedAbsoluteMobileConfig;
+    host?: AbsoluteMobileHost;
+    outputDirectory?: string;
+    prepareBuildNumber?: (buildIdentity: string) => Promise<number>;
+    projectRoot: string;
+    run?: (command: string[], options?: CommandOptions) => Promise<number>;
+    buildNumber?: number;
+};
+export declare const fingerprintAbsoluteIosNativeProject: (nativeDirectory: string) => Promise<string>;
+export declare const buildAbsoluteIosRelease: (options: BuildAbsoluteIosReleaseOptions) => Promise<{
+    artifactPath: string;
+    metadata: {
+        artifact: "App.ipa";
+        sha256: string;
+        type: "ipa";
+        format: typeof ABSOLUTE_IOS_RELEASE_FORMAT;
+        bytes: number;
+        runtime: string;
+        releaseId: string;
+        appBuild: string;
+        appId: string;
+        platform: "ios";
+        buildNumber?: number | undefined;
+        engine: "capacitor";
+        marketingVersion: string;
+        signed: boolean;
+    };
+    releaseRoot: string;
+}>;
+export {};

package/dist/src/mobile/iosSimulatorController.d.ts

@@ -0,0 +1,89 @@
+import type { NormalizedAbsoluteMobileConfig } from './config';
+export declare const ABSOLUTE_IOS_SIMULATOR_NAME = "AbsoluteJS iPhone";
+export type AbsoluteIosCommandOptions = {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    signal?: AbortSignal;
+};
+export type AbsoluteIosCommandResult = {
+    exitCode: number;
+    stderr: string;
+    stdout: string;
+};
+export type AbsoluteIosDevState = 'booting' | 'building' | 'checking-native' | 'closed' | 'closing' | 'configuring' | 'connecting' | 'failed' | 'installing' | 'launching' | 'ready' | 'streaming-logs' | 'syncing';
+export type AbsoluteIosNativeLogEntry = {
+    level: 'debug' | 'error' | 'fault' | 'info' | 'notice';
+    message: string;
+    tag: string;
+};
+type AbsoluteIosLogStream = {
+    close: () => Promise<void>;
+};
+export type AbsoluteIosDevProject = {
+    cap: string;
+    config: NormalizedAbsoluteMobileConfig;
+    nativeDirectory: string;
+    projectRoot: string;
+    xcodebuild: string;
+    xcrun: string;
+};
+export type AbsoluteIosDevSession = {
+    close: () => Promise<void>;
+    nativeCacheHit: boolean;
+    rebuild: () => Promise<AbsoluteIosDevSession>;
+    relaunch: () => Promise<void>;
+    screenshot: (destination: string) => Promise<string>;
+    startedSimulator: boolean;
+    state: AbsoluteIosDevState;
+    timings: Record<string, number>;
+    udid: string;
+};
+export type AbsoluteIosDevPhaseTiming = {
+    durationMs: number;
+    phase: AbsoluteIosDevState;
+    totalMs: number;
+};
+export type PrepareAbsoluteIosDevOptions = {
+    createNativeProject: boolean;
+    projectRoot: string;
+    run?: (command: string[], options?: AbsoluteIosCommandOptions) => Promise<number>;
+};
+export type StartAbsoluteIosDevOptions = {
+    capture?: (command: string[], options?: AbsoluteIosCommandOptions) => AbsoluteIosCommandResult;
+    https?: boolean;
+    log?: (message: string) => void;
+    nativeLog?: (entry: AbsoluteIosNativeLogEntry) => void;
+    onPhaseTiming?: (timing: AbsoluteIosDevPhaseTiming) => void;
+    onStateChange?: (state: AbsoluteIosDevState) => void;
+    port: number;
+    project: AbsoluteIosDevProject;
+    run?: (command: string[], options?: AbsoluteIosCommandOptions) => Promise<number>;
+    signal?: AbortSignal;
+    sleep?: (milliseconds: number) => Promise<void>;
+    spawn?: (command: string[], options?: AbsoluteIosCommandOptions) => void;
+    startNativeLogs?: (command: string[], options: AbsoluteIosCommandOptions, onLine: (line: string) => void) => AbsoluteIosLogStream;
+};
+export declare const parseIosDeviceTypes: (source: string) => {
+    identifier: string;
+    name: string;
+}[];
+export declare const parseIosRuntimes: (source: string) => {
+    identifier: string;
+    isAvailable: boolean;
+    name: string;
+    version: string;
+}[];
+export declare const parseIosSimulators: (source: string) => {
+    isAvailable: boolean;
+    name: string;
+    runtime: string;
+    state: string;
+    udid: string;
+}[];
+export declare const repairAbsoluteIosDevSession: (projectRoot: string) => Promise<boolean>;
+export declare const fingerprintAbsoluteIosDevProject: (project: Pick<AbsoluteIosDevProject, "nativeDirectory">) => Promise<string>;
+export declare const parseAbsoluteIosLogLine: (line: string) => AbsoluteIosNativeLogEntry | null;
+export declare const redactAbsoluteIosLog: (value: string) => string;
+export declare const prepareAbsoluteIosDevProject: (config: NormalizedAbsoluteMobileConfig, options: PrepareAbsoluteIosDevOptions) => Promise<AbsoluteIosDevProject>;
+export declare const startAbsoluteIosDevSession: (options: StartAbsoluteIosDevOptions) => Promise<AbsoluteIosDevSession>;
+export {};

package/dist/src/mobile/materializedBundle.d.ts

@@ -20,3 +20,17 @@ export declare const materializeAbsoluteMobileCompatibilityBundle: (input: Absol
     format: 1;
     releases: AbsoluteMobileCompatibilityArtifact[];
 }>;
+export declare const readAbsoluteMobileMaterializedReleases: (root: string) => Promise<{
+    artifact: {
+        releaseId: string;
+        pages: import("./releaseArtifact").AbsoluteMobileCompatibilityPage[];
+        routes: import("./releaseArtifact").AbsoluteMobileCompatibilityRoute[];
+        format: typeof import("./releaseArtifact").ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT;
+        runtime: string;
+        appBuild: string;
+        appId: string;
+        generation: number;
+        producer: import("./releaseArtifact").AbsoluteMobileCompatibilityProducer;
+    };
+    producer: Bun.BunFile;
+}[]>;

package/dist/src/mobile/nativeAuth.d.ts

@@ -0,0 +1,17 @@
+import type { NormalizedAbsoluteMobileConfig } from './config';
+export declare const ABSOLUTE_AUTH_PACKAGE: "@absolutejs/auth";
+export declare const ABSOLUTE_NATIVE_AUTH_CLIENTS_ENV: "ABSOLUTE_AUTH_NATIVE_CLIENTS";
+export declare const ABSOLUTE_NATIVE_AUTH_SCOPES: readonly ["openid", "profile"];
+export declare const ABSOLUTE_SYNC_PACKAGE: "@absolutejs/sync";
+export type AbsoluteMobileAuthManifest = {
+    clientId: string;
+    issuer: string;
+    redirectUri: string;
+    scopes: string[];
+};
+export declare const createAbsoluteMobileAuthManifest: (config: NormalizedAbsoluteMobileConfig) => AbsoluteMobileAuthManifest;
+export declare const installAbsoluteMobileAuthEnvironment: (projectRoot: string, config: NormalizedAbsoluteMobileConfig) => AbsoluteMobileAuthManifest | undefined;
+export declare const projectUsesAbsoluteAuth: (projectRoot: string) => boolean;
+export declare const projectUsesAbsoluteSync: (projectRoot: string) => boolean;
+export declare const resolveAbsoluteMobileAuthManifest: (projectRoot: string, config: NormalizedAbsoluteMobileConfig) => AbsoluteMobileAuthManifest | undefined;
+export declare const serializeAbsoluteMobileAuthEnvironment: (config: NormalizedAbsoluteMobileConfig, auth: AbsoluteMobileAuthManifest | undefined) => string | undefined;

package/dist/src/mobile/nativeBackgroundSync.d.ts

@@ -0,0 +1,4 @@
+import type { NormalizedAbsoluteMobileConfig } from './config';
+export declare const applyAbsoluteNativeBackgroundSync: (projectRoot: string, config: NormalizedAbsoluteMobileConfig, platforms?: import("..").MobilePlatform[]) => Promise<{
+    changed: boolean;
+}>;

package/dist/src/mobile/nativeDeepLinks.d.ts

@@ -0,0 +1,5 @@
+import type { MobilePlatform } from '../../types/build';
+import type { NormalizedAbsoluteMobileConfig } from './config';
+export declare const applyAbsoluteNativeDeepLinks: (config: NormalizedAbsoluteMobileConfig, platforms?: readonly MobilePlatform[]) => Promise<{
+    changed: MobilePlatform[];
+}>;

package/dist/src/mobile/releaseArtifact.d.ts

@@ -3,10 +3,13 @@ export declare const ABSOLUTE_MOBILE_COMPATIBILITY_FORMAT: 1;
 export declare const ABSOLUTE_MOBILE_RETAINED_GENERATIONS = 3;
 export type AbsoluteMobileCompatibilityPage = {
     bundleHash: string;
+    bundlePath: string;
     contract: string;
     framework: AbsoluteMobilePageFramework;
     pageId: string;
     propsSchemaHash: string;
+    styleBundleHash?: string;
+    styleBundlePath?: string;
 };
 export type AbsoluteMobileCompatibilityRoute = {
     method: 'GET' | 'HEAD';

package/dist/src/mobile/releaseDoctor.d.ts

@@ -0,0 +1,13 @@
+import type { NormalizedAbsoluteMobileConfig } from './config';
+export type AbsoluteMobileReleaseCheck = {
+    detail: string;
+    id: string;
+    path?: string;
+    remediation?: string;
+    status: 'fail' | 'pass';
+};
+export type AbsoluteMobileReleaseDoctorResult = {
+    checks: AbsoluteMobileReleaseCheck[];
+    ready: boolean;
+};
+export declare const inspectAbsoluteMobileRelease: (config: NormalizedAbsoluteMobileConfig, projectRoot: string) => Promise<AbsoluteMobileReleaseDoctorResult>;

package/dist/src/mobile/releasePublisher.d.ts

@@ -0,0 +1,130 @@
+import type { AbsoluteAndroidReleaseMetadata } from './androidRelease';
+import type { AbsoluteIosReleaseMetadata } from './iosRelease';
+export type AbsoluteGooglePlayReleaseTarget = {
+    changesNotSentForReview?: boolean;
+    inAppUpdatePriority?: number;
+    name?: string;
+    releaseNotes?: readonly {
+        language: string;
+        text: string;
+    }[];
+    reviewBehavior?: 'CANCEL_IN_REVIEW_AND_SUBMIT' | 'ERROR_IF_IN_REVIEW';
+    status?: 'completed' | 'draft' | 'halted' | 'inProgress';
+    track: string;
+    userFraction?: number;
+};
+export type AbsoluteAppStoreConnectReleaseTarget = {
+    groups?: readonly string[];
+    submitForReview?: boolean;
+    whatsNew?: readonly {
+        locale: string;
+        text: string;
+    }[];
+};
+export type AbsoluteNativeReleasePublication = {
+    channel?: {
+        channel: string;
+        releaseId: string;
+    };
+    record: {
+        metadata: AbsoluteAndroidReleaseMetadata | AbsoluteIosReleaseMetadata;
+    };
+    reused: boolean;
+    googlePlay?: {
+        receipt: {
+            intent: {
+                track: string;
+            };
+            packageName: string;
+            provider: 'google-play';
+            releaseId: string;
+            sha256: string;
+            stage: string;
+            versionCode?: string;
+        };
+        reused: boolean;
+    };
+    appStoreConnect?: {
+        receipt: {
+            appleAppId: string;
+            buildId?: string;
+            buildNumber: number;
+            intent: {
+                groups: string[];
+                submitForReview: boolean;
+            };
+            marketingVersion: string;
+            provider: 'app-store-connect';
+            releaseId: string;
+            sha256: string;
+            stage: string;
+        };
+        reused: boolean;
+    };
+};
+export type AbsoluteNativeReleasePublisher = {
+    prepareAndroidRelease?: (options: {
+        buildIdentity: string;
+        googlePlay?: AbsoluteGooglePlayReleaseTarget;
+        packageName: string;
+        signal?: AbortSignal;
+    }) => Promise<{
+        versionCode?: number;
+    }>;
+    prepareIosRelease?: (options: {
+        buildIdentity: string;
+        bundleId: string;
+        marketingVersion: string;
+        signal?: AbortSignal;
+    }) => Promise<{
+        buildNumber: number;
+    }>;
+    publish: (options: {
+        allowUnsigned?: boolean;
+        appStoreConnect?: AbsoluteAppStoreConnectReleaseTarget;
+        channel?: string;
+        googlePlay?: AbsoluteGooglePlayReleaseTarget;
+        releaseRoot: string;
+        signal?: AbortSignal;
+    }) => Promise<AbsoluteNativeReleasePublication>;
+};
+export declare const prepareAbsoluteIosRelease: (publisher: AbsoluteNativeReleasePublisher, options: {
+    buildIdentity: string;
+    bundleId: string;
+    marketingVersion: string;
+    signal?: AbortSignal;
+}) => Promise<number>;
+type PrepareAbsoluteAndroidReleaseOptions = {
+    buildIdentity: string;
+    googlePlay: AbsoluteGooglePlayReleaseTarget;
+    packageName: string;
+    signal?: AbortSignal;
+};
+export declare const prepareAbsoluteAndroidRelease: (publisher: AbsoluteNativeReleasePublisher, options: PrepareAbsoluteAndroidReleaseOptions) => Promise<number>;
+export type PublishAbsoluteAndroidReleaseOptions = {
+    allowUnsigned?: boolean;
+    channel?: string;
+    googlePlay?: AbsoluteGooglePlayReleaseTarget;
+    modulePath: string;
+    projectRoot: string;
+    release: {
+        metadata: AbsoluteAndroidReleaseMetadata;
+        releaseRoot: string;
+    };
+    signal?: AbortSignal;
+};
+export declare const loadAbsoluteNativeReleasePublisher: (projectRoot: string, requestedModulePath: string) => Promise<AbsoluteNativeReleasePublisher>;
+export declare const publishAbsoluteAndroidRelease: (options: PublishAbsoluteAndroidReleaseOptions) => Promise<AbsoluteNativeReleasePublication>;
+export declare const publishAbsoluteIosRelease: (options: {
+    allowUnsigned?: boolean;
+    appStoreConnect?: AbsoluteAppStoreConnectReleaseTarget;
+    channel?: string;
+    modulePath: string;
+    projectRoot: string;
+    release: {
+        metadata: AbsoluteIosReleaseMetadata;
+        releaseRoot: string;
+    };
+    signal?: AbortSignal;
+}) => Promise<AbsoluteNativeReleasePublication>;
+export {};

package/dist/src/mobile/remoteMacAgent.d.ts

@@ -0,0 +1,2 @@
+export declare const runAbsoluteRemoteMacAgent: (args: string[]) => Promise<void>;
+export declare const runAbsoluteRemoteMacAgentSafely: (args: string[]) => Promise<void>;

package/dist/src/mobile/remoteMacAgentEntry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/mobile/remoteMacProtocol.d.ts

@@ -0,0 +1,114 @@
+import type { FileSink } from 'bun';
+import type { NormalizedAbsoluteMobileConfig } from './config';
+import type { AbsoluteIosDevPhaseTiming, AbsoluteIosDevSession, AbsoluteIosDevState, AbsoluteIosNativeLogEntry } from './iosSimulatorController';
+export { ABSOLUTE_REMOTE_MAC_EVENT_PREFIX, ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION } from './remoteMacWire';
+export type AbsoluteRemoteMacProfile = {
+    bunPath: string;
+    createdAt: string;
+    destination: string;
+    name: string;
+    port?: number;
+    workspaceRoot: string;
+    xcodeVersion: string;
+};
+export type AbsoluteRemoteMacInspection = {
+    bunPath: string;
+    home: string;
+    os: string;
+    xcodeVersion: string;
+};
+export type AbsoluteRemoteIosDevProject = {
+    cap: string;
+    config: NormalizedAbsoluteMobileConfig;
+    nativeDirectory: string;
+    projectRoot: string;
+    profile: AbsoluteRemoteMacProfile;
+    remoteProjectRoot: string;
+    remote: true;
+    xcodebuild: string;
+    xcrun: string;
+};
+export type AbsoluteIosDevelopmentProject = AbsoluteRemoteIosDevProject | (import('./iosSimulatorController').AbsoluteIosDevProject & {
+    remote?: false;
+});
+export type AbsoluteRemoteMacCommandResult = {
+    exitCode: number;
+    stderr: string;
+    stdout: string;
+};
+export type AbsoluteRemoteMacTransport = {
+    capture: (command: string[]) => Promise<AbsoluteRemoteMacCommandResult>;
+    spawn: (command: string[], options: {
+        signal?: AbortSignal;
+    }) => {
+        exited: Promise<number>;
+        kill: () => void;
+        stderr: ReadableStream<Uint8Array>;
+        stdin: FileSink;
+        stdout: ReadableStream<Uint8Array>;
+    };
+};
+export type AbsoluteRemoteIosOptions = {
+    https?: boolean;
+    log?: (message: string) => void;
+    nativeLog?: (entry: AbsoluteIosNativeLogEntry) => void;
+    onPhaseTiming?: (timing: AbsoluteIosDevPhaseTiming) => void;
+    onStateChange?: (state: AbsoluteIosDevState) => void;
+    port: number;
+    project: AbsoluteRemoteIosDevProject;
+    signal?: AbortSignal;
+    installAgent?: (project: AbsoluteRemoteIosDevProject) => Promise<{
+        remotePath: string;
+        uploaded?: boolean;
+    }>;
+    syncProject?: (project: AbsoluteRemoteIosDevProject) => Promise<void>;
+    transport?: AbsoluteRemoteMacTransport;
+};
+export declare const validateAbsoluteRemoteMacProfileName: (name: string) => string;
+export declare const validateAbsoluteSshDestination: (destination: string) => string;
+export declare const absoluteRemoteMacSshBase: (profile: Pick<AbsoluteRemoteMacProfile, "destination" | "port">, options?: {
+    acceptNew?: boolean;
+}) => string[];
+export declare const getAbsoluteRemoteMacProfile: (name?: string, profilePath?: string) => Promise<AbsoluteRemoteMacProfile | undefined>;
+export declare const inspectAbsoluteRemoteMac: (destination: string, options?: {
+    acceptNew?: boolean;
+    port?: number;
+    transport?: Pick<AbsoluteRemoteMacTransport, "capture">;
+}) => Promise<{
+    bunPath: string;
+    home: string;
+    os: string;
+    xcodeVersion: string;
+}>;
+export declare const listAbsoluteRemoteMacProfiles: (profilePath?: string) => Promise<{
+    defaultProfile: string | undefined;
+    profiles: AbsoluteRemoteMacProfile[];
+}>;
+export declare const pairAbsoluteRemoteMac: (options: {
+    destination: string;
+    name: string;
+    port?: number;
+    profilePath?: string;
+    transport?: Pick<AbsoluteRemoteMacTransport, "capture">;
+    workspaceRoot?: string;
+}) => Promise<AbsoluteRemoteMacProfile>;
+export declare const removeAbsoluteRemoteMacProfile: (name: string, profilePath?: string) => Promise<boolean>;
+export declare const createAbsoluteRemoteIosDevProject: (config: NormalizedAbsoluteMobileConfig, projectRoot: string, profile: AbsoluteRemoteMacProfile) => AbsoluteRemoteIosDevProject;
+export declare const installAbsoluteRemoteMacAgent: (project: AbsoluteRemoteIosDevProject) => Promise<{
+    remotePath: string;
+    uploaded: boolean;
+    bytes: number;
+    path: string;
+    sha256: string;
+}>;
+export declare const materializeAbsoluteRemoteMacAgent: (projectRoot: string) => Promise<{
+    bytes: number;
+    path: string;
+    sha256: string;
+}>;
+export declare const absoluteRemoteProjectSyncCommands: (project: AbsoluteRemoteIosDevProject) => {
+    remote: string[];
+    tar: string[];
+};
+export declare const syncAbsoluteRemoteMacProject: (project: AbsoluteRemoteIosDevProject) => Promise<void>;
+export declare const startAbsoluteRemoteIosDevSession: (options: AbsoluteRemoteIosOptions) => Promise<AbsoluteIosDevSession>;

package/dist/src/mobile/remoteMacWire.d.ts

@@ -0,0 +1,2 @@
+export declare const ABSOLUTE_REMOTE_MAC_EVENT_PREFIX = "ABSOLUTE_REMOTE_MAC\t";
+export declare const ABSOLUTE_REMOTE_MAC_PROTOCOL_VERSION = 1;

package/dist/src/mobile/routeMatcher.d.ts

@@ -0,0 +1,3 @@
+import type { AbsoluteMobileCompatibilityRoute } from './releaseArtifact';
+export declare const matchesAbsoluteMobileRoutePattern: (pattern: string, pathname: string) => boolean;
+export declare const resolveAbsoluteMobileRoute: (routes: readonly AbsoluteMobileCompatibilityRoute[], pathname: string, method?: "GET" | "HEAD") => AbsoluteMobileCompatibilityRoute | undefined;