@undefineds.co/xpod 0.3.58 → 0.3.62

package/node_modules/@undefineds.co/shared-ui/dist/workspace.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext, useContext, useState } from 'react';
+import { cn } from './utils.js';
+const WorkspaceNavigationContext = createContext(null);
+export function TwoPaneWorkspace({ header, list, main, className, layoutMode = 'auto', }) {
+    const [mobilePane, setMobilePane] = useState('list');
+    const showMain = () => setMobilePane('main');
+    const showList = () => setMobilePane('list');
+    const navigation = {
+        mode: layoutMode === 'narrow' ? 'stack' : 'split',
+        activePane: mobilePane,
+        mobilePane,
+        showMain,
+        showList,
+        openMain: showMain,
+        backToList: showList,
+    };
+    return (_jsx(WorkspaceNavigationContext.Provider, { value: navigation, children: _jsxs("div", { className: cn('flex min-h-0 flex-1 flex-col bg-background', className), "data-applet-layout": "two-pane", children: [_jsx("header", { className: "h-16 shrink-0 border-b border-border bg-layout-content", "data-testid": "applet-header-pane", children: header }), _jsxs("div", { className: cn('grid min-h-0 flex-1', layoutMode === 'narrow'
+                        ? 'grid-cols-1'
+                        : 'grid-cols-[minmax(12rem,15rem)_minmax(0,1fr)]', layoutMode === 'auto' && 'max-md:grid-cols-1'), "data-layout-mode": layoutMode, "data-mobile-pane": mobilePane, children: [_jsx("aside", { className: cn('min-h-0 overflow-y-auto border-r bg-card @container', layoutMode !== 'wide' && 'max-md:border-r-0', layoutMode === 'narrow' && mobilePane === 'main' && 'hidden', layoutMode === 'auto' && mobilePane === 'main' && 'max-md:hidden'), "data-applet-pane": "list", "data-testid": "applet-list-pane", children: list }), _jsxs("div", { className: cn('min-h-0 overflow-y-auto bg-background @container', layoutMode === 'narrow' && mobilePane === 'list' && 'hidden', layoutMode === 'auto' && mobilePane === 'list' && 'max-md:hidden'), "data-applet-pane": "main", "data-testid": "applet-main-pane", children: [_jsx("button", { type: "button", className: cn('items-center px-4 py-3 text-sm text-muted-foreground hover:text-foreground', layoutMode === 'narrow' ? 'inline-flex' : 'hidden', layoutMode === 'auto' && 'max-md:inline-flex'), onClick: navigation.showList, children: "\u2190 \u8FD4\u56DE\u5217\u8868" }), main] })] })] }) }));
+}
+export function useAppletLayout() {
+    const navigation = useContext(WorkspaceNavigationContext);
+    if (!navigation) {
+        throw new Error('useAppletLayout must be used inside TwoPaneWorkspace');
+    }
+    return navigation;
+}
+export function AppletList(props) {
+    return _jsx("nav", { className: cn('space-y-1 p-3', props.className), ...props });
+}
+export function AppletListItem({ selected, className, onClick, ...props }) {
+    const navigation = useContext(WorkspaceNavigationContext);
+    return (_jsx("button", { type: "button", "aria-current": selected ? 'page' : undefined, className: cn('flex w-full items-center rounded-md px-3 py-2 text-left text-sm hover:bg-accent aria-[current=page]:bg-accent aria-[current=page]:font-medium', className), onClick: (event) => {
+            onClick?.(event);
+            navigation?.showMain();
+        }, ...props }));
+}

package/node_modules/@undefineds.co/shared-ui/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@undefineds.co/shared-ui",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./theme.css": "./dist/theme.css"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json && node ../../scripts/fix-dist-js-imports.mjs dist && cp src/theme.css dist/theme.css",
+    "test": "vitest run test --config ../../vitest.packages.config.mts",
+    "lint": "echo \"lint not configured\""
+  },
+  "dependencies": {
+    "@radix-ui/react-slot": "^1.2.4",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "tailwind-merge": "^3.5.0"
+  },
+  "peerDependencies": {
+    "react": "^19.2.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.14",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8"
+  }
+}

