@hachej/boring-ui-kit 0.1.111 → 0.2.0

package/dist/text-drafts.js

@@ -0,0 +1,378 @@
+import { identifier, locator, reference } from '@hachej/boring-files/publication';
+import { randomUUID } from '@hachej/boring-files/platform';
+function object(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new TypeError('Invalid recovery record');
+    return Object.fromEntries(Object.entries(value));
+}
+function integer(value, minimum = 1) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < minimum)
+        throw new TypeError('Invalid recovery bound');
+    return value;
+}
+function expectation(value) {
+    const input = object(value);
+    if (input.kind === 'absent')
+        return { kind: 'absent', target: locator(input.target) };
+    if (input.kind === 'revision')
+        return { kind: 'revision', target: reference(input.target) };
+    throw new TypeError('Invalid recovery base');
+}
+function key(value) {
+    const input = object(value), identity = object(input.identity);
+    return { identity: { principalId: identifier(identity.principalId), scopeId: identifier(identity.scopeId), initiatorId: identifier(identity.initiatorId) },
+        providerInstanceId: identifier(input.providerInstanceId), target: locator(input.target), format: identifier(input.format) };
+}
+function draftRef(value) {
+    const input = object(value);
+    return { key: key(input.key), base: expectation(input.base), writerId: identifier(input.writerId), sequence: integer(input.sequence) };
+}
+function sameRef(left, right) { return JSON.stringify(left) === JSON.stringify(right); }
+function failure(value) {
+    const input = object(value);
+    if (input.kind !== 'denied' && input.kind !== 'expired' && input.kind !== 'unavailable' && input.kind !== 'unknown')
+        throw new TypeError('Invalid recovery result');
+    return { kind: input.kind, reason: typeof input.reason === 'string' ? input.reason.slice(0, 1024) : 'Draft storage failed' };
+}
+function unavailable(reason) { return { kind: 'unavailable', reason }; }
+function conflict() { return { kind: 'conflict', reason: 'The recovery choice, current document, or local buffer changed' }; }
+function validateText(text, maxBytes) {
+    if (typeof text !== 'string' || text.length > maxBytes)
+        throw new TypeError('Recovery text exceeds its limit');
+    const bytes = new TextEncoder().encode(text);
+    if (bytes.length > maxBytes || new TextDecoder('utf-8', { ignoreBOM: true }).decode(bytes) !== text)
+        throw new TypeError('Recovery text is not bounded valid Unicode');
+    return text;
+}
+export function createTextDrafts(owner) {
+    const binding = owner.binding;
+    const maxBytes = integer(binding?.maxBytes ?? 8 * 1024 * 1024), maxDrafts = integer(binding?.maxDrafts ?? 20);
+    if (binding) {
+        identifier(binding.providerInstanceId);
+        identifier(binding.format);
+        integer(binding.expiresAt);
+        integer(binding.retentionMs);
+    }
+    const writerId = randomUUID();
+    let sequence = 0, checkSequence = 0, closed = false;
+    let recovery = binding ? { kind: 'active', checkpoint: { kind: 'idle' }, discovery: { kind: 'idle' } } : { kind: 'disabled' };
+    let current;
+    let restored;
+    let timer;
+    const activeKey = binding ? key({ identity: owner.snapshot().identity, providerInstanceId: binding.providerInstanceId, target: owner.snapshot().base.target, format: binding.format }) : undefined;
+    function emit(next) { recovery = next; owner.changed(next); }
+    function stop(kind) {
+        checkSequence++;
+        current = undefined;
+        if (kind !== 'disposed')
+            restored = undefined;
+        if (timer !== undefined)
+            clearTimeout(timer);
+        binding?.signal.removeEventListener('abort', revoke);
+        emit({ kind });
+    }
+    function revoke() { if (!closed)
+        stop('revoked'); }
+    function access(allowDisposed = false) {
+        if (!binding)
+            return unavailable('Draft recovery is disabled');
+        if (binding.signal.aborted) {
+            if (!closed && recovery.kind !== 'revoked')
+                stop('revoked');
+            return { kind: 'denied', reason: 'Draft access was revoked' };
+        }
+        if (binding.expiresAt <= Date.now()) {
+            if (!closed && recovery.kind !== 'expired')
+                stop('expired');
+            return { kind: 'expired', reason: 'Draft access expired' };
+        }
+        if (closed && !allowDisposed)
+            return unavailable('Viewer is disposed');
+        if (owner.snapshot().readOnly)
+            return { kind: 'denied', reason: 'Viewer is read-only' };
+        return undefined;
+    }
+    function scheduleExpiry() {
+        if (!binding || closed || recovery.kind !== 'active')
+            return;
+        if (timer !== undefined)
+            clearTimeout(timer);
+        let expiry = binding.expiresAt;
+        if (current && current.draft.expiresAt > Date.now())
+            expiry = Math.min(expiry, current.draft.expiresAt);
+        if (recovery.discovery.kind === 'offered')
+            for (const choice of recovery.discovery.choices)
+                expiry = Math.min(expiry, choice.expiresAt);
+        timer = setTimeout(() => {
+            if (access())
+                return;
+            if (current && current.draft.expiresAt <= Date.now())
+                checkpointFailure(current.draft.ref, 'write', { kind: 'expired', reason: 'The recovery checkpoint expired' });
+            if (recovery.kind === 'active' && recovery.discovery.kind === 'offered') {
+                const choices = recovery.discovery.choices.filter(choice => choice.expiresAt > Date.now());
+                emit({ ...recovery, discovery: choices.length ? { ...recovery.discovery, choices } : { kind: 'empty' } });
+            }
+            scheduleExpiry();
+        }, Math.min(2_147_483_647, Math.max(1, expiry - Date.now())));
+        if (typeof timer === 'object' && 'unref' in timer)
+            timer.unref();
+    }
+    function discovery(value) {
+        if (recovery.kind === 'active') {
+            emit({ ...recovery, discovery: value });
+            scheduleExpiry();
+        }
+        return value;
+    }
+    function parseDraft(value) {
+        const input = object(value), ref = draftRef(input.ref);
+        if (input.version !== 1 || !activeKey || JSON.stringify(ref.key) !== JSON.stringify(activeKey) || !owner.sameLocator(ref.base.target, activeKey.target))
+            throw new TypeError('Draft belongs to a different identity, provider, resource, view, or format');
+        const createdAt = integer(input.createdAt, 0), expiresAt = integer(input.expiresAt);
+        if (expiresAt <= createdAt)
+            throw new TypeError('Invalid draft retention');
+        return { version: 1, ref, text: validateText(input.text, maxBytes), createdAt, expiresAt };
+    }
+    async function list() {
+        if (!binding || !activeKey)
+            return unavailable('Draft recovery is disabled');
+        try {
+            const value = object(await binding.store.list(structuredClone(activeKey), maxDrafts));
+            if (value.kind !== 'available')
+                return failure(value);
+            if (!Array.isArray(value.drafts) || value.drafts.length > maxDrafts || typeof value.truncated !== 'boolean')
+                return unavailable('Draft storage returned an unbounded listing');
+            const drafts = value.drafts.map(parseDraft);
+            if (new Set(drafts.map(item => JSON.stringify(item.ref))).size !== drafts.length)
+                return unavailable('Draft storage returned duplicate records');
+            return { kind: 'available', drafts: drafts.filter(item => item.expiresAt > Date.now()), truncated: value.truncated };
+        }
+        catch {
+            return unavailable('Draft storage could not be read or validated');
+        }
+    }
+    function checkpointFailure(ref, operation, result) {
+        if (!access() && recovery.kind === 'active' && (operation === 'remove' || current && sameRef(current.draft.ref, ref)))
+            emit({ ...recovery, checkpoint: { kind: 'failed', ref, operation, result } });
+    }
+    async function write(draft) {
+        const denied = access();
+        if (denied || !binding)
+            return denied ?? unavailable('Draft recovery is disabled');
+        let result;
+        try {
+            const value = object(await binding.store.write(structuredClone(draft)));
+            result = value.kind === 'stored' ? { kind: 'stored', ref: draft.ref } : value.kind === 'superseded' ? { kind: 'superseded' } : failure(value);
+        }
+        catch {
+            result = { kind: 'unknown', reason: 'Draft storage acknowledgement was lost' };
+        }
+        const revoked = access();
+        if (revoked)
+            return revoked;
+        if (result.kind === 'stored' && draft.expiresAt <= Date.now())
+            result = { kind: 'expired', reason: 'The recovery checkpoint expired before acknowledgement' };
+        if (result.kind === 'stored' && current && sameRef(current.draft.ref, draft.ref) && recovery.kind === 'active')
+            emit({ ...recovery, checkpoint: { kind: 'stored', ref: draft.ref } });
+        else if (result.kind === 'superseded' && current && sameRef(current.draft.ref, draft.ref) && recovery.kind === 'active')
+            emit({ ...recovery, checkpoint: { kind: 'idle' } });
+        else if ('reason' in result)
+            checkpointFailure(draft.ref, 'write', result);
+        return result;
+    }
+    function capture() {
+        const state = owner.snapshot();
+        if (access() || !binding || !activeKey || !state.dirty)
+            return undefined;
+        if (current && current.version === state.bufferVersion && owner.sameBase(current.draft.ref.base, state.base) && current.draft.text === state.text && current.draft.expiresAt > Date.now())
+            return current.draft.ref;
+        const now = Date.now();
+        const draft = { version: 1, ref: { key: activeKey, base: structuredClone(state.base), writerId, sequence: ++sequence }, text: state.text, createdAt: now, expiresAt: Math.min(binding.expiresAt, now + binding.retentionMs) };
+        const item = { draft, version: state.bufferVersion, promise: Promise.resolve({ kind: 'superseded' }) };
+        current = item;
+        try {
+            validateText(draft.text, maxBytes);
+        }
+        catch {
+            const result = unavailable('The current text cannot be stored as a recovery draft');
+            item.promise = Promise.resolve(result);
+            checkpointFailure(draft.ref, 'write', result);
+            return draft.ref;
+        }
+        item.promise = Promise.resolve().then(() => write(draft));
+        if (recovery.kind === 'active')
+            emit({ ...recovery, checkpoint: { kind: 'pending', ref: draft.ref } });
+        scheduleExpiry();
+        return draft.ref;
+    }
+    async function remove(ref) {
+        const denied = access(true);
+        if (denied || !binding)
+            return denied ?? unavailable('Draft recovery is disabled');
+        let result;
+        try {
+            const value = object(await binding.store.remove(structuredClone(ref)));
+            if (value.kind !== 'removed' && value.kind !== 'missing' && value.kind !== 'superseded')
+                result = failure(value);
+        }
+        catch {
+            result = { kind: 'unknown', reason: 'Draft removal acknowledgement was lost' };
+        }
+        if (result)
+            checkpointFailure(ref, 'remove', result);
+        else if (!access() && current && sameRef(current.draft.ref, ref) && recovery.kind === 'active')
+            emit({ ...recovery, checkpoint: { kind: 'idle' } });
+        return access(true) ?? result;
+    }
+    async function latest() {
+        try {
+            const read = await owner.read();
+            if (read.kind === 'missing')
+                return { kind: 'absent', target: locator(owner.snapshot().base.target) };
+            if (read.kind !== 'available')
+                return unavailable('The current document could not be checked');
+            const ref = reference(read.snapshot.ref);
+            if (!activeKey || !owner.sameLocator(ref, activeKey.target))
+                return unavailable('The current read returned a different resource');
+            return { kind: 'revision', target: ref };
+        }
+        catch {
+            return unavailable('The current document could not be checked');
+        }
+    }
+    function guarded(selection) {
+        if (access())
+            return false;
+        owner.sync();
+        return !access() && owner.selected(selection) && !owner.pending();
+    }
+    async function choose(input, restore) {
+        const denied = access();
+        if (denied)
+            return denied;
+        let selected;
+        try {
+            selected = structuredClone(input);
+            selected = { ...selected, draft: draftRef(selected.draft) };
+        }
+        catch {
+            return conflict();
+        }
+        const offer = recovery.kind === 'active' && recovery.discovery.kind === 'offered' ? recovery.discovery.choices.find(choice => JSON.stringify(choice.selection) === JSON.stringify(selected)) : undefined;
+        if (!offer || offer.expiresAt <= Date.now() || !guarded(selected.viewer))
+            return conflict();
+        const serial = checkSequence;
+        const guard = () => serial === checkSequence && offer.expiresAt > Date.now() && guarded(selected.viewer);
+        if (restore && owner.snapshot().dirty && !(owner.snapshot().base.kind === 'absent' && owner.snapshot().text === owner.emptyText && owner.snapshot().bufferVersion === 0))
+            return conflict();
+        const remote = await latest();
+        if (!guard())
+            return access() ?? conflict();
+        if (remote.kind !== 'revision' && remote.kind !== 'absent')
+            return remote;
+        if (!owner.sameBase(remote, selected.observedCurrent))
+            return conflict();
+        const records = await list();
+        if (!guard())
+            return access() ?? conflict();
+        if (records.kind !== 'available')
+            return records;
+        const draft = records.drafts.find(item => sameRef(item.ref, selected.draft));
+        if (!draft || draft.text !== offer.text || draft.expiresAt !== offer.expiresAt)
+            return conflict();
+        if (!restore) {
+            const result = await remove(draft.ref);
+            if (result)
+                return result;
+            if (guard())
+                discovery({ kind: 'idle' });
+            return { kind: 'discarded' };
+        }
+        if (!owner.sameBase(remote, draft.ref.base) || !owner.sameBase(remote, owner.snapshot().base))
+            return conflict();
+        try {
+            binding?.validateText?.(draft.text);
+        }
+        catch {
+            return unavailable('The recovered document is not valid for this viewer');
+        }
+        if (!guard())
+            return access() ?? conflict();
+        if (!owner.restore(draft.text, guard))
+            return conflict();
+        restored = draft;
+        checkSequence++;
+        discovery({ kind: 'idle' });
+        return { kind: 'restored', selection: owner.selection() };
+    }
+    const actions = {
+        checkDrafts: async () => {
+            const denied = access();
+            if (denied)
+                return denied;
+            owner.sync();
+            const selection = owner.selection(), serial = ++checkSequence;
+            if (!guarded(selection))
+                return unavailable('A save must be settled before checking recovery drafts');
+            discovery({ kind: 'checking' });
+            const remote = await latest();
+            if (serial !== checkSequence || !guarded(selection)) {
+                const result = access() ?? unavailable('The viewer changed during recovery discovery');
+                return serial === checkSequence ? discovery(result) : result;
+            }
+            if (remote.kind !== 'revision' && remote.kind !== 'absent')
+                return discovery(remote);
+            const records = await list();
+            if (serial !== checkSequence || !guarded(selection)) {
+                const result = access() ?? unavailable('The viewer changed during recovery discovery');
+                return serial === checkSequence ? discovery(result) : result;
+            }
+            if (records.kind !== 'available')
+                return discovery(records);
+            const offerId = randomUUID();
+            return discovery(records.drafts.length ? { kind: 'offered', truncated: records.truncated, choices: records.drafts.map(draft => ({ selection: { offerId, draft: draft.ref, viewer: selection, observedCurrent: remote }, text: draft.text, createdAt: draft.createdAt, expiresAt: draft.expiresAt, compatibility: owner.sameBase(draft.ref.base, remote) ? 'exact' : 'conflict' })) } : { kind: 'empty' });
+        },
+        checkpointDraft: async () => {
+            const denied = access();
+            if (denied)
+                return denied;
+            owner.sync();
+            const retry = recovery.kind === 'active' && recovery.checkpoint.kind === 'failed' && recovery.checkpoint.operation === 'write' ? recovery.checkpoint.ref : undefined;
+            const ref = capture();
+            if (!ref || !current)
+                return { kind: 'clean' };
+            const item = current;
+            if (retry && sameRef(retry, ref))
+                item.promise = write(item.draft);
+            return item.promise;
+        },
+        restoreDraft: async (choice) => {
+            const result = await choose(choice, true);
+            return result.kind === 'discarded' ? conflict() : result;
+        },
+        discardDraft: async (choice) => {
+            const result = await choose(choice, false);
+            return result.kind === 'restored' ? conflict() : result;
+        },
+    };
+    if (binding) {
+        binding.signal.addEventListener('abort', revoke, { once: true });
+        if (!access())
+            scheduleExpiry();
+    }
+    return {
+        actions, capture, remove, currentRef: () => current?.draft.ref, state: () => recovery,
+        acknowledge: (ref, text) => {
+            if (ref)
+                void remove(ref);
+            if (restored?.text === text) {
+                void remove(restored.ref);
+                restored = undefined;
+            }
+        },
+        dispose: () => { if (!closed) {
+            stop('disposed');
+            closed = true;
+        } },
+    };
+}

