@@ -47,14 +47,102 @@ export type { Dialect };
 
 /**
  * Discriminated union describing how a column default should be emitted.
- * - { kind: "now" }            — dialect-aware: sql`CURRENT_TIMESTAMP` (sqlite) or .defaultNow() (postgres)
- * - { kind: "sqlExpr"; raw }   — raw SQL expression wrapped in sql`...` (CURRENT_DATE, CURRENT_TIME, function calls)
- * - { kind: "literal"; value } — .default(JSON.stringify(value))
+ * - { kind: "now" }              — dialect-aware: sql`CURRENT_TIMESTAMP` (sqlite) or .defaultNow() (postgres)
+ * - { kind: "sqlExpr"; raw }     — raw SQL expression wrapped in sql`...` (CURRENT_DATE, CURRENT_TIME, function calls)
+ * - { kind: "literal"; value }   — .default(JSON.stringify(value))
+ * - { kind: "arrayLiteral"; elements } — .default([...]) for an isArray field. Drizzle's
+ *   `.array().default(x)` (postgres) and `.$type<E[]>().default(x)` (sqlite json)
+ *   both want a JS array, NOT the raw metadata string ("{}" / "[]" / "{a,b}"),
+ *   which would fail `tsc` (TS2345). The metadata @default MUST be a string (the
+ *   Java loader rejects a JSON array default), so the array literal is parsed out
+ *   of that string here and emitted as a real JS array. Elements are pre-rendered
+ *   TS literal source (numbers/booleans bare, strings quoted).
  */
 export type DefaultExpr =
   | { kind: "now" }
   | { kind: "sqlExpr"; raw: string }
