@intentsolutionsio/vercel-pack 1.0.0 → 1.0.3

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Jeremy Longshore
+Copyright (c) 2026 Jeremy Longshore
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,6 +1,12 @@
 # Vercel Skill Pack
 
-> Claude Code skill pack for Vercel integration (30 skills)
+> 30 production-grade Claude Code skills for Vercel deployments, serverless functions, Edge Runtime, and platform operations.
+
+Deploy, scale, and operate Vercel applications with real API endpoints (`api.vercel.com/v9/*`), real CLI commands (`vercel deploy`, `vercel env`, `vercel rollback`), real Edge Function patterns (`export const config = { runtime: 'edge' }`), and real error codes (`FUNCTION_INVOCATION_FAILED`, `FUNCTION_THROTTLED`). Every skill contains working code, not placeholders.
+
+**Links:** [Vercel Docs](https://vercel.com/docs) | [Vercel REST API](https://vercel.com/docs/rest-api) | [Install](#installation)
+
+---
 
 ## Installation
 
@@ -8,61 +14,78 @@
 /plugin install vercel-pack@claude-code-plugins-plus
 ```
 
-## Skills Included
+## What's Inside
 
 ### Standard Skills (S01-S12)
-| Skill | Description |
-|-------|-------------|
-| `vercel-install-auth` | Install Auth |
-| `vercel-hello-world` | Hello World |
-| `vercel-local-dev-loop` | Local Dev Loop |
-| `vercel-sdk-patterns` | Sdk Patterns |
-| `vercel-deploy-preview` | Deploy Preview |
-| `vercel-edge-functions` | Edge Functions |
-| `vercel-common-errors` | Common Errors |
-| `vercel-debug-bundle` | Debug Bundle |
-| `vercel-rate-limits` | Rate Limits |
-| `vercel-security-basics` | Security Basics |
-| `vercel-prod-checklist` | Prod Checklist |
-| `vercel-upgrade-migration` | Upgrade Migration |
+
+| # | Skill | What It Does |
+|---|-------|-------------|
+| S01 | `vercel-install-auth` | Install CLI, create scoped access tokens, link projects, pull env vars |
+| S02 | `vercel-hello-world` | Deploy minimal project with static page + serverless API route |
+| S03 | `vercel-local-dev-loop` | Run `vercel dev`, manage `.env` files, test functions locally with Vitest |
+| S04 | `vercel-sdk-patterns` | Typed REST API client wrapper with pagination, retry, and error classes |
+| S05 | `vercel-deploy-preview` | Create preview deployments via CLI and API, configure deployment protection |
+| S06 | `vercel-edge-functions` | Build Edge Functions with geo headers, middleware, streaming, Edge Config |
+| S07 | `vercel-common-errors` | Diagnose BUILD_FAILED, FUNCTION_INVOCATION_TIMEOUT, 404s, and env var issues |
+| S08 | `vercel-debug-bundle` | Collect deployment state, function logs, and platform status for support tickets |
+| S09 | `vercel-rate-limits` | Handle API 429s with retry, implement WAF rate limiting with @vercel/firewall |
+| S10 | `vercel-security-basics` | Security headers, CSP, deployment protection, token rotation, secret scoping |
+| S11 | `vercel-prod-checklist` | Production deploy checklist with domain setup, health checks, instant rollback |
+| S12 | `vercel-upgrade-migration` | Upgrade CLI, Node.js runtime, Next.js versions with breaking change detection |
 
 ### Pro Skills (P13-P18)
-| Skill | Description |
-|-------|-------------|
-| `vercel-ci-integration` | Ci Integration |
-| `vercel-deploy-integration` | Deploy Integration |
-| `vercel-webhooks-events` | Webhooks Events |
-| `vercel-performance-tuning` | Performance Tuning |
-| `vercel-cost-tuning` | Cost Tuning |
-| `vercel-reference-architecture` | Reference Architecture |
+
+| # | Skill | What It Does |
+|---|-------|-------------|
+| P13 | `vercel-ci-integration` | GitHub Actions workflows for preview on PR, production on merge, test gating |
+| P14 | `vercel-deploy-integration` | Production deploy methods, instant rollback, rolling releases, deploy hooks |
+| P15 | `vercel-webhooks-events` | Handle deployment.ready/error webhooks with HMAC signature verification |
+| P16 | `vercel-performance-tuning` | Edge caching, ISR, cold start elimination, bundle optimization, image optimization |
+| P17 | `vercel-cost-tuning` | Fluid Compute pricing, function memory right-sizing, spend management |
+| P18 | `vercel-reference-architecture` | Layered project structure with typed env vars, lazy DB, health checks |
 
 ### Flagship Skills (F19-F24)
-| Skill | Description |
-|-------|-------------|
-| `vercel-multi-env-setup` | Multi Env Setup |
-| `vercel-observability` | Observability |
-| `vercel-incident-runbook` | Incident Runbook |
-| `vercel-data-handling` | Data Handling |
-| `vercel-enterprise-rbac` | Enterprise Rbac |
-| `vercel-migration-deep-dive` | Migration Deep Dive |
+
+| # | Skill | What It Does |
+|---|-------|-------------|
+| F19 | `vercel-multi-env-setup` | Scoped env vars per environment, custom environments, branch-specific domains |
+| F20 | `vercel-observability` | Vercel Analytics, runtime logs, log drains, OpenTelemetry, Sentry integration |
+| F21 | `vercel-incident-runbook` | 5-minute triage, instant rollback procedure, communication templates, postmortem |
+| F22 | `vercel-data-handling` | PII redaction, GDPR data subject requests, data residency via function regions |
+| F23 | `vercel-enterprise-rbac` | Team roles, Access Groups, SAML SSO, audit logging, middleware-level auth |
+| F24 | `vercel-migration-deep-dive` | Migrate from Netlify/AWS/Cloudflare with config mapping and DNS cutover |
 
 ### Flagship+ Skills (X25-X30)
-| Skill | Description |
-|-------|-------------|
-| `vercel-advanced-troubleshooting` | Advanced Troubleshooting |
-| `vercel-load-scale` | Load Scale |
-| `vercel-reliability-patterns` | Reliability Patterns |
-| `vercel-policy-guardrails` | Policy Guardrails |
-| `vercel-architecture-variants` | Architecture Variants |
-| `vercel-known-pitfalls` | Known Pitfalls |
+
+| # | Skill | What It Does |
+|---|-------|-------------|
+| X25 | `vercel-advanced-troubleshooting` | Request tracing, cold start analysis, bundle inspection, edge crash debugging |
+| X26 | `vercel-load-scale` | k6/autocannon load tests, Fluid Compute concurrency tuning, capacity planning |
+| X27 | `vercel-reliability-patterns` | Circuit breakers, retry with backoff, stale cache fallback, idempotency keys |
+| X28 | `vercel-policy-guardrails` | ESLint rules, pre-commit credential scanning, CI policy checks, deploy freezes |
+| X29 | `vercel-architecture-variants` | 5 architecture blueprints from static site to multi-zone enterprise |
+| X30 | `vercel-known-pitfalls` | 15 anti-patterns with severity ratings, detection scripts, and fixes |
 
 ## Usage
 
-Skills trigger automatically when you discuss Vercel topics. For example:
+Skills trigger automatically when you discuss Vercel topics:
+
+- "Help me set up Vercel" triggers `vercel-install-auth`
+- "Deploy my app to production" triggers `vercel-prod-checklist`
+- "My Vercel function is timing out" triggers `vercel-common-errors`
+- "Set up edge middleware for auth" triggers `vercel-edge-functions`
+- "Why is my Vercel bill so high?" triggers `vercel-cost-tuning`
+
+## Key API Endpoints Covered
 
-- "Help me set up Vercel" → triggers `vercel-install-auth`
-- "Debug this Vercel error" → triggers `vercel-common-errors`
-- "Deploy my Vercel integration" → triggers `vercel-deploy-integration`
+| Operation | Method | Endpoint |
+|-----------|--------|----------|
+| List projects | GET | `/v9/projects` |
+| Create deployment | POST | `/v13/deployments` |
+| List deployments | GET | `/v6/deployments` |
+| Manage env vars | GET/POST/PATCH/DELETE | `/v9/projects/{id}/env` |
+| Add domain | POST | `/v9/projects/{id}/domains` |
+| Promote deployment | POST | `/v9/projects/{id}/promote` |
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentsolutionsio/vercel-pack",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "Claude Code skill pack for Vercel - 30 skills covering deployments, edge functions, preview environments, performance optimization, and production operations",
   "main": "README.md",
   "type": "module",
@@ -30,13 +30,13 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/jeremylongshore/claude-code-plugins.git",
+    "url": "git+https://github.com/jeremylongshore/claude-code-plugins-plus-skills.git",
     "directory": "plugins/saas-packs/vercel-pack"
   },
   "bugs": {
-    "url": "https://github.com/jeremylongshore/claude-code-plugins/issues"
+    "url": "https://github.com/jeremylongshore/claude-code-plugins-plus-skills/issues"
   },
-  "homepage": "https://claudecodeplugins.io/plugins/vercel-pack",
+  "homepage": "https://tonsofskills.com/learn/vercel/",
   "publishConfig": {
     "access": "public"
   }

package/skills/vercel-advanced-troubleshooting/SKILL.md

@@ -1,261 +1,251 @@
 ---
 name: vercel-advanced-troubleshooting
-description: |
-  Apply Vercel advanced debugging techniques for hard-to-diagnose issues.
-  Use when standard troubleshooting fails, investigating complex race conditions,
-  or preparing evidence bundles for Vercel support escalation.
+description: 'Advanced debugging for hard-to-diagnose Vercel issues including cold
+  starts, edge errors, and function tracing.
+
+  Use when standard troubleshooting fails, investigating intermittent failures,
+
+  or preparing evidence for Vercel support escalation.
+
   Trigger with phrases like "vercel hard bug", "vercel mystery error",
-  "vercel impossible to debug", "difficult vercel issue", "vercel deep debug".
-allowed-tools: Read, Grep, Bash(kubectl:*), Bash(curl:*), Bash(tcpdump:*)
+
+  "vercel intermittent failure", "difficult vercel issue", "vercel deep debug".
+
+  '
+allowed-tools: Read, Grep, Bash(vercel:*), Bash(curl:*), Bash(jq:*)
 version: 1.0.0
 license: MIT
 author: Jeremy Longshore <jeremy@intentsolutions.io>
+tags:
+- saas
+- vercel
+- debugging
+- advanced
+- troubleshooting
+compatibility: Designed for Claude Code, also compatible with Codex and OpenClaw
 ---
-
 # Vercel Advanced Troubleshooting
 
 ## Overview
-Deep debugging techniques for complex Vercel issues that resist standard troubleshooting.
+
+Diagnose hard-to-find Vercel issues: intermittent cold start failures, edge function crashes, region-specific behavior, function bundling problems, and serverless concurrency issues. Uses systematic isolation, request tracing, and Vercel-specific debugging techniques.
 
 ## Prerequisites
-- Access to production logs and metrics
-- kubectl access to clusters
-- Network capture tools available
-- Understanding of distributed tracing
 
-## Evidence Collection Framework
+- Vercel CLI with access to production logs
+- Familiarity with `vercel-common-errors` (standard debugging)
+- `curl` and `jq` for API inspection
+- Access to deployment inspection tools
+
+## Instructions
+
+### Step 1: Request-Level Tracing
 
-### Comprehensive Debug Bundle
 ```bash
-#!/bin/bash
-# advanced-vercel-debug.sh
+# Trace a single request through Vercel's edge network
+curl -v https://yourdomain.com/api/endpoint 2>&1 | grep -E "x-vercel|cf-ray|age|cache"
+
+# Key headers to check:
+# x-vercel-id: <region>::<function-id> — which region served the request
+# x-vercel-cache: HIT/MISS/STALE — edge cache status
+# x-vercel-execution-region: iad1 — function execution region
+# age: 45 — seconds since edge cached the response
+# x-matched-path: /api/endpoint — routing match result
+```
+
+### Step 2: Cold Start Investigation
 
-BUNDLE="vercel-advanced-debug-$(date +%Y%m%d-%H%M%S)"
-mkdir -p "$BUNDLE"/{logs,metrics,network,config,traces}
+```typescript
+// Instrument cold start timing in your function
+let coldStart = true;
+const initTime = Date.now();
+
+export default function handler(req, res) {
+  const isCold = coldStart;
+  coldStart = false;
+
+  const handlerStart = Date.now();
+  // ... your logic ...
+
+  res.setHeader('x-cold-start', String(isCold));
+  res.setHeader('x-init-duration', String(handlerStart - initTime));
+  res.json({
+    coldStart: isCold,
+    initDuration: isCold ? handlerStart - initTime : 0,
+    handlerDuration: Date.now() - handlerStart,
+    region: process.env.VERCEL_REGION,
+  });
+}
+```
 
-# 1. Extended logs (1 hour window)
-kubectl logs -l app=vercel-integration --since=1h > "$BUNDLE/logs/pods.log"
-journalctl -u vercel-service --since "1 hour ago" > "$BUNDLE/logs/system.log"
+```bash
+# Measure cold start frequency over N requests
+for i in $(seq 1 20); do
+  curl -s https://yourdomain.com/api/endpoint \
+    | jq '{coldStart, initDuration, region}'
+  sleep 2  # Wait between requests to allow isolate recycling
+done
+```
 
-# 2. Metrics dump
-curl -s localhost:9090/api/v1/query?query=vercel_requests_total > "$BUNDLE/metrics/requests.json"
-curl -s localhost:9090/api/v1/query?query=vercel_errors_total > "$BUNDLE/metrics/errors.json"
+### Step 3: Function Bundle Analysis
 
-# 3. Network capture (30 seconds)
-timeout 30 tcpdump -i any port 443 -w "$BUNDLE/network/capture.pcap" &
+```bash
+# Check what's being bundled into your function
+vercel inspect https://my-app-xxx.vercel.app
 
-# 4. Distributed traces
-curl -s localhost:16686/api/traces?service=vercel > "$BUNDLE/traces/jaeger.json"
+# Check function sizes in the deployment
+curl -s -H "Authorization: Bearer $VERCEL_TOKEN" \
+  "https://api.vercel.com/v13/deployments/dpl_xxx" \
+  | jq '.functions | to_entries[] | {path: .key, size: .value.size, regions: .value.regions}'
 
-# 5. Configuration state
-kubectl get cm vercel-config -o yaml > "$BUNDLE/config/configmap.yaml"
-kubectl get secret vercel-secrets -o yaml > "$BUNDLE/config/secrets-redacted.yaml"
+# Locally — check what @vercel/nft traces for a function
+npx @vercel/nft print api/heavy-endpoint.ts 2>/dev/null | head -50
+# Shows all files that will be bundled
 
-tar -czf "$BUNDLE.tar.gz" "$BUNDLE"
-echo "Advanced debug bundle: $BUNDLE.tar.gz"
+# Find unexpectedly large dependencies
+npx @vercel/nft print api/heavy-endpoint.ts 2>/dev/null \
+  | xargs -I {} du -sh {} 2>/dev/null | sort -rh | head -20
 ```
 
-## Systematic Isolation
-
-### Layer-by-Layer Testing
+### Step 4: Region-Specific Debugging
 
-```typescript
-// Test each layer independently
-async function diagnoseVercelIssue(): Promise<DiagnosisReport> {
-  const results: DiagnosisResult[] = [];
+```bash
+# Test from different regions to isolate geographic issues
+# Use Vercel's deployment URL with region hints
+for region in iad1 sfo1 cdg1 hnd1; do
+  echo "=== Region: $region ==="
+  curl -s -w "HTTP %{http_code} | Time: %{time_total}s\n" \
+    -H "x-vercel-ip-country: US" \
+    https://yourdomain.com/api/endpoint
+done
+
+# Check if the issue is region-dependent
+# If latency varies wildly, check:
+# 1. Function region vs database region (cross-region latency)
+# 2. Edge middleware adding delay
+# 3. External API calls from wrong region
+```
 
-  // Layer 1: Network connectivity
-  results.push(await testNetworkConnectivity());
+### Step 5: Edge Function Crash Debugging
 
-  // Layer 2: DNS resolution
-  results.push(await testDNSResolution('api.vercel.com'));
+```typescript
+// Edge functions crash silently on Node.js API usage
+// Common crashes and their symptoms:
 
-  // Layer 3: TLS handshake
-  results.push(await testTLSHandshake('api.vercel.com'));
+// Symptom: EDGE_FUNCTION_INVOCATION_FAILED with no error details
+// Cause: Using Node.js Buffer, fs, crypto.createHash in edge runtime
 
-  // Layer 4: Authentication
-  results.push(await testAuthentication());
+// Diagnostic: check if imports are edge-compatible
+export const config = { runtime: 'edge' };
 
-  // Layer 5: API response
-  results.push(await testAPIResponse());
+export default function handler(request: Request) {
+  // This will crash silently:
+  // const hash = require('crypto').createHash('sha256');
 
-  // Layer 6: Response parsing
-  results.push(await testResponseParsing());
+  // Use Web Crypto instead:
+  const encoder = new TextEncoder();
+  const data = encoder.encode('test');
+  const hashBuffer = await crypto.subtle.digest('SHA-256', data);
 
-  return { results, firstFailure: results.find(r => !r.success) };
+  return Response.json({ ok: true });
 }
 ```
 
-### Minimal Reproduction
-
-```typescript
-// Strip down to absolute minimum
-async function minimalRepro(): Promise<void> {
-  // 1. Fresh client, no customization
-  const client = new VercelClient({
-    apiKey: process.env.VERCEL_API_KEY!,
-  });
-
-  // 2. Simplest possible call
-  try {
-    const result = await client.ping();
-    console.log('Ping successful:', result);
-  } catch (error) {
-    console.error('Ping failed:', {
-      message: error.message,
-      code: error.code,
-      stack: error.stack,
-    });
-  }
-}
+```bash
+# Check if a module is edge-compatible
+npx edge-runtime --eval "import('your-module')" 2>&1
+# Errors here mean the module won't work in edge functions
 ```
 
-## Timing Analysis
+### Step 6: Concurrency and Throttling Debug
 
-```typescript
-class TimingAnalyzer {
-  private timings: Map<string, number[]> = new Map();
-
-  async measure<T>(label: string, fn: () => Promise<T>): Promise<T> {
-    const start = performance.now();
-    try {
-      return await fn();
-    } finally {
-      const duration = performance.now() - start;
-      const existing = this.timings.get(label) || [];
-      existing.push(duration);
-      this.timings.set(label, existing);
-    }
-  }
-
-  report(): TimingReport {
-    const report: TimingReport = {};
-    for (const [label, times] of this.timings) {
-      report[label] = {
-        count: times.length,
-        min: Math.min(...times),
-        max: Math.max(...times),
-        avg: times.reduce((a, b) => a + b, 0) / times.length,
-        p95: this.percentile(times, 95),
-      };
-    }
-    return report;
-  }
-}
-```
+```bash
+# Check current function concurrency limits
+curl -s -H "Authorization: Bearer $VERCEL_TOKEN" \
+  "https://api.vercel.com/v9/projects/my-app" \
+  | jq '{plan: .plan, concurrency: .concurrencyBucketName}'
 
-## Memory and Resource Analysis
+# Hobby: 10 concurrent, Pro: 1000, Enterprise: 100000
 
-```typescript
-// Detect memory leaks in Vercel client usage
-const heapUsed: number[] = [];
-
-setInterval(() => {
-  const usage = process.memoryUsage();
-  heapUsed.push(usage.heapUsed);
-
-  // Alert on sustained growth
-  if (heapUsed.length > 60) { // 1 hour at 1/min
-    const trend = heapUsed[59] - heapUsed[0];
-    if (trend > 100 * 1024 * 1024) { // 100MB growth
-      console.warn('Potential memory leak in vercel integration');
-    }
-  }
-}, 60000);
+# Load test to find throttling threshold
+npx autocannon -c 50 -d 10 https://yourdomain.com/api/endpoint
+# Watch for 429 responses indicating FUNCTION_THROTTLED
 ```
 
-## Race Condition Detection
+### Step 7: Systematic Isolation
 
-```typescript
-// Detect concurrent access issues
-class VercelConcurrencyChecker {
-  private inProgress: Set<string> = new Set();
-
-  async execute<T>(key: string, fn: () => Promise<T>): Promise<T> {
-    if (this.inProgress.has(key)) {
-      console.warn(`Concurrent access detected for ${key}`);
-    }
-
-    this.inProgress.add(key);
-    try {
-      return await fn();
-    } finally {
-      this.inProgress.delete(key);
-    }
-  }
-}
 ```
+Issue persists? Isolate systematically:
 
-## Support Escalation Template
+1. Does it happen on preview deployments?
+   └── No → Production-only env var or domain issue
 
-```markdown
-## Vercel Support Escalation
+2. Does it happen with a minimal function?
+   └── No → Issue is in your code, not Vercel platform
 
-**Severity:** P[1-4]
-**Request ID:** [from error response]
-**Timestamp:** [ISO 8601]
+3. Does it happen in all regions?
+   └── No → Region-specific infrastructure issue
 
-### Issue Summary
-[One paragraph description]
+4. Does it happen with edge runtime?
+   └── No → Node.js-specific issue (cold starts, module compat)
 
-### Steps to Reproduce
-1. [Step 1]
-2. [Step 2]
+5. Does it happen without middleware?
+   └── No → Middleware is interfering — check matcher scope
 
-### Expected vs Actual
-- Expected: [behavior]
-- Actual: [behavior]
+6. Create minimal reproduction:
+   └── api/test.ts with only the failing behavior
+   └── Deploy standalone and test
+```
 
-### Evidence Attached
-- [ ] Debug bundle (vercel-advanced-debug-*.tar.gz)
-- [ ] Minimal reproduction code
-- [ ] Timing analysis
-- [ ] Network capture (if relevant)
+### Step 8: Vercel Support Escalation
 
-### Workarounds Attempted
-1. [Workaround 1] - Result: [outcome]
-2. [Workaround 2] - Result: [outcome]
-```
+```bash
+# Collect comprehensive evidence
+mkdir vercel-debug && cd vercel-debug
 
-## Instructions
+# Deployment details
+vercel inspect https://yourdomain.com > inspect.txt
+vercel logs https://yourdomain.com --limit=200 > logs.txt
 
-### Step 1: Collect Evidence Bundle
-Run the comprehensive debug script to gather all relevant data.
+# Request trace
+curl -v https://yourdomain.com/api/failing-endpoint 2>&1 > curl-trace.txt
 
-### Step 2: Systematic Isolation
-Test each layer independently to identify the failure point.
+# Function analysis
+curl -s -H "Authorization: Bearer $VERCEL_TOKEN" \
+  "https://api.vercel.com/v13/deployments/dpl_xxx" > deployment.json
 
-### Step 3: Create Minimal Reproduction
-Strip down to the simplest failing case.
+# Platform status at time of issue
+curl -s "https://www.vercel-status.com/api/v2/summary.json" > status.json
 
-### Step 4: Escalate with Evidence
-Use the support template with all collected evidence.
+tar czf vercel-debug-$(date +%Y%m%d).tar.gz .
+```
 
 ## Output
-- Comprehensive debug bundle collected
-- Failure layer identified
-- Minimal reproduction created
-- Support escalation submitted
 
-## Error Handling
-| Issue | Cause | Solution |
-|-------|-------|----------|
-| Can't reproduce | Race condition | Add timing analysis |
-| Intermittent failure | Timing-dependent | Increase sample size |
-| No useful logs | Missing instrumentation | Add debug logging |
-| Memory growth | Resource leak | Use heap profiling |
+- Request traced through Vercel's edge network with region and cache data
+- Cold start frequency and duration quantified
+- Function bundle analyzed for size issues
+- Issue isolated to specific layer (edge, runtime, region, middleware)
+- Evidence bundle ready for support escalation
 
-## Examples
+## Error Handling
 
-### Quick Layer Test
-```bash
-# Test each layer in sequence
-curl -v https://api.vercel.com/health 2>&1 | grep -E "(Connected|TLS|HTTP)"
-```
+| Symptom | Likely Cause | Debug Approach |
+|---------|-------------|---------------|
+| Intermittent 500 errors | Cold start + unhandled async | Add global error handler, check init code |
+| Latency spikes every ~15 min | Function isolate recycling (cold start) | Measure with x-cold-start header |
+| Works in preview, fails in prod | Env var scope mismatch | Compare env vars across environments |
+| EDGE_FUNCTION_INVOCATION_FAILED | Node.js API in edge runtime | Check imports for Node.js-only modules |
+| Function works locally, fails deployed | Missing dependency or env var | Run `vercel build` locally, check output |
 
 ## Resources
-- [Vercel Support Portal](https://support.vercel.com)
-- [Vercel Status Page](https://www.vercel-status.com)
+
+- [Vercel Error Codes](https://vercel.com/docs/errors)
+- [Function Limitations](https://vercel.com/docs/functions/limitations)
+- [Edge Runtime API](https://vercel.com/docs/functions/runtimes/edge)
+- [Vercel Support](https://vercel.com/support)
+- [@vercel/nft](https://github.com/vercel/nft)
 
 ## Next Steps
-For load testing, see `vercel-load-scale`.
+
+For load testing and scaling, see `vercel-load-scale`.

package/skills/vercel-advanced-troubleshooting/references/errors.md

@@ -0,0 +1,11 @@
+# Error Handling Reference
+
+| Issue | Cause | Solution |
+|-------|-------|----------|
+| Can't reproduce | Race condition | Add timing analysis |
+| Intermittent failure | Timing-dependent | Increase sample size |
+| No useful logs | Missing instrumentation | Add debug logging |
+| Memory growth | Resource leak | Use heap profiling |
+
+---
+*[Tons of Skills](https://tonsofskills.com) by [Intent Solutions](https://intentsolutions.io) | [jeremylongshore.com](https://jeremylongshore.com)*