@wavehouse/chtypes 0.4.0 → 0.5.1

package/dist/registry.d.ts

@@ -1,8 +1,21 @@
 /**
  * The artifact-directory loader: one subdirectory per ClickHouse minor line,
- * each self-contained (docs/reference/artifact.md).
+ * 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:
  *
@@ -14,16 +27,29 @@
  *    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. 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.
+ *    `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 line is taken, on request, from the first directory that
- * has it. A line no directory has is the one §7 error,
- * `ArtifactMissingError` — or, with `autofetch`, a fetch on first `open()`.
+ * `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.
  */
 import { type EnsureOptions } from './fetch.js';
 import { Library } from './library.js';
@@ -74,7 +100,8 @@ export interface RegistryOptions {
      * 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.
+     * 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
@@ -86,27 +113,58 @@ export interface RegistryOptions {
      */
     preload?: readonly string[] | undefined;
     /**
-     * Lazy fetch on first open (docs/guides/fetch.md §6): `open()` of a line no
+     * 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 line. 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()` stays synchronous and never fetches.
+     * 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;
+}
+/** 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()` / `open()`) or an explicit
- * `preload` — not `versions()`, not `libraries()`, not `has()`. An open costs
- * about 120 MB resident per version, which a listing call must not spend on a
- * caller's behalf.
+ * 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
@@ -129,14 +187,17 @@ export declare class Registry {
     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 byId;
     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;
     /**
-     * Minor line -> the FIRST directory on the search path that holds it, as the
-     * construction-time manifest scan found it. What `versions()` answers from,
-     * and what makes "no artifact anywhere" and a bad `preload` entry decidable
-     * at construction without a single `dlopen`.
+     * 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;
@@ -144,9 +205,13 @@ export declare class Registry {
     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
-     * line.
+     * 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
@@ -156,7 +221,7 @@ export declare class Registry {
      * @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
-     *   `<minor>/manifest.json` — both suppressed when autofetch is on. A
+     *   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
@@ -169,28 +234,44 @@ export declare class Registry {
     constructor(dir?: string, options?: RegistryOptions);
     /**
      * Open one `preload` entry, before the constructor returns, without
-     * fetching. Resolution is `for()`'s, and so is the failure: a line no
-     * directory holds is the same `ArtifactMissingError`, raised earlier.
+     * 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 `<dir>/<minor>/` if it is an artifact directory; null when it is not. */
-    private loadLine;
-    private lookup;
+    /** 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;
     /**
-     * Resolve without fetching: what is already open, then the line's directory
-     * as the construction-time scan recorded it, then a fresh walk of the search
-     * path for a line installed since. `undefined` means no directory holds it,
-     * which is a fetch's cue on `open()` and the §7 error everywhere else —
-     * `preload` never fetches, and this is the one function that makes the
-     * preload path and the first-use path identical in everything else.
+     * 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 resolve;
+    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.
+     * 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
@@ -198,54 +279,79 @@ export declare class Registry {
      */
     versions(): string[];
     /**
-     * The libraries this registry has OPENED, in release order (oldest minor
-     * line first) — what is open right now, never what could be. A discovered
-     * line that no `for()` and no `preload` has opened appears in `versions()`
-     * and not here. It opens nothing.
+     * 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.
      */
     libraries(): readonly Library[];
     /**
-     * Resolve a version to its library. A minor line ("25.8") or an exact patch
-     * ("25.8.28.1-lts") both work, and an unknown patch inside a loaded minor line
-     * resolves to that line — asking for "25.8.30.16" finds the loaded 25.8.
+     * 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: the line is
-     * taken from the first directory on the search path that holds it
-     * (docs/guides/fetch.md §1), `dlopen`ed once, and joins `libraries()` from
-     * then on. Never a fetch: this call is synchronous; `open()` is the one that
-     * may fetch.
+     * **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 the nearest version:
-     * answering 26.7 semantics from a 25.8 artifact is a lie, and silent
-     * wrongness is what the rigs score hardest.
+     * 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 the line;
-     *   the message names every directory looked in and the fetch command.
-     * @throws {RegistryError} when a directory holds the line but it does not load.
+     *   `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()`, with the lazy fetch of docs/guides/fetch.md §6 in front of it: a line no
-     * directory on the search path holds is fetched through `ensure()` — into
-     * the directory a fetch writes to (§1), verified, once per process per line
-     * even under concurrent opens — and then loaded. With `autofetch` off (the
-     * default) this is `for()` behind a promise, and a missing line rejects
-     * with the same `ArtifactMissingError`.
+     * `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 the line is missing and autofetch is off.
+     * @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: loaded already, or held
-     * by a directory on the search path (which `for()` would load). Never a
-     * fetch, and never a load.
+     * 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;
     /**
@@ -278,6 +384,10 @@ export declare function resolveRegistryDir(explicit?: string): string | null;
  * 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? */
+/**
+ * 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;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAMH,OAAO,EAAU,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAExD,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;;;;;;;;;;;;;;;;;;;OAmBG;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;;;;;;;;;;;;;;;;;;;;GAoBG;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,IAAI,CAA8B;IACnD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA6B;IACnD,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;IAE9C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,YAAY,GAAG,CAAC,EAAE,MAAM,EAAE,OAAO,GAAE,eAAoB,EAoEtD;IAED;;;;OAIG;IACH,OAAO,CAAC,WAAW;IASnB,8EAA8E;IAC9E,OAAO,CAAC,IAAI;IAgDZ,iFAAiF;IACjF,OAAO,CAAC,QAAQ;IAQhB,OAAO,CAAC,MAAM;IAId;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO;IA0Bf;;;;;;;;OAQG;IACH,QAAQ,IAAI,MAAM,EAAE,CAInB;IAED;;;;;OAKG;IACH,SAAS,IAAI,SAAS,OAAO,EAAE,CAE9B;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAI5B;IAED;;;;;;;;;;;;OAYG;IACG,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAW5C;IAED;;;;OAIG;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,6EAA6E;AAC7E,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAatD"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"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"}