-  | { kind: "literal"; value: unknown };
+  | { kind: "literal"; value: unknown }
+  | { kind: "arrayLiteral"; elements: string[] };
+
+/**
+ * Parse a string @default for an isArray field into the element source-literals
+ * that go inside a JS `[...]` array literal, or return undefined when the shape
+ * is ambiguous/unsupported (caller then falls back to a raw sql`...` cast so the
+ * output ALWAYS typechecks — never a bare string).
+ *
+ * Recognized input shapes (the metadata @default is always a string — an array
+ * default is authored as "[]" / "{}" / "{a,b}", never a JSON array, because the
+ * Java loader requires @default to be a string):
+ *   - "{}"            → []           (Postgres empty-array literal)
+ *   - "[]"            → []           (JSON empty array)
+ *   - "{a,b}"         → elements a,b (Postgres array literal, comma-separated)
+ *   - '["a","b"]'     → elements a,b (JSON array)
+ *
+ * `numericElements` controls quoting: numeric/boolean element subtypes emit bare
+ * literals (1, true), everything else is quoted as a string literal. A parse that
+ * can't be represented safely (nested quotes/commas we don't fully model, mixed
+ * shapes) returns undefined.
+ */
+function parseArrayDefault(
+  raw: string,
+  numericElements: boolean,
+): string[] | undefined {
+  const trimmed = raw.trim();
+
+  // JSON array form: '[]' or '["a","b"]' or '[1,2]'.
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return undefined;
+    }
+    if (!Array.isArray(parsed)) return undefined;
+    const out: string[] = [];
+    for (const el of parsed) {
+      if (numericElements) {
+        if (typeof el === "number" || typeof el === "boolean") {
+          out.push(String(el));
+        } else if (typeof el === "string" && el.trim() !== "" && !Number.isNaN(Number(el))) {
+          out.push(String(Number(el)));
+        } else {
+          return undefined; // numeric column but a non-numeric element — bail to raw SQL
+        }
+      } else {
+        if (typeof el === "string") {
+          out.push(JSON.stringify(el));
+        } else if (typeof el === "number" || typeof el === "boolean") {
+          out.push(JSON.stringify(String(el)));
+        } else {
+          return undefined;
+        }
+      }
+    }
+    return out;
+  }
+
+  // Postgres array-literal form: '{}' or '{a,b}'.
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    const inner = trimmed.slice(1, -1).trim();
+    if (inner === "") return []; // '{}' → empty array
+    // A quote or nested brace means an escaping shape we don't fully model — bail
+    // to a raw sql`...` cast rather than mis-split it.
+    if (/["{}]/.test(inner)) return undefined;
+    const parts = inner.split(",").map((p) => p.trim());
+    const out: string[] = [];
+    for (const p of parts) {
+      if (numericElements) {
+        if (p === "" || Number.isNaN(Number(p))) return undefined;
+        out.push(String(Number(p)));
+      } else {
+        out.push(JSON.stringify(p));
+      }
+    }
+    return out;
+  }
+
+  return undefined;
+}
 
 /**
  * Patterns recognized as SQL expressions in a default value. Anything matching
@@ -455,6 +543,29 @@ export function mapColumnType(
       } else {
         defaultExpr = { kind: "sqlExpr", raw: canonical };
       }
+    } else if (
+      isArray &&
+      subType !== FIELD_SUBTYPE_OBJECT &&
+      subType !== FIELD_SUBTYPE_MAP &&
+      typeof defaultAttr === "string"
+    ) {
+      // Array branch (scalar element arrays only). The column is a native
+      // Postgres array (.array()) or a sqlite json-mode text column typed
+      // .$type<E[]>() — BOTH want a JS array default, not the raw @default
+      // string ("{}" / "[]" / "{a,b}"), which fails `tsc` (TS2345). Parse the
+      // string into element literals; on an unsupported shape, fall back to a
+      // raw sql`...` cast so the emitted default ALWAYS typechecks.
+      const numericElements = sqliteJsonArrayElementTsType(subType) === "number"
+        || sqliteJsonArrayElementTsType(subType) === "boolean";
+      const elements = parseArrayDefault(defaultAttr, numericElements);
+      if (elements !== undefined) {
+        defaultExpr = { kind: "arrayLiteral", elements };
+      } else {
+        // Unparseable — emit the raw metadata string as a typed SQL cast. The
+        // dialect-specific SQL is resolved in the template (postgres needs a
+        // ::type[] cast; sqlite json takes the raw string).
+        defaultExpr = { kind: "sqlExpr", raw: defaultAttr };
+      }
     } else {
       // Literal branch: use the field-type-converted value so booleans/numbers
       // are real JS booleans/numbers (not strings). field.defaultValue() applies
 
@@ -316,9 +316,16 @@ function renderColumn(
       } else {
         modifiersStr += `.defaultNow()`;
       }
+    } else if (spec.defaultExpr.kind === "arrayLiteral") {
+      // isArray field: Drizzle's .array().default(x) (postgres) and
+      // .$type<E[]>().default(x) (sqlite json) want a JS array literal, not the
+      // raw @default string. Elements are pre-rendered TS source literals.
+      modifiersStr += `.default([${spec.defaultExpr.elements.join(", ")}])`;
     } else if (spec.defaultExpr.kind === "sqlExpr") {
       const sqlSym = imp("sql@drizzle-orm");
-      // Raw SQL keyword/expression — emit as sql`<raw>` for both dialects.
+      // Raw SQL keyword/expression — emit as sql`<raw>` for both dialects. This
+      // is also the always-typechecks fallback for an array @default whose shape
+      // parseArrayDefault couldn't safely model.
       sqlDefaultSegment = code`.default(${sqlSym}\`${spec.defaultExpr.raw}\`)`;
     } else {
       // literal
 
@@ -0,0 +1,120 @@
+// Regression guard: a downstream adopter upgrading to 0.15.1 hit a codegen-ts
+// bug where an isArray field with a @default emitted Drizzle output that failed
+// `tsc` (TS2345). Before 0.15.0 an isArray string field mapped to jsonb, where
+// `.default("[]")` was valid; the 0.15.0 @dbColumnType slim-and-derive (ADR-0036)
+// made isArray emit a NATIVE text[] (.array()) column, but the default-emitter
+// still passed the raw @default string through — and Drizzle's .array().default(x)
+// (and the sqlite .$type<E[]>().default(x)) want a JS array, not a string.
+//
+// This is the robust complement to the string/shape assertions in
+// column-mapper.test.ts: it actually COMPILES the generated entity with the real
+// TS compiler (mirrors test/projection/compile.test.ts), so the fix is proven to
+// TYPECHECK, not just string-match. The @default MUST be a string (the Java
+// loader rejects a JSON-array default), which is exactly why the fix lives in
+// codegen-ts and can't be pushed into metadata.
+
+import { describe, test, expect } from "bun:test";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import ts from "typescript";
+import { MetaDataLoader, InMemoryStringSource } from "@metaobjectsdev/metadata";
+import { entityFile } from "../src/generators/index.js";
+import { makeRenderContext } from "../src/render-context.js";
+import { buildPkMap } from "../src/pk-resolver.js";
+import { buildRelationMap } from "../src/relation-resolver.js";
+import type { GenContext } from "../src/generator.js";
+import type { Dialect } from "../src/metaobjects-config.js";
+
+async function loadRoot() {
+  const json = JSON.stringify({
+    "metadata.root": {
+      package: "test",
+      children: [
+        {
+          "object.entity": {
+            name: "Rule",
+            children: [
+              { "source.rdb": { "@table": "rules" } },
+              { "field.int": { name: "id" } },
+              // Empty-array defaults in both notations.
+              { "field.string": { name: "conditions", isArray: true, "@default": "{}" } },
+              { "field.string": { name: "emptyJson", isArray: true, "@default": "[]" } },
+              // Non-empty defaults: Postgres array-literal + JSON-array shapes.
+              { "field.string": { name: "tags", isArray: true, "@default": "{a,b}" } },
+              { "field.string": { name: "jsonTags", isArray: true, "@default": "[\"x\",\"y\"]" } },
+              // A scalar (non-array) default stays byte-identical behavior.
+              { "field.string": { name: "status", "@default": "active" } },
+              { "identity.primary": { name: "id", "@fields": "id" } },
+            ],
+          },
+        },
+      ],
+    },
+  });
+  const result = await new MetaDataLoader().load([new InMemoryStringSource(json)]);
+  if (result.errors.length > 0) {
+    throw new Error(`Loader errors:\n${result.errors.map((e) => e.message).join("\n")}`);
+  }
+  return result.root;
+}
+
+// Real TS compiler gate. Files are written under this package so the program
+// resolves drizzle-orm/zod from the package's own node_modules (the REAL types).
+function compile(dir: string, files: string[]): readonly ts.Diagnostic[] {
+  const program = ts.createProgram(
+    files.map((f) => join(dir, f)),
+    {
+      strict: true,
+      noEmit: true,
+      target: ts.ScriptTarget.ES2022,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      skipLibCheck: true,
+    },
+  );
+  return ts.getPreEmitDiagnostics(program);
+}
+
+async function genAndCompile(dialect: Dialect): Promise<readonly ts.Diagnostic[]> {
+  const root = await loadRoot();
+  const dir = mkdtempSync(join(import.meta.dir, "tmp-array-default-"));
+  try {
+    const renderContext = makeRenderContext({
+      dialect,
+      loadedRoot: root,
+      outDir: dir,
+      dbImport: "~/db",
+      pkMap: buildPkMap(root),
+      relationMap: buildRelationMap(root),
+    });
+    const ctx: GenContext = {
+      entities: root.objects(),
+      loadedRoot: root,
+      matches: () => true,
+      projectRoot: dir,
+      config: { outDir: dir, extStyle: "none", dbImport: "~/db", dialect } as never,
+      renderContext,
+      warn: () => {},
+    };
+    // allowlists:false → no runtime-ts import; the program is self-contained over
+    // drizzle + zod, so the .array()/.$type<E[]>() column defaults are exactly
+    // what gets type-checked.
+    const files = await entityFile({ allowlists: false }).generate(ctx);
+    for (const f of files) writeFileSync(join(dir, f.path), f.content);
+    return compile(dir, files.map((f) => f.path));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+describe("isArray @default generates typechecking Drizzle output (TS2345 regression guard)", () => {
+  test("Postgres: array-column defaults type-check with ZERO diagnostics", async () => {
+    const diagnostics = await genAndCompile("postgres");
+    expect(diagnostics.map((d) => ts.flattenDiagnosticMessageText(d.messageText, "\n"))).toEqual([]);
+  });
+
+  test("SQLite: json array-column defaults type-check with ZERO diagnostics", async () => {
+    const diagnostics = await genAndCompile("sqlite");
+    expect(diagnostics.map((d) => ts.flattenDiagnosticMessageText(d.messageText, "\n"))).toEqual([]);
+  });
+});
@@ -150,6 +150,64 @@ describe("mapColumnType — Postgres", () => {
   });
 });
 
+describe("mapColumnType — isArray @default (regression: raw string → TS2345)", () => {
+  // Drizzle's .array().default(x) / .$type<E[]>().default(x) want a JS array,
+  // not the raw @default string ("{}"/"[]"/"{a,b}"). Before the fix these
+  // emitted a bare string literal that failed `tsc`. The @default MUST be a
+  // string (the Java loader rejects a JSON-array default), so the array literal
+  // is parsed out of the string. Emission is dialect-agnostic (arrayLiteral).
+  function arrayField(subType: string, name: string, def: string) {
+    const f = metaField(subType, name);
+    f.setIsArray(true);
+    f.setAttr("default", def);
+    return f;
+  }
+
+  test("string[] with '{}' → arrayLiteral []", () => {
+    const spec = mapColumnType(arrayField(FIELD_SUBTYPE_STRING, "conditions", "{}"), "postgres");
+    expect(spec.defaultExpr).toEqual({ kind: "arrayLiteral", elements: [] });
+  });
+
+  test("string[] with '[]' → arrayLiteral []", () => {
+    const spec = mapColumnType(arrayField(FIELD_SUBTYPE_STRING, "conditions", "[]"), "postgres");
+    expect(spec.defaultExpr).toEqual({ kind: "arrayLiteral", elements: [] });
+  });
+
+  test("string[] with '{a,b}' → arrayLiteral of quoted string literals", () => {
+    const spec = mapColumnType(arrayField(FIELD_SUBTYPE_STRING, "tags", "{a,b}"), "postgres");
+    expect(spec.defaultExpr).toEqual({ kind: "arrayLiteral", elements: ['"a"', '"b"'] });
+  });
+
+  test("string[] with JSON '[\"a\",\"b\"]' → arrayLiteral of quoted string literals", () => {
+    const spec = mapColumnType(arrayField(FIELD_SUBTYPE_STRING, "tags", '["a","b"]'), "postgres");
+    expect(spec.defaultExpr).toEqual({ kind: "arrayLiteral", elements: ['"a"', '"b"'] });
+  });
+
+  test("int[] with '{1,2}' → arrayLiteral of BARE numeric literals", () => {
+    const spec = mapColumnType(arrayField(FIELD_SUBTYPE_INT, "nums", "{1,2}"), "postgres");
+    expect(spec.defaultExpr).toEqual({ kind: "arrayLiteral", elements: ["1", "2"] });
+  });
+
+  test("sqlite json array default parses identically (dialect-agnostic)", () => {
+    const spec = mapColumnType(arrayField(FIELD_SUBTYPE_STRING, "tags", "{a,b}"), "sqlite");
+    expect(spec.defaultExpr).toEqual({ kind: "arrayLiteral", elements: ['"a"', '"b"'] });
+  });
+
+  test("unparseable array shape falls back to a raw sql`...` cast (never a bare string)", () => {
+    // A nested-quote/brace shape parseArrayDefault refuses to split → sqlExpr,
+    // which the template emits as .default(sql`...`) (always typechecks).
+    const spec = mapColumnType(arrayField(FIELD_SUBTYPE_STRING, "weird", '{"a,b",c}'), "postgres");
+    expect(spec.defaultExpr).toEqual({ kind: "sqlExpr", raw: '{"a,b",c}' });
+  });
+
+  test("scalar (non-array) @default is unchanged — still a literal", () => {
+    const f = metaField(FIELD_SUBTYPE_STRING, "status");
+    f.setAttr("default", "active");
+    const spec = mapColumnType(f, "postgres");
+    expect(spec.defaultExpr).toEqual({ kind: "literal", value: "active" });
+  });
+});
+
 describe("mapColumnType — field.object column parity with migrate-ts (SP-H Unit 4)", () => {
   // migrate-ts/expected-schema maps a (non-flattened) field.object → { kind: "json" }
   // → JSONB on Postgres / JSON on SQLite. Codegen must AGREE: the default