@wavehouse/chtypes 0.5.1 → 1.0.0

package/dist/registry.d.ts

@@ -1,393 +1,46 @@
 /**
- * The artifact-directory loader: one subdirectory per ClickHouse minor line,
- * each self-contained (docs/reference/artifact.md), plus — since #284 — every
- * OTHER installed exact patch of a line, in a sibling `patches/` tree:
- *
- *   <registry>/25.8/{manifest.json, libchtypes.dylib, CH_VERSION, unsafe_families.txt}
- *   <registry>/patches/25.8/25.8.28.1-lts/{manifest.json, libchtypes.dylib, ...}
- *
- * The flat `<registry>/<minor>/` slot is what a LINE request resolves to —
- * exactly the pre-#284 layout, so every SDK through 0.4.x keeps reading it
- * unchanged. Any OTHER exact patch of that line lives in
- * `<registry>/patches/<minor>/<clickhouse_version>/`, which no released SDK
- * (0.4.x and earlier) scans, fetches into or deletes (measured, issue #284
- * comment 5919199794): it is a new, additive tree, not a migration of the old
- * one. When a line fetch changes which patch occupies the flat slot, the
- * outgoing install is DEMOTED — an atomic, same-filesystem rename into
- * `patches/<minor>/<its version>/` — never deleted, so a server still on the
- * older patch keeps its exact match with no re-fetch.
- *
- * Two rules here were paid for and are not negotiable:
- *
- *  - **The shared library's file name comes from `manifest.json`'s `library`
- *    field.** Not from a hard-coded `libchtypes.so`, not from a glob, not from
- *    the platform. The current tree proves why: every darwin artifact says
- *    `libchtypes.dylib` while the *shipping* linux artifacts still say
- *    `libchtypes_s1.so`, so a loader that constructs the name finds nothing on
- *    the platform that matters.
- *  - **Each artifact is loaded into its own symbol scope (`RTLD_LOCAL`).** That
- *    is the entire mechanism by which two builds that both define
- *    `DB::DataTypeFactory` live in one process — now routinely two builds of
- *    the SAME minor line, one per patch. ffi-rs loads through libloading,
- *    which uses `RTLD_LAZY | RTLD_LOCAL`; `assertLocalSymbolScope()` in the
- *    test suite proves it from outside rather than trusting the claim.
- *
- * Where a registry IS follows the search path of docs/guides/fetch.md §1 (`paths.ts`):
- * the explicit directory, `CHTYPES_REGISTRY`, the per-user cache, then the
- * reserved system locations. Construction READS THE MANIFESTS on that path and
- * `dlopen`s nothing; a version is taken, on request, from the first directory
- * that has it. Resolution (docs/reference/bindings.md §Version selection):
- *
- *  - **A line request** ("25.8") never falls back and never crosses lines: the
- *    newest patch of the line, in the first search-path directory that holds
- *    any patch of it (a nested install beating a flat one on a version tie),
- *    pinned for this registry for as long as it runs.
- *  - **A patch request** ("25.8.28.1-lts") loads that exact patch when it is
- *    open or installed anywhere on the search path. Otherwise it falls back to
- *    the newest installed patch of the same line, flags the result
- *    `exact: false`, and warns once per (requested, actual) pair per process —
- *    never another line, which stays the one §7 error, `ArtifactMissingError`.
- *
- * A patch spelled with no channel suffix matches that patch on any channel
- * (docs/guides/fetch.md Decision 7); ordering is numeric, channel ignored.
+ * `Registry`: from a version request to a loaded `Library`
+ * (`docs/reference/bindings-v1.md` §6, "The sequence").
+ *
+ *   registry.for(request)
+ *     1. the registry's memo: a request opened before returns the same Library,
+ *        for the registry's life (a line request never moves mid-process: a
+ *        newer patch installed later is picked up by a new registry)
+ *     2. resolved = resolveInstalled(request, host platform, fetch options)   never the network
+ *     3. on a miss: autofetch on  -> resolved = ensure(request, fetch options)  may use the network
+ *                   autofetch off -> ArtifactMissingError, naming request and platform
+ *     4. input = adapt(resolved): the library path, the predicate VERBATIM (never
+ *        re-encoded: a re-encoding is a second derivation of the statement the
+ *        signature covered) and the platform
+ *     5. loader steps 1-6, once per image; step 7 under the process setup
+ *     6. the image's Library, whose `resolved` is the record that first opened it
+ *
+ * Construction opens nothing: `Registry.open` is asynchronous only because the
+ * fetch layer is, and nothing opens an artifact except a request for a version
+ * or `preload`. The binding orders and matches no versions itself: which
+ * installed build a floating request means is the fetch layer's.
  */
