@uvrn/api 1.0.1 → 1.0.3

package/README.md

@@ -2,6 +2,8 @@
 
 UVRN REST API — HTTP server for Delta Engine bundle processing. Exposes run, validate, and verify over HTTP so any client (browser, script, or service) can call the engine without installing the core or SDK.
 
+**Disclaimer:** UVRN is in Alpha testing. The engine measures whether your sources agree with each other — not whether they’re correct. Final trust of output rests with the user. Use at your own risk. Have fun.
+
 ## Install
 
 ```bash
@@ -27,16 +29,20 @@ Or from your app:
 ```typescript
 import { startServer, createServer } from '@uvrn/api';
 
-const server = await createServer();
-await startServer(server);
+// Default: start with default config (port 3000)
+await startServer();
+
+// Or create server with custom config, then listen
+const server = await createServer({ port: 4000 });
+await server.listen({ port: 4000, host: '0.0.0.0' });
 ```
 
-2. **Send a bundle** (e.g. POST to `/delta/run`) and get a receipt in the response. Use `/delta/validate` and `/delta/verify` for validation and verification.
+2. **Send a bundle** (e.g. POST to `/api/v1/delta/run`) and get a receipt in the response. Use `/api/v1/delta/validate` and `/api/v1/delta/verify` for validation and verification.
 
 Example with curl:
 
 ```bash
