feat: Ekklesia Module Package v1, the canonical packager and verifier (ADR 0049)

A separately versioned module is now distributed as one deterministic
.tar.gz and its SHA-256, produced by an Ekklesia-owned packager and checked by
Core before anything is installed. This slice implements the portable `any`
target, with the module template as the end-to-end proof. ADR 0049 is
accepted.

@ekklesia/contracts: the Module Package v1 contract. The strict
ekklesia.package.json schema (packageFormat 1, identity, target, runtime,
provenance, incorporated Ekklesia packages, strict transitional facts, an
exact byte-wise-sorted file list with size and SHA-256), target names, and the
generated runtime package.json.

@ekklesia/module-pack (new, tooling): `ekklesia-pack-module --module <dir>
--target any --out <dir> --source-revision <commit>`.
- Bundles server, schema, and jobs with esbuild, SDK, contracts, and Drizzle
  included; only Node built-ins remain imports. Any warning, unresolved
  import, external dependency, or native or platform-specific package fails.
- Copies browser artifacts as built, after proving them current, and the
  migrations; generates package.json and ekklesia.package.json; never ships
  src, tests, declarations, source maps, or workspace ranges.
- THIRD_PARTY_NOTICES: every third-party package traced from the bundles'
  own inputs, credited once with its declared licence and every licence,
  copying, copyright, and notice file it ships. A missing licence fails; a
  missing text fails unless its standard text is complete without copyright
  lines (Apache-2.0, vendored, needed by drizzle-orm).
- Deterministic ustar and gzip: sorted paths, uid/gid 0, empty names, mtime
  0, 0755/0644, no links. Byte-identical across runs and machines.
- Writes only the archive and its .sha256; never deploys, links, or installs,
  so the workspace's install state is untouched.

Core: verifyModulePackage and `verify-module-package.js <archive>
[--sha256 | --sha256-file] [--extract-to <new dir>]`. Reads the archive in
memory and refuses links, special entries, setuid/setgid/sticky modes, unsafe
or escaping paths, and a second top-level directory; checks metadata, every
file, identity, target, Node.js range, SDK, and the transitional Drizzle
agreement; runs the platform's module and migration discovery; loads the
backend once in a forked process with an empty environment; only then
extracts, with normalized modes, into a new directory. Errors are sanitized.

@ekklesia/module-ui-build: analyzeModuleUi reports each artifact's inputs
and whether the built file is current. The nested stylesheet build now works
from the module directory, so artifacts no longer depend on the caller's
working directory.

The split deploy smoke builds the package with the canonical packager
(scripts/lib/build-module-package.Dockerfile replaces the test-only pnpm
deploy packaging), verifies it with the same generic image, installs the
verified tree, removes it, and reinstalls the exact same archive.

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

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