package/node_modules/@undefineds.co/solid-sdk/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './session';
+export * from './pod-runtime';
+export * from './react';

package/node_modules/@undefineds.co/solid-sdk/dist/index.js

@@ -0,0 +1,3 @@
+export * from './session.js';
+export * from './pod-runtime.js';
+export * from './react.js';

package/node_modules/@undefineds.co/solid-sdk/dist/pod-runtime.d.ts

@@ -0,0 +1,45 @@
+export type PodRuntimeFetch = typeof fetch;
+export type PodRuntimeAdapter<Database> = {
+    discoverPod(args: {
+        webId: string;
+        fetch: PodRuntimeFetch;
+        signal: AbortSignal;
+        isCurrent(): boolean;
+    }): Promise<string> | string;
+    openDatabase(args: {
+        webId: string;
+        podUrl: string;
+        fetch: PodRuntimeFetch;
+        signal: AbortSignal;
+        isCurrent(): boolean;
+    }): Promise<Database> | Database;
+    hydrateCollections(args: {
+        webId: string;
+        podUrl: string;
+        database: Database;
+        signal: AbortSignal;
+        isCurrent(): boolean;
+    }): Promise<void> | void;
+};
+export type OpenPodRuntime<Database> = {
+    readonly webId: string;
+    readonly podUrl: string;
+    readonly database: Database;
+    readonly collections: 'ready';
+};
+export type CreatePodRuntimeOptions<Database> = {
+    adapter: PodRuntimeAdapter<Database>;
+};
+export type PodRuntimeClearIdentity = string | {
+    webId: string;
+    podUrl?: string;
+};
+export type PodRuntime<Database> = {
+    open(args: {
+        webId: string;
+        fetch: PodRuntimeFetch;
+    }): Promise<OpenPodRuntime<Database>>;
+    clear(identity?: PodRuntimeClearIdentity): void;
+    dispose(): void;
+};
+export declare function createPodRuntime<Database>(options: CreatePodRuntimeOptions<Database>): PodRuntime<Database>;

package/node_modules/@undefineds.co/solid-sdk/dist/pod-runtime.js

