@tpsdev-ai/flair-bench 0.22.0

package/dist/prefixes.js

@@ -0,0 +1,64 @@
+/**
+ * prefixes.ts — the input-prefix convention table.
+ *
+ * Mirrors resources/embeddings-provider.ts's Phase 2 behavior (flair#504):
+ * HFE 0.3.0's engine prepends a literal `"search_document: "` /
+ * `"search_query: "` string ahead of the text it hands to the model, for
+ * nomic-family models trained on that asymmetric-prefix convention. flair-
+ * bench talks to node-llama-cpp directly (no HFE in the loop — see the
+ * package README for why), so it has to replicate that string-prepend
+ * itself rather than pass an `inputType` option through to a wrapper that
+ * does it.
+ *
+ * KEYED ON MODEL FILENAME, for now — nomic is the only convention flair
+ * ships today, and there's exactly one production model family to match.
+ * This table is the seam for adding more: a future entry keys on another
+ * filename pattern (or, if a GGUF ever carries a documented convention-id
+ * in its own metadata, that becomes the preferred match — filename is a
+ * pragmatic fallback, not a design commitment). Nomic upstream has a request
+ * to carry this in the GGUF/HFE registration surface itself rather than
+ * every consumer re-deriving it from a filename convention — see
+ * harper-fabric-embeddings#4 (upstream proposal, not yet merged as of this
+ * writing).
+ *
+ * A model whose filename matches no entry gets `undefined` from
+ * `resolvePrefixConvention()` — texts are embedded unprefixed, and the
+ * result is labeled accordingly rather than silently guessing.
+ */
+const NOMIC_CONVENTION = {
+    id: "nomic-search-prefix",
+    documentPrefix: "search_document: ",
+    queryPrefix: "search_query: ",
+};
+/**
+ * The convention table. Order matters only in that the first match wins —
+ * kept a flat array (not a Map) since patterns can overlap in principle
+ * (e.g. a future family sharing a "nomic-embed" substring with a distinct
+ * suffix) and an explicit ordered scan makes that resolvable without a key
+ * collision.
+ */
+const CONVENTIONS = [
+    {
+        id: "nomic-embed-text-family",
+        // nomic-embed-text-v1.5.*, nomic-embed-text-v2-moe.* — both nomic
+        // families document the same search_document:/search_query: task-prefix
+        // convention on their model cards.
+        filenamePattern: /^nomic-embed-text/i,
+        convention: NOMIC_CONVENTION,
+    },
+];
+/** Resolve the prefix convention for a GGUF file, by basename. `undefined` = no known convention (embed unprefixed). */
+export function resolvePrefixConvention(fileName) {
+    const base = fileName.replace(/^.*[/\\]/, "");
+    for (const entry of CONVENTIONS) {
+        if (entry.filenamePattern.test(base))
+            return entry.convention;
+    }
+    return undefined;
+}
+export function applyDocumentPrefix(text, convention) {
+    return convention ? `${convention.documentPrefix}${text}` : text;
+}
+export function applyQueryPrefix(text, convention) {
+    return convention ? `${convention.queryPrefix}${text}` : text;
+}

package/dist/recommend-heuristic.d.ts

@@ -0,0 +1,22 @@
+/**
+ * recommend-heuristic.ts — the pure "which model should I use" pick,
+ * factored out of index.ts's recommend() so it's unit-testable against
+ * fixture BatchResult objects (see test/recommend.test.ts) without ever
+ * touching node-llama-cpp or a real GGUF file.
+ *
+ * See recommend()'s own doc in index.ts for the honesty caveats this
+ * heuristic carries (single-request serial measurement, no concurrency
+ * model, fixed fraction/ceiling thresholds).
+ */
+import type { BatchResult, Recommendation } from "./types.js";
+export declare const DEFAULT_RAM_HEADROOM_FRACTION = 0.5;
+export declare const DEFAULT_LATENCY_THRESHOLD_MS = 500;
+export interface RecommendHeuristicOptions {
+    ramHeadroomFraction?: number;
+    latencyThresholdMsPerEmbed?: number;
+}
+export interface RecommendHeuristicResult {
+    recommendation: Recommendation | null;
+    notes: string[];
+}
+export declare function pickRecommendation(batch: BatchResult, options?: RecommendHeuristicOptions): RecommendHeuristicResult;

package/dist/recommend-heuristic.js

