orangeslice 1.0.0

package/README.md

@@ -0,0 +1,107 @@
+# orangeslice
+
+Rate-limited B2B API client for AI agents. Call `orangeslice.b2b.sql()` anywhere, anytime - concurrency and rate limiting handled automatically.
+
+## Documentation
+
+**Before writing queries, read the docs in [`./docs/`](./docs/):**
+
+| Doc | What it covers |
+|-----|----------------|
+| [B2B_DATABASE.md](./docs/B2B_DATABASE.md) | Database overview, API endpoint, request format |
+| [B2B_SCHEMA.md](./docs/B2B_SCHEMA.md) | All tables and columns |
+| [B2B_EMPLOYEE_SEARCH.md](./docs/B2B_EMPLOYEE_SEARCH.md) | How to search for people/employees |
+| [B2B_GENERALIZATION_RULES.md](./docs/B2B_GENERALIZATION_RULES.md) | Query patterns and best practices |
+| [B2B_NLP_QUERY_MAPPINGS.md](./docs/B2B_NLP_QUERY_MAPPINGS.md) | Natural language to SQL mappings |
+| [B2B_TABLE_INDICES.ts](./docs/B2B_TABLE_INDICES.ts) | TypeScript types for all tables |
+
+Start with `B2B_DATABASE.md` and `B2B_SCHEMA.md` to understand the data model.
+
+## Installation
+
+```bash
+npm install orangeslice
+```
+
+## Usage
+
+```typescript
+import { orangeslice } from 'orangeslice';
+
+// Query the B2B database - automatically rate-limited
+const companies = await orangeslice.b2b.sql(`
+  SELECT company_name, domain, employee_count 
+  FROM linkedin_company 
+  WHERE universal_name = 'stripe'
+`);
+
+// Multiple parallel calls are queued (max 2 concurrent by default)
+const results = await Promise.all([
+  orangeslice.b2b.sql("SELECT * FROM linkedin_company WHERE universal_name = 'stripe'"),
+  orangeslice.b2b.sql("SELECT * FROM linkedin_company WHERE universal_name = 'openai'"),
+  orangeslice.b2b.sql("SELECT * FROM linkedin_company WHERE universal_name = 'meta'"),
+  orangeslice.b2b.sql("SELECT * FROM linkedin_company WHERE universal_name = 'google'"),
+  orangeslice.b2b.sql("SELECT * FROM linkedin_company WHERE universal_name = 'amazon'"),
+]);
+// ^ Only 2 run at once, rest wait in queue automatically
+```
+
+## Configuration
+
+```typescript
+// Optional - configure before use
+orangeslice.b2b.configure({
+  proxyUrl: 'http://your-proxy-url:3000/query',  // default: B2B_SQL_PROXY_URL env var
+  concurrency: 3,                                  // default: 2
+  minDelayMs: 200,                                 // default: 100ms between requests
+});
+```
+
+## Environment Variables
+
+```bash
+B2B_SQL_PROXY_URL=http://165.22.151.131:3000/query
+```
+
+## How It Works
+
+```
+Agent calls:  [1] [2] [3] [4] [5] [6]
+                ↓
+Queue:       [ 1, 2 running ] [ 3, 4, 5, 6 waiting ]
+                ↓
+API:         [1] [2]  ← only 2 hit the API at once
+                ↓
+             [3] [4]  ← when 1,2 finish, 3,4 start
+```
+
+**Agent never has to:**
+- Think about concurrency
+- Add `await sleep()`
+- Worry about rate limits
+- Handle API throttling errors
+
+## API Reference
+
+### `orangeslice.b2b.sql<T>(query: string): Promise<T>`
+
+Execute SQL and return rows.
+
+```typescript
+const companies = await orangeslice.b2b.sql<Company[]>(
+  "SELECT * FROM linkedin_company WHERE employee_count > 1000 LIMIT 10"
+);
+```
+
+### `orangeslice.b2b.query<T>(query: string): Promise<QueryResult<T>>`
+
+Execute SQL and return full result with metadata.
+
+```typescript
+const result = await orangeslice.b2b.query("SELECT * FROM linkedin_company LIMIT 10");
+// result.rows, result.rowCount, result.duration_ms
+```
+
+## Note on Concurrency
+
+The rate limit is **per-process**. If you run multiple scripts simultaneously, each has its own queue. For most AI agent use cases (single script), this is fine.

