@smartsoft001-mobilems/claude-plugins 2.86.0 → 2.88.0

package/plugins/mobilems/skills/mobilems-events/references/lib-contents.md

@@ -0,0 +1,212 @@
+# libs/museum-events — structure to create
+
+Copy from the reference MobilEMS app's `libs/museum-events` and thread `<PREFIX>`. Events ships a
+single project: `shell/angular`. It is a standalone booking module — it has no `domain` library, no
+NgRx `+state`, and no shared-module `forFeature`. Everything it needs lives in `shell/angular`.
+
+```
+libs/museum-events/
+└── shell/angular/                          # project: museum-events-shell-angular
+    ├── eslint.config.mjs
+    ├── jest.config.ts
+    ├── project.json
+    ├── tsconfig.json
+    ├── tsconfig.lib.json
+    ├── tsconfig.spec.json
+    └── src/
+        ├── index.ts                        # export * from './lib';
+        ├── test-setup.ts                   # setupZoneTestEnv(...) from jest-preset-angular
+        ├── __mocks__/
+        │   └── @smartsoft001-mobilems/
+        │       ├── angular.ts               # jest mock — keep
+        │       └── models.ts                # jest mock — keep
+        └── lib/
+            ├── index.ts                    # export * from './events.module'; export * from './events.routes';
+            ├── events.module.ts            # MuseumEventsModule (references/module-and-routes.md)
+            ├── events.routes.ts            # eventsRoutes — lazy loadComponent per page + Masonry on list
+            ├── models/
+            │   └── events.models.ts         # IEvent, IEventResponse, IEventsSearchResponse, IEventPeriod,
+            │                                #   IEventPeriodsResponse, IReservationRequest, IReservationResponse,
+            │                                #   IReservationValidationError
+            ├── pages/
+            │   ├── list/                     # EventsListComponent (+ template/styles)
+            │   ├── item/                     # EventItemComponent
+            │   ├── booking/                  # BookingComponent (+ .spec)
+            │   ├── confirm/                  # ConfirmComponent (+ .spec)
+            │   └── cancel/                   # CancelComponent (+ .spec)
+            ├── services/
+            │   └── events-reservation.service.ts   # EventsReservationService (+ .spec)
+            └── pipes/
+                └── time-format.pipe.ts       # TimeFormatPipe (standalone)
+```
+
+> Copy only what the reference has. There is **no `domain/` directory** for events and **no
+> `+state/` directory** — its event/reservation shapes are plain TypeScript interfaces in
+> `models/events.models.ts`.
+
+## `shell/angular/src/index.ts` and `lib/index.ts`
+
+The public barrel re-exports the lib barrel, which exports the module + the routes:
+
+```ts
+// src/index.ts
+export * from './lib';
+```
+
+```ts
+// src/lib/index.ts
+export * from './events.module';
+export * from './events.routes';
+```
+
+## Models — `lib/models/events.models.ts` (verbatim — pure types)
+
+Plain interfaces describing the events API and the reservation flow. Thread nothing; copy verbatim.
+
+```ts
+export interface IEvent {
+  id: number;
+  name: string;
+  image: string | null;
+  description: string | null;
+  startDate: string | null;
+  endDate: string | null;
+  ticketsLeft: number;
+  price: number;
+  location: {
+    name: string | null;
+    latitude: number | null;
+    longitude: number | null;
+  } | null;
+}
+
+export interface IEventResponse {
+  data: IEvent;
+  status: number;
+  message: string | null;
+}
+
+export interface IEventsSearchResponse {
+  data: {
+    paginatorDetails: {
+      currentPage: number;
+      maxPerPage: number;
+      totalItemsCount: number;
+      totalPagesCount: number;
+    };
+    items: IEvent[];
+  };
+  status: number;
+  message: string | null;
+}
+
+export interface IEventPeriod {
+  id: number;
+  start_time: string;
+  end_time: string;
+  available_seats: number;
+}
+
+export interface IEventPeriodsResponse {
+  periods: IEventPeriod[];
+}
+
+export interface IReservationRequest {
+  email: string;
+  firstName: string;
+  lastName?: string;
+  numberOfParticipants: number;
+  periodId: number;
+  eventId: number;
+  date: string;
+}
+
+export interface IReservationResponse {
+  message: string;
+  code: number;
+}
+
+export interface IReservationValidationError {
+  errors?: Record<string, string>;
+  message?: string;
+  code: number;
+}
+```
+
+## Service — `lib/services/events-reservation.service.ts`
+
+`EventsReservationService` is `@Injectable({ providedIn: 'root' })`. It injects `HttpClient`, reads
+`environment.apiUrl` from `@<PREFIX>/angular`, and calls the events API: `getEvent`,
+`getEvents` (paged search), `getAvailableDates` and `getPeriods` (the calendar / time-slot picker),
+and `register` / `confirm` / `cancel` (the reservation lifecycle). Copy verbatim and thread `<PREFIX>`
+on the `environment` import:
+
+```ts
+import { environment } from '@<PREFIX>/angular';
+```
+
+It depends on no shared module — the booking flow is entirely self-contained.
+
+## Pipe — `lib/pipes/time-format.pipe.ts` (verbatim)
+
+A small standalone pipe that trims a time string to `HH:mm`:
+
+```ts
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({ name: 'timeFormat', standalone: true })
+export class TimeFormatPipe implements PipeTransform {
+  transform(value: string): string {
+    if (!value) return value;
+    return value.substring(0, 5);
+  }
+}
+```
+
+## Pages — `lib/pages/{list,item,booking,confirm,cancel}` (copy verbatim, thread `<PREFIX>`)
+
+All five are standalone components, lazy-loaded by `events.routes.ts`:
+
+- **list** — `EventsListComponent`: the Masonry grid of events (uses `getEvents`).
+- **item** — `EventItemComponent`: a single event's detail (uses `getEvent`).
+- **booking** — `BookingComponent`: the reservation form (date picker via `getAvailableDates`,
+  time-slot via `getPeriods`, submit via `register`).
+- **confirm** — `ConfirmComponent`: confirmation landing for the `:id/potwierdzenie` route
+  (`confirm(token)`).
+- **cancel** — `CancelComponent`: cancellation landing for the `:id/anulowanie` route
+  (`cancel(token)`).
+
+Thread `<PREFIX>` on any `@<PREFIX>/angular` imports. The components also use `@ngx-translate/core`,
+`@smartsoft001-mobilems/angular`, `@smartsoft001/angular`, and `@thisissoon/angular-masonry` — all
+foundation packages.
+
+## Jest mocks — `src/__mocks__/@smartsoft001-mobilems/{angular,models}.ts` (keep)
+
+Copy both mock files verbatim. The jest config maps `@smartsoft001-mobilems/angular` and
+`@smartsoft001-mobilems/models` to these mocks (see `moduleNameMapper` below) so the lib's specs run
+without pulling the real packages.
+
+## Wiring
+
+- **tsconfig.base.json path** — add the single shell path (events has no domain path):
+  ```json
+  "@<PREFIX>/museum-events/shell/angular": ["libs/museum-events/shell/angular/src/index.ts"]
+  ```
+- **project.json** — copy the project config (name `museum-events-shell-angular`) and normalize every
+  path field to the lib's real location `libs/museum-events/shell/angular/...`. The reference's
+  `sourceRoot` is stale (`libs/museum-events/src` — missing the `shell/angular` segment); set it to
+  `libs/museum-events/shell/angular/src`. The `jestConfig` / `tsConfig` target options already point
+  at `libs/museum-events/shell/angular/...` — verify each field against a known-good sibling and fix
+  only the stale ones.
+- **jest.config.ts** — copy with `displayName: 'museum-events-shell-angular'`,
+  `coverageDirectory: '../../../../coverage/libs/museum-events/shell/angular'`, and the
+  `moduleNameMapper` pointing `@smartsoft001-mobilems/angular` and `@smartsoft001-mobilems/models` at
+  the `src/__mocks__/...` files. Copy `tsconfig.json`, `tsconfig.lib.json`, `tsconfig.spec.json`,
+  `eslint.config.mjs`, and `test-setup.ts` as-is.
+- **commit scope** — `commitlint.config.js` reads `libs/` dir names, so `museum-events` becomes a
+  valid scope automatically; no edit needed.
+
+Events imports only foundation packages (`@smartsoft001-mobilems/angular`,
+`@smartsoft001-mobilems/models`, `@smartsoft001/angular`, `@thisissoon/angular-masonry`,
+`@ngx-translate/core`), all installed by `mobilems-project-init`. It adds no new npm dependency (see
+SKILL.md step 1).

