@house-rules/projects 0.0.0-stage → 0.1.1

package/AGENTS.md

@@ -0,0 +1,17 @@
+# @house-rules/projects: notes for agents
+
+Projects is a capability module owning project records, not tasks, repositories or notes. Read `README.md` for options and adoption differences.
+
+## Mount and bind
+
+Use `Projects.layerPostgres(options)` with the shared SQL client, or `Projects.layerMemory(options)` with the memory unit adapter. Raw `Projects.layer(options)` needs `ProjectStore`. Storage statics default to `Projects.presets.default`; raw Projects.layer requires options. Add `{ ...ProjectsMount, layer }` to the module plan. Composition captures Projects and calls `bindProjects` once through Runtime. Features call `ProjectsOperations.create/update/show/list/archive` through declared edges.
+
+Register `{ "workspace": "packages/projects" }` in migrations.json. Installed consumers use `{ "package": "@house-rules/projects" }`. Migrations own `projects` and publish `projects_view` over that table alone. The view exposes id, slug, name, status, description, created_at and updated_at. Read models must filter access themselves.
+
+## Access and facts
+
+Person callers need `projects:read` or `projects:write`. All operation bindings refuse system callers with ProjectAccessDenied, even when system permissions include those grants. No ownership is stored or inferred. Without ProjectAccess, every permitted person can access every project. Composition may provide ProjectAccess before acquiring Projects. Its access method takes the actor and project id, or null for creation, and returns write/read/none. Its visibleProjects method returns ids for storage filtering. Lists trust that id set. Denied existing objects appear not found; denied creation is forbidden. Port failures use ProjectAccessUnavailable.
+
+Writes return `{ project, events }`. ProjectCreated carries the stored project. ProjectUpdated carries before and after, including slug changes and archiving. No-op changes return the unchanged project and no events. Import ProjectEvents from the browser-safe contract door. The composing layer decides whether to record facts. Projects never emits events or reads CurrentActor.
+
+Writes require an open unit and never open one. Memory registers undo before mutation. Postgres serializes module writes with a transaction advisory lock, then joins the open transaction. Do not remove the lock without preserving atomic slug conflicts and read/modify/write behaviour. Invalid input returns ProjectInputInvalid with field slug/name/status and a safe user-facing message; invalid configuration uses field options. Unavailable errors expose fixed text, never their cause.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jakub Szwajka
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,42 @@
-# Temporary Holding Version
+# @house-rules/projects
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Project records with configurable statuses and unique slugs. This support module is not in the public publish workflow.
+
+## Mount
+
+```ts
+const projects = Projects.layerPostgres(Projects.presets.default);
+const mount = { ...ProjectsMount, layer: projects };
+```
+
+Provide the shared SQL client and sqlUnitOfWork in the module plan's infrastructure. Use Projects.layerMemory with memoryUnitOfWork for memory storage. Register packages/projects in migrations.json, or the package identity when installed. Composition binds operations through bindProjects once. Features call ProjectsOperations through declared edges; write operations lift transactional.
+
+## Options
+
+Projects.presets.default supplies statuses active/archived, defaultStatus active and archivedStatus archived. Configuration must list distinct, nonempty statuses and contain both chosen statuses. Statuses are exact, case-sensitive strings. Set all options when overriding the preset, or spread it to change selected values.
+
+The default slug rules trim and lowercase input, require a letter or digit first, then lowercase letters, digits or hyphens, and cap length at 64 UTF-16 units. Configure slug.pattern as a regular-expression source, slug.maxLength, slug.lowercase and slug.trim. The pattern applies after normalisation; use anchors for whole-slug rules. Invalid regex syntax fails acquisition as ProjectInputInvalid. Slugs remain unique regardless of status. Names are trimmed and require 1 to 200 UTF-16 units. Descriptions are plain text, defaulting to an empty string. Invalid slug, name or status returns ProjectInputInvalid with the field and a safe user-facing message. Invalid configuration uses field options.
+
+## Operations and facts
+
+| Operation | Input | Result |
+| --- | --- | --- |
+| create | slug, name, optional status and description | project plus ProjectCreated fact |
+| update | ref and patch with optional slug/name/status/description | project plus ProjectUpdated fact when changed |
+| show | `{ id }` or `{ slug }` | project |
+| list | optional status | projects ordered by lowercased name, then slug |
+| archive | `{ id }` or `{ slug }` | update result using archivedStatus |
+
+List without a status includes all projects, including archived records. Apps must filter the statuses they want to show. Slug changes are allowed; apps that forbid them must enforce that rule in their features. Explicit status filters are validated. Ordering uses JavaScript lowercase and code-unit comparison in both adapters, independent of database collation. Archive is a status change, not a delete. A repeated archive or unchanged patch returns the existing project with an empty events array and leaves updatedAt unchanged. Timestamps are epoch milliseconds. Facts contain plain project snapshots without envelopes; a feature may record them through its own event-log edge.
+
+## Access
+
+Person operation callers need projects:read or projects:write. All bindings refuse system callers, even with those grants. The raw service accepts an explicit Actor and assumes the composing layer has checked permissions. Without ProjectAccess there is no object access rule. To restrict objects, provide ProjectAccess when acquiring Projects. access(actor, projectId) returns write/read/none; null checks creation. visibleProjects(actor) returns ids to filter lists in storage, including SQL. A read relation cannot write. Denied reads or changes return ProjectNotFound; denied creation returns ProjectAccessDenied. Map host failures to ProjectAccessUnavailable. The port belongs to Projects and stores no host policy.
+
+## Storage
+
+Both adapters require an open unit for writes and support rollback. Postgres serializes module mutations with a transaction-scoped advisory lock to preserve rename uniqueness and prevent lost field updates. Seed scripts and other direct writers must take the same `pg_advisory_xact_lock(hashtext('house-rules/projects'))` in their transaction before checking or writing slugs. Otherwise, concurrent duplicates can return ProjectStoreUnavailable rather than ProjectSlugTaken. It decodes rows through Schema. The projects_view publishes only this module's columns. Consumers must apply their own access filters when selecting that view. Run the shared memory/Postgres suites with `pnpm --filter @house-rules/projects test`; database tests use MigrationsTesting.database.
+
+## Board adoption
+
+Configure active/paused/done/archived and the board slug pattern `^[a-z0-9][a-z0-9_-]{0,63}$`, with lowercase and trim disabled, to keep board's strict slug acceptance. The default framework rules instead normalise case/space and reject underscores. Board's list hides done/archived by default; this list includes every status unless one status is requested. Board's ordering uses PostgreSQL lower(name) and its collation; this module uses deterministic JavaScript comparison. Board's no-op update is null; here it is a project with no facts. Records expose a stable text id and epoch-millisecond createdAt/updatedAt instead of board's createdAt string and hidden UUID. Slug changes are supported. Joined task counts, repositories, tasks and notes remain app read-model work. Board keeps owner/agent writes in composition's access port. No board files are changed by this package.

