campus-stats 0.4.0

package/dist/db/store-api.d.ts

@@ -0,0 +1,9 @@
+import type { CampusCache } from "../types.js";
+import type { SyncResult } from "../sources/types.js";
+export type StoreMode = "json" | "sqlite";
+export declare function resolveStoreMode(args: string[]): StoreMode;
+export declare function resolveDbPath(args: string[], cwd?: string): string;
+export declare function readStore(mode: StoreMode, dbPath: string): Promise<CampusCache>;
+export declare function writeSyncToStore(mode: StoreMode, dbPath: string, result: SyncResult): Promise<CampusCache>;
+export declare function writeCacheToStore(mode: StoreMode, dbPath: string, cache: CampusCache): Promise<void>;
+export declare function runMigrate(args: string[]): Promise<void>;

package/dist/db/store-api.js

@@ -0,0 +1,70 @@
+import path from "node:path";
+import { loadCache, saveCache, cachePath, mergeSyncResult } from "../cache.js";
+import { DEFAULT_DB_PATH, migrateJsonCacheToSqlite } from "./migrate.js";
+import { SqliteStore } from "./sqlite-store.js";
+export function resolveStoreMode(args) {
+    if (args.includes("--json"))
+        return "json";
+    if (args.includes("--sqlite") || getArg(args, "--db"))
+        return "sqlite";
+    return "json";
+}
+export function resolveDbPath(args, cwd = process.cwd()) {
+    const raw = getArg(args, "--db") ?? DEFAULT_DB_PATH;
+    return path.isAbsolute(raw) ? raw : path.join(cwd, raw);
+}
+function getArg(args, name) {
+    const idx = args.indexOf(name);
+    if (idx === -1)
+        return undefined;
+    const value = args[idx + 1];
+    if (!value || value.startsWith("--"))
+        throw new Error(`Missing value for ${name}`);
+    return value;
+}
+export async function readStore(mode, dbPath) {
+    if (mode === "json")
+        return loadCache();
+    const store = new SqliteStore(dbPath);
+    try {
+        return store.loadCache();
+    }
+    finally {
+        store.close();
+    }
+}
+export async function writeSyncToStore(mode, dbPath, result) {
+    if (mode === "json") {
+        const cache = mergeSyncResult(await loadCache(), result);
+        await saveCache(cache);
+        return cache;
+    }
+    const store = new SqliteStore(dbPath);
+    try {
+        const existing = store.loadCache();
+        const merged = mergeSyncResult(existing, result);
+        store.upsertCache(merged);
+        return merged;
+    }
+    finally {
+        store.close();
+    }
+}
+export async function writeCacheToStore(mode, dbPath, cache) {
+    if (mode === "json") {
+        await saveCache(cache);
+        return;
+    }
+    const store = new SqliteStore(dbPath);
+    try {
+        store.replaceAll(cache);
+    }
+    finally {
+        store.close();
+    }
+}
+export async function runMigrate(args) {
+    const dbPath = resolveDbPath(args);
+    const result = await migrateJsonCacheToSqlite(dbPath, cachePath());
+    console.log(JSON.stringify(result, null, 2));
+}

