@finbheara/domain 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Finbheara Systems
+
+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,199 @@
-# Temporary Holding Version
+# @finbheara/domain
 
-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.
+Places, CLRG regions, school names, ages and dances as they are actually printed: read,
+compared and told apart. A domain model downstream of
+[`@finbheara/names`](https://www.npmjs.com/package/@finbheara/names), which reads the
+person names.
+
+- **Places**: a print in, the set of place-tree nodes it may mean out. A country, a state or
+  province, a county, a city, or a CLRG region, with a relation between any two readings.
+- **CLRG regions**: the CLRG's dance regions and their Oireachtas codes, and the region a
+  location phrase falls in.
+- **School names**: a printed school name in, a `SchoolName` out, with a display form, a
+  filing key and a verdict on whether two prints may be one school.
+- **Ages**: an age group (`U12`, `Over 21`, `13-14`) or a year of birth in, an `Age` out: a
+  closed range of birth years, exact when it is one year, with `fitsIn`, `overlaps` and a
+  team's `averageAge`.
+- **Dances**: a spoken or printed set dance or céilí dance in, the dances it may name out,
+  with tempo rules and hand counts.
+
+It was built on the stage announcements and results sheets of Irish dance competitions,
+where one school arrives as `Ardvarna Academy of Irish Dance (Calgary, AB)` and as
+`ARDVARNA ACADEMY - Calgary, Alberta`.
+
+```sh
+npm install @finbheara/domain
+```
+
+ESM, Node ≥ 22 or Bun ≥ 1.4.2. MIT. Not affiliated with or endorsed by any dance commission.
+
+## Entry points
+
+| import | what |
+|---|---|
+| `@finbheara/domain/place` | `place()`, `createPlaceReader`, `placeRelation`, the `Place` types |
+| `@finbheara/domain/clrg-regions` | `REGIONS`, `regionOf`, `resolvePhrase` |
+| `@finbheara/domain/school` | `createSchoolNameReader`, `DEFAULT_SCHOOL_NAME_READER`, `compareSchoolNames`, `foldSchoolName` |
+| `@finbheara/domain/tune` | `tune()`, `tuneRelation`, `tempoLegal`, `settingAt`, `TUNE_NODES`: the CLRG set dance list |
+| `@finbheara/domain/ceili` | `ceili()`, `ceiliRelation`, `CEILI_NODES`: the céilí handbook dances |
+| `@finbheara/domain/dance` | `dance()`: a print read as a tune and a céilí dance, narrowed by its round |
+| `@finbheara/domain/age` | `Age.from`, `Age.fromYOB`, `ageRelation`, `canOverlap`, `averageAge`, `isAveraged`, the age constants |
+| `@finbheara/domain/dance-types` | `danceTypes()`, `DANCE_TYPES`, `rhythmOfTime`, and the shared `DanceMatch`/`DanceRelation`/`SetRhythm`/`TimeSignature` types |
+
+The library does no I/O and installs nothing process-wide. Every reader has a default and a
+factory: build your own with options when the default is not what you want.
+
+## Read a place
+
+```ts
+import { place, placeRelation } from "@finbheara/domain/place";
+
+const p = place("Pennsylvania, Mid-Atlantic Region");
+p.arm;                       // "resolved"
+p.pl2;                       // "USA-PA"
+p.nodes.map((n) => n.id);    // ["USA", "USA-PA", "IDTANA-MARO"]
+p.country;                   // "USA"
+p.region;                    // "IDTANA-MARO"
+
+place("Calgary, AB").pl2;    // "CAN-AB/calgary"
+place("Co. Cork").region;    // "MUNSTER"
+place("CA").arm;             // "ambiguous": California or Canada
+place("Dublin").arm;         // "ambiguous": Ireland, California or Ohio
+
+placeRelation(place("Calgary, AB"), place("Western Canada"));  // "contains"
+placeRelation(place("Virginia"), place("Ontario"));            // "conflict"
+```
+
+A `Place` is one of four arms: `resolved`, `plural` (a print naming more than one place),
+`ambiguous` (one print, several readings) and `unread`. Only `conflict` between two readings
+says they cannot be one place; `same`, `contains` and `overlaps` do not.
+
+## Find a CLRG region
+
+```ts
+import { REGIONS, regionOf, resolvePhrase } from "@finbheara/domain/clrg-regions";
+
+regionOf("Pennsylvania");                          // "MARO"
+REGIONS.MARO;                                      // "Mid-Atlantic Region USA"
+resolvePhrase("Pennsylvania, Mid-Atlantic Region"); // ["MARO"]
+resolvePhrase("Calgary in Western Canada");         // ["WCRO"]
+resolvePhrase("Derry in Ireland");                  // ["ULSTER"]
+```
+
+`resolvePhrase` answers every region a phrase supports, and `[]` where it supports none. A
+token that names places in two regions resolves only with a co-token that settles it.
+
+## Read a school name
+
+```ts
+import { DEFAULT_SCHOOL_NAME_READER, compareSchoolNames } from "@finbheara/domain/school";
+
+const reader = DEFAULT_SCHOOL_NAME_READER;
+const s = reader.schoolName("Ardvarna Academy of Irish Dance (Calgary, AB)");
+s.sn2;               // "Ardvarna Academy (CAN-AB/calgary)"   display form
+s.sn3;               // "ARDVARNA ACADEMY (CAN-AB/calgary)"   filing key
+s.institution;       // "academy"
+s.location?.pl3;     // "CAN-AB/calgary"
+s.isSchool();        // true
+
+reader.schoolName("Scoil Rince Glenmorvan").sn2;  // "S.R. Glenmorvan"
+reader.schoolName("N/A").refusal?.reason;         // "placeholder"
+
+compareSchoolNames("Ardvarna Academy of Irish Dance (Calgary, AB)",
+                   "ARDVARNA ACADEMY - Calgary, Alberta", reader).verdict;  // "CANDIDATE"
+compareSchoolNames("Ardvarna Academy (Calgary, AB)",
+                   "Ardvarna Academy (Ontario)", reader).verdict;           // "BLOCKED"
+compareSchoolNames("Ardvarna Academy",
+                   "Ardvarna Academy (Ontario)", reader).verdict;           // "AMBIGUOUS"
+compareSchoolNames("Ardvarna Academy", "Glenmorvan Academy", reader).verdict; // "DIFFERENT"
+```
+
+The verdicts: `CANDIDATE` (same name, compatible qualifiers), `BLOCKED` (same name,
+contradicting qualifiers), `AMBIGUOUS` (needs context) and `DIFFERENT`. A verdict is a name
+reading and never an identity: two schools can share a name.
+
+`DEFAULT_SCHOOL_NAME_READER` is the generic reader: no lexicon, the shipped registers, frozen.
+Nothing replaces it, and the package holds no other. `compareSchoolNames` and
+`schoolPrintSplit` take the reader as an argument, always, so a print is never read by a
+reader you did not choose. A reader with a lexicon (for the surnames a school is named after),
+your own exception and refusal registers, or your own garbage is one you build:
+
+```ts
+import { compareSchoolNames, createSchoolNameReader } from "@finbheara/domain/school";
+
+const reader = createSchoolNameReader({ lexicon: (key) => myLexicon.get(key) });
+compareSchoolNames("Ardvarna Academy", "Ardvarna Academy (Ontario)", reader);
+```
+
+### Your own garbage
+
+The shipped refusals are generic: a card number, keyboard filler, a run with no letter in it,
+the shared placeholder list of `@finbheara/names` (`N/A`, `No School`, ...). What YOUR data
+prints in a school field and is not a school, such as an entry system's own "school not
+listed" instruction, a test entry, or a note typed into the wrong field, is yours to declare.
+Pass it as `garbage`, the same idea as `phraseClassifier(lexicon, { garbageVocab })` in
+`@finbheara/names`:
+
+```ts
+import { createSchoolNameReader } from "@finbheara/domain/school";
+
+const reader = createSchoolNameReader({
+	garbage: [
+		{ pattern: "-- my school is not on this list --", kind: "exact", reason: "placeholder" },
+		{ pattern: "demo school ", kind: "prefix", reason: "placeholder" },
+		{ pattern: "^sister of .+$", kind: "regex", reason: "not-a-name" },
+	],
+});
+reader.schoolName("-- My School Is Not On This List --").refusal?.reason;  // "placeholder"
+```
+
+A row's `pattern` is matched against the print with its case lowered, its accents and
+invisible characters dropped and its whitespace collapsed; a `regex` is compiled with the `i`
+flag and anchors itself. Your rows are asked before the shipped ones and the first match
+answers.
+
+## Read an age
+
+Ages are as of 1 January of the competition year. An `Age` is a closed range of birth years,
+whatever it was read from, so a year of birth and a one-year age group are the same thing.
+
+```ts
+import { Age, averageAge, canOverlap } from "@finbheara/domain/age";
+
+const dancer = Age.fromYOB(2014);
+dancer.isExact();                                       // true
+
+const u12 = Age.from("U12", { year: 2026 });
+u12.birthYears();                                       // { from: 2014, to: 2023 }
+dancer.fitsIn(u12);                                     // true
+
+// With the age groups the event offered, U12 is one birth year, so it is exact.
+const ladder = { caps: [11, 12, 13], overs: [], ranges: [] };
+Age.from("U12", { year: 2026, ladder }).isExact();      // true
+
+Age.fromYOB(1999).fitsIn(Age.from("U18", { year: 2025 }));               // false
+Age.fromYOB(1999).fitsIn(Age.from("Over 21", { year: 2026, top: true })); // true
+
+canOverlap(u12, Age.from("U14", { year: 2026 }), dancer);                 // true
+```
+
+A team's age is the average of its dancers' ages, rounded to two decimals. `averageAge`
+takes exact ages only and returns an `AverageAge`, a separate type that refuses, by name,
+any use that would treat it as one dancer's age.
+
+```ts
+const team = averageAge([1990, 1985, 1999, 1988].map((y) => Age.fromYOB(y)));
+team.meanAge(2026);                                     // 34.5
+team.fitsIn(Age.from("U40", { year: 2026 }));           // true
+
+averageAge([u12]);                                      // throws AgeMisuseError "not-exact"
+```
+
+## Known gaps
+
+- `place()` reads `"Derry in Ireland"` and `"Calgary in Western Canada"` as `unread`: it does
+  not split a phrase at `in`. `resolvePhrase` finds their regions.
+
+## Licence
+
+MIT, Copyright (c) 2026 Finbheara Systems.

package/dist/age.js

@@ -0,0 +1,420 @@
+var YOUNGEST_FLOOR = 0;
+var ADULT_FLOOR = 18;
+var MAJORS_FLOOR_YEARS = 3;
+var UNDER_CAP = Object.freeze({ plain: 2, exceptional: 4 });
+var UNDER_CAP_MAX_TOP = 21;
+var YOUNG_FLOOR = Object.freeze({ hard: 2, soft: 4 });
+var MIN_MAJOR_AGE = 4;
+var MIN_FEIS_AGE = 3;
+var DANCE_UP_YEARS = 1;
+var ageOnJanuary1 = (year, born) => year - born - 1;
+var yearsSinceBirth = (year, born) => year - born;
+var UNDER = /^(?:u|under\s*)(\d+)$/i;
+var OVER = /^(?:o|over\s*)(\d+)$/i;
+var RANGE = /^u?(\d+)\s*[-–]\s*(\d+)$/i;
+var ADULT_WORD = /^(?:adults?|ad|advanced|masters?)$/i;
+var SENIOR_WORD = /^seniors?$/i;
+var NO_LADDER = Object.freeze({ caps: [], overs: [], ranges: [] });
+function maxWhere(xs, pred) {
+  let best;
+  for (const x of xs)
+    if (pred(x) && (best === undefined || x > best))
+      best = x;
+  return best;
+}
+function minWhere(xs, pred) {
+  let best;
+  for (const x of xs)
+    if (pred(x) && (best === undefined || x < best))
+      best = x;
+  return best;
+}
+function readRange(a, b, ladder) {
+  if (!Number.isFinite(a) || !Number.isFinite(b) || b <= a)
+    return {
+      kind: "range",
+      interval: null,
+      refusal: "backwards-range",
+      clauses: [],
+      parts: [a, b]
+    };
+  const overlapping = ladder.ranges.includes(a) || ladder.ranges.includes(b + 1);
+  const bottom = !ladder.caps.some((c) => c <= a);
+  const atAdultFloor = bottom && a >= ADULT_FLOOR;
+  const youngest = bottom && !atAdultFloor;
+  const onRung = ladder.caps.includes(a);
+  const floor = overlapping || atAdultFloor || onRung ? a : Math.max(YOUNGEST_FLOOR, a - 1);
+  const clauses = [overlapping ? "range-overlapping" : "range-inclusive"];
+  if (youngest)
+    clauses.push("youngest-absorbs");
+  else if (atAdultFloor)
+    clauses.push("range-adult-floor");
+  else if (!overlapping)
+    clauses.push(onRung ? "range-floor-on-rung" : "range-floor-widened");
+  return {
+    kind: "range",
+    interval: { lo: youngest ? YOUNGEST_FLOOR : floor, hi: overlapping ? b : b + 1 },
+    refusal: null,
+    clauses,
+    parts: [a, b]
+  };
+}
+function read(token, ladder, top) {
+  const r = RANGE.exec(token);
+  if (r !== null)
+    return readRange(Number(r[1]), Number(r[2]), ladder);
+  if (ADULT_WORD.test(token))
+    return {
+      kind: "adult",
+      interval: { lo: ADULT_FLOOR, hi: Number.POSITIVE_INFINITY },
+      refusal: null,
+      clauses: ["and-over-no-ceiling"],
+      parts: []
+    };
+  if (SENIOR_WORD.test(token)) {
+    const top = maxWhere(ladder.caps, () => true);
+    return top === undefined ? { kind: "senior", interval: null, refusal: "senior-without-ladder", clauses: [], parts: [] } : {
+      kind: "senior",
+      interval: { lo: top, hi: Number.POSITIVE_INFINITY },
+      refusal: null,
+      clauses: ["and-over-no-ceiling"],
+      parts: []
+    };
+  }
+  const u = UNDER.exec(token);
+  if (u !== null) {
+    const n = Number(u[1]);
+    const below = maxWhere(ladder.caps, (c) => c < n);
+    return {
+      kind: "under",
+      interval: { lo: below ?? YOUNGEST_FLOOR, hi: n },
+      refusal: null,
+      clauses: [below === undefined ? "youngest-absorbs" : "under-floored-on-rung"],
+      parts: [n]
+    };
+  }
+  const o = OVER.exec(token);
+  if (o !== null) {
+    const n = Number(o[1]);
+    const above = top ? undefined : minWhere(ladder.overs, (c) => c > n);
+    if (above === undefined)
+      return {
+        kind: "over",
+        interval: { lo: n, hi: Number.POSITIVE_INFINITY },
+        refusal: null,
+        clauses: ["and-over-no-ceiling"],
+        parts: [n]
+      };
+    const gapped = ladder.caps.length > 0 && !ladder.caps.some((c) => c > n && c < above);
+    return {
+      kind: "over",
+      interval: { lo: n, hi: gapped ? Number.POSITIVE_INFINITY : above },
+      refusal: null,
+      clauses: [gapped ? "over-ceiling-refused-gap" : "over-ceiling-from-next-over"],
+      parts: [n]
+    };
+  }
+  return { kind: null, interval: null, refusal: "not-a-band", clauses: [], parts: [] };
+}
+
+class AgeMisuseError extends Error {
+  misuse;
+  constructor(misuse, detail) {
+    super(`age: ${misuse}: ${detail}`);
+    this.name = "AgeMisuseError";
+    this.misuse = misuse;
+  }
+}
+var display = (iv) => `[${iv.lo},${iv.hi === Number.POSITIVE_INFINITY ? "∞" : iv.hi})`;
+var currentYear = () => new Date().getUTCFullYear();
+function withRelations(a) {
+  const self = a;
+  return Object.assign(self, {
+    fitsIn: (container) => {
+      if (isAveraged(container))
+        throw new AgeMisuseError("average-as-container", `${self.ag2} cannot fit inside an average age (${String(container)}); an average is not a dancer`);
+      const r = ageRelation(self, container);
+      return r.relation === "same" || r.reason === "b-contains-a";
+    },
+    overlaps: (other) => {
+      const r = ageRelation(self, other).relation;
+      return r === "same" || r === "contains" || r === "overlaps";
+    }
+  });
+}
+function fromPrint(print, context = {}) {
+  const ladder = context.ladder ?? NO_LADDER;
+  const year = context.year === undefined ? currentYear() : context.year;
+  const ag1 = print.trim().toLowerCase();
+  const reading = ag1 === "" ? { kind: null, interval: null, refusal: null, clauses: [], parts: [] } : read(print.trim(), ladder, context.top === true);
+  const iv = reading.interval;
+  const arm = ag1 === "" ? "empty" : iv === null ? "open" : "band";
+  const ag2 = iv !== null ? display(iv) : ag1 === "" ? "" : `${ag1}?`;
+  const source = sourceOf(reading);
+  return withRelations({
+    [Symbol.toStringTag]: "Age",
+    toString: () => ag2,
+    arm,
+    kind: reading.kind,
+    ag0: print,
+    ag1,
+    ag2,
+    parts: reading.parts,
+    length: ag2.length,
+    refusal: reading.refusal,
+    source,
+    clauses: reading.clauses,
+    ladder,
+    year,
+    isEmpty: () => arm === "empty",
+    isAge: () => iv !== null,
+    isExact: () => {
+      if (iv === null || year === null)
+        return false;
+      const b = birthYearsOfInterval(iv, year);
+      return b.from !== null && b.from === b.to;
+    },
+    isAndOver: () => iv !== null && iv.hi === Number.POSITIVE_INFINITY,
+    isAdult: () => reading.kind === "adult",
+    interval: () => iv,
+    birthYears: (y) => {
+      const at = y ?? year;
+      if (at === null)
+        throw new Error(`Age.from(${JSON.stringify(print)}): birthYears needs a competition year`);
+      return birthYearsOfInterval(iv, at);
+    },
+    floorObserved: () => reading.kind !== "under" || iv === null ? null : reading.clauses.includes("under-floored-on-rung")
+  });
+}
+function fromYOB(from, to = from) {
+  for (const y of [from, to])
+    if (y !== null && !Number.isInteger(y))
+      throw new RangeError(`Age.fromYOB(${from}, ${to}): a year of birth is a whole number`);
+  if (from === null && to === null)
+    throw new RangeError("Age.fromYOB(null, null): at least one end is a year");
+  if (from !== null && to !== null && from > to)
+    throw new RangeError(`Age.fromYOB(${from}, ${to}): the earliest year comes first`);
+  const exact = from !== null && from === to;
+  const ag0 = exact ? String(from) : `${from ?? ""}..${to ?? ""}`;
+  const ag2 = `b${ag0}`;
+  const years = Object.freeze({ from, to });
+  return withRelations({
+    [Symbol.toStringTag]: "Age",
+    toString: () => ag2,
+    arm: "yob",
+    kind: "yob",
+    ag0,
+    ag1: ag0,
+    ag2,
+    parts: exact ? [from] : [from, to].filter((y) => y !== null),
+    length: ag2.length,
+    refusal: null,
+    source: "printed-yob",
+    clauses: [],
+    ladder: NO_LADDER,
+    year: null,
+    isEmpty: () => false,
+    isAge: () => true,
+    isExact: () => exact,
+    isAndOver: () => from === null,
+    isAdult: () => false,
+    interval: () => null,
+    birthYears: () => years,
+    floorObserved: () => null
+  });
+}
+var Age = Object.freeze({ from: fromPrint, fromYOB });
+function sourceOf(r) {
+  const iv = r.interval;
+  if (iv === null)
+    return "open";
+  switch (r.kind) {
+    case "range":
+      return "printed-range";
+    case "over":
+      return iv.hi === Number.POSITIVE_INFINITY ? "printed-band" : "sibling-narrowed";
+    case "adult":
+    case "senior":
+      return "printed-band";
+    case "under":
+      return iv.lo > YOUNGEST_FLOOR ? "sibling-narrowed" : "printed-band";
+    default:
+      return "open";
+  }
+}
+function birthYearsOfInterval(iv, year) {
+  if (iv === null)
+    return { from: null, to: null };
+  return {
+    from: iv.hi === Number.POSITIVE_INFINITY ? null : year - iv.hi,
+    to: Math.min(year - iv.lo - 1, year - MAJORS_FLOOR_YEARS)
+  };
+}
+var inBirthYears = (a) => a.arm === "yob" || a.year !== null;
+function spanOf(a) {
+  if (!a.isAge())
+    return null;
+  if (inBirthYears(a)) {
+    const b = a.birthYears();
+    return {
+      lo: b.from ?? Number.NEGATIVE_INFINITY,
+      hi: b.to ?? Number.POSITIVE_INFINITY
+    };
+  }
+  const iv = a.interval();
+  return { lo: iv.lo, hi: iv.hi - 1 };
+}
+function ageRelation(a, b) {
+  for (const x of [a, b])
+    if (isAveraged(x))
+      throw new AgeMisuseError("average-in-relation", `${String(x)} is an average, not a dancer's birth years; ask its fitsIn`);
+  if (inBirthYears(a) !== inBirthYears(b))
+    throw new Error("ageRelation: one reading is in birth years and the other has no competition year; read both with a year, or neither");
+  if (!a.isAge())
+    return { relation: "silent", reason: "a-not-a-band" };
+  if (!b.isAge())
+    return { relation: "silent", reason: "b-not-a-band" };
+  const sa = spanOf(a);
+  const sb = spanOf(b);
+  const years = inBirthYears(a);
+  if (sa.hi < sb.lo)
+    return { relation: "disjoint", reason: years ? "a-older" : "a-younger" };
+  if (sb.hi < sa.lo)
+    return { relation: "disjoint", reason: years ? "a-younger" : "a-older" };
+  if (sa.lo === sb.lo && sa.hi === sb.hi)
+    return { relation: "same", reason: "equal" };
+  if (sa.lo <= sb.lo && sb.hi <= sa.hi)
+    return { relation: "contains", reason: "a-contains-b" };
+  if (sb.lo <= sa.lo && sa.hi <= sb.hi)
+    return { relation: "contains", reason: "b-contains-a" };
+  return { relation: "overlaps", reason: "partial" };
+}
+function canOverlap(...ages) {
+  for (let i = 0;i < ages.length; i++)
+    for (let j = i + 1;j < ages.length; j++)
+      if (ageRelation(ages[i], ages[j]).relation === "disjoint")
+        return false;
+  return true;
+}
+var AVERAGE_AGE_DECIMALS = 2;
+var HUNDREDTHS = 10 ** AVERAGE_AGE_DECIMALS;
+function roundedMeanHundredths(k, n) {
+  if (!Number.isInteger(k) || !Number.isInteger(n) || n <= 0)
+    throw new RangeError(`roundedMeanHundredths(${k}, ${n}): whole numbers, n > 0`);
+  return Math.floor((2 * HUNDREDTHS * k + n) / (2 * n));
+}
+function isAveraged(a) {
+  return a[Symbol.toStringTag] === "AverageAge";
+}
+function averageAge(ages) {
+  if (ages.length === 0)
+    throw new AgeMisuseError("empty-average", "averageAge needs at least one exact age");
+  let sum = 0;
+  for (const [i, a] of ages.entries()) {
+    if (isAveraged(a))
+      throw new AgeMisuseError("average-of-averages", `input ${i} (${String(a)}) is already an average; average the members instead`);
+    if (!a.isExact())
+      throw new AgeMisuseError("not-exact", `input ${i} (${String(a)}) is not one birth year; an average takes exact ages only`);
+    sum += a.birthYears().from;
+  }
+  const n = ages.length;
+  const members = Object.freeze([...ages]);
+  const hundredths = (year) => roundedMeanHundredths(n * (year - 1) - sum, n);
+  const self = {
+    [Symbol.toStringTag]: "AverageAge",
+    provenance: `average of ${n}`,
+    members,
+    n,
+    birthYearSum: sum,
+    meanBirthYear: sum / n,
+    toString: () => `avg(${n}):b${sum / n}`,
+    isExact: () => false,
+    meanAgeHundredths: hundredths,
+    meanAge: (year) => hundredths(year) / HUNDREDTHS,
+    fitsIn: (container) => {
+      if (isAveraged(container))
+        throw new AgeMisuseError("average-as-container", `nothing fits inside an average age (${String(container)})`);
+      if (container.year === null)
+        throw new AgeMisuseError("average-container-no-year", `${String(container)} has no competition year to take the average age in`);
+      const iv = container.interval();
+      if (iv === null)
+        return false;
+      const h = hundredths(container.year);
+      return iv.lo * HUNDREDTHS <= h && h < iv.hi * HUNDREDTHS;
+    },
+    birthYears: () => {
+      throw new AgeMisuseError("average-birth-years", `an average of ${n} has no year of birth; read meanBirthYear, which is not a dancer's`);
+    }
+  };
+  return self;
+}
+function birthYearsDisjoint(a, b) {
+  if (a.to !== null && b.from !== null && a.to < b.from)
+    return true;
+  if (b.to !== null && a.from !== null && b.to < a.from)
+    return true;
+  return false;
+}
+function birthYearsMeet(card, other, slack = 0) {
+  if (card.from !== null && other.to !== null && card.from > other.to)
+    return false;
+  if (card.to !== null && other.from !== null && card.to + slack < other.from)
+    return false;
+  return true;
+}
+function underCapApplies(bandFrom, year) {
+  return bandFrom !== null && year - bandFrom <= UNDER_CAP_MAX_TOP;
+}
+function underCappedYears(b, year, n = UNDER_CAP.plain) {
+  if (n > UNDER_CAP.exceptional)
+    throw new Error(`under-cap: ${n} is over the exceptional cap of ${UNDER_CAP.exceptional}`);
+  if (!underCapApplies(b.from, year))
+    return b;
+  const cap = b.from + n;
+  if (b.to !== null && b.to <= cap)
+    return b;
+  return { from: b.from, to: cap };
+}
+function underCapRefuses(bandFrom, identityFrom, n) {
+  return identityFrom > bandFrom + n;
+}
+function youngFloor(year, oldest) {
+  const s = yearsSinceBirth(year, oldest);
+  if (s >= YOUNG_FLOOR.soft)
+    return "clear";
+  if (s < YOUNG_FLOOR.hard)
+    return "too-young";
+  return "same-school-only";
+}
+var tooYoungForMajor = (year, oldest) => yearsSinceBirth(year, oldest) < MIN_MAJOR_AGE;
+var tooYoungForFeis = (year, oldest) => yearsSinceBirth(year, oldest) < MIN_FEIS_AGE;
+export {
+  ADULT_FLOOR,
+  AVERAGE_AGE_DECIMALS,
+  Age,
+  AgeMisuseError,
+  DANCE_UP_YEARS,
+  MAJORS_FLOOR_YEARS,
+  MIN_FEIS_AGE,
+  MIN_MAJOR_AGE,
+  UNDER_CAP,
+  UNDER_CAP_MAX_TOP,
+  YOUNGEST_FLOOR,
+  YOUNG_FLOOR,
+  ageOnJanuary1,
+  ageRelation,
+  averageAge,
+  birthYearsDisjoint,
+  birthYearsMeet,
+  birthYearsOfInterval,
+  canOverlap,
+  isAveraged,
+  roundedMeanHundredths,
+  tooYoungForFeis,
+  tooYoungForMajor,
+  underCapApplies,
+  underCapRefuses,
+  underCappedYears,
+  yearsSinceBirth,
+  youngFloor
+};

package/dist/ceili.js

@@ -0,0 +1,15 @@
+import {
+  CEILI_NODES2,
+  allCeilis2,
+  ceiliById2,
+  ceili2,
+  ceiliRelation2
+} from "./chunks/place-7gqecaxd.js";
+import"./chunks/place-g6yw4cq6.js";
+export {
+  CEILI_NODES2 as CEILI_NODES,
+  allCeilis2 as allCeilis,
+  ceili2 as ceili,
+  ceiliById2 as ceiliById,
+  ceiliRelation2 as ceiliRelation
+};