PinkSync - Accessibility Orchestration Platform

PinkSync is a comprehensive Layer 1 accessibility orchestration platform designed specifically for deaf users. It acts as a unified gateway connecting deaf communities with accessible services, products, and programs while providing real-time accessibility enhancements across multiple environments.

🚀 Now powered by Deno! PinkSync has been migrated from Next.js to Deno for a more lightweight, modern, and efficient runtime. No build step required, native TypeScript support, and significantly faster performance.

🎯 NEW: API Hub - Explore our comprehensive API Hub with 9+ Deaf-first APIs, interactive playground, and real-time status monitoring. Perfect for developers building accessible applications. Learn more →

🎯 Core Concept

PinkSync consists of two primary components working together:

DeafAUTH Backend (The Brain)

• Centralized authentication and preference management
• User profile and accessibility settings storage
• API gateway for service integrations
• Real-time content transformation engine

PinkSync Browser Extension (The Hands)

• Chrome extension that runs on every website
• Automatically applies accessibility preferences
• Enables captions on all video platforms
• Converts audio alerts to visual notifications
• Auto-fills accessibility forms

Together, they provide seamless accessibility:

• Listens to events across platforms (web, extension, mobile)
• Transforms complex interfaces into deaf-friendly experiences
• Connects users with relevant services and providers
• Learns from deaf communities to improve accessibility continuously

🏗️ Architecture

Multi-Environment Support

• Browser Extension: Popup and content injection
• Web Application: Embedded and standalone modes
• Signal System: Real-time notifications and alerts
• Notificator: Visual notification engine
• API Hub: Developer portal for Deaf-first APIs

Core Systems

1. Event Orchestrator: Node-based event listener architecture
2. DeafAuth: Visual-first authentication system
3. RAG Research Center: Vector database of accessibility research
4. Background Workers: AI-powered automation and bots
5. API Broker: Unified gateway to partner services
6. PinkFlow Engine: Real-time accessibility adjustments

🌿 Branch Strategy

PinkSync uses a structured branching model to manage development and deployments:

Core Branches

• main - Primary development branch (modern standard)

  • Production-ready code
  • Base for all new features
  • Auto-deploys to staging

• master - Legacy compatibility branch

  • Mirror of main branch
  • Maintained for backward compatibility

• features - Integration testing branch

  • Pre-production feature integration
  • Test multiple features together

Feature Branch Patterns

Different types of development use specific prefixes:

• service-* - Microservices (e.g., service-deafauth)
• api-* - API endpoints (e.g., api-interpreters)
• feat-* / feature-* - New features (e.g., feat-video-captions)
• tool-* - Tools and utilities (e.g., tool-qr-scanner)
• video-* - Video processing features
• data-* - Data processing features
• admin-* - Admin interfaces

Each feature branch automatically deploys to its own URL:

https://pinkycollie.github.io/PinkSync/{branch-name}/

📖 Detailed Documentation: See BRANCH_STRATEGY.md for complete branching guidelines and workflows.

🧩 Microservices Ecosystem

PinkSync is built as a comprehensive microservices platform with features distributed across multiple branches. Below is the complete catalog of all services and features available in the PinkSync ecosystem.

Core Microservices (Main Platform)

🔐 deafauth

Visual-first authentication and preference management system

• Sign language video authentication
• User profile and accessibility settings storage
• Multi-device deaf profile synchronization
• Visual biometric patterns
• Deaf cultural identity support

🎯 event-orchestrator

Node-based event listener and processing architecture

• Real-time event handling across platforms
• User interaction processing
• Content change detection
• System notification management

🤖 rag-engine

Research-Augmented Generation system for accessibility learning

• Vector database of deaf accessibility research
• Community feedback aggregation
• Real-world usage pattern analysis
• Continuous recommendation improvements

👷 workers

Background job processors for automation

• Content transformation
• Real-time accessibility analysis
• Provider service matching
• Research data processing
• Community voice aggregation

🌉 api-broker

Unified gateway for partner service integrations

• Vocational rehabilitation services
• Educational resources
• Employment opportunities
• Community services
• Healthcare providers