package/dist/fantasy.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Product helpers aimed at women's fantasy football apps
+ * (club leagues + national-team tournaments).
+ */
+import { type StatsBombSourceOptions, type WomenCompetitionInfo } from "./sources/statsbomb.js";
+import type { SyncResult } from "./sources/types.js";
+import type { CampusCache, Competition } from "./types.js";
+export type { WomenCompetitionInfo };
+/** Default cap when enriching player stats in fantasy sync. */
+export declare const FANTASY_PLAYER_STATS_LIMIT = 25;
+export interface FantasySyncOptions extends StatsBombSourceOptions {
+    /**
+     * When including player stats, only enrich matches from each competition's
+     * latest season (recommended for fantasy scoring without downloading every
+     * historical event file).
+     */
+    latestSeasonPlayersOnly?: boolean;
+    /** Optional progress logger (CLI uses stderr). */
+    onProgress?: (message: string) => void;
+}
+/**
+ * List every women's competition currently published in StatsBomb Open Data.
+ * Includes club leagues (Liga F, WSL, …) and national-team tournaments
+ * (Women's World Cup, UEFA Women's Euro).
+ */
+export declare function listWomenCompetitions(options?: StatsBombSourceOptions): Promise<WomenCompetitionInfo[]>;
+/**
+ * One-shot sync of the full women's open-data catalogue — clubs + selecciones.
+ * This is the recommended bootstrap for a worldwide women's fantasy product.
+ */
+export declare function syncFantasyBundle(options?: FantasySyncOptions): Promise<SyncResult>;
+/**
+ * Re-sync every competition already present in a local cache (refresh path).
+ */
+export declare function updateCachedCompetitions(cache: CampusCache, options?: FantasySyncOptions): Promise<SyncResult>;
+export declare function competitionIsInternational(c: Competition): boolean;

package/dist/fantasy.js

