neozipkit 0.1.1

package/src/browser/TokenVerifierBrowser.ts

@@ -0,0 +1,344 @@
+// ======================================
+//	TokenVerifierBrowser.ts
+//  Browser-compatible blockchain token verification utilities for ZIP archives
+//  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
+// ======================================
+
+import ZipKitBrowser from './ZipKitBrowser';
+import { ZipEntry } from '../shared/ZipKit';
+import { TOKENIZED_METADATA } from '../shared/constants/Headers';
+import { NZIP_CONTRACT_ABI, CURRENT_DEPLOYMENT } from '../server/blockchain/constants';
+
+// Token types (adapted for browser)
+export interface NZipTokenInfo {
+  version: string;
+  tokenId: string;
+  contractAddress: string;
+  network: string;
+  networkChainId: number;
+  transactionHash: string;
+  merkleRoot: string;
+  fileName: string;
+  mintedAt: string;
+}
+
+export interface TokenVerificationOptions {
+  skipHash?: boolean;
+  skipToken?: boolean;
+  generateCertificate?: boolean;
+  zipFileName?: string;
+}
+
+export interface TokenVerificationResult {
+  isTokenized: boolean;
+  tokenMetadata: NZipTokenInfo | null;
+  calculatedMerkleRoot: string | null;
+  blockchainMerkleRoot: string | null;
+  blockchainTimestamp?: number; // Actual blockchain timestamp from tokenizationTime
+  verificationPassed: boolean;
+  certificatePath?: string;
+  errorMessage?: string;
+}
+
+export interface BlockchainVerification {
+  merkleRootMatches: boolean;
+  blockchainMerkleRoot: string;
+  calculatedMerkleRoot: string;
+  verificationStatus: 'PASSED' | 'FAILED' | 'UNAVAILABLE';
+  verificationTime?: number;
+  blockNumber?: number;
+}
+
+// Network configuration for blockchain queries
+const NETWORK_CONFIG: Record<string, any> = {
+  'Base Sepolia': {
+    chainId: 84532,
+    rpcUrls: [
+      'https://sepolia.base.org',
+      'https://base-sepolia.g.alchemy.com/v2/demo',
+      'https://base-sepolia-rpc.publicnode.com',
+      'https://base-sepolia.blockpi.network/v1/rpc/public'
+    ]
+  },
+  'Base Mainnet': {
+    chainId: 8453,
+    rpcUrls: [
+      'https://mainnet.base.org',
+      'https://base-mainnet.g.alchemy.com/v2/demo',
+      'https://base-rpc.publicnode.com',
+      'https://base.blockpi.network/v1/rpc/public'
+    ]
+  }
+};
+
+// Use the complete contract ABI from constants
+const CONTRACT_ABI = NZIP_CONTRACT_ABI;
+
+/**
+ * Browser-compatible token verification class
+ */
+export class TokenVerifierBrowser {
+  private zipKit: ZipKitBrowser;
+
+  constructor(zipKit: ZipKitBrowser) {
+    this.zipKit = zipKit;
+  }
+
+  /**
+   * Checks if the ZIP file contains NFT token metadata and verifies the merkle root
+   */
+  async checkForTokenization(
+    zipEntries: ZipEntry[],
+    options: TokenVerificationOptions = {}
+  ): Promise<TokenVerificationResult> {
+      // Look for the tokenized metadata file
+  const tokenEntry = zipEntries.find(entry => entry.filename === TOKENIZED_METADATA);
+    
+    if (!tokenEntry) {
+      return {
+        isTokenized: false,
+        tokenMetadata: null,
+        calculatedMerkleRoot: null,
+        blockchainMerkleRoot: null,
+        verificationPassed: false
+      };
+    }
+
+    try {
+      // Extract the token metadata
+      const tokenData = await this.zipKit.extractBlob(tokenEntry);
+      
+      if (!tokenData) {
+        return {
+          isTokenized: false,
+          tokenMetadata: null,
+          calculatedMerkleRoot: null,
+          blockchainMerkleRoot: null,
+          verificationPassed: false,
+          errorMessage: 'Could not read token metadata'
+        };
+      }
+
+      const tokenContent = await this.blobToString(tokenData);
+      const tokenMetadata = JSON.parse(tokenContent);
+      
+      // Validate token metadata structure
+      if (!this.validateTokenInfo(tokenMetadata)) {
+        return {
+          isTokenized: false,
+          tokenMetadata: null,
+          calculatedMerkleRoot: null,
+          blockchainMerkleRoot: null,
+          verificationPassed: false,
+          errorMessage: 'Invalid token metadata structure'
+        };
+      }
+
+      // Skip verification if requested
+      if (options.skipHash || options.skipToken) {
+        return {
+          isTokenized: true,
+          tokenMetadata,
+          calculatedMerkleRoot: null,
+          blockchainMerkleRoot: null,
+          verificationPassed: false,
+          errorMessage: options.skipHash ? 'Hash verification skipped' : 'Token verification skipped'
+        };
+      }
+
+      // Calculate merkle root excluding token file
+      const calculatedMerkleRoot = await this.calculateMerkleRootExcludingToken(zipEntries);
+      
+      if (!calculatedMerkleRoot) {
+        return {
+          isTokenized: true,
+          tokenMetadata,
+          calculatedMerkleRoot: null,
+          blockchainMerkleRoot: null,
+          verificationPassed: false,
+          errorMessage: 'Could not calculate merkle root'
+        };
+      }
+
+      // Query blockchain for the actual merkle root and timestamp
+      const blockchainData = await this.queryBlockchainData(tokenMetadata);
+      
+      if (!blockchainData.merkleRoot) {
+        return {
+          isTokenized: true,
+          tokenMetadata,
+          calculatedMerkleRoot,
+          blockchainMerkleRoot: null,
+          blockchainTimestamp: blockchainData.timestamp ?? undefined,
+          verificationPassed: false,
+          errorMessage: 'Could not retrieve merkle root from blockchain'
+        };
+      }
+
+      const verificationPassed = blockchainData.merkleRoot === calculatedMerkleRoot;
+      
+      return {
+        isTokenized: true,
+        tokenMetadata,
+        calculatedMerkleRoot,
+        blockchainMerkleRoot: blockchainData.merkleRoot,
+        blockchainTimestamp: blockchainData.timestamp ?? undefined,
+        verificationPassed,
+        errorMessage: verificationPassed ? undefined : 'Merkle root mismatch - archive may be tampered'
+      };
+      
+    } catch (error) {
+      return {
+        isTokenized: false,
+        tokenMetadata: null,
+        calculatedMerkleRoot: null,
+        blockchainMerkleRoot: null,
+        verificationPassed: false,
+        errorMessage: `Error processing token: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+
+  /**
+   * Validates token metadata structure
+   */
+  private validateTokenInfo(tokenMetadata: any): tokenMetadata is NZipTokenInfo {
+    return tokenMetadata &&
+           typeof tokenMetadata.version === 'string' &&
+           typeof tokenMetadata.tokenId === 'string' &&
+           typeof tokenMetadata.contractAddress === 'string' &&
+           typeof tokenMetadata.network === 'string' &&
+           typeof tokenMetadata.networkChainId === 'number' &&
+           typeof tokenMetadata.transactionHash === 'string' &&
+           typeof tokenMetadata.merkleRoot === 'string' &&
+           typeof tokenMetadata.fileName === 'string' &&
+           typeof tokenMetadata.mintedAt === 'string';
+  }
+
+  /**
+   * Calculates the merkle root excluding the token metadata file
+   */
+  private async calculateMerkleRootExcludingToken(zipEntries: ZipEntry[]): Promise<string | null> {
+    try {
+      // Get all entries except the token file
+      const contentEntries = zipEntries.filter(entry => entry.filename !== TOKENIZED_METADATA);
+      
+      if (contentEntries.length === 0) {
+        return null;
+      }
+
+      // For each content entry, ensure we have SHA-256 hash calculated
+      for (const entry of contentEntries) {
+        if (!entry.sha256) {
+          // Extract the file to calculate its SHA-256 hash
+          await this.zipKit.extractBlob(entry);
+        }
+      }
+
+      // Calculate merkle root from content files
+      // This would need to be implemented based on the ZipKit's merkle tree functionality
+      // For now, we'll use a placeholder that would need to be implemented
+      return await this.zipKit.getMerkleRoot?.() || null;
+    } catch (error) {
+      console.error('Error calculating merkle root:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Queries the blockchain to get the actual merkle root and timestamp stored in the smart contract
+   */
+  private async queryBlockchainData(tokenMetadata: NZipTokenInfo): Promise<{merkleRoot: string | null, timestamp: number | null}> {
+    try {
+      // Dynamic import of ethers to avoid SSR issues
+      const { ethers } = await import('ethers');
+      
+      const networkConfig = NETWORK_CONFIG[tokenMetadata.network];
+      if (!networkConfig) {
+        console.warn(`Unsupported network: ${tokenMetadata.network}`);
+        return { merkleRoot: null, timestamp: null };
+      }
+
+      // Try multiple RPC endpoints
+      for (const rpcUrl of networkConfig.rpcUrls) {
+        try {
+          const provider = new ethers.JsonRpcProvider(rpcUrl);
+          
+          // Test connection with a timeout
+          const blockNumber = await Promise.race([
+            provider.getBlockNumber(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), 5000))
+          ]);
+
+          // Create contract instance
+          const contract = new ethers.Contract(tokenMetadata.contractAddress, CONTRACT_ABI, provider);
+          
+          // Call getZipFileInfo to get the blockchain-stored data
+          const zipInfo = await contract.getZipFileInfo(tokenMetadata.tokenId);
+          
+          return {
+            merkleRoot: zipInfo.merkleRootHash,
+            timestamp: Number(zipInfo.tokenizationTime)
+          };
+          
+        } catch (error) {
+          console.warn(`RPC ${rpcUrl} failed:`, error);
+          continue;
+        }
+      }
+      
+      console.warn(`All RPC endpoints failed for network: ${tokenMetadata.network}`);
+      return { merkleRoot: null, timestamp: null };
+      
+    } catch (error) {
+      console.error('Blockchain query error:', error);
+      return { merkleRoot: null, timestamp: null };
+    }
+  }
+
+  /**
+   * Helper to convert Blob to string
+   */
+  private async blobToString(blob: Blob): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(reader.result as string);
+      reader.onerror = reject;
+      reader.readAsText(blob);
+    });
+  }
+
+  /**
+   * Creates a formatted summary of token information
+   */
+  createTokenSummary(tokenMetadata: NZipTokenInfo): string {
+    return `
+🎫 NFT Token Information:
+   Token ID: ${tokenMetadata.tokenId}
+   Network: ${tokenMetadata.network}
+   Contract: ${tokenMetadata.contractAddress}
+   Transaction: ${tokenMetadata.transactionHash}
+   File: ${tokenMetadata.fileName}
+   Minted: ${new Date(tokenMetadata.mintedAt).toLocaleString()}
+   `;
+  }
+}
+
+/**
+ * Creates a new TokenVerifierBrowser instance
+ */
+export function createTokenVerifier(zipKit: ZipKitBrowser): TokenVerifierBrowser {
+  return new TokenVerifierBrowser(zipKit);
+}
+
+/**
+ * Convenience function to check for tokenization
+ */
+export async function checkForTokenization(
+  zipKit: ZipKitBrowser,
+  zipEntries: ZipEntry[],
+  options: TokenVerificationOptions = {}
+): Promise<TokenVerificationResult> {
+  const verifier = new TokenVerifierBrowser(zipKit);
+  return verifier.checkForTokenization(zipEntries, options);
+} 

package/src/browser/ZipKitBrowser.ts

@@ -0,0 +1,242 @@
+// ======================================
+//	ZipKitBrowser.ts
+//  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
+// ======================================
+
+import ZipKit, { CompressOptions, CreateZipOptions } from '../shared/ZipKit';
+import ZipEntry from '../shared/ZipEntry';
+import Errors from '../shared/constants/Errors';
+import * as Headers from '../shared/constants/Headers';
+import { TOKENIZED_METADATA, TIMESTAMP_SUBMITTED, TIMESTAMP_METADATA } from '../shared/constants/Headers';
+import { sha256 } from '../shared/components/ZipCrypto';
+import { crc32 } from '../shared/components/Util';
+import { DATATYPE, getTypeOf } from '../shared/components/Util';
+import type { FileData } from '../shared/types';
+
+// Re-export everything from ZipKit
+export * from '../shared/ZipKit';
+export { ZipEntry, Errors, Headers, sha256, getTypeOf };
+
+// ======================================
+//	ZipKitBrowser
+// ======================================
+
+export default class ZipKitBrowser extends ZipKit {
+  constructor() {
+    super();      // Call the parent constructor
+
+    // console.log('ZipKit.support.isNode: ', ZipKit.support.isNode);
+    // console.log('ZipKit.support.buffer: ', ZipKit.support.buffer);
+    // console.log('ZipKit.support.blob: ', ZipKit.support.blob);
+    // console.log('ZipKit.support.streams: ', ZipKit.support.streams);
+    // console.log('ZipKit.support.fileReader: ', ZipKit.support.fileReader);
+  }
+
+  // --------------------------------------
+  // Load a ZIP file from a Blob and return the ZipEntry array
+
+  async loadZipBlob(data: Blob): Promise<ZipEntry[] | null> {
+    if (getTypeOf(data) !== DATATYPE.BLOB) {
+      throw new Error(Errors.DATATYPE_UNSUPPORTED);
+    }
+
+    return new Promise((resolve, reject) => {
+      const _readEntries = (data: Buffer): ZipEntry[] | null => {
+        try { 
+          super.loadZip(data);
+          return super.getDirectory();
+        } catch (error) {
+          reject(error);
+          return null;
+        }
+      };
+
+      const reader = new window.FileReader();
+      reader.readAsArrayBuffer(data);
+
+      reader.onload = function(this: FileReader, e: ProgressEvent<FileReader>) {
+        if (!this.result) {
+          reject(new Error('Failed to read file'));
+          return;
+        }
+        const _inBuf = Buffer.from(this.result as ArrayBuffer);
+        resolve(_readEntries(_inBuf));
+      };
+
+      reader.onerror = function(this: FileReader, e: ProgressEvent<FileReader>) {
+        reject(this.error || new Error('Failed to read file'));
+      };
+    });
+  }
+
+  // --------------------------------------
+  // Create a ZipEntry for a File object
+
+  createZipFileEntry(file: FileData): ZipEntry {
+    const entry = super.createZipEntry(file.name);
+    entry.fileData = file;
+    entry.uncompressedSize = file.size;
+
+    const fileDate = new Date(file.lastModified);
+    entry.timeDateDOS = entry.setDateTime(fileDate);
+    entry.cmpMethod = Headers.CMP_METHOD.DEFLATED;
+
+    return entry;
+  }
+
+  // --------------------------------------
+  // Calculate the SHA256 hash of a File object
+
+  async hashFile(file: FileData): Promise<string> {
+    const arrayBuffer = await file.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+    return sha256(buffer);
+  }
+
+  // --------------------------------------
+  // Compress the data and return the compressed data buffer
+  // Set the ZipEntry compressSize and CRC32 values
+
+  async compressDataBlob(entry: ZipEntry, data: Blob, options?: CompressOptions): Promise<Buffer> {
+    if (getTypeOf(data) !== DATATYPE.BLOB) {
+      throw new Error(Errors.DATATYPE_UNSUPPORTED);
+    }
+
+    return new Promise(async (resolve, reject) => {
+      const _compressData = async (entry: ZipEntry, data: Buffer, options?: CompressOptions): Promise<Buffer> => {
+        return await super.compressData(entry, data, options);
+      };
+
+      const reader = new window.FileReader();
+      reader.readAsArrayBuffer(data);
+
+      reader.onload = async function(this: FileReader, e: ProgressEvent<FileReader>) {
+        if (!this.result) {
+          reject(new Error('Failed to read file'));
+          return;
+        }
+        try {
+          const _inBuf = Buffer.from(this.result as ArrayBuffer);
+          const result = await _compressData(entry, _inBuf, options);
+          resolve(result);
+        } catch (error) {
+          reject(error);
+        }
+      };
+
+      reader.onerror = function(this: FileReader, e: ProgressEvent<FileReader>) {
+        reject(this.error || new Error('Failed to read file'));
+      };
+    });
+  }
+
+  // --------------------------------------
+  // Extract a Blob from a ZipEntry
+
+  async extractBlob(entry: ZipEntry, skipHashCheck?: boolean): Promise<Blob | null> {
+    try {
+      const _outBuf = await super.extract(entry, skipHashCheck);
+      if (!_outBuf) return null;
+      
+      // Convert Buffer to Uint8Array for Blob compatibility
+      const uint8Array = new Uint8Array(_outBuf);
+      return new Blob([uint8Array], { type: 'application/octet-stream' });
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  // --------------------------------------
+  // Create a ZIP file in memory and return a Blob
+
+  async createZipBlob(cmpOptions?: CompressOptions, options?: CreateZipOptions): Promise<Blob | null> {
+    const _onError = options?.onError || (() => {});
+    const _onEntryDone = options?.onEntryDone || (() => {});
+
+    const zipEntries = super.getDirectory();
+    if (!zipEntries) {
+      _onError(new Error(Errors.NO_FILES));
+      return null;
+    }
+
+    let offset = 0;
+    const buffers: Buffer[] = [];
+
+    for (const entry of zipEntries) {
+      if (!entry.isUpdated) {
+        // CRITICAL FIX: Check for token files even in copy mode
+        if (entry.filename === TOKENIZED_METADATA || entry.filename === TIMESTAMP_SUBMITTED || entry.filename === TIMESTAMP_METADATA) {
+          // Force this entry to be processed with special handling instead of copied
+          entry.isUpdated = true;
+          // Don't continue here - let it fall through to special handling below
+        } else {
+          const inData = super.copyEntry(entry);
+          entry.localHdrOffset = offset;
+          offset += inData.length;
+          buffers.push(inData);
+          _onEntryDone(entry, 'Copied');
+          continue;
+        }
+      }
+
+      if (!entry.fileData) {
+        _onError(new Error(Errors.FILE_NOT_FOUND));
+        return null;
+      }
+
+      const fileBuffer = await entry.fileData.arrayBuffer();
+      
+      // Special handling for token metadata files - store uncompressed with CRC-32
+      if (entry.filename === TOKENIZED_METADATA || entry.filename === TIMESTAMP_SUBMITTED || entry.filename === TIMESTAMP_METADATA) {
+        // For token metadata, use STORED compression (no compression)
+        const buffer = Buffer.from(fileBuffer);
+        
+        // Calculate CRC-32 for the token file (not SHA-256 to avoid Merkle Root interference)
+        entry.crc = crc32(buffer);
+        
+        // Set up entry for STORED compression
+        entry.cmpMethod = 0; // STORED
+        entry.compressedSize = buffer.length;
+        entry.uncompressedSize = buffer.length;
+        
+        // Do NOT set SHA-256 hash for token metadata to avoid Merkle Root calculation
+        // entry.sha256 should remain undefined for metadata files
+        
+        const localHdr = entry.createLocalHdr();
+        entry.localHdrOffset = offset;
+        offset += localHdr.length + buffer.length;
+        
+        buffers.push(localHdr);
+        buffers.push(buffer);
+        _onEntryDone(entry, 'Stored (metadata)');
+      } else {
+        // Normal file processing with compression
+        const cmpData = await super.compressData(entry, Buffer.from(fileBuffer), cmpOptions);
+        const localHdr = entry.createLocalHdr();
+
+        entry.localHdrOffset = offset;
+        offset += localHdr.length + cmpData.length;
+
+        buffers.push(localHdr);
+        buffers.push(cmpData);
+        _onEntryDone(entry, 'Written');
+      }
+    }
+
+    const centralDirOffset = offset;
+    for (const entry of zipEntries) {
+      const centralDirEntry = entry.centralDirEntry();
+      offset += centralDirEntry.length;
+      buffers.push(centralDirEntry);
+    }
+
+    const centralDirSize = offset - centralDirOffset;
+    const ceBuf = super.centralEndHdr(centralDirSize, centralDirOffset);
+    buffers.push(ceBuf);
+
+    const combinedBuffer = Buffer.concat(buffers);
+    // Convert Buffer to Uint8Array for Blob compatibility
+    const uint8Array = new Uint8Array(combinedBuffer);
+    return new Blob([uint8Array], { type: 'application/zip' });
+  } 
+}

package/src/browser/ZipKitStampBrowser.ts

@@ -0,0 +1,9 @@
+// A browser-safe version of ZipKitStamp
+
+export const createTimestamp = async (hash: string, options: any = {}): Promise<any> => {
+  throw new Error('Blockchain timestamp creation is not supported in browsers');
+};
+
+export const verifyTimestamp = async (timestamp: any, options: any = {}): Promise<any> => {
+  throw new Error('Blockchain timestamp verification is not supported in browsers');
+}; 

package/src/browser-index.ts

@@ -0,0 +1,36 @@
+// =============================================================================
+// NeoZipKit - Browser-Only Package Exports  
+// =============================================================================
+
+// Core shared exports
+import ZipKit from './shared/ZipKit';
+export { ZipEntry, Errors, CMP_METHOD, TIMESTAMP_METADATA, TIMESTAMP_SUBMITTED } from './shared/ZipKit';
+export type { CompressOptions } from './shared/ZipKit';
+export * from './shared/ZipKit';
+export * from './shared/ZipEntry';
+export default ZipKit;
+
+// Browser-only exports
+export { default as ZipKitBrowser } from './browser/ZipKitBrowser';
+export { CertificateGeneratorBrowser } from './browser/CertificateGeneratorBrowser';
+export { TokenVerificationResult, checkForTokenization as checkForTokenizationBrowser, NZipTokenInfo } from './browser/TokenVerifierBrowser';
+export type { TokenVerificationOptions } from './browser/TokenVerifierBrowser';
+
+// Shared component exports
+export { default as HashAccumulator } from './shared/components/HashAccumulator';
+export * from './shared/components/Util';
+export * from './shared/components/Support';
+
+// Type and constant exports
+export * from './shared/types';
+export * from './shared/constants/Headers';
+export * from './shared/constants/Errors';
+export * from './shared/version';
+
+// Platform-specific conditional exports
+export const PlatformUtils = {
+  // Browser detection
+  isBrowser: typeof window !== 'undefined' && typeof document !== 'undefined',
+  // Node.js detection  
+  isNode: typeof process !== 'undefined' && process.versions && process.versions.node,
+};

package/src/index.ts

@@ -0,0 +1,48 @@
+// =============================================================================
+// NeoZipKit - Unified Package Exports
+// =============================================================================
+
+// Core shared exports
+import ZipKit from './shared/ZipKit';
+export { ZipEntry, Errors, CMP_METHOD, TIMESTAMP_METADATA, TIMESTAMP_SUBMITTED } from './shared/ZipKit';
+export type { CompressOptions } from './shared/ZipKit';
+export * from './shared/ZipKit';
+export * from './shared/ZipEntry';
+export default ZipKit;
+
+// Browser-only exports
+export { default as ZipKitBrowser } from './browser/ZipKitBrowser';
+export { CertificateGeneratorBrowser } from './browser/CertificateGeneratorBrowser';
+export { TokenVerificationResult, checkForTokenization as checkForTokenizationBrowser, NZipTokenInfo } from './browser/TokenVerifierBrowser';
+export type { TokenVerificationOptions } from './browser/TokenVerifierBrowser';
+
+// Server-only exports (now included in main build)
+export { default as ZipKitServer } from './server/platform/server/ZipKitServer';
+export { verifyTimestamp, createTimestamp } from './server/platform/servercomponents/ZipKitOTS';
+
+// Blockchain exports  
+export * from './server/blockchain';
+export { checkForTokenization as checkForTokenizationServer } from './server/blockchain/TokenVerifier';
+export { NFTMinter } from './server/blockchain/NFTMinter';
+export { WalletAnalyzer } from './server/blockchain/WalletAnalyzer';
+export { WalletManager } from './server/blockchain/WalletManager';
+export { ZipTokenProcessor } from './server/blockchain/ZipTokenProcessor';
+
+// Shared component exports
+export { default as HashAccumulator } from './shared/components/HashAccumulator';
+export * from './shared/components/Util';
+export * from './shared/components/Support';
+
+// Type and constant exports
+export * from './shared/types';
+export * from './shared/constants/Headers';
+export * from './shared/constants/Errors';
+export * from './shared/version';
+
+// Platform-specific conditional exports
+export const PlatformUtils = {
+  // Browser detection
+  isBrowser: typeof window !== 'undefined' && typeof document !== 'undefined',
+  // Node.js detection  
+  isNode: typeof process !== 'undefined' && process.versions && process.versions.node,
+};