🌊 pinkflow

Real-time accessibility adjustment engine

• Dynamic content transformation
• User preference application
• Visual enhancement processing
• Sign language integration

🤟 asl-glosser

ASL (American Sign Language) glossing service

• Sign language processing
• ASL-to-text conversion
• Cultural context preservation
• Multi-dialect support

🗣️ sign-speak

Comprehensive sign language service

• Sign language recognition
• Real-time interpretation
• Multiple sign language support (ASL, BSL, ISL, etc.)
• Visual gesture analysis

📹 vcode (Video Communication)

Core video communication service

• Deaf-first video calling
• Real-time visual communication
• Platform integration (Google Meet, Zoom, Teams, WebEx)
• Evidence generation for legal/medical meetings

👥 interpreters

Interpreter booking and management service

• Sign language interpreter scheduling
• Availability management
• Booking coordination
• Session recording and documentation

Extended Microservices (Feature Branches)

🎭 360 Magicians Platform (integrated-360-Magicians)

Comprehensive deaf-first business ecosystem

accessibility-api

• WCAG AAA compliant interface APIs
• Visual feedback systems
• Deaf-first design patterns
• Multi-modal accessibility features

deaf-first-identity

• Deaf cultural identity management
• Community networking
• Cultural celebration alerts
• Deaf advocacy tools

sign-language-auth

• Advanced sign language authentication
• Video-based identity verification
• Cultural competency validation
• Secure deaf-centric access control

🎥 VCode Platform (vcode)

Advanced video and AI-powered communication

ai-service

• Groq AI integration
• Whisper-large-v3 for transcription
• Specialized models (Medical, Legal, Technical)
• Real-time AI assistance
• ASL processing AI

content-service

• Content management and delivery
• Multi-modal evidence generation
• Meeting content analysis
• Transcription services

user-service

• User profile management
• Preference storage
• Session management
• Deaf user experience customization

vr-service

• Virtual reality accessibility features
• Immersive sign language environments
• 3D visual communication spaces
• VR meeting accessibility

📊 Analytics & Performance (videoized)

pink-sync-analytics

• Usage analytics and insights
• Accessibility metrics tracking
• User engagement monitoring
• Platform performance analysis

pink-sync-preloader

• Resource preloading optimization
• Fast initial load times
• Asset management
• Performance enhancement

Feature-Specific Services

📱 QR Code & Holograms (QR-Code-Holograms)