@@ -0,0 +1,152 @@
+/**
+ * Product helpers aimed at women's fantasy football apps
+ * (club leagues + national-team tournaments).
+ */
+import { emptyCache, mergeSyncResult } from "./cache.js";
+import { StatsBombSource, } from "./sources/statsbomb.js";
+/** Default cap when enriching player stats in fantasy sync. */
+export const FANTASY_PLAYER_STATS_LIMIT = 25;
+/**
+ * List every women's competition currently published in StatsBomb Open Data.
+ * Includes club leagues (Liga F, WSL, …) and national-team tournaments
+ * (Women's World Cup, UEFA Women's Euro).
+ */
+export async function listWomenCompetitions(options = {}) {
+    const source = new StatsBombSource(options);
+    return source.listWomenCompetitions();
+}
+/**
+ * One-shot sync of the full women's open-data catalogue — clubs + selecciones.
+ * This is the recommended bootstrap for a worldwide women's fantasy product.
+ */
+export async function syncFantasyBundle(options = {}) {
+    const { latestSeasonPlayersOnly = true, onProgress, includePlayerStats = false, playerStatsLimit = FANTASY_PLAYER_STATS_LIMIT, ...sourceOpts } = options;
+    const source = new StatsBombSource({
+        ...sourceOpts,
+        includePlayerStats: false,
+    });
+    const catalogue = await source.listWomenCompetitions();
+    onProgress?.(`Fantasy bundle: ${catalogue.length} women's competitions (clubs + national teams)…`);
+    let merged = emptySyncResult();
+    for (const comp of catalogue) {
+        onProgress?.(`  syncing ${comp.name}${comp.international ? " (national teams)" : ""}…`);
+        const slice = await source.syncCompetition(comp.name);
+        merged = mergeSyncResults(merged, slice);
+    }
+    if (includePlayerStats) {
+        const enrichSource = new StatsBombSource({
+            ...sourceOpts,
+            includePlayerStats: true,
+            playerStatsLimit,
+        });
+        const targets = pickMatchesForPlayerStats(merged, {
+            latestSeasonOnly: latestSeasonPlayersOnly,
+            limit: playerStatsLimit,
+        });
+        onProgress?.(`  enriching player stats for ${targets.length} matches (fantasy metrics)…`);
+        const players = await enrichSource.loadPlayerStatsForMatches(targets);
+        merged.players = players.players;
+        merged.playerMatchStats = players.playerMatchStats;
+        merged.lineups = players.lineups;
+    }
+    return merged;
+}
+/**
+ * Re-sync every competition already present in a local cache (refresh path).
+ */
+export async function updateCachedCompetitions(cache, options = {}) {
+    const names = [...new Set(cache.competitions.map((c) => c.name))];
+    if (names.length === 0) {
+        return syncFantasyBundle(options);
+    }
+    const { onProgress, includePlayerStats = false, playerStatsLimit = FANTASY_PLAYER_STATS_LIMIT, latestSeasonPlayersOnly = true, ...sourceOpts } = options;
+    const source = new StatsBombSource({
+        ...sourceOpts,
+        includePlayerStats: false,
+    });
+    let merged = emptySyncResult();
+    for (const name of names) {
+        onProgress?.(`  updating ${name}…`);
+        const slice = await source.syncCompetition(name);
+        merged = mergeSyncResults(merged, slice);
+    }
+    if (includePlayerStats) {
+        const enrichSource = new StatsBombSource({
+            ...sourceOpts,
+            includePlayerStats: true,
+            playerStatsLimit,
+        });
+        const targets = pickMatchesForPlayerStats(merged, {
+            latestSeasonOnly: latestSeasonPlayersOnly,
+            limit: playerStatsLimit,
+        });
+        onProgress?.(`  enriching player stats for ${targets.length} matches…`);
+        const players = await enrichSource.loadPlayerStatsForMatches(targets);
+        merged.players = players.players;
+        merged.playerMatchStats = players.playerMatchStats;
+        merged.lineups = players.lineups;
+    }
+    return merged;
+}
+export function competitionIsInternational(c) {
+    return c.international === true;
+}
+function emptySyncResult() {
+    return {
+        competitions: [],
+        seasons: [],
+        teams: [],
+        matches: [],
+        players: [],
+        playerMatchStats: [],
+        lineups: [],
+        injuries: [],
+    };
+}
+function mergeSyncResults(a, b) {
+    const cache = mergeSyncResult(mergeSyncResult(emptyCache(), {
+        ...a,
+        players: a.players ?? [],
+        playerMatchStats: a.playerMatchStats ?? [],
+        lineups: a.lineups ?? [],
+        injuries: a.injuries ?? [],
+    }), {
+        ...b,
+        players: b.players ?? [],
+        playerMatchStats: b.playerMatchStats ?? [],
+        lineups: b.lineups ?? [],
+        injuries: b.injuries ?? [],
+    });
+    return {
+        competitions: cache.competitions,
+        seasons: cache.seasons,
+        teams: cache.teams,
+        matches: cache.matches,
+        players: cache.players,
+        playerMatchStats: cache.playerMatchStats,
+        lineups: cache.lineups,
+        injuries: cache.injuries,
+    };
+}
+function pickMatchesForPlayerStats(result, opts) {
+    const seasonsByComp = new Map();
+    for (const s of result.seasons) {
+        const list = seasonsByComp.get(s.competitionId) ?? [];
+        list.push(s);
+        seasonsByComp.set(s.competitionId, list);
+    }
+    const latestSeasonIds = new Set();
+    if (opts.latestSeasonOnly) {
+        for (const [, seasons] of seasonsByComp) {
+            // Season names are chronological enough for open-data labels; prefer last by name.
+            const sorted = [...seasons].sort((a, b) => a.name.localeCompare(b.name));
+            const latest = sorted[sorted.length - 1];
+            if (latest)
+                latestSeasonIds.add(latest.id);
+        }
+    }
+    const candidates = result.matches
+        .filter((m) => (opts.latestSeasonOnly ? latestSeasonIds.has(m.seasonId) : true))
+        .sort((a, b) => (b.date ?? "").localeCompare(a.date ?? ""));
+    return candidates.slice(0, opts.limit);
+}