package/plugins/mobilems/skills/mobilems-events/references/module-and-routes.md

@@ -0,0 +1,113 @@
+# MuseumEventsModule + route registration
+
+## `libs/museum-events/shell/angular/src/lib/events.module.ts`
+
+`MuseumEventsModule` is a pure routing host: it imports `RouterModule.forChild(eventsRoutes)` and
+nothing else. There is no shared-module `forFeature` and no NgRx state — each page is a standalone
+component pulled in lazily by the routes, and data access goes through the standalone
+`EventsReservationService` (`providedIn: 'root'`). Copy this module verbatim; it has no `<PREFIX>` to
+thread.
+
+```ts
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+
+import { eventsRoutes } from './events.routes';
+
+@NgModule({
+  imports: [RouterModule.forChild(eventsRoutes)],
+})
+export class MuseumEventsModule {}
+```
+
+## `events.routes.ts`
+
+Every page is loaded lazily with `loadComponent`. The list route additionally provides the `Masonry`
+SSR factory (the real library in the browser, a no-op mock during SSR). Copy verbatim — there is no
+`<PREFIX>` to thread here either.
+
+```ts
+import { Route } from '@angular/router';
+import { Masonry } from '@thisissoon/angular-masonry';
+
+export const eventsRoutes: Route[] = [
+  {
+    path: ':id/potwierdzenie',
+    loadComponent: () =>
+      import('./pages/confirm/confirm.component').then(
+        (m) => m.ConfirmComponent,
+      ),
+  },
+  {
+    path: ':id/anulowanie',
+    loadComponent: () =>
+      import('./pages/cancel/cancel.component').then((m) => m.CancelComponent),
+  },
+  {
+    path: ':id/booking',
+    loadComponent: () =>
+      import('./pages/booking/booking.component').then(
+        (m) => m.BookingComponent,
+      ),
+  },
+  {
+    path: ':id/:slug',
+    loadComponent: () =>
+      import('./pages/item/item.component').then((m) => m.EventItemComponent),
+  },
+  {
+    path: ':id',
+    loadComponent: () =>
+      import('./pages/item/item.component').then((m) => m.EventItemComponent),
+  },
+  {
+    path: '',
+    loadComponent: () =>
+      import('./pages/list/list.component').then((m) => m.EventsListComponent),
+    providers: [
+      {
+        provide: Masonry,
+        useFactory: () => {
+          if (typeof window !== 'undefined' && (window as any)['Masonry']) {
+            return (window as any)['Masonry'];
+          }
+          return class {
+            layout() {
+              return;
+            }
+            reloadItems() {
+              return;
+            }
+            destroy() {
+              return;
+            }
+          };
+        },
+      },
+    ],
+  },
+];
+```
+
+> Route order matters: the specific reservation sub-routes (`:id/potwierdzenie`, `:id/anulowanie`,
+> `:id/booking`) come before the generic `:id/:slug` and `:id` detail routes, and the bare list route
+> `''` comes last. Keep this order.
+
+## Register in `apps/web/src/app/app.routes.ts`
+
+Events registers a single **top-level** route. Add the `wydarzenia` route to the `appRoutes` array
+(idempotently — if a `wydarzenia` route already exists, skip). Events is a booking destination
+browsed from the top level, so it is added at the top level only and is NOT placed under the
+`wyszukaj/:text` search route — events do not appear in search results.
+
+Top-level — add to `appRoutes`:
+
+```ts
+  {
+    path: 'wydarzenia',
+    loadChildren: () =>
+      import('@<PREFIX>/museum-events/shell/angular').then(
+        (m) => m.MuseumEventsModule,
+      ),
+  },
+```

