@gjsify/model-store 0.0.0-stage → 0.64.20

package/README.md

@@ -1,3 +1,56 @@
-# Temporary Holding Version
+# @gjsify/model-store
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Where an AI model lives, whether it is there, and how it gets there: one store per capability (speech, embeddings, image generation), with streaming download, SHA-256 verification, progress in the WebML CG `monitor` shape, and three sources in a fixed order. Pure TypeScript on `node:*` APIs: it runs under plain Node as well as under GJS.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project. **Tier 3 (experimental, ADR 0003)**: tested against a temporary directory and an injected `fetch`; no test downloads a model. Design: ADR 0132 § 5.
+
+## Installation
+
+```bash
+gjsify install @gjsify/model-store
+```
+
+## Usage
+
+The manifest belongs to the package (or app) that uses the models. Every field is measured from the real file.
+
+```typescript
+import { ModelStore, type ModelEntry } from '@gjsify/model-store';
+
+const MODELS: readonly ModelEntry[] = [
+    {
+        id: 'silero-v5',
+        file: 'silero_vad_v5.onnx',
+        url: 'https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/silero_vad_v5.onnx',
+        bytes: 2313101,
+        sha256: '6b99cbfd39246b6706f98ec13c7c50c6b299181f2474fa05cbc8046acc274396',
+        license: 'MIT',
+        redistributable: true,
+    },
+];
+
+const store = new ModelStore({ capability: 'speech', models: MODELS });
+
+if (store.availability('silero-v5') === 'downloadable') {
+    await store.install('silero-v5', {
+        monitor: (m) => m.addEventListener('downloadprogress', (e) => console.log(e.receivedBytes, e.loaded)),
+    });
+}
+const path = await store.resolve('silero-v5');
+```
+
+## Sources, in order
+
+1. **A configured path** — `resolve(id, { path })`, for a model the person already has. It must exist and have the manifest's size; otherwise `locate()` throws instead of silently downloading.
+2. **The app's data dirs** — `appDataDirs`, read-only, for an app that ships a model whose `redistributable` is `true`.
+3. **The cache** — `<user cache>/gjsify/models/<capability>/`, which `install()` downloads into. `<user cache>` is `$XDG_CACHE_HOME` or `~/.cache` as GLib answers it (`%LOCALAPPDATA%` on Windows).
+
+`legacyDirs` names directories an older release cached into; a matching file is moved into the cache the first time it is looked up.
+
+Digests: a downloaded file is hashed while it streams and only renamed into place once it matches, so the cache is checked by size afterwards. A configured or app-shipped file is hashed by `resolve()` once per process (remembered per size and mtime). `locate()` and `availability()` are synchronous and read no model bytes.
+
+The store never answers `unavailable` itself: that is the capability's call (no engine, or `checkFit` from `@gjsify/machine-fit` says `none`).
+
+## License
+
+MIT

package/lib/esm/_virtual/_rolldown/runtime.js

@@ -0,0 +1 @@
+var e=Object.defineProperty,__name=(t,n)=>e(t,`name`,{value:n,configurable:!0});export{__name};

package/lib/esm/cache-dir.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";import{homedir as e}from"node:os";import{isAbsolute as t,join as n}from"node:path";import r from"node:process";function userCacheDir(){let i=r.env.XDG_CACHE_HOME;if(i!==void 0&&i!==``&&t(i))return i;if(r.platform===`win32`){let e=r.env.LOCALAPPDATA;if(e!==void 0&&e!==``)return e}return n(e(),`.cache`)}function modelsRoot(){return n(userCacheDir(),`gjsify`,`models`)}export{modelsRoot,userCacheDir};

package/lib/esm/index.js

@@ -0,0 +1 @@
+import{modelsRoot as e,userCacheDir as t}from"./cache-dir.js";import{validateManifest as n}from"./manifest.js";import{DownloadProgressEvent as r}from"./progress.js";import{ModelStore as i,sha256File as a}from"./store.js";export{r as DownloadProgressEvent,i as ModelStore,e as modelsRoot,a as sha256File,t as userCacheDir,n as validateManifest};

