@brownandroot/api 1.1.0 → 1.2.1

package/README.md

@@ -10,9 +10,11 @@ npm install @brownandroot/api
 
 ---
 
-## SvelteKit Remote Functions
+## Client-Side Cache API (recommended for SvelteKit)
 
-For SvelteKit apps, the package ships ready-to-use remote functions that run on the server and read credentials from environment variables automatically — no manual client instantiation needed.
+The package ships a browser-side API at `@brownandroot/api/cache` that wraps every remote function with an **IndexedDB stale-while-revalidate cache**. On the first call the data is fetched from the server; on every subsequent call the cached data is returned instantly. A background refresh runs automatically when the cached data is older than **4 hours**.
+
+All list and dropdown functions accept an optional filter object — every entity field is available as an optional filter key. The `q` field performs a case-insensitive partial-text match across the entity's searchable text fields.
 
 ### Setup
 
@@ -27,21 +29,225 @@ Enable remote functions in `svelte.config.js` (if not already):
 
 ```js
 kit: {
-  experimental: { remoteFunctions: true }
+	experimental: {
+		remoteFunctions: true
+	}
 }
 ```
 
 ### Usage
 
-Import directly from the domain sub-path and call in components:
+```svelte
+<script lang="ts">
+  import { getWorkordersDropdown, getEmployees, clearCache } from '@brownandroot/api/cache'
+
+  // First page load: fetches from server and caches in IndexedDB.
+  // Subsequent loads: returns from IndexedDB instantly, refreshes in background.
+  const workorders = $derived(await getWorkordersDropdown({ businessUnitId: 'BU001' }))
+
+  // Multiple filters compose freely
+  const employees = $derived(await getEmployees({
+    hbu: 'TX01',
+    payClass: 'H',
+    q: 'john',
+  }))
+
+  // After a mutation, clear the affected entity so the next read re-fetches
+  async function onCreate() {
+    await createWorkorder(formData)
+    clearCache('workorders')
+  }
+</script>
+```
+
+### Filter reference
+
+All filter fields are optional. Omit the filter object entirely to return all records.
+
+#### Workorders
+
+```typescript
+import { getWorkorders, getWorkordersDropdown } from '@brownandroot/api/cache'
+
+interface WorkorderFilters {
+	businessUnitId?: string // exact match
+	costCodeId?: string // exact match
+	isActive?: boolean // exact match
+	completed?: boolean // exact match
+	area?: string // exact match
+	parentWorkOrder?: string // exact match
+	q?: string // partial match on description or clientWorkOrderId
+}
+
+// Returns Workorder[]
+const all = await getWorkorders()
+const active = await getWorkorders({ isActive: true })
+const byBu = await getWorkorders({ businessUnitId: 'BU001', isActive: true })
+const search = await getWorkorders({ q: 'pipe' })
+
+// Returns { value, label }[] — always applies isActive: true by default
+const dropdown = await getWorkordersDropdown({ businessUnitId: 'BU001' })
+```
+
+#### Employees
+
+```typescript
+import { getEmployees, getEmployeesDropdown } from '@brownandroot/api/cache'
+
+interface EmployeeFilters {
+	businessUnitId?: string // exact match
+	hbu?: string // exact match on home business unit
+	supervisor?: string // exact match on supervisor employee ID
+	payClass?: string // exact match
+	jobType?: string // exact match
+	jobStep?: string // exact match
+	sector?: string // exact match
+	division?: string // exact match
+	q?: string // partial match on name or email
+}
+
+const byHbu = await getEmployees({ hbu: 'TX01' })
+const byName = await getEmployees({ q: 'john' })
+const dropdown = await getEmployeesDropdown({ businessUnitId: 'BU001' })
+```
+
+#### Cost Codes
+
+```typescript
+import { getCostcodes, getCostcodesDropdown } from '@brownandroot/api/cache'
+
+interface CostcodeFilters {
+	businessUnitId?: string // exact match
+	isActive?: boolean // exact match
+	entryFlag?: boolean // exact match
+	payTypeCode?: string // resolves pay type → objectAccount, filters by match
+	q?: string // partial match on description or jdeCostCode
+}
+
+const byBu = await getCostcodes({ businessUnitId: 'BU001' })
+const search = await getCostcodes({ q: 'labor' })
+
+// Dropdown applies isActive: true and entryFlag: true by default,
+// and also excludes expired cost codes
+const dropdown = await getCostcodesDropdown({ businessUnitId: 'BU001' })
+const dropdownByPayType = await getCostcodesDropdown({
+	businessUnitId: 'BU001',
+	payTypeCode: 'PT01',
+})
+```
+
+> **payTypeCode cross-reference:** When `payTypeCode` is set, the filter looks up that pay type's `objectAccount` from the (also cached) pay types list and only returns cost codes whose `objectAccount` matches. If the pay type has no `objectAccount`, all cost codes pass this filter.
+
+#### Pay Types
+
+```typescript
+import { getPaytypes, getPaytypesDropdown } from '@brownandroot/api/cache'
+
+interface PaytypeFilters {
+	payClass?: string // exact match
+	category?: string // exact match
+	type?: string // exact match
+	isActive?: boolean // exact match
+	perDiemPayType?: boolean // exact match
+	q?: string // partial match on description
+}
+
+const hourly = await getPaytypes({ payClass: 'H' })
+const dropdown = await getPaytypesDropdown({ isActive: true })
+// Dropdown returns { value, label, payClass }[]
+```
+
+#### Business Units
+
+```typescript
+import { getBusinessUnits, getBusinessUnitsDropdown } from '@brownandroot/api/cache'
+
+interface BusinessUnitFilters {
+	subsector?: string // exact match
+	isActive?: boolean // exact match
+	clientId?: string // exact match
+	q?: string // partial match on description or clientDescription
+}
+
+const active = await getBusinessUnits({ isActive: true })
+const dropdown = await getBusinessUnitsDropdown({ subsector: 'Gulf Coast' })
+```
+
+#### Job Type / Job Steps
+
+```typescript
+import { getJobtypejobsteps, getJobtypejobstepsDropdown } from '@brownandroot/api/cache'
+
+interface JobtypejobstepFilters {
+	jobType?: string // exact match
+	payclass?: string // exact match
+	isActive?: boolean // exact match
+	grp?: string // exact match
+	q?: string // partial match on description, jobType, or jobStep
+}
+
+const welders = await getJobtypejobsteps({ jobType: 'WE' })
+const dropdown = await getJobtypejobstepsDropdown({ isActive: true })
+```
+
+### Single-record lookups
+
+Single-record functions always fetch fresh from the server (no IndexedDB):
+
+```typescript
+import {
+	getEmployee,
+	getSupervisorChain,
+	getJdeFromEmail,
+	verifyIdentity,
+	getWorkorder,
+	getCostcode,
+	getPaytype,
+	getBusinessUnit,
+	getJobtypejobstep,
+} from '@brownandroot/api/cache'
+
+const emp = await getEmployee('12345')
+const chain = await getSupervisorChain('12345')
+const { jde, employee } = await getJdeFromEmail('john@example.com')
+const verified = await verifyIdentity({
+	first3FirstName: 'joh',
+	first3LastName: 'doe',
+	dob: '1985-03-15',
+	ssn4: '4321',
+})
+```
+
+### Cache management
+
+```typescript
+import { clearCache } from '@brownandroot/api/cache'
+
+clearCache() // clear all entities
+clearCache('workorders') // clear a specific entity
+clearCache('employees')
+clearCache('costcodes')
+clearCache('paytypes')
+clearCache('businessUnits')
+clearCache('jobtypejobsteps')
+```
+
+Call `clearCache(entity)` immediately after any mutation that changes that entity so the next read fetches fresh data.
+
+---
+
+## Remote Functions (server-side)
+
+For SvelteKit apps that need direct server-side access without the IndexedDB layer, the package also ships ready-to-use remote functions that run on the server and read credentials from environment variables automatically.
 
 ```svelte
 <script lang="ts">
-  import { getEmployeesDropdown } from '@brownandroot/api/employees'
-  import { getBusinessUnitsDropdown } from '@brownandroot/api/businessUnits'
+  import { getEmployees } from '@brownandroot/api/employees'
+  import { getBusinessUnits } from '@brownandroot/api/businessUnits'
 
-  const employees = $derived(await getEmployeesDropdown())
-  const businessUnits = $derived(await getBusinessUnitsDropdown())
+  // These always fetch from the server on every call
+  const employees = $derived(await getEmployees())
+  const businessUnits = $derived(await getBusinessUnits())
 </script>
 ```
 
