@nxgt/mongo-kit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Steve Tsala
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,273 @@
+# @nxgt/mongo-kit
+
+An application's MongoDB in one object: a configuration checked once, the
+clients it needs opened from it, and every collection of
+[`@nxgt/mongo`](https://www.npmjs.com/package/@nxgt/mongo) typed on the
+database it lives in.
+
+```ts
+import { createKit, defineConfig } from '@nxgt/mongo-kit';
+import * as collections from './models';   // every `defineCollection` of the app
+
+export const kit = await createKit(
+	defineConfig({ uri: process.env.MONGO_URI!, collections }),
+);
+
+const user = await kit.db.users.create({ email: 'ada@example.com' });
+const posts = await kit.db.posts.findMany({ filter: { authorId: user._id } });
+await kit.db.command({ ping: 1 });         // the driver's Db, untouched
+```
+
+`kit.db` is the driver's `Db` with the collections on it: `db.users` is the
+typed collection `getCollection(db, users)` gives, and everything a `Db`
+answers to is still there. Nothing else has to be wired: no `getCollection`
+at each call site, no client to pass around, no session to thread by hand.
+
+> **0.x, on `@nxgt/mongo`.** The API is still settling.
+
+## Install
+
+```sh
+bun add @nxgt/mongo-kit @nxgt/mongo mongodb zod
+```
+
+- `@nxgt/mongo`: required peer. The collections, their options and their
+  behaviour are its; this package wires them.
+- `mongodb` `>=7.0.0 <8`: required peer, as `@nxgt/mongo` needs it. `zod` is
+  `@nxgt/mongo`'s.
+- `typescript` 6: required peer, the version every `@nxgt` package pins.
+- Tested against MongoDB 8.2. A **replica set** only for transactions, which
+  is MongoDB's own rule.
+
+## The collections
+
+They come from a module object — one import, and every type follows:
+
+```ts
+// src/models/index.ts
+export * from './users.model';
+export * from './posts.model';
+
+// src/db.ts
+import * as collections from './models';
+```
+
+Each export that is a `defineCollection` becomes a key on the scope, under
+the name it is exported by; anything else in the module — a function, a
+constant, a type — is left where it is. The key is the name the application
+reads (`db.users`), and the collection's own `name` is the one on the server,
+so `export const users = defineCollection({ name: 'app_users', … })` is
+`db.users` here and `app_users` there. Two exports on one server collection
+are refused: two keys writing to the same place is a mistake, not a feature.
+
+For a **script** — a sync or a migration run from the repository — the files
+can be read from disk instead:
+
+```ts
+import { syncCollections } from '@nxgt/mongo';
+import { discoverCollections } from '@nxgt/mongo-kit';
+
+const definitions = await discoverCollections({ glob: 'src/**/*.model.ts' });
+await syncCollections(db, definitions);     // `db` from connectMongo, say
+```
+
+It gives `@nxgt/mongo`'s `AnyCollectionDefinition[]`, **with no types**: a
+glob is read at run time, so a bundler cannot follow it and the compiler sees
+nothing. It **runs under Bun** — the glob is `Bun.Glob` — and it imports each
+file it finds, so their top level runs. It is for scripts, never for the
+wiring of an application.
+
+## Several databases
+
+They name themselves, and `kit.databases` reads them:
+
+```ts
+export const kit = await createKit(
+	defineConfig({
+		databases: {
+			main: { uri: process.env.MONGO_URI!, collections },
+			analytics: { uri: process.env.ANALYTICS_URI!, collections: events },
+		},
+	}),
+);
+
+await kit.databases.main.users.create({ email: 'ada@example.com' });
+await kit.databases.analytics.events.create({ kind: 'signup' });
+```
+
+`kit.db` is then `never`: with two databases there is no “the” database, and
+the name is what says which — and reading it anyway, from JavaScript or
+across an `any`, throws. A single database is named `default`, so
+`kit.databases.default` and `kit.clients.default` are the long way of writing
+the same thing, and `sync()` reports under that key.
+
+Two databases on one URI share one client, which is what `connectMongo`
+already does; their `clientOptions` must then be identical, since the second
+hold on a client opened with other options is refused.
+
+## The actor and the session
+
+```ts
+await kit.as(userId).db.posts.create({ title: 'a' });   // stamps createdBy
+
+await kit.as(userId).transaction(async (tx) => {
+	const team = await tx.db.teams.create({ name: 'Core' });
+	await tx.db.users.update(userId, { teamId: team._id });
+});
+```
+
+`as` and `withSession` give back **another kit** over the same clients: the
+one they came from is unchanged, so a request's kit never leaks into the
+next. The collections are built on the first read and kept, so a request
+pays for the collections it touches and no others.
+
+`transaction` runs the body with a kit whose collections are all in the
+session — nothing has to be passed. **The driver retries the body from the
+start** on a transient error, so it must be safe to run twice: keep side
+effects that are not MongoDB's out of it. A transaction inside a transaction
+**joins** the outer one, and takes no `{ on }`, since the session already
+decided; MongoDB has no savepoints, so an inner failure takes the whole
+transaction with it.
+
+With several clients, `{ on: 'main' }` says whose, since a transaction lives
+on one client — and inside that body only the databases on that client can be
+used: an operation on another one carries a session its client does not own,
+and the driver refuses it.
+
+The actor's type is the one the collections agree on: a kit whose collections
+stamp an `ObjectId` takes an `ObjectId`, and one whose collections stamp
+nothing has no `as` to call.
+
+## Sync
+
+```ts
+const reports = await kit.sync();          // { main: [ … ], analytics: [ … ] }
+await kit.sync({ dryRun: true });          // what it would change
+```
+
+The first database that throws stops the rest, which is what `dryRun` is for:
+it reports everything at once. It syncs exactly the collections the kit
+wires, database by database —
+`@nxgt/mongo`'s `syncAll` cannot, since its registry knows no database. It is
+a **deployment step**: `collMod` needs the `dbAdmin` role, and an index build
+runs outside any transaction. For tests and development, `autoSync: true` in
+the config syncs each collection before its first operation instead.
+
+## Closing
+
+```ts
+await kit.close();                         // or `await using kit = await createKit(…)`
+```
+
+It gives back the clients it opened, and leaves alone a `client` the config
+gave it: what it did not open is not its to close. Only the kit `createKit`
+returned can be closed — one from `as`, `withSession` or a transaction shares
+those clients and refuses.
+
+## API
+
+### `defineConfig(config)`
+
+Checks the configuration and freezes it. It connects to nothing and reads no
+environment variable: the application writes `uri: process.env.MONGO_URI!`,
+and what is wrong throws here, where the application starts.
+
+| Key | Default | |
+| --- | --- | --- |
+| `uri` | — | One of `uri` and `client`, never both. |
+| `client` | — | A client the application opened. Never closed by the kit. |
+| `clientOptions` | `{}` | Passed to the driver with `uri`. Refused with `client`. |
+| `database` | the URI's, else `test` | The database's name. |
+| `collections` | — | `import * as collections from './models'`. |
+| `options` | `{}` | `@nxgt/mongo`'s collection options, for every collection. |
+| `optionsFor` | `{}` | The same, per key, merged over `options`. |
+| `autoSync` | `false` | Sync each collection before its first operation. |
+
+`db`, `session`, `actor` and `autoSync` are not collection options here: the
+kit decides them, and one of them under `options` does not compile, while one
+under `optionsFor` is refused by `defineConfig` — the types cannot see that
+deep. Several databases go under `databases: { main: …, … }`, each one taking
+the same keys; a lone database is named `default`.
+
+### `createKit(config)`
+
+Opens what the configuration describes, and gives a `MongoKit`:
+
+| Member | |
+| --- | --- |
+| `db` | The only database's scope; `never` with several, and it throws if read anyway. |
+| `databases` | Every scope, under its name — `default` when the config named none. |
+| `clients` | The `MongoClient` of each database, under the same names. |
+| `actor`, `session` | What this kit stamps and runs in, if anything. |
+| `as(actor)` | The same kit, stamping that actor. |
+| `withSession(session)` | The same kit, in that session; `undefined` takes it away. |
+| `transaction(fn, options?)` | `fn` with a kit in a transaction. May run twice. |
+| `sync(options?)` | `SyncReport[]` per database, under its name. |
+| `close()` | Gives back what it opened. Idempotent. |
+
+`KitOf<typeof config>` is that kit's type, for an application that declares
+it — a service holding the kit, say — rather than reading it off `await
+createKit(…)`.
+
+### `discoverCollections({ glob, cwd?, export? })`
+
+The definitions of the files a glob matches, read at run time and untyped.
+`cwd` is where the glob starts, `process.cwd()` by default. `export` reads
+one export by name in each file, and throws for a matched file that has no
+definition under it; without `export`, every export that is a definition is
+taken. Two files defining the same server collection are refused. It needs
+the Bun runtime, and it is for scripts.
+
+## What does not compile
+
+Each is a `@ts-expect-error` case in this package's type tests.
+
+- A collection wired under a name the driver's `Db` already has
+  (`command`, `watch`, `collection`, …): it would be unreachable.
+- `db.usrs`, or a field no schema has in a `create`.
+- `kit.db` when the kit holds several databases, `kit.databases.nowhere`,
+  or `{ on: 'nowhere' }`.
+- `optionsFor` under a key no collection is wired under.
+- `session`, `db`, `actor` or `autoSync` under `options`. Under
+  `optionsFor`, the same four are refused by `defineConfig` instead.
+- `as` with an actor of the wrong type, and `as` at all when the
+  collections stamp none or disagree.
+
+## Traps
+
+- **A key the driver's `Db` has is refused twice**: by the types where the
+  config is written, and by `createKit` against the object itself — which is
+  what catches a member a later driver release adds.
+- **The scope is a `Db` underneath.** `Object.keys(kit.db)` lists the
+  collections, not the driver's members; a driver method read off it is
+  bound, so `const { command } = kit.db` works.
+- **`createKit` connects.** `defineConfig` does not, so a wrong URI throws
+  where the kit is created, and a database that fails gives back every
+  connection opened before it.
+- **A client the config gave is never closed**, including by `await using`.
+  Close it where it was opened.
+- **`autoSync` is for tests and development.** In production `sync()` is a
+  deployment step: it needs `dbAdmin`, and an index build is not in a
+  transaction.
+- **A kit from `as` or `withSession` cannot be closed**, and `close()` on it
+  throws: the clients are the root kit's.
+- **`discoverCollections` runs under Bun**, has no types, and does not
+  survive bundling. It is for scripts run from the repository; a Node script
+  calling it gets `Bun is not defined`.
+- **Two collections that stamp actors of different types** leave `as`
+  uncallable: one call could not stamp both.
+- **`{ on }` is required at run time, not by the types**, and cannot be: two
+  databases on one URI share a client and need none, so what decides is the
+  number of *clients*. Without it, a kit holding two throws.
+- **A transaction body may run twice.** The driver retries it from the start
+  on a transient error, so it must hold nothing that MongoDB would not roll
+  back.
+- **A transaction reaches one client's databases.** With `{ on: 'main' }`,
+  an operation on a database of another client carries a session that client
+  does not own, and the driver refuses it.
+- **`kit.db` throws on a kit with several databases**, where its type is
+  already `never`: the message names the databases to read instead.
+
+## License
+
+MIT

package/dist/config/checks.d.ts

@@ -0,0 +1,9 @@
+import type { AnyCollectionDefinition } from '@nxgt/mongo';
+import type { DatabaseConfig } from './types';
+/** A definition, told by its shape: `instanceof` has no class to ask. */
+export declare function isDefinition(value: unknown): value is AnyCollectionDefinition;
+/** The definitions of a module object, under the keys they are exported by. */
+export declare function definitionsOf(collections: object): [string, AnyCollectionDefinition][];
+/** Everything one database's config must answer before anything connects. */
+export declare function checkDatabase(name: string, config: DatabaseConfig<object>): [string, AnyCollectionDefinition][];
+//# sourceMappingURL=checks.d.ts.map

package/dist/config/checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.d.ts","sourceRoot":"","sources":["../../src/config/checks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,yEAAyE;AACzE,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,uBAAuB,CAU7E;AAED,+EAA+E;AAC/E,wBAAgB,aAAa,CAC5B,WAAW,EAAE,MAAM,GACjB,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAAE,CAKrC;AA6BD,6EAA6E;AAC7E,wBAAgB,aAAa,CAC5B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,cAAc,CAAC,MAAM,CAAC,GAC5B,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAAE,CA8DrC"}

package/dist/config/define-config.d.ts

@@ -0,0 +1,30 @@
+import type { Checked, KitConfig, KitConfigInput } from './types';
+/**
+ * The configuration of an application's MongoDB, checked once and frozen.
+ *
+ * ```ts
+ * import * as collections from './models';
+ *
+ * export const config = defineConfig({
+ * 	uri: process.env.MONGO_URI!,
+ * 	collections,
+ * });
+ * ```
+ *
+ * Several databases name themselves:
+ *
+ * ```ts
+ * defineConfig({
+ * 	databases: {
+ * 		main: { uri: process.env.MONGO_URI!, collections },
+ * 		analytics: { uri: process.env.ANALYTICS_URI!, collections: events },
+ * 	},
+ * });
+ * ```
+ *
+ * It connects to nothing and reads no environment variable: what is wrong
+ * with the configuration throws here, where the application starts, and the
+ * variables are the application's to read.
+ */
+export declare function defineConfig<const C extends KitConfigInput>(config: C & Checked<C>): KitConfig<C>;
+//# sourceMappingURL=define-config.d.ts.map

package/dist/config/define-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-config.d.ts","sourceRoot":"","sources":["../../src/config/define-config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,OAAO,EAEP,SAAS,EACT,cAAc,EACd,MAAM,SAAS,CAAC;AAuBjB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,CAAC,KAAK,CAAC,CAAC,SAAS,cAAc,EAC1D,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GACpB,SAAS,CAAC,CAAC,CAAC,CAQd"}

package/dist/config/types.d.ts

@@ -0,0 +1,124 @@
+import type { AnyCollectionDefinition, CollectionOptions } from '@nxgt/mongo';
+import type { Db, MongoClient, MongoClientOptions } from 'mongodb';
+/**
+ * The collections of a module, as `import * as collections` gives them: its
+ * other exports — types are gone already, and a function or a constant is no
+ * definition — are left out of the scope rather than refused.
+ */
+export type CollectionsOf<C> = {
+    [K in keyof C as C[K] extends AnyCollectionDefinition ? K : never]: C[K];
+};
+/**
+ * A name the driver's `Db` already uses. The scope carries the collections
+ * over a `Db`, so a collection under one of these names would be unreachable
+ * — and `db.watch` would answer something other than what a caller expects.
+ *
+ * Read from the driver's own type, never from a list of ours: a member the
+ * driver adds is covered the day the pin moves. At run time the same question
+ * is asked of the object itself, with `in`.
+ */
+export type ReservedName = keyof Db;
+/** The keys of `C` that a `Db` already answers to. */
+export type Collides<C> = Extract<keyof CollectionsOf<C>, ReservedName>;
+/**
+ * Makes a colliding key unassignable, and says why where the developer is
+ * looking: under that key, the value would have to be a string no definition
+ * is.
+ */
+export type NoCollision<C> = [Collides<C>] extends [never] ? unknown : {
+    [K in Collides<C>]: `"${K & string}" is a member of the driver's Db: wire this collection under another key`;
+};
+/**
+ * Makes options written for a key no collection is wired under unassignable,
+ * and says so under that key — the same shape as `NoCollision`.
+ */
+export type Unwired<Cols, OF> = [
+    Exclude<keyof OF, keyof CollectionsOf<Cols>>
+] extends [never] ? unknown : {
+    [K in Exclude<keyof OF, keyof CollectionsOf<Cols>>]: `"${K & string}" is not wired by this database: there are no options for it`;
+};
+/** The options of one collection, minus what the kit decides itself. */
+export type KitCollectionOptions<Def> = Omit<CollectionOptions<Def>, 'db' | 'session' | 'actor' | 'autoSync'>;
+/** One database: where it is, and what it holds. */
+export interface DatabaseConfig<C> {
+    /**
+     * Where to connect. One of `uri` and `client`, never both. Databases on
+     * one URI share a client, which the kit closes with its last holder.
+     */
+    uri?: string;
+    /**
+     * A client the application opened. The kit uses it and **never closes
+     * it**: what it did not open is not its to close.
+     */
+    client?: MongoClient;
+    /** Passed to the driver with `uri`. Refused with `client`, which has its own. */
+    clientOptions?: MongoClientOptions;
+    /** The database's name. Default: the one the URI names, or `test`. */
+    database?: string;
+    /** `import * as collections from './models'`, passed as it is. */
+    collections: C;
+    /** For every collection of this database. */
+    options?: KitCollectionOptions<AnyCollectionDefinition>;
+    /** For one collection, merged over `options`. */
+    optionsFor?: {
+        [K in keyof CollectionsOf<C>]?: KitCollectionOptions<CollectionsOf<C>[K]>;
+    };
+    /**
+     * Sync each collection before its first operation, once per database:
+     * `@nxgt/mongo`'s `autoSync`. For tests and development, never for
+     * production, where `sync()` is a deployment step.
+     */
+    autoSync?: boolean;
+}
+/** One database, or several under their names. */
+export type KitConfigInput = DatabaseConfig<object> | {
+    databases: Record<string, DatabaseConfig<object>>;
+};
+/**
+ * The config with every key it has to refuse — one the driver's `Db` already
+ * answers to, or options for a collection that is not wired — turned into the
+ * message above. `defineConfig` takes its argument as `C & Checked<C>`, and a
+ * constraint written that way is what makes the refusal land on the key the
+ * application wrote, rather than on the whole object.
+ */
+export type Checked<C> = C extends {
+    databases: infer D;
+} ? {
+    databases: {
+        [N in keyof D]: CheckedDatabase<D[N]>;
+    };
+} : CheckedDatabase<C>;
+/** One database's collections, and the options written for them. */
+type CheckedDatabase<D> = D extends {
+    collections: infer Cols;
+} ? {
+    collections: Cols & NoCollision<Cols>;
+} & (D extends {
+    optionsFor: infer OF;
+} ? {
+    optionsFor: OF & Unwired<Cols, OF>;
+} : unknown) : D;
+/** The databases of a config, whichever of the two shapes it was written in. */
+export type DatabasesOf<C> = C extends {
+    databases: infer D;
+} ? D : {
+    default: C;
+};
+/** The name of every database. */
+export type DbName<C> = keyof DatabasesOf<C> & string;
+/** The collections of one database, as they were passed. */
+export type CollectionsIn<C, N extends DbName<C>> = DatabasesOf<C>[N] extends {
+    collections: infer Cols;
+} ? Cols : never;
+/**
+ * What `defineConfig` gives back: the databases under their names, checked
+ * and frozen, carrying the shape it was written in — which is what decides
+ * whether the kit has a `db` of its own.
+ */
+export interface KitConfig<C> {
+    readonly databases: {
+        readonly [N in DbName<C>]: DatabaseConfig<CollectionsIn<C, N>>;
+    };
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/config/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":"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"}

package/dist/discover.d.ts

@@ -0,0 +1,37 @@
+import type { AnyCollectionDefinition } from '@nxgt/mongo';
+/** What to scan, and what to read in each file it finds. */
+export interface DiscoverOptions {
+    /** A glob, relative to `cwd`: `'src/models/*.model.ts'`. */
+    glob: string;
+    /** Where the glob starts. Default: the process's working directory. */
+    cwd?: string;
+    /**
+     * The export to read in each file. Default: every export that is a
+     * definition, which is what `import * as collections` gives.
+     */
+    export?: string;
+}
+/**
+ * The definitions of the files a glob matches, read at run time.
+ *
+ * For scripts — a sync or a migration run from the repository — and for
+ * nothing else: a glob is read from the file system, so it finds nothing
+ * once the application is bundled, and it produces **no types**. An
+ * application wires its collections with `import * as collections from
+ * './models'`, which a bundler follows and the compiler sees.
+ *
+ * ```ts
+ * import { connectMongo, syncCollections } from '@nxgt/mongo';
+ * import { discoverCollections } from '@nxgt/mongo-kit';
+ *
+ * const mongo = await connectMongo(process.env.MONGO_URI!);
+ * const definitions = await discoverCollections({ glob: 'src/**\/*.model.ts' });
+ * await syncCollections(mongo.db, definitions);
+ * await mongo.close();
+ * ```
+ *
+ * The files are imported, so their top level runs, and the glob is
+ * `Bun.Glob`: this one function needs the Bun runtime.
+ */
+export declare function discoverCollections(options: DiscoverOptions): Promise<AnyCollectionDefinition[]>;
+//# sourceMappingURL=discover.d.ts.map

package/dist/discover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../src/discover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAG3D,4DAA4D;AAC5D,MAAM,WAAW,eAAe;IAC/B,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,mBAAmB,CACxC,OAAO,EAAE,eAAe,GACtB,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAiCpC"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { defineConfig } from './config/define-config';
+export type { CollectionsIn, CollectionsOf, DatabaseConfig, DbName, KitCollectionOptions, KitConfig, KitConfigInput, NoCollision, ReservedName, Unwired, } from './config/types';
+export { type DiscoverOptions, discoverCollections } from './discover';
+export { createKit } from './kit/create-kit';
+export type { DbScope, KitActor, KitOf, KitTransactionOptions, MongoKit, SoleScope, } from './kit/types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,YAAY,EACX,aAAa,EACb,aAAa,EACb,cAAc,EACd,MAAM,EACN,oBAAoB,EACpB,SAAS,EACT,cAAc,EACd,WAAW,EACX,YAAY,EACZ,OAAO,GACP,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,KAAK,eAAe,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,YAAY,EACX,OAAO,EACP,QAAQ,EACR,KAAK,EACL,qBAAqB,EACrB,QAAQ,EACR,SAAS,GACT,MAAM,aAAa,CAAC"}