package/plugins/mobilems/skills/mobilems-events/scripts/detect-init.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+#
+# detect-init.sh <workspace-root>
+#
+# Precondition gate for mobilems-objects (and the other module skills follow the same shape):
+# confirm the MobilEMS foundation from mobilems-project-init is present. Portable to macOS bash 3.2.
+#
+# Exit 0 → foundation present, OK to add the module.
+# Exit 3 → foundation missing (tell the user to run /mobilems:project-init first).
+set -eu
+
+ROOT="${1:?usage: detect-init.sh <workspace-root>}"
+cd "$ROOT" 2>/dev/null || { echo "ERROR: no such dir: $ROOT" >&2; exit 2; }
+
+miss() {
+  echo "FOUNDATION MISSING: $1" >&2
+  echo "Run /mobilems:project-init first to lay down the MobilEMS foundation." >&2
+  exit 3
+}
+
+[ -f apps/web/src/app/app.config.ts ] || miss "app.config.ts missing"
+grep -q "SharedModule.forRoot" apps/web/src/app/app.config.ts || miss "SharedModule.forRoot not in app.config.ts (foundation not applied)"
+grep -q "./lib/components" libs/shared/angular/src/index.ts 2>/dev/null || miss "shared-lib components barrel not populated"
+[ -f apps/web/src/app/app.routes.ts ] || miss "app.routes.ts missing"
+
+PREFIX="$(grep -oE '@[a-z0-9-]+/angular' tsconfig.base.json | head -1 | sed -E 's#@([a-z0-9-]+)/angular#\1#')"
+echo "FOUNDATION OK. Detected prefix: ${PREFIX:-<unknown>}"
+[ -d libs/museum-objects ] && echo "NOTE: libs/museum-objects already exists — build steps must be idempotent." >&2
+exit 0