@@ -0,0 +1,147 @@
+const KEY_SEPARATOR = '\u0000';
+function normalizeIdentityPart(value) {
+    const trimmed = value.trim();
+    try {
+        return new URL(trimmed).href;
+    }
+    catch {
+        return trimmed;
+    }
+}
+function compositeKey(webId, podUrl) {
+    return `${normalizeIdentityPart(webId)}${KEY_SEPARATOR}${normalizeIdentityPart(podUrl)}`;
+}
+function nextGeneration(generations, webIdKey) {
+    const generation = (generations.get(webIdKey) ?? 0) + 1;
+    generations.set(webIdKey, generation);
+    return generation;
+}
+function createAbortedOpenError() {
+    const error = new Error('Pod open aborted because the runtime identity changed');
+    error.name = 'AbortError';
+    return error;
+}
+export function createPodRuntime(options) {
+    const { adapter } = options;
+    const readyByWebId = new Map();
+    const readyByComposite = new Map();
+    const pendingByWebId = new Map();
+    const generations = new Map();
+    const clear = (identity) => {
+        if (!identity) {
+            readyByWebId.clear();
+            readyByComposite.clear();
+            for (const pending of pendingByWebId.values()) {
+                pending.controller.abort();
+            }
+            pendingByWebId.clear();
+            for (const webIdKey of generations.keys()) {
+                nextGeneration(generations, webIdKey);
+            }
+            return;
+        }
+        if (typeof identity === 'string') {
+            clearWebId(identity);
+            return;
+        }
+        clearWebId(identity.webId, identity.podUrl);
+    };
+    const clearWebId = (webId, podUrl) => {
+        const webIdKey = normalizeIdentityPart(webId);
+        nextGeneration(generations, webIdKey);
+        pendingByWebId.get(webIdKey)?.controller.abort();
+        pendingByWebId.delete(webIdKey);
+        if (podUrl) {
+            const key = compositeKey(webId, podUrl);
+            readyByComposite.delete(key);
+            if (normalizeIdentityPart(readyByWebId.get(webIdKey)?.podUrl ?? '') === normalizeIdentityPart(podUrl)) {
+                readyByWebId.delete(webIdKey);
+            }
+            return;
+        }
+        const existing = readyByWebId.get(webIdKey);
+        if (existing) {
+            readyByComposite.delete(compositeKey(existing.webId, existing.podUrl));
+        }
+        readyByWebId.delete(webIdKey);
+    };
+    return {
+        open(args) {
+            const webIdKey = normalizeIdentityPart(args.webId);
+            const cached = readyByWebId.get(webIdKey);
+            if (cached) {
+                return Promise.resolve(cached);
+            }
+            const pending = pendingByWebId.get(webIdKey);
+            if (pending) {
+                return pending.promise;
+            }
+            const generation = generations.get(webIdKey) ?? 0;
+            generations.set(webIdKey, generation);
+            const controller = new AbortController();
+            const isCurrent = () => !controller.signal.aborted && (generations.get(webIdKey) ?? 0) === generation;
+            const assertCurrent = () => {
+                if (!isCurrent()) {
+                    throw createAbortedOpenError();
+                }
+            };
+            const promise = (async () => {
+                const podUrl = await adapter.discoverPod({
+                    webId: args.webId,
+                    fetch: args.fetch,
+                    signal: controller.signal,
+                    isCurrent,
+                });
+                assertCurrent();
+                const key = compositeKey(args.webId, podUrl);
+                const existing = readyByComposite.get(key);
+                if (existing) {
+                    if (isCurrent()) {
+                        readyByWebId.set(webIdKey, existing);
+                    }
+                    return existing;
+                }
+                const database = await adapter.openDatabase({
+                    webId: args.webId,
+                    podUrl,
+                    fetch: args.fetch,
+                    signal: controller.signal,
+                    isCurrent,
+                });
+                assertCurrent();
+                await adapter.hydrateCollections({
+                    webId: args.webId,
+                    podUrl,
+                    database,
+                    signal: controller.signal,
+                    isCurrent,
+                });
+                assertCurrent();
+                const opened = {
+                    webId: args.webId,
+                    podUrl,
+                    database,
+                    collections: 'ready',
+                };
+                if (isCurrent()) {
+                    readyByWebId.set(webIdKey, opened);
+                    readyByComposite.set(key, opened);
+                }
+                return opened;
+            })();
+            pendingByWebId.set(webIdKey, { generation, promise, controller });
+            const removePending = () => {
+                const pendingOpen = pendingByWebId.get(webIdKey);
+                if (pendingOpen?.generation === generation && pendingOpen.promise === promise) {
+                    pendingByWebId.delete(webIdKey);
+                }
+            };
+            promise.then(removePending, removePending);
+            return promise;
+        },
+        clear,
+        dispose() {
+            clear();
+        },
+    };
+}

package/node_modules/@undefineds.co/solid-sdk/dist/react.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from 'react';
+import type { OpenPodRuntime, PodRuntime } from './pod-runtime';
+import type { SolidSessionRuntime, SolidSessionSnapshot } from './session';
+export interface SolidRuntimeValue<Database = unknown> {
+    readonly session: SolidSessionRuntime;
+    readonly pod: PodRuntime<Database>;
+    readonly currentPod?: OpenPodRuntime<Database>;
+}
+export interface SolidRuntimeProviderProps<Database = unknown> {
+    value: SolidRuntimeValue<Database>;
+    children?: ReactNode;
+}
+export declare function SolidRuntimeProvider<Database = unknown>({ value, children, }: SolidRuntimeProviderProps<Database>): import("react").FunctionComponentElement<import("react").ProviderProps<SolidRuntimeValue<unknown> | null>>;
+export declare function useSolidRuntime<Database = unknown>(): SolidRuntimeValue<Database>;
+export declare function useSolidSessionSnapshot(): SolidSessionSnapshot;

package/node_modules/@undefineds.co/solid-sdk/dist/react.js

