@lagoon-protocol/lagoon-mcp 0.1.0

package/dist/resources/glossary.js

@@ -0,0 +1,407 @@
+/**
+ * DeFi Glossary Resource
+ *
+ * Comprehensive terminology guide for Lagoon DeFi Protocol.
+ * Explains vault concepts, financial metrics, and transaction types.
+ */
+export function getDefiGlossary() {
+    return `# Lagoon DeFi Protocol - Glossary
+
+## Core Vault Concepts
+
+### Vault
+A DeFi vault is an automated investment strategy that manages user deposits to generate yield. In Lagoon, vaults are ERC-4626 compliant smart contracts that accept deposits of a specific asset and issue shares representing ownership.
+
+**Key Properties:**
+- **Address**: Unique Ethereum address identifying the vault contract
+- **Symbol**: Short identifier (e.g., "LAG-USDC-ETH")
+- **Asset**: The underlying ERC-20 token accepted for deposits
+- **Total Assets**: Combined value of all deposited assets (in asset units)
+- **Total Supply**: Total shares issued to depositors
+- **Price Per Share (PPS)**: Vault share value = totalAssets / totalSupply
+
+### Shares
+Vault shares represent proportional ownership of the vault's assets. When users deposit, they receive shares. When they withdraw, they burn shares to receive assets.
+
+**Share Mechanics:**
+- Shares are minted on deposit at current PPS
+- Shares are burned on withdrawal at current PPS
+- Share value increases as vault generates yield
+- Shares are transferable ERC-20 tokens
+
+### Asset
+The underlying ERC-20 token that the vault accepts for deposits (e.g., USDC, WETH, DAI).
+
+**Asset Properties:**
+- Decimals: Precision (e.g., USDC = 6, WETH = 18)
+- Price USD: Current USD value per token unit
+- Symbol: Token ticker (e.g., "USDC", "WETH")
+
+---
+
+## Financial Metrics
+
+### Total Value Locked (TVL)
+The total USD value of all assets deposited in the vault. Critical metric for vault size and adoption.
+
+**Calculation:** \`TVL = totalAssets * assetPriceUsd\`
+
+**Interpretation:**
+- TVL > $10M: Large, established vault
+- TVL $1M-$10M: Medium-sized vault
+- TVL < $1M: Small or new vault
+
+### Annual Percentage Rate (APR)
+The annualized rate of return for vault deposits. Lagoon provides multiple APR metrics:
+
+**Types:**
+- **Gross APR**: Total yield before fees
+- **Net APR**: Yield after management and performance fees
+- **Linear Net APR**: Simple annualized return
+- **Live APR**: Current real-time APR estimate
+
+**Time Periods:**
+- **Inception APR**: Since vault launch
+- **Yearly APR**: Last 365 days
+- **Monthly APR**: Last 30 days
+- **Weekly APR**: Last 7 days
+
+### Price Per Share (PPS)
+The value of one vault share in terms of underlying assets.
+
+**Calculation:** \`PPS = totalAssets / totalSupply\`
+
+**Growth:** PPS increases as vault generates yield. A rising PPS indicates profitable strategy.
+
+**Example:**
+- Initial PPS: 1.0 (1 share = 1 asset)
+- After 1 year at 10% APR: 1.1 (1 share = 1.1 assets)
+- Depositor's gain: 10% return
+
+### Capacity
+Maximum assets the vault can accept. Some vaults have capacity limits due to strategy constraints.
+
+**Properties:**
+- **Max Capacity**: Hard limit on total deposits
+- **Utilization**: Current deposits / max capacity
+- **Remaining Capacity**: Available deposit space
+
+**Risk Indicator:**
+- Utilization > 90%: High risk of deposit reversion
+- Utilization 70-90%: Approaching capacity
+- Utilization < 70%: Ample room for deposits
+
+---
+
+## Vault States and Operations
+
+### Vault States
+Vaults transition through different operational states:
+
+**State Values:**
+- **OPEN**: Normal operation, accepting deposits/withdrawals
+- **CLOSING**: Last call for deposits, preparing to close
+- **CLOSED**: No new deposits, only withdrawals allowed
+
+### Settlement Process
+Lagoon uses an asynchronous and synchronous settlement system for deposits and withdrawals:
+
+**Synchronous Deposit Flow:**
+1. User requests deposit
+2. Vault processes deposit immediately
+3. Shares minted and distributed to users
+
+**Asynchronous Deposit Flow:**
+1. User requests deposit → assets locked in pending state
+2. Vault processes batch during settlement window
+3. Shares minted and distributed to users
+
+**Asynchronous Withdrawal Flow:**
+1. User requests redemption → shares locked in pending state
+2. Vault liquidates positions during settlement
+3. Assets returned to users
+
+**Key Fields:**
+- **Pending Settlement**: Assets/shares awaiting batch processing
+- **Average Settlement**: Typical time for settlement (hours)
+- **Safe Asset Balance**: Immediately available liquidity
+
+---
+
+## Transaction Types
+
+### TotalAssetsUpdated
+Records changes to vault's total asset value. Most frequent transaction type.
+
+**Use Cases:**
+- Performance tracking over time
+- TVL history and trend analysis
+- Price per share calculations
+
+**Data Fields:**
+- totalAssets: New total assets (BigInt)
+- totalAssetsUsd: New TVL in USD
+- timestamp: When update occurred
+
+### PeriodSummary
+Aggregated vault metrics for a specific time period (typically daily).
+
+**Use Cases:**
+- Volume analysis (deposits + withdrawals)
+- Daily TVL snapshots
+- Activity level tracking
+
+**Data Fields:**
+- tvl: Total value locked at period end
+- deposits: Total deposited during period (BigInt)
+- withdrawals: Total withdrawn during period (BigInt)
+
+### DepositRequest
+User initiates a deposit into the vault.
+
+**Data Fields:**
+- sender: User address
+- amount: Assets to deposit (BigInt)
+- shares: Expected shares to receive
+
+### SettleDeposit
+Vault processes pending deposits and mints shares.
+
+**Data Fields:**
+- assetsDeposited: Assets added to vault (BigInt)
+- sharesMinted: Shares issued to depositors
+
+### RedeemRequest
+User initiates a withdrawal from the vault.
+
+**Data Fields:**
+- redeemer: User address
+- shares: Shares to burn (BigInt)
+- assets: Expected assets to receive
+
+### SettleRedeem
+Vault processes pending withdrawals and returns assets.
+
+**Data Fields:**
+- sharesRedeemed: Shares burned (BigInt)
+- assetsWithdrawn: Assets returned to users
+
+### StateUpdated
+Vault state transition (OPEN ↔ CLOSING ↔ CLOSED).
+
+**Data Fields:**
+- oldState: Previous state
+- newState: New state
+- reason: Why state changed
+
+### RatesUpdated
+Changes to vault fee rates.
+
+**Data Fields:**
+- managementFee: New management fee (%)
+- performanceFee: New performance fee (%)
+
+---
+
+## Fees and Revenue
+
+### Management Fee
+Annual fee charged on total assets under management, regardless of performance.
+
+**Typical Range:** 0% - 2% annually
+
+**Example:** 2% management fee = 2% of TVL charged per year
+
+### Performance Fee
+Fee charged on profits generated by the vault strategy.
+
+**Typical Range:** 0% - 20% of profits
+
+**Example:** 10% performance fee = 10% of gains goes to vault manager
+
+**Calculation:**
+- Vault generates 15% return
+- 10% performance fee applied
+- User receives: 15% * 0.9 = 13.5% net return
+- Manager receives: 15% * 0.1 = 1.5% of profit
+
+### High Water Mark
+Ensures performance fees are only charged on new profits, not recovery of previous losses.
+
+**Mechanism:**
+- Tracks highest PPS achieved
+- Performance fees only apply to gains above high water mark
+- Prevents double-charging on volatile performance
+
+---
+
+## Roles and Governance
+
+### Curator
+Entity that designs and manages the vault strategy. Curators are responsible for:
+- Strategy selection and optimization
+- Risk management and monitoring
+- Performance reporting
+- Fee collection
+
+**Multiple Curators:** Some vaults have multiple curators collaborating on strategy.
+
+### Integrator
+Platform or protocol that integrates the Lagoon vault into their UI/UX.
+
+**Benefits:**
+- Custom branding and user experience
+- Integration fees or revenue sharing
+- Whitelabel vault access
+
+### Roles (Smart Contract)
+**Owner:** Administrative control over vault settings
+**Valuation Manager:** Updates vault valuations and pricing
+**Whitelist Manager:** Controls deposit access permissions
+**Safe:** Multisig wallet holding vault assets
+**Fee Receiver:** Receives management and performance fees
+
+---
+
+## DeFi Integrations
+
+Vaults may integrate with external DeFi protocols for yield generation:
+
+**Common Integrations:**
+- **DEX (Decentralized Exchange)**: Uniswap, Curve, Balancer for liquidity provision
+- **Lending Protocols**: Aave, Compound for supply-side yield
+- **Staking**: Native token staking for rewards
+- **Derivatives**: Options, perpetuals for hedged strategies
+
+**Integration Properties:**
+- Name: Protocol name (e.g., "Uniswap V3")
+- Type: Category (DEX, Lending, Staking, etc.)
+- Description: Strategy details
+- Link: Protocol URL
+
+---
+
+## Yield Components
+
+### Native Yields
+Base yield from underlying protocol (e.g., Uniswap trading fees, Aave lending interest).
+
+**Properties:**
+- APR: Current annualized rate
+- Description: Source of yield
+- Start/End Timestamp: Yield period
+- Logo: Protocol branding
+
+### Incentives
+Additional yield from protocol token emissions or rewards programs.
+
+**Properties:**
+- APR: Incentive rate
+- Incentive Rate: Tokens distributed per unit time
+- Reference Token: Reward token (e.g., UNI, COMP)
+- End Timestamp: When incentives expire
+
+### Airdrops
+One-time token distributions to vault participants.
+
+**Properties:**
+- APR: Annualized value of airdrop
+- Distribution Timestamp: When distributed
+- Multiplier: Boost factor for early participants
+- PPS Increase: Impact on share value
+
+---
+
+## Risk Metrics
+
+### Concentration Risk
+Percentage of portfolio in single vault or asset.
+
+**Risk Levels:**
+- <20%: Low concentration, well-diversified
+- 20-30%: Moderate concentration
+- >30%: High concentration risk
+
+### Chain Risk
+Exposure to specific blockchain networks.
+
+**Considerations:**
+- Multi-chain diversification reduces risk
+- Consider chain security, decentralization
+- Bridge risks for cross-chain strategies
+
+### Curator Track Record
+Historical performance and reliability of vault curator.
+
+**Evaluation Criteria:**
+- Past vault performance
+- Strategy consistency
+- Risk management history
+- Transparency and communication
+
+---
+
+## Common Calculations
+
+### Deposit Calculation
+**Shares Received** = depositAmount / pricePerShare
+
+**Example:**
+- Deposit: 1000 USDC
+- Current PPS: 1.05
+- Shares Received: 1000 / 1.05 = 952.38 shares
+
+### Withdrawal Calculation
+**Assets Received** = sharesRedeemed * pricePerShare
+
+**Example:**
+- Redeem: 1000 shares
+- Current PPS: 1.10
+- Assets Received: 1000 * 1.10 = 1100 USDC
+
+### Return Calculation
+**Percent Return** = ((currentPPS / depositPPS) - 1) * 100
+
+**Example:**
+- Deposit PPS: 1.00
+- Current PPS: 1.15
+- Return: ((1.15 / 1.00) - 1) * 100 = 15%
+
+### TVL Change
+**Percent Change** = ((endTVL / startTVL) - 1) * 100
+
+**Example:**
+- Start TVL: $1M
+- End TVL: $1.2M
+- Change: ((1.2 / 1.0) - 1) * 100 = +20%
+
+---
+
+## Best Practices
+
+### For Analysis
+1. **Compare Time Periods**: Use multiple APR time windows for trend analysis
+2. **Check Capacity**: Ensure vault has room before recommending deposits
+3. **Review Fees**: Factor in management and performance fees for net returns
+4. **Assess Risk**: Consider curator track record, capacity utilization, chain risk
+5. **Verify Liquidity**: Check safe asset balance for immediate withdrawal needs
+
+### For Portfolio Management
+1. **Diversify**: Spread across multiple vaults, assets, and chains
+2. **Monitor Performance**: Track PPS growth and APR consistency
+3. **Rebalance**: Adjust allocations based on performance and risk
+4. **Stay Informed**: Watch for state changes, fee updates, and integrations
+
+### For Risk Management
+1. **Capacity Awareness**: Avoid vaults >80% utilized
+2. **Curator Due Diligence**: Research curator history and strategy
+3. **Emergency Planning**: Understand settlement times for withdrawals
+4. **Fee Impact**: Calculate net returns after all fees
+
+---
+
+*Last Updated: ${new Date().toISOString().split('T')[0]}*
+*Version: Phase 3 - Lagoon MCP Server*
+`;
+}
+//# sourceMappingURL=glossary.js.map

