@axium/client 0.27.0 → 0.28.0

package/assets/theme.css

@@ -50,6 +50,7 @@ html {
 
 	--border-disabled: 1px solid hsl(0 5 calc(var(--bg-light) - var(--light-step)));
 	--border-accent: 1px solid hsl(var(--hue) 10 calc(var(--bg-light) + (var(--light-step) * 3)));
+	--border-alt: 1px solid var(--bg-alt);
 	--border-strong: 1px solid hsl(var(--hue) 20 calc(var(--bg-light) + (var(--light-step) * 3)));
 
 	--border-error: 1px solid hsl(0 50 var(--fg-light));

package/dist/access.js

@@ -1,20 +1,23 @@
-import * as cache from './cache.js';
+import Cache from './cache.js';
 import { fetchAPI } from './requests.js';
+const cache = new Cache((itemType, itemId) => fetchAPI('GET', 'acl/:itemType/:itemId', {}, itemType, itemId), {
+    ttl: 3600_000,
+});
 export async function updateACL(itemType, itemId, target, permissions) {
     const result = await fetchAPI('PATCH', 'acl/:itemType/:itemId', { target, permissions }, itemType, itemId);
-    cache.invalidate('acl', `${itemType}/${itemId}`);
+    cache.invalidate(itemType, itemId);
     return result;
 }
 export async function getACL(itemType, itemId) {
-    return await cache.use('acl', `${itemType}/${itemId}`, () => fetchAPI('GET', 'acl/:itemType/:itemId', {}, itemType, itemId));
+    return await cache.get(itemType, itemId);
 }
 export async function addToACL(itemType, itemId, target) {
     const result = await fetchAPI('PUT', 'acl/:itemType/:itemId', target, itemType, itemId);
-    cache.invalidate('acl', `${itemType}/${itemId}`);
+    cache.invalidate(itemType, itemId);
     return result;
 }
 export async function removeFromACL(itemType, itemId, target) {
     const result = await fetchAPI('DELETE', 'acl/:itemType/:itemId', target, itemType, itemId);
-    cache.invalidate('acl', `${itemType}/${itemId}`);
+    cache.invalidate(itemType, itemId);
     return result;
 }

package/dist/cache.d.ts

@@ -1,20 +1,53 @@
-export interface Options {
+import * as z from 'zod';
+export interface CacheOptions {
     /** Maximum number of items the cache can hold */
     itemLimit: number;
+    /** @todo replace with `Temporal.DurationLike` */
+    ttl: number;
 }
+export declare const CacheData: z.ZodRecord<z.ZodString, z.ZodObject<{
+    $timestamp: z.ZodCoercedDate<unknown>;
+}, z.core.$loose>>;
+/** @todo replace `$timestamp` with `Temporal.InstantLike` */
+export interface CacheData<V> extends Record<string, V & {
+    $timestamp: number;
+}> {
+}
+declare const kTimestamp: unique symbol;
 /**
- * Create a cache manually. Only useful when you want to specify different options.
- */
-export declare function create(cacheName: string, options?: Partial<Options>): void;
-/**
- * Use a cache for some arbitrary operation.
+ * Cache some arbitrary operation.
  * This is primarily intended for de-duplicating API requests
- * @param cacheName The name of the cache to use, e.g. `'users'`
- * @param key The key for the item in the cache. This can be anything used for the key of a `Map`
- * @param miss The function to run on a cache miss
- * @remarks
- * Note that a cache will automatically be created if it doesn't already exist
  */
-export declare function use<Key, Result>(cacheName: string, key: Key, miss: () => Result): Result;
-export declare function invalidate(cacheName: string, key: any): void;
-export declare function update(cacheName: string, key: any, value: any): void;
+export declare class Cache<Keys extends string[], V extends object> {
+    /**
+     * Function to run when there is a cache miss
+     * @
+     */
+    protected readonly miss: (...keys: Keys) => V | Promise<V>;
+    protected items: Map<string, V & {
+        [kTimestamp]: number;
+    }>;
+    protected pending: Map<string, Promise<V>>;
+    readonly options: CacheOptions;
+    private onWrite?;
+    constructor(
+    /**
+     * Function to run when there is a cache miss
+     * @
+     */
+    miss: (...keys: Keys) => V | Promise<V>, options?: Partial<CacheOptions>);
+    protected key(keys: Keys): string;
+    get size(): number;
+    protected valid(timestamp?: number): boolean;
+    protected write(key: string, value: V | Promise<V>): void;
+    get(...keys: Keys): V | Promise<V>;
+    set(...args: [...keys: Keys, value: V | Promise<V>]): void;
+    invalidate(...keys: Keys): void;
+    persist(onWrite: (data: CacheData<V>) => void, 
+    /** @todo replace `$timestamp` with `Temporal.InstantLike` */
+    existingContent?: Record<string, V & {
+        $timestamp?: number;
+    }>): void;
+    toJSON(): CacheData<V>;
+}
+export default Cache;

package/dist/cache.js

@@ -1,48 +1,99 @@
-const _caches = Object.create(null);
+import * as z from 'zod';
 const defaultCacheOptions = {
     itemLimit: 10_000,
+    ttl: 3600_000,
 };
-/**
- * Create a cache manually. Only useful when you want to specify different options.
- */
-export function create(cacheName, options = {}) {
-    if (_caches[cacheName])
-        throw new Error('Multiple caches with the same name are not allowed');
-    _caches[cacheName] = {
-        items: new Map(),
-        ...defaultCacheOptions,
-        ...options,
-    };
+export const CacheData = z.record(z.string(), z.looseObject({
+    /** @todo replace with temporal instant */
+    $timestamp: z.coerce.date(),
+}));
+function isThenable(value) {
+    return !!(value && typeof value == 'object' && 'then' in value && typeof value.then == 'function');
 }
+const kTimestamp = Symbol('kTimestamp');
 /**
- * Use a cache for some arbitrary operation.
+ * Cache some arbitrary operation.
  * This is primarily intended for de-duplicating API requests
- * @param cacheName The name of the cache to use, e.g. `'users'`
- * @param key The key for the item in the cache. This can be anything used for the key of a `Map`
- * @param miss The function to run on a cache miss
- * @remarks
- * Note that a cache will automatically be created if it doesn't already exist
  */
-export function use(cacheName, key, miss) {
-    const cache = (_caches[cacheName] ||= { items: new Map(), ...defaultCacheOptions });
-    const cached = cache.items.get(key);
-    if (cached)
-        return cached;
-    const result = miss();
-    cache.items.set(key, result);
-    return result;
-}
-export function invalidate(cacheName, key) {
-    const cache = _caches[cacheName];
-    if (!cache)
-        throw new ReferenceError("Can't invalidate key in non-existent cache: " + cacheName);
-    if (cache)
-        cache.items.delete(key);
-}
-export function update(cacheName, key, value) {
-    const cache = _caches[cacheName];
-    if (!cache)
-        throw new ReferenceError("Can't update key in non-existent cache: " + cacheName);
-    if (cache)
-        cache.items.set(key, value);
+export class Cache {
+    miss;
+    items = new Map();
+    pending = new Map();
+    options;
+    onWrite;
+    constructor(
+    /**
+     * Function to run when there is a cache miss
+     * @
+     */
+    miss, options = {}) {
+        this.miss = miss;
+        this.options = { ...defaultCacheOptions, ...options };
+    }
+    key(keys) {
+        return keys.join(':');
+    }
+    get size() {
+        return this.items.size;
+    }
+    valid(timestamp) {
+        return !this.options.ttl || !timestamp || timestamp.valueOf() + this.options.ttl < Date.now();
+    }
+    write(key, value) {
+        if (isThenable(value)) {
+            this.pending.set(key, value);
+            void value.then(resolved => {
+                this.write(key, resolved);
+                this.pending.delete(key);
+            });
+            return;
+        }
+        if (this.items.size >= this.options.itemLimit) {
+            const [key] = this.items.entries().next().value;
+            this.items.delete(key);
+        }
+        this.items.set(key, Object.assign(value, { [kTimestamp]: Date.now() }));
+        this.onWrite?.(this.toJSON());
+    }
+    get(...keys) {
+        const key = this.key(keys);
+        const pending = this.pending.get(key);
+        if (pending)
+            return pending;
+        const cached = this.items.get(key);
+        if (cached) {
+            if (this.valid(cached[kTimestamp]))
+                return cached;
+            this.items.delete(key);
+        }
+        const result = this.miss(...keys);
+        this.write(key, result);
+        return result;
+    }
+    set(...args) {
+        const value = args.pop();
+        const key = this.key(args);
+        this.write(key, value);
+    }
+    invalidate(...keys) {
+        this.items.delete(this.key(keys));
+    }
+    persist(onWrite, 
+    /** @todo replace `$timestamp` with `Temporal.InstantLike` */
+    existingContent) {
+        this.onWrite = onWrite;
+        if (!existingContent)
+            return;
+        for (const [key, value] of Object.entries(existingContent)) {
+            const { $timestamp = Date.now() } = value;
+            if (!this.valid($timestamp))
+                continue;
+            delete value.$timestamp;
+            this.items.set(key, Object.assign(value, { [kTimestamp]: $timestamp }));
+        }
+    }
+    toJSON() {
+        return Object.fromEntries(this.items.entries().map(([k, v]) => [k, { ...v, $timestamp: v[kTimestamp] }]));
+    }
 }
+export default Cache;

package/dist/cli/auth.d.ts

@@ -0,0 +1,2 @@
+export declare const clientUA: string;
+export declare function login(url?: string): Promise<void>;

package/dist/cli/auth.js

@@ -0,0 +1,140 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { NewSessionResponse } from '@axium/core';
+import * as io from 'ioium/node';
+import { createServer } from 'node:http';
+import { createInterface } from 'node:readline/promises';
+import { styleText } from 'node:util';
+import { config, resolveServerURL } from '../config.js';
+import { prefix, setPrefix, setToken } from '../requests.js';
+import { getCurrentSession } from '../user.js';
+import * as cache from './cache.js';
+import { saveConfig } from './config.js';
+import * as os from 'node:os';
+import $pkg from '../../package.json' with { type: 'json' };
+export const clientUA = `Axium Client/${$pkg.version} (${os.type()}; ${process.arch})`;
+export async function login(url) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const rl = __addDisposableResource(env_1, createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        }), false);
+        rl.on('SIGINT', () => io.exit('Aborted.', 7));
+        if (prefix[0] != '/')
+            url ||= prefix;
+        url ||= await rl.question('Axium server URL: ');
+        url = resolveServerURL(url);
+        setPrefix(url);
+        const sessionReady = Promise.withResolvers();
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        const server = createServer(async (req, res) => {
+            res.setHeader('access-control-allow-origin', '*');
+            res.setHeader('access-control-allow-methods', '*');
+            res.setHeader('access-control-allow-headers', '*');
+            if (req.method == 'HEAD' || req.method == 'OPTIONS') {
+                res.writeHead(200).end();
+                return;
+            }
+            if (!req.headers['content-type']?.endsWith('/json')) {
+                res.writeHead(415).end('Unexpected content type');
+                return;
+            }
+            if (req.method !== 'POST') {
+                res.writeHead(405).end('Unexpected request method');
+                return;
+            }
+            const { promise: bodyReady, resolve, reject } = Promise.withResolvers();
+            let body = '';
+            req.on('data', chunk => (body += chunk.toString()));
+            req.on('end', resolve);
+            req.on('error', reject);
+            try {
+                await bodyReady;
+                res.writeHead(200).end();
+                sessionReady.resolve(NewSessionResponse.parse(JSON.parse(body)));
+            }
+            catch (e) {
+                res.statusCode = 500;
+                res.end('Internal server error: ' + io.errorText(e));
+                sessionReady.reject(io.errorText(e));
+            }
+        });
+        const serverReady = Promise.withResolvers();
+        server.listen(() => {
+            const { port } = server.address();
+            serverReady.resolve(port);
+        });
+        server.on('error', e => io.exit('Failed to start local callback server: ' + io.errorText(e), 5));
+        const port = await serverReady.promise;
+        const authURL = new URL(`/login/client?port=${port}&client=${encodeURIComponent(clientUA)}`, url).href;
+        console.log('Authenticate by visiting this URL in your browser: ' + styleText('underline', authURL));
+        const { token } = await sessionReady.promise.catch(e => io.exit('Failed to obtain session: ' + e, 6));
+        setToken(token);
+        server.close();
+        const session = await io.track('Verifying session', getCurrentSession().catch(e => io.exit(e, 6)));
+        io.debug('Session UUID: ' + session.id);
+        console.log(`Welcome ${session.user.name}! Your session is valid until ${session.expires.toLocaleDateString()}.`);
+        config.token = token;
+        config.server = url;
+        saveConfig();
+        await cache.update(true);
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+}

package/dist/cli/cache.d.ts

@@ -0,0 +1,80 @@
+import * as z from 'zod';
+export declare const dir: string;
+declare const create: unique symbol;
+export declare class Handle<S extends z.ZodObject> {
+    private init;
+    private _data?;
+    readonly path: string;
+    get schema(): S;
+    private constructor();
+    load(): void;
+    save(): void;
+    update(): Promise<void>;
+    isValid(): Promise<boolean>;
+    get data(): z.infer<S>;
+    static [create]<S extends z.ZodObject>(init: Init<S>): Handle<S>;
+}
+export interface Init<S extends z.ZodObject> {
+    path: string;
+    schema: S;
+    update(existing?: z.infer<S>): z.infer<S> | Promise<z.infer<S>>;
+    isValid(data: z.infer<S>, lastUpdatedTs: number): boolean | Promise<boolean>;
+    onLoad?(data: z.infer<S>): unknown;
+}
+export declare function useAt<S extends z.ZodObject>(init: Init<S>): Handle<S>;
+export declare const meta: Handle<z.ZodObject<{
+    fetched: z.ZodInt;
+    session: z.ZodObject<{
+        id: z.ZodUUID;
+        userId: z.ZodUUID;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        expires: z.ZodCoercedDate<unknown>;
+        created: z.ZodCoercedDate<unknown>;
+        elevated: z.ZodBoolean;
+        user: z.ZodObject<{
+            id: z.ZodUUID;
+            name: z.ZodString;
+            email: z.ZodEmail;
+            emailVerified: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
+            preferences: z.ZodLazy<z.ZodObject<{
+                debug: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            roles: z.ZodArray<z.ZodString>;
+            tags: z.ZodArray<z.ZodString>;
+            registeredAt: z.ZodCoercedDate<unknown>;
+            isAdmin: z.ZodBoolean;
+            isSuspended: z.ZodBoolean;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    apps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        image: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$loose>>;
+export declare const sync: Handle<z.ZodObject<{
+    objects: z.ZodArray<z.ZodObject<{
+        $type: z.ZodString;
+        id: z.ZodUUID;
+    }, z.core.$loose>>;
+    index: z.ZodCoercedBigInt<unknown>;
+}, z.core.$strip>>;
+export declare function load(): void;
+export declare function update(force?: boolean): Promise<void>;
+export declare function clear(): void;
+export interface CacheInfo {
+    path: string;
+    size?: bigint;
+    exists: boolean;
+}
+export interface CacheInfoLocal extends CacheInfo {
+    valid: boolean;
+    fromAPI?: false;
+}
+export interface CacheInfoAPI extends CacheInfo {
+    entries: number;
+    fromAPI: true;
+}
+export declare function info(): AsyncGenerator<CacheInfoLocal | CacheInfoAPI>;
+export {};

package/dist/cli/cache.js

@@ -0,0 +1,155 @@
+import { App, Session, SyncState, User } from '@axium/core';
+import * as io from 'ioium/node';
+import { existsSync, mkdirSync, statSync, unlinkSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path/posix';
+import * as z from 'zod';
+import { CacheData } from '../cache.js';
+import { fetchAPI } from '../requests.js';
+import { apiUserCache, getCurrentSession } from '../user.js';
+export const dir = join(process.env.XDG_CACHE_HOME || join(homedir(), '.cache'), 'axium');
+mkdirSync(dir, { recursive: true });
+const create = Symbol('Handle::new');
+export class Handle {
+    init;
+    _data;
+    path;
+    get schema() {
+        return this.init.schema;
+    }
+    constructor(init) {
+        this.init = init;
+        this.path = resolve(dir, init.path);
+    }
+    load() {
+        if (!existsSync(this.path)) {
+            io.debug('Ignoring missing cache file:', this.path);
+            return;
+        }
+        try {
+            this._data = io.readJSON(this.path, this.schema);
+        }
+        catch (e) {
+            io.warn(`Failed to load cache from '${this.path}':\n${e}`);
+            return;
+        }
+        this.init.onLoad?.(this._data);
+    }
+    save() {
+        if (!this._data)
+            throw new ReferenceError('Cache data is not loaded');
+        try {
+            io.writeJSON(this.path, this._data);
+        }
+        catch (e) {
+            io.error(e);
+        }
+    }
+    async update() {
+        this._data = await this.init.update(this._data);
+        this.init.onLoad?.(this._data);
+        this.save();
+    }
+    async isValid() {
+        if (!this._data)
+            return false;
+        return this.init.isValid(this._data, statSync(this.path).mtimeMs);
+    }
+    get data() {
+        return this._data;
+    }
+    static [create](init) {
+        return new Handle(init);
+    }
+}
+const handles = [];
+export function useAt(init) {
+    const handle = Handle[create](init);
+    mkdirSync(dirname(handle.path), { recursive: true });
+    handles.push(handle);
+    return handle;
+}
+const _dayMs = 24 * 3600_000;
+export const meta = useAt({
+    path: 'meta.json',
+    schema: z.looseObject({
+        fetched: z.int(),
+        session: Session.extend({ user: User }),
+        apps: App.array(),
+    }),
+    async update() {
+        const [session, apps] = await io.track('Fetching metadata', Promise.all([getCurrentSession(), fetchAPI('GET', 'apps')]));
+        return { fetched: Date.now(), session, apps };
+    },
+    isValid: meta => meta.fetched + _dayMs > Date.now(),
+});
+export const sync = useAt({
+    path: 'sync.json',
+    schema: SyncState,
+    async update(sync) {
+        if (!sync)
+            return await fetchAPI('GET', 'sync/init');
+        const diff = await fetchAPI('GET', 'sync', { since: sync.index });
+        const deleted = new Set(diff.deleted);
+        const objects = sync.objects.filter(o => !deleted.has(o.id));
+        const existing = Object.fromEntries(objects.map(o => [o.id, o]));
+        for (const obj of diff.created)
+            objects.push(obj);
+        for (const updated of diff.updated) {
+            const base = existing[updated.id];
+            if (!base)
+                throw new ReferenceError("Can not update object because it isn't cached");
+            if (base.$type !== updated.$type)
+                throw new ReferenceError(`Type mismatch whilst updating cache object: currently ${base.$type}, incoming ${updated.$type}`);
+            Object.assign(base, updated);
+        }
+        return { objects, index: diff.index };
+    },
+    async isValid({ index }) {
+        const md = await fetchAPI('GET', 'sync/metadata');
+        return md.index >= index;
+    },
+});
+const persistedAPICaches = [];
+function persistAPI(cache, path) {
+    path = resolve(dir, path);
+    let data;
+    try {
+        data = io.readJSON(path, CacheData);
+    }
+    catch {
+        // missing
+    }
+    cache.persist(data => io.writeJSON(path, data), data);
+    persistedAPICaches.push({ path, cache });
+}
+export function load() {
+    for (const handle of handles)
+        handle.load();
+    persistAPI(apiUserCache, 'users.json');
+}
+export async function update(force = false) {
+    for (const handle of handles) {
+        if (force || !(await handle.isValid()))
+            await handle.update();
+    }
+}
+export function clear() {
+    for (const handle of handles)
+        unlinkSync(handle.path);
+    for (const { path } of persistedAPICaches)
+        unlinkSync(path);
+}
+export async function* info() {
+    for (const handle of handles) {
+        const { path } = handle;
+        const exists = existsSync(path);
+        const { size } = exists ? statSync(path, { bigint: true }) : {};
+        yield { path, exists, size, valid: await handle.isValid() };
+    }
+    for (const { path, cache } of persistedAPICaches) {
+        const exists = existsSync(path);
+        const { size } = exists ? statSync(path, { bigint: true }) : {};
+        yield { path, exists, size, entries: cache.size, fromAPI: true };
+    }
+}

package/dist/cli/config.d.ts

@@ -1,5 +1,4 @@
 export declare const configDir: string;
-export declare const cacheDir: string;
 export declare function session(): {
     id: string;
     userId: string;
@@ -24,5 +23,3 @@ export declare function session(): {
 };
 export declare function loadConfig(safe: boolean): Promise<void>;
 export declare function saveConfig(): void;
-export declare const _dayMs: number;
-export declare function updateCache(force: boolean): Promise<void>;

package/dist/cli/config.js

@@ -1,24 +1,22 @@
-import * as io from 'ioium/node';
 import { loadPlugin } from '@axium/core/node/plugins';
+import * as io from 'ioium/node';
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path/posix';
 import { ClientConfig, config } from '../config.js';
-import { fetchAPI, setPrefix, setToken } from '../requests.js';
-import { getCurrentSession } from '../user.js';
+import { setPrefix, setToken } from '../requests.js';
+import * as cache from './cache.js';
 export const configDir = join(process.env.XDG_CONFIG_HOME || join(homedir(), '.config'), 'axium');
 mkdirSync(configDir, { recursive: true });
 const axcConfig = join(configDir, 'config.json');
 if (!existsSync(axcConfig))
     writeFileSync(axcConfig, '{}');
-export const cacheDir = join(process.env.XDG_CACHE_HOME || join(homedir(), '.cache'), 'axium');
-mkdirSync(cacheDir, { recursive: true });
 export function session() {
     if (!config.token)
         io.exit('Not logged in.', 4);
-    if (!config.cache)
+    if (!cache.meta.data)
         io.exit('No session data available.', 3);
-    return config.cache.session;
+    return cache.meta.data.session;
 }
 export async function loadConfig(safe) {
     try {
@@ -38,17 +36,3 @@ export function saveConfig() {
     io.writeJSON(axcConfig, config);
     io.debug('Saved config to ' + axcConfig);
 }
-export const _dayMs = 24 * 3600_000;
-export async function updateCache(force) {
-    if (!force && config.cache && config.cache.fetched + _dayMs > Date.now())
-        return;
-    const [session, apps] = await io.track('Fetching metadata', Promise.all([getCurrentSession(), fetchAPI('GET', 'apps')]));
-    config.cache = { fetched: Date.now(), session, apps };
-    try {
-        io.writeJSON(axcConfig, config);
-    }
-    catch (e) {
-        io.error(e);
-        return;
-    }
-}

package/dist/cli/index.js

@@ -1,77 +1,26 @@
 #! /usr/bin/env node
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
+import { formatBytes } from '@axium/core';
 import { outputDaemonStatus, pluginText } from '@axium/core/node';
 import { _findPlugin, plugins } from '@axium/core/plugins';
 import { CommanderError, program } from 'commander';
 import * as io from 'ioium/node';
-import { createServer } from 'node:http';
-import * as os from 'node:os';
-import { createInterface } from 'node:readline/promises';
+import { basename } from 'node:path';
 import { styleText } from 'node:util';
 import * as z from 'zod';
 import $pkg from '../../package.json' with { type: 'json' };
-import { config, resolveServerURL } from '../config.js';
-import { prefix, setPrefix, setToken, useUserAgent } from '../requests.js';
-import { getCurrentSession, logout } from '../user.js';
-import { loadConfig, saveConfig, updateCache } from './config.js';
+import { config } from '../config.js';
+import { prefix, useUserAgent } from '../requests.js';
+import { logout } from '../user.js';
+import { clientUA, login } from './auth.js';
+import * as cache from './cache.js';
+import { loadConfig, saveConfig, session } from './config.js';
 const safe = z.stringbool().default(false).parse(process.env.SAFE?.toLowerCase()) || process.argv.includes('--safe');
 const debug = z.stringbool().default(false).parse(process.env.DEBUG?.toLowerCase()) || process.argv.includes('--debug');
 if (debug)
     io._setDebugOutput(true);
-const clientUA = `Axium Client/${$pkg.version} (${os.type()}; ${process.arch})`;
 useUserAgent(clientUA);
 await loadConfig(safe);
+cache.load();
 process.on('SIGHUP', () => {
     io.info('Reloading configuration due to SIGHUP.');
     void loadConfig(safe);
@@ -84,7 +33,7 @@ program
     .configureHelp({ showGlobalOptions: true })
     .option('--debug', 'override debug mode')
     .option('--no-debug', 'override debug mode')
-    .option('--refresh-session', 'Force a refresh of session and user metadata from server', false)
+    .option('--refresh', 'Force an update of caches from server', false)
     .option('--cache-only', 'Run entirely from local cache, even if it is expired.', false)
     .option('--safe', 'do not execute code from plugins', false)
     .hook('preAction', async (axc, action) => {
@@ -92,101 +41,20 @@ program
     if (!config.token)
         return;
     if (!opt.cacheOnly && action.name() != 'login')
-        await updateCache(opt.refreshSession);
+        await cache.update(opt.refresh);
 });
 program.on('option:debug', () => io._setDebugOutput(true));
-program
-    .command('login')
-    .description('Log in to your account on an Axium server')
-    .argument('[server]', 'Axium server URL')
-    .action(async (url) => {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        const rl = __addDisposableResource(env_1, createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        }), false);
-        rl.on('SIGINT', () => io.exit('Aborted.', 7));
-        if (prefix[0] != '/')
-            url ||= prefix;
-        url ||= await rl.question('Axium server URL: ');
-        url = resolveServerURL(url);
-        setPrefix(url);
-        const sessionReady = Promise.withResolvers();
-        // eslint-disable-next-line @typescript-eslint/no-misused-promises
-        const server = createServer(async (req, res) => {
-            res.setHeader('access-control-allow-origin', '*');
-            res.setHeader('access-control-allow-methods', '*');
-            res.setHeader('access-control-allow-headers', '*');
-            if (req.method == 'HEAD' || req.method == 'OPTIONS') {
-                res.writeHead(200).end();
-                return;
-            }
-            if (!req.headers['content-type']?.endsWith('/json')) {
-                res.writeHead(415).end('Unexpected content type');
-                return;
-            }
-            if (req.method !== 'POST') {
-                res.writeHead(405).end('Unexpected request method');
-                return;
-            }
-            const { promise: bodyReady, resolve, reject } = Promise.withResolvers();
-            let body = '';
-            req.on('data', chunk => (body += chunk.toString()));
-            req.on('end', resolve);
-            req.on('error', reject);
-            try {
-                await bodyReady;
-                sessionReady.resolve(JSON.parse(body));
-                res.writeHead(200).end();
-            }
-            catch (e) {
-                res.statusCode = 500;
-                res.end('Internal server error: ' + e.message);
-                sessionReady.reject(e.message);
-            }
-        });
-        const serverReady = Promise.withResolvers();
-        server.listen(() => {
-            const { port } = server.address();
-            serverReady.resolve(port);
-        });
-        server.on('error', e => io.exit('Failed to start local callback server: ' + e.message, 5));
-        const port = await serverReady.promise;
-        const authURL = new URL(`/login/client?port=${port}&client=${encodeURIComponent(clientUA)}`, url).href;
-        console.log('Authenticate by visiting this URL in your browser: ' + styleText('underline', authURL));
-        const { token } = await sessionReady.promise.catch(e => io.exit('Failed to obtain session: ' + e, 6));
-        setToken(token);
-        server.close();
-        const session = await io.track('Verifying session', getCurrentSession().catch(e => io.exit(e.message, 6)));
-        io.debug('Session UUID: ' + session.id);
-        console.log(`Welcome ${session.user.name}! Your session is valid until ${session.expires.toLocaleDateString()}.`);
-        config.token = token;
-        config.server = url;
-        saveConfig();
-        await updateCache(true);
-    }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
-    }
-    finally {
-        __disposeResources(env_1);
-    }
-});
+program.command('login').description('Log in to your account on an Axium server').argument('[server]', 'Axium server URL').action(login);
 program.command('logout').action(async () => {
-    if (!config.token)
-        io.exit('Not logged in.', 4);
-    if (!config.cache)
-        io.exit('No session data available.', 3);
-    await logout(config.cache.session.userId, config.cache.session.id);
+    const { id, userId } = session();
+    await logout(userId, id);
 });
 program.command('status').action(() => {
     if (!config.token)
         return console.log('Not logged in.');
     if (!config.cache)
         return console.log('No session data available.');
-    const { session } = config.cache;
+    const { session } = cache.meta.data;
     console.log('Logged in to', new URL(prefix).host);
     console.log(styleText('whiteBright', 'Session:'), 'valid until', session.expires.toLocaleDateString(), styleText('dim', `(${session.id})`));
     const { user } = session;
@@ -205,8 +73,8 @@ program
     for (const plugin of plugins.values())
         await plugin._client?.run();
 });
-const axiumPlugin = program.command('plugin').alias('plugins').description('Manage plugins');
-axiumPlugin
+const axcPlugin = program.command('plugin').alias('plugins').description('Manage plugins');
+axcPlugin
     .command('list')
     .alias('ls')
     .description('List loaded plugins')
@@ -226,7 +94,7 @@ axiumPlugin
         console.log(plugin.name, opt.versions ? plugin.version : '');
     }
 });
-axiumPlugin
+axcPlugin
     .command('info')
     .description('Get information about a plugin')
     .argument('<plugin>', 'the plugin to get information about')
@@ -235,7 +103,7 @@ axiumPlugin
     for (const line of pluginText(plugin))
         console.log(line);
 });
-axiumPlugin
+axcPlugin
     .command('remove')
     .alias('rm')
     .description('Remove a plugin')
@@ -246,6 +114,32 @@ axiumPlugin
     plugins.delete(plugin.name);
     saveConfig();
 });
