yaver-feedback-react-native 0.9.2 → 0.9.4

package/dist/_core/remoteless.js

@@ -0,0 +1,75 @@
+"use strict";
+// AUTO-SYNCED from shared/client-core/src/remoteless.ts.
+// DO NOT EDIT IN PLACE. Edit the source and re-run
+// scripts/sync-client-core.sh. CI checks drift via `--check`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remotelessCapability = remotelessCapability;
+exports.resolveRemotelessPlacement = resolveRemotelessPlacement;
+const LOCAL_SUPPORT = {
+    "analysis-chat": "supported", "code-edit": "bounded", "git-read": "supported", "git-commit": "bounded",
+    "git-push": "bounded", "static-preflight": "supported",
+    "existing-web-artifact": "supported", "dev-server": "unavailable",
+    "web-build": "unavailable", "flutter-render": "unavailable",
+    "native-build": "unavailable", simulator: "unavailable", shell: "unavailable",
+    test: "unavailable", deploy: "unavailable", container: "unavailable",
+};
+const LABELS = {
+    "analysis-chat": "analysis and chat", "code-edit": "editing", "git-read": "Git inspection", "git-commit": "Git commit",
+    "git-push": "Git push", "static-preflight": "static preflight",
+    "existing-web-artifact": "an existing web artifact", "dev-server": "a dev server",
+    "web-build": "a web build", "flutter-render": "Flutter rendering",
+    "native-build": "a native build", simulator: "a simulator", shell: "shell commands",
+    test: "tests", deploy: "deployment", container: "containers",
+};
+function remotelessCapability(capability, surface) {
+    const support = capability === "analysis-chat" ? "supported" : surface === "ios" || surface === "android"
+        ? LOCAL_SUPPORT[capability]
+        : capability === "existing-web-artifact" ? "supported" : "unavailable";
+    const label = LABELS[capability];
+    const host = surface === "ios" ? "iPhone/iPad" : surface === "android" ? "Android device" : surface === "web" ? "browser" : "companion device";
+    if (support === "supported")
+        return {
+            capability, support, code: `remoteless.${capability}.supported`,
+            summary: `${label} can run on this device`,
+            detail: `${label} does not require a remote shell or build toolchain.`,
+            route: { label: "Choose a device", path: "/devices" },
+        };
+    if (support === "bounded")
+        return {
+            capability, support, code: `remoteless.${capability}.bounded`,
+            summary: `${label} is available on this device with limits`,
+            detail: `${label} can run locally, but background execution is bounded and interrupted work returns to Review.`,
+            route: { label: "Choose a device", path: "/devices" },
+        };
+    return {
+        capability, support, code: `remoteless.${capability}.unavailable`,
+        summary: `${label} needs another execution target`,
+        detail: capability === "flutter-render"
+            ? `The ${host} can display an already-built Flutter web artifact, but Yaver's remoteless runtime has no Flutter SDK, shell, dev server, or simulator. Build and serve it on your primary/secondary device or Cloud Workspace.`
+            : `Yaver's remoteless runtime on this ${host} cannot provide ${label}: it has no general shell, package manager, persistent process host, simulator, native SDK, or container runtime. Use an eligible primary/secondary device or Cloud Workspace.`,
+        route: { label: "Choose a capable device", path: "/devices" },
+        alternateRoute: { label: "Use Cloud Workspace", path: "/cloud-onboarding" },
+    };
+}
+function resolveRemotelessPlacement(input) {
+    const capability = remotelessCapability(input.capability, input.surface);
+    if (!input.forceLocal) {
+        // Enforce precedence here instead of trusting every surface to construct
+        // its array correctly. Within a role, caller order remains significant
+        // (for example project-assigned primary before account-wide primary).
+        const target = ["explicit", "primary", "secondary", "focused"]
+            .map((role) => input.candidates.find((candidate) => candidate.role === role && candidate.connected))
+            .find((candidate) => !!candidate);
+        if (target) {
+            const degraded = target.role === "secondary";
+            return { lane: "remote", target, degraded, banner: degraded ? `Using secondary · ${target.name} · primary unavailable` : null };
+        }
+    }
+    const configured = input.candidates.filter((candidate) => candidate.role !== "focused");
+    const reason = configured.length ? "Primary and secondary devices are unavailable." : "No eligible remote device is configured.";
+    if (capability.support === "unavailable")
+        return { lane: "blocked", capability, banner: `${reason} ${capability.summary}.` };
+    if (input.forceLocal)
+        return { lane: "remoteless", capability, banner: `No remote box selected · ${capability.summary}.` };
+    return { lane: "remoteless", capability, banner: `Remoteless fallback · ${reason} ${capability.summary}.` };
+}