-curl -X POST http://localhost:3000/delta/run \
+curl -X POST http://localhost:3000/api/v1/delta/run \
   -H "Content-Type: application/json" \
   -d '{"bundleId":"example-001","claim":"Compare sources","thresholdPct":0.1,"dataSpecs":[...]}'
 ```
@@ -49,6 +55,8 @@ curl -X POST http://localhost:3000/delta/run \
 
 ## Links
 
+**Open source:** Source code and issues: [GitHub (uvrn-packages)](https://github.com/UVRN-org/uvrn-packages). Project landing: [UVRN](https://github.com/UVRN-org/uvrn).
+
 - [Repository](https://github.com/UVRN-org/uvrn-packages) — monorepo (this package: `uvrn-api`)
 - [@uvrn/core](https://www.npmjs.com/package/@uvrn/core) — Delta Engine core used by this server
 - [@uvrn/cli](https://www.npmjs.com/package/@uvrn/cli) — run the engine from the command line instead of HTTP

package/package.json

@@ -1,9 +1,15 @@
 {
   "name": "@uvrn/api",
-  "version": "1.0.1",
+  "version": "1.0.3",
+  "publishConfig": {
+    "access": "public"
+  },
   "description": "UVRN REST API — HTTP access to bundle processing",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "bin": {
+    "uvrn-api": "dist/server.js"
+  },
   "keywords": [
     "uvrn",
     "rest-api",
@@ -18,11 +24,11 @@
   },
   "homepage": "https://github.com/UVRN-org/uvrn-packages#readme",
   "dependencies": {
-    "fastify": "^4.25.0",
-    "@fastify/cors": "^8.5.0",
-    "@fastify/rate-limit": "^9.1.0",
-    "@fastify/helmet": "^11.1.0",
-    "@uvrn/core": "1.0.1"
+    "fastify": "^5.7.3",
+    "@fastify/cors": "^10.0.0",
+    "@fastify/rate-limit": "^10.0.0",
+    "@fastify/helmet": "^12.0.0",
+    "@uvrn/core": "^1.0.3"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
@@ -37,8 +43,12 @@
     "typescript": "^5.3.0"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "scripts": {
     "dev": "tsx watch src/server.ts",
     "build": "tsc",

package/TESTING_GUIDE.md

@@ -1,495 +0,0 @@
-# Delta Engine API - Testing Guide
-
-## Quick Start
-
-### 1. Start the Development Server
-
-```bash
-cd packages/uvrn-api
-npm run dev
-```
-
-**What to look for:**
-- ✅ Server starts without errors
-- ✅ You see log messages like:
-  ```
-  🚀 Delta Engine API server running at http://0.0.0.0:3000
-  📊 Health check: http://0.0.0.0:3000/api/v1/health
-  📦 Environment: development
-  🔒 Rate limit: 100 requests per 1 minute
-  ```
-
-### 2. Run Automated Tests
-
-From the repository root:
-
-```bash
-./test-api.sh
-```
-
-This will test all 5 endpoints plus error scenarios.
-
----
-
-## Manual Testing
-
-### Test 1: Health Check ✅
-
-**Purpose:** Verify the server is running and the engine is available
-
-```bash
-curl http://localhost:3000/api/v1/health
-```
-
-**Expected Response (200 OK):**
-```json
-{
-  "status": "healthy",
-  "uptime": 12345,
-  "version": "1.0.0",
-  "engine": {
-    "available": true
-  },
-  "timestamp": "2026-01-15T14:55:00.000Z"
-}
-```
-
-**What to look for:**
-- ✅ `status: "healthy"`
-- ✅ `engine.available: true`
-- ✅ HTTP status code `200`
-
----
-
-### Test 2: Version Information ✅
-
-**Purpose:** Check API, engine, and protocol versions
-
-```bash
-curl http://localhost:3000/api/v1/version
-```
-
-**Expected Response (200 OK):**
-```json
-{
-  "apiVersion": "1.0.0",
-  "engineVersion": "1.0.0",
-  "protocolVersion": "1.0"
-}
-```
-
-**What to look for:**
-- ✅ All version fields present
-- ✅ HTTP status code `200`
-
----
-
-### Test 3: Validate Bundle Schema ✅
-
-**Purpose:** Validate a bundle without executing it
-
-```bash
-curl -X POST http://localhost:3000/api/v1/delta/validate \
-  -H "Content-Type: application/json" \
-  -d '{
-    "bundleId": "test-bundle-001",
-    "claim": "Revenue reconciliation test",
-    "dataSpecs": [
-      {
-        "id": "spec-1",
-        "label": "Q4 Revenue Report",
-        "sourceKind": "report",
-        "originDocIds": ["doc-123"],
-        "metrics": [
-          {"key": "revenue", "value": 100000, "unit": "USD"}
-        ]
-      }
-    ],
-    "thresholdPct": 0.1
-  }'
-```
-
-**Expected Response (200 OK):**
-```json
-{
-  "valid": true
-}
-```
-
-**What to look for:**
-- ✅ `valid: true` for correct bundles
-- ✅ HTTP status code `200`
-
----
-
-### Test 4: Run Engine on Bundle 🚀
-
-**Purpose:** Execute the delta engine and get a receipt
-
-```bash
-curl -X POST http://localhost:3000/api/v1/delta/run \
-  -H "Content-Type: application/json" \
-  -d '{
-    "bundleId": "revenue-q4-2025",
-    "claim": "Q4 2025 revenue: $500K",
-    "dataSpecs": [
-      {
-        "id": "spec-1",
-        "label": "Accounting System",
-        "sourceKind": "report",
-        "originDocIds": ["acc-report-q4"],
-        "metrics": [
-          {"key": "revenue", "value": 500000, "unit": "USD"}
-        ]
-      },
-      {
-        "id": "spec-2",
-        "label": "Sales Database",
-        "sourceKind": "report",
-        "originDocIds": ["sales-db-q4"],
-        "metrics": [
-          {"key": "revenue", "value": 502000, "unit": "USD"}
-        ]
-      }
-    ],
-    "thresholdPct": 0.05
-  }'
-```
-
-**Expected Response (200 OK):**
-```json
-{
-  "bundleId": "revenue-q4-2025",
-  "deltaFinal": 0.004,
-  "sources": ["Accounting System", "Sales Database"],
-  "rounds": [
-    {
-      "round": 1,
-      "deltasByMetric": {"revenue": 0.004},
-      "withinThreshold": true,
-      "witnessRequired": false
-    }
-  ],
-  "suggestedFixes": [],
-  "outcome": "consensus",
-  "hash": "abc123..."
-}
-```
-
-**What to look for:**
-- ✅ Receipt contains all fields: `bundleId`, `deltaFinal`, `sources`, `rounds`, `outcome`, `hash`
-- ✅ `outcome` is either `"consensus"` or `"indeterminate"`
-- ✅ `hash` is a SHA-256 hash string
-- ✅ HTTP status code `200`
-
----
-
-### Test 5: Verify Receipt 🔐
-
-**Purpose:** Verify receipt integrity by recomputing the hash
-
-```bash
-curl -X POST http://localhost:3000/api/v1/delta/verify \
-  -H "Content-Type: application/json" \
-  -d '{
-    "bundleId": "test-001",
-    "deltaFinal": 0.02,
-    "sources": ["Source A", "Source B"],
-    "rounds": [
-      {
-        "round": 1,
-        "deltasByMetric": {"metric1": 0.02},
-        "withinThreshold": true,
-        "witnessRequired": false
-      }
-    ],
-    "suggestedFixes": [],
-    "outcome": "consensus",
-    "hash": "abc123def456..."
-  }'
-```
-
-**Expected Response (200 OK):**
-```json
-{
-  "verified": true,
-  "recomputedHash": "abc123def456..."
-}
-```
-
-**What to look for:**
-- ✅ `verified: true` if hash matches
-- ✅ `verified: false` if hash doesn't match
-- ✅ `recomputedHash` is provided
-- ✅ HTTP status code `200`
-
----
-
-## Error Scenario Testing
-
-### Test 6: Invalid Bundle Schema ❌
-
-```bash
-curl -X POST http://localhost:3000/api/v1/delta/validate \
-  -H "Content-Type: application/json" \
-  -d '{
-    "bundleId": "incomplete",
-    "claim": "Missing dataSpecs field"
-  }'
-```
-
-**Expected Response (200 OK with validation errors):**
-```json
-{
-  "valid": false,
-  "errors": [
-    {
-      "field": "bundle",
-      "message": "Missing required field: dataSpecs"
-    }
-  ]
-}
-```
-
-**What to look for:**
-- ✅ `valid: false`
-- ✅ `errors` array with details
-- ✅ HTTP status code `200` (validation succeeded, bundle failed)
-
----
-
-### Test 7: Wrong Content-Type ❌
-
-```bash
-curl -X POST http://localhost:3000/api/v1/delta/run \
-  -H "Content-Type: text/plain" \
-  -d 'not json'
-```
-
-**Expected Response (415 Unsupported Media Type):**
-```json
-{
-  "error": {
-    "code": "UNSUPPORTED_MEDIA_TYPE",
-    "message": "Content-Type must be application/json",
-    "details": {
-      "receivedContentType": "text/plain"
-    }
-  }
-}
-```
-
-**What to look for:**
-- ✅ HTTP status code `415`
-- ✅ Error message explains the issue
-
----
-
-### Test 8: Malformed JSON ❌
-
-```bash
-curl -X POST http://localhost:3000/api/v1/delta/run \
-  -H "Content-Type: application/json" \
-  -d '{invalid json'
-```
-
-**Expected Response (400 Bad Request):**
-```json
-{
-  "error": {
-    "code": "BAD_REQUEST",
-    "message": "Invalid JSON",
-    "details": {...}
-  }
-}
-```
-
-**What to look for:**
-- ✅ HTTP status code `400`
-- ✅ Clear error message
-
----
-
-### Test 9: Rate Limiting 🚦
-
-```bash
-# Run this in a loop to exceed rate limit
-for i in {1..105}; do
-  curl -s http://localhost:3000/api/v1/health > /dev/null
-done
-curl http://localhost:3000/api/v1/health
-```
-
-**Expected Response (429 Too Many Requests):**
-```json
-{
-  "error": {
-    "code": "RATE_LIMIT_EXCEEDED",
-    "message": "Too many requests, please try again later",
-    "details": {
-      "rateLimitMax": 100,
-      "timeWindow": "1 minute"
-    }
-  }
-}
-```
-
-**What to look for:**
-- ✅ HTTP status code `429`
-- ✅ Rate limit details in response
-
----
-
-### Test 10: 404 Not Found ❌
-
-```bash
-curl http://localhost:3000/api/v1/nonexistent
-```
-
-**Expected Response (404 Not Found):**
-```json
-{
-  "error": {
-    "code": "NOT_FOUND",
-    "message": "Route GET /api/v1/nonexistent not found",
-    "details": {
-      "method": "GET",
-      "url": "/api/v1/nonexistent"
-    }
-  }
-}
-```
-
-**What to look for:**
-- ✅ HTTP status code `404`
-- ✅ Clear error message with URL
-
----
-
-## Testing with Real Bundles
-
-You can test with existing demo bundles from the CLI:
-
-```bash
-# Find demo bundles
-ls ../../examples/*.json
-
-# Test with a real bundle
-curl -X POST http://localhost:3000/api/v1/delta/run \
-  -H "Content-Type: application/json" \
-  -d @../../examples/revenue-bundle.json
-```
-
----
-
-## Server Logs
-
-When running in development mode (`npm run dev`), you'll see detailed logs:
-
-**Good logs to look for:**
-```
-[INFO] Incoming request - GET /api/v1/health
-[INFO] Request completed - Status: 200, Time: 5ms
-```
-
-**Error logs:**
-```
-[ERROR] Engine execution failed - Invalid bundle structure
-[WARN] Rate limit exceeded for IP 127.0.0.1
-```
-
----
-
-## Checklist: Server is Working ✅
-
-After running all tests, verify:
-
-- [ ] Health endpoint returns `healthy` status
-- [ ] Version endpoint returns correct versions
-- [ ] Validate endpoint accepts valid bundles
-- [ ] Validate endpoint rejects invalid bundles
-- [ ] Run endpoint executes engine and returns receipt
-- [ ] Verify endpoint checks receipt integrity
-- [ ] Rate limiting kicks in after 100 requests
-- [ ] Wrong content-type returns 415 error
-- [ ] Malformed JSON returns 400 error
-- [ ] Non-existent routes return 404 error
-- [ ] All responses have correct error structure
-- [ ] Server logs requests and responses
-- [ ] No crashes or unhandled exceptions
-
----
-
-## Performance Testing
-
-To test performance and concurrent requests:
-
-```bash
-# Install autocannon if not already installed
-npm install -g autocannon
-
-# Run load test (100 requests, 10 concurrent)
-autocannon -c 10 -d 10 http://localhost:3000/api/v1/health
-```
-
-**What to look for:**
-- ✅ Response times < 100ms for health endpoint
-- ✅ No 5xx errors under load
-- ✅ Rate limiting works correctly
-
----
-
-## Troubleshooting
-
-### Server won't start
-
-1. Check if port 3000 is already in use:
-   ```bash
-   lsof -i :3000
-   ```
-
-2. Use a different port:
-   ```bash
-   PORT=3001 npm run dev
-   ```
-
-### Engine not available
-
-If health check shows `engine.available: false`:
-
-1. Ensure `@uvrn/core` is installed:
-   ```bash
-   npm list @uvrn/core
-   ```
-
-2. Build the engine package:
-   ```bash
-   cd ../uvrn-core && npm run build
-   ```
-
-### CORS errors (in browser)
-
-If testing from a browser and seeing CORS errors:
-
-1. Set allowed origins in `.env`:
-   ```
-   CORS_ORIGINS=http://localhost:3000,http://localhost:8080
-   ```
-
-2. Restart the server
-
----
-
-## Next Steps
-
-Once all tests pass:
-1. ✅ Proceed to Task A.2.3 (OpenAPI Specification)
-2. ✅ Add integration tests with Jest
-3. ✅ Deploy to staging environment
-4. ✅ Run load tests with realistic traffic
-
----
-
-**Created:** 2026-01-15
-**API Version:** 1.0.0
-**Last Updated:** 2026-01-15

package/jest.config.js

@@ -1,13 +0,0 @@
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  roots: ['<rootDir>/tests'],
-  testMatch: ['**/*.test.ts'],
-  collectCoverageFrom: [
-    'src/**/*.ts',
-    '!src/**/*.d.ts',
-    '!src/index.ts',
-  ],
-  coverageDirectory: 'coverage',
-  coverageReporters: ['text', 'lcov', 'html'],
-};

