@finbheara/domain 0.1.0 → 0.2.0

package/README.md

@@ -16,6 +16,8 @@ person names.
   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.
+- **A database-backed index** of any of these nouns: the slots an in-memory name map hashes
+  on, stored as indexed columns of a SQLite table you own.
 
 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
@@ -33,11 +35,12 @@ ESM, Node ≥ 22 or Bun ≥ 1.4.2. MIT. Not affiliated with or endorsed by any d
 |---|---|
 | `@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/school` | `createSchoolNameReader`, `DEFAULT_SCHOOL_NAME_READER`, `compareSchoolNames`, `foldSchoolName`, `schoolEncoder`, `schoolColumns` |
 | `@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/noun-index` | `createIndex`, `indexSchema`, `personEncoder`, and the `SqlHandle`/`NounEncoder` types: a database-backed name map (below) |
 | `@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
@@ -189,6 +192,78 @@ team.fitsIn(Age.from("U40", { year: 2026 }));           // true
 averageAge([u12]);                                      // throws AgeMisuseError "not-exact"
 ```
 
+## Index names in a database
+
+`createNameMap` (from `@finbheara/names`) and `mapOfSchools` hold their names in memory. An
+index holds them in a SQLite table, as columns: every slot those maps hash a name on, indexed,
+so a lookup at a level is one equality and nothing is loaded. It is a multi-map: a row is one
+name and one value, and a lookup answers every value filed at the name's slot.
+
+The package depends on no SQLite module. Hand it a handle with `prepare(sql)` returning a
+statement with `run(...)` and `all(...)`: `bun:sqlite`'s `Database` and `node:sqlite`'s
+`DatabaseSync` (Node ≥ 22.5) are both one as they are.
+
+```ts
+import { Database } from "bun:sqlite";            // or: import { DatabaseSync } from "node:sqlite"
+import { createNameMap, personName } from "@finbheara/names/normalize";
+import { createIndex, indexSchema, personEncoder } from "@finbheara/domain/noun-index";
+
+const db = new Database(":memory:");
+const people = personEncoder();
+const { table, indexes } = indexSchema(people, { table: "person" });
+db.prepare(table).run();
+for (const s of indexes) db.prepare(s).run();      // after a bulk load, if you have one
+
+const index = createIndex(db, people, { table: "person" });
+index.add(personName("Aoife Ní Mhaolvarna"), 1);
+index.add(personName("Mhaolvarna, Aoife Ni"), 2);
+index.add(personName("Kestrel Evbatyrov"), 3);
+
+index.get(personName("AOIFE NI MHAOLVARNA"), "nn3");  // [1, 2]
+index.get(personName("Aoife Ní Mhaolvarna"), "nn0");  // [1]
+index.find("surname_key", personName("Aoife Ní Mhaolvarna").surnameKey());  // [1, 2]
+index.nouns(2)[0]?.nn2;                                // "NiMhaolvarna<<Aoife": the parse, read back
+```
+
+`map(level)` is the single-valued view, with `createNameMap`'s interface and its answers:
+the first name filed at a slot keeps it, a later `set` replaces the value, and a print that
+names no person is held and never found.
+
+```ts
+const byName = index.map("nn3");
+byName.get(personName("Aoife Ni Mhaolvarna"));        // 1
+byName.size;                                           // 2
+createNameMap<number>("nn3", [...byName]).size;        // 2
+```
+
+The person columns are the print, the reading it was parsed under, and `nameColumns()` from
+`@finbheara/names`; the levels are `nn0`-`nn4`. A school's (`schoolEncoder` from
+`@finbheara/domain/school`) are the print, `sn0`-`sn4`, `realWords` and `matchKey`, and its
+levels are `mapOfSchools`'s. One print may be filed under several schools, and a school under
+many prints:
+
+```ts
+import { DEFAULT_SCHOOL_NAME_READER, schoolEncoder } from "@finbheara/domain/school";
+
+const read = (p: string) => DEFAULT_SCHOOL_NAME_READER.schoolName(p);
+const schools = createIndex(db, schoolEncoder(), { table: "school" });  // after its indexSchema
+schools.add(read("Ardvarna Academy"), 10);
+schools.add(read("Ardvarna Academy"), 11);
+schools.add(read("Ardvarna Academy (Ontario)"), 11);
+schools.add(read("ARDVARNA ACADEMY - Calgary, Alberta"), 10);
+
+schools.get(read("Ardvarna Academy"), "sn0");         // [10, 11]
+schools.nouns(11).map((s) => s.sn0);                   // ["Ardvarna Academy", "Ardvarna Academy (Ontario)"]
+schools.get(read("Ardvarna Academy of Irish Dance (Calgary, AB)"), "sn3");  // [10]
+```
+
+`rows({ column: keys, ... })` answers every row where any column holds one of its keys, and
+`glob(column, pattern)` a SQLite `GLOB` on one column. An encoder is a plain object: add a
+column of your own by spreading one, `{ ...enc, columns: [...enc.columns, "k"], encode: (x) =>
+({ ...enc.encode(x), k: f(x) }) }`. `indexSchema` takes the table, the value column and its
+type (`{ value: "id", valueType: "INTEGER PRIMARY KEY" }` makes the value the row id); on such a table `map(level)` iterates in value order, and a `set` to a value another row
+holds is refused by the key).
+
 ## Known gaps
 
 - `place()` reads `"Derry in Ireland"` and `"Calgary in Western Canada"` as `unread`: it does