package/dist/_core/trace.d.ts

@@ -0,0 +1,47 @@
+/**
+ * trace.ts — one shared paste-ready trace assembler for every surface.
+ *
+ * WHY (2026-08-09): a crash/failure on web, mobile, or the console used to
+ * copy different things — RawFailureBanner copied just `failure.raw`, the
+ * mobile Logs sheet copied `combinedLogText`, RuntimeLab copied raw console
+ * lines. None carried the surface identity, versions, task id, runner/model,
+ * or the log tail, so pasting into an issue or a vibing follow-up lost the
+ * context that makes a bug reproducible. One assembler here gives every
+ * surface the SAME structured blob (surface → versions → device/relay →
+ * task → error → log tail), so web and mobile can never drift
+ * (AGENTS.md: one shared classifier, no copies). Mirrored into
+ * mobile/src/_core and web/lib/_core by scripts/sync-client-core.sh.
+ */
+export interface TraceContext {
+    /** Surface name: "web" | "mobile" | "console" | "cli" | "watch" ... */
+    surface: string;
+    /** e.g. web build label, mobile JS bundle version, cli version. */
+    surfaceVersion?: string;
+    /** Agent version reported by /info (e.g. "1.99.409"). */
+    agentVersion?: string;
+    /** Device the task ran on (name + id). */
+    device?: string;
+    /** Relay region / id if known. */
+    relay?: string;
+    /** Task identity + lifecycle. */
+    task?: {
+        id: string;
+        status?: string;
+        runner?: string;
+        model?: string;
+        title?: string;
+    };
+    /** The human-readable error (already extracted/named). */
+    error?: string;
+    /** Raw failure blob (the undecorated original). */
+    raw?: string;
+    /** Log tail — last N lines of the relevant log (agent/relay/runtime). */
+    logTail?: string;
+    /** When the trace was captured (ms epoch). */
+    ts?: number;
+}
+/**
+ * Assemble a paste-ready trace. Every present field becomes one labelled
+ * line; nothing is ever invented. Returns a plain-text blob.
+ */
+export declare function assembleTrace(ctx: TraceContext): string;

package/dist/_core/trace.js

@@ -0,0 +1,38 @@
+"use strict";
+// AUTO-SYNCED from shared/client-core/src/trace.ts.
+// DO NOT EDIT IN PLACE. Edit the source and re-run
+// scripts/sync-client-core.sh. CI checks drift via `--check`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assembleTrace = assembleTrace;
+const MASK = /token\s*[=:]\s*\S+|Bearer\s+\S+|api[_-]?key\s*[=:]\s*\S+|password\s*[=:]\s*\S+/gi;
+function sanitize(s) {
+    return String(s || "").replace(MASK, "[redacted]");
+}
+/**
+ * Assemble a paste-ready trace. Every present field becomes one labelled
+ * line; nothing is ever invented. Returns a plain-text blob.
+ */
+function assembleTrace(ctx) {
+    const out = [];
+    out.push("--- Yaver trace ---");
+    out.push(`surface: ${sanitize(ctx.surface)}`);
+    if (ctx.surfaceVersion)
+        out.push(`surface.version: ${sanitize(ctx.surfaceVersion)}`);
+    if (ctx.agentVersion)
+        out.push(`agent.version: ${sanitize(ctx.agentVersion)}`);
+    if (ctx.device)
+        out.push(`device: ${sanitize(ctx.device)}`);
+    if (ctx.relay)
+        out.push(`relay: ${sanitize(ctx.relay)}`);
+    if (ctx.task) {
+        out.push(`task: ${sanitize(ctx.task.id)}${ctx.task.status ? ` status=${sanitize(ctx.task.status)}` : ""}${ctx.task.runner ? ` runner=${sanitize(ctx.task.runner)}` : ""}${ctx.task.model ? ` model=${sanitize(ctx.task.model)}` : ""}${ctx.task.title ? ` title=${sanitize(ctx.task.title)}` : ""}`);
+    }
+    if (ctx.error)
+        out.push(`error: ${sanitize(ctx.error)}`);
+    if (ctx.raw)
+        out.push(`raw: ${sanitize(ctx.raw)}`);
+    if (ctx.logTail)
+        out.push(`log-tail:\n${sanitize(ctx.logTail)}`);
+    out.push(`ts: ${ctx.ts ?? Date.now()}`);
+    return out.join("\n");
+}

