midnight-mcp 0.2.9 → 0.2.10

package/dist/{chunk-5PGBYGCG.js → chunk-7KJSVMFI.js}

@@ -25,7 +25,7 @@ import {
   validateNumber,
   validateQuery,
   vectorStore
-} from "./chunk-WZVWUFLH.js";
+} from "./chunk-C23TNY65.js";
 
 // src/tools/search/schemas.ts
 import { z } from "zod";
@@ -786,11 +786,11 @@ async function analyzeContract(input) {
         });
       }
     }
-    if (!parsed.imports.includes("std")) {
+    if (!parsed.imports.includes("CompactStandardLibrary")) {
       findings.push({
         severity: "info",
         message: "Standard library not imported",
-        suggestion: `Consider adding 'include "std";' for common utilities`
+        suggestion: "Consider adding 'import CompactStandardLibrary;' for common utilities"
       });
     }
   }
@@ -1630,13 +1630,15 @@ Always import the standard library:
 import CompactStandardLibrary;
 \`\`\`
 
-For multi-file contracts, use \`include\`:
+For modular code, use module imports (not a separate \`include\` directive):
 \`\`\`compact
-include "types";
-include "ledger";
-include "circuits";
+import "path/to/module";
+import { SomeType } from "other/module";
 \`\`\`
 
+> **Note:** The docs describe modules and \`import\` syntax, but do not document
+> a separate \`include\` directive. Use \`import\` for code organization.
+
 ---
 
 ## 3. Ledger Declarations
@@ -1681,6 +1683,14 @@ ledger privateData: Field;                 // Private, not exported
 | \`Uint<N>\` | Unsigned integer (N = 8, 16, 32, 64, 128, 256) | \`balance: Uint<64>\` |
 | \`Uint<MIN..MAX>\` | Bounded unsigned integer | \`score: Uint<0..100>\` |
 
+**\u26A0\uFE0F Uint Type Equivalence:** \`Uint<N>\` (sized) and \`Uint<0..MAX>\` (bounded) are the **SAME type family**.
+\`Uint<N>\` is exactly equivalent to \`Uint<0..(2^N - 1)>\`:
+- \`Uint<8>\` = \`Uint<0..255>\` (2^8 - 1 = 255)
+- \`Uint<16>\` = \`Uint<0..65535>\` (2^16 - 1 = 65535)
+- \`Uint<64>\` = \`Uint<0..18446744073709551615>\`
+
+These can be used interchangeably - they are **not** separate types.
+
 ### Collection Types
 | Type | Description | Example |
 |------|-------------|---------|
@@ -1913,41 +1923,60 @@ export circuit check_broken(guess: Field): Boolean {
 
 ### Counter Operations
 \`\`\`compact
-// These work in circuits:
-counter.increment(1);
-counter.decrement(1);
-counter.resetToDefault();
-
-// \u26A0\uFE0F DOES NOT WORK IN CIRCUITS:
-// const val = counter.value();  // ERROR: operation undefined
-// Instead, read counter value in TypeScript SDK: ledgerState.counter
+// ALL Counter methods work in circuits:
+counter.increment(1);           // Increase by amount (Uint<16>)
+counter.decrement(1);           // Decrease by amount (Uint<16>)
+const val = counter.read();     // Get current value (returns Uint<64>)
+const low = counter.lessThan(100); // Compare with threshold (returns Boolean)
+counter.resetToDefault();       // Reset to zero
+
+// \u26A0\uFE0F WRONG: counter.value() does NOT exist - use counter.read()
 \`\`\`
 
 ### Map Operations
 \`\`\`compact
-// These work in circuits:
-balances.insert(address, 100);
-balances.remove(address);
-
-// \u26A0\uFE0F DOES NOT WORK IN CIRCUITS:
-// const balance = balances.lookup(address);  // ERROR
-// const exists = balances.member(address);   // ERROR
-// Instead, use witnesses to read values:
-witness get_balance(addr: Bytes<32>): Uint<64>;
+// Map<key_type, value_type> - All operations work in circuits unless noted
+
+// Insert/update operations
+balances.insert(address, 100);           // insert(key, value): []
+balances.insertDefault(address);         // insertDefault(key): [] - inserts default value
+
+// Query operations (all work in circuits \u2705)
+const balance = balances.lookup(address);  // lookup(key): value_type
+const exists = balances.member(address);   // member(key): Boolean
+const empty = balances.isEmpty();          // isEmpty(): Boolean
+const count = balances.size();             // size(): Uint<64>
+
+// Remove operations
+balances.remove(address);                // remove(key): []
+balances.resetToDefault();               // resetToDefault(): [] - clears entire map
+
+// Coin-specific (only when value_type is QualifiedCoinInfo)
+// coinMap.insertCoin(key, coinInfo, recipient): []
 \`\`\`
 
+**TypeScript-only:** \`[Symbol.iterator]()\` for iteration - not available in circuits.
+
 ### Set Operations
 \`\`\`compact
-// These work in circuits:
-members.insert(address);
-members.remove(address);
-
-// \u26A0\uFE0F DOES NOT WORK IN CIRCUITS:
-// const isMember = members.member(address);  // ERROR
-// Use witness instead:
-witness is_member(addr: Bytes<32>): Boolean;
+// Set<value_type> - All operations work in circuits unless noted
+
+// Insert/remove operations
+members.insert(address);                    // insert(elem): []
+members.remove(address);                    // remove(elem): []
+members.resetToDefault();                   // resetToDefault(): [] - clears entire set
+
+// Query operations (all work in circuits \u2705)
+const isMember = members.member(address);   // member(elem): Boolean
+const empty = members.isEmpty();            // isEmpty(): Boolean
+const count = members.size();               // size(): Uint<64>
+
+// Coin-specific (only when value_type is QualifiedCoinInfo)
+// coinSet.insertCoin(coinInfo, recipient): []
 \`\`\`
 
+**TypeScript-only:** \`[Symbol.iterator]()\` for iteration - not available in circuits.
+
 ### Maybe Operations
 \`\`\`compact
 const opt: Maybe<Field> = some<Field>(42);
@@ -2162,9 +2191,13 @@ npm install @openzeppelin/compact-contracts
 ## Usage Example
 
 \`\`\`compact
-include "std";
-include "@openzeppelin/compact-contracts/token/FungibleToken.compact";
-include "@openzeppelin/compact-contracts/access/Ownable.compact";
+pragma language_version >= 0.18.0;
+
+import CompactStandardLibrary;
+import "@openzeppelin/compact-contracts/src/token/FungibleToken"
+  prefix FungibleToken_;
+import "@openzeppelin/compact-contracts/src/access/Ownable"
+  prefix Ownable_;
 
 ledger {
   // Inherit from OpenZeppelin contracts
@@ -2199,8 +2232,11 @@ The recommended standard for privacy-preserving tokens on Midnight.
 ## Basic Usage
 
 \`\`\`compact
-include "std";
-include "@openzeppelin/compact-contracts/token/FungibleToken.compact";
+pragma language_version >= 0.18.0;
+
+import CompactStandardLibrary;
+import "@openzeppelin/compact-contracts/src/token/FungibleToken"
+  prefix FungibleToken_;
 
 ledger {
   ...FungibleToken.ledger;
@@ -2241,7 +2277,8 @@ export circuit revealBalance(): Field {
 ## Minting and Burning
 
 \`\`\`compact
-include "@openzeppelin/compact-contracts/access/Ownable.compact";
+import "@openzeppelin/compact-contracts/src/access/Ownable"
+  prefix Ownable_;
 
 ledger {
   ...FungibleToken.ledger;
@@ -2283,7 +2320,8 @@ Patterns for controlling who can call contract functions.
 Simple single-owner access control.
 
 \`\`\`compact
-include "@openzeppelin/compact-contracts/access/Ownable.compact";
+import "@openzeppelin/compact-contracts/src/access/Ownable"
+  prefix Ownable_;
 
 ledger {
   ...Ownable.ledger;
@@ -2309,7 +2347,8 @@ export circuit transferOwnership(newOwner: Address): Void {
 For more complex permission systems.
 
 \`\`\`compact
-include "@openzeppelin/compact-contracts/access/AccessControl.compact";
+import "@openzeppelin/compact-contracts/src/access/AccessControl"
+  prefix AccessControl_;
 
 ledger {
   ...AccessControl.ledger;
@@ -2337,8 +2376,10 @@ export circuit grantMinterRole(account: Address): Void {
 ## Combining Patterns
 
 \`\`\`compact
-include "@openzeppelin/compact-contracts/access/Ownable.compact";
-include "@openzeppelin/compact-contracts/security/Pausable.compact";
+import "@openzeppelin/compact-contracts/src/access/Ownable"
+  prefix Ownable_;
+import "@openzeppelin/compact-contracts/src/security/Pausable"
+  prefix Pausable_;
 
 ledger {
   ...Ownable.ledger;
@@ -2366,8 +2407,10 @@ Security utilities for Compact contracts.
 Emergency stop mechanism for contracts.
 
 \`\`\`compact
-include "@openzeppelin/compact-contracts/security/Pausable.compact";
-include "@openzeppelin/compact-contracts/access/Ownable.compact";
+import "@openzeppelin/compact-contracts/src/security/Pausable"
+  prefix Pausable_;
+import "@openzeppelin/compact-contracts/src/access/Ownable"
+  prefix Ownable_;
 
 ledger {
   ...Pausable.ledger;
@@ -2773,134 +2816,131 @@ var EMBEDDED_CODE = {
   "midnight://code/examples/counter": `// Counter Example Contract
 // A simple contract demonstrating basic Compact concepts
 
