@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely/dist/esm/util/provide-controlled-connection.js

@@ -0,0 +1,22 @@
+/// <reference types="./provide-controlled-connection.d.ts" />
+import { Deferred } from './deferred.js';
+import { freeze } from './object-utils.js';
+export async function provideControlledConnection(connectionProvider) {
+    const connectionDefer = new Deferred();
+    const connectionReleaseDefer = new Deferred();
+    connectionProvider
+        .provideConnection(async (connection) => {
+        connectionDefer.resolve(connection);
+        return await connectionReleaseDefer.promise;
+    })
+        .catch((ex) => connectionDefer.reject(ex));
+    // Create composite of the connection and the release method instead of
+    // modifying the connection or creating a new nesting `DatabaseConnection`.
+    // This way we don't accidentally override any methods of 3rd party
+    // connections and don't return wrapped connections to drivers that
+    // expect a certain specific connection class.
+    return freeze({
+        connection: await connectionDefer.promise,
+        release: connectionReleaseDefer.resolve,
+    });
+}

package/dist/server/node_modules/kysely/dist/esm/util/query-id.d.ts

@@ -0,0 +1,4 @@
+export interface QueryId {
+    readonly queryId: string;
+}
+export declare function createQueryId(): QueryId;

package/dist/server/node_modules/kysely/dist/esm/util/query-id.js

@@ -0,0 +1,14 @@
+/// <reference types="./query-id.d.ts" />
+import { randomString } from './random-string.js';
+export function createQueryId() {
+    return new LazyQueryId();
+}
+class LazyQueryId {
+    #queryId;
+    get queryId() {
+        if (this.#queryId === undefined) {
+            this.#queryId = randomString(8);
+        }
+        return this.#queryId;
+    }
+}

package/dist/server/node_modules/kysely/dist/esm/util/random-string.d.ts

@@ -0,0 +1 @@
+export declare function randomString(length: number): string;

package/dist/server/node_modules/kysely/dist/esm/util/random-string.js

@@ -0,0 +1,75 @@
+/// <reference types="./random-string.d.ts" />
+const CHARS = [
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F',
+    'G',
+    'H',
+    'I',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'O',
+    'P',
+    'Q',
+    'R',
+    'S',
+    'T',
+    'U',
+    'V',
+    'W',
+    'X',
+    'Y',
+    'Z',
+    'a',
+    'b',
+    'c',
+    'd',
+    'e',
+    'f',
+    'g',
+    'h',
+    'i',
+    'j',
+    'k',
+    'l',
+    'm',
+    'n',
+    'o',
+    'p',
+    'q',
+    'r',
+    's',
+    't',
+    'u',
+    'v',
+    'w',
+    'x',
+    'y',
+    'z',
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+];
+export function randomString(length) {
+    let chars = '';
+    for (let i = 0; i < length; ++i) {
+        chars += randomChar();
+    }
+    return chars;
+}
+function randomChar() {
+    return CHARS[~~(Math.random() * CHARS.length)];
+}

package/dist/server/node_modules/kysely/dist/esm/util/require-all-props.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Utility type to force use of all properties of T.
+ *
+ * Similar to Required<T> build-in type, but allows `undefined` values.
+ */
+type AllProps<T> = T & {
+    [P in keyof T]-?: unknown;
+};
+/**
+ * Helper function to check listed properties according to given type. Check if all properties has been used when object is initialised.
+ *
+ * Example use:
+ *
+ * ```ts
+ * type SomeType = { propA: string; propB?: number; }
+ *
+ * // propB has to be mentioned even it is optional. It still should be initialized with undefined.
+ * const a: SomeType = requireAllProps<SomeType>({ propA: "value A", propB: undefined });
+ *
+ * // checked type is implicit for variable.
+ * const b = requireAllProps<SomeType>({ propA: "value A", propB: undefined });
+ * ```
+ *
+ * Wrong use of this helper:
+ *
+ * 1. Omit checked type - all checked properties will be expect as of type never
+ *
+ * ```ts
+ * type SomeType = { propA: string; propB?: number; }
+ * // const z: SomeType = requireAllProps({ propC: "no type will work" }); // Property 'propA' is missing in type '{ propC: string; }' but required in type 'SomeType'.
+ * ```
+ *
+ * 2. Apply to spreaded object - there is no way how to check in compile time if spreaded object contains all properties
+ *
+ * ```ts
+ * type SomeType = { propA: string; propB?: number; }
+ * const y: SomeType = { propA: "" }; // valid object according to SomeType declaration
+ * // const x = requireAllProps<SomeType>({ ...y }); // Argument of type '{ propA: string; propB?: number; }' is not assignable to parameter of type 'AllProps<SomeType>'.
+ * ```
+ *
+ * @param obj object to check if all properties has been used
+ * @returns untouched obj parameter is returned
+ */
+export declare function requireAllProps<T>(obj: AllProps<T>): T;
+export {};

