@fungi.computer/tourtois 0.0.0-stage → 0.0.1

package/dist/desktop-layout.d.ts

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import { type BentoPlacement, type BentoOp } from "@fungi.computer/maosaico/bento";
+import { type AppGillDesktopSize, type AppGillParam } from "@fungi.computer/gills";
+export declare const desktopLayoutSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        surfaceId: z.ZodString;
+        gillId: z.ZodString;
+        size: z.ZodEnum<{
+            S: "S";
+            M: "M";
+            L: "L";
+        }>;
+        col: z.ZodNumber;
+        row: z.ZodNumber;
+        params: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>;
+    launcher: z.ZodObject<{
+        pinned: z.ZodArray<z.ZodString>;
+        hidden: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type DesktopLayout = z.output<typeof desktopLayoutSchema>;
+export type DesktopGill = Readonly<{
+    surfaceId: string;
+    gillId: string;
+    title: string;
+    sizes: readonly AppGillDesktopSize[];
+    kind: "app" | "launcher";
+    params?: readonly AppGillParam[] | undefined;
+}>;
+export declare const desktopArrangeSchema: z.ZodObject<{
+    scope: z.ZodEnum<{
+        member: "member";
+        team: "team";
+    }>;
+    basedOn: z.ZodNullable<z.ZodNumber>;
+    ops: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"add">;
+        surfaceId: z.ZodString;
+        gillId: z.ZodString;
+        size: z.ZodEnum<{
+            S: "S";
+            M: "M";
+            L: "L";
+        }>;
+        params: z.ZodExactOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        at: z.ZodOptional<z.ZodObject<{
+            col: z.ZodNumber;
+            row: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"move">;
+        id: z.ZodString;
+        to: z.ZodObject<{
+            col: z.ZodNumber;
+            row: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"resize">;
+        id: z.ZodString;
+        size: z.ZodEnum<{
+            S: "S";
+            M: "M";
+            L: "L";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"remove">;
+        id: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"reset">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"launcher">;
+        id: z.ZodString;
+        state: z.ZodEnum<{
+            Shown: "Shown";
+            Pinned: "Pinned";
+            Hidden: "Hidden";
+        }>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+export type DesktopArrange = z.output<typeof desktopArrangeSchema>;
+export declare const desktopArrangeResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"accepted">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"rejected">;
+    code: z.ZodEnum<{
+        invalid: "invalid";
+        owner_required: "owner_required";
+        unknown_gill: "unknown_gill";
+        unknown_app: "unknown_app";
+        size_not_allowed: "size_not_allowed";
+        unknown_item: "unknown_item";
+        too_many: "too_many";
+        conflict: "conflict";
+        too_large: "too_large";
+        quota_exceeded: "quota_exceeded";
+        params_invalid: "params_invalid";
+    }>;
+}, z.core.$strict>], "kind">;
+export type DesktopArrangeResult = z.output<typeof desktopArrangeResultSchema>;
+/** Only the selected Gill's declared keys may be persisted. */
+export declare function validDesktopGillParams(params: Readonly<Record<string, string>> | undefined, declared?: readonly AppGillParam[]): boolean;
+export declare function desktopPlacements(layout: DesktopLayout): readonly BentoPlacement[];
+export declare function compactDesktopLayout(layout: DesktopLayout): DesktopLayout;
+export declare function availableDesktopLayout(layout: DesktopLayout, catalog: readonly DesktopGill[]): DesktopLayout;
+export declare function initialDesktopLayout(catalog: readonly DesktopGill[], inboxSurfaceId: string | null): DesktopLayout;
+/** Apply one atomic operation batch without reading or writing storage. */
+export declare function applyDesktopOps(current: DesktopLayout, ops: DesktopArrange["ops"], catalog: readonly DesktopGill[], launchableAppIds: readonly string[], createId: () => string): {
+    kind: "accepted";
+    layout: DesktopLayout | null;
+} | Extract<DesktopArrangeResult, {
+    kind: "rejected";
+}>;
+/** Responsive cells are a projection; only the relative intent reaches the wide layout. */
+export declare function desktopBentoIntent(layout: DesktopLayout, projected: readonly BentoPlacement[], op: BentoOp): DesktopArrange["ops"][number] | null;

package/dist/desktop-layout.js

@@ -0,0 +1,305 @@
+import { z } from "zod";
+import { applyBentoOps, arrangeBento, } from "@fungi.computer/maosaico/bento";
+import { gillParamsSchema, } from "@fungi.computer/gills";
+import * as Schema from "effect/Schema";
+/** Stored placement values use the maintained Gill grammar. */
+const desktopGillParamsSchema = z
+    .record(z.string().min(1).max(64), z.string().max(256))
+    .refine((value) => Schema.is(gillParamsSchema)(value));
+const identity = z.string().min(1).max(513);
+const cell = z
+    .number()
+    .int()
+    .nonnegative()
+    .max(Number.MAX_SAFE_INTEGER - 2);
+const size = z.enum(["S", "M", "L"]);
+const launcherIds = z
+    .array(identity)
+    .max(128)
+    .refine((ids) => new Set(ids).size === ids.length, "App identities must be unique");
+const uniqueIds = (items) => new Set(items.map((item) => item.id)).size === items.length;
+export const desktopLayoutSchema = z.strictObject({
+    version: z.literal(1),
+    items: z
+        .array(z.strictObject({
+        id: identity,
+        surfaceId: identity,
+        gillId: identity,
+        size,
+        col: cell.max(3),
+        row: cell.max(47),
+        params: desktopGillParamsSchema.exactOptional(),
+    }))
+        .max(24)
+        .refine(uniqueIds, "Gill identities must be unique"),
+    launcher: z
+        .strictObject({ pinned: launcherIds, hidden: launcherIds })
+        .refine((value) => value.pinned.every((id) => !value.hidden.includes(id)), "Pinned Apps cannot be hidden"),
+});
+export const desktopArrangeSchema = z.strictObject({
+    scope: z.enum(["member", "team"]),
+    basedOn: z.number().int().positive().nullable(),
+    ops: z
+        .array(z.discriminatedUnion("kind", [
+        z.strictObject({
+            kind: z.literal("add"),
+            surfaceId: identity,
+            gillId: identity,
+            size,
+            params: desktopGillParamsSchema.exactOptional(),
+            at: z
+                .strictObject({ col: cell.max(3), row: cell.max(47) })
+                .optional(),
+        }),
+        z.strictObject({
+            kind: z.literal("move"),
+            id: identity,
+            to: z.strictObject({ col: cell.max(3), row: cell.max(47) }),
+        }),
+        z.strictObject({ kind: z.literal("resize"), id: identity, size }),
+        z.strictObject({ kind: z.literal("remove"), id: identity }),
+        z.strictObject({ kind: z.literal("reset") }),
+        z.strictObject({
+            kind: z.literal("launcher"),
+            id: identity,
+            state: z.enum(["Shown", "Pinned", "Hidden"]),
+        }),
+    ]))
+        .max(24),
+});
+export const desktopArrangeResultSchema = z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("accepted") }),
+    z.strictObject({
+        kind: z.literal("rejected"),
+        code: z.enum([
+            "invalid",
+            "owner_required",
+            "unknown_gill",
+            "unknown_app",
+            "size_not_allowed",
+            "unknown_item",
+            "too_many",
+            "conflict",
+            "too_large",
+            "quota_exceeded",
+            "params_invalid",
+        ]),
+    }),
+]);
+/** Only the selected Gill's declared keys may be persisted. */
+export function validDesktopGillParams(params, declared = []) {
+    const values = params ?? {};
+    return (Object.keys(values).every((key) => declared.some((param) => param.key === key)) &&
+        declared.every((param) => !param.required ||
+            (Object.hasOwn(values, param.key) && Boolean(values[param.key]))));
+}
+export function desktopPlacements(layout) {
+    return layout.items.map((item) => ({
+        id: item.id,
+        col: item.col,
+        row: item.row,
+        w: item.size === "S" ? 1 : 2,
+        h: item.size === "L" ? 2 : 1,
+    }));
+}
+export function compactDesktopLayout(layout) {
+    const cells = arrangeBento(desktopPlacements(layout), 4);
+    return {
+        ...layout,
+        items: layout.items.map((item) => {
+            const placement = cells.find((position) => position.id === item.id);
+            return {
+                ...item,
+                col: placement?.col ?? item.col,
+                row: placement?.row ?? item.row,
+            };
+        }),
+    };
+}
+export function availableDesktopLayout(layout, catalog) {
+    return {
+        ...layout,
+        items: layout.items.filter((item) => catalog.some((gill) => gill.surfaceId === item.surfaceId &&
+            gill.gillId === item.gillId &&
+            gill.sizes.includes(item.size))),
+    };
+}
+export function initialDesktopLayout(catalog, inboxSurfaceId) {
+    const inbox = catalog.find((gill) => gill.kind === "app" &&
+        gill.surfaceId === inboxSurfaceId &&
+        gill.sizes.includes("L"));
+    return {
+        version: 1,
+        items: [
+            ...(inbox
+                ? [
+                    {
+                        id: "inbox",
+                        surfaceId: inbox.surfaceId,
+                        gillId: inbox.gillId,
+                        size: "L",
+                        col: 0,
+                        row: 0,
+                    },
+                ]
+                : []),
+            {
+                id: "launcher",
+                surfaceId: "tourtois",
+                gillId: "launcher",
+                size: "M",
+                col: inbox ? 2 : 0,
+                row: 0,
+            },
+        ],
+        launcher: { pinned: [], hidden: [] },
+    };
+}
+/** Apply one atomic operation batch without reading or writing storage. */
+export function applyDesktopOps(current, ops, catalog, launchableAppIds, createId) {
+    let layout = current;
+    for (const op of ops) {
+        if (op.kind === "reset") {
+            if (ops.length !== 1)
+                return { kind: "rejected", code: "invalid" };
+            continue;
+        }
+        if (op.kind === "launcher") {
+            if (!launchableAppIds.includes(op.id))
+                return { kind: "rejected", code: "unknown_app" };
+            layout = {
+                ...layout,
+                launcher: {
+                    pinned: [
+                        ...layout.launcher.pinned.filter((id) => id !== op.id),
+                        ...(op.state === "Pinned" ? [op.id] : []),
+                    ],
+                    hidden: [
+                        ...layout.launcher.hidden.filter((id) => id !== op.id),
+                        ...(op.state === "Hidden" ? [op.id] : []),
+                    ],
+                },
+            };
+            continue;
+        }
+        if (op.kind === "add") {
+            const gill = catalog.find((entry) => entry.surfaceId === op.surfaceId && entry.gillId === op.gillId);
+            if (!gill)
+                return { kind: "rejected", code: "unknown_gill" };
+            if (!gill.sizes.includes(op.size))
+                return { kind: "rejected", code: "size_not_allowed" };
+            if (!validDesktopGillParams(op.params, gill.params))
+                return { kind: "rejected", code: "params_invalid" };
+            if (layout.items.length >= 24)
+                return { kind: "rejected", code: "too_many" };
+            const item = {
+                id: createId(),
+                surfaceId: op.surfaceId,
+                gillId: op.gillId,
+                size: op.size,
+                col: op.at?.col ?? 0,
+                row: op.at?.row ?? 0,
+            };
+            if (op.params !== undefined)
+                item.params = op.params;
+            layout = compactDesktopLayout({
+                ...layout,
+                items: [...layout.items, item],
+            });
+            continue;
+        }
+        const item = layout.items.find((entry) => entry.id === op.id);
+        if (!item)
+            return { kind: "rejected", code: "unknown_item" };
+        if (op.kind === "remove") {
+            layout = compactDesktopLayout({
+                ...layout,
+                items: layout.items.filter((entry) => entry.id !== op.id),
+            });
+            continue;
+        }
+        if (op.kind === "resize") {
+            const gill = catalog.find((entry) => entry.surfaceId === item.surfaceId && entry.gillId === item.gillId);
+            if (!gill?.sizes.includes(op.size))
+                return { kind: "rejected", code: "size_not_allowed" };
+        }
+        const cells = applyBentoOps(desktopPlacements(layout), [
+            op.kind === "move"
+                ? { kind: "move", id: op.id, col: op.to.col, row: op.to.row }
+                : {
+                    kind: "resize",
+                    id: op.id,
+                    w: op.size === "S" ? 1 : 2,
+                    h: op.size === "L" ? 2 : 1,
+                },
+        ], 4);
+        layout = {
+            ...layout,
+            items: layout.items.map((entry) => {
+                const position = cells.find((cell) => cell.id === entry.id);
+                return {
+                    ...entry,
+                    size: op.kind === "resize" && entry.id === op.id ? op.size : entry.size,
+                    col: position?.col ?? entry.col,
+                    row: position?.row ?? entry.row,
+                };
+            }),
+        };
+    }
+    const parsed = desktopLayoutSchema.safeParse(layout);
+    if (!parsed.success)
+        return { kind: "rejected", code: "invalid" };
+    return {
+        kind: "accepted",
+        layout: ops[0]?.kind === "reset" ? null : parsed.data,
+    };
+}
+/** Responsive cells are a projection; only the relative intent reaches the wide layout. */
+export function desktopBentoIntent(layout, projected, op) {
+    const item = layout.items.find((item) => item.id === op.id);
+    const shown = projected.find((item) => item.id === op.id);
+    if (!item || !shown)
+        return null;
+    if (op.kind === "resize")
+        return {
+            kind: "resize",
+            id: op.id,
+            size: op.h >= 2 ? "L" : op.w >= 2 ? "M" : "S",
+        };
+    // A phone row crossing is an ordering intent between tiles. Translate it to
+    // the neighbour's canonical cell; writing the phone cell would erase the wide layout.
+    const reflowed = projected.some((cell) => {
+        const canonical = layout.items.find((item) => item.id === cell.id);
+        return (canonical && (canonical.col !== cell.col || canonical.row !== cell.row));
+    });
+    if (reflowed && op.row !== shown.row) {
+        const neighbours = projected
+            .filter((other) => other.id !== op.id &&
+            op.col < other.col + other.w &&
+            op.col + shown.w > other.col &&
+            op.row < other.row + other.h &&
+            op.row + shown.h > other.row)
+            .sort((a, b) => Math.abs(a.row - shown.row) - Math.abs(b.row - shown.row));
+        const neighbour = neighbours[0];
+        const canonical = layout.items.find((item) => item.id === neighbour?.id);
+        if (canonical && neighbour)
+            return {
+                kind: "move",
+                id: op.id,
+                to: {
+                    col: canonical.col,
+                    row: op.row < shown.row
+                        ? canonical.row
+                        : canonical.row + Math.max(1, neighbour.h - shown.h),
+                },
+            };
+    }
+    return {
+        kind: "move",
+        id: op.id,
+        to: {
+            col: Math.max(0, Math.min(3, item.col + op.col - shown.col)),
+            row: Math.max(0, item.row + op.row - shown.row),
+        },
+    };
+}