package/dist/b2b.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Configure the B2B client
+ */
+export declare function configure(options: {
+    proxyUrl?: string;
+    concurrency?: number;
+    minDelayMs?: number;
+}): void;
+export interface QueryResult<T = Record<string, unknown>> {
+    rows: T[];
+    rowCount: number;
+    duration_ms: number;
+}
+/**
+ * Execute a SQL query against the B2B database.
+ * Automatically rate-limited and concurrency-controlled.
+ *
+ * @example
+ * const companies = await b2b.sql<Company[]>("SELECT * FROM linkedin_company WHERE domain = 'stripe.com'");
+ */
+export declare function sql<T = Record<string, unknown>[]>(query: string): Promise<T>;
+/**
+ * Execute a SQL query and get full result with metadata
+ */
+export declare function query<T = Record<string, unknown>>(sqlQuery: string): Promise<QueryResult<T>>;
+export declare const b2b: {
+    sql: typeof sql;
+    query: typeof query;
+    configure: typeof configure;
+};

package/dist/b2b.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.b2b = void 0;
+exports.configure = configure;
+exports.sql = sql;
+exports.query = query;
+const queue_1 = require("./queue");
+// Default config
+let config = {
+    proxyUrl: process.env.B2B_SQL_PROXY_URL || "http://165.22.151.131:3000/query",
+    concurrency: 2,
+    minDelayMs: 100, // 100ms between requests = max 10/sec
+};
+// Create queue and rate limiter with defaults
+let queue = (0, queue_1.createQueue)(config.concurrency);
+let rateLimiter = (0, queue_1.createRateLimiter)(config.minDelayMs);
+/**
+ * Configure the B2B client
+ */
+function configure(options) {
+    if (options.proxyUrl)
+        config.proxyUrl = options.proxyUrl;
+    if (options.concurrency) {
+        config.concurrency = options.concurrency;
+        queue = (0, queue_1.createQueue)(options.concurrency);
+    }
+    if (options.minDelayMs !== undefined) {
+        config.minDelayMs = options.minDelayMs;
+        rateLimiter = (0, queue_1.createRateLimiter)(options.minDelayMs);
+    }
+}
+/**
+ * Execute a SQL query against the B2B database.
+ * Automatically rate-limited and concurrency-controlled.
+ *
+ * @example
+ * const companies = await b2b.sql<Company[]>("SELECT * FROM linkedin_company WHERE domain = 'stripe.com'");
+ */
+async function sql(query) {
+    return queue(async () => {
+        return rateLimiter(async () => {
+            const response = await fetch(config.proxyUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ sql: query }),
+            });
+            if (!response.ok) {
+                throw new Error(`B2B SQL request failed: ${response.status} ${response.statusText}`);
+            }
+            const data = (await response.json());
+            if (data.error) {
+                throw new Error(`B2B SQL error: ${data.error}`);
+            }
+            return (data.rows || []);
+        });
+    });
+}
+/**
+ * Execute a SQL query and get full result with metadata
+ */
+async function query(sqlQuery) {
+    return queue(async () => {
+        return rateLimiter(async () => {
+            const response = await fetch(config.proxyUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ sql: sqlQuery }),
+            });
+            if (!response.ok) {
+                throw new Error(`B2B SQL request failed: ${response.status} ${response.statusText}`);
+            }
+            const data = (await response.json());
+            if (data.error) {
+                throw new Error(`B2B SQL error: ${data.error}`);
+            }
+            return {
+                rows: (data.rows || []),
+                rowCount: data.rowCount || 0,
+                duration_ms: data.duration_ms || 0,
+            };
+        });
+    });
+}
+// Export as namespace
+exports.b2b = {
+    sql,
+    query,
+    configure,
+};

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+import { b2b } from "./b2b";
+export { b2b };
+/**
+ * Main orangeslice namespace
+ *
+ * @example
+ * import { orangeslice } from 'orangeslice';
+ *
+ * // Configure (optional)
+ * orangeslice.b2b.configure({ concurrency: 3 });
+ *
+ * // Query - automatically rate-limited
+ * const companies = await orangeslice.b2b.sql("SELECT * FROM linkedin_company WHERE domain = 'stripe.com'");
+ *
+ * // Multiple parallel calls are queued automatically
+ * const results = await Promise.all([
+ *   orangeslice.b2b.sql("SELECT * FROM linkedin_company WHERE universal_name = 'stripe'"),
+ *   orangeslice.b2b.sql("SELECT * FROM linkedin_company WHERE universal_name = 'openai'"),
+ *   orangeslice.b2b.sql("SELECT * FROM linkedin_company WHERE universal_name = 'meta'"),
+ * ]);
+ */
+export declare const orangeslice: {
+    b2b: {
+        sql: typeof import("./b2b").sql;
+        query: typeof import("./b2b").query;
+        configure: typeof import("./b2b").configure;
+    };
+};
+export default orangeslice;