package/dist/adapters/memory/project.d.ts

@@ -0,0 +1,3 @@
+import { Layer } from "effect";
+import { ProjectStore } from "../../storage.js";
+export declare const memoryProjectStore: () => Layer.Layer<ProjectStore>;

package/dist/adapters/memory/project.js

@@ -0,0 +1,40 @@
+import { UnitOfWork } from "@house-rules/domain";
+import { Effect, Layer } from "effect";
+import { ProjectStore } from "../../storage.js";
+import { ProjectSlugTaken, ProjectStoreUnavailable } from "../../project/project.js";
+import { projectOrder } from "../../project/order.js";
+export const memoryProjectStore = () => Layer.sync(ProjectStore, () => {
+    const rows = new Map();
+    const save = Effect.fn("ProjectStore.memory.save")(function* (project, insert) {
+        yield* UnitOfWork.required;
+        if ([...rows.values()].some((row) => row.slug === project.slug && row.id !== project.id)) {
+            return yield* new ProjectSlugTaken({ slug: project.slug });
+        }
+        const before = rows.get(project.id);
+        if (insert === (before !== undefined))
+            return yield* new ProjectStoreUnavailable({ cause: "Invalid project id." });
+        yield* UnitOfWork.onRollback(Effect.sync(() => {
+            if (before === undefined)
+                rows.delete(project.id);
+            else
+                rows.set(project.id, before);
+        }));
+        rows.set(project.id, { ...project });
+    });
+    return ProjectStore.of({
+        lock: UnitOfWork.required,
+        get: (ref) => Effect.sync(() => {
+            const found = "id" in ref
+                ? rows.get(ref.id)
+                : [...rows.values()].find((row) => row.slug === ref.slug);
+            return found === undefined ? undefined : { ...found };
+        }),
+        list: (status, ids) => Effect.sync(() => [...rows.values()]
+            .filter((row) => (status === undefined || row.status === status) &&
+            (ids === undefined || ids.includes(row.id)))
+            .sort(projectOrder)
+            .map((row) => ({ ...row }))),
+        insert: (project) => save(project, true),
+        replace: (project) => save(project, false),
+    });
+});

