@desert-ant-labs/emo 0.3.0

package/LICENSE.md

@@ -0,0 +1,136 @@
+# Desert Ant Labs Source-Available License
+
+Version 1.0 · 2026-06-15
+
+Copyright © 2026 Studio Company B.V., trading as Desert Ant Labs (`desertant.ai`).
+
+This license governs Your use of the software, model weights, datasets, documentation, and associated assets in this repository (collectively, the **"Licensed Materials"**). It is a **source-available license intended for professional and business use**; it is not an OSI-approved open-source license. The rights granted here are subject to a per-Model usage cap and the other terms set out below.
+
+## Definitions
+
+- **"Desert Ant Labs"** (also "We", "Us", "Our") — Studio Company B.V., a private limited liability company (*besloten vennootschap*) incorporated under the laws of the Netherlands, with statutory seat in Amsterdam, registered with the Dutch Chamber of Commerce (KvK) under number **81228112**, trading as Desert Ant Labs.
+- **"Model"** — a set of trained weights published by Desert Ant Labs under a single HuggingFace repository (for example, `huggingface.co/desert-ant-labs/eye`). Each Model is a distinct work under this license.
+- **"Monthly Active User"** or **"MAU"** — a unique end user who interacts with a feature powered by a Model during a calendar month. Internal use by Your own employees and contractors does not count.
+- **"You"** — the individual or legal entity exercising rights under this license.
+
+## 0. Acceptance
+
+By downloading, accessing, using, copying, modifying, or distributing the Licensed Materials, You agree to be bound by this license. If You do not agree, You may not use the Licensed Materials.
+
+## 1. Grant
+
+Subject to Your continued compliance with this license, Desert Ant Labs grants You a worldwide, royalty-free, non-exclusive, non-transferable, non-sublicensable license to use, reproduce, modify, and distribute the Licensed Materials.
+
+## 2. Free-tier use
+
+You may use the Licensed Materials free of charge, including for commercial purposes, subject to the following per-Model threshold:
+
+> **For each Desert Ant Labs Model that Your products incorporate, the aggregate Monthly Active Users across all Your products must not exceed 100,000 in any calendar month.**
+
+The threshold applies independently to each Model. Two Models at 50,000 MAU each do not combine into 100,000 MAU; each is independently within its own free-tier limit.
+
+If a repository contains only software (no trained Model weights), no MAU threshold applies to that software on its own. The threshold attaches to the Models the software is used with.
+
+## 3. Research and academic use
+
+Use of the Licensed Materials for non-commercial scientific research and academic publications is exempt from the MAU threshold in Section 2, provided that any resulting publication credits "Desert Ant Labs" and links to the relevant Model repository.
+
+## 4. Commercial license
+
+If Your aggregate MAU for any Model exceeds 100,000 (or You expect it to within the next calendar month), You must obtain a commercial license from Desert Ant Labs before continuing to distribute or operate any product that incorporates that Model. A commercial license covers only the Models named in it; other Models remain under the free tier subject to their own thresholds.
+
+Contact: <licensing@desertant.ai>.
+
+## 5. Patent grant
+
+Each contributor to the Licensed Materials grants You a perpetual, worldwide, non-exclusive, royalty-free, irrevocable (except as stated in this Section) patent license to make, use, sell, offer to sell, and import the Licensed Materials, where such license applies only to those patent claims licensable by that contributor that are necessarily infringed by the Licensed Materials.
+
+**If You institute patent litigation against any entity** (including a cross-claim or counterclaim in a lawsuit) alleging that the Licensed Materials infringe a patent, **all patent licenses granted to You under this license terminate as of the date such litigation is filed.**
+
+## 6. Restrictions
+
+You may not:
+
+1. Sell, sublicense, or otherwise distribute the Licensed Materials themselves, or any substantially unmodified derivative of them, as a standalone product or hosted service.
+2. Use the Licensed Materials to train, distill, fine-tune, or otherwise derive a model that You release or distribute under any license more permissive than this license, including any OSI-approved open-source license. Internal research, personal fine-tuning, and use of derivative models that remain under this license are not restricted.
+3. Remove or alter the copyright, license, attribution, or third-party notices in the Licensed Materials.
+
+You may freely embed the Licensed Materials in Your own product, subject to Section 2 and the rest of this license.
+
+## 7. Attribution
+
+You must retain this LICENSE file and the copyright notice in all copies and substantial portions of the Licensed Materials. Where Your product surfaces acknowledgements, third-party notices, or "About" / "Credits" screens, please credit **"Desert Ant Labs (`desertant.ai`)"**.
+
+## 8. Modifications
+
+You may modify the Licensed Materials. If You distribute modified Licensed Materials, You must:
+
+(a) include a prominent notice stating that You have modified them, with the date of modification; and
+(b) ensure that Your distributed modifications are licensed under this license.
+
+This license governs the Licensed Materials and modifications to them. Applications and products that merely incorporate, link to, or call the Licensed Materials are Your own work; their structure, source, and license are not constrained by this license, subject only to Sections 2, 6, and 7.
+
+## 9. Reporting
+
+To enable Desert Ant Labs to administer the free tier, You agree:
+
+(a) to maintain reasonable records of Your aggregate MAU per Model; and
+(b) upon written request from Desert Ant Labs, to provide a reasonable summary of those records sufficient to confirm compliance with Section 2. Such requests will be made no more than once per calendar year per licensee, except in the case of a reasonable, specific suspicion of breach.
+
+You are encouraged — but not required — to notify Desert Ant Labs at <licensing@desertant.ai> when Your aggregate MAU for any Model first exceeds 80,000.
+
+## 10. Trademarks
+
+This license does not grant You any right to use the trade names, trademarks, service marks, or product names of Desert Ant Labs, except for the limited attribution use specified in Section 7. All goodwill arising from such attribution use inures to the benefit of Desert Ant Labs.
+
+## 11. Third-party components
+
+The Licensed Materials may include or derive from components licensed by third parties. Those components remain subject to their own licenses; nothing in this license overrides those terms. Notices for such components are provided in the model card or in a `THIRD_PARTY_NOTICES.md` file alongside the Licensed Materials.
+
+## 12. Termination
+
+This license terminates automatically and immediately upon any of the following:
+
+(a) Your aggregate MAU for any Model exceeds 100,000 and You do not obtain a commercial license within thirty (30) days;
+(b) Your breach of Section 6 (Restrictions); or
+(c) Your institution of patent litigation as described in Section 5.
+
+For any other curable breach, Desert Ant Labs will provide written notice; if the breach is not cured within thirty (30) days of receipt of that notice, this license terminates as of the date the notice was sent.
+
+Upon termination, You must cease using and distributing the Licensed Materials. Sections 7 (Attribution, with respect to copies already in the field), 10 (Trademarks), 11 (Third-Party Components), 13 (No Warranty), 14 (Limitation of Liability), and 15 (Governing Law) survive termination.
+
+## 13. No warranty
+
+THE LICENSED MATERIALS ARE 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 NON-INFRINGEMENT. Desert Ant Labs makes no representation that the Licensed Materials are error-free, secure, or suitable for any particular use.
+
+## 14. Limitation of liability
+
+IN NO EVENT SHALL DESERT ANT LABS BE LIABLE FOR ANY INDIRECT, INCIDENTAL, CONSEQUENTIAL, SPECIAL, OR EXEMPLARY DAMAGES (INCLUDING LOST PROFITS, LOSS OF DATA, OR BUSINESS INTERRUPTION) ARISING FROM OR IN CONNECTION WITH THE LICENSED MATERIALS, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+DESERT ANT LABS' TOTAL CUMULATIVE LIABILITY UNDER OR IN CONNECTION WITH THIS LICENSE SHALL NOT EXCEED THE GREATER OF (A) ONE HUNDRED EUROS (€100) OR (B) THE TOTAL FEES PAID BY YOU TO DESERT ANT LABS UNDER A SEPARATE COMMERCIAL LICENSE IN THE TWELVE (12) MONTHS PRECEDING THE CLAIM.
+
+Nothing in this license limits or excludes liability to the extent such limitation or exclusion is not permitted by applicable mandatory law, including liability for willful misconduct (*opzet*) or gross negligence (*bewuste roekeloosheid*) and any mandatory provision of Dutch consumer-protection law.
+
+## 15. Governing law and jurisdiction
+
+This license is governed by the laws of the Netherlands, without regard to its conflict-of-laws provisions. The competent courts of Amsterdam, the Netherlands, have exclusive jurisdiction over any dispute arising under or in connection with this license, subject to mandatory provisions of applicable consumer-protection law.
+
+The United Nations Convention on Contracts for the International Sale of Goods (CISG, 1980) does not apply to this license.
+
+## 16. Miscellaneous
+
+(a) **Severability.** If any provision of this license is held unenforceable by a court of competent jurisdiction, the remaining provisions remain in full force and effect, and the unenforceable provision shall be interpreted to give effect to its intent to the greatest extent permitted by law.
+
+(b) **No waiver.** Failure or delay by Desert Ant Labs to enforce any right under this license is not a waiver of that right.
+
+(c) **Assignment.** You may not assign this license without Desert Ant Labs' prior written consent. Desert Ant Labs may freely assign this license to a successor in interest. This license binds and benefits each party's successors and permitted assigns.
+
+(d) **Entire agreement.** This license, together with any separate commercial license referenced in Section 4, is the entire agreement between You and Desert Ant Labs regarding the Licensed Materials and supersedes all prior agreements on the same subject matter.
+
+(e) **Language.** The authoritative version of this license is in English. Any translation is for convenience only; in the event of any conflict, the English version controls.
+
+---
+
+Commercial licensing inquiries: <licensing@desertant.ai>.
+
+© 2026 Studio Company B.V., trading as Desert Ant Labs. Statutory seat: Amsterdam, the Netherlands. KvK: **81228112**.