package/lib/esm/manifest.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";const e=/^[0-9a-f]{64}$/,t=/^[^/\\]+$/;function validateManifest(n){let r=new Set,i=new Set;for(let a of n){let n=`model '${a.id}'`;if(r.has(a.id))throw Error(`Manifest lists ${n} twice`);if(i.has(a.file))throw Error(`Manifest: ${n} reuses file '${a.file}'`);if(r.add(a.id),i.add(a.file),!t.test(a.file)||a.file===`.`||a.file===`..`)throw Error(`Manifest: ${n} has file '${a.file}', which is not a plain file name`);if(!e.test(a.sha256))throw Error(`Manifest: ${n} has no lowercase hex sha256`);if(!Number.isSafeInteger(a.bytes)||a.bytes<=0)throw Error(`Manifest: ${n} has size ${a.bytes}`);if(!a.url.startsWith(`https://`))throw Error(`Manifest: ${n} is not fetched over https`);if(a.license.length===0)throw Error(`Manifest: ${n} names no licence`)}}export{validateManifest};

package/lib/esm/progress.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";var DownloadProgressEvent=class extends Event{modelId;receivedBytes;totalBytes;loaded;total=1;lengthComputable=!0;constructor(e,t,n){super(`downloadprogress`),this.modelId=e,this.receivedBytes=t,this.totalBytes=n,this.loaded=n===0?1:t/n}},ProgressFanout=class{modelId;#e=new Set;#t=-1;constructor(e){this.modelId=e}add(e){if(e===void 0)return;let t=new EventTarget;e(t),this.#e.add(t)}report(e,t){let n=t===0?1:e/t;if(!(!(e===0||e===t)&&n-this.#t<.001)&&n!==this.#t){this.#t=n;for(let n of this.#e)n.dispatchEvent(new DownloadProgressEvent(this.modelId,e,t))}}};export{DownloadProgressEvent,ProgressFanout};