@@ -0,0 +1,48 @@
+/**
+ * recommend-heuristic.ts — the pure "which model should I use" pick,
+ * factored out of index.ts's recommend() so it's unit-testable against
+ * fixture BatchResult objects (see test/recommend.test.ts) without ever
+ * touching node-llama-cpp or a real GGUF file.
+ *
+ * See recommend()'s own doc in index.ts for the honesty caveats this
+ * heuristic carries (single-request serial measurement, no concurrency
+ * model, fixed fraction/ceiling thresholds).
+ */
+import { basename } from "node:path";
+export const DEFAULT_RAM_HEADROOM_FRACTION = 0.5; // generous: a model may use up to half of currently-available RAM
+export const DEFAULT_LATENCY_THRESHOLD_MS = 500; // generous: 500ms/embed serial is a very permissive ceiling
+export function pickRecommendation(batch, options = {}) {
+    const ramHeadroomFraction = options.ramHeadroomFraction ?? DEFAULT_RAM_HEADROOM_FRACTION;
+    const latencyThresholdMsPerEmbed = options.latencyThresholdMsPerEmbed ?? DEFAULT_LATENCY_THRESHOLD_MS;
+    const notes = [
+        `Heuristic: best measured recall (MRR) among models whose peak RSS delta fits within ${Math.round(ramHeadroomFraction * 100)}% of available RAM (${(batch.host.availableRamGiB * ramHeadroomFraction).toFixed(1)} GiB budget on this host) and whose ms/embed is <= ${latencyThresholdMsPerEmbed}ms. Doesn't know your concurrency, batching, or serving framework — see README for the full limits list.`,
+    ];
+    if (batch.models.length === 0) {
+        return { recommendation: null, notes: [...notes, "No models were benchmarked."] };
+    }
+    const budgetMiB = batch.host.availableRamGiB * ramHeadroomFraction * 1024;
+    const affordable = batch.models.filter((m) => m.peakRssDeltaMiB <= budgetMiB && m.msPerEmbedSerialWarm <= latencyThresholdMsPerEmbed);
+    let pool = affordable;
+    if (affordable.length === 0) {
+        pool = batch.models;
+        notes.push(`No model fit the RAM/latency budget above — falling back to ranking all ${batch.models.length} benchmarked model(s) by recall alone. Treat this pick as informational, not a "fits your host" claim.`);
+    }
+    const ranked = [...pool].sort((a, b) => b.aggregate.mrr - a.aggregate.mrr || a.msPerEmbedSerialWarm - b.msPerEmbedSerialWarm);
+    const best = ranked[0];
+    const runnerUp = ranked[1];
+    let reason;
+    if (runnerUp) {
+        reason =
+            `${basename(best.model.fileName)} because p@3 ${best.aggregate.p3.toFixed(3)} vs ${runnerUp.aggregate.p3.toFixed(3)} ` +
+                `(MRR ${best.aggregate.mrr.toFixed(3)} vs ${runnerUp.aggregate.mrr.toFixed(3)}) at ${best.msPerEmbedSerialWarm.toFixed(1)}ms/embed ` +
+                `and ${best.peakRssDeltaMiB.toFixed(0)} MiB peak RSS on your ${batch.host.availableRamGiB.toFixed(1)}GiB-available ${batch.host.backend} host.`;
+    }
+    else {
+        reason =
+            `${basename(best.model.fileName)} — the only model benchmarked (p@3 ${best.aggregate.p3.toFixed(3)}, MRR ${best.aggregate.mrr.toFixed(3)}) ` +
+                `at ${best.msPerEmbedSerialWarm.toFixed(1)}ms/embed and ${best.peakRssDeltaMiB.toFixed(0)} MiB peak RSS on your ${batch.host.availableRamGiB.toFixed(1)}GiB-available ${batch.host.backend} host. ` +
+                `Run with more --model-file flags to get a real comparison.`;
+    }
+    const recommendation = { fileName: best.model.fileName, reason };
+    return { recommendation, notes };
+}

package/dist/scorer.d.ts

