khal-os 1.260324.2

package/src/components/apps/dev3000/Dev3000App.tsx

@@ -0,0 +1,224 @@
+'use client';
+
+import { AlertTriangle, Clock, Filter, Pause, Play, Trash2 } from 'lucide-react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { SplitPane, StatusBar, Toolbar } from '@/components/os-primitives';
+import { SidebarNav } from '@/components/os-primitives/sidebar-nav';
+import { useNats } from '@/lib/hooks/use-nats';
+import { SUBJECTS } from '@/lib/subjects';
+import type { Dev3000ContextValue } from './dev3000-context';
+import { Dev3000Context } from './dev3000-context';
+import { ErrorsPanel } from './ErrorsPanel';
+import { Sidebar } from './Sidebar';
+import { TimelineLog } from './TimelineLog';
+import type { D3kLogEntry, D3kSource, D3kTab } from './types';
+import { useMessageBuffer } from './use-message-buffer';
+
+export function Dev3000App(_props: { windowId: string; meta?: Record<string, unknown> }) {
+	const [activeTab, setActiveTab] = useState<D3kTab>('timeline');
+	const [paused, setPaused] = useState(false);
+	const [filter, setFilter] = useState('');
+	const [sourceFilter, setSourceFilter] = useState<D3kSource | 'ALL'>('ALL');
+
+	const { connected, subscribe, request, orgId } = useNats();
+	const buffer = useMessageBuffer();
+
+	// Stable ref for buffer.push so the subscribe callback never goes stale
+	const pushRef = useRef(buffer.push);
+	pushRef.current = buffer.push;
+	const pausedRef = useRef(paused);
+	pausedRef.current = paused;
+
+	const [d3kRunning, setD3kRunning] = useState(false);
+
+	// Subscribe to d3k.log, then request replay of buffered entries
+	useEffect(() => {
+		if (!orgId || !connected) return;
+
+		// 1. Subscribe first
+		const subject = SUBJECTS.d3k.log(orgId);
+		const unsub = subscribe(subject, (data: unknown) => {
+			if (pausedRef.current) return;
+			try {
+				const entry = data as D3kLogEntry;
+				if (entry.id && entry.message) {
+					pushRef.current(entry);
+				}
+			} catch {
+				// ignore malformed entries
+			}
+		});
+
+		// 2. Then request status — response includes buffered entries (targeted to this client only)
+		const timer = setTimeout(() => {
+			request(SUBJECTS.d3k.status(orgId), {}, 5_000)
+				.then((result) => {
+					const status = result as { d3kRunning?: boolean; entries?: D3kLogEntry[] };
+					if (status.d3kRunning !== undefined) setD3kRunning(status.d3kRunning);
+					if (status.entries && !pausedRef.current) {
+						for (const entry of status.entries) {
+							pushRef.current(entry);
+						}
+					}
+				})
+				.catch(() => {
+					// service may not be running yet
+				});
+		}, 100);
+
+		return () => {
+			unsub();
+			clearTimeout(timer);
+		};
+	}, [orgId, connected, subscribe, request]);
+
+	// Run d3k command via NATS request
+	const runCommand = useCallback(
+		async (command: string, args?: string[]) => {
+			if (!orgId) return { ok: false, error: 'Not connected' };
+			const subject = SUBJECTS.d3k.cmd(orgId);
+			try {
+				const result = (await request(subject, { command, args }, 20_000)) as {
+					ok: boolean;
+					output?: string;
+					error?: string;
+				};
+				return result;
+			} catch (err) {
+				return { ok: false, error: (err as Error).message };
+			}
+		},
+		[orgId, request]
+	);
+
+	// Filtered count
+	const filteredCount = useMemo(() => {
+		let result = buffer.entries;
+		if (sourceFilter !== 'ALL') {
+			result = result.filter((e) => e.source === sourceFilter);
+		}
+		if (filter) {
+			const lower = filter.toLowerCase();
+			result = result.filter((e) => e.message.toLowerCase().includes(lower));
+		}
+		return result.length;
+	}, [buffer.entries, filter, sourceFilter]);
+
+	const countLabel =
+		filter || sourceFilter !== 'ALL'
+			? `${filteredCount}/${buffer.entries.length} entries`
+			: `${buffer.entries.length} entries`;
+
+	// Context value
+	const ctxValue = useMemo<Dev3000ContextValue>(
+		() => ({
+			buffer,
+			filter,
+			setFilter,
+			sourceFilter,
+			setSourceFilter,
+			paused,
+			setPaused,
+			activeTab,
+			setActiveTab,
+			runCommand,
+		}),
+		[buffer, filter, sourceFilter, paused, activeTab, runCommand]
+	);
+
+	return (
+		<Dev3000Context.Provider value={ctxValue}>
+			<div className="flex h-full flex-col bg-background-100">
+				<div className="flex-1 overflow-hidden">
+					<SplitPane defaultSize={200} min={160} max={300} collapseBelow={400}>
+						{/* ---- Sidebar ---- */}
+						<SplitPane.Panel className="bg-gray-alpha-50">
+							<SidebarNav label="dev3000" title="dev3000">
+								<SidebarNav.Group title="Views">
+									<SidebarNav.Item
+										active={activeTab === 'timeline'}
+										onClick={() => setActiveTab('timeline')}
+										icon={<Clock />}
+									>
+										Timeline
+									</SidebarNav.Item>
+									<SidebarNav.Item
+										active={activeTab === 'errors'}
+										onClick={() => setActiveTab('errors')}
+										icon={<AlertTriangle />}
+									>
+										Errors
+									</SidebarNav.Item>
+								</SidebarNav.Group>
+							</SidebarNav>
+
+							{/* Source filter panel */}
+							<div className="flex-1 overflow-y-auto border-t border-gray-alpha-200 p-3">
+								<Sidebar />
+							</div>
+						</SplitPane.Panel>
+
+						{/* ---- Main area ---- */}
+						<SplitPane.Panel>
+							<div className="flex h-full flex-col">
+								{/* Toolbar — only for timeline tab */}
+								{activeTab === 'timeline' && (
+									<Toolbar>
+										<Toolbar.Group>
+											<Toolbar.Button
+												tooltip={paused ? 'Resume' : 'Pause'}
+												onClick={() => setPaused(!paused)}
+												active={paused}
+											>
+												{paused ? <Play /> : <Pause />}
+											</Toolbar.Button>
+											<Toolbar.Button tooltip="Clear log" onClick={() => buffer.clear()}>
+												<Trash2 />
+											</Toolbar.Button>
+										</Toolbar.Group>
+										<Toolbar.Separator />
+										<Toolbar.Group>
+											<Toolbar.Button tooltip="Filter">
+												<Filter />
+											</Toolbar.Button>
+										</Toolbar.Group>
+										<Toolbar.Input
+											placeholder="Filter by message..."
+											value={filter}
+											onChange={(e) => setFilter(e.target.value)}
+										/>
+										<Toolbar.Spacer />
+										<Toolbar.Text>{countLabel}</Toolbar.Text>
+									</Toolbar>
+								)}
+
+								{/* Content */}
+								<div className="flex-1 overflow-hidden">
+									{activeTab === 'timeline' && (
+										<TimelineLog entries={buffer.entries} filter={filter} sourceFilter={sourceFilter} paused={paused} />
+									)}
+									{activeTab === 'errors' && <ErrorsPanel />}
+								</div>
+							</div>
+						</SplitPane.Panel>
+					</SplitPane>
+				</div>
+
+				{/* Status bar */}
+				<StatusBar>
+					<StatusBar.Item>dev3000</StatusBar.Item>
+					<StatusBar.Separator />
+					<StatusBar.Item>{countLabel}</StatusBar.Item>
+					<StatusBar.Spacer />
+					<StatusBar.Item variant={d3kRunning ? 'success' : 'default'}>
+						{d3kRunning ? 'd3k running' : 'd3k stopped'}
+					</StatusBar.Item>
+					<StatusBar.Separator />
+					<StatusBar.Item variant={connected ? 'success' : 'default'}>
+						{connected ? 'connected' : 'disconnected'}
+					</StatusBar.Item>
+				</StatusBar>
+			</div>
+		</Dev3000Context.Provider>
+	);
+}