package/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orangeslice = exports.b2b = void 0;
+const b2b_1 = require("./b2b");
+Object.defineProperty(exports, "b2b", { enumerable: true, get: function () { return b2b_1.b2b; } });
+/**
+ * Main orangeslice namespace
+ *
+ * @example
+ * import { orangeslice } from 'orangeslice';
+ *
+ * // Configure (optional)
+ * orangeslice.b2b.configure({ concurrency: 3 });
+ *
+ * // Query - automatically rate-limited
+ * const companies = await orangeslice.b2b.sql("SELECT * FROM linkedin_company WHERE domain = 'stripe.com'");
+ *
+ * // Multiple parallel calls are queued automatically
+ * const results = await Promise.all([
+ *   orangeslice.b2b.sql("SELECT * FROM linkedin_company WHERE universal_name = 'stripe'"),
+ *   orangeslice.b2b.sql("SELECT * FROM linkedin_company WHERE universal_name = 'openai'"),
+ *   orangeslice.b2b.sql("SELECT * FROM linkedin_company WHERE universal_name = 'meta'"),
+ * ]);
+ */
+exports.orangeslice = {
+    b2b: b2b_1.b2b,
+};
+exports.default = exports.orangeslice;

package/dist/queue.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Simple concurrency queue - limits how many async operations run at once.
+ * Any excess calls are queued and run when a slot opens.
+ */
+export declare function createQueue(concurrency: number): <T>(fn: () => Promise<T>) => Promise<T>;
+/**
+ * Rate limiter - ensures minimum delay between requests
+ */
+export declare function createRateLimiter(minDelayMs: number): <T>(fn: () => Promise<T>) => Promise<T>;

package/dist/queue.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQueue = createQueue;
+exports.createRateLimiter = createRateLimiter;
+/**
+ * Simple concurrency queue - limits how many async operations run at once.
+ * Any excess calls are queued and run when a slot opens.
+ */
+function createQueue(concurrency) {
+    let active = 0;
+    const pending = [];
+    const next = () => {
+        if (active < concurrency && pending.length > 0) {
+            active++;
+            const resolve = pending.shift();
+            resolve();
+        }
+    };
+    return async (fn) => {
+        // Wait for a slot to open
+        await new Promise((resolve) => {
+            pending.push(resolve);
+            next();
+        });
+        try {
+            return await fn();
+        }
+        finally {
+            active--;
+            next();
+        }
+    };
+}
+/**
+ * Rate limiter - ensures minimum delay between requests
+ */
+function createRateLimiter(minDelayMs) {
+    let lastRequest = 0;
+    return async (fn) => {
+        const now = Date.now();
+        const timeSinceLastRequest = now - lastRequest;
+        if (timeSinceLastRequest < minDelayMs) {
+            await new Promise((resolve) => setTimeout(resolve, minDelayMs - timeSinceLastRequest));
+        }
+        lastRequest = Date.now();
+        return fn();
+    };
+}

package/docs/B2B_CROSS_TABLE_TEST_FINDINGS.md