package/dist/_core/trace.test.d.ts

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

package/dist/_core/trace.test.js

@@ -0,0 +1,60 @@
+"use strict";
+// AUTO-SYNCED from shared/client-core/src/trace.test.ts.
+// DO NOT EDIT IN PLACE. Edit the source and re-run
+// scripts/sync-client-core.sh. CI checks drift via `--check`.
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * trace.test.ts — guards for the shared trace assembler.
+ *
+ * Run: npx tsx shared/client-core/src/trace.test.ts
+ */
+const trace_1 = require("./trace");
+let failures = 0;
+const eq = (got, want, label) => {
+    if (JSON.stringify(got) === JSON.stringify(want))
+        console.log(`ok   ${label}`);
+    else {
+        console.error(`FAIL ${label}:\n  got  ${JSON.stringify(got)}\n  want ${JSON.stringify(want)}`);
+        failures++;
+    }
+};
+const ok = (c, label) => eq(Boolean(c), true, label);
+{
+    const t = (0, trace_1.assembleTrace)({
+        surface: "web",
+        surfaceVersion: "1.1.164",
+        agentVersion: "1.99.409",
+        device: "ubuntu-4gb-hel1-1 (2ed7da41…)",
+        relay: "public-free",
+        task: { id: "abc123", status: "failed", runner: "opencode", model: "deepseek/deepseek-v4-flash", title: "build" },
+        error: "flutter exited before becoming ready",
+        raw: "the raw failure bytes",
+        logTail: "line1\nline2",
+        ts: 1700000000000,
+    });
+    ok(t.includes("surface: web"), "surface line present");
+    ok(t.includes("agent.version: 1.99.409"), "agent version present");
+    ok(t.includes("task: abc123 status=failed runner=opencode"), "task line present");
+    ok(t.includes("error: flutter exited before becoming ready"), "error present");
+    ok(t.includes("log-tail:\nline1\nline2"), "log tail present under its label");
+    ok(t.includes("ts: 1700000000000"), "timestamp present");
+}
+{
+    // No invented fields when absent.
+    const t = (0, trace_1.assembleTrace)({ surface: "mobile", task: { id: "x" } });
+    ok(!t.includes("agent.version"), "no agent.version when absent");
+    ok(!t.includes("error:"), "no error when absent");
+    ok(t.includes("surface: mobile"), "surface still present");
+}
+{
+    // Secrets are redacted.
+    const t = (0, trace_1.assembleTrace)({ surface: "web", error: "failed with token=abc123xyz" });
+    ok(t.includes("[redacted]") && !t.includes("abc123xyz"), "token redacted from error");
+    const t2 = (0, trace_1.assembleTrace)({ surface: "mobile", raw: "Authorization: Bearer deadbeef" });
+    ok(t2.includes("[redacted]") && !t2.includes("deadbeef"), "bearer redacted from raw");
+}
+if (failures > 0) {
+    console.error(`\n${failures} FAILURE(s)`);
+    process.exit(1);
+}
+console.log("\nall trace tests pass");

package/dist/auth.d.ts

@@ -10,7 +10,7 @@
  *     (`yaver://oauth-callback`) the Yaver mobile app uses.
  *   - Email / password sign-up + login (no 2FA flow — for SDK simplicity).
  *   - Token validation.
- *   - `/devices/list` → owned + shared (guest) remote dev machines.
+ *   - `/devices/list` → owner remote dev machines.
  *
  * Mobile-only. A web equivalent will ship as a separate `yaver-web-feedback`
  * package; do not import this module from a browser bundle.
