yakmesh 1.3.1 → 1.3.2

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 All notable changes to YAKMESH will be documented in this file.
 
+## [1.3.2] - 2026-01-17
+
+### Added
+- **Public Content Delivery API** - Content-addressed storage for decentralized website hosting
+- `GET /content` - List available content with stats
+- `GET /content/:hash` - Fetch content by hash with optional proof
+- `POST /content` - Publish content with consensus verification
+- Content gossip via mesh for cross-node synchronization
+- Consensus proof system for verified content
+
+### Fixed
+- Gossip protocol method calls (use `spreadRumor()` instead of `broadcast()`)
+- Direct messaging via mesh instead of non-existent gossip.sendTo()
+
+### Community
+- Added social links: Discord, Telegram, X (Twitter)
+- Created Discord announcement template
+
+---
+
 ## [1.3.1] - 2026-01-16
 
 ### Security

package/README.md

@@ -179,6 +179,12 @@ See [TRADEMARK.md](TRADEMARK.md) for trademark usage policy.
   <br><br>
   <strong><a href="https://yakmesh.dev">yakmesh.dev</a></strong>
   <br><br>
+  <p>
+    <a href="https://discord.gg/E62tAE2wGh">💬 Discord</a> •
+    <a href="https://t.me/yakmesh">📱 Telegram</a> •
+    <a href="https://x.com/yakmesh">𝕏 Twitter</a>
+  </p>
+  <br>
   <sub>© 2026 YAKMESH™ Project. Sturdy & Secure.</sub>
   <br>
   <sub>YAKMESH™ is a trademark of PeerQuanta, application pending (Serial No. 99594620).</sub>

package/announcements/discord-v1.3.1.md

@@ -0,0 +1,55 @@
+# 🦬 YAKMESH v1.3.1 — Public Content Delivery + Mesh Peering Confirmed!
+
+Hey everyone! Big update today:
+
+## ✅ What's New
+
+### 🌐 Public Content Delivery API
+We've added a complete **content-addressed storage system** with public delivery:
+
+```
+GET /content/:hash          → Fetch any content by its hash
+GET /content/:hash/proof    → Get consensus proof for verification
+POST /content/publish       → Store and gossip content to mesh
+```
+
+**Key features:**
+- Content addressed by SHA3-256 hash (trustless verification)
+- Consensus proofs for light client verification
+- LRU caching for instant edge delivery
+- Automatic mesh sync via gossip protocol
+
+### 🔗 First Successful LAN Mesh Peering
+Tested and confirmed: **two Yakmesh nodes successfully peered** with matching network fingerprints. The Code Proof Protocol verified both were running identical codebases before allowing the connection.
+
+**Connection is as simple as:**
+```powershell
+POST http://localhost:3000/connect
+{ "address": "ws://192.168.1.178:9001" }
+```
+
+### 📱 New Social Channels
+We're now on:
+- 💬 **Discord**: https://discord.gg/E62tAE2wGh
+- 📱 **Telegram**: https://t.me/yakmesh  
+- 𝕏 **Twitter**: https://x.com/yakmesh
+
+## 📦 Install
+
+```bash
+npm install yakmesh@1.3.1
+```
+
+## 🔗 Links
+- 🌐 Website: https://yakmesh.dev
+- 📖 GitHub: https://github.com/yakmesh/yakmesh
+- 📦 npm: https://npmjs.com/package/yakmesh
+
+---
+
+**What's next?**
+- Multi-node cluster testing
+- Production deployment
+- Website/webapp hosting demos
+
+Questions? Drop them here! 🦬

package/content/api.js