package/src/config/loader.ts

@@ -1,60 +0,0 @@
-/**
- * Configuration Loader
- * Loads and validates server configuration from environment variables
- */
-
-import { ServerConfig, ConfigValidationError } from './types';
-
-/**
- * Load configuration from environment variables with defaults
- */
-export function loadConfig(): ServerConfig {
-  const config: ServerConfig = {
-    port: parseInt(process.env.PORT || '3000', 10),
-    host: process.env.HOST || '0.0.0.0',
-    corsOrigins: process.env.CORS_ORIGINS?.split(',').map(o => o.trim()) || ['*'],
-    rateLimitMax: parseInt(process.env.RATE_LIMIT_MAX || '100', 10),
-    rateLimitTimeWindow: process.env.RATE_LIMIT_TIME_WINDOW || '1 minute',
-    logLevel: (process.env.LOG_LEVEL as ServerConfig['logLevel']) || 'info',
-    nodeEnv: (process.env.NODE_ENV as ServerConfig['nodeEnv']) || 'development'
-  };
-
-  const errors = validateConfig(config);
-  if (errors.length > 0) {
-    const errorMessages = errors.map(e => `${e.field}: ${e.message}`).join(', ');
-    throw new Error(`Configuration validation failed: ${errorMessages}`);
-  }
-
-  return config;
-}
-
-/**
- * Validate configuration values
- */
-function validateConfig(config: ServerConfig): ConfigValidationError[] {
-  const errors: ConfigValidationError[] = [];
-
-  if (config.port < 1 || config.port > 65535) {
-    errors.push({ field: 'port', message: 'Must be between 1 and 65535' });
-  }
-
-  if (!config.host) {
-    errors.push({ field: 'host', message: 'Host cannot be empty' });
-  }
-
-  if (config.rateLimitMax < 1) {
-    errors.push({ field: 'rateLimitMax', message: 'Must be at least 1' });
-  }
-
-  const validLogLevels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
-  if (!validLogLevels.includes(config.logLevel)) {
-    errors.push({ field: 'logLevel', message: `Must be one of: ${validLogLevels.join(', ')}` });
-  }
-
-  const validNodeEnvs = ['development', 'production', 'test'];
-  if (!validNodeEnvs.includes(config.nodeEnv)) {
-    errors.push({ field: 'nodeEnv', message: `Must be one of: ${validNodeEnvs.join(', ')}` });
-  }
-
-  return errors;
-}