-include "std";
+pragma language_version >= 0.16 && <= 0.18;
 
-ledger {
-  // Public counter - visible to everyone
-  counter: Counter;
-  
-  // Track last modifier (public)
-  lastModifier: Opaque<"address">;
-}
+import CompactStandardLibrary;
+
+// Public counter - visible to everyone
+export ledger counter: Counter;
+
+// Track last modifier (public)
+export ledger lastModifier: Opaque<"address">;
 
 // Increment the counter
-export circuit increment(amount: Field): Field {
+export circuit increment(amount: Uint<16>): Uint<64> {
   // Validate input
-  assert(amount > 0, "Amount must be positive");
-  assert(amount <= 100, "Amount too large");
+  assert(amount > 0 as Uint<16>, "Amount must be positive");
+  assert(amount <= 100 as Uint<16>, "Amount too large");
   
   // Update counter
-  ledger.counter.increment(amount);
+  counter.increment(amount);
   
   // Return new value
-  return ledger.counter.value();
+  return counter.read();
 }
 
 // Decrement the counter
-export circuit decrement(amount: Field): Field {
+export circuit decrement(amount: Uint<16>): Uint<64> {
   // Validate input
-  assert(amount > 0, "Amount must be positive");
-  assert(ledger.counter.value() >= amount, "Counter would go negative");
+  assert(amount > 0 as Uint<16>, "Amount must be positive");
+  assert(counter.read() >= (amount as Uint<64>), "Counter would go negative");
   
   // Update counter
-  ledger.counter.decrement(amount);
+  counter.decrement(amount);
   
   // Return new value
-  return ledger.counter.value();
+  return counter.read();
 }
 
 // Read current value (view function)
-export circuit getValue(): Field {
-  return ledger.counter.value();
+export circuit getValue(): Uint<64> {
+  return counter.read();
+}
+
+// Check if counter is below threshold
+export circuit isLessThan(threshold: Uint<64>): Boolean {
+  return counter.lessThan(threshold);
 }
 `,
   "midnight://code/examples/bboard": `// Bulletin Board Example Contract
 // Demonstrates private messaging with selective disclosure
 
-include "std";
+pragma language_version >= 0.16 && <= 0.18;
 
-ledger {
-  // Public: message count and IDs
-  messageCount: Counter;
-  messageIds: Set<Field>;
-  
-  // Private: actual message contents
-  @private
-  messages: Map<Field, Opaque<"string">>;
-  
-  // Private: message authors
-  @private
-  authors: Map<Field, Opaque<"address">>;
-}
+import CompactStandardLibrary;
+
+// Public: message count and IDs
+export ledger messageCount: Counter;
+export ledger messageIds: Set<Field>;
+
+// Private: actual message contents (no export = private)
+ledger messages: Map<Field, Opaque<"string">>;
+
+// Private: message authors
+ledger authors: Map<Field, Opaque<"address">>;
+
+// Witness to fetch message content
+witness getMessageContent(id: Field): Opaque<"string">;
 
 // Post a new message (content is private)
-export circuit postMessage(content: Opaque<"string">, author: Opaque<"address">): Field {
-  // Generate unique message ID
-  const messageId = ledger.messageCount.value();
+export circuit postMessage(content: Opaque<"string">, author: Opaque<"address">): Uint<64> {
+  // Generate unique message ID using counter read
+  const messageId = messageCount.read();
   
   // Store message privately
-  ledger.messages.insert(messageId, content);
-  ledger.authors.insert(messageId, author);
+  messages.insert(messageId as Field, content);
+  authors.insert(messageId as Field, author);
   
   // Update public counters
-  ledger.messageCount.increment(1);
-  ledger.messageIds.add(messageId);
+  messageCount.increment(1);
+  messageIds.insert(messageId as Field);
   
   return messageId;
 }
 
-// Witness to fetch message content
-witness getMessageContent(id: Field): Opaque<"string"> {
-  return ledger.messages.get(id);
-}
-
 // Reveal a message publicly (owner's choice)
 export circuit revealMessage(id: Field): Opaque<"string"> {
-  assert(ledger.messageIds.contains(id), "Message not found");
+  assert(messageIds.member(id), "Message not found");
   
   const content = getMessageContent(id);
   return disclose(content);
 }
 
 // Get total message count
-export circuit getMessageCount(): Field {
-  return ledger.messageCount.value();
+export circuit getMessageCount(): Uint<64> {
+  return messageCount.read();
 }
 `,
   "midnight://code/patterns/state-management": `// State Management Pattern
 // Best practices for managing public and private state
 
-include "std";
+pragma language_version >= 0.16 && <= 0.18;
 
-ledger {
-  // PUBLIC STATE
-  // - Use for data that should be transparent
-  // - Visible in blockchain explorers
-  // - Can be queried by anyone
-  
-  totalSupply: Counter;
-  publicConfig: Field;
-  
-  // PRIVATE STATE
-  // - Use for sensitive user data
-  // - Only owner can read
-  // - Requires witnesses to access in circuits
-  
-  @private
-  userSecrets: Map<Opaque<"address">, Bytes<32>>;
-  
-  @private
-  privateBalances: Map<Opaque<"address">, Field>;
-}
+import CompactStandardLibrary;
 
-// Reading public state is straightforward
-export circuit getTotalSupply(): Field {
-  return ledger.totalSupply.value();
-}
+// PUBLIC STATE
+// - Use 'export ledger' for data that should be transparent
+// - Visible in blockchain explorers
+// - Can be queried by anyone
+
+export ledger totalSupply: Uint<64>;
+export ledger publicConfig: Field;
+
+// PRIVATE STATE
+// - Use 'ledger' without export for sensitive user data
+// - Only owner can read
+// - Requires witnesses to access in circuits
 
-// Reading private state requires a witness
-witness getUserSecret(user: Opaque<"address">): Bytes<32> {
-  return ledger.userSecrets.get(user);
+ledger userSecrets: Map<Opaque<"address">, Bytes<32>>;
+ledger privateBalances: Map<Opaque<"address">, Field>;
+
+// Witnesses for private data access
+witness getUserSecret(user: Opaque<"address">): Bytes<32>;
+witness getPrivateBalance(user: Opaque<"address">): Field;
+
+// Reading public state is straightforward
+export circuit getTotalSupply(): Uint<64> {
+  return ledger.totalSupply;
 }
 
 // Using private state in a circuit
@@ -2911,7 +2951,7 @@ export circuit proveSecretKnowledge(
   const secret = getUserSecret(user);
   
   // Prove knowledge without revealing secret
-  assert(hash(secret) == secretHash);
+  assert(persistentHash(secret) == secretHash, "Invalid secret");
   return true;
 }
 
@@ -2921,53 +2961,45 @@ export circuit revealBalance(user: Opaque<"address">): Field {
   // Explicitly reveal - user's choice
   return disclose(balance);
 }
-
-witness getPrivateBalance(user: Opaque<"address">): Field {
-  return ledger.privateBalances.get(user);
-}
 `,
   "midnight://code/patterns/access-control": `// Access Control Pattern
 // Implementing permissions and authorization
 
-include "std";
+pragma language_version >= 0.16 && <= 0.18;
+
+import CompactStandardLibrary;
 
-ledger {
-  // Role definitions
-  owner: Opaque<"address">;
-  admins: Set<Opaque<"address">>;
-  
-  // Access-controlled state
-  sensitiveData: Field;
-  
-  @private
-  adminKeys: Map<Opaque<"address">, Bytes<32>>;
-}
+// Role definitions
+export ledger owner: Opaque<"address">;
+export ledger admins: Set<Opaque<"address">>;
+
+// Access-controlled state
+export ledger sensitiveData: Field;
+
+// Private admin keys
+ledger adminKeys: Map<Opaque<"address">, Bytes<32>>;
 
 // Witness to get caller identity
-witness getCaller(): Opaque<"address"> {
-  return getCurrentCaller();
-}
+witness getCaller(): Opaque<"address">;
 
 // Only owner can call
-export circuit onlyOwnerAction(newValue: Field): Void {
+export circuit onlyOwnerAction(newValue: Field): [] {
   const caller = getCaller();
-  assert(caller == ledger.owner, "Not owner");
+  assert(caller == owner, "Not owner");
   
-  ledger.sensitiveData = newValue;
+  sensitiveData = newValue;
 }
 
 // Only admins can call
-export circuit onlyAdminAction(data: Field): Void {
+export circuit onlyAdminAction(data: Field): [] {
   const caller = getCaller();
-  assert(ledger.admins.contains(caller), "Not admin");
+  assert(admins.member(caller), "Not admin");
   
   // Admin action here
 }
 
 // Multi-sig pattern (require multiple approvals)
-witness getApprovalCount(action: Bytes<32>): Field {
-  return countApprovals(action);
-}
+witness getApprovalCount(action: Bytes<32>): Field;
 
 export circuit requireMultisig(action: Bytes<32>, threshold: Field): Boolean {
   const approvals = getApprovalCount(action);
@@ -2976,11 +3008,9 @@ export circuit requireMultisig(action: Bytes<32>, threshold: Field): Boolean {
 }
 
 // Time-locked action
-witness getCurrentTime(): Field {
-  return getBlockTimestamp();
-}
+witness getCurrentTime(): Field;
 
-export circuit timeLockedAction(unlockTime: Field): Void {
+export circuit timeLockedAction(unlockTime: Field): [] {
   const currentTime = getCurrentTime();
   assert(currentTime >= unlockTime, "Action is timelocked");
   
@@ -2990,21 +3020,23 @@ export circuit timeLockedAction(unlockTime: Field): Void {
   "midnight://code/patterns/privacy-preserving": `// Privacy-Preserving Patterns
 // Techniques for maintaining privacy in smart contracts
 
-include "std";
+pragma language_version >= 0.16 && <= 0.18;
+
+import CompactStandardLibrary;
 
-ledger {
-  // Commitment-based private balance
-  balanceCommitments: Map<Opaque<"address">, Field>;
-  
-  // Nullifier set (prevents double-spending)
-  nullifiers: Set<Field>;
-  
-  @private
-  secretBalances: Map<Opaque<"address">, Field>;
-  
-  @private
-  secretNonces: Map<Opaque<"address">, Field>;
-}
+// Commitment-based private balance
+export ledger balanceCommitments: Map<Opaque<"address">, Field>;
+
+// Nullifier set (prevents double-spending)
+export ledger nullifiers: Set<Field>;
+
+// Private state
+ledger secretBalances: Map<Opaque<"address">, Field>;
+ledger secretNonces: Map<Opaque<"address">, Field>;
+
+// Witnesses for private state
+witness getSecretBalance(user: Opaque<"address">): Field;
+witness getSecretNonce(user: Opaque<"address">): Field;
 
 // PATTERN 1: Commitment Scheme
 // Store commitments instead of values
@@ -3014,11 +3046,14 @@ export circuit deposit(
   amount: Field,
   nonce: Field
 ): Field {
-  // Create commitment: hash(amount, nonce, user)
-  const commitment = hash(amount, nonce, user);
+  // Create commitment: hash(amount || nonce)
+  // Use a struct to combine values into a single hashable input
+  struct CommitmentInput { amount: Field, nonce: Field }
+  const input = CommitmentInput { amount: amount, nonce: nonce };
+  const commitment = persistentHash<Field>(input);
   
   // Store commitment (hides amount)
-  ledger.balanceCommitments.insert(user, commitment);
+  balanceCommitments.insert(user, commitment);
   
   return commitment;
 }
@@ -3030,31 +3065,31 @@ export circuit proveBalance(
   minBalance: Field
 ): Boolean {
   // Verify commitment
-  const expectedCommitment = hash(amount, nonce, user);
-  assert(ledger.balanceCommitments.get(user) == expectedCommitment);
+  struct CommitmentInput { amount: Field, nonce: Field }
+  const input = CommitmentInput { amount: amount, nonce: nonce };
+  const expectedCommitment = persistentHash<Field>(input);
+  assert(balanceCommitments.lookup(user) == expectedCommitment, "Invalid commitment");
   
   // Prove property without revealing value
-  assert(amount >= minBalance);
+  assert(amount >= minBalance, "Insufficient balance");
   return true;
 }
 
 // PATTERN 2: Nullifiers (Prevent Double-Spending)
 
-witness generateNullifier(secret: Bytes<32>, action: Field): Field {
-  return hash(secret, action);
-}
+witness generateNullifier(secret: Bytes<32>, action: Field): Field;
 
 export circuit spendOnce(
   secret: Bytes<32>,
   action: Field
-): Void {
+): [] {
   const nullifier = generateNullifier(secret, action);
   
   // Check nullifier hasn't been used
-  assert(!ledger.nullifiers.contains(nullifier), "Already spent");
+  assert(!nullifiers.member(nullifier), "Already spent");
   
   // Mark as used
-  ledger.nullifiers.add(nullifier);
+  nullifiers.insert(nullifier);
   
   // Perform action
 }
@@ -3062,72 +3097,55 @@ export circuit spendOnce(
 // PATTERN 3: Range Proofs
 
 export circuit proveInRange(
-  @private value: Field,
+  value: Field,
   min: Field,
   max: Field
 ): Boolean {
   // Prove value is in range without revealing it
-  assert(value >= min);
-  assert(value <= max);
+  assert(value >= min, "Below minimum");
+  assert(value <= max, "Above maximum");
   return true;
 }
 
 // PATTERN 4: Private Set Membership
 
+witness computeMerkleRoot(element: Field, proof: Vector<10, Field>): Field;
+
 export circuit proveMembership(
-  @private element: Field,
+  element: Field,
   setRoot: Field,
-  @private proof: Array<Field>
+  proof: Vector<10, Field>
 ): Boolean {
   // Prove element is in set without revealing which element
   const computedRoot = computeMerkleRoot(element, proof);
-  assert(computedRoot == setRoot);
+  assert(computedRoot == setRoot, "Invalid membership proof");
   return true;
 }
-
-witness computeMerkleRoot(element: Field, proof: Array<Field>): Field {
-  // Compute Merkle root from element and proof
-  return merkleCompute(element, proof);
-}
 `,
   "midnight://code/templates/token": `// Privacy-Preserving Token Template
 // Starter template for token contracts with privacy features
 
-include "std";
+pragma language_version >= 0.16 && <= 0.18;
 
-ledger {
-  // Public token metadata
-  name: Opaque<"string">;
-  symbol: Opaque<"string">;
-  decimals: Field;
-  totalSupply: Counter;
-  
-  // Private balances
-  @private
-  balances: Map<Opaque<"address">, Field>;
-  
-  // Private allowances
-  @private
-  allowances: Map<Opaque<"address">, Map<Opaque<"address">, Field>>;
-}
+import CompactStandardLibrary;
 
-// Witnesses for private state access
-witness getBalance(account: Opaque<"address">): Field {
-  return ledger.balances.get(account) ?? 0;
-}
+// Public token metadata
+export ledger name: Bytes<32>;
+export ledger symbol: Bytes<8>;
+export ledger decimals: Uint<8>;
+export ledger totalSupply: Uint<64>;
 
-witness getAllowance(owner: Opaque<"address">, spender: Opaque<"address">): Field {
-  return ledger.allowances.get(owner)?.get(spender) ?? 0;
-}
+// Private balances
+ledger balances: Map<Opaque<"address">, Uint<64>>;
 
-witness getCaller(): Opaque<"address"> {
-  return getCurrentCaller();
-}
+// Witnesses for private state access
+witness getBalance(account: Opaque<"address">): Uint<64>;
+witness getCaller(): Opaque<"address">;
 
 // Transfer tokens privately
 export circuit transfer(
   to: Opaque<"address">,
-  amount: Field
+  amount: Uint<64>
 ): Boolean {
   const from = getCaller();
   const fromBalance = getBalance(from);
@@ -3137,224 +3155,153 @@ export circuit transfer(
   assert(fromBalance >= amount, "Insufficient balance");
   
   // Update balances privately
-  ledger.balances.insert(from, fromBalance - amount);
-  ledger.balances.insert(to, getBalance(to) + amount);
-  
-  return true;
-}
-
-// Approve spender
-export circuit approve(
-  spender: Opaque<"address">,
-  amount: Field
-): Boolean {
-  const owner = getCaller();
-  
-  // Get or create allowance map for owner
-  // Note: Simplified - actual implementation needs nested map handling
-  ledger.allowances.get(owner).insert(spender, amount);
-  
-  return true;
-}
-
-// Transfer from approved account
-export circuit transferFrom(
-  from: Opaque<"address">,
-  to: Opaque<"address">,
-  amount: Field
-): Boolean {
-  const spender = getCaller();
-  const allowance = getAllowance(from, spender);
-  const fromBalance = getBalance(from);
-  
-  // Validate
-  assert(amount > 0, "Invalid amount");
-  assert(allowance >= amount, "Insufficient allowance");
-  assert(fromBalance >= amount, "Insufficient balance");
-  
-  // Update state
-  ledger.balances.insert(from, fromBalance - amount);
-  ledger.balances.insert(to, getBalance(to) + amount);
-  ledger.allowances.get(from).insert(spender, allowance - amount);
+  balances.insert(from, fromBalance - amount);
+  balances.insert(to, getBalance(to) + amount);
   
   return true;
 }
 
 // Reveal balance (user's choice)
-export circuit revealMyBalance(): Field {
+export circuit revealMyBalance(): Uint<64> {
   const caller = getCaller();
   const balance = getBalance(caller);
   return disclose(balance);
 }
+
+// Get total supply
+witness getTotalSupply(): Uint<64> {
+  return ledger.totalSupply;
+}
+
+// Mint new tokens (admin only)
+export circuit mint(to: Opaque<"address">, amount: Uint<64>): Boolean {
+  // Add access control in production
+  balances.insert(to, getBalance(to) + amount);
+  ledger.totalSupply = getTotalSupply() + amount;
+  return true;
+}
 `,
   "midnight://code/templates/voting": `// Private Voting Template
 // Starter template for privacy-preserving voting contracts
 
-include "std";
+pragma language_version >= 0.16 && <= 0.18;
 
-ledger {
-  // Public: proposal metadata
-  proposalCount: Counter;
-  proposals: Map<Field, Opaque<"string">>;
-  votingDeadlines: Map<Field, Field>;
-  
-  // Public: vote tallies (revealed after voting ends)
-  finalTallies: Map<Field, Map<Field, Field>>; // proposalId -> optionId -> count
-  
-  // Private: individual votes
-  @private
-  votes: Map<Field, Map<Opaque<"address">, Field>>; // proposalId -> voter -> option
-  
-  // Nullifiers to prevent double voting
-  voteNullifiers: Set<Field>;
-  
-  // Eligible voters
-  eligibleVoters: Set<Opaque<"address">>;
-}
+import CompactStandardLibrary;
 
-// Witnesses
-witness getCaller(): Opaque<"address"> {
-  return getCurrentCaller();
-}
+// Public: proposal metadata
+export ledger proposalCount: Counter;
+export ledger proposals: Map<Uint<64>, Bytes<256>>;
+export ledger votingDeadlines: Map<Uint<64>, Uint<64>>;
 
-witness getCurrentTime(): Field {
-  return getBlockTimestamp();
-}
+// Private: individual votes
+ledger votes: Map<Uint<64>, Map<Opaque<"address">, Uint<8>>>;
 
-witness getVote(proposalId: Field, voter: Opaque<"address">): Field {
-  return ledger.votes.get(proposalId)?.get(voter) ?? 0;
-}
+// Nullifiers to prevent double voting
+export ledger voteNullifiers: Set<Bytes<32>>;
 
-witness computeNullifier(voter: Opaque<"address">, proposalId: Field): Field {
-  return hash(voter, proposalId);
-}
+// Eligible voters
+export ledger eligibleVoters: Set<Opaque<"address">>;
+
+// Witnesses
+witness getCaller(): Opaque<"address">;
+witness getCurrentTime(): Uint<64>;
+witness getVote(proposalId: Uint<64>, voter: Opaque<"address">): Uint<8>;
+witness computeNullifier(voter: Opaque<"address">, proposalId: Uint<64>): Bytes<32>;
 
 // Create a new proposal
 export circuit createProposal(
-  description: Opaque<"string">,
-  deadline: Field,
-  options: Field
-): Field {
-  const proposalId = ledger.proposalCount.value();
-  
-  // Store proposal
-  ledger.proposals.insert(proposalId, description);
-  ledger.votingDeadlines.insert(proposalId, deadline);
+  description: Bytes<256>,
+  deadline: Uint<64>
+): Uint<64> {
+  const proposalId = proposalCount.read();
   
-  // Initialize tally for each option
-  // (Simplified - actual implementation needs loop)
+  // Store proposal - proposalId is Uint<64> from Counter.read()
+  proposals.insert(proposalId, description);
+  votingDeadlines.insert(proposalId, deadline);
   
-  ledger.proposalCount.increment(1);
+  proposalCount.increment(1);
   return proposalId;
 }
 
 // Cast a private vote
 export circuit vote(
-  proposalId: Field,
-  option: Field
+  proposalId: Uint<64>,
+  option: Uint<8>
 ): Boolean {
   const voter = getCaller();
   const currentTime = getCurrentTime();
   
   // Check eligibility
-  assert(ledger.eligibleVoters.contains(voter), "Not eligible to vote");
+  assert(eligibleVoters.member(voter), "Not eligible to vote");
   
   // Check deadline
-  const deadline = ledger.votingDeadlines.get(proposalId);
+  const deadline = votingDeadlines.lookup(proposalId);
   assert(currentTime < deadline, "Voting ended");
   
   // Check for double voting using nullifier
   const nullifier = computeNullifier(voter, proposalId);
-  assert(!ledger.voteNullifiers.contains(nullifier), "Already voted");
-  
-  // Record vote privately
-  ledger.votes.get(proposalId).insert(voter, option);
+  assert(!voteNullifiers.member(nullifier), "Already voted");
   
   // Add nullifier to prevent double voting
-  ledger.voteNullifiers.add(nullifier);
+  voteNullifiers.insert(nullifier);
   
   return true;
 }
 
 // Reveal individual vote (voter's choice)
-export circuit revealMyVote(proposalId: Field): Field {
+export circuit revealMyVote(proposalId: Uint<32>): Uint<8> {
   const voter = getCaller();
   const myVote = getVote(proposalId, voter);
   return disclose(myVote);
 }
 
-// Tally votes (after deadline)
-// Note: This is simplified - real implementation would need
-// a mechanism to privately aggregate votes
-export circuit tallyVotes(proposalId: Field): Boolean {
-  const currentTime = getCurrentTime();
-  const deadline = ledger.votingDeadlines.get(proposalId);
-  
-  assert(currentTime >= deadline, "Voting still active");
-  
-  // In a real implementation, votes would be aggregated
-  // using homomorphic encryption or MPC
-  
-  return true;
-}
-
 // Add eligible voter (admin only)
-export circuit addVoter(voter: Opaque<"address">): Void {
+export circuit addVoter(voter: Opaque<"address">): [] {
   // Add access control in real implementation
-  ledger.eligibleVoters.add(voter);
+  eligibleVoters.insert(voter);
 }
 `,
   "midnight://code/examples/nullifier": `// Nullifier Pattern Example
 // Demonstrates how to create and use nullifiers to prevent double-spending/actions
 
-include "std";
+pragma language_version >= 0.16 && <= 0.18;
+
+import CompactStandardLibrary;
 
-ledger {
-  // Set of used nullifiers - prevents replay attacks
-  usedNullifiers: Set<Bytes<32>>;
-  
-  // Track claimed rewards
-  claimedRewards: Counter;
-}
+// Set of used nullifiers - prevents replay attacks
+export ledger usedNullifiers: Set<Bytes<32>>;
+
+// Track claimed rewards
+export ledger claimedRewards: Counter;
 
 // Hash function for creating nullifiers
 // Combines secret + public data to create unique identifier
-witness computeNullifier(secret: Field, commitment: Field): Bytes<32> {
-  // Hash the secret with the commitment
-  // The nullifier reveals nothing about the secret
-  // but is unique per secret+commitment pair
-  return hash(secret, commitment);
-}
+witness computeNullifier(secret: Field, commitment: Field): Bytes<32>;
 
 // Alternative: nullifier from address and action ID
-witness computeActionNullifier(
-  userSecret: Field, 
-  actionId: Field
-): Bytes<32> {
-  // Create nullifier: hash(secret || actionId)
-  return hash(userSecret, actionId);
-}
+witness computeActionNullifier(userSecret: Field, actionId: Field): Bytes<32>;
 
 // Claim a reward (can only claim once per user)
+// Note: rewardAmount is Uint<16> to match Counter.increment signature
 export circuit claimReward(
   secret: Field,
   commitment: Field,
-  rewardAmount: Field
+  rewardAmount: Uint<16>
 ): Boolean {
   // Compute the nullifier
   const nullifier = computeNullifier(secret, commitment);
   
   // Check nullifier hasn't been used (prevents double-claim)
   assert(
-    !ledger.usedNullifiers.contains(nullifier), 
+    !usedNullifiers.member(nullifier), 
     "Reward already claimed"
   );
   
   // Mark nullifier as used
-  ledger.usedNullifiers.add(nullifier);
+  usedNullifiers.insert(nullifier);
   
-  // Process reward
-  ledger.claimedRewards.increment(rewardAmount);
+  // Process reward (Counter.increment takes Uint<16>)
+  claimedRewards.increment(rewardAmount);
   
   return true;
 }
@@ -3370,12 +3317,12 @@ export circuit voteWithNullifier(
   
   // Ensure hasn't voted on this proposal
   assert(
-    !ledger.usedNullifiers.contains(nullifier),
+    !usedNullifiers.member(nullifier),
     "Already voted on this proposal"
   );
   
   // Record nullifier
-  ledger.usedNullifiers.add(nullifier);
+  usedNullifiers.insert(nullifier);
   
   // Process vote...
   return true;
@@ -3384,42 +3331,18 @@ export circuit voteWithNullifier(
   "midnight://code/examples/hash": `// Hash Functions in Compact
 // Examples of using hash functions for various purposes
 
-include "std";
+pragma language_version >= 0.16 && <= 0.18;
 
-ledger {
-  commitments: Set<Bytes<32>>;
-  hashedData: Map<Field, Bytes<32>>;
-}
+import CompactStandardLibrary;
 
-// Basic hash function usage
-witness simpleHash(data: Field): Bytes<32> {
-  // Hash a single field element
-  return hash(data);
-}
+export ledger commitments: Set<Bytes<32>>;
+export ledger hashedData: Map<Field, Bytes<32>>;
 
-// Hash multiple values together
-witness hashMultiple(a: Field, b: Field, c: Field): Bytes<32> {
-  // Concatenate and hash
-  return hash(a, b, c);
-}
+// Basic hash function usage
+witness simpleHash(data: Field): Bytes<32>;
 
 // Create a commitment (hash of value + randomness)
-witness createCommitment(value: Field, randomness: Field): Bytes<32> {
-  // Pedersen-style commitment: H(value || randomness)
-  return hash(value, randomness);
-}
-
-// Hash bytes data
-witness hashBytes(data: Bytes<64>): Bytes<32> {
-  return hash(data);
-}
-
-// Create nullifier from secret
-witness createNullifier(secret: Field, publicInput: Field): Bytes<32> {
-  // Nullifier = H(secret || publicInput)
-  // Reveals nothing about secret, but is deterministic
-  return hash(secret, publicInput);
-}
+witness createCommitment(value: Field, randomness: Field): Bytes<32>;
 
 // Verify a commitment matches
 export circuit verifyCommitment(
@@ -3435,108 +3358,105 @@ export circuit verifyCommitment(
 // Store a hashed value
 export circuit storeHashed(id: Field, data: Field): Bytes<32> {
   const hashed = simpleHash(data);
-  ledger.hashedData.insert(id, hashed);
+  hashedData.insert(id, hashed);
   return hashed;
 }
 
 // Commit-reveal pattern
 export circuit commit(commitment: Bytes<32>): Boolean {
-  assert(!ledger.commitments.contains(commitment), "Already committed");
-  ledger.commitments.add(commitment);
+  assert(!commitments.member(commitment), "Already committed");
+  commitments.insert(commitment);
   return true;
 }
 
 export circuit reveal(value: Field, randomness: Field): Field {
   const commitment = createCommitment(value, randomness);
-  assert(ledger.commitments.contains(commitment), "No matching commitment");
+  assert(commitments.member(commitment), "No matching commitment");
   return disclose(value);
 }
 `,
   "midnight://code/examples/simple-counter": `// Simple Counter Contract
 // Minimal example for learning Compact basics
 
-include "std";
+pragma language_version >= 0.16 && <= 0.18;
+
+import CompactStandardLibrary;
 
 // Ledger state - stored on chain
-ledger {
-  counter: Counter;
-}
+export ledger counter: Counter;
 
 // Increment the counter by 1
-export circuit increment(): Field {
-  ledger.counter.increment(1);
-  return ledger.counter.value();
+export circuit increment(): Uint<64> {
+  counter.increment(1);
+  return counter.read();
 }
 
 // Decrement the counter by 1  
-export circuit decrement(): Field {
-  assert(ledger.counter.value() > 0, "Cannot go below zero");
-  ledger.counter.decrement(1);
-  return ledger.counter.value();
+export circuit decrement(): Uint<64> {
+  assert(counter.read() > 0, "Cannot go below zero");
+  counter.decrement(1);
+  return counter.read();
 }
 
 // Get current value
-export circuit get(): Field {
-  return ledger.counter.value();
+export circuit get(): Uint<64> {
+  return counter.read();
+}
+
+// Check if below threshold
+export circuit isBelowLimit(limit: Uint<64>): Boolean {
+  return counter.lessThan(limit);
 }
 
-// Reset to zero (add access control in real apps)
-export circuit reset(): Void {
-  const current = ledger.counter.value();
-  ledger.counter.decrement(current);
+// Reset to zero
+export circuit reset(): [] {
+  counter.resetToDefault();
 }
 `,
   "midnight://code/templates/basic": `// Basic Compact Contract Template
 // Starting point for new contracts
 
-include "std";
+pragma language_version >= 0.16 && <= 0.18;
+
+import CompactStandardLibrary;
 
 // ============================================
 // LEDGER STATE
 // ============================================
 
-ledger {
-  // Public state (visible on-chain)
-  initialized: Boolean;
-  owner: Opaque<"address">;
-  
-  // Private state (only owner can see)
-  @private
-  secretData: Field;
-}
+// Public state (visible on-chain)
+export ledger initialized: Boolean;
+export ledger owner: Opaque<"address">;
+
+// Private state (only owner can see)
+ledger secretData: Field;
+
+// ============================================
+// WITNESSES
+// ============================================
+
+witness getCaller(): Opaque<"address">;
+witness getSecret(): Field;
 
 // ============================================
 // INITIALIZATION
 // ============================================
 
 export circuit initialize(ownerAddress: Opaque<"address">): Boolean {
-  assert(!ledger.initialized, "Already initialized");
+  assert(!initialized, "Already initialized");
   
-  ledger.owner = ownerAddress;
-  ledger.initialized = true;
+  owner = ownerAddress;
+  initialized = true;
   
   return true;
 }
 
-// ============================================
-// ACCESS CONTROL
-// ============================================
-
-witness getCaller(): Opaque<"address"> {
-  // Returns the transaction sender
-  return context.caller;
-}
-
-witness isOwner(): Boolean {
-  return getCaller() == ledger.owner;
-}
-
 // ============================================
 // PUBLIC FUNCTIONS
 // ============================================
 
 export circuit publicFunction(input: Field): Field {
-  assert(ledger.initialized, "Not initialized");
+  assert(initialized, "Not initialized");
   
   // Your logic here
   return input * 2;
@@ -3546,22 +3466,19 @@ export circuit publicFunction(input: Field): Field {
 // OWNER-ONLY FUNCTIONS
 // ============================================
 
-export circuit setSecret(newSecret: Field): Void {
-  assert(isOwner(), "Only owner can set secret");
-  ledger.secretData = newSecret;
+export circuit setSecret(newSecret: Field): [] {
+  const caller = getCaller();
+  assert(caller == owner, "Only owner can set secret");
+  secretData = newSecret;
 }
 
 // ============================================
 // PRIVATE DATA ACCESS
 // ============================================
 
-witness getSecret(): Field {
-  assert(isOwner(), "Only owner can view");
-  return ledger.secretData;
-}
-
 export circuit revealSecret(): Field {
-  assert(isOwner(), "Only owner can reveal");
+  const caller = getCaller();
+  assert(caller == owner, "Only owner can reveal");
   return disclose(getSecret());
 }
 `
@@ -4671,10 +4588,11 @@ Key Compact concepts:
 - \`Field\`, \`Boolean\`, \`Uint<N>\`, \`Bytes<N>\` - Primitive types
 
 Always include:
-1. Proper imports (include "std")
-2. Clear ledger state definitions
-3. Access control where appropriate
-4. Comprehensive inline comments
+1. Proper imports (import CompactStandardLibrary;)
+2. pragma language_version >= 0.18.0;
+3. Clear ledger state definitions
+4. Access control where appropriate
+5. Comprehensive inline comments
 
 Return ONLY the Compact code, no explanations.`;
   const userPrompt = options.baseExample ? `Based on this example contract:
@@ -4859,6 +4777,406 @@ ${code}
   }
 }
 
+// src/services/syntax-validator.ts
+var ADT_SEARCH_LIMIT = 10;
+var SYNTAX_RESULTS_LIMIT = 10;
+var SYNTAX_SUBQUERY_LIMIT = 5;
+var MAX_NOTE_SOURCE_LENGTH = 500;
+var NOTE_MIN_LENGTH = 20;
+var NOTE_MAX_LENGTH = 300;
+var MAX_NOTES_PER_ADT = 3;
+async function searchADTInfo(adtName) {
+  try {
+    const docsResult = await searchDocsHosted(
+      `${adtName} ADT operations methods ledger`,
+      ADT_SEARCH_LIMIT,
+      "reference"
+    );
+    if (!docsResult.results || docsResult.results.length === 0) {
+      logger.debug(`No indexed docs found for ADT: ${adtName}`);
+      return null;
+    }
+    const operations = [];
+    const notes = [];
+    let sourceDocPath;
+    for (const result of docsResult.results) {
+      const content = result.content || result.code || "";
+      const isLedgerADTDoc = result.source.filePath.includes("ledger-adt");
+      if (!sourceDocPath && isLedgerADTDoc) {
+        sourceDocPath = result.source.filePath;
+      }
+      if (isLedgerADTDoc) {
+        const methodPattern = /\|\s*`?(\w+)`?\s*\|\s*`?\(([^)]*)\)\s*(?::\s*([^|`]+))?`?\s*\|\s*([^|]+)\|/g;
+        let match;
+        while ((match = methodPattern.exec(content)) !== null) {
+          const [, methodName, params, returnType, description] = match;
+          if (methodName && !operations.some((op) => op.method === methodName)) {
+            const descText = description?.trim() || "";
+            const worksInCircuits = !/not available|not supported|not in circuits|typescript|sdk|off[-\s]?chain/i.test(
+              descText
+            );
+            operations.push({
+              method: methodName,
+              signature: `(${params})${returnType ? `: ${returnType.trim()}` : ""}`,
+              description: descText,
+              worksInCircuits,
+              source: "indexed-docs"
+            });
+          }
+        }
+        const inlinePattern = /(?:method|operation|function)\s+`?(\w+)`?\s*\(([^)]*)\)/gi;
+        while ((match = inlinePattern.exec(content)) !== null) {
+          const [, methodName, params] = match;
+          if (methodName && !operations.some((op) => op.method === methodName)) {
+            const worksInCircuits = !/not available|not supported|not in circuits|typescript|sdk|off[-\s]?chain/i.test(
+              content
+            );
+            operations.push({
+              method: methodName,
+              signature: `(${params})`,
+              description: "Extracted from documentation",
+              worksInCircuits,
+              source: "indexed-docs"
+            });
+          }
+        }
+      }
+      if (content.toLowerCase().includes(adtName.toLowerCase()) && content.length < MAX_NOTE_SOURCE_LENGTH) {
+        const cleanNote = content.replace(/\s+/g, " ").trim();
+        if (cleanNote.length > NOTE_MIN_LENGTH && cleanNote.length < NOTE_MAX_LENGTH) {
+          notes.push(cleanNote);
+        }
+      }
+    }
+    if (operations.length === 0) {
+      logger.debug(`Could not parse operations for ADT: ${adtName}`);
+      return null;
+    }
+    return {
+      name: adtName,
+      operations,
+      notes: notes.slice(0, MAX_NOTES_PER_ADT),
+      sourceDocPath,
+      lastVerified: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (error) {
+    logger.warn(`Failed to search indexed docs for ADT ${adtName}`, {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+async function searchCompactSyntax(topic) {
+  try {
+    const [docsResult, codeResult] = await Promise.all([
+      searchDocsHosted(
+        `Compact ${topic} syntax`,
+        SYNTAX_SUBQUERY_LIMIT,
+        "reference"
+      ),
+      searchCompactHosted(`${topic}`, SYNTAX_SUBQUERY_LIMIT)
+    ]);
+    const mergedResults = [
+      ...docsResult.results || [],
+      ...codeResult.results || []
+    ];
+    return {
+      results: mergedResults.slice(0, SYNTAX_RESULTS_LIMIT),
+      totalResults: mergedResults.length,
+      query: topic,
+      lastIndexed: docsResult.lastIndexed || codeResult.lastIndexed
+    };
+  } catch (error) {
+    logger.warn(`Failed to search Compact syntax for topic ${topic}`, {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+async function validateADTOperations(adtName, staticOperations) {
+  const discrepancies = [];
+  const enrichments = [];
+  const indexedInfo = await searchADTInfo(adtName);
+  if (!indexedInfo) {
+    return {
+      validated: false,
+      operations: staticOperations.map((op) => ({
+        method: op.method,
+        description: op.note,
+        worksInCircuits: op.works,
+        source: "static-fallback"
+      })),
+      discrepancies: [
+        "Could not validate against indexed docs - using static data"
+      ],
+      enrichments: []
+    };
+  }
+  const operations = [];
+  const indexedMethodNames = new Set(
+    indexedInfo.operations.map((op) => op.method.toLowerCase())
+  );
+  const staticMethodNames = new Set(
+    staticOperations.map(
+      (op) => op.method.replace(/^\./, "").replace(/\(.*$/, "").toLowerCase()
+    )
+  );
+  for (const indexedOp of indexedInfo.operations) {
+    operations.push(indexedOp);
+    const staticOp = staticOperations.find(
+      (s) => s.method.toLowerCase().includes(indexedOp.method.toLowerCase()) || indexedOp.method.toLowerCase().includes(
+        s.method.replace(/^\./, "").replace(/\(.*$/, "").toLowerCase()
+      )
+    );
+    if (staticOp && !staticOp.works && indexedOp.worksInCircuits) {
+      discrepancies.push(
+        `Static said ${staticOp.method} doesn't work, but indexed docs show it does`
+      );
+    }
+  }
+  for (const staticOp of staticOperations) {
+    const methodName = staticOp.method.replace(/^\./, "").replace(/\(.*$/, "").toLowerCase();
+    if (!indexedMethodNames.has(methodName)) {
+      discrepancies.push(
+        `Static references ${staticOp.method} but not found in indexed docs - may not exist`
+      );
+    }
+  }
+  for (const indexedOp of indexedInfo.operations) {
+    const methodName = indexedOp.method.toLowerCase();
+    if (!staticMethodNames.has(methodName)) {
+      enrichments.push(
+        `Indexed docs show ${indexedOp.method} exists but was missing from static reference`
+      );
+    }
+  }
+  return {
+    validated: true,
+    operations,
+    discrepancies,
+    enrichments
+  };
+}
+async function validateBuiltinFunctions(staticBuiltins) {
+  const discrepancies = [];
+  const enrichments = [];
+  const results = await Promise.all(
+    staticBuiltins.map(async (builtin) => {
+      const searchResult = await searchCompactSyntax(
+        `${builtin.name} function builtin`
+      );
+      return { builtin, found: (searchResult?.results?.length || 0) > 0 };
+    })
+  );
+  for (const { builtin, found } of results) {
+    if (!found) {
+      discrepancies.push(
+        `Builtin "${builtin.name}" not found in indexed docs - may not exist or have different name`
+      );
+    }
+  }
+  const allBuiltinsSearch = await searchCompactSyntax(
+    "builtin function stdlib standard library"
+  );
+  if (allBuiltinsSearch?.results) {
+    const knownNames = new Set(staticBuiltins.map((b) => b.name.toLowerCase()));
+    for (const result of allBuiltinsSearch.results) {
+      const content = result.content || result.code || "";
+      const funcPattern = /\b(export\s+)?function\s+(\w+)/gi;
+      let match;
+      while ((match = funcPattern.exec(content)) !== null) {
+        const funcName = match[2].toLowerCase();
+        if (!knownNames.has(funcName) && funcName.length > 2) {
+          enrichments.push(`Indexed docs mention "${match[2]}" function`);
+        }
+      }
+    }
+  }
+  return {
+    dataType: "BUILTIN_FUNCTIONS",
+    validated: discrepancies.length === 0,
+    discrepancies,
+    enrichments: [...new Set(enrichments)].slice(0, 10),
+    deprecatedPatterns: [],
+    lastValidated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function validateTypeCompatibility(staticRules) {
+  const discrepancies = [];
+  const enrichments = [];
+  const typeSearch = await searchCompactSyntax(
+    "type cast Field Uint Bytes conversion compatible"
+  );
+  if (typeSearch?.results) {
+    for (const result of typeSearch.results) {
+      const content = (result.content || result.code || "").toLowerCase();
+      for (const rule of staticRules) {
+        const typeMatch = rule.types.match(
+          /^\s*(.+?)\s*(?:==|=|<=|>=|<|>|[+*])\s*(.+?)\s*$/
+        );
+        const typeA = typeMatch?.[1]?.trim().toLowerCase();
+        const typeB = typeMatch?.[2]?.trim().toLowerCase();
+        if (typeA && typeB) {
+          if (content.includes(typeA) && content.includes(typeB) && content.includes("compatible")) {
+            if (!rule.works) {
+              discrepancies.push(
+                `Static says "${rule.types}" doesn't work, but docs suggest compatibility`
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+  return {
+    dataType: "TYPE_COMPATIBILITY",
+    validated: discrepancies.length === 0,
+    discrepancies,
+    enrichments,
+    deprecatedPatterns: [],
+    lastValidated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function validateCommonErrors(staticErrors) {
+  const discrepancies = [];
+  const enrichments = [];
+  const errorSearch = await searchDocsHosted(
+    "error compile compilation failure parse",
+    ADT_SEARCH_LIMIT,
+    "all"
+  );
+  if (errorSearch?.results) {
+    const knownErrors = new Set(
+      staticErrors.map((e) => e.error.toLowerCase().slice(0, 30))
+    );
+    for (const result of errorSearch.results) {
+      const content = result.content || result.code || "";
+      const errorPattern = /(?:error|Error):\s*["']?([^"'\n]+)["']?/g;
+      let match;
+      while ((match = errorPattern.exec(content)) !== null) {
+        const errorMsg = match[1].toLowerCase().slice(0, 30);
+        if (!knownErrors.has(errorMsg) && errorMsg.length > 10) {
+          enrichments.push(`Docs mention error: "${match[1].slice(0, 50)}..."`);
+        }
+      }
+    }
+  }
+  return {
+    dataType: "COMMON_ERRORS",
+    validated: true,
+    // Errors are informational, hard to validate
+    discrepancies,
+    enrichments: [...new Set(enrichments)].slice(0, 10),
+    deprecatedPatterns: [],
+    lastValidated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+var DEPRECATED_SYNTAX_PATTERNS = [
+  {
+    pattern: /ledger\s*\{/,
+    name: "ledger-block",
+    message: "Deprecated: Use 'export ledger field: Type;' instead of ledger { } block",
+    since: "0.16"
+  },
+  {
+    pattern: /Cell\s*<\s*\w+\s*>/,
+    name: "cell-wrapper",
+    message: "Deprecated: Cell<T> wrapper removed, use Type directly",
+    since: "0.15"
+  },
+  {
+    pattern: /:\s*Void\b/,
+    name: "void-type",
+    message: "Void type doesn't exist, use [] (empty tuple) for no return",
+    since: "always"
+  },
+  {
+    pattern: /\.\s*value\s*\(\s*\)/,
+    name: "counter-value",
+    message: "Counter.value() doesn't exist, use Counter.read() instead",
+    since: "always"
+  },
+  {
+    pattern: /::\w+/,
+    name: "rust-enum-syntax",
+    message: "Rust-style :: enum access doesn't work, use dot notation (Choice.rock)",
+    since: "always"
+  },
+  {
+    pattern: /pure\s+function\b/,
+    name: "pure-function",
+    message: "Use 'pure circuit' not 'pure function' for helper functions",
+    since: "0.16"
+  },
+  {
+    pattern: /witness\s+\w+\s*\([^)]*\)\s*:\s*\w+\s*\{/,
+    name: "witness-with-body",
+    message: "Witnesses are declarations only - no body allowed. Implementation goes in TypeScript prover.",
+    since: "always"
+  }
+];
+function scanForDeprecatedPatterns(code) {
+  const issues = [];
+  const lines = code.split("\n");
+  for (const { pattern, name, message } of DEPRECATED_SYNTAX_PATTERNS) {
+    for (let i = 0; i < lines.length; i++) {
+      if (pattern.test(lines[i])) {
+        issues.push({
+          pattern: name,
+          message,
+          lineNumber: i + 1
+        });
+      }
+    }
+  }
+  return issues;
+}
+async function validateAllStaticData(staticData) {
+  const results = {};
+  const [builtinResult, typeResult, errorResult, adtResults] = await Promise.all([
+    staticData.builtinFunctions ? validateBuiltinFunctions(staticData.builtinFunctions) : Promise.resolve(null),
+    staticData.typeCompatibility ? validateTypeCompatibility(staticData.typeCompatibility) : Promise.resolve(null),
+    staticData.commonErrors ? validateCommonErrors(staticData.commonErrors) : Promise.resolve(null),
+    staticData.ledgerTypeLimits ? Promise.all(
+      Object.entries(staticData.ledgerTypeLimits).map(
+        async ([name, data]) => ({
+          name,
+          result: await validateADTOperations(
+            name,
+            data.circuitOperations
+          )
+        })
+      )
+    ) : Promise.resolve([])
+  ]);
+  if (builtinResult) results.builtinFunctions = builtinResult;
+  if (typeResult) results.typeCompatibility = typeResult;
+  if (errorResult) results.commonErrors = errorResult;
+  for (const { name, result } of adtResults) {
+    results[`adt_${name}`] = {
+      dataType: `LEDGER_TYPE_LIMITS.${name}`,
+      validated: result.validated,
+      discrepancies: result.discrepancies,
+      enrichments: result.enrichments,
+      deprecatedPatterns: [],
+      lastValidated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const allDiscrepancies = Object.values(results).flatMap(
+    (r) => r.discrepancies
+  );
+  const allEnrichments = Object.values(results).flatMap((r) => r.enrichments);
+  return {
+    overall: {
+      validated: allDiscrepancies.length === 0,
+      totalDiscrepancies: allDiscrepancies.length,
+      totalEnrichments: allEnrichments.length
+    },
+    results,
+    lastValidated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
 // src/server.ts
 var SERVER_INFO = {
   name: "midnight-mcp",
@@ -5725,17 +6043,30 @@ var TYPE_COMPATIBILITY = {
 var LEDGER_TYPE_LIMITS = {
   Counter: {
     circuitOperations: [
-      { method: ".increment(n)", works: true, note: "Adds n to counter" },
+      {
+        method: ".increment(n)",
+        works: true,
+        note: "Increase counter by n (Uint<16>)"
+      },
       {
         method: ".decrement(n)",
         works: true,
-        note: "Subtracts n from counter"
+        note: "Decrease counter by n (Uint<16>)"
+      },
+      {
+        method: ".read()",
+        works: true,
+        note: "Get current value (returns Uint<64>)"
       },
-      { method: ".resetToDefault()", works: true, note: "Resets to 0" },
-      { method: ".value()", works: false, note: "NOT available in circuits" }
+      {
+        method: ".lessThan(n)",
+        works: true,
+        note: "Compare with threshold (returns Boolean)"
+      },
+      { method: ".resetToDefault()", works: true, note: "Reset to 0" }
     ],
     typescriptAccess: "Access counter value via `ledgerState.counter` in TypeScript SDK",
-    reason: "ZK circuits cannot read current ledger state - only modify it"
+    note: "All Counter operations work in circuits. Use .read() to get value, NOT .value()"
   },
   Map: {
     circuitOperations: [
@@ -5744,20 +6075,40 @@ var LEDGER_TYPE_LIMITS = {
         works: true,
         note: "Adds/updates entry"
       },
+      {
+        method: ".insertDefault(key)",
+        works: true,
+        note: "Inserts default value for key"
+      },
       { method: ".remove(key)", works: true, note: "Removes entry" },
       {
         method: ".lookup(key)",
         works: true,
-        note: "Returns Option<ValueType> - use in circuits"
+        note: "Returns value_type - gets value for key"
       },
       {
         method: ".member(key)",
         works: true,
         note: "Returns Boolean - checks if key exists"
+      },
+      {
+        method: ".isEmpty()",
+        works: true,
+        note: "Returns Boolean - checks if map is empty"
+      },
+      {
+        method: ".size()",
+        works: true,
+        note: "Returns Uint<64> - number of entries"
+      },
+      {
+        method: ".resetToDefault()",
+        works: true,
+        note: "Clears entire map"
       }
     ],
-    typescriptAccess: "Query map via `contractState.data.get(key)` in TypeScript SDK",
-    note: "Map.lookup() and Map.member() ARE available in circuits (verified with OpenZeppelin contracts)"
+    typescriptAccess: "Query map via `contractState.data.get(key)` or iterate with `[Symbol.iterator]()` in TypeScript SDK",
+    note: "All Map operations work in circuits. insertCoin() available when value_type is QualifiedCoinInfo."
   },
   Set: {
     circuitOperations: [
@@ -5767,10 +6118,25 @@ var LEDGER_TYPE_LIMITS = {
         method: ".member(value)",
         works: true,
         note: "Returns Boolean - checks if value exists in set"
+      },
+      {
+        method: ".isEmpty()",
+        works: true,
+        note: "Returns Boolean - checks if set is empty"
+      },
+      {
+        method: ".size()",
+        works: true,
+        note: "Returns Uint<64> - number of elements"
+      },
+      {
+        method: ".resetToDefault()",
+        works: true,
+        note: "Clears entire set"
       }
     ],
-    typescriptAccess: "Check membership via `contractState.set.has(value)` in TypeScript SDK",
-    note: "Set.member() IS available in circuits"
+    typescriptAccess: "Check membership via `contractState.set.has(value)` or iterate with `[Symbol.iterator]()` in TypeScript SDK",
+    note: "All Set operations work in circuits. insertCoin() available when value_type is QualifiedCoinInfo."
   },
   MerkleTree: {
     circuitOperations: [
@@ -5800,11 +6166,16 @@ Or use bounded Uint<0..N> for parameters that need constraints`
   },
   {
     error: 'operation "value" undefined for ledger field type Counter',
-    cause: "Trying to read Counter.value() inside a circuit",
-    fix: `Counter values cannot be read in circuits. Options:
-1. Use a witness: witness get_counter_value(): Uint<64>;
-2. Read from TypeScript SDK: ledgerState.counter
-3. Track the value in a separate Field ledger variable`
+    cause: "Using wrong method name - Counter uses .read() not .value()",
+    fix: `Use counter.read() to get the current value:
+const current = ledger.counter.read();
+
+Counter ADT methods available in circuits:
+- increment(amount: Uint<16>): []  - increase counter
+- decrement(amount: Uint<16>): []  - decrease counter
+- read(): Uint<64>                 - get current value
+- lessThan(threshold: Uint<64>): Boolean - compare
+- resetToDefault(): []             - reset to zero`
   },
   {
     error: "implicit disclosure of witness value",
@@ -6336,7 +6707,7 @@ async function extractContractStructure(input) {
       });
     }
   }
-  const hasStdlibImport = imports.includes("CompactStandardLibrary") || code.includes('include "std"');
+  const hasStdlibImport = imports.includes("CompactStandardLibrary") || code.includes("import CompactStandardLibrary");
   if (hasStdlibImport) {
     for (const circuit of circuits) {
       if (stdlibExports.includes(circuit.name)) {
@@ -6447,7 +6818,7 @@ async function extractContractStructure(input) {
     });
     break;
   }
-  const counterValuePattern = /(\w+)\.value\b/g;
+  const counterValuePattern = /(\w+)\.value\s*\(/g;
   let counterMatch;
   while ((counterMatch = counterValuePattern.exec(code)) !== null) {
     const varName = counterMatch[1];
@@ -6459,8 +6830,8 @@ async function extractContractStructure(input) {
       potentialIssues.push({
         type: "invalid_counter_access",
         line: lineNum,
-        message: `Counter type '${varName}' does not have a '.value' property`,
-        suggestion: `Counter only has '.increment(n)'. Use 'Uint<32>' or 'Uint<64>' instead if you need to read the value`,
+        message: `Counter type '${varName}' does not have '.value()' - use '.read()' instead`,
+        suggestion: `Counter ADT methods: increment(n), decrement(n), read(), lessThan(n), resetToDefault()`,
         severity: "error"
       });
     }
@@ -7106,6 +7477,96 @@ async function getLatestSyntax(input) {
     } catch {
     }
     if (compactReference) {
+      logger.debug(
+        "Starting comprehensive hybrid validation against indexed docs"
+      );
+      let comprehensiveValidation;
+      try {
+        comprehensiveValidation = await validateAllStaticData({
+          builtinFunctions: BUILTIN_FUNCTIONS.stdlib,
+          typeCompatibility: [
+            ...TYPE_COMPATIBILITY.comparisons,
+            ...TYPE_COMPATIBILITY.arithmetic
+          ],
+          commonErrors: COMMON_ERRORS,
+          ledgerTypeLimits: LEDGER_TYPE_LIMITS
+        });
+        logger.debug("Comprehensive validation complete", {
+          validated: comprehensiveValidation.overall.validated,
+          discrepancies: comprehensiveValidation.overall.totalDiscrepancies,
+          enrichments: comprehensiveValidation.overall.totalEnrichments
+        });
+      } catch (err) {
+        logger.warn(
+          "Comprehensive validation failed, falling back to ADT-only validation",
+          {
+            error: err instanceof Error ? err.message : String(err)
+          }
+        );
+      }
+      const validationWarnings = [];
+      const validationEnrichments = [];
+      if (comprehensiveValidation) {
+        for (const [key, result] of Object.entries(
+          comprehensiveValidation.results
+        )) {
+          if (result.discrepancies.length > 0) {
+            validationWarnings.push(
+              `${key}: ${result.discrepancies.join("; ")}`
+            );
+          }
+          if (result.enrichments.length > 0) {
+            validationEnrichments.push(
+              `${key}: ${result.enrichments.join("; ")}`
+            );
+          }
+        }
+      }
+      let indexedSyntaxPatterns;
+      try {
+        const syntaxSearch = await searchCompactSyntax(
+          "circuit witness ledger pragma"
+        );
+        if (syntaxSearch && syntaxSearch.results.length > 0) {
+          indexedSyntaxPatterns = {
+            resultCount: syntaxSearch.results.length,
+            topSources: syntaxSearch.results.slice(0, 3).map((r) => ({
+              path: r.source.filePath,
+              repo: r.source.repository
+            }))
+          };
+        }
+      } catch {
+      }
+      const validatedLedgerTypeLimits = {};
+      for (const [adtName, staticInfo] of Object.entries(LEDGER_TYPE_LIMITS)) {
+        const typedStaticInfo = staticInfo;
+        const adtValidation = comprehensiveValidation?.results[`adt_${adtName}`];
+        if (adtValidation?.validated) {
+          validatedLedgerTypeLimits[adtName] = {
+            ...typedStaticInfo,
+            validatedAgainstDocs: true,
+            validationDiscrepancies: adtValidation.discrepancies,
+            validationEnrichments: adtValidation.enrichments
+          };
+        } else {
+          validatedLedgerTypeLimits[adtName] = {
+            ...typedStaticInfo,
+            validatedAgainstDocs: false,
+            warning: "Could not validate against indexed docs - using static reference"
+          };
+        }
+      }
+      const quickStartTemplate = `${RECOMMENDED_PRAGMA}
+
+import CompactStandardLibrary;
+
+export ledger counter: Counter;
+
+export circuit increment(): [] {
+  counter.increment(1);
+}`;
+      const deprecatedInTemplate = scanForDeprecatedPatterns(quickStartTemplate);
       return {
         repository: "midnightntwrk/compact",
         version: `${COMPACT_VERSION.min}-${COMPACT_VERSION.max} (current)`,
@@ -7116,6 +7577,29 @@ async function getLatestSyntax(input) {
           maintenanceGuide: "See docs/SYNTAX_MAINTENANCE.md for update instructions"
         },
         ...versionWarning && { versionWarning },
+        // Comprehensive hybrid validation status
+        hybridValidation: {
+          enabled: true,
+          comprehensive: true,
+          // Overall validation stats
+          overall: comprehensiveValidation?.overall || {
+            validated: false,
+            totalDiscrepancies: 0,
+            totalEnrichments: 0
+          },
+          // Which data types were validated
+          validatedDataTypes: comprehensiveValidation ? Object.keys(comprehensiveValidation.results) : [],
+          // All warnings from ALL static data validation
+          warnings: validationWarnings.length > 0 ? validationWarnings : void 0,
+          // All enrichments discovered from indexed docs
+          enrichments: validationEnrichments.length > 0 ? validationEnrichments : void 0,
+          // Indexed syntax pattern sources
+          indexedSyntaxPatterns,
+          // Deprecated patterns found in quick start template (should be none!)
+          deprecatedPatternsInTemplate: deprecatedInTemplate.length > 0 ? deprecatedInTemplate : void 0,
+          // Last validation timestamp
+          lastValidated: comprehensiveValidation?.lastValidated || (/* @__PURE__ */ new Date()).toISOString()
+        },
         // Quick start template - ALWAYS compiles
         quickStartTemplate: `${RECOMMENDED_PRAGMA}
 
@@ -7133,8 +7617,8 @@ export circuit increment(): [] {
         builtinFunctions: BUILTIN_FUNCTIONS,
         // Type compatibility rules
         typeCompatibility: TYPE_COMPATIBILITY,
-        // Ledger type limitations in circuits
-        ledgerTypeLimits: LEDGER_TYPE_LIMITS,
+        // Ledger type limitations - VALIDATED against indexed docs
+        ledgerTypeLimits: validatedLedgerTypeLimits,
         // Common compilation errors with fixes
         commonErrors: COMMON_ERRORS,
         // Common mistakes that cause compilation failures
@@ -7176,7 +7660,7 @@ export circuit increment(): [] {
           },
           {
             wrong: "counter.value()",
-            correct: "// Read via witness or TypeScript SDK",
+            correct: "counter.read()  // Returns Uint<64>",
             error: 'operation "value" undefined for Counter'
           },
           {
@@ -7241,7 +7725,7 @@ Use quickStartTemplate as your base. Check commonMistakes BEFORE submitting code
 
 KEY RULES:
 1. public_key() is NOT a builtin - use persistentHash pattern
-2. Counter.value() NOT available in circuits - use witnesses
+2. Counter uses .read() not .value() - all ADT methods work in circuits
 3. Map.lookup()/Set.member() ARE available in circuits (verified)
 4. Arithmetic results need casting: (a + b) as Uint<64>
 5. Uint\u2192Bytes needs two casts: (amount as Field) as Bytes<32>
@@ -9630,4 +10114,4 @@ export {
   startServer,
   startHttpServer
 };
-//# sourceMappingURL=chunk-5PGBYGCG.js.map
+//# sourceMappingURL=chunk-7KJSVMFI.js.map