package/plugins/mobilems/skills/mobilems-events/scripts/verify-module.sh

@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+#
+# verify-module.sh <workspace-root> <PREFIX>
+#
+# Post-condition check for mobilems-events: the standalone booking library created
+# (shell/angular only — no domain, no forFeature), MuseumEventsModule wiring RouterModule.forChild,
+# lazy routes, the five pages + reservation service + models + time-format pipe present, the
+# wydarzenia route registered as a single top-level route, and the foundation deps it reuses present.
+# macOS bash 3.2 safe.
+set -eu
+
+ROOT="${1:?usage: verify-module.sh <workspace-root> <PREFIX>}"
+PREFIX="${2:?usage: verify-module.sh <workspace-root> <PREFIX>}"
+cd "$ROOT" 2>/dev/null || { echo "ERROR: no such dir: $ROOT" >&2; exit 2; }
+
+fail=0
+pass() { echo "  PASS: $1"; }
+bad()  { echo "  FAIL: $1" >&2; fail=1; }
+
+SHELL_LIB=libs/museum-events/shell/angular
+LIB="$SHELL_LIB/src/lib"
+MOD="$LIB/events.module.ts"
+ROUTES="$LIB/events.routes.ts"
+
+echo "== Library =="
+[ -d "$SHELL_LIB" ] && pass "shell/angular project present" || bad "libs/museum-events/shell/angular missing"
+[ -f "$MOD" ] && pass "events.module.ts present" || bad "events.module.ts missing"
+grep -q "class MuseumEventsModule" "$MOD" 2>/dev/null && pass "MuseumEventsModule class declared" || bad "MuseumEventsModule class not declared"
+grep -q "RouterModule.forChild" "$MOD" 2>/dev/null && pass "RouterModule.forChild wired" || bad "RouterModule.forChild missing in module"
+[ -f "$ROUTES" ] && pass "events.routes.ts present" || bad "events.routes.ts missing"
+grep -q "@$PREFIX/museum-events/shell/angular" tsconfig.base.json && pass "tsconfig shell path added" || bad "tsconfig @$PREFIX/museum-events/shell/angular path missing"
+
+echo "== Pages =="
+for p in list item booking confirm cancel; do
+  [ -f "$LIB/pages/$p/$p.component.ts" ] && pass "$p page present" || bad "pages/$p/$p.component.ts missing"
+done
+
+echo "== Service, models, pipe =="
+[ -f "$LIB/services/events-reservation.service.ts" ] && pass "events-reservation.service.ts present" || bad "services/events-reservation.service.ts missing"
+grep -q "class EventsReservationService" "$LIB/services/events-reservation.service.ts" 2>/dev/null && pass "EventsReservationService class declared" || bad "EventsReservationService class not declared"
+[ -f "$LIB/models/events.models.ts" ] && pass "events.models.ts present" || bad "models/events.models.ts missing"
+[ -f "$LIB/pipes/time-format.pipe.ts" ] && pass "time-format.pipe.ts present" || bad "pipes/time-format.pipe.ts missing"
+grep -q "class TimeFormatPipe" "$LIB/pipes/time-format.pipe.ts" 2>/dev/null && pass "TimeFormatPipe class declared" || bad "TimeFormatPipe class not declared"
+
+echo "== Route registration =="
+APP_ROUTES=apps/web/src/app/app.routes.ts
+grep -q "@$PREFIX/museum-events/shell/angular" "$APP_ROUTES" && pass "events route registered" || bad "events route not in app.routes.ts"
+# single top-level route — expect exactly 1 occurrence
+n=$(grep -c "@$PREFIX/museum-events/shell/angular" "$APP_ROUTES" || true)
+[ "${n:-0}" -eq 1 ] && pass "registered as a single top-level route ($n)" || bad "expected exactly 1 route registration, found $n"
+grep -q "wydarzenia" "$APP_ROUTES" && pass "wydarzenia path present" || bad "wydarzenia path missing"
+
+echo "== Foundation deps =="
+grep -q "@smartsoft001-mobilems/angular" package.json && pass "@smartsoft001-mobilems/angular present" || bad "@smartsoft001-mobilems/angular missing"
+grep -q "@smartsoft001-mobilems/models" package.json && pass "@smartsoft001-mobilems/models present" || bad "@smartsoft001-mobilems/models missing"
+
+echo
+if [ "$fail" = 0 ]; then echo "VERIFY: all checks passed."; else echo "VERIFY: FAILED — fix the items above and re-run." >&2; fi
+exit "$fail"