@@ -0,0 +1,32 @@
+/**
+ * scorer.ts — precision@3 / MRR scoring, faithfully replicated from
+ * test/bench/recall-harness/run.ts's `statsFor()` (that function is not
+ * exported, so it can't be imported directly — see test/scorer-sync.test.ts,
+ * which parses run.ts's source text and asserts it still contains this
+ * exact formula, so a change to the harness's scoring math trips a loud
+ * failure here instead of silently drifting).
+ *
+ * KEEP THIS FUNCTION BYTE-FOR-BYTE IDENTICAL (modulo variable/type names) to
+ * run.ts's `statsFor()`:
+ *
+ *   function statsFor(rows: QueryRow[]): { p3: number; mrr: number; n: number } {
+ *     if (!rows.length) return { p3: 0, mrr: 0, n: 0 };
+ *     const hits3 = rows.filter(r => r.rank >= 0 && r.rank < 3).length;
+ *     const rr = rows.reduce((s, r) => s + (r.rank >= 0 ? 1 / (r.rank + 1) : 0), 0);
+ *     return { p3: hits3 / rows.length, mrr: rr / rows.length, n: rows.length };
+ *   }
+ */
+import type { QueryKind } from "./corpus-v2.js";
+import type { AggregateStat, PerKindStat } from "./types.js";
+export interface ScoredRow {
+    /** 0-based rank of the expected record, or -1 if not found. */
+    rank: number;
+    kind: QueryKind;
+}
+export declare function statsFor(rows: readonly {
+    rank: number;
+}[]): AggregateStat;
+export declare function scoreRows(rows: readonly ScoredRow[]): {
+    aggregate: AggregateStat;
+    perKind: Record<QueryKind, PerKindStat>;
+};

package/dist/scorer.js

@@ -0,0 +1,31 @@
+/**
+ * scorer.ts — precision@3 / MRR scoring, faithfully replicated from
+ * test/bench/recall-harness/run.ts's `statsFor()` (that function is not
+ * exported, so it can't be imported directly — see test/scorer-sync.test.ts,
+ * which parses run.ts's source text and asserts it still contains this
+ * exact formula, so a change to the harness's scoring math trips a loud
+ * failure here instead of silently drifting).
+ *
+ * KEEP THIS FUNCTION BYTE-FOR-BYTE IDENTICAL (modulo variable/type names) to
+ * run.ts's `statsFor()`:
+ *
+ *   function statsFor(rows: QueryRow[]): { p3: number; mrr: number; n: number } {
+ *     if (!rows.length) return { p3: 0, mrr: 0, n: 0 };
+ *     const hits3 = rows.filter(r => r.rank >= 0 && r.rank < 3).length;
+ *     const rr = rows.reduce((s, r) => s + (r.rank >= 0 ? 1 / (r.rank + 1) : 0), 0);
+ *     return { p3: hits3 / rows.length, mrr: rr / rows.length, n: rows.length };
+ *   }
+ */
+export function statsFor(rows) {
+    if (!rows.length)
+        return { p3: 0, mrr: 0, n: 0 };
+    const hits3 = rows.filter((r) => r.rank >= 0 && r.rank < 3).length;
+    const rr = rows.reduce((s, r) => s + (r.rank >= 0 ? 1 / (r.rank + 1) : 0), 0);
+    return { p3: hits3 / rows.length, mrr: rr / rows.length, n: rows.length };
+}
+const ALL_KINDS = ["stress", "trap", "hard", "clean"];
+export function scoreRows(rows) {
+    const aggregate = statsFor(rows);
+    const perKind = Object.fromEntries(ALL_KINDS.map((k) => [k, statsFor(rows.filter((r) => r.kind === k))]));
+    return { aggregate, perKind };
+}

package/dist/share.d.ts

@@ -0,0 +1,30 @@
+/**
+ * share.ts — canonical share-JSON schema + local write.
+ *
+ * PRIVACY CONTRACT: the document built here MUST NEVER contain a hostname,
+ * filesystem path, or username. `model.fileBasename` is a basename (see
+ * ModelIdentity.fileName's own doc — never the full path); `hardware.label`
+ * is a freeform string the CALLER chose (see types.ts's HostFingerprint —
+ * defaults to nothing, never auto-filled from os.hostname()). See
+ * test/share-schema.test.ts for the automated forbidden-field check this
+ * contract is gated on.
+ *
+ * The submission endpoint is a placeholder — see writeShareDocument's doc.
+ * No network call happens anywhere in this file.
+ */
+import type { ModelBenchResult, HostFingerprint, ShareDocument } from "./types.js";
+/** Config placeholder for the future hosted submission endpoint (not implemented — see README "Stubbed"). */
+export declare const SUBMISSION_ENDPOINT_PLACEHOLDER = "https://bench.tps.dev/api/submit";
+export declare function buildShareDocument(result: ModelBenchResult, host: HostFingerprint): ShareDocument;
+export interface WrittenShare {
+    filePath: string;
+    endpointNote: string;
+}
+/**
+ * Writes the share document locally and returns where. The hosted
+ * submission endpoint (SUBMISSION_ENDPOINT_PLACEHOLDER) is not wired up —
+ * this function never makes a network call; the CLI layer is what prints
+ * `endpointNote` to the user (core does no console output — see index.ts's
+ * header).
+ */
+export declare function writeShareDocument(doc: ShareDocument, outDir?: string): WrittenShare;