-import { type EnsureOptions } from './fetch.js';
-import { Library } from './library.js';
-/** The nine fields `lib/build.sh` writes. Unknown fields are ignored. */
-export interface Manifest {
-    library: string;
-    library_bytes?: number;
-    library_sha256?: string;
-    clickhouse_version?: string;
-    clickhouse_minor?: string;
-    clickhouse_commit?: string;
-    os?: string;
-    arch?: string;
-    unsafe_families?: string;
-}
-/** Options for `new Registry(dir, options)`. */
+import { type Library } from './library.js';
+import { type FetchV1Options, type Resolved } from './ocifetch/index.js';
+/** The fetch layer's options (bases, cache directory, system directories, trusted keys, token, allow-unsigned, offline, frozen, lock path, ...) without its test-only hooks. */
+export type FetchOptions = Omit<FetchV1Options, 'beforeIndexRename' | 'httpLog' | 'clock'>;
 export interface RegistryOptions {
-    /**
-     * The server timezone assumed for bare DateTime / DateTime64 columns. Defaults
-     * to UTC — what a stock ClickHouse container uses — and is deliberately not
-     * read from the environment, so the host's TZ cannot leak into results.
-     */
-    timezone?: string;
-    /**
-     * Re-hash each library and compare against `manifest.library_sha256` before
-     * loading. SHOULD be on for an artifact that came from anywhere but a local
-     * build, and MUST be on for one that came over a network.
-     *
-     * A policy on the REGISTRY, not a property of `preload`: a library's
-     * checksum is computed immediately before that library is `dlopen`ed and at
-     * no other time — at construction for the preloaded lines, at first use for
-     * the rest, never for a line nobody asks for.
-     *
-     * What this option ADDS is the sha256 comparison. The cheaper
-     * `manifest.library_bytes` size check that runs just before it is NOT
-     * conditional on this option — `load()` below always makes it, on every
-     * open, regardless (issue #82). Its timing is the same as the checksum's:
-     * at construction for the preloaded lines, at first use for the rest.
-     */
-    verifyChecksums?: boolean;
-    /**
-     * Open these lines AT CONSTRUCTION — the one eager path, and the same option
-     * Go spells `WithPreload(...)`, Python `preload=[...]` and Rust
-     * `RegistryOptions::preload`.
-     *
-     * Each entry is a version spelling resolved exactly as `for()` resolves one:
-     * a minor line (`'25.8'`) or an exact patch (`'25.8.28.1-lts'`), never a
-     * path. They are opened in the order given, before the constructor returns,
-     * and an entry no directory on the §1 search path holds is
-     * `ArtifactMissingError` — the same §7 error the first `for()` would have
-     * thrown, thrown earlier. A patch entry that falls back to its line warns at
-     * construction, exactly as `for()` would.
-     *
-     * It NEVER fetches, even with `autofetch` on: this constructor is
-     * synchronous and `ensure()` is not, and autofetch is a first-use behavior
-     * in all four bindings. An empty list is exactly the default.
-     *
-     * Deliberately a list of lines rather than "everything in the directory": a
-     * registry directory is whatever a fetch left behind, and each open costs
-     * about 120 MB resident.
-     */
-    preload?: readonly string[] | undefined;
-    /**
-     * Lazy fetch on first open (docs/guides/fetch.md §6): `open()` of a version no
-     * directory on the search path holds runs `ensure()` first, into the
-     * directory a fetch writes to (§1), once per process per (destination,
-     * spelling). Off by default — a production process must not begin a 250 MB
-     * download inside a request — and `CHTYPES_AUTOFETCH=1` turns it on from the
-     * environment. `for()` / `resolve()` stay synchronous and never fetch.
-     */
-    autofetch?: boolean | undefined;
-    /** Options handed to `ensure()` by autofetch: source (`url`/`tag`), lock, keys, progress. */
-    fetch?: EnsureOptions | undefined;
-}
-/**
- * What a `resolve()` / `openResolution()` call hands back: the loaded
- * `Library`, the caller's own spelling, what actually loaded, and whether the
- * two are the same patch (docs/reference/bindings.md §Version selection).
- * `for()` / `open()` run the same resolution and hand back only `.library`.
- */
-export interface Resolution {
-    /** The `Library` this resolution loaded (or found already loaded). */
-    readonly library: Library;
-    /** The caller's own spelling, trimmed — never normalized further. */
-    readonly requested: string;
-    /**
-     * What actually loaded, i.e. `library.version`. Equal to the requested
-     * patch when `exact` is true; the newest installed/published patch of the
-     * requested line otherwise.
-     */
-    readonly version: string;
-    /**
-     * `true` for a line request — it asked for "a patch of this line" and got
-     * one. For a patch request, `true` only when the loaded version matches the
-     * requested patch (a spelled channel matches only itself; an unspelled one
-     * matches on any channel). `false` means the fallback within the line was
-     * taken, and a warning was already issued for this (requested, actual) pair
-     * — once per pair per process.
-     */
-    readonly exact: boolean;
+    readonly fetch?: FetchOptions | undefined;
+    /** Fetch on a miss. Defaults to the `CHTYPES_AUTOFETCH` environment variable, and is off when that is unset. */
+    readonly autofetch?: boolean | undefined;
+    /** Requests opened at construction, in list order. They never fetch, even with autofetch on. */
+    readonly preload?: readonly string[] | undefined;
 }
