@kecan0406/aninames 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kecan0406
+
+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,91 @@
-# Temporary Holding Version
+# aninames
 
-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.
+A multilingual alias index for anime titles and characters. Type a title or a character name the way you know it — 後藤ひとり, gotou hitori, Hitori Gotoh, 고토 히토리, ぼざろ, 봇치 더 록, 孤独摇滚 — and get the work or the character.
+
+aninames ships data files, not a service: a scheduled build merges open data sources into one SQLite file per license layer, and a small search library joins the layers on your machine. The same build also cuts the search keys into small static files, so a client can search without downloading the databases (see [Static index](#static-index)).
+
+## Layers
+
+Sources under different share-alike licenses cannot be merged into one database, so every built file holds one layer. Load the layers whose terms suit you; `core` is always required.
+
+| Layer | File | License | Sources |
+|---|---|---|---|
+| `core` | `core.sqlite` | ODbL 1.0 (contents DbCL) | Wikidata (CC0), anime-offline-database (ODbL), VNDB (ODbL) |
+| `kowiki` | `kowiki.sqlite` | CC BY-SA 4.0 | Korean Wikipedia article titles and redirects |
+| `unlicensed` | `unlicensed.sqlite` | none stated by the sources | AniDB titles (Anime-Lists mirror), Bangumi Archive, Anissia, Danbooru |
+
+The `unlicensed` layer carries data whose sources state no license. It is published as a separate file so you can leave it out; redistributing it is at your own risk.
+
+Korean names generated from kana readings (national-standard and fan spellings) are marked `generated` and rank below sourced names.
+
+## Status
+
+v0, built and searched locally.
+
+Golden queries (`tests/golden.ts`) and the 139 character tags of ttheme's palettes (`tests/ttheme.tsv`), `mise run eval`:
+
+| Layers | Titles | Characters | Typos (not counted) | ttheme tags resolved |
+|---|---|---|---|---|
+| core, kowiki, unlicensed | 15/15 | 13/13 | 9/9 | 139/139 |
+| core, kowiki | 15/15 | 13/13 | 9/9 | 46/139 |
+| core | 15/15 | 13/13 | 9/9 | 46/139 |
+
+Without `unlicensed`, Danbooru tags resolve only where Wikidata records one (P13236).
+
+`mise run probe` searches a frozen sample of works and characters (`tests/probe.json`, 150 per popularity band) by forms of their own names and reports the share found first and the mean reciprocal rank, keeping names several entities share apart. With all layers, names no other entity carries are found first 99–100% of the time in Japanese, kana, romaji and Korean; romaji with one letter dropped 77–95%; Korean initials (ㄱㅌ ㅎㅌㄹ) 64–100%; Korean typed on an English keyboard (rhxh glxhfl) 72–100%. A given name alone, or a name several characters share, is genuinely ambiguous and ranks by popularity. It also searches Korean Wikipedia titles and redirects without the `kowiki` layer: spellings only Korean Wikipedia has are found first 20% (works) and 42% (characters) of the time, which is what that layer adds.
+
+`mise run silver` hides the external ids that link characters across sources and measures how well name matching alone rejoins them: 89.0% recall, 98.8% precision on 5,040 such pairs.
+
+Works and characters flagged adult (VNDB titles with no release under 18, Bangumi `nsfw`, anime-offline-database `hentai`; a character when all its works are) are returned with `adult: true`; `search(query, { adult: false })` leaves them out.
+
+Korean names: 19,065 characters carry a Korean name from a source (Wikidata, Korean Wikipedia cast lists, Danbooru, Bangumi), 7,057 of them from Korean Wikipedia alone. The rest get generated spellings (fan style preferred, national standard and loanword forms ranked lower).
+
+Built sizes: `core.sqlite` 610 MB, `kowiki.sqlite` 25 MB, `unlicensed.sqlite` 830 MB, plus `ttheme-<layer>.json` slices mapping Danbooru-tagged characters to their names for consumers without SQLite: each character's Danbooru tags (its main tag, the one with the most posts, first), that post count, its popularity and its names by language, with `other` for names no source labels. `mise run pack` writes `dist/release`: the databases zstd-compressed, the slices gzipped, `ttheme.json` (each slice's file, SHA-256 and size) and `NOTICE.md` (each layer's sources and terms).
+
+## Releases
+
+`.github/workflows/release.yml` fetches every source, builds, runs `eval`, packs and chunks every Sunday (and on demand), then publishes the files as a `data-<date>` release, keeping the four latest, and deploys `dist/site` to GitHub Pages as the static index. The latest release is always at `https://github.com/kecan0406/aninames/releases/latest/download/<file>` — ttheme reads `ttheme.json` there once a day and downloads the slices whose hash changed.
+
+## Static index
+
+`https://names.ttheme.dev/` serves each layer's search keys as sorted, gzip'd JSON files, so a search fetches only the few files its query needs instead of the databases (610, 25 and 830 MB). `mise run chunk` writes it to `dist/site`:
+
+| Path | Holds |
+|---|---|
+| `manifest.json` | the format number, the build time and, for every layer and table, each file's lower bound (prefix-compressed against the one before) and name |
+| `<layer>/<table>/<hash>.json.gz` | about 32 KB of JSON rows sorted by key (16 KB for `entity`), named by the first 48 bits of the SHA-256 of the file |
+| `NOTICE.md`, `index.html` | each layer's sources and terms |
+
+The key tables are `flat` (folded names), `latin` (romaji keys), `sound` (sound keys across kana, Hangul and romaji), `part` (name tokens) and `initial` (Korean initials); their rows are `[key, entity number, name weight, flags, popularity, standing, bonus]`. `entity` rows, keyed by entity number (which follows the entity ids' order), carry the id, names, Danbooru tags, works and family of one entity in that layer. Layers stay in separate files; the only values a file carries from other layers are derived numbers and flags (popularity, family standing, adult, which layers know the entity).
+
+On the 10-04 build: 19,167 files, 149 MB gzip'd, a manifest of 236 KB gzip'd. `mise run compare` searches the probe sample (4,370 queries) both ways: the files find the entity first 87% of the time, SQLite 86% (FTS substring search is not in the files; typo search reads the rows around the query's position instead). A cold query needs a median of 2 rounds (p90 3), 31 files (p90 78) and 287 KB (p90 584 KB).
+
+The client is `@kecan0406/aninames` (`src/client/`), plain TypeScript for Node 22 and Bun that depends only on `es-hangul`:
+
+```ts
+import { cachedSource, httpSource, Names } from '@kecan0406/aninames'
+
+const source = cachedSource(httpSource('https://names.ttheme.dev'), `${cacheDir}/aninames`)
+const names = new Names(source, { layers: ['core', 'kowiki'] })
+const [first] = await names.search('봇치', { limit: 10, signal })
+const works = await names.lookup(first?.works ?? [])
+```
+
+`search` returns `Found` cards (`id`, `kind`, `label`, `names`, `danbooru` tags with the most posts first, `works`, `score`, `adult`); `search(query, { kind, limit, adult: false })` narrows it, and `lookup(ids)` returns the cards of given ids in one round. `cachedSource` keeps the files it fetched forever (their names are hashes of their contents), revalidates the manifest with its ETag or Last-Modified once a day (`maxAge`), answers from the cache when offline, refetches the manifest when the site has moved on to a new build, and deletes files a new manifest no longer names. `fileSource(dir)` reads a local `dist/site`.
+
+## Development
+
+```sh
+mise run fetch    # download raw data into .cache/raw
+mise run stage    # parse it into .cache/stage/*.jsonl
+mise run build    # write dist/core.sqlite, dist/kowiki.sqlite, dist/unlicensed.sqlite
+mise run search 고토 히토리
+mise run eval     # golden queries and the ttheme cast
+mise run probe    # search popular to long-tail entities by forms of their names
+mise run silver   # measure character merging against hidden cross-source ids
+mise run chunk    # write the static index to dist/site
+mise run compare  # search the probe sample with SQLite and with the client over dist/site
+mise run lib      # compile the client into lib/ for the npm package
+```
+
+Code is MIT-licensed (see `LICENSE`); the data files carry the licenses above.

package/lib/client/chunks.d.ts

@@ -0,0 +1,26 @@
+import type { Layer } from '../model.ts';
+import { type EntityRow, type KeyRow, type KeyTable, type Manifest } from './format.ts';
+export type Rows = KeyRow[] | EntityRow[];
+export type Loaded = (path: string) => Rows | undefined;
+export interface Range {
+    low: string;
+    high: string;
+    open?: boolean;
+    limit?: number;
+    spans?: number;
+    keep?: (row: KeyRow) => boolean;
+}
+export declare class View {
+    readonly wanted: Set<string>;
+    readonly manifest: Manifest;
+    readonly layers: Layer[];
+    labels: boolean;
+    private readonly loaded;
+    constructor(manifest: Manifest, layers: Layer[], loaded: Loaded);
+    private rows;
+    keys(table: KeyTable, range: Range): KeyRow[];
+    private keysIn;
+    around(table: KeyTable, key: string, radius: number): KeyRow[];
+    entity(eid: number, mask?: number): EntityRow[];
+    byId(id: string): EntityRow[];
+}

package/lib/client/chunks.js

@@ -0,0 +1,121 @@
+import { chunkPath, present } from "./format.js";
+import { compare } from "./order.js";
+function last(count, below) {
+    let lo = 0;
+    let hi = count;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (below(mid))
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo - 1;
+}
+function firstRow(rows, low, open) {
+    return (last(rows.length, (at) => {
+        const c = compare(rows[at][0], low);
+        return c < 0 || (open && c === 0);
+    }) + 1);
+}
+export class View {
+    wanted = new Set();
+    manifest;
+    layers;
+    labels = false;
+    loaded;
+    constructor(manifest, layers, loaded) {
+        this.manifest = manifest;
+        this.layers = layers;
+        this.loaded = loaded;
+    }
+    rows(layer, table, hash) {
+        const path = chunkPath(layer, table, hash);
+        const rows = this.loaded(path);
+        if (!rows)
+            this.wanted.add(path);
+        return rows;
+    }
+    keys(table, range) {
+        return this.layers.flatMap((layer) => this.keysIn(layer, table, range));
+    }
+    keysIn(layer, table, range) {
+        const spans = this.manifest.layers.get(layer)?.keys[table];
+        if (!spans)
+            return [];
+        const { low, high, open = false, limit = Number.POSITIVE_INFINITY, spans: most = Number.POSITIVE_INFINITY } = range;
+        const start = Math.max(0, last(spans.bounds.length, (at) => {
+            const c = compare(spans.bounds[at], low);
+            return c < 0 || (open && c === 0);
+        }));
+        const out = [];
+        for (let at = start; at < spans.files.length && at < start + most && out.length < limit; at++) {
+            const c = compare(spans.bounds[at], high);
+            if (c > 0 || (open && c === 0))
+                break;
+            const rows = this.rows(layer, table, spans.files[at]);
+            if (!rows)
+                continue;
+            for (let i = firstRow(rows, low, open); i < rows.length && out.length < limit; i++) {
+                const row = rows[i];
+                const d = compare(row[0], high);
+                if (d > 0 || (open && d === 0))
+                    break;
+                if (!range.keep || range.keep(row))
+                    out.push(row);
+            }
+        }
+        return out;
+    }
+    around(table, key, radius) {
+        const out = [];
+        for (const layer of this.layers) {
+            const spans = this.manifest.layers.get(layer)?.keys[table];
+            if (!spans || spans.files.length === 0)
+                continue;
+            const at = Math.max(0, last(spans.bounds.length, (i) => compare(spans.bounds[i], key) <= 0));
+            for (let i = Math.max(0, at - radius); i <= Math.min(spans.files.length - 1, at + radius); i++) {
+                const rows = this.rows(layer, table, spans.files[i]);
+                if (rows)
+                    out.push(...rows);
+            }
+        }
+        return out;
+    }
+    entity(eid, mask = 0) {
+        const out = [];
+        for (const layer of this.layers) {
+            if (mask && !(mask & present(layer)))
+                continue;
+            const spans = this.manifest.layers.get(layer)?.entity;
+            if (!spans)
+                continue;
+            const at = last(spans.eids.length, (i) => spans.eids[i] <= eid);
+            if (at < 0)
+                continue;
+            const rows = this.rows(layer, 'entity', spans.files[at]);
+            const i = rows ? last(rows.length, (r) => rows[r].eid < eid) + 1 : -1;
+            const row = rows?.[i];
+            if (row?.eid === eid)
+                out.push(row);
+        }
+        return out;
+    }
+    byId(id) {
+        const out = [];
+        for (const layer of this.layers) {
+            const spans = this.manifest.layers.get(layer)?.entity;
+            if (!spans)
+                continue;
+            const at = last(spans.bounds.length, (i) => compare(spans.bounds[i], id) <= 0);
+            if (at < 0)
+                continue;
+            const rows = this.rows(layer, 'entity', spans.files[at]);
+            const i = rows ? last(rows.length, (r) => compare(rows[r].id, id) < 0) + 1 : -1;
+            const row = rows?.[i];
+            if (row?.id === id)
+                out.push(row);
+        }
+        return out;
+    }
+}

package/lib/client/engine.d.ts

@@ -0,0 +1,20 @@
+import type { Kind } from '../model.ts';
+import type { View } from './chunks.ts';
+export interface Hit {
+    eid: number;
+    kind: Kind;
+    score: number;
+    matched: string;
+    how: string;
+    rank: number;
+    standing: number;
+    extra: number;
+    adult: boolean;
+    mask: number;
+}
+export interface Options {
+    kind?: Kind;
+    limit?: number;
+    adult?: boolean;
+}
+export declare function search(view: View, query: string, options?: Options): Hit[] | undefined;

package/lib/client/engine.js

@@ -0,0 +1,244 @@
+import { swapLayout, TOP, typing } from "../match.js";
+import { editDistance, flat, latinKey, partKey, qualifiers, soundKeys } from "../text.js";
+import { ADULT, CHARACTER, MAIN } from "./format.js";
+const SEEDS = 8;
+const FAMILY = 16;
+const PEOPLE = 10;
+const SPANS = 2;
+const RADIUS = 1;
+function hitOf(row, score, how) {
+    const flags = row[3];
+    return {
+        eid: row[1],
+        kind: flags & CHARACTER ? 'character' : 'work',
+        score,
+        matched: row[0],
+        how,
+        rank: row[4],
+        standing: row[5],
+        extra: row[6],
+        adult: (flags & ADULT) !== 0,
+        mask: flags & ~(CHARACTER | MAIN | ADULT),
+    };
+}
+function keeper(kind) {
+    if (!kind)
+        return undefined;
+    const character = kind === 'character';
+    return (row) => ((row[3] & CHARACTER) !== 0) === character;
+}
+function candidates(view, query, kind) {
+    const hits = new Map();
+    const keep = keeper(kind);
+    const consider = (row, base, how) => {
+        if (keep && !keep(row))
+            return;
+        const score = base * (row[2] / 1000);
+        const current = hits.get(row[1]);
+        if (!current || current.score < score)
+            hits.set(row[1], hitOf(row, score, how));
+    };
+    const exact = (table, key) => view.keys(table, { low: key, high: key, ...(keep ? { keep } : {}) });
+    const prefix = (table, low, high) => view.keys(table, { low, high, open: true, limit: 3000, spans: SPANS, ...(keep ? { keep } : {}) });
+    const q = flat(query);
+    if (!q)
+        return hits;
+    for (const row of exact('flat', q))
+        consider(row, 100, 'exact');
+    const latin = latinKey(query);
+    if (latin && /[a-z]/.test(latin))
+        for (const row of exact('latin', latin))
+            consider(row, 95, 'latin');
+    if (/^[ㄱ-ㅎ\s]+$/.test(query.trim())) {
+        const key = query.replace(/\s+/g, '');
+        for (const row of exact('initial', key))
+            consider(row, 86, 'initials');
+        for (const row of prefix('initial', key, `${key}${TOP}`))
+            consider(row, 60 + 20 * ([...key].length / [...row[0]].length), 'initials prefix');
+    }
+    if (!/\s/.test(query.trim())) {
+        for (const row of exact('part', partKey(query)))
+            consider(row, row[3] & CHARACTER && row[3] & MAIN ? 92 : 84, 'part');
+    }
+    for (const key of /[ㄱ-ㅎㅏ-ㅣᄀ-ᇿ]/.test(query) ? [] : soundKeys(qualifiers(query).base)) {
+        for (const row of exact('sound', key))
+            consider(row, 82, 'sound');
+    }
+    const length = [...q].length;
+    for (const [low, high] of typing(q)) {
+        for (const row of prefix('flat', low, high))
+            consider(row, 60 + 25 * (length / [...row[0]].length), low === q ? 'prefix' : 'typing');
+    }
+    return hits;
+}
+function fuzzy(view, query, kind) {
+    const hits = new Map();
+    const q = flat(query);
+    const chars = [...q];
+    if (chars.length < 4)
+        return hits;
+    const limit = chars.length >= 8 ? 2 : 1;
+    const keep = keeper(kind);
+    for (const row of view.around('flat', q, RADIUS)) {
+        if (keep && !keep(row))
+            continue;
+        const name = [...row[0]];
+        let score = 0;
+        const whole = editDistance(q, row[0], limit);
+        if (whole <= limit)
+            score = 92 - 10 * whole;
+        else if (name.length > chars.length) {
+            const lead = editDistance(q, name.slice(0, chars.length).join(''), limit);
+            if (lead <= limit)
+                score = 72 - 10 * lead;
+        }
+        if (score === 0)
+            continue;
+        score *= row[2] / 1000;
+        const current = hits.get(row[1]);
+        if (!current || current.score < score)
+            hits.set(row[1], hitOf(row, score, 'typo'));
+    }
+    return hits;
+}
+function reach(view, hit) {
+    return [...new Set(view.entity(hit.eid, hit.mask).flatMap((row) => row.reach))];
+}
+function named(rows, text) {
+    return rows.some((row) => row.names.some((name) => name.flat.includes(text)));
+}
+function family(view, hits, query) {
+    const wanted = flat(query);
+    const seeds = [...hits.values()]
+        .filter((hit) => hit.kind === 'work' && hit.score >= 50)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, SEEDS);
+    for (const seed of seeds) {
+        const score = seed.score * 0.97;
+        const matched = flat(seed.matched);
+        for (const other of reach(view, seed).slice(0, FAMILY)) {
+            const current = hits.get(other);
+            if (current && current.score >= score)
+                continue;
+            const rows = view.entity(other);
+            const row = rows[0];
+            if (!row || (!named(rows, wanted) && !named(rows, matched)))
+                continue;
+            hits.set(other, {
+                eid: other,
+                kind: 'work',
+                score,
+                matched: seed.matched,
+                how: `family(${seed.how})`,
+                rank: row.rank,
+                standing: row.standing,
+                extra: row.extra,
+                adult: row.adult,
+                mask: 0,
+            });
+        }
+    }
+}
+function scoped(view, query) {
+    const hits = new Map();
+    const tokens = query.normalize('NFKC').split(/\s+/).filter(Boolean);
+    for (let cut = 1; cut < tokens.length; cut++) {
+        for (const [who, where] of [
+            [tokens.slice(0, cut), tokens.slice(cut)],
+            [tokens.slice(cut), tokens.slice(0, cut)],
+        ]) {
+            const before = view.wanted.size;
+            const people = [...candidates(view, who.join(' '), 'character').values()]
+                .filter((h) => h.score >= 80)
+                .sort((a, b) => b.score - a.score)
+                .slice(0, PEOPLE);
+            if (people.length === 0)
+                continue;
+            const series = flat(where.join(' '));
+            const matched = [...candidates(view, where.join(' '), 'work').values()]
+                .filter((h) => h.score >= 50)
+                .sort((a, b) => b.score - a.score);
+            if (view.wanted.size > before)
+                continue;
+            const works = new Set(matched.map((h) => h.eid));
+            for (const hit of matched.slice(0, 20))
+                for (const other of reach(view, hit))
+                    works.add(other);
+            for (const person of people) {
+                const rows = view.entity(person.eid, person.mask);
+                const linked = rows.some((row) => row.works.some(([eid]) => works.has(eid)));
+                const qualified = rows.some((row) => row.names.some((name) => {
+                    if (!name.qual)
+                        return false;
+                    const q = flat(name.qual);
+                    return q.startsWith(series) || series.startsWith(q);
+                }));
+                if (!linked && !qualified)
+                    continue;
+                const score = 90 + person.score / 10;
+                const current = hits.get(person.eid);
+                if (!current || current.score < score)
+                    hits.set(person.eid, { ...person, score, how: linked ? 'scoped-work' : 'scoped-qual' });
+            }
+        }
+    }
+    return hits;
+}
+export function search(view, query, options = {}) {
+    const { kind } = options;
+    const hits = candidates(view, query, kind);
+    const swapped = swapLayout(query);
+    if (swapped)
+        candidates(view, swapped, kind);
+    fuzzy(view, query, kind);
+    if (!kind || kind === 'character') {
+        const tokens = query.normalize('NFKC').split(/\s+/).filter(Boolean);
+        for (let cut = 1; cut < tokens.length; cut++) {
+            for (const part of [tokens.slice(0, cut), tokens.slice(cut)]) {
+                candidates(view, part.join(' '), 'character');
+                candidates(view, part.join(' '), 'work');
+            }
+        }
+    }
+    if (view.wanted.size > 0)
+        return undefined;
+    if (!kind || kind === 'character') {
+        for (const [eid, hit] of scoped(view, query)) {
+            const current = hits.get(eid);
+            if (!current || current.score < hit.score)
+                hits.set(eid, hit);
+        }
+    }
+    if (!kind || kind === 'work')
+        family(view, hits, query);
+    if (view.wanted.size > 0)
+        return undefined;
+    const merge = (more, factor, how) => {
+        for (const [eid, hit] of more) {
+            const score = hit.score * factor;
+            const current = hits.get(eid);
+            if (!current || current.score < score)
+                hits.set(eid, { ...hit, score, how: how ? `${how}(${hit.how})` : hit.how });
+        }
+    };
+    let best = Math.max(0, ...[...hits.values()].map((h) => h.score));
+    if (best < 90 && swapped) {
+        merge(candidates(view, swapped, kind), 0.95, 'layout');
+        best = Math.max(0, ...[...hits.values()].map((h) => h.score));
+    }
+    if (best < 95)
+        merge(fuzzy(view, query, kind), 1);
+    if (view.wanted.size > 0)
+        return undefined;
+    const prior = (hit) => (hit.kind === 'work' ? hit.extra : 0);
+    const first = [...hits.values()]
+        .map((hit) => ({ ...hit, score: hit.score + (15 * hit.rank) / 1000 + prior(hit) }))
+        .sort((a, b) => b.score - a.score)
+        .filter((hit) => options.adult !== false || !hit.adult)
+        .slice(0, 60);
+    const weight = /\s/.test(query.trim()) ? 15 : 25;
+    return first
+        .map((hit) => ({ ...hit, score: (hits.get(hit.eid)?.score ?? 0) + (weight * hit.standing) / 1000 + hit.extra }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, options.limit ?? 10);
+}

package/lib/client/format.d.ts

@@ -0,0 +1,74 @@
+import { type Kind, type Layer, type NameKind } from '../model.ts';
+export declare const FORMAT = 1;
+export declare const KEY_TABLES: readonly ["flat", "latin", "sound", "part", "initial"];
+export type KeyTable = (typeof KEY_TABLES)[number];
+export type Table = KeyTable | 'entity';
+export declare const NAME_KINDS: readonly NameKind[];
+export declare const TRUSTED: readonly string[];
+export declare const CHARACTER = 1;
+export declare const MAIN = 2;
+export declare const ADULT = 4;
+export declare function present(layer: Layer): number;
+export declare const HASH_LENGTH = 12;
+export declare function chunkPath(layer: Layer, table: Table, hash: string): string;
+export declare function parsePath(path: string): {
+    layer: Layer;
+    table: Table;
+    hash: string;
+} | undefined;
+export declare function shared(a: string, b: string): number;
+export interface Packed {
+    share: number[];
+    rest: string[];
+    files: string;
+    eids?: number[];
+}
+export declare function pack(keys: string[], hashes: string[], eids?: number[]): Packed;
+export interface Spans {
+    bounds: string[];
+    files: string[];
+}
+export interface EntitySpans extends Spans {
+    eids: number[];
+}
+export interface LayerSpans {
+    keys: Record<KeyTable, Spans>;
+    entity: EntitySpans;
+}
+export interface Manifest {
+    built: string;
+    layers: Map<Layer, LayerSpans>;
+}
+export declare function readManifest(text: string): Manifest;
+export declare function manifestPaths(manifest: Manifest): Set<string>;
+export type KeyRow = readonly [
+    key: string,
+    eid: number,
+    weight: number,
+    flags: number,
+    rank: number,
+    standing: number,
+    extra: number
+];
+export interface Name {
+    text: string;
+    lang: string | null;
+    kind: NameKind;
+    trust: number;
+    qual: string | null;
+    flat: string;
+}
+export interface EntityRow {
+    eid: number;
+    id: string;
+    kind: Kind;
+    names: Name[];
+    danbooru: [tag: string, posts: number | null][];
+    works: [eid: number, id: string][];
+    reach: number[];
+    rank: number;
+    standing: number;
+    extra: number;
+    adult: boolean;
+}
+export declare function readRows(table: Table, value: unknown): KeyRow[] | EntityRow[] | undefined;