package/plugins/mobilems/skills/mobilems-object-collections/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: mobilems-object-collections
+description: Add the museum COLLECTIONS feature module to a MobilEMS app initialized with mobilems-project-init. Use whenever the user wants to add / scaffold / wire the collections (kolekcje) module, the public collections module, the collection list + detail pages, the collections filters (keywords / cycles), or asks to "dodaj moduł kolekcji". Creates libs/museum-collections (domain + shell/angular), registers the /kolekcje route, builds the collections shared component, and adds the public-collections npm packages. Requires the MobilEMS foundation to exist first.
+user-invocable: true
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, AskUserQuestion
+---
+
+# MobilEMS collections module
+
+Add the **collections** (kolekcje) feature module to a MobilEMS app whose foundation was built by
+`mobilems-project-init`. This skill builds the `libs/museum-collections` library, the collections
+shared component, the collections route, and adds the public-collections npm packages.
+
+Collections is a list/detail view backed by `PublicCollectionsSharedModule.forFeature` over the
+`MuseumCollection` entity, with a `filters` component that narrows the list by keywords and cycles.
+
+## Precondition
+
+Run `scripts/detect-init.sh <workspace-root>`. It confirms the MobilEMS foundation is present
+(`SharedModule.forRoot` in `app.config.ts`, a populated shared-lib barrel). If not, tell the user to
+run `/mobilems:project-init` first. Hold `<PREFIX>` (from `tsconfig.base.json`; reference uses
+`@msr`) and the reference repo path (same one init used).
+
+## Steps
+
+1. **npm deps** — add `@smartsoft001-mobilems/public-collections-domain`,
+   `@smartsoft001-mobilems/public-collections-shell-angular`,
+   `@smartsoft001-mobilems/public-collections-shell-dtos` (match the installed mobilems line).
+   Resolve versions at run time; do not `npm install` unless asked. No extra third-party viewer deps.
+2. **Library** — create `libs/museum-collections/{domain,shell/angular}` per `references/lib-contents.md`:
+   copy the domain entity (`MuseumCollection extends PublicCollection`) and the shell
+   (`MuseumCollectionsModule`, routes, `components/filters`, `pages/{list,item}`, `services`), thread
+   `<PREFIX>`. Add the two `tsconfig.base.json` paths and the `museum-collections` commit scope.
+3. **Module + routes** — see `references/module-and-routes.md`: `MuseumCollectionsModule` wraps
+   `PublicCollectionsSharedModule.forFeature({ routing: false, config: { type: MuseumCollection, apiUrl, entity: 'publicCollections' } })`
+   with the `Masonry` SSR factory and the `CrudService → CollectionsService` provider. Add the lazy
+   `kolekcje` route to `appRoutes` in `apps/web/src/app/app.routes.ts` and a matching child under the
+   `wyszukaj/:text` search route.
+4. **Collections shared component** — see `references/shared-components.md`: build
+   `components/collections-grid-item` (it imports `public-collections-domain`) in the shared lib and
+   export it from `components/index.ts`. Collections contributes no widget-map entry and no model type
+   (those are objects-only).
+5. **Verify** — run `scripts/verify-module.sh <workspace-root> <PREFIX>`: asserts the lib +
+   `MuseumCollection` entity exist, the `forFeature` is wired, the `kolekcje` route is registered
+   (top-level + search child), the `collections-grid-item` component is built and exported, and the
+   three public-collections deps are present. Fix and re-run.
+
+## Known QA pitfalls (from live deployments — fix while copying, not after)
+
+Each of these was a real Linear bug on a museum project built with this skill (Ostrowiec MOB-961/994,
+Tomaszów MOB-956). The cross-cutting rules live in `mobilems-project-init`
+`references/qa-hardening.md`; these are the collections-specific ones:
+
+- **One card component, reused everywhere.** The home page and the collection detail must render the
+  SAME shared `collections-grid-item` / object card components as the list views — a second ad-hoc
+  card on the home page was a High-priority bug (MOB-994). Never fork a card per page.
+- **No hardcoded UI strings.** The detail heading was shipped as a literal `Zbiory {{ title }}` and
+  stayed Polish in EN — every static label goes through a translation key (PL + EN in
+  `translations.json`). The list page needs a VISIBLE translated heading (not only `sr-only`), and
+  exactly one `h1` per page.
+- **Card image fallback:** when a collection thumbnail fails to load, show the app's `no-image`
+  placeholder instead of a broken image.
+- **Hover:** underline the card **title** on hover (not the "Zobacz więcej" link) — same pattern as
+  objects.
+- **Search debounce 250 ms** in the filters (`@debounce(250)`), total count + shared
+  `NextPageComponent` on the list — consistent with objects/news.
+- **Keyword/cycle chips wrap on 360 px** — chips caused page-level horizontal scroll on mobile.
+- **Heading font must cover Polish diacritics** — collection card titles rendered in a fallback
+  font because the configured serif (Bacasime Antique) lacks `ą ć ę ł ń ś ź ż`; verify the Tailwind
+  heading `fontFamily` is non-empty and latin-ext complete (see qa-hardening).
+- **Warning-clean templates:** remove needless `?.` on non-nullable signals (NG8107) after copying.
+
+## Notes
+
+- This skill builds only the collections module + its shared component + its route. It never adds
+  other feature modules and never re-runs the foundation.
+- Bundled `references/` + `scripts/` ship automatically. Do not hand-edit `plugin.json`.