@@ -52,7 +258,7 @@ import { query } from '$app/server'
 import { getSupervisorChain } from '@brownandroot/api/employees'
 
 export const getMyManagers = query(async () => {
-  return (await getSupervisorChain('12345')).slice(0, 2)
+	return (await getSupervisorChain('12345')).slice(0, 2)
 })
 ```
 
@@ -85,36 +291,15 @@ const client = new ApiHubClient({
 ### Fetching
 
 ```typescript
-// All employees
 const employees = await client.getEmployees()
-
-// Dropdown format: { value: employeeId, label: name }[]
-const dropdown = await client.getEmployeesDropdown()
-
-// Single employee by ID — throws if not found
-const employee = await client.getEmployee('12345')
-```
-
-### Search
-
-```typescript
-// By name (case-insensitive partial match)
-const results = await client.searchByName('John')
-
-// By email (case-insensitive partial match)
-const results = await client.searchByEmail('john@example.com')
-
-// By home business unit (case-insensitive partial match)
-const results = await client.searchByHbu('TX01')
+const dropdown = await client.getEmployeesDropdown() // { value: employeeId, label: name }[]
+const employee = await client.getEmployee('12345') // throws if not found
+const employeePrivileged = await client.getEmployeePrivileged('12345') // includes hourlyRate and annualSalary
 ```
 
 ### Org hierarchy
 
 ```typescript
-// All employees reporting directly to a supervisor
-const reports = await client.getBySupervisor('12345')
-
-// Full supervisor chain above an employee (excludes the employee themselves)
 const chain = await client.getSupervisorChain('12345')
 ```
 
@@ -128,21 +313,14 @@ const { jde, employee } = await client.getJdeFromEmail('john@example.com')
 
 ### Identity verification
 
-Verifies an employee's identity from name, date of birth, and last 4 of SSN alone — no employee ID needed. Returns the full employee record on a match.
-
 ```typescript
 const employee = await client.verifyIdentity({
-	first3FirstName: 'joh',    // first 3 chars of first name, case-insensitive
-	first3LastName: 'doe',     // first 3 chars of last name, case-insensitive
-	dob: '1985-03-15',         // YYYY-MM-DD
-	ssn4: '4321',              // last 4 digits of SSN
+	first3FirstName: 'joh',
+	first3LastName: 'doe',
+	dob: '1985-03-15',
+	ssn4: '4321',
 })
-
-if (employee) {
-	// identity confirmed — full Employee object returned
-} else {
-	// no employee matched these inputs
-}
+// Employee on match, null on no match
 // Throws on 400 (missing fields) or 503 (not configured server-side)
 ```
 
@@ -150,75 +328,59 @@ if (employee) {
 
 ```typescript
 interface Employee {
-	// Identity
-	employeeId: string
-	name: string | null
-	email: string | null
-	badgeNumber: string | null
-	nccerNumber: string | null
-
-	// Organization
-	company: string | null         // company code
-	businessUnitId: string | null
-	hbu: string | null             // home business unit
-	departmentCode: string | null
-	division: string | null
-	sector: string | null
-	subsector: string | null
-
-	// Contact
-	phone: string | null
-
-	// Employment
-	employementStatus: string | null
-	employeePayStatus: string | null
-	recordType: string | null
-
-	// Job
-	jobType: string | null
-	jobStep: string | null
-	jobDescription: string | null
-	workSchedule: string | null
-	shift: string | null
-
-	// Pay & compensation
-	payClass: string | null
-	payFrequency: string | null
-	payCycleCode: string | null
-	checkRouteCode: string | null
-	hourlyRate: string | null      // string — format as needed
-	annualSalary: string | null    // string — format as needed
-
-	// Tax
-	residentTaxArea: string | null
-	workTaxArea: string | null
-
-	// Benefits
-	benefitGroup: string | null
-
-	// PTO
-	topFlexPtoDate: string | null  // ISO timestamp
-	clientPtoDate: string | null   // ISO timestamp
-
-	// Security & reporting
-	securityLevel: string | null
-	reportingLevel: string | null
-
-	// Relationships
-	supervisor: string | null      // supervisor employee ID
-	mentor: string | null
-
-	// Dates
-	hireDate: string | null
-	termDate: string | null
-	adjustedServiceDate: string | null
-
-	// Metadata
-	source: string | null
-	createdAt: string | null
-	updatedAtJulian: number | null
-	updatedAt: string | null
+  employeeId: string
+  name: string | null
+  email: string | null
+  personalEmail: string | null
+  clientEmail: string | null
+  workEmail: string | null
+  badgeNumber: string | null
+  nccerNumber: string | null
+  company: string | null
+  businessUnitId: string | null
+  hbu: string | null
+  departmentCode: string | null
+  division: string | null
+  sector: string | null
+  subsector: string | null
+  phone: string | null
+  employementStatus: string | null
+  employeePayStatus: string | null
+  recordType: string | null
+  jobType: string | null
+  jobStep: string | null
+  jobDescription: string | null
+  workSchedule: string | null
+  shift: string | null
+  payClass: string | null
+  payFrequency: string | null
+  payCycleCode: string | null
+  checkRouteCode: string | null
+  residentTaxArea: string | null
+  workTaxArea: string | null
+  benefitGroup: string | null
+  topFlexPtoDate: string | null
+  clientPtoDate: string | null
+  securityLevel: string | null
+  reportingLevel: string | null
+  supervisor: string | null
+  mentor: string | null
+  hireDate: string | null
+  termDate: string | null
+  adjustedServiceDate: string | null
+  identityHash: string | null
+  source: string | null
+  createdAt: string | null
+  updatedAtJulian: number | null
+  updatedAt: string | null
 }