@@ -0,0 +1,255 @@
+# B2B Cross-Table Query Test Findings
+
+Comprehensive performance comparison between normalized tables (`linkedin_profile`, `linkedin_company`) and denormalized views (`lkd_profile`, `lkd_company`) for cross-table queries.
+
+---
+
+## Executive Summary
+
+| Pattern                            | Normalized | Denormalized | Winner       | Speedup |
+| ---------------------------------- | ---------- | ------------ | ------------ | ------- |
+| **Company ID lookup → employees**  | 48ms       | 279ms        | Normalized   | 5.8x    |
+| **Company name (org) search**      | 274ms      | 8,600ms      | Normalized   | 31x     |
+| **GIN-indexed org ILIKE**          | 430ms      | 29,409ms     | Normalized   | 68x     |
+| **Title ILIKE (common term)**      | 64ms       | 313ms        | Normalized   | 4.9x    |
+| **updated_at filter**              | 4ms        | 14ms         | Normalized   | 3.5x    |
+| **Company ID direct lookup**       | 4ms        | 31ms         | Normalized   | 7.8x    |
+| **Headline (rare term)**           | 2,530ms    | 1,258ms      | Denormalized | 2x      |
+| **Skill array search**             | 216ms      | 169ms        | Denormalized | 1.3x    |
+| **Industry + employee_count**      | 742ms      | 202ms        | Denormalized | 3.7x    |
+| **Headline + company size (JOIN)** | 20,205ms   | 217ms        | Denormalized | 93x     |
+| **Multi-skill + company size**     | 28,173ms   | 1,281ms      | Denormalized | 22x     |
+| **Skill + company industry**       | TIMEOUT    | 3,553ms      | Denormalized | ∞       |
+| **Complex multi-filter + company** | TIMEOUT    | 4,947ms      | Denormalized | ∞       |
+| **AI company + SF location**       | TIMEOUT    | 11,061ms     | Denormalized | ∞       |
+
+**Key Finding**: When combining profile text filters (headline, skills) with company constraints (employee_count, industry), **denormalized JOINs are 20-90x faster** and often the only option that completes within timeout.
+
+---
+
+## Critical Pattern: Profile + Company Combined Filters
+
+The most important discovery: **cross-table queries with text filters perform dramatically better with denormalized tables**.
+
+### Normalized Multi-JOIN (Often Fails)
+
+```sql
+-- ❌ TIMEOUT or 20+ seconds
+SELECT lp.id, lp.first_name, lp.headline, lc.company_name
+FROM linkedin_profile lp
+JOIN linkedin_profile_position3 pos ON pos.linkedin_profile_id = lp.id
+JOIN linkedin_company lc ON lc.id = pos.linkedin_company_id
+WHERE pos.end_date IS NULL
+  AND lp.headline ILIKE '%engineer%'
+  AND lc.employee_count > 1000
+LIMIT 50
+-- Result: 20,205ms
+```
+
+### Denormalized JOIN (Fast)
+
+```sql
+-- ✅ 217ms - 93x faster
+SELECT lkd.profile_id, lkd.first_name, lkd.headline, lkdc.name
+FROM lkd_profile lkd
+JOIN lkd_company lkdc ON lkdc.linkedin_company_id = lkd.linkedin_company_id
+WHERE lkd.headline ILIKE '%engineer%'
+  AND lkdc.employee_count > 1000
+LIMIT 50
+-- Result: 217ms
+```
+
+---
+
+## Test Results by Category
+
+### A. Company-First Queries
+
+| Test | Query                           | Normalized | Denormalized | Winner            |
+| ---- | ------------------------------- | ---------- | ------------ | ----------------- |
+| A1   | Employees at company ID         | **48ms**   | 279ms        | Normalized (5.8x) |
+| A2   | Employees by company name (org) | **274ms**  | 8,600ms      | Normalized (31x)  |
+| A3   | Engineers at large companies    | **96ms**   | 234ms        | Normalized (2.4x) |
+
+**Conclusion**: For company-first queries, normalized tables win due to indexed lookups.
+
+### B. Profile-First Queries
+
+| Test | Query                      | Normalized | Denormalized | Winner              |
+| ---- | -------------------------- | ---------- | ------------ | ------------------- |
+| B1   | Python developers          | 216ms      | **169ms**    | Denormalized (1.3x) |
+| B2   | US Data Scientists         | 644ms      | **557ms**    | Denormalized (1.2x) |
+| B3   | Senior engineers + company | 4,535ms    | **196ms**    | Denormalized (23x)  |
+
+**Conclusion**: Simple profile queries are similar; profile + company queries favor denormalized.
+
+### C. Complex Prospecting Queries
+
+| Test | Query                                     | Normalized  | Denormalized | Winner            |
+| ---- | ----------------------------------------- | ----------- | ------------ | ----------------- |
+| C1   | Decision makers at funded startups        | **1,198ms** | 3,124ms      | Normalized (2.6x) |
+| C2   | AI company employees in SF                | TIMEOUT     | **11,061ms** | Denormalized (∞)  |
+| C3   | Hybrid (normalized profile + lkd_company) | 9,631ms     | -            | -                 |
+
+**Conclusion**: When funding table is used (indexed JOIN), normalized wins. When text filters span tables, denormalized wins.
+
+### D. Company Lookups
+
+| Test | Query                      | Normalized | Denormalized | Winner              |
+| ---- | -------------------------- | ---------- | ------------ | ------------------- |
+| D1   | Company by ID              | **4ms**    | 31ms         | Normalized (7.8x)   |
+| D2   | Industry + employee filter | 742ms      | **202ms**    | Denormalized (3.7x) |
+
+### E. Edge Cases
+
+| Test | Query                 | Normalized | Denormalized | Winner              |
+| ---- | --------------------- | ---------- | ------------ | ------------------- |
+| E1   | Headline (blockchain) | 713ms      | **384ms**    | Denormalized (1.9x) |
+| E2   | Company description   | 144ms      | 152ms        | Tie                 |
+
+### F. Verification Tests
+
+| Test | Query                        | Normalized | Denormalized | Winner              |
+| ---- | ---------------------------- | ---------- | ------------ | ------------------- |
+| F1   | Multi-skill + company size   | 28,173ms   | **1,281ms**  | Denormalized (22x)  |
+| F2   | Country + org (GIN)          | **990ms**  | 4,594ms      | Normalized (4.6x)   |
+| F3   | Title regex + company filter | 434ms      | **227ms**    | Denormalized (1.9x) |
+
+### G. Index Pattern Tests
+
+| Test | Query                     | Normalized | Denormalized | Winner            |
+| ---- | ------------------------- | ---------- | ------------ | ----------------- |
+| G1   | org ILIKE (GIN indexed)   | **430ms**  | 29,409ms     | Normalized (68x)  |
+| G2   | headline ILIKE (no index) | 2,530ms    | **1,258ms**  | Denormalized (2x) |
+| G3   | title ILIKE               | **64ms**   | 313ms        | Normalized (4.9x) |
+| G4   | updated_at filter         | **4ms**    | 14ms         | Normalized (3.5x) |
+
+### H. Cross-Table JOIN Patterns
+
+| Test | Query                     | Normalized | Denormalized | Winner             |
+| ---- | ------------------------- | ---------- | ------------ | ------------------ |
+| H1   | Headline + employee_count | 20,205ms   | **217ms**    | Denormalized (93x) |
+| H2   | Skill + company industry  | TIMEOUT    | **3,553ms**  | Denormalized (∞)   |
+| H3   | Multi-filter + company    | TIMEOUT    | **4,947ms**  | Denormalized (∞)   |
+
+---
+
+## Decision Rules for Cross-Table Queries
+
+### Use Normalized (`linkedin_profile` + `linkedin_company` JOINs) When:
+
+1. **Company-first lookup** - Start with company ID, get employees
+2. **GIN-indexed field** - Searching `linkedin_profile.org` (company name)
+3. **Indexed lookups** - `updated_at`, company ID, profile ID
+4. **Title field search** - `linkedin_profile.title` is faster
+5. **Indexed JOIN tables** - `linkedin_crunchbase_funding`, `linkedin_profile_position3` by company
+
+### Use Denormalized (`lkd_profile` JOIN `lkd_company`) When:
+
+1. **Headline + company filter** - 93x faster
+2. **Skill + company constraint** - Normalized times out
+3. **Multi-filter combinations** - 22x faster
+4. **Industry + employee_count** - 3.7x faster
+5. **Text filter spanning profile + company** - Often only option
+
+### Never Use:
+
+1. `lkd_profile.company_name` ILIKE - Use `linkedin_profile.org` (68x faster)
+2. Normalized multi-JOIN with headline filter - Will timeout or be 20s+
+
+---
+
+## Recommended Query Patterns
+
+### Pattern 1: Find Employees at Company by Name
+
+```sql
+-- ✅ BEST: Use GIN-indexed org field
+SELECT id, first_name, title, headline, org
+FROM linkedin_profile
+WHERE org ILIKE '%Google%'
+LIMIT 50
+-- Result: 274ms
+```
+
+### Pattern 2: Find Engineers at Large Companies
+
+```sql
+-- ✅ BEST: Denormalized JOIN (93x faster)
+SELECT lkd.profile_id, lkd.first_name, lkd.headline, lkdc.name, lkdc.employee_count
+FROM lkd_profile lkd
+JOIN lkd_company lkdc ON lkdc.linkedin_company_id = lkd.linkedin_company_id
+WHERE lkd.headline ILIKE '%engineer%'
+  AND lkdc.employee_count > 1000
+LIMIT 50
+-- Result: 217ms
+```
+
+### Pattern 3: Find People with Skills at Specific Company Types
+
+```sql
+-- ✅ BEST: Denormalized (normalized times out)
+SELECT lkd.profile_id, lkd.first_name, lkd.headline, lkdc.name
+FROM lkd_profile lkd
+JOIN lkd_company lkdc ON lkdc.linkedin_company_id = lkd.linkedin_company_id
+WHERE 'Python' = ANY(lkd.skills)
+  AND 'SQL' = ANY(lkd.skills)
+  AND lkdc.employee_count BETWEEN 100 AND 5000
+LIMIT 50
+-- Result: 1,281ms (normalized: 28,173ms)
+```
+
+### Pattern 4: Prospecting Query (Profile Criteria + Company Criteria)
+
+```sql
+-- ✅ BEST: Denormalized for multi-filter
+SELECT lkd.profile_id, lkd.first_name, lkd.title, lkdc.name, lkdc.employee_count
+FROM lkd_profile lkd
+JOIN lkd_company lkdc ON lkdc.linkedin_company_id = lkd.linkedin_company_id
+WHERE lkd.title ~* '(manager|director|lead)'
+  AND lkdc.employee_count BETWEEN 100 AND 1000
+LIMIT 50
+-- Result: 227ms (normalized: 434ms)
+```
+
+### Pattern 5: Decision Makers at Funded Startups
+
+```sql
+-- ✅ BEST: Normalized when using indexed funding table
+SELECT DISTINCT lp.id, lp.first_name, lp.title, lc.company_name
+FROM linkedin_profile lp
+JOIN linkedin_profile_position3 pos ON pos.linkedin_profile_id = lp.id
+JOIN linkedin_company lc ON lc.id = pos.linkedin_company_id
+JOIN linkedin_crunchbase_funding cf ON cf.linkedin_company_id = lc.id
+WHERE pos.end_date IS NULL
+  AND lp.title ~* '(CEO|CTO|VP|Director|Head)'
+  AND lc.employee_count BETWEEN 10 AND 500
+LIMIT 50
+-- Result: 1,198ms
+```
+
+---
+
+## Summary: The Cross-Table Golden Rules
+
+1. **Company name search** → Always use `linkedin_profile.org` (GIN indexed, 68x faster)
+2. **Headline/skill + company constraint** → Always use denormalized JOIN (20-93x faster, normalized often times out)
+3. **Company-first lookups** → Use normalized (5-8x faster)
+4. **Indexed table JOINs (funding, positions)** → Normalized is fine
+5. **Multi-filter profile + company** → Denormalized is the only option that works
+
+### Quick Decision:
+
+```
+Need to search by company name?
+  └─ YES → Use linkedin_profile.org
+
+Need profile text filter (headline/skills) + company constraint?
+  └─ YES → Use lkd_profile JOIN lkd_company
+
+Need company ID lookup or indexed JOIN?
+  └─ YES → Use normalized tables
+
+Default for prospecting queries:
+  └─ Use lkd_profile JOIN lkd_company
+```