diff --git a/packages/db/src/query/builder/index.ts b/packages/db/src/query/builder/index.ts
index dcdfe6c0e..3a04550a5 100644
--- a/packages/db/src/query/builder/index.ts
+++ b/packages/db/src/query/builder/index.ts
@@ -42,6 +42,9 @@ import type {
   MergeContextWithJoinType,
   OrderByCallback,
   OrderByOptions,
+  QueryRefsForContext,
+  QuerySchemaFromSource,
+  QueryWhereCallback,
   RefsForContext,
   ResultTypeFromSelect,
   SchemaFromSource,
@@ -138,6 +141,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
   ): QueryBuilder<{
     baseSchema: SchemaFromSource<TSource>
     schema: SchemaFromSource<TSource>
+    querySchema: QuerySchemaFromSource<TSource>
     fromSourceName: keyof TSource & string
     hasJoins: false
   }> {
@@ -182,11 +186,20 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
   >(
     source: TSource,
     onCallback: JoinOnCallback<
-      MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
+      MergeContextForJoinCallback<
+        TContext,
+        SchemaFromSource<TSource>,
+        QuerySchemaFromSource<TSource>
+      >
     >,
     type: TJoinType = `left` as TJoinType,
   ): QueryBuilder<
-    MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, TJoinType>
+    MergeContextWithJoinType<
+      TContext,
+      SchemaFromSource<TSource>,
+      TJoinType,
+      QuerySchemaFromSource<TSource>
+    >
   > {
     const [alias, from] = this._createRefForSource(source, `join clause`)
 
@@ -194,7 +207,11 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
     const currentAliases = this._getCurrentAliases()
     const newAliases = [...currentAliases, alias]
     const refProxy = createRefProxy(newAliases) as RefsForContext<
-      MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
+      MergeContextForJoinCallback<
+        TContext,
+        SchemaFromSource<TSource>,
+        QuerySchemaFromSource<TSource>
+      >
     >
 
     // Get the join condition expression
@@ -249,10 +266,19 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
   leftJoin<TSource extends Source>(
     source: TSource,
     onCallback: JoinOnCallback<
-      MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
+      MergeContextForJoinCallback<
+        TContext,
+        SchemaFromSource<TSource>,
+        QuerySchemaFromSource<TSource>
+      >
     >,
   ): QueryBuilder<
-    MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `left`>
+    MergeContextWithJoinType<
+      TContext,
+      SchemaFromSource<TSource>,
+      `left`,
+      QuerySchemaFromSource<TSource>
+    >
   > {
     return this.join(source, onCallback, `left`)
   }
@@ -275,10 +301,19 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
   rightJoin<TSource extends Source>(
     source: TSource,
     onCallback: JoinOnCallback<
-      MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
+      MergeContextForJoinCallback<
+        TContext,
+        SchemaFromSource<TSource>,
+        QuerySchemaFromSource<TSource>
+      >
     >,
   ): QueryBuilder<
-    MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `right`>
+    MergeContextWithJoinType<
+      TContext,
+      SchemaFromSource<TSource>,
+      `right`,
+      QuerySchemaFromSource<TSource>
+    >
   > {
     return this.join(source, onCallback, `right`)
   }
@@ -301,10 +336,19 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
   innerJoin<TSource extends Source>(
     source: TSource,
     onCallback: JoinOnCallback<
-      MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
+      MergeContextForJoinCallback<
+        TContext,
+        SchemaFromSource<TSource>,
+        QuerySchemaFromSource<TSource>
+      >
     >,
   ): QueryBuilder<
-    MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `inner`>
+    MergeContextWithJoinType<
+      TContext,
+      SchemaFromSource<TSource>,
+      `inner`,
+      QuerySchemaFromSource<TSource>
+    >
   > {
     return this.join(source, onCallback, `inner`)
   }
@@ -327,10 +371,19 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
   fullJoin<TSource extends Source>(
     source: TSource,
     onCallback: JoinOnCallback<
-      MergeContextForJoinCallback<TContext, SchemaFromSource<TSource>>
+      MergeContextForJoinCallback<
+        TContext,
+        SchemaFromSource<TSource>,
+        QuerySchemaFromSource<TSource>
+      >
     >,
   ): QueryBuilder<
-    MergeContextWithJoinType<TContext, SchemaFromSource<TSource>, `full`>
+    MergeContextWithJoinType<
+      TContext,
+      SchemaFromSource<TSource>,
+      `full`,
+      QuerySchemaFromSource<TSource>
+    >
   > {
     return this.join(source, onCallback, `full`)
   }
@@ -363,9 +416,9 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
    *   .where(({users}) => eq(users.active, true))
    * ```
    */
-  where(callback: WhereCallback<TContext>): QueryBuilder<TContext> {
+  where(callback: QueryWhereCallback<TContext>): QueryBuilder<TContext> {
     const aliases = this._getCurrentAliases()
-    const refProxy = createRefProxy(aliases) as RefsForContext<TContext>
+    const refProxy = createRefProxy(aliases) as QueryRefsForContext<TContext>
     const expression = callback(refProxy)
 
     // Validate that the callback returned a valid expression
@@ -691,7 +744,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
       // TODO: enforcing return only one result with also a default orderBy if none is specified
       // limit: 1,
       singleResult: true,
-    })
+    }) as any
   }
 
   // Helper methods
@@ -754,7 +807,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
           ...builder.query,
           select: undefined, // remove the select clause if it exists
           fnSelect: callback,
-        })
+        }) as any
       },
       /**
        * Filter rows using a function that operates on each row
@@ -780,7 +833,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
             ...(builder.query.fnWhere || []),
             callback as (row: NamespacedRow) => any,
           ],
-        })
+        }) as any
       },
       /**
        * Filter grouped rows using a function that operates on each aggregated row
@@ -808,7 +861,7 @@ export class BaseQueryBuilder<TContext extends Context = Context> {
             ...(builder.query.fnHaving || []),
             callback as (row: NamespacedRow) => any,
           ],
-        })
+        }) as any
       },
     }
   }
diff --git a/packages/db/src/query/builder/types.ts b/packages/db/src/query/builder/types.ts
index 11360dd82..a47e8e865 100644
--- a/packages/db/src/query/builder/types.ts
+++ b/packages/db/src/query/builder/types.ts
@@ -37,6 +37,9 @@ export interface Context {
   baseSchema: ContextSchema
   // The current schema available (includes joined collections)
   schema: ContextSchema
+  // Optional schema used for query refs in where/orderBy callbacks.
+  // When omitted, refs default to the main `schema`.
+  querySchema?: ContextSchema
   // the name of the source that was used in the from clause
   fromSourceName: string
   // Whether this query has joins
@@ -85,6 +88,21 @@ export type Source = {
 export type InferCollectionType<T> =
   T extends CollectionImpl<infer TOutput, any, any, any, any> ? TOutput : never
 
+declare const QuerySchemaBrand: unique symbol
+
+export type CollectionWithQuerySchema<
+  TCollection extends CollectionImpl<any, any, any, any, any>,
+  TQuerySchema extends object,
+> = TCollection & {
+  readonly [QuerySchemaBrand]: TQuerySchema
+}
+
+type InferCollectionQuerySchema<T> = T extends {
+  readonly [QuerySchemaBrand]: infer TQuerySchema
+}
+  ? TQuerySchema
+  : InferCollectionType<T>
+
 /**
  * SchemaFromSource - Converts a Source definition into a ContextSchema
  *
@@ -103,6 +121,14 @@ export type SchemaFromSource<T extends Source> = Prettify<{
       : never
 }>
 
+export type QuerySchemaFromSource<T extends Source> = Prettify<{
+  [K in keyof T]: T[K] extends CollectionImpl<any, any, any, any, any>
+    ? InferCollectionQuerySchema<T[K]>
+    : T[K] extends QueryBuilder<infer TContext>
+      ? GetQueryResult<TContext>
+      : never
+}>
+
 /**
  * GetAliases - Extracts all table aliases available in a query context
  *
@@ -111,6 +137,11 @@ export type SchemaFromSource<T extends Source> = Prettify<{
  */
 export type GetAliases<TContext extends Context> = keyof TContext[`schema`]
 
+type ResolveQuerySchema<TContext extends Context> =
+  TContext[`querySchema`] extends ContextSchema
+    ? TContext[`querySchema`]
+    : TContext[`schema`]
+
 /**
  * WhereCallback - Type for where/having clause callback functions
  *
@@ -124,6 +155,10 @@ export type WhereCallback<TContext extends Context> = (
   refs: RefsForContext<TContext>,
 ) => any
 
+export type QueryWhereCallback<TContext extends Context> = (
+  refs: QueryRefsForContext<TContext>,
+) => any
+
 /**
  * SelectValue - Union of all valid values in a select clause
  *
@@ -290,7 +325,7 @@ type NeedsExtraction<T> = T extends
  * Example: `(refs) => refs.users.createdAt`
  */
 export type OrderByCallback<TContext extends Context> = (
-  refs: RefsForContext<TContext>,
+  refs: QueryRefsForContext<TContext>,
 ) => any
 
 /**
@@ -388,27 +423,25 @@ export type FunctionalHavingRow<TContext extends Context> = TContext[`schema`] &
  * After `select()` is called, this type also includes `$selected` which provides access
  * to the SELECT result fields via `$selected.fieldName` syntax.
  */
-export type RefsForContext<TContext extends Context> = {
-  [K in keyof TContext[`schema`]]: IsNonExactOptional<
-    TContext[`schema`][K]
-  > extends true
-    ? IsNonExactNullable<TContext[`schema`][K]> extends true
-      ? // T is both non-exact optional and non-exact nullable (e.g., string | null | undefined)
-          // Extract the non-undefined and non-null part and place undefined outside
-          Ref<NonNullable<TContext[`schema`][K]>> | undefined
-      : // T is optional (T | undefined) but not exactly undefined, and not nullable
-          // Extract the non-undefined part and place undefined outside
-          Ref<NonUndefined<TContext[`schema`][K]>> | undefined
-    : IsNonExactNullable<TContext[`schema`][K]> extends true
-      ? // T is nullable (T | null) but not exactly null, and not optional
-        // Extract the non-null part and place null outside
-        Ref<NonNull<TContext[`schema`][K]>> | null
-      : // T is exactly undefined, exactly null, or neither optional nor nullable
-        // Wrap in RefProxy as-is (includes exact undefined, exact null, and normal types)
-        Ref<TContext[`schema`][K]>
-} & (TContext[`result`] extends object
-  ? { $selected: Ref<TContext[`result`]> }
-  : {})
+type RefsForSchema<TSchema extends ContextSchema, TResult> = {
+  [K in keyof TSchema]: IsNonExactOptional<TSchema[K]> extends true
+    ? IsNonExactNullable<TSchema[K]> extends true
+      ? Ref<NonNullable<TSchema[K]>> | undefined
+      : Ref<NonUndefined<TSchema[K]>> | undefined
+    : IsNonExactNullable<TSchema[K]> extends true
+      ? Ref<NonNull<TSchema[K]>> | null
+      : Ref<TSchema[K]>
+} & (TResult extends object ? { $selected: Ref<TResult> } : {})
+
+export type RefsForContext<TContext extends Context> = RefsForSchema<
+  TContext[`schema`],
+  TContext[`result`]
+>
+
+export type QueryRefsForContext<TContext extends Context> = RefsForSchema<
+  ResolveQuerySchema<TContext>,
+  TContext[`result`]
+>
 
 /**
  * Type Detection Helpers
@@ -574,6 +607,7 @@ export type MergeContextWithJoinType<
   TContext extends Context,
   TNewSchema extends ContextSchema,
   TJoinType extends `inner` | `left` | `right` | `full` | `outer` | `cross`,
+  TNewQuerySchema extends ContextSchema = TNewSchema,
 > = {
   baseSchema: TContext[`baseSchema`]
   // Apply optionality immediately to the schema
@@ -583,6 +617,12 @@ export type MergeContextWithJoinType<
     TJoinType,
     TContext[`fromSourceName`]
   >
+  querySchema: ApplyJoinOptionalityToMergedSchema<
+    ResolveQuerySchema<TContext>,
+    TNewQuerySchema,
+    TJoinType,
+    TContext[`fromSourceName`]
+  >
   fromSourceName: TContext[`fromSourceName`]
   hasJoins: true
   // Track join types for reference
@@ -685,6 +725,14 @@ export type GetResult<TContext extends Context> = Prettify<
         TContext[`schema`][TContext[`fromSourceName`]]
 >
 
+export type GetQueryResult<TContext extends Context> = Prettify<
+  TContext[`result`] extends object
+    ? TContext[`result`]
+    : TContext[`hasJoins`] extends true
+      ? ResolveQuerySchema<TContext>
+      : ResolveQuerySchema<TContext>[TContext[`fromSourceName`]]
+>
+
 /**
  * ApplyJoinOptionalityToSchema - Legacy helper for complex join scenarios
  *
@@ -807,10 +855,12 @@ export type HasJoinType<
 export type MergeContextForJoinCallback<
   TContext extends Context,
   TNewSchema extends ContextSchema,
+  TNewQuerySchema extends ContextSchema = TNewSchema,
 > = {
   baseSchema: TContext[`baseSchema`]
   // Merge schemas without applying join optionality - both are non-optional in join condition
   schema: TContext[`schema`] & TNewSchema
+  querySchema: ResolveQuerySchema<TContext> & TNewQuerySchema
   fromSourceName: TContext[`fromSourceName`]
   hasJoins: true
   joinTypes: TContext[`joinTypes`] extends Record<string, any>
diff --git a/packages/db/src/query/index.ts b/packages/db/src/query/index.ts
index 524b4dcf1..b7bf4782f 100644
--- a/packages/db/src/query/index.ts
+++ b/packages/db/src/query/index.ts
@@ -57,8 +57,8 @@ export {
   liveQueryCollectionOptions,
 } from './live-query-collection.js'
 
-export { type LiveQueryCollectionConfig } from './live/types.js'
-export { type LiveQueryCollectionUtils } from './live/collection-config-builder.js'
+export type { LiveQueryCollectionConfig } from './live/types.js'
+export type { LiveQueryCollectionUtils } from './live/collection-config-builder.js'
 
 // Predicate utilities for predicate push-down
 export {
@@ -72,3 +72,8 @@ export {
 } from './predicate-utils.js'
 
 export { DeduplicatedLoadSubset } from './subset-dedupe.js'
+
+export {
+  withQueryableFields,
+  type QueryableFieldsConfig,
+} from './queryable-fields.js'
diff --git a/packages/db/src/query/live-query-collection.ts b/packages/db/src/query/live-query-collection.ts
index 47eceac15..2db73e83b 100644
--- a/packages/db/src/query/live-query-collection.ts
+++ b/packages/db/src/query/live-query-collection.ts
@@ -7,7 +7,7 @@ import {
 import type { LiveQueryCollectionUtils } from './live/collection-config-builder.js'
 import type { LiveQueryCollectionConfig } from './live/types.js'
 import type { InitialQueryBuilder, QueryBuilder } from './builder/index.js'
-import type { Collection } from '../collection/index.js'
+import type { Collection, CollectionImpl } from '../collection/index.js'
 import type {
   CollectionConfig,
   CollectionConfigSingleRowOption,
@@ -15,7 +15,14 @@ import type {
   SingleResult,
   UtilsRecord,
 } from '../types.js'
-import type { Context, GetResult } from './builder/types.js'
+import type {
+  Context,
+  GetQueryResult,
+  GetResult,
+  InferCollectionType,
+  SchemaFromSource,
+  Source,
+} from './builder/types.js'
 
 type CollectionConfigForContext<
   TContext extends Context,
@@ -35,6 +42,92 @@ type CollectionForContext<
   ? Collection<TResult, string | number, TUtils> & SingleResult
   : Collection<TResult, string | number, TUtils> & NonSingleResult
 
+type QueryableFieldList = ReadonlyArray<string>
+
+type KeysFromList<TKeys> =
+  TKeys extends ReadonlyArray<infer TKey> ? TKey : never
+
+type ResolveQueryableSchema<
+  TDocument extends object,
+  TFilterable,
+  TSortable,
+> = [TFilterable] extends [undefined]
+  ? [TSortable] extends [undefined]
+    ? TDocument
+    : Pick<
+        TDocument,
+        Extract<
+          KeysFromList<TFilterable> | KeysFromList<TSortable>,
+          keyof TDocument
+        >
+      >
+  : Pick<
+      TDocument,
+      Extract<
+        KeysFromList<TFilterable> | KeysFromList<TSortable>,
+        keyof TDocument
+      >
+    >
+
+type QuerySchemaFromSourceWithQueryable<
+  TSource extends Source,
+  TFilterable extends QueryableFieldList | undefined,
+  TSortable extends QueryableFieldList | undefined,
+> = {
+  [K in keyof TSource]: TSource[K] extends CollectionImpl<
+    infer _TOutput,
+    infer _TKey,
+    infer _TUtils,
+    infer _TSchema,
+    infer _TInput
+  >
+    ? ResolveQueryableSchema<
+        InferCollectionType<TSource[K]>,
+        TFilterable,
+        TSortable
+      >
+    : TSource[K] extends QueryBuilder<infer TContext>
+      ? GetQueryResult<TContext>
+      : never
+}
+
+type InitialQueryBuilderWithQueryable<
+  TFilterable extends QueryableFieldList | undefined,
+  TSortable extends QueryableFieldList | undefined,
+> = {
+  from: <TSource extends Source>(
+    source: TSource,
+  ) => QueryBuilder<{
+    baseSchema: SchemaFromSource<TSource>
+    schema: SchemaFromSource<TSource>
+    querySchema: QuerySchemaFromSourceWithQueryable<
+      TSource,
+      TFilterable,
+      TSortable
+    >
+    fromSourceName: keyof TSource & string
+    hasJoins: false
+  }>
+}
+
+type LiveQueryCollectionConfigWithQueryable<
+  TContext extends Context,
+  TResult extends object,
+  TFilterable extends QueryableFieldList | undefined,
+  TSortable extends QueryableFieldList | undefined,
+> = Omit<
+  LiveQueryCollectionConfig<TContext, TResult>,
+  `query` | `queryable`
+> & {
+  query: (
+    q: InitialQueryBuilderWithQueryable<TFilterable, TSortable>,
+  ) => QueryBuilder<TContext>
+  queryable: {
+    filterable?: TFilterable
+    sortable?: TSortable
+  }
+}
+
 /**
  * Creates live query collection options for use with createCollection
  *
@@ -59,6 +152,22 @@ type CollectionForContext<
  * @param config - Configuration options for the live query collection
  * @returns Collection options that can be passed to createCollection
  */
+export function liveQueryCollectionOptions<
+  TContext extends Context,
+  TResult extends object = GetResult<TContext>,
+  TFilterable extends QueryableFieldList | undefined = undefined,
+  TSortable extends QueryableFieldList | undefined = undefined,
+>(
+  config: LiveQueryCollectionConfigWithQueryable<
+    TContext,
+    TResult,
+    TFilterable,
+    TSortable
+  >,
+): CollectionConfigForContext<TContext, TResult> & {
+  utils: LiveQueryCollectionUtils
+}
+
 export function liveQueryCollectionOptions<
   TContext extends Context,
   TResult extends object = GetResult<TContext>,
@@ -66,11 +175,31 @@ export function liveQueryCollectionOptions<
   config: LiveQueryCollectionConfig<TContext, TResult>,
 ): CollectionConfigForContext<TContext, TResult> & {
   utils: LiveQueryCollectionUtils
+}
+
+export function liveQueryCollectionOptions<
+  TContext extends Context,
+  TResult extends object = GetResult<TContext>,
+>(
+  config:
+    | LiveQueryCollectionConfig<TContext, TResult>
+    | LiveQueryCollectionConfigWithQueryable<
+        TContext,
+        TResult,
+        QueryableFieldList | undefined,
+        QueryableFieldList | undefined
+      >,
+): CollectionConfigForContext<TContext, TResult> & {
+  utils: LiveQueryCollectionUtils
 } {
+  const normalizedConfig = config as unknown as LiveQueryCollectionConfig<
+    TContext,
+    TResult
+  >
   const collectionConfigBuilder = new CollectionConfigBuilder<
     TContext,
     TResult
-  >(config)
+  >(normalizedConfig)
   return collectionConfigBuilder.getConfig() as CollectionConfigForContext<
     TContext,
     TResult
@@ -108,6 +237,18 @@ export function liveQueryCollectionOptions<
  *     }
  *   }
  * })
+ *
+ * // Optional: constrain queryable refs at compile-time
+ * const constrained = createLiveQueryCollection({
+ *   queryable: {
+ *     filterable: ['id', 'status'] as const,
+ *     sortable: ['created_at'] as const,
+ *   },
+ *   query: (q) =>
+ *     q
+ *       .from({ post: postsCollection })
+ *       .where(({ post }) => eq(post.status, 'published'))
+ * })
  * ```
  */
 
@@ -122,6 +263,24 @@ export function createLiveQueryCollection<
 }
 
 // Overload 2: Accept full config object with optional utilities
+export function createLiveQueryCollection<
+  TContext extends Context,
+  TResult extends object = GetResult<TContext>,
+  TUtils extends UtilsRecord = {},
+  TFilterable extends QueryableFieldList | undefined = undefined,
+  TSortable extends QueryableFieldList | undefined = undefined,
+>(
+  config: LiveQueryCollectionConfigWithQueryable<
+    TContext,
+    TResult,
+    TFilterable,
+    TSortable
+  > & { utils?: TUtils },
+): CollectionForContext<TContext, TResult> & {
+  utils: LiveQueryCollectionUtils & TUtils
+}
+
+// Overload 3: Accept full config object with optional utilities
 export function createLiveQueryCollection<
   TContext extends Context,
   TResult extends object = GetResult<TContext>,
@@ -140,6 +299,12 @@ export function createLiveQueryCollection<
 >(
   configOrQuery:
     | (LiveQueryCollectionConfig<TContext, TResult> & { utils?: TUtils })
+    | (LiveQueryCollectionConfigWithQueryable<
+        TContext,
+        TResult,
+        QueryableFieldList | undefined,
+        QueryableFieldList | undefined
+      > & { utils?: TUtils })
     | ((q: InitialQueryBuilder) => QueryBuilder<TContext>),
 ): CollectionForContext<TContext, TResult> & {
   utils: LiveQueryCollectionUtils & TUtils
diff --git a/packages/db/src/query/live/types.ts b/packages/db/src/query/live/types.ts
index 04d0b389f..fa93fdf48 100644
--- a/packages/db/src/query/live/types.ts
+++ b/packages/db/src/query/live/types.ts
@@ -69,6 +69,15 @@ export interface LiveQueryCollectionConfig<
     | ((q: InitialQueryBuilder) => QueryBuilder<TContext>)
     | QueryBuilder<TContext>
 
+  /**
+   * Optional compile-time queryability hints for constrained `where`/`orderBy` refs.
+   * Runtime behavior is unchanged.
+   */
+  queryable?: {
+    filterable?: ReadonlyArray<string>
+    sortable?: ReadonlyArray<string>
+  }
+
   /**
    * Function to extract the key from result items
    * If not provided, defaults to using the key from the D2 stream
diff --git a/packages/db/src/query/queryable-fields.ts b/packages/db/src/query/queryable-fields.ts
new file mode 100644
index 000000000..889caf1e0
--- /dev/null
+++ b/packages/db/src/query/queryable-fields.ts
@@ -0,0 +1,81 @@
+import type { CollectionImpl } from '../collection/index.js'
+import type {
+  CollectionWithQuerySchema,
+  InferCollectionType,
+} from './builder/types.js'
+
+type QueryableField<TDocument extends object> = Extract<keyof TDocument, string>
+
+type QueryableFieldList<TDocument extends object> = ReadonlyArray<
+  QueryableField<TDocument>
+>
+
+type KeysFromList<TKeys> =
+  TKeys extends ReadonlyArray<infer TKey> ? TKey : never
+
+type ResolveQueryableKeys<
+  TDocument extends object,
+  TFilterable,
+  TSortable,
+> = Extract<
+  KeysFromList<TFilterable> | KeysFromList<TSortable>,
+  QueryableField<TDocument>
+>
+
+type ResolveQueryableSchema<
+  TDocument extends object,
+  TFilterable,
+  TSortable,
+> = [TFilterable] extends [undefined]
+  ? [TSortable] extends [undefined]
+    ? TDocument
+    : Pick<TDocument, ResolveQueryableKeys<TDocument, TFilterable, TSortable>>
+  : Pick<TDocument, ResolveQueryableKeys<TDocument, TFilterable, TSortable>>
+
+export type QueryableFieldsConfig<
+  TDocument extends object,
+  TFilterable extends QueryableFieldList<TDocument> | undefined = undefined,
+  TSortable extends QueryableFieldList<TDocument> | undefined = undefined,
+> = {
+  filterable?: TFilterable
+  sortable?: TSortable
+}
+
+/**
+ * Adds compile-time queryable field constraints to a collection source.
+ *
+ * Runtime behavior is unchanged. This only affects the refs available in
+ * query callbacks like `where` and `orderBy`.
+ */
+export function withQueryableFields<
+  TCollection extends CollectionImpl<any, any, any, any, any>,
+  TFilterable extends
+    | QueryableFieldList<InferCollectionType<TCollection>>
+    | undefined = undefined,
+  TSortable extends
+    | QueryableFieldList<InferCollectionType<TCollection>>
+    | undefined = undefined,
+>(
+  collection: TCollection,
+  _queryable: QueryableFieldsConfig<
+    InferCollectionType<TCollection>,
+    TFilterable,
+    TSortable
+  >,
+): CollectionWithQuerySchema<
+  TCollection,
+  ResolveQueryableSchema<
+    InferCollectionType<TCollection>,
+    TFilterable,
+    TSortable
+  >
+> {
+  return collection as CollectionWithQuerySchema<
+    TCollection,
+    ResolveQueryableSchema<
+      InferCollectionType<TCollection>,
+      TFilterable,
+      TSortable
+    >
+  >
+}
diff --git a/packages/db/tests/query/queryable-fields.test-d.ts b/packages/db/tests/query/queryable-fields.test-d.ts
new file mode 100644
index 000000000..0568fb70c
--- /dev/null
+++ b/packages/db/tests/query/queryable-fields.test-d.ts
@@ -0,0 +1,214 @@
+import { describe, expectTypeOf, test } from 'vitest'
+import { createCollection } from '../../src/collection/index.js'
+import {
+  Query,
+  createLiveQueryCollection,
+  eq,
+  withQueryableFields,
+} from '../../src/query/index.js'
+import { mockSyncCollectionOptions } from '../utils.js'
+
+type JobEngagementDocument = {
+  _id: string
+  status: `ACTIVE` | `INACTIVE`
+  user_id: string
+  employer_id: string
+  created_at: string
+  updated_at: string
+  platform_fee_percent: number
+}
+
+function createEngagementsCollection() {
+  return createCollection(
+    mockSyncCollectionOptions<JobEngagementDocument>({
+      id: `test-engagements`,
+      getKey: (engagement) => engagement._id,
+      initialData: [],
+    }),
+  )
+}
+
+describe(`Queryable field constraints`, () => {
+  test(`supports queryable option on createLiveQueryCollection config`, () => {
+    const engagementsCollection = createEngagementsCollection()
+
+    const collection = createLiveQueryCollection({
+      queryable: {
+        filterable: [
+          `_id`,
+          `status`,
+          `user_id`,
+          `employer_id`,
+          `created_at`,
+          `updated_at`,
+        ] as const,
+        sortable: [`created_at`, `updated_at`, `status`] as const,
+      },
+      query: (q) =>
+        q
+          .from({ engagement: engagementsCollection })
+          .where(({ engagement }) => eq(engagement.status, `ACTIVE`))
+          .orderBy(({ engagement }) => engagement.updated_at, `desc`),
+    })
+
+    expectTypeOf(collection.toArray).toEqualTypeOf<
+      Array<JobEngagementDocument>
+    >()
+  })
+
+  test(`queryable option rejects disallowed fields at compile-time`, () => {
+    const engagementsCollection = createEngagementsCollection()
+
+    createLiveQueryCollection({
+      queryable: {
+        filterable: [
+          `_id`,
+          `status`,
+          `user_id`,
+          `employer_id`,
+          `created_at`,
+          `updated_at`,
+        ] as const,
+        sortable: [`created_at`, `updated_at`, `status`] as const,
+      },
+      query: (q) =>
+        q
+          .from({ engagement: engagementsCollection })
+          .where(({ engagement }) => {
+            // @ts-expect-error platform_fee_percent is not queryable
+            return eq(engagement.platform_fee_percent, 0.15)
+          }),
+    })
+  })
+
+  test(`empty queryable lists do not widen back to full document`, () => {
+    const engagementsCollection = createEngagementsCollection()
+
+    createLiveQueryCollection({
+      queryable: {
+        filterable: [] as const,
+        sortable: [] as const,
+      },
+      query: (q) =>
+        q
+          .from({ engagement: engagementsCollection })
+          .where(({ engagement }) => {
+            // @ts-expect-error no fields are queryable when both lists are empty
+            return eq(engagement.status, `ACTIVE`)
+          }),
+    })
+  })
+
+  test(`allows configured fields in where and orderBy`, () => {
+    const engagementsCollection = createEngagementsCollection()
+
+    const queryableEngagements = withQueryableFields(engagementsCollection, {
+      filterable: [
+        `_id`,
+        `status`,
+        `user_id`,
+        `employer_id`,
+        `created_at`,
+        `updated_at`,
+      ] as const,
+      sortable: [`created_at`, `updated_at`, `status`] as const,
+    })
+
+    const collection = createLiveQueryCollection({
+      query: (q) =>
+        q
+          .from({ engagement: queryableEngagements })
+          .where(({ engagement }) => eq(engagement.status, `ACTIVE`))
+          .orderBy(({ engagement }) => engagement.updated_at, `desc`),
+    })
+
+    expectTypeOf(collection.toArray).toEqualTypeOf<
+      Array<JobEngagementDocument>
+    >()
+  })
+
+  test(`rejects disallowed where fields at compile-time`, () => {
+    const engagementsCollection = createEngagementsCollection()
+
+    const queryableEngagements = withQueryableFields(engagementsCollection, {
+      filterable: [
+        `_id`,
+        `status`,
+        `user_id`,
+        `employer_id`,
+        `created_at`,
+        `updated_at`,
+      ] as const,
+      sortable: [`created_at`, `updated_at`, `status`] as const,
+    })
+
+    createLiveQueryCollection({
+      query: (q) =>
+        q.from({ engagement: queryableEngagements }).where(({ engagement }) => {
+          // @ts-expect-error platform_fee_percent is not queryable
+          return eq(engagement.platform_fee_percent, 0.15)
+        }),
+    })
+  })
+
+  test(`rejects disallowed orderBy fields at compile-time`, () => {
+    const engagementsCollection = createEngagementsCollection()
+
+    const queryableEngagements = withQueryableFields(engagementsCollection, {
+      filterable: [
+        `_id`,
+        `status`,
+        `user_id`,
+        `employer_id`,
+        `created_at`,
+        `updated_at`,
+      ] as const,
+      sortable: [`created_at`, `updated_at`, `status`] as const,
+    })
+
+    createLiveQueryCollection({
+      query: (q) =>
+        q
+          .from({ engagement: queryableEngagements })
+          .where(({ engagement }) => eq(engagement.status, `ACTIVE`))
+          .orderBy(({ engagement }) => {
+            // @ts-expect-error platform_fee_percent is not queryable
+            return engagement.platform_fee_percent
+          }),
+    })
+  })
+
+  test(`keeps restrictions across subquery refs while preserving output shape`, () => {
+    const engagementsCollection = createEngagementsCollection()
+
+    const queryableEngagements = withQueryableFields(engagementsCollection, {
+      filterable: [
+        `_id`,
+        `status`,
+        `user_id`,
+        `employer_id`,
+        `created_at`,
+        `updated_at`,
+      ] as const,
+      sortable: [`created_at`, `updated_at`, `status`] as const,
+    })
+
+    const subquery = new Query().from({ engagement: queryableEngagements })
+
+    createLiveQueryCollection({
+      query: (q) =>
+        q.from({ engagement: subquery }).where(({ engagement }) => {
+          // @ts-expect-error platform_fee_percent is not queryable via subquery refs
+          return eq(engagement.platform_fee_percent, 0.15)
+        }),
+    })
+
+    const resultCollection = createLiveQueryCollection({
+      query: (q) => q.from({ engagement: subquery }),
+    })
+
+    expectTypeOf(resultCollection.toArray).toEqualTypeOf<
+      Array<JobEngagementDocument>
+    >()
+  })
+})