package/package.json

@@ -1,75 +1,243 @@
 {
   "name": "@hachej/boring-ui-kit",
-  "version": "0.1.111",
-  "type": "module",
+  "version": "0.2.0",
   "license": "MIT",
-  "description": "Shared shadcn-style UI primitives for Boring packages and app-generated panes.",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hachej/boring-ui"
-  },
-  "homepage": "https://github.com/hachej/boring-ui",
+  "private": false,
+  "type": "module",
+  "description": "Independent headless viewer contracts with optional resource and native Pi subpaths.",
+  "sideEffects": [
+    "**/*.css"
+  ],
   "files": [
-    "dist"
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md",
+    "styles"
   ],
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./styles.css": {
-      "style": "./dist/styles.css",
-      "default": "./dist/styles.css"
+    "./contracts": {
+      "types": "./dist/contracts.d.ts",
+      "import": "./dist/contracts.js"
     },
-    "./tokens.css": {
-      "style": "./dist/tokens.css",
-      "default": "./dist/tokens.css"
-    }
+    "./anchor-conformance": {
+      "types": "./dist/anchor-conformance.d.ts",
+      "import": "./dist/anchor-conformance.js"
+    },
+    "./resources": {
+      "types": "./dist/resources.d.ts",
+      "import": "./dist/resources.js"
+    },
+    "./markdown": {
+      "types": "./dist/markdown.d.ts",
+      "import": "./dist/markdown.js"
+    },
+    "./pi": {
+      "types": "./dist/pi.d.ts",
+      "import": "./dist/pi.js"
+    },
+    "./markdown-editor": {
+      "types": "./dist/markdown-editor.d.ts",
+      "import": "./dist/markdown-editor.js"
+    },
+    "./native-chat": {
+      "types": "./dist/native-chat.d.ts",
+      "import": "./dist/native-chat.js"
+    },
+    "./remote-chat": {
+      "types": "./dist/remote-chat.d.ts",
+      "import": "./dist/remote-chat.js"
+    },
+    "./canvas": {
+      "types": "./dist/canvas.d.ts",
+      "import": "./dist/canvas.js"
+    },
+    "./canvas-editor": {
+      "types": "./dist/canvas-editor.d.ts",
+      "import": "./dist/canvas-editor.js"
+    },
+    "./html": {
+      "types": "./dist/html.d.ts",
+      "import": "./dist/html.js"
+    },
+    "./html-viewer": {
+      "types": "./dist/html-viewer.d.ts",
+      "import": "./dist/html-viewer.js"
+    },
+    "./experience": {
+      "types": "./dist/experience.d.ts",
+      "import": "./dist/experience.js"
+    },
+    "./experience/compose": {
+      "types": "./dist/experience-compose.d.ts",
+      "import": "./dist/experience-compose.js"
+    },
+    "./experience/document": {
+      "types": "./dist/experience-document.d.ts",
+      "import": "./dist/experience-document.js"
+    },
+    "./experience/document-viewer": {
+      "types": "./dist/experience-document-viewer.d.ts",
+      "import": "./dist/experience-document-viewer.js"
+    },
+    "./experience/regions": {
+      "types": "./dist/experience-regions.d.ts",
+      "import": "./dist/experience-regions.js"
+    },
+    "./canvas-document": {
+      "types": "./dist/canvas-document.d.ts",
+      "import": "./dist/canvas-document.js"
+    },
+    "./text-buffer": {
+      "types": "./dist/public-text-buffer.d.ts",
+      "import": "./dist/public-text-buffer.js"
+    },
+    "./file-tree": {
+      "types": "./dist/file-tree.d.ts",
+      "import": "./dist/file-tree.js"
+    },
+    "./file-tree-view": {
+      "types": "./dist/file-tree-view.d.ts",
+      "import": "./dist/file-tree-view.js"
+    },
+    "./file-tree.css": "./styles/file-tree.css"
   },