@@ -99,12 +99,6 @@ export interface RemoteDevice {
     needsAuth: boolean;
     runnerDown: boolean;
     lastHeartbeat: number;
-    isGuest: boolean;
-    hostUserId?: string;
-    hostName?: string;
-    hostEmail?: string;
-    hostUserIdString?: string;
-    accessScope: 'owner' | 'shared-scoped' | 'shared-legacy';
     quicHost: string;
     quicPort: number;
     /** Agent HTTP port — preferred over quicPort when present. */
@@ -121,53 +115,14 @@ export interface RemoteDevice {
 }
 export interface DeviceList {
     owned: RemoteDevice[];
-    shared: RemoteDevice[];
 }
 export interface DeviceReachability {
     reachable: boolean;
     url?: string;
 }
-export interface GuestInvitation {
-    hostUserId: string;
-    hostName: string;
-    hostEmail: string;
-    hostUserIdString?: string;
-    createdAt: number;
-    expiresAt: number;
-    inviteCode?: string;
-}
-export interface ActiveGuestHost {
-    hostUserId: string;
-    hostName: string;
-    hostEmail: string;
-    grantedAt: number;
-}
-export interface GuestHostsResponse {
-    pending: GuestInvitation[];
-    active: ActiveGuestHost[];
-}
-export interface InvitationHostDevice {
-    deviceId: string;
-    name: string;
-    platform: string;
-    lastHeartbeat?: number;
-    proposed: boolean;
-}
-export interface InvitationPreview {
-    inviteCode: string;
-    hostUserId: string;
-    hostName: string;
-    hostEmail: string;
-    hostUserIdString?: string;
-    proposedDeviceIds?: string[];
-    hostDevices: InvitationHostDevice[];
-    invitedByUserId?: boolean;
-    expiresAt: number;
-    createdAt: number;
-}
 /**
- * Fetch the set of remote dev machines this user can reach. Splits into
- * owned (user is the host) vs shared (host invited them as a guest).
+ * Fetch the signed-in owner's remote dev machines. Legacy non-owner rows are
+ * discarded even if a stale backend still returns them.
  *
  * Collapses duplicate rows before splitting — Convex can return multiple
  * rows per physical machine after a re-pair or hostname change, and the
@@ -176,15 +131,3 @@ export interface InvitationPreview {
 export declare function listReachableDevices(token: string): Promise<DeviceList>;
 export declare function buildDeviceCandidateUrls(device: RemoteDevice): string[];
 export declare function probeDeviceReachability(device: RemoteDevice, timeoutMs?: number): Promise<DeviceReachability>;
-export declare function mintGuestSdkToken(token: string, hostUserId: string, targetDeviceId: string): Promise<{
-    token: string;
-    expiresAt: number;
-    allowedProjects?: string[];
-}>;
-export declare function fetchGuestHosts(token: string): Promise<GuestHostsResponse>;
-export declare function findInviteByCode(token: string, code: string): Promise<InvitationPreview | null>;
-export declare function acceptGuestByCode(token: string, code: string, approvedDeviceIds?: string[]): Promise<{
-    hostName: string;
-    hostEmail: string;
-}>;
-export declare function acceptGuestInvitation(token: string, hostUserId: string, approvedDeviceIds?: string[]): Promise<void>;

package/dist/auth.js

@@ -11,7 +11,7 @@
  *     (`yaver://oauth-callback`) the Yaver mobile app uses.
  *   - Email / password sign-up + login (no 2FA flow — for SDK simplicity).
  *   - Token validation.
- *   - `/devices/list` → owned + shared (guest) remote dev machines.
+ *   - `/devices/list` → owner remote dev machines.
  *
  * Mobile-only. A web equivalent will ship as a separate `yaver-web-feedback`
  * package; do not import this module from a browser bundle.
@@ -39,11 +39,6 @@ exports.loginWithEmail = loginWithEmail;
 exports.listReachableDevices = listReachableDevices;
 exports.buildDeviceCandidateUrls = buildDeviceCandidateUrls;
 exports.probeDeviceReachability = probeDeviceReachability;
-exports.mintGuestSdkToken = mintGuestSdkToken;
-exports.fetchGuestHosts = fetchGuestHosts;
-exports.findInviteByCode = findInviteByCode;
-exports.acceptGuestByCode = acceptGuestByCode;
-exports.acceptGuestInvitation = acceptGuestInvitation;
 // AsyncStorage is an optional peer dep — degrade gracefully if missing.
 let AsyncStorage = null;
 try {
@@ -358,8 +353,8 @@ async function loginWithEmail(email, password) {
     return { token: data.token, userId: data.userId };
 }
 /**
- * Fetch the set of remote dev machines this user can reach. Splits into
- * owned (user is the host) vs shared (host invited them as a guest).
+ * Fetch the signed-in owner's remote dev machines. Legacy non-owner rows are
+ * discarded even if a stale backend still returns them.
  *
  * Collapses duplicate rows before splitting — Convex can return multiple
  * rows per physical machine after a re-pair or hostname change, and the
@@ -371,7 +366,7 @@ async function listReachableDevices(token) {
             headers: { Authorization: `Bearer ${token}` },
         });
         if (!res.ok)
-            return { owned: [], shared: [] };
+            return { owned: [] };
         const data = await res.json();
         const raw = (data.devices ?? []);
         // Normalise Convex field names → SDK's RemoteDevice shape. The
@@ -385,12 +380,6 @@ async function listReachableDevices(token) {
             needsAuth: !!d.needsAuth,
             runnerDown: !!d.runnerDown,
             lastHeartbeat: d.lastHeartbeat ?? 0,
-            isGuest: !!d.isGuest,
-            hostUserId: d.hostUserId,
-            hostName: d.hostName,
-            hostEmail: d.hostEmail,
-            hostUserIdString: d.hostUserIdString,
-            accessScope: d.accessScope ?? 'owner',
             quicHost: d.quicHost ?? d.host ?? '',
             quicPort: d.quicPort ?? 0,
             httpPort: d.httpPort ?? d.quicPort,
@@ -405,13 +394,10 @@ async function listReachableDevices(token) {
         // Lazy require so Jest + tree-shakers don't choke on a circular import.
         const { collapseRemoteDevices } = require('./deviceDedup');
         const deduped = collapseRemoteDevices(normalised);
-        return {
-            owned: deduped.filter((d) => !d.isGuest),
-            shared: deduped.filter((d) => d.isGuest),
-        };
+        return { owned: deduped };
     }
     catch {
-        return { owned: [], shared: [] };
+        return { owned: [] };
     }
 }
 function buildDeviceCandidateUrls(device) {
@@ -453,71 +439,3 @@ async function probeDeviceReachability(device, timeoutMs = 2500) {
     }
     return { reachable: false };
 }
-async function mintGuestSdkToken(token, hostUserId, targetDeviceId) {
-    const res = await fetch(`${convexSiteUrl}/guests/sdk-token`, {
-        method: 'POST',
-        headers: {
-            Authorization: `Bearer ${token}`,
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ hostUserId, targetDeviceId }),
-    });
-    if (!res.ok) {
-        const data = await res.json().catch(() => ({}));
-        throw new Error(data.error || 'Failed to mint delegated SDK token');
-    }
-    return res.json();
-}
-async function fetchGuestHosts(token) {
-    const res = await fetch(`${convexSiteUrl}/guests/hosts`, {
-        headers: { Authorization: `Bearer ${token}` },
-    });
-    if (!res.ok) {
-        const data = await res.json().catch(() => ({}));
-        throw new Error(data.error || 'Failed to fetch guest hosts');
-    }
-    return res.json();
-}
-async function findInviteByCode(token, code) {
-    const cleaned = code.toUpperCase().trim();
-    const res = await fetch(`${convexSiteUrl}/guests/find-by-code?code=${encodeURIComponent(cleaned)}`, { headers: { Authorization: `Bearer ${token}` } });
-    if (res.status === 404)
-        return null;
-    if (!res.ok) {
-        const data = await res.json().catch(() => ({}));
-        throw new Error(data.error || 'Failed to load invite');
-    }
-    return res.json();
-}
-async function acceptGuestByCode(token, code, approvedDeviceIds) {
-    const res = await fetch(`${convexSiteUrl}/guests/accept-code`, {
-        method: 'POST',
-        headers: {
-            Authorization: `Bearer ${token}`,
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-            code: code.toUpperCase().trim(),
-            approvedDeviceIds,
-        }),
-    });
-    if (!res.ok) {
-        const data = await res.json().catch(() => ({}));
-        throw new Error(data.error || 'Invalid invite code');
-    }
-    return res.json();
-}
-async function acceptGuestInvitation(token, hostUserId, approvedDeviceIds) {
-    const res = await fetch(`${convexSiteUrl}/guests/accept`, {
-        method: 'POST',
-        headers: {
-            Authorization: `Bearer ${token}`,
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ hostUserId, approvedDeviceIds }),
-    });
-    if (!res.ok) {
-        const data = await res.json().catch(() => ({}));
-        throw new Error(data.error || 'Failed to accept invitation');
-    }
-}

package/dist/deviceDogfood.d.ts

@@ -0,0 +1,53 @@
+type SecureStoreLike = {
+    getItemAsync(key: string): Promise<string | null>;
+    setItemAsync(key: string, value: string): Promise<void>;
+    deleteItemAsync(key: string): Promise<void>;
+};
+export type DeviceDogfoodState = 'unregistered' | 'pending' | 'active' | 'cancelled' | 'revoked' | 'superseded';
+export interface DeviceDogfoodOptions {
+    /** Public identifier registered by the app owner in Yaver Settings. */
+    appId: string;
+    label?: string;
+    backendUrl?: string;
+    /** Advanced bare-RN integration. Expo apps use SecureStore automatically. */
+    secureStore?: SecureStoreLike;
+}
+export interface DeviceDogfoodSession {
+    active: true;
+    appId: string;
+    installationId: string;
+    token: string;
+    expiresAt: number;
+    scopes: string[];
+    projectSlug?: string;
+    targetDeviceId?: string;
+}
+/** Account-free third-party Dogfood enrollment. The UUID is a public lookup
+ * handle; possession is proven by the private key retained in this app. */
+export declare class YaverDeviceDogfood {
+    private readonly options;
+    private readonly backendUrl;
+    private readonly store;
+    private readonly storageKey;
+    constructor(options: DeviceDogfoodOptions);
+    private identity;
+    enrollmentInfo(): Promise<{
+        appId: string;
+        installationId: string;
+        registrationSlot: string;
+        publicKey: string;
+    }>;
+    enroll(platform?: string): Promise<{
+        status: DeviceDogfoodState;
+        installationId: string;
+    }>;
+    status(): Promise<DeviceDogfoodState>;
+    session(): Promise<DeviceDogfoodSession | null>;
+    /** Rotate the key but keep the logical slot. Approval supersedes the prior
+     * generation, making its already-issued sessions fail immediately. */
+    reRegister(platform?: string): Promise<{
+        status: DeviceDogfoodState;
+        installationId: string;
+    }>;
+}
+export {};