package/src/config/types.ts

@@ -1,18 +0,0 @@
-/**
- * Server Configuration Types
- */
-
-export interface ServerConfig {
-  port: number;
-  host: string;
-  corsOrigins: string[];
-  rateLimitMax: number;
-  rateLimitTimeWindow: string;
-  logLevel: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
-  nodeEnv: 'development' | 'production' | 'test';
-}
-
-export interface ConfigValidationError {
-  field: string;
-  message: string;
-}

package/src/index.ts

@@ -1,13 +0,0 @@
-/**
- * Delta Engine API - Entry Point
- * Exports for programmatic usage
- */
-
-export { startServer, createServer } from './server';
-export type { ServerConfig } from './config/types';
-export type {
-  ErrorResponse,
-  HealthResponse,
-  VersionResponse,
-  ValidationResponse
-} from './types/api';

package/src/middleware/errorHandler.ts

@@ -1,69 +0,0 @@
-/**
- * Global Error Handler
- * Handles uncaught errors and formats error responses
- */
-
-import { FastifyInstance, FastifyError, FastifyRequest, FastifyReply } from 'fastify';
-import { ErrorResponse } from '../types/api';
-
-/**
- * Register global error handler
- */
-export function registerErrorHandler(server: FastifyInstance): void {
-  server.setErrorHandler((error: FastifyError, request: FastifyRequest, reply: FastifyReply) => {
-    // Log the error
-    request.log.error({
-      err: error,
-      url: request.url,
-      method: request.method
-    }, 'Request error');
-
-    // Determine status code
-    const statusCode = error.statusCode || 500;
-
-    // Map error to code
-    let errorCode = 'INTERNAL_ERROR';
-    if (statusCode === 400) errorCode = 'BAD_REQUEST';
-    else if (statusCode === 404) errorCode = 'NOT_FOUND';
-    else if (statusCode === 415) errorCode = 'UNSUPPORTED_MEDIA_TYPE';
-    else if (statusCode === 429) errorCode = 'RATE_LIMIT_EXCEEDED';
-    else if (statusCode === 503) errorCode = 'SERVICE_UNAVAILABLE';
-
-    // Build error response
-    const errorResponse: ErrorResponse = {
-      error: {
-        code: errorCode,
-        message: error.message || 'An unexpected error occurred',
-        details: {
-          statusCode
-        }
-      }
-    };
-
-    // Don't expose internal error details in production
-    if (process.env.NODE_ENV !== 'production' && error.stack) {
-      errorResponse.error.details = {
-        ...errorResponse.error.details,
-        stack: error.stack
-      };
-    }
-
-    reply.code(statusCode).send(errorResponse);
-  });
-
-  // Handle 404 errors
-  server.setNotFoundHandler((request: FastifyRequest, reply: FastifyReply) => {
-    const errorResponse: ErrorResponse = {
-      error: {
-        code: 'NOT_FOUND',
-        message: `Route ${request.method} ${request.url} not found`,
-        details: {
-          method: request.method,
-          url: request.url
-        }
-      }
-    };
-
-    reply.code(404).send(errorResponse);
-  });
-}