-  "sideEffects": [
-    "*.css"
-  ],
   "peerDependencies": {
-    "react": "^18.0.0 || ^19.0.0",
-    "react-dom": "^18.0.0 || ^19.0.0"
+    "@hachej/boring-files": "0.2.0",
+    "@earendil-works/pi-durable": "1.1.0",
+    "react": "19.3.0",
+    "react-dom": "19.3.0",
+    "marked": "17.0.6",
+    "@tiptap/core": "3.31.4",
+    "@tiptap/react": "3.31.4",
+    "@tiptap/pm": "3.31.4",
+    "@tiptap/starter-kit": "3.31.4",
+    "@tiptap/markdown": "3.31.4",
+    "@tiptap/extensions": "3.31.4",
+    "@tiptap/extension-list": "3.31.4",
+    "@tiptap/extension-table": "3.31.4",
+    "@tiptap/extension-image": "3.31.4",
+    "@tiptap/extension-highlight": "3.31.4",
+    "@tiptap/extension-bubble-menu": "3.31.4",
+    "@tiptap/extension-floating-menu": "3.31.4",
+    "@earendil-works/chord": "1.1.0",
+    "@earendil-works/pi-ai": "1.1.0",
+    "tldraw": "5.5.2",
+    "@tldraw/editor": "5.5.2",
+    "@tldraw/store": "5.5.2",
+    "@json-render/core": "0.21.0",
+    "@json-render/react": "0.21.0",
+    "zod": "4.6.5",
+    "@tldraw/tlschema": "5.5.2",
+    "@radix-ui/react-collapsible": "1.1.20",
+    "lucide-react": "1.51.0"
+  },
+  "peerDependenciesMeta": {
+    "@hachej/boring-files": {
+      "optional": true
+    },
+    "@earendil-works/pi-durable": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "marked": {
+      "optional": true
+    },
+    "@tiptap/core": {
+      "optional": true
+    },
+    "@tiptap/react": {
+      "optional": true
+    },
+    "@tiptap/pm": {
+      "optional": true
+    },
+    "@tiptap/starter-kit": {
+      "optional": true
+    },
+    "@tiptap/markdown": {
+      "optional": true
+    },
+    "@tiptap/extensions": {
+      "optional": true
+    },
+    "@tiptap/extension-list": {
+      "optional": true
+    },
+    "@tiptap/extension-table": {
+      "optional": true
+    },
+    "@tiptap/extension-image": {
+      "optional": true
+    },
+    "@tiptap/extension-highlight": {
+      "optional": true
+    },
+    "@tiptap/extension-bubble-menu": {
+      "optional": true
+    },
+    "@tiptap/extension-floating-menu": {
+      "optional": true
+    },
+    "@earendil-works/chord": {
+      "optional": true
+    },
+    "@earendil-works/pi-ai": {
+      "optional": true
+    },
+    "tldraw": {
+      "optional": true
+    },
+    "@tldraw/editor": {
+      "optional": true
+    },
+    "@tldraw/store": {
+      "optional": true
+    },
+    "@json-render/core": {
+      "optional": true
+    },
+    "@json-render/react": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    },
+    "@tldraw/tlschema": {
+      "optional": true
+    },
+    "@radix-ui/react-collapsible": {
+      "optional": true
+    },
+    "lucide-react": {
+      "optional": true
+    }
   },