package/dist/resources/glossary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glossary.js","sourceRoot":"","sources":["../../src/resources/glossary.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,UAAU,eAAe;IAC7B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2YQ,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;;CAEtD,CAAC;AACF,CAAC"}

package/dist/resources/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Resource Registry
+ *
+ * Central registry for all MCP resources.
+ * Resources provide static content like documentation and schemas.
+ */
+export interface Resource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+}
+/**
+ * Resource Registry
+ * Resources available to MCP clients
+ */
+export declare const resources: Resource[];
+//# sourceMappingURL=index.d.ts.map

package/dist/resources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resources/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,eAAO,MAAM,SAAS,EAAE,QAAQ,EAmB/B,CAAC"}

package/dist/resources/index.js

@@ -0,0 +1,29 @@
+/**
+ * Resource Registry
+ *
+ * Central registry for all MCP resources.
+ * Resources provide static content like documentation and schemas.
+ */
+/**
+ * Resource Registry
+ * Resources available to MCP clients
+ */
+export const resources = [
+    {
+        uri: 'lagoon://graphql-schema',
+        name: 'GraphQL Schema',
+        description: 'Complete GraphQL schema in SDL format. ' +
+            'Includes all types, queries, and mutations for the Lagoon API. ' +
+            'Cached for 24 hours.',
+        mimeType: 'text/plain',
+    },
+    {
+        uri: 'lagoon://defi-glossary',
+        name: 'DeFi Glossary',
+        description: 'Comprehensive terminology guide for Lagoon DeFi Protocol. ' +
+            'Explains vault concepts, financial metrics, transaction types, and calculations. ' +
+            'Essential reference for understanding vault data and analysis.',
+        mimeType: 'text/markdown',
+    },
+];
+//# sourceMappingURL=index.js.map