• QR code scanning and processing
• AR sign language holograms
• Visual information accessibility
• Library management system
• API endpoints: /api/scanqr/*

📝 Registration System (REGISTRATION)

• User registration workflows
• Sign-in/sign-up pages
• Password recovery
• Account management

✅ VCode API Verification (add-new-feature-vcode)

• Comprehensive API testing suite
• Endpoint verification
• Integration testing
• API quality assurance

🎛️ Admin Console (admin-console)

• Platform administration interface
• Data seeding and management
• System configuration
• User management tools

⚙️ Video Processing (data-processor-worker, video-processor)

• Mux video processing integration
• Real-time video analytics
• Queue-based job processing
• Multi-tenant video support
• WebSocket communication
• Professional video features

🏢 DeafLifeOS Integration (deaflifeos)

• DeafLifeOS platform fork
• Comprehensive deaf life management
• Daily living assistance
• Community resources

🏢 Enterprise Features (enterprise-page)

• Developer sign language support
• Enterprise-grade accessibility
• Business integration tools
• Corporate deaf accessibility

💬 Communication Automation (fear-explainer-content-generator)

• Automated communication systems
• Content generation for accessibility
• Fear/anxiety explainer tools
• Simplified communication

📋 Queue Processing (new-feat-queue-processing)

• Video processing job queues
• Asynchronous task management
• Background job scheduling
• API route: /api/queue/*

🆕 New Sectors (new-sectors)

• Expansion into new industry sectors
• Developer tooling for sign language
• Industry-specific accessibility

👁️ VisualDesk Integration (visualdesk)

• VisualDesk platform integration
• Desktop accessibility features
• VCode API integration
• Workspace accessibility tools

🚀 Getting Started

Backend Setup

Prerequisites

• Node.js 18+
• npm or pnpm

Prerequisites

• Deno 1.45+ (Install Deno)
• No Node.js or npm required!

Installation

# Clone the repository
git clone https://github.com/pinkycollie/PinkSync.git
cd PinkSync

# No installation step needed - Deno handles dependencies automatically!

# Development mode (with hot reload)
deno task dev

# Production mode
deno task start

# The server will start on http://localhost:8000

Why Deno?

PinkSync migrated from Next.js to Deno to provide:

• ⚡ Zero build step - Run TypeScript directly
• 🔒 Secure by default - Explicit permissions for network, file system, etc.
• 🎯 Native TypeScript - No transpilation needed
• 📦 No node_modules - Dependencies loaded from URLs
• 🚀 Faster startup - Instant server start
• 🌐 Web standards - Built-in fetch, Request, Response
• 💪 Modern runtime - Latest JavaScript/TypeScript features

Development

# Run development server with watch mode
deno task dev

# Check code formatting
deno fmt

# Lint code
deno lint

# Type check
deno check server.ts

# Run tests (if any)
deno test

Browser Extension Setup

For Users

1. Visit Chrome Web Store (coming soon)
2. Search for "PinkSync"
3. Click "Add to Chrome"
4. Sign in with DeafAUTH credentials
5. Enjoy automatic accessibility everywhere!

For Developers

# Extension files are in /extension directory
cd extension

# Load in Chrome
1. Open chrome://extensions
2. Enable "Developer mode"
3. Click "Load unpacked"
4. Select the extension directory

See extension/README.md for detailed instructions.

🔧 Configuration

PinkSync supports multiple deployment environments:

• Standalone: Full web application
• Extension: Browser extension mode
• Embedded: Widget integration for third-party sites
• API: Headless API mode

See config/ directory for environment-specific configurations.

Working with Feature Branches

To explore or work with specific microservices from feature branches:

# List all available feature branches
git branch -r | grep origin/

# Check out a specific feature branch
git checkout -b <branch-name> origin/<branch-name>

# Example: Check out the VCode platform
git checkout -b vcode origin/vcode

# Example: Check out 360 Magicians
git checkout -b integrated-360-Magicians origin/integrated-360-Magicians

# View services in the current branch
ls -la services/

Microservice Deployment

Each microservice can be deployed independently:

# Deploy a specific service (example with Docker)
cd services/<service-name>
docker build -t pinksync-<service-name> .
docker run -p 8000:8000 pinksync-<service-name>

# Or use the centralized deployment
docker-compose up <service-name>

🌐 Branch-Specific GitHub Pages Deployments

NEW! Every branch can now be automatically deployed to its own GitHub Pages URL for independent testing and preview:

# Each branch gets its own URL
service-deafauth    → https://pinkycollie.github.io/PinkSync/service-deafauth/
api-interpreters    → https://pinkycollie.github.io/PinkSync/api-interpreters/
feat-new-feature    → https://pinkycollie.github.io/PinkSync/feat-new-feature/

Supported Branch Patterns:

• service-* - Service microservices
• api-* - API endpoints
• tool-* - Tools and utilities
• feat-* / feature-* - New features
• video-*, data-* - Processing services
• Special branches: vcode, videoized, REGISTRATION

How It Works:

1. Create a branch with a supported pattern: git checkout -b service-my-service
2. Push your changes: git push origin service-my-service
3. Automatic deployment triggers via GitHub Actions
4. Access your deployment: https://pinkycollie.github.io/PinkSync/service-my-service/

Documentation:

• 📖 Branch Deployments Guide - Complete guide
• 🔗 Deployment URLs Reference - All deployment URLs
• 📋 Staging Guide - Staging environments

This enables true microservice independence - each branch/service can be developed, tested, and previewed in isolation without affecting other services!

📦 Versioning & Releases

PinkSync follows Semantic Versioning (MAJOR.MINOR.PATCH):

# Check current version
npm run version:current

# Create a new release (interactive)
npm run release:create

# Quick version bumps
npm run release:patch   # Bug fixes (1.0.0 → 1.0.1)
npm run release:minor   # New features (1.0.0 → 1.1.0)
npm run release:major   # Breaking changes (1.0.0 → 2.0.0)

# View changelog
npm run changelog:view

Version History:

• Current Version: 1.0.0
• See CHANGELOG.md for full version history
• See Release Guide for release procedures

Release Management:

• Automated releases via GitHub Actions on tag push
• Each release includes:
  • Changelog extraction
  • GitHub release with notes
  • Automatic deployment to GitHub Pages
  • Version metadata in deployments

Branch Versioning: Each branch deployment includes version metadata:

• Main: Production version (e.g., 1.0.0)
• Service branches: Independent versions (e.g., deafauth@2.1.0)
• Feature branches: Pre-release versions (e.g., 1.1.0-feat-xyz)

🌐 Integration with mbtq.dev

PinkSync is designed to work seamlessly with the mbtq.dev ecosystem, providing:

• Unified accessibility layer
• Shared user profiles and preferences
• Cross-platform accessibility enhancements

🤝 Partner & Provider Integration

PinkSync connects with various service providers to enhance deaf users' livelihood:

• Vocational rehabilitation services
• Educational resources
• Employment opportunities
• Community services
• Healthcare providers

📚 Research & Community

PinkSync maintains a RAG (Retrieval-Augmented Generation) system that:

• Collects research on deaf accessibility
• Aggregates feedback from deaf communities
• Learns from real-world usage patterns
• Improves recommendations over time

🔐 Security & Privacy

• Visual-first authentication (deafAuth)
• End-to-end encryption for sensitive data
• Privacy-first data collection
• User-controlled data sharing

📖 Documentation

• API Hub - NEW! 🔥 Developer portal with 9+ Deaf-first APIs
• Complete Architecture - NEW! Full system architecture
• Branch Deployments Guide - NEW! Deploy any branch to GitHub Pages
• Deployment URLs Reference - NEW! Quick reference for all deployment URLs
• Release Guide - NEW! Version control and release management
• Changelog - NEW! Version history and changes
• Staging Guide - Preview environments
• API Gateway - NEW! Extension API documentation
• Browser Extension - NEW! Extension setup and usage
• Architecture Guide
• API Documentation
• Deployment Guide
• Contributing

🛠️ Development

Project Structure

/app                        - Next.js application pages
/components                 - React components
/config                     - Environment configurations
/extension                  - Browser extension
  /scripts                  - Background worker, content scripts
  /styles                   - Extension CSS
  /icons                    - Extension icons
  manifest.json             - Extension configuration
/lib                        - Utility libraries
/routes                     - Deno server routes
  /api                      - API endpoints
/services                   - Microservices (see Microservices Ecosystem above)
  /event-orchestrator       - Event handling system
  /deafauth                 - Authentication services
  /rag-engine               - Research and learning system
  /workers                  - Background job processors
  /api-broker               - Partner API integrations
  /pinkflow                 - Accessibility engine
  /asl-glosser              - ASL glossing service
  /vcode                    - Video communication service
  /interpreters             - Interpreter booking service
  /sign-speak               - Sign language service
  /accessibility-api        - (360 Magicians) Accessibility APIs
  /deaf-first-identity      - (360 Magicians) Identity management
  /sign-language-auth       - (360 Magicians) Sign language authentication
  /ai-service               - (VCode) AI and ML services
  /content-service          - (VCode) Content management
  /user-service             - (VCode) User management
  /vr-service               - (VCode) Virtual reality features
  /pink-sync-analytics.ts   - (Videoized) Analytics service
  /pink-sync-preloader.ts   - (Videoized) Performance optimization
/config                     - Environment configurations
/types                      - TypeScript type definitions
/public                     - Static assets
/docs                       - Documentation
  architecture-complete.md  - Complete system architecture
  api-gateway.md            - API documentation for extension
server.ts                   - Main Deno server entry point
deno.json                   - Deno configuration and tasks

Branch-Based Features

The PinkSync platform uses feature branches for developing and testing new microservices:

• feat-Pinksync-AI - Main branch with core platform and browser extension
• integrated-360-Magicians - 360 Magicians deaf-first business platform
• vcode - Advanced video communication with Groq AI integration
• QR-Code-Holograms - QR code scanning and AR hologram features
• REGISTRATION - Enhanced authentication and registration system
• add-new-feature-vcode - VCode API verification suite
• admin-console - Platform administration interface
• data-processor-worker - Video processing with Mux integration
• video-processor - Multi-tenant video support
• videoized - Analytics and performance optimization
• deaflifeos - DeafLifeOS integration
• enterprise-page - Enterprise features and developer tools
• fear-explainer-content-generator - Communication automation
• new-feat-queue-processing - Job queue processing
• new-sectors - Industry sector expansion
• visualdesk - VisualDesk desktop integration

Each branch represents a modular feature set that can be independently developed, tested, and deployed.

🤖 Background Workers

PinkSync uses background workers for:

• Content transformation
• Real-time accessibility analysis
• Provider service matching
• Research data processing
• Community voice aggregation

📡 Event System

The event listener architecture processes:

• User interactions
• Content changes
• Provider updates
• Community feedback
• System notifications

🎨 Accessibility Features

• Text simplification
• Visual enhancements
• Sign language integration
• Transcription services
• Custom user preferences
• Persistent profiles

🚀 Recommended Modern Tools & Integrations

Based on PinkSync's microservices architecture and deaf-first mission, here are cutting-edge tools we recommend integrating:

🎯 Priority Integrations (High Impact)

1. LiveKit - Real-time Video Infrastructure

• Purpose: Replace/enhance current video communication
• Benefits: Open-source WebRTC, built-in recording, low latency
• Use Case: Better video calls for VCode service
• Integration: New microservice services/livekit-bridge

npm create livekit-app@latest

2. Qdrant Vector Database - Enhanced RAG Engine

• Purpose: Upgrade rag-engine with better semantic search
• Benefits: Self-hostable, fast similarity search, sign language embeddings
• Use Case: Improved accessibility research recommendations
• Integration: Replace current RAG backend

docker pull qdrant/qdrant

3. MediaPipe (Google) - Sign Language Recognition

• Purpose: Real-time hand tracking and pose estimation
• Benefits: Accurate ASL detection, runs in browser, free
• Use Case: New service for real-time sign language recognition
• Integration: New microservice services/mediapipe-asl

npm install @mediapipe/hands @mediapipe/pose

4. Kong Gateway - API Gateway Replacement

• Purpose: Professional API gateway to replace api-broker
• Benefits: Plugin ecosystem, rate limiting, auth, analytics
• Use Case: Central gateway for all microservices
• Integration: Replace/enhance api-broker

docker pull kong/kong-gateway

5. Supabase - Backend-as-a-Service

• Purpose: PostgreSQL + real-time + auth + storage
• Benefits: Real-time subscriptions, row-level security, built-in auth
• Use Case: Unified backend for deafauth and user management
• Integration: New microservice services/supabase-sync

npx supabase init

🔥 High-Value Additions

6. AssemblyAI - Advanced Speech Recognition

• Purpose: Better than Whisper for meeting transcription
• Benefits: Speaker diarization, sentiment analysis, topic detection
• Use Case: Enhanced VCode meeting transcription
• Integration: Add to ai-service

npm install assemblyai

7. Deno Deploy - Edge Computing

• Purpose: Deploy Deno services globally with low latency
• Benefits: Perfect for current Deno architecture, automatic scaling
• Use Case: Edge deployment for pinkflow and event-orchestrator
• Integration: Native deployment for existing services

8. Redis Streams - Event Streaming

• Purpose: Lightweight event streaming for event-orchestrator
• Benefits: In-memory speed, pub/sub, persistence
• Use Case: Replace current event system with scalable streaming
• Integration: Upgrade event-orchestrator

npm install ioredis

🎨 Accessibility & UI Enhancements

9. Radix UI - Accessible Components

• Purpose: WCAG-compliant UI primitives
• Benefits: Headless, customizable, accessible by default
• Use Case: Browser extension and web app UI
• Integration: Replace current component library

npm install @radix-ui/react-*

10. axe-core - Accessibility Testing

• Purpose: Automated accessibility audits
• Benefits: WCAG compliance checking, CI/CD integration
• Use Case: Ensure all features meet accessibility standards
• Integration: Add to testing pipeline

npm install @axe-core/playwright

🧠 AI & Machine Learning

11. Vercel AI SDK - AI Assistant Framework

• Purpose: Build AI assistants and chatbots
• Benefits: Streaming responses, multiple providers, edge support
• Use Case: Intelligent accessibility assistant
• Integration: New microservice services/ai-assistant

npm install ai

12. TensorFlow.js - Browser-based ML

• Purpose: Client-side sign language recognition
• Benefits: Privacy-preserving, no server needed, hardware accelerated
• Use Case: Browser extension ASL detection
• Integration: Add to extension/scripts

npm install @tensorflow/tfjs

📊 Monitoring & DevOps

13. Grafana + Prometheus - Observability Stack

• Purpose: System monitoring and metrics
• Benefits: Custom dashboards, alerting, service health
• Use Case: Monitor all microservices performance
• Integration: New infrastructure service

docker-compose up prometheus grafana

14. Sentry - Error Tracking

• Purpose: Real-time error monitoring
• Benefits: Performance monitoring, user feedback, replay sessions
• Use Case: Track bugs and performance issues
• Integration: Add to all services

npm install @sentry/deno @sentry/react

🏗️ Development Tools

15. Turborepo - Monorepo Management

• Purpose: High-performance build system
• Benefits: Smart caching, parallel execution, remote caching
• Use Case: Manage all microservices in one repo
• Integration: Restructure project as monorepo

npx create-turbo@latest

16. Backstage (Spotify) - Developer Portal

• Purpose: Internal developer platform
• Benefits: Service catalog, documentation, templates
• Use Case: Manage all microservices and their documentation
• Integration: New developer portal

npx @backstage/create-app@latest

🔐 Identity & Security

17. Clerk - Modern Authentication

• Purpose: Enhanced authentication with video support
• Benefits: Multi-factor auth, organization management, webhooks
• Use Case: Upgrade deafauth with modern features
• Integration: Replace/enhance deafauth

npm install @clerk/clerk-react

18. Ceramic Network - Decentralized Identity

• Purpose: Self-sovereign identity for deaf users
• Benefits: Verifiable credentials, privacy-preserving, portable
• Use Case: Deaf community credentials and reputation
• Integration: New microservice services/ceramic-identity

npm install @ceramicnetwork/http-client

📹 Video Processing

19. Cloudflare Stream - Video Infrastructure

• Purpose: Video encoding and delivery
• Benefits: Cheaper than Mux, built-in captions, global CDN
• Use Case: Replace/complement Mux for video processing
• Integration: Add to vcode service

20. FFmpeg.wasm - Browser Video Processing

• Purpose: Client-side video processing
• Benefits: Privacy-friendly, no upload needed, instant processing
• Use Case: Browser-based video editing for deaf users
• Integration: Add to extension and web app

npm install @ffmpeg/ffmpeg

💡 Getting Started with Integrations

1. Start Small: Begin with LiveKit, Qdrant, and MediaPipe
2. Measure Impact: Monitor user engagement and accessibility improvements
3. Iterate: Add more services based on user feedback
4. Document: Update this README as new services are integrated

🛠️ Integration Scaffolding

Use these generators to quickly scaffold new microservices:

# Create new Deno service
deno run --allow-read --allow-write https://deno.land/x/scaffolder/mod.ts

# Create new Node.js microservice
npx express-generator services/new-service

# Create API gateway service
npx create-kong-plugin my-plugin

# Create monitoring stack
git clone https://github.com/vegasbrianc/prometheus.git

📄 License

[License information to be added]

🙏 Acknowledgments

Built for and with the deaf community to enhance digital accessibility and independence.

---

Note: This platform actively integrates modern tools to provide the best deaf-first accessibility experience. Check individual branch READMEs for branch-specific integrations and features.