-  "dependencies": {
-    "@radix-ui/react-alert-dialog": "^1.1.23",
-    "@radix-ui/react-checkbox": "^1.3.11",
-    "@radix-ui/react-collapsible": "^1.1.20",
-    "@radix-ui/react-dialog": "^1.1.23",
-    "@radix-ui/react-dropdown-menu": "^2.1.24",
-    "@radix-ui/react-hover-card": "^1.1.23",
-    "@radix-ui/react-label": "^2.1.15",
-    "@radix-ui/react-popover": "^1.1.23",
-    "@radix-ui/react-scroll-area": "^1.2.18",
-    "@radix-ui/react-select": "^2.3.7",
-    "@radix-ui/react-separator": "^1.1.15",
-    "@radix-ui/react-slot": "^1.3.3",
-    "@radix-ui/react-tabs": "^1.1.21",
-    "@radix-ui/react-tooltip": "^1.2.16",
-    "class-variance-authority": "^0.7.1",
-    "clsx": "^2.1.1",
-    "cmdk": "^1.1.1",
-    "tailwind-merge": "^3.5.0"
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hachej/boring-ui.git",
+    "directory": "packages/ui"
   },
-  "devDependencies": {
-    "@types/react": "^19.2.18",
-    "@types/react-dom": "^19.2.5",
-    "react": "^19.2.8",
-    "react-dom": "^19.2.8",
-    "tsup": "^8.4.0",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.11",
-    "@tailwindcss/postcss": "^4.3.3",
-    "postcss": "^8.5.25",
-    "tailwindcss": "^4.3.3"
+  "homepage": "https://github.com/hachej/boring-ui#readme",
+  "bugs": {
+    "url": "https://github.com/hachej/boring-ui/issues"
   },
-  "scripts": {
-    "build": "tsup && node scripts/build-styles.mjs",
-    "typecheck": "tsc --noEmit",
-    "lint": "pnpm run typecheck",
-    "test": "vitest run --passWithNoTests",
-    "clean": "rm -rf dist .tsbuildinfo"
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   }
-}
+}