package/dist/resources/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/resources/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH;;;GAGG;AACH,MAAM,CAAC,MAAM,SAAS,GAAe;IACnC;QACE,GAAG,EAAE,yBAAyB;QAC9B,IAAI,EAAE,gBAAgB;QACtB,WAAW,EACT,yCAAyC;YACzC,iEAAiE;YACjE,sBAAsB;QACxB,QAAQ,EAAE,YAAY;KACvB;IACD;QACE,GAAG,EAAE,wBAAwB;QAC7B,IAAI,EAAE,eAAe;QACrB,WAAW,EACT,4DAA4D;YAC5D,mFAAmF;YACnF,gEAAgE;QAClE,QAAQ,EAAE,eAAe;KAC1B;CACF,CAAC"}

package/dist/resources/schema.d.ts

@@ -0,0 +1,22 @@
+/**
+ * GraphQL Schema Resource
+ *
+ * Provides the complete GraphQL schema in SDL (Schema Definition Language) format.
+ * Cached for 24 hours as the schema rarely changes.
+ *
+ * This resource enables Claude to:
+ * - Understand available types, queries, mutations
+ * - Validate query syntax before execution
+ * - Discover new fields and relationships
+ * - Generate accurate query suggestions
+ */
+/**
+ * Fetch and cache the GraphQL schema
+ *
+ * Uses introspection query to fetch schema metadata,
+ * then converts to SDL format for easy reading.
+ *
+ * @returns GraphQL schema in SDL format
+ */
+export declare function getGraphQLSchema(): Promise<string>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/resources/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/resources/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAWH;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,MAAM,CAAC,CAgDxD"}