-/** TEST-ONLY: forget every warned pair, so a suite can assert a fresh warning fires. Not re-exported from index.ts. */
-export declare function resetPatchFallbackWarnings(): void;
-/**
- * The artifact-directory loader — the multi-version entry point of this
- * package.
- *
- * **Construction reads `manifest.json` files and `dlopen`s nothing**, with or
- * without a directory. Nothing in this package opens an artifact except a
- * request for a specific version (`for()` / `resolve()` / `open()` /
- * `openResolution()`) or an explicit `preload` — not `versions()`, not
- * `libraries()`, not `has()`. An open costs about 120 MB resident per patch,
- * which a listing call must not spend on a caller's behalf, and which grows
- * with every DISTINCT patch a process is asked for — libraries are never
- * dlclosed (docs/guides/multi-version.md).
- *
- * An open dlopens the artifact into its own symbol scope (`RTLD_LOCAL`),
- * verifies its ABI revision against this binding's `ABI_REVISION` (a different
- * nonzero revision is refused; 0 means the artifact predates the probe and
- * degrades per symbol), and runs that library's one-time `chs_init` with the
- * registry's timezone and the artifact's own `unsafe_families.txt`.
- *
- * Libraries are never dlclosed; `close()` joins background threads only.
- * Loading the same artifact path from two `Registry` instances shares one
- * loaded image, so `chs_init` still runs exactly once per artifact.
- */
 export declare class Registry {
-    /**
-     * The primary registry directory: the first on the search path that holds
-     * artifacts — or, with `autofetch` and nothing installed anywhere, the
-     * directory the first fetch will create.
-     */
-    readonly dir: string;
-    /** The §1 search path, in order, every candidate whether or not it exists. */
-    readonly searchPath: readonly string[];
-    /** This host's platform key, e.g. `darwin-arm64` — the only artifacts a process can dlopen. */
-    readonly platform: string;
-    private readonly byPath;
-    private readonly loaded;
-    /** Line -> the library currently answering FOR THE LINE. Set once per line; never re-pointed while this registry runs (R3/R8). */
-    private readonly linePins;
-    /**
-     * Line -> every patch the construction-time manifest scan found for it,
-     * across the whole search path. What `versions()` answers from, and what
-     * makes "no artifact anywhere" and a bad `preload` entry decidable at
-     * construction without a single `dlopen`. Resolution itself re-scans the
-     * live filesystem on every call (a patch installed after construction, by
-     * this process or another, is used from the next call on).
-     */
-    private readonly known;
-    private readonly timezone;
-    private readonly verifyChecksums;
-    private readonly autofetch;
-    private readonly fetchOptions;
-    private readonly explicit;
-    /** (dest, line) already `Ensure()`d successfully by THIS registry's autofetch — never re-read over the network again. */
-    private readonly ensuredLines;
-    /** (dest, exact patch) autofetch has already confirmed CHTYPES_ARTIFACT_UNPUBLISHED for — never retried within this registry's lifetime. */
-    private readonly unpublishedPatches;
-    /**
-     * Scan a registry. Reads manifests; opens nothing unless `preload` names a
-     * version.
-     *
-     * @param dir - the registry root; the head of the search path. Absent, the
-     *   path is `CHTYPES_REGISTRY`, the per-user artifact cache, then the system
-     *   locations (see `registrySearchPath` / `defaultRegistryDir`).
-     * @param options - timezone, checksum verification, autofetch, preload — see
-     *   `RegistryOptions`.
-     * @throws {RegistryError} for what manifests can decide, and only that: a
-     *   directory named explicitly (the argument or `CHTYPES_REGISTRY`) that does
-     *   not exist, and no directory on the search path holding a readable
-     *   manifest at either slot — both suppressed when autofetch is on. A
-     *   `preload` entry no directory holds is `ArtifactMissingError`. Everything
-     *   a bad artifact can be wrong about — a failed checksum, a load failure, a
-     *   library whose ClickHouse version disagrees with its manifest — is
-     *   reported by the call that opens it, which is `preload`'s open at
-     *   construction or the first `for()` otherwise.
-     * @throws {ChtypesError} when an artifact reports a different nonzero ABI
-     *   revision than this binding speaks, or `chs_init` fails (e.g. an unknown
-     *   timezone — the message names it); again, from the call that opens it.
-     */
-    constructor(dir?: string, options?: RegistryOptions);
-    /**
-     * Open one `preload` entry, before the constructor returns, without
-     * fetching. Resolution is `for()`'s (minus any fetch), and so is the
-     * failure: a version no directory holds anywhere is the same
-     * `ArtifactMissingError`, raised earlier. A patch entry that falls back
-     * warns here, at construction, exactly as `for()` would.
-     */
-    private preloadLine;
-    /** dlopen one artifact directory, cross-check it, `chs_init` it, index it. */
-    private load;
-    /** Load an artifact directory whose manifest is already known-readable, or return null when it is not one. */
-    private loadDir;
-    /** Every patch (both slots, every search-path root) this registry can currently see for `minor` — a live scan. */
-    private scanLine;
-    /** R3: line request — the pin if this registry already has one, else the newest patch in the first root that holds any. */
-    private resolveLineSync;
-    /** R4 steps 1-2: an exact match, already open or anywhere on the search path — never a fallback. */
-    private resolveExactPatchSync;
-    /**
-     * R4 in full, synchronous shape: exact, else the newest-installed fallback
-     * within the line. R-c: the already-open check is free (no I/O) and always
-     * current; everything past it needs a directory read per search-path entry,
-     * so once a request has fallen back, the WHOLE re-check — retrying the exact
-     * match and picking the fallback alike — is throttled together, at most
-     * once per `FALLBACK_RECHECK_MS` per requested patch per process.
-     *
-     * §3: the warning fires as soon as the fallback patch is CHOSEN — its
-     * version is already known from the manifest scan, before `loadDir` ever
-     * runs — so a caller sees the warning even when the chosen directory then
-     * fails to load (a broken artifact is still a fallback that was taken).
-     */
-    private resolvePatchSync;
-    private resolveSync;
-    /** Would `req` resolve without opening anything? Mirrors `resolveSync` with no `load()` call. */
-    private wouldResolve;
-    private warnFallback;
-    /**
-     * Every ClickHouse minor line this registry CAN ANSWER FOR, oldest first —
-     * the ones it has opened plus the ones its construction-time manifest scan
-     * discovered on the search path, at either slot.
-     *
-     * That is one meaning in all four bindings, and it is the meaning that
-     * survives lazy loading: "the lines that happen to be open" would read as an
-     * empty registry until the first `for()`. It opens nothing.
-     */
-    versions(): string[];
-    /**
-     * The libraries this registry has OPENED, in full numeric version order —
-     * what is open right now, never what could be. Two patches of one line both
-     * appear, each in its own slot in this order. A discovered patch that no
-     * `for()` and no `preload` has opened appears in `versions()` and not here.
-     * It opens nothing.
-     */
+    #private;
+    private constructor();
+    /** Construct a registry. It opens nothing, except each `preload` request, in list order. */
+    static open(options?: RegistryOptions): Promise<Registry>;
+    /** Open a version: the installed build the request names, fetched first when autofetch is on and none is installed. */
+    for(request: string): Promise<Library>;
+    /** What is installed: the fetch layer's own listing. */
+    installed(): Promise<readonly Resolved[]>;
+    /** The libraries this registry has opened, in order of first open. */
     libraries(): readonly Library[];
-    /**
-     * Resolve a version to its library. A minor line ("25.8") never falls back:
-     * the newest patch of the line, from the first search-path directory that
-     * holds any patch of it. An exact patch ("25.8.28.1-lts") loads that patch
-     * when it is open or installed anywhere on the search path; otherwise the
-     * newest installed patch of the same line is loaded instead, and one
-     * warning is written per (requested, actual) pair per process — `resolve()`
-     * reports the same fallback as `exact: false` instead of only warning.
-     *
-     * **This is what opens an artifact.** Construction does not: a version is
-     * loaded on first request, `dlopen`ed once, and joins `libraries()` from
-     * then on. Never a fetch: this call is synchronous; `open()` /
-     * `openResolution()` are the ones that may fetch.
-     *
-     * Failure is the one §7 error, never a fallback to another line: answering
-     * 26.7 semantics from a 25.8 artifact is a lie, and silent wrongness is what
-     * the rigs score hardest.
-     *
-     * @param version - a minor line (`"25.8"`) or an exact patch
-     *   (`"25.8.28.1-lts"`), e.g. what `parseVersionResult` discovered.
-     * @returns the loaded `Library` for that version.
-     * @throws {ArtifactMissingError} (`code` `CHTYPES_ARTIFACT_MISSING`, a
-     *   `RegistryError`) when no directory on the search path holds a matching
-     *   or fallback patch; the message names every directory looked in and the
-     *   fetch command.
-     * @throws {ChtypesError} when `version` is not a ClickHouse version spelling at all.
-     * @throws {RegistryError} when a directory holds a version but it does not load.
-     */
-    for(version: string): Library;
-    /**
-     * `for()`, but returns the full `Resolution` — the requested spelling, what
-     * actually loaded, and whether the two are the same patch. Never fetches;
-     * `openResolution()` is the async twin that may.
-     *
-     * @throws {ArtifactMissingError} as `for()`.
-     * @throws {ChtypesError} when `version` is not a ClickHouse version spelling at all.
-     */
-    resolve(version: string): Resolution;
-    /**
-     * `for()`, with the lazy fetch of docs/guides/fetch.md §6 in front of it. A
-     * LINE request no directory holds is fetched through `ensure()` and loaded.
-     * A PATCH request tries `ensure()` of that exact patch first; on
-     * `CHTYPES_ARTIFACT_UNPUBLISHED` (remembered for this registry, so it costs
-     * one network round trip, not one per call) it falls back to `ensure()` of
-     * the line and loads whatever that installs, with `exact: false` and one
-     * warning. Any other fetch failure (untrusted, corrupt, pinned, source
-     * unreachable) surfaces as itself and is never remembered, so a later call
-     * retries. With `autofetch` off, this is `for()` behind a promise.
-     *
-     * @throws {ArtifactMissingError} when nothing is found and autofetch is off.
-     * @throws {FetchError} the §7 fetch verdicts (`CHTYPES_ARTIFACT_UNTRUSTED`,
-     *   `…_CORRUPT`, `…_PINNED`, `…_UNPUBLISHED`, `CHTYPES_SOURCE_UNREACHABLE`).
-     * @throws {RegistryError} when the fetched artifact does not load.
-     */
-    open(version: string): Promise<Library>;
-    /** `open()`, but returns the full `Resolution` — see `resolve()` and `open()`. */
-    openResolution(version: string): Promise<Resolution>;
-    /** `ensure(line)`, at most once per (dest, line) over this registry's lifetime — never re-read over the network again. */
-    private ensureLineOnce;
-    /**
-     * True when this registry can answer for a version without fetching or
-     * loading: already open, or held by a directory on the search path (at
-     * either slot) which `for()` would load. A patch resolves true when the
-     * patch itself, or any patch of its line, is installed or open — the same
-     * condition `for()` would resolve, fallback included. Never a fetch, and
-     * never a load.
-     */
-    has(version: string): boolean;
-    /**
-     * Join every loaded library's background threads. `chs_init` registers
-     * `chs_shutdown` with `atexit`, so an ordinary process needs no call; a test
-     * that must not depend on `atexit` should make one.
-     */
-    close(): void;
-    /** `using registry = new Registry(...)` closes it at scope exit. */
-    [Symbol.dispose](): void;
 }