package/plugins/mobilems/skills/mobilems-object-collections/references/lib-contents.md

@@ -0,0 +1,76 @@
+# libs/museum-collections — structure to create
+
+Copy from the reference repo's `libs/museum-collections` and thread `<PREFIX>`. The lib has two
+projects: a `domain` (the entity) and a `shell/angular` (the Angular module + UI). Both rely on Nx
+inferred targets + the `tsconfig.base.json` path mappings — there are **no** `project.json` /
+`package.json` / `tsconfig.*.json` / `jest.config` / `__mocks__` files under either project (only
+`src/`). This is leaner than `museum-objects`; do not invent config files the reference doesn't have.
+
+```
+libs/museum-collections/
+├── domain/                              # project: museum-collections-domain (inferred)
+│   └── src/
+│       ├── index.ts                     # export * from './lib/entities';
+│       └── lib/
+│           └── entities/                # MuseumCollection extends PublicCollection (+ index)
+└── shell/angular/                       # project: museum-collections-shell-angular (inferred)
+    └── src/
+        ├── index.ts                     # export * from './lib/pages'; ./lib/components; ./lib/collections.module
+        └── lib/
+            ├── collections.module.ts    # MuseumCollectionsModule (references/module-and-routes.md)
+            ├── collections.routes.ts
+            ├── components/              # filters (keywords/cycles) + index
+            ├── pages/                   # list (ListComponent), item (ItemComponent) + index
+            └── services/               # collections.service.ts + index
+```
+
+There are no `enums/`, `specifications/`, or `value-objects/` dirs in the domain — the connection
+shape (keywords/cycles) is inlined on the entity below.
+
+## Domain entity (verbatim, thread nothing — pure types)
+
+`MuseumCollection extends PublicCollection` (from `@smartsoft001-mobilems/public-collections-domain`)
+adds `paginatorDetails?` and a `connections?` block (keywords + cycles). Reproduce exactly:
+
+```ts
+import { Model } from '@smartsoft001/models';
+import { PublicCollection } from '@smartsoft001-mobilems/public-collections-domain';
+
+@Model({})
+export class MuseumCollection extends PublicCollection {
+  paginatorDetails?: {
+    currentPage: number;
+    maxPerPage: number;
+    totalItemsCount: number;
+    totalPagesCount: number;
+  };
+
+  connections?: {
+    keywords: {
+      id: number;
+      name: string;
+      count: number;
+    }[];
+    cycles: {
+      id: number;
+      name: string;
+      count: number;
+    }[];
+  };
+}
+```
+
+## Wiring
+
+- **tsconfig.base.json paths** (add both):
+  ```json
+  "@<PREFIX>/museum-collections/domain": ["libs/museum-collections/domain/src/index.ts"],
+  "@<PREFIX>/museum-collections/shell/angular": ["libs/museum-collections/shell/angular/src/index.ts"]
+  ```
+- **project.json** — none in the reference; both projects use Nx inferred targets. Do not add one.
+- **commit scope** — `commitlint.config.js` reads `libs/` dir names, so `museum-collections` becomes
+  a valid scope automatically; no edit needed.
+
+The `components/filters` component renders the keyword/cycle facets exposed by the entity's
+`connections` block; the list/detail rendering itself comes from `PublicCollectionsSharedModule`.
+No third-party viewer deps are needed (unlike the objects 3D tab).