package/src/components/apps/dev3000/ErrorsPanel.tsx

@@ -0,0 +1,160 @@
+'use client';
+
+import { AlertTriangle, CheckCircle, Loader2, RefreshCw } from 'lucide-react';
+import { useCallback, useState } from 'react';
+import { EmptyState } from '@/components/os-primitives/empty-state';
+import { useDev3000 } from './dev3000-context';
+
+type ErrorsState = 'idle' | 'loading' | 'success' | 'error';
+
+interface D3kErrorsResponse {
+	total: number;
+	showing: number;
+	errors: string[];
+}
+
+interface ParsedError {
+	key: string;
+	time: string;
+	source: string;
+	message: string;
+}
+
+// Parse d3k log line: "[HH:mm:ss.SSS] [SOURCE] [TAG] message"
+const LOG_LINE_RE = /^\[(\d{2}:\d{2}:\d{2}\.\d{3})]\s+\[(\w+)]\s+(.*)$/;
+
+function parseErrors(raw: string): { errors: ParsedError[]; total: number } {
+	try {
+		const parsed: D3kErrorsResponse = JSON.parse(raw);
+		const errors = (parsed.errors || []).map((line, i) => {
+			const match = line.match(LOG_LINE_RE);
+			if (match) {
+				return { key: `${match[1]}-${i}`, time: match[1], source: match[2], message: match[3] };
+			}
+			return { key: `raw-${i}`, time: '', source: '', message: line };
+		});
+		return { errors, total: parsed.total || 0 };
+	} catch {
+		return { errors: [{ key: 'raw-0', time: '', source: '', message: raw }], total: 0 };
+	}
+}
+
+function ErrorRow({ error }: { error: ParsedError }) {
+	return (
+		<div className="px-3 py-2 text-[11px] transition-colors hover:bg-gray-alpha-50">
+			<div className="flex items-baseline gap-2">
+				{error.time && <span className="shrink-0 font-mono text-gray-600">{error.time}</span>}
+				{error.source && (
+					<span className="shrink-0 rounded bg-red-500/10 px-1 py-0.5 font-mono text-[9px] font-semibold text-red-600">
+						{error.source}
+					</span>
+				)}
+			</div>
+			<p className="mt-0.5 font-mono leading-4 text-gray-1000">{error.message}</p>
+		</div>
+	);
+}
+
+export function ErrorsPanel() {
+	const { runCommand } = useDev3000();
+	const [state, setState] = useState<ErrorsState>('idle');
+	const [errors, setErrors] = useState<ParsedError[]>([]);
+	const [total, setTotal] = useState(0);
+	const [errorMsg, setErrorMsg] = useState('');
+
+	const fetchErrors = useCallback(async () => {
+		setState('loading');
+		setErrors([]);
+		setErrorMsg('');
+		const result = await runCommand('errors').catch((err) => ({
+			ok: false as const,
+			error: (err as Error).message,
+			output: undefined as string | undefined,
+		}));
+		if (result.ok && result.output) {
+			const parsed = parseErrors(result.output);
+			setErrors(parsed.errors);
+			setTotal(parsed.total);
+			setState('success');
+		} else if (result.ok) {
+			setErrors([]);
+			setState('success');
+		} else {
+			setState('error');
+			setErrorMsg(result.error || 'Failed to fetch errors.');
+		}
+	}, [runCommand]);
+
+	return (
+		<div className="flex h-full flex-col">
+			{/* Header with refresh */}
+			<div className="flex items-center gap-2 border-b border-gray-alpha-200 px-3 py-2">
+				<AlertTriangle className="h-4 w-4 text-red-500" />
+				<span className="text-label-13 font-medium text-gray-1000">Errors</span>
+				{state === 'success' && <span className="text-[11px] text-gray-600">{total} total</span>}
+				<button
+					type="button"
+					onClick={fetchErrors}
+					disabled={state === 'loading'}
+					className="ml-auto flex items-center gap-1 rounded px-2 py-1 text-[11px] font-medium text-gray-800 transition-colors hover:bg-gray-alpha-200 disabled:opacity-50"
+				>
+					{state === 'loading' ? <Loader2 className="h-3 w-3 animate-spin" /> : <RefreshCw className="h-3 w-3" />}
+					{state === 'loading' ? 'Fetching...' : 'Refresh'}
+				</button>
+			</div>
+
+			{/* Content */}
+			<div className="flex-1 overflow-auto">
+				{state === 'idle' && (
+					<div className="p-3">
+						<EmptyState
+							title="Click to fetch errors"
+							description="Run d3k errors to see recent browser and server errors."
+							action={
+								<button
+									type="button"
+									onClick={fetchErrors}
+									className="rounded bg-red-500 px-3 py-1.5 text-xs font-medium text-white transition-colors hover:bg-red-600"
+								>
+									Fetch Errors
+								</button>
+							}
+						/>
+					</div>
+				)}
+
+				{state === 'loading' && (
+					<div className="flex h-32 items-center justify-center">
+						<Loader2 className="h-5 w-5 animate-spin text-gray-600" />
+					</div>
+				)}
+
+				{state === 'success' && errors.length === 0 && (
+					<div className="p-3">
+						<EmptyState
+							title="No errors"
+							description="No recent errors found in the d3k session."
+							icon={<CheckCircle className="h-8 w-8 text-green-500" />}
+						/>
+					</div>
+				)}
+
+				{state === 'success' && errors.length > 0 && (
+					<div className="divide-y divide-gray-alpha-100">
+						{errors.map((error) => (
+							<ErrorRow key={error.key} error={error} />
+						))}
+					</div>
+				)}
+
+				{state === 'error' && (
+					<div className="p-3">
+						<div className="rounded border border-red-200 bg-red-50 p-3">
+							<p className="font-mono text-[11px] text-red-600">{errorMsg}</p>
+						</div>
+					</div>
+				)}
+			</div>
+		</div>
+	);
+}