package/dist/noun-index.js

@@ -0,0 +1,233 @@
+import {
+  NAME_COLUMNS,
+  NAME_LEVEL_COLUMNS,
+  nameColumns,
+  personName
+} from "@finbheara/names/normalize";
+var IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+var RESERVED = new Set(`rowid oid _rowid_ __r __v all and as by check create default delete distinct drop
+	from group in index insert into is key limit not null on or order primary references
+	select set table to union unique update values where`.split(/\s+/u));
+function ident(s, what) {
+  if (!IDENT.test(s) || RESERVED.has(s.toLowerCase()))
+    throw new Error(`noun-index: ${what} ${JSON.stringify(s)} is not a usable identifier`);
+  return s;
+}
+function resolve(encoder, options) {
+  const table = ident(options.table ?? "noun_index", "table");
+  const value = ident(options.value ?? "value", "value column");
+  const valueType = (options.valueType ?? "").trim();
+  if (!/^[A-Za-z ()0-9]*$/u.test(valueType))
+    throw new Error(`noun-index: value type ${JSON.stringify(valueType)} is not a type`);
+  const seen = new Set([value.toLowerCase()]);
+  for (const c of encoder.columns) {
+    ident(c, "column");
+    if (seen.has(c.toLowerCase()))
+      throw new Error(`noun-index: column ${c} is declared twice`);
+    seen.add(c.toLowerCase());
+  }
+  for (const c of [...encoder.levels, ...encoder.indexed])
+    if (!encoder.columns.includes(c))
+      throw new Error(`noun-index: ${c} is not a column`);
+  return { table, value, valueType, isKey: /primary\s+key/iu.test(valueType) };
+}
+function indexSchema(encoder, options = {}) {
+  const r = resolve(encoder, options);
+  const cols = [`${r.value}${r.valueType === "" ? "" : ` ${r.valueType}`}`];
+  for (const c of encoder.columns)
+    cols.push(`${c} TEXT`);
+  const indexes = [];
+  if (!r.isKey)
+    indexes.push(`CREATE INDEX IF NOT EXISTS ${r.table}_${r.value} ON ${r.table}(${r.value})`);
+  for (const c of encoder.indexed)
+    indexes.push(`CREATE INDEX IF NOT EXISTS ${r.table}_${c} ON ${r.table}(${c})`);
+  return { table: `CREATE TABLE IF NOT EXISTS ${r.table}(${cols.join(", ")})`, indexes };
+}
+var CHUNK = 500;
+function createIndex(handle, encoder, options = {}) {
+  const r = resolve(encoder, options);
+  const { table: T, value: VC } = r;
+  const cols = encoder.columns;
+  const prepared = new Map;
+  const stmt = (sql) => {
+    let s = prepared.get(sql);
+    if (s === undefined) {
+      s = handle.prepare(sql);
+      prepared.set(sql, s);
+    }
+    return s;
+  };
+  const column = (c) => {
+    if (!cols.includes(c))
+      throw new Error(`noun-index: ${c} is not a column of ${T}`);
+    return c;
+  };
+  const level = (l) => {
+    if (!encoder.levels.includes(l))
+      throw new Error(`noun-index: ${l} is not a level of ${T}`);
+    return l;
+  };
+  const insertSql = `INSERT INTO ${T}(${VC}, ${cols.join(", ")}) VALUES(${cols.map(() => "?").join(", ")}, ?)`;
+  const params = (x) => {
+    const e = encoder.encode(x);
+    return cols.map((c) => e[c] ?? null);
+  };
+  const insert = (x, value) => {
+    stmt(insertSql).run(value, ...params(x));
+  };
+  const keyAt = (x, l) => {
+    level(l);
+    return encoder.key === undefined ? encoder.encode(x)[l] ?? null : encoder.key(x, l);
+  };
+  const valuesWhere = (col, key) => stmt(`SELECT ${VC} AS v FROM ${T} WHERE ${col} = ? ORDER BY rowid`).all(key).map((o) => o.v);
+  const pick = (columns) => columns === undefined ? cols : columns.map(column);
+  const toRows = (raw, picked) => raw.map((o) => {
+    const row = {};
+    for (const c of picked)
+      row[c] = o[c] ?? null;
+    return { value: o.__v, row };
+  });
+  const selectList = (picked) => ["rowid AS __r", `${VC} AS __v`, ...picked].join(", ");
+  const index = {
+    table: T,
+    encoder,
+    add: insert,
+    addAll(entries) {
+      for (const [x, v] of entries)
+        insert(x, v);
+    },
+    get(x, l) {
+      const k = keyAt(x, l);
+      return k === null ? [] : valuesWhere(l, k);
+    },
+    has(x, l) {
+      const k = keyAt(x, l);
+      return k !== null && stmt(`SELECT 1 FROM ${T} WHERE ${l} = ? LIMIT 1`).all(k).length > 0;
+    },
+    find: (c, key) => valuesWhere(column(c), key),
+    rows(where, columns) {
+      const picked = pick(columns);
+      const seen = new Map;
+      for (const [c, keys] of Object.entries(where)) {
+        column(c);
+        const uniq = [...new Set(keys)];
+        for (let i = 0;i < uniq.length; i += CHUNK) {
+          const part = uniq.slice(i, i + CHUNK);
+          const sql = `SELECT ${selectList(picked)} FROM ${T} WHERE ${c} IN (${part.map(() => "?").join(",")})`;
+          for (const o of stmt(sql).all(...part))
+            seen.set(Number(o.__r), o);
+        }
+      }
+      return toRows([...seen].sort((a, b) => a[0] - b[0]).map(([, o]) => o), picked);
+    },
+    glob(c, pattern, columns) {
+      const picked = pick(columns);
+      const raw = stmt(`SELECT ${selectList(picked)} FROM ${T} WHERE ${column(c)} GLOB ? ORDER BY rowid`).all(pattern);
+      return toRows(raw, picked);
+    },
+    nouns(value) {
+      const raw = stmt(`SELECT ${cols.join(", ")} FROM ${T} WHERE ${VC} = ? ORDER BY rowid`).all(value);
+      return raw.map((o) => encoder.decode(o));
+    },
+    remove(value) {
+      const n = stmt(`SELECT count(*) AS n FROM ${T} WHERE ${VC} = ?`).all(value)[0].n;
+      if (n > 0)
+        stmt(`DELETE FROM ${T} WHERE ${VC} = ?`).run(value);
+      return Number(n);
+    },
+    size: () => Number(stmt(`SELECT count(*) AS n FROM ${T}`).all()[0].n),
+    map: (l) => viewAt(l)
+  };
+  function viewAt(l) {
+    const lc = level(l);
+    const heads = `SELECT rowid AS __r, ${VC} AS __v, ${cols.join(", ")} FROM ${T}
+			WHERE ${lc} IS NULL OR rowid IN (SELECT min(rowid) FROM ${T} WHERE ${lc} IS NOT NULL GROUP BY ${lc})
+			ORDER BY rowid`;
+    const head = (k) => stmt(`SELECT rowid AS __r, ${VC} AS __v FROM ${T} WHERE ${lc} = ? ORDER BY rowid LIMIT 1`).all(k)[0];
+    const all = () => stmt(heads).all();
+    const view = {
+      dop: l,
+      get size() {
+        const o = stmt(`SELECT (SELECT count(DISTINCT ${lc}) FROM ${T}) + (SELECT count(*) FROM ${T} WHERE ${lc} IS NULL) AS n`).all()[0];
+        return Number(o.n);
+      },
+      get(x) {
+        const k = keyAt(x, l);
+        return k === null ? undefined : head(k)?.__v;
+      },
+      has(x) {
+        const k = keyAt(x, l);
+        return k !== null && head(k) !== undefined;
+      },
+      set(x, value) {
+        const k = keyAt(x, l);
+        const h = k === null ? undefined : head(k);
+        if (h === undefined)
+          insert(x, value);
+        else
+          stmt(`UPDATE ${T} SET ${VC} = ? WHERE rowid = ?`).run(value, h.__r);
+        return this;
+      },
+      delete(x) {
+        const k = keyAt(x, l);
+        if (k === null || head(k) === undefined)
+          return false;
+        stmt(`DELETE FROM ${T} WHERE ${lc} = ?`).run(k);
+        return true;
+      },
+      clear() {
+        stmt(`DELETE FROM ${T}`).run();
+      },
+      *keys() {
+        for (const o of all())
+          yield encoder.decode(o);
+      },
+      *values() {
+        for (const o of all())
+          yield o.__v;
+      },
+      *entries() {
+        for (const o of all())
+          yield [encoder.decode(o), o.__v];
+      },
+      [Symbol.iterator]() {
+        return this.entries();
+      }
+    };
+    return view;
+  }
+  return index;
+}
+var sameColumns = (a, b) => NAME_COLUMNS.every((c) => a[c] === b[c]);
+function personEncoder(options = {}) {
+  const read = options.read ?? ((p, o) => personName(p, o));
+  const printCol = options.print ?? "print";
+  const readingCol = options.reading ?? "reading";
+  const readingOf = (x, cols) => {
+    const g = read(x.nn0, "given-first");
+    if (g === x || sameColumns(cols, nameColumns(g)))
+      return "given-first";
+    if (sameColumns(cols, nameColumns(read(x.nn0, "surname-first"))))
+      return "surname-first";
+    throw new Error(`personEncoder: ${JSON.stringify(x.nn0)} was not read by this encoder's reader in either order`);
+  };
+  return {
+    columns: [printCol, readingCol, ...NAME_COLUMNS],
+    levels: NAME_LEVEL_COLUMNS,
+    indexed: NAME_COLUMNS.filter((c) => c !== "given_key"),
+    encode(x) {
+      const cols = nameColumns(x);
+      return { [printCol]: x.nn0, [readingCol]: readingOf(x, cols), ...cols };
+    },
+    key: (x, level) => nameColumns(x)[level],
+    decode(row) {
+      const order = row[readingCol] === "surname-first" ? "surname-first" : "given-first";
+      return read(row[printCol] ?? "", order);
+    }
+  };
+}
+export {
+  createIndex,
+  indexSchema,
+  personEncoder
+};