package/dist/desktop-visibility.d.ts

@@ -0,0 +1,8 @@
+/** The desktop stays mounted; layout determines whether it can receive input. */
+export type DesktopVisibility = "revealed" | "partial" | "covered";
+export declare function desktopVisibility({ hasVisibleWindows, mode, zoomedId, phone, }: {
+    hasVisibleWindows: boolean;
+    mode: "tiled" | "floating";
+    zoomedId: string | null;
+    phone: boolean;
+}): DesktopVisibility;

package/dist/desktop-visibility.js

@@ -0,0 +1,5 @@
+export function desktopVisibility({ hasVisibleWindows, mode, zoomedId, phone, }) {
+    if (!hasVisibleWindows)
+        return "revealed";
+    return mode === "tiled" || zoomedId !== null || phone ? "covered" : "partial";
+}

package/dist/layers.d.ts

@@ -0,0 +1,5 @@
+import { type ReactNode } from "react";
+/** Tourtois composes Caps portal destinations with Maosaico's ordered roots. */
+export declare function TourtoisLayers({ children }: {
+    children?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/layers.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { OverlayRoot } from "@fungi.computer/caps/components/overlay-root";
+import { MaosaicoLayers, useLayer } from "@fungi.computer/maosaico";
+import { useMemo } from "react";
+function OverlayContainers({ children, subscribeDismiss, }) {
+    const popover = useLayer("popover");
+    const dialog = useLayer("dialog");
+    const toast = useLayer("toast");
+    const tooltip = useLayer("tooltip");
+    const containers = useMemo(() => ({ popover, dialog, toast, tooltip }), [popover, dialog, toast, tooltip]);
+    return (_jsx(OverlayRoot, { containers: containers, subscribeDismiss: subscribeDismiss, children: children }));
+}
+/** Tourtois composes Caps portal destinations with Maosaico's ordered roots. */
+export function TourtoisLayers({ children }) {
+    const dismissal = useMemo(() => {
+        const listeners = new Set();
+        return {
+            subscribe: (listener) => {
+                listeners.add(listener);
+                return () => {
+                    listeners.delete(listener);
+                };
+            },
+            dismiss: () => {
+                for (const listener of listeners)
+                    listener();
+            },
+        };
+    }, []);
+    return (_jsx(MaosaicoLayers, { onDismiss: dismissal.dismiss, children: _jsx(OverlayContainers, { subscribeDismiss: dismissal.subscribe, children: children }) }));
+}

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+import "@fungi.computer/parakeet/styles.css";
+import "@fungi.computer/caps/fonts.css";

package/dist/main.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/// <reference types="vite/client" />
+import { createRoot } from "react-dom/client";
+import { ResultState } from "@fungi.computer/caps/blocks/result-state";
+import "@fungi.computer/parakeet/styles.css";
+import "@fungi.computer/caps/fonts.css";
+const root = document.getElementById("tourtois-root");
+if (!root)
+    throw new Error("Tourtois root is missing");
+// Tourtois is a shell, not a framed App: its host composes it into the host's
+// own top-level document with escalated permissions. This Release keeps the
+// desktop's storage and methods; its page only says where the shell lives.
+const reactRoot = createRoot(root);
+reactRoot.render(_jsx("main", { className: "tourtois-shell", "data-tourtois-release": true, children: _jsx(ResultState, { title: "Tourtois runs as your shell", description: "Your host serves Tourtois as its trusted home. Open your host's home page to use it." }) }));
+import.meta.hot?.dispose(() => {
+    reactRoot.unmount();
+});

package/dist/member-avatar-cache.d.ts

@@ -0,0 +1,15 @@
+import { type MemberAvatar } from "@fungi.computer/sprite-zdog/avatar";
+/** Memory fallback lasts for this page; it does not claim durable storage. */
+type AvatarCacheOutcome = {
+    readonly kind: "persistent";
+} | {
+    readonly kind: "memory";
+    readonly stage: "read" | "write";
+};
+/** Guard acquisition as well as use: a sandbox may throw on the getter itself. */
+export declare function createMemberAvatarCache(storage: () => Pick<Storage, "getItem" | "setItem">): {
+    snapshot: () => MemberAvatar;
+    write: (next: MemberAvatar) => AvatarCacheOutcome;
+    subscribe: (listener: () => void) => () => void;
+};
+export {};

package/dist/member-avatar-cache.js

@@ -0,0 +1,69 @@
+import * as Schema from "effect/Schema";
+import * as Option from "effect/Option";
+import { defaultMemberAvatar, memberAvatarSchema, } from "@fungi.computer/sprite-zdog/avatar";
+const storageKey = "fungi.member.avatar.v1";
+/** Guard acquisition as well as use: a sandbox may throw on the getter itself. */
+export function createMemberAvatarCache(storage) {
+    const listeners = new Set();
+    let outcome = { kind: "persistent" };
+    let cachedRaw;
+    let cached = defaultMemberAvatar;
+    function snapshot() {
+        if (outcome.kind === "memory")
+            return cached;
+        let raw;
+        try {
+            raw = storage().getItem(storageKey);
+        }
+        catch (cause) {
+            outcome = { kind: "memory", stage: "read" };
+            console.warn("Member avatar using memory cache", outcome, cause);
+            return cached;
+        }
+        if (raw === cachedRaw)
+            return cached;
+        cachedRaw = raw;
+        const decoded = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown))(raw);
+        const parsed = Option.isSome(decoded)
+            ? memberAvatarSchema.safeParse(decoded.value)
+            : undefined;
+        cached = parsed?.success ? parsed.data : defaultMemberAvatar;
+        return cached;
+    }
+    function write(next) {
+        const value = memberAvatarSchema.parse(next);
+        const raw = JSON.stringify(value);
+        snapshot();
+        if (raw === cachedRaw)
+            return outcome;
+        if (outcome.kind === "persistent") {
+            try {
+                storage().setItem(storageKey, raw);
+            }
+            catch (cause) {
+                outcome = { kind: "memory", stage: "write" };
+                console.warn("Member avatar using memory cache", outcome, cause);
+            }
+        }
+        cachedRaw = raw;
+        cached = value;
+        for (const listener of listeners)
+            listener();
+        return outcome;
+    }
+    function subscribe(listener) {
+        listeners.add(listener);
+        const onStorage = (event) => {
+            if (outcome.kind === "persistent" &&
+                (event.key === storageKey || event.key === null)) {
+                listener();
+            }
+        };
+        window.addEventListener("storage", onStorage);
+        return () => {
+            listeners.delete(listener);
+            window.removeEventListener("storage", onStorage);
+        };
+    }
+    return { snapshot, write, subscribe };
+}