package/src/components/apps/dev3000/Sidebar.tsx

@@ -0,0 +1,41 @@
+'use client';
+
+import { useDev3000 } from './dev3000-context';
+import type { D3kSource } from './types';
+
+const SOURCES: Array<{ label: string; value: D3kSource | 'ALL' }> = [
+	{ label: 'ALL', value: 'ALL' },
+	{ label: 'SRV', value: 'SERVER' },
+	{ label: 'BRW', value: 'BROWSER' },
+	{ label: 'NET', value: 'NETWORK' },
+	{ label: 'D3K', value: 'D3K' },
+];
+
+export function Sidebar() {
+	const { sourceFilter, setSourceFilter } = useDev3000();
+
+	return (
+		<div className="flex flex-col gap-3 overflow-y-auto">
+			{/* Source filter */}
+			<div>
+				<h3 className="mb-1.5 text-[11px] font-medium uppercase tracking-wider text-gray-700">Source</h3>
+				<div className="flex flex-wrap gap-1.5">
+					{SOURCES.map(({ label, value }) => (
+						<button
+							key={value}
+							type="button"
+							onClick={() => setSourceFilter(value)}
+							className={`rounded px-2 py-1 text-[11px] font-medium transition-colors ${
+								sourceFilter === value
+									? 'bg-blue-600 text-white'
+									: 'bg-gray-alpha-100 text-gray-900 hover:bg-gray-alpha-200'
+							}`}
+						>
+							{label}
+						</button>
+					))}
+				</div>
+			</div>
+		</div>
+	);
+}

