@boxxy/rules 0.0.0-stage → 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 the boxxy authors
+
+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
+<div align="center">
+  <h1>@boxxy/rules</h1>
 
-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.
+  <p>
+    <a href="https://www.npmjs.com/package/@boxxy/rules"><img src="https://img.shields.io/npm/v/@boxxy/rules" alt="npm version"></a>
+    <a href="./LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT license"></a>
+  </p>
+
+  <p>
+    <a href="../../docs/design/boxxy/README.md">Documentation</a>
+  </p>
+</div>
+
+boxxy's rules loader. `loadRules` checks a rules checkout's `rules.yaml` against the concepts and
+the phase kinds boxxy compiles in, builds the plug-in registry, and gives the loaded rules a
+version. [`example/`](./example/) holds the v1 rules file and its prompts.
+
+The package does no I/O: the caller reads the checkout and passes in its commit hash and its files'
+bytes.
+
+## Install
+
+Install the package from [npm](https://www.npmjs.com/package/@boxxy/rules) with Bun:
+
+```bash
+bun add @boxxy/rules
+```
+
+The package runs on [Bun](https://bun.sh) 1.3 or newer.
+
+## Features
+
+- `loadRules`, which returns the loaded rules, or every rejection with its file, its path in the
+  file and its reason ([the pipeline](../../docs/design/boxxy/v1.md#the-pipeline)).
+- The rules version, a content hash of the commit, the files the loader read, each concept pin and
+  each phase kind ([the rules version](../../docs/design/boxxy/rules.md#the-rules-version)).
+
+## Documentation
+
+The [rules design](../../docs/design/boxxy/rules.md) says why rules live in git, and
+[`02-types.ts`](../../docs/design/boxxy/sketches/v1/core/02-types.ts) gives the shape of the loaded
+rules.

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const rulesFileName = "rules.yaml";

package/dist/dry-run/dry-run-rules.d.ts

@@ -0,0 +1,9 @@
+import type { LoadedRules } from '@boxxy/model';
+import type { DryRunItem, RulesDryRunLine } from '../types.ts';
+interface DryRunInput {
+    readonly current: LoadedRules;
+    readonly proposed: LoadedRules;
+    readonly items: readonly DryRunItem[];
+}
+export declare function dryRunRules(input: DryRunInput): RulesDryRunLine[];
+export {};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { rulesFileName } from './constants.ts';
+export { loadRules } from './loading/load-rules.ts';
+export { dryRunRules } from './dry-run/dry-run-rules.ts';
+export type { DryRunItem, RulesDryRunLine } from './types.ts';

package/dist/loading/build-rejection.d.ts

@@ -0,0 +1,2 @@
+import type { LoadRejection, LoadRejectionReason } from '@boxxy/model';
+export declare function buildRejection(path: readonly PropertyKey[], reason: LoadRejectionReason): LoadRejection;

package/dist/loading/collect-filter-rejections.d.ts

@@ -0,0 +1,3 @@
+import type { LoadRejection, Registry } from '@boxxy/model';
+import type { ParsedRulesFile } from '../parse/rules-file-schema.ts';
+export declare function collectFilterRejections(file: ParsedRulesFile, registry: Registry): LoadRejection[];

package/dist/loading/collect-recipe-rejections.d.ts

@@ -0,0 +1,3 @@
+import type { LoadRejection } from '@boxxy/model';
+import type { ParsedRulesFile } from '../parse/rules-file-schema.ts';
+export declare function collectRecipeRejections(file: ParsedRulesFile): LoadRejection[];

package/dist/loading/collect-step-rejections.d.ts

@@ -0,0 +1,3 @@
+import type { LoadRejection, PhaseKind, PhaseName } from '@boxxy/model';
+import type { ParsedRulesFile } from '../parse/rules-file-schema.ts';
+export declare function collectStepRejections(file: ParsedRulesFile, phases: ReadonlyMap<PhaseName, PhaseKind>): LoadRejection[];

package/dist/loading/load-rules.d.ts

@@ -0,0 +1,12 @@
+import type { Concept, ConceptName, ConceptPin, LoadResult, PhaseKind } from '@boxxy/model';
+interface LoadRulesInput {
+    readonly checkout: {
+        readonly commit: string;
+        readonly files: ReadonlyMap<string, Uint8Array>;
+    };
+    readonly concepts: readonly Concept[];
+    readonly pins: ReadonlyMap<ConceptName, ConceptPin>;
+    readonly phases: readonly PhaseKind[];
+}
+export declare function loadRules(input: LoadRulesInput): LoadResult;
+export {};

package/dist/loading/to-filter.d.ts

@@ -0,0 +1,3 @@
+import type { Filter } from '@boxxy/model';
+import type { ParsedRulesFile } from '../parse/rules-file-schema.ts';
+export declare function toFilter(filter: ParsedRulesFile['pools'][number]['takes']): Filter;

package/dist/parse/parse-concept-entry.d.ts

@@ -0,0 +1,5 @@
+import type { ConceptEntry, ConceptName } from '@boxxy/model';
+export declare function parseConceptEntry(entry: ConceptEntry): {
+    readonly name: ConceptName;
+    readonly version: number;
+};

package/dist/parse/parse-rules-file.d.ts

@@ -0,0 +1,11 @@
+import type { LoadRejection } from '@boxxy/model';
+import type { ParsedRulesFile } from './rules-file-schema.ts';
+type RulesFileParse = {
+    readonly kind: 'parsed';
+    readonly file: ParsedRulesFile;
+} | {
+    readonly kind: 'rejected';
+    readonly rejections: readonly LoadRejection[];
+};
+export declare function parseRulesFile(fileName: string, bytes: Uint8Array): RulesFileParse;
+export {};

package/dist/parse/rules-file-schema.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+declare const stepSchema: z.ZodObject<{
+    phase: z.core.$ZodBranded<z.ZodString, "PhaseName", "out">;
+    maxAttempts: z.ZodInt;
+    timeoutMinutes: z.ZodOptional<z.ZodInt>;
+    on: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"next">, z.ZodLiteral<"again">, z.ZodObject<{
+        to: z.core.$ZodBranded<z.ZodString, "PhaseName", "out">;
+        max: z.ZodExactOptional<z.ZodInt>;
+        resume: z.ZodExactOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        end: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        hold: z.core.$ZodBranded<z.ZodString, "RulesHoldReason", "out">;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export declare const rulesFileSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    concepts: z.ZodArray<z.ZodTemplateLiteral<`${string}@${number}`>>;
+    pipelines: z.ZodRecord<z.core.$ZodBranded<z.ZodString, "PipelineName", "out">, z.ZodArray<z.ZodObject<{
+        phase: z.core.$ZodBranded<z.ZodString, "PhaseName", "out">;
+        maxAttempts: z.ZodInt;
+        timeoutMinutes: z.ZodOptional<z.ZodInt>;
+        on: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"next">, z.ZodLiteral<"again">, z.ZodObject<{
+            to: z.core.$ZodBranded<z.ZodString, "PhaseName", "out">;
+            max: z.ZodExactOptional<z.ZodInt>;
+            resume: z.ZodExactOptional<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
+            end: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            hold: z.core.$ZodBranded<z.ZodString, "RulesHoldReason", "out">;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>>;
+    kinds: z.ZodRecord<z.core.$ZodBranded<z.ZodString, "ItemKindName", "out">, z.ZodObject<{
+        pipeline: z.core.$ZodBranded<z.ZodString, "PipelineName", "out">;
+        recipes: z.ZodRecord<z.ZodString, z.core.$ZodBranded<z.ZodString, "RecipeName", "out">>;
+    }, z.core.$strict>>;
+    skills: z.ZodOptional<z.ZodObject<{
+        source: z.core.$ZodBranded<z.ZodString, "RepoName", "out">;
+        ref: z.core.$ZodBranded<z.ZodString, "CommitSha", "out">;
+    }, z.core.$strict>>;
+    relationTypes: z.ZodArray<z.core.$ZodBranded<z.ZodString, "RelationTypeName", "out">>;
+    recipes: z.ZodRecord<z.core.$ZodBranded<z.ZodString, "RecipeName", "out">, z.ZodObject<{
+        agent: z.ZodString;
+        model: z.ZodString;
+        effort: z.ZodEnum<{
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            xhigh: "xhigh";
+        }>;
+        prompt: z.ZodString;
+        source: z.core.$ZodBranded<z.ZodString, "SourceName", "out">;
+        skills: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    limits: z.ZodArray<z.ZodObject<{
+        name: z.core.$ZodBranded<z.ZodString, "LimitName", "out">;
+        max: z.ZodInt;
+        counts: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>;
+    pools: z.ZodArray<z.ZodObject<{
+        name: z.core.$ZodBranded<z.ZodString, "PoolName", "out">;
+        slots: z.ZodOptional<z.ZodNever>;
+        takes: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        order: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>]>>;
+    }, z.core.$strict>>;
+    lead: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>]>>>;
+    propagation: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        over: z.core.$ZodBranded<z.ZodString, "RelationTypeName", "out">;
+        toward: z.ZodEnum<{
+            source: "source";
+            target: "target";
+        }>;
+    }, z.core.$strict>>>;
+    sleep: z.ZodObject<{
+        afterIdleMinutes: z.ZodInt;
+        afterQuietMinutes: z.ZodInt;
+        afterUnattendedMinutes: z.ZodInt;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ParsedRulesFile = z.output<typeof rulesFileSchema>;
+export type ParsedStep = z.output<typeof stepSchema>;
+export {};

package/dist/registry/build-registry.d.ts

@@ -0,0 +1,6 @@
+import type { ConceptPin, LoadRejection, Registry } from '@boxxy/model';
+import type { PinnedConcept } from '../types.ts';
+export declare function buildRegistry(pinned: readonly PinnedConcept[], pins: readonly ConceptPin[]): {
+    readonly value: Registry;
+    readonly rejections: readonly LoadRejection[];
+};

package/dist/registry/resolve-plugin.d.ts

@@ -0,0 +1,4 @@
+import type { JsonValue } from '@boxxy/content-hash';
+import type { ParamKindName, Registered, Resolved } from '@boxxy/model';
+import type { Checked } from '../types.ts';
+export declare function resolvePlugin<K extends ParamKindName>(registered: Registered<K>, params: JsonValue, key: string, path: readonly PropertyKey[]): Checked<Resolved<K>>;

package/dist/registry/resolve-signal-ref.d.ts

@@ -0,0 +1,3 @@
+import type { Registry, SignalRef } from '@boxxy/model';
+import type { Checked, ResolvedSignal } from '../types.ts';
+export declare function resolveSignalRef(ref: SignalRef, path: readonly PropertyKey[], registry: Registry): Checked<ResolvedSignal>;

package/dist/test-utils/build-example-load-input.d.ts

@@ -0,0 +1,11 @@
+import type { Concept, ConceptName, ConceptPin } from '@boxxy/model';
+interface ExampleLoadInput {
+    readonly checkout: {
+        readonly commit: string;
+        readonly files: ReadonlyMap<string, Uint8Array>;
+    };
+    readonly concepts: readonly Concept[];
+    readonly pins: ReadonlyMap<ConceptName, ConceptPin>;
+}
+export declare function buildExampleLoadInput(): ExampleLoadInput;
+export {};

package/dist/test-utils/load-mock-rules.d.ts

@@ -0,0 +1,7 @@
+import type { JsonValue, LoadedRules } from '@boxxy/model';
+interface MockRulesInput {
+    readonly steps: readonly JsonValue[];
+    readonly kinds?: Readonly<Record<string, string>>;
+}
+export declare function loadMockRules(input: MockRulesInput): LoadedRules;
+export {};

package/dist/types.d.ts

@@ -0,0 +1,24 @@
+import type { Concept, ItemId, ItemView, LoadRejection, Position, Resolved, RetryLever, Settled, SignalKey } from '@boxxy/model';
+export interface Checked<T> {
+    readonly value: T | null;
+    readonly rejections: readonly LoadRejection[];
+}
+export interface ResolvedSignal {
+    readonly key: SignalKey;
+    readonly resolved: Resolved<'signal'>;
+}
+export interface PinnedConcept {
+    readonly concept: Concept;
+    readonly entryIndex: number;
+}
+export interface RulesDryRunLine {
+    readonly item: ItemId;
+    readonly now: Position;
+    readonly then: Position;
+    readonly moved: boolean;
+}
+export interface DryRunItem {
+    readonly item: ItemView;
+    readonly attempts: readonly Settled[];
+    readonly retries: readonly RetryLever[];
+}

package/example/prompts/build-v1.md

@@ -0,0 +1,4 @@
+Build the item {{title}} to its design and acceptance list, and open a pull request.
+
+Run the checks that the repo's own agent instructions name. Close out `built`, `blocked` with the
+question the owner must answer, or `abandoned`.

package/example/prompts/design-attended-v1.md

@@ -0,0 +1,4 @@
+Design the item {{title}} with the owner, who works in this session with you.
+
+Ask the owner what you need to know. When the owner is done, close out `designed` with the design,
+`blocked` with the open question, or `abandoned`.

package/example/prompts/design-v1.md

@@ -0,0 +1,4 @@
+Design the item {{title}} against its acceptance list.
+
+Close out `designed` with the design, `blocked` with the question the owner must answer, or
+`abandoned`.

package/example/prompts/review-v1.md

@@ -0,0 +1,4 @@
+Review the pull request of the item {{title}} against its acceptance list.
+
+Run `noslop review --report json`. Close out `passed`, or `changes-requested` with each finding as
+text.

package/example/prompts/triage-v1.md

@@ -0,0 +1,5 @@
+Triage the item {{title}}.
+
+Decide whether boxxy takes it on: close out `accepted`, `duplicate` with the other item, or
+`declined` with the reason. An accepted item needs an acceptance list. Accept no criterion that only
+a release or a live run can prove.

package/example/rules.yaml

@@ -0,0 +1,110 @@
+# The v1 rules file: four phases, two limits, five pools and the sleep times.
+version: 1
+concepts: [pool@2, defer@1, expedite@1] # pool@2 adds the filter field `designMode`
+
+pipelines:
+  standard:
+    - phase: triage
+      maxAttempts: 2
+      timeoutMinutes: 20
+      on: # every outcome of the phase kind, or the load fails
+        accepted: next
+        duplicate: { hold: duplicate } # the owner confirms with `boxxy item close`,
+        declined: { hold: declined } # or sends the item on with `boxxy item retry`
+    - phase: design
+      maxAttempts: 2
+      timeoutMinutes: 90 # the clock of an agent-mode attempt; an attended one sleeps instead
+      on:
+        designed: next
+        blocked: { hold: blocked } # the agent's question; the owner answers with `boxxy item note`
+        abandoned: again # the same phase again, counted against maxAttempts
+    - phase: build
+      maxAttempts: 2
+      timeoutMinutes: 180
+      on:
+        built: next
+        blocked: { hold: blocked }
+        abandoned: again
+    - phase: review
+      maxAttempts: 2
+      timeoutMinutes: 45
+      on:
+        passed: { end: reviewed }
+        changes-requested: { to: build, max: 3, resume: true } # wakes the build's kept session
+
+kinds:
+  core.idea:
+    pipeline: standard
+    recipes:
+      triage: triage-v1
+      design: design-v1
+      design/attended: design-attended-v1
+      build: build-v1
+      review: review-v1
+  core.issue:
+    pipeline: standard
+    recipes:
+      triage: triage-v1
+      design: design-v1
+      design/attended: design-attended-v1
+      build: build-v1
+      review: review-v1
+
+skills: # one commit of the skills repo, for every recipe
+  source: example/skills
+  ref: 4f1c9e07a2b35d68c0e1f7a9b3d5c2e8f6a4b1d0
+
+relationTypes: [blocks, duplicate-of, relates-to]
+
+recipes: # the pin and each recipe's skills are part of the recipe hash
+  triage-v1:
+    agent: claude
+    model: claude-opus-5-5
+    effort: medium
+    prompt: prompts/triage-v1.md
+    source: subscription
+    skills: []
+  design-v1:
+    agent: claude
+    model: claude-opus-5-5
+    effort: medium
+    prompt: prompts/design-v1.md
+    source: subscription
+    skills: [bake-off]
+  design-attended-v1:
+    agent: claude
+    model: claude-opus-5-5
+    effort: medium
+    prompt: prompts/design-attended-v1.md
+    source: subscription
+    skills: [bake-off]
+  build-v1:
+    agent: claude
+    model: claude-opus-5-5
+    effort: medium
+    prompt: prompts/build-v1.md
+    source: subscription
+    skills: []
+  review-v1:
+    agent: claude
+    model: claude-opus-5-5
+    effort: medium
+    prompt: prompts/review-v1.md
+    source: subscription
+    skills: []
+
+limits:
+  - { name: workers, max: 7, counts: {} }
+  - { name: owner-design, max: 1, counts: { phase: design, designMode: attended } }
+
+pools: # a filter and a sort; a limit caps the attempts
+  - { name: triage, takes: { phase: triage }, order: [oldest] }
+  - { name: design-with-owner, takes: { phase: design, designMode: attended }, order: [oldest] }
+  - { name: design, takes: { phase: design, designMode: agent }, order: [oldest] }
+  - { name: review, takes: { phase: review }, order: [oldest] }
+  - { name: build, takes: { phase: build }, order: [oldest] }
+
+sleep:
+  afterIdleMinutes: 30 # a session that waits for the owner this long sleeps
+  afterQuietMinutes: 60 # an attended session with no activity this long counts as waiting
+  afterUnattendedMinutes: 240 # an attended session the owner has not attached to this long sleeps

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@boxxy/rules",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.3",
+  "description": "boxxy's rules loader: checks a rules checkout and builds the plug-in registry",
+  "homepage": "https://github.com/zgeoff/boxxy/tree/main/modules/rules#readme",
+  "bugs": "https://github.com/zgeoff/boxxy/issues",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zgeoff/boxxy.git",
+    "directory": "modules/rules"
+  },
+  "files": [
+    "src",
+    "!src/**/*.test.ts",
+    "example",
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./src/index.ts"
+    },
+    "./example/*": "./example/*",
+    "./test-utils/*": "./src/test-utils/*.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsrs -p tsconfig.build.json",
+    "typecheck": "tsrs --noEmit"
+  },
+  "dependencies": {
+    "@boxxy/content-hash": "0.1.3",
+    "@boxxy/model": "0.1.3",
+    "tiny-invariant": "1.3.3",
+    "ts-pattern": "5.9.2",
+    "yaml": "2.9.1",
+    "zod": "4.6.7"
+  },
+  "engines": {
+    "bun": ">=1.3",
+    "node": ">=24"
+  }
+}

package/src/constants.ts

@@ -0,0 +1 @@
+export const rulesFileName = 'rules.yaml';

package/src/dry-run/dry-run-rules.ts

@@ -0,0 +1,53 @@
+import type { LoadedRules, Position } from '@boxxy/model';
+import { findPosition } from '@boxxy/model';
+import type { DryRunItem, RulesDryRunLine } from '../types.ts';
+
+interface DryRunInput {
+  // the rules the server runs
+  readonly current: LoadedRules;
+
+  // a rules file that passed the loader
+  readonly proposed: LoadedRules;
+
+  // the open items only
+  readonly items: readonly DryRunItem[];
+}
+
+// Folds the position of each item twice over the same attempts and levers, once under each rules
+// set. It writes nothing. A live attempt is not touched by a rules change, so the line of an item
+// with a live attempt says where the item stands after that attempt settles as stored so far.
+export function dryRunRules(input: DryRunInput): RulesDryRunLine[] {
+  return input.items.map((entry) => {
+    const now = foldPosition(input.current, entry);
+    const next = foldPosition(input.proposed, entry);
+
+    // oxlint-disable-next-line unicorn/no-thenable -- the wire name of the contract; never awaited
+    return { item: entry.item.id, now, then: next, moved: !isSamePosition(now, next) };
+  });
+}
+
+function foldPosition(rules: LoadedRules, entry: DryRunItem): Position {
+  return findPosition({
+    pipeline: rules.kinds.get(entry.item.kind)?.pipeline ?? null,
+    attempts: entry.attempts,
+    retries: entry.retries,
+  });
+}
+
+function isSamePosition(left: Position, right: Position): boolean {
+  if (left.kind === 'phase' && right.kind === 'phase') {
+    return left.phase === right.phase && left.round === right.round;
+  }
+
+  if (left.kind === 'end' && right.kind === 'end') {
+    return left.reason === right.reason;
+  }
+
+  return (
+    left.kind === 'hold' &&
+    right.kind === 'hold' &&
+    left.reason === right.reason &&
+    left.then === right.then &&
+    left.round === right.round
+  );
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { rulesFileName } from './constants.ts';
+export { loadRules } from './loading/load-rules.ts';
+export { dryRunRules } from './dry-run/dry-run-rules.ts';
+export type { DryRunItem, RulesDryRunLine } from './types.ts';

package/src/loading/build-rejection.ts

@@ -0,0 +1,10 @@
+import type { LoadRejection, LoadRejectionReason } from '@boxxy/model';
+import { formatKeyPath } from '@boxxy/model';
+import { rulesFileName } from '../constants.ts';
+
+export function buildRejection(
+  path: readonly PropertyKey[],
+  reason: LoadRejectionReason,
+): LoadRejection {
+  return { file: rulesFileName, path: formatKeyPath(path), reason };
+}

package/src/loading/collect-filter-rejections.ts

@@ -0,0 +1,44 @@
+import type { Filter, LoadRejection, Registry } from '@boxxy/model';
+import type { ParsedRulesFile } from '../parse/rules-file-schema.ts';
+import { buildRejection } from './build-rejection.ts';
+import { toFilter } from './to-filter.ts';
+
+export function collectFilterRejections(
+  file: ParsedRulesFile,
+  registry: Registry,
+): LoadRejection[] {
+  const fields = registry['filter-field'];
+  const limitCounts = file.limits.map((limit) => toFilter(limit.counts));
+
+  const unknownFields = [
+    ...file.limits.map((limit, index) => ({
+      filter: limit.counts,
+      path: ['limits', index, 'counts'],
+    })),
+    ...file.pools.map((pool, index) => ({ filter: pool.takes, path: ['pools', index, 'takes'] })),
+  ].flatMap((entry) =>
+    Object.keys(entry.filter)
+      .filter((field) => !fields.has(field))
+      .map((field) =>
+        buildRejection([...entry.path, field], { kind: 'unknown-filter-field', field }),
+      ),
+  );
+
+  const unbounded = file.pools.flatMap((pool, index) =>
+    limitCounts.some((counts) => isSureToCount(counts, toFilter(pool.takes)))
+      ? []
+      : [buildRejection(['pools', index], { kind: 'pool-without-limit', pool: pool.name })],
+  );
+
+  return [...unknownFields, ...unbounded];
+}
+
+// A limit counts every attempt of a pool only when each field it filters on is one the pool takes
+// on too, with no value the limit leaves out.
+function isSureToCount(counts: Filter, takes: Filter): boolean {
+  return Object.entries(counts).every(([field, counted]) => {
+    const taken = Object.hasOwn(takes, field) ? takes[field] : undefined;
+
+    return taken !== undefined && taken.every((value) => counted.includes(value));
+  });
+}