@@ -0,0 +1,167 @@
+import { describe, expect, it } from "vitest";
+import {
+  MODULE_PACKAGE_FORMAT,
+  MODULE_PACKAGE_METADATA_FILENAME,
+  modulePackageArchiveFileName,
+  modulePackageRuntimePackage,
+  safeParseModulePackageMetadata,
+  safeParseModulePackageRuntimePackage,
+  safeParseModulePackageTarget,
+} from "../src/index.js";
+
+const digest = "a".repeat(64);
+
+function metadata(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    packageFormat: 1,
+    module: { id: "example", version: "0.1.0" },
+    target: "any",
+    runtime: { node: ">=24.11.0 <25" },
+    provenance: {
+      revision: "86ae907f59458508e3277666cdd214f5bd7c1078",
+      packager: { name: "@ekklesia/module-pack", version: "0.1.2" },
+    },
+    incorporates: { "@ekklesia/contracts": "0.1.2", "@ekklesia/module-sdk": "0.1.2" },
+    transitional: { databaseRuntime: { "drizzle-orm": "0.45.2" } },
+    files: [
+      { path: "THIRD_PARTY_NOTICES", size: 10, sha256: digest },
+      { path: "dist/server/index.js", size: 20, sha256: digest },
+      { path: "ekklesia.module.json", size: 30, sha256: digest },
+      { path: "package.json", size: 40, sha256: digest },
+    ],
+    ...overrides,
+  };
+}
+
+describe("Ekklesia Module Package v1 metadata (ADR 0049)", () => {
+  it("names the format, its metadata file, and the recommended archive file name", () => {
+    expect(MODULE_PACKAGE_FORMAT).toBe(1);
+    expect(MODULE_PACKAGE_METADATA_FILENAME).toBe("ekklesia.package.json");
+    expect(modulePackageArchiveFileName("example", "0.1.0", "any")).toBe(
+      "example-0.1.0-any.tar.gz",
+    );
+  });
+
+  it("accepts a complete any-target package description", () => {
+    expect(safeParseModulePackageMetadata(metadata()).success).toBe(true);
+  });
+
+  it("accepts a package that incorporates nothing and needs no transitional facts", () => {
+    const { transitional: _transitional, ...rest } = metadata();
+    expect(safeParseModulePackageMetadata({ ...rest, incorporates: {} }).success).toBe(true);
+  });
+
+  it.each([
+    ["an unknown top-level field", { signature: "x" }],
+    ["format 2", { packageFormat: 2 }],
+    ["a missing source revision", { provenance: { packager: { name: "p", version: "1.0.0" } } }],
+    [
+      "an abbreviated revision",
+      { provenance: { revision: "86ae907", packager: { name: "p", version: "1.0.0" } } },
+    ],
+    ["a non-semver module version", { module: { id: "example", version: "1.0" } }],
+    ["an invalid module id", { module: { id: "Example", version: "0.1.0" } }],
+    ["an invalid Node range", { runtime: { node: "soon" } }],
+    ["native runtime facts on an any target", { runtime: { node: ">=24", nodeApi: 9 } }],
+    ["a non-Ekklesia incorporated package", { incorporates: { zod: "4.4.3" } }],
+    [
+      "an incorporated range instead of a version",
+      { incorporates: { "@ekklesia/module-sdk": "^0.1.0" } },
+    ],
+    ["an unknown transitional key", { transitional: { orm: {} } }],
+    ["an unknown database runtime", { transitional: { databaseRuntime: { prisma: "6.0.0" } } }],
+  ])("rejects %s", (_label, overrides) => {
+    expect(safeParseModulePackageMetadata(metadata(overrides)).success).toBe(false);
+  });
+
+  it.each([
+    ["an absolute path", "/etc/passwd"],
+    ["a parent segment", "dist/../../secret"],
+    ["a dot segment", "./package.json"],
+    ["an empty segment", "dist//index.js"],
+    ["a backslash", "dist\\index.js"],
+    ["a NUL byte", "dist/\u0000"],
+    ["the metadata file itself", "ekklesia.package.json"],
+  ])("rejects a file entry with %s", (_label, path) => {
+    const files = [{ path, size: 1, sha256: digest }];
+    expect(safeParseModulePackageMetadata(metadata({ files })).success).toBe(false);
+  });
+
+  it("requires file entries in byte-wise path order, without duplicates", () => {
+    const entry = (path: string) => ({ path, size: 1, sha256: digest });
+    expect(
+      safeParseModulePackageMetadata(metadata({ files: [entry("b"), entry("a")] })).success,
+    ).toBe(false);
+    expect(
+      safeParseModulePackageMetadata(metadata({ files: [entry("a"), entry("a")] })).success,
+    ).toBe(false);
+    // Byte-wise, not locale order: upper case sorts before lower case.
+    expect(
+      safeParseModulePackageMetadata(metadata({ files: [entry("THIRD"), entry("dist")] })).success,
+    ).toBe(true);
+  });
+
+  it.each([
+    ["an uppercase digest", { sha256: "A".repeat(64) }],
+    ["a short digest", { sha256: "a".repeat(63) }],
+    ["a negative size", { size: -1 }],
+    ["a fractional size", { size: 1.5 }],
+  ])("rejects a file entry with %s", (_label, override) => {
+    const files = [{ path: "package.json", size: 1, sha256: digest, ...override }];
+    expect(safeParseModulePackageMetadata(metadata({ files })).success).toBe(false);
+  });
+});
+
+describe("module package targets", () => {
+  it.each([
+    "any",
+    "linux-x64-glibc",
+    "linux-arm64-glibc",
+    "linux-x64-musl",
+    "darwin-arm64",
+  ])("accepts %s", (target) => {
+    expect(safeParseModulePackageTarget(target).success).toBe(true);
+  });
+
+  it.each([
+    "",
+    "ANY",
+    "linux-x64",
+    "linux-x64-gnu",
+    "darwin-arm64-glibc",
+    "linux",
+    "any-x64",
+  ])("rejects %j", (target) => {
+    expect(safeParseModulePackageTarget(target).success).toBe(false);
+  });
+});
+
+describe("the generated runtime package.json", () => {
+  it("holds exactly what module discovery reads", () => {
+    expect(
+      modulePackageRuntimePackage({ name: "@ekklesia/module-template", version: "0.1.0" }),
+    ).toEqual({
+      name: "@ekklesia/module-template",
+      version: "0.1.0",
+      private: true,
+      type: "module",
+      ekklesia: { layer: "module" },
+    });
+  });
+
+  it("accepts the generated shape and nothing more", () => {
+    const generated = modulePackageRuntimePackage({ name: "@scope/example", version: "1.2.3" });
+    expect(safeParseModulePackageRuntimePackage(generated).success).toBe(true);
+    for (const extra of [
+      { dependencies: { "@ekklesia/module-sdk": "workspace:*" } },
+      { scripts: { build: "tsc" } },
+      { exports: { ".": "./dist/server/index.js" } },
+      { imports: { "#x": "./x.js" } },
+    ]) {
+      expect(safeParseModulePackageRuntimePackage({ ...generated, ...extra }).success).toBe(false);
+    }
+    expect(safeParseModulePackageRuntimePackage({ ...generated, type: "commonjs" }).success).toBe(
+      false,
+    );
+  });
+});