package/README.md

@@ -0,0 +1,117 @@
+# @desert-ant-labs/emo
+
+On-device emoji suggestions from text. Suggests the best-matching emoji for short
+tasks, calendar entries, notes, or message drafts across **23 languages** — fully
+in-process, no inference runtime.
+
+```ts
+import { suggestions } from "@desert-ant-labs/emo";
+
+const results = await suggestions("Pay my bills");
+// [{ emoji: "💰", confidence: 0.62 }, ...]
+
+const emoji = (await suggestions("犬の散歩", 1))[0]?.emoji; // "🐕"
+const toned = (await suggestions("go for a run", 1, { skinTone: "medium" }))[0]?.emoji; // "🏃🏽"
+```
+
+## Features
+
+- Pure-JS inference (no ONNX/WASM runtime) — prediction is sub-millisecond
+- Suggests from a data-driven vocabulary of ~300 task/calendar/message emojis
+- Supports 23 languages (incl. CJK, Arabic, Thai, Hindi, …)
+- Model (~5.0 MB, 4-bit palettized) is fetched from the Hugging Face Hub at a **pinned revision**, then
+  cached — to the **filesystem** on Node and to **Cache Storage** in the browser, so
+  it loads once and runs offline after
+
+## Install
+
+```bash
+npm install @desert-ant-labs/emo
+```
+
+## Importing
+
+Pure ESM and fully tree-shakeable. The **same import works everywhere** — Node, bundlers,
+browsers, and edge/worker runtimes — the right build is selected automatically:
+
+```ts
+import { suggestions } from "@desert-ant-labs/emo";
+```
+
+CommonJS consumers use dynamic import (`const { suggestions } = await import("@desert-ant-labs/emo")`);
+native `require()` works on Node ≥ 22.12.
+
+**Minimal footprint / bring-your-own-bytes.** If you load the model files yourself, import the
+hub-free core from `@desert-ant-labs/emo/core` — only the ~6 KB inference engine, with zero
+network/filesystem code:
+
+```ts
+import { createEmo } from "@desert-ant-labs/emo/core";
+
+// weights and tokenizer are Uint8Array buffers; meta is the parsed emo_meta.json
+const emo = createEmo({ weights, tokenizer, meta });
+emo.suggestions("walk the dog", 1)[0]?.emoji; // "🐕"
+```
+
+## Loading model
+
+Model files are fetched from the Hugging Face Hub
+([`desert-ant-labs/emo`](https://huggingface.co/desert-ant-labs/emo)) at a pinned
+revision and cached. The first call downloads `emo.safetensors`, `emo_tokenizer.bin`,
+and `emo_meta.json`; subsequent calls read from the cache.
+
+- **Node**: `suggestions()` works zero-config; files cache under `~/.cache/emo`.
+  To run fully offline, ship the files yourself and point at a folder with
+  `env.localModelPath` (or `EMO_LOCAL_PATH`).
+- **Browser**: same API; files cache in Cache Storage.
+
+```ts
+import { env, load, suggestions } from "@desert-ant-labs/emo";
+
+// optional global config (set before first use)
+env.revision = "main";              // or a commit SHA / tag
+env.cacheDir = "/var/cache/emo";    // Node only
+env.localModelPath = "./emo-model"; // Node: use local files, skip the Hugging Face Hub
+
+// or load an explicit instance (synchronous inference after it resolves)
+const emo = await load({ revision: "main" });
+emo.suggestions("book a flight to Tokyo", 1)[0]?.emoji; // "✈️"
+```
+
+## API
+
+```ts
+export function suggestions(text: string, limit?: number, options?: EmoSuggestionOptions): Promise<EmoSuggestion[]>;
+export function load(options?: Partial<EmoEnv>): Promise<EmoModel>;
+export function createEmo(buffers: { weights; tokenizer; meta }): EmoModel; // raw buffers
+export const env: EmoEnv;
+export function reset(): void; // clear the memoized model so the next suggestions() re-reads env
+
+export interface EmoSuggestion {
+  emoji: string;
+  confidence: number;
+}
+
+export interface EmoSuggestionOptions {
+  skinTone?: EmojiSkinTone; // default: "default"
+}
+
+export type EmojiSkinTone = "default" | "light" | "mediumLight" | "medium" | "mediumDark" | "dark";
+```
+
+`suggestions(text, limit = 3, options)` returns up to `limit` emojis, most likely first;
+empty input returns `[]`. `skinTone` post-processes skin-tone-capable emoji; the default is `"default"` (no modifier). `EmoModel.suggestions` is synchronous once loaded.
+
+## Example
+
+[`examples/EmoExample`](examples/EmoExample) is a small todo-list web app that predicts an
+emoji for each task on-device. Run it with `node server.js` from that folder and open
+<http://localhost:5173>.
+
+## Model
+
+Published at [`desert-ant-labs/emo`](https://huggingface.co/desert-ant-labs/emo) on Hugging Face.
+
+## License
+
+See [`LICENSE.md`](LICENSE.md) — Desert Ant Labs Source-Available License v1.0. Free for commercial use up to 100,000 MAU per Model; <licensing@desertant.ai> above that.

package/dist/cache-node.d.ts

@@ -0,0 +1,5 @@
+import type { FileCache } from "./hub.js";
+/** Filesystem-backed cache (Node): downloaded files persist across runs. */
+export declare function fsCache(cacheDir: string): FileCache;
+/** Reads model files from a local directory (for `localModelPath`). */
+export declare function localReader(dir: string): (name: string) => Promise<Uint8Array | null>;

package/dist/cache-node.js

@@ -0,0 +1,32 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+const keyToPath = (cacheDir, key) => join(cacheDir, key.replace(/^https?:\/\//, "").replace(/[^a-zA-Z0-9._/-]/g, "_"));
+/** Filesystem-backed cache (Node): downloaded files persist across runs. */
+export function fsCache(cacheDir) {
+    return {
+        async get(key) {
+            try {
+                return new Uint8Array(await readFile(keyToPath(cacheDir, key)));
+            }
+            catch {
+                return null;
+            }
+        },
+        async put(key, data) {
+            const path = keyToPath(cacheDir, key);
+            await mkdir(dirname(path), { recursive: true });
+            await writeFile(path, data);
+        },
+    };
+}
+/** Reads model files from a local directory (for `localModelPath`). */
+export function localReader(dir) {
+    return async (name) => {
+        try {
+            return new Uint8Array(await readFile(join(dir, name)));
+        }
+        catch {
+            return null;
+        }
+    };
+}

package/dist/cache-web.d.ts

@@ -0,0 +1,3 @@
+import type { FileCache } from "./hub.js";
+/** Cache Storage-backed cache (browser): downloaded files persist across visits. */
+export declare function webCache(name?: string): FileCache;

package/dist/cache-web.js

@@ -0,0 +1,24 @@
+/** Cache Storage-backed cache (browser): downloaded files persist across visits. */
+export function webCache(name = "emo-model") {
+    return {
+        async get(key) {
+            try {
+                const cache = await caches.open(name);
+                const res = await cache.match(key);
+                return res ? new Uint8Array(await res.arrayBuffer()) : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        async put(key, data) {
+            try {
+                const cache = await caches.open(name);
+                await cache.put(key, new Response(data));
+            }
+            catch {
+                /* caching is best-effort */
+            }
+        },
+    };
+}

package/dist/hub.d.ts

@@ -0,0 +1,31 @@
+import { EmoModel } from "./model.js";
+export declare const DEFAULT_HOST = "https://huggingface.co";
+export declare const DEFAULT_REPO = "desert-ant-labs/emo";
+/** Pinned revision of the model repo (a commit SHA). */
+export declare const DEFAULT_REVISION = "bcbd42b62f8d6c0bad5d2b4a76598a908f102235";
+/** Resolution + caching configuration (mutate the exported `env` to change defaults). */
+export interface EmoEnv {
+    /** Hugging Face host serving the model repo. */
+    host: string;
+    /** Model repo id, e.g. `"desert-ant-labs/emo"`. */
+    repo: string;
+    /** Pinned revision (commit SHA, tag, or branch). */
+    revision: string;
+    /** Allow fetching from the Hugging Face Hub. Set `false` to require a local copy. */
+    allowRemote: boolean;
+    /** Cache downloaded files (filesystem on Node, Cache Storage in the browser). */
+    useCache: boolean;
+    /** Directory of pre-downloaded model files to use instead of the Hugging Face Hub (Node). */
+    localModelPath?: string;
+    /** Filesystem cache directory (Node). */
+    cacheDir?: string;
+    /** Optional Hugging Face access token (Node). */
+    token?: string;
+}
+/** A key/value store for cached file bytes, keyed by resolve URL. */
+export interface FileCache {
+    get(key: string): Promise<Uint8Array | null>;
+    put(key: string, data: Uint8Array): Promise<void>;
+}
+/** Resolves all model files (local dir → cache → Hugging Face Hub) and builds an {@link EmoModel}. */
+export declare function loadModel(env: EmoEnv, cache: FileCache | null, readLocal?: (name: string) => Promise<Uint8Array | null>): Promise<EmoModel>;

package/dist/hub.js

@@ -0,0 +1,42 @@
+import { createEmo } from "./model.js";
+export const DEFAULT_HOST = "https://huggingface.co";
+export const DEFAULT_REPO = "desert-ant-labs/emo";
+/** Pinned revision of the model repo (a commit SHA). */
+export const DEFAULT_REVISION = "bcbd42b62f8d6c0bad5d2b4a76598a908f102235";
+const FILES = ["emo.safetensors", "emo_tokenizer.bin", "emo_meta.json"];
+function resolveUrl(env, name) {
+    return `${env.host}/${env.repo}/resolve/${env.revision}/${name}`;
+}
+async function fetchFile(env, name, cache, readLocal) {
+    if (readLocal) {
+        const local = await readLocal(name);
+        if (local)
+            return local;
+    }
+    const url = resolveUrl(env, name);
+    if (cache && env.useCache) {
+        const hit = await cache.get(url);
+        if (hit)
+            return hit;
+    }
+    if (!env.allowRemote)
+        throw new Error(`emo: ${name} unavailable locally and remote loading is disabled`);
+    const res = await fetch(url, env.token ? { headers: { Authorization: `Bearer ${env.token}` } } : undefined);
+    if (!res.ok)
+        throw new Error(`emo: failed to fetch ${name} from ${url} (${res.status} ${res.statusText})`);
+    const data = new Uint8Array(await res.arrayBuffer());
+    if (cache && env.useCache) {
+        try {
+            await cache.put(url, data);
+        }
+        catch {
+            /* caching is best-effort */
+        }
+    }
+    return data;
+}
+/** Resolves all model files (local dir → cache → Hugging Face Hub) and builds an {@link EmoModel}. */
+export async function loadModel(env, cache, readLocal) {
+    const [weights, tokenizer, meta] = await Promise.all(FILES.map((name) => fetchFile(env, name, cache, readLocal)));
+    return createEmo({ weights, tokenizer, meta: JSON.parse(new TextDecoder().decode(meta)) });
+}

package/dist/index.browser.d.ts

@@ -0,0 +1,17 @@
+import { type EmoEnv } from "./hub.js";
+import { type EmoModel, type EmoSuggestion } from "./model.js";
+import { type EmoSuggestionOptions } from "./skin-tone.js";
+export { createEmo, EmoModel, type EmoSuggestion, type EmoMeta } from "./model.js";
+export { applyEmojiSkinTone, type EmojiSkinTone, type EmoSuggestionOptions } from "./skin-tone.js";
+export { loadModel, type EmoEnv, type FileCache } from "./hub.js";
+/** Loading configuration. Mutate before the first call, or pass overrides to {@link load}. */
+export declare const env: EmoEnv;
+/** Loads the model from the Hugging Face Hub (cached in Cache Storage). */
+export declare function load(options?: Partial<EmoEnv>): Promise<EmoModel>;
+/**
+ * Returns emoji suggestions for a phrase, most likely first. The model is loaded
+ * (and cached) lazily on first call. Empty input returns `[]`.
+ */
+export declare function suggestions(text: string, limit?: number, options?: EmoSuggestionOptions): Promise<EmoSuggestion[]>;
+/** Clears the memoized model so the next {@link suggestions} call re-reads `env`. */
+export declare function reset(): void;

package/dist/index.browser.js

@@ -0,0 +1,37 @@
+import { webCache } from "./cache-web.js";
+import { DEFAULT_HOST, DEFAULT_REPO, DEFAULT_REVISION, loadModel } from "./hub.js";
+export { createEmo, EmoModel } from "./model.js";
+export { applyEmojiSkinTone } from "./skin-tone.js";
+export { loadModel } from "./hub.js";
+/** Loading configuration. Mutate before the first call, or pass overrides to {@link load}. */
+export const env = {
+    host: DEFAULT_HOST,
+    repo: DEFAULT_REPO,
+    revision: DEFAULT_REVISION,
+    allowRemote: true,
+    useCache: true,
+};
+/** Loads the model from the Hugging Face Hub (cached in Cache Storage). */
+export async function load(options = {}) {
+    const e = { ...env, ...options };
+    return loadModel(e, e.useCache ? webCache() : null);
+}
+let modelPromise = null;
+/**
+ * Returns emoji suggestions for a phrase, most likely first. The model is loaded
+ * (and cached) lazily on first call. Empty input returns `[]`.
+ */
+export async function suggestions(text, limit = 3, options = {}) {
+    if (!modelPromise) {
+        // Don't cache a rejected load: clear the slot on failure so the next call retries.
+        modelPromise = load().catch((err) => {
+            modelPromise = null;
+            throw err;
+        });
+    }
+    return (await modelPromise).suggestions(text, limit, options);
+}
+/** Clears the memoized model so the next {@link suggestions} call re-reads `env`. */
+export function reset() {
+    modelPromise = null;
+}

package/dist/index.node.d.ts

@@ -0,0 +1,17 @@
+import { type EmoEnv } from "./hub.js";
+import { type EmoModel, type EmoSuggestion } from "./model.js";
+import { type EmoSuggestionOptions } from "./skin-tone.js";
+export { createEmo, EmoModel, type EmoSuggestion, type EmoMeta } from "./model.js";
+export { applyEmojiSkinTone, type EmojiSkinTone, type EmoSuggestionOptions } from "./skin-tone.js";
+export { loadModel, type EmoEnv, type FileCache } from "./hub.js";
+/** Loading configuration. Mutate before the first call, or pass overrides to {@link load}. */
+export declare const env: EmoEnv;
+/** Loads the model: a local dir if configured, else the Hugging Face Hub (cached to disk). */
+export declare function load(options?: Partial<EmoEnv>): Promise<EmoModel>;
+/**
+ * Returns emoji suggestions for a phrase, most likely first. The model is loaded
+ * (and cached) lazily on first call. Empty input returns `[]`.
+ */
+export declare function suggestions(text: string, limit?: number, options?: EmoSuggestionOptions): Promise<EmoSuggestion[]>;
+/** Clears the memoized model so the next {@link suggestions} call re-reads `env`. */
+export declare function reset(): void;

package/dist/index.node.js

@@ -0,0 +1,44 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fsCache, localReader } from "./cache-node.js";
+import { DEFAULT_HOST, DEFAULT_REPO, DEFAULT_REVISION, loadModel } from "./hub.js";
+export { createEmo, EmoModel } from "./model.js";
+export { applyEmojiSkinTone } from "./skin-tone.js";
+export { loadModel } from "./hub.js";
+/** Loading configuration. Mutate before the first call, or pass overrides to {@link load}. */
+export const env = {
+    host: DEFAULT_HOST,
+    repo: DEFAULT_REPO,
+    revision: DEFAULT_REVISION,
+    allowRemote: true,
+    useCache: true,
+    cacheDir: process.env.EMO_CACHE_DIR ?? join(homedir(), ".cache", "emo"),
+    localModelPath: process.env.EMO_LOCAL_PATH,
+    token: process.env.HF_TOKEN ?? process.env.HUGGING_FACE_HUB_TOKEN,
+};
+/** Loads the model: a local dir if configured, else the Hugging Face Hub (cached to disk). */
+export async function load(options = {}) {
+    const e = { ...env, ...options };
+    const cache = e.useCache && e.cacheDir ? fsCache(e.cacheDir) : null;
+    const readLocal = e.localModelPath ? localReader(e.localModelPath) : undefined;
+    return loadModel(e, cache, readLocal);
+}
+let modelPromise = null;
+/**
+ * Returns emoji suggestions for a phrase, most likely first. The model is loaded
+ * (and cached) lazily on first call. Empty input returns `[]`.
+ */
+export async function suggestions(text, limit = 3, options = {}) {
+    if (!modelPromise) {
+        // Don't cache a rejected load: clear the slot on failure so the next call retries.
+        modelPromise = load().catch((err) => {
+            modelPromise = null;
+            throw err;
+        });
+    }
+    return (await modelPromise).suggestions(text, limit, options);
+}
+/** Clears the memoized model so the next {@link suggestions} call re-reads `env`. */
+export function reset() {
+    modelPromise = null;
+}

package/dist/model.d.ts

@@ -0,0 +1,33 @@
+import { type EmoSuggestionOptions } from "./skin-tone.js";
+export { applyEmojiSkinTone, type EmojiSkinTone, type EmoSuggestionOptions } from "./skin-tone.js";
+/** A single emoji suggestion. */
+export interface EmoSuggestion {
+    /** The suggested emoji. */
+    emoji: string;
+    /** The model's normalized confidence, from `0` to `1`. */
+    confidence: number;
+}
+export interface EmoMeta {
+    labels: string[];
+    n_hashes: number;
+    n_buckets: number;
+    n_importance: number;
+    sem_dim: number;
+    sem_pad_index: number;
+}
+/** Loads the bundled model and runs emoji inference. Construct once and reuse. */
+export declare class EmoModel {
+    private readonly meta;
+    private readonly tok;
+    private readonly w;
+    private readonly maxLen;
+    constructor(weights: Uint8Array, tokenizer: Uint8Array, meta: EmoMeta);
+    /** Returns up to `limit` emoji suggestions, most likely first. */
+    suggestions(text: string, limit?: number, options?: EmoSuggestionOptions): EmoSuggestion[];
+}
+/** Creates an {@link EmoModel} from raw buffers (lowest-level entry). */
+export declare function createEmo(buffers: {
+    weights: Uint8Array;
+    tokenizer: Uint8Array;
+    meta: EmoMeta;
+}): EmoModel;

package/dist/model.js

@@ -0,0 +1,163 @@
+import { applyEmojiSkinTone } from "./skin-tone.js";
+import { ngramEncode, SemTokenizer } from "./tokenizer.js";
+export { applyEmojiSkinTone } from "./skin-tone.js";
+// A weight tensor, either raw F32 or a 4-bit k-means palette kept packed in memory
+// (a U8 index per weight, 2 per byte) and decoded on access — ~8x less memory than
+// expanding to floats, for ~0.1ms more per inference.
+class Tensor {
+    rows;
+    cols;
+    floats;
+    packed;
+    palette;
+    constructor(rows, cols, floats, packed, palette) {
+        this.rows = rows;
+        this.cols = cols;
+        this.floats = floats;
+        this.packed = packed;
+        this.palette = palette;
+    }
+    get(i) {
+        const f = this.floats;
+        if (f !== null)
+            return f[i];
+        const byte = this.packed[i >> 1];
+        return this.palette[(i & 1) ? (byte >> 4) & 0xf : byte & 0xf];
+    }
+}
+function erf(x) {
+    const t = 1 / (1 + 0.3275911 * Math.abs(x));
+    const y = 1 - (((((1.061405429 * t - 1.453152027) * t) + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t * Math.exp(-x * x);
+    return x >= 0 ? y : -y;
+}
+const gelu = (x) => 0.5 * x * (1 + erf(x / Math.SQRT2));
+// Minimal safetensors reader: u64 header length, JSON header, then raw tensor bytes.
+// Each weight is either raw F32, or a 4-bit k-means palette stored as a packed U8 index
+// tensor plus a "<name>.palette" F32 tensor (logical 2-D shape kept in __metadata__).
+// Palette weights stay packed and are decoded on access (see Tensor).
+function parseWeights(bytes) {
+    const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const headerLen = Number(dv.getBigUint64(0, true));
+    const header = JSON.parse(new TextDecoder().decode(bytes.subarray(8, 8 + headerLen)));
+    const dataStart = 8 + headerLen;
+    const meta = header.__metadata__ ?? {};
+    const slice = (name) => {
+        const e = header[name];
+        if (!e)
+            throw new Error(`emo: missing tensor ${name}`);
+        const [a, b] = e.data_offsets;
+        const out = new Uint8Array(b - a);
+        out.set(bytes.subarray(dataStart + a, dataStart + b));
+        return { shape: e.shape, bytes: out };
+    };
+    const f32 = (name) => new Float32Array(slice(name).bytes.buffer);
+    const expand = (name) => {
+        if (header[name + ".palette"]) {
+            const [rows, cols] = meta["shape." + name].split(",").map(Number);
+            return new Tensor(rows, cols, null, slice(name).bytes, f32(name + ".palette"));
+        }
+        const [rows, cols = 1] = slice(name).shape;
+        return new Tensor(rows, cols, f32(name), null, null);
+    };
+    return {
+        embed: expand("embed"), sem: expand("sem"), importance: expand("importance"),
+        w1: expand("w1"), b1: expand("b1"), w2: expand("w2"), b2: expand("b2"),
+    };
+}
+/** Loads the bundled model and runs emoji inference. Construct once and reuse. */
+export class EmoModel {
+    meta;
+    tok;
+    w;
+    maxLen = 1024;
+    constructor(weights, tokenizer, meta) {
+        this.meta = meta;
+        this.w = parseWeights(weights);
+        this.tok = new SemTokenizer(tokenizer);
+    }
+    /** Returns up to `limit` emoji suggestions, most likely first. */
+    suggestions(text, limit = 3, options = {}) {
+        const trimmed = text.trim();
+        if (!trimmed)
+            return [];
+        const { embed, sem, importance, w1, b1, w2, b2 } = this.w;
+        const ngDim = embed.cols;
+        const semDim = sem.cols;
+        const ng = new Float32Array(ngDim);
+        const f = ngramEncode(trimmed, this.meta.n_buckets, this.meta.n_hashes, this.meta.n_importance, this.maxLen);
+        for (let i = 0; i < f.buckets.length; i++) {
+            const im = f.importance[i];
+            for (let k = 0; k < this.meta.n_hashes; k++) {
+                const w = importance.get(im * importance.cols + k) * f.signs[i][k];
+                const base = f.buckets[i][k] * ngDim;
+                for (let c = 0; c < ngDim; c++)
+                    ng[c] += w * embed.get(base + c);
+            }
+        }
+        const fcount = Math.max(1, f.buckets.length);
+        for (let c = 0; c < ngDim; c++)
+            ng[c] /= fcount;
+        let ids = this.tok.encode(trimmed);
+        if (ids.length > this.maxLen)
+            ids = ids.slice(0, this.maxLen);
+        if (ids.length === 0)
+            ids = [this.meta.sem_pad_index];
+        const sv = new Float32Array(semDim);
+        for (const id of ids) {
+            if (id >= sem.rows)
+                continue;
+            const base = id * semDim;
+            for (let c = 0; c < semDim; c++)
+                sv[c] += sem.get(base + c);
+        }
+        for (let c = 0; c < semDim; c++)
+            sv[c] /= ids.length;
+        let norm = 0;
+        for (let c = 0; c < semDim; c++)
+            norm += sv[c] * sv[c];
+        norm = Math.sqrt(norm) + 1e-9;
+        for (let c = 0; c < semDim; c++)
+            sv[c] /= norm;
+        const inDim = ngDim + semDim;
+        const x = new Float32Array(inDim);
+        x.set(ng, 0);
+        x.set(sv, ngDim);
+        const hid = w1.rows;
+        const h = new Float32Array(hid);
+        for (let o = 0; o < hid; o++) {
+            let acc = b1.get(o);
+            const base = o * inDim;
+            for (let i = 0; i < inDim; i++)
+                acc += w1.get(base + i) * x[i];
+            h[o] = gelu(acc);
+        }
+        const n = w2.rows;
+        const logits = new Float32Array(n);
+        let maxLogit = -Infinity;
+        for (let o = 0; o < n; o++) {
+            let acc = b2.get(o);
+            const base = o * hid;
+            for (let i = 0; i < hid; i++)
+                acc += w2.get(base + i) * h[i];
+            logits[o] = acc;
+            if (acc > maxLogit)
+                maxLogit = acc;
+        }
+        let sum = 0;
+        for (let o = 0; o < n; o++) {
+            logits[o] = Math.exp(logits[o] - maxLogit);
+            sum += logits[o];
+        }
+        const labels = this.meta.labels;
+        const order = Array.from({ length: n }, (_, i) => i).sort((a, b) => logits[b] - logits[a]);
+        const skinTone = options.skinTone ?? "default";
+        return order.slice(0, Math.max(0, limit)).map((i) => ({
+            emoji: applyEmojiSkinTone(labels[i], skinTone),
+            confidence: logits[i] / sum,
+        }));
+    }
+}
+/** Creates an {@link EmoModel} from raw buffers (lowest-level entry). */
+export function createEmo(buffers) {
+    return new EmoModel(buffers.weights, buffers.tokenizer, buffers.meta);
+}

package/dist/skin-tone.d.ts

@@ -0,0 +1,8 @@
+/** Preferred emoji skin tone variant for skin-tone-capable emoji. */
+export type EmojiSkinTone = "default" | "light" | "mediumLight" | "medium" | "mediumDark" | "dark";
+/** Options for emoji suggestion post-processing. */
+export interface EmoSuggestionOptions {
+    /** Preferred skin tone for skin-tone-capable emoji. Defaults to `"default"` (no modifier). */
+    skinTone?: EmojiSkinTone;
+}
+export declare function applyEmojiSkinTone(emoji: string, skinTone?: EmojiSkinTone): string;

package/dist/skin-tone.js

@@ -0,0 +1,51 @@
+const modifiers = {
+    light: "🏻",
+    mediumLight: "🏼",
+    medium: "🏽",
+    mediumDark: "🏾",
+    dark: "🏿",
+};
+const isModifier = (cp) => cp >= 0x1f3fb && cp <= 0x1f3ff;
+const isVariationSelector16 = (cp) => cp === 0xfe0f;
+function isEmojiModifierBase(cp) {
+    return cp === 0x261d || cp === 0x26f9 ||
+        (cp >= 0x270a && cp <= 0x270d) || cp === 0x1f385 ||
+        (cp >= 0x1f3c2 && cp <= 0x1f3c4) || cp === 0x1f3c7 ||
+        (cp >= 0x1f3ca && cp <= 0x1f3cc) || (cp >= 0x1f442 && cp <= 0x1f443) ||
+        (cp >= 0x1f446 && cp <= 0x1f450) || (cp >= 0x1f466 && cp <= 0x1f478) ||
+        cp === 0x1f47c || (cp >= 0x1f481 && cp <= 0x1f483) ||
+        (cp >= 0x1f485 && cp <= 0x1f487) || cp === 0x1f48f || cp === 0x1f491 ||
+        cp === 0x1f4aa || (cp >= 0x1f574 && cp <= 0x1f575) || cp === 0x1f57a ||
+        cp === 0x1f590 || (cp >= 0x1f595 && cp <= 0x1f596) ||
+        (cp >= 0x1f645 && cp <= 0x1f647) || (cp >= 0x1f64b && cp <= 0x1f64f) ||
+        cp === 0x1f6a3 || (cp >= 0x1f6b4 && cp <= 0x1f6b6) || cp === 0x1f6c0 ||
+        cp === 0x1f6cc || cp === 0x1f90c || (cp >= 0x1f918 && cp <= 0x1f91f) ||
+        cp === 0x1f926 || (cp >= 0x1f930 && cp <= 0x1f939) ||
+        (cp >= 0x1f93d && cp <= 0x1f93e) || cp === 0x1f977 ||
+        (cp >= 0x1f9b5 && cp <= 0x1f9b6) || (cp >= 0x1f9b8 && cp <= 0x1f9b9) ||
+        (cp >= 0x1f9cd && cp <= 0x1f9cf) || (cp >= 0x1f9d1 && cp <= 0x1f9dd) ||
+        (cp >= 0x1faf0 && cp <= 0x1faf8);
+}
+export function applyEmojiSkinTone(emoji, skinTone = "default") {
+    if (skinTone === "default")
+        return emoji;
+    const modifier = modifiers[skinTone];
+    const chars = Array.from(emoji);
+    let out = "";
+    for (let i = 0; i < chars.length; i++) {
+        const cp = chars[i].codePointAt(0);
+        if (isModifier(cp))
+            continue;
+        out += chars[i];
+        if (isEmojiModifierBase(cp)) {
+            out += modifier;
+            while (i + 1 < chars.length) {
+                const next = chars[i + 1].codePointAt(0);
+                if (!isModifier(next) && !isVariationSelector16(next))
+                    break;
+                i++;
+            }
+        }
+    }
+    return out;
+}

package/dist/tokenizer.d.ts

@@ -0,0 +1,16 @@
+export interface NGramFeatures {
+    buckets: Int32Array[];
+    signs: Float32Array[];
+    importance: Int32Array;
+}
+export declare function ngramEncode(text: string, nBuckets: number, nHashes: number, nImportance: number, maxFeatures: number): NGramFeatures;
+export declare class SemTokenizer {
+    private pieces;
+    private scores;
+    private index;
+    private unkId;
+    private unkScore;
+    private maxLen;
+    constructor(data: Uint8Array);
+    encode(text: string): number[];
+}

package/dist/tokenizer.js

@@ -0,0 +1,229 @@
+const FNV_OFFSET = 0xcbf29ce484222325n;
+const FNV_PRIME = 0x100000001b3n;
+const MASK = (1n << 64n) - 1n;
+function fnv64(s, seed) {
+    let h = (FNV_OFFSET ^ seed) & MASK;
+    for (const b of new TextEncoder().encode(s)) {
+        h = ((h ^ BigInt(b)) * FNV_PRIME) & MASK;
+    }
+    return h;
+}
+const BUCKET_SEEDS = [
+    0x9e3779b97f4a7c15n, 0xc2b2ae3d27d4eb4fn, 0x165667b19e3779f9n,
+    0x27d4eb2f165667c5n, 0x85ebca77c2b2ae63n,
+];
+const IMP_SEED = 0xff51afd7ed558ccdn;
+const NA = [3, 5];
+const NC = [1, 2];
+const NJ = [2, 4];
+const NS = [2, 4];
+const NI = [1, 3];
+const reWord = /\p{L}|\p{M}|\p{N}/u;
+const reMark = /\p{M}/u;
+const cp = (s) => s.codePointAt(0);
+const isHangul = (s) => cp(s) >= 0xac00 && cp(s) <= 0xd7a3;
+function isCJK(s) {
+    const v = cp(s);
+    return (v >= 0x4e00 && v <= 0x9fff) || (v >= 0x3400 && v <= 0x4dbf)
+        || (v >= 0x20000 && v <= 0x2a6df) || (v >= 0xf900 && v <= 0xfaff)
+        || (v >= 0x3040 && v <= 0x30ff) || (v >= 0x31f0 && v <= 0x31ff)
+        || isHangul(s);
+}
+function isSEA(s) {
+    const v = cp(s);
+    return (v >= 0x0e00 && v <= 0x0eff) || (v >= 0x1000 && v <= 0x109f) || (v >= 0x1780 && v <= 0x17ff);
+}
+const isIndic = (s) => cp(s) >= 0x0900 && cp(s) <= 0x0dff;
+function jamo(c) {
+    if (!isHangul(c))
+        return [c];
+    const s = cp(c) - 0xac00;
+    const r = [String.fromCodePoint(0x1100 + Math.floor(s / 588)), String.fromCodePoint(0x1161 + Math.floor((s % 588) / 28))];
+    if (s % 28 !== 0)
+        r.push(String.fromCodePoint(0x11a7 + (s % 28)));
+    return r;
+}
+function normalize(text) {
+    return text.normalize("NFKC").toLowerCase().split(/\s+/).filter(Boolean).join(" ");
+}
+function tokens(text) {
+    const out = [];
+    let cur = [];
+    for (const c of text) {
+        if (reWord.test(c))
+            cur.push(c);
+        else if (cur.length) {
+            out.push(cur);
+            cur = [];
+        }
+    }
+    if (cur.length)
+        out.push(cur);
+    return out;
+}
+function clusters(s) {
+    const out = [];
+    let cur = [];
+    for (const c of s) {
+        if (!cur.length) {
+            cur = [c];
+            continue;
+        }
+        const p = cp(cur[cur.length - 1]);
+        const vir = p >= 0x0900 && p <= 0x0dff && ((p & 0xff) === 0x4d || (p & 0xff) === 0xcd);
+        if (reMark.test(c) || vir)
+            cur.push(c);
+        else {
+            out.push(cur);
+            cur = [c];
+        }
+    }
+    if (cur.length)
+        out.push(cur);
+    return out;
+}
+function charGrams(s, lo, hi, tag) {
+    const r = [];
+    for (let n = lo; n <= hi; n++) {
+        for (let i = 0; i + n <= s.length; i++)
+            r.push(tag + s.slice(i, i + n).join(""));
+    }
+    return r;
+}
+function clusterGrams(cl, lo, hi, tag) {
+    const r = [];
+    for (let n = lo; n <= hi; n++) {
+        for (let i = 0; i + n <= cl.length; i++)
+            r.push(tag + cl.slice(i, i + n).flat().join(""));
+    }
+    return r;
+}
+function feats(text) {
+    const out = [];
+    for (const run of tokens(normalize(text))) {
+        if (run.some(isSEA)) {
+            out.push(...charGrams(run, NS[0], NS[1], "s:"));
+        }
+        else if (run.some(isIndic)) {
+            const cl = clusters(run);
+            out.push("a:" + run.join(""));
+            out.push(...clusterGrams(cl, 1, 1, "k:"));
+            out.push(...clusterGrams([["<"], ...cl, [">"]], 2, NI[1], "k:"));
+        }
+        else if (run.some(isCJK)) {
+            const ex = [];
+            for (const c of run) {
+                if (isHangul(c))
+                    out.push(...charGrams(jamo(c), NJ[0], NJ[1], "j:"));
+                ex.push(c);
+            }
+            out.push(...charGrams(ex, NC[0], NC[1], "c:"));
+        }
+        else {
+            out.push("w:" + run.join(""));
+            out.push(...charGrams(["<", ...run, ">"], NA[0], NA[1], "g:"));
+        }
+    }
+    return out.length ? out : ["w:\u0000"];
+}
+export function ngramEncode(text, nBuckets, nHashes, nImportance, maxFeatures) {
+    let fs = feats(text);
+    if (fs.length > maxFeatures)
+        fs = fs.slice(0, maxFeatures);
+    const buckets = [];
+    const signs = [];
+    const importance = new Int32Array(fs.length);
+    const nb = BigInt(nBuckets);
+    const ni = BigInt(nImportance);
+    for (let f = 0; f < fs.length; f++) {
+        const bk = new Int32Array(nHashes);
+        const sg = new Float32Array(nHashes);
+        for (let k = 0; k < nHashes; k++) {
+            const h = fnv64(fs[f], BUCKET_SEEDS[k]);
+            bk[k] = Number(h % nb);
+            sg[k] = (h >> 63n) & 1n ? 1 : -1;
+        }
+        buckets.push(bk);
+        signs.push(sg);
+        importance[f] = Number(fnv64(fs[f], IMP_SEED) % ni);
+    }
+    return { buckets, signs, importance };
+}
+export class SemTokenizer {
+    pieces = [];
+    scores;
+    index = new Map();
+    unkId;
+    unkScore;
+    maxLen = 1;
+    constructor(data) {
+        const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        if (data[0] !== 0x45 || data[1] !== 0x4d || data[2] !== 0x54 || data[3] !== 0x4b) {
+            throw new Error("bad tokenizer file");
+        }
+        this.unkId = dv.getInt32(6, true);
+        const k = dv.getUint32(10, true);
+        let off = 14;
+        this.scores = new Float32Array(k);
+        for (let i = 0; i < k; i++) {
+            this.scores[i] = dv.getFloat32(off, true);
+            off += 4;
+        }
+        const lens = new Array(k);
+        for (let i = 0; i < k; i++) {
+            lens[i] = dv.getUint16(off, true);
+            off += 2;
+        }
+        const dec = new TextDecoder();
+        for (let i = 0; i < k; i++) {
+            const piece = dec.decode(data.subarray(off, off + lens[i]));
+            off += lens[i];
+            this.pieces.push(piece);
+            this.index.set(piece, i);
+            const n = [...piece].length;
+            if (n > this.maxLen)
+                this.maxLen = n;
+        }
+        this.maxLen = Math.min(this.maxLen, 24);
+        this.unkScore = this.scores[this.unkId];
+    }
+    encode(text) {
+        const norm = "\u2581" + text.toLowerCase().normalize("NFKC").replace(/ /g, "\u2581");
+        const s = [...norm];
+        const n = s.length;
+        if (n === 0)
+            return [];
+        const NEG = -1e18;
+        const best = new Float64Array(n + 1).fill(NEG);
+        best[0] = 0;
+        const backPos = new Int32Array(n + 1).fill(-1);
+        const backId = new Int32Array(n + 1).fill(-1);
+        for (let i = 1; i <= n; i++) {
+            const lo = Math.max(0, i - this.maxLen);
+            for (let j = lo; j < i; j++) {
+                const tid = this.index.get(s.slice(j, i).join(""));
+                if (tid !== undefined) {
+                    const sc = best[j] + this.scores[tid];
+                    if (sc > best[i]) {
+                        best[i] = sc;
+                        backPos[i] = j;
+                        backId[i] = tid;
+                    }
+                }
+            }
+            const cand = best[i - 1] + this.unkScore;
+            if (cand > best[i]) {
+                best[i] = cand;
+                backPos[i] = i - 1;
+                backId[i] = this.unkId;
+            }
+        }
+        const ids = [];
+        let i = n;
+        while (i > 0) {
+            ids.push(backId[i]);
+            i = backPos[i];
+        }
+        return ids.reverse();
+    }
+}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@desert-ant-labs/emo",
+  "version": "0.3.0",
+  "description": "On-device emoji suggestions from text.",
+  "type": "module",
+  "main": "./dist/index.node.js",
+  "types": "./dist/index.node.d.ts",
+  "exports": {
+    ".": {
+      "browser": {
+        "types": "./dist/index.browser.d.ts",
+        "default": "./dist/index.browser.js"
+      },
+      "worker": {
+        "types": "./dist/index.browser.d.ts",
+        "default": "./dist/index.browser.js"
+      },
+      "workerd": {
+        "types": "./dist/index.browser.d.ts",
+        "default": "./dist/index.browser.js"
+      },
+      "edge-light": {
+        "types": "./dist/index.browser.d.ts",
+        "default": "./dist/index.browser.js"
+      },
+      "node": {
+        "types": "./dist/index.node.d.ts",
+        "default": "./dist/index.node.js"
+      },
+      "default": {
+        "types": "./dist/index.node.d.ts",
+        "default": "./dist/index.node.js"
+      }
+    },
+    "./core": {
+      "types": "./dist/model.d.ts",
+      "default": "./dist/model.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "node --import tsx --test test/*.test.ts",
+    "lint:publint": "publint --strict",
+    "lint:attw": "attw --pack . --profile esm-only",
+    "check:pkg": "npm run build && npm run lint:publint && npm run lint:attw",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "emoji",
+    "on-device",
+    "multilingual",
+    "text-classification"
+  ],
+  "license": "SEE LICENSE IN LICENSE.md",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Desert-Ant-Labs/emo-js.git"
+  },
+  "homepage": "https://github.com/Desert-Ant-Labs/emo-js",
+  "engines": {
+    "node": ">=18"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18",
+    "@types/node": "^22",
+    "publint": "^0.3",
+    "tsx": "^4",
+    "typescript": "^5"
+  }
+}