@undefineds.co/xpod 0.3.57 → 0.3.61

package/node_modules/@undefineds.co/shared-ui/dist/button.d.ts

@@ -0,0 +1,10 @@
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+export declare const buttonVariants: (props?: ({
+    variant?: "default" | "secondary" | "destructive" | "outline" | "link" | "ghost" | "subtle" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+export declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;

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

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Slot } from '@radix-ui/react-slot';
+import { cva } from 'class-variance-authority';
+import * as React from 'react';
+import { cn } from './utils.js';
+export const buttonVariants = cva('inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50', {
+    variants: {
+        variant: {
+            default: 'bg-primary text-primary-foreground hover:bg-primary/90',
+            destructive: 'bg-destructive text-destructive-foreground hover:bg-destructive/90',
+            outline: 'border border-input bg-background hover:bg-accent hover:text-accent-foreground',
+            secondary: 'bg-secondary text-secondary-foreground hover:bg-secondary/80',
+            ghost: 'hover:bg-accent hover:text-accent-foreground',
+            link: 'text-primary underline-offset-4 hover:underline',
+            subtle: 'bg-muted text-muted-foreground hover:bg-muted/80',
+        },
+        size: {
+            default: 'h-10 px-4 py-2',
+            sm: 'h-9 rounded-md px-3',
+            lg: 'h-11 rounded-md px-8',
+            icon: 'h-10 w-10',
+        },
+    },
+    defaultVariants: { variant: 'default', size: 'default' },
+});
+export const Button = React.forwardRef(({ className, variant, size, asChild = false, ...props }, ref) => {
+    const Component = asChild ? Slot : 'button';
+    return (_jsx(Component, { className: cn(buttonVariants({ variant, size, className })), ref: ref, ...props }));
+});
+Button.displayName = 'Button';

package/node_modules/@undefineds.co/shared-ui/dist/card.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
+export declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+export declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import { cn } from './utils.js';
+export const Card = React.forwardRef(({ className, ...props }, ref) => (_jsx("div", { ref: ref, className: cn('rounded-2xl border border-border/50 bg-card shadow-lg shadow-black/5 transition-all duration-200', className), ...props })));
+Card.displayName = 'Card';
+export const CardHeader = React.forwardRef(({ className, ...props }, ref) => _jsx("div", { ref: ref, className: cn('flex flex-col gap-1 p-6', className), ...props }));
+CardHeader.displayName = 'CardHeader';
+export const CardTitle = React.forwardRef(({ className, ...props }, ref) => _jsx("h3", { ref: ref, className: cn('text-2xl font-semibold tracking-tight', className), ...props }));
+CardTitle.displayName = 'CardTitle';
+export const CardDescription = React.forwardRef(({ className, ...props }, ref) => _jsx("p", { ref: ref, className: cn('text-sm text-muted-foreground', className), ...props }));
+CardDescription.displayName = 'CardDescription';
+export const CardContent = React.forwardRef(({ className, ...props }, ref) => _jsx("div", { ref: ref, className: cn('p-6 pt-0', className), ...props }));
+CardContent.displayName = 'CardContent';
+export const CardFooter = React.forwardRef(({ className, ...props }, ref) => _jsx("div", { ref: ref, className: cn('flex items-center p-6 pt-0', className), ...props }));
+CardFooter.displayName = 'CardFooter';

package/node_modules/@undefineds.co/shared-ui/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './badge';
+export * from './button';
+export * from './card';
+export * from './input';
+export * from './utils';
+export * from './workspace';

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

@@ -0,0 +1,6 @@
+export * from './badge.js';
+export * from './button.js';
+export * from './card.js';
+export * from './input.js';
+export * from './utils.js';
+export * from './workspace.js';

package/node_modules/@undefineds.co/shared-ui/dist/input.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+export interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+}
+export declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;

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

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import { cn } from './utils.js';
+export const Input = React.forwardRef(({ className, type = 'text', ...props }, ref) => (_jsx("input", { ref: ref, type: type, className: cn('flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50', className), ...props })));
+Input.displayName = 'Input';

package/node_modules/@undefineds.co/shared-ui/dist/theme.css

@@ -0,0 +1,121 @@
+@layer base {
+  :root {
+    --background: 0 0% 98%;
+    --foreground: 0 0% 12%;
+    --card: 0 0% 100%;
+    --card-foreground: 0 0% 12%;
+    --popover: 0 0% 100%;
+    --popover-foreground: 0 0% 12%;
+    --primary: 252 46% 57%;
+    --primary-foreground: 0 0% 100%;
+    --secondary: 0 0% 96%;
+    --secondary-foreground: 0 0% 12%;
+    --muted: 0 0% 96%;
+    --muted-foreground: 0 0% 43%;
+    --accent: 0 0% 96%;
+    --accent-foreground: 0 0% 12%;
+    --destructive: 352 43% 49%;
+    --destructive-foreground: 0 0% 100%;
+    --border: 0 0% 88%;
+    --input: 0 0% 88%;
+    --ring: 252 46% 57%;
+    --lineage: 252 46% 57%;
+    --lineage-foreground: 0 0% 100%;
+    --boundary: 202 34% 37%;
+    --boundary-foreground: 0 0% 100%;
+    --success: 160 48% 30%;
+    --success-foreground: 0 0% 100%;
+    --warning: 44 72% 36%;
+    --warning-foreground: 0 0% 100%;
+    --radius-xs: 2px;
+    --radius-sm: 4px;
+    --radius-md: 8px;
+    --radius-lg: 12px;
+    --radius-xl: 16px;
+    --radius-2xl: 16px;
+    --radius-3xl: 16px;
+    --radius: 0.5rem;
+  }
+
+  .dark {
+    --background: 0 0% 8%;
+    --foreground: 0 0% 96%;
+    --card: 0 0% 10%;
+    --card-foreground: 0 0% 96%;
+    --popover: 0 0% 10%;
+    --popover-foreground: 0 0% 96%;
+    --primary: 252 48% 65%;
+    --primary-foreground: 0 0% 100%;
+    --secondary: 0 0% 15%;
+    --secondary-foreground: 0 0% 96%;
+    --muted: 0 0% 15%;
+    --muted-foreground: 0 0% 68%;
+    --accent: 0 0% 15%;
+    --accent-foreground: 0 0% 96%;
+    --destructive: 352 43% 49%;
+    --destructive-foreground: 0 0% 100%;
+    --border: 0 0% 21%;
+    --input: 0 0% 21%;
+    --ring: 252 48% 65%;
+    --lineage: 252 48% 65%;
+    --lineage-foreground: 0 0% 100%;
+    --boundary: 202 34% 48%;
+    --boundary-foreground: 0 0% 100%;
+    --success: 160 48% 42%;
+    --success-foreground: 0 0% 100%;
+    --warning: 44 72% 48%;
+    --warning-foreground: 0 0% 100%;
+  }
+
+  .light {
+    --background: 0 0% 98%;
+    --foreground: 0 0% 12%;
+    --card: 0 0% 100%;
+    --card-foreground: 0 0% 12%;
+    --popover: 0 0% 100%;
+    --popover-foreground: 0 0% 12%;
+    --primary: 252 46% 57%;
+    --primary-foreground: 0 0% 100%;
+    --secondary: 0 0% 96%;
+    --secondary-foreground: 0 0% 12%;
+    --muted: 0 0% 96%;
+    --muted-foreground: 0 0% 43%;
+    --accent: 0 0% 96%;
+    --accent-foreground: 0 0% 12%;
+    --destructive: 352 43% 49%;
+    --destructive-foreground: 0 0% 100%;
+    --border: 0 0% 88%;
+    --input: 0 0% 88%;
+    --ring: 252 46% 57%;
+    --lineage: 252 46% 57%;
+    --lineage-foreground: 0 0% 100%;
+    --boundary: 202 34% 37%;
+    --boundary-foreground: 0 0% 100%;
+    --success: 160 48% 30%;
+    --success-foreground: 0 0% 100%;
+    --warning: 44 72% 36%;
+    --warning-foreground: 0 0% 100%;
+  }
+}
+
+@theme inline {
+  --color-background: hsl(var(--background));
+  --color-foreground: hsl(var(--foreground));
+  --color-card: hsl(var(--card));
+  --color-card-foreground: hsl(var(--card-foreground));
+  --color-primary: hsl(var(--primary));
+  --color-primary-foreground: hsl(var(--primary-foreground));
+  --color-secondary: hsl(var(--secondary));
+  --color-secondary-foreground: hsl(var(--secondary-foreground));
+  --color-muted: hsl(var(--muted));
+  --color-muted-foreground: hsl(var(--muted-foreground));
+  --color-accent: hsl(var(--accent));
+  --color-accent-foreground: hsl(var(--accent-foreground));
+  --color-destructive: hsl(var(--destructive));
+  --color-destructive-foreground: hsl(var(--destructive-foreground));
+  --color-border: hsl(var(--border));
+  --color-input: hsl(var(--input));
+  --color-ring: hsl(var(--ring));
+  --color-success: hsl(var(--success));
+  --color-warning: hsl(var(--warning));
+}

package/node_modules/@undefineds.co/shared-ui/dist/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;

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

@@ -0,0 +1,5 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

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

@@ -0,0 +1,23 @@
+import { type ComponentProps, type ReactNode } from 'react';
+interface WorkspaceNavigation {
+    mode: 'split' | 'stack';
+    activePane: 'list' | 'main';
+    mobilePane: 'list' | 'main';
+    showMain(): void;
+    showList(): void;
+    openMain(): void;
+    backToList(): void;
+}
+export declare function TwoPaneWorkspace({ header, list, main, className, layoutMode, }: {
+    header: ReactNode;
+    list: ReactNode;
+    main: ReactNode;
+    className?: string;
+    layoutMode?: 'auto' | 'wide' | 'narrow';
+}): import("react").JSX.Element;
+export declare function useAppletLayout(): Pick<WorkspaceNavigation, 'mode' | 'activePane' | 'openMain' | 'backToList'>;
+export declare function AppletList(props: ComponentProps<'nav'>): import("react").JSX.Element;
+export declare function AppletListItem({ selected, className, onClick, ...props }: ComponentProps<'button'> & {
+    selected?: boolean;
+}): import("react").JSX.Element;
+export {};

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;