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/module-sdk/tests/define-module-runtime.test.ts

@@ -6,10 +6,12 @@ import {
   MODULE_HTTP_METHODS,
   type ModuleHttpRouteRegistrar,
   type ModuleRegistrationContext,
+  type ModuleRuntimeDefinitionWithDatabase,
+  type ModuleRuntimeDefinitionWithoutDatabase,
 } from "../src/index.js";
 
 describe("defineModuleRuntime", () => {
-  it("types each database mode without exposing a legacy-or-ABI union", () => {
+  it("types the ABI executor for a database module, and no database at all otherwise", () => {
     defineModuleRuntime({
       database: { abi: 1 },
       id: "example",
@@ -35,16 +37,27 @@ describe("defineModuleRuntime", () => {
     });
 
     defineModuleRuntime({
-      id: "legacy",
+      id: "no-database",
       version: "0.1.0",
       start({ services }) {
-        expectTypeOf(services.database.select).toBeFunction();
-        // @ts-expect-error Legacy modules do not receive the ABI executor.
-        services.database.abiVersion;
+        // The SDK never types the legacy Drizzle facade (ADR 0053): a module without the ABI has
+        // no database to reach.
+        expectTypeOf(services.database).toBeNever();
       },
     });
   });
 
+  it("types the result as the SDK's own named interfaces, so a module's declarations can name it", () => {
+    // A module that emits declarations names its default export's type; with an inferred literal
+    // type that would reach into packages a standalone module does not depend on directly.
+    expectTypeOf(
+      defineModuleRuntime({ database: { abi: 1 }, id: "example", version: "0.1.0" }),
+    ).toEqualTypeOf<ModuleRuntimeDefinitionWithDatabase>();
+    expectTypeOf(
+      defineModuleRuntime({ id: "example", version: "0.1.0" }),
+    ).toEqualTypeOf<ModuleRuntimeDefinitionWithoutDatabase>();
+  });
+
   it("defines a frozen server runtime without duplicating the static manifest", async () => {
     const start = vi.fn();
     const runtime = defineModuleRuntime({

packages/module-sdk/tests/define-module-schema.test.ts

@@ -1,25 +0,0 @@
-import { getTableConfig, integer } from "drizzle-orm/pg-core";
-import { describe, expect, it } from "vitest";
-import { createModuleTable, defineModuleSchema } from "../src/index.js";
-
-describe("module schema authoring", () => {
-  it("creates namespaced PostgreSQL tables and a typed frozen definition", () => {
-    const moduleTable = createModuleTable("care-team");
-    const members = moduleTable("members", { id: integer().primaryKey() });
-    const definition = defineModuleSchema({
-      moduleId: "care-team",
-      tables: { members },
-    });
-
-    expect(getTableConfig(members).name).toBe("care_team_members");
-    expect(definition.tables.members).toBe(members);
-    expect(Object.isFrozen(definition)).toBe(true);
-    expect(Object.isFrozen(definition.tables)).toBe(true);
-  });
-
-  it("rejects invalid module and logical table names", () => {
-    expect(() => createModuleTable("Not Valid")).toThrow();
-    const moduleTable = createModuleTable("example");
-    expect(() => moduleTable("Not Valid", { id: integer() })).toThrow();
-  });
-});