chore: harden repository guardrails

tests/boundaries.test.ts

@@ -12,21 +12,93 @@ describe("repository dependency boundaries", () => {
     expect(result.violations).toEqual([]);
   });
 
+  it("accepts generated module composition only through the generated bootstrap boundary", async () => {
+    const result = await checkBoundaries(path.join(fixtures, "legal-generated-bootstrap"));
+    expect(result.violations).toEqual([]);
+  });
+
+  it("honors explicit pnpm workspace exclusions", async () => {
+    const result = await checkBoundaries(path.join(fixtures, "workspace-exclusion"));
+    expect(result.violations).toEqual([]);
+  });
+
   it.each([
     ["core-imports-module", "core-is-feature-agnostic"],
+    ["app-imports-module", "apps-are-composition-roots"],
+    ["module-imports-core", "modules-use-public-platform-contracts"],
     ["module-imports-surface", "modules-use-public-platform-contracts"],
+    ["package-boundary-direction", "modules-use-public-platform-contracts"],
     ["cross-module-import", "modules-do-not-import-other-modules"],
+    ["surface-imports-module", "surfaces-use-public-contracts"],
+    ["cross-surface-import", "surfaces-are-independent"],
+    ["builder-imports-module", "builder-composes-contracts"],
+    ["contracts-import-core", "contracts-do-not-depend-upward"],
+    ["sdk-imports-core", "sdks-do-not-depend-on-implementations"],
+    ["shared-role-order", "sdks-do-not-depend-on-implementations"],
+    ["package-without-exports", "workspace-imports-use-public-exports"],
+    ["private-package-import", "workspace-imports-use-public-exports"],
+    ["non-workspace-version", "internal-dependencies-use-workspace-protocol"],
+    ["workspace-alias", "workspace-dependency-aliases-are-forbidden"],
+    ["undeclared-workspace-dependency", "workspace-dependencies-are-declared"],
+    ["duplicate-package-name", "workspace-package-names-are-unique"],
+    ["unknown-shared-role", "shared-packages-declare-known-roles"],
+    ["workspace-unsupported-pattern", "workspace-patterns-use-supported-syntax"],
+    ["package-cycle", "no-circular-package-dependencies"],
     ["module-has-ui", "modules-do-not-own-ui"],
+    ["module-ui-framework", "modules-do-not-own-ui"],
+    ["module-imports-ui-package", "modules-use-public-platform-contracts"],
+    ["cross-package-relative", "workspace-imports-use-public-exports"],
     ["cycle", "no-circular-source-dependencies"],
   ])("rejects %s", async (fixture, expectedRule) => {
     const result = await checkBoundaries(path.join(fixtures, fixture));
     expect(result.violations.map((violation) => violation.rule)).toContain(expectedRule);
   });
 
-  it("rejects both component and stylesheet files inside a module", async () => {
+  it("rejects component, stylesheet, and case-insensitive view files inside a module", async () => {
     const result = await checkBoundaries(path.join(fixtures, "module-has-ui"));
     expect(
       result.violations.filter((violation) => violation.rule === "modules-do-not-own-ui"),
+    ).toHaveLength(3);
+  });
+
+  it("rejects UI framework dependencies, imports, and view formats inside a module", async () => {
+    const result = await checkBoundaries(path.join(fixtures, "module-ui-framework"));
+    expect(
+      result.violations.filter((violation) => violation.rule === "modules-do-not-own-ui"),
+    ).toHaveLength(4);
+  });
+
+  it("requires workspace: ranges in every dependency field", async () => {
+    const result = await checkBoundaries(path.join(fixtures, "non-workspace-version"));
+    expect(
+      result.violations.filter(
+        (violation) => violation.rule === "internal-dependencies-use-workspace-protocol",
+      ),
+    ).toHaveLength(4);
+  });
+
+  it("resolves forbidden workspace aliases before applying layer rules", async () => {
+    const result = await checkBoundaries(path.join(fixtures, "workspace-alias"));
+    expect(
+      result.violations.filter(
+        (violation) => violation.rule === "workspace-dependency-aliases-are-forbidden",
+      ),
     ).toHaveLength(2);
+    expect(result.violations.map((violation) => violation.rule)).toEqual(
+      expect.arrayContaining([
+        "workspace-dependency-aliases-are-forbidden",
+        "modules-use-public-platform-contracts",
+      ]),
+    );
+  });
+
+  it("prevents contracts and SDKs from depending upward through shared packages", async () => {
+    const result = await checkBoundaries(path.join(fixtures, "shared-role-order"));
+    expect(result.violations.map((violation) => violation.rule)).toEqual(
+      expect.arrayContaining([
+        "contracts-do-not-depend-upward",
+        "sdks-do-not-depend-on-implementations",
+      ]),
+    );
   });
 });