@@ -0,0 +1,348 @@
+/**
+ * YAKMESH™ Public Content API
+ * HTTP endpoints for public content delivery
+ * 
+ * Public (no auth required):
+ * - GET /content/:hash - Fetch content by hash
+ * - GET /content/:hash/meta - Fetch metadata only
+ * - GET /content/:hash/proof - Fetch consensus proof
+ * - GET /content/list - List available content
+ * 
+ * Authenticated (rate limited):
+ * - POST /content/publish - Publish new content
+ * - DELETE /content/:hash - Remove content (owner only)
+ * 
+ * @module content/api
+ * @license MIT
+ * @copyright 2026 YAKMESH Contributors
+ */
+
+import { Router } from 'express';
+import { ContentStore, ContentType, ContentStatus, computeContentHash } from './store.js';
+
+/**
+ * Create content API router
+ */
+export function createContentAPI(contentStore, options = {}) {
+  const router = Router();
+  
+  const {
+    writeLimiter,
+    readLimiter,
+    validateString,
+  } = options;
+
+  // =========================================
+  // PUBLIC READ ENDPOINTS (No Auth)
+  // =========================================
+
+  /**
+   * GET /content/:hash
+   * Fetch content by hash with optional proof
+   * 
+   * Query params:
+   * - proof=1 : Include consensus proof in response headers
+   * - download=1 : Force download (Content-Disposition)
+   */
+  router.get('/:hash', readLimiter, (req, res) => {
+    const { hash } = req.params;
+    const includeProof = req.query.proof === '1';
+    const download = req.query.download === '1';
+
+    // Get content with metadata
+    const result = contentStore.getWithProof(hash);
+    
+    if (!result) {
+      return res.status(404).json({ 
+        error: 'Content not found',
+        hash,
+        hint: 'Content may not have synced yet. Try again later.',
+      });
+    }
+
+    // Set content type
+    res.setHeader('Content-Type', result.meta?.contentType || 'application/octet-stream');
+    res.setHeader('Content-Length', result.meta?.size || result.content.length);
+    res.setHeader('X-Content-Hash', result.hash);
+    res.setHeader('X-Content-Status', result.meta?.status || 'unknown');
+    
+    // Cache headers (immutable content = cache forever)
+    if (result.verified) {
+      res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
+    } else {
+      res.setHeader('Cache-Control', 'public, max-age=60');
+    }
+
+    // Include proof in headers if requested
+    if (includeProof && result.proof) {
+      res.setHeader('X-Consensus-Proof', JSON.stringify(result.proof));
+      res.setHeader('X-Verified', result.verified ? 'true' : 'false');
+    }
+
+    // Download disposition
+    if (download && result.meta?.name) {
+      res.setHeader('Content-Disposition', `attachment; filename="${result.meta.name}"`);
+    }
+
+    // Send content
+    res.send(result.content);
+  });
+
+  /**
+   * GET /content/:hash/meta
+   * Fetch metadata only (no content body)
+   */
+  router.get('/:hash/meta', readLimiter, (req, res) => {
+    const { hash } = req.params;
+    const meta = contentStore.getMeta(hash);
+    
+    if (!meta) {
+      return res.status(404).json({ error: 'Content not found', hash });
+    }
+
+    res.json(meta.toJSON ? meta.toJSON() : meta);
+  });
+
+  /**
+   * GET /content/:hash/proof
+   * Fetch consensus proof for light client verification
+   */
+  router.get('/:hash/proof', readLimiter, (req, res) => {
+    const { hash } = req.params;
+    const meta = contentStore.getMeta(hash);
+    
+    if (!meta) {
+      return res.status(404).json({ error: 'Content not found', hash });
+    }
+
+    if (!meta.consensusProof) {
+      return res.status(404).json({ 
+        error: 'No consensus proof yet',
+        hash,
+        status: meta.status,
+        hint: 'Content may still be pending consensus.',
+      });
+    }
+
+    res.json({
+      hash,
+      verified: meta.status === ContentStatus.VERIFIED,
+      proof: meta.consensusProof.toJSON ? meta.consensusProof.toJSON() : meta.consensusProof,
+    });
+  });
+
+  /**
+   * GET /content/list
+   * List available content
+   * 
+   * Query params:
+   * - tag=<tag> : Filter by tag
+   * - status=<status> : Filter by status (local, pending, verified)
+   * - limit=<n> : Max results (default 100)
+   * - offset=<n> : Pagination offset
+   */
+  router.get('/', readLimiter, (req, res) => {
+    const { tag, status, limit = 100, offset = 0 } = req.query;
+    
+    const items = contentStore.list({
+      tag,
+      status,
+      limit: Math.min(parseInt(limit) || 100, 1000),
+      offset: parseInt(offset) || 0,
+    });
+
+    res.json({
+      items,
+      count: items.length,
+      stats: contentStore.getStats(),
+    });
+  });
+
+  /**
+   * HEAD /content/:hash
+   * Check if content exists (useful for CDN/cache validation)
+   */
+  router.head('/:hash', readLimiter, (req, res) => {
+    const { hash } = req.params;
+    
+    if (contentStore.has(hash)) {
+      const meta = contentStore.getMeta(hash);
+      res.setHeader('Content-Type', meta?.contentType || 'application/octet-stream');
+      res.setHeader('Content-Length', meta?.size || 0);
+      res.setHeader('X-Content-Hash', hash);
+      res.setHeader('X-Content-Status', meta?.status || 'unknown');
+      res.status(200).end();
+    } else {
+      res.status(404).end();
+    }
+  });
+
+  // =========================================
+  // AUTHENTICATED WRITE ENDPOINTS
+  // =========================================
+
+  /**
+   * POST /content/publish
+   * Publish new content to the mesh
+   * 
+   * Body (JSON):
+   * {
+   *   content: <string|object>,
+   *   contentType?: <mime-type>,
+   *   name?: <human-readable-name>,
+   *   tags?: [<tag>, ...],
+   *   ttl?: <seconds>
+   * }
+   * 
+   * Body (multipart/form-data):
+   * - file: uploaded file
+   * - name: optional name
+   * - tags: comma-separated tags
+   */
+  router.post('/publish', writeLimiter, async (req, res) => {
+    try {
+      let content;
+      let options = {};
+
+      // Handle JSON body
+      if (req.is('application/json')) {
+        if (!req.body.content) {
+          return res.status(400).json({ error: 'Content required' });
+        }
+        content = req.body.content;
+        options = {
+          contentType: req.body.contentType,
+          name: req.body.name,
+          tags: req.body.tags || [],
+          ttl: req.body.ttl || 0,
+        };
+      } 
+      // Handle raw body
+      else if (req.body && Buffer.isBuffer(req.body)) {
+        content = req.body;
+        options = {
+          contentType: req.headers['content-type'] || 'application/octet-stream',
+          name: req.headers['x-content-name'],
+          tags: req.headers['x-content-tags']?.split(',') || [],
+        };
+      }
+      // Handle form data (basic - for full multipart use multer)
+      else if (req.body?.content) {
+        content = req.body.content;
+        options = {
+          contentType: req.body.contentType,
+          name: req.body.name,
+          tags: typeof req.body.tags === 'string' ? req.body.tags.split(',') : req.body.tags,
+        };
+      }
+      else {
+        return res.status(400).json({ error: 'Content required in body' });
+      }
+
+      // Store and publish
+      const result = await contentStore.store(content, options);
+
+      res.status(201).json({
+        success: true,
+        hash: result.hash,
+        status: result.status,
+        meta: result.meta?.toJSON ? result.meta.toJSON() : result.meta,
+        url: `/content/${result.hash}`,
+      });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  /**
+   * POST /content/request
+   * Request content from mesh (if not locally available)
+   */
+  router.post('/request', writeLimiter, async (req, res) => {
+    const { hash } = req.body;
+    
+    if (!hash) {
+      return res.status(400).json({ error: 'Hash required' });
+    }
+
+    try {
+      // Check local first
+      if (contentStore.has(hash)) {
+        return res.json({
+          found: true,
+          local: true,
+          hash,
+        });
+      }
+
+      // Request from mesh
+      const result = await contentStore.request(hash);
+      
+      res.json({
+        found: true,
+        local: false,
+        hash: result.hash,
+        meta: result.meta,
+      });
+    } catch (error) {
+      res.status(404).json({
+        found: false,
+        hash,
+        error: error.message,
+      });
+    }
+  });
+
+  /**
+   * DELETE /content/:hash
+   * Remove content (local only - cannot remove from mesh)
+   */
+  router.delete('/:hash', writeLimiter, (req, res) => {
+    const { hash } = req.params;
+    
+    if (!contentStore.has(hash)) {
+      return res.status(404).json({ error: 'Content not found', hash });
+    }
+
+    // Note: This only removes locally - content may still exist on other nodes
+    contentStore.delete(hash);
+
+    res.json({
+      deleted: true,
+      hash,
+      note: 'Content removed locally. Other mesh nodes may still have copies.',
+    });
+  });
+
+  /**
+   * GET /content/stats
+   * Get content store statistics
+   */
+  router.get('/stats', readLimiter, (req, res) => {
+    res.json(contentStore.getStats());
+  });
+
+  /**
+   * POST /content/verify
+   * Compute hash for content without storing
+   * Useful for clients to verify content integrity
+   */
+  router.post('/verify', readLimiter, (req, res) => {
+    const content = req.body.content || req.body;
+    
+    if (!content) {
+      return res.status(400).json({ error: 'Content required' });
+    }
+
+    const hash = computeContentHash(content);
+    
+    res.json({
+      hash,
+      exists: contentStore.has(hash),
+    });
+  });
+
+  return router;
+}
+
+export default createContentAPI;

package/content/index.js

@@ -0,0 +1,19 @@
+/**
+ * YAKMESH™ Content Module
+ * Content-addressed storage with public delivery
+ * 
+ * @module content
+ * @license MIT
+ * @copyright 2026 YAKMESH Contributors
+ */
+
+export { 
+  ContentStore, 
+  ContentType, 
+  ContentStatus, 
+  ContentMetadata,
+  ConsensusProof,
+  computeContentHash,
+} from './store.js';
+
+export { createContentAPI } from './api.js';

package/content/store.js

@@ -0,0 +1,670 @@
+/**
+ * YAKMESH™ Content Store
+ * Content-addressed storage with consensus proofs
+ * 
+ * Provides public content delivery while maintaining mesh security:
+ * - Content addressed by hash (trustless verification)
+ * - Consensus proofs for light client verification
+ * - Edge caching for instant public access
+ * - Mesh sync for decentralized replication
+ * 
+ * @module content/store
+ * @license MIT
+ * @copyright 2026 YAKMESH Contributors
+ */
+
+import { sha3_256 } from '@noble/hashes/sha3.js';
+import { bytesToHex, utf8ToBytes } from '@noble/hashes/utils.js';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, unlinkSync, statSync } from 'fs';
+import { join, dirname } from 'path';
+
+/**
+ * Content types supported
+ */
+export const ContentType = {
+  JSON: 'application/json',
+  HTML: 'text/html',
+  TEXT: 'text/plain',
+  BINARY: 'application/octet-stream',
+  JAVASCRIPT: 'application/javascript',
+  CSS: 'text/css',
+  IMAGE_PNG: 'image/png',
+  IMAGE_JPG: 'image/jpeg',
+  IMAGE_SVG: 'image/svg+xml',
+};
+
+/**
+ * Content status in the network
+ */
+export const ContentStatus = {
+  LOCAL: 'local',           // Only on this node
+  PENDING: 'pending',       // Awaiting consensus
+  VERIFIED: 'verified',     // Consensus reached
+  REJECTED: 'rejected',     // Failed consensus
+};
+
+/**
+ * Compute content hash (SHA3-256)
+ */
+export function computeContentHash(content) {
+  if (typeof content === 'string') {
+    return bytesToHex(sha3_256(utf8ToBytes(content)));
+  }
+  if (Buffer.isBuffer(content)) {
+    return bytesToHex(sha3_256(new Uint8Array(content)));
+  }
+  if (content instanceof Uint8Array) {
+    return bytesToHex(sha3_256(content));
+  }
+  // Object - serialize deterministically
+  return bytesToHex(sha3_256(utf8ToBytes(JSON.stringify(content))));
+}
+
+/**
+ * Content metadata
+ */
+class ContentMetadata {
+  constructor(options = {}) {
+    this.hash = options.hash;
+    this.contentType = options.contentType || ContentType.BINARY;
+    this.size = options.size || 0;
+    this.createdAt = options.createdAt || Date.now();
+    this.publishedBy = options.publishedBy || null;
+    this.status = options.status || ContentStatus.LOCAL;
+    this.consensusProof = options.consensusProof || null;
+    this.tags = options.tags || [];
+    this.name = options.name || null;  // Optional human-readable name
+    this.ttl = options.ttl || 0;       // 0 = permanent
+  }
+
+  toJSON() {
+    return {
+      hash: this.hash,
+      contentType: this.contentType,
+      size: this.size,
+      createdAt: this.createdAt,
+      publishedBy: this.publishedBy,
+      status: this.status,
+      consensusProof: this.consensusProof,
+      tags: this.tags,
+      name: this.name,
+      ttl: this.ttl,
+    };
+  }
+
+  static fromJSON(json) {
+    return new ContentMetadata(json);
+  }
+}
+
+/**
+ * Consensus proof for light client verification
+ */
+class ConsensusProof {
+  constructor(options = {}) {
+    this.contentHash = options.contentHash;
+    this.timestamp = options.timestamp || Date.now();
+    this.validators = options.validators || [];  // Array of { nodeId, signature }
+    this.quorum = options.quorum || 0;           // Required signatures
+    this.networkId = options.networkId || null;
+  }
+
+  /**
+   * Check if proof has quorum
+   */
+  hasQuorum() {
+    return this.validators.length >= this.quorum;
+  }
+
+  /**
+   * Add validator signature
+   */
+  addValidator(nodeId, signature) {
+    if (!this.validators.find(v => v.nodeId === nodeId)) {
+      this.validators.push({ nodeId, signature, timestamp: Date.now() });
+    }
+  }
+
+  toJSON() {
+    return {
+      contentHash: this.contentHash,
+      timestamp: this.timestamp,
+      validators: this.validators,
+      quorum: this.quorum,
+      networkId: this.networkId,
+    };
+  }
+
+  static fromJSON(json) {
+    return new ConsensusProof(json);
+  }
+}
+
+/**
+ * YAKMESH Content Store
+ * Content-addressed storage with mesh sync and public delivery
+ */
+export class ContentStore {
+  constructor(config = {}) {
+    this.config = {
+      dataDir: config.dataDir || './data/content',
+      maxContentSize: config.maxContentSize || 10 * 1024 * 1024, // 10MB default
+      cacheSize: config.cacheSize || 100,                        // LRU cache entries
+      quorumSize: config.quorumSize || 2,                        // Minimum validators
+      ...config,
+    };
+
+    this.contentDir = join(this.config.dataDir, 'objects');
+    this.metaDir = join(this.config.dataDir, 'meta');
+    
+    // In-memory caches
+    this.contentCache = new Map();  // hash -> content (LRU)
+    this.metaCache = new Map();     // hash -> ContentMetadata
+    this.nameIndex = new Map();     // name -> hash (for human-readable lookup)
+    
+    // Mesh integration (set by init)
+    this.mesh = null;
+    this.identity = null;
+    this.oracle = null;
+    this.gossip = null;
+  }
+
+  /**
+   * Initialize the content store
+   */
+  async init(node = null) {
+    // Create directories
+    mkdirSync(this.contentDir, { recursive: true });
+    mkdirSync(this.metaDir, { recursive: true });
+
+    // Load existing metadata into cache
+    this._loadMetadataIndex();
+
+    // Integrate with node if provided
+    if (node) {
+      this.mesh = node.mesh;
+      this.identity = node.identity;
+      this.oracle = node.oracle;
+      this.gossip = node.gossip;
+      
+      // Content gossip is handled by the server via mesh.on('rumor')
+      // which calls contentStore._handleContentGossip()
+    }
+
+    console.log(`✓ Content store initialized: ${this.config.dataDir}`);
+    console.log(`   Objects: ${this.metaCache.size}`);
+    
+    return this;
+  }
+
+  /**
+   * Load metadata index from disk
+   */
+  _loadMetadataIndex() {
+    if (!existsSync(this.metaDir)) return;
+
+    const files = readdirSync(this.metaDir);
+    for (const file of files) {
+      if (!file.endsWith('.json')) continue;
+      try {
+        const metaPath = join(this.metaDir, file);
+        const json = JSON.parse(readFileSync(metaPath, 'utf8'));
+        const meta = ContentMetadata.fromJSON(json);
+        this.metaCache.set(meta.hash, meta);
+        if (meta.name) {
+          this.nameIndex.set(meta.name, meta.hash);
+        }
+      } catch (e) {
+        console.warn(`Failed to load metadata: ${file}`);
+      }
+    }
+  }
+
+  /**
+   * Get content path for a hash
+   */
+  _getContentPath(hash) {
+    // Store in subdirectories for filesystem efficiency (git-style)
+    const prefix = hash.slice(0, 2);
+    const suffix = hash.slice(2);
+    return join(this.contentDir, prefix, suffix);
+  }
+
+  /**
+   * Get metadata path for a hash
+   */
+  _getMetaPath(hash) {
+    return join(this.metaDir, `${hash}.json`);
+  }
+
+  /**
+   * Store content
+   */
+  async store(content, options = {}) {
+    // Compute hash
+    const hash = computeContentHash(content);
+    
+    // Check size limit
+    const size = Buffer.isBuffer(content) ? content.length : 
+                 typeof content === 'string' ? Buffer.byteLength(content) :
+                 Buffer.byteLength(JSON.stringify(content));
+    
+    if (size > this.config.maxContentSize) {
+      throw new Error(`Content exceeds max size: ${size} > ${this.config.maxContentSize}`);
+    }
+
+    // Check if already exists
+    if (this.has(hash)) {
+      const existing = this.getMeta(hash);
+      return { hash, status: 'exists', meta: existing };
+    }
+
+    // Create metadata
+    const meta = new ContentMetadata({
+      hash,
+      contentType: options.contentType || this._detectContentType(content),
+      size,
+      publishedBy: this.identity?.identity?.nodeId || options.publishedBy || 'unknown',
+      status: ContentStatus.LOCAL,
+      tags: options.tags || [],
+      name: options.name || null,
+      ttl: options.ttl || 0,
+    });
+
+    // Write content to disk
+    const contentPath = this._getContentPath(hash);
+    mkdirSync(dirname(contentPath), { recursive: true });
+    
+    if (Buffer.isBuffer(content)) {
+      writeFileSync(contentPath, content);
+    } else if (typeof content === 'string') {
+      writeFileSync(contentPath, content, 'utf8');
+    } else {
+      writeFileSync(contentPath, JSON.stringify(content), 'utf8');
+    }
+
+    // Write metadata
+    writeFileSync(this._getMetaPath(hash), JSON.stringify(meta.toJSON(), null, 2));
+
+    // Update caches
+    this.metaCache.set(hash, meta);
+    if (meta.name) {
+      this.nameIndex.set(meta.name, hash);
+    }
+    this._addToContentCache(hash, content);
+
+    // Gossip to mesh
+    if (this.gossip && options.publish !== false) {
+      await this.publish(hash);
+    }
+
+    return { hash, status: 'stored', meta };
+  }
+
+  /**
+   * Retrieve content by hash
+   */
+  get(hash) {
+    // Resolve name to hash if needed
+    if (!hash.match(/^[a-f0-9]{64}$/i)) {
+      hash = this.nameIndex.get(hash) || hash;
+    }
+
+    // Check memory cache
+    if (this.contentCache.has(hash)) {
+      return this.contentCache.get(hash);
+    }
+
+    // Check disk
+    const contentPath = this._getContentPath(hash);
+    if (!existsSync(contentPath)) {
+      return null;
+    }
+
+    // Load and cache
+    const content = readFileSync(contentPath);
+    this._addToContentCache(hash, content);
+    
+    return content;
+  }
+
+  /**
+   * Get content with metadata and proof
+   */
+  getWithProof(hash) {
+    const content = this.get(hash);
+    if (!content) return null;
+
+    const meta = this.getMeta(hash);
+    
+    return {
+      content,
+      hash,
+      meta: meta?.toJSON() || null,
+      proof: meta?.consensusProof || null,
+      verified: meta?.status === ContentStatus.VERIFIED,
+    };
+  }
+
+  /**
+   * Get metadata for content
+   */
+  getMeta(hash) {
+    // Resolve name if needed
+    if (!hash.match(/^[a-f0-9]{64}$/i)) {
+      hash = this.nameIndex.get(hash) || hash;
+    }
+    return this.metaCache.get(hash) || null;
+  }
+
+  /**
+   * Check if content exists
+   */
+  has(hash) {
+    // Resolve name if needed
+    if (!hash.match(/^[a-f0-9]{64}$/i)) {
+      hash = this.nameIndex.get(hash) || hash;
+    }
+    return this.metaCache.has(hash) || existsSync(this._getContentPath(hash));
+  }
+
+  /**
+   * Delete content
+   */
+  delete(hash) {
+    const meta = this.getMeta(hash);
+    
+    // Remove from disk
+    const contentPath = this._getContentPath(hash);
+    const metaPath = this._getMetaPath(hash);
+    
+    if (existsSync(contentPath)) unlinkSync(contentPath);
+    if (existsSync(metaPath)) unlinkSync(metaPath);
+
+    // Remove from caches
+    this.contentCache.delete(hash);
+    this.metaCache.delete(hash);
+    if (meta?.name) {
+      this.nameIndex.delete(meta.name);
+    }
+
+    return true;
+  }
+
+  /**
+   * List all content
+   */
+  list(options = {}) {
+    const { tag, status, limit = 100, offset = 0 } = options;
+    
+    let items = Array.from(this.metaCache.values());
+    
+    // Filter by tag
+    if (tag) {
+      items = items.filter(m => m.tags.includes(tag));
+    }
+    
+    // Filter by status
+    if (status) {
+      items = items.filter(m => m.status === status);
+    }
+    
+    // Sort by created date (newest first)
+    items.sort((a, b) => b.createdAt - a.createdAt);
+    
+    // Paginate
+    return items.slice(offset, offset + limit).map(m => m.toJSON());
+  }
+
+  /**
+   * Publish content to mesh
+   */
+  async publish(hash) {
+    const meta = this.getMeta(hash);
+    if (!meta) {
+      throw new Error(`Content not found: ${hash}`);
+    }
+
+    // Create announcement message
+    const announcement = {
+      type: 'content_announce',
+      hash,
+      meta: {
+        contentType: meta.contentType,
+        size: meta.size,
+        publishedBy: meta.publishedBy,
+        tags: meta.tags,
+        name: meta.name,
+      },
+      timestamp: Date.now(),
+    };
+
+    // Sign with node identity
+    if (this.identity) {
+      announcement.signature = this.identity.sign(JSON.stringify(announcement));
+    }
+
+    // Gossip to mesh
+    if (this.gossip) {
+      this.gossip.spreadRumor('content', announcement);
+    }
+
+    // Update status
+    meta.status = ContentStatus.PENDING;
+    writeFileSync(this._getMetaPath(hash), JSON.stringify(meta.toJSON(), null, 2));
+
+    return { published: true, hash };
+  }
+
+  /**
+   * Request content from mesh
+   */
+  async request(hash) {
+    if (this.has(hash)) {
+      return this.getWithProof(hash);
+    }
+
+    // Broadcast request
+    if (this.gossip) {
+      this.gossip.spreadRumor('content', {
+        type: 'content_request',
+        hash,
+        requestedBy: this.identity?.identity?.nodeId,
+        timestamp: Date.now(),
+      });
+    }
+
+    // Wait for response (with timeout)
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`Content not found: ${hash}`));
+      }, 10000);
+
+      const checkInterval = setInterval(() => {
+        if (this.has(hash)) {
+          clearTimeout(timeout);
+          clearInterval(checkInterval);
+          resolve(this.getWithProof(hash));
+        }
+      }, 500);
+    });
+  }
+
+  /**
+   * Handle content gossip from peers
+   */
+  async _handleContentGossip(data, origin) {
+    switch (data.type) {
+      case 'content_announce':
+        // Peer has new content - request it if we don't have it
+        if (!this.has(data.hash)) {
+          console.log(`📦 New content announced: ${data.hash.slice(0, 16)}... from ${origin.slice(0, 16)}...`);
+          // Request full content via mesh
+          if (this.mesh) {
+            this.mesh.sendTo(origin, {
+              type: 'content_request',
+              hash: data.hash,
+              requestedBy: this.identity?.identity?.nodeId,
+            });
+          }
+        }
+        break;
+
+      case 'content_request':
+        // Peer wants content - send if we have it
+        if (this.has(data.hash)) {
+          const result = this.getWithProof(data.hash);
+          if (this.mesh && result) {
+            this.mesh.sendTo(origin, {
+              type: 'content_response',
+              hash: data.hash,
+              content: result.content.toString('base64'),
+              meta: result.meta,
+              proof: result.proof,
+            });
+          }
+        }
+        break;
+
+      case 'content_response':
+        // Received content from peer
+        if (!this.has(data.hash)) {
+          const content = Buffer.from(data.content, 'base64');
+          const computedHash = computeContentHash(content);
+          
+          // Verify hash
+          if (computedHash !== data.hash) {
+            console.warn(`⚠️ Content hash mismatch from ${origin.slice(0, 16)}...`);
+            return;
+          }
+
+          // Store it
+          await this.store(content, {
+            ...data.meta,
+            publish: false,  // Don't re-gossip
+          });
+
+          // Apply consensus proof if present
+          if (data.proof) {
+            const meta = this.getMeta(data.hash);
+            meta.consensusProof = ConsensusProof.fromJSON(data.proof);
+            meta.status = data.proof.hasQuorum?.() ? ContentStatus.VERIFIED : ContentStatus.PENDING;
+            writeFileSync(this._getMetaPath(data.hash), JSON.stringify(meta.toJSON(), null, 2));
+          }
+
+          console.log(`✓ Content received: ${data.hash.slice(0, 16)}...`);
+        }
+        break;
+
+      case 'content_validate':
+        // Peer is requesting validation vote
+        if (this.has(data.hash) && this.identity && this.oracle) {
+          const content = this.get(data.hash);
+          const isValid = this.oracle.validateContent(content, data.contentType);
+          
+          if (isValid) {
+            // Sign validation
+            const vote = {
+              type: 'content_vote',
+              hash: data.hash,
+              nodeId: this.identity.identity.nodeId,
+              vote: 'valid',
+              signature: this.identity.sign(data.hash),
+              timestamp: Date.now(),
+            };
+            this.gossip.spreadRumor('content', vote);
+          }
+        }
+        break;
+
+      case 'content_vote':
+        // Received validation vote
+        const meta = this.getMeta(data.hash);
+        if (meta) {
+          if (!meta.consensusProof) {
+            meta.consensusProof = new ConsensusProof({
+              contentHash: data.hash,
+              quorum: this.config.quorumSize,
+              networkId: this.mesh?.networkId,
+            });
+          }
+          meta.consensusProof.addValidator(data.nodeId, data.signature);
+          
+          if (meta.consensusProof.hasQuorum()) {
+            meta.status = ContentStatus.VERIFIED;
+            console.log(`✓ Content verified (quorum reached): ${data.hash.slice(0, 16)}...`);
+          }
+          
+          writeFileSync(this._getMetaPath(data.hash), JSON.stringify(meta.toJSON(), null, 2));
+        }
+        break;
+    }
+  }
+
+  /**
+   * Add to LRU content cache
+   */
+  _addToContentCache(hash, content) {
+    // Simple LRU: remove oldest if at capacity
+    if (this.contentCache.size >= this.config.cacheSize) {
+      const oldest = this.contentCache.keys().next().value;
+      this.contentCache.delete(oldest);
+    }
+    this.contentCache.set(hash, content);
+  }
+
+  /**
+   * Detect content type from content
+   */
+  _detectContentType(content) {
+    if (typeof content === 'object' && !Buffer.isBuffer(content)) {
+      return ContentType.JSON;
+    }
+    
+    const str = content.toString().slice(0, 100);
+    
+    if (str.startsWith('<!DOCTYPE') || str.startsWith('<html')) {
+      return ContentType.HTML;
+    }
+    if (str.startsWith('{') || str.startsWith('[')) {
+      return ContentType.JSON;
+    }
+    if (str.includes('function') || str.includes('const ') || str.includes('import ')) {
+      return ContentType.JAVASCRIPT;
+    }
+    
+    return ContentType.TEXT;
+  }
+
+  /**
+   * Get store statistics
+   */
+  getStats() {
+    let totalSize = 0;
+    let verified = 0;
+    let pending = 0;
+    let local = 0;
+
+    for (const meta of this.metaCache.values()) {
+      totalSize += meta.size;
+      switch (meta.status) {
+        case ContentStatus.VERIFIED: verified++; break;
+        case ContentStatus.PENDING: pending++; break;
+        case ContentStatus.LOCAL: local++; break;
+      }
+    }
+
+    return {
+      totalObjects: this.metaCache.size,
+      totalSize,
+      verified,
+      pending,
+      local,
+      cacheSize: this.contentCache.size,
+      dataDir: this.config.dataDir,
+    };
+  }
+}
+
+export { ContentMetadata, ConsensusProof };
+export default ContentStore;

