@@ -509,18 +509,27 @@ export async function runBaseline(
     }
   } else {
     let metadata;
-    try {
-      metadata = await loadMemory(metaRoot);
-    } catch (err) {
-      log.error(`migrate baseline: failed to load metadata: ${(err as Error).message}`);
-      return 2;
-    }
+    // Load metaobjects.config.ts ONCE, up front, for BOTH the consumer providers
+    // and the columnNamingStrategy — mirroring the DB path (and `meta gen`) so
+    // offline baseline resolves config-registered custom subtypes too (#157).
+    let baselineConfigProviders:
+      | readonly import("@metaobjectsdev/codegen-ts").MetaDataTypeProvider[]
+      | undefined;
     let baselineStrategy: "snake_case" | "literal" | "kebab-case" = "snake_case";
     try {
       const cfg = await loadMetaobjectsConfig(metaRoot);
+      baselineConfigProviders = cfg.providers;
       if (cfg.columnNamingStrategy) baselineStrategy = cfg.columnNamingStrategy;
     } catch {
-      // config absent — default snake_case
+      // config absent — no custom providers, default snake_case
+    }
+    try {
+      metadata = await loadMemory(metaRoot, {
+        ...(baselineConfigProviders !== undefined ? { providers: baselineConfigProviders } : {}),
+      });
+    } catch (err) {
+      log.error(`migrate baseline: failed to load metadata: ${(err as Error).message}`);
+      return 2;
     }
     const baselineViews = buildProjectionViews(metadata, { dialect: config.dialect, columnNamingStrategy: baselineStrategy });
     snapshot = baselineFromMetadata(metadata, config.dialect, baselineStrategy, baselineViews);
@@ -553,9 +562,26 @@ export async function runOfflineGenerate(
     log.error(`migrate: --dialect required for offline generation (or use --from-db)`);
     return 2;
   }
+  // Load metaobjects.config.ts ONCE, up front, for BOTH the consumer providers
+  // and the columnNamingStrategy — mirroring the DB path (and `meta gen`) so
+  // offline generate resolves config-registered custom subtypes too (#157).
+  let offlineConfigProviders:
+    | readonly import("@metaobjectsdev/codegen-ts").MetaDataTypeProvider[]
+    | undefined;
+  let offlineStrategy: "snake_case" | "literal" | "kebab-case" = "snake_case";
+  try {
+    const cfg = await loadMetaobjectsConfig(metaRoot);
+    offlineConfigProviders = cfg.providers;
+    if (cfg.columnNamingStrategy) offlineStrategy = cfg.columnNamingStrategy;
+  } catch {
+    // config absent — no custom providers, default snake_case
+  }
+
   let metadata;
   try {
-    metadata = await loadMemory(metaRoot);
+    metadata = await loadMemory(metaRoot, {
+      ...(offlineConfigProviders !== undefined ? { providers: offlineConfigProviders } : {}),
+    });
   } catch (err) {
     log.error(`migrate: failed to load metadata: ${(err as Error).message}`);
     return 2;
@@ -584,13 +610,6 @@ export async function runOfflineGenerate(
   const collectedAmbiguous: AmbiguousChange[] = [];
   const onAmbiguousResolution = mapOnAmbiguous(config.onAmbiguous);
 
-  let offlineStrategy: "snake_case" | "literal" | "kebab-case" = "snake_case";
-  try {
-    const cfg = await loadMetaobjectsConfig(metaRoot);
-    if (cfg.columnNamingStrategy) offlineStrategy = cfg.columnNamingStrategy;
-  } catch {
-    // config absent — default snake_case
-  }
   const offlineViews = buildProjectionViews(metadata, { dialect: config.dialect, columnNamingStrategy: offlineStrategy });
 
   let plan;
 
@@ -0,0 +1,121 @@
+import { describe, test, expect, afterAll } from "bun:test";
+import { mkdtemp, rm, mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runBaseline, runOfflineGenerate } from "../src/commands/migrate.js";
+
+// #157 — the offline migrate paths (baseline + offline generate) must thread the
+// consumer `providers` from metaobjects.config.ts into loadMemory, exactly like
+// `meta gen` and the DB migrate paths do. Otherwise a project that registers a
+// custom subtype via a config provider hits `Unknown type <subtype>` on offline
+// `meta migrate`, forcing a "strip the custom nodes" workaround.
+
+const dirs: string[] = [];
+afterAll(async () => {
+  for (const d of dirs) await rm(d, { recursive: true, force: true });
+});
+
+// A config that registers a custom `validator.geocheck` subtype via a provider —
+// mirrors how an adopter ships a custom subtype to gen/migrate. A validator is
+// used (not a field) so it exercises provider-threading without also depending on
+// how the migrate column-mapper handles a novel physical type.
+const CUSTOM_CONFIG = [
+  `import { defineConfig } from "@metaobjectsdev/codegen-ts";`,
+  `import { entityFile } from "@metaobjectsdev/codegen-ts/generators";`,
+  `import { TypeId, TYPE_VALIDATOR, MetaValidator } from "@metaobjectsdev/metadata";`,
+  `const geoProvider = {`,
+  `  id: "test-geocheck",`,
+  `  dependencies: ["metaobjects-core-types"],`,
+  `  registerTypes(registry) {`,
+  `    registry.register({`,
+  `      typeId: new TypeId(TYPE_VALIDATOR, "geocheck"),`,
+  `      description: "A custom validator",`,
+  `      factory: (typeId, name) => new MetaValidator(typeId, name),`,
+  `      childRules: [],`,
+  `      attributes: [],`,
+  `    });`,
+  `  },`,
+  `};`,
+  `export default defineConfig({`,
+  `  outDir: "out",`,
+  `  dialect: "postgres",`,
+  `  generators: [entityFile()],`,
+  `  providers: [geoProvider],`,
+  `});`,
+].join("\n");
+
+// An entity (writable table) whose `name` field carries the custom validator.
+// The `validator.geocheck` child resolves ONLY when the config provider loads —
+// so an offline migrate that doesn't thread providers fails at metadata load.
+const CUSTOM_META = {
+  "metadata.root": {
+    package: "acme::geo",
+    children: [
+      {
+        "object.entity": {
+          name: "Place",
+          children: [
+            { "field.long": { name: "id" } },
+            {
+              "field.string": {
+                name: "name",
+                children: [{ "validator.geocheck": { name: "chk" } }],
+              },
+            },
+            { "source.rdb": { name: "src", "@table": "places" } },
+            {
+              "identity.primary": {
+                name: "pk",
+                "@fields": ["id"],
+                "@generation": "increment",
+              },
+            },
+          ],
+        },
+      },
+    ],
+  },
+};
+
+async function customProject(): Promise<string> {
+  const root = await mkdtemp(join(tmpdir(), "mts-migprov-"));
+  dirs.push(root);
+  await mkdir(join(root, "metaobjects"), { recursive: true });
+  await writeFile(
+    join(root, "metaobjects", "meta.json"),
+    JSON.stringify(CUSTOM_META),
+    "utf8",
+  );
+  await writeFile(join(root, "metaobjects.config.ts"), CUSTOM_CONFIG, "utf8");
+  return root;
+}
+
+describe("offline migrate threads config providers (#157)", () => {
+  test("runBaseline loads a config-registered custom subtype (no strip workaround)", async () => {
+    const root = await customProject();
+    const code = await runBaseline(
+      { dialect: "postgres", outDir: "./.metaobjects/migrations", fromDb: false } as any,
+      root,
+    );
+    expect(code).toBe(0);
+  });
+
+  test("runOfflineGenerate loads a config-registered custom subtype", async () => {
+    const root = await customProject();
+    // baseline first (also needs the provider) so there is a snapshot to diff.
+    await runBaseline(
+      { dialect: "postgres", outDir: "./.metaobjects/migrations", fromDb: false } as any,
+      root,
+    );
+    const code = await runOfflineGenerate(
+      {
+        dialect: "postgres",
+        outDir: "./.metaobjects/migrations",
+        allow: [],
+        onAmbiguous: "error",
+      } as any,
+      root,
+    );
+    expect(code).toBe(0);
+  });
+});