package/dist/server/node_modules/kysely/dist/esm/util/require-all-props.js

@@ -0,0 +1,39 @@
+/// <reference types="./require-all-props.d.ts" />
+/**
+ * Helper function to check listed properties according to given type. Check if all properties has been used when object is initialised.
+ *
+ * Example use:
+ *
+ * ```ts
+ * type SomeType = { propA: string; propB?: number; }
+ *
+ * // propB has to be mentioned even it is optional. It still should be initialized with undefined.
+ * const a: SomeType = requireAllProps<SomeType>({ propA: "value A", propB: undefined });
+ *
+ * // checked type is implicit for variable.
+ * const b = requireAllProps<SomeType>({ propA: "value A", propB: undefined });
+ * ```
+ *
+ * Wrong use of this helper:
+ *
+ * 1. Omit checked type - all checked properties will be expect as of type never
+ *
+ * ```ts
+ * type SomeType = { propA: string; propB?: number; }
+ * // const z: SomeType = requireAllProps({ propC: "no type will work" }); // Property 'propA' is missing in type '{ propC: string; }' but required in type 'SomeType'.
+ * ```
+ *
+ * 2. Apply to spreaded object - there is no way how to check in compile time if spreaded object contains all properties
+ *
+ * ```ts
+ * type SomeType = { propA: string; propB?: number; }
+ * const y: SomeType = { propA: "" }; // valid object according to SomeType declaration
+ * // const x = requireAllProps<SomeType>({ ...y }); // Argument of type '{ propA: string; propB?: number; }' is not assignable to parameter of type 'AllProps<SomeType>'.
+ * ```
+ *
+ * @param obj object to check if all properties has been used
+ * @returns untouched obj parameter is returned
+ */
+export function requireAllProps(obj) {
+    return obj;
+}

package/dist/server/node_modules/kysely/dist/esm/util/stack-trace-utils.d.ts

@@ -0,0 +1 @@
+export declare function extendStackTrace(err: unknown, stackError: Error): unknown;

package/dist/server/node_modules/kysely/dist/esm/util/stack-trace-utils.js

@@ -0,0 +1,14 @@
+/// <reference types="./stack-trace-utils.d.ts" />
+import { isObject, isString } from './object-utils.js';
+export function extendStackTrace(err, stackError) {
+    if (isStackHolder(err) && stackError.stack) {
+        // Remove the first line that just says `Error`.
+        const stackExtension = stackError.stack.split('\n').slice(1).join('\n');
+        err.stack += `\n${stackExtension}`;
+        return err;
+    }
+    return err;
+}
+function isStackHolder(obj) {
+    return isObject(obj) && isString(obj.stack);
+}

package/dist/server/node_modules/kysely/dist/esm/util/streamable.d.ts

@@ -0,0 +1,29 @@
+export interface Streamable<O> {
+    /**
+     * Executes the query and streams the rows.
+     *
+     * The optional argument `chunkSize` defines how many rows to fetch from the database
+     * at a time. It only affects some dialects like PostgreSQL that support it.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const stream = db
+     *   .selectFrom('person')
+     *   .select(['first_name', 'last_name'])
+     *   .where('gender', '=', 'other')
+     *   .stream()
+     *
+     * for await (const person of stream) {
+     *   console.log(person.first_name)
+     *
+     *   if (person.last_name === 'Something') {
+     *     // Breaking or returning before the stream has ended will release
+     *     // the database connection and invalidate the stream.
+     *     break
+     *   }
+     * }
+     * ```
+     */
+    stream(chunkSize?: number): AsyncIterableIterator<O>;
+}

