feat: standalone module-build readiness for the public @ekklesia packages (ADR 0053)

Makes the public module-development package set usable from a module
repository outside the monorepo. Nothing is published.

- Curated @ekklesia/module-sdk: an explicit author API, no contracts
  barrel, no identity/authorization internals, no Drizzle and no legacy
  ModuleDatabase type. defineModuleRuntime returns the SDK's own named
  interfaces so a module's emitted declarations never reach into
  @ekklesia/contracts. defineModuleSchema is gone; createModuleTable and
  defineModuleSchemaMetadata live in @ekklesia/module-database.
- Drizzle: no longer a dependency of module-sdk or contracts. Core keeps
  the legacy Drizzle schema validator (moved to core/src/modules) and
  its legacy runtime support; drizzle-orm is an optional peer only.
- React is a peer (plus devDependency) of @ekklesia/ui; the boundary
  checker allows exactly that consumer-selected peer.
- @ekklesia/typescript-config is publishable; module-ui-host is private.
  Every public package carries "ekklesia.distribution":
  "module-development" and no monorepo-root prepack.
- module-pack reads the Node.js range from the module's own engines.node
  and recognizes Ekklesia packages by name plus that marker, so
  registry-installed packages are incorporated, SDK-compatibility
  checked, and never credited as third-party.
- scripts/pack-public-packages.ts (pnpm packages:pack) rebuilds, packs
  and inspects the nine public tarballs; scripts/test-standalone-module.sh
  (pnpm test:standalone-module, new CI job) installs them into a fixture
  module outside the repository and proves it typechecks, builds,
  packages, and verifies.
- Public-package boundary tests and module-development docs.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

packages/contracts/package.json

@@ -19,25 +19,33 @@
   "scripts": {
     "build": "tsc --project tsconfig.build.json",
     "lint": "biome lint .",
-    "prepack": "pnpm --workspace-root exec turbo run build --filter=@ekklesia/contracts",
     "test": "vitest run",
     "typecheck": "tsc --noEmit --project tsconfig.json"
   },
   "dependencies": {
-    "drizzle-orm": "0.45.2",
     "semver": "7.8.5",
     "spdx-expression-parse": "5.0.0",
     "zod": "4.4.3"
   },
+  "peerDependencies": {
+    "drizzle-orm": ">=0.45.2 <0.46.0"
+  },
+  "peerDependenciesMeta": {
+    "drizzle-orm": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@biomejs/biome": "2.5.3",
     "@types/node": "24.13.3",
     "@types/semver": "7.7.1",
     "@types/spdx-expression-parse": "4.0.0",
+    "drizzle-orm": "0.45.2",
     "typescript": "7.0.2",
     "vitest": "4.1.10"
   },
   "ekklesia": {
-    "layer": "contracts"
+    "layer": "contracts",
+    "distribution": "module-development"
   }
 }

packages/contracts/src/index.ts

@@ -11,7 +11,6 @@ export * from "./module-manifest.js";
 export * from "./module-migration.js";
 export * from "./module-realtime.js";
 export * from "./module-runtime.js";
-export * from "./module-schema.js";
 export * from "./module-schema-metadata.js";
 export * from "./module-schema-names.js";
 export * from "./module-storage.js";

packages/contracts/src/module-schema.ts