@@ -0,0 +1,15 @@
+import { createContext, createElement, useContext } from 'react';
+const SolidRuntimeContext = createContext(null);
+export function SolidRuntimeProvider({ value, children, }) {
+    return createElement(SolidRuntimeContext.Provider, { value: value }, children);
+}
+export function useSolidRuntime() {
+    const value = useContext(SolidRuntimeContext);
+    if (!value) {
+        throw new Error('useSolidRuntime must be used within SolidRuntimeProvider');
+    }
+    return value;
+}
+export function useSolidSessionSnapshot() {
+    return useSolidRuntime().session.getSnapshot();
+}

package/node_modules/@undefineds.co/solid-sdk/dist/session.d.ts

@@ -0,0 +1,42 @@
+import { type IHandleIncomingRedirectOptions, type ILoginInputOptions, type ILogoutOptions, type ISessionEventListener, type ISessionInfo } from '@inrupt/solid-client-authn-browser';
+export type SolidSessionSnapshot = {
+    status: 'initializing';
+    webId?: undefined;
+    error?: undefined;
+} | {
+    status: 'anonymous';
+    webId?: undefined;
+    error?: undefined;
+} | {
+    status: 'authenticated';
+    webId: string;
+    error?: undefined;
+} | {
+    status: 'error';
+    webId?: string;
+    error: Error;
+};
+export type SolidSessionListener = (snapshot: SolidSessionSnapshot) => void;
+export type SolidSessionAdapter = {
+    readonly info: Pick<ISessionInfo, 'isLoggedIn' | 'webId'>;
+    events: ISessionEventListener;
+    fetch: typeof fetch;
+    handleIncomingRedirect(options?: string | IHandleIncomingRedirectOptions): Promise<Pick<ISessionInfo, 'isLoggedIn' | 'webId'> | undefined>;
+    login(options: ILoginInputOptions): Promise<void>;
+    logout(options?: ILogoutOptions): Promise<void>;
+};
+export type SolidSessionRuntime = {
+    readonly fetch: typeof fetch;
+    getSnapshot(): SolidSessionSnapshot;
+    initialize(options?: {
+        restorePreviousSession?: boolean;
+    }): Promise<SolidSessionSnapshot>;
+    login(options: ILoginInputOptions): Promise<void>;
+    logout(options?: ILogoutOptions): Promise<void>;
+    subscribe(listener: SolidSessionListener): () => void;
+    dispose(): void;
+};
+export type CreateSolidSessionRuntimeOptions = {
+    session?: SolidSessionAdapter;
+};
+export declare function createSolidSessionRuntime(options?: CreateSolidSessionRuntimeOptions): SolidSessionRuntime;

package/node_modules/@undefineds.co/solid-sdk/dist/session.js