package/dist/server/node_modules/kysely/dist/esm/util/streamable.js

@@ -0,0 +1,2 @@
+/// <reference types="./streamable.d.ts" />
+export {};

package/dist/server/node_modules/kysely/dist/esm/util/type-error.d.ts

@@ -0,0 +1,3 @@
+export interface KyselyTypeError<E extends string> {
+    readonly __kyselyTypeError__: E;
+}

package/dist/server/node_modules/kysely/dist/esm/util/type-error.js

@@ -0,0 +1,2 @@
+/// <reference types="./type-error.d.ts" />
+export {};

package/dist/server/node_modules/kysely/dist/esm/util/type-utils.d.ts

@@ -0,0 +1,189 @@
+import type { InsertResult } from '../query-builder/insert-result.js';
+import type { DeleteResult } from '../query-builder/delete-result.js';
+import type { UpdateResult } from '../query-builder/update-result.js';
+import type { KyselyTypeError } from './type-error.js';
+import type { MergeResult } from '../query-builder/merge-result.js';
+/**
+ * Given a database type and a union of table names in that db, returns
+ * a union type with all possible column names.
+ *
+ * Example:
+ *
+ * ```ts
+ * interface Person {
+ *   id: number
+ * }
+ *
+ * interface Pet {
+ *   name: string
+ *   species: 'cat' | 'dog'
+ * }
+ *
+ * interface Movie {
+ *   stars: number
+ * }
+ *
+ * interface Database {
+ *   person: Person
+ *   pet: Pet
+ *   movie: Movie
+ * }
+ *
+ * type Columns = AnyColumn<Database, 'person' | 'pet'>
+ *
+ * // Columns == 'id' | 'name' | 'species'
+ * ```
+ */
+export type AnyColumn<DB, TB extends keyof DB> = {
+    [T in TB]: keyof DB[T];
+}[TB] & string;
+/**
+ * Extracts a column type.
+ */
+export type ExtractColumnType<DB, TB extends keyof DB, C> = {
+    [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
+}[TB];
+/**
+ * Given a database type and a union of table names in that db, returns
+ * a union type with all possible `table`.`column` combinations.
+ *
+ * Example:
+ *
+ * ```ts
+ * interface Person {
+ *   id: number
+ * }
+ *
+ * interface Pet {
+ *   name: string
+ *   species: 'cat' | 'dog'
+ * }
+ *
+ * interface Movie {
+ *   stars: number
+ * }
+ *
+ * interface Database {
+ *   person: Person
+ *   pet: Pet
+ *   movie: Movie
+ * }
+ *
+ * type Columns = AnyColumnWithTable<Database, 'person' | 'pet'>
+ *
+ * // Columns == 'person.id' | 'pet.name' | 'pet.species'
+ * ```
+ */
+export type AnyColumnWithTable<DB, TB extends keyof DB> = {
+    [T in TB]: `${T & string}.${keyof DB[T] & string}`;
+}[TB];
+/**
+ * Just like {@link AnyColumn} but with a ` as <string>` suffix.
+ */
+export type AnyAliasedColumn<DB, TB extends keyof DB> = `${AnyColumn<DB, TB>} as ${string}`;
+/**
+ * Just like {@link AnyColumnWithTable} but with a ` as <string>` suffix.
+ */
+export type AnyAliasedColumnWithTable<DB, TB extends keyof DB> = `${AnyColumnWithTable<DB, TB>} as ${string}`;
+/**
+ * Extracts the item type of an array.
+ */
+export type ArrayItemType<T> = T extends ReadonlyArray<infer I> ? I : never;
+export type SimplifySingleResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : O extends MergeResult ? O : Simplify<O> | undefined;
+export type SimplifyResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : O extends MergeResult ? O : Simplify<O>;
+export type Simplify<T> = DrainOuterGeneric<{
+    [K in keyof T]: T[K];
+} & {}>;
+/**
+ * Represents a database row whose column names and their types are unknown.
+ */
+export type UnknownRow = Record<string, unknown>;
+/**
+ * Makes all properties of object type `T` nullable.
+ */
+export type Nullable<T> = {
+    [P in keyof T]: T[P] | null;
+};
+/**
+ * Evaluates to `true` if `T` is `never`.
+ */
+export type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Evaluates to `true` if `T` is `any`.
+ */
+export type IsAny<T> = 0 extends T & 1 ? true : false;
+/**
+ * Evaluates to `true` if the types `T` and `U` are equal.
+ */
+export type Equals<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;
+export type NarrowPartial<O, T> = DrainOuterGeneric<T extends object ? {
+    [K in keyof O & string]: K extends keyof T ? T[K] extends NotNull ? Exclude<O[K], null> : T[K] extends O[K] ? T[K] : KyselyTypeError<`$narrowType() call failed: passed type does not exist in '${K}'s type union`> : O[K];
+} : never>;
+/**
+ * A type constant for marking a column as not null. Can be used with `$narrowPartial`.
+ *
+ * Example:
+ *
+ * ```ts
+ * import type { NotNull } from 'kysely'
+ *
+ * await db.selectFrom('person')
+ *   .where('nullable_column', 'is not', null)
+ *   .selectAll()
+ *   .$narrowType<{ nullable_column: NotNull }>()
+ *   .executeTakeFirstOrThrow()
+ * ```
+ */
+export type NotNull = {
+    readonly __notNull__: unique symbol;
+};
+export type SqlBool = boolean | 0 | 1;
+/**
+ * Utility to reduce depth of TypeScript's internal type instantiation stack.
+ *
+ * Example:
+ *
+ * ```ts
+ * type A<T> = { item: T }
+ *
+ * type Test<T> = A<
+ *   A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<T>>>>>>>>>>>>>>>>>>>>>>>>
+ * >
+ *
+ * // type Error = Test<number> // Type instantiation is excessively deep and possibly infinite.ts (2589)
+ * ```
+ *
+ * To fix this, we can use `DrainOuterGeneric`:
+ *
+ * ```ts
+ * type A<T> = DrainOuterGeneric<{ item: T }>
+ *
+ * type Test<T> = A<
+ *  A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<T>>>>>>>>>>>>>>>>>>>>>>>>
+ * >
+ *
+ * type Ok = Test<number> // Ok
+ * ```
+ */
+export type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never;
+export type ShallowRecord<K extends keyof any, T> = DrainOuterGeneric<{
+    [P in K]: T;
+}>;
+/**
+ * Dehydrates any root properties of an object that are not valid JSON types.
+ *
+ * For now, we catch anything in {@link StringsWhenDataTypeNotAvailable} and convert it to `string`.
+ */
+export type ShallowDehydrateObject<O> = {
+    [K in keyof O]: ShallowDehydrateValue<O[K]>;
+};
+/**
+ * Dehydrates a value when it is not a valid JSON type.
+ *
+ * For now, we catch anything in {@link StringsWhenDataTypeNotAvailable} and convert it to `string`,
+ * and anything in {@link NumbersWhenDataTypeNotAvailable} and convert it to `number`.
+ */
+export type ShallowDehydrateValue<T> = T extends null | undefined ? T : T extends (infer U)[] | null | undefined ? Array<ShallowDehydrateValue<U>> | Extract<T, null | undefined> : Exclude<T, StringsWhenDataTypeNotAvailable | NumbersWhenDataTypeNotAvailable> | ([Extract<T, NumbersWhenDataTypeNotAvailable>] extends [never] ? never : number) | ([Extract<T, StringsWhenDataTypeNotAvailable>] extends [never] ? never : string);
+export type StringsWhenDataTypeNotAvailable = Date | Uint8Array;
+export type NumbersWhenDataTypeNotAvailable = bigint | NumericString;
+export type NumericString = `${number}`;

package/dist/server/node_modules/kysely/dist/esm/util/type-utils.js

@@ -0,0 +1,2 @@
+/// <reference types="./type-utils.d.ts" />
+export {};

package/dist/server/node_modules/kysely/helpers/mssql.d.ts

@@ -0,0 +1 @@
+export * from '../dist/cjs/helpers/mssql.js'

package/dist/server/node_modules/kysely/helpers/mssql.js

@@ -0,0 +1 @@
+module.exports = require('../dist/cjs/helpers/mssql.js')

package/dist/server/node_modules/kysely/helpers/mysql.d.ts

@@ -0,0 +1 @@
+export * from '../dist/cjs/helpers/mysql.js'

package/dist/server/node_modules/kysely/helpers/mysql.js

@@ -0,0 +1 @@
+module.exports = require('../dist/cjs/helpers/mysql.js')

package/dist/server/node_modules/kysely/helpers/postgres.d.ts

@@ -0,0 +1 @@
+export * from '../dist/cjs/helpers/postgres.js'

package/dist/server/node_modules/kysely/helpers/postgres.js

@@ -0,0 +1 @@
+module.exports = require('../dist/cjs/helpers/postgres.js')

package/dist/server/node_modules/kysely/helpers/sqlite.d.ts

@@ -0,0 +1 @@
+export * from '../dist/cjs/helpers/sqlite.js'

package/dist/server/node_modules/kysely/helpers/sqlite.js

@@ -0,0 +1 @@
+module.exports = require('../dist/cjs/helpers/sqlite.js')

package/dist/server/node_modules/kysely/outdated-typescript.d.ts

@@ -0,0 +1,5 @@
+import type { KyselyTypeError } from './dist/cjs/util/type-error'
+
+declare const Kysely: KyselyTypeError<'The installed TypeScript version is outdated and cannot guarantee type-safety with Kysely. Please upgrade to version 4.6 or newer.'>
+declare const RawBuilder: KyselyTypeError<'The installed TypeScript version is outdated and cannot guarantee type-safety with Kysely. Please upgrade to version 4.6 or newer.'>
+declare const sql: KyselyTypeError<'The installed TypeScript version is outdated and cannot guarantee type-safety with Kysely. Please upgrade to version 4.6 or newer.'>

package/dist/server/node_modules/kysely/package.json

@@ -0,0 +1,143 @@
+{
+  "name": "kysely",
+  "version": "0.28.9",
+  "description": "Type safe SQL query builder",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/kysely-org/kysely.git"
+  },
+  "homepage": "https://kysely.dev",
+  "keywords": [
+    "query",
+    "builder",
+    "query builder",
+    "sql",
+    "typescript",
+    "postgres",
+    "postgresql",
+    "mysql",
+    "sqlite",
+    "mssql",
+    "ms sql server",
+    "sql server",
+    "type-safe",
+    "type-safety",
+    "plugins"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "typesVersions": {
+    "<4.6": {
+      "*": [
+        "outdated-typescript.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "helpers",
+    "outdated-typescript.d.ts"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/cjs/index.js"
+    },
+    "./helpers/postgres": {
+      "import": "./dist/esm/helpers/postgres.js",
+      "require": "./dist/cjs/helpers/postgres.js",
+      "default": "./dist/cjs/helpers/postgres.js"
+    },
+    "./helpers/mysql": {
+      "import": "./dist/esm/helpers/mysql.js",
+      "require": "./dist/cjs/helpers/mysql.js",
+      "default": "./dist/cjs/helpers/mysql.js"
+    },
+    "./helpers/mssql": {
+      "import": "./dist/esm/helpers/mssql.js",
+      "require": "./dist/cjs/helpers/mssql.js",
+      "default": "./dist/cjs/helpers/mssql.js"
+    },
+    "./helpers/sqlite": {
+      "import": "./dist/esm/helpers/sqlite.js",
+      "require": "./dist/cjs/helpers/sqlite.js",
+      "default": "./dist/cjs/helpers/sqlite.js"
+    }
+  },
+  "author": "Sami Koskimäki <sami@jakso.me>",
+  "license": "MIT",
+  "contributors": [
+    "Sami Koskimäki <sami@jakso.me>",
+    "Igal Klebanov <igalklebanov@gmail.com>"
+  ],
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.2",
+    "@ark/attest": "^0.55.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/chai": "^5.2.3",
+    "@types/chai-as-promised": "^8.0.2",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.10.1",
+    "@types/pg": "^8.15.6",
+    "@types/pg-cursor": "^2.7.2",
+    "@types/semver": "^7.7.1",
+    "@types/sinon": "^17.0.4",
+    "better-sqlite3": "^12.5.0",
+    "chai": "^6.2.1",
+    "chai-as-promised": "^8.0.2",
+    "esbuild": "^0.27.0",
+    "jsr": "^0.13.4",
+    "lodash": "^4.17.21",
+    "mocha": "^11.7.5",
+    "mysql2": "^3.15.3",
+    "pathe": "^2.0.3",
+    "pg": "^8.15.6",
+    "pg-cursor": "^2.14.6",
+    "pkg-types": "^2.3.0",
+    "playwright": "^1.57.0",
+    "prettier": "^3.7.3",
+    "semver": "^7.7.3",
+    "sinon": "^21.0.0",
+    "std-env": "^3.10.0",
+    "tarn": "^3.0.2",
+    "tedious": "^19.1.3",
+    "tsd": "^0.33.0",
+    "typescript": "~5.9.3"
+  },
+  "scripts": {
+    "clean": "rm -rf dist & rm -rf test/node/dist & rm -rf test/browser/bundle.js & rm -rf helpers",
+    "bench:ts": "pnpm build && cd ./test/ts-benchmarks && node --experimental-strip-types ./index.ts",
+    "test": "pnpm build && pnpm test:node:build && pnpm test:node:run && pnpm test:typings && pnpm test:esmimports && pnpm test:exports",
+    "test:node:build": "tsc -p test/node",
+    "test:node": "pnpm build && pnpm test:node:build && pnpm test:node:run",
+    "test:node:run": "mocha --timeout 15000 test/node/dist/**/*.test.js",
+    "test:browser:build": "rm -rf test/browser/bundle.js && esbuild test/browser/main.ts --bundle --outfile=test/browser/bundle.js",
+    "test:browser": "pnpm build && pnpm test:browser:build && node test/browser/test.js",
+    "test:bun": "pnpm build && bun link && cd test/bun && bun install && bun run test",
+    "test:cloudflare-workers": "pnpm build && pnpm -r test --filter kysely-cloudflare-workers-test",
+    "test:deno": "deno run --allow-env --allow-read --allow-net --no-lock test/deno/local.test.ts && deno run --allow-env --allow-read --allow-net --no-lock test/deno/cdn.test.ts",
+    "test:typings": "tsd test/typings",
+    "test:esmimports": "node scripts/check-esm-imports.js",
+    "test:esbuild": "esbuild --bundle --platform=node --external:pg-native dist/esm/index.js --outfile=/dev/null",
+    "test:exports": "attw --pack . && node scripts/check-exports.js",
+    "test:jsdocs": "deno check --doc-only --no-lock --unstable-sloppy-imports --config=\"deno.check.json\" ./src",
+    "test:outdatedts": "pnpm build && cd test/outdated-ts && pnpm i && pnpm test",
+    "lint:deno": "deno lint --config=\"deno.lint.json\" ./src",
+    "prettier": "prettier --write 'src/**/*.ts' 'test/**/*.ts'",
+    "build": "pnpm clean && (pnpm build:esm & pnpm build:cjs) && pnpm script:module-fixup && pnpm script:copy-interface-doc",
+    "build:esm": "tsc -p tsconfig.json && pnpm script:add-deno-type-references",
+    "build:cjs": "tsc -p tsconfig-cjs.json",
+    "script:module-fixup": "node scripts/module-fixup.js",
+    "script:copy-interface-doc": "node scripts/copy-interface-documentation.js",
+    "script:add-deno-type-references": "node scripts/add-deno-type-references.js",
+    "script:align-versions": "node --experimental-strip-types scripts/align-versions.mts",
+    "script:generate-site-examples": "node scripts/generate-site-examples.js",
+    "script:exclude-test-files-for-backwards-compat": "node --experimental-strip-types scripts/exclude-test-files-for-backwards-compat.mts",
+    "script:remove-global-augmentations": "node --experimental-strip-types scripts/remove-global-augmentations.mts",
+    "version": "pnpm script:align-versions && git add ."
+  }
+}

package/dist/server/node_modules/kysely-bun-worker/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 subframe7536
+
+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.