// Send message
{ type: "message", content: string, channel: string }

// Typing indicator
{ type: "typing", channel: string, typing: boolean }

// Join/leave channel
{ type: "join", channel: string }
{ type: "leave", channel: string }

// Keepalive
{ type: "ping" }

// New message
{ 
  type: "message", 
  id: string, 
  sender: string,        // user_id
  content: string, 
  channel: string, 
  timestamp: string      // ISO8601
}

// Presence update
{ 
  type: "presence", 
  user_id: string, 
  online: boolean, 
  channel: string 
}

// Typing indicator
{ 
  type: "typing", 
  user_id: string, 
  channel: string, 
  typing: boolean 
}

// Keepalive response
{ type: "pong" }

// Error
{ type: "error", code: string, message: string }

// POST /api/v1/upload response
interface UploadResponse {
  id: string;
  url: string;           // Download URL
  thumbnail_url: string; // Thumbnail URL (if applicable)
  sha256: string;        // Content hash
  size_bytes: number;
}

GET /api/auth/get-session
Headers: Cookie: better-auth.session_token=<token>

Response (200):
{
  "user": {
    "id": string,
    "email": string,
    "name": string,
    "image": string | null,
    "role": "admin" | "member" | "child",
    "emailVerified": boolean,
    "banned": boolean,
    "createdAt": string,
    "updatedAt": string
  },
  "session": {
    "id": string,
    "userId": string,
    "expiresAt": string,
    "ipAddress": string,
    "userAgent": string
  }
}

Response (401):
{ "user": null, "session": null }

trustedOrigins: [
  'https://casa.devarno.cloud',
  'https://*.devarno.cloud',
  ...(process.env.NODE_ENV === 'development' ? ['http://localhost:3000'] : []),
]

cd proto-contracts
buf generate

interface ListResponse {
  success: boolean;
  data: Array<{
    title: string;           // Org name (e.g., "sparki-tools")
    slug: string;            // URL-safe identifier
    cluster: string;         // Always "devarno-orgs"
    _meta: {
      external_id: string;   // GitHub URL
      last_synced: string;   // ISO8601 timestamp
    };
    // raw_data fields spread into response:
    url: string;             // GitHub org URL
    website: string;         // Official website
    description: string;     // Short description
    stack: string[];         // Tech stack (Go, TypeScript, etc.)
    repo_count: number;
    repos: string[];         // Repository names
    highlights: string[];    // Key features
    status: string;          // "active" | "archived" | "planned"
  }>;
  metadata: {
    application: string;
    component_type: string;
    total_count: number;
    filtered_count: number;
    page: number;
    page_size: number;
    total_pages: number;
    has_next: boolean;
    has_previous: boolean;
  };
  timestamp: string;         // ISO8601
}

// src/content/devarno-data-loader.ts
import { createV01tClient } from '@v01t/client';

export async function loadDevarnoData(): Promise<DevarnoData> {
  try {
    const client = createV01tClient({
      baseUrl: process.env.V01T_API_URL,
    });
    
    const response = await client.getNodes('devarno-ecosystem', {
      page_size: 50,
    });
    
    return transformNodeDataToDevarnoData(response.data);
  } catch (error) {
    // Fallback to static data if V01T unavailable
    return getStaticDevarnoData();
  }
}

// src/app/dashboard/page.tsx (server component)
export default async function DashboardPage() {
  const data = await loadDevarnoData();
  return <Dashboard data={data} />;
}

python api/manage.py seed_ecosystem --skip-existing=false

interface ListResponse {
  success: boolean;
  data: Array<{
    title: string;              // Article headline
    slug: string;               // URL-safe identifier
    cluster: string;            // Always "flight-path-articles"
    _meta: {
      external_id: string;      // Notion page ID
      last_synced: string;      // ISO8601 timestamp
    };
    // raw_data fields spread into response:
    id: string;                 // Notion page ID (for content fetch)
    excerpt: string;            // Short summary
    publishedAt: string;        // ISO8601 timestamp
    status: string;             // "draft" | "published" | "archived"
    priority: number;           // Publication order
    conversion_intent: string;  // "engagement" | "education" | "lead_gen"
    business_value_score: number; // 0-10
    word_count: number;
    readTime: string;           // e.g., "15min"
    tags: string[];
    keywords: string[];
    isPremium: boolean;
    author: {
      name: string;
      avatar: string;           // Image path
    };
  }>;
  metadata: {
    application: string;
    component_type: string;
    total_count: number;
    filtered_count: number;
    page: number;
    page_size: number;
    total_pages: number;
    has_next: boolean;
    has_previous: boolean;
  };
  timestamp: string;
}

// src/lib/articles.ts
export class ArticlesService {
  static async getArticles() {
    try {
      const response = await fetch(
        `${process.env.V01T_API_URL}/trace/flight-path/artefact/?page_size=50`,
        { next: { revalidate: 120 } }
      );
      const json = await response.json();
      return json.data.map(convertArtefactToArticle);
    } catch {
      return MOCK_ARTICLES;
    }
  }

  static async getArticle(slug: string) {
    const articles = await this.getArticles();
    return articles.find(a => a.slug === slug);
  }
}

function convertArtefactToArticle(artefact: Artefact): Article {
  return {
    id: artefact.raw_data.id,        // Notion page ID
    slug: artefact.slug,
    title: artefact.title,
    excerpt: artefact.raw_data.excerpt,
    publishedAt: artefact.raw_data.publishedAt,
    readTime: artefact.raw_data.readTime,
    author: artefact.raw_data.author,
    tags: artefact.raw_data.tags,
  };
}

// src/app/blog/[slug]/page.tsx (server component)
import { ArticlesService } from '@/lib/articles';
import { getNotionPage } from '@/lib/notion';

export default async function BlogPage({ params }: { params: { slug: string } }) {
  // Fetch metadata from V01T
  const article = await ArticlesService.getArticle(params.slug);
  if (!article) notFound();

  // Fetch content from Notion (article.id = Notion page ID)
  const content = await getNotionPage(article.id);

  return (
    <article>
      <h1>{article.title}</h1>
      <RichText blocks={content.blocks} />
    </article>
  );
}

python api/manage.py seed_flight_path --skip-existing=false

interface ErrorResponse {
  success: false;
  error: string;              // Human-readable message
  code?: string;              // Machine-readable code
  details?: Record<string, any>;
}

import { V01tApiError, V01tNetworkError } from '@v01t/client';

try {
  const response = await client.getNodes('devarno-ecosystem');
} catch (error) {
  if (error instanceof V01tApiError) {
    console.error('V01T API error:', error.code, error.message);
    return getCachedData() || MOCK_DATA;
  } else if (error instanceof V01tNetworkError) {
    console.error('V01T network error:', error.message);
    return getLocalData();
  }
}

// Server-side caching
const response = await fetch(url, { next: { revalidate: 120 } });

// On-demand revalidation
revalidateTag('v01t-organizations');
revalidateTag('v01t-articles');