@@ -0,0 +1,127 @@
+import { EVENTS, Session, } from '@inrupt/solid-client-authn-browser';
+function snapshotFromSessionInfo(info) {
+    if (info?.isLoggedIn && info.webId) {
+        return {
+            status: 'authenticated',
+            webId: info.webId,
+        };
+    }
+    return { status: 'anonymous' };
+}
+function normalizeError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    return new Error(String(error));
+}
+function snapshotFromSessionError(error, info) {
+    return {
+        status: 'error',
+        webId: info.webId,
+        error: normalizeError(error),
+    };
+}
+function areSnapshotsEqual(left, right) {
+    if (!left || left.status !== right.status || left.webId !== right.webId) {
+        return false;
+    }
+    if (left.status === 'error' && right.status === 'error') {
+        return left.error === right.error;
+    }
+    return true;
+}
+export function createSolidSessionRuntime(options = {}) {
+    const session = options.session ?? new Session();
+    const listeners = new Set();
+    let snapshot = { status: 'initializing' };
+    let lastNotifiedSnapshot;
+    let initialization;
+    let isInitializing = false;
+    let initializationErrorSnapshot;
+    let disposed = false;
+    const publish = (nextSnapshot) => {
+        snapshot = nextSnapshot;
+        if (disposed) {
+            return snapshot;
+        }
+        if (areSnapshotsEqual(lastNotifiedSnapshot, snapshot)) {
+            return snapshot;
+        }
+        lastNotifiedSnapshot = snapshot;
+        for (const listener of listeners) {
+            listener(snapshot);
+        }
+        return snapshot;
+    };
+    const publishSessionInfo = () => publish(snapshotFromSessionInfo(session.info));
+    const publishAnonymous = () => publish({ status: 'anonymous' });
+    const publishSessionExpired = () => publish(snapshotFromSessionError('Solid session expired', session.info));
+    const publishSessionError = (code, description) => {
+        const errorSnapshot = snapshotFromSessionError(description ?? code ?? 'Solid session error', session.info);
+        if (isInitializing) {
+            initializationErrorSnapshot = errorSnapshot;
+        }
+        publish(errorSnapshot);
+    };
+    session.events.on(EVENTS.LOGIN, publishSessionInfo);
+    session.events.on(EVENTS.SESSION_RESTORED, publishSessionInfo);
+    session.events.on(EVENTS.LOGOUT, publishAnonymous);
+    session.events.on(EVENTS.SESSION_EXPIRED, publishSessionExpired);
+    const errorEvents = session.events;
+    errorEvents.on(EVENTS.ERROR, publishSessionError);
+    return {
+        fetch: session.fetch,
+        getSnapshot() {
+            return snapshot;
+        },
+        initialize(options = {}) {
+            if (initialization) {
+                return initialization;
+            }
+            isInitializing = true;
+            initializationErrorSnapshot = undefined;
+            publish({ status: 'initializing' });
+            const nextInitialization = session.handleIncomingRedirect({
+                restorePreviousSession: options.restorePreviousSession ?? true,
+            }).then((info) => {
+                const nextSnapshot = snapshotFromSessionInfo(info ?? session.info);
+                if (nextSnapshot.status === 'anonymous' && initializationErrorSnapshot?.status === 'error') {
+                    return initializationErrorSnapshot;
+                }
+                return publish(nextSnapshot);
+            })
+                .catch((error) => publish(snapshotFromSessionError(error, session.info)))
+                .finally(() => {
+                if (initialization === nextInitialization) {
+                    initialization = undefined;
+                    isInitializing = false;
+                    initializationErrorSnapshot = undefined;
+                }
+            });
+            initialization = nextInitialization;
+            return initialization;
+        },
+        login(options) {
+            return session.login(options);
+        },
+        async logout(options) {
+            await session.logout(options);
+            publish({ status: 'anonymous' });
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        dispose() {
+            disposed = true;
+            listeners.clear();
+            session.events.off(EVENTS.LOGIN, publishSessionInfo);
+            session.events.off(EVENTS.SESSION_RESTORED, publishSessionInfo);
+            session.events.off(EVENTS.LOGOUT, publishAnonymous);
+            session.events.off(EVENTS.SESSION_EXPIRED, publishSessionExpired);
+            errorEvents.off(EVENTS.ERROR, publishSessionError);
+        },
+    };
+}

package/node_modules/@undefineds.co/solid-sdk/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@undefineds.co/solid-sdk",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./session": {
+      "types": "./dist/session.d.ts",
+      "import": "./dist/session.js"
+    },
+    "./pod-runtime": {
+      "types": "./dist/pod-runtime.d.ts",
+      "import": "./dist/pod-runtime.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json && node ../../scripts/fix-dist-js-imports.mjs dist",
+    "test": "vitest run test --config ../../vitest.packages.config.mts"
+  },
+  "dependencies": {
+    "@inrupt/solid-client-authn-browser": "^3.1.1"
+  },
+  "peerDependencies": {
+    "react": "^19.2.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.14",
+    "react": "^19.2.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7"
+  }
+}

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@undefineds.co/xpod",
-  "version": "0.3.58",
+  "version": "0.3.62",
   "description": "Xpod is an extended Community Solid Server, offering rich-feature, production-level Solid Pod and identity management.",
   "repository": "https://github.com/undefinedsco/xpod",
   "author": "developer@undefineds.co",
   "license": "MIT",
   "private": false,
+  "workspaces": [
+    "packages/*",
+    "ui"
+  ],
   "bin": {
     "xpod": "./bin/xpod.js"
   },