package/src/components/apps/dev3000/TimelineLog.tsx

@@ -0,0 +1,173 @@
+'use client';
+
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { EmptyState } from '@/components/os-primitives/empty-state';
+import type { D3kLogEntry, D3kSource } from './types';
+
+// ---------------------------------------------------------------------------
+// Source badge colors
+// ---------------------------------------------------------------------------
+
+const SOURCE_STYLES: Record<D3kSource, string> = {
+	SERVER: 'bg-blue-500/15 text-blue-600',
+	BROWSER: 'bg-amber-500/15 text-amber-600',
+	NETWORK: 'bg-green-500/15 text-green-600',
+	D3K: 'bg-purple-500/15 text-purple-600',
+	UNKNOWN: 'bg-gray-500/15 text-gray-600',
+};
+
+const LEVEL_TEXT: Record<string, string> = {
+	error: 'text-red-500',
+	warn: 'text-amber-500',
+	info: 'text-gray-1000',
+	debug: 'text-gray-600',
+};
+
+// ---------------------------------------------------------------------------
+// Time formatting
+// ---------------------------------------------------------------------------
+
+function formatTimestamp(ts: number): string {
+	const d = new Date(ts);
+	const h = String(d.getHours()).padStart(2, '0');
+	const m = String(d.getMinutes()).padStart(2, '0');
+	const s = String(d.getSeconds()).padStart(2, '0');
+	const ms = String(d.getMilliseconds()).padStart(3, '0');
+	return `${h}:${m}:${s}.${ms}`;
+}
+
+// ---------------------------------------------------------------------------
+// LogRow
+// ---------------------------------------------------------------------------
+
+function LogRow({ entry, index }: { entry: D3kLogEntry; index: number }) {
+	const [expanded, setExpanded] = useState(false);
+
+	return (
+		<div>
+			<button
+				type="button"
+				onClick={() => setExpanded(!expanded)}
+				className={`flex w-full items-baseline gap-2 px-2 py-0.5 text-left text-[11px] leading-5 transition-colors hover:bg-gray-alpha-200 ${
+					index % 2 === 0 ? 'bg-transparent' : 'bg-gray-alpha-50'
+				}`}
+			>
+				{/* Timestamp */}
+				<span className="shrink-0 font-mono text-gray-700">{formatTimestamp(entry.timestamp)}</span>
+
+				{/* Source badge */}
+				<span
+					className={`shrink-0 rounded px-1 py-0.5 font-mono text-[9px] font-semibold ${SOURCE_STYLES[entry.source]}`}
+				>
+					{entry.source}
+				</span>
+
+				{/* Sub-tag badge */}
+				{entry.tag && (
+					<span className="shrink-0 rounded bg-gray-alpha-100 px-1 py-0.5 font-mono text-[9px] text-gray-700">
+						{entry.tag}
+					</span>
+				)}
+
+				{/* Message */}
+				<span className={`min-w-0 truncate font-mono ${LEVEL_TEXT[entry.level] || 'text-gray-1000'}`}>
+					{entry.message}
+				</span>
+			</button>
+
+			{/* Expanded detail */}
+			{expanded && (
+				<div className="mx-2 mb-1 rounded border border-gray-alpha-200 bg-gray-alpha-50 p-2">
+					<pre className="overflow-auto whitespace-pre-wrap break-all font-mono text-[11px] leading-4 text-gray-1000">
+						{entry.message}
+					</pre>
+					<div className="mt-1 flex gap-2 text-[10px] text-gray-600">
+						<span>Source: {entry.source}</span>
+						<span>Level: {entry.level}</span>
+						<span>ID: {entry.id}</span>
+					</div>
+				</div>
+			)}
+		</div>
+	);
+}
+
+// ---------------------------------------------------------------------------
+// TimelineLog
+// ---------------------------------------------------------------------------
+
+interface TimelineLogProps {
+	entries: D3kLogEntry[];
+	filter: string;
+	sourceFilter: D3kSource | 'ALL';
+	paused: boolean;
+}
+
+export function TimelineLog({ entries, filter, sourceFilter, paused }: TimelineLogProps) {
+	const containerRef = useRef<HTMLDivElement>(null);
+	const wasAtBottomRef = useRef(true);
+	const prevEntryCountRef = useRef(0);
+
+	const filtered = useMemo(() => {
+		let result = entries;
+		if (sourceFilter !== 'ALL') {
+			result = result.filter((e) => e.source === sourceFilter);
+		}
+		if (filter) {
+			const lower = filter.toLowerCase();
+			result = result.filter((e) => e.message.toLowerCase().includes(lower));
+		}
+		return result;
+	}, [entries, filter, sourceFilter]);
+
+	const handleScroll = () => {
+		const el = containerRef.current;
+		if (!el) return;
+		const threshold = 30;
+		wasAtBottomRef.current = el.scrollHeight - el.scrollTop - el.clientHeight < threshold;
+	};
+
+	useEffect(() => {
+		const el = containerRef.current;
+		if (!el) return;
+		const hasNewEntries = filtered.length > prevEntryCountRef.current;
+		prevEntryCountRef.current = filtered.length;
+		if (!paused && hasNewEntries && wasAtBottomRef.current) {
+			el.scrollTop = el.scrollHeight;
+		}
+	}, [filtered.length, paused]);
+
+	useEffect(() => {
+		if (!paused) {
+			const el = containerRef.current;
+			if (el) {
+				el.scrollTop = el.scrollHeight;
+				wasAtBottomRef.current = true;
+			}
+		}
+	}, [paused]);
+
+	if (filtered.length === 0 && !filter && sourceFilter === 'ALL') {
+		return (
+			<div className="flex h-full items-center justify-center">
+				<EmptyState title="No log entries yet" description="Waiting for dev3000 to produce log output..." />
+			</div>
+		);
+	}
+
+	if (filtered.length === 0) {
+		return (
+			<div className="flex h-full items-center justify-center">
+				<EmptyState title="No matching entries" description="Try adjusting your filter or source selection." />
+			</div>
+		);
+	}
+
+	return (
+		<div ref={containerRef} className="h-full overflow-auto" onScroll={handleScroll}>
+			{filtered.map((entry, i) => (
+				<LogRow key={entry.id} entry={entry} index={i} />
+			))}
+		</div>
+	);
+}