package/dist/http.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Polite HTTP helper for HTML sources (FBref, etc.).
+ * Sequential requests share a minimum delay; failed GETs retry with backoff.
+ */
+export interface HttpClientOptions {
+    userAgent?: string;
+    /** Minimum ms between request starts (default 1500). */
+    minIntervalMs?: number;
+    /** Max attempts including the first (default 3). */
+    maxAttempts?: number;
+    fetchImpl?: typeof fetch;
+    sleep?: (ms: number) => Promise<void>;
+}
+export declare class HttpClient {
+    private readonly userAgent;
+    private readonly minIntervalMs;
+    private readonly maxAttempts;
+    private readonly fetchImpl;
+    private readonly sleep;
+    private chain;
+    private lastStartedAt;
+    constructor(options?: HttpClientOptions);
+    getText(url: string): Promise<string>;
+    private scheduledGet;
+}

package/dist/http.js

@@ -0,0 +1,63 @@
+/**
+ * Polite HTTP helper for HTML sources (FBref, etc.).
+ * Sequential requests share a minimum delay; failed GETs retry with backoff.
+ */
+const DEFAULT_UA = "campus/0.0.1 (women's football research; +https://gitlab.com/marina34/campus)";
+function defaultSleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export class HttpClient {
+    userAgent;
+    minIntervalMs;
+    maxAttempts;
+    fetchImpl;
+    sleep;
+    chain = Promise.resolve();
+    lastStartedAt = 0;
+    constructor(options = {}) {
+        this.userAgent = options.userAgent ?? DEFAULT_UA;
+        this.minIntervalMs = options.minIntervalMs ?? 1500;
+        this.maxAttempts = options.maxAttempts ?? 3;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+        this.sleep = options.sleep ?? defaultSleep;
+    }
+    async getText(url) {
+        let lastError;
+        for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+            try {
+                return await this.scheduledGet(url);
+            }
+            catch (err) {
+                lastError = err;
+                if (attempt === this.maxAttempts)
+                    break;
+                const backoff = this.minIntervalMs * attempt;
+                await this.sleep(backoff);
+            }
+        }
+        throw lastError instanceof Error
+            ? lastError
+            : new Error(`HTTP GET failed for ${url}`);
+    }
+    scheduledGet(url) {
+        const run = this.chain.then(async () => {
+            const wait = Math.max(0, this.minIntervalMs - (Date.now() - this.lastStartedAt));
+            if (wait > 0)
+                await this.sleep(wait);
+            this.lastStartedAt = Date.now();
+            const res = await this.fetchImpl(url, {
+                headers: {
+                    "user-agent": this.userAgent,
+                    accept: "text/html,application/xhtml+xml",
+                },
+            });
+            if (!res.ok) {
+                throw new Error(`HTTP ${res.status} for ${url}`);
+            }
+            return res.text();
+        });
+        // Keep the queue alive even if a request fails.
+        this.chain = run.then(() => undefined, () => undefined);
+        return run;
+    }
+}

package/dist/identity/match.d.ts

@@ -0,0 +1,22 @@
+import type { Team } from "../types.js";
+import type { CanonicalIdentity, IdentityConfidence } from "./types.js";
+/** Normalize club names for comparison across providers. */
+export declare function normalizeTeamName(name: string): string;
+export interface TeamMatchCandidate {
+    left: Team;
+    right: Team;
+    score: number;
+    confidence: IdentityConfidence;
+}
+/** Dice coefficient on normalized tokens. */
+export declare function nameSimilarity(a: string, b: string): number;
+/**
+ * Propose team matches between two source cohorts.
+ * `left` / `right` are typically teams that appear in the same competition
+ * context but come from different providers.
+ */
+export declare function matchTeamsAcrossSources(left: Team[], right: Team[], options?: {
+    competitionHint?: string;
+    minScore?: number;
+}): TeamMatchCandidate[];
+export declare function candidateToIdentity(candidate: TeamMatchCandidate, competitionHint?: string): CanonicalIdentity;

package/dist/identity/match.js