package/lib/esm/store.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";import{modelsRoot as e}from"./cache-dir.js";import{validateManifest as t}from"./manifest.js";import{ProgressFanout as n}from"./progress.js";import{join as r}from"node:path";import{createHash as i,randomUUID as a}from"node:crypto";import{closeSync as o,copyFileSync as s,mkdirSync as c,openSync as l,renameSync as u,statSync as d,unlinkSync as f,writeSync as p}from"node:fs";import{open as m}from"node:fs/promises";const h=/^[a-z0-9][a-z0-9-]*$/;function sizeOf(e){try{let t=d(e);return t.isFile()?t.size:null}catch{return null}}function removeQuietly(e){try{f(e)}catch{}}async function sha256File(e,t){let n=i(`sha256`),r=await m(e,`r`);try{let e=new Uint8Array(1024*1024);for(;;){t?.throwIfAborted();let{bytesRead:i}=await r.read(e,0,e.length,null);if(i===0)break;n.update(e.subarray(0,i))}}finally{await r.close()}return n.digest(`hex`)}var ModelStore=class{capability;models;defaultModel;#e;#t;#n;#r;#i=new Map;#a=new Map;constructor(e){if(!h.test(e.capability))throw Error(`ModelStore: capability '${e.capability}' is not a lowercase directory name`);if(e.models.length===0)throw Error(`ModelStore '${e.capability}': no models`);t(e.models),this.capability=e.capability,this.models=e.models,this.defaultModel=e.defaultModel??e.models[0].id,this.#e=e.root,this.#t=e.appDataDirs??[];let n=e.legacyDirs??[];this.#n=typeof n==`function`?n:()=>n,this.#r=e.fetch,this.require(this.defaultModel)}get cacheDir(){return r(this.#e??e(),this.capability)}find(e=this.defaultModel){return this.models.find(t=>t.id===e)}require(e=this.defaultModel){let t=this.find(e);if(t===void 0){let t=this.models.map(e=>e.id).join(`, `);throw RangeError(`Unknown ${this.capability} model '${e}' — known ids: ${t}`)}return t}cachePath(e=this.defaultModel){return r(this.cacheDir,this.require(e).file)}locate(e=this.defaultModel,t={}){let n=this.require(e);if(t.path!==void 0){let e=sizeOf(t.path);if(e!==n.bytes){let r=e===null?`no file`:`${e} bytes`;throw Error(`${this.capability} model '${n.id}': ${t.path} has ${r}, expected ${n.bytes}`)}return{path:t.path,source:`configured`}}for(let e of this.#t){let t=r(e,n.file);if(sizeOf(t)===n.bytes)return{path:t,source:`app-data`}}let i=r(this.cacheDir,n.file);if(sizeOf(i)===n.bytes||this.#o(n,i))return{path:i,source:`cache`}}availability(e=this.defaultModel,t={}){let n=this.require(e);return this.locate(n.id,t)===void 0?this.#i.has(n.id)?`downloading`:`downloadable`:`available`}installed(){return this.models.filter(e=>this.locate(e.id)!==void 0).map(e=>e.id)}async resolve(e=this.defaultModel,t={}){let n=this.require(e),r=this.locate(n.id,t);if(r===void 0)throw Error(`${this.capability} model '${n.id}' is not installed — await install('${n.id}') first. ${n.bytes} bytes from ${n.url}.`);return r.source!==`cache`&&await this.#s(n,r.path,t.signal),r.path}install(e=this.defaultModel,t={}){let r;try{if(r=this.require(e),!t.force&&this.locate(r.id,t)!==void 0){let e=new n(r.id);return e.add(t.monitor),this.resolve(r.id,t).then(t=>(e.report(r.bytes,r.bytes),t))}}catch(e){return Promise.reject(e)}let i=this.#i.get(r.id);if(i!==void 0)return i.progress.add(t.monitor),i.promise;let a=new n(r.id);a.add(t.monitor);let o=this.#c(r,a,t).finally(()=>this.#i.delete(r.id));return this.#i.set(r.id,{promise:o,progress:a}),o}uninstall(e=this.defaultModel){let t=this.cachePath(e);return sizeOf(t)===null?!1:(f(t),!0)}#o(e,t){for(let n of this.#n()){let i=r(n,e.file);if(sizeOf(i)===e.bytes)try{c(this.cacheDir,{recursive:!0});try{u(i,t)}catch{let e=`${t}.part-${a()}`;try{s(i,e),u(e,t)}catch(t){throw removeQuietly(e),t}removeQuietly(i)}return!0}catch{return!1}}return!1}async#s(e,t,n){let r=d(t),i=`${r.size}:${r.mtimeMs}`;if(this.#a.get(t)===i)return;let a=await sha256File(t,n);if(a!==e.sha256)throw Error(`${this.capability} model '${e.id}': ${t} has sha256 ${a}, expected ${e.sha256}`);this.#a.set(t,i)}async#c(e,t,n){let s=n.signal,d=await(n.fetch??this.#r??((e,t)=>fetch(e,t)))(e.url,{signal:s,redirect:`follow`});if(!d.ok)throw Error(`Downloading ${e.id} from ${e.url} failed: HTTP ${d.status}`);let f=d.headers.get(`content-length`);if(f!==null&&Number(f)!==e.bytes)throw Error(`Downloading ${e.id} refused: ${e.url} declares ${f} bytes, the manifest says ${e.bytes}`);let m=this.cacheDir,h=r(m,e.file);c(m,{recursive:!0});let g=`${h}.part-${a()}`,_=l(g,`w`),v=!1;try{let n=i(`sha256`),r=0,write=i=>{if(r+=i.length,r>e.bytes)throw Error(`Downloading ${e.id} failed: more than the manifest's ${e.bytes} bytes`);n.update(i),p(_,i),t.report(r,e.bytes)};t.report(0,e.bytes);let a=d.body?.getReader();if(a!==void 0)try{for(;;){s?.throwIfAborted();let{done:e,value:t}=await a.read();if(e)break;t!==void 0&&t.length>0&&write(t)}}catch(e){throw await a.cancel().catch(()=>void 0),e}else write(new Uint8Array(await d.arrayBuffer()));if(r!==e.bytes)throw Error(`Downloading ${e.id} failed: got ${r} bytes, expected ${e.bytes}`);let c=n.digest(`hex`);if(c!==e.sha256)throw Error(`Downloading ${e.id} failed: sha256 ${c}, expected ${e.sha256}`);return o(_),v=!0,u(g,h),t.report(e.bytes,e.bytes),h}catch(e){throw v||o(_),removeQuietly(g),e}}};export{ModelStore,sha256File};