package/discord.md

@@ -52,12 +52,14 @@ const { slices } = encoder.encode('Hello mesh!');
 
 ---
 
-## 📦 Current Version: `1.2.0`
+## 📦 Current Version: `1.3.2`
 
-✅ TME (Temporal Matrix Encoding)
+✅ TME™ (Temporal Matrix Encoding)
 ✅ ML-DSA-65 Post-Quantum Signatures  
-✅ Full security hardening suite
-✅ 42+ tests passing
+✅ Code Proof Protocol (codebase verification)
+✅ Public Content Delivery API (v1.3.2 - gossip integration)
+✅ ECHO™, PULSE™, PHANTOM™, BEACON™ protocols
+✅ 68+ tests passing
 
 ---
 
@@ -65,6 +67,9 @@ const { slices } = encoder.encode('Hello mesh!');
 🌐 Website: https://yakmesh.dev
 📦 npm: https://npmjs.com/package/yakmesh
 📖 GitHub: https://github.com/yakmesh/yakmesh
+💬 Discord: https://discord.gg/E62tAE2wGh
+📱 Telegram: https://t.me/yakmesh
+𝕏 Twitter: https://x.com/yakmesh
 📄 Whitepaper: `docs/WHITEPAPER.md`
 
 **USPTO Serial No. 99594620**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yakmesh",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "YAKMESH: Yielding Atomic Kernel Modular Encryption Secured Hub - Post-quantum secure P2P mesh network for the 2026 threat landscape",
   "type": "module",
   "main": "server/index.js",