@@ -0,0 +1,106 @@
+import { entityId } from "../ids.js";
+const NOISE = new Set([
+    "w",
+    "wfc",
+    "fc",
+    "cf",
+    "afc",
+    "women",
+    "women's",
+    "womens",
+    "lady",
+    "ladies",
+    "club",
+    "the",
+]);
+/** Normalize club names for comparison across providers. */
+export function normalizeTeamName(name) {
+    return name
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/\p{M}/gu, "")
+        .replace(/[^a-z0-9\s]/g, " ")
+        .split(/\s+/)
+        .filter((t) => t && !NOISE.has(t))
+        .join(" ")
+        .trim();
+}
+function tokenSet(name) {
+    return new Set(normalizeTeamName(name).split(" ").filter(Boolean));
+}
+/** Dice coefficient on normalized tokens. */
+export function nameSimilarity(a, b) {
+    const na = normalizeTeamName(a);
+    const nb = normalizeTeamName(b);
+    if (!na || !nb)
+        return 0;
+    if (na === nb)
+        return 1;
+    const ta = tokenSet(a);
+    const tb = tokenSet(b);
+    if (ta.size === 0 || tb.size === 0)
+        return 0;
+    let inter = 0;
+    for (const t of ta)
+        if (tb.has(t))
+            inter += 1;
+    return (2 * inter) / (ta.size + tb.size);
+}
+function confidenceFor(score) {
+    if (score >= 0.9)
+        return "high";
+    if (score >= 0.7)
+        return "medium";
+    return "low";
+}
+/**
+ * Propose team matches between two source cohorts.
+ * `left` / `right` are typically teams that appear in the same competition
+ * context but come from different providers.
+ */
+export function matchTeamsAcrossSources(left, right, options = {}) {
+    const minScore = options.minScore ?? 0.7;
+    const usedRight = new Set();
+    const candidates = [];
+    for (const l of left) {
+        let best;
+        for (const r of right) {
+            if (usedRight.has(r.id))
+                continue;
+            // Never link two refs from the same provider key as a "cross-source" hit.
+            const lSources = new Set(l.sources.map((s) => s.source));
+            if (r.sources.some((s) => lSources.has(s.source)))
+                continue;
+            const score = nameSimilarity(l.name, r.name);
+            if (score < minScore)
+                continue;
+            const cand = {
+                left: l,
+                right: r,
+                score,
+                confidence: confidenceFor(score),
+            };
+            if (!best || cand.score > best.score)
+                best = cand;
+        }
+        if (best) {
+            usedRight.add(best.right.id);
+            candidates.push(best);
+        }
+    }
+    return candidates.sort((a, b) => b.score - a.score);
+}
+export function candidateToIdentity(candidate, competitionHint) {
+    const slug = normalizeTeamName(candidate.left.name).replace(/\s+/g, "-") || "team";
+    return {
+        id: entityId("identity", "team", slug),
+        kind: "team",
+        name: candidate.left.name,
+        aliases: [...new Set([candidate.left.name, candidate.right.name])],
+        sources: [...candidate.left.sources, ...candidate.right.sources],
+        confidence: candidate.confidence,
+        // Status filled by rule layer; default pending here.
+        status: "pending",
+        competitionHint,
+    };
+}

package/dist/identity/propose.d.ts

@@ -0,0 +1,8 @@
+import type { CampusCache, Team } from "../types.js";
+/** Split cached teams by primary provenance source. */
+export declare function partitionTeamsBySource(teams: Team[]): Map<string, Team[]>;
+/**
+ * Propose identities between the first two source cohorts present for a
+ * competition (typically statsbomb vs fbref).
+ */
+export declare function proposeIdentitiesForCompetition(cache: CampusCache, competitionName: string): CampusCache;

package/dist/identity/propose.js