@@ -1,73 +0,0 @@
-import { is } from "drizzle-orm";
-import { type AnyPgTable, PgTable } from "drizzle-orm/pg-core";
-import { type ModuleId, moduleIdSchema } from "./identifiers.js";
-
-export {
-  moduleTableLocalNameSchema,
-  moduleTableName,
-  moduleTableNamespace,
-  moduleTablePrefix,
-  POSTGRES_IDENTIFIER_MAX_LENGTH,
-  physicalModuleTableNameSchema,
-} from "./module-schema-names.js";
-
-export interface ModuleSchemaDefinition<
-  Tables extends Readonly<Record<string, AnyPgTable>> = Readonly<Record<string, AnyPgTable>>,
-> {
-  readonly moduleId: ModuleId;
-  readonly tables: Tables;
-}
-
-const schemaDefinitionKeys = new Set(["moduleId", "tables"]);
-const drizzleTableIsAlias = Symbol.for("drizzle:IsAlias");
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function hasOnlyStringKeys(value: object, allowedKeys?: ReadonlySet<string>): boolean {
-  return Reflect.ownKeys(value).every(
-    (key) => typeof key === "string" && (!allowedKeys || allowedKeys.has(key)),
-  );
-}
-
-export function isModuleSchemaDefinition(value: unknown): value is ModuleSchemaDefinition {
-  try {
-    if (
-      !isRecord(value) ||
-      !hasOnlyStringKeys(value, schemaDefinitionKeys) ||
-      !moduleIdSchema.safeParse(value.moduleId).success ||
-      !isRecord(value.tables) ||
-      !hasOnlyStringKeys(value.tables)
-    ) {
-      return false;
-    }
-
-    const tables = Object.values(value.tables);
-    return (
-      tables.length > 0 &&
-      tables.every(
-        (table) =>
-          is(table, PgTable) &&
-          (table as unknown as Record<PropertyKey, unknown>)[drizzleTableIsAlias] === false,
-      )
-    );
-  } catch {
-    return false;
-  }
-}
-
-export function parseModuleSchemaDefinition(value: unknown): ModuleSchemaDefinition {
-  if (!isModuleSchemaDefinition(value)) {
-    throw new TypeError("Invalid Ekklesia module schema definition.");
-  }
-
-  const tables = Object.freeze(
-    Object.fromEntries(
-      Object.entries(value.tables).sort(([left], [right]) =>
-        left < right ? -1 : left > right ? 1 : 0,
-      ),
-    ) as Record<string, AnyPgTable>,
-  );
-  return Object.freeze({ moduleId: value.moduleId, tables });
-}

packages/contracts/tests/module-schema.test.ts

@@ -1,11 +1,5 @@
-import { alias, getTableConfig, integer } from "drizzle-orm/pg-core";
 import { describe, expect, it } from "vitest";
-import {
-  moduleTableName,
-  parseModuleSchemaDefinition,
-  physicalModuleTableNameSchema,
-} from "../src/index.js";
-import { pgTable } from "drizzle-orm/pg-core";
+import { moduleTableName, physicalModuleTableNameSchema } from "../src/index.js";
 
 describe("module schema contract", () => {
   it("creates deterministic physical names from module and local identifiers", () => {
@@ -22,33 +16,4 @@ describe("module schema contract", () => {
       "The namespaced PostgreSQL table name is invalid or too long.",
     );
   });
-
-  it("normalizes and freezes a typed schema definition without freezing its tables", () => {
-    const records = pgTable("example_records", { id: integer().primaryKey() });
-    const definition = parseModuleSchemaDefinition({
-      moduleId: "example",
-      tables: { records },
-    });
-
-    expect(definition.tables.records).toBe(records);
-    expect(getTableConfig(records).name).toBe("example_records");
-    expect(Object.isFrozen(definition)).toBe(true);
-    expect(Object.isFrozen(definition.tables)).toBe(true);
-    expect(Object.isFrozen(records)).toBe(false);
-  });
-
-  it("rejects malformed, empty, unknown, and non-PostgreSQL table definitions", () => {
-    const records = pgTable("example_records", { id: integer() });
-    const disguisedRecords = alias(records, "example_disguised_records");
-    expect(() => parseModuleSchemaDefinition({ moduleId: "example", tables: {} })).toThrow();
-    expect(() =>
-      parseModuleSchemaDefinition({ moduleId: "example", tables: { records: {} } }),
-    ).toThrow();
-    expect(() =>
-      parseModuleSchemaDefinition({ moduleId: "example", tables: { records }, extra: true }),
-    ).toThrow();
-    expect(() =>
-      parseModuleSchemaDefinition({ moduleId: "example", tables: { disguisedRecords } }),
-    ).toThrow();
-  });
 });