# TRO-M01: Developer documentation for obfuscation process
**Area:** Widget.js Telnyx Obfuscation
**Model:** minimax/minimax-m2.5
**Tokens:** 6,735
**Cost:** $0.0067
**Time:** 5142ms
**Timestamp:** 2026-02-16T12:18:51.771521

---

# Developer Documentation: Telnyx Reference Obfuscation System

> **Version:** 1.0.0  
> **Last Updated:** 2024  
> **Maintainer:** Platform Engineering Team

---

## Table of Contents

1. [Overview](#overview)
2. [Why We Obfuscate Telnyx References](#why-we-obfuscate-telnyx-references)
3. [How the Mapping Works](#how-the-mapping-works)
4. [Adding New References](#adding-new-references)
5. [Debugging with Source Maps](#debugging-with-source-maps)
6. [CI/CD Integration](#cicd-integration)
7. [Troubleshooting](#troubleshooting)
8. [Security Considerations](#security-considerations)

---

## Overview

This document describes the Telnyx reference obfuscation system implemented in the Sunaiva Talking Widget. The system abstracts all Telnyx-specific identifiers, API endpoints, and configuration values behind internal reference names, preventing direct exposure of our telecommunications infrastructure.

### System Components

| Component | Purpose |
|-----------|---------|
| `telnyx-mappings.json` | Central mapping configuration file |
| `Obfuscator` class | Runtime mapping resolution |
| Build scripts | Automated obfuscation during CI/CD |
| Source maps | Debugging support for obfuscated builds |

---

## Why We Obfuscate Telnyx References

### Business Rationale

We obfuscate Telnyx references for five strategic reasons:

1. **Competitive Intelligence Protection**
   - Prevents competitors from identifying our telecom provider
   - Blocks easy replication of our technical infrastructure
   - Protects our pricing margins and vendor relationships

2. **Agency Partner Abstraction**
   - Agency resellers don't need to understand our underlying stack
   - Simplifies partner onboarding and training
   - Allows vendor changes without requiring partner re-certification

3. **Reduced Attack Surface**
   - Hides infrastructure details from public-facing code
   - Limits information available to potential bad actors
   - Prevents easy identification of API endpoints and capabilities

4. **Business Flexibility**
   - Enables seamless provider migration if needed
   - Abstracts vendor-specific quirks from application logic
   - Simplifies contractual negotiations with vendors

5. **Professional Positioning**
   - Presents a polished, self-contained product
   - Avoids appearing to rely heavily on third-party services
   - Maintains brand control over the complete user experience

### What Gets Obfuscated

The following Telnyx-specific elements are abstracted:

- Phone numbers (DIDs, toll-free numbers)
- Application IDs and API keys (in configuration)
- Webhook endpoints and URLs
- Messaging profile identifiers
- SIP trunking credentials
- Region-specific endpoint hostnames

---

## How the Mapping Works

### Architecture

```
┌─────────────────────────────────────────────────────────────┐
│                     Application Code                        │
│                                                             │
│  import { TelnyxMapper } from './lib/telnyx-mapper';       │
│                                                             │
│  const config = TelnyxMapper.resolve('production_01');    │
│  // Returns: { number: '+1234567890', appId: '...' }      │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                   Obfuscation Layer                         │
│                                                             │
│  ┌──────────────────┐    ┌──────────────────────────────┐  │
│  │ Internal Name    │    │ Telnyx Value                 │  │
│  ├──────────────────┤    ├──────────────────────────────┤  │
│  │ production_01    │ -> │ +1234567890                 │  │
│  │ staging_01       │ -> │ +1987654321                 │  │
│  │ test_voice_app   │ -> │ abc123def456                │  │
│  └──────────────────┘    └──────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                  telnyx-mappings.json                       │
└─────────────────────────────────────────────────────────────┘
```

### Mapping File Structure

Create `config/telnyx-mappings.json`:

```json
{
  "_meta": {
    "version": "1.0.0",
    "lastUpdated": "2024-01-15T10:30:00Z",
    "environment": "production"
  },
  "phoneNumbers": {
    "production_main": {
      "value": "+61295181234",
      "type": "did",
      "region": "au-sydney",
      "capabilities": ["voice", "sms"]
    },
    "production_tollfree": {
      "value": "+18005556789",
      "type": "tollfree",
      "region": "us",
      "capabilities": ["voice", "sms"]
    },
    "staging_01": {
      "value": "+61295189999",
      "type": "did",
      "region": "au-melbourne",
      "capabilities": ["voice"]
    }
  },
  "applications": {
    "voice_widget_prod": {
      "value": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      "type": "voice_application",
      "features": ["dtmf", "recording", "transcription"]
    },
    "voice_widget_staging": {
      "value": "deadbeef-cafe-0000-0000-0123456789ab",
      "type": "voice_application",
      "features": ["dtmf", "recording"]
    }
  },
  "webhooks": {
    "production_callback": {
      "value": "https://api.sunaiva.com/v1/webhooks/telnyx",
      "type": "webhook",
      "events": ["call_completed", "call_initiated", "recording_ready"]
    },
    "production_messaging": {
      "value": "https://api.sunaiva.com/v1/webhooks/telnyx/messaging",
      "type": "webhook",
      "events": ["message_received", "message_delivered"]
    }
  },
  "apiEndpoints": {
    "telnyx_api": {
      "value": "api.telnyx.com",
      "type": "endpoint",
      "version": "v2"
    },
    "telnyx_media": {
      "value": "media.telnyx.com",
      "type": "endpoint",
      "version": "v1"
    }
  }
}
```

### Obfuscator Class Implementation

Create `src/lib/telnyx-mapper.ts`:

```typescript
import mappings from '../../config/telnyx-mappings.json';

type MappingCategory = 'phoneNumbers' | 'applications' | 'webhooks' | 'apiEndpoints';

interface MappingEntry {
  value: string;
  type: string;
  region?: string;
  capabilities?: string[];
  features?: string[];
  events?: string[];
}

interface Mappings {
  _meta: {
    version: string;
    lastUpdated: string;
    environment: string;
  };
  phoneNumbers: Record<string, MappingEntry>;
  applications: Record<string, MappingEntry>;
  webhooks: Record<string, MappingEntry>;
  apiEndpoints: Record<string, MappingEntry>;
}

export class TelnyxMapper {
  private static mappings: Mappings = mappings as Mappings;

  /**
   * Resolve an internal reference name to its Telnyx value
   * @param referenceName - Internal reference (e.g., 'production_main')
   * @param category - Category of mapping ('phoneNumbers', 'applications', etc.)
   * @returns The Telnyx value, or null if not found
   */
  static resolve(referenceName: string, category: MappingCategory): string | null {
    const categoryMappings = this.mappings[category];
    
    if (!categoryMappings) {
      console.error(`[TelnyxMapper] Unknown category: ${category}`);
      return null;
    }

    const entry = categoryMappings[referenceName];
    
    if (!entry) {
      console.error(`[TelnyxMapper] Reference not found: ${referenceName} in ${category}`);
      return null;
    }

    // Log resolution in development only
    if (process.env.NODE_ENV === 'development') {
      console.log(`[TelnyxMapper] Resolved ${category}.${referenceName} -> ${entry.value}`);
    }

    return entry.value;
  }

  /**
   * Get full mapping entry with metadata
   */
  static resolveWithMeta(referenceName: string, category: MappingCategory): MappingEntry | null {
    const categoryMappings = this.mappings[category];
    
    if (!categoryMappings) {
      return null;
    }

    return categoryMappings[referenceName] || null;
  }

  /**
   * Get all mappings in a category
   */
  static getCategory(category: MappingCategory): Record<string, MappingEntry> {
    return this.mappings[category] || {};
  }

  /**
   * Validate all mappings are present and valid
   */
  static validate(): { valid: boolean; errors: string[] } {
    const errors: string[] = [];
    const categories: MappingCategory[] = ['phoneNumbers', 'applications', 'webhooks', 'apiEndpoints'];

    for (const category of categories) {
      const entries = this.mappings[category];
      
      if (!entries) {
        errors.push(`Missing category: ${category}`);
        continue;
      }

      for (const [name, entry] of Object.entries(entries)) {
        if (!entry.value) {
          errors.push(`Empty value for ${category}.${name}`);
        }
        if (!entry.type) {
          errors.push(`Missing type for ${category}.${name}`);
        }
      }
    }

    return {
      valid: errors.length === 0,
      errors
    };
  }

  /**
   * Get mapping metadata
   */
  static getMeta() {
    return this.mappings._meta;
  }
}

// Convenience functions for common use cases
export const resolvePhoneNumber = (ref: string) => 
  TelnyxMapper.resolve(ref, 'phoneNumbers');

export const resolveApplication = (ref: string) => 
  TelnyxMapper.resolve(ref, 'applications');

export const resolveWebhook = (ref: string) => 
  TelnyxMapper.resolve(ref, 'webhooks');

export const resolveApiEndpoint = (ref: string) => 
  TelnyxMapper.resolve(ref, 'apiEndpoints');
```

### Usage Examples

```typescript
import { TelnyxMapper, resolvePhoneNumber } from '../lib/telnyx-mapper';

// Basic usage
const phoneNumber = TelnyxMapper.resolve('production_main', 'phoneNumbers');
// Returns: '+61295181234'

// With full metadata
const appConfig = TelnyxMapper.resolveWithMeta('voice_widget_prod', 'applications');
// Returns: { value: 'a1b2c3d4-...', type: 'voice_application', features: [...] }

// Using convenience functions
const webhookUrl = resolveWebhook('production_callback');
// Returns: 'https://api.sunaiva.com/v1/webhooks/telnyx'

// In configuration
const widgetConfig = {
  phoneNumber: resolvePhoneNumber('production_main'),
  appId: resolveApplication('voice_widget_prod'),
  webhookUrl: resolveWebhook('production_callback')
};
```

---

## Adding New References

### Step-by-Step Process

#### Step 1: Update the Mapping File

Add new entries to `config/telnyx-mappings.json`:

```json
{
  "phoneNumbers": {
    "production_main": { ... },
    "production_secondary": {
      "value": "+61295181235",
      "type": "did",
      "region": "au-sydney",
      "capabilities": ["voice", "sms"]
    }
  }
}
```

#### Step 2: Add TypeScript Types (If Needed)

If adding a new category, extend the types in `src/lib/telnyx-mapper.ts`:

```typescript
// Add new category type
type MappingCategory = 
  | 'phoneNumbers' 
  | 'applications' 
  | 'webhooks' 
  | 'apiEndpoints'
  | 'sipTrunks';  // New category
```

#### Step 3: Use the New Reference

```typescript
const newNumber = resolvePhoneNumber('production_secondary');
```

#### Step 4: Validate Mappings

Run validation to ensure no broken references:

```bash
npm run validate:mappings
```

Expected output:
```
✓ Telnyx mappings validated
  - phoneNumbers: 5 entries
  - applications: 3 entries
  - webhooks: 4 entries
  - apiEndpoints: 2 entries
```

### Naming Conventions

| Reference Type | Pattern | Example |
|---------------|---------|---------|
| Phone numbers | `{environment}_{purpose}` | `production_main`, `staging_backup` |
| Applications | `{app_type}_{environment}` | `voice_widget_prod`, `messaging_api_staging` |
| Webhooks | `{environment}_{handler}` | `production_callback`, `staging_messaging` |
| Endpoints | `{service}_{region}` | `telnyx_api_au`, `media_cdn_us` |

### Checklist for New References

- [ ] Added entry to `telnyx-mappings.json`
- [ ] Included all required fields (`value`, `type`)
- [ ] Added optional metadata (`region`, `capabilities`, etc.)
- [ ] Updated `_meta.lastUpdated` timestamp
- [ ] Tested resolution in development environment
- [ ] Updated documentation (if new category)
- [ ] Verified no sensitive values in non-production mappings

---

## Debugging with Source Maps

### Overview

Source maps enable debugging of minified/obfuscated JavaScript as if it were the original source. Our build pipeline generates source maps that map obfuscated identifiers back to their original Telnyx reference names.

### Enabling Source Maps

#### Development Build

Source maps are automatically included in development builds:

```bash
npm run dev
```

The output includes:
```
dist/
├── js/
│   ├── main.js
│   └── main.js.map    # Source map included
```

#### Production Build

To include source maps in production (for debugging only):

```bash
npm run build:source-maps
```

Or set environment variable:

```bash
SOURCEMAP=true npm run build
```

> **Security Note:** Production source maps should be disabled in live environments. See [Security Considerations](#security-considerations).

### Browser DevTools Integration

#### Chrome/Edge

1. Open Developer Tools (F12)
2. Navigate to **Sources** tab
3. Enable **Enable JavaScript source maps** in Settings (F1)
4. The original reference names appear in the debugger

#### Firefox

1. Open Developer Tools (F12)
2. Navigate to **Debugger** tab
3. Source maps are enabled by default
4. Original names appear in the call stack

### Debugging Workflow

#### Viewing Obfuscated Values

When stopped at a breakpoint in minified code:

1. Inspect variables in the **Scope** panel
2. Original mapping names display as comments:
   ```javascript
   // Original: telnyx-mappings.json :: production_main
   var a = "+61295181234";
   ```

#### Using the TelnyxMapper Debugger

We've included a debug utility for development:

```typescript
import { TelnyxMapper } from '../lib/telnyx-mapper';

// Enable debug mode
TelnyxMapper.setDebug(true);

// All resolutions are logged
const num = resolvePhoneNumber('production_main');
// Console: [TelnyxMapper] DEBUG Resolving production_main -> +61295181234
```

#### Browser Console Debug Helper

Add this bookmarklet for quick reference lookup:

```javascript
javascript:(function(){const m=document.querySelector('script[data-telnyx-mappings]');if(m){const refs=JSON.parse(m.textContent);console.table(refs);}else{console.warn('Telnyx mappings not found in page');}})();
```

### Troubleshooting Source Maps

| Issue | Cause | Solution |
|-------|-------|----------|
| Source map 404 | Missing `.map` file | Run build with source maps enabled |
| "Source map invalid" | Incorrect source map URL | Verify `//# sourceMappingURL` comment |
| Original names not showing | Browser source maps disabled | Enable in DevTools settings |
| Wrong mappings shown | Stale cache | Hard refresh (Cmd+Shift+R) |

---

## CI/CD Integration

### Build Pipeline Overview

```
┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   Commit    │───▶│   Build     │───▶│   Test      │───▶│  Deploy     │
│             │    │             │    │             │    │             │
│  - Code     │    │  - Obfuscate│    │ - Unit      │    │  - Staging  │
│  - Mappings │    │  - Minify   │    │ - Integration│   │  - Production│
└─────────────┘    │  - SourceMap│    │  - E2E     │    │             │
                   └─────────────┘    └─────────────┘    └─────────────┘
```

### GitHub Actions Workflow

Create `.github/workflows/build.yml`:

```yaml
name: Build and Obfuscate

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Validate Telnyx mappings
        run: npm run validate:mappings
        env:
          NODE_ENV: development
      
      - name: Build application
        run: npm run build
        env:
          NODE_ENV: production
          SOURCEMAP: ${{ github.event_name == 'pull_request' }}
      
      - name: Run tests
        run: npm run test:coverage
      
      - name: Upload build artifacts
        uses: actions/upload-artifact@v4
        with:
          name: build-output
          path: dist/
          retention-days: 7
      
      - name: Upload source maps (PR only)
        if: github.event_name == 'pull_request'
        uses: actions/upload-artifact@v4
        with:
          name: source-maps
          path: dist/**/*.map
          retention-days: 3

  deploy-staging:
    needs: build
    if: github.ref == 'refs/heads/develop'
    runs-on: ubuntu-latest
    
    steps:
      - name: Download artifacts
        uses: actions/download-artifact@v4
        with:
          name: build-output
          path: dist/
      
      - name: Deploy to staging
        run: npm run deploy:staging
        env:
          STAGING_API_KEY: ${{ secrets.STAGING_API_KEY }}

  deploy-production:
    needs: build
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    
    steps:
      - name: Download artifacts
        uses: actions/download-artifact@v4
        with:
          name: build-output
          path: dist/
      
      - name: Deploy to production
        run: npm run deploy:production
        env:
          PRODUCTION_API_KEY: ${{ secrets.PRODUCTION_API_KEY }}
```

### Build Scripts

Update `package.json`:

```json
{
  "scripts": {
    "validate:mappings": "node scripts/validate-mappings.js",
    "build": "npm run validate:mappings && npm run build:rollup",
    "build:rollup": "rollup -c rollup.config.js",
    "build:source-maps": "SOURCEMAP=true npm run build:rollup",
    "dev": "NODE_ENV=development rollup -c -w",
    "deploy:staging": "./scripts/deploy.sh staging",
    "deploy:production": "./scripts/deploy.sh production"
  }
}
```

### Rollup Configuration

Create `rollup.config.js`:

```javascript
import resolve from '@rollup/plugin-node-resolve';
import commonjs from '@rollup/plugin-commonjs';
import terser from '@rollup/plugin-terser';
import sourceMaps from 'rollup-plugin-sourcemaps';
import json from '@rollup/plugin-json';

const production = process.env.NODE_ENV === 'production';
const sourceMapsEnabled = process.env.SOURCEMAP === 'true';

export default {
  input: 'src/index.ts',
  output: {
    file: 'dist/js/talking-widget.js',
    format: 'iife',
    name: 'SunaivaWidget',
    sourcemap: sourceMapsEnabled,
    sourcemapPathTransform: (relativePath) => {
      // Transform source map paths for obfuscated references
      return relativePath;
    }
  },
  plugins: [
    resolve({
      browser: true,
      preferBuiltins: false
    }),
    commonjs(),
    json(),
    sourceMaps(),
    production && terser({
      compress: {
        // Preserve mapping comments
        comments: /telnyx-mappings|SourceMap/
      },
      mangle: {
        // Keep TelnyxMapper class name for debugging
        reserved: ['TelnyxMapper', 'resolvePhoneNumber']
      }
    })
  ].filter(Boolean)
};
```

### Environment-Specific Configurations

#### Development

```bash
NODE_ENV=development
SOURCEMAP=true
LOG_LEVEL=debug
```

#### Staging

```bash
NODE_ENV=staging
SOURCEMAP=true    # For debugging staging issues
LOG_LEVEL=info
```

#### Production

```bash
NODE_ENV=production
SOURCEMAP=false   # Disabled for security
LOG_LEVEL=warn
```

### Validation Script

Create `scripts/validate-mappings.js`:

```javascript
const fs = require('fs');
const path = require('path');

const MAPPINGS_PATH = path.join(__dirname, '../config/telnyx-mappings.json');

function validateMappings() {
  console.log('Validating Telnyx mappings...\n');
  
  let mappings;
  try {
    const content = fs.readFileSync(MAPPINGS_PATH, 'utf8');
    mappings = JSON.parse(content);
  } catch (error) {
    console.error(`❌ Failed to read mappings file: ${error.message}`);
    process.exit(1);
  }

  const errors = [];
  const categories = ['phoneNumbers', 'applications', 'webhooks', 'apiEndpoints'];

  for (const category of categories) {
    if (!mappings[category]) {
      errors.push(`Missing category: ${category}`);
      continue;
    }

    const entries = mappings[category];
    let count = 0;
    
    for (const [name, entry] of Object.entries(entries)) {
      count++;
      
      if (!entry.value || entry.value.trim() === '') {
        errors.push(`Empty value: ${category}.${name}`);
      }
      
      if (!entry.type) {
        errors.push(`Missing type: ${category}.${name}`);
      }
      
      // Validate phone numbers format
      if (category === 'phoneNumbers' && entry.value) {
        if (!/^\+[1-9]\d{1,14}$/.test(entry.value)) {
          errors.push(`Invalid phone format: ${category}.${name} = ${entry.value}`);
        }
      }
      
      // Validate URLs
      if (entry.type === 'webhook' && entry.value) {
        try {
          new URL(entry.value);
        } catch {
          errors.push(`Invalid URL: ${category}.${name} = ${entry.value}`);
        }
      }
    }
    
    console.log(`✓ ${category}: ${count} entries`);
  }

  // Check _meta
  if (!mappings._meta) {
    errors.push('Missing _meta section');
  } else {
    console.log(`✓ _meta: version ${mappings._meta.version}`);
  }

  if (errors.length > 0) {
    console.error('\n❌ Validation failed:\n');
    errors.forEach(err => console.error(`  - ${err}`));
    process.exit(1);
  }

  console.log('\n✅ All mappings valid\n');
}

validateMappings();
```

---

## Troubleshooting

### Common Issues

#### 1. Reference Not Found

**Error:**
```
[TelnyxMapper] Reference not found: production_backup in phoneNumbers
```

**Cause:** The reference name doesn't exist in `telnyx-mappings.json`

**Solution:**
```bash
# List available phone numbers
npm run list:mappings -- --category phoneNumbers
```

#### 2. Empty Value Returned

**Error:** `resolve()` returns `null` or empty string

**Cause:** Entry exists but has empty `value` field

**Solution:** Check `config/telnyx-mappings.json`:
```json
"production_backup": {
  "value": "",  // This is the problem
  "type": "did"
}
```

Fix:
```json
"production_backup": {
  "value": "+61295189999",
  "type": "did"
}
```

#### 3. Wrong Environment Mappings

**Issue:** Production build uses staging phone numbers

**Cause:** Wrong mapping file deployed or `NODE_ENV` misconfigured

**Solution:**
```bash
# Verify which mappings are bundled
npm run inspect:mappings

# Check environment
echo $NODE_ENV
```

#### 4. Source Map 404 in Browser

**Error:** `Failed to load source map for main.js`

**Cause:** Source map file not uploaded or path incorrect

**Solution:**
```bash
# Verify source map exists
ls -la dist/*.map

# Check sourceMappingURL in JS file
grep "sourceMappingURL" dist/main.js
```

#### 5. Build Fails with Obfuscation Error

**Error:** `RollupError: Could not resolve import from obfuscated reference`

**Cause:** Mapping reference in code doesn't match `telnyx-mappings.json`

**Solution:**
```bash
# Validate mappings before build
npm run validate:mappings
```

### Debug Commands

| Command | Purpose |
|---------|---------|
| `npm run validate:mappings` | Validate all mapping entries |
| `npm run list:mappings` | List all configured references |
| `npm run inspect:mappings -- ref` | Show full details of a reference |
| `npm run build:verbose` | Build with detailed logging |

---

## Security Considerations

### Production Hardening

1. **Disable Source Maps in Production**
   ```bash
   # In production environment
   SOURCEMAP=false npm run build
   ```

2. **Verify No Telnyx Values in Source**
   ```bash
   # Search for exposed Telnyx values
   grep -r "api.telnyx.com" dist/
   grep -r "+6129518" dist/
   ```

3. **Environment-Specific Mappings**
   - Never include production credentials in non-production mappings
   - Use separate mapping files per environment if needed
   - Rotate production values regularly

### Access Control

- Restrict access to `telnyx-mappings.json` to engineering team
- Store production mapping values in secrets management
- Audit mapping file changes through version control

### Monitoring

Set up alerts for:
- Failed mapping validations in CI
- Unexpected reference resolution failures in production
- Changes to mapping configuration files

---

## Appendix

### File Structure

```
project/
├── config/
│   └── telnyx-mappings.json          # Central mapping configuration
├── src/
│   └── lib/
│       └── telnyx-mapper.ts          # Obfuscation resolution class
├── scripts/
│   ├── validate-mappings.js          # Validation script
│   ├── list-mappings.js              # Listing script
│   └── deploy.sh                     # Deployment script
├── .github/
│   └── workflows/
│       └── build.yml                 # CI/CD pipeline
├── rollup.config.js                  # Build configuration
└── package.json                      # Scripts and dependencies
```

### Related Documentation

- [Telnyx API Documentation](https://developers.telnyx.com/)
- [Rollup Configuration Guide](https://rollupjs.org/)
- [Source Maps Specification](https://sourcemaps.info/)

---

## Changelog

| Version | Date | Changes |
|---------|------|---------|
| 1.0.0 | 2024-01-15 | Initial documentation |

---

*For questions or updates, contact the Platform Engineering Team.*