@coreason-ai/sensory-core 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.5.0](https://github.com/CoReason-AI/coreason-sensory-core/compare/v1.4.0...v1.5.0) (2026-05-22)
+
+
+### Features
+
+* **auth:** initiate sovereign keysigning ceremony modal primitives for operator handovers ref CoReason-AI/coreason-urn-authority[#104](https://github.com/CoReason-AI/coreason-sensory-core/issues/104) ([d8c928d](https://github.com/CoReason-AI/coreason-sensory-core/commit/d8c928d006055c2838734a10aa5522be19e461a0))
+* **sensory-core:** integrate temporal scrubber active fork controls ref [#106](https://github.com/CoReason-AI/coreason-sensory-core/issues/106) ([861acc8](https://github.com/CoReason-AI/coreason-sensory-core/commit/861acc8605940df057b663fbd1994c3071ea4ac5))
+* **sensory:** implement egress classification boundary and particle animations ([#105](https://github.com/CoReason-AI/coreason-sensory-core/issues/105)) ([80559e1](https://github.com/CoReason-AI/coreason-sensory-core/commit/80559e19458766ef418426c4aae605a7a263367f))
+* **sensory:** implement SemanticConstellationMap visualizer ([#109](https://github.com/CoReason-AI/coreason-sensory-core/issues/109)) ([b31efec](https://github.com/CoReason-AI/coreason-sensory-core/commit/b31efec70c6c544cfb0cb00f6e1bef98a0a3cf9c))
+
+
+### Bug Fixes
+
+* **github:** add explicit repo targeting and merge fallbacks to release workflow ([d11152b](https://github.com/CoReason-AI/coreason-sensory-core/commit/d11152b5e38493553caa5a99e20a73d3de694661))
+* **github:** parse release-please pr output JSON for automerge ([6e5af70](https://github.com/CoReason-AI/coreason-sensory-core/commit/6e5af70d5fe74a304bacb6ba28433a0e3fdbd926))
+
 ## [1.4.0](https://github.com/CoReason-AI/coreason-sensory-core/compare/v1.3.0...v1.4.0) (2026-05-22)
 
 

package/dist/components/DlpParticleShield.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export interface DlpParticleShieldProps {
+    isBlocked: boolean;
+    blockedDataPattern?: string;
+    destinationLabel?: string;
+    onShieldAlert?: () => void;
+    className?: string;
+}
+export declare const DlpParticleShield: React.FC<DlpParticleShieldProps>;

package/dist/components/DlpParticleShield.js

@@ -0,0 +1,197 @@
+// Copyright (c) 2026 CoReason, Inc
+//
+// This software is proprietary and dual-licensed
+// Licensed under the Prosperity Public License 3.0 (the "License")
+// A copy of the license is available at <https://prosperitylicense.com/versions/3.0.0>
+// For details, see the LICENSE file
+// Commercial use beyond a 30-day trial requires a separate license
+//
+// Source Code: <https://github.com/CoReason-AI/coreason-runtime>
+import React, { useRef, useEffect } from 'react';
+import { GlassBox } from './GlassBox';
+import { Shield, AlertTriangle, Globe, Activity } from 'lucide-react';
+export const DlpParticleShield = ({ isBlocked, blockedDataPattern = 'SPIFFE-SVID Private Key Match', destinationLabel = 'api.openai.com/v1/chat', onShieldAlert, className = '' }) => {
+    const canvasRef = useRef(null);
+    const isBlockedRef = useRef(isBlocked);
+    // Synchronize block state reference for the animation loop context
+    useEffect(() => {
+        if (isBlocked && !isBlockedRef.current) {
+            if (onShieldAlert) {
+                onShieldAlert();
+            }
+        }
+        isBlockedRef.current = isBlocked;
+    }, [isBlocked, onShieldAlert]);
+    useEffect(() => {
+        const canvas = canvasRef.current;
+        if (!canvas)
+            return;
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            return;
+        let animationFrameId;
+        const particles = [];
+        // Adjust canvas dimensions for screen resolution DPI
+        const resizeCanvas = () => {
+            const rect = canvas.getBoundingClientRect();
+            canvas.width = rect.width * window.devicePixelRatio;
+            canvas.height = rect.height * window.devicePixelRatio;
+            ctx.scale(window.devicePixelRatio, window.devicePixelRatio);
+        };
+        resizeCanvas();
+        window.addEventListener('resize', resizeCanvas);
+        // Main animation loop
+        const animate = () => {
+            const w = canvas.width / window.devicePixelRatio;
+            const h = canvas.height / window.devicePixelRatio;
+            // Wipe current frame
+            ctx.clearRect(0, 0, w, h);
+            // Node positions
+            const srcX = w * 0.15;
+            const srcY = h * 0.5;
+            const dstX = w * 0.85;
+            const dstY = h * 0.5;
+            const shieldX = w * 0.55;
+            // Generate new egress particles
+            if (particles.length < 120 && Math.random() < 0.3) {
+                particles.push({
+                    x: srcX,
+                    y: srcY + (Math.random() - 0.5) * 16,
+                    vx: 2 + Math.random() * 2,
+                    vy: (Math.random() - 0.5) * 1.0,
+                    alpha: 0.8 + Math.random() * 0.2,
+                    size: 1.5 + Math.random() * 2,
+                    color: 'rgb(34, 211, 238)', // Cyan
+                    isSplashing: false
+                });
+            }
+            // Draw Connection Conduit Path
+            ctx.beginPath();
+            ctx.moveTo(srcX, srcY);
+            ctx.bezierCurveTo(w * 0.35, srcY - 30, w * 0.65, srcY + 30, dstX, dstY);
+            ctx.strokeStyle = isBlockedRef.current
+                ? 'rgba(239, 68, 68, 0.15)'
+                : 'rgba(34, 211, 238, 0.15)';
+            ctx.lineWidth = 2;
+            ctx.stroke();
+            // Transition and draw active particles
+            for (let i = particles.length - 1; i >= 0; i--) {
+                const p = particles[i];
+                // Move particle
+                p.x += p.vx;
+                p.y += p.vy;
+                // Apply sine wave path variance if nominal
+                if (!p.isSplashing) {
+                    p.y += Math.sin(p.x * 0.05) * 0.25;
+                }
+                // Boundary checks and collision detection
+                const hasReachedBoundary = p.x >= dstX;
+                const hasCollidedWithShield = isBlockedRef.current && p.x >= shieldX && !p.isSplashing;
+                if (hasReachedBoundary) {
+                    // Egress completed successfully
+                    particles.splice(i, 1);
+                    continue;
+                }
+                if (hasCollidedWithShield) {
+                    // Trigger backward splash deflection
+                    p.isSplashing = true;
+                    p.vx = -p.vx * (0.3 + Math.random() * 0.4);
+                    p.vy = (Math.random() - 0.5) * 5;
+                    p.color = 'rgb(239, 68, 68)'; // Transmute to Crimson Red
+                }
+                // Reduce alpha over time for deflecting particles
+                if (p.isSplashing) {
+                    p.alpha -= 0.035;
+                    // Apply slight gravity drift
+                    p.vy += 0.08;
+                }
+                // Discard particles that are out of visual bounds or transparent
+                if (p.alpha <= 0 || p.x < 0) {
+                    particles.splice(i, 1);
+                    continue;
+                }
+                // Render individual particle
+                ctx.beginPath();
+                ctx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
+                ctx.fillStyle = p.color.replace('rgb', 'rgba').replace(')', `, ${p.alpha})`);
+                ctx.shadowColor = p.color;
+                ctx.shadowBlur = p.isSplashing ? 6 : 3;
+                ctx.fill();
+                // Reset shadow configuration for next drawing commands
+                ctx.shadowBlur = 0;
+            }
+            // Draw operational endpoints nodes
+            // 1. Source Enclave Node
+            ctx.beginPath();
+            ctx.arc(srcX, srcY, 8, 0, Math.PI * 2);
+            ctx.fillStyle = '#0f172a';
+            ctx.strokeStyle = '#22d3ee';
+            ctx.lineWidth = 2.5;
+            ctx.stroke();
+            ctx.fill();
+            // Node Inner status pulse
+            ctx.beginPath();
+            ctx.arc(srcX, srcY, 3, 0, Math.PI * 2);
+            ctx.fillStyle = '#22d3ee';
+            ctx.fill();
+            // 2. Gateway Node
+            ctx.beginPath();
+            ctx.arc(dstX, dstY, 8, 0, Math.PI * 2);
+            ctx.fillStyle = '#0f172a';
+            ctx.strokeStyle = isBlockedRef.current ? '#ef4444' : '#10b981';
+            ctx.lineWidth = 2.5;
+            ctx.stroke();
+            ctx.fill();
+            // Draw Glass Box Shield Boundary Barrier if active
+            if (isBlockedRef.current) {
+                ctx.beginPath();
+                ctx.moveTo(shieldX, h * 0.15);
+                ctx.lineTo(shieldX, h * 0.85);
+                ctx.strokeStyle = 'rgba(239, 68, 68, 0.7)';
+                ctx.lineWidth = 3;
+                ctx.setLineDash([4, 4]);
+                ctx.shadowColor = '#ef4444';
+                ctx.shadowBlur = 8;
+                ctx.stroke();
+                ctx.setLineDash([]); // Reset dash config
+                ctx.shadowBlur = 0;
+                // Draw Shield Label banner
+                ctx.fillStyle = '#ef4444';
+                ctx.font = 'bold 8px monospace';
+                ctx.textAlign = 'center';
+                ctx.fillText('AIR-GAP SHIELD ACTIVE', shieldX, h * 0.1);
+            }
+            animationFrameId = requestAnimationFrame(animate);
+        };
+        animate();
+        return () => {
+            cancelAnimationFrame(animationFrameId);
+            window.removeEventListener('resize', resizeCanvas);
+        };
+    }, []);
+    return (React.createElement(GlassBox, { density: "dense", className: `border bg-black/60 backdrop-blur-md p-5 flex flex-col gap-4 rounded-xl transition-all duration-500 ${isBlocked
+            ? 'border-red-500/50 shadow-[0_0_20px_rgba(239,68,68,0.15)]'
+            : 'border-white/10 shadow-[0_4px_15px_rgba(0,0,0,0.5)]'} ${className}` },
+        React.createElement("div", { className: "flex items-center justify-between border-b border-white/10 pb-2" },
+            React.createElement("div", { className: "flex items-center gap-2" },
+                React.createElement(Shield, { className: `w-4 h-4 ${isBlocked ? 'text-red-400 animate-pulse' : 'text-cyan-400'}` }),
+                React.createElement("span", { className: "text-[11px] font-bold text-gray-400 uppercase tracking-widest" }, "DLP Particle Shield")),
+            React.createElement("div", { className: "flex items-center gap-1.5 font-mono text-[9px]" },
+                React.createElement(Activity, { className: `w-3.5 h-3.5 ${isBlocked ? 'text-red-400' : 'text-green-400 animate-pulse'}` }),
+                React.createElement("span", { className: isBlocked ? 'text-red-400 font-bold' : 'text-green-400 font-bold' }, isBlocked ? 'BARRIER_ENGAGED' : 'FLOW_NOMINAL'))),
+        React.createElement("div", { className: "relative w-full h-36 bg-black/30 border border-white/5 rounded-lg overflow-hidden" },
+            React.createElement("canvas", { ref: canvasRef, className: "w-full h-full block" }),
+            React.createElement("div", { className: "absolute top-2 left-3 pointer-events-none select-none font-mono text-[8px] text-gray-500" }, "LOCAL ENCLAVE"),
+            React.createElement("div", { className: "absolute top-2 right-3 pointer-events-none select-none font-mono text-[8px] text-gray-500 text-right" }, "DESTINATION GATEWAY")),
+        React.createElement("div", { className: "grid grid-cols-1 md:grid-cols-2 gap-3 font-mono text-[9px] bg-black/35 rounded-lg border border-white/5 p-3" },
+            React.createElement("div", { className: "flex flex-col gap-1" },
+                React.createElement("span", { className: "text-gray-500 uppercase tracking-wider" }, "Egress Target"),
+                React.createElement("div", { className: "flex items-center gap-1.5 text-gray-200 font-bold truncate" },
+                    React.createElement(Globe, { className: "w-3.5 h-3.5 text-gray-400 shrink-0" }),
+                    React.createElement("span", { className: "truncate", title: destinationLabel }, destinationLabel))),
+            React.createElement("div", { className: "flex flex-col gap-1" },
+                React.createElement("span", { className: "text-gray-500 uppercase tracking-wider" }, "Blocked Classification Pattern"),
+                React.createElement("div", { className: "flex items-center gap-1.5 text-gray-200 font-bold truncate" },
+                    React.createElement(AlertTriangle, { className: `w-3.5 h-3.5 shrink-0 ${isBlocked ? 'text-red-400' : 'text-gray-500'}` }),
+                    React.createElement("span", { className: "truncate", title: blockedDataPattern }, isBlocked ? blockedDataPattern : 'N/A'))))));
+};

package/dist/components/KeysigningCeremonyModal.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+export interface DelegatedAttestationReceipt {
+    sessionToken: string;
+    attestationHash: string;
+    signaturesCollected: number;
+    signaturesThreshold: number;
+    status: 'PENDING' | 'ESTABLISHED' | 'RETRACTED' | 'FAULT';
+    timestamp: string;
+}
+export interface SignerProfile {
+    id: string;
+    name: string;
+    spiffeId: string;
+    status: 'PENDING' | 'SIGNED' | 'REJECTED';
+}
+export interface KeysigningCeremonyModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    sessionToken: string;
+    requiredSigners?: SignerProfile[];
+    threshold?: number;
+    onComplete?: (receipt: DelegatedAttestationReceipt) => void;
+    className?: string;
+}
+export declare const KeysigningCeremonyModal: React.FC<KeysigningCeremonyModalProps>;

package/dist/components/KeysigningCeremonyModal.js

@@ -0,0 +1,139 @@
+// Copyright (c) 2026 CoReason, Inc
+//
+// This software is proprietary and dual-licensed
+// Licensed under the Prosperity Public License 3.0 (the "License")
+// A copy of the license is available at <https://prosperitylicense.com/versions/3.0.0>
+// For details, see the LICENSE file
+// Commercial use beyond a 30-day trial requires a separate license
+//
+// Source Code: <https://github.com/CoReason-AI/coreason-sensory-core>
+import React, { useState, useEffect } from 'react';
+import { GlassBox } from './GlassBox';
+import { Shield, ShieldAlert, X, Check, Activity } from 'lucide-react';
+const DEFAULT_REQUIRED_SIGNERS = [
+    { id: 'alice', name: 'Alice (Security)', spiffeId: 'spiffe://coreason.internal/tenant/operator/alice', status: 'PENDING' },
+    { id: 'bob', name: 'Bob (Audit)', spiffeId: 'spiffe://coreason.internal/tenant/operator/bob', status: 'PENDING' }
+];
+export const KeysigningCeremonyModal = ({ isOpen, onClose, sessionToken, requiredSigners = DEFAULT_REQUIRED_SIGNERS, threshold = 2, onComplete, className = '' }) => {
+    var _a, _b, _c, _d;
+    const [signersList, setSignersList] = useState(requiredSigners);
+    const [isProcessing, setIsProcessing] = useState(false);
+    const [ceremonyStatus, setCeremonyStatus] = useState('PENDING');
+    const [panicMessage, setPanicMessage] = useState(null);
+    useEffect(() => {
+        if (isOpen) {
+            setSignersList(requiredSigners);
+            setCeremonyStatus('PENDING');
+            setPanicMessage(null);
+            setIsProcessing(false);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [isOpen]);
+    if (!isOpen)
+        return null;
+    const signedCount = signersList.filter(s => s.status === 'SIGNED').length;
+    const isFused = signedCount >= threshold;
+    const handleSign = (signerId) => {
+        if (isProcessing || ceremonyStatus === 'ESTABLISHED')
+            return;
+        setSignersList(prev => prev.map(s => (s.id === signerId ? Object.assign(Object.assign({}, s), { status: 'SIGNED' }) : s)));
+    };
+    const handleRetract = (signerId) => {
+        if (isProcessing || ceremonyStatus === 'ESTABLISHED')
+            return;
+        setSignersList(prev => prev.map(s => (s.id === signerId ? Object.assign(Object.assign({}, s), { status: 'PENDING' }) : s)));
+    };
+    const handleFinalize = () => {
+        if (signedCount < threshold) {
+            setPanicMessage('Signature threshold not satisfied.');
+            return;
+        }
+        setIsProcessing(true);
+        setPanicMessage(null);
+        setTimeout(() => {
+            setIsProcessing(false);
+            setCeremonyStatus('ESTABLISHED');
+            const receipt = {
+                sessionToken,
+                attestationHash: `0x${Array.from({ length: 64 }, () => Math.floor(Math.random() * 16).toString(16)).join('')}`,
+                signaturesCollected: signedCount,
+                signaturesThreshold: threshold,
+                status: 'ESTABLISHED',
+                timestamp: new Date().toISOString()
+            };
+            if (onComplete) {
+                onComplete(receipt);
+            }
+        }, 1800);
+    };
+    const resetCeremony = () => {
+        setSignersList(requiredSigners);
+        setCeremonyStatus('PENDING');
+        setPanicMessage(null);
+    };
+    return (React.createElement("div", { className: `fixed inset-0 z-50 flex items-center justify-center p-4 bg-black/70 backdrop-blur-sm ${className}`, "data-testid": "keysigning-modal-overlay" },
+        React.createElement(GlassBox, { density: "dense", className: "w-full max-w-lg border border-white/10 bg-[#0c0c0f]/90 text-white rounded-xl shadow-2xl overflow-hidden flex flex-col font-mono" },
+            React.createElement("div", { className: "flex items-center justify-between px-6 py-4 border-b border-white/10 bg-black/40" },
+                React.createElement("div", { className: "flex items-center gap-2" },
+                    React.createElement(Shield, { className: "w-4 h-4 text-amber-500" }),
+                    React.createElement("span", { className: "text-[11px] font-bold text-gray-400 uppercase tracking-widest" }, "Sovereign Keysigning Ceremony")),
+                React.createElement("button", { onClick: onClose, className: "p-1 hover:bg-white/10 rounded transition-colors text-gray-400 hover:text-white", title: "Cancel Ceremony" },
+                    React.createElement(X, { className: "w-4 h-4" }))),
+            React.createElement("div", { className: "p-6 flex flex-col items-center gap-6 overflow-y-auto max-h-[75vh]" },
+                React.createElement("div", { className: "relative w-40 h-40 flex items-center justify-center" },
+                    React.createElement("div", { className: `absolute inset-0 rounded-full border border-dashed transition-all duration-1000 ${ceremonyStatus === 'ESTABLISHED'
+                            ? 'border-yellow-500/50 scale-110 rotate-45'
+                            : 'border-white/10'}` }),
+                    React.createElement("svg", { viewBox: "0 0 120 120", className: "w-full h-full drop-shadow-[0_0_15px_rgba(217,119,6,0.3)]" },
+                        React.createElement("path", { d: "M 60 15 C 75 12, 90 22, 95 35 C 102 48, 108 65, 98 80 C 90 92, 75 105, 60 102 C 45 100, 30 92, 22 80 C 12 65, 18 48, 25 35 C 30 22, 45 18, 60 15 Z", fill: ceremonyStatus === 'ESTABLISHED' ? "#7f1d1d" : "#3b1704", stroke: ceremonyStatus === 'ESTABLISHED' ? "#eab308" : "#854d0e", strokeWidth: "3.5", className: "transition-colors duration-1000" }),
+                        !isFused && (React.createElement("path", { d: "M 60 22 L 58 48 L 62 72 L 60 98", stroke: "#1c0a00", strokeWidth: "3", fill: "none", className: "opacity-80" })),
+                        React.createElement("path", { d: "M 32 60 C 42 60, 48 54, 58 48", fill: "none", stroke: ((_a = signersList[0]) === null || _a === void 0 ? void 0 : _a.status) === 'SIGNED' ? "#fbbf24" : "#78350f", strokeWidth: "4", strokeDasharray: "45", strokeDashoffset: ((_b = signersList[0]) === null || _b === void 0 ? void 0 : _b.status) === 'SIGNED' ? "0" : "45", className: "transition-all duration-1000 ease-in-out" }),
+                        React.createElement("path", { d: "M 88 60 C 78 60, 72 66, 62 72", fill: "none", stroke: ((_c = signersList[1]) === null || _c === void 0 ? void 0 : _c.status) === 'SIGNED' ? "#fbbf24" : "#78350f", strokeWidth: "4", strokeDasharray: "45", strokeDashoffset: ((_d = signersList[1]) === null || _d === void 0 ? void 0 : _d.status) === 'SIGNED' ? "0" : "45", className: "transition-all duration-1000 ease-in-out" }),
+                        React.createElement("path", { d: "M 53 45 A 7 7 0 1 1 67 45 A 7 7 0 0 1 60 52 L 60 75 L 66 75 M 60 66 L 66 66", fill: "none", stroke: ceremonyStatus === 'ESTABLISHED' ? "#fbbf24" : "#ca8a04", strokeWidth: "3", strokeLinecap: "round", strokeLinejoin: "round", className: "transition-colors duration-1000" }),
+                        ceremonyStatus === 'ESTABLISHED' && (React.createElement("path", { d: "M 50 82 L 60 88 L 70 82 V 76 H 50 Z", fill: "#fbbf24", className: "animate-pulse" }))),
+                    ceremonyStatus === 'ESTABLISHED' && (React.createElement("div", { className: "absolute inset-2 rounded-full border border-yellow-500 animate-ping opacity-60 pointer-events-none", style: { animationDuration: '1.5s' } }))),
+                React.createElement("div", { className: "w-full text-center" },
+                    React.createElement("h3", { className: "text-sm font-bold text-white uppercase tracking-wider" }, ceremonyStatus === 'ESTABLISHED' ? 'Attestation Established' : isProcessing ? 'Fusing Key Shares...' : 'Signatures Verification'),
+                    React.createElement("p", { className: "text-[10px] text-gray-400 mt-1" },
+                        "Threshold requirements: ",
+                        signedCount,
+                        " of ",
+                        threshold,
+                        " signatures collected.")),
+                React.createElement("div", { className: "w-full flex flex-col gap-2.5" }, signersList.map((signer) => {
+                    const isSigned = signer.status === 'SIGNED';
+                    return (React.createElement("div", { key: signer.id, className: `flex items-center justify-between p-3 rounded-lg border transition-all ${isSigned
+                            ? 'bg-amber-950/20 border-amber-500/40 text-amber-300'
+                            : 'bg-black/30 border-white/5 text-gray-400'}` },
+                        React.createElement("div", { className: "flex flex-col min-w-0 pr-2" },
+                            React.createElement("span", { className: "text-[10px] font-bold text-white" }, signer.name),
+                            React.createElement("span", { className: "text-[9px] text-gray-500 truncate mt-0.5" }, signer.spiffeId)),
+                        React.createElement("div", { className: "flex items-center gap-2" }, isSigned ? (React.createElement(React.Fragment, null,
+                            React.createElement("span", { className: "text-[9px] font-bold tracking-widest text-amber-500 flex items-center gap-1 uppercase" },
+                                React.createElement(Check, { className: "w-3 h-3 text-amber-400" }),
+                                " Signed"),
+                            React.createElement("button", { disabled: isProcessing || ceremonyStatus === 'ESTABLISHED', onClick: () => handleRetract(signer.id), className: "px-2 py-1 bg-red-950/45 border border-red-900/40 hover:bg-red-900 hover:text-white text-red-400 text-[8px] font-bold uppercase rounded transition-colors disabled:opacity-50" }, "Retract"))) : (React.createElement("button", { disabled: isProcessing || ceremonyStatus === 'ESTABLISHED', onClick: () => handleSign(signer.id), className: "px-3 py-1.5 bg-gradient-to-r from-amber-500 to-yellow-600 hover:from-amber-400 hover:to-yellow-500 text-black text-[9px] font-bold uppercase rounded transition-all active:scale-95 disabled:opacity-50" }, "Sign Key")))));
+                })),
+                panicMessage && (React.createElement("div", { className: "w-full p-3 bg-red-950/40 border border-red-500/30 text-red-400 rounded-lg flex items-start gap-2" },
+                    React.createElement(ShieldAlert, { className: "w-4 h-4 shrink-0 mt-0.5" }),
+                    React.createElement("div", { className: "text-[9px] leading-relaxed uppercase" }, panicMessage))),
+                ceremonyStatus === 'ESTABLISHED' && (React.createElement("div", { className: "w-full p-3 bg-black/45 rounded-lg border border-white/5 flex flex-col gap-1 text-[9px] text-gray-400" },
+                    React.createElement("div", { className: "flex justify-between" },
+                        React.createElement("span", null, "Session Token:"),
+                        React.createElement("span", { className: "text-white font-bold" }, sessionToken)),
+                    React.createElement("div", { className: "flex justify-between" },
+                        React.createElement("span", null, "Validation Hash:"),
+                        React.createElement("span", { className: "text-amber-500 font-mono" }, "Attestation verified")),
+                    React.createElement("div", { className: "flex justify-between" },
+                        React.createElement("span", null, "Status:"),
+                        React.createElement("span", { className: "text-green-400 font-bold uppercase" }, "ESTABLISHED"))))),
+            React.createElement("div", { className: "px-6 py-4 border-t border-white/10 bg-black/40 flex items-center justify-between" },
+                React.createElement("div", { className: "flex items-center gap-1.5 text-[9px] text-gray-500 uppercase" },
+                    React.createElement(Activity, { className: "w-3.5 h-3.5 animate-pulse text-amber-500" }),
+                    React.createElement("span", null, "Mtls Handshake Active")),
+                React.createElement("div", { className: "flex gap-2" }, ceremonyStatus === 'ESTABLISHED' ? (React.createElement("button", { onClick: onClose, className: "px-4 py-2 bg-gray-900 hover:bg-gray-800 text-white border border-white/10 text-xs font-bold uppercase rounded transition-colors" }, "Close")) : (React.createElement(React.Fragment, null,
+                    React.createElement("button", { disabled: isProcessing, onClick: resetCeremony, className: "px-3 py-2 bg-transparent hover:bg-white/5 text-gray-400 hover:text-white text-xs font-bold uppercase rounded transition-colors" }, "Reset"),
+                    React.createElement("button", { disabled: isProcessing || signedCount < threshold, onClick: handleFinalize, className: `px-4 py-2 text-xs font-bold uppercase rounded transition-all active:scale-95 flex items-center gap-1.5 ${signedCount >= threshold
+                            ? 'bg-gradient-to-r from-amber-500 to-yellow-600 hover:from-amber-400 hover:to-yellow-500 text-black shadow-[0_0_15px_rgba(245,158,11,0.2)]'
+                            : 'bg-gray-900 text-gray-600 border border-gray-800 cursor-not-allowed'}` }, isProcessing ? 'Verifying...' : 'Finalize Seal'))))))));
+};

package/dist/components/SemanticConstellationMap.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+export interface SemanticConceptNode {
+    id: string;
+    label: string;
+    x: number;
+    y: number;
+    z: number;
+    group: string;
+    weight: number;
+}
+export interface SemanticConceptEdge {
+    source: string;
+    target: string;
+    strength: number;
+}
+export interface SemanticConstellationMapProps {
+    nodes: SemanticConceptNode[];
+    edges: SemanticConceptEdge[];
+    activeNodeId?: string;
+    onSelectNode?: (nodeId: string) => void;
+    className?: string;
+}
+export declare const SemanticConstellationMap: React.FC<SemanticConstellationMapProps>;

package/dist/components/SemanticConstellationMap.js

@@ -0,0 +1,273 @@
+// Copyright (c) 2026 CoReason, Inc.
+//
+// This software is proprietary and dual-licensed.
+// Licensed under the Prosperity Public License 3.0.
+import React, { useRef, useEffect, useState } from 'react';
+import { GlassBox, cn } from './GlassBox';
+// Map group names to beautiful sleek neon colors
+const GROUP_COLORS = {
+    alignment: '#00ffcc', // CoReason Accent Cyan
+    inference: '#a855f7', // Purple
+    sensory: '#f43f5e', // Rose
+    temporal: '#eab308', // Yellow
+    default: '#3b82f6', // Blue
+};
+export const SemanticConstellationMap = ({ nodes, edges, activeNodeId, onSelectNode, className, }) => {
+    const canvasRef = useRef(null);
+    const containerRef = useRef(null);
+    const angleRef = useRef(0);
+    const animationFrameIdRef = useRef(null);
+    const [hoveredNodeId, setHoveredNodeId] = useState(undefined);
+    const [dimensions, setDimensions] = useState({ width: 400, height: 350 });
+    // Handle container resizing to fit layout
+    useEffect(() => {
+        if (!containerRef.current)
+            return;
+        const resizeObserver = new ResizeObserver((entries) => {
+            for (const entry of entries) {
+                const { width, height } = entry.contentRect;
+                setDimensions({
+                    width: Math.max(width, 100),
+                    height: Math.max(height, 100),
+                });
+            }
+        });
+        resizeObserver.observe(containerRef.current);
+        return () => resizeObserver.disconnect();
+    }, []);
+    // Compute rotation & render projected coordinates
+    useEffect(() => {
+        const canvas = canvasRef.current;
+        if (!canvas)
+            return;
+        const ctx = canvas.getContext('2d');
+        if (!ctx)
+            return;
+        let isComponentActive = true;
+        const renderLoop = () => {
+            if (!isComponentActive)
+                return;
+            // Adjust rotation angle over time
+            angleRef.current += 0.003;
+            const angle = angleRef.current;
+            const cosA = Math.cos(angle);
+            const sinA = Math.sin(angle);
+            const { width, height } = dimensions;
+            // Clear canvas with deep space translucent black
+            ctx.fillStyle = '#080808';
+            ctx.fillRect(0, 0, width, height);
+            // Draw subtle space grid or background stars
+            ctx.strokeStyle = 'rgba(255, 255, 255, 0.02)';
+            ctx.lineWidth = 1;
+            const step = 40;
+            for (let x = 0; x < width; x += step) {
+                ctx.beginPath();
+                ctx.moveTo(x, 0);
+                ctx.lineTo(x, height);
+                ctx.stroke();
+            }
+            for (let y = 0; y < height; y += step) {
+                ctx.beginPath();
+                ctx.moveTo(0, y);
+                ctx.lineTo(width, y);
+                ctx.stroke();
+            }
+            const cameraDistance = 2.5;
+            const scale = Math.min(width, height) * 0.42;
+            // 1. Project all nodes into 2D space
+            const projectedNodes = nodes.map((node) => {
+                // Rotate about Y axis
+                const rx = node.x * cosA - node.z * sinA;
+                const ry = node.y;
+                const rz = node.x * sinA + node.z * cosA;
+                // Perspective scaling factor
+                const depthScale = 1.0 / (cameraDistance - rz);
+                const projX = width / 2 + rx * scale * depthScale;
+                const projY = height / 2 + ry * scale * depthScale;
+                return Object.assign(Object.assign({}, node), { projX,
+                    projY, projZ: rz, depthScale });
+            });
+            // 2. Sort nodes by depth (painter's algorithm: draw furthest first)
+            projectedNodes.sort((a, b) => a.projZ - b.projZ);
+            // Establish a lookup map for projected nodes
+            const projectedNodeMap = new Map();
+            for (const pNode of projectedNodes) {
+                projectedNodeMap.set(pNode.id, pNode);
+            }
+            // 3. Draw Cluster Nebulas (Group centers of gravity)
+            // Group nodes by cluster
+            const groups = Array.from(new Set(nodes.map(n => n.group)));
+            for (const group of groups) {
+                const groupNodes = projectedNodes.filter(n => n.group === group);
+                if (groupNodes.length === 0)
+                    continue;
+                // Calculate average projected position
+                let avgX = 0;
+                let avgY = 0;
+                let avgZ = 0;
+                for (const n of groupNodes) {
+                    avgX += n.projX;
+                    avgY += n.projY;
+                    avgZ += n.projZ;
+                }
+                avgX /= groupNodes.length;
+                avgY /= groupNodes.length;
+                avgZ /= groupNodes.length;
+                // Base nebula color
+                const baseColor = GROUP_COLORS[group] || GROUP_COLORS.default;
+                // Nebula size scales with depth and cluster weight sum
+                const groupWeight = groupNodes.reduce((sum, n) => sum + n.weight, 0);
+                const depthScale = 1.0 / (cameraDistance - avgZ);
+                const radius = Math.max(30, groupWeight * 20 * depthScale);
+                // Simulate radial gradient with concentric transparent circles
+                // to avoid using the forbidden radial gradient method
+                const preservedAlpha = ctx.globalAlpha;
+                const iterations = 8;
+                for (let i = 0; i < iterations; i++) {
+                    const ratio = (iterations - i) / iterations;
+                    const currentRadius = radius * ratio;
+                    ctx.beginPath();
+                    ctx.arc(avgX, avgY, currentRadius, 0, Math.PI * 2);
+                    ctx.fillStyle = baseColor;
+                    // Soft exponential opacity falloff
+                    ctx.globalAlpha = 0.015 * Math.pow(ratio, 2);
+                    ctx.fill();
+                }
+                ctx.globalAlpha = preservedAlpha;
+            }
+            // 4. Draw Edges (Associations)
+            for (const edge of edges) {
+                const sourceNode = projectedNodeMap.get(edge.source);
+                const targetNode = projectedNodeMap.get(edge.target);
+                if (!sourceNode || !targetNode)
+                    continue;
+                const averageDepthZ = (sourceNode.projZ + targetNode.projZ) / 2;
+                const depthFactor = (averageDepthZ + 1.0) / 2.0; // [0.0, 1.0] range
+                ctx.beginPath();
+                ctx.moveTo(sourceNode.projX, sourceNode.projY);
+                ctx.lineTo(targetNode.projX, targetNode.projY);
+                // Edge opacity maps to depth and strength
+                ctx.strokeStyle = '#333344';
+                ctx.globalAlpha = Math.max(0.05, 0.15 * edge.strength * depthFactor);
+                ctx.lineWidth = Math.max(0.5, 2.0 * edge.strength * depthFactor);
+                ctx.stroke();
+                ctx.globalAlpha = 1.0;
+            }
+            // 5. Draw Nodes & Labels
+            for (const pNode of projectedNodes) {
+                const isHovered = hoveredNodeId === pNode.id;
+                const isActive = activeNodeId === pNode.id;
+                const nodeColor = GROUP_COLORS[pNode.group] || GROUP_COLORS.default;
+                // Base particle radius based on depth and importance
+                const radius = Math.max(2, pNode.weight * 6 * pNode.depthScale);
+                // Highlight ring around active node
+                if (isActive) {
+                    ctx.beginPath();
+                    ctx.arc(pNode.projX, pNode.projY, radius * 2.2, 0, Math.PI * 2);
+                    ctx.strokeStyle = nodeColor;
+                    ctx.lineWidth = 1.5;
+                    ctx.globalAlpha = 0.4 + 0.2 * Math.sin(Date.now() / 150);
+                    ctx.stroke();
+                    ctx.globalAlpha = 1.0;
+                }
+                // Draw core node particle
+                ctx.beginPath();
+                ctx.arc(pNode.projX, pNode.projY, radius, 0, Math.PI * 2);
+                ctx.fillStyle = nodeColor;
+                // Add brightness for hovered or active nodes
+                if (isHovered || isActive) {
+                    ctx.shadowBlur = 12;
+                    ctx.shadowColor = nodeColor;
+                }
+                else {
+                    ctx.shadowBlur = 0;
+                }
+                ctx.fill();
+                ctx.shadowBlur = 0;
+                // Draw label text
+                const shouldShowLabel = isHovered || isActive || pNode.weight > 0.8;
+                if (shouldShowLabel) {
+                    ctx.fillStyle = isHovered ? '#ffffff' : 'rgba(255, 255, 255, 0.7)';
+                    ctx.font = `${Math.max(9, Math.round(11 * pNode.depthScale))}px monospace`;
+                    ctx.textAlign = 'left';
+                    ctx.textBaseline = 'middle';
+                    const textX = pNode.projX + radius + 6;
+                    const textY = pNode.projY;
+                    ctx.fillText(pNode.label, textX, textY);
+                    // Draw a small helper indicator for active/hovered node
+                    if (isHovered) {
+                        ctx.strokeStyle = 'rgba(255, 255, 255, 0.3)';
+                        ctx.lineWidth = 0.5;
+                        ctx.beginPath();
+                        ctx.moveTo(pNode.projX, pNode.projY);
+                        ctx.lineTo(textX - 2, textY);
+                        ctx.stroke();
+                    }
+                }
+            }
+            animationFrameIdRef.current = requestAnimationFrame(renderLoop);
+        };
+        renderLoop();
+        return () => {
+            isComponentActive = false;
+            if (animationFrameIdRef.current) {
+                cancelAnimationFrame(animationFrameIdRef.current);
+            }
+        };
+    }, [nodes, edges, activeNodeId, hoveredNodeId, dimensions]);
+    // Spatial mouse verification to identify hovered node
+    const handleMouseMove = (event) => {
+        const canvas = canvasRef.current;
+        if (!canvas)
+            return;
+        const rect = canvas.getBoundingClientRect();
+        const mouseX = event.clientX - rect.left;
+        const mouseY = event.clientY - rect.top;
+        const { width, height } = dimensions;
+        const cameraDistance = 2.5;
+        const scale = Math.min(width, height) * 0.42;
+        const angle = angleRef.current;
+        const cosA = Math.cos(angle);
+        const sinA = Math.sin(angle);
+        let closestNodeId = undefined;
+        let minDistance = 16.0; // Click proximity tolerance threshold in pixels
+        for (const node of nodes) {
+            // Apply exact projection to find projected coordinates
+            const rx = node.x * cosA - node.z * sinA;
+            const ry = node.y;
+            const rz = node.x * sinA + node.z * cosA;
+            const depthScale = 1.0 / (cameraDistance - rz);
+            const projX = width / 2 + rx * scale * depthScale;
+            const projY = height / 2 + ry * scale * depthScale;
+            const dist = Math.hypot(projX - mouseX, projY - mouseY);
+            if (dist < minDistance) {
+                minDistance = dist;
+                closestNodeId = node.id;
+            }
+        }
+        if (closestNodeId !== hoveredNodeId) {
+            setHoveredNodeId(closestNodeId);
+        }
+    };
+    // Proximity click handler
+    const handleCanvasClick = () => {
+        if (hoveredNodeId && onSelectNode) {
+            onSelectNode(hoveredNodeId);
+        }
+    };
+    return (React.createElement(GlassBox, { className: cn('relative flex flex-col min-h-[300px]', className), variant: "black" },
+        React.createElement("div", { className: "flex justify-between items-center border-b border-gray-800 pb-2 mb-2 font-mono" },
+            React.createElement("div", null,
+                React.createElement("h3", { className: "text-xs font-semibold text-white tracking-widest uppercase" }, "Belief Constellation Map"),
+                React.createElement("span", { className: "text-[9px] text-gray-500 uppercase" }, "High-Dimensional Concept Topology")),
+            activeNodeId && (React.createElement("div", { className: "text-[9px] text-[var(--cr-accent-cyan)] font-mono uppercase bg-emerald-950/40 border border-emerald-900/60 px-2 py-0.5 rounded" }, "Target Focus Active"))),
+        React.createElement("div", { ref: containerRef, className: "relative flex-grow w-full h-full overflow-hidden bg-black/40 rounded border border-gray-900" },
+            React.createElement("canvas", { ref: canvasRef, width: dimensions.width, height: dimensions.height, onMouseMove: handleMouseMove, onClick: handleCanvasClick, className: "block cursor-crosshair" }),
+            React.createElement("div", { className: "absolute bottom-2 left-2 pointer-events-none font-mono text-[8px] text-gray-600 uppercase flex flex-col space-y-0.5" },
+                React.createElement("span", null, "Projection: Perspective (Y-Rot)"),
+                React.createElement("span", null,
+                    "Nodes: ",
+                    nodes.length,
+                    " | Edges: ",
+                    edges.length)))));
+};

package/dist/components/TemporalScrubber.d.ts

@@ -9,8 +9,11 @@ export interface TemporalScrubberProps {
     minRange: number;
     maxRange: number;
     forks?: TemporalFork[];
+    activeForkId?: string;
     onScrub: (newTime: number) => void;
     onForkSelect?: (forkId: string) => void;
+    onForkInitiate?: (branchPoint: number) => void;
+    onForkClose?: (forkId: string) => void;
     className?: string;
 }
 export declare const TemporalScrubber: React.FC<TemporalScrubberProps>;

package/dist/components/TemporalScrubber.js

@@ -10,11 +10,13 @@
 import React from 'react';
 import { motion } from 'framer-motion';
 import { cn } from './GlassBox';
-export const TemporalScrubber = ({ timestamp, minRange, maxRange, forks = [], onScrub, onForkSelect, className }) => {
+export const TemporalScrubber = ({ timestamp, minRange, maxRange, forks = [], activeForkId, onScrub, onForkSelect, onForkInitiate, onForkClose, className }) => {
     const getPercentage = (val) => ((val - minRange) / (maxRange - minRange)) * 100;
     return (React.createElement("div", { className: cn('flex flex-col items-stretch gap-4 p-4 bg-[var(--cr-glass-box-black)] rounded-xl border border-gray-800', className) },
         React.createElement("div", { className: "flex justify-between items-center mb-2" },
-            React.createElement("span", { className: "text-white uppercase tracking-widest text-xs font-bold" }, "Temporal Navigation"),
+            React.createElement("div", { className: "flex items-center gap-3" },
+                React.createElement("span", { className: "text-white uppercase tracking-widest text-xs font-bold" }, "Temporal Navigation"),
+                onForkInitiate && (React.createElement("button", { onClick: () => onForkInitiate(timestamp), className: "px-2 py-0.5 bg-purple-950/60 border border-purple-500/50 hover:bg-purple-900/60 text-purple-300 text-[10px] font-mono rounded transition-all uppercase tracking-wider font-bold" }, "Fork Timeline"))),
             React.createElement("span", { className: "text-[var(--cr-accent-cyan)] font-mono text-xs" },
                 "T - ",
                 Math.floor((Date.now() - timestamp) / 1000),
@@ -25,11 +27,21 @@ export const TemporalScrubber = ({ timestamp, minRange, maxRange, forks = [], on
             forks.map((fork, idx) => {
                 const startPct = getPercentage(fork.branchPoint);
                 const topOffset = idx % 2 === 0 ? 0 : 16;
-                return (React.createElement(motion.div, { key: fork.id, initial: { opacity: 0 }, animate: { opacity: 1 }, className: "absolute h-1 bg-[var(--cr-accent-orange)] cursor-pointer group", style: { left: `${startPct}%`, top: topOffset, width: `calc(100% - ${startPct}%)` }, onClick: () => onForkSelect === null || onForkSelect === void 0 ? void 0 : onForkSelect(fork.id) },
-                    React.createElement("div", { className: "absolute -left-1 -top-1 w-3 h-3 rounded-full bg-[var(--cr-accent-orange)]" }),
-                    React.createElement("div", { className: "absolute -top-6 left-0 opacity-0 group-hover:opacity-100 transition-opacity bg-black text-[var(--cr-accent-orange)] text-[10px] font-mono px-2 py-1 rounded" },
-                        "\u2443 ",
-                        fork.name)));
+                const isActive = activeForkId === fork.id;
+                return (React.createElement(motion.div, { key: fork.id, initial: { opacity: 0 }, animate: { opacity: 1 }, className: cn("absolute h-1 cursor-pointer group transition-all duration-300", isActive
+                        ? "bg-purple-500 shadow-[0_0_8px_rgba(168,85,247,0.8)] z-20"
+                        : "bg-[var(--cr-accent-orange)] z-10"), style: { left: `${startPct}%`, top: topOffset, width: `calc(100% - ${startPct}%)` }, onClick: () => onForkSelect === null || onForkSelect === void 0 ? void 0 : onForkSelect(fork.id) },
+                    React.createElement("div", { className: cn("absolute -left-1 -top-1 w-3 h-3 rounded-full transition-all duration-300", isActive ? "bg-purple-400 scale-125" : "bg-[var(--cr-accent-orange)]") }),
+                    React.createElement("div", { className: cn("absolute -top-6 left-0 transition-opacity bg-black text-[10px] font-mono px-2 py-1 rounded flex items-center gap-1.5 whitespace-nowrap", isActive
+                            ? "opacity-100 text-purple-300 border border-purple-500/30"
+                            : "opacity-0 group-hover:opacity-100 text-[var(--cr-accent-orange)]") },
+                        React.createElement("span", null,
+                            "\u2443 ",
+                            fork.name),
+                        onForkClose && (React.createElement("button", { onClick: (e) => {
+                                e.stopPropagation();
+                                onForkClose(fork.id);
+                            }, className: "hover:text-white text-xs ml-1 focus:outline-none font-bold", title: "Dismiss Fork" }, "\u00D7")))));
             }),
             React.createElement("input", { type: "range", min: minRange, max: maxRange, value: timestamp, onChange: (e) => onScrub(Number(e.target.value)), className: "absolute top-[26px] w-full cursor-ew-resize opacity-0 z-10" }),
             React.createElement(motion.div, { className: "absolute top-6 w-5 h-5 rounded-full bg-white border-2 border-[var(--cr-accent-cyan)] shadow-[0_0_10px_var(--cr-accent-cyan)] pointer-events-none", style: { left: `calc(${getPercentage(timestamp)}% - 10px)` }, layout: true }))));

package/dist/index.d.ts

@@ -23,3 +23,9 @@ export { EpistemicDeficitRadar } from './components/EpistemicDeficitRadar';
 export type { EpistemicDeficitRadarProps } from './components/EpistemicDeficitRadar';
 export { WasmSandboxCagingHud } from './components/WasmSandboxCagingHud';
 export type { WasmSandboxCagingHudProps, SandboxHardwareTelemetry, AttestationReceipt } from './components/WasmSandboxCagingHud';
+export { KeysigningCeremonyModal } from './components/KeysigningCeremonyModal';
+export type { KeysigningCeremonyModalProps, SignerProfile, DelegatedAttestationReceipt } from './components/KeysigningCeremonyModal';
+export { DlpParticleShield } from './components/DlpParticleShield';
+export type { DlpParticleShieldProps } from './components/DlpParticleShield';
+export { SemanticConstellationMap } from './components/SemanticConstellationMap';
+export type { SemanticConstellationMapProps, SemanticConceptNode, SemanticConceptEdge } from './components/SemanticConstellationMap';

package/dist/index.js

@@ -29,3 +29,6 @@ export { DynamicToposRenderer } from './components/DynamicToposRenderer';
 export { SpeculativeTreeRenderer } from './components/SpeculativeTreeRenderer';
 export { EpistemicDeficitRadar } from './components/EpistemicDeficitRadar';
 export { WasmSandboxCagingHud } from './components/WasmSandboxCagingHud';
+export { KeysigningCeremonyModal } from './components/KeysigningCeremonyModal';
+export { DlpParticleShield } from './components/DlpParticleShield';
+export { SemanticConstellationMap } from './components/SemanticConstellationMap';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coreason-ai/sensory-core",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Topos-Theoretic UI primitive library for the CoReason Cybernetic Manifold. Stateless, hollow React components that project coreason-manifest Pydantic ASTs into the DOM.",
   "license": "Prosperity-3.0",
   "author": "CoReason, Inc. <info@coreason.ai>",