-/** Numeric ordering: 25.10 is a later minor than 25.8, whatever strings say. */
-export declare function compareMinor(a: string, b: string): number;
-/**
- * Where the registry is: the explicit argument, else `CHTYPES_REGISTRY`, else
- * the first of the per-user artifact cache and the system locations that
- * holds artifacts (docs/guides/fetch.md §1). An explicit path and the environment
- * variable are returned as given — a wrong one must produce an error naming
- * it, not a silent fallback — while the unnamed candidates only count if they
- * actually hold artifacts.
- */
-export declare function resolveRegistryDir(explicit?: string): string | null;
-/**
- * The per-user artifact cache for this host —
- * `${XDG_CACHE_HOME:-~/.cache}/chtypes/artifacts/abi<R>/<os>-<arch>`, R this
- * binding's `ABI_REVISION` and `<arch>` spelled the artifact way (`amd64`,
- * `arm64`). Where `chtypes fetch` and `scripts/fetch.sh` install, and what
- * every SDK's tests and playgrounds fall back to when `CHTYPES_REGISTRY` is
- * unset — one directory the four SDKs at the same revision agree on. A path,
- * not a promise: `Registry` still throws if nothing is there.
- */
-export declare function defaultRegistryDir(): string;
-/**
- * Does this directory hold at least one artifact with a usable manifest, at
- * either slot — the flat `<dir>/<minor>/` layout or the `<dir>/patches/<minor>/<version>/`
- * sibling tree? A registry that holds only nested installs is not empty.
- */
-export declare function looksLikeRegistry(dir: string): boolean;
 //# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAMH,OAAO,EAAmB,KAAK,aAAa,EAAmE,MAAM,YAAY,CAAC;AAElI,OAAO,EAAE,OAAO,EAAW,MAAM,cAAc,CAAC;AAWhD,yEAAyE;AACzE,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,gDAAgD;AAChD,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;;;;;;;;;;OAeG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;IACxC;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAChC,6FAA6F;IAC7F,KAAK,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;CACnC;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,sEAAsE;IACtE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,qEAAqE;IACrE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;;;OAOG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AA0HD,uHAAuH;AACvH,wBAAgB,0BAA0B,IAAI,IAAI,CAEjD;AAaD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,QAAQ;IACnB;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,+FAA+F;IAC/F,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,kIAAkI;IAClI,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;IACvD;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsC;IAC5D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAU;IAC1C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAU;IACpC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAgB;IAC7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,yHAAyH;IACzH,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;IAClD,4IAA4I;IAC5I,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAqB;IAExD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,YAAY,GAAG,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,EAiDtD;IAED;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;IAanB,8EAA8E;IAC9E,OAAO,CAAC,IAAI;IA2CZ,8GAA8G;IAC9G,OAAO,CAAC,OAAO;IAMf,kHAAkH;IAClH,OAAO,CAAC,QAAQ;IAUhB,2HAA2H;IAC3H,OAAO,CAAC,eAAe;IAWvB,oGAAoG;IACpG,OAAO,CAAC,qBAAqB;IAQ7B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,gBAAgB;IAuCxB,OAAO,CAAC,WAAW;IAInB,iGAAiG;IACjG,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,YAAY;IAIpB;;;;;;;;OAQG;IACH,QAAQ,IAAI,MAAM,EAAE,CAInB;IAED;;;;;;OAMG;IACH,SAAS,IAAI,SAAS,OAAO,EAAE,CAE9B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE5B;IAED;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CASnC;IAED;;;;;;;;;;;;;;;OAeG;IACG,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAE5C;IAED,kFAAkF;IAC5E,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAsDzD;IAED,0HAA0H;YAC5G,cAAc;IAQ5B;;;;;;;OAOG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAQ5B;IAED;;;;OAIG;IACH,KAAK,IAAI,IAAI,CAEZ;IAED,oEAAoE;IACpE,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAEvB;CACF;AAED,gFAAgF;AAChF,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAUzD;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CASnE;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAgCtD"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH,OAAO,EAAE,KAAK,OAAO,EAAa,MAAM,cAAc,CAAC;AACvD,OAAO,EAGL,KAAK,cAAc,EAInB,KAAK,QAAQ,EAEd,MAAM,qBAAqB,CAAC;AAK7B,gLAAgL;AAChL,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,cAAc,EAAE,mBAAmB,GAAG,SAAS,GAAG,OAAO,CAAC,CAAC;AAE3F,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,GAAG,SAAS,CAAC;IAC1C,gHAAgH;IAChH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACzC,gGAAgG;IAChG,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;CAClD;AAiBD,qBAAa,QAAQ;;IAMnB,OAAO,eAGN;IAED,4FAA4F;IAC5F,OAAa,IAAI,CAAC,OAAO,GAAE,eAAoB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAOlE;IAED,uHAAuH;IACjH,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAG3C;IAED,wDAAwD;IAClD,SAAS,IAAI,OAAO,CAAC,SAAS,QAAQ,EAAE,CAAC,CAE9C;IAED,sEAAsE;IACtE,SAAS,IAAI,SAAS,OAAO,EAAE,CAE9B;CA4CF"}