package/dist/resources/schema.js

@@ -0,0 +1,67 @@
+/**
+ * GraphQL Schema Resource
+ *
+ * Provides the complete GraphQL schema in SDL (Schema Definition Language) format.
+ * Cached for 24 hours as the schema rarely changes.
+ *
+ * This resource enables Claude to:
+ * - Understand available types, queries, mutations
+ * - Validate query syntax before execution
+ * - Discover new fields and relationships
+ * - Generate accurate query suggestions
+ */
+import { getIntrospectionQuery, buildClientSchema, printSchema, } from 'graphql';
+import { graphqlClient } from '../graphql/client.js';
+import { cache, cacheKeys, cacheTTL } from '../cache/index.js';
+/**
+ * Fetch and cache the GraphQL schema
+ *
+ * Uses introspection query to fetch schema metadata,
+ * then converts to SDL format for easy reading.
+ *
+ * @returns GraphQL schema in SDL format
+ */
+export async function getGraphQLSchema() {
+    // Check cache first
+    const cacheKey = cacheKeys.schema();
+    const cached = cache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    try {
+        // Execute introspection query
+        const introspectionQuery = getIntrospectionQuery();
+        const result = await graphqlClient.request(introspectionQuery);
+        // Build client schema from introspection result
+        const schema = buildClientSchema(result);
+        // Convert to SDL format (human-readable)
+        const sdl = printSchema(schema);
+        // Add helpful header
+        const schemaWithHeader = `# Lagoon DeFi Protocol - GraphQL Schema
+# Generated: ${new Date().toISOString()}
+#
+# This schema defines all available types, queries, and mutations
+# for the Lagoon DeFi vault analytics API.
+#
+# Key Types:
+# - Vault: DeFi vault with asset info, financial metrics, and curator details
+# - Transaction: Historical transaction data for performance tracking
+# - User: User portfolio with positions across multiple chains
+# - Asset: ERC-20 token information with pricing
+#
+
+${sdl}`;
+        // Cache with 24-hour TTL
+        cache.set(cacheKey, schemaWithHeader, cacheTTL.schema);
+        return schemaWithHeader;
+    }
+    catch (error) {
+        // If introspection fails, return error message
+        const errorMessage = `# Error fetching GraphQL schema
+# ${error instanceof Error ? error.message : String(error)}
+#
+# The schema is temporarily unavailable. Please try again later.`;
+        return errorMessage;
+    }
+}
+//# sourceMappingURL=schema.js.map