+const axcCache = program.command('cache').description('Manage the local cache');
+axcCache
+    .command('info')
+    .description('Show information about what is being cached')
+    .action(async () => {
+    let size = 0n, files = 0;
+    for await (const info of cache.info()) {
+        process.stdout.write(basename(info.path) + ':');
+        if (!info.exists) {
+            console.log(styleText('dim', ' (missing)'));
+            continue;
+        }
+        files++;
+        size += info.size;
+        console.log('', styleText('blue', formatBytes(info.size)) + ',', info.fromAPI ? info.entries + ' entries' : info.valid ? styleText('green', 'valid') : styleText('yellow', 'invalid'));
+    }
+    console.log('Caching', styleText('blue', formatBytes(size)), 'across', styleText('blueBright', files.toString()), 'files');
+});
+axcCache.command('clear').description('Clear the local cache').action(cache.clear);
+axcCache
+    .command('refresh')
+    .description('Update local caches')
+    .option('-f, --force', 'Force a refresh even if the cache is still valid')
+    .action(async (opt) => {
+    await cache.update(opt.force);
+});
 try {
     await program.parseAsync();
 }

package/dist/cli/sync.d.ts

@@ -0,0 +1,17 @@
+import type { ZodObject, ZodUUID } from 'zod';
+export interface $Objects {
+}
+export type ObjectType = keyof $Objects extends never ? string : keyof $Objects;
+type ObjectValues = keyof $Objects extends never ? Record<string, {
+    id: string;
+}[]> : {
+    [K in keyof $Objects]: ($Objects[K] & {
+        id: string;
+    })[];
+};
+export declare function useSchema<Type extends ObjectType, S extends ZodObject<{
+    id: ZodUUID;
+}>>(type: Type, schema: S): void;
+export declare function get<Type extends ObjectType>(type: Type): ObjectValues[Type];
+export declare function save<Type extends ObjectType>(type: Type, objects: ObjectValues[Type]): void;
+export {};

