@xfey/tutti 0.1.0

package/dist/server-shell/http/routes/project-api/skills-routes.js

@@ -0,0 +1,185 @@
+import { DeleteSkillBodySchema, DeleteSkillResponseSchema, GetSkillResponseSchema, GetSkillsResponseSchema, ImportSkillZipBodySchema, ImportSkillZipResponseSchema, } from "@tutti/shared/schemas/api";
+import { commitUserSkillImport, deleteUserSkill, listUserSkills, prepareUserSkillZipImport, readUserSkill, } from "../../../../skills/index.js";
+import { recordReadNotificationEvent } from "../../../../collaboration-state/index.js";
+import { decideCommandIdempotencyReplay, executeIdempotentCommand, readCommandIdempotencyRecord, } from "../../../command-idempotency/index.js";
+import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
+import { requireHostProjectSession, requireProjectStore } from "./session-requirements.js";
+import { requireTuttiHome, skillsChangedInvalidates, withAsyncSkillServiceErrorMapping, withSkillServiceErrorMapping, } from "./skills-helpers.js";
+import { abortDownloadedStagedUpload, cleanupDownloadedStagedUpload, downloadStagedUpload, } from "./staged-uploads.js";
+export function registerSkillRoutes(app, { options, workspaceEvents, }) {
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/skills`, {
+        schema: {
+            response: {
+                200: GetSkillsResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        return withSkillServiceErrorMapping(() => ({
+            items: listUserSkills(requireTuttiHome(options)),
+        }));
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/skills/:skillName`, {
+        schema: {
+            response: {
+                200: GetSkillResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        return withSkillServiceErrorMapping(() => ({
+            skill: readUserSkill(requireTuttiHome(options), request.params.skillName),
+        }));
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/skills/import`, {
+        schema: {
+            body: ImportSkillZipBodySchema,
+            response: {
+                200: ImportSkillZipResponseSchema,
+            },
+        },
+    }, async (request) => {
+        const session = requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const commandId = request.body.command_id;
+        const command = {
+            command_name: "skills.import_zip",
+            target_ref: request.body.payload.upload_id,
+            payload: request.body.payload,
+        };
+        const replay = decideCommandIdempotencyReplay(readCommandIdempotencyRecord(store.db, commandId), command);
+        let staged;
+        try {
+            staged =
+                replay.kind === "start"
+                    ? await downloadStagedUpload({
+                        routeOptions: options,
+                        expected: request.body.payload,
+                        purpose: "skill_zip",
+                    })
+                    : undefined;
+            const downloaded = staged;
+            const plan = downloaded === undefined
+                ? undefined
+                : await withAsyncSkillServiceErrorMapping(() => prepareUserSkillZipImport({
+                    zipBuffer: downloaded.content,
+                    fileName: request.body.payload.file_name,
+                }));
+            const invalidates = skillsChangedInvalidates();
+            const execution = executeIdempotentCommand({
+                db: store.db,
+                command_id: commandId,
+                command_name: command.command_name,
+                target_ref: command.target_ref,
+                payload: request.body.payload,
+                ...(options.now === undefined ? {} : { now: options.now }),
+                execute: (tx) => withSkillServiceErrorMapping(() => {
+                    if (plan === undefined) {
+                        throw new Error("Staged skill upload was not downloaded");
+                    }
+                    const imported = commitUserSkillImport({
+                        tuttiHome: requireTuttiHome(options),
+                        plan,
+                    });
+                    recordReadNotificationEvent(tx, {
+                        scope: "skills",
+                        source_kind: "skill",
+                        source_ref: imported.skill.name,
+                        actor: {
+                            kind: "human",
+                            ref: session.account.account_ref,
+                        },
+                        occurred_at: imported.skill.updated_at ??
+                            (options.now === undefined ? new Date() : options.now()).toISOString(),
+                    });
+                    return {
+                        disposition: imported.disposition,
+                        result: { skill: imported.skill },
+                    };
+                }),
+            });
+            const response = {
+                command_id: execution.command_id,
+                disposition: execution.disposition,
+                invalidates,
+            };
+            if (execution.result !== undefined) {
+                response.result = execution.result;
+            }
+            if (!execution.replayed) {
+                if (staged !== undefined) {
+                    await cleanupDownloadedStagedUpload(staged);
+                    staged = undefined;
+                }
+                workspaceEvents.publish({
+                    event_type: "query.invalidate",
+                    payload: {
+                        reason: "bulk_state_change",
+                        message: "Skills changed.",
+                    },
+                    invalidates,
+                });
+            }
+            return response;
+        }
+        catch (error) {
+            if (staged !== undefined) {
+                await abortDownloadedStagedUpload(staged);
+            }
+            throw error;
+        }
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/skills/delete`, {
+        schema: {
+            body: DeleteSkillBodySchema,
+            response: {
+                200: DeleteSkillResponseSchema,
+            },
+        },
+    }, (request) => {
+        const session = requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const invalidates = skillsChangedInvalidates();
+        const execution = executeIdempotentCommand({
+            db: store.db,
+            command_id: request.body.command_id,
+            command_name: "skills.delete",
+            target_ref: request.body.payload.skill_name,
+            payload: request.body.payload,
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: (tx) => withSkillServiceErrorMapping(() => {
+                const disposition = deleteUserSkill(requireTuttiHome(options), request.body.payload.skill_name);
+                if (disposition.kind === "deleted") {
+                    recordReadNotificationEvent(tx, {
+                        scope: "skills",
+                        source_kind: "skill_deleted",
+                        source_ref: disposition.skill_name,
+                        actor: {
+                            kind: "human",
+                            ref: session.account.account_ref,
+                        },
+                        occurred_at: (options.now === undefined ? new Date() : options.now()).toISOString(),
+                    });
+                }
+                return { disposition };
+            }),
+        });
+        const response = {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            invalidates,
+        };
+        if (!execution.replayed) {
+            workspaceEvents.publish({
+                event_type: "query.invalidate",
+                payload: {
+                    reason: "bulk_state_change",
+                    message: "Skills changed.",
+                },
+                invalidates,
+            });
+        }
+        return response;
+    });
+}
+//# sourceMappingURL=skills-routes.js.map

package/dist/server-shell/http/routes/project-api/staged-uploads.d.ts

@@ -0,0 +1,14 @@
+import type { RelayUploadPurpose, StagedUploadReference } from "@tutti/shared/schemas/api";
+import type { HostProjectApiRouteOptions, ResolvedStagedUpload } from "./types.js";
+export type DownloadedStagedUpload = {
+    resolved: ResolvedStagedUpload;
+    content: Buffer;
+};
+export declare function downloadStagedUpload(options: {
+    routeOptions: HostProjectApiRouteOptions;
+    expected: StagedUploadReference;
+    purpose: RelayUploadPurpose;
+}): Promise<DownloadedStagedUpload>;
+export declare function cleanupDownloadedStagedUpload(upload: DownloadedStagedUpload): Promise<void>;
+export declare function abortDownloadedStagedUpload(upload: DownloadedStagedUpload): Promise<void>;
+//# sourceMappingURL=staged-uploads.d.ts.map

package/dist/server-shell/http/routes/project-api/staged-uploads.js

@@ -0,0 +1,149 @@
+import { createHash } from "node:crypto";
+import { maxStagedUploadBytesForPurpose } from "@tutti/shared/schemas/api";
+import { HostProjectStoreUnavailableError, HostProjectValidationError } from "./errors.js";
+function sha256Digest(content) {
+    return `sha256:${createHash("sha256").update(content).digest("hex")}`;
+}
+function requireStagedUploadResolver(options) {
+    if (options.resolveStagedUpload === undefined) {
+        throw new HostProjectStoreUnavailableError();
+    }
+    return options.resolveStagedUpload;
+}
+function assertResolvedUploadMetadata(options) {
+    if (options.resolved.upload.purpose !== options.purpose) {
+        throw new HostProjectValidationError("Upload purpose does not match this endpoint");
+    }
+    if (options.resolved.upload.file_name !== options.expected.file_name) {
+        throw new HostProjectValidationError("Upload file name does not match staged metadata");
+    }
+    if (options.resolved.upload.size_bytes !== options.expected.size_bytes) {
+        throw new HostProjectValidationError("Upload size does not match staged metadata");
+    }
+    if (options.resolved.upload.sha256 !== options.expected.sha256) {
+        throw new HostProjectValidationError("Upload digest does not match staged metadata");
+    }
+    if (options.expected.media_type !== undefined &&
+        options.resolved.upload.media_type !== options.expected.media_type) {
+        throw new HostProjectValidationError("Upload media type does not match staged metadata");
+    }
+}
+async function readResponseBodyWithLimit(response, maxBytes) {
+    const contentLength = response.headers.get("content-length");
+    if (contentLength !== null) {
+        const parsed = Number(contentLength);
+        if (Number.isFinite(parsed) && parsed > maxBytes) {
+            throw new HostProjectValidationError("Upload content size does not match staged metadata");
+        }
+    }
+    if (response.body === null) {
+        const content = Buffer.from(await response.arrayBuffer());
+        if (content.byteLength > maxBytes) {
+            throw new HostProjectValidationError("Upload content size does not match staged metadata");
+        }
+        return content;
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let totalBytes = 0;
+    try {
+        for (;;) {
+            const chunk = await reader.read();
+            if (chunk.done) {
+                break;
+            }
+            if (!(chunk.value instanceof Uint8Array)) {
+                throw new HostProjectValidationError("Upload object could not be downloaded");
+            }
+            const value = chunk.value;
+            totalBytes += value.byteLength;
+            if (totalBytes > maxBytes) {
+                throw new HostProjectValidationError("Upload content size does not match staged metadata");
+            }
+            chunks.push(value);
+        }
+    }
+    catch (error) {
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // The fetch body may already be closed.
+        }
+        throw error;
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks, totalBytes);
+}
+async function fetchUploadBytes(url, maxBytes) {
+    let response;
+    try {
+        response = await fetch(url, { method: "GET" });
+    }
+    catch {
+        throw new HostProjectValidationError("Upload object could not be downloaded");
+    }
+    if (!response.ok) {
+        throw new HostProjectValidationError("Upload object could not be downloaded");
+    }
+    return readResponseBodyWithLimit(response, maxBytes);
+}
+async function disposeResolvedStagedUpload(upload, status) {
+    try {
+        await fetch(upload.delete.url, { method: "DELETE" });
+    }
+    catch {
+        // R2 lifecycle cleanup remains the fallback for already-staged uploads.
+    }
+    try {
+        await upload.complete(status);
+    }
+    catch {
+        // Completion metadata is best-effort after the host has decided the terminal status.
+    }
+}
+export async function downloadStagedUpload(options) {
+    const maxBytes = maxStagedUploadBytesForPurpose(options.purpose);
+    if (options.expected.size_bytes > maxBytes) {
+        throw new HostProjectValidationError(`Upload content cannot exceed ${maxBytes} bytes`);
+    }
+    let resolved;
+    try {
+        resolved = await requireStagedUploadResolver(options.routeOptions)(options.expected.upload_id);
+    }
+    catch {
+        throw new HostProjectValidationError("Upload session could not be resolved");
+    }
+    assertResolvedUploadMetadata({
+        expected: options.expected,
+        resolved,
+        purpose: options.purpose,
+    });
+    let content;
+    try {
+        content = await fetchUploadBytes(resolved.get.url, options.expected.size_bytes);
+        if (content.byteLength !== options.expected.size_bytes) {
+            throw new HostProjectValidationError("Upload content size does not match staged metadata");
+        }
+        if (sha256Digest(content) !== options.expected.sha256) {
+            throw new HostProjectValidationError("Upload content digest does not match staged metadata");
+        }
+    }
+    catch (error) {
+        await disposeResolvedStagedUpload(resolved, "aborted");
+        throw error;
+    }
+    return {
+        resolved,
+        content,
+    };
+}
+export async function cleanupDownloadedStagedUpload(upload) {
+    await disposeResolvedStagedUpload(upload.resolved, "completed");
+}
+export async function abortDownloadedStagedUpload(upload) {
+    await disposeResolvedStagedUpload(upload.resolved, "aborted");
+}
+//# sourceMappingURL=staged-uploads.js.map

package/dist/server-shell/http/routes/project-api/system-routes.d.ts

@@ -0,0 +1,8 @@
+import type { FastifyInstance } from "fastify";
+import type { WorkspaceEventBus } from "../../workspace-events.js";
+import type { HostProjectApiRouteOptions } from "./types.js";
+export declare function registerSystemRoutes(app: FastifyInstance, { options, workspaceEvents, }: {
+    options: HostProjectApiRouteOptions;
+    workspaceEvents: WorkspaceEventBus;
+}): void;
+//# sourceMappingURL=system-routes.d.ts.map

package/dist/server-shell/http/routes/project-api/system-routes.js

@@ -0,0 +1,141 @@
+import { UpdateProjectDisplayNameBodySchema, UpdateProjectDisplayNameResponseSchema, } from "@tutti/shared/schemas/api";
+import { BootstrapResponseSchema, GetEventsRequestSchema, OpenApiDocumentProjectionSchema, ProviderConfigProjectionSchema, ProviderUsageProjectionSchema, SessionResponseSchema, WorkspaceResponseSchema, } from "./schemas.js";
+import { executeIdempotentCommand } from "../../../command-idempotency/index.js";
+import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
+import { openWorkspaceEventStream } from "./events-stream.js";
+import { projectDisplayNameInvalidates } from "./invalidations.js";
+import { buildHostProjectOpenApiDocument } from "./openapi.js";
+import { requireValidProjectDisplayNamePayload } from "./payload-validation.js";
+import { requireHostProjectSession, requireProjectStore, } from "./session-requirements.js";
+import { buildBootstrapSnapshots, resolveWorkspaceProjection, } from "./workspace-projections.js";
+function updateProjectDisplayName(options, payload) {
+    const currentName = options.project.display_name;
+    const nextName = payload.display_name;
+    if (currentName === nextName) {
+        return {
+            disposition: { kind: "unchanged" },
+            result: { project: { display_name: currentName } },
+        };
+    }
+    options.updateProjectDisplayName?.(nextName);
+    options.project.display_name = nextName;
+    return {
+        disposition: { kind: "updated" },
+        result: { project: { display_name: nextName } },
+    };
+}
+export function registerSystemRoutes(app, { options, workspaceEvents, }) {
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/openapi.json`, {
+        schema: {
+            response: {
+                200: OpenApiDocumentProjectionSchema,
+            },
+        },
+    }, () => buildHostProjectOpenApiDocument());
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/events`, {
+        schema: {
+            querystring: GetEventsRequestSchema,
+        },
+    }, (request, reply) => {
+        requireHostProjectSession(request, options);
+        openWorkspaceEventStream({ request, reply, events: workspaceEvents });
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/provider/config`, {
+        schema: {
+            response: {
+                200: ProviderConfigProjectionSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        return options.getProviderConfig?.() ?? { status: "not_configured" };
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/provider/usage`, {
+        schema: {
+            response: {
+                200: ProviderUsageProjectionSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        return options.getProviderUsage?.() ?? { total_tokens: 0 };
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/session`, {
+        schema: {
+            response: {
+                200: SessionResponseSchema,
+            },
+        },
+    }, (request) => requireHostProjectSession(request, options));
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/workspace`, {
+        schema: {
+            response: {
+                200: WorkspaceResponseSchema,
+            },
+        },
+    }, async (request) => {
+        requireHostProjectSession(request, options);
+        return await resolveWorkspaceProjection(options);
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/workspace/project-display-name`, {
+        schema: {
+            body: UpdateProjectDisplayNameBodySchema,
+            response: {
+                200: UpdateProjectDisplayNameResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const payload = requireValidProjectDisplayNamePayload(request.body.payload);
+        const execution = executeIdempotentCommand({
+            db: store.db,
+            command_id: request.body.command_id,
+            command_name: "workspace.update_project_display_name",
+            target_ref: `project:${options.project.project_id}`,
+            payload,
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: () => updateProjectDisplayName(options, payload),
+        });
+        const invalidates = projectDisplayNameInvalidates();
+        const response = {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            invalidates,
+        };
+        if (execution.result !== undefined) {
+            response.result = execution.result;
+        }
+        if (!execution.replayed) {
+            workspaceEvents.publish({
+                event_type: "query.invalidate",
+                payload: {
+                    reason: "bulk_state_change",
+                    message: "Project display name changed.",
+                },
+                invalidates,
+            });
+        }
+        return response;
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/bootstrap`, {
+        schema: {
+            response: {
+                200: BootstrapResponseSchema,
+            },
+        },
+    }, async (request) => {
+        const session = requireHostProjectSession(request, options);
+        const providerConfig = options.getProviderConfig?.() ?? { status: "not_configured" };
+        const now = options.now ?? (() => new Date());
+        return {
+            generated_at: now().toISOString(),
+            event_cursor: options.getCurrentEventCursor?.() ?? workspaceEvents.currentEventCursor(),
+            workspace: await resolveWorkspaceProjection(options),
+            session,
+            provider_config: providerConfig,
+            snapshots: buildBootstrapSnapshots(options, now, session),
+        };
+    });
+}
+//# sourceMappingURL=system-routes.js.map

package/dist/server-shell/http/routes/project-api/types.d.ts

@@ -0,0 +1,137 @@
+import type { ReadOnlyChatAssistantHandle } from "../../../../chat-assistant/index.js";
+import type { Phase5ControlPlane } from "../../../../control-plane/index.js";
+import type { ApprovalRequestManager } from "../../../../approvals/index.js";
+import type { HostProjectStore } from "../../../../store/index.js";
+import type { ProjectId, RelayProjectRef } from "@tutti/shared/ids";
+import type { AccountAvatarProjection } from "@tutti/shared/domain";
+import type { TrustedRelaySessionMetadataStore } from "../../../session/relay-session-context.js";
+import type { WorkspaceEventBus } from "../../workspace-events.js";
+import type { HOST_MAINLINE_BRANCH } from "./constants.js";
+import type { ProviderUsageProjection, RelayUploadProjection } from "@tutti/shared/schemas/api";
+export type ResolvedStagedUpload = {
+    upload: RelayUploadProjection;
+    get: {
+        method: "GET";
+        url: string;
+    };
+    delete: {
+        method: "DELETE";
+        url: string;
+    };
+    complete: (status: "completed" | "aborted") => Promise<void>;
+};
+export type HostProviderConfigProjection = {
+    status: "not_configured";
+} | {
+    status: "configured";
+    provider: "openai";
+    auth_kind: "api_key";
+    redacted_key: string;
+    default_model: string;
+    validated_at: string;
+} | {
+    status: "invalid";
+    provider?: "openai";
+    auth_kind?: "api_key";
+    redacted_key?: string;
+    default_model?: string;
+    validated_at?: string;
+    invalid_reason_code?: "provider_auth_invalid" | "provider_quota_or_billing_required" | "provider_rate_limited" | "provider_model_unavailable" | "provider_network_error" | "unknown";
+};
+export type HostWorkspaceRelayState = {
+    status: "connected" | "reconnecting" | "unavailable";
+    relay_url: string;
+    relay_project_ref?: RelayProjectRef;
+    join_url?: string;
+    join_url_visibility?: "visible_once" | "not_recoverable";
+    join_token_expires_at?: string;
+    join_token_reusable: boolean;
+};
+export type HostRepoProjection = {
+    mainline_branch: typeof HOST_MAINLINE_BRANCH;
+    mainline_head?: {
+        oid: string;
+        short_oid: string;
+    };
+    mainline_timeline: {
+        entries: Array<{
+            oid: string;
+            committed_at: string;
+        }>;
+    };
+    mainline_clean: boolean;
+};
+export type HostProjectApiCapabilities = {
+    sse: boolean;
+    relay_join: boolean;
+    repo_viewer: boolean;
+    provider_config_query: boolean;
+    browser_secret_write: false;
+    task_auto_scheduler: boolean;
+    task_run_now_scheduler: boolean;
+    clarification: boolean;
+};
+export type HostProjectApiRouteOptions = {
+    project: {
+        project_id: ProjectId;
+        display_name: string;
+        identity_source: "git_config";
+    };
+    server: {
+        version: string;
+        started_at: string;
+        mode: "development" | "production";
+    };
+    relay: {
+        getState: () => HostWorkspaceRelayState;
+        refreshJoinUrl?: () => Promise<HostWorkspaceRelayState>;
+    };
+    trustedMetadataStore: TrustedRelaySessionMetadataStore;
+    store?: HostProjectStore;
+    events?: WorkspaceEventBus;
+    controlPlane?: Phase5ControlPlane;
+    approvalManager?: ApprovalRequestManager;
+    chatAssistant?: ReadOnlyChatAssistantHandle;
+    tuttiHome?: string;
+    getProviderConfig?: () => HostProviderConfigProjection;
+    getProviderUsage?: () => ProviderUsageProjection;
+    capabilities?: Partial<Omit<HostProjectApiCapabilities, "browser_secret_write">>;
+    getRepo?: () => HostRepoProjection;
+    updateProjectDisplayName?: (displayName: string) => void;
+    resolveStagedUpload?: (uploadId: RelayUploadProjection["upload_id"]) => Promise<ResolvedStagedUpload>;
+    workspaceOps?: {
+        workspaceRoot: string;
+        viewerAssetCacheRoot: string;
+    };
+    getCurrentEventCursor?: () => string;
+    now?: () => Date;
+};
+export type HostSessionProjection = {
+    account: {
+        account_ref: string;
+        display_name: string;
+        avatar: AccountAvatarProjection;
+    };
+    membership: {
+        label: "owner" | "member";
+        relay_project_ref?: string;
+        joined_at: string;
+    };
+    client_session: {
+        client_session_id: string;
+        transport: "relay_tunnel";
+        connected_at: string;
+    };
+};
+export type HostWorkspaceProjection = {
+    project: HostProjectApiRouteOptions["project"];
+    server: HostProjectApiRouteOptions["server"];
+    repo: HostRepoProjection;
+    relay: Omit<HostWorkspaceRelayState, "relay_project_ref">;
+    provider: {
+        status: HostProviderConfigProjection["status"];
+        provider?: "openai";
+    };
+    capabilities: HostProjectApiCapabilities;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/server-shell/http/routes/project-api/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/server-shell/http/routes/project-api/viewer-projections.d.ts

@@ -0,0 +1,17 @@
+import type { ViewerFileProjection, ViewerTreeEntryProjection } from "@tutti/shared/schemas/api";
+import { type ViewerFileResult, type ViewerTreeEntry } from "../../../../workspace-ops/index.js";
+export declare function viewerPageLimit(limit: number | undefined): number;
+export declare function paginateViewerItems<T>(items: T[], request: {
+    limit?: number;
+    cursor?: string;
+}): {
+    items: T[];
+    page: {
+        next_cursor?: string;
+        has_more: boolean;
+        limit: number;
+    };
+};
+export declare function toViewerTreeEntryProjection(entry: ViewerTreeEntry): ViewerTreeEntryProjection;
+export declare function toViewerFileProjection(file: ViewerFileResult["file"]): ViewerFileProjection;
+//# sourceMappingURL=viewer-projections.d.ts.map