package/dist/resources/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/resources/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,WAAW,GAEZ,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE/D;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,oBAAoB;IACpB,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC;IACpC,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAS,QAAQ,CAAC,CAAC;IAC3C,IAAI,MAAM,EAAE,CAAC;QACX,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,IAAI,CAAC;QACH,8BAA8B;QAC9B,MAAM,kBAAkB,GAAG,qBAAqB,EAAE,CAAC;QACnD,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,OAAO,CAAqB,kBAAkB,CAAC,CAAC;QAEnF,gDAAgD;QAChD,MAAM,MAAM,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;QAEzC,yCAAyC;QACzC,MAAM,GAAG,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;QAEhC,qBAAqB;QACrB,MAAM,gBAAgB,GAAG;eACd,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;;;;;;;;;;;;EAYrC,GAAG,EAAE,CAAC;QAEJ,yBAAyB;QACzB,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;QAEvD,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,+CAA+C;QAC/C,MAAM,YAAY,GAAG;IACrB,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;;iEAEO,CAAC;QAE9D,OAAO,YAAY,CAAC;IACtB,CAAC;AACH,CAAC"}

package/dist/schemas/config.schema.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+/**
+ * Environment variable validation schema
+ *
+ * Validates all environment variables at startup to ensure proper configuration.
+ * Uses Zod for runtime validation and type inference.
+ */
+export declare const envSchema: z.ZodObject<{
+    /**
+     * GraphQL API endpoint for Lagoon backend
+     * Must be a valid URL
+     * @default 'http://localhost:3001/query'
+     */
+    LAGOON_GRAPHQL_URL: z.ZodDefault<z.ZodString>;
+    /**
+     * Runtime environment
+     * @default 'development'
+     */
+    NODE_ENV: z.ZodDefault<z.ZodEnum<["development", "production", "test"]>>;
+    /**
+     * Cache TTL in seconds (optional override)
+     * @default 600 (10 minutes)
+     */
+    CACHE_TTL: z.ZodOptional<z.ZodEffects<z.ZodString, number, string>>;
+    /**
+     * Maximum number of cache entries (optional override)
+     * @default 1000
+     */
+    CACHE_MAX_KEYS: z.ZodOptional<z.ZodEffects<z.ZodString, number, string>>;
+}, "strip", z.ZodTypeAny, {
+    LAGOON_GRAPHQL_URL: string;
+    NODE_ENV: "development" | "production" | "test";
+    CACHE_TTL?: number | undefined;
+    CACHE_MAX_KEYS?: number | undefined;
+}, {
+    LAGOON_GRAPHQL_URL?: string | undefined;
+    NODE_ENV?: "development" | "production" | "test" | undefined;
+    CACHE_TTL?: string | undefined;
+    CACHE_MAX_KEYS?: string | undefined;
+}>;
+/**
+ * Validated environment variable type
+ * Inferred from the Zod schema
+ */
+export type Env = z.infer<typeof envSchema>;
+//# sourceMappingURL=config.schema.d.ts.map