package/dist/member-avatar.d.ts

@@ -0,0 +1,39 @@
+import { type MemberAvatar } from "@fungi.computer/sprite-zdog/avatar";
+import type { RenderStyle } from "@fungi.computer/sprite";
+import { type CSSProperties, type ReactNode } from "react";
+import type { WhistleJsonValue } from "@fungi.computer/whistle";
+/** Decode the host-granted avatar preference. */
+export declare const parseMemberAvatar: (value: WhistleJsonValue) => MemberAvatar | null;
+/** Account edits and host settings changes invalidate this query. */
+export declare const accountAvatarQuery: readonly ["tourtois", "account-avatar"];
+/** Save the person's avatar through the host's account; returns the saved value. */
+export type MemberAvatarSave = (next: MemberAvatar) => Promise<MemberAvatar>;
+/** Read the person's saved avatar, parsed by the reader. */
+export type MemberAvatarReader = (signal: AbortSignal) => Promise<MemberAvatar | null>;
+/**
+ * Read the avatar through a host-granted source: an isolated dashboard's
+ * capability, or the host's own account read. Without one, the sprite draws
+ * from this browser's cache.
+ */
+export declare function MemberAvatarSource({ read, children, }: {
+    read: MemberAvatarReader;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * The current avatar: the account's value once read (refreshing the
+ * cache), otherwise the cached value, updated across tabs.
+ */
+export declare function useMemberAvatar(): MemberAvatar;
+/** The person's sprite as the shell presents it: saved style and appearance. */
+export declare function OwnSprite(props: {
+    readonly activity?: string;
+    readonly expression?: string;
+    readonly className?: string;
+    readonly style?: CSSProperties;
+    readonly renderStyle?: RenderStyle;
+    readonly "aria-hidden"?: "true";
+}): import("react/jsx-runtime").JSX.Element;
+/** Host-rendered picker: Apps read the preference but never write account routes. */
+export declare function AvatarSettings({ save: write }: {
+    save: MemberAvatarSave;
+}): import("react/jsx-runtime").JSX.Element;