package/src/components/apps/dev3000/dev3000-context.tsx

@@ -0,0 +1,29 @@
+'use client';
+
+import { createContext, useContext } from 'react';
+import type { D3kLogEntry, D3kSource, D3kTab } from './types';
+
+export interface Dev3000ContextValue {
+	buffer: {
+		entries: D3kLogEntry[];
+		push: (entry: D3kLogEntry) => void;
+		clear: () => void;
+	};
+	filter: string;
+	setFilter: (f: string) => void;
+	sourceFilter: D3kSource | 'ALL';
+	setSourceFilter: (s: D3kSource | 'ALL') => void;
+	paused: boolean;
+	setPaused: (p: boolean) => void;
+	activeTab: D3kTab;
+	setActiveTab: (t: D3kTab) => void;
+	runCommand: (command: string, args?: string[]) => Promise<{ ok: boolean; output?: string; error?: string }>;
+}
+
+export const Dev3000Context = createContext<Dev3000ContextValue | null>(null);
+
+export function useDev3000(): Dev3000ContextValue {
+	const ctx = useContext(Dev3000Context);
+	if (!ctx) throw new Error('useDev3000 must be used within <Dev3000App>');
+	return ctx;
+}

package/src/components/apps/dev3000/index.ts

@@ -0,0 +1,4 @@
+export { Dev3000App } from './Dev3000App';
+export type { Dev3000ContextValue } from './dev3000-context';
+export { useDev3000 } from './dev3000-context';
+export type { D3kLogEntry, D3kSource, D3kTab } from './types';