package/dist/adapters/postgres/project.d.ts

@@ -0,0 +1,4 @@
+import { Layer } from "effect";
+import { SqlClient } from "effect/sql/SqlClient";
+import { ProjectStore } from "../../storage.js";
+export declare const postgresProjectStore: Layer.Layer<ProjectStore, never, SqlClient>;

package/dist/adapters/postgres/project.js

@@ -0,0 +1,42 @@
+import { UnitOfWork } from "@house-rules/domain";
+import { Effect, Layer, Schema } from "effect";
+import { SqlClient } from "effect/sql/SqlClient";
+import { ProjectStore } from "../../storage.js";
+import { Project, ProjectSlugTaken, ProjectStoreUnavailable } from "../../project/project.js";
+import { projectOrder } from "../../project/order.js";
+const decodeRows = Schema.decodeUnknownEffect(Schema.Array(Project));
+const unavailable = (cause) => new ProjectStoreUnavailable({ cause });
+export const postgresProjectStore = Layer.effect(ProjectStore, Effect.gen(function* () {
+    const sql = yield* SqlClient;
+    const columns = sql.literal('id, slug, name, status, description, created_at::float8 as "createdAt", updated_at::float8 as "updatedAt"');
+    const read = (query) => query.pipe(Effect.flatMap(decodeRows), Effect.mapError(unavailable));
+    // One transaction lock keeps rename conflicts and read/modify/write changes atomic.
+    const lock = Effect.gen(function* () {
+        yield* UnitOfWork.required;
+        yield* sql `select pg_advisory_xact_lock(hashtext('house-rules/projects'))`.pipe(Effect.mapError(unavailable));
+    });
+    const save = Effect.fn("ProjectStore.postgres.save")(function* (project, insert) {
+        yield* lock;
+        const taken = yield* sql `select id from projects where slug = ${project.slug} and id <> ${project.id}`.pipe(Effect.mapError(unavailable));
+        if (taken.length > 0)
+            return yield* new ProjectSlugTaken({ slug: project.slug });
+        const rows = yield* read(insert
+            ? sql `insert into projects (id, slug, name, status, description, created_at, updated_at) values (${project.id}, ${project.slug}, ${project.name}, ${project.status}, ${project.description}, ${project.createdAt}, ${project.updatedAt}) on conflict (slug) do nothing returning ${columns}`
+            : sql `update projects set slug = ${project.slug}, name = ${project.name}, status = ${project.status}, description = ${project.description}, updated_at = ${project.updatedAt} where id = ${project.id} returning ${columns}`);
+        if (rows.length === 0)
+            return yield* new ProjectStoreUnavailable({ cause: "Project write returned no row." });
+    });
+    return ProjectStore.of({
+        lock,
+        get: (ref) => read("id" in ref
+            ? sql `select ${columns} from projects where id = ${ref.id}`
+            : sql `select ${columns} from projects where slug = ${ref.slug}`).pipe(Effect.map((rows) => rows[0])),
+        list: (status, ids) => {
+            if (ids !== undefined && ids.length === 0)
+                return Effect.succeed([]);
+            return read(sql `select ${columns} from projects where ${status === undefined ? sql `true` : sql `status = ${status}`} and ${ids === undefined ? sql `true` : sql `id in ${sql.in(ids)}`}`).pipe(Effect.map((rows) => [...rows].sort(projectOrder)));
+        },
+        insert: (project) => save(project, true),
+        replace: (project) => save(project, false),
+    });
+}));

package/dist/contract.d.ts

@@ -0,0 +1,4 @@
+export { CreateProjectResult, UpdateProjectResult, ProjectEvents } from "./project/events.js";
+export { ProjectsOperations } from "./project/operations.js";
+export { ProjectPermissions, type ProjectPermission } from "./project/permissions.js";
+export { Project, ProjectRef, NewProject, ProjectPatch, ProjectFilter, ProjectFailure, ProjectNotFound, ProjectSlugTaken, ProjectInputInvalid, ProjectAccessDenied, ProjectAccessUnavailable, ProjectStoreUnavailable, } from "./project/project.js";

package/dist/contract.js