+
+interface EmployeePrivileged extends Employee {
+  hourlyRate: string | null
+  annualSalary: string | null
+}
+
+getEmployees, getEmployee, employee searches, getJdeFromEmail, and verifyIdentity all return the public Employee shape (without compensation fields). Use getEmployeePrivileged when compensation fields are required.
 ```
 
 ---
@@ -229,9 +391,6 @@ interface Employee {
 const units = await client.getBusinessUnits()
 const dropdown = await client.getBusinessUnitsDropdown() // { value, label }[]
 const unit = await client.getBusinessUnit('BU001')
-
-// Search by description (case-insensitive partial match)
-const results = await client.searchBusinessUnits('west')
 ```
 
 ---
@@ -242,15 +401,6 @@ const results = await client.searchBusinessUnits('west')
 const codes = await client.getCostcodes()
 const dropdown = await client.getCostcodesDropdown() // { value, label }[]
 const code = await client.getCostcode('CC001')
-
-// Filtered by business unit
-const buDropdown = await client.getCostcodesDropdownByBu('BU001')
-
-// Filtered by business unit and pay type
-const buPtDropdown = await client.getCostcodesDropdownByBuAndPayType('BU001', 'PT01')
-
-// Search by description or JDE cost code (case-insensitive partial match)
-const results = await client.searchCostcodes('labor')
 ```
 
 ---
@@ -261,9 +411,6 @@ const results = await client.searchCostcodes('labor')
 const types = await client.getPaytypes()
 const dropdown = await client.getPaytypesDropdown() // { value, label, payClass }[]
 const type = await client.getPaytype('PT001')
-
-// Search by description (case-insensitive partial match)
-const results = await client.searchPaytypes('regular')
 ```
 
 ---
@@ -274,12 +421,6 @@ const results = await client.searchPaytypes('regular')
 const orders = await client.getWorkorders()
 const dropdown = await client.getWorkordersDropdown() // { value, label }[]
 const order = await client.getWorkorder('WO001')
-
-// Filtered by business unit
-const buDropdown = await client.getWorkordersDropdownByBu('BU001')
-
-// Search by description or client work order ID (case-insensitive partial match)
-const results = await client.searchWorkorders('pipe')
 ```
 
 ---
@@ -301,11 +442,11 @@ const item = await client.getJobtypejobstep('JTJS001')
 ```typescript
 const result = await client.chat({
 	messages: [{ role: 'user', content: 'Summarize this document...' }],
-	source: 'my-app',    // your application name
-	user: 'jane.doe',    // user identifier for logging
-	function: 'summarize', // optional label for logging
-	temperature: 0.7,    // optional, default 0.7
-	maxTokens: 1000,     // optional
+	source: 'my-app',
+	user: 'jane.doe',
+	function: 'summarize',
+	temperature: 0.7,
+	maxTokens: 1000,
 })
 
 console.log(result.message.content)
@@ -314,17 +455,13 @@ console.log(result.usage) // { tokensIn, tokensOut, totalTokens }
 
 ### Streaming chat
 
-Returns a raw SSE `Response` for you to proxy or consume directly.
-
 ```typescript
 const response = await client.chatStream({
 	messages: [{ role: 'user', content: 'Hello' }],
 	userContext: { name: 'Jane Doe', department: 'Engineering', roles: ['admin'] },
-	useRag: true,    // optional, search document knowledge base
-	tools: ['...'],  // optional
+	useRag: true,
 	source: 'my-app',
 })
-
 // Proxy to the browser, or read the SSE stream directly
 ```
 
@@ -338,31 +475,20 @@ const logs = await client.getLlmLogs() // newest first
 
 ## Documents (RAG)
 
-Upload and search documents in the knowledge base.
-
 ```typescript
-// Upload a document (PDF or CSV)
 const doc = await client.uploadDocument('report.pdf', base64Content, 'jane.doe')
-
-// List all documents
 const docs = await client.listDocuments()
-
-// Search with a natural language query
 const results = await client.searchDocuments('overtime policy', 5)
 // results: { chunkId, content, fileName, documentType, score }[]
-
-// Delete a document and all its chunks
 await client.deleteDocument(doc.id)
 ```
 
 ---
 
-## Cache management
-
-All GET methods cache responses client-side for `cacheTtl` milliseconds (default 5 minutes). To invalidate:
+## Cache management (ApiHubClient)
 
 ```typescript
-client.clearCache()           // clear everything
+client.clearCache() // clear everything
 client.clearCache('/employees') // clear a specific path
 ```
 
@@ -390,20 +516,30 @@ import type {
 	DropdownOption,
 	PaytypeDropdownOption,
 } from '@brownandroot/api'
