@@ -121,13 +121,13 @@ export interface MetaobjectsGenConfig extends Omit<ResolvedGenConfig, "dbImport"
    * porting docs). This keeps the option a safe no-op on sqlite/D1 instead of
    * emitting a non-compiling column + a Zod schema disagreeing with it.
    *
-   * Date-mode filtering (`?filter[<timestamp>][gte]=...`) is not yet supported —
-   * `runtime-ts`'s filter parser keeps the qs value a string, which throws at
-   * request time against a Date-mode Drizzle column. Known limitation; not
-   * threaded through at runtime, but `runGen` DOES warn (once per run, naming
-   * every offending entity+field) when this mode meets a `@filterable`
-   * `field.timestamp` — see `runner.ts`'s Important-4 check. Track before
-   * recommending date mode for a filterable timestamp field.
+   * Date-mode filtering (`?filter[<timestamp>][gte]=...`) IS supported: a
+   * `@filterable` `field.timestamp` generated under this mode carries
+   * `dateValues: true` in its `FilterAllowlist` rule, and `runtime-ts`'s filter
+   * parser coerces the query-string value with `new Date(...)` rather than binding
+   * a string against a Date-typed column (a malformed value is rejected as
+   * `filter.invalid_value`). `field.date` / `field.time` are unaffected — Drizzle
+   * types both as strings under every dialect.
    */
   timestampMode?: "date" | "string";
   /** Path prefix applied to generated route registrations + hook fetch URLs. Defaults to "". */
 
@@ -100,7 +100,7 @@ function renderEntity(entity: MetaObject, ctx: RenderContext, opts?: RenderEntit
     ...(enumAliases !== null ? [enumAliases] : []),
     renderZodValidators(entity, ctx),
     renderEntityConstants(entity, ctx.apiPrefix),
-    ...(allowlists ? [renderFilterAllowlist(entity), renderSortAllowlist(entity)] : []),
+    ...(allowlists ? [renderFilterAllowlist(entity, undefined, ctx), renderSortAllowlist(entity)] : []),
     renderFilterType(entity),
     ...(tphBlock !== null ? [tphBlock] : []),
   ];
 