@@ -0,0 +1,4 @@
+export { CreateProjectResult, UpdateProjectResult, ProjectEvents } from "./project/events.js";
+export { ProjectsOperations } from "./project/operations.js";
+export { ProjectPermissions } from "./project/permissions.js";
+export { Project, ProjectRef, NewProject, ProjectPatch, ProjectFilter, ProjectFailure, ProjectNotFound, ProjectSlugTaken, ProjectInputInvalid, ProjectAccessDenied, ProjectAccessUnavailable, ProjectStoreUnavailable, } from "./project/project.js";

package/dist/facade.d.ts

@@ -0,0 +1,304 @@
+import { Effect, Layer } from "effect";
+import { ProjectStore } from "./storage.js";
+import { ProjectsOptions } from "./project/options.js";
+import { ProjectInputInvalid } from "./project/project.js";
+declare const Projects_base: import("effect/Context").ServiceClass<Projects, "projects", {
+    create: (actor: {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+    }, input: {
+        readonly slug: string;
+        readonly name: string;
+        readonly status?: string;
+        readonly description?: string;
+    }) => Effect.Effect<{
+        project: {
+            readonly id: string;
+            readonly slug: string;
+            readonly name: string;
+            readonly status: string;
+            readonly description: string;
+            readonly createdAt: number;
+            readonly updatedAt: number;
+        };
+        events: {
+            kind: "ProjectCreated";
+            project: {
+                id: string;
+                slug: string;
+                name: string;
+                status: string;
+                description: string;
+                createdAt: number;
+                updatedAt: number;
+            };
+        }[];
+    }, import("@house-rules/domain").NoOpenUnit | import("./project/project.js").ProjectAccessDenied | import("./project/project.js").ProjectAccessUnavailable | ProjectInputInvalid | import("./project/project.js").ProjectNotFound | import("./project/project.js").ProjectSlugTaken | import("./project/project.js").ProjectStoreUnavailable, never>;
+    update: (actor: {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+    }, ref: {
+        readonly id: string;
+    } | {
+        readonly slug: string;
+    }, patch: {
+        readonly slug?: string;
+        readonly name?: string;
+        readonly status?: string;
+        readonly description?: string;
+    }) => Effect.Effect<{
+        project: {
+            readonly id: string;
+            readonly slug: string;
+            readonly name: string;
+            readonly status: string;
+            readonly description: string;
+            readonly createdAt: number;
+            readonly updatedAt: number;
+        };
+        events: {
+            kind: "ProjectUpdated";
+            before: {
+                id: string;
+                slug: string;
+                name: string;
+                status: string;
+                description: string;
+                createdAt: number;
+                updatedAt: number;
+            };
+            after: {
+                id: string;
+                slug: string;
+                name: string;
+                status: string;
+                description: string;
+                createdAt: number;
+                updatedAt: number;
+            };
+        }[];
+    }, import("@house-rules/domain").NoOpenUnit | import("./project/project.js").ProjectAccessDenied | import("./project/project.js").ProjectAccessUnavailable | ProjectInputInvalid | import("./project/project.js").ProjectNotFound | import("./project/project.js").ProjectSlugTaken | import("./project/project.js").ProjectStoreUnavailable, never>;
+    archive: (actor: import("@house-rules/domain").Actor, ref: import("./project/project.js").ProjectRef) => Effect.Effect<{
+        project: {
+            readonly id: string;
+            readonly slug: string;
+            readonly name: string;
+            readonly status: string;
+            readonly description: string;
+            readonly createdAt: number;
+            readonly updatedAt: number;
+        };
+        events: {
+            kind: "ProjectUpdated";
+            before: {
+                id: string;
+                slug: string;
+                name: string;
+                status: string;
+                description: string;
+                createdAt: number;
+                updatedAt: number;
+            };
+            after: {
+                id: string;
+                slug: string;
+                name: string;
+                status: string;
+                description: string;
+                createdAt: number;
+                updatedAt: number;
+            };
+        }[];
+    }, import("@house-rules/domain").NoOpenUnit | import("./project/project.js").ProjectAccessDenied | import("./project/project.js").ProjectAccessUnavailable | ProjectInputInvalid | import("./project/project.js").ProjectNotFound | import("./project/project.js").ProjectSlugTaken | import("./project/project.js").ProjectStoreUnavailable, never>;
+    show: (actor: import("@house-rules/domain").Actor, ref: import("./project/project.js").ProjectRef) => Effect.Effect<{
+        readonly id: string;
+        readonly slug: string;
+        readonly name: string;
+        readonly status: string;
+        readonly description: string;
+        readonly createdAt: number;
+        readonly updatedAt: number;
+    }, import("./project/project.js").ProjectAccessDenied | import("./project/project.js").ProjectAccessUnavailable | import("./project/project.js").ProjectNotFound | import("./project/project.js").ProjectStoreUnavailable, never>;
+    list: (actor: {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+    }, filter?: {
+        readonly status?: string;
+    } | undefined) => Effect.Effect<readonly {
+        readonly id: string;
+        readonly slug: string;
+        readonly name: string;
+        readonly status: string;
+        readonly description: string;
+        readonly createdAt: number;
+        readonly updatedAt: number;
+    }[], import("./project/project.js").ProjectAccessUnavailable | ProjectInputInvalid | import("./project/project.js").ProjectStoreUnavailable, never>;
+}> & {
+    readonly id: "projects";
+} & {
+    readonly make: (options: {
+        readonly statuses: readonly string[];
+        readonly defaultStatus: string;
+        readonly archivedStatus: string;
+        readonly slug: {
+            readonly pattern: string;
+            readonly maxLength: number;
+            readonly lowercase: boolean;
+            readonly trim: boolean;
+        };
+    } | undefined) => Effect.Effect<{
+        create: (actor: {
+            readonly id: string & import("effect/Brand").Brand<"ActorId">;
+        }, input: {
+            readonly slug: string;
+            readonly name: string;
+            readonly status?: string;
+            readonly description?: string;
+        }) => Effect.Effect<{
+            project: {
+                readonly id: string;
+                readonly slug: string;
+                readonly name: string;
+                readonly status: string;
+                readonly description: string;
+                readonly createdAt: number;
+                readonly updatedAt: number;
+            };
+            events: {
+                kind: "ProjectCreated";
+                project: {
+                    id: string;
+                    slug: string;
+                    name: string;
+                    status: string;
+                    description: string;
+                    createdAt: number;
+                    updatedAt: number;
+                };
+            }[];
+        }, import("@house-rules/domain").NoOpenUnit | import("./project/project.js").ProjectAccessDenied | import("./project/project.js").ProjectAccessUnavailable | ProjectInputInvalid | import("./project/project.js").ProjectNotFound | import("./project/project.js").ProjectSlugTaken | import("./project/project.js").ProjectStoreUnavailable, never>;
+        update: (actor: {
+            readonly id: string & import("effect/Brand").Brand<"ActorId">;
+        }, ref: {
+            readonly id: string;
+        } | {
+            readonly slug: string;
+        }, patch: {
+            readonly slug?: string;
+            readonly name?: string;
+            readonly status?: string;
+            readonly description?: string;
+        }) => Effect.Effect<{
+            project: {
+                readonly id: string;
+                readonly slug: string;
+                readonly name: string;
+                readonly status: string;
+                readonly description: string;
+                readonly createdAt: number;
+                readonly updatedAt: number;
+            };
+            events: {
+                kind: "ProjectUpdated";
+                before: {
+                    id: string;
+                    slug: string;
+                    name: string;
+                    status: string;
+                    description: string;
+                    createdAt: number;
+                    updatedAt: number;
+                };
+                after: {
+                    id: string;
+                    slug: string;
+                    name: string;
+                    status: string;
+                    description: string;
+                    createdAt: number;
+                    updatedAt: number;
+                };
+            }[];
+        }, import("@house-rules/domain").NoOpenUnit | import("./project/project.js").ProjectAccessDenied | import("./project/project.js").ProjectAccessUnavailable | ProjectInputInvalid | import("./project/project.js").ProjectNotFound | import("./project/project.js").ProjectSlugTaken | import("./project/project.js").ProjectStoreUnavailable, never>;
+        archive: (actor: import("@house-rules/domain").Actor, ref: import("./project/project.js").ProjectRef) => Effect.Effect<{
+            project: {
+                readonly id: string;
+                readonly slug: string;
+                readonly name: string;
+                readonly status: string;
+                readonly description: string;
+                readonly createdAt: number;
+                readonly updatedAt: number;
+            };
+            events: {
+                kind: "ProjectUpdated";
+                before: {
+                    id: string;
+                    slug: string;
+                    name: string;
+                    status: string;
+                    description: string;
+                    createdAt: number;
+                    updatedAt: number;
+                };
+                after: {
+                    id: string;
+                    slug: string;
+                    name: string;
+                    status: string;
+                    description: string;
+                    createdAt: number;
+                    updatedAt: number;
+                };
+            }[];
+        }, import("@house-rules/domain").NoOpenUnit | import("./project/project.js").ProjectAccessDenied | import("./project/project.js").ProjectAccessUnavailable | ProjectInputInvalid | import("./project/project.js").ProjectNotFound | import("./project/project.js").ProjectSlugTaken | import("./project/project.js").ProjectStoreUnavailable, never>;
+        show: (actor: import("@house-rules/domain").Actor, ref: import("./project/project.js").ProjectRef) => Effect.Effect<{
+            readonly id: string;
+            readonly slug: string;
+            readonly name: string;
+            readonly status: string;
+            readonly description: string;
+            readonly createdAt: number;
+            readonly updatedAt: number;
+        }, import("./project/project.js").ProjectAccessDenied | import("./project/project.js").ProjectAccessUnavailable | import("./project/project.js").ProjectNotFound | import("./project/project.js").ProjectStoreUnavailable, never>;
+        list: (actor: {
+            readonly id: string & import("effect/Brand").Brand<"ActorId">;
+        }, filter?: {
+            readonly status?: string;
+        } | undefined) => Effect.Effect<readonly {
+            readonly id: string;
+            readonly slug: string;
+            readonly name: string;
+            readonly status: string;
+            readonly description: string;
+            readonly createdAt: number;
+            readonly updatedAt: number;
+        }[], import("./project/project.js").ProjectAccessUnavailable | ProjectInputInvalid | import("./project/project.js").ProjectStoreUnavailable, never>;
+    }, ProjectInputInvalid, ProjectStore>;
+    readonly layer: (options: {
+        readonly statuses: readonly string[];
+        readonly defaultStatus: string;
+        readonly archivedStatus: string;
+        readonly slug: {
+            readonly pattern: string;
+            readonly maxLength: number;
+            readonly lowercase: boolean;
+            readonly trim: boolean;
+        };
+    } | undefined) => import("@house-rules/domain").ModuleLayer<Projects, ProjectInputInvalid, ProjectStore>;
+};
+export declare class Projects extends Projects_base {
+    static readonly presets: {
+        readonly default: {
+            readonly statuses: readonly ["active", "archived"];
+            readonly defaultStatus: "active";
+            readonly archivedStatus: "archived";
+            readonly slug: {
+                readonly pattern: "^[a-z0-9][a-z0-9-]*$";
+                readonly maxLength: 64;
+                readonly lowercase: true;
+                readonly trim: true;
+            };
+        };
+    };
+    static readonly layerMemory: (options?: ProjectsOptions) => Layer.Layer<Projects, ProjectInputInvalid, never>;
+    static readonly layerPostgres: (options?: ProjectsOptions) => Layer.Layer<Projects, ProjectInputInvalid, import("effect/sql/SqlClient").SqlClient>;
+}
+export {};