@@ -58,10 +62,12 @@
     "https://linkedsoftwaredependencies.org/bundles/npm/@undefineds.co/xpod/^0.0.0/templates/": "templates/"
   },
   "scripts": {
-    "build": "bun run build:ts && bun run build:components && bun run build:ui",
+    "build": "bun run build:ts && bun run build:components && bun run build:packages && bun run build:ui",
+    "build:packages": "bun run --filter '@undefineds.co/solid-sdk' build && bun run --filter '@undefineds.co/shared-ui' build && bun run --filter '@undefineds.co/extension-sdk' build && bun run --filter '@undefineds.co/ai-connection' build",
+    "test:packages": "bun run --filter './packages/*' test",
     "build:ts": "tsc",
     "build:components": "componentsjs-generator -s src -c dist/components -r undefineds -i config/components-ignore.json",
-    "build:ui": "cd ui && bun install --frozen-lockfile && bun run build",
+    "build:ui": "cd ui && bun install --frozen-lockfile && bun run build:all",
     "prepare.": "bun run build",
     "release": "node scripts/publish-release.cjs",
     "clean": "rm -rf data/*",
@@ -69,12 +75,16 @@
     "vanilla": "community-solid-server -c config/main.vanilla.json -f ./data_vanilla -p 3000",
     "cli": "bun src/cli/index.ts",
     "start": "bun src/main.ts",
-    "local": "dotenv -e .env.local -- bun src/main.ts -c config/local.json",
-    "cloud": "dotenv -e .env.cloud -- bun src/main.ts -c config/cloud.json",
+    "local": "dotenv -e .env.local -o -- env -u CSS_REDIS_CLIENT -u REDIS_URL -u CSS_REDIS_USERNAME -u CSS_REDIS_PASSWORD -u CSS_MINIO_ACCESS_KEY -u CSS_MINIO_SECRET_KEY -u CSS_MINIO_ENDPOINT -u CSS_MINIO_BUCKET_NAME bun --no-env-file src/main.ts -e .env.local -c config/local.json",
+    "cloud": "dotenv -e .env.cloud -o -- bun --no-env-file src/main.ts -e .env.cloud -c config/cloud.json",
     "dev": "./scripts/dev-start.sh",
     "dev:local": "./scripts/dev-start.sh --local",
-    "dev:seed": "NODE_ENV=development CSS_SEED_CONFIG=$PWD/config/seed.dev.json dotenv -e .env.local -- bun src/main.ts -c config/local.json",
-    "dev:cloud": "NODE_ENV=development CSS_SEED_CONFIG=$PWD/config/seed.dev.json dotenv -e .env.cloud -- bun src/main.ts -c config/cloud.json",
+    "settings:dev": "cd ui && bun run dev:settings",
+    "settings:open": "node scripts/open-settings.mjs",
+    "settings:test": "bun run test -- tests/ui/settings-launch.test.ts",
+    "settings:accept": "bun scripts/accept-xpod-settings.ts",
+    "dev:seed": "NODE_ENV=development CSS_SEED_CONFIG=$PWD/config/seed.dev.json dotenv -e .env.local -o -- env -u CSS_REDIS_CLIENT -u REDIS_URL -u CSS_REDIS_USERNAME -u CSS_REDIS_PASSWORD -u CSS_MINIO_ACCESS_KEY -u CSS_MINIO_SECRET_KEY -u CSS_MINIO_ENDPOINT -u CSS_MINIO_BUCKET_NAME bun --no-env-file src/main.ts -e .env.local -c config/local.json",
+    "dev:cloud": "NODE_ENV=development CSS_SEED_CONFIG=$PWD/config/seed.dev.json dotenv -e .env.cloud -o -- bun --no-env-file src/main.ts -e .env.cloud -c config/cloud.json",
     "dev:api": "NODE_ENV=development dotenv -e .env.local -- bun src/api/main.ts",
     "dev:init": "NODE_ENV=development bun scripts/init-dev-credentials.ts",
     "dev:test": "NODE_ENV=development bun scripts/test-dev-flow.ts",
@@ -96,6 +106,10 @@
     "test:w3c": "vitest --run tests/storage/w3c-sparql-full.test.ts",
     "test:storage": "vitest --run tests/storage/",
     "benchmark:rdf-models": "bun scripts/rdf-models-benchmark.ts",
+    "benchmark:rdf-models:pg": "bun scripts/rdf-postgres-models-benchmark.ts",
+    "benchmark:rdf-models:pg:gate": "bun scripts/assert-rdf-benchmark-report-gate.ts",
+    "test:rdf:access-smoke": "bun scripts/run-rdf-access-smoke.ts",
+    "ops:rdf:reset:pg": "bun scripts/reset-postgres-rdf-index.ts",
     "dev:cluster:lite": "docker compose -f docker-compose.standalone.yml up --build",
     "dev:cluster:lite:down": "docker compose -f docker-compose.standalone.yml down",
     "doctor:dev-procs": "node scripts/dev-process-doctor.cjs scan",
@@ -108,6 +122,8 @@
     "test:bun:runtime": "bun run build:ts && bun run build:components && XPOD_TEST_TRANSPORT=port bun scripts/run-bun-runtime-smoke.ts",
     "test:integration:lite:up": "docker compose -f docker-compose.standalone.yml up -d --build",
     "test:integration:lite:down": "docker compose -f docker-compose.standalone.yml down",
+    "smoke:server:reader-embedding": "bun scripts/smoke-reader-embedding-from-pod.ts",
+    "smoke:ai-connection:codex": "bun scripts/ai-gateway-codex-smoke.ts",
     "build:single": "node scripts/build-single-file.js",
     "build:single:bun": "node scripts/build-bun-single.js",
     "build:single:bun:package": "node scripts/build-platform-package.cjs --current",
@@ -135,13 +151,13 @@
     "smoke:tunnel:ngrok:inrupt": "bun scripts/ngrok-inrupt-oidc-smoke.ts"
   },
   "devDependencies": {
-    "@playwright/test": "^1.57.0",
     "@anthropic-ai/claude-agent-sdk": "^0.2.39",
+    "@playwright/test": "^1.57.0",
     "@types/http-proxy": "^1.17.17",
     "@types/nat-upnp": "^1.1.5",
     "@types/node": "^22.0.0",
     "@types/pg": "^8.10.2",
-    "@types/react": "^18.2.66",
+    "@types/react": "^19.2.5",
     "@types/react-dom": "^18.2.22",
     "@vitest/coverage-v8": "^1.4.0",
     "@zed-industries/claude-code-acp": "^0.16.1",
@@ -154,7 +170,7 @@
     "nat-upnp": "^1.1.1",
     "node-pty": "^1.1.0",
     "nodemon": "^3.1.10",
-    "rdf-test-suite": "^2.1.3",
+    "rdf-test-suite": "2.1.4",
     "ts-node": "^10.9.2",
     "typescript": "5.5",
     "vitest": "^1.4.0"
@@ -172,14 +188,15 @@
     "@inrupt/solid-client-authn-core": "^3.1.0",
     "@inrupt/solid-client-authn-node": "^3.1.0",
     "@mariozechner/pi-coding-agent": "^0.55.1",
+    "@radix-ui/react-slot": "^1.2.4",
     "@solid/community-server": "8.0.0-alpha.1",
-    "@undefineds.co/drizzle-solid": "0.3.18",
-    "@undefineds.co/models": "0.2.46",
+    "@undefineds.co/models": "0.2.47",
     "abstract-level": "^1.0.4",
     "acme-client": "^5.1.3",
     "ai": "^6.0.6",
     "asynciterator": "^3.9.0",
     "awilix": "^12.0.5",
+    "class-variance-authority": "^0.7.1",
     "classic-level": "^1.4.1",
     "clsx": "^2.1.0",
     "drizzle-orm": "^0.45.1",
@@ -195,11 +212,12 @@
     "portfinder": "^1.0.38",
     "quadstore": "^15.4.1",
     "quadstore-comunica": "^6.3.1",
-    "react": "^18.2.0",
+    "react": "^19.2.0",
     "react-dom": "^18.2.0",
     "react-i18next": "^13.3.1",
     "react-router-dom": "^6.22.3",
     "sqlite-vec": "^0.1.7-alpha.2",
+    "tailwind-merge": "^3.5.0",
     "tree-kill": "^1.2.2",
     "winston": "^3.17.0",
     "winston-daily-rotate-file": "^5.0.0",