package/dist/cli/sync.js

@@ -0,0 +1,24 @@
+import { sync as syncCache } from './cache.js';
+let _byType;
+function byType() {
+    _byType ||= Object.groupBy(syncCache.data.objects, o => o.$type);
+    return _byType;
+}
+const schemas = new Map();
+export function useSchema(type, schema) {
+    schemas.set(type, schema);
+}
+export function get(type) {
+    const value = byType()[type] || [];
+    const schema = schemas.get(type);
+    if (!schema)
+        return value;
+    return value.map(obj => schema.parse(obj));
+}
+export function save(type, objects) {
+    _byType ||= {};
+    _byType[type] = objects;
+    syncCache.data.objects = syncCache.data.objects.filter(o => o.$type !== type);
+    for (const object of objects)
+        syncCache.data.objects.push(Object.assign(object, { $type: type }));
+}

package/dist/config.d.ts

@@ -2,37 +2,6 @@ import * as z from 'zod';
 export declare const ClientConfig: z.ZodObject<{
     token: z.ZodOptional<z.ZodNullable<z.ZodBase64URL>>;
     server: z.ZodOptional<z.ZodNullable<z.ZodURL>>;
-    cache: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        fetched: z.ZodInt;
-        session: z.ZodObject<{
-            id: z.ZodUUID;
-            userId: z.ZodUUID;
-            name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            expires: z.ZodCoercedDate<unknown>;
-            created: z.ZodCoercedDate<unknown>;
-            elevated: z.ZodBoolean;
-            user: z.ZodObject<{
-                id: z.ZodUUID;
-                name: z.ZodString;
-                email: z.ZodEmail;
-                emailVerified: z.ZodOptional<z.ZodNullable<z.ZodCoercedDate<unknown>>>;
-                preferences: z.ZodLazy<z.ZodObject<{
-                    debug: z.ZodDefault<z.ZodBoolean>;
-                }, z.core.$strip>>;
-                roles: z.ZodArray<z.ZodString>;
-                tags: z.ZodArray<z.ZodString>;
-                registeredAt: z.ZodCoercedDate<unknown>;
-                isAdmin: z.ZodBoolean;
-                isSuspended: z.ZodBoolean;
-            }, z.core.$strip>;
-        }, z.core.$strip>;
-        apps: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            name: z.ZodOptional<z.ZodString>;
-            image: z.ZodOptional<z.ZodString>;
-            icon: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$loose>>>;
     plugins: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$loose>;
 export interface ClientConfig extends z.infer<typeof ClientConfig> {

package/dist/config.js

@@ -1,17 +1,8 @@
 import { debug, warn } from 'ioium';
-import { App, Session, User } from '@axium/core';
 import * as z from 'zod';
 export const ClientConfig = z.looseObject({
     token: z.base64url().nullish(),
     server: z.url().nullish(),
-    // Cache to reduce server load:
-    cache: z
-        .looseObject({
-        fetched: z.int(),
-        session: Session.extend({ user: User }),
-        apps: App.array(),
-    })
-        .nullish(),
     plugins: z.string().array().default([]),
 });
 export const config = {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export * from './access.js';
-export * from './apps.js';
-export * as cache from './cache.js';
+export * as preferences from './preferences.js';
+export * from './cache.js';
 export * from './config.js';
 export * from './locales.js';
 export * from './requests.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 export * from './access.js';
-export * from './apps.js';
-export * as cache from './cache.js';
+export * as preferences from './preferences.js';
+export * from './cache.js';
 export * from './config.js';
 export * from './locales.js';
 export * from './requests.js';

package/dist/preferences.d.ts

@@ -0,0 +1,5 @@
+import type { AppPreferences } from '@axium/core';
+export declare function get<A extends string>(userId: string, appId: A): Promise<AppPreferences<A>>;
+export declare function set<A extends string>(userId: string, appId: A, preferences: AppPreferences<A>): Promise<AppPreferences<A>>;
+export declare function clear<A extends string>(userId: string, appId: A): Promise<AppPreferences<A>>;
+export declare function appPref<A extends string, K extends keyof AppPreferences<A>>(userId: string, appId: A, key: K): Promise<AppPreferences<A>[K]>;

package/dist/{apps.js → preferences.js}

@@ -1,33 +1,33 @@
 import { appPreferences } from '@axium/core';
-import * as cache from './cache.js';
+import Cache from './cache.js';
 import { fetchAPI } from './requests.js';
-export async function getAppPreferences(userId, appId) {
+const cache = new Cache(async (userId, appId) => {
     const schema = appPreferences.get(appId);
     if (!schema)
         throw new Error(`Missing schema for "${appId}"`);
-    const pref = await cache.use('app_preferences', userId + ':' + appId, async () => {
-        const result = await fetchAPI('GET', 'users/:id/preferences/:appId', {}, userId, appId);
-        return schema.parse(result);
-    });
-    return pref;
+    const result = await fetchAPI('GET', 'users/:id/preferences/:appId', {}, userId, appId);
+    return schema.parse(result);
+});
+export async function get(userId, appId) {
+    return (await cache.get(userId, appId));
 }
-export async function setAppPreferences(userId, appId, preferences) {
+export async function set(userId, appId, preferences) {
     const schema = appPreferences.get(appId);
     if (!schema)
         throw new Error(`Missing schema for "${appId}"`);
     const result = await fetchAPI('POST', 'users/:id/preferences/:appId', preferences, userId, appId);
-    cache.update('app_preferences', userId + ':' + appId, result);
+    cache.set(userId, appId, result);
     return schema.parse(result);
 }
-export async function clearAppPreferences(userId, appId) {
+export async function clear(userId, appId) {
     const schema = appPreferences.get(appId);
     if (!schema)
         throw new Error(`Missing schema for "${appId}"`);
     const result = await fetchAPI('DELETE', 'users/:id/preferences/:appId', {}, userId, appId);
-    cache.invalidate('app_preferences', userId + ':' + appId);
+    cache.invalidate(userId, appId);
     return schema.parse(result);
 }
 export async function appPref(userId, appId, key) {
-    const pref = await getAppPreferences(userId, appId);
+    const pref = await get(userId, appId);
     return pref[key];
 }

package/dist/requests.d.ts

@@ -1,4 +1,4 @@
-import type { APIParameters, APIValues, Endpoint, RequestBody } from '@axium/core/api';
+import type { APIParameters, Endpoint, RequestBody, Result } from '@axium/core/api';
 import { $API } from '@axium/core/api';
 import type { RequestMethod } from '@axium/core/requests';
 export declare let token: string | null;
@@ -9,4 +9,4 @@ export declare function setPrefix(value: string): void;
  * Only for use on non-browser clients, e.g. Node.js
  */
 export declare function useUserAgent(ua: string | null): void;
-export declare function fetchAPI<const E extends Endpoint, const M extends keyof $API[E] & RequestMethod>(method: M, endpoint: E, data?: RequestBody<M, E>, ...params: APIParameters<E>): Promise<M extends keyof APIValues[E] ? (APIValues[E][M] extends readonly [unknown, infer R] ? R : APIValues[E][M]) : unknown>;
+export declare function fetchAPI<const E extends Endpoint, const M extends keyof $API[E] & RequestMethod>(method: M, endpoint: E, data?: RequestBody<M, E>, ...params: APIParameters<E>): Promise<Result<M, E>>;

package/dist/user.d.ts

@@ -1,5 +1,6 @@
 import type { NewSessionResponse, Passkey, PasskeyChangeable, Session, User, UserPublic, Verification } from '@axium/core';
 import * as z from 'zod';
+import Cache from './cache.js';
 export declare function login(userId: string): Promise<NewSessionResponse>;
 /**
  * Create an elevated session for the user to perform sensitive actions.
@@ -14,7 +15,9 @@ export declare function logout(userId: string, ...sessionId: string[]): Promise<
 export declare function logoutAll(userId: string): Promise<Session[]>;
 export declare function logoutCurrentSession(): Promise<Session>;
 export declare function register(_data: Record<string, unknown>): Promise<void>;
-export declare function userInfo(userId: string): Promise<UserPublic & Partial<User>>;
+declare const userCache: Cache<[string], UserPublic>;
+export { userCache as apiUserCache };
+export declare function userInfo(userId: string): Promise<UserPublic>;
 export declare function updateUser(userId: string, data: Record<string, FormDataEntryValue>): Promise<User>;
 export declare function fullUserInfo(userId: string): Promise<User & {
     sessions: Session[];

package/dist/user.js

@@ -1,7 +1,7 @@
 import { startAuthentication, startRegistration } from '@simplewebauthn/browser';
 import * as z from 'zod';
 import { fetchAPI } from './requests.js';
-import * as cache from './cache.js';
+import Cache from './cache.js';
 export async function login(userId) {
     const options = await fetchAPI('PUT', 'users/:id/auth', { type: 'login' }, userId);
     const response = await startAuthentication({ optionsJSON: options });
@@ -62,14 +62,16 @@ function _checkId(userId) {
         throw e instanceof z.core.$ZodError ? z.prettifyError(e) : e;
     }
 }
+const userCache = new Cache((userId) => fetchAPI('GET', 'users/:id', {}, userId), { ttl: 86400_000 });
+export { userCache as apiUserCache };
 export async function userInfo(userId) {
     _checkId(userId);
-    return await cache.use('user', userId, () => fetchAPI('GET', 'users/:id', {}, userId));
+    return await userCache.get(userId);
 }
 export async function updateUser(userId, data) {
     _checkId(userId);
     const result = await fetchAPI('PATCH', 'users/:id', data, userId);
-    cache.update('user', userId, result);
+    userCache.set(userId, result);
     return result;
 }
 export async function fullUserInfo(userId) {
@@ -86,7 +88,7 @@ export async function deleteUser(userId, deletingId = userId) {
     const response = await startAuthentication({ optionsJSON: options });
     await fetchAPI('POST', 'users/:id/auth', response, deletingId);
     const result = await fetchAPI('DELETE', 'users/:id', response, userId);
-    cache.invalidate('user', userId);
+    userCache.invalidate(userId);
     return result;
 }
 export async function emailVerificationEnabled(userId) {

package/lib/AppPreferences.svelte

@@ -1,5 +1,6 @@
 <script lang="ts">
-	import { getAppPreferences, setAppPreferences, text } from '@axium/client';
+	import { text } from '@axium/client';
+	import { preferences as uap } from '@axium/client';
 	import { structurallyEqual } from 'utilium';
 	import type { ZodObject } from 'zod';
 	import ZodInput from './ZodInput.svelte';
@@ -12,7 +13,7 @@
 		_parentDialog,
 	}: { userId: string; appId: string; schema: ZodObject; _parentDialog?: HTMLDialogElement } = $props();
 
-	let initialValue = $state(await getAppPreferences(userId, appId));
+	let initialValue = $state(await uap.get(userId, appId));
 	let currentValue = $state({ ...initialValue });
 
 	function cancel() {
@@ -21,7 +22,7 @@
 	}
 
 	async function save() {
-		initialValue = await setAppPreferences(userId, appId, currentValue);
+		initialValue = await uap.set(userId, appId, currentValue);
 		if (!_parentDialog) return;
 		_parentDialog.close();
 		toast('success', text('AppPreferences.toast_saved'));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/client",
-	"version": "0.27.0",
+	"version": "0.28.0",
 	"author": "James Prevett <jp@jamespre.dev>",
 	"funding": {
 		"type": "individual",
@@ -45,7 +45,7 @@
 		"build": "tsc"
 	},
 	"peerDependencies": {
-		"@axium/core": ">=0.30.0",
+		"@axium/core": ">=0.32.0",
 		"ioium": "^1.0.2",
 		"semver": "^7.7.4",
 		"svelte": "^5.36.0",

package/dist/apps.d.ts

@@ -1,5 +0,0 @@
-import type { AppPreferences } from '@axium/core';
-export declare function getAppPreferences<A extends string>(userId: string, appId: A): Promise<AppPreferences<A>>;
-export declare function setAppPreferences<A extends string>(userId: string, appId: A, preferences: AppPreferences<A>): Promise<AppPreferences<A>>;
-export declare function clearAppPreferences<A extends string>(userId: string, appId: A): Promise<AppPreferences<A>>;
-export declare function appPref<A extends string, K extends keyof AppPreferences<A>>(userId: string, appId: A, key: K): Promise<AppPreferences<A>[K]>;