package/dist/share.js

@@ -0,0 +1,75 @@
+/**
+ * share.ts — canonical share-JSON schema + local write.
+ *
+ * PRIVACY CONTRACT: the document built here MUST NEVER contain a hostname,
+ * filesystem path, or username. `model.fileBasename` is a basename (see
+ * ModelIdentity.fileName's own doc — never the full path); `hardware.label`
+ * is a freeform string the CALLER chose (see types.ts's HostFingerprint —
+ * defaults to nothing, never auto-filled from os.hostname()). See
+ * test/share-schema.test.ts for the automated forbidden-field check this
+ * contract is gated on.
+ *
+ * The submission endpoint is a placeholder — see writeShareDocument's doc.
+ * No network call happens anywhere in this file.
+ */
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { TOOL_VERSION } from "./version.js";
+/** Config placeholder for the future hosted submission endpoint (not implemented — see README "Stubbed"). */
+export const SUBMISSION_ENDPOINT_PLACEHOLDER = "https://bench.tps.dev/api/submit"; // not live; no network call is ever made against this
+function deriveModelName(fileBasename) {
+    // Strip a trailing .gguf and a recognizable quant/variant suffix so the
+    // "name" reads as the model family, e.g. "nomic-embed-text-v1.5.Q4_K_M.gguf"
+    // -> "nomic-embed-text-v1.5". Best-effort — falls back to the basename
+    // minus extension if no quant suffix is recognized.
+    const withoutExt = fileBasename.replace(/\.gguf$/i, "");
+    const withoutQuant = withoutExt.replace(/\.((?:Q|IQ)[0-9][A-Z0-9_]*|F16|F32|BF16)$/i, "");
+    return withoutQuant;
+}
+export function buildShareDocument(result, host) {
+    return {
+        toolVersion: TOOL_VERSION,
+        timestamp: new Date().toISOString(),
+        model: {
+            name: deriveModelName(result.model.fileName),
+            fileBasename: result.model.fileName,
+            sha256: result.model.sha256,
+            quant: result.model.quant,
+            paramsApprox: result.model.paramsApprox,
+            dims: result.model.dims,
+        },
+        hardware: {
+            label: host.label,
+            platform: host.platform,
+            arch: host.arch,
+            cpuModel: host.cpuModel,
+            ramGiB: Math.round(host.totalRamGiB * 10) / 10,
+            gpu: host.gpuDeviceNames.length > 0 ? host.gpuDeviceNames.join(", ") : null,
+            backend: host.backend,
+        },
+        results: {
+            aggregate: result.aggregate,
+            perKind: result.perKind,
+            msPerEmbedSerialWarm: Math.round(result.msPerEmbedSerialWarm * 100) / 100,
+            peakRssMiB: Math.round(result.peakRssDeltaMiB * 10) / 10,
+        },
+    };
+}
+/**
+ * Writes the share document locally and returns where. The hosted
+ * submission endpoint (SUBMISSION_ENDPOINT_PLACEHOLDER) is not wired up —
+ * this function never makes a network call; the CLI layer is what prints
+ * `endpointNote` to the user (core does no console output — see index.ts's
+ * header).
+ */
+export function writeShareDocument(doc, outDir = ".") {
+    mkdirSync(outDir, { recursive: true });
+    const safeModelName = doc.model.name.replace(/[^a-zA-Z0-9._-]/g, "_");
+    const fileName = `flair-bench-share-${safeModelName}-${doc.timestamp.replace(/[:.]/g, "-")}.json`;
+    const filePath = join(outDir, fileName);
+    writeFileSync(filePath, JSON.stringify(doc, null, 2) + "\n", "utf8");
+    return {
+        filePath,
+        endpointNote: `submission endpoint not yet configured — file saved at ${filePath}`,
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,156 @@
+/**
+ * types.ts — shared types for the flair-bench public API.
+ *
+ * Kept dependency-free (no node-llama-cpp types leak here) so a future
+ * `flair bench` CLI subcommand (see README "Library use") can import just
+ * the shapes it needs without pulling in the embedding engine.
+ */
+import type { QueryKind } from "./corpus-v2.js";
+export type { QueryKind };
+/** "metal" | "cuda" | "vulkan" — the backend node-llama-cpp actually loaded, or "cpu" if none. */
+export type ComputeBackend = "metal" | "cuda" | "vulkan" | "cpu";
+/**
+ * Host fingerprint. `label` is a freeform, user-chosen grouping key (e.g.
+ * "fabric-free-gcp", "local-m4-mini") — NOT a hostname. Real hostnames never
+ * appear here; see share.ts for the privacy contract that leans on this.
+ */
+export interface HostFingerprint {
+    label?: string;
+    platform: string;
+    arch: string;
+    cpuModel: string;
+    totalRamGiB: number;
+    availableRamGiB: number;
+    backend: ComputeBackend;
+    /** GPU device name(s) node-llama-cpp reports, e.g. ["Apple M4 Pro"]. Empty when backend is "cpu". */
+    gpuDeviceNames: string[];
+}
+/** Everything about the GGUF file identifying the model under test. */
+export interface ModelIdentity {
+    /** Basename only — never the full path (privacy: no local filesystem layout in shared results). */
+    fileName: string;
+    sha256: string;
+    sizeBytes: number;
+    /** e.g. "Q4_K_M" — read from GGUF metadata when present, else parsed from the filename. */
+    quant: string;
+    quantSource: "gguf-metadata" | "filename-fallback";
+    /** Embedding vector dimensionality. */
+    dims: number;
+    /**
+     * Approximate total parameter count, computed by summing every tensor's
+     * element count from the GGUF's own tensor index (the same method
+     * llama.cpp's own CLI reports "params" with) — not read from a
+     * general.parameter_count field, which embedding-architecture GGUFs don't
+     * reliably carry.
+     */
+    paramsApprox: number;
+    /** Bits per weight: (file size in bits) / paramsApprox. */
+    bpw: number;
+}
+export interface PerKindStat {
+    n: number;
+    p3: number;
+    mrr: number;
+}
+export interface AggregateStat {
+    n: number;
+    p3: number;
+    mrr: number;
+}
+export interface ModelBenchResult {
+    model: ModelIdentity;
+    loadTimeMs: number;
+    /** Serial, warm (post-warmup), N>=64 embed calls; mean ms/embed. */
+    msPerEmbedSerialWarm: number;
+    /** process.memoryUsage().rss peak observed during this model's load+embed phase, minus the pre-load baseline. */
+    peakRssDeltaMiB: number;
+    aggregate: AggregateStat;
+    perKind: Record<QueryKind, PerKindStat>;
+}
+export interface CorpusInfo {
+    version: "v2";
+    records: number;
+    queries: number;
+}
+export interface BatchResult {
+    toolVersion: string;
+    timestamp: string;
+    corpus: CorpusInfo;
+    host: HostFingerprint;
+    models: ModelBenchResult[];
+}
+export interface BenchOptions {
+    /** One or more GGUF file paths. Batch = multiple entries. */
+    modelFiles: string[];
+    /** Freeform host-grouping label — see HostFingerprint.label. */
+    label?: string;
+    /** Number of corpus texts embedded during warmup before timing starts. Default 8. */
+    warmupN?: number;
+    /** Progress/diagnostic callback — core never calls console.*; a caller (e.g. the CLI) wires this to stderr. */
+    onProgress?: (event: BenchProgressEvent) => void;
+}
+export type BenchProgressEvent = {
+    type: "host-fingerprinted";
+    host: HostFingerprint;
+} | {
+    type: "model-start";
+    fileName: string;
+    index: number;
+    total: number;
+} | {
+    type: "model-loaded";
+    fileName: string;
+    loadTimeMs: number;
+} | {
+    type: "model-embedding";
+    fileName: string;
+    done: number;
+    total: number;
+} | {
+    type: "model-done";
+    fileName: string;
+    result: ModelBenchResult;
+};
+export interface RecommendOptions extends BenchOptions {
+    /** Fraction of *available* RAM a model's peak RSS delta may use. Default 0.5 (generous headroom). */
+    ramHeadroomFraction?: number;
+    /** ms/embed ceiling for a model to be considered "usable" on this host. Default 500 (generous). */
+    latencyThresholdMsPerEmbed?: number;
+}
+export interface Recommendation {
+    fileName: string;
+    reason: string;
+}
+export interface RecommendResult {
+    batch: BatchResult;
+    recommendation: Recommendation | null;
+    /** Human-readable lines explaining the heuristic's inputs/limits — always populated, even with no pick. */
+    notes: string[];
+}
+export interface ShareDocument {
+    toolVersion: string;
+    timestamp: string;
+    model: {
+        name: string;
+        fileBasename: string;
+        sha256: string;
+        quant: string;
+        paramsApprox: number;
+        dims: number;
+    };
+    hardware: {
+        label?: string;
+        platform: string;
+        arch: string;
+        cpuModel: string;
+        ramGiB: number;
+        gpu: string | null;
+        backend: ComputeBackend;
+    };
+    results: {
+        aggregate: AggregateStat;
+        perKind: Record<QueryKind, PerKindStat>;
+        msPerEmbedSerialWarm: number;
+        peakRssMiB: number;
+    };
+}

package/dist/types.js

@@ -0,0 +1,8 @@
+/**
+ * types.ts — shared types for the flair-bench public API.
+ *
+ * Kept dependency-free (no node-llama-cpp types leak here) so a future
+ * `flair bench` CLI subcommand (see README "Library use") can import just
+ * the shapes it needs without pulling in the embedding engine.
+ */
+export {};

package/dist/version.d.ts

@@ -0,0 +1,8 @@
+/**
+ * version.ts — single source of truth for the tool version stamped into
+ * output/share documents. Kept as a plain constant (rather than a JSON
+ * import of package.json at runtime) to sidestep NodeNext JSON-import-
+ * attribute edge cases in a published dist/ build. test/version-sync.test.ts
+ * asserts this stays equal to package.json's "version" field.
+ */
+export declare const TOOL_VERSION = "0.22.0";

package/dist/version.js

@@ -0,0 +1,8 @@
+/**
+ * version.ts — single source of truth for the tool version stamped into
+ * output/share documents. Kept as a plain constant (rather than a JSON
+ * import of package.json at runtime) to sidestep NodeNext JSON-import-
+ * attribute edge cases in a published dist/ build. test/version-sync.test.ts
+ * asserts this stays equal to package.json's "version" field.
+ */
+export const TOOL_VERSION = "0.22.0";

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@tpsdev-ai/flair-bench",
+  "version": "0.22.0",
+  "description": "Standalone embedding recall benchmark for flair — run real recall numbers (p@3/MRR) against any GGUF embedding model, batch-compare, get a host-aware recommendation, and share redacted results. No flair install required.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "flair-bench": "dist/cli-shim.cjs"
+  },
+  "files": [
+    "dist/",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc --noCheck",
+    "test": "bun test",
+    "sync:corpus": "node scripts/sync-corpus.mjs",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node -e \"try{const{chmodSync,statSync}=require('fs');for(const p of ['dist/cli-shim.cjs','dist/cli.js']){try{if(statSync(p).isFile()){chmodSync(p,0o755);console.error('@tpsdev-ai/flair-bench: chmod +x ' + p + ' OK')}}catch(e){if(e.code!=='ENOENT')console.error('postinstall warn:',e.message)}}}catch(e){console.error('postinstall warn:',e.message)}\""
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "node-llama-cpp": "3.18.1"
+  },
+  "optionalDependencies": {
+    "@node-llama-cpp/linux-arm64": "3.18.1",
+    "@node-llama-cpp/linux-armv7l": "3.18.1",
+    "@node-llama-cpp/linux-x64": "3.18.1",
+    "@node-llama-cpp/mac-arm64-metal": "3.18.1",
+    "@node-llama-cpp/mac-x64": "3.18.1",
+    "@node-llama-cpp/win-arm64": "3.18.1",
+    "@node-llama-cpp/win-x64": "3.18.1"
+  },
+  "devDependencies": {
+    "@types/node": "24.11.0",
+    "typescript": "5.9.3"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tpsdev-ai/flair.git",
+    "directory": "packages/flair-bench"
+  },
+  "homepage": "https://tps.dev/#flair",
+  "keywords": [
+    "flair",
+    "embeddings",
+    "benchmark",
+    "recall",
+    "gguf",
+    "llama.cpp",
+    "ai",
+    "semantic-search"
+  ]
+}