package/dist/deviceDogfood.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YaverDeviceDogfood = void 0;
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const buffer_1 = require("buffer");
+const auth_1 = require("./auth");
+function b64(bytes) { return buffer_1.Buffer.from(bytes).toString('base64'); }
+function fromB64(value) { return new Uint8Array(buffer_1.Buffer.from(value, 'base64')); }
+function b64url(bytes) {
+    return buffer_1.Buffer.from(bytes).toString('base64').replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+}
+function randomBytes(length) {
+    const cryptoObject = globalThis?.crypto;
+    if (cryptoObject?.getRandomValues) {
+        const out = new Uint8Array(length);
+        cryptoObject.getRandomValues(out);
+        return out;
+    }
+    try {
+        return require('expo-crypto').getRandomBytes(length);
+    }
+    catch {
+        throw new Error('Secure randomness is unavailable. Install expo-crypto or provide global crypto.getRandomValues.');
+    }
+}
+function defaultSecureStore() {
+    try {
+        const store = require('expo-secure-store');
+        if (store?.getItemAsync && store?.setItemAsync)
+            return store;
+    }
+    catch { /* named error below */ }
+    throw new Error('Secure Dogfood identity storage is unavailable. Install expo-secure-store or pass secureStore.');
+}
+async function responseJSON(response) {
+    const body = await response.json().catch(() => ({}));
+    if (!response.ok)
+        throw new Error(body?.error || `Yaver Dogfood request failed (HTTP ${response.status})`);
+    return body;
+}
+function enrollmentMessage(appId, installationId, challenge) {
+    return new TextEncoder().encode(`yaver-dogfood-enroll-v1\n${appId}\n${installationId}\n${challenge}`);
+}
+function sessionMessage(appId, installationId, challenge) {
+    return new TextEncoder().encode(`yaver-dogfood-session-v1\n${appId}\n${installationId}\n${challenge}`);
+}
+/** Account-free third-party Dogfood enrollment. The UUID is a public lookup
+ * handle; possession is proven by the private key retained in this app. */
+class YaverDeviceDogfood {
+    constructor(options) {
+        this.options = options;
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{2,127}$/.test(options.appId))
+            throw new Error('A valid Dogfood appId is required');
+        this.backendUrl = (options.backendUrl || auth_1.DEFAULT_CONVEX_SITE_URL).replace(/\/$/, '');
+        this.store = options.secureStore || defaultSecureStore();
+        this.storageKey = `yaver_feedback_dogfood_v1_${options.appId}`;
+    }
+    async identity() {
+        const raw = await this.store.getItemAsync(this.storageKey);
+        if (raw) {
+            try {
+                const saved = JSON.parse(raw);
+                if (fromB64(saved.publicKey).length === tweetnacl_1.default.sign.publicKeyLength && fromB64(saved.secretKey).length === tweetnacl_1.default.sign.secretKeyLength)
+                    return saved;
+            }
+            catch { /* rotate corrupt identity below */ }
+        }
+        const seed = randomBytes(32);
+        const pair = tweetnacl_1.default.sign.keyPair.fromSeed(seed);
+        seed.fill(0);
+        const identity = {
+            installationId: b64url(randomBytes(18)), registrationSlot: b64url(randomBytes(18)),
+            publicKey: b64(pair.publicKey), secretKey: b64(pair.secretKey),
+        };
+        await this.store.setItemAsync(this.storageKey, JSON.stringify(identity));
+        return identity;
+    }
+    async enrollmentInfo() {
+        const identity = await this.identity();
+        return { appId: this.options.appId, installationId: identity.installationId, registrationSlot: identity.registrationSlot, publicKey: identity.publicKey };
+    }
+    async enroll(platform = 'unknown') {
+        const identity = await this.identity();
+        const started = await responseJSON(await fetch(`${this.backendUrl}/dogfood/enroll/start`, {
+            method: 'POST', headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ appId: this.options.appId, installationId: identity.installationId, registrationSlot: identity.registrationSlot, publicKey: identity.publicKey, platform, label: this.options.label }),
+        }));
+        if (started.status === 'active')
+            return { status: 'active', installationId: identity.installationId };
+        const signature = b64(tweetnacl_1.default.sign.detached(enrollmentMessage(this.options.appId, identity.installationId, started.challenge), fromB64(identity.secretKey)));
+        await responseJSON(await fetch(`${this.backendUrl}/dogfood/enroll/prove`, {
+            method: 'POST', headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ appId: this.options.appId, installationId: identity.installationId, signature }),
+        }));
+        return { status: 'pending', installationId: identity.installationId };
+    }
+    async status() {
+        const identity = await this.identity();
+        const response = await fetch(`${this.backendUrl}/dogfood/enroll/status?appId=${encodeURIComponent(this.options.appId)}&installationId=${encodeURIComponent(identity.installationId)}`);
+        if (response.status === 404)
+            return 'unregistered';
+        return (await responseJSON(response)).status;
+    }
+    async session() {
+        const identity = await this.identity();
+        if (await this.status() !== 'active')
+            return null;
+        const challenge = await responseJSON(await fetch(`${this.backendUrl}/dogfood/session/challenge`, {
+            method: 'POST', headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ appId: this.options.appId, installationId: identity.installationId }),
+        }));
+        const signature = b64(tweetnacl_1.default.sign.detached(sessionMessage(this.options.appId, identity.installationId, challenge.challenge), fromB64(identity.secretKey)));
+        const result = await responseJSON(await fetch(`${this.backendUrl}/dogfood/session`, {
+            method: 'POST', headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ appId: this.options.appId, installationId: identity.installationId, signature }),
+        }));
+        return { active: true, appId: this.options.appId, installationId: identity.installationId, token: result.token, expiresAt: result.expiresAt, scopes: result.scopes || [], projectSlug: result.projectSlug, targetDeviceId: result.targetDeviceId };
+    }
+    /** Rotate the key but keep the logical slot. Approval supersedes the prior
+     * generation, making its already-issued sessions fail immediately. */
+    async reRegister(platform = 'unknown') {
+        const previous = await this.identity();
+        const seed = randomBytes(32);
+        const pair = tweetnacl_1.default.sign.keyPair.fromSeed(seed);
+        seed.fill(0);
+        const next = {
+            installationId: b64url(randomBytes(18)), registrationSlot: previous.registrationSlot,
+            publicKey: b64(pair.publicKey), secretKey: b64(pair.secretKey),
+        };
+        await this.store.setItemAsync(this.storageKey, JSON.stringify(next));
+        return this.enroll(platform);
+    }
+}
+exports.YaverDeviceDogfood = YaverDeviceDogfood;