package/src/components/apps/dev3000/schema.ts

@@ -0,0 +1,48 @@
+import { type Static, Type } from '@sinclair/typebox';
+
+// --- Log entry published by the service ---
+
+export const D3kLogEntrySchema = Type.Object({
+	id: Type.String(),
+	timestamp: Type.Number(),
+	source: Type.Union([
+		Type.Literal('SERVER'),
+		Type.Literal('BROWSER'),
+		Type.Literal('NETWORK'),
+		Type.Literal('D3K'),
+		Type.Literal('UNKNOWN'),
+	]),
+	level: Type.Union([Type.Literal('info'), Type.Literal('warn'), Type.Literal('error'), Type.Literal('debug')]),
+	message: Type.String(),
+	tag: Type.Optional(Type.String()),
+});
+export type D3kLogEntrySchema = Static<typeof D3kLogEntrySchema>;
+
+// --- Command request/response ---
+
+export const D3kCmdRequest = Type.Object({
+	command: Type.String(), // e.g. 'errors', 'logs', 'fix'
+	args: Type.Optional(Type.Array(Type.String())),
+});
+export type D3kCmdRequest = Static<typeof D3kCmdRequest>;
+
+export const D3kCmdResponse = Type.Object({
+	ok: Type.Boolean(),
+	output: Type.Optional(Type.String()),
+	error: Type.Optional(Type.String()),
+});
+export type D3kCmdResponse = Static<typeof D3kCmdResponse>;
+
+// --- Status request/response ---
+
+export const D3kStatusRequest = Type.Object({});
+export type D3kStatusRequest = Static<typeof D3kStatusRequest>;
+
+export const D3kStatusResponse = Type.Object({
+	d3kRunning: Type.Boolean(),
+	lineCount: Type.Number(),
+	version: Type.String(),
+	uptime: Type.Number(),
+	entries: Type.Optional(Type.Array(D3kLogEntrySchema)),
+});
+export type D3kStatusResponse = Static<typeof D3kStatusResponse>;