package/src/routes/delta.ts

@@ -1,120 +0,0 @@
-/**
- * Delta Engine API Routes
- * Endpoints for bundle processing, validation, and verification
- */
-
-import { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
-import {
-  DeltaBundle,
-  DeltaReceipt,
-  runDeltaEngine,
-  validateBundle,
-  verifyReceipt
-} from '@uvrn/core';
-import { ErrorResponse, ValidationResponse } from '../types/api';
-
-/**
- * Register delta engine routes
- */
-export async function registerDeltaRoutes(server: FastifyInstance): Promise<void> {
-  // POST /api/v1/delta/run - Execute engine on bundle
-  server.post<{
-    Body: DeltaBundle;
-    Reply: DeltaReceipt | ErrorResponse;
-  }>('/api/v1/delta/run', async (request: FastifyRequest<{ Body: DeltaBundle }>, reply: FastifyReply) => {
-    try {
-      const bundle = request.body;
-
-      // Validate bundle schema
-      const validation = validateBundle(bundle);
-      if (!validation.valid) {
-        return reply.code(400).send({
-          error: {
-            code: 'INVALID_BUNDLE',
-            message: 'Bundle validation failed',
-            details: { validationError: validation.error }
-          }
-        });
-      }
-
-      // Execute engine
-      const receipt = runDeltaEngine(bundle);
-
-      return reply.code(200).send(receipt);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      request.log.error({ error: errorMessage }, 'Engine execution failed');
-
-      return reply.code(500).send({
-        error: {
-          code: 'ENGINE_ERROR',
-          message: 'Failed to process bundle',
-          details: { error: errorMessage }
-        }
-      });
-    }
-  });
-
-  // POST /api/v1/delta/validate - Validate bundle schema
-  server.post<{
-    Body: DeltaBundle;
-    Reply: ValidationResponse | ErrorResponse;
-  }>('/api/v1/delta/validate', async (request: FastifyRequest<{ Body: DeltaBundle }>, reply: FastifyReply) => {
-    try {
-      const bundle = request.body;
-      const validation = validateBundle(bundle);
-
-      if (!validation.valid) {
-        return reply.code(200).send({
-          valid: false,
-          errors: [
-            {
-              field: 'bundle',
-              message: validation.error || 'Validation failed'
-            }
-          ]
-        });
-      }
-
-      return reply.code(200).send({ valid: true });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      request.log.error({ error: errorMessage }, 'Validation failed');
-
-      return reply.code(500).send({
-        error: {
-          code: 'VALIDATION_ERROR',
-          message: 'Failed to validate bundle',
-          details: { error: errorMessage }
-        }
-      });
-    }
-  });
-
-  // POST /api/v1/delta/verify - Verify receipt replay
-  server.post<{
-    Body: DeltaReceipt;
-    Reply: { verified: boolean; recomputedHash?: string } | ErrorResponse;
-  }>('/api/v1/delta/verify', async (request: FastifyRequest<{ Body: DeltaReceipt }>, reply: FastifyReply) => {
-    try {
-      const receipt = request.body;
-      const verifyResult = verifyReceipt(receipt);
-
-      return reply.code(200).send({
-        verified: verifyResult.verified,
-        recomputedHash: verifyResult.recomputedHash
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      request.log.error({ error: errorMessage }, 'Verification failed');
-
-      return reply.code(500).send({
-        error: {
-          code: 'VERIFICATION_ERROR',
-          message: 'Failed to verify receipt',
-          details: { error: errorMessage }
-        }
-      });
-    }
-  });
-}

package/src/routes/health.ts

@@ -1,65 +0,0 @@
-/**
- * Health and Version Routes
- * System status and version information endpoints
- */
-
-import { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
-import { HealthResponse, VersionResponse } from '../types/api';
-
-const SERVER_START_TIME = Date.now();
-const API_VERSION = '1.0.0';
-const PROTOCOL_VERSION = '1.0';
-
-/**
- * Register health and version routes
- */
-export async function registerHealthRoutes(server: FastifyInstance): Promise<void> {
-  // GET /api/v1/health - Health check endpoint
-  server.get<{
-    Reply: HealthResponse;
-  }>('/api/v1/health', async (_request: FastifyRequest, reply: FastifyReply) => {
-    const uptime = Date.now() - SERVER_START_TIME;
-
-    // Check if engine is available by attempting to import it
-    let engineAvailable = true;
-    try {
-      require('@uvrn/core');
-    } catch {
-      engineAvailable = false;
-    }
-
-    const health: HealthResponse = {
-      status: engineAvailable ? 'healthy' : 'unhealthy',
-      uptime,
-      version: API_VERSION,
-      engine: {
-        available: engineAvailable
-      },
-      timestamp: new Date().toISOString()
-    };
-
-    const statusCode = engineAvailable ? 200 : 503;
-    return reply.code(statusCode).send(health);
-  });
-
-  // GET /api/v1/version - Version information
-  server.get<{
-    Reply: VersionResponse;
-  }>('/api/v1/version', async (_request: FastifyRequest, reply: FastifyReply) => {
-    let engineVersion = 'unknown';
-    try {
-      const enginePkg = require('@uvrn/core/package.json');
-      engineVersion = enginePkg.version;
-    } catch {
-      // Engine version not available
-    }
-
-    const version: VersionResponse = {
-      apiVersion: API_VERSION,
-      engineVersion,
-      protocolVersion: PROTOCOL_VERSION
-    };
-
-    return reply.code(200).send(version);
-  });
-}

package/src/server.ts

@@ -1,139 +0,0 @@
-/**
- * Delta Engine API Server
- * Fastify-based REST API for bundle processing
- */
-
-import Fastify, { FastifyInstance } from 'fastify';
-import cors from '@fastify/cors';
-import helmet from '@fastify/helmet';
-import rateLimit from '@fastify/rate-limit';
-import { loadConfig } from './config/loader';
-import { ServerConfig } from './config/types';
-import { registerDeltaRoutes } from './routes/delta';
-import { registerHealthRoutes } from './routes/health';
-import { registerErrorHandler } from './middleware/errorHandler';
-
-/**
- * Create and configure Fastify server instance
- */
-export async function createServer(config?: ServerConfig): Promise<FastifyInstance> {
-  // Load configuration
-  const serverConfig = config || loadConfig();
-
-  // Create Fastify instance with logging
-  const server = Fastify({
-    logger: {
-      level: serverConfig.logLevel,
-      transport: serverConfig.nodeEnv === 'development' ? {
-        target: 'pino-pretty',
-        options: {
-          translateTime: 'HH:MM:ss Z',
-          ignore: 'pid,hostname'
-        }
-      } : undefined
-    }
-  });
-
-  // Register plugins
-  await server.register(helmet, {
-    contentSecurityPolicy: serverConfig.nodeEnv === 'production' ? undefined : false
-  });
-
-  await server.register(cors, {
-    origin: serverConfig.corsOrigins,
-    credentials: true
-  });
-
-  await server.register(rateLimit, {
-    max: serverConfig.rateLimitMax,
-    timeWindow: serverConfig.rateLimitTimeWindow,
-    errorResponseBuilder: () => ({
-      error: {
-        code: 'RATE_LIMIT_EXCEEDED',
-        message: 'Too many requests, please try again later',
-        details: {
-          rateLimitMax: serverConfig.rateLimitMax,
-          timeWindow: serverConfig.rateLimitTimeWindow
-        }
-      }
-    })
-  });
-
-  // Add request logging hook
-  server.addHook('onRequest', async (request, _reply) => {
-    request.log.info({
-      url: request.url,
-      method: request.method,
-      ip: request.ip
-    }, 'Incoming request');
-  });
-
-  server.addHook('onResponse', async (request, reply) => {
-    request.log.info({
-      url: request.url,
-      method: request.method,
-      statusCode: reply.statusCode,
-      responseTime: reply.elapsedTime
-    }, 'Request completed');
-  });
-
-  // Validate content-type for POST requests
-  server.addHook('preHandler', async (request, reply) => {
-    if (request.method === 'POST' && request.url.startsWith('/api/v1/delta/')) {
-      const contentType = request.headers['content-type'];
-      if (!contentType || !contentType.includes('application/json')) {
-        return reply.code(415).send({
-          error: {
-            code: 'UNSUPPORTED_MEDIA_TYPE',
-            message: 'Content-Type must be application/json',
-            details: {
-              receivedContentType: contentType || 'none'
-            }
-          }
-        });
-      }
-    }
-  });
-
-  // Register routes
-  await registerHealthRoutes(server);
-  await registerDeltaRoutes(server);
-
-  // Register error handler (must be last)
-  registerErrorHandler(server);
-
-  return server;
-}
-
-/**
- * Start the server
- */
-export async function startServer(config?: ServerConfig): Promise<FastifyInstance> {
-  const serverConfig = config || loadConfig();
-  const server = await createServer(serverConfig);
-
-  try {
-    await server.listen({
-      port: serverConfig.port,
-      host: serverConfig.host
-    });
-
-    server.log.info(`🚀 Delta Engine API server running at http://${serverConfig.host}:${serverConfig.port}`);
-    server.log.info(`📊 Health check: http://${serverConfig.host}:${serverConfig.port}/api/v1/health`);
-    server.log.info(`📦 Environment: ${serverConfig.nodeEnv}`);
-    server.log.info(`🔒 Rate limit: ${serverConfig.rateLimitMax} requests per ${serverConfig.rateLimitTimeWindow}`);
-
-    return server;
-  } catch (error) {
-    server.log.error(error);
-    throw error;
-  }
-}
-
-// Start server if run directly
-if (require.main === module) {
-  startServer().catch((error) => {
-    console.error('Failed to start server:', error);
-    process.exit(1);
-  });
-}

package/src/types/api.ts

@@ -1,35 +0,0 @@
-/**
- * API-specific type definitions
- */
-
-export interface ErrorResponse {
-  error: {
-    code: string;
-    message: string;
-    details?: Record<string, unknown>;
-  };
-}
-
-export interface HealthResponse {
-  status: 'healthy' | 'unhealthy';
-  uptime: number;
-  version: string;
-  engine: {
-    available: boolean;
-  };
-  timestamp: string;
-}
-
-export interface VersionResponse {
-  apiVersion: string;
-  engineVersion: string;
-  protocolVersion: string;
-}
-
-export interface ValidationResponse {
-  valid: boolean;
-  errors?: Array<{
-    field: string;
-    message: string;
-  }>;
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "tests"]
-}