package/lib/types/cache-dir.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The per-user cache directory, as `GLib.get_user_cache_dir()` answers it on
+ * Linux and macOS: `$XDG_CACHE_HOME` when it is an absolute path, else
+ * `~/.cache`. Flatpak sets `XDG_CACHE_HOME` to the sandbox's own cache, so a
+ * Flatpak app lands in `~/.var/app/<id>/cache` like every GLib app does.
+ *
+ * Read from the environment instead of GLib so the package runs under plain
+ * Node too. On Windows GLib answers the Internet cache folder; this answers
+ * `%LOCALAPPDATA%`, which is where Windows apps keep caches.
+ */
+export declare function userCacheDir(): string;
+/** `<user cache>/gjsify/models` — the root every capability's directory sits under. */
+export declare function modelsRoot(): string;

package/lib/types/index.d.ts

@@ -0,0 +1,4 @@
+export { modelsRoot, userCacheDir } from './cache-dir.js';
+export { validateManifest, type ModelEntry } from './manifest.js';
+export { DownloadProgressEvent, type CreateMonitorCallback } from './progress.js';
+export { ModelStore, sha256File, type FetchLike, type InstallOptions, type LocatedModel, type LocateOptions, type ModelAvailability, type ModelSource, type ModelStoreOptions, type ResolveOptions, } from './store.js';

package/lib/types/manifest.d.ts

@@ -0,0 +1,29 @@
+/** One fetchable model. Capability packages extend it with their own fields. */
+export interface ModelEntry {
+    /** Stable id, unique within one store. */
+    readonly id: string;
+    /** File name inside the cache directory. Upstream's own name, so a hand-placed file matches. */
+    readonly file: string;
+    /** Where it is fetched from: upstream, never a mirror of ours (ADR 0132 § 5). */
+    readonly url: string;
+    /** Exact size in bytes. */
+    readonly bytes: number;
+    /** SHA-256 of the file, lowercase hex. */
+    readonly sha256: string;
+    /** SPDX id of the MODEL's licence, which is not the package's. */
+    readonly license: string;
+    /**
+     * Whether the licence allows redistributing the file. An app may ship a
+     * model in its data dir only when this is `true`; the store fetches from
+     * `url` either way.
+     */
+    readonly redistributable: boolean;
+    /** One line for a settings panel or a download prompt. */
+    readonly description?: string;
+}
+/**
+ * Throws on the manifest mistakes that would otherwise surface as a refused
+ * download much later: a duplicate id or file, a malformed digest, a size of
+ * zero, a non-https URL, or a file name that would escape the cache dir.
+ */
+export declare function validateManifest(models: readonly ModelEntry[]): void;

package/lib/types/manifest.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/progress.d.ts

@@ -0,0 +1,25 @@
+/** The `monitor` option of every capability's `create()` and of `install()`. */
+export type CreateMonitorCallback = (monitor: EventTarget) => void;
+/** `downloadprogress`: `loaded` is 0…1 as in the WebML CG APIs; `receivedBytes`/`totalBytes` are ours. */
+export declare class DownloadProgressEvent extends Event {
+    readonly modelId: string;
+    readonly receivedBytes: number;
+    readonly totalBytes: number;
+    readonly loaded: number;
+    readonly total = 1;
+    readonly lengthComputable = true;
+    constructor(modelId: string, receivedBytes: number, totalBytes: number);
+}
+/** Fans one download's progress out to every caller waiting on it. */
+export declare class ProgressFanout {
+    #private;
+    readonly modelId: string;
+    constructor(modelId: string);
+    add(monitor: CreateMonitorCallback | undefined): void;
+    /**
+     * Fires at 0, at 1, and between them only when the fraction moved by at
+     * least 0.1 % — a 548 MB download in 64 KiB chunks would otherwise fire
+     * eight thousand events for a progress bar that shows a thousand states.
+     */
+    report(receivedBytes: number, totalBytes: number): void;
+}