+
+// Filter interfaces (from cache module)
+import type {
+	EmployeeFilters,
+	WorkorderFilters,
+	CostcodeFilters,
+	PaytypeFilters,
+	BusinessUnitFilters,
+	JobtypejobstepFilters,
+} from '@brownandroot/api/cache'
 ```
 
 ---
 
 ## Error handling
 
-All methods throw an `Error` when the API returns a non-OK response. The error message contains the server's detail or the HTTP status.
+All methods throw an `Error` when the API returns a non-OK response.
 
 ```typescript
 try {
-	const emp = await client.getEmployee('99999')
+	const emp = await getEmployee('99999')
 } catch (err) {
 	console.error(err.message) // "Employee not found"
 }
 ```
 
-`verifyIdentity` is the exception — it returns `null` when no employee matches the inputs, and only throws for request errors (400, 503, network failure).
+`verifyIdentity` returns `null` when no employee matches the inputs, and only throws for request errors (400, 503, network failure).

package/dist/businessUnits.remote.d.ts

@@ -1,4 +1,3 @@
 export declare const getBusinessUnits: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").BusinessUnit[]>;
 export declare const getBusinessUnitsDropdown: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").DropdownOption[]>;
 export declare const getBusinessUnit: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").BusinessUnit>;
-export declare const searchBusinessUnits: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").BusinessUnit[]>;

package/dist/businessUnits.remote.js

@@ -4,4 +4,3 @@ import { getClient } from './client.js';
 export const getBusinessUnits = query(async () => getClient().getBusinessUnits());
 export const getBusinessUnitsDropdown = query(async () => getClient().getBusinessUnitsDropdown());
 export const getBusinessUnit = query(z.string(), async (id) => getClient().getBusinessUnit(id));
-export const searchBusinessUnits = query(z.string(), async (q) => getClient().searchBusinessUnits(q));

package/dist/cache.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Client-side cache API for @brownandroot/api.
+ *
+ * Wraps remote functions with an IndexedDB stale-while-revalidate cache so
+ * pages load instantly on subsequent visits. Filters are applied in-memory
+ * against the full cached dataset — no per-field server endpoints needed.
+ *
+ * Import from: @brownandroot/api/cache
+ */
+import type { Employee, EmployeePrivileged, BusinessUnit, Costcode, Paytype, Workorder, Jobtypejobstep, DropdownOption, PaytypeDropdownOption } from './index.js';
+import { type IdbStore } from './idb.js';
+export interface EmployeeFilters {
+    /** Exact match on businessUnitId */
+    businessUnitId?: string;
+    /** Exact match on home business unit (hbu) */
+    hbu?: string;
+    /** Exact match on supervisor employee ID */
+    supervisor?: string;
+    /** Exact match on payClass */
+    payClass?: string;
+    /** Exact match on jobType */
+    jobType?: string;
+    /** Exact match on jobStep */
+    jobStep?: string;
+    /** Exact match on sector */
+    sector?: string;
+    /** Exact match on division */
+    division?: string;
+    /** Case-insensitive partial match on name or email */
+    q?: string;
+}
+export interface WorkorderFilters {
+    /** Exact match on businessUnitId */
+    businessUnitId?: string;
+    /** Exact match on costCodeId */
+    costCodeId?: string;
+    /** Exact match on isActive */
+    isActive?: boolean;
+    /** Exact match on completed */
+    completed?: boolean;
+    /** Exact match on area */
+    area?: string;
+    /** Exact match on parentWorkOrder */
+    parentWorkOrder?: string;
+    /** Case-insensitive partial match on description or clientWorkOrderId */
+    q?: string;
+}
+export interface CostcodeFilters {
+    /** Exact match on businessUnitId */
+    businessUnitId?: string;
+    /** Exact match on isActive */
+    isActive?: boolean;
+    /** Exact match on entryFlag */
+    entryFlag?: boolean;
+    /**
+     * Filter by pay type — resolves the pay type's objectAccount and returns
+     * only cost codes whose objectAccount matches. If the pay type has no
+     * objectAccount, all cost codes pass this filter.
+     */
+    payTypeCode?: string;
+    /** Case-insensitive partial match on description or jdeCostCode */
+    q?: string;
+}
+export interface PaytypeFilters {
+    /** Exact match on payClass */
+    payClass?: string;
+    /** Exact match on category */
+    category?: string;
+    /** Exact match on type */
+    type?: string;
+    /** Exact match on isActive */
+    isActive?: boolean;
+    /** Exact match on perDiemPayType */
+    perDiemPayType?: boolean;
+    /** Case-insensitive partial match on description */
+    q?: string;
+}
+export interface BusinessUnitFilters {
+    /** Exact match on subsector */
+    subsector?: string;
+    /** Exact match on isActive */
+    isActive?: boolean;
+    /** Exact match on clientId */
+    clientId?: string;
+    /** Case-insensitive partial match on description or clientDescription */
+    q?: string;
+}
+export interface JobtypejobstepFilters {
+    /** Exact match on jobType */
+    jobType?: string;
+    /** Exact match on payclass */
+    payclass?: string;
+    /** Exact match on isActive */
+    isActive?: boolean;
+    /** Exact match on grp */
+    grp?: string;
+    /** Case-insensitive partial match on description, jobType, or jobStep */
+    q?: string;
+}
+export declare function getEmployees(filters?: EmployeeFilters): Promise<Employee[]>;
+export declare function getEmployeesDropdown(filters?: EmployeeFilters): Promise<DropdownOption[]>;
+/** Single employee by ID — always fetches fresh (no IndexedDB). */
+export declare function getEmployee(employeeId: string): Promise<Employee>;
+/** Single employee by ID including compensation fields — always fetches fresh (no IndexedDB). */
+export declare function getEmployeePrivileged(employeeId: string): Promise<EmployeePrivileged>;
+/** Full supervisor chain above an employee — always fetches fresh. */
+export declare function getSupervisorChain(employeeId: string): Promise<Employee[]>;
+/** Look up JDE number and employee from email — always fetches fresh. */
+export declare function getJdeFromEmail(email: string): Promise<{
+    jde: string | null;
+    employee: Employee | null;
+}>;
+/** Verify employee identity — always fetches fresh. */
+export declare function verifyIdentity(inputs: {
+    first3FirstName: string;
+    first3LastName: string;
+    dob: string;
+    ssn4: string;
+}): Promise<Employee | null>;
+export declare function getWorkorders(filters?: WorkorderFilters): Promise<Workorder[]>;
+export declare function getWorkordersDropdown(filters?: WorkorderFilters): Promise<DropdownOption[]>;
+/** Single workorder by ID — always fetches fresh (no IndexedDB). */
+export declare function getWorkorder(id: string): Promise<Workorder>;
+export declare function getCostcodes(filters?: CostcodeFilters): Promise<Costcode[]>;
+export declare function getCostcodesDropdown(filters?: CostcodeFilters): Promise<DropdownOption[]>;
+/** Single cost code by ID — always fetches fresh (no IndexedDB). */
+export declare function getCostcode(id: string): Promise<Costcode>;
+export declare function getPaytypes(filters?: PaytypeFilters): Promise<Paytype[]>;
+export declare function getPaytypesDropdown(filters?: PaytypeFilters): Promise<PaytypeDropdownOption[]>;
+/** Single pay type by ID — always fetches fresh (no IndexedDB). */
+export declare function getPaytype(id: string): Promise<Paytype>;
+export declare function getBusinessUnits(filters?: BusinessUnitFilters): Promise<BusinessUnit[]>;
+export declare function getBusinessUnitsDropdown(filters?: BusinessUnitFilters): Promise<DropdownOption[]>;
+/** Single business unit by ID — always fetches fresh (no IndexedDB). */
+export declare function getBusinessUnit(id: string): Promise<BusinessUnit>;
+export declare function getJobtypejobsteps(filters?: JobtypejobstepFilters): Promise<Jobtypejobstep[]>;
+export declare function getJobtypejobstepsDropdown(filters?: JobtypejobstepFilters): Promise<DropdownOption[]>;
+/** Single job type/job step by ID — always fetches fresh (no IndexedDB). */
+export declare function getJobtypejobstep(id: string): Promise<Jobtypejobstep>;
+/**
+ * Clear the IndexedDB cache for a specific entity, or all entities.
+ *
+ * Call after mutations to ensure the next read fetches fresh data from
+ * the server instead of returning stale cached results.
+ *
+ * @example
+ * await createWorkorder(data)
+ * clearCache('workorders')  // next getWorkorders() will re-fetch
+ *
+ * clearCache()  // clear everything
+ */
+export declare function clearCache(entity?: IdbStore): void;

package/dist/cache.js

@@ -0,0 +1,328 @@
+/**
+ * Client-side cache API for @brownandroot/api.
+ *
+ * Wraps remote functions with an IndexedDB stale-while-revalidate cache so
+ * pages load instantly on subsequent visits. Filters are applied in-memory
+ * against the full cached dataset — no per-field server endpoints needed.
+ *
+ * Import from: @brownandroot/api/cache
+ */
+import { idbGet, idbSet, idbClear } from './idb.js';
+// Remote functions — called as HTTP on the client, directly on the server (SSR)
+import { getEmployees as _getEmployees, getEmployee as _getEmployee, getEmployeePrivileged as _getEmployeePrivileged, getJdeFromEmail as _getJdeFromEmail, getSupervisorChain as _getSupervisorChain, verifyIdentity as _verifyIdentity, } from './employees.remote.js';
+import { getBusinessUnits as _getBusinessUnits, getBusinessUnit as _getBusinessUnit } from './businessUnits.remote.js';
+import { getCostcodes as _getCostcodes, getCostcode as _getCostcode } from './costcodes.remote.js';
+import { getPaytypes as _getPaytypes, getPaytype as _getPaytype } from './paytypes.remote.js';
+import { getWorkorders as _getWorkorders, getWorkorder as _getWorkorder } from './workorders.remote.js';
+import { getJobtypejobsteps as _getJobtypejobsteps, getJobtypejobstep as _getJobtypejobstep, } from './jobtypejobsteps.remote.js';
+// ---------------------------------------------------------------------------
+// Internal: stale-while-revalidate fetch helpers
+// ---------------------------------------------------------------------------
+/** How long cached data is considered fresh before a background refresh is triggered. */
+const CACHE_TTL_MS = 4 * 60 * 60 * 1000; // 4 hours
+async function loadCached(store, fetcher) {
+    const cached = await idbGet(store, 'all');
+    if (cached) {
+        // Only refresh in the background if the cached data is older than the TTL
+        if (Date.now() - cached.fetchedAt >= CACHE_TTL_MS) {
+            fetcher()
+                .then((fresh) => idbSet(store, 'all', fresh))
+                .catch(() => { });
+        }
+        return cached.data;
+    }
+    // Cache miss — must await
+    const data = await fetcher();
+    await idbSet(store, 'all', data);
+    return data;
+}
+// ---------------------------------------------------------------------------
+// Internal: filter helpers
+// ---------------------------------------------------------------------------
+function applyEmployeeFilters(data, f) {
+    if (!f)
+        return data;
+    return data.filter((e) => {
+        if (f.businessUnitId !== undefined && e.businessUnitId !== f.businessUnitId)
+            return false;
+        if (f.hbu !== undefined && e.hbu !== f.hbu)
+            return false;
+        if (f.supervisor !== undefined && e.supervisor !== f.supervisor)
+            return false;
+        if (f.payClass !== undefined && e.payClass !== f.payClass)
+            return false;
+        if (f.jobType !== undefined && e.jobType !== f.jobType)
+            return false;
+        if (f.jobStep !== undefined && e.jobStep !== f.jobStep)
+            return false;
+        if (f.sector !== undefined && e.sector !== f.sector)
+            return false;
+        if (f.division !== undefined && e.division !== f.division)
+            return false;
+        if (f.q) {
+            const q = f.q.toLowerCase();
+            const name = e.name?.toLowerCase() ?? '';
+            const email = e.email?.toLowerCase() ?? '';
+            if (!name.includes(q) && !email.includes(q))
+                return false;
+        }
+        return true;
+    });
+}
+function applyWorkorderFilters(data, f) {
+    if (!f)
+        return data;
+    return data.filter((w) => {
+        if (f.businessUnitId !== undefined && w.businessUnitId !== f.businessUnitId)
+            return false;
+        if (f.costCodeId !== undefined && w.costCodeId !== f.costCodeId)
+            return false;
+        if (f.isActive !== undefined && w.isActive !== f.isActive)
+            return false;
+        if (f.completed !== undefined && w.completed !== f.completed)
+            return false;
+        if (f.area !== undefined && w.area !== f.area)
+            return false;
+        if (f.parentWorkOrder !== undefined && w.parentWorkOrder !== f.parentWorkOrder)
+            return false;
+        if (f.q) {
+            const q = f.q.toLowerCase();
+            const desc = w.description?.toLowerCase() ?? '';
+            const wo = w.clientWorkOrderId?.toLowerCase() ?? '';
+            if (!desc.includes(q) && !wo.includes(q))
+                return false;
+        }
+        return true;
+    });
+}
+function applyPaytypeFilters(data, f) {
+    if (!f)
+        return data;
+    return data.filter((p) => {
+        if (f.payClass !== undefined && p.payClass !== f.payClass)
+            return false;
+        if (f.category !== undefined && p.category !== f.category)
+            return false;
+        if (f.type !== undefined && p.type !== f.type)
+            return false;
+        if (f.isActive !== undefined && p.isActive !== f.isActive)
+            return false;
+        if (f.perDiemPayType !== undefined && p.perDiemPayType !== f.perDiemPayType)
+            return false;
+        if (f.q) {
+            const q = f.q.toLowerCase();
+            if (!p.description.toLowerCase().includes(q))
+                return false;
+        }
+        return true;
+    });
+}
+function applyBusinessUnitFilters(data, f) {
+    if (!f)
+        return data;
+    return data.filter((b) => {
+        if (f.subsector !== undefined && b.subsector !== f.subsector)
+            return false;
+        if (f.isActive !== undefined && b.isActive !== f.isActive)
+            return false;
+        if (f.clientId !== undefined && b.clientId !== f.clientId)
+            return false;
+        if (f.q) {
+            const q = f.q.toLowerCase();
+            const desc = b.description.toLowerCase();
+            const client = b.clientDescription?.toLowerCase() ?? '';
+            if (!desc.includes(q) && !client.includes(q))
+                return false;
+        }
+        return true;
+    });
+}
+function applyJobtypejobstepFilters(data, f) {
+    if (!f)
+        return data;
+    return data.filter((j) => {
+        if (f.jobType !== undefined && j.jobType !== f.jobType)
+            return false;
+        if (f.payclass !== undefined && j.payclass !== f.payclass)
+            return false;
+        if (f.isActive !== undefined && j.isActive !== f.isActive)
+            return false;
+        if (f.grp !== undefined && j.grp !== f.grp)
+            return false;
+        if (f.q) {
+            const q = f.q.toLowerCase();
+            const desc = j.description?.toLowerCase() ?? '';
+            const jt = j.jobType?.toLowerCase() ?? '';
+            const js = j.jobStep?.toLowerCase() ?? '';
+            if (!desc.includes(q) && !jt.includes(q) && !js.includes(q))
+                return false;
+        }
+        return true;
+    });
+}
+// Costcodes filter is async because payTypeCode requires a cross-reference
+async function applyCostcodeFilters(data, f) {
+    if (!f)
+        return data;
+    // Resolve payTypeCode → objectAccount
+    let payTypeObjectAccount;
+    if (f.payTypeCode !== undefined) {
+        const allPaytypes = await loadCached('paytypes', () => _getPaytypes());
+        payTypeObjectAccount = allPaytypes.find((p) => p.id === f.payTypeCode)?.objectAccount;
+    }
+    return data.filter((c) => {
+        if (f.businessUnitId !== undefined && c.businessUnitId !== f.businessUnitId)
+            return false;
+        if (f.isActive !== undefined && c.isActive !== f.isActive)
+            return false;
+        if (f.entryFlag !== undefined && c.entryFlag !== f.entryFlag)
+            return false;
+        if (f.payTypeCode !== undefined) {
+            // If paytype has an objectAccount, cost code must match it
+            if (payTypeObjectAccount && c.objectAccount !== payTypeObjectAccount)
+                return false;
+        }
+        if (f.q) {
+            const q = f.q.toLowerCase();
+            const desc = c.description?.toLowerCase() ?? '';
+            const code = c.jdeCostCode?.toLowerCase() ?? '';
+            if (!desc.includes(q) && !code.includes(q))
+                return false;
+        }
+        return true;
+    });
+}
+// ---------------------------------------------------------------------------
+// Public API — Employees
+// ---------------------------------------------------------------------------
+export async function getEmployees(filters) {
+    const all = await loadCached('employees', () => _getEmployees());
+    return applyEmployeeFilters(all, filters);
+}
+export async function getEmployeesDropdown(filters) {
+    const results = await getEmployees(filters);
+    return results.map((e) => ({ value: e.employeeId, label: e.name ?? e.employeeId }));
+}
+/** Single employee by ID — always fetches fresh (no IndexedDB). */
+export async function getEmployee(employeeId) {
+    return _getEmployee(employeeId);
+}
+/** Single employee by ID including compensation fields — always fetches fresh (no IndexedDB). */
+export async function getEmployeePrivileged(employeeId) {
+    return _getEmployeePrivileged(employeeId);
+}
+/** Full supervisor chain above an employee — always fetches fresh. */
+export async function getSupervisorChain(employeeId) {
+    return _getSupervisorChain(employeeId);
+}
+/** Look up JDE number and employee from email — always fetches fresh. */
+export async function getJdeFromEmail(email) {
+    return _getJdeFromEmail(email);
+}
+/** Verify employee identity — always fetches fresh. */
+export async function verifyIdentity(inputs) {
+    return _verifyIdentity(inputs);
+}
+// ---------------------------------------------------------------------------
+// Public API — Workorders
+// ---------------------------------------------------------------------------
+export async function getWorkorders(filters) {
+    const all = await loadCached('workorders', () => _getWorkorders());
+    return applyWorkorderFilters(all, filters);
+}
+export async function getWorkordersDropdown(filters) {
+    const results = await getWorkorders({ isActive: true, ...filters });
+    return results.map((w) => ({ value: w.id, label: w.description ?? w.id }));
+}
+/** Single workorder by ID — always fetches fresh (no IndexedDB). */
+export async function getWorkorder(id) {
+    return _getWorkorder(id);
+}
+// ---------------------------------------------------------------------------
+// Public API — Cost Codes
+// ---------------------------------------------------------------------------
+export async function getCostcodes(filters) {
+    const all = await loadCached('costcodes', () => _getCostcodes());
+    return applyCostcodeFilters(all, filters);
+}
+export async function getCostcodesDropdown(filters) {
+    const mergedFilters = { isActive: true, entryFlag: true, ...filters };
+    const results = await getCostcodes(mergedFilters);
+    const now = new Date();
+    return results
+        .filter((c) => !c.expirationDate || new Date(c.expirationDate) >= now)
+        .map((c) => ({
+        value: c.id,
+        label: `${c.jdeCostCode ?? c.id} - ${c.description ?? ''}`,
+    }));
+}
+/** Single cost code by ID — always fetches fresh (no IndexedDB). */
+export async function getCostcode(id) {
+    return _getCostcode(id);
+}
+// ---------------------------------------------------------------------------
+// Public API — Pay Types
+// ---------------------------------------------------------------------------
+export async function getPaytypes(filters) {
+    const all = await loadCached('paytypes', () => _getPaytypes());
+    return applyPaytypeFilters(all, filters);
+}
+export async function getPaytypesDropdown(filters) {
+    const results = await getPaytypes(filters);
+    return results.map((p) => ({ value: p.id, label: p.description, payClass: p.payClass }));
+}
+/** Single pay type by ID — always fetches fresh (no IndexedDB). */
+export async function getPaytype(id) {
+    return _getPaytype(id);
+}
+// ---------------------------------------------------------------------------
+// Public API — Business Units
+// ---------------------------------------------------------------------------
+export async function getBusinessUnits(filters) {
+    const all = await loadCached('businessUnits', () => _getBusinessUnits());
+    return applyBusinessUnitFilters(all, filters);
+}
+export async function getBusinessUnitsDropdown(filters) {
+    const results = await getBusinessUnits(filters);
+    return results.map((b) => ({ value: b.id, label: b.description }));
+}
+/** Single business unit by ID — always fetches fresh (no IndexedDB). */
+export async function getBusinessUnit(id) {
+    return _getBusinessUnit(id);
+}
+// ---------------------------------------------------------------------------
+// Public API — Job Type / Job Steps
+// ---------------------------------------------------------------------------
+export async function getJobtypejobsteps(filters) {
+    const all = await loadCached('jobtypejobsteps', () => _getJobtypejobsteps());
+    return applyJobtypejobstepFilters(all, filters);
+}
+export async function getJobtypejobstepsDropdown(filters) {
+    const results = await getJobtypejobsteps(filters);
+    return results.map((j) => ({
+        value: j.id,
+        label: j.description ?? `${j.jobType ?? ''} ${j.jobStep ?? ''}`.trim(),
+    }));
+}
+/** Single job type/job step by ID — always fetches fresh (no IndexedDB). */
+export async function getJobtypejobstep(id) {
+    return _getJobtypejobstep(id);
+}
+// ---------------------------------------------------------------------------
+// Cache management
+// ---------------------------------------------------------------------------
+/**
+ * Clear the IndexedDB cache for a specific entity, or all entities.
+ *
+ * Call after mutations to ensure the next read fetches fresh data from
+ * the server instead of returning stale cached results.
+ *
+ * @example
+ * await createWorkorder(data)
+ * clearCache('workorders')  // next getWorkorders() will re-fetch
+ *
+ * clearCache()  // clear everything
+ */
+export function clearCache(entity) {
+    idbClear(entity).catch(() => { });
+}

package/dist/costcodes.remote.d.ts

@@ -1,9 +1,3 @@
 export declare const getCostcodes: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").Costcode[]>;
 export declare const getCostcodesDropdown: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").DropdownOption[]>;
 export declare const getCostcode: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Costcode>;
-export declare const getCostcodesDropdownByBu: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").DropdownOption[]>;
-export declare const getCostcodesDropdownByBuAndPayType: import("@sveltejs/kit").RemoteQueryFunction<{
-    businessUnitId: string;
-    payTypeCode: string;
-}, import("./index.js").DropdownOption[]>;
-export declare const searchCostcodes: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Costcode[]>;

package/dist/costcodes.remote.js

@@ -1,13 +1,6 @@
 import { query } from '$app/server';
 import { z } from 'zod';
 import { getClient } from './client.js';
-const buPayTypeSchema = z.object({
-    businessUnitId: z.string(),
-    payTypeCode: z.string(),
-});
 export const getCostcodes = query(async () => getClient().getCostcodes());
 export const getCostcodesDropdown = query(async () => getClient().getCostcodesDropdown());
 export const getCostcode = query(z.string(), async (id) => getClient().getCostcode(id));
-export const getCostcodesDropdownByBu = query(z.string(), async (businessUnitId) => getClient().getCostcodesDropdownByBu(businessUnitId));
-export const getCostcodesDropdownByBuAndPayType = query(buPayTypeSchema, async ({ businessUnitId, payTypeCode }) => getClient().getCostcodesDropdownByBuAndPayType(businessUnitId, payTypeCode));
-export const searchCostcodes = query(z.string(), async (q) => getClient().searchCostcodes(q));

package/dist/employees.remote.d.ts

@@ -1,15 +1,12 @@
 export declare const getEmployees: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").Employee[]>;
 export declare const getEmployeesDropdown: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").DropdownOption[]>;
 export declare const getEmployee: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Employee>;
-export declare const searchByName: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Employee[]>;
-export declare const getBySupervisor: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Employee[]>;
-export declare const searchByEmail: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Employee[]>;
+export declare const getEmployeePrivileged: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").EmployeePrivileged>;
 export declare const getSupervisorChain: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Employee[]>;
 export declare const getJdeFromEmail: import("@sveltejs/kit").RemoteQueryFunction<string, {
     jde: string | null;
     employee: import("./index.js").Employee | null;
 }>;
-export declare const searchByHbu: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Employee[]>;
 export declare const verifyIdentity: import("@sveltejs/kit").RemoteCommand<{
     first3FirstName: string;
     first3LastName: string;

package/dist/employees.remote.js

@@ -11,10 +11,7 @@ const verifyIdentitySchema = z.object({
 export const getEmployees = query(async () => getClient().getEmployees());
 export const getEmployeesDropdown = query(async () => getClient().getEmployeesDropdown());
 export const getEmployee = query(employeeIdSchema, async (employeeId) => getClient().getEmployee(employeeId));
-export const searchByName = query(z.string(), async (name) => getClient().searchByName(name));
-export const getBySupervisor = query(employeeIdSchema, async (supervisorId) => getClient().getBySupervisor(supervisorId));
-export const searchByEmail = query(z.string(), async (email) => getClient().searchByEmail(email));
+export const getEmployeePrivileged = query(employeeIdSchema, async (employeeId) => getClient().getEmployeePrivileged(employeeId));
 export const getSupervisorChain = query(employeeIdSchema, async (employeeId) => getClient().getSupervisorChain(employeeId));
 export const getJdeFromEmail = query(z.string(), async (email) => getClient().getJdeFromEmail(email));
-export const searchByHbu = query(z.string(), async (hbu) => getClient().searchByHbu(hbu));
 export const verifyIdentity = command(verifyIdentitySchema, async (inputs) => getClient().verifyIdentity(inputs));

package/dist/idb.d.ts

@@ -0,0 +1,13 @@
+declare const STORES: readonly ["workorders", "employees", "costcodes", "paytypes", "businessUnits", "jobtypejobsteps"];
+export type IdbStore = (typeof STORES)[number];
+interface IdbEntry<T> {
+    data: T;
+    fetchedAt: number;
+}
+/** Get a cached entry. Returns null in SSR (no window) or on cache miss. */
+export declare function idbGet<T>(store: IdbStore, key: string): Promise<IdbEntry<T> | null>;
+/** Store a value with the current timestamp. */
+export declare function idbSet<T>(store: IdbStore, key: string, data: T): Promise<void>;
+/** Clear a specific store, or all stores when called with no argument. */
+export declare function idbClear(store?: IdbStore): Promise<void>;
+export {};

package/dist/idb.js

@@ -0,0 +1,79 @@
+const DB_NAME = 'apihub-cache';
+const DB_VERSION = 1;
+const STORES = [
+    'workorders',
+    'employees',
+    'costcodes',
+    'paytypes',
+    'businessUnits',
+    'jobtypejobsteps',
+];
+function openDb() {
+    return new Promise((resolve, reject) => {
+        const req = indexedDB.open(DB_NAME, DB_VERSION);
+        req.onupgradeneeded = () => {
+            const db = req.result;
+            for (const store of STORES) {
+                if (!db.objectStoreNames.contains(store)) {
+                    db.createObjectStore(store);
+                }
+            }
+        };
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+    });
+}
+/** Get a cached entry. Returns null in SSR (no window) or on cache miss. */
+export async function idbGet(store, key) {
+    if (typeof window === 'undefined')
+        return null;
+    try {
+        const db = await openDb();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(store, 'readonly');
+            const req = tx.objectStore(store).get(key);
+            req.onsuccess = () => resolve(req.result ?? null);
+            req.onerror = () => reject(req.error);
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/** Store a value with the current timestamp. */
+export async function idbSet(store, key, data) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        const db = await openDb();
+        await new Promise((resolve, reject) => {
+            const tx = db.transaction(store, 'readwrite');
+            const req = tx.objectStore(store).put({ data, fetchedAt: Date.now() }, key);
+            req.onsuccess = () => resolve();
+            req.onerror = () => reject(req.error);
+        });
+    }
+    catch {
+        // Ignore write failures — cache is best-effort
+    }
+}
+/** Clear a specific store, or all stores when called with no argument. */
+export async function idbClear(store) {
+    if (typeof window === 'undefined')
+        return;
+    try {
+        const db = await openDb();
+        const storeNames = store ? [store] : [...STORES];
+        await new Promise((resolve, reject) => {
+            const tx = db.transaction(storeNames, 'readwrite');
+            for (const s of storeNames) {
+                tx.objectStore(s).clear();
+            }
+            tx.oncomplete = () => resolve();
+            tx.onerror = () => reject(tx.error);
+        });
+    }
+    catch {
+        // Ignore failures
+    }
+}

package/dist/index.d.ts

@@ -24,8 +24,6 @@ export interface Employee {
     jobDescription: string | null;
     workSchedule: string | null;
     shift: string | null;
-    hourlyRate: string | null;
-    annualSalary: string | null;
     termDate: string | null;
     hireDate: string | null;
     topFlexPtoDate: string | null;
@@ -50,6 +48,10 @@ export interface Employee {
     updatedAtJulian: number | null;
     updatedAt: string | null;
 }
+export interface EmployeePrivileged extends Employee {
+    hourlyRate: string | null;
+    annualSalary: string | null;
+}
 export interface ApiHubClientOptions {
     baseUrl: string;
     apiKey: string;
@@ -218,6 +220,8 @@ export declare class ApiHubClient {
     getEmployeesDropdown(): Promise<DropdownOption[]>;
     /** Get a single employee by employeeId */
     getEmployee(employeeId: string): Promise<Employee>;
+    /** Get a single employee with compensation fields by employeeId */
+    getEmployeePrivileged(employeeId: string): Promise<EmployeePrivileged>;
     /** Search employees by name (case-insensitive partial match) */
     searchByName(name: string): Promise<Employee[]>;
     /** Get all employees reporting to a supervisor */

package/dist/index.js

@@ -61,6 +61,10 @@ export class ApiHubClient {
     async getEmployee(employeeId) {
         return this.request(`/employees/${encodeURIComponent(employeeId)}`);
     }
+    /** Get a single employee with compensation fields by employeeId */
+    async getEmployeePrivileged(employeeId) {
+        return this.request(`/employees/privileged/${encodeURIComponent(employeeId)}`);
+    }
     /** Search employees by name (case-insensitive partial match) */
     async searchByName(name) {
         return this.request(`/employees/search?name=${encodeURIComponent(name)}`);

package/dist/paytypes.remote.d.ts

@@ -1,4 +1,3 @@
 export declare const getPaytypes: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").Paytype[]>;
 export declare const getPaytypesDropdown: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").PaytypeDropdownOption[]>;
 export declare const getPaytype: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Paytype>;
-export declare const searchPaytypes: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Paytype[]>;

package/dist/paytypes.remote.js

@@ -4,4 +4,3 @@ import { getClient } from './client.js';
 export const getPaytypes = query(async () => getClient().getPaytypes());
 export const getPaytypesDropdown = query(async () => getClient().getPaytypesDropdown());
 export const getPaytype = query(z.string(), async (id) => getClient().getPaytype(id));
-export const searchPaytypes = query(z.string(), async (q) => getClient().searchPaytypes(q));

package/dist/workorders.remote.d.ts

@@ -1,5 +1,3 @@
 export declare const getWorkorders: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").Workorder[]>;
 export declare const getWorkordersDropdown: import("@sveltejs/kit").RemoteQueryFunction<void, import("./index.js").DropdownOption[]>;
-export declare const getWorkordersDropdownByBu: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").DropdownOption[]>;
 export declare const getWorkorder: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Workorder>;
-export declare const searchWorkorders: import("@sveltejs/kit").RemoteQueryFunction<string, import("./index.js").Workorder[]>;

package/dist/workorders.remote.js

@@ -3,6 +3,4 @@ import { z } from 'zod';
 import { getClient } from './client.js';
 export const getWorkorders = query(async () => getClient().getWorkorders());
 export const getWorkordersDropdown = query(async () => getClient().getWorkordersDropdown());
-export const getWorkordersDropdownByBu = query(z.string(), async (businessUnitId) => getClient().getWorkordersDropdownByBu(businessUnitId));
 export const getWorkorder = query(z.string(), async (id) => getClient().getWorkorder(id));
-export const searchWorkorders = query(z.string(), async (q) => getClient().searchWorkorders(q));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@brownandroot/api",
-	"version": "1.1.0",
+	"version": "1.2.1",
 	"type": "module",
 	"repository": {
 		"type": "git",
@@ -14,6 +14,10 @@
 			"types": "./dist/index.d.ts",
 			"default": "./dist/index.js"
 		},
+		"./cache": {
+			"types": "./dist/cache.d.ts",
+			"default": "./dist/cache.js"
+		},
 		"./employees": {
 			"types": "./dist/employees.remote.d.ts",
 			"default": "./dist/employees.remote.js"