@@ -0,0 +1,45 @@
+import { matchTeamsAcrossSources } from "./match.js";
+import { applyIdentityRules } from "./rules.js";
+import { upsertIdentities } from "./store.js";
+function teamsForCompetition(cache, competitionName) {
+    const competition = cache.competitions.find((c) => c.name.toLowerCase() === competitionName.toLowerCase());
+    if (!competition)
+        return [];
+    const ids = new Set();
+    for (const m of cache.matches) {
+        if (m.competitionId !== competition.id)
+            continue;
+        ids.add(m.homeTeamId);
+        ids.add(m.awayTeamId);
+    }
+    return cache.teams.filter((t) => ids.has(t.id));
+}
+/** Split cached teams by primary provenance source. */
+export function partitionTeamsBySource(teams) {
+    const map = new Map();
+    for (const team of teams) {
+        const source = team.sources[0]?.source ?? "unknown";
+        const list = map.get(source) ?? [];
+        list.push(team);
+        map.set(source, list);
+    }
+    return map;
+}
+/**
+ * Propose identities between the first two source cohorts present for a
+ * competition (typically statsbomb vs fbref).
+ */
+export function proposeIdentitiesForCompetition(cache, competitionName) {
+    const teams = teamsForCompetition(cache, competitionName);
+    const bySource = [...partitionTeamsBySource(teams).entries()];
+    if (bySource.length < 2) {
+        throw new Error(`Need teams from at least two sources in cache for "${competitionName}" before proposing identities.`);
+    }
+    const [, left] = bySource[0];
+    const [, right] = bySource[1];
+    const candidates = matchTeamsAcrossSources(left, right, {
+        competitionHint: competitionName,
+    });
+    const identities = applyIdentityRules(candidates, competitionName);
+    return upsertIdentities(cache, identities);
+}

package/dist/identity/rules.d.ts

@@ -0,0 +1,8 @@
+import type { CanonicalIdentity } from "./types.js";
+import { type TeamMatchCandidate } from "./match.js";
+/**
+ * Auto-resolve only high-confidence exact-ish matches.
+ * Medium/low stay `pending` for review — never silent merge.
+ */
+export declare function applyIdentityRules(candidates: TeamMatchCandidate[], competitionHint?: string): CanonicalIdentity[];
+export declare function isQueryableIdentity(identity: CanonicalIdentity): boolean;

package/dist/identity/rules.js

@@ -0,0 +1,17 @@
+import { candidateToIdentity, } from "./match.js";
+/**
+ * Auto-resolve only high-confidence exact-ish matches.
+ * Medium/low stay `pending` for review — never silent merge.
+ */
+export function applyIdentityRules(candidates, competitionHint) {
+    return candidates.map((c) => {
+        const identity = candidateToIdentity(c, competitionHint);
+        if (c.confidence === "high" && c.score >= 0.95) {
+            return { ...identity, status: "resolved" };
+        }
+        return { ...identity, status: "pending", confidence: c.confidence };
+    });
+}
+export function isQueryableIdentity(identity) {
+    return identity.status === "resolved";
+}

package/dist/identity/store.d.ts

@@ -0,0 +1,5 @@
+import type { CampusCache } from "../types.js";
+import type { CanonicalIdentity } from "./types.js";
+export declare function mergeIdentities(existing: CanonicalIdentity[], incoming: CanonicalIdentity[]): CanonicalIdentity[];
+export declare function upsertIdentities(cache: CampusCache, identities: CanonicalIdentity[]): CampusCache;
+export declare function setIdentityStatus(cache: CampusCache, identityId: string, status: CanonicalIdentity["status"]): CampusCache;

package/dist/identity/store.js

@@ -0,0 +1,20 @@
+export function mergeIdentities(existing, incoming) {
+    const map = new Map();
+    for (const item of existing)
+        map.set(item.id, item);
+    for (const item of incoming)
+        map.set(item.id, item);
+    return [...map.values()];
+}
+export function upsertIdentities(cache, identities) {
+    return {
+        ...cache,
+        identities: mergeIdentities(cache.identities, identities),
+    };
+}
+export function setIdentityStatus(cache, identityId, status) {
+    return {
+        ...cache,
+        identities: cache.identities.map((identity) => identity.id === identityId ? { ...identity, status } : identity),
+    };
+}