package/dist/school.js

@@ -2172,9 +2172,35 @@ function mapOfSchools(dop, entries) {
     map.set(name, value);
   return map;
 }
+var SCHOOL_LEVEL_COLUMNS = ["sn0", "sn1", "sn2", "sn3", "sn4", "realWords"];
+function schoolColumns(name) {
+  return {
+    sn0: slotOf(name, "sn0"),
+    sn1: slotOf(name, "sn1"),
+    sn2: slotOf(name, "sn2"),
+    sn3: slotOf(name, "sn3"),
+    sn4: slotOf(name, "sn4"),
+    realWords: slotOf(name, "realWords")
+  };
+}
 function isLadderLevel(dop) {
   return LADDER.has(dop);
 }
+function schoolEncoder(options = {}) {
+  const reader = options.reader ?? DEFAULT_SCHOOL_NAME_READER;
+  const printCol = options.print ?? "print";
+  return {
+    columns: [printCol, ...SCHOOL_LEVEL_COLUMNS, "matchKey"],
+    levels: SCHOOL_LEVEL_COLUMNS,
+    indexed: [...SCHOOL_LEVEL_COLUMNS, "matchKey"],
+    encode(x) {
+      const key = foldSchoolName(x.sn0);
+      return { [printCol]: x.sn0, ...schoolColumns(x), matchKey: key === "" ? null : key };
+    },
+    key: (x, level) => schoolColumns(x)[level],
+    decode: (row) => reader.schoolName(row[printCol] ?? "")
+  };
+}
 function compareSchoolNames(a, b, reader) {
   return compareSchools(reader.schoolName(a), reader.schoolName(b));
 }