package/lib/types/store.d.ts

@@ -0,0 +1,111 @@
+import { type ModelEntry } from './manifest.js';
+import { type CreateMonitorCallback } from './progress.js';
+/**
+ * The WebML CG availability states. The store itself never answers
+ * `unavailable` — that is the capability's verdict (no engine, or `checkFit`
+ * says `none`) — but the type is shared so the capability can return either.
+ */
+export type ModelAvailability = 'available' | 'downloading' | 'downloadable' | 'unavailable';
+/** Where {@link ModelStore.locate} found a model. */
+export type ModelSource = 'configured' | 'app-data' | 'cache';
+export interface LocatedModel {
+    readonly path: string;
+    readonly source: ModelSource;
+}
+/** The subset of `fetch` the store uses, so a test can inject one. */
+export type FetchLike = (url: string, init: {
+    signal?: AbortSignal;
+    redirect?: 'follow';
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    headers: {
+        get(name: string): string | null;
+    };
+    body?: {
+        getReader(): {
+            read(): Promise<{
+                done: boolean;
+                value?: Uint8Array;
+            }>;
+            cancel(): Promise<void>;
+        };
+    } | null;
+    arrayBuffer(): Promise<ArrayBuffer>;
+}>;
+export interface ModelStoreOptions<E extends ModelEntry> {
+    /** Directory name under the models root: `speech`, `embeddings`, `image`. Lowercase, digits, dashes. */
+    readonly capability: string;
+    readonly models: readonly E[];
+    /** The id `undefined` means. Default: the first entry. */
+    readonly defaultModel?: string;
+    /** Override `<user cache>/gjsify/models`. Tests, or an app that keeps models elsewhere. */
+    readonly root?: string;
+    /** Directories an app ships models in, read-only. Searched before the cache. */
+    readonly appDataDirs?: readonly string[];
+    /**
+     * Directories an older release cached into. A match is moved into the
+     * cache once. A function is called per lookup, so a directory derived from
+     * the user cache follows a changed `XDG_CACHE_HOME` the way `cacheDir` does.
+     */
+    readonly legacyDirs?: readonly string[] | (() => readonly string[]);
+    /** Override the global `fetch`. */
+    readonly fetch?: FetchLike;
+}
+export interface LocateOptions {
+    /** A file the app was told to use for this id. Must exist and have the manifest's size. */
+    readonly path?: string;
+}
+export interface ResolveOptions extends LocateOptions {
+    readonly signal?: AbortSignal;
+}
+export interface InstallOptions extends ResolveOptions {
+    /** Receives an EventTarget firing `downloadprogress`, at least at 0 and 1. */
+    readonly monitor?: CreateMonitorCallback;
+    /** Re-fetch into the cache even when a source already has the model. */
+    readonly force?: boolean;
+    /** Override the store's `fetch` for this call. */
+    readonly fetch?: FetchLike;
+}
+/** Hex SHA-256 of a file, read in 1 MiB slices so a 548 MB model never sits in memory. */
+export declare function sha256File(path: string, signal?: AbortSignal): Promise<string>;
+export declare class ModelStore<E extends ModelEntry = ModelEntry> {
+    #private;
+    readonly capability: string;
+    readonly models: readonly E[];
+    readonly defaultModel: string;
+    constructor(options: ModelStoreOptions<E>);
+    /** `<root>/<capability>`. Resolved per call, so a changed `XDG_CACHE_HOME` is honoured. */
+    get cacheDir(): string;
+    find(id?: string): E | undefined;
+    /** The entry for `id`, or a `RangeError` naming the ids that exist. */
+    require(id?: string): E;
+    /** Where `id` is cached, whether or not it is there yet. */
+    cachePath(id?: string): string;
+    /**
+     * Where `id` is, by size only. Synchronous, reads no model bytes, never
+     * downloads. Moves a file from a legacy directory into the cache on the
+     * way. Throws for a configured path that is missing or has the wrong size:
+     * the app said the person has this file, so falling through to a download
+     * would be the surprise.
+     */
+    locate(id?: string, options?: LocateOptions): LocatedModel | undefined;
+    /** `available` when a source has it, `downloading` while `install()` runs, else `downloadable`. */
+    availability(id?: string, options?: LocateOptions): ModelAvailability;
+    /** Ids some source has, in manifest order. */
+    installed(): string[];
+    /**
+     * The verified path of `id`. Never downloads: rejects when no source has
+     * it, and when a configured or app-shipped file fails its digest.
+     */
+    resolve(id?: string, options?: ResolveOptions): Promise<string>;
+    /**
+     * Make `id` usable, fetching it into the cache when no source has it.
+     * Resolves to its verified path. Two overlapping calls share one download
+     * and both get progress; aborting either caller's signal aborts it for both.
+     * Every failure is a rejection, an unknown id included.
+     */
+    install(id?: string, options?: InstallOptions): Promise<string>;
+    /** Delete the CACHED file of `id` — never a configured or app-shipped one. `false` when none was there. */
+    uninstall(id?: string): boolean;
+}

package/lib/types/store.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/package.json

@@ -1,6 +1,82 @@
 {
-  "name": "@gjsify/model-store",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+    "name": "@gjsify/model-store",
+    "version": "0.64.20",
+    "description": "Where an AI model lives and how it gets there: one store per capability with streaming download, SHA-256 verification, WebML-shaped download progress, and three sources in order (a configured path, an app's read-only data dir, the per-user cache). Pure TypeScript on node:* APIs.",
+    "module": "lib/esm/index.js",
+    "types": "lib/types/index.d.ts",
+    "type": "module",
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "types": "./lib/types/index.d.ts",
+            "default": "./lib/esm/index.js"
+        }
+    },
+    "files": [
+        "lib",
+        "!lib/types/**/*.spec.d.ts"
+    ],
+    "scripts": {
+        "clear": "gjsify clear lib tmp tsconfig.tsbuildinfo test.gjs.mjs test.node.mjs",
+        "check": "gjsify tsc --noEmit",
+        "build": "gjsify run build:gjsify && gjsify run build:types",
+        "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+        "build:types": "gjsify tsc",
+        "build:test": "gjsify run build:test:gjs && gjsify run build:test:node",
+        "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+        "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
+        "test": "gjsify run build:gjsify && gjsify run build:test && gjsify run test:node && gjsify run test:gjs",
+        "test:gjs": "gjsify run test.gjs.mjs",
+        "test:node": "node test.node.mjs"
+    },
+    "keywords": [
+        "model",
+        "cache",
+        "download",
+        "sha256",
+        "ai",
+        "onnx",
+        "gguf"
+    ],
+    "dependencies": {
+        "@gjsify/crypto": "^0.64.20",
+        "@gjsify/fs": "^0.64.20",
+        "@gjsify/os": "^0.64.20",
+        "@gjsify/path": "^0.64.20",
+        "@gjsify/process": "^0.64.20"
+    },
+    "devDependencies": {
+        "@gjsify/cli": "^0.64.20",
+        "@gjsify/unit": "^0.64.20",
+        "@types/node": "^25.9.2",
+        "typescript": "^6.0.3"
+    },
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/gjsify/gjsify.git",
+        "directory": "packages/gjs/model-store"
+    },
+    "bugs": {
+        "url": "https://github.com/gjsify/gjsify/issues"
+    },
+    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/gjs/model-store#readme",
+    "gjsify": {
+        "tier": 3,
+        "runtimes": {
+            "gjs": "polyfill",
+            "node": "none",
+            "browser": "none",
+            "nativescript": "none"
+        },
+        "os": {
+            "linux": "supported",
+            "darwin": "supported",
+            "win32": "partial"
+        },
+        "osNotes": {
+            "win32": "The cache root is %LOCALAPPDATA%\\gjsify\\models, where GLib's get_user_cache_dir() would answer the Internet cache folder."
+        },
+        "headless": true
+    }
+}