package/server/index.js

@@ -19,6 +19,9 @@ import { MeshNetwork } from '../mesh/network.js';
 import { ReplicationEngine } from '../database/replication.js';
 import { GossipProtocol } from '../gossip/protocol.js';
 
+// Content store for public delivery
+import { ContentStore, createContentAPI } from '../content/index.js';
+
 // Oracle system imports
 import { 
   getOracle, 
@@ -115,6 +118,9 @@ export class YakmeshNode {
     this.codeProof = null;
     this.consensus = null;
     
+    // Content store for public delivery
+    this.contentStore = null;
+    
     // Time source detector
     this.timeSource = null;
     
@@ -206,12 +212,26 @@ export class YakmeshNode {
       if (topic === 'network_handshake') {
         this._handleNetworkHandshake(data, origin);
       }
+      
+      // Handle content gossip (for public content delivery)
+      if (topic === 'content') {
+        if (this.contentStore) {
+          this.contentStore._handleContentGossip(data, origin);
+        }
+      }
     });
 
-    // 5. Start HTTP server
+    // 5. Initialize content store for public delivery
+    this.contentStore = new ContentStore({
+      dataDir: this.config.database?.contentPath || './data/content',
+      quorumSize: 2,
+    });
+    await this.contentStore.init(this);
+    
+    // 6. Start HTTP server
     await this._startHttpServer();
 
-    // 6. Connect to bootstrap nodes
+    // 7. Connect to bootstrap nodes
     await this._connectToBootstrap();
 
     // 7. Initialize PeerQuanta integration (if enabled)
@@ -222,13 +242,18 @@ export class YakmeshNode {
     console.log('\n✓ Yakmesh Node is running!\n');
     console.log(`  Node ID:    ${this.identity.identity.nodeId}`);
     console.log(`  HTTP:       http://localhost:${this.config.network.httpPort}`);
+    console.log(`  Content:    http://localhost:${this.config.network.httpPort}/content`);
     console.log(`  Dashboard:  http://localhost:${this.config.network.httpPort}/dashboard`);
     console.log(`  WebSocket:  ws://localhost:${this.config.network.wsPort}`);
     console.log(`  Algorithm:  ML-DSA-65 (Post-Quantum)`);
     console.log(`  Oracle:     ✓ ${this.oracle.selfHash.slice(0, 16)}...`);
     console.log(`  Network:    ${this.genesisNetwork.networkName} (${this.genesisNetwork.networkId})`);
+    if (this.contentStore) {
+      const stats = this.contentStore.getStats();
+      console.log(`  Content:    ${stats.totalObjects} objects (${stats.verified} verified)`);
+    }
     if (this.adapter) {
-      console.log(`  Adapter: ✓ Enabled`);
+      console.log(`  Adapter:    ✓ Enabled`);
     }
     console.log('');
 
@@ -491,6 +516,18 @@ export class YakmeshNode {
       return obj && typeof obj === 'object' && !Array.isArray(obj);
     };
     
+    // =========================================
+    // PUBLIC CONTENT API (No Auth for reads)
+    // =========================================
+    
+    // Mount content API at /content
+    const contentAPI = createContentAPI(this.contentStore, {
+      writeLimiter,
+      readLimiter: generalLimiter,
+      validateString,
+    });
+    app.use('/content', contentAPI);
+    
     // Serve dashboard
     app.get('/dashboard', (req, res) => {
       res.sendFile('dashboard/index.html', { root: import.meta.dirname + '/..' });

package/yakmesh.config.js

@@ -0,0 +1,8 @@
+// Alpha node - connects to Gamma on LAN
+export default {
+  nodeId: 'alpha-lan-test',
+  server: { port: 3001, host: '0.0.0.0' },
+  mesh: { port: 9002, host: '0.0.0.0' },
+  peers: ['ws://192.168.1.178:9001'],
+  dataDir: './test-nodes/data-alpha'
+};