package/dist/facade.js

@@ -0,0 +1,28 @@
+import { defineModule } from "@house-rules/domain";
+import { Effect, Layer, Option, Schema } from "effect";
+import { memoryProjectStore } from "./adapters/memory/project.js";
+import { postgresProjectStore } from "./adapters/postgres/project.js";
+import { ProjectStore } from "./storage.js";
+import { ProjectAccess } from "./project/access.js";
+import { ProjectsOptions, projectsPresets } from "./project/options.js";
+import { ProjectInputInvalid } from "./project/project.js";
+import { makeProjects } from "./project/projects.js";
+export class Projects extends defineModule()("projects", {
+    make: (options = projectsPresets.default) => Effect.gen(function* () {
+        const invalid = () => new ProjectInputInvalid({ field: "options", message: "Invalid projects options." });
+        const settings = yield* Schema.decodeEffect(ProjectsOptions)(options).pipe(Effect.mapError(invalid));
+        if (new Set(settings.statuses).size !== settings.statuses.length ||
+            !settings.statuses.includes(settings.defaultStatus) ||
+            !settings.statuses.includes(settings.archivedStatus))
+            return yield* invalid();
+        const pattern = yield* Effect.try({
+            try: () => new RegExp(settings.slug.pattern),
+            catch: invalid,
+        });
+        return makeProjects(yield* ProjectStore, Option.getOrUndefined(yield* Effect.serviceOption(ProjectAccess)), settings, pattern);
+    }),
+}) {
+    static presets = projectsPresets;
+    static layerMemory = (options = projectsPresets.default) => this.layer(options).pipe(Layer.provide(memoryProjectStore()));
+    static layerPostgres = (options = projectsPresets.default) => this.layer(options).pipe(Layer.provide(postgresProjectStore));
+}