@beeuni/sdk 0.1.0 → 0.3.0

package/dist/react/query-contracts.d.ts

@@ -45,5 +45,11 @@ export declare const FRESHNESS: {
     readonly modelPicker: "config";
     readonly gateway: "inventory";
     readonly triggers: "config";
+    readonly captureDevices: "directory";
+    readonly captureTimeline: "inventory";
+    readonly capturePolicy: "config";
+    readonly captureWorkspace: "config";
+    readonly captureEnrollmentTokens: "config";
+    readonly captureEnrollments: "directory";
 };
 export {};

package/dist/react/query-contracts.js

@@ -60,4 +60,10 @@ export const FRESHNESS = {
     modelPicker: 'config',
     gateway: 'inventory',
     triggers: 'config',
+    captureDevices: 'directory',
+    captureTimeline: 'inventory',
+    capturePolicy: 'config',
+    captureWorkspace: 'config',
+    captureEnrollmentTokens: 'config',
+    captureEnrollments: 'directory',
 };

package/dist/react/query-keys.d.ts

@@ -1,6 +1,18 @@
+import type { ReviewItemsQuery } from '../core/rest/projects-client/review.js';
 import type { ListProjectSessionsOptions } from '../core/rest/projects-client/sessions.js';
-type SessionListFilters = Pick<ListProjectSessionsOptions, 'parent' | 'startedBy' | 'q' | 'labels'>;
+type SessionListFilters = Pick<ListProjectSessionsOptions, 'parent' | 'startedBy' | 'q' | 'labels' | 'view'>;
 export declare const qk: {
+    readonly capture: {
+        readonly deviceGrant: (userCode: string) => readonly ["capture", "device-grant", string];
+        readonly account: (accountId: string) => readonly ["capture", "account", string];
+        readonly workspace: (accountId: string) => readonly ["capture", "account", string, "workspace"];
+        readonly devices: (accountId: string, scope: string, userId: string | null) => readonly ["capture", "account", string, "devices", string, string | null];
+        readonly timeline: (accountId: string) => readonly ["capture", "account", string, "timeline"];
+        readonly timelineRead: (accountId: string, kind: string, query: unknown) => readonly ["capture", "account", string, "timeline", string, unknown];
+        readonly policy: (accountId: string) => readonly ["capture", "account", string, "policy"];
+        readonly enrollmentTokens: (accountId: string) => readonly ["capture", "account", string, "enrollment-tokens"];
+        readonly enrollments: (accountId: string) => readonly ["capture", "account", string, "enrollments"];
+    };
     readonly accounts: {
         readonly scope: () => readonly ["kx", "accounts"];
         readonly list: (userId: string | null | undefined) => readonly ["kx", "accounts", string];
@@ -30,9 +42,11 @@ export declare const qk: {
         readonly session: (projectId: string, sessionId: string) => readonly ["kx", "drives", "session", string, string];
     };
     readonly project: {
-        readonly starterSuggestions: (id: string) => readonly ["kx", "project", string, "starter-suggestions"];
         readonly scope: (id: string) => readonly ["kx", "project", string];
         readonly needsInput: (id: string) => readonly ["kx", "project", string, "needs-input"];
+        readonly reviewSummary: (id: string) => readonly ["kx", "project", string, "review-summary"];
+        readonly reviewItemsScope: (id: string) => readonly ["kx", "project", string, "review-items"];
+        readonly reviewItemPages: (id: string, query?: ReviewItemsQuery) => readonly ["kx", "project", string, "review-items", "pages", "all" | import("../index.js").ReviewSegment, "all" | import("../index.js").ReviewItemKind, string, number | "default"];
         readonly summary: (id: string) => readonly ["kx", "project", string, "summary"];
         readonly detail: (id: string) => readonly ["kx", "project", string, "detail"];
         readonly config: (id: string) => readonly ["kx", "project", string, "config"];
@@ -41,6 +55,7 @@ export declare const qk: {
         readonly sessionsScope: (id: string) => readonly ["kx", "project", string, "sessions"];
         readonly sessions: (id: string, scope?: "visible" | "project") => readonly ["kx", "project", string, "sessions", "list", "project" | "visible"];
         readonly sessionsPaged: (id: string, scope?: "visible" | "project", filters?: SessionListFilters) => readonly ["kx", "project", string, "sessions", "list-paged", "project" | "visible"] | readonly ["kx", "project", string, "sessions", "list-paged", "project" | "visible", {
+            view?: "archived" | "pinned" | undefined;
             labels?: string[] | undefined;
             parent: string | null;
             startedBy: "me" | "others" | "automated" | null;

package/dist/react/query-keys.js

@@ -1,16 +1,29 @@
 function normalizeSessionListFilters(filters) {
     const q = filters?.q?.trim();
     const labels = filters?.labels?.length ? [...filters.labels].sort() : null;
-    if (!filters?.parent && !filters?.startedBy && !q && !labels)
+    const view = filters?.view;
+    if (!filters?.parent && !filters?.startedBy && !q && !labels && !view)
         return undefined;
     return {
         parent: filters?.parent ?? null,
         startedBy: filters?.startedBy ?? null,
         q: q ?? null,
         ...(labels ? { labels } : {}),
+        ...(view ? { view } : {}),
     };
 }
 export const qk = {
+    capture: {
+        deviceGrant: (userCode) => ['capture', 'device-grant', userCode],
+        account: (accountId) => ['capture', 'account', accountId],
+        workspace: (accountId) => [...qk.capture.account(accountId), 'workspace'],
+        devices: (accountId, scope, userId) => [...qk.capture.account(accountId), 'devices', scope, userId],
+        timeline: (accountId) => [...qk.capture.account(accountId), 'timeline'],
+        timelineRead: (accountId, kind, query) => [...qk.capture.timeline(accountId), kind, query],
+        policy: (accountId) => [...qk.capture.account(accountId), 'policy'],
+        enrollmentTokens: (accountId) => [...qk.capture.account(accountId), 'enrollment-tokens'],
+        enrollments: (accountId) => [...qk.capture.account(accountId), 'enrollments'],
+    },
     accounts: {
         scope: () => ['kx', 'accounts'],
         list: (userId) => [...qk.accounts.scope(), userId ?? 'anonymous'],
@@ -42,9 +55,18 @@ export const qk = {
         session: (projectId, sessionId) => [...qk.drives.scope(), 'session', projectId, sessionId],
     },
     project: {
-        starterSuggestions: (id) => [...qk.project.scope(id), 'starter-suggestions'],
         scope: (id) => ['kx', 'project', id],
         needsInput: (id) => [...qk.project.scope(id), 'needs-input'],
+        reviewSummary: (id) => [...qk.project.scope(id), 'review-summary'],
+        reviewItemsScope: (id) => [...qk.project.scope(id), 'review-items'],
+        reviewItemPages: (id, query = {}) => [
+            ...qk.project.reviewItemsScope(id),
+            'pages',
+            query.segment ?? 'all',
+            query.kind ?? 'all',
+            query.sessionId ?? 'all',
+            query.limit ?? 'default',
+        ],
         summary: (id) => [...qk.project.scope(id), 'summary'],
         detail: (id) => [...qk.project.scope(id), 'detail'],
         config: (id) => [...qk.project.scope(id), 'config'],

package/dist/react/reset-identity-state.js

@@ -4,6 +4,7 @@ import { useSessionWorkingStore } from '../browser/stores/session-working-store.
 import { useSyncStore } from '../browser/stores/sync-store.js';
 import { resetSessionCacheOwnership } from '../browser/session-sync/session-cache-ownership.js';
 import { resetSessionSyncControllers } from '../browser/session-sync/session-sync-registry.js';
+import { resetSessionOpenBundles } from '../core/session/open-bundle.js';
 import { registerIdentityReset, runIdentityResets } from './identity-reset-registry.js';
 import { resetSessionOpenPrefetches } from './prefetch-session-open.js';
 import './use-model-store.js';
@@ -14,6 +15,7 @@ registerIdentityReset(() => useDiagnosticsStore.getState().clearAll());
 registerIdentityReset(resetSessionSyncControllers);
 registerIdentityReset(resetSessionCacheOwnership);
 registerIdentityReset(resetSessionOpenPrefetches);
+registerIdentityReset(resetSessionOpenBundles);
 export function resetIdentityState() {
     runIdentityResets();
 }

package/dist/react/session-cache-write.d.ts

@@ -3,6 +3,7 @@ import { type ProjectSession } from '../core/rest/projects-client/sessions.js';
 export type ProjectSessionsUpdater = (sessions: ProjectSession[]) => ProjectSession[];
 export declare function applyToCachedSessionShape(cached: unknown, update: ProjectSessionsUpdater): unknown;
 export declare function updateCachedProjectSessions(queryClient: QueryClient, projectId: string, update: ProjectSessionsUpdater): void;
+export declare function findCachedProjectSession(queryClient: QueryClient, projectId: string, match: (session: ProjectSession) => boolean): ProjectSession | undefined;
 export declare function upsertIntoCachedSessionShape(cached: unknown, session: ProjectSession): unknown;
 export declare function removeCachedProjectSession(queryClient: QueryClient, projectId: string, sessionId: string): () => void;
 export declare function upsertCachedProjectSession(queryClient: QueryClient, projectId: string, session: ProjectSession): void;

package/dist/react/session-cache-write.js

@@ -21,6 +21,10 @@ function sessionBelongsInList(projectId, query, session) {
         return true;
     if (filters.q)
         return false;
+    if (filters.view === 'pinned' && !session.pinned_at)
+        return false;
+    if (filters.view === 'archived' && !session.archived_at)
+        return false;
     if (filters.parent === 'root' && parentId !== null)
         return false;
     if (filters.parent && filters.parent !== 'root')
@@ -68,6 +72,22 @@ export function updateCachedProjectSessions(queryClient, projectId, update) {
         predicate: (query) => isSessionCacheKey(projectId, query),
     }, (cached) => applyToCachedSessionShape(cached, update));
 }
+export function findCachedProjectSession(queryClient, projectId, match) {
+    let found;
+    const entries = queryClient.getQueriesData({
+        queryKey: qk.project.sessionsScope(projectId),
+        predicate: (query) => isSessionCacheKey(projectId, query),
+    });
+    for (const [, cached] of entries) {
+        applyToCachedSessionShape(cached, (rows) => {
+            found ??= rows.find(match);
+            return rows;
+        });
+        if (found)
+            return found;
+    }
+    return undefined;
+}
 export function upsertIntoCachedSessionShape(cached, session) {
     const upsert = (items) => {
         const index = items.findIndex((row) => row.session_id === session.session_id);

package/dist/react/session-transcript-subscription.js

@@ -1,5 +1,6 @@
 'use client';
 import { getSessionCacheOwnership, resolveSessionCacheOwnerScope, sessionCacheOwnerScopesConflict, } from '../browser/session-sync/session-cache-ownership.js';
+import { sessionLogRowsFor } from '../core/session-log/v1-view.js';
 import { useCurrentRuntime } from './use-current-runtime.js';
 export function useReadableSessionId(sessionId, beeuniSessionScope) {
     const runtimeScope = useCurrentRuntime((state) => state.sandboxId) ?? 'none';
@@ -9,7 +10,8 @@ export function useReadableSessionId(sessionId, beeuniSessionScope) {
     return cacheBelongsToAnotherRuntime ? '' : sessionId;
 }
 export function selectSessionRows(state, sessionId) {
-    return state.buildSessionMessages(sessionId, state.messages[sessionId], state.parts);
+    const rows = state.buildSessionMessages(sessionId, state.messages[sessionId], state.parts);
+    return sessionLogRowsFor(state.sessionLogs, sessionId, rows, (id) => state.optimisticEchoOf(sessionId, id));
 }
 const toolSignatures = new WeakMap();
 function toolSignature(parts) {

package/dist/react/sign-in-with-beeuni.d.ts

@@ -51,6 +51,7 @@ export declare function SignInWithBeeuni({ basePath, returnTo, children, ...rest
     referrerPolicy?: import("react").HTMLAttributeReferrerPolicy | undefined;
     id?: string | undefined | undefined;
     content?: string | undefined | undefined;
+    rev?: string | undefined | undefined;
     role?: import("react").AriaRole | undefined;
     dir?: string | undefined | undefined;
     download?: any;
@@ -61,9 +62,12 @@ export declare function SignInWithBeeuni({ basePath, returnTo, children, ...rest
     security?: string | undefined | undefined;
     onError?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
     slot?: string | undefined | undefined;
+    target?: import("react").HTMLAttributeAnchorTarget | undefined;
+    rel?: string | undefined | undefined;
+    onClick?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
+    onEnded?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
     hrefLang?: string | undefined | undefined;
     ping?: string | undefined | undefined;
-    target?: import("react").HTMLAttributeAnchorTarget | undefined;
     defaultChecked?: boolean | undefined | undefined;
     defaultValue?: string | number | readonly string[] | undefined;
     suppressContentEditableWarning?: boolean | undefined | undefined;
@@ -72,7 +76,7 @@ export declare function SignInWithBeeuni({ basePath, returnTo, children, ...rest
     autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {}) | undefined;
     autoFocus?: boolean | undefined | undefined;
     className?: string | undefined | undefined;
-    contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+    contentEditable?: "inherit" | (boolean | "true" | "false") | "plaintext-only" | undefined;
     contextMenu?: string | undefined | undefined;
     draggable?: (boolean | "true" | "false") | undefined;
     enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined | undefined;
@@ -85,8 +89,6 @@ export declare function SignInWithBeeuni({ basePath, returnTo, children, ...rest
     datatype?: string | undefined | undefined;
     inlist?: any;
     property?: string | undefined | undefined;
-    rel?: string | undefined | undefined;
-    rev?: string | undefined | undefined;
     typeof?: string | undefined | undefined;
     vocab?: string | undefined | undefined;
     autoCorrect?: string | undefined | undefined;
@@ -209,7 +211,6 @@ export declare function SignInWithBeeuni({ basePath, returnTo, children, ...rest
     onEmptiedCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
     onEncrypted?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
     onEncryptedCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
-    onEnded?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
     onEndedCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
     onLoadedData?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
     onLoadedDataCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
@@ -243,7 +244,6 @@ export declare function SignInWithBeeuni({ basePath, returnTo, children, ...rest
     onWaitingCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
     onAuxClick?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
     onAuxClickCapture?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
-    onClick?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
     onClickCapture?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
     onContextMenu?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;
     onContextMenuCapture?: import("react").MouseEventHandler<HTMLAnchorElement> | undefined;

package/dist/react/turn-end-handoff.d.ts

@@ -0,0 +1,13 @@
+import { type TurnEndWatchDeps } from '../core/session/turn-end-watch.js';
+export declare function resetTurnEndHandoffForTests(deps?: Partial<TurnEndWatchDeps>): void;
+export declare function turnEndHandoffWatching(): string[];
+export interface TurnEndHandoffInput {
+    enabled: boolean;
+    projectId: string;
+    sessionId: string;
+    runtimeSessionId?: string | null;
+    working: boolean;
+    openTurnToken: string | null;
+    lastEndedToken: string | null;
+}
+export declare function useTurnEndHandoff(input: TurnEndHandoffInput): void;

package/dist/react/turn-end-handoff.js

@@ -0,0 +1,101 @@
+'use client';
+import { useQueryClient } from '@tanstack/react-query';
+import { useEffect, useRef } from 'react';
+import { getSessionTurn } from '../core/rest/projects-client/sessions.js';
+import { openSessionStream, sessionStreamConnected } from '../core/session/control-stream.js';
+import { createTurnEndWatch, } from '../core/session/turn-end-watch.js';
+import { unwrapError } from '../core/turns/errors.js';
+import { hasNotifySink, notifySessionError, notifyTaskComplete } from '../platform/ui.js';
+import { registerIdentityReset } from './identity-reset-registry.js';
+import { findCachedProjectSession } from './session-cache-write.js';
+import { realRuntimeTitle } from './use-opencode-events/helpers.js';
+import { runtimeKeys } from './use-opencode-sessions/index.js';
+let watch = null;
+let overrides = null;
+function announce(...[handoff, outcome, watchedSinceMs]) {
+    const title = handoff.title?.();
+    if (outcome.kind === 'completed') {
+        notifyTaskComplete(handoff.sessionId, title, { watchedSinceMs, projectId: handoff.projectId });
+    }
+    else if (outcome.kind === 'failed') {
+        notifySessionError(handoff.sessionId, unwrapError(outcome.error), title, {
+            projectId: handoff.projectId,
+        });
+    }
+}
+function subscribeTurnFrames(projectId, sessionId, onRead) {
+    const handle = openSessionStream({
+        projectId,
+        sessionId,
+        onControl: (frame) => {
+            if (frame.type !== 'beeuni.control.turn')
+                return;
+            const payload = frame.payload;
+            if (!payload?.known || !Array.isArray(payload.turns))
+                return;
+            onRead({
+                turns: payload.turns,
+                ...(payload.last_ended ? { last_ended: payload.last_ended } : {}),
+                ...(payload.recent_failures ? { recent_failures: payload.recent_failures } : {}),
+            });
+        },
+    });
+    return () => handle.close();
+}
+function turnEndWatch() {
+    watch ??= createTurnEndWatch({
+        readTurn: (projectId, sessionId) => getSessionTurn(projectId, sessionId, { showErrors: false }),
+        subscribe: subscribeTurnFrames,
+        pushLive: sessionStreamConnected,
+        onEnded: announce,
+        ...overrides,
+    });
+    return watch;
+}
+registerIdentityReset(() => watch?.releaseAll());
+export function resetTurnEndHandoffForTests(deps) {
+    overrides = deps ?? null;
+    watch = null;
+}
+export function turnEndHandoffWatching() {
+    return watch?.watching() ?? [];
+}
+function sessionTitle(queryClient, projectId, sessionId, runtimeSessionId) {
+    const row = findCachedProjectSession(queryClient, projectId, (session) => session.session_id === sessionId);
+    const named = row?.custom_name || row?.name;
+    if (named)
+        return named;
+    if (!runtimeSessionId)
+        return undefined;
+    const runtime = queryClient.getQueryData(runtimeKeys.runtimeSession(runtimeSessionId)) ??
+        queryClient.getQueryData(runtimeKeys.sessions())?.find((s) => s.id === runtimeSessionId);
+    return realRuntimeTitle(runtime?.title) ?? undefined;
+}
+export function useTurnEndHandoff(input) {
+    const queryClient = useQueryClient();
+    const latest = useRef(input);
+    useEffect(() => {
+        latest.current = input;
+    });
+    const { enabled, projectId, sessionId } = input;
+    useEffect(() => {
+        if (!enabled || !projectId || !sessionId)
+            return;
+        watch?.release(projectId, sessionId);
+        return () => {
+            const last = latest.current;
+            if (!last.working || last.projectId !== projectId || last.sessionId !== sessionId)
+                return;
+            if (!hasNotifySink())
+                return;
+            const runtimeSessionId = last.runtimeSessionId;
+            turnEndWatch().watch({
+                projectId,
+                sessionId,
+                openTurnToken: last.openTurnToken,
+                lastEndedToken: last.lastEndedToken,
+                title: () => sessionTitle(queryClient, projectId, sessionId, runtimeSessionId),
+            });
+        };
+    }, [enabled, projectId, sessionId, queryClient]);
+}

package/dist/react/use-admin-providers.d.ts

@@ -1,7 +1,6 @@
-import { type AdminBootModePolicy } from '../core/rest/projects-client/admin-providers.js';
-export declare function useAdminProviderDistribution(): import("@tanstack/react-query").UseQueryResult<import("../index.js").AdminProviderDistribution, Error>;
-export declare function useAdminProviderSandboxes(): import("@tanstack/react-query").UseQueryResult<import("../index.js").AdminProviderSandboxesResponse, Error>;
-export declare function useAdminProviderAnalytics(days: number, enabled: boolean): import("@tanstack/react-query").UseQueryResult<import("../index.js").AdminProviderAnalytics, Error>;
+export declare function useAdminProviderDistribution(): import("@tanstack/react-query").UseQueryResult<import("../internal/platform-admin.js").AdminProviderDistribution, Error>;
+export declare function useAdminProviderSandboxes(): import("@tanstack/react-query").UseQueryResult<import("../internal/platform-admin.js").AdminProviderSandboxesResponse, Error>;
+export declare function useAdminProviderAnalytics(days: number, enabled: boolean): import("@tanstack/react-query").UseQueryResult<import("../internal/platform-admin.js").AdminProviderAnalytics, Error>;
 export declare function useAdminProviderFallback(): import("@tanstack/react-query").UseQueryResult<{
     enabled: boolean;
 }, Error>;
@@ -16,5 +15,3 @@ export interface AdminProviderMigrationVariables {
 export declare function useSetAdminProviderDistribution(options?: AdminProviderMutationOptions): import("@tanstack/react-query").UseMutationResult<unknown, Error, Record<string, number>, unknown>;
 export declare function useMigrateAdminSandboxProvider(options?: AdminProviderMutationOptions): import("@tanstack/react-query").UseMutationResult<unknown, Error, AdminProviderMigrationVariables, unknown>;
 export declare function useSetAdminProviderFallback(options?: AdminProviderMutationOptions): import("@tanstack/react-query").UseMutationResult<unknown, Error, boolean, unknown>;
-export declare function useAdminBootModes(): import("@tanstack/react-query").UseQueryResult<import("../index.js").AdminBootModes, Error>;
-export declare function useSetAdminBootModes(options?: AdminProviderMutationOptions): import("@tanstack/react-query").UseMutationResult<import("../index.js").AdminBootModes, Error, AdminBootModePolicy, unknown>;

package/dist/react/use-admin-providers.js

@@ -1,5 +1,5 @@
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
-import { getAdminProviderDistribution, listAdminSandboxes, getAdminProviderAnalytics, getAdminProviderFallback, setAdminProviderDistribution, migrateAdminSandboxProvider, setAdminProviderFallback, getAdminBootModes, setAdminBootModes } from '../core/rest/projects-client/admin-providers.js';
+import { getAdminProviderDistribution, listAdminSandboxes, getAdminProviderAnalytics, getAdminProviderFallback, setAdminProviderDistribution, migrateAdminSandboxProvider, setAdminProviderFallback } from '../core/rest/projects-client/admin-providers.js';
 export function useAdminProviderDistribution() {
     return useQuery({ queryKey: ['admin', 'provider-distribution'], queryFn: () => getAdminProviderDistribution() });
 }
@@ -33,13 +33,3 @@ export function useSetAdminProviderFallback(options = {}) {
             void qc.invalidateQueries({ queryKey: ['admin', 'provider-fallback'] });
         } });
 }
-export function useAdminBootModes() {
-    return useQuery({ queryKey: ['admin', 'boot-modes'], queryFn: () => getAdminBootModes(), refetchInterval: 30_000 });
-}
-export function useSetAdminBootModes(options = {}) {
-    const qc = useQueryClient();
-    return useMutation({ mutationFn: (policy) => setAdminBootModes(policy), onError: options.onError, onSuccess: (data) => {
-            options.onSuccess?.();
-            qc.setQueryData(['admin', 'boot-modes'], data);
-        } });
-}

package/dist/react/use-capture.d.ts

@@ -0,0 +1,47 @@
+import { type CaptureEnrollmentStatus, type CaptureEnrollmentTokenInput, type CaptureDaysQuery, type CapturePolicy, type CaptureSearchQuery, type CaptureWindowQuery } from '../core/rest/platform-client/capture.js';
+export declare function useCaptureDeviceGrant(userCode: string | null | undefined): import("@tanstack/react-query").UseQueryResult<import("../index.js").CaptureDeviceGrantDetail, Error>;
+export declare function useApproveCaptureDevice(): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureDeviceGrant, Error, {
+    userCode: string;
+    accountId?: string;
+}, unknown>;
+export declare function useDenyCaptureDevice(): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureDeviceGrant, Error, string, unknown>;
+type AccountId = string | null | undefined;
+export declare function useCaptureDevices(accountId: AccountId, opts?: {
+    scope?: 'mine' | 'account';
+    userId?: string;
+}): import("@tanstack/react-query").UseQueryResult<{
+    devices: import("../index.js").CaptureDevice[];
+    health: import("../index.js").CaptureHealthSummary;
+}, Error>;
+export declare function useRevokeCaptureDevice(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureDevice, Error, string, unknown>;
+export declare function useCaptureDays(accountId: AccountId, query?: CaptureDaysQuery): import("@tanstack/react-query").UseQueryResult<import("../index.js").CaptureDays, Error>;
+export declare function useCaptureTimeline(accountId: AccountId, query: CaptureWindowQuery | null): import("@tanstack/react-query").UseQueryResult<import("../index.js").CaptureTimeline, Error>;
+export declare function useCaptureTimelineItems(accountId: AccountId, query: CaptureWindowQuery | null): import("@tanstack/react-query").UseQueryResult<import("../index.js").CaptureTimelineItems, Error>;
+export declare function useCaptureSearch(accountId: AccountId, query: CaptureSearchQuery | null): import("@tanstack/react-query").UseQueryResult<import("../index.js").CaptureSearchResult, Error>;
+export declare function useCaptureChunkMedia(accountId: AccountId, chunkId: string | null | undefined, opts?: {
+    userId?: string;
+}): import("@tanstack/react-query").UseQueryResult<import("../index.js").CaptureChunkMedia, Error>;
+export declare function useCaptureEnrollmentTokens(accountId: AccountId): import("@tanstack/react-query").UseQueryResult<{
+    tokens: import("../index.js").CaptureEnrollmentToken[];
+}, Error>;
+export declare function useCreateCaptureEnrollmentToken(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureEnrollmentTokenSecret, Error, CaptureEnrollmentTokenInput, unknown>;
+export declare function useRevokeCaptureEnrollmentToken(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureEnrollmentToken, Error, string, unknown>;
+export declare function useCaptureEnrollments(accountId: AccountId, opts?: {
+    status?: CaptureEnrollmentStatus;
+}): import("@tanstack/react-query").UseQueryResult<{
+    enrollments: import("../index.js").CaptureEnrollment[];
+}, Error>;
+export declare function useApproveCaptureEnrollment(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureEnrollment, Error, {
+    enrollmentId: string;
+    userId?: string | null;
+}, unknown>;
+export declare function useDenyCaptureEnrollment(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureEnrollment, Error, string, unknown>;
+export declare function useLinkCaptureDevice(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureDevice, Error, {
+    deviceId: string;
+    userId: string | null;
+}, unknown>;
+export declare function useCapturePolicy(accountId: AccountId): import("@tanstack/react-query").UseQueryResult<import("../index.js").CapturePolicyRecord, Error>;
+export declare function useSetCapturePolicy(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CapturePolicyRecord, Error, CapturePolicy, unknown>;
+export declare function useCaptureWorkspace(accountId: AccountId): import("@tanstack/react-query").UseQueryResult<import("../index.js").CaptureWorkspace, Error>;
+export declare function useSetCaptureEnabled(accountId: AccountId): import("@tanstack/react-query").UseMutationResult<import("../index.js").CaptureWorkspace, Error, boolean, unknown>;
+export {};

package/dist/react/use-capture.js

@@ -0,0 +1,173 @@
+'use client';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { approveCaptureDeviceGrant, approveCaptureEnrollment, createCaptureEnrollmentToken, denyCaptureEnrollment, listCaptureEnrollments, listCaptureEnrollmentTokens, linkCaptureDevice, revokeCaptureEnrollmentToken, denyCaptureDeviceGrant, getCaptureChunkMedia, getCaptureDays, getCaptureDeviceGrant, getCapturePolicy, getCaptureTimeline, getCaptureTimelineItems, getCaptureWorkspace, listCaptureDevices, revokeCaptureDevice, searchCapture, setCaptureEnabled, setCapturePolicy, } from '../core/rest/platform-client/capture.js';
+import { contract, FRESHNESS } from './query-contracts.js';
+import { qk } from './query-keys.js';
+export function useCaptureDeviceGrant(userCode) {
+    return useQuery({
+        queryKey: qk.capture.deviceGrant(userCode ?? ''),
+        queryFn: () => getCaptureDeviceGrant(userCode),
+        enabled: !!userCode,
+        ...contract('volatile'),
+    });
+}
+export function useApproveCaptureDevice() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (args) => approveCaptureDeviceGrant(args.userCode, args.accountId),
+        onSuccess: (grant, args) => queryClient.setQueryData(qk.capture.deviceGrant(args.userCode), grant),
+    });
+}
+export function useDenyCaptureDevice() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (userCode) => denyCaptureDeviceGrant(userCode),
+        onSuccess: (grant, userCode) => queryClient.setQueryData(qk.capture.deviceGrant(userCode), grant),
+    });
+}
+export function useCaptureDevices(accountId, opts = {}) {
+    return useQuery({
+        queryKey: qk.capture.devices(accountId ?? '', opts.scope ?? 'mine', opts.userId ?? null),
+        queryFn: () => listCaptureDevices(accountId, opts),
+        enabled: !!accountId,
+        ...contract(FRESHNESS.captureDevices),
+    });
+}
+export function useRevokeCaptureDevice(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (deviceId) => revokeCaptureDevice(accountId, deviceId),
+        onSuccess: () => queryClient.invalidateQueries({ queryKey: qk.capture.account(accountId ?? '') }),
+    });
+}
+export function useCaptureDays(accountId, query = {}) {
+    return useQuery({
+        queryKey: qk.capture.timelineRead(accountId ?? '', 'days', query),
+        queryFn: () => getCaptureDays(accountId, query),
+        enabled: !!accountId,
+        ...contract(FRESHNESS.captureTimeline),
+    });
+}
+export function useCaptureTimeline(accountId, query) {
+    return useQuery({
+        queryKey: qk.capture.timelineRead(accountId ?? '', 'runs', query),
+        queryFn: () => getCaptureTimeline(accountId, query ?? undefined),
+        enabled: !!accountId && !!query,
+        ...contract(FRESHNESS.captureTimeline),
+    });
+}
+export function useCaptureTimelineItems(accountId, query) {
+    return useQuery({
+        queryKey: qk.capture.timelineRead(accountId ?? '', 'items', query),
+        queryFn: () => getCaptureTimelineItems(accountId, query ?? undefined),
+        enabled: !!accountId && !!query,
+        ...contract(FRESHNESS.captureTimeline),
+    });
+}
+export function useCaptureSearch(accountId, query) {
+    return useQuery({
+        queryKey: qk.capture.timelineRead(accountId ?? '', 'search', query),
+        queryFn: () => searchCapture(accountId, query),
+        enabled: !!accountId && !!query?.q.trim(),
+        ...contract(FRESHNESS.captureTimeline),
+    });
+}
+export function useCaptureChunkMedia(accountId, chunkId, opts = {}) {
+    return useQuery({
+        queryKey: qk.capture.timelineRead(accountId ?? '', 'media', { chunkId, userId: opts.userId ?? null }),
+        queryFn: () => getCaptureChunkMedia(accountId, chunkId, opts),
+        enabled: !!accountId && !!chunkId,
+        ...contract(FRESHNESS.captureTimeline),
+        staleTime: 240_000,
+        refetchInterval: 240_000,
+    });
+}
+export function useCaptureEnrollmentTokens(accountId) {
+    return useQuery({
+        queryKey: qk.capture.enrollmentTokens(accountId ?? ''),
+        queryFn: () => listCaptureEnrollmentTokens(accountId),
+        enabled: !!accountId,
+        ...contract(FRESHNESS.captureEnrollmentTokens),
+    });
+}
+export function useCreateCaptureEnrollmentToken(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (input) => createCaptureEnrollmentToken(accountId, input),
+        onSuccess: () => void queryClient.invalidateQueries({ queryKey: qk.capture.enrollmentTokens(accountId ?? '') }),
+    });
+}
+export function useRevokeCaptureEnrollmentToken(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (tokenId) => revokeCaptureEnrollmentToken(accountId, tokenId),
+        onSuccess: () => void queryClient.invalidateQueries({ queryKey: qk.capture.enrollmentTokens(accountId ?? '') }),
+    });
+}
+export function useCaptureEnrollments(accountId, opts = {}) {
+    return useQuery({
+        queryKey: [...qk.capture.enrollments(accountId ?? ''), opts.status ?? 'all'],
+        queryFn: () => listCaptureEnrollments(accountId, opts),
+        enabled: !!accountId,
+        ...contract(FRESHNESS.captureEnrollments),
+    });
+}
+function invalidateRollout(queryClient, accountId) {
+    for (const queryKey of [qk.capture.enrollments(accountId), qk.capture.enrollmentTokens(accountId), [...qk.capture.account(accountId), 'devices']]) {
+        void queryClient.invalidateQueries({ queryKey });
+    }
+}
+export function useApproveCaptureEnrollment(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (args) => approveCaptureEnrollment(accountId, args.enrollmentId, args.userId),
+        onSuccess: () => invalidateRollout(queryClient, accountId ?? ''),
+    });
+}
+export function useDenyCaptureEnrollment(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (enrollmentId) => denyCaptureEnrollment(accountId, enrollmentId),
+        onSuccess: () => invalidateRollout(queryClient, accountId ?? ''),
+    });
+}
+export function useLinkCaptureDevice(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (args) => linkCaptureDevice(accountId, args.deviceId, args.userId),
+        onSuccess: () => invalidateRollout(queryClient, accountId ?? ''),
+    });
+}
+export function useCapturePolicy(accountId) {
+    return useQuery({
+        queryKey: qk.capture.policy(accountId ?? ''),
+        queryFn: () => getCapturePolicy(accountId),
+        enabled: !!accountId,
+        ...contract(FRESHNESS.capturePolicy),
+    });
+}
+export function useSetCapturePolicy(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (policy) => setCapturePolicy(accountId, policy),
+        onSuccess: (record) => queryClient.setQueryData(qk.capture.policy(accountId ?? ''), record),
+    });
+}
+export function useCaptureWorkspace(accountId) {
+    return useQuery({
+        queryKey: qk.capture.workspace(accountId ?? ''),
+        queryFn: () => getCaptureWorkspace(accountId),
+        enabled: !!accountId,
+        ...contract(FRESHNESS.captureWorkspace),
+    });
+}
+export function useSetCaptureEnabled(accountId) {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (enabled) => setCaptureEnabled(accountId, enabled),
+        onSuccess: (workspace) => {
+            queryClient.setQueryData(qk.capture.workspace(accountId ?? ''), workspace);
+            void queryClient.invalidateQueries({ queryKey: qk.capture.account(accountId ?? '') });
+        },
+    });
+}

package/dist/react/use-feature-flag.js

@@ -9,6 +9,7 @@ const GRADUATED_FEATURE_FLAG_KEYS = new Set([
     'session_transcript_history',
     'teams',
     'config_releases',
+    'apps',
 ]);
 export function useFeatureFlag(projectId, key) {
     const query = useQuery({