@rekal/mem 0.0.0

package/dist/index.d.mts

@@ -0,0 +1,1465 @@
+import * as _$node_fs0 from "node:fs";
+import { EventEmitter } from "node:events";
+import { inspect } from "node:util";
+import { Database } from "bun:sqlite";
+
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/union-to-intersection.d.ts
+/**
+Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void} & {great(arg: string): void} & {escape: boolean}
+```
+
+@category Type
+*/
+type UnionToIntersection<Union> = (// `extends unknown` is always going to be the case and is used to convert the
+// `Union` into a [distributive conditional
+// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+Union extends unknown // The union type is used as the only argument to a function since the union
+// of function arguments is an intersection.
+? (distributedUnion: Union) => void // This won't happen.
+: never // Infer the `Intersection` type since TypeScript represents the positional
+// arguments of unions of functions as an intersection of the union.
+) extends ((mergedIntersection: infer Intersection) => void) // The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
+? Intersection & Union : never;
+//#endregion
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/keys-of-union.d.ts
+/**
+Create a union of all keys from a given type, even those exclusive to specific union members.
+
+Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
+
+@link https://stackoverflow.com/a/49402091
+
+@example
+```
+import type {KeysOfUnion} from 'type-fest';
+
+type A = {
+	common: string;
+	a: number;
+};
+
+type B = {
+	common: string;
+	b: string;
+};
+
+type C = {
+	common: string;
+	c: boolean;
+};
+
+type Union = A | B | C;
+
+type CommonKeys = keyof Union;
+//=> 'common'
+
+type AllKeys = KeysOfUnion<Union>;
+//=> 'common' | 'a' | 'b' | 'c'
+```
+
+@category Object
+*/
+type KeysOfUnion<ObjectType> = // Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
+keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
+//#endregion
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/is-any.d.ts
+/**
+Returns a boolean for whether the given type is `any`.
+
+@link https://stackoverflow.com/a/49928360/1490091
+
+Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+@example
+```
+import type {IsAny} from 'type-fest';
+
+const typedObject = {a: 1, b: 2} as const;
+const anyObject: any = {a: 1, b: 2};
+
+function get<O extends (IsAny<O> extends true ? {} : Record<string, number>), K extends keyof O = keyof O>(object: O, key: K) {
+	return object[key];
+}
+
+const typedA = get(typedObject, 'a');
+//=> 1
+
+const anyA = get(anyObject, 'a');
+//=> any
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+//#endregion
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/is-optional-key-of.d.ts
+/**
+Returns a boolean for whether the given key is an optional key of type.
+
+This is useful when writing utility types or schema validators that need to differentiate `optional` keys.
+
+@example
+```
+import type {IsOptionalKeyOf} from 'type-fest';
+
+type User = {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+};
+
+type Admin = {
+	name: string;
+	surname?: string;
+};
+
+type T1 = IsOptionalKeyOf<User, 'luckyNumber'>;
+//=> true
+
+type T2 = IsOptionalKeyOf<User, 'name'>;
+//=> false
+
+type T3 = IsOptionalKeyOf<User, 'name' | 'luckyNumber'>;
+//=> boolean
+
+type T4 = IsOptionalKeyOf<User | Admin, 'name'>;
+//=> false
+
+type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
+//=> boolean
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsOptionalKeyOf<Type extends object, Key extends keyof Type> = IsAny<Type | Key> extends true ? never : Key extends keyof Type ? Type extends Record<Key, Type[Key]> ? false : true : false;
+//#endregion
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/optional-keys-of.d.ts
+/**
+Extract all optional keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the optional keys only.
+
+@example
+```
+import type {OptionalKeysOf, Except} from 'type-fest';
+
+type User = {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+};
+
+const REMOVE_FIELD = Symbol('remove field symbol');
+type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
+	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+};
+
+const update1: UpdateOperation<User> = {
+	name: 'Alice',
+};
+
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD,
+};
+```
+
+@category Utilities
+*/
+type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
+: never;
+//#endregion
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/required-keys-of.d.ts
+/**
+Extract all required keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
+
+@example
+```
+import type {RequiredKeysOf} from 'type-fest';
+
+declare function createValidation<
+	Entity extends object,
+	Key extends RequiredKeysOf<Entity> = RequiredKeysOf<Entity>,
+>(field: Key, validator: (value: Entity[Key]) => boolean): (entity: Entity) => boolean;
+
+type User = {
+	name: string;
+	surname: string;
+	luckyNumber?: number;
+};
+
+const validator1 = createValidation<User>('name', value => value.length < 25);
+const validator2 = createValidation<User>('surname', value => value.length < 25);
+
+// @ts-expect-error
+const validator3 = createValidation<User>('luckyNumber', value => value > 0);
+// Error: Argument of type '"luckyNumber"' is not assignable to parameter of type '"name" | "surname"'.
+```
+
+@category Utilities
+*/
+type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
+? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
+//#endregion
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/is-never.d.ts
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+type A = IsNever<never>;
+//=> true
+
+type B = IsNever<any>;
+//=> false
+
+type C = IsNever<unknown>;
+//=> false
+
+type D = IsNever<never[]>;
+//=> false
+
+type E = IsNever<object>;
+//=> false
+
+type F = IsNever<string>;
+//=> false
+```
+
+@example
+```
+import type {IsNever} from 'type-fest';
+
+type IsTrue<T> = T extends true ? true : false;
+
+// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
+type A = IsTrue<never>;
+//=> never
+
+// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
+type IsTrueFixed<T> =
+	IsNever<T> extends true ? false : T extends true ? true : false;
+
+type B = IsTrueFixed<never>;
+//=> false
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+//#endregion
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/if.d.ts
+/**
+An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
+
+Use-cases:
+- You can use this in combination with `Is*` types to create an if-else-like experience. For example, `If<IsAny<any>, 'is any', 'not any'>`.
+
+Note:
+- Returns a union of if branch and else branch if the given type is `boolean` or `any`. For example, `If<boolean, 'Y', 'N'>` will return `'Y' | 'N'`.
+- Returns the else branch if the given type is `never`. For example, `If<never, 'Y', 'N'>` will return `'N'`.
+
+@example
+```
+import type {If} from 'type-fest';
+
+type A = If<true, 'yes', 'no'>;
+//=> 'yes'
+
+type B = If<false, 'yes', 'no'>;
+//=> 'no'
+
+type C = If<boolean, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type D = If<any, 'yes', 'no'>;
+//=> 'yes' | 'no'
+
+type E = If<never, 'yes', 'no'>;
+//=> 'no'
+```
+
+@example
+```
+import type {If, IsAny, IsNever} from 'type-fest';
+
+type A = If<IsAny<unknown>, 'is any', 'not any'>;
+//=> 'not any'
+
+type B = If<IsNever<never>, 'is never', 'not never'>;
+//=> 'is never'
+```
+
+@example
+```
+import type {If, IsEqual} from 'type-fest';
+
+type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
+
+type A = IfEqual<string, string, 'equal', 'not equal'>;
+//=> 'equal'
+
+type B = IfEqual<string, number, 'equal', 'not equal'>;
+//=> 'not equal'
+```
+
+Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:
+
+@example
+```
+import type {If, IsEqual, StringRepeat} from 'type-fest';
+
+type HundredZeroes = StringRepeat<'0', 100>;
+
+// The following implementation is not tail recursive
+type Includes<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? If<IsEqual<First, Char>,
+			'found',
+			Includes<Rest, Char>>
+		: 'not found';
+
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type Fails = Includes<HundredZeroes, '1'>;
+//           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
+
+// However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
+type IncludesWithoutIf<S extends string, Char extends string> =
+	S extends `${infer First}${infer Rest}`
+		? IsEqual<First, Char> extends true
+			? 'found'
+			: IncludesWithoutIf<Rest, Char>
+		: 'not found';
+
+// Now, instantiations with long strings will work
+type Works = IncludesWithoutIf<HundredZeroes, '1'>;
+//=> 'not found'
+```
+
+@category Type Guard
+@category Utilities
+*/
+type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
+//#endregion
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/simplify.d.ts
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+declare function fn(object: Record<string, unknown>): void;
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+// @ts-expect-error
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see {@link SimplifyDeep}
+@category Object
+*/
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+//#endregion
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/is-equal.d.ts
+/**
+Returns a boolean for whether the two given types are equal.
+
+@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+Use-cases:
+- If you want to make a conditional branch based on the result of a comparison of two types.
+
+@example
+```
+import type {IsEqual} from 'type-fest';
+
+// This type returns a boolean for whether the given array includes the given item.
+// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+type Includes<Value extends readonly any[], Item> =
+	Value extends readonly [Value[0], ...infer rest]
+		? IsEqual<Value[0], Item> extends true
+			? true
+			: Includes<rest, Item>
+		: false;
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false : false;
+// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
+type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
+//#endregion
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/omit-index-signature.d.ts
+/**
+Omit any index signatures from the given object type, leaving only explicitly defined properties.
+
+This is the counterpart of `PickIndexSignature`.
+
+Use-cases:
+- Remove overly permissive signatures from third-party types.
+
+This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record<string, unknown>`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+(The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+```
+const indexed: Record<string, unknown> = {}; // Allowed
+
+// @ts-expect-error
+const keyed: Record<'foo', unknown> = {}; // Error
+// TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+```
+
+Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+```
+type Indexed = {} extends Record<string, unknown>
+	? '✅ `{}` is assignable to `Record<string, unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<string, unknown>`';
+
+type IndexedResult = Indexed;
+//=> '✅ `{}` is assignable to `Record<string, unknown>`'
+
+type Keyed = {} extends Record<'foo' | 'bar', unknown>
+	? '✅ `{}` is assignable to `Record<\'foo\' | \'bar\', unknown>`'
+	: '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`';
+
+type KeyedResult = Keyed;
+//=> '❌ `{}` is NOT assignable to `Record<\'foo\' | \'bar\', unknown>`'
+```
+
+Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+```
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
+};
+```
+
+...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
+
+```
+type OmitIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType
+	// Is `{}` assignable to `Record<KeyType, unknown>`?
+	as {} extends Record<KeyType, unknown>
+		? never // ✅ `{}` is assignable to `Record<KeyType, unknown>`
+		: KeyType // ❌ `{}` is NOT assignable to `Record<KeyType, unknown>`
+	]: ObjectType[KeyType];
+};
+```
+
+If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+@example
+```
+import type {OmitIndexSignature} from 'type-fest';
+
+type Example = {
+	// These index signatures will be removed.
+	[x: string]: any;
+	[x: number]: any;
+	[x: symbol]: any;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will remain.
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
+//=> {foo: 'bar'; qux?: 'baz'}
+```
+
+@see {@link PickIndexSignature}
+@category Object
+*/
+type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
+//#endregion
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/pick-index-signature.d.ts
+/**
+Pick only index signatures from the given object type, leaving out all explicitly defined properties.
+
+This is the counterpart of `OmitIndexSignature`.
+
+@example
+```
+import type {PickIndexSignature} from 'type-fest';
+
+declare const symbolKey: unique symbol;
+
+type Example = {
+	// These index signatures will remain.
+	[x: string]: unknown;
+	[x: number]: unknown;
+	[x: symbol]: unknown;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will be removed.
+	['kebab-case-key']: string;
+	[symbolKey]: string;
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleIndexSignature = PickIndexSignature<Example>;
+// {
+// 	[x: string]: unknown;
+// 	[x: number]: unknown;
+// 	[x: symbol]: unknown;
+// 	[x: `head-${string}`]: string;
+// 	[x: `${string}-tail`]: string;
+// 	[x: `head-${string}-tail`]: string;
+// 	[x: `${bigint}`]: string;
+// 	[x: `embedded-${number}`]: string;
+// }
+```
+
+@see {@link OmitIndexSignature}
+@category Object
+*/
+type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
+//#endregion
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/merge.d.ts
+// Merges two objects without worrying about index signatures.
+type SimpleMerge<Destination, Source> = Simplify<{ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source>;
+/**
+Merge two types into a new type. Keys of the second type overrides keys of the first type.
+
+This is different from the TypeScript `&` (intersection) operator. With `&`, conflicting property types are intersected, which often results in `never`. For example, `{a: string} & {a: number}` makes `a` become `string & number`, which resolves to `never`. With `Merge`, the second type's keys cleanly override the first, so `Merge<{a: string}, {a: number}>` gives `{a: number}` as expected. `Merge` also produces a flattened type (via `Simplify`), making it more readable in IDE tooltips compared to `A & B`.
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+type Foo = {
+	a: string;
+	b: number;
+};
+
+type Bar = {
+	a: number; // Conflicts with Foo['a']
+	c: boolean;
+};
+
+// With `&`, `a` becomes `string & number` which is `never`. Not what you want.
+type WithIntersection = (Foo & Bar)['a'];
+//=> never
+
+// With `Merge`, `a` is cleanly overridden to `number`.
+type WithMerge = Merge<Foo, Bar>['a'];
+//=> number
+```
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+type Foo = {
+	[x: string]: unknown;
+	[x: number]: unknown;
+	foo: string;
+	bar: symbol;
+};
+
+type Bar = {
+	[x: number]: number;
+	[x: symbol]: unknown;
+	bar: Date;
+	baz: boolean;
+};
+
+export type FooBar = Merge<Foo, Bar>;
+//=> {
+// 	[x: string]: unknown;
+// 	[x: number]: number;
+// 	[x: symbol]: unknown;
+// 	foo: string;
+// 	bar: Date;
+// 	baz: boolean;
+// }
+```
+
+Note: If you want a merge type that more accurately reflects the runtime behavior of object spread or `Object.assign`, refer to the {@link ObjectMerge} type.
+
+@see {@link ObjectMerge}
+@category Object
+*/
+type Merge<Destination, Source> = Destination extends unknown // For distributing `Destination`
+? Source extends unknown // For distributing `Source`
+? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen
+: never;
+// Should never happen
+type _Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
+//#endregion
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/internal/object.d.ts
+/**
+Works similar to the built-in `Pick` utility type, except for the following differences:
+- Distributes over union types and allows picking keys from any member of the union type.
+- Primitives types are returned as-is.
+- Picks all keys if `Keys` is `any`.
+- Doesn't pick `number` from a `string` index signature.
+
+@example
+```
+type ImageUpload = {
+	url: string;
+	size: number;
+	thumbnailUrl: string;
+};
+
+type VideoUpload = {
+	url: string;
+	duration: number;
+	encodingFormat: string;
+};
+
+// Distributes over union types and allows picking keys from any member of the union type
+type MediaDisplay = HomomorphicPick<ImageUpload | VideoUpload, "url" | "size" | "duration">;
+//=> {url: string; size: number} | {url: string; duration: number}
+
+// Primitive types are returned as-is
+type Primitive = HomomorphicPick<string | number, 'toUpperCase' | 'toString'>;
+//=> string | number
+
+// Picks all keys if `Keys` is `any`
+type Any = HomomorphicPick<{a: 1; b: 2} | {c: 3}, any>;
+//=> {a: 1; b: 2} | {c: 3}
+
+// Doesn't pick `number` from a `string` index signature
+type IndexSignature = HomomorphicPick<{[k: string]: unknown}, number>;
+//=> {}
+*/
+type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = { [P in keyof T as Extract<P, Keys>]: T[P] };
+/**
+Merges user specified options with default options.
+
+@example
+```
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: true};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//=> {maxRecursionDepth: 10; leavesOnly: true}
+```
+
+@example
+```
+// Complains if default values are not provided for optional options
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
+```
+
+@example
+```
+// Complains if an option's default type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+
+@example
+```
+// Complains if an option's specified type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: 'yes'};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                                                   ~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+*/
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key]: SpecifiedOptions[Key] }> & Required<Options>>>>;
+//#endregion
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/except.d.ts
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', string>;
+//=> never
+```
+
+@example
+```
+type Filtered = Filter<'bar', 'foo'>;
+//=> 'bar'
+```
+
+@see {Except}
+*/
+type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : (KeyType extends ExcludeType ? never : KeyType);
+type ExceptOptions = {
+  /**
+  Disallow assigning non-specified properties.
+  	Note that any omitted properties in the resulting type will be present in autocomplete as `undefined`.
+  	@default false
+  */
+  requireExactProps?: boolean;
+};
+type DefaultExceptOptions = {
+  requireExactProps: false;
+};
+/**
+Create a type from an object type without certain keys.
+
+We recommend setting the `requireExactProps` option to `true`.
+
+This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+
+This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
+
+@example
+```
+import type {Except} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b: string;
+};
+
+type FooWithoutA = Except<Foo, 'a'>;
+//=> {b: string}
+
+// @ts-expect-error
+const fooWithoutA: FooWithoutA = {a: 1, b: '2'};
+// errors: 'a' does not exist in type '{ b: string; }'
+
+type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
+//=> {a: number} & Partial<Record<'b', never>>
+
+// @ts-expect-error
+const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
+// errors at 'b': Type 'string' is not assignable to type 'undefined'.
+
+// The `Omit` utility type doesn't work when omitting specific keys from objects containing index signatures.
+
+// Consider the following example:
+
+type UserData = {
+	[metadata: string]: string;
+	email: string;
+	name: string;
+	role: 'admin' | 'user';
+};
+
+// `Omit` clearly doesn't behave as expected in this case:
+type PostPayload = Omit<UserData, 'email'>;
+//=> {[x: string]: string; [x: number]: string}
+
+// In situations like this, `Except` works better.
+// It simply removes the `email` key while preserving all the other keys.
+type PostPayloadFixed = Except<UserData, 'email'>;
+//=> {[x: string]: string; name: string; role: 'admin' | 'user'}
+```
+
+@category Object
+*/
+type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = _Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
+type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType] } & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
+//#endregion
+//#region ../../node_modules/.bun/type-fest@5.5.0/node_modules/type-fest/source/set-optional.d.ts
+/**
+Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.
+
+Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are optional.
+
+@example
+```
+import type {SetOptional} from 'type-fest';
+
+type Foo = {
+	a: number;
+	b?: string;
+	c: boolean;
+};
+
+type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
+//=> {a: number; b?: string; c?: boolean}
+```
+
+@category Object
+*/
+type SetOptional<BaseType, Keys extends keyof BaseType> = (BaseType extends ((...arguments_: never) => any) ? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType> : unknown) & _SetOptional<BaseType, Keys>;
+type _SetOptional<BaseType, Keys extends keyof BaseType> = BaseType extends unknown // To distribute `BaseType` when it's a union type.
+? Simplify< // Pick just the keys that are readonly from the base type.
+Except<BaseType, Keys> & // Pick the keys that should be mutable from the base type and make them mutable.
+Partial<HomomorphicPick<BaseType, Keys>>> : never;
+//#endregion
+//#region src/log.d.ts
+type LogLevel = (typeof LOG_LEVELS)[number];
+type LogFn<T = void> = (...msg: unknown[]) => T;
+type Logger<T = void> = Record<LogLevel, LogFn<T>>;
+declare const LOG_LEVELS: readonly ["cancel", "info", "success", "warn", "error", "debug", "fatal", "prompt", "log", "trace"];
+declare function isLogLevel(level: string): level is LogLevel;
+declare function shouldLog(level: string, minLevel?: LogLevel): boolean;
+declare abstract class LoggerBase<T = void> implements Logger<T> {
+  cancel: LogFn<T>;
+  info: LogFn<T>;
+  success: LogFn<T>;
+  warn: LogFn<T>;
+  error: LogFn<T>;
+  debug: LogFn<T>;
+  fatal: LogFn<T>;
+  prompt: LogFn<T>;
+  log: LogFn<T>;
+  trace: LogFn<T>;
+  constructor();
+  protected abstract _log(level: LogLevel, ...msg: unknown[]): T;
+}
+//#endregion
+//#region src/runtime.node.d.ts
+declare function parseYaml(content: string): unknown;
+//#endregion
+//#region src/util.d.ts
+declare function hash(content: string): string;
+declare function toError(err: unknown): Error;
+type Events = Record<string, unknown[]>;
+type TypedEmitter<T extends Events> = {
+  on<K extends keyof T>(event: K, fn: (...args: T[K]) => void): TypedEmitter<T>;
+  off<K extends keyof T>(event: K, fn: (...args: T[K]) => void): TypedEmitter<T>;
+  once<K extends keyof T>(event: K, fn: (...args: T[K]) => void): TypedEmitter<T>;
+  emit<K extends keyof T>(event: K, ...args: T[K]): boolean;
+};
+//#endregion
+//#region src/progress.d.ts
+type ProgressOpts = {
+  max?: number;
+  status?: string;
+  value?: number;
+};
+type ProgressEvents = {
+  update: [progress: Progress];
+  done: [progress: Progress];
+};
+declare const Progress_base: new () => TypedEmitter<ProgressEvents>;
+declare class Progress extends Progress_base {
+  #private;
+  name: string;
+  constructor(name: string, opts?: ProgressOpts);
+  get group(): boolean;
+  set(opts: ProgressOpts | number): this;
+  get status(): string;
+  set status(status: string);
+  set value(value: number);
+  get value(): number;
+  set max(max: number);
+  get max(): number;
+  get done(): boolean;
+  get ratio(): number;
+  get pct(): number;
+  stop(): void;
+  children(): Progress[];
+  child(name: string, opts?: ProgressOpts): Progress;
+  [inspect.custom](_depth: number, _options: object): string;
+  toString(indent?: number): string;
+}
+//#endregion
+//#region src/md.d.ts
+type MarkdownSection = {
+  content: string[];
+  context: string[]; /** full heading text with markdown syntax, e.g. "## Section 1.2" */
+  headingText: string; /** heading without markdown syntax, e.g. "Section 1.2" */
+  heading: string;
+  level: number;
+  offset: number;
+};
+type MarkdownDoc = {
+  body: string;
+  bodyOffset: number;
+  frontmatter: Frontmatter;
+  frontmatterText?: string;
+  sections: MarkdownSection[];
+  text: string;
+};
+type Frontmatter = Record<string, unknown>;
+declare function parseFrontmatter(text: string): Omit<MarkdownDoc, "sections">;
+declare function parseMarkdown(text: string): MarkdownDoc;
+declare function parseSections(md: string): MarkdownSection[];
+declare function chunkText(text: string, tok: TokenCounter, size?: number): string[];
+declare function chunkMarkdown(md: string, tok: TokenCounter, size?: number): string[];
+//#endregion
+//#region src/doc.d.ts
+type DocFrontmatter = {
+  description?: string;
+  tags?: string[];
+  entities?: string[];
+} & Frontmatter;
+type DocHeading = {
+  level: number;
+  text: string;
+};
+declare class Doc {
+  #private;
+  uri: string;
+  path: string;
+  hash: string;
+  updated: Date;
+  headings: DocHeading[];
+  parsed: MarkdownDoc;
+  protected constructor(uri: string, path: string);
+  /** Full original markdown text, including frontmatter. */
+  get text(): string;
+  /** Markdown body without frontmatter. */
+  get body(): string;
+  /** Parsed frontmatter as an object. */
+  get fm(): DocFrontmatter;
+  /** Name of the doc, derived from the file or folder name, without extension */
+  get name(): string;
+  get $description(): string | undefined;
+  /** Desc from frontmatter or packed from headings. */
+  get description(): string | undefined;
+  /** Title from fontmatter or first heading */
+  get $title(): string | undefined;
+  /** `$title` if it doesn't contain the name, otherwise `name - $title` */
+  get title(): string;
+  get tags(): string[];
+  get entities(): string[];
+  get isDir(): boolean;
+  protected load(): Promise<Doc | undefined>;
+  static load(entry: string | VfsEntry): Promise<Doc | undefined>;
+  static load(uri: string, path?: string): Promise<Doc | undefined>;
+}
+//#endregion
+//#region src/vfs.d.ts
+declare class Node {
+  uri: string;
+  doc: Doc;
+  constructor(uri: string, doc: Doc);
+}
+type VfsFolder = {
+  uri: string;
+  path: string;
+  merge?: boolean;
+};
+type VfsEntry = {
+  uri: string;
+  path?: string;
+};
+type VfsPath = {
+  node: VfsNode;
+  path: string;
+};
+type VfsNode = {
+  name: string;
+  parent?: VfsNode;
+  uri: string;
+  paths: string[];
+  depth: number;
+  children: Map<string, VfsNode>;
+};
+type VfsFindOptions = {
+  /** URI to start from, defaults to root */uri?: string;
+  depth?: number;
+  pattern?: string;
+  ignoreCase?: boolean;
+  limit?: number;
+  type?: "file" | "directory";
+};
+type VfsView = {
+  uri: string;
+  node: VfsNode;
+  paths: VfsPath[];
+};
+type VfsScope = VfsView & {
+  map: (path: string) => string | undefined;
+};
+declare class Vfs {
+  #private;
+  ctx: Context;
+  constructor(ctx: Context);
+  get folders(): VfsFolder[];
+  isFolder(path: string): boolean;
+  getScope(uri?: string, opts?: {
+    children?: boolean;
+  }): VfsScope;
+  getNode(uri: string, create?: boolean): VfsNode;
+  resolve(node: VfsNode | string, opts?: {
+    children?: boolean;
+  }): VfsView;
+  addFolder(folder: VfsFolder): void;
+  matcher(opts?: VfsFindOptions): (uri: string) => boolean;
+  find(opts?: VfsFindOptions): AsyncGenerator<VfsEntry>;
+  ls(opts?: Omit<VfsFindOptions, "depth">): AsyncGenerator<VfsEntry, void, any>;
+  /** Normalizes the URI and path to a real path if it exists **/
+  normPath(p: VfsPath): VfsEntry;
+}
+//#endregion
+//#region src/search.d.ts
+type SearchMode = "hybrid" | "vec" | "fts";
+type SearchScore = {
+  score: number;
+  display_score?: number;
+  rank: number;
+};
+type SearchResult = {
+  uri: string;
+  path: string;
+  doc: DocRow;
+  scores: Partial<Record<SearchMode, SearchScore>>;
+  match: {
+    fts?: FTSResult;
+    vec?: VecResult;
+  };
+} & VfsEntry;
+type SearchResultMap = {
+  hybrid: HybridSR;
+  vec: VecSR;
+  fts: FtsSR;
+};
+type HybridSR = SearchResult & {
+  scores: {
+    hybrid: SearchScore;
+  };
+};
+type VecSR = SearchResult & {
+  scores: {
+    vec: SearchScore;
+  };
+  match: {
+    vec: VecResult;
+  };
+};
+type FtsSR = SearchResult & {
+  scores: {
+    fts: SearchScore;
+  };
+  match: {
+    fts: FTSResult;
+  };
+};
+type SearchOptions = {
+  limit?: number;
+  uri?: string;
+  mode?: SearchMode;
+};
+type FtsSearchOptions = Omit<SearchOptions, "mode"> & {
+  op?: "AND" | "OR";
+};
+declare class Search {
+  db: Db;
+  ctx: Context;
+  private constructor();
+  static load(ctx: Context): Promise<Search>;
+  search(query: string, opts?: SearchOptions): Promise<SearchResult[]>;
+  searchVec(query: string, opts?: Omit<SearchOptions, "mode"> & {
+    slice?: boolean;
+  }): Promise<VecSR[]>;
+  searchFts(query: string, opts?: FtsSearchOptions): Promise<FtsSR[]>;
+  rank<M extends SearchMode>(mode: M, results: SearchResultMap[M][]): SearchResultMap[M][];
+  /** Reciprocal Rank Fusion: merge FTS and vector results */
+  private fuse;
+}
+//#endregion
+//#region src/store.d.ts
+type StoreChunk = EmbedderChunk & {
+  doc_id: number;
+  doc: Doc;
+};
+declare class Store {
+  db: Db;
+  ctx: Context;
+  private constructor();
+  static load(ctx: Context): Promise<Store>;
+  add(doc: Doc): number;
+  chunk(id: number, doc: Doc): Promise<StoreChunk[]>;
+  index(): Promise<Map<number, Doc>>;
+  embed(docs: Map<number, Doc>): Promise<void>;
+  sync(opts?: {
+    embed?: boolean;
+  }): Promise<void>;
+  prune(syncStart: string): Promise<void>;
+}
+//#endregion
+//#region src/context.d.ts
+type ContextEvents = {
+  log: [level: LogLevel, ...msg: unknown[]];
+  progress: [progress: Progress];
+};
+type ContextOptions = {
+  embedder?: EmbedderOptions;
+  folders?: VfsFolder[];
+  root?: string;
+};
+declare class Context extends LoggerBase {
+  #private;
+  opts: ContextOptions;
+  events: TypedEmitter<ContextEvents> & EventEmitter;
+  constructor(opts?: ContextOptions);
+  protected _log(level: LogLevel, ...msg: unknown[]): void;
+  get root(): string;
+  db(): Promise<Db>;
+  search(): Promise<Search>;
+  store(): Promise<Store>;
+  embedder(): Promise<Embedder>;
+  vfs(): Promise<Vfs>;
+}
+//#endregion
+//#region src/embed/base.d.ts
+declare class Embedder {
+  #private;
+  ctx: Context;
+  opts: ResolvedEmbedderOptions;
+  model: ResolvedEmbedderModel;
+  status: Progress;
+  constructor(ctx: Context);
+  info(): {
+    model: string;
+    backend: ModelBackend;
+    variant?: string;
+  };
+  backend(): Promise<EmbedderBackend>;
+  transform(input: string | EmbedderDoc | EmbedderChunk): string;
+  embed(input: string | EmbedderDoc | EmbedderChunk): Promise<number[]>;
+  embed(input: (string | EmbedderDoc | EmbedderChunk)[]): Promise<number[][]>;
+  chunk(input: string | EmbedderDoc): Promise<EmbedderChunk[]>;
+}
+//#endregion
+//#region src/embed/index.d.ts
+type TokenCounter = {
+  toks(input: string): number;
+};
+type EmbedderDevice = "cpu" | "gpu" | "api";
+interface EmbedderBackend extends TokenCounter {
+  device: EmbedderDevice;
+  maxTokens: number;
+  dims: number;
+  embed(input: string[]): Promise<number[][]>;
+}
+type EmbedderDoc = {
+  text: string;
+  title?: string;
+};
+type EmbedderPrompt = {
+  document?: (doc: EmbedderDoc) => string;
+  query?: (query: string) => string;
+};
+type EmbedderModel = {
+  uri: string;
+  base?: string;
+  models?: string[];
+  prompt?: EmbedderPrompt;
+  pooling?: "none" | "mean" | "cls" | "first_token" | "eos" | "last_token";
+};
+type ModelBackend = "transformers" | "llama" | "openai";
+type EmbedderContext = {
+  opts: ResolvedEmbedderOptions;
+  root: string;
+  status: Progress;
+  logger: Logger;
+};
+type EmbedderChunk = {
+  seq: number;
+  text: string;
+  prompt: string;
+  embedding?: number[];
+};
+type EmbedderOptions = {
+  batchSize?: number;
+  model?: EmbedderModel | string;
+  maxTokens?: number;
+  maxDims?: number;
+  threads?: number;
+  useGpu?: boolean;
+  onProgress?: (status: Progress) => void;
+};
+type ResolvedEmbedderModel = Merge<EmbedderModel, {
+  prompt: Required<EmbedderPrompt>;
+}>;
+type ResolvedEmbedderOptions = Merge<SetOptional<Required<EmbedderOptions>, "onProgress">, {
+  model: ResolvedEmbedderModel;
+}>;
+//#endregion
+//#region src/db.d.ts
+type DocRow = {
+  id: number;
+  path: string;
+  hash: string;
+  body: string;
+  vec_hash?: string;
+  description: string;
+  title: string;
+  tags: string;
+  entities: string;
+  updated_at: string;
+  synced_at?: string;
+  deadline?: number;
+};
+type VecResult = {
+  doc_id: number;
+  path: string;
+  seq: number;
+  distance: number;
+  score: number;
+  rank?: number;
+};
+type FTSResult = {
+  rowid: number;
+  score: number;
+  rank?: number;
+};
+type DbSearchOptions = {
+  limit?: number;
+  scope?: string[];
+};
+declare function hasEmbedding<T extends EmbedderChunk>(c: T): c is T & {
+  embedding: number[];
+};
+declare function assertEmbeddings<T extends EmbedderChunk>(chunks: T[]): asserts chunks is (T & {
+  embedding: number[];
+})[];
+declare class Db {
+  #private;
+  private constructor();
+  static load(dbPath: string): Promise<Db>;
+  private init;
+  reset(): void;
+  private initVec;
+  getDoc(from: string | number): DocRow | undefined;
+  getDocs(from?: (string | number)[]): Map<number, DocRow>;
+  addDoc(row: Omit<DocRow, "id">): number;
+  deleteDoc(id: number, tables?: {
+    docs?: boolean;
+    vec?: boolean;
+  }): void;
+  get vec(): {
+    exists: boolean;
+    dims?: number;
+    init?: boolean;
+  };
+  getStatus(): {
+    cache: number;
+    dbSize: number;
+    docs: number;
+    docsWithDescription: number;
+    lastSync: string | null;
+    unembedded: number;
+    vecDims: number | undefined;
+    vecs: number;
+    vocabTerms: number;
+  };
+  transaction<A extends any[], T>(fn: (...args: A) => T): {
+    (...args: A): T;
+    deferred: (...args: A) => T;
+    immediate: (...args: A) => T;
+    exclusive: (...args: A) => T;
+  };
+  getUnembeddedDocs(): DocRow[];
+  touchDoc(id: number): void;
+  markEmbedded(id: number, docHash: string): void;
+  /** Delete docs not seen since the given sync timestamp, optionally scoped to a path prefix. */
+  deleteStaleDocs(syncedBefore: string, prefix?: string): number;
+  /** Scoped FTS search: only match docs whose path starts with one of the given prefixes */
+  searchFts(query: string, opts?: DbSearchOptions): FTSResult[];
+  /** * Gets weights for high-frequency terms.
+   * Note: Truly common words will result in an IDF of 0 or less.
+   */
+  getStopWords(): Map<string, number>;
+  getWeights(terms: string[]): number[];
+  /** Insert embeddings into the vec table */
+  insertEmbeddings(chunks: StoreChunk[]): void;
+  /** Delete all vec entries for a doc */
+  deleteEmbeddings(docId: number): void;
+  /** Global KNN search, returns top results across all docs */
+  searchVec(embedding: number[], opts?: DbSearchOptions): VecResult[];
+  setDeadline(docId: number, deadline: number): void;
+  getMeta(key: string): string | undefined;
+  setMeta(key: string, value: string): void;
+  cacheGet<T>(key: string): T | undefined;
+  cacheSet<T>(key: string, value: T): T;
+  cachePrune(maxEntries?: number): void;
+}
+//#endregion
+//#region src/fs.d.ts
+declare function sstat(path: string): _$node_fs0.Stats | undefined;
+declare function astat(path: string): Promise<_$node_fs0.Stats | undefined>;
+declare function findUp(root: string, name: string, stop?: string): string | undefined;
+declare function normPath(...paths: string[]): string;
+declare function gitRoot(path: string): string | undefined;
+//#endregion
+//#region src/query.d.ts
+type Token$1 = {
+  type: "term";
+  value: string;
+  neg?: boolean;
+  req?: boolean;
+  field?: string;
+} | {
+  type: "op";
+  value: "AND" | "OR";
+} | {
+  type: "paren";
+  value: "(" | ")";
+};
+declare function tokenize(input: string): Token$1[];
+/** Build an FTS5 query string from user input */
+declare function toFts(input: string, defaultOp?: "AND" | "OR"): string;
+//#endregion
+//#region src/uri.d.ts
+declare const URI_PREFIX = "rekal://";
+declare function assertUri(uri: string): void;
+declare function normUri(uri?: string, dir?: boolean): string;
+declare function parentUri(uri: string): string | undefined;
+//#endregion
+//#region src/snippet.d.ts
+type Token = {
+  text: string;
+  lower: string;
+};
+type TokenWithScore = Token & {
+  score: number;
+};
+type SnippetOptions = {
+  query: string;
+  lines?: number;
+  stopWords?: Map<string, number>;
+};
+type SnippetWindow = {
+  start: number;
+  heat: number;
+  coverage: number;
+  score: number;
+};
+type SnippetResult = {
+  lines: string[];
+  tokens: Token[][];
+  scores: number[];
+  windows: SnippetWindow[];
+  best: SnippetWindow;
+  heat: number[];
+  snippet: string[];
+};
+declare const WORD_REGEX: RegExp;
+declare function isStopWord(word: string): boolean;
+declare class Snippet {
+  query: (Token & {
+    score: number;
+  })[];
+  prefixes: Set<string>;
+  prefixRegex: RegExp;
+  opts: Required<SnippetOptions>;
+  constructor(opts: SnippetOptions);
+  normalize(text: string): string;
+  tokenize(text: string, queryOnly?: boolean): Token[];
+  score(token: Token, queryToken: Token): number;
+  match(input: Token | string): TokenWithScore | undefined;
+  scores(tokens: Token[][]): {
+    coverage: Set<string>[];
+    scores: number[];
+  };
+  heat(lines: string[], scores: number[]): number[];
+  extract(text: string): SnippetResult;
+  debug(result: SnippetResult): void;
+  highlight(text: string, hl: (word: string, offset: number) => string): string;
+}
+//#endregion
+export { Context, ContextOptions, type Database, Db, DbSearchOptions, Doc, DocFrontmatter, DocRow, Embedder, EmbedderBackend, EmbedderChunk, EmbedderContext, EmbedderDevice, EmbedderDoc, EmbedderModel, EmbedderOptions, EmbedderPrompt, Events, FTSResult, Frontmatter, FtsSR, FtsSearchOptions, HybridSR, LOG_LEVELS, LogFn, LogLevel, Logger, LoggerBase, MarkdownDoc, MarkdownSection, ModelBackend, Node, Progress, ProgressOpts, ResolvedEmbedderModel, ResolvedEmbedderOptions, Search, SearchMode, SearchOptions, SearchResult, SearchScore, Snippet, SnippetOptions, SnippetResult, SnippetWindow, Store, StoreChunk, Token, TokenCounter, TokenWithScore, TypedEmitter, URI_PREFIX, VecResult, VecSR, Vfs, VfsEntry, VfsFindOptions, VfsFolder, VfsNode, VfsPath, VfsScope, VfsView, WORD_REGEX, assertEmbeddings, assertUri, astat, chunkMarkdown, chunkText, findUp, gitRoot, hasEmbedding, hash, isLogLevel, isStopWord, normPath, normUri, parentUri, parseFrontmatter, parseMarkdown, parseSections, parseYaml, shouldLog, sstat, toError, toFts, tokenize };