@@ -2217,6 +2243,7 @@ export {
   DEFAULT_SCHOOL_NAME_CAPACITY,
   DEFAULT_SCHOOL_NAME_READER,
   NOT_A_SCHOOL,
+  SCHOOL_LEVEL_COLUMNS,
   SCHOOL_NAME_EXCEPTIONS,
   compareSchoolNames,
   compareSchools,
@@ -2231,7 +2258,9 @@ export {
   realWords,
   realWordsInPrintOrder,
   sameInEveryPart,
+  schoolColumns,
   schoolCompare,
+  schoolEncoder,
   schoolInitials,
   schoolKeyTokens,
   schoolPrintSplit,

package/dist/types/noun-index.d.ts

@@ -0,0 +1,67 @@
+import { type PersonName, type ResolvedNameOrder, type TransitiveLevel } from "@finbheara/names/normalize";
+export type SqlValue = string | number | bigint | null;
+export interface SqlStatement {
+    run(...params: SqlValue[]): unknown;
+    all(...params: SqlValue[]): unknown[];
+}
+export interface SqlHandle {
+    prepare(sql: string): SqlStatement;
+}
+export type EncodedRow = Readonly<Record<string, string | null>>;
+export interface NounEncoder<X, L extends string = string> {
+    readonly columns: readonly string[];
+    readonly levels: readonly L[];
+    readonly indexed: readonly string[];
+    encode(x: X): EncodedRow;
+    key?(x: X, level: L): string | null;
+    decode(row: EncodedRow): X;
+}
+export interface IndexOptions {
+    readonly table?: string;
+    readonly value?: string;
+    readonly valueType?: string;
+}
+export interface IndexRow<V> {
+    readonly value: V;
+    readonly row: EncodedRow;
+}
+export interface IndexMap<X, V, L extends string> {
+    readonly dop: L;
+    readonly size: number;
+    get(x: X): V | undefined;
+    has(x: X): boolean;
+    set(x: X, value: V): this;
+    delete(x: X): boolean;
+    clear(): void;
+    keys(): IterableIterator<X>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[X, V]>;
+    [Symbol.iterator](): IterableIterator<[X, V]>;
+}
+export interface NounIndex<X, L extends string, V extends SqlValue> {
+    readonly table: string;
+    readonly encoder: NounEncoder<X, L>;
+    add(x: X, value: V): void;
+    addAll(entries: Iterable<readonly [X, V]>): void;
+    get(x: X, level: L): V[];
+    has(x: X, level: L): boolean;
+    find(column: string, key: string): V[];
+    rows(where: Readonly<Record<string, readonly string[]>>, columns?: readonly string[]): IndexRow<V>[];
+    glob(column: string, pattern: string, columns?: readonly string[]): IndexRow<V>[];
+    nouns(value: V): X[];
+    remove(value: V): number;
+    size(): number;
+    map(level: L): IndexMap<X, V, L>;
+}
+export declare function indexSchema(encoder: NounEncoder<unknown>, options?: IndexOptions): {
+    table: string;
+    indexes: string[];
+};
+export declare function createIndex<X, L extends string, V extends SqlValue = SqlValue>(handle: SqlHandle, encoder: NounEncoder<X, L>, options?: IndexOptions): NounIndex<X, L, V>;
+export type PersonReader = (print: string, order: ResolvedNameOrder) => PersonName;
+export interface PersonEncoderOptions {
+    readonly read?: PersonReader;
+    readonly print?: string;
+    readonly reading?: string;
+}
+export declare function personEncoder(options?: PersonEncoderOptions): NounEncoder<PersonName, TransitiveLevel>;

package/dist/types/school-compare.d.ts

@@ -33,4 +33,7 @@ export interface SchoolMap<V> {
 }
 export declare function setOfSchools(dop: SchoolDop): SchoolSet;
 export declare function mapOfSchools<V>(dop: SchoolDop, entries?: Iterable<readonly [SchoolName, V]>): SchoolMap<V>;
+export declare const SCHOOL_LEVEL_COLUMNS: readonly ["sn0", "sn1", "sn2", "sn3", "sn4", "realWords"];
+export type SchoolLevelColumn = (typeof SCHOOL_LEVEL_COLUMNS)[number];
+export declare function schoolColumns(name: SchoolName): Readonly<Record<SchoolLevelColumn, string | null>>;
 export declare function isLadderLevel(dop: SchoolDop): boolean;

package/dist/types/school-encoder.d.ts

@@ -0,0 +1,8 @@
+import type { NounEncoder } from "./noun-index.ts";
+import { type SchoolLevelColumn } from "./school-compare.ts";
+import { type SchoolName, type SchoolNameParser } from "./school-name.ts";
+export interface SchoolEncoderOptions {
+    readonly reader?: SchoolNameParser;
+    readonly print?: string;
+}
+export declare function schoolEncoder(options?: SchoolEncoderOptions): NounEncoder<SchoolName, SchoolLevelColumn>;

package/dist/types/school.d.ts

@@ -1,7 +1,9 @@
 export { createSchoolNameReader, DEFAULT_SCHOOL_NAME_CAPACITY, DEFAULT_SCHOOL_NAME_READER, realWords, realWordsInPrintOrder, schoolInitials, schoolPrintSplit, } from "./school-name.ts";
 export type { LexiconFlags, SchoolConcern, SchoolInitials, SchoolLexicon, SchoolName, SchoolNameParser, SchoolNameReader, SchoolNameReaderOptions, SchoolPart, SchoolPrintSplit, SchoolRefusal, } from "./school-name.ts";
-export { isColumnCutOf, isInitialismOf, isLadderLevel, mapOfSchools, probablySameSchool, sameInEveryPart, schoolCompare, schoolTokensAt, setOfSchools, } from "./school-compare.ts";
-export type { SchoolDop, SchoolMap, SchoolSet } from "./school-compare.ts";
+export { isColumnCutOf, isInitialismOf, isLadderLevel, mapOfSchools, probablySameSchool, SCHOOL_LEVEL_COLUMNS, schoolColumns, sameInEveryPart, schoolCompare, schoolTokensAt, setOfSchools, } from "./school-compare.ts";
+export type { SchoolDop, SchoolLevelColumn, SchoolMap, SchoolSet } from "./school-compare.ts";
+export { schoolEncoder } from "./school-encoder.ts";
+export type { SchoolEncoderOptions } from "./school-encoder.ts";
 export { compareSchoolNames, compareSchools } from "./school-identity.ts";
 export type { IdentityResult, IdentityVerdict } from "./school-identity.ts";
 export { foldSchoolName, hasSpecificToken, schoolKeyTokens } from "./school-match-key.ts";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@finbheara/domain",
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"description": "Places, CLRG regions, school names, ages and dances as they are printed: read, compared and told apart",
 	"keywords": [
 		"places",
@@ -49,6 +49,10 @@
 			"types": "./dist/types/dance-types.d.ts",
 			"default": "./dist/dance-types.js"
 		},
+		"./noun-index": {
+			"types": "./dist/types/noun-index.d.ts",
+			"default": "./dist/noun-index.js"
+		},
 		"./package.json": "./package.json"
 	},
 	"files": ["dist/*.js", "dist/chunks/*.js", "dist/types/**/*.d.ts", "README.md", "LICENSE"],