package/dist/identity/types.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Cross-source identity model for campus.
+ *
+ * A CanonicalIdentity groups one or more provider-native SourceRefs that
+ * refer to the same real-world club (later: player). Confidence and status
+ * decide whether the link is safe to auto-apply in queries.
+ */
+import type { SourceRef } from "../refs.js";
+export type IdentityKind = "team" | "player";
+/** How sure we are that the linked source refs are the same entity. */
+export type IdentityConfidence = "high" | "medium" | "low";
+/**
+ * `resolved` — safe to treat as one entity in queries.
+ * `pending` — candidate needs human review; do not auto-merge.
+ * `rejected` — reviewed and kept separate.
+ */
+export type IdentityStatus = "resolved" | "pending" | "rejected";
+export interface CanonicalIdentity {
+    /** Stable campus identity id, e.g. `identity:team:…`. */
+    id: string;
+    kind: IdentityKind;
+    /** Preferred display name. */
+    name: string;
+    /** Extra names that should match this identity. */
+    aliases: string[];
+    /** Provider refs that belong to this identity. */
+    sources: SourceRef[];
+    confidence: IdentityConfidence;
+    status: IdentityStatus;
+    /** Optional competition context used when the match was proposed. */
+    competitionHint?: string;
+}

package/dist/identity/types.js

@@ -0,0 +1,8 @@
+/**
+ * Cross-source identity model for campus.
+ *
+ * A CanonicalIdentity groups one or more provider-native SourceRefs that
+ * refer to the same real-world club (later: player). Confidence and status
+ * decide whether the link is safe to auto-apply in queries.
+ */
+export {};

package/dist/ids.d.ts

@@ -0,0 +1,2 @@
+/** Build stable campus ids from a provider key + native parts. */
+export declare function entityId(source: string, ...parts: Array<string | number>): string;

package/dist/ids.js

@@ -0,0 +1,4 @@
+/** Build stable campus ids from a provider key + native parts. */
+export function entityId(source, ...parts) {
+    return [source, ...parts.map(String)].join(":");
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export type { SourceRef, TeamKind, Competition, Season, Team, Match, Player, PlayerMatchStats, LineupEntry, InjuryRecord, CampusCache, } from "./types.js";
+export type { IdentityKind, IdentityConfidence, IdentityStatus, CanonicalIdentity, } from "./identity/types.js";
+export type { FootballSource, SyncResult } from "./sources/types.js";
+export { StatsBombSource } from "./sources/statsbomb.js";
+export type { WomenCompetitionInfo } from "./sources/statsbomb.js";
+export { FbrefSource, listFbrefPilotNames } from "./sources/fbref.js";
+export { emptyCache, cachePath, loadCache, saveCache, mergeSyncResult, DEFAULT_CACHE_DIR, DEFAULT_CACHE_FILE, } from "./cache.js";
+export { SqliteStore, SCHEMA_SQL } from "./db/sqlite-store.js";
+export { FANTASY_PLAYER_STATS_LIMIT, listWomenCompetitions, syncFantasyBundle, updateCachedCompetitions, competitionIsInternational, } from "./fantasy.js";
+export type { FantasySyncOptions } from "./fantasy.js";
+export { GITLAB_PROJECT_ID, DATA_BUNDLE_PACKAGE, DATA_BUNDLE_VERSION, DATA_BUNDLE_FILE, dataBundleUrl, dataBundleMetaUrl, } from "./data-bundle.js";
+export { CampusClient } from "./client.js";
+export type { SquadMember } from "./client.js";
+export { DEFAULT_FANTASY_RULES, scorePlayerMatchStats, scoreFantasyPoints, } from "./scoring.js";
+export type { FantasyScoringRules, FantasyPointRow } from "./scoring.js";
+export { INJURIES_AVAILABLE, INJURIES_STATUS_MESSAGE, listInjuries, } from "./injuries.js";