package/dist/schemas/config.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;GAKG;AACH,eAAO,MAAM,SAAS;IACpB;;;;OAIG;;IAOH;;;OAGG;;IAMH;;;OAGG;;IAQH;;;OAGG;;;;;;;;;;;;EAOH,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC"}

package/dist/schemas/config.schema.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+/**
+ * Environment variable validation schema
+ *
+ * Validates all environment variables at startup to ensure proper configuration.
+ * Uses Zod for runtime validation and type inference.
+ */
+export const envSchema = z.object({
+    /**
+     * GraphQL API endpoint for Lagoon backend
+     * Must be a valid URL
+     * @default 'http://localhost:3001/query'
+     */
+    LAGOON_GRAPHQL_URL: z
+        .string()
+        .url('LAGOON_GRAPHQL_URL must be a valid URL')
+        .default('http://localhost:3001/query')
+        .describe('GraphQL API endpoint for Lagoon backend'),
+    /**
+     * Runtime environment
+     * @default 'development'
+     */
+    NODE_ENV: z
+        .enum(['development', 'production', 'test'])
+        .default('development')
+        .describe('Runtime environment'),
+    /**
+     * Cache TTL in seconds (optional override)
+     * @default 600 (10 minutes)
+     */
+    CACHE_TTL: z
+        .string()
+        .regex(/^\d+$/, 'CACHE_TTL must be a positive integer')
+        .transform(Number)
+        .optional()
+        .describe('Cache TTL in seconds (default: 600)'),
+    /**
+     * Maximum number of cache entries (optional override)
+     * @default 1000
+     */
+    CACHE_MAX_KEYS: z
+        .string()
+        .regex(/^\d+$/, 'CACHE_MAX_KEYS must be a positive integer')
+        .transform(Number)
+        .optional()
+        .describe('Maximum cache entries (default: 1000)'),
+});
+//# sourceMappingURL=config.schema.js.map

package/dist/schemas/config.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.schema.js","sourceRoot":"","sources":["../../src/schemas/config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC;IAChC;;;;OAIG;IACH,kBAAkB,EAAE,CAAC;SAClB,MAAM,EAAE;SACR,GAAG,CAAC,wCAAwC,CAAC;SAC7C,OAAO,CAAC,6BAA6B,CAAC;SACtC,QAAQ,CAAC,yCAAyC,CAAC;IAEtD;;;OAGG;IACH,QAAQ,EAAE,CAAC;SACR,IAAI,CAAC,CAAC,aAAa,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC;SAC3C,OAAO,CAAC,aAAa,CAAC;SACtB,QAAQ,CAAC,qBAAqB,CAAC;IAElC;;;OAGG;IACH,SAAS,EAAE,CAAC;SACT,MAAM,EAAE;SACR,KAAK,CAAC,OAAO,EAAE,sCAAsC,CAAC;SACtD,SAAS,CAAC,MAAM,CAAC;SACjB,QAAQ,EAAE;SACV,QAAQ,CAAC,qCAAqC,CAAC;IAElD;;;OAGG;IACH,cAAc,EAAE,CAAC;SACd,MAAM,EAAE;SACR,KAAK,CAAC,OAAO,EAAE,2CAA2C,CAAC;SAC3D,SAAS,CAAC,MAAM,CAAC;SACjB,QAAQ,EAAE;SACV,QAAQ,CAAC,uCAAuC,CAAC;CACrD,CAAC,CAAC"}

package/dist/sdk/__tests__/apr-service.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * APR Service Test Suite
+ *
+ * Comprehensive tests for SDK APR calculations and period summary transformations.
+ */
+export {};
+//# sourceMappingURL=apr-service.test.d.ts.map

package/dist/sdk/__tests__/apr-service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apr-service.test.d.ts","sourceRoot":"","sources":["../../../src/sdk/__tests__/apr-service.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}