@@ -180,36 +180,11 @@ export async function runGen(opts: RunGenOpts): Promise<RunGenResult> {
   // 2. Resolve targets + entity-module target.
   const config = normalizeConfig(opts.config);
 
-  // Important-4 (post-#281 pre-publish review) — a @filterable timestamp field
-  // under timestampMode:"date" throws at REQUEST time in runtime-ts's filter
-  // parser (documented limitation; see drizzle-fastify/filter-parser.ts's
-  // "datetime" coerce case). Detect-and-WARN at generation time instead of
-  // leaving it a silent build-time no-signal (repo precedent: #226/#258
-  // detect-and-refuse an un-appliable migration at gen time rather than fail
-  // at apply). Reading config.timestampMode AFTER normalizeConfig means this is
-  // naturally silent on sqlite/D1 (normalized to "string" there) and in the
-  // default "string" mode — no dialect/mode branching needed here. One warning
-  // for the whole run, naming every offending entity+field, not one per field.
-  if (config.timestampMode === "date") {
-    const offenders = safeEntities
-      .filter((e) => !e.isAbstract)
-      .map((e) => ({
-        entity: e.name,
-        fields: e.fields()
-          .filter((f) => f.subType === FIELD_SUBTYPE_TIMESTAMP && f.attr(FIELD_ATTR_FILTERABLE) === true)
-          .map((f) => f.name),
-      }))
-      .filter((o) => o.fields.length > 0);
-    if (offenders.length > 0) {
-      const named = offenders.map((o) => `${o.entity}.${o.fields.join(",")}`).join("; ");
-      warnings.push(
-        `timestampMode: "date" — @filterable timestamp field(s) [${named}] will throw at ` +
-          `request time when filtered (e.g. ?filter[field][gte]=...) — runtime-ts's filter ` +
-          `parser does not yet thread the Date-mode column type through. Not enforced; ` +
-          `remove @filterable from these fields or avoid filtering them until this is fixed.`,
-      );
-    }
-  }
+  // (Historical: a warning stood here for a @filterable timestamp under
+  // timestampMode:"date", which used to throw at REQUEST time in runtime-ts's
+  // filter parser. That limitation is fixed — the generated allowlist now carries
+  // `dateValues: true` for a Date-mode timestamp column and the parser coerces with
+  // `new Date(...)` — so the warning was removed rather than left to cry wolf.)
 
   const targets = config.targets;
   const targetOf = (g: Generator): ResolvedTarget => {
 
@@ -165,7 +165,7 @@ ${docsPrefix}export type ${entity.name} = ${z}.infer<typeof ${entity.name}Schema
     ...(enumAliases !== null ? [enumAliases] : []),
     renderZodValidators(entity, ctx),
     renderEntityConstants(entity, ctx.apiPrefix),
-    ...(allowlists ? [renderFilterAllowlist(entity), renderSortAllowlist(entity)] : []),
+    ...(allowlists ? [renderFilterAllowlist(entity, undefined, ctx), renderSortAllowlist(entity)] : []),
     renderFilterType(entity),
     ...(tphBlock !== null ? [tphBlock] : []),
   ];
 
@@ -16,6 +16,7 @@ import {
   opsForSubType,
 } from "@metaobjectsdev/metadata";
 import { sortableFields } from "./filter-shared.js";
+import type { RenderContext } from "../render-context.js";
 
 const NUMBER_SUBTYPES = new Set<string>([
   FIELD_SUBTYPE_INT,
@@ -52,8 +53,15 @@ function filterableFields(entity: MetaObject, exclude?: string): MetaField[] {
  * `exclude` (FR-017): drop a field from the allowlist. Used by per-subtype TPH
  * allowlists to omit the discriminator — it's pinned by the per-subtype route
  * path, so a client must not filter on it.
+ *
+ * `ctx` supplies `timestampMode`: under `"date"` a `field.timestamp` column binds a JS
+ * `Date`, so its rule carries `dateValues: true` and runtime-ts's filter parser coerces
+ * the query-string value with `new Date(...)` rather than binding a string against a
+ * Date-typed column (which threw at request time). `ctx.timestampMode` is already
+ * normalized to `"string"` for sqlite/D1 at both config choke points, so no dialect
+ * branching is needed here. Absent `ctx`, or in the default mode, output is unchanged.
  */
-export function renderFilterAllowlist(entity: MetaObject, exclude?: string): Code {
+export function renderFilterAllowlist(entity: MetaObject, exclude?: string, ctx?: RenderContext): Code {
   const fields = filterableFields(entity, exclude);
   if (fields.length === 0) {
     return code`
@@ -66,7 +74,12 @@ export const ${entity.name}FilterAllowlist = {} as const satisfies FilterAllowli
     .map((f) => {
       const ops = opsForSubType(f.subType).map((o) => JSON.stringify(o)).join(", ");
       const sub = filterSubTypeFor(f.subType);
-      return `  ${f.name}: { ops: [${ops}] as const, subType: ${JSON.stringify(sub)} as const, leadingWildcard: false }`;
+      // Only field.timestamp is governed by timestampMode — Drizzle types
+      // field.date / field.time as strings under every dialect.
+      const dateValues = ctx?.timestampMode === "date" && f.subType === FIELD_SUBTYPE_TIMESTAMP
+        ? ", dateValues: true as const"
+        : "";
+      return `  ${f.name}: { ops: [${ops}] as const, subType: ${JSON.stringify(sub)} as const, leadingWildcard: false${dateValues} }`;
     })
     .join(",\n");
   return code`
 
@@ -176,7 +176,7 @@ ${constFieldLines.join("\n")}
 } as const;
 `,
     ...(allowlists
-      ? [renderFilterAllowlist(projection), renderSortAllowlist(projection)]
+      ? [renderFilterAllowlist(projection, undefined, ctx), renderSortAllowlist(projection)]
       : []),
     renderFilterType(projection),
   ];
 
@@ -40,7 +40,7 @@ export function renderValueObjectFile(obj: MetaObject, apiPrefix = "", ctx?: Ren
   // not filter on it). Included fields are the subtype's own + inherited base
   // filterable fields. Drives the per-subtype REST routes' filter layer.
   const discField = tphSubtype ? tphDiscriminatorPin(obj)?.fieldName : undefined;
-  const tphFilterAllowlist = tphSubtype ? renderFilterAllowlist(obj, discField) : null;
+  const tphFilterAllowlist = tphSubtype ? renderFilterAllowlist(obj, discField, ctx) : null;
   const tphSortAllowlist = tphSubtype ? renderSortAllowlist(obj, discField) : null;
   // FR-017 Tier 3: the per-subtype CLIENT filter type, discriminator-excluded —
   // kept in lockstep with the per-subtype allowlist above so a typed
 
@@ -3,6 +3,9 @@ import { renderFilterAllowlist, renderSortAllowlist } from "../../src/templates/
 import { resolve } from "node:path";
 import { MetaDataLoader } from "@metaobjectsdev/metadata";
 import { FileSource } from "@metaobjectsdev/metadata/core";
+import { makeRenderContext } from "../../src/render-context.js";
+import { buildPkMap } from "../../src/pk-resolver.js";
+import { buildRelationMap } from "../../src/relation-resolver.js";
 
 const FIXTURE = resolve(import.meta.dir, "..", "fixtures", "filter-fixture.json");
 
@@ -73,3 +76,54 @@ describe("renderSortAllowlist", () => {
     expect(out).toMatch(/price:\s*\{/);
   });
 });
+
+describe("renderFilterAllowlist — timestampMode date-mode marking", () => {
+  // A date-mode timestamp column binds a JS Date, so the rule must carry
+  // `dateValues: true` for runtime-ts's parser to coerce with `new Date(...)`
+  // instead of binding a string (which threw at request time). The behavioral
+  // half of this contract is pinned in runtime-ts's filter-parser-date-mode test.
+  async function allowlistFor(mode?: "date" | "string") {
+    const { root } = await new MetaDataLoader().load([new FileSource(FIXTURE)]);
+    const entity = root.objects().find((c) => c.name === "Subscriber")!;
+    const ctx = makeRenderContext({
+      dialect: "postgres",
+      ...(mode !== undefined && { timestampMode: mode }),
+      loadedRoot: root,
+      outDir: "/x",
+      dbImport: "~/db",
+      pkMap: buildPkMap(root),
+      relationMap: buildRelationMap(root),
+    });
+    return renderFilterAllowlist(entity, undefined, ctx).toString();
+  }
+
+  test('timestampMode:"date" marks the timestamp field and ONLY the timestamp field', async () => {
+    const out = await allowlistFor("date");
+    expect(out).toMatch(/createdAt:\s*\{[^}]*dateValues: true/);
+    // Non-timestamp fields must not be marked — the flag is meaningless for them
+    // and would make the parser try to Date-coerce a string or boolean.
+    expect(out).not.toMatch(/email:\s*\{[^}]*dateValues/);
+    expect(out).not.toMatch(/subscribed:\s*\{[^}]*dateValues/);
+  });
+
+  test('the default "string" mode emits no dateValues at all', async () => {
+    expect(await allowlistFor()).not.toContain("dateValues");
+    expect(await allowlistFor("string")).not.toContain("dateValues");
+  });
+
+  test('dialect:"sqlite" never marks — timestampMode normalizes to "string" there', async () => {
+    const { root } = await new MetaDataLoader().load([new FileSource(FIXTURE)]);
+    const entity = root.objects().find((c) => c.name === "Subscriber")!;
+    const ctx = makeRenderContext({
+      dialect: "sqlite", timestampMode: "date", loadedRoot: root,
+      outDir: "/x", dbImport: "~/db",
+      pkMap: buildPkMap(root), relationMap: buildRelationMap(root),
+    });
+    expect(renderFilterAllowlist(entity, undefined, ctx).toString()).not.toContain("dateValues");
+  });
+
+  test("no ctx (bare call) is unchanged", async () => {
+    const entity = await loadEntity("Subscriber");
+    expect(renderFilterAllowlist(entity).toString()).not.toContain("dateValues");
+  });
+});
@@ -9,11 +9,14 @@
 // dynamically `import()` it, then call the real `safeParse`/`parse` on the
 // real Zod object it exports — not a string match.
 //
-// Covers the three Criticals + Important 5 found by that review, plus a
-// codegen-time WARNING for Important 4 (added on top after the initial fix
-// was reviewed clean — a cheap generation-time detect for the one runtime gap
-// left documented-not-fixed: filtering a date-mode timestamp throws at
-// request time; see runGen's warning + filter-parser.ts's limitation note):
+// Covers the three Criticals + Important 5 found by that review. Important 4
+// (filtering a date-mode timestamp threw at request time) was originally shipped
+// as a generation-time WARNING because the runtime fix was deferred; that fix has
+// since landed — the generated allowlist carries `dateValues` and runtime-ts's
+// parser coerces with `new Date(...)` — so the warning was removed and the last
+// describe block below now pins its ABSENCE. The behavioral pins for the fix
+// itself live in runtime-ts's filter-parser-date-mode test and in
+// templates/filter-allowlist.test.ts.
 //   CRITICAL 1 — z.date() rejects every JSON wire value; fix is z.coerce.date().
 //   CRITICAL 2 — sqlite/D1 + date mode used to emit non-compiling code (a
 //                regression #281 itself introduced); fix normalizes the mode
@@ -269,27 +272,19 @@ describe('IMPORTANT 4: runGen warns (once) when timestampMode: "date" meets a @f
     }
   }
 
-  test('warns exactly once, naming every offending entity+field, when dialect:"postgres" + timestampMode:"date"', async () => {
-    const { warnings } = await runWithMetadata(TWO_FILTERABLE_TIMESTAMPS, "postgres", "date");
-    const hits = warnings.filter((w) => w.includes('timestampMode: "date"'));
-    expect(hits.length).toBe(1); // once per run, not once per field/entity
-    expect(hits[0]).toContain("Post.updatedAt");
-    expect(hits[0]).toContain("Comment.postedAt");
-    expect(hits[0]).not.toContain("archivedAt"); // non-filterable — not named
-  });
-
-  test('silent in the default "string" mode (timestampMode omitted)', async () => {
-    const { warnings } = await runWithMetadata(TWO_FILTERABLE_TIMESTAMPS, "postgres");
-    expect(warnings.filter((w) => w.includes('timestampMode: "date"'))).toEqual([]);
-  });
-
-  test('silent when no field is both @filterable and a timestamp, even in date mode', async () => {
-    const { warnings } = await runWithMetadata(NO_FILTERABLE_TIMESTAMP, "postgres", "date");
-    expect(warnings.filter((w) => w.includes('timestampMode: "date"'))).toEqual([]);
-  });
-
-  test('silent under dialect:"sqlite" — timestampMode normalizes to "string" (Critical 2), so Important 4 never fires', async () => {
-    const { warnings } = await runWithMetadata(TWO_FILTERABLE_TIMESTAMPS, "sqlite", "date");
-    expect(warnings.filter((w) => w.includes('timestampMode: "date"'))).toEqual([]);
+  test("no warning is emitted in any mode — the limitation it announced is fixed", async () => {
+    // The warning was correct while date-mode filtering threw at request time. Now
+    // that the allowlist carries `dateValues` and the parser coerces, it would be
+    // crying wolf, so it is gone. Pinned in all four combinations so a revert of
+    // the fix cannot quietly re-land the warning instead of the behavior.
+    for (const [json, dialect, mode] of [
+      [TWO_FILTERABLE_TIMESTAMPS, "postgres", "date"],
+      [TWO_FILTERABLE_TIMESTAMPS, "postgres", undefined],
+      [NO_FILTERABLE_TIMESTAMP, "postgres", "date"],
+      [TWO_FILTERABLE_TIMESTAMPS, "sqlite", "date"],
+    ] as const) {
+      const { warnings } = await runWithMetadata(json, dialect, mode);
+      expect(warnings.filter((w) => w.includes('timestampMode: "date"'))).toEqual([]);
+    }
   });
 });
@@ -20,6 +20,18 @@ export interface FilterFieldRule {
   readonly ops: readonly FilterOp[];
   readonly subType: FilterSubType;
   readonly leadingWildcard: boolean;
+  /**
+   * `subType: "datetime"` only. Set by codegen when the column was emitted under
+   * `timestampMode: "date"`, i.e. the Drizzle column binds a JS `Date` rather than an
+   * ISO string. The filter parser then coerces the query-string value with `new Date(...)`
+   * instead of passing the raw string through — binding a string to a Date-typed column
+   * throws `value.toISOString is not a function` at request time.
+   *
+   * Optional and defaulting to false, so an allowlist generated before this existed keeps
+   * its exact previous behavior. `field.date` / `field.time` never set it: Drizzle types
+   * both as strings under every dialect, so they are not governed by `timestampMode`.
+   */
+  readonly dateValues?: boolean;
 }
 
 export type FilterAllowlist = Readonly<Record<string, FilterFieldRule>>;