@keystrokehq/platform 0.1.1 → 0.1.2

package/dist/{start-BQ0b7Zex.cjs → start-Cm1hxyF_.cjs}

@@ -1,6 +1,4 @@
-const require_dist$2 = require("./dist-COpoWBp6.cjs");
-const require_dist$3 = require("./dist-BPaInPOA.cjs");
-const require_dist$4 = require("./dist-CW17n9gj.cjs");
+const require_dist$2 = require("./dist-DvjFaP47.cjs");
 require("./chunk-BZUGFHVS-7RRM7Jpb.cjs");
 const require_chunk_TN7HHBQW = require("./chunk-TN7HHBQW-D_SK6w5n.cjs");
 let node_fs = require("node:fs");
@@ -16,18 +14,17 @@ let better_auth = require("better-auth");
 let better_auth_plugins_bearer = require("better-auth/plugins/bearer");
 let better_auth_plugins_device_authorization = require("better-auth/plugins/device-authorization");
 let better_auth_plugins = require("better-auth/plugins");
-let _keystrokehq_database = require("@keystrokehq/database");
-let pg = require("pg");
-pg = require_dist$2.__toESM(pg, 1);
-require("node:url");
-let node_crypto = require("node:crypto");
-let node_async_hooks = require("node:async_hooks");
+let _keystrokehq_platform_database = require("@keystrokehq/platform-database");
 let better_auth_api = require("better-auth/api");
 let better_auth_plugins_magic_link = require("better-auth/plugins/magic-link");
 let resend = require("resend");
 let _keystrokehq_runtime = require("@keystrokehq/runtime");
 require("node:fs/promises");
+require("node:url");
+let _keystrokehq_database = require("@keystrokehq/database");
 let node_module = require("node:module");
+let node_crypto = require("node:crypto");
+let node_async_hooks = require("node:async_hooks");
 require("zod/v3");
 require("zod/v4-mini");
 let zod_v4 = require("zod/v4");
@@ -40,6 +37,8 @@ node_events = require_dist$2.__toESM(node_events, 1);
 let node_assert = require("node:assert");
 node_assert = require_dist$2.__toESM(node_assert, 1);
 let node_timers_promises = require("node:timers/promises");
+let pg = require("pg");
+pg = require_dist$2.__toESM(pg, 1);
 let _keystrokehq_http = require("@keystrokehq/http");
 let hono = require("hono");
 //#region ../../node_modules/.pnpm/jose@6.2.3/node_modules/jose/dist/webapi/lib/buffer_utils.js
@@ -1296,26 +1295,3017 @@ function createAuthJwtVerifier(authBaseUrl) {
 	});
 }
 //#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/entity.js
+const entityKind = Symbol.for("drizzle:entityKind");
+function is(value, type) {
+	if (!value || typeof value !== "object") return false;
+	if (value instanceof type) return true;
+	if (!Object.prototype.hasOwnProperty.call(type, entityKind)) throw new Error(`Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`);
+	let cls = Object.getPrototypeOf(value).constructor;
+	if (cls) while (cls) {
+		if (entityKind in cls && cls[entityKind] === type[entityKind]) return true;
+		cls = Object.getPrototypeOf(cls);
+	}
+	return false;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/column.js
+var Column = class {
+	constructor(table, config) {
+		this.table = table;
+		this.config = config;
+		this.name = config.name;
+		this.keyAsName = config.keyAsName;
+		this.notNull = config.notNull;
+		this.default = config.default;
+		this.defaultFn = config.defaultFn;
+		this.onUpdateFn = config.onUpdateFn;
+		this.hasDefault = config.hasDefault;
+		this.primary = config.primaryKey;
+		this.isUnique = config.isUnique;
+		this.uniqueName = config.uniqueName;
+		this.uniqueType = config.uniqueType;
+		this.dataType = config.dataType;
+		this.columnType = config.columnType;
+		this.generated = config.generated;
+		this.generatedIdentity = config.generatedIdentity;
+	}
+	static [entityKind] = "Column";
+	name;
+	keyAsName;
+	primary;
+	notNull;
+	default;
+	defaultFn;
+	onUpdateFn;
+	hasDefault;
+	isUnique;
+	uniqueName;
+	uniqueType;
+	dataType;
+	columnType;
+	enumValues = void 0;
+	generated = void 0;
+	generatedIdentity = void 0;
+	config;
+	mapFromDriverValue(value) {
+		return value;
+	}
+	mapToDriverValue(value) {
+		return value;
+	}
+	shouldDisableInsert() {
+		return this.config.generated !== void 0 && this.config.generated.type !== "byDefault";
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/column-builder.js
+var ColumnBuilder = class {
+	static [entityKind] = "ColumnBuilder";
+	config;
+	constructor(name, dataType, columnType) {
+		this.config = {
+			name,
+			keyAsName: name === "",
+			notNull: false,
+			default: void 0,
+			hasDefault: false,
+			primaryKey: false,
+			isUnique: false,
+			uniqueName: void 0,
+			uniqueType: void 0,
+			dataType,
+			columnType,
+			generated: void 0
+		};
+	}
+	/**
+	* Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
+	*
+	* @example
+	* ```ts
+	* const users = pgTable('users', {
+	* 	id: integer('id').$type<UserId>().primaryKey(),
+	* 	details: json('details').$type<UserDetails>().notNull(),
+	* });
+	* ```
+	*/
+	$type() {
+		return this;
+	}
+	/**
+	* Adds a `not null` clause to the column definition.
+	*
+	* Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
+	*/
+	notNull() {
+		this.config.notNull = true;
+		return this;
+	}
+	/**
+	* Adds a `default <value>` clause to the column definition.
+	*
+	* Affects the `insert` model of the table - columns *with* `default` are optional on insert.
+	*
+	* If you need to set a dynamic default value, use {@link $defaultFn} instead.
+	*/
+	default(value) {
+		this.config.default = value;
+		this.config.hasDefault = true;
+		return this;
+	}
+	/**
+	* Adds a dynamic default value to the column.
+	* The function will be called when the row is inserted, and the returned value will be used as the column value.
+	*
+	* **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+	*/
+	$defaultFn(fn) {
+		this.config.defaultFn = fn;
+		this.config.hasDefault = true;
+		return this;
+	}
+	/**
+	* Alias for {@link $defaultFn}.
+	*/
+	$default = this.$defaultFn;
+	/**
+	* Adds a dynamic update value to the column.
+	* The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
+	* If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
+	*
+	* **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
+	*/
+	$onUpdateFn(fn) {
+		this.config.onUpdateFn = fn;
+		this.config.hasDefault = true;
+		return this;
+	}
+	/**
+	* Alias for {@link $onUpdateFn}.
+	*/
+	$onUpdate = this.$onUpdateFn;
+	/**
+	* Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
+	*
+	* In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
+	*/
+	primaryKey() {
+		this.config.primaryKey = true;
+		this.config.notNull = true;
+		return this;
+	}
+	/** @internal Sets the name of the column to the key within the table definition if a name was not given. */
+	setName(name) {
+		if (this.config.name !== "") return;
+		this.config.name = name;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/table.utils.js
+const TableName = Symbol.for("drizzle:Name");
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/foreign-keys.js
+var ForeignKeyBuilder$1 = class {
+	static [entityKind] = "PgForeignKeyBuilder";
+	/** @internal */
+	reference;
+	/** @internal */
+	_onUpdate = "no action";
+	/** @internal */
+	_onDelete = "no action";
+	constructor(config, actions) {
+		this.reference = () => {
+			const { name, columns, foreignColumns } = config();
+			return {
+				name,
+				columns,
+				foreignTable: foreignColumns[0].table,
+				foreignColumns
+			};
+		};
+		if (actions) {
+			this._onUpdate = actions.onUpdate;
+			this._onDelete = actions.onDelete;
+		}
+	}
+	onUpdate(action) {
+		this._onUpdate = action === void 0 ? "no action" : action;
+		return this;
+	}
+	onDelete(action) {
+		this._onDelete = action === void 0 ? "no action" : action;
+		return this;
+	}
+	/** @internal */
+	build(table) {
+		return new ForeignKey$1(table, this);
+	}
+};
+var ForeignKey$1 = class {
+	constructor(table, builder) {
+		this.table = table;
+		this.reference = builder.reference;
+		this.onUpdate = builder._onUpdate;
+		this.onDelete = builder._onDelete;
+	}
+	static [entityKind] = "PgForeignKey";
+	reference;
+	onUpdate;
+	onDelete;
+	getName() {
+		const { name, columns, foreignColumns } = this.reference();
+		const columnNames = columns.map((column) => column.name);
+		const foreignColumnNames = foreignColumns.map((column) => column.name);
+		const chunks = [
+			this.table[TableName],
+			...columnNames,
+			foreignColumns[0].table[TableName],
+			...foreignColumnNames
+		];
+		return name ?? `${chunks.join("_")}_fk`;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/tracing-utils.js
+function iife(fn, ...args) {
+	return fn(...args);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/unique-constraint.js
+function uniqueKeyName$1(table, columns) {
+	return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/utils/array.js
+function parsePgArrayValue(arrayString, startFrom, inQuotes) {
+	for (let i = startFrom; i < arrayString.length; i++) {
+		const char = arrayString[i];
+		if (char === "\\") {
+			i++;
+			continue;
+		}
+		if (char === "\"") return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i + 1];
+		if (inQuotes) continue;
+		if (char === "," || char === "}") return [arrayString.slice(startFrom, i).replace(/\\/g, ""), i];
+	}
+	return [arrayString.slice(startFrom).replace(/\\/g, ""), arrayString.length];
+}
+function parsePgNestedArray(arrayString, startFrom = 0) {
+	const result = [];
+	let i = startFrom;
+	let lastCharIsComma = false;
+	while (i < arrayString.length) {
+		const char = arrayString[i];
+		if (char === ",") {
+			if (lastCharIsComma || i === startFrom) result.push("");
+			lastCharIsComma = true;
+			i++;
+			continue;
+		}
+		lastCharIsComma = false;
+		if (char === "\\") {
+			i += 2;
+			continue;
+		}
+		if (char === "\"") {
+			const [value2, startFrom2] = parsePgArrayValue(arrayString, i + 1, true);
+			result.push(value2);
+			i = startFrom2;
+			continue;
+		}
+		if (char === "}") return [result, i + 1];
+		if (char === "{") {
+			const [value2, startFrom2] = parsePgNestedArray(arrayString, i + 1);
+			result.push(value2);
+			i = startFrom2;
+			continue;
+		}
+		const [value, newStartFrom] = parsePgArrayValue(arrayString, i, false);
+		result.push(value);
+		i = newStartFrom;
+	}
+	return [result, i];
+}
+function parsePgArray(arrayString) {
+	const [result] = parsePgNestedArray(arrayString, 1);
+	return result;
+}
+function makePgArray(array) {
+	return `{${array.map((item) => {
+		if (Array.isArray(item)) return makePgArray(item);
+		if (typeof item === "string") return `"${item.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+		return `${item}`;
+	}).join(",")}}`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/common.js
+var PgColumnBuilder = class extends ColumnBuilder {
+	foreignKeyConfigs = [];
+	static [entityKind] = "PgColumnBuilder";
+	array(size) {
+		return new PgArrayBuilder(this.config.name, this, size);
+	}
+	references(ref, actions = {}) {
+		this.foreignKeyConfigs.push({
+			ref,
+			actions
+		});
+		return this;
+	}
+	unique(name, config) {
+		this.config.isUnique = true;
+		this.config.uniqueName = name;
+		this.config.uniqueType = config?.nulls;
+		return this;
+	}
+	generatedAlwaysAs(as) {
+		this.config.generated = {
+			as,
+			type: "always",
+			mode: "stored"
+		};
+		return this;
+	}
+	/** @internal */
+	buildForeignKeys(column, table) {
+		return this.foreignKeyConfigs.map(({ ref, actions }) => {
+			return iife((ref2, actions2) => {
+				const builder = new ForeignKeyBuilder$1(() => {
+					const foreignColumn = ref2();
+					return {
+						columns: [column],
+						foreignColumns: [foreignColumn]
+					};
+				});
+				if (actions2.onUpdate) builder.onUpdate(actions2.onUpdate);
+				if (actions2.onDelete) builder.onDelete(actions2.onDelete);
+				return builder.build(table);
+			}, ref, actions);
+		});
+	}
+	/** @internal */
+	buildExtraConfigColumn(table) {
+		return new ExtraConfigColumn(table, this.config);
+	}
+};
+var PgColumn = class extends Column {
+	constructor(table, config) {
+		if (!config.uniqueName) config.uniqueName = uniqueKeyName$1(table, [config.name]);
+		super(table, config);
+		this.table = table;
+	}
+	static [entityKind] = "PgColumn";
+};
+var ExtraConfigColumn = class extends PgColumn {
+	static [entityKind] = "ExtraConfigColumn";
+	getSQLType() {
+		return this.getSQLType();
+	}
+	indexConfig = {
+		order: this.config.order ?? "asc",
+		nulls: this.config.nulls ?? "last",
+		opClass: this.config.opClass
+	};
+	defaultConfig = {
+		order: "asc",
+		nulls: "last",
+		opClass: void 0
+	};
+	asc() {
+		this.indexConfig.order = "asc";
+		return this;
+	}
+	desc() {
+		this.indexConfig.order = "desc";
+		return this;
+	}
+	nullsFirst() {
+		this.indexConfig.nulls = "first";
+		return this;
+	}
+	nullsLast() {
+		this.indexConfig.nulls = "last";
+		return this;
+	}
+	/**
+	* ### PostgreSQL documentation quote
+	*
+	* > An operator class with optional parameters can be specified for each column of an index.
+	* The operator class identifies the operators to be used by the index for that column.
+	* For example, a B-tree index on four-byte integers would use the int4_ops class;
+	* this operator class includes comparison functions for four-byte integers.
+	* In practice the default operator class for the column's data type is usually sufficient.
+	* The main point of having operator classes is that for some data types, there could be more than one meaningful ordering.
+	* For example, we might want to sort a complex-number data type either by absolute value or by real part.
+	* We could do this by defining two operator classes for the data type and then selecting the proper class when creating an index.
+	* More information about operator classes check:
+	*
+	* ### Useful links
+	* https://www.postgresql.org/docs/current/sql-createindex.html
+	*
+	* https://www.postgresql.org/docs/current/indexes-opclass.html
+	*
+	* https://www.postgresql.org/docs/current/xindex.html
+	*
+	* ### Additional types
+	* If you have the `pg_vector` extension installed in your database, you can use the
+	* `vector_l2_ops`, `vector_ip_ops`, `vector_cosine_ops`, `vector_l1_ops`, `bit_hamming_ops`, `bit_jaccard_ops`, `halfvec_l2_ops`, `sparsevec_l2_ops` options, which are predefined types.
+	*
+	* **You can always specify any string you want in the operator class, in case Drizzle doesn't have it natively in its types**
+	*
+	* @param opClass
+	* @returns
+	*/
+	op(opClass) {
+		this.indexConfig.opClass = opClass;
+		return this;
+	}
+};
+var IndexedColumn = class {
+	static [entityKind] = "IndexedColumn";
+	constructor(name, keyAsName, type, indexConfig) {
+		this.name = name;
+		this.keyAsName = keyAsName;
+		this.type = type;
+		this.indexConfig = indexConfig;
+	}
+	name;
+	keyAsName;
+	type;
+	indexConfig;
+};
+var PgArrayBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgArrayBuilder";
+	constructor(name, baseBuilder, size) {
+		super(name, "array", "PgArray");
+		this.config.baseBuilder = baseBuilder;
+		this.config.size = size;
+	}
+	/** @internal */
+	build(table) {
+		const baseColumn = this.config.baseBuilder.build(table);
+		return new PgArray(table, this.config, baseColumn);
+	}
+};
+var PgArray = class PgArray extends PgColumn {
+	constructor(table, config, baseColumn, range) {
+		super(table, config);
+		this.baseColumn = baseColumn;
+		this.range = range;
+		this.size = config.size;
+	}
+	size;
+	static [entityKind] = "PgArray";
+	getSQLType() {
+		return `${this.baseColumn.getSQLType()}[${typeof this.size === "number" ? this.size : ""}]`;
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") value = parsePgArray(value);
+		return value.map((v) => this.baseColumn.mapFromDriverValue(v));
+	}
+	mapToDriverValue(value, isNestedArray = false) {
+		const a = value.map((v) => v === null ? null : is(this.baseColumn, PgArray) ? this.baseColumn.mapToDriverValue(v, true) : this.baseColumn.mapToDriverValue(v));
+		if (isNestedArray) return a;
+		return makePgArray(a);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/enum.js
+const isPgEnumSym = Symbol.for("drizzle:isPgEnum");
+function isPgEnum(obj) {
+	return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/subquery.js
+var Subquery = class {
+	static [entityKind] = "Subquery";
+	constructor(sql, fields, alias, isWith = false, usedTables = []) {
+		this._ = {
+			brand: "Subquery",
+			sql,
+			selectedFields: fields,
+			alias,
+			isWith,
+			usedTables
+		};
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/tracing.js
+const tracer = { startActiveSpan(name, fn) {
+	return fn();
+} };
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/view-common.js
+const ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/table.js
+const Schema = Symbol.for("drizzle:Schema");
+const Columns = Symbol.for("drizzle:Columns");
+const ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
+const OriginalName = Symbol.for("drizzle:OriginalName");
+const BaseName = Symbol.for("drizzle:BaseName");
+const IsAlias = Symbol.for("drizzle:IsAlias");
+const ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
+const IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
+var Table = class {
+	static [entityKind] = "Table";
+	/** @internal */
+	static Symbol = {
+		Name: TableName,
+		Schema,
+		OriginalName,
+		Columns,
+		ExtraConfigColumns,
+		BaseName,
+		IsAlias,
+		ExtraConfigBuilder
+	};
+	/**
+	* @internal
+	* Can be changed if the table is aliased.
+	*/
+	[TableName];
+	/**
+	* @internal
+	* Used to store the original name of the table, before any aliasing.
+	*/
+	[OriginalName];
+	/** @internal */
+	[Schema];
+	/** @internal */
+	[Columns];
+	/** @internal */
+	[ExtraConfigColumns];
+	/**
+	*  @internal
+	* Used to store the table name before the transformation via the `tableCreator` functions.
+	*/
+	[BaseName];
+	/** @internal */
+	[IsAlias] = false;
+	/** @internal */
+	[IsDrizzleTable] = true;
+	/** @internal */
+	[ExtraConfigBuilder] = void 0;
+	constructor(name, schema, baseName) {
+		this[TableName] = this[OriginalName] = name;
+		this[Schema] = schema;
+		this[BaseName] = baseName;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/sql/sql.js
+function isSQLWrapper(value) {
+	return value !== null && value !== void 0 && typeof value.getSQL === "function";
+}
+function mergeQueries(queries) {
+	const result = {
+		sql: "",
+		params: []
+	};
+	for (const query of queries) {
+		result.sql += query.sql;
+		result.params.push(...query.params);
+		if (query.typings?.length) {
+			if (!result.typings) result.typings = [];
+			result.typings.push(...query.typings);
+		}
+	}
+	return result;
+}
+var StringChunk = class {
+	static [entityKind] = "StringChunk";
+	value;
+	constructor(value) {
+		this.value = Array.isArray(value) ? value : [value];
+	}
+	getSQL() {
+		return new SQL([this]);
+	}
+};
+var SQL = class SQL {
+	constructor(queryChunks) {
+		this.queryChunks = queryChunks;
+		for (const chunk of queryChunks) if (is(chunk, Table)) {
+			const schemaName = chunk[Table.Symbol.Schema];
+			this.usedTables.push(schemaName === void 0 ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
+		}
+	}
+	static [entityKind] = "SQL";
+	/** @internal */
+	decoder = noopDecoder;
+	shouldInlineParams = false;
+	/** @internal */
+	usedTables = [];
+	append(query) {
+		this.queryChunks.push(...query.queryChunks);
+		return this;
+	}
+	toQuery(config) {
+		return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
+			const query = this.buildQueryFromSourceParams(this.queryChunks, config);
+			span?.setAttributes({
+				"drizzle.query.text": query.sql,
+				"drizzle.query.params": JSON.stringify(query.params)
+			});
+			return query;
+		});
+	}
+	buildQueryFromSourceParams(chunks, _config) {
+		const config = Object.assign({}, _config, {
+			inlineParams: _config.inlineParams || this.shouldInlineParams,
+			paramStartIndex: _config.paramStartIndex || { value: 0 }
+		});
+		const { casing, escapeName, escapeParam, prepareTyping, inlineParams, paramStartIndex } = config;
+		return mergeQueries(chunks.map((chunk) => {
+			if (is(chunk, StringChunk)) return {
+				sql: chunk.value.join(""),
+				params: []
+			};
+			if (is(chunk, Name)) return {
+				sql: escapeName(chunk.value),
+				params: []
+			};
+			if (chunk === void 0) return {
+				sql: "",
+				params: []
+			};
+			if (Array.isArray(chunk)) {
+				const result = [new StringChunk("(")];
+				for (const [i, p] of chunk.entries()) {
+					result.push(p);
+					if (i < chunk.length - 1) result.push(new StringChunk(", "));
+				}
+				result.push(new StringChunk(")"));
+				return this.buildQueryFromSourceParams(result, config);
+			}
+			if (is(chunk, SQL)) return this.buildQueryFromSourceParams(chunk.queryChunks, {
+				...config,
+				inlineParams: inlineParams || chunk.shouldInlineParams
+			});
+			if (is(chunk, Table)) {
+				const schemaName = chunk[Table.Symbol.Schema];
+				const tableName = chunk[Table.Symbol.Name];
+				return {
+					sql: schemaName === void 0 || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
+					params: []
+				};
+			}
+			if (is(chunk, Column)) {
+				const columnName = casing.getColumnCasing(chunk);
+				if (_config.invokeSource === "indexes") return {
+					sql: escapeName(columnName),
+					params: []
+				};
+				const schemaName = chunk.table[Table.Symbol.Schema];
+				return {
+					sql: chunk.table[IsAlias] || schemaName === void 0 ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
+					params: []
+				};
+			}
+			if (is(chunk, View)) {
+				const schemaName = chunk[ViewBaseConfig].schema;
+				const viewName = chunk[ViewBaseConfig].name;
+				return {
+					sql: schemaName === void 0 || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
+					params: []
+				};
+			}
+			if (is(chunk, Param)) {
+				if (is(chunk.value, Placeholder)) return {
+					sql: escapeParam(paramStartIndex.value++, chunk),
+					params: [chunk],
+					typings: ["none"]
+				};
+				const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
+				if (is(mappedValue, SQL)) return this.buildQueryFromSourceParams([mappedValue], config);
+				if (inlineParams) return {
+					sql: this.mapInlineParam(mappedValue, config),
+					params: []
+				};
+				let typings = ["none"];
+				if (prepareTyping) typings = [prepareTyping(chunk.encoder)];
+				return {
+					sql: escapeParam(paramStartIndex.value++, mappedValue),
+					params: [mappedValue],
+					typings
+				};
+			}
+			if (is(chunk, Placeholder)) return {
+				sql: escapeParam(paramStartIndex.value++, chunk),
+				params: [chunk],
+				typings: ["none"]
+			};
+			if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== void 0) return {
+				sql: escapeName(chunk.fieldAlias),
+				params: []
+			};
+			if (is(chunk, Subquery)) {
+				if (chunk._.isWith) return {
+					sql: escapeName(chunk._.alias),
+					params: []
+				};
+				return this.buildQueryFromSourceParams([
+					new StringChunk("("),
+					chunk._.sql,
+					new StringChunk(") "),
+					new Name(chunk._.alias)
+				], config);
+			}
+			if (isPgEnum(chunk)) {
+				if (chunk.schema) return {
+					sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName),
+					params: []
+				};
+				return {
+					sql: escapeName(chunk.enumName),
+					params: []
+				};
+			}
+			if (isSQLWrapper(chunk)) {
+				if (chunk.shouldOmitSQLParens?.()) return this.buildQueryFromSourceParams([chunk.getSQL()], config);
+				return this.buildQueryFromSourceParams([
+					new StringChunk("("),
+					chunk.getSQL(),
+					new StringChunk(")")
+				], config);
+			}
+			if (inlineParams) return {
+				sql: this.mapInlineParam(chunk, config),
+				params: []
+			};
+			return {
+				sql: escapeParam(paramStartIndex.value++, chunk),
+				params: [chunk],
+				typings: ["none"]
+			};
+		}));
+	}
+	mapInlineParam(chunk, { escapeString }) {
+		if (chunk === null) return "null";
+		if (typeof chunk === "number" || typeof chunk === "boolean") return chunk.toString();
+		if (typeof chunk === "string") return escapeString(chunk);
+		if (typeof chunk === "object") {
+			const mappedValueAsString = chunk.toString();
+			if (mappedValueAsString === "[object Object]") return escapeString(JSON.stringify(chunk));
+			return escapeString(mappedValueAsString);
+		}
+		throw new Error("Unexpected param value: " + chunk);
+	}
+	getSQL() {
+		return this;
+	}
+	as(alias) {
+		if (alias === void 0) return this;
+		return new SQL.Aliased(this, alias);
+	}
+	mapWith(decoder) {
+		this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
+		return this;
+	}
+	inlineParams() {
+		this.shouldInlineParams = true;
+		return this;
+	}
+	/**
+	* This method is used to conditionally include a part of the query.
+	*
+	* @param condition - Condition to check
+	* @returns itself if the condition is `true`, otherwise `undefined`
+	*/
+	if(condition) {
+		return condition ? this : void 0;
+	}
+};
+var Name = class {
+	constructor(value) {
+		this.value = value;
+	}
+	static [entityKind] = "Name";
+	brand;
+	getSQL() {
+		return new SQL([this]);
+	}
+};
+const noopDecoder = { mapFromDriverValue: (value) => value };
+const noopEncoder = { mapToDriverValue: (value) => value };
+({
+	...noopDecoder,
+	...noopEncoder
+});
+var Param = class {
+	/**
+	* @param value - Parameter value
+	* @param encoder - Encoder to convert the value to a driver parameter
+	*/
+	constructor(value, encoder = noopEncoder) {
+		this.value = value;
+		this.encoder = encoder;
+	}
+	static [entityKind] = "Param";
+	brand;
+	getSQL() {
+		return new SQL([this]);
+	}
+};
+function sql(strings, ...params) {
+	const queryChunks = [];
+	if (params.length > 0 || strings.length > 0 && strings[0] !== "") queryChunks.push(new StringChunk(strings[0]));
+	for (const [paramIndex, param2] of params.entries()) queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
+	return new SQL(queryChunks);
+}
+((sql2) => {
+	function empty() {
+		return new SQL([]);
+	}
+	sql2.empty = empty;
+	function fromList(list) {
+		return new SQL(list);
+	}
+	sql2.fromList = fromList;
+	function raw(str) {
+		return new SQL([new StringChunk(str)]);
+	}
+	sql2.raw = raw;
+	function join(chunks, separator) {
+		const result = [];
+		for (const [i, chunk] of chunks.entries()) {
+			if (i > 0 && separator !== void 0) result.push(separator);
+			result.push(chunk);
+		}
+		return new SQL(result);
+	}
+	sql2.join = join;
+	function identifier(value) {
+		return new Name(value);
+	}
+	sql2.identifier = identifier;
+	function placeholder2(name2) {
+		return new Placeholder(name2);
+	}
+	sql2.placeholder = placeholder2;
+	function param2(value, encoder) {
+		return new Param(value, encoder);
+	}
+	sql2.param = param2;
+})(sql || (sql = {}));
+((SQL2) => {
+	class Aliased {
+		constructor(sql2, fieldAlias) {
+			this.sql = sql2;
+			this.fieldAlias = fieldAlias;
+		}
+		static [entityKind] = "SQL.Aliased";
+		/** @internal */
+		isSelectionField = false;
+		getSQL() {
+			return this.sql;
+		}
+		/** @internal */
+		clone() {
+			return new Aliased(this.sql, this.fieldAlias);
+		}
+	}
+	SQL2.Aliased = Aliased;
+})(SQL || (SQL = {}));
+var Placeholder = class {
+	constructor(name2) {
+		this.name = name2;
+	}
+	static [entityKind] = "Placeholder";
+	getSQL() {
+		return new SQL([this]);
+	}
+};
+const IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
+var View = class {
+	static [entityKind] = "View";
+	/** @internal */
+	[ViewBaseConfig];
+	/** @internal */
+	[IsDrizzleView] = true;
+	constructor({ name: name2, schema, selectedFields, query }) {
+		this[ViewBaseConfig] = {
+			name: name2,
+			originalName: name2,
+			schema,
+			selectedFields,
+			query,
+			isExisting: !query,
+			isAlias: false
+		};
+	}
+	getSQL() {
+		return new SQL([this]);
+	}
+};
+Column.prototype.getSQL = function() {
+	return new SQL([this]);
+};
+Table.prototype.getSQL = function() {
+	return new SQL([this]);
+};
+Subquery.prototype.getSQL = function() {
+	return new SQL([this]);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/utils.js
+function getColumnNameAndConfig(a, b) {
+	return {
+		name: typeof a === "string" && a.length > 0 ? a : "",
+		config: typeof a === "object" ? a : b
+	};
+}
+const textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder();
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/int.common.js
+var PgIntColumnBaseBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgIntColumnBaseBuilder";
+	generatedAlwaysAsIdentity(sequence) {
+		if (sequence) {
+			const { name, ...options } = sequence;
+			this.config.generatedIdentity = {
+				type: "always",
+				sequenceName: name,
+				sequenceOptions: options
+			};
+		} else this.config.generatedIdentity = { type: "always" };
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+		return this;
+	}
+	generatedByDefaultAsIdentity(sequence) {
+		if (sequence) {
+			const { name, ...options } = sequence;
+			this.config.generatedIdentity = {
+				type: "byDefault",
+				sequenceName: name,
+				sequenceOptions: options
+			};
+		} else this.config.generatedIdentity = { type: "byDefault" };
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+		return this;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/bigint.js
+var PgBigInt53Builder = class extends PgIntColumnBaseBuilder {
+	static [entityKind] = "PgBigInt53Builder";
+	constructor(name) {
+		super(name, "number", "PgBigInt53");
+	}
+	/** @internal */
+	build(table) {
+		return new PgBigInt53(table, this.config);
+	}
+};
+var PgBigInt53 = class extends PgColumn {
+	static [entityKind] = "PgBigInt53";
+	getSQLType() {
+		return "bigint";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "number") return value;
+		return Number(value);
+	}
+};
+var PgBigInt64Builder = class extends PgIntColumnBaseBuilder {
+	static [entityKind] = "PgBigInt64Builder";
+	constructor(name) {
+		super(name, "bigint", "PgBigInt64");
+	}
+	/** @internal */
+	build(table) {
+		return new PgBigInt64(table, this.config);
+	}
+};
+var PgBigInt64 = class extends PgColumn {
+	static [entityKind] = "PgBigInt64";
+	getSQLType() {
+		return "bigint";
+	}
+	mapFromDriverValue(value) {
+		return BigInt(value);
+	}
+};
+function bigint(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (config.mode === "number") return new PgBigInt53Builder(name);
+	return new PgBigInt64Builder(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/bigserial.js
+var PgBigSerial53Builder = class extends PgColumnBuilder {
+	static [entityKind] = "PgBigSerial53Builder";
+	constructor(name) {
+		super(name, "number", "PgBigSerial53");
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+	}
+	/** @internal */
+	build(table) {
+		return new PgBigSerial53(table, this.config);
+	}
+};
+var PgBigSerial53 = class extends PgColumn {
+	static [entityKind] = "PgBigSerial53";
+	getSQLType() {
+		return "bigserial";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "number") return value;
+		return Number(value);
+	}
+};
+var PgBigSerial64Builder = class extends PgColumnBuilder {
+	static [entityKind] = "PgBigSerial64Builder";
+	constructor(name) {
+		super(name, "bigint", "PgBigSerial64");
+		this.config.hasDefault = true;
+	}
+	/** @internal */
+	build(table) {
+		return new PgBigSerial64(table, this.config);
+	}
+};
+var PgBigSerial64 = class extends PgColumn {
+	static [entityKind] = "PgBigSerial64";
+	getSQLType() {
+		return "bigserial";
+	}
+	mapFromDriverValue(value) {
+		return BigInt(value);
+	}
+};
+function bigserial(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (config.mode === "number") return new PgBigSerial53Builder(name);
+	return new PgBigSerial64Builder(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/boolean.js
+var PgBooleanBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgBooleanBuilder";
+	constructor(name) {
+		super(name, "boolean", "PgBoolean");
+	}
+	/** @internal */
+	build(table) {
+		return new PgBoolean(table, this.config);
+	}
+};
+var PgBoolean = class extends PgColumn {
+	static [entityKind] = "PgBoolean";
+	getSQLType() {
+		return "boolean";
+	}
+};
+function boolean(name) {
+	return new PgBooleanBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/char.js
+var PgCharBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgCharBuilder";
+	constructor(name, config) {
+		super(name, "string", "PgChar");
+		this.config.length = config.length;
+		this.config.enumValues = config.enum;
+	}
+	/** @internal */
+	build(table) {
+		return new PgChar(table, this.config);
+	}
+};
+var PgChar = class extends PgColumn {
+	static [entityKind] = "PgChar";
+	length = this.config.length;
+	enumValues = this.config.enumValues;
+	getSQLType() {
+		return this.length === void 0 ? `char` : `char(${this.length})`;
+	}
+};
+function char(a, b = {}) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgCharBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/cidr.js
+var PgCidrBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgCidrBuilder";
+	constructor(name) {
+		super(name, "string", "PgCidr");
+	}
+	/** @internal */
+	build(table) {
+		return new PgCidr(table, this.config);
+	}
+};
+var PgCidr = class extends PgColumn {
+	static [entityKind] = "PgCidr";
+	getSQLType() {
+		return "cidr";
+	}
+};
+function cidr(name) {
+	return new PgCidrBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/custom.js
+var PgCustomColumnBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgCustomColumnBuilder";
+	constructor(name, fieldConfig, customTypeParams) {
+		super(name, "custom", "PgCustomColumn");
+		this.config.fieldConfig = fieldConfig;
+		this.config.customTypeParams = customTypeParams;
+	}
+	/** @internal */
+	build(table) {
+		return new PgCustomColumn(table, this.config);
+	}
+};
+var PgCustomColumn = class extends PgColumn {
+	static [entityKind] = "PgCustomColumn";
+	sqlName;
+	mapTo;
+	mapFrom;
+	constructor(table, config) {
+		super(table, config);
+		this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+		this.mapTo = config.customTypeParams.toDriver;
+		this.mapFrom = config.customTypeParams.fromDriver;
+	}
+	getSQLType() {
+		return this.sqlName;
+	}
+	mapFromDriverValue(value) {
+		return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
+	}
+	mapToDriverValue(value) {
+		return typeof this.mapTo === "function" ? this.mapTo(value) : value;
+	}
+};
+function customType$1(customTypeParams) {
+	return (a, b) => {
+		const { name, config } = getColumnNameAndConfig(a, b);
+		return new PgCustomColumnBuilder(name, config, customTypeParams);
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/date.common.js
+var PgDateColumnBaseBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgDateColumnBaseBuilder";
+	defaultNow() {
+		return this.default(sql`now()`);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/date.js
+var PgDateBuilder = class extends PgDateColumnBaseBuilder {
+	static [entityKind] = "PgDateBuilder";
+	constructor(name) {
+		super(name, "date", "PgDate");
+	}
+	/** @internal */
+	build(table) {
+		return new PgDate(table, this.config);
+	}
+};
+var PgDate = class extends PgColumn {
+	static [entityKind] = "PgDate";
+	getSQLType() {
+		return "date";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return new Date(value);
+		return value;
+	}
+	mapToDriverValue(value) {
+		return value.toISOString();
+	}
+};
+var PgDateStringBuilder = class extends PgDateColumnBaseBuilder {
+	static [entityKind] = "PgDateStringBuilder";
+	constructor(name) {
+		super(name, "string", "PgDateString");
+	}
+	/** @internal */
+	build(table) {
+		return new PgDateString(table, this.config);
+	}
+};
+var PgDateString = class extends PgColumn {
+	static [entityKind] = "PgDateString";
+	getSQLType() {
+		return "date";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return value;
+		return value.toISOString().slice(0, -14);
+	}
+};
+function date(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (config?.mode === "date") return new PgDateBuilder(name);
+	return new PgDateStringBuilder(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/double-precision.js
+var PgDoublePrecisionBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgDoublePrecisionBuilder";
+	constructor(name) {
+		super(name, "number", "PgDoublePrecision");
+	}
+	/** @internal */
+	build(table) {
+		return new PgDoublePrecision(table, this.config);
+	}
+};
+var PgDoublePrecision = class extends PgColumn {
+	static [entityKind] = "PgDoublePrecision";
+	getSQLType() {
+		return "double precision";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return Number.parseFloat(value);
+		return value;
+	}
+};
+function doublePrecision(name) {
+	return new PgDoublePrecisionBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/inet.js
+var PgInetBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgInetBuilder";
+	constructor(name) {
+		super(name, "string", "PgInet");
+	}
+	/** @internal */
+	build(table) {
+		return new PgInet(table, this.config);
+	}
+};
+var PgInet = class extends PgColumn {
+	static [entityKind] = "PgInet";
+	getSQLType() {
+		return "inet";
+	}
+};
+function inet(name) {
+	return new PgInetBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/integer.js
+var PgIntegerBuilder = class extends PgIntColumnBaseBuilder {
+	static [entityKind] = "PgIntegerBuilder";
+	constructor(name) {
+		super(name, "number", "PgInteger");
+	}
+	/** @internal */
+	build(table) {
+		return new PgInteger(table, this.config);
+	}
+};
+var PgInteger = class extends PgColumn {
+	static [entityKind] = "PgInteger";
+	getSQLType() {
+		return "integer";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return Number.parseInt(value);
+		return value;
+	}
+};
+function integer$1(name) {
+	return new PgIntegerBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/interval.js
+var PgIntervalBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgIntervalBuilder";
+	constructor(name, intervalConfig) {
+		super(name, "string", "PgInterval");
+		this.config.intervalConfig = intervalConfig;
+	}
+	/** @internal */
+	build(table) {
+		return new PgInterval(table, this.config);
+	}
+};
+var PgInterval = class extends PgColumn {
+	static [entityKind] = "PgInterval";
+	fields = this.config.intervalConfig.fields;
+	precision = this.config.intervalConfig.precision;
+	getSQLType() {
+		return `interval${this.fields ? ` ${this.fields}` : ""}${this.precision ? `(${this.precision})` : ""}`;
+	}
+};
+function interval(a, b = {}) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgIntervalBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/json.js
+var PgJsonBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgJsonBuilder";
+	constructor(name) {
+		super(name, "json", "PgJson");
+	}
+	/** @internal */
+	build(table) {
+		return new PgJson(table, this.config);
+	}
+};
+var PgJson = class extends PgColumn {
+	static [entityKind] = "PgJson";
+	constructor(table, config) {
+		super(table, config);
+	}
+	getSQLType() {
+		return "json";
+	}
+	mapToDriverValue(value) {
+		return JSON.stringify(value);
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") try {
+			return JSON.parse(value);
+		} catch {
+			return value;
+		}
+		return value;
+	}
+};
+function json(name) {
+	return new PgJsonBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/jsonb.js
+var PgJsonbBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgJsonbBuilder";
+	constructor(name) {
+		super(name, "json", "PgJsonb");
+	}
+	/** @internal */
+	build(table) {
+		return new PgJsonb(table, this.config);
+	}
+};
+var PgJsonb = class extends PgColumn {
+	static [entityKind] = "PgJsonb";
+	constructor(table, config) {
+		super(table, config);
+	}
+	getSQLType() {
+		return "jsonb";
+	}
+	mapToDriverValue(value) {
+		return JSON.stringify(value);
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") try {
+			return JSON.parse(value);
+		} catch {
+			return value;
+		}
+		return value;
+	}
+};
+function jsonb(name) {
+	return new PgJsonbBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/line.js
+var PgLineBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgLineBuilder";
+	constructor(name) {
+		super(name, "array", "PgLine");
+	}
+	/** @internal */
+	build(table) {
+		return new PgLineTuple(table, this.config);
+	}
+};
+var PgLineTuple = class extends PgColumn {
+	static [entityKind] = "PgLine";
+	getSQLType() {
+		return "line";
+	}
+	mapFromDriverValue(value) {
+		const [a, b, c] = value.slice(1, -1).split(",");
+		return [
+			Number.parseFloat(a),
+			Number.parseFloat(b),
+			Number.parseFloat(c)
+		];
+	}
+	mapToDriverValue(value) {
+		return `{${value[0]},${value[1]},${value[2]}}`;
+	}
+};
+var PgLineABCBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgLineABCBuilder";
+	constructor(name) {
+		super(name, "json", "PgLineABC");
+	}
+	/** @internal */
+	build(table) {
+		return new PgLineABC(table, this.config);
+	}
+};
+var PgLineABC = class extends PgColumn {
+	static [entityKind] = "PgLineABC";
+	getSQLType() {
+		return "line";
+	}
+	mapFromDriverValue(value) {
+		const [a, b, c] = value.slice(1, -1).split(",");
+		return {
+			a: Number.parseFloat(a),
+			b: Number.parseFloat(b),
+			c: Number.parseFloat(c)
+		};
+	}
+	mapToDriverValue(value) {
+		return `{${value.a},${value.b},${value.c}}`;
+	}
+};
+function line(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (!config?.mode || config.mode === "tuple") return new PgLineBuilder(name);
+	return new PgLineABCBuilder(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/macaddr.js
+var PgMacaddrBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgMacaddrBuilder";
+	constructor(name) {
+		super(name, "string", "PgMacaddr");
+	}
+	/** @internal */
+	build(table) {
+		return new PgMacaddr(table, this.config);
+	}
+};
+var PgMacaddr = class extends PgColumn {
+	static [entityKind] = "PgMacaddr";
+	getSQLType() {
+		return "macaddr";
+	}
+};
+function macaddr(name) {
+	return new PgMacaddrBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/macaddr8.js
+var PgMacaddr8Builder = class extends PgColumnBuilder {
+	static [entityKind] = "PgMacaddr8Builder";
+	constructor(name) {
+		super(name, "string", "PgMacaddr8");
+	}
+	/** @internal */
+	build(table) {
+		return new PgMacaddr8(table, this.config);
+	}
+};
+var PgMacaddr8 = class extends PgColumn {
+	static [entityKind] = "PgMacaddr8";
+	getSQLType() {
+		return "macaddr8";
+	}
+};
+function macaddr8(name) {
+	return new PgMacaddr8Builder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/numeric.js
+var PgNumericBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgNumericBuilder";
+	constructor(name, precision, scale) {
+		super(name, "string", "PgNumeric");
+		this.config.precision = precision;
+		this.config.scale = scale;
+	}
+	/** @internal */
+	build(table) {
+		return new PgNumeric(table, this.config);
+	}
+};
+var PgNumeric = class extends PgColumn {
+	static [entityKind] = "PgNumeric";
+	precision;
+	scale;
+	constructor(table, config) {
+		super(table, config);
+		this.precision = config.precision;
+		this.scale = config.scale;
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return value;
+		return String(value);
+	}
+	getSQLType() {
+		if (this.precision !== void 0 && this.scale !== void 0) return `numeric(${this.precision}, ${this.scale})`;
+		else if (this.precision === void 0) return "numeric";
+		else return `numeric(${this.precision})`;
+	}
+};
+var PgNumericNumberBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgNumericNumberBuilder";
+	constructor(name, precision, scale) {
+		super(name, "number", "PgNumericNumber");
+		this.config.precision = precision;
+		this.config.scale = scale;
+	}
+	/** @internal */
+	build(table) {
+		return new PgNumericNumber(table, this.config);
+	}
+};
+var PgNumericNumber = class extends PgColumn {
+	static [entityKind] = "PgNumericNumber";
+	precision;
+	scale;
+	constructor(table, config) {
+		super(table, config);
+		this.precision = config.precision;
+		this.scale = config.scale;
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "number") return value;
+		return Number(value);
+	}
+	mapToDriverValue = String;
+	getSQLType() {
+		if (this.precision !== void 0 && this.scale !== void 0) return `numeric(${this.precision}, ${this.scale})`;
+		else if (this.precision === void 0) return "numeric";
+		else return `numeric(${this.precision})`;
+	}
+};
+var PgNumericBigIntBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgNumericBigIntBuilder";
+	constructor(name, precision, scale) {
+		super(name, "bigint", "PgNumericBigInt");
+		this.config.precision = precision;
+		this.config.scale = scale;
+	}
+	/** @internal */
+	build(table) {
+		return new PgNumericBigInt(table, this.config);
+	}
+};
+var PgNumericBigInt = class extends PgColumn {
+	static [entityKind] = "PgNumericBigInt";
+	precision;
+	scale;
+	constructor(table, config) {
+		super(table, config);
+		this.precision = config.precision;
+		this.scale = config.scale;
+	}
+	mapFromDriverValue = BigInt;
+	mapToDriverValue = String;
+	getSQLType() {
+		if (this.precision !== void 0 && this.scale !== void 0) return `numeric(${this.precision}, ${this.scale})`;
+		else if (this.precision === void 0) return "numeric";
+		else return `numeric(${this.precision})`;
+	}
+};
+function numeric$1(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	const mode = config?.mode;
+	return mode === "number" ? new PgNumericNumberBuilder(name, config?.precision, config?.scale) : mode === "bigint" ? new PgNumericBigIntBuilder(name, config?.precision, config?.scale) : new PgNumericBuilder(name, config?.precision, config?.scale);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/point.js
+var PgPointTupleBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgPointTupleBuilder";
+	constructor(name) {
+		super(name, "array", "PgPointTuple");
+	}
+	/** @internal */
+	build(table) {
+		return new PgPointTuple(table, this.config);
+	}
+};
+var PgPointTuple = class extends PgColumn {
+	static [entityKind] = "PgPointTuple";
+	getSQLType() {
+		return "point";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") {
+			const [x, y] = value.slice(1, -1).split(",");
+			return [Number.parseFloat(x), Number.parseFloat(y)];
+		}
+		return [value.x, value.y];
+	}
+	mapToDriverValue(value) {
+		return `(${value[0]},${value[1]})`;
+	}
+};
+var PgPointObjectBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgPointObjectBuilder";
+	constructor(name) {
+		super(name, "json", "PgPointObject");
+	}
+	/** @internal */
+	build(table) {
+		return new PgPointObject(table, this.config);
+	}
+};
+var PgPointObject = class extends PgColumn {
+	static [entityKind] = "PgPointObject";
+	getSQLType() {
+		return "point";
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") {
+			const [x, y] = value.slice(1, -1).split(",");
+			return {
+				x: Number.parseFloat(x),
+				y: Number.parseFloat(y)
+			};
+		}
+		return value;
+	}
+	mapToDriverValue(value) {
+		return `(${value.x},${value.y})`;
+	}
+};
+function point(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (!config?.mode || config.mode === "tuple") return new PgPointTupleBuilder(name);
+	return new PgPointObjectBuilder(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/postgis_extension/utils.js
+function hexToBytes(hex) {
+	const bytes = [];
+	for (let c = 0; c < hex.length; c += 2) bytes.push(Number.parseInt(hex.slice(c, c + 2), 16));
+	return new Uint8Array(bytes);
+}
+function bytesToFloat64(bytes, offset) {
+	const view = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+	for (let i = 0; i < 8; i++) view.setUint8(i, bytes[offset + i]);
+	return view.getFloat64(0, true);
+}
+function parseEWKB(hex) {
+	const bytes = hexToBytes(hex);
+	let offset = 0;
+	const byteOrder = bytes[offset];
+	offset += 1;
+	const view = new DataView(bytes.buffer);
+	const geomType = view.getUint32(offset, byteOrder === 1);
+	offset += 4;
+	if (geomType & 536870912) {
+		view.getUint32(offset, byteOrder === 1);
+		offset += 4;
+	}
+	if ((geomType & 65535) === 1) {
+		const x = bytesToFloat64(bytes, offset);
+		offset += 8;
+		const y = bytesToFloat64(bytes, offset);
+		offset += 8;
+		return [x, y];
+	}
+	throw new Error("Unsupported geometry type");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/postgis_extension/geometry.js
+var PgGeometryBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgGeometryBuilder";
+	constructor(name) {
+		super(name, "array", "PgGeometry");
+	}
+	/** @internal */
+	build(table) {
+		return new PgGeometry(table, this.config);
+	}
+};
+var PgGeometry = class extends PgColumn {
+	static [entityKind] = "PgGeometry";
+	getSQLType() {
+		return "geometry(point)";
+	}
+	mapFromDriverValue(value) {
+		return parseEWKB(value);
+	}
+	mapToDriverValue(value) {
+		return `point(${value[0]} ${value[1]})`;
+	}
+};
+var PgGeometryObjectBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgGeometryObjectBuilder";
+	constructor(name) {
+		super(name, "json", "PgGeometryObject");
+	}
+	/** @internal */
+	build(table) {
+		return new PgGeometryObject(table, this.config);
+	}
+};
+var PgGeometryObject = class extends PgColumn {
+	static [entityKind] = "PgGeometryObject";
+	getSQLType() {
+		return "geometry(point)";
+	}
+	mapFromDriverValue(value) {
+		const parsed = parseEWKB(value);
+		return {
+			x: parsed[0],
+			y: parsed[1]
+		};
+	}
+	mapToDriverValue(value) {
+		return `point(${value.x} ${value.y})`;
+	}
+};
+function geometry(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (!config?.mode || config.mode === "tuple") return new PgGeometryBuilder(name);
+	return new PgGeometryObjectBuilder(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/real.js
+var PgRealBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgRealBuilder";
+	constructor(name, length) {
+		super(name, "number", "PgReal");
+		this.config.length = length;
+	}
+	/** @internal */
+	build(table) {
+		return new PgReal(table, this.config);
+	}
+};
+var PgReal = class extends PgColumn {
+	static [entityKind] = "PgReal";
+	constructor(table, config) {
+		super(table, config);
+	}
+	getSQLType() {
+		return "real";
+	}
+	mapFromDriverValue = (value) => {
+		if (typeof value === "string") return Number.parseFloat(value);
+		return value;
+	};
+};
+function real$1(name) {
+	return new PgRealBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/serial.js
+var PgSerialBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgSerialBuilder";
+	constructor(name) {
+		super(name, "number", "PgSerial");
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+	}
+	/** @internal */
+	build(table) {
+		return new PgSerial(table, this.config);
+	}
+};
+var PgSerial = class extends PgColumn {
+	static [entityKind] = "PgSerial";
+	getSQLType() {
+		return "serial";
+	}
+};
+function serial(name) {
+	return new PgSerialBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/smallint.js
+var PgSmallIntBuilder = class extends PgIntColumnBaseBuilder {
+	static [entityKind] = "PgSmallIntBuilder";
+	constructor(name) {
+		super(name, "number", "PgSmallInt");
+	}
+	/** @internal */
+	build(table) {
+		return new PgSmallInt(table, this.config);
+	}
+};
+var PgSmallInt = class extends PgColumn {
+	static [entityKind] = "PgSmallInt";
+	getSQLType() {
+		return "smallint";
+	}
+	mapFromDriverValue = (value) => {
+		if (typeof value === "string") return Number(value);
+		return value;
+	};
+};
+function smallint(name) {
+	return new PgSmallIntBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/smallserial.js
+var PgSmallSerialBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgSmallSerialBuilder";
+	constructor(name) {
+		super(name, "number", "PgSmallSerial");
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+	}
+	/** @internal */
+	build(table) {
+		return new PgSmallSerial(table, this.config);
+	}
+};
+var PgSmallSerial = class extends PgColumn {
+	static [entityKind] = "PgSmallSerial";
+	getSQLType() {
+		return "smallserial";
+	}
+};
+function smallserial(name) {
+	return new PgSmallSerialBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/text.js
+var PgTextBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgTextBuilder";
+	constructor(name, config) {
+		super(name, "string", "PgText");
+		this.config.enumValues = config.enum;
+	}
+	/** @internal */
+	build(table) {
+		return new PgText(table, this.config);
+	}
+};
+var PgText = class extends PgColumn {
+	static [entityKind] = "PgText";
+	enumValues = this.config.enumValues;
+	getSQLType() {
+		return "text";
+	}
+};
+function text$1(a, b = {}) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgTextBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/time.js
+var PgTimeBuilder = class extends PgDateColumnBaseBuilder {
+	constructor(name, withTimezone, precision) {
+		super(name, "string", "PgTime");
+		this.withTimezone = withTimezone;
+		this.precision = precision;
+		this.config.withTimezone = withTimezone;
+		this.config.precision = precision;
+	}
+	static [entityKind] = "PgTimeBuilder";
+	/** @internal */
+	build(table) {
+		return new PgTime(table, this.config);
+	}
+};
+var PgTime = class extends PgColumn {
+	static [entityKind] = "PgTime";
+	withTimezone;
+	precision;
+	constructor(table, config) {
+		super(table, config);
+		this.withTimezone = config.withTimezone;
+		this.precision = config.precision;
+	}
+	getSQLType() {
+		return `time${this.precision === void 0 ? "" : `(${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
+	}
+};
+function time(a, b = {}) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgTimeBuilder(name, config.withTimezone ?? false, config.precision);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/timestamp.js
+var PgTimestampBuilder = class extends PgDateColumnBaseBuilder {
+	static [entityKind] = "PgTimestampBuilder";
+	constructor(name, withTimezone, precision) {
+		super(name, "date", "PgTimestamp");
+		this.config.withTimezone = withTimezone;
+		this.config.precision = precision;
+	}
+	/** @internal */
+	build(table) {
+		return new PgTimestamp(table, this.config);
+	}
+};
+var PgTimestamp = class extends PgColumn {
+	static [entityKind] = "PgTimestamp";
+	withTimezone;
+	precision;
+	constructor(table, config) {
+		super(table, config);
+		this.withTimezone = config.withTimezone;
+		this.precision = config.precision;
+	}
+	getSQLType() {
+		return `timestamp${this.precision === void 0 ? "" : ` (${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return new Date(this.withTimezone ? value : value + "+0000");
+		return value;
+	}
+	mapToDriverValue = (value) => {
+		return value.toISOString();
+	};
+};
+var PgTimestampStringBuilder = class extends PgDateColumnBaseBuilder {
+	static [entityKind] = "PgTimestampStringBuilder";
+	constructor(name, withTimezone, precision) {
+		super(name, "string", "PgTimestampString");
+		this.config.withTimezone = withTimezone;
+		this.config.precision = precision;
+	}
+	/** @internal */
+	build(table) {
+		return new PgTimestampString(table, this.config);
+	}
+};
+var PgTimestampString = class extends PgColumn {
+	static [entityKind] = "PgTimestampString";
+	withTimezone;
+	precision;
+	constructor(table, config) {
+		super(table, config);
+		this.withTimezone = config.withTimezone;
+		this.precision = config.precision;
+	}
+	getSQLType() {
+		return `timestamp${this.precision === void 0 ? "" : `(${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
+	}
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return value;
+		const shortened = value.toISOString().slice(0, -1).replace("T", " ");
+		if (this.withTimezone) {
+			const offset = value.getTimezoneOffset();
+			return `${shortened}${offset <= 0 ? "+" : "-"}${Math.floor(Math.abs(offset) / 60).toString().padStart(2, "0")}`;
+		}
+		return shortened;
+	}
+};
+function timestamp(a, b = {}) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (config?.mode === "string") return new PgTimestampStringBuilder(name, config.withTimezone ?? false, config.precision);
+	return new PgTimestampBuilder(name, config?.withTimezone ?? false, config?.precision);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/uuid.js
+var PgUUIDBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgUUIDBuilder";
+	constructor(name) {
+		super(name, "string", "PgUUID");
+	}
+	/**
+	* Adds `default gen_random_uuid()` to the column definition.
+	*/
+	defaultRandom() {
+		return this.default(sql`gen_random_uuid()`);
+	}
+	/** @internal */
+	build(table) {
+		return new PgUUID(table, this.config);
+	}
+};
+var PgUUID = class extends PgColumn {
+	static [entityKind] = "PgUUID";
+	getSQLType() {
+		return "uuid";
+	}
+};
+function uuid(name) {
+	return new PgUUIDBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/varchar.js
+var PgVarcharBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgVarcharBuilder";
+	constructor(name, config) {
+		super(name, "string", "PgVarchar");
+		this.config.length = config.length;
+		this.config.enumValues = config.enum;
+	}
+	/** @internal */
+	build(table) {
+		return new PgVarchar(table, this.config);
+	}
+};
+var PgVarchar = class extends PgColumn {
+	static [entityKind] = "PgVarchar";
+	length = this.config.length;
+	enumValues = this.config.enumValues;
+	getSQLType() {
+		return this.length === void 0 ? `varchar` : `varchar(${this.length})`;
+	}
+};
+function varchar(a, b = {}) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgVarcharBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/vector_extension/bit.js
+var PgBinaryVectorBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgBinaryVectorBuilder";
+	constructor(name, config) {
+		super(name, "string", "PgBinaryVector");
+		this.config.dimensions = config.dimensions;
+	}
+	/** @internal */
+	build(table) {
+		return new PgBinaryVector(table, this.config);
+	}
+};
+var PgBinaryVector = class extends PgColumn {
+	static [entityKind] = "PgBinaryVector";
+	dimensions = this.config.dimensions;
+	getSQLType() {
+		return `bit(${this.dimensions})`;
+	}
+};
+function bit(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgBinaryVectorBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/vector_extension/halfvec.js
+var PgHalfVectorBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgHalfVectorBuilder";
+	constructor(name, config) {
+		super(name, "array", "PgHalfVector");
+		this.config.dimensions = config.dimensions;
+	}
+	/** @internal */
+	build(table) {
+		return new PgHalfVector(table, this.config);
+	}
+};
+var PgHalfVector = class extends PgColumn {
+	static [entityKind] = "PgHalfVector";
+	dimensions = this.config.dimensions;
+	getSQLType() {
+		return `halfvec(${this.dimensions})`;
+	}
+	mapToDriverValue(value) {
+		return JSON.stringify(value);
+	}
+	mapFromDriverValue(value) {
+		return value.slice(1, -1).split(",").map((v) => Number.parseFloat(v));
+	}
+};
+function halfvec(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgHalfVectorBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/vector_extension/sparsevec.js
+var PgSparseVectorBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgSparseVectorBuilder";
+	constructor(name, config) {
+		super(name, "string", "PgSparseVector");
+		this.config.dimensions = config.dimensions;
+	}
+	/** @internal */
+	build(table) {
+		return new PgSparseVector(table, this.config);
+	}
+};
+var PgSparseVector = class extends PgColumn {
+	static [entityKind] = "PgSparseVector";
+	dimensions = this.config.dimensions;
+	getSQLType() {
+		return `sparsevec(${this.dimensions})`;
+	}
+};
+function sparsevec(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgSparseVectorBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/vector_extension/vector.js
+var PgVectorBuilder = class extends PgColumnBuilder {
+	static [entityKind] = "PgVectorBuilder";
+	constructor(name, config) {
+		super(name, "array", "PgVector");
+		this.config.dimensions = config.dimensions;
+	}
+	/** @internal */
+	build(table) {
+		return new PgVector(table, this.config);
+	}
+};
+var PgVector = class extends PgColumn {
+	static [entityKind] = "PgVector";
+	dimensions = this.config.dimensions;
+	getSQLType() {
+		return `vector(${this.dimensions})`;
+	}
+	mapToDriverValue(value) {
+		return JSON.stringify(value);
+	}
+	mapFromDriverValue(value) {
+		return value.slice(1, -1).split(",").map((v) => Number.parseFloat(v));
+	}
+};
+function vector(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	return new PgVectorBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/columns/all.js
+function getPgColumnBuilders() {
+	return {
+		bigint,
+		bigserial,
+		boolean,
+		char,
+		cidr,
+		customType: customType$1,
+		date,
+		doublePrecision,
+		inet,
+		integer: integer$1,
+		interval,
+		json,
+		jsonb,
+		line,
+		macaddr,
+		macaddr8,
+		numeric: numeric$1,
+		point,
+		geometry,
+		real: real$1,
+		serial,
+		smallint,
+		smallserial,
+		text: text$1,
+		time,
+		timestamp,
+		uuid,
+		varchar,
+		bit,
+		halfvec,
+		sparsevec,
+		vector
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/table.js
+const InlineForeignKeys$1 = Symbol.for("drizzle:PgInlineForeignKeys");
+const EnableRLS = Symbol.for("drizzle:EnableRLS");
+var PgTable = class extends Table {
+	static [entityKind] = "PgTable";
+	/** @internal */
+	static Symbol = Object.assign({}, Table.Symbol, {
+		InlineForeignKeys: InlineForeignKeys$1,
+		EnableRLS
+	});
+	/**@internal */
+	[InlineForeignKeys$1] = [];
+	/** @internal */
+	[EnableRLS] = false;
+	/** @internal */
+	[Table.Symbol.ExtraConfigBuilder] = void 0;
+	/** @internal */
+	[Table.Symbol.ExtraConfigColumns] = {};
+};
+function pgTableWithSchema(name, columns, extraConfig, schema, baseName = name) {
+	const rawTable = new PgTable(name, schema, baseName);
+	const parsedColumns = typeof columns === "function" ? columns(getPgColumnBuilders()) : columns;
+	const builtColumns = Object.fromEntries(Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
+		const colBuilder = colBuilderBase;
+		colBuilder.setName(name2);
+		const column = colBuilder.build(rawTable);
+		rawTable[InlineForeignKeys$1].push(...colBuilder.buildForeignKeys(column, rawTable));
+		return [name2, column];
+	}));
+	const builtColumnsForExtraConfig = Object.fromEntries(Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
+		const colBuilder = colBuilderBase;
+		colBuilder.setName(name2);
+		return [name2, colBuilder.buildExtraConfigColumn(rawTable)];
+	}));
+	const table = Object.assign(rawTable, builtColumns);
+	table[Table.Symbol.Columns] = builtColumns;
+	table[Table.Symbol.ExtraConfigColumns] = builtColumnsForExtraConfig;
+	if (extraConfig) table[PgTable.Symbol.ExtraConfigBuilder] = extraConfig;
+	return Object.assign(table, { enableRLS: () => {
+		table[PgTable.Symbol.EnableRLS] = true;
+		return table;
+	} });
+}
+const pgTable = (name, columns, extraConfig) => {
+	return pgTableWithSchema(name, columns, extraConfig, void 0);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/pg-core/indexes.js
+var IndexBuilderOn$1 = class {
+	constructor(unique, name) {
+		this.unique = unique;
+		this.name = name;
+	}
+	static [entityKind] = "PgIndexBuilderOn";
+	on(...columns) {
+		return new IndexBuilder$1(columns.map((it) => {
+			if (is(it, SQL)) return it;
+			it = it;
+			const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType, it.indexConfig);
+			it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+			return clonedIndexedColumn;
+		}), this.unique, false, this.name);
+	}
+	onOnly(...columns) {
+		return new IndexBuilder$1(columns.map((it) => {
+			if (is(it, SQL)) return it;
+			it = it;
+			const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType, it.indexConfig);
+			it.indexConfig = it.defaultConfig;
+			return clonedIndexedColumn;
+		}), this.unique, true, this.name);
+	}
+	/**
+	* Specify what index method to use. Choices are `btree`, `hash`, `gist`, `spgist`, `gin`, `brin`, or user-installed access methods like `bloom`. The default method is `btree.
+	*
+	* If you have the `pg_vector` extension installed in your database, you can use the `hnsw` and `ivfflat` options, which are predefined types.
+	*
+	* **You can always specify any string you want in the method, in case Drizzle doesn't have it natively in its types**
+	*
+	* @param method The name of the index method to be used
+	* @param columns
+	* @returns
+	*/
+	using(method, ...columns) {
+		return new IndexBuilder$1(columns.map((it) => {
+			if (is(it, SQL)) return it;
+			it = it;
+			const clonedIndexedColumn = new IndexedColumn(it.name, !!it.keyAsName, it.columnType, it.indexConfig);
+			it.indexConfig = JSON.parse(JSON.stringify(it.defaultConfig));
+			return clonedIndexedColumn;
+		}), this.unique, true, this.name, method);
+	}
+};
+var IndexBuilder$1 = class {
+	static [entityKind] = "PgIndexBuilder";
+	/** @internal */
+	config;
+	constructor(columns, unique, only, name, method = "btree") {
+		this.config = {
+			name,
+			columns,
+			unique,
+			only,
+			method
+		};
+	}
+	concurrently() {
+		this.config.concurrently = true;
+		return this;
+	}
+	with(obj) {
+		this.config.with = obj;
+		return this;
+	}
+	where(condition) {
+		this.config.where = condition;
+		return this;
+	}
+	/** @internal */
+	build(table) {
+		return new Index$1(this.config, table);
+	}
+};
+var Index$1 = class {
+	static [entityKind] = "PgIndex";
+	config;
+	constructor(config, table) {
+		this.config = {
+			...config,
+			table
+		};
+	}
+};
+function index$1(name) {
+	return new IndexBuilderOn$1(false, name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/sqlite-core/foreign-keys.js
+var ForeignKeyBuilder = class {
+	static [entityKind] = "SQLiteForeignKeyBuilder";
+	/** @internal */
+	reference;
+	/** @internal */
+	_onUpdate;
+	/** @internal */
+	_onDelete;
+	constructor(config, actions) {
+		this.reference = () => {
+			const { name, columns, foreignColumns } = config();
+			return {
+				name,
+				columns,
+				foreignTable: foreignColumns[0].table,
+				foreignColumns
+			};
+		};
+		if (actions) {
+			this._onUpdate = actions.onUpdate;
+			this._onDelete = actions.onDelete;
+		}
+	}
+	onUpdate(action) {
+		this._onUpdate = action;
+		return this;
+	}
+	onDelete(action) {
+		this._onDelete = action;
+		return this;
+	}
+	/** @internal */
+	build(table) {
+		return new ForeignKey(table, this);
+	}
+};
+var ForeignKey = class {
+	constructor(table, builder) {
+		this.table = table;
+		this.reference = builder.reference;
+		this.onUpdate = builder._onUpdate;
+		this.onDelete = builder._onDelete;
+	}
+	static [entityKind] = "SQLiteForeignKey";
+	reference;
+	onUpdate;
+	onDelete;
+	getName() {
+		const { name, columns, foreignColumns } = this.reference();
+		const columnNames = columns.map((column) => column.name);
+		const foreignColumnNames = foreignColumns.map((column) => column.name);
+		const chunks = [
+			this.table[TableName],
+			...columnNames,
+			foreignColumns[0].table[TableName],
+			...foreignColumnNames
+		];
+		return name ?? `${chunks.join("_")}_fk`;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
+function uniqueKeyName(table, columns) {
+	return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/sqlite-core/columns/common.js
+var SQLiteColumnBuilder = class extends ColumnBuilder {
+	static [entityKind] = "SQLiteColumnBuilder";
+	foreignKeyConfigs = [];
+	references(ref, actions = {}) {
+		this.foreignKeyConfigs.push({
+			ref,
+			actions
+		});
+		return this;
+	}
+	unique(name) {
+		this.config.isUnique = true;
+		this.config.uniqueName = name;
+		return this;
+	}
+	generatedAlwaysAs(as, config) {
+		this.config.generated = {
+			as,
+			type: "always",
+			mode: config?.mode ?? "virtual"
+		};
+		return this;
+	}
+	/** @internal */
+	buildForeignKeys(column, table) {
+		return this.foreignKeyConfigs.map(({ ref, actions }) => {
+			return ((ref2, actions2) => {
+				const builder = new ForeignKeyBuilder(() => {
+					const foreignColumn = ref2();
+					return {
+						columns: [column],
+						foreignColumns: [foreignColumn]
+					};
+				});
+				if (actions2.onUpdate) builder.onUpdate(actions2.onUpdate);
+				if (actions2.onDelete) builder.onDelete(actions2.onDelete);
+				return builder.build(table);
+			})(ref, actions);
+		});
+	}
+};
+var SQLiteColumn = class extends Column {
+	constructor(table, config) {
+		if (!config.uniqueName) config.uniqueName = uniqueKeyName(table, [config.name]);
+		super(table, config);
+		this.table = table;
+	}
+	static [entityKind] = "SQLiteColumn";
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/sqlite-core/columns/blob.js
+var SQLiteBigIntBuilder = class extends SQLiteColumnBuilder {
+	static [entityKind] = "SQLiteBigIntBuilder";
+	constructor(name) {
+		super(name, "bigint", "SQLiteBigInt");
+	}
+	/** @internal */
+	build(table) {
+		return new SQLiteBigInt(table, this.config);
+	}
+};
+var SQLiteBigInt = class extends SQLiteColumn {
+	static [entityKind] = "SQLiteBigInt";
+	getSQLType() {
+		return "blob";
+	}
+	mapFromDriverValue(value) {
+		if (typeof Buffer !== "undefined" && Buffer.from) {
+			const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
+			return BigInt(buf.toString("utf8"));
+		}
+		return BigInt(textDecoder.decode(value));
+	}
+	mapToDriverValue(value) {
+		return Buffer.from(value.toString());
+	}
+};
+var SQLiteBlobJsonBuilder = class extends SQLiteColumnBuilder {
+	static [entityKind] = "SQLiteBlobJsonBuilder";
+	constructor(name) {
+		super(name, "json", "SQLiteBlobJson");
+	}
+	/** @internal */
+	build(table) {
+		return new SQLiteBlobJson(table, this.config);
+	}
+};
+var SQLiteBlobJson = class extends SQLiteColumn {
+	static [entityKind] = "SQLiteBlobJson";
+	getSQLType() {
+		return "blob";
+	}
+	mapFromDriverValue(value) {
+		if (typeof Buffer !== "undefined" && Buffer.from) {
+			const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
+			return JSON.parse(buf.toString("utf8"));
+		}
+		return JSON.parse(textDecoder.decode(value));
+	}
+	mapToDriverValue(value) {
+		return Buffer.from(JSON.stringify(value));
+	}
+};
+var SQLiteBlobBufferBuilder = class extends SQLiteColumnBuilder {
+	static [entityKind] = "SQLiteBlobBufferBuilder";
+	constructor(name) {
+		super(name, "buffer", "SQLiteBlobBuffer");
+	}
+	/** @internal */
+	build(table) {
+		return new SQLiteBlobBuffer(table, this.config);
+	}
+};
+var SQLiteBlobBuffer = class extends SQLiteColumn {
+	static [entityKind] = "SQLiteBlobBuffer";
+	mapFromDriverValue(value) {
+		if (Buffer.isBuffer(value)) return value;
+		return Buffer.from(value);
+	}
+	getSQLType() {
+		return "blob";
+	}
+};
+function blob(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (config?.mode === "json") return new SQLiteBlobJsonBuilder(name);
+	if (config?.mode === "bigint") return new SQLiteBigIntBuilder(name);
+	return new SQLiteBlobBufferBuilder(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/sqlite-core/columns/custom.js
+var SQLiteCustomColumnBuilder = class extends SQLiteColumnBuilder {
+	static [entityKind] = "SQLiteCustomColumnBuilder";
+	constructor(name, fieldConfig, customTypeParams) {
+		super(name, "custom", "SQLiteCustomColumn");
+		this.config.fieldConfig = fieldConfig;
+		this.config.customTypeParams = customTypeParams;
+	}
+	/** @internal */
+	build(table) {
+		return new SQLiteCustomColumn(table, this.config);
+	}
+};
+var SQLiteCustomColumn = class extends SQLiteColumn {
+	static [entityKind] = "SQLiteCustomColumn";
+	sqlName;
+	mapTo;
+	mapFrom;
+	constructor(table, config) {
+		super(table, config);
+		this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
+		this.mapTo = config.customTypeParams.toDriver;
+		this.mapFrom = config.customTypeParams.fromDriver;
+	}
+	getSQLType() {
+		return this.sqlName;
+	}
+	mapFromDriverValue(value) {
+		return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
+	}
+	mapToDriverValue(value) {
+		return typeof this.mapTo === "function" ? this.mapTo(value) : value;
+	}
+};
+function customType(customTypeParams) {
+	return (a, b) => {
+		const { name, config } = getColumnNameAndConfig(a, b);
+		return new SQLiteCustomColumnBuilder(name, config, customTypeParams);
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/sqlite-core/columns/integer.js
+var SQLiteBaseIntegerBuilder = class extends SQLiteColumnBuilder {
+	static [entityKind] = "SQLiteBaseIntegerBuilder";
+	constructor(name, dataType, columnType) {
+		super(name, dataType, columnType);
+		this.config.autoIncrement = false;
+	}
+	primaryKey(config) {
+		if (config?.autoIncrement) this.config.autoIncrement = true;
+		this.config.hasDefault = true;
+		return super.primaryKey();
+	}
+};
+var SQLiteBaseInteger = class extends SQLiteColumn {
+	static [entityKind] = "SQLiteBaseInteger";
+	autoIncrement = this.config.autoIncrement;
+	getSQLType() {
+		return "integer";
+	}
+};
+var SQLiteIntegerBuilder = class extends SQLiteBaseIntegerBuilder {
+	static [entityKind] = "SQLiteIntegerBuilder";
+	constructor(name) {
+		super(name, "number", "SQLiteInteger");
+	}
+	build(table) {
+		return new SQLiteInteger(table, this.config);
+	}
+};
+var SQLiteInteger = class extends SQLiteBaseInteger {
+	static [entityKind] = "SQLiteInteger";
+};
+var SQLiteTimestampBuilder = class extends SQLiteBaseIntegerBuilder {
+	static [entityKind] = "SQLiteTimestampBuilder";
+	constructor(name, mode) {
+		super(name, "date", "SQLiteTimestamp");
+		this.config.mode = mode;
+	}
+	/**
+	* @deprecated Use `default()` with your own expression instead.
+	*
+	* Adds `DEFAULT (cast((julianday('now') - 2440587.5)*86400000 as integer))` to the column, which is the current epoch timestamp in milliseconds.
+	*/
+	defaultNow() {
+		return this.default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`);
+	}
+	build(table) {
+		return new SQLiteTimestamp(table, this.config);
+	}
+};
+var SQLiteTimestamp = class extends SQLiteBaseInteger {
+	static [entityKind] = "SQLiteTimestamp";
+	mode = this.config.mode;
+	mapFromDriverValue(value) {
+		if (this.config.mode === "timestamp") return /* @__PURE__ */ new Date(value * 1e3);
+		return new Date(value);
+	}
+	mapToDriverValue(value) {
+		const unix = value.getTime();
+		if (this.config.mode === "timestamp") return Math.floor(unix / 1e3);
+		return unix;
+	}
+};
+var SQLiteBooleanBuilder = class extends SQLiteBaseIntegerBuilder {
+	static [entityKind] = "SQLiteBooleanBuilder";
+	constructor(name, mode) {
+		super(name, "boolean", "SQLiteBoolean");
+		this.config.mode = mode;
+	}
+	build(table) {
+		return new SQLiteBoolean(table, this.config);
+	}
+};
+var SQLiteBoolean = class extends SQLiteBaseInteger {
+	static [entityKind] = "SQLiteBoolean";
+	mode = this.config.mode;
+	mapFromDriverValue(value) {
+		return Number(value) === 1;
+	}
+	mapToDriverValue(value) {
+		return value ? 1 : 0;
+	}
+};
+function integer(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (config?.mode === "timestamp" || config?.mode === "timestamp_ms") return new SQLiteTimestampBuilder(name, config.mode);
+	if (config?.mode === "boolean") return new SQLiteBooleanBuilder(name, config.mode);
+	return new SQLiteIntegerBuilder(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/sqlite-core/columns/numeric.js
+var SQLiteNumericBuilder = class extends SQLiteColumnBuilder {
+	static [entityKind] = "SQLiteNumericBuilder";
+	constructor(name) {
+		super(name, "string", "SQLiteNumeric");
+	}
+	/** @internal */
+	build(table) {
+		return new SQLiteNumeric(table, this.config);
+	}
+};
+var SQLiteNumeric = class extends SQLiteColumn {
+	static [entityKind] = "SQLiteNumeric";
+	mapFromDriverValue(value) {
+		if (typeof value === "string") return value;
+		return String(value);
+	}
+	getSQLType() {
+		return "numeric";
+	}
+};
+var SQLiteNumericNumberBuilder = class extends SQLiteColumnBuilder {
+	static [entityKind] = "SQLiteNumericNumberBuilder";
+	constructor(name) {
+		super(name, "number", "SQLiteNumericNumber");
+	}
+	/** @internal */
+	build(table) {
+		return new SQLiteNumericNumber(table, this.config);
+	}
+};
+var SQLiteNumericNumber = class extends SQLiteColumn {
+	static [entityKind] = "SQLiteNumericNumber";
+	mapFromDriverValue(value) {
+		if (typeof value === "number") return value;
+		return Number(value);
+	}
+	mapToDriverValue = String;
+	getSQLType() {
+		return "numeric";
+	}
+};
+var SQLiteNumericBigIntBuilder = class extends SQLiteColumnBuilder {
+	static [entityKind] = "SQLiteNumericBigIntBuilder";
+	constructor(name) {
+		super(name, "bigint", "SQLiteNumericBigInt");
+	}
+	/** @internal */
+	build(table) {
+		return new SQLiteNumericBigInt(table, this.config);
+	}
+};
+var SQLiteNumericBigInt = class extends SQLiteColumn {
+	static [entityKind] = "SQLiteNumericBigInt";
+	mapFromDriverValue = BigInt;
+	mapToDriverValue = String;
+	getSQLType() {
+		return "numeric";
+	}
+};
+function numeric(a, b) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	const mode = config?.mode;
+	return mode === "number" ? new SQLiteNumericNumberBuilder(name) : mode === "bigint" ? new SQLiteNumericBigIntBuilder(name) : new SQLiteNumericBuilder(name);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/sqlite-core/columns/real.js
+var SQLiteRealBuilder = class extends SQLiteColumnBuilder {
+	static [entityKind] = "SQLiteRealBuilder";
+	constructor(name) {
+		super(name, "number", "SQLiteReal");
+	}
+	/** @internal */
+	build(table) {
+		return new SQLiteReal(table, this.config);
+	}
+};
+var SQLiteReal = class extends SQLiteColumn {
+	static [entityKind] = "SQLiteReal";
+	getSQLType() {
+		return "real";
+	}
+};
+function real(name) {
+	return new SQLiteRealBuilder(name ?? "");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/sqlite-core/columns/text.js
+var SQLiteTextBuilder = class extends SQLiteColumnBuilder {
+	static [entityKind] = "SQLiteTextBuilder";
+	constructor(name, config) {
+		super(name, "string", "SQLiteText");
+		this.config.enumValues = config.enum;
+		this.config.length = config.length;
+	}
+	/** @internal */
+	build(table) {
+		return new SQLiteText(table, this.config);
+	}
+};
+var SQLiteText = class extends SQLiteColumn {
+	static [entityKind] = "SQLiteText";
+	enumValues = this.config.enumValues;
+	length = this.config.length;
+	constructor(table, config) {
+		super(table, config);
+	}
+	getSQLType() {
+		return `text${this.config.length ? `(${this.config.length})` : ""}`;
+	}
+};
+var SQLiteTextJsonBuilder = class extends SQLiteColumnBuilder {
+	static [entityKind] = "SQLiteTextJsonBuilder";
+	constructor(name) {
+		super(name, "json", "SQLiteTextJson");
+	}
+	/** @internal */
+	build(table) {
+		return new SQLiteTextJson(table, this.config);
+	}
+};
+var SQLiteTextJson = class extends SQLiteColumn {
+	static [entityKind] = "SQLiteTextJson";
+	getSQLType() {
+		return "text";
+	}
+	mapFromDriverValue(value) {
+		return JSON.parse(value);
+	}
+	mapToDriverValue(value) {
+		return JSON.stringify(value);
+	}
+};
+function text(a, b = {}) {
+	const { name, config } = getColumnNameAndConfig(a, b);
+	if (config.mode === "json") return new SQLiteTextJsonBuilder(name);
+	return new SQLiteTextBuilder(name, config);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/sqlite-core/columns/all.js
+function getSQLiteColumnBuilders() {
+	return {
+		blob,
+		customType,
+		integer,
+		numeric,
+		real,
+		text
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/sqlite-core/table.js
+const InlineForeignKeys = Symbol.for("drizzle:SQLiteInlineForeignKeys");
+var SQLiteTable = class extends Table {
+	static [entityKind] = "SQLiteTable";
+	/** @internal */
+	static Symbol = Object.assign({}, Table.Symbol, { InlineForeignKeys });
+	/** @internal */
+	[Table.Symbol.Columns];
+	/** @internal */
+	[InlineForeignKeys] = [];
+	/** @internal */
+	[Table.Symbol.ExtraConfigBuilder] = void 0;
+};
+function sqliteTableBase(name, columns, extraConfig, schema, baseName = name) {
+	const rawTable = new SQLiteTable(name, schema, baseName);
+	const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
+	const builtColumns = Object.fromEntries(Object.entries(parsedColumns).map(([name2, colBuilderBase]) => {
+		const colBuilder = colBuilderBase;
+		colBuilder.setName(name2);
+		const column = colBuilder.build(rawTable);
+		rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
+		return [name2, column];
+	}));
+	const table = Object.assign(rawTable, builtColumns);
+	table[Table.Symbol.Columns] = builtColumns;
+	table[Table.Symbol.ExtraConfigColumns] = builtColumns;
+	if (extraConfig) table[SQLiteTable.Symbol.ExtraConfigBuilder] = extraConfig;
+	return table;
+}
+const sqliteTable = (name, columns, extraConfig) => {
+	return sqliteTableBase(name, columns, extraConfig);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@opentelemetry+api@1.9.1_@types+better-sqlite3@7.6.13_@types+pg@8.20_77911661b3ede76946c974aead4d265f/node_modules/drizzle-orm/sqlite-core/indexes.js
+var IndexBuilderOn = class {
+	constructor(name, unique) {
+		this.name = name;
+		this.unique = unique;
+	}
+	static [entityKind] = "SQLiteIndexBuilderOn";
+	on(...columns) {
+		return new IndexBuilder(this.name, columns, this.unique);
+	}
+};
+var IndexBuilder = class {
+	static [entityKind] = "SQLiteIndexBuilder";
+	/** @internal */
+	config;
+	constructor(name, columns, unique) {
+		this.config = {
+			name,
+			columns,
+			unique,
+			where: void 0
+		};
+	}
+	/**
+	* Condition for partial index.
+	*/
+	where(condition) {
+		this.config.where = condition;
+		return this;
+	}
+	/** @internal */
+	build(table) {
+		return new Index(this.config, table);
+	}
+};
+var Index = class {
+	static [entityKind] = "SQLiteIndex";
+	config;
+	constructor(config, table) {
+		this.config = {
+			...config,
+			table
+		};
+	}
+};
+function index(name) {
+	return new IndexBuilderOn(name, false);
+}
+function getDatabaseHandle() {
+	throw new Error("Database not initialized. Call initDatabase() before getDb().");
+}
+const users = pgTable("users", {
+	id: text$1("id").primaryKey(),
+	name: text$1("name").notNull(),
+	email: text$1("email").notNull().unique(),
+	emailVerified: boolean("email_verified").notNull(),
+	image: text$1("image"),
+	preferences: jsonb("preferences"),
+	createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+	updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+});
+const usersSqlite = sqliteTable("users", {
+	id: text("id").primaryKey(),
+	name: text("name").notNull(),
+	email: text("email").notNull().unique(),
+	emailVerified: integer("email_verified", { mode: "boolean" }).notNull(),
+	image: text("image"),
+	preferences: text("preferences", { mode: "json" }),
+	createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull()
+});
+const authAccounts = pgTable("accounts", {
+	id: text$1("id").primaryKey(),
+	accountId: text$1("account_id").notNull(),
+	providerId: text$1("provider_id").notNull(),
+	userId: text$1("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+	accessToken: text$1("access_token"),
+	refreshToken: text$1("refresh_token"),
+	idToken: text$1("id_token"),
+	accessTokenExpiresAt: timestamp("access_token_expires_at", { withTimezone: true }),
+	refreshTokenExpiresAt: timestamp("refresh_token_expires_at", { withTimezone: true }),
+	scope: text$1("scope"),
+	password: text$1("password"),
+	createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+	updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+}, (table) => [index$1("account_user_id_idx").on(table.userId)]);
+const authAccountsSqlite = sqliteTable("accounts", {
+	id: text("id").primaryKey(),
+	accountId: text("account_id").notNull(),
+	providerId: text("provider_id").notNull(),
+	userId: text("user_id").notNull().references(() => usersSqlite.id, { onDelete: "cascade" }),
+	accessToken: text("access_token"),
+	refreshToken: text("refresh_token"),
+	idToken: text("id_token"),
+	accessTokenExpiresAt: integer("access_token_expires_at", { mode: "timestamp_ms" }),
+	refreshTokenExpiresAt: integer("refresh_token_expires_at", { mode: "timestamp_ms" }),
+	scope: text("scope"),
+	password: text("password"),
+	createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull()
+}, (table) => [index("account_user_id_idx").on(table.userId)]);
+const authDeviceCodes = pgTable("device_auth_codes", {
+	id: text$1("id").primaryKey(),
+	deviceCode: text$1("device_code").notNull(),
+	userCode: text$1("user_code").notNull(),
+	userId: text$1("user_id"),
+	expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+	status: text$1("status").notNull(),
+	lastPolledAt: timestamp("last_polled_at", { withTimezone: true }),
+	pollingInterval: integer$1("polling_interval"),
+	clientId: text$1("client_id"),
+	scope: text$1("scope")
+});
+const authDeviceCodesSqlite = sqliteTable("device_auth_codes", {
+	id: text("id").primaryKey(),
+	deviceCode: text("device_code").notNull(),
+	userCode: text("user_code").notNull(),
+	userId: text("user_id"),
+	expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull(),
+	status: text("status").notNull(),
+	lastPolledAt: integer("last_polled_at", { mode: "timestamp_ms" }),
+	pollingInterval: integer("polling_interval"),
+	clientId: text("client_id"),
+	scope: text("scope")
+});
+const authJwks = pgTable("jwks", {
+	id: text$1("id").primaryKey(),
+	publicKey: text$1("public_key").notNull(),
+	privateKey: text$1("private_key").notNull(),
+	createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+	expiresAt: timestamp("expires_at", { withTimezone: true })
+});
+const authJwksSqlite = sqliteTable("jwks", {
+	id: text("id").primaryKey(),
+	publicKey: text("public_key").notNull(),
+	privateKey: text("private_key").notNull(),
+	createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+	expiresAt: integer("expires_at", { mode: "timestamp_ms" })
+});
+const authSessions = pgTable("sessions", {
+	id: text$1("id").primaryKey(),
+	expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+	token: text$1("token").notNull().unique(),
+	createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+	updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+	ipAddress: text$1("ip_address"),
+	userAgent: text$1("user_agent"),
+	userId: text$1("user_id").notNull().references(() => users.id, { onDelete: "cascade" })
+}, (table) => [index$1("session_user_id_idx").on(table.userId)]);
+const authSessionsSqlite = sqliteTable("sessions", {
+	id: text("id").primaryKey(),
+	expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull(),
+	token: text("token").notNull().unique(),
+	createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull(),
+	ipAddress: text("ip_address"),
+	userAgent: text("user_agent"),
+	userId: text("user_id").notNull().references(() => usersSqlite.id, { onDelete: "cascade" })
+}, (table) => [index("session_user_id_idx").on(table.userId)]);
+const authVerifications = pgTable("verification", {
+	id: text$1("id").primaryKey(),
+	identifier: text$1("identifier").notNull(),
+	value: text$1("value").notNull(),
+	expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+	createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+	updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+}, (table) => [index$1("verification_identifier_idx").on(table.identifier)]);
+const authVerificationsSqlite = sqliteTable("verification", {
+	id: text("id").primaryKey(),
+	identifier: text("identifier").notNull(),
+	value: text("value").notNull(),
+	expiresAt: integer("expires_at", { mode: "timestamp_ms" }).notNull(),
+	createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull()
+}, (table) => [index("verification_identifier_idx").on(table.identifier)]);
+//#endregion
 //#region ../../packages/platform-database/dist/schema/auth/index.mjs
-function authSchemaFor(dialect = require_dist$4.getDatabaseHandle().dialect) {
+function authSchemaFor(dialect = getDatabaseHandle().dialect) {
 	if (dialect === "sqlite") return {
-		users: require_dist$4.usersSqlite,
-		session: require_dist$4.authSessionsSqlite,
-		account: require_dist$4.authAccountsSqlite,
-		verification: require_dist$4.authVerificationsSqlite,
-		deviceCode: require_dist$4.authDeviceCodesSqlite,
-		jwks: require_dist$4.authJwksSqlite
+		users: usersSqlite,
+		session: authSessionsSqlite,
+		account: authAccountsSqlite,
+		verification: authVerificationsSqlite,
+		deviceCode: authDeviceCodesSqlite,
+		jwks: authJwksSqlite
 	};
 	return {
-		users: require_dist$4.users,
-		session: require_dist$4.authSessions,
-		account: require_dist$4.authAccounts,
-		verification: require_dist$4.authVerifications,
-		deviceCode: require_dist$4.authDeviceCodes,
-		jwks: require_dist$4.authJwks
+		users,
+		session: authSessions,
+		account: authAccounts,
+		verification: authVerifications,
+		deviceCode: authDeviceCodes,
+		jwks: authJwks
 	};
 }
-function authDatabaseAdapterOptions(dialect = require_dist$4.getDatabaseHandle().dialect) {
+function authDatabaseAdapterOptions(dialect = getDatabaseHandle().dialect) {
 	return {
 		provider: dialect === "sqlite" ? "sqlite" : "pg",
 		schema: authSchemaFor(dialect)
@@ -1323,7 +4313,7 @@ function authDatabaseAdapterOptions(dialect = require_dist$4.getDatabaseHandle()
 }
 /** Better Auth database adapter wired to the active Drizzle handle. */
 function createAuthDatabaseAdapter() {
-	const { db } = require_dist$4.getDatabaseHandle();
+	const { db } = getDatabaseHandle();
 	const { provider, schema } = authDatabaseAdapterOptions();
 	return (0, _better_auth_drizzle_adapter.drizzleAdapter)(db, {
 		provider,
@@ -1356,7 +4346,7 @@ function createCliDeviceOrganizationPlugin() {
 				error: "invalid_request",
 				error_description: "Organization id is required"
 			});
-			if (!await require_dist$4.selectUserOrganizationMembership(session.user.id, organizationId)) throw new better_auth_api.APIError("FORBIDDEN", {
+			if (!await (0, _keystrokehq_platform_database.selectUserOrganizationMembership)(session.user.id, organizationId)) throw new better_auth_api.APIError("FORBIDDEN", {
 				error: "access_denied",
 				error_description: "You are not a member of this organization"
 			});
@@ -1493,8 +4483,8 @@ function resolveSocialProviders() {
 	return Object.keys(providers).length > 0 ? providers : void 0;
 }
 async function linkUserCreateBeforeHook(user) {
-	const email = require_dist$4.normalizeUserEmail(user.email);
-	const existing = await require_dist$4.selectUserByNormalizedEmail(email);
+	const email = (0, _keystrokehq_platform_database.normalizeUserEmail)(user.email);
+	const existing = await (0, _keystrokehq_platform_database.selectUserByNormalizedEmail)(email);
 	if (existing) return {
 		data: {
 			...user,
@@ -25112,43 +28102,43 @@ var tt = [
 	},
 	{
 		name: "cat",
-		load: async () => (await Promise.resolve().then(() => require("./cat-TSFMZVYS-CoIsiESf.cjs"))).catCommand
+		load: async () => (await Promise.resolve().then(() => require("./cat-TSFMZVYS-DA84HtAp.cjs"))).catCommand
 	},
 	{
 		name: "printf",
-		load: async () => (await Promise.resolve().then(() => require("./printf-TWGXF445-RWHVX5FV.cjs"))).printfCommand
+		load: async () => (await Promise.resolve().then(() => require("./printf-TWGXF445-B0tOxQT6.cjs"))).printfCommand
 	},
 	{
 		name: "ls",
-		load: async () => (await Promise.resolve().then(() => require("./ls-ZJGQER7M-BYVAD1YO.cjs"))).lsCommand
+		load: async () => (await Promise.resolve().then(() => require("./ls-ZJGQER7M-CynOwieQ.cjs"))).lsCommand
 	},
 	{
 		name: "mkdir",
-		load: async () => (await Promise.resolve().then(() => require("./mkdir-MEPGZOB6-BY2rSz4n.cjs"))).mkdirCommand
+		load: async () => (await Promise.resolve().then(() => require("./mkdir-MEPGZOB6-Z0WHNFtR.cjs"))).mkdirCommand
 	},
 	{
 		name: "rmdir",
-		load: async () => (await Promise.resolve().then(() => require("./rmdir-OC4ZLPYA-BuPVwHWE.cjs"))).rmdirCommand
+		load: async () => (await Promise.resolve().then(() => require("./rmdir-OC4ZLPYA-DrF3bZoQ.cjs"))).rmdirCommand
 	},
 	{
 		name: "touch",
-		load: async () => (await Promise.resolve().then(() => require("./touch-UA33VN3N-DazOwQQS.cjs"))).touchCommand
+		load: async () => (await Promise.resolve().then(() => require("./touch-UA33VN3N-DIda6f8u.cjs"))).touchCommand
 	},
 	{
 		name: "rm",
-		load: async () => (await Promise.resolve().then(() => require("./rm-SSGETQVQ-bPTxcRcX.cjs"))).rmCommand
+		load: async () => (await Promise.resolve().then(() => require("./rm-SSGETQVQ-BSLrKStW.cjs"))).rmCommand
 	},
 	{
 		name: "cp",
-		load: async () => (await Promise.resolve().then(() => require("./cp-BISAAS7A-BTlFdjse.cjs"))).cpCommand
+		load: async () => (await Promise.resolve().then(() => require("./cp-BISAAS7A-CPlXYVs4.cjs"))).cpCommand
 	},
 	{
 		name: "mv",
-		load: async () => (await Promise.resolve().then(() => require("./mv-W5BIQ646-DmAtW345.cjs"))).mvCommand
+		load: async () => (await Promise.resolve().then(() => require("./mv-W5BIQ646-tAPnueJb.cjs"))).mvCommand
 	},
 	{
 		name: "ln",
-		load: async () => (await Promise.resolve().then(() => require("./ln-4LGSXXGD-lLnmqTxq.cjs"))).lnCommand
+		load: async () => (await Promise.resolve().then(() => require("./ln-4LGSXXGD-DxTw2TAq.cjs"))).lnCommand
 	},
 	{
 		name: "chmod",
@@ -25164,15 +28154,15 @@ var tt = [
 	},
 	{
 		name: "head",
-		load: async () => (await Promise.resolve().then(() => require("./head-442HYESI-_I53Pnb1.cjs"))).headCommand
+		load: async () => (await Promise.resolve().then(() => require("./head-442HYESI-Dh7Qcjzs.cjs"))).headCommand
 	},
 	{
 		name: "tail",
-		load: async () => (await Promise.resolve().then(() => require("./tail-R4PCA2C4-CtnCdzuO.cjs"))).tailCommand
+		load: async () => (await Promise.resolve().then(() => require("./tail-R4PCA2C4-CLtu5GPs.cjs"))).tailCommand
 	},
 	{
 		name: "wc",
-		load: async () => (await Promise.resolve().then(() => require("./wc-LF7NU4LA-Dha3d9oq.cjs"))).wcCommand
+		load: async () => (await Promise.resolve().then(() => require("./wc-LF7NU4LA-Ci3_hJug.cjs"))).wcCommand
 	},
 	{
 		name: "stat",
@@ -25180,95 +28170,95 @@ var tt = [
 	},
 	{
 		name: "grep",
-		load: async () => (await Promise.resolve().then(() => require("./grep-V3LQVMRQ-Ds_E1Mcg.cjs"))).grepCommand
+		load: async () => (await Promise.resolve().then(() => require("./grep-V3LQVMRQ-CnT0y0-P.cjs"))).grepCommand
 	},
 	{
 		name: "fgrep",
-		load: async () => (await Promise.resolve().then(() => require("./grep-V3LQVMRQ-Ds_E1Mcg.cjs"))).fgrepCommand
+		load: async () => (await Promise.resolve().then(() => require("./grep-V3LQVMRQ-CnT0y0-P.cjs"))).fgrepCommand
 	},
 	{
 		name: "egrep",
-		load: async () => (await Promise.resolve().then(() => require("./grep-V3LQVMRQ-Ds_E1Mcg.cjs"))).egrepCommand
+		load: async () => (await Promise.resolve().then(() => require("./grep-V3LQVMRQ-CnT0y0-P.cjs"))).egrepCommand
 	},
 	{
 		name: "rg",
-		load: async () => (await Promise.resolve().then(() => require("./rg-S4FXYXWB-CfvW0egS.cjs"))).rgCommand
+		load: async () => (await Promise.resolve().then(() => require("./rg-S4FXYXWB-ByK2CLxu.cjs"))).rgCommand
 	},
 	{
 		name: "sed",
-		load: async () => (await Promise.resolve().then(() => require("./sed-S5UIK574-CedHHKip.cjs"))).sedCommand
+		load: async () => (await Promise.resolve().then(() => require("./sed-S5UIK574-B3Klx8N4.cjs"))).sedCommand
 	},
 	{
 		name: "awk",
-		load: async () => (await Promise.resolve().then(() => require("./awk2-LA3USKJP-BNV-PUu0.cjs"))).awkCommand2
+		load: async () => (await Promise.resolve().then(() => require("./awk2-LA3USKJP-Ddh1vPYe.cjs"))).awkCommand2
 	},
 	{
 		name: "sort",
-		load: async () => (await Promise.resolve().then(() => require("./sort-SW2YEO5B-CNvaPgBI.cjs"))).sortCommand
+		load: async () => (await Promise.resolve().then(() => require("./sort-SW2YEO5B-DIDExLis.cjs"))).sortCommand
 	},
 	{
 		name: "uniq",
-		load: async () => (await Promise.resolve().then(() => require("./uniq-XSIZR6PB-D1uH-xXs.cjs"))).uniqCommand
+		load: async () => (await Promise.resolve().then(() => require("./uniq-XSIZR6PB-BhdgA9iI.cjs"))).uniqCommand
 	},
 	{
 		name: "comm",
-		load: async () => (await Promise.resolve().then(() => require("./comm-VV2LDX2J-Ct7AXc22.cjs"))).commCommand
+		load: async () => (await Promise.resolve().then(() => require("./comm-VV2LDX2J-CSfuzlYr.cjs"))).commCommand
 	},
 	{
 		name: "cut",
-		load: async () => (await Promise.resolve().then(() => require("./cut-OKARJCCV-LemaM014.cjs"))).cutCommand
+		load: async () => (await Promise.resolve().then(() => require("./cut-OKARJCCV-Ci0PtEgB.cjs"))).cutCommand
 	},
 	{
 		name: "paste",
-		load: async () => (await Promise.resolve().then(() => require("./paste-7JC6S4DX-C-0O4u2q.cjs"))).pasteCommand
+		load: async () => (await Promise.resolve().then(() => require("./paste-7JC6S4DX-Bs8ByIXb.cjs"))).pasteCommand
 	},
 	{
 		name: "tr",
-		load: async () => (await Promise.resolve().then(() => require("./tr-36LHWFRQ-CrF6131T.cjs"))).trCommand
+		load: async () => (await Promise.resolve().then(() => require("./tr-36LHWFRQ-COkRmY_6.cjs"))).trCommand
 	},
 	{
 		name: "rev",
-		load: async () => (await Promise.resolve().then(() => require("./rev-5EHFX4EJ-gMcdZInq.cjs"))).rev
+		load: async () => (await Promise.resolve().then(() => require("./rev-5EHFX4EJ-Cgya-Fo0.cjs"))).rev
 	},
 	{
 		name: "nl",
-		load: async () => (await Promise.resolve().then(() => require("./nl-WSDW7I4O-DqGjVldy.cjs"))).nl
+		load: async () => (await Promise.resolve().then(() => require("./nl-WSDW7I4O-BfBF-iiF.cjs"))).nl
 	},
 	{
 		name: "fold",
-		load: async () => (await Promise.resolve().then(() => require("./fold-4TQNYMSW-C4KhiKXo.cjs"))).fold
+		load: async () => (await Promise.resolve().then(() => require("./fold-4TQNYMSW-DU7ysgn3.cjs"))).fold
 	},
 	{
 		name: "expand",
-		load: async () => (await Promise.resolve().then(() => require("./expand-JSPG6VOP-BDy27RvB.cjs"))).expand
+		load: async () => (await Promise.resolve().then(() => require("./expand-JSPG6VOP-DjHywCfM.cjs"))).expand
 	},
 	{
 		name: "unexpand",
-		load: async () => (await Promise.resolve().then(() => require("./unexpand-CADSA4VO-BwtCgpf8.cjs"))).unexpand
+		load: async () => (await Promise.resolve().then(() => require("./unexpand-CADSA4VO-DekKk-hg.cjs"))).unexpand
 	},
 	{
 		name: "strings",
-		load: async () => (await Promise.resolve().then(() => require("./strings-6WDHLGMX-CHWp5DnU.cjs"))).strings
+		load: async () => (await Promise.resolve().then(() => require("./strings-6WDHLGMX-D2bfJpyh.cjs"))).strings
 	},
 	{
 		name: "split",
-		load: async () => (await Promise.resolve().then(() => require("./split-4KKZZXXE-nt0tLTli.cjs"))).split
+		load: async () => (await Promise.resolve().then(() => require("./split-4KKZZXXE-CSVvRIzD.cjs"))).split
 	},
 	{
 		name: "column",
-		load: async () => (await Promise.resolve().then(() => require("./column-XT6UFXNQ-CjqSbReY.cjs"))).column
+		load: async () => (await Promise.resolve().then(() => require("./column-XT6UFXNQ-D-31htgy.cjs"))).column
 	},
 	{
 		name: "join",
-		load: async () => (await Promise.resolve().then(() => require("./join-TBRGI3LQ-C-dsbt1O.cjs"))).join
+		load: async () => (await Promise.resolve().then(() => require("./join-TBRGI3LQ-DR2e5mf6.cjs"))).join
 	},
 	{
 		name: "tee",
-		load: async () => (await Promise.resolve().then(() => require("./tee-YUZ2FKCJ-DJYybbg7.cjs"))).teeCommand
+		load: async () => (await Promise.resolve().then(() => require("./tee-YUZ2FKCJ-BbxSWxw6.cjs"))).teeCommand
 	},
 	{
 		name: "find",
-		load: async () => (await Promise.resolve().then(() => require("./find-INTH3OLC-D6LkPRVn.cjs"))).findCommand
+		load: async () => (await Promise.resolve().then(() => require("./find-INTH3OLC-B5hj2iWq.cjs"))).findCommand
 	},
 	{
 		name: "basename",
@@ -25280,19 +28270,19 @@ var tt = [
 	},
 	{
 		name: "tree",
-		load: async () => (await Promise.resolve().then(() => require("./tree-YLD52CNT-u4cOkoBM.cjs"))).treeCommand
+		load: async () => (await Promise.resolve().then(() => require("./tree-YLD52CNT-kZ9vPZ-R.cjs"))).treeCommand
 	},
 	{
 		name: "du",
-		load: async () => (await Promise.resolve().then(() => require("./du-572XNP42-3RIhvC5P.cjs"))).duCommand
+		load: async () => (await Promise.resolve().then(() => require("./du-572XNP42-BnHmg4U2.cjs"))).duCommand
 	},
 	{
 		name: "env",
-		load: async () => (await Promise.resolve().then(() => require("./env-36M5BO7M-D_8C_5X5.cjs"))).envCommand
+		load: async () => (await Promise.resolve().then(() => require("./env-36M5BO7M-BxusWRsf.cjs"))).envCommand
 	},
 	{
 		name: "printenv",
-		load: async () => (await Promise.resolve().then(() => require("./env-36M5BO7M-D_8C_5X5.cjs"))).printenvCommand
+		load: async () => (await Promise.resolve().then(() => require("./env-36M5BO7M-BxusWRsf.cjs"))).printenvCommand
 	},
 	{
 		name: "alias",
@@ -25308,7 +28298,7 @@ var tt = [
 	},
 	{
 		name: "xargs",
-		load: async () => (await Promise.resolve().then(() => require("./xargs-MGZPH7AX-BX6HS5mB.cjs"))).xargsCommand
+		load: async () => (await Promise.resolve().then(() => require("./xargs-MGZPH7AX-DNyBXxK4.cjs"))).xargsCommand
 	},
 	{
 		name: "true",
@@ -25324,23 +28314,23 @@ var tt = [
 	},
 	{
 		name: "bash",
-		load: async () => (await Promise.resolve().then(() => require("./bash-YZ33HQZQ-DafyaX5Y.cjs"))).bashCommand
+		load: async () => (await Promise.resolve().then(() => require("./bash-YZ33HQZQ-CSOYNHWg.cjs"))).bashCommand
 	},
 	{
 		name: "sh",
-		load: async () => (await Promise.resolve().then(() => require("./bash-YZ33HQZQ-DafyaX5Y.cjs"))).shCommand
+		load: async () => (await Promise.resolve().then(() => require("./bash-YZ33HQZQ-CSOYNHWg.cjs"))).shCommand
 	},
 	{
 		name: "jq",
-		load: async () => (await Promise.resolve().then(() => require("./jq-4XLYLOS5-DwRPL82B.cjs"))).jqCommand
+		load: async () => (await Promise.resolve().then(() => require("./jq-4XLYLOS5-CKdOTiVR.cjs"))).jqCommand
 	},
 	{
 		name: "base64",
-		load: async () => (await Promise.resolve().then(() => require("./base64-C2AIWVNC-Ca8wsOx8.cjs"))).base64Command
+		load: async () => (await Promise.resolve().then(() => require("./base64-C2AIWVNC-BaiY8WTm.cjs"))).base64Command
 	},
 	{
 		name: "diff",
-		load: async () => (await Promise.resolve().then(() => require("./diff-MWJFIG7X-CM3vdBmY.cjs"))).diffCommand
+		load: async () => (await Promise.resolve().then(() => require("./diff-MWJFIG7X-F82OACp-.cjs"))).diffCommand
 	},
 	{
 		name: "date",
@@ -25348,15 +28338,15 @@ var tt = [
 	},
 	{
 		name: "sleep",
-		load: async () => (await Promise.resolve().then(() => require("./sleep-X22JJINO-Dx_bFfIX.cjs"))).sleepCommand
+		load: async () => (await Promise.resolve().then(() => require("./sleep-X22JJINO-UJvessts.cjs"))).sleepCommand
 	},
 	{
 		name: "timeout",
-		load: async () => (await Promise.resolve().then(() => require("./timeout-YDCRSLPQ-C2SC5vB7.cjs"))).timeoutCommand
+		load: async () => (await Promise.resolve().then(() => require("./timeout-YDCRSLPQ-DEPvQ6Ih.cjs"))).timeoutCommand
 	},
 	{
 		name: "time",
-		load: async () => (await Promise.resolve().then(() => require("./time-D4LNBSWX-DNNPSFOx.cjs"))).timeCommand
+		load: async () => (await Promise.resolve().then(() => require("./time-D4LNBSWX-BQSWzFeK.cjs"))).timeCommand
 	},
 	{
 		name: "seq",
@@ -25364,19 +28354,19 @@ var tt = [
 	},
 	{
 		name: "expr",
-		load: async () => (await Promise.resolve().then(() => require("./expr-5JAACS4X-z-ugAUQD.cjs"))).exprCommand
+		load: async () => (await Promise.resolve().then(() => require("./expr-5JAACS4X-Df3xFZ4w.cjs"))).exprCommand
 	},
 	{
 		name: "md5sum",
-		load: async () => (await Promise.resolve().then(() => require("./md5sum-SPU24VSG-BXWbsDvm.cjs"))).md5sumCommand
+		load: async () => (await Promise.resolve().then(() => require("./md5sum-SPU24VSG-8_h79vAu.cjs"))).md5sumCommand
 	},
 	{
 		name: "sha1sum",
-		load: async () => (await Promise.resolve().then(() => require("./sha1sum-2PTOAFR6-CkkcLEco.cjs"))).sha1sumCommand
+		load: async () => (await Promise.resolve().then(() => require("./sha1sum-2PTOAFR6-Bl7iC2ql.cjs"))).sha1sumCommand
 	},
 	{
 		name: "sha256sum",
-		load: async () => (await Promise.resolve().then(() => require("./sha256sum-NS7D3IXX-Czd21v8R.cjs"))).sha256sumCommand
+		load: async () => (await Promise.resolve().then(() => require("./sha256sum-NS7D3IXX-DdD-z8yU.cjs"))).sha256sumCommand
 	},
 	{
 		name: "file",
@@ -25384,11 +28374,11 @@ var tt = [
 	},
 	{
 		name: "html-to-markdown",
-		load: async () => (await Promise.resolve().then(() => require("./html-to-markdown-JW4MSQZO-CxCkv6Mj.cjs"))).htmlToMarkdownCommand
+		load: async () => (await Promise.resolve().then(() => require("./html-to-markdown-JW4MSQZO-CD4oQKoL.cjs"))).htmlToMarkdownCommand
 	},
 	{
 		name: "help",
-		load: async () => (await Promise.resolve().then(() => require("./help-HZ6M2CKN-C_gwqv6N.cjs"))).helpCommand
+		load: async () => (await Promise.resolve().then(() => require("./help-HZ6M2CKN-pRM3zbwR.cjs"))).helpCommand
 	},
 	{
 		name: "which",
@@ -25396,7 +28386,7 @@ var tt = [
 	},
 	{
 		name: "tac",
-		load: async () => (await Promise.resolve().then(() => require("./tac-2STMMJYW-DJvRhvlJ.cjs"))).tac
+		load: async () => (await Promise.resolve().then(() => require("./tac-2STMMJYW-D0fFvjly.cjs"))).tac
 	},
 	{
 		name: "hostname",
@@ -25408,49 +28398,49 @@ var tt = [
 	},
 	{
 		name: "od",
-		load: async () => (await Promise.resolve().then(() => require("./od-WOKFDJTP-BNpft7pj.cjs"))).od
+		load: async () => (await Promise.resolve().then(() => require("./od-WOKFDJTP-CHXPdcv9.cjs"))).od
 	},
 	{
 		name: "gzip",
-		load: async () => (await Promise.resolve().then(() => require("./gzip-O5ASJAFY-MdBB0FQ4.cjs"))).gzipCommand
+		load: async () => (await Promise.resolve().then(() => require("./gzip-O5ASJAFY-Dwnbh7Hd.cjs"))).gzipCommand
 	},
 	{
 		name: "gunzip",
-		load: async () => (await Promise.resolve().then(() => require("./gzip-O5ASJAFY-MdBB0FQ4.cjs"))).gunzipCommand
+		load: async () => (await Promise.resolve().then(() => require("./gzip-O5ASJAFY-Dwnbh7Hd.cjs"))).gunzipCommand
 	},
 	{
 		name: "zcat",
-		load: async () => (await Promise.resolve().then(() => require("./gzip-O5ASJAFY-MdBB0FQ4.cjs"))).zcatCommand
+		load: async () => (await Promise.resolve().then(() => require("./gzip-O5ASJAFY-Dwnbh7Hd.cjs"))).zcatCommand
 	}
 ];
 (typeof __BROWSER__ > "u" || !__BROWSER__) && (tt.push({
 	name: "tar",
-	load: async () => (await Promise.resolve().then(() => require("./tar-STHHZTZ6-Btz1HNi9.cjs"))).tarCommand
+	load: async () => (await Promise.resolve().then(() => require("./tar-STHHZTZ6-Bxk0yG7D.cjs"))).tarCommand
 }), tt.push({
 	name: "yq",
-	load: async () => (await Promise.resolve().then(() => require("./yq-4QJW3EQG-CqoPq62R.cjs"))).yqCommand
+	load: async () => (await Promise.resolve().then(() => require("./yq-4QJW3EQG-9kH_HlxF.cjs"))).yqCommand
 }), tt.push({
 	name: "xan",
-	load: async () => (await Promise.resolve().then(() => require("./xan-Y6WF3IRG-DF8LgdcK.cjs"))).xanCommand
+	load: async () => (await Promise.resolve().then(() => require("./xan-Y6WF3IRG-EnrntEIM.cjs"))).xanCommand
 }), tt.push({
 	name: "sqlite3",
-	load: async () => (await Promise.resolve().then(() => require("./sqlite3-CGOEFJAO-BWLd6W0g.cjs"))).sqlite3Command
+	load: async () => (await Promise.resolve().then(() => require("./sqlite3-CGOEFJAO-DTNqDMXu.cjs"))).sqlite3Command
 }));
 var Yt = [];
 (typeof __BROWSER__ > "u" || !__BROWSER__) && (Yt.push({
 	name: "python3",
-	load: async () => (await Promise.resolve().then(() => require("./python3-POMOR4OA-BuqCCpBS.cjs"))).python3Command
+	load: async () => (await Promise.resolve().then(() => require("./python3-POMOR4OA-DYjQ3ccZ.cjs"))).python3Command
 }), Yt.push({
 	name: "python",
-	load: async () => (await Promise.resolve().then(() => require("./python3-POMOR4OA-BuqCCpBS.cjs"))).pythonCommand
+	load: async () => (await Promise.resolve().then(() => require("./python3-POMOR4OA-DYjQ3ccZ.cjs"))).pythonCommand
 }));
 var Qt = [];
 (typeof __BROWSER__ > "u" || !__BROWSER__) && (Qt.push({
 	name: "js-exec",
-	load: async () => (await Promise.resolve().then(() => require("./js-exec-N5KEZBH7-C-U_T49T.cjs"))).jsExecCommand
+	load: async () => (await Promise.resolve().then(() => require("./js-exec-N5KEZBH7-8xgWmlL7.cjs"))).jsExecCommand
 }), Qt.push({
 	name: "node",
-	load: async () => (await Promise.resolve().then(() => require("./js-exec-N5KEZBH7-C-U_T49T.cjs"))).nodeStubCommand
+	load: async () => (await Promise.resolve().then(() => require("./js-exec-N5KEZBH7-8xgWmlL7.cjs"))).nodeStubCommand
 }));
 new TextEncoder();
 Object.freeze({
@@ -25938,7 +28928,7 @@ function decryptSecretPayload(ciphertext) {
 	return Buffer.concat([decipher.update(encrypted), decipher.final()]).toString("utf8");
 }
 function usePlatformStore() {
-	return require_dist$4.getOrganizationScopeId() !== void 0;
+	return (0, _keystrokehq_platform_database.getOrganizationScopeId)() !== void 0;
 }
 function assertOrganizationScope() {
 	if (!usePlatformStore()) throw new Error("Secret store requires organization scope");
@@ -25947,7 +28937,7 @@ function createSecretStore() {
 	return {
 		async get(ref) {
 			assertOrganizationScope();
-			const row = await require_dist$4.selectSecretValue(ref.kind, ref.id, ref.field);
+			const row = await (0, _keystrokehq_platform_database.selectSecretValue)(ref.kind, ref.id, ref.field);
 			if (!row) return null;
 			return decryptSecretPayload(row.ciphertext);
 		},
@@ -25955,7 +28945,7 @@ function createSecretStore() {
 			assertOrganizationScope();
 			const now = /* @__PURE__ */ new Date();
 			const ciphertext = encryptSecretPayload(plaintext);
-			await require_dist$4.upsertSecretValue({
+			await (0, _keystrokehq_platform_database.upsertSecretValue)({
 				id: crypto.randomUUID(),
 				refKind: ref.kind,
 				refId: ref.id,
@@ -25967,7 +28957,7 @@ function createSecretStore() {
 		},
 		async deleteRef(kind, id) {
 			assertOrganizationScope();
-			await require_dist$4.deleteSecretValuesForRef(kind, id);
+			await (0, _keystrokehq_platform_database.deleteSecretValuesForRef)(kind, id);
 		}
 	};
 }
@@ -25980,7 +28970,7 @@ async function setCredentialInstanceSecret(options) {
 		scopeId: options.scopeId,
 		exceptId: options.id
 	});
-	if (require_dist$4.getOrganizationScopeId() !== void 0) {
+	if ((0, _keystrokehq_platform_database.getOrganizationScopeId)() !== void 0) {
 		await (0, _keystrokehq_database.upsertCredentialInstance)({
 			id: options.id,
 			slug: options.key,
@@ -26016,7 +29006,7 @@ async function setCredentialInstanceSecret(options) {
 	});
 }
 async function readCredentialInstanceSecret(instanceId) {
-	if (require_dist$4.getOrganizationScopeId() === void 0) return null;
+	if ((0, _keystrokehq_platform_database.getOrganizationScopeId)() === void 0) return null;
 	return createSecretStore().get({
 		kind: "credential_instance",
 		id: instanceId,
@@ -26024,7 +29014,7 @@ async function readCredentialInstanceSecret(instanceId) {
 	});
 }
 async function deleteCredentialInstanceSecret(instanceId) {
-	if (require_dist$4.getOrganizationScopeId() === void 0) return;
+	if ((0, _keystrokehq_platform_database.getOrganizationScopeId)() === void 0) return;
 	await createSecretStore().deleteRef("credential_instance", instanceId);
 }
 //#endregion
@@ -47930,11 +50920,11 @@ async function resolveDeployManifest(input) {
 }
 /** Cut over activeArtifactId, then sync org project registry from the artifact manifest. */
 async function promoteProjectDeploy(input) {
-	const project = await require_dist$4.selectProjectById(input.projectId);
+	const project = await (0, _keystrokehq_platform_database.selectProjectById)(input.projectId);
 	if (!project) throw new Error(`Project ${input.projectId} not found`);
-	const artifact = await require_dist$4.selectProjectArtifactById(input.artifactId);
+	const artifact = await (0, _keystrokehq_platform_database.selectProjectArtifactById)(input.artifactId);
 	if (!artifact || artifact.projectId !== input.projectId) throw new Error(`Artifact ${input.artifactId} not found for project ${input.projectId}`);
-	const organization = await require_dist$4.selectOrganizationById(project.organizationId);
+	const organization = await (0, _keystrokehq_platform_database.selectOrganizationById)(project.organizationId);
 	if (!organization) throw new Error(`Organization not found for project ${input.projectId}`);
 	if (!input.artifactBytes && artifact.manifestJson == null) throw new require_dist$2.RouteManifestNotFoundError("Artifact has no stored route manifest; rebuild and redeploy");
 	const manifest = await resolveDeployManifest({
@@ -47942,18 +50932,18 @@ async function promoteProjectDeploy(input) {
 		artifactManifest: artifact.manifestJson,
 		artifactBytes: input.artifactBytes ?? Buffer.alloc(0)
 	});
-	if (artifact.manifestJson == null) await require_dist$4.updateProjectArtifactManifest({
+	if (artifact.manifestJson == null) await (0, _keystrokehq_platform_database.updateProjectArtifactManifest)({
 		artifactId: input.artifactId,
 		manifestJson: manifest
 	});
-	if (project.pendingArtifactId === input.artifactId) await require_dist$4.promoteProjectArtifact({
+	if (project.pendingArtifactId === input.artifactId) await (0, _keystrokehq_platform_database.promoteProjectArtifact)({
 		projectId: input.projectId,
 		artifactId: input.artifactId
 	});
 	else if (project.activeArtifactId !== input.artifactId) throw new Error(`Artifact ${input.artifactId} is not the pending deploy for project ${input.projectId}`);
 	const ephemeralRoutes = [];
 	await (0, _keystrokehq_database.runWithProjectDatabase)({
-		url: require_dist$4.resolveOrgDatabaseUrl(organization),
+		url: (0, _keystrokehq_platform_database.resolveOrgDatabaseUrl)(organization),
 		searchPath: organization.dbSchema
 	}, async () => (0, _keystrokehq_database.runWithProjectScope)(project.id, async () => {
 		await (0, _keystrokehq_runtime.syncRegistryFromStoredManifest)(manifest);
@@ -47969,7 +50959,7 @@ async function promoteProjectDeploy(input) {
 		});
 	}));
 	const webhookRoutes = [...(0, _keystrokehq_runtime.extractWebhookRoutesFromManifest)(manifest), ...ephemeralRoutes];
-	if (webhookRoutes.length > 0) await require_dist$4.ensureWebhookApiKeys(project.id, webhookRoutes, project.id);
+	if (webhookRoutes.length > 0) await (0, _keystrokehq_platform_database.ensureWebhookApiKeys)(project.id, webhookRoutes, project.id);
 }
 /** Decide whether a pg-boss job should start runtime, skip as stale, or fail. */
 function resolveRuntimeArtifact(project, jobArtifactId) {
@@ -48035,7 +51025,7 @@ async function handleProjectRuntimeJob(runtime, resolveStartInput, payload) {
 	if (payload.kind !== "runtime") return;
 	const job = toProjectRuntimeJob(payload);
 	try {
-		const project = await require_dist$4.selectProjectById(job.projectId);
+		const project = await (0, _keystrokehq_platform_database.selectProjectById)(job.projectId);
 		if (!project) throw new Error(`Project ${job.projectId} not found`);
 		const resolved = resolveRuntimeArtifact(project, job.artifactId);
 		if (resolved.action === "skip") return;
@@ -48052,7 +51042,7 @@ async function handleProjectRuntimeJob(runtime, resolveStartInput, payload) {
 				artifactId: resolved.artifactId,
 				baseUrl: result.baseUrl
 			});
-			await require_dist$4.updateProjectActive(job.projectId, result);
+			await (0, _keystrokehq_platform_database.updateProjectActive)(job.projectId, result);
 			if (input.previousRuntimeId) await destroyProjectRuntime(runtime, input, input.previousRuntimeId);
 		} catch (error) {
 			if (result) await destroyProjectRuntime(runtime, input, result.runtimeId);
@@ -48060,7 +51050,7 @@ async function handleProjectRuntimeJob(runtime, resolveStartInput, payload) {
 		}
 	} catch (error) {
 		console.error(`[project.runtime] ${job.projectId} failed`, error);
-		if (payload.exhaustedRetries) await require_dist$4.updateProjectFailed(job.projectId, "Project runtime failed after retries");
+		if (payload.exhaustedRetries) await (0, _keystrokehq_platform_database.updateProjectFailed)(job.projectId, "Project runtime failed after retries");
 		throw error;
 	}
 }
@@ -48224,7 +51214,7 @@ async function resolveOrganizationContext(c) {
 		ok: false,
 		response: c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Forbidden" }), 403)
 	};
-	const membership = await require_dist$4.selectUserOrganizationMembership(c.get("user").id, organizationId);
+	const membership = await (0, _keystrokehq_platform_database.selectUserOrganizationMembership)(c.get("user").id, organizationId);
 	if (!membership) return {
 		ok: false,
 		response: c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Forbidden" }), 403)
@@ -48251,11 +51241,11 @@ function requireProject() {
 		const organization = c.get("organization");
 		const projectId = c.req.param("projectId")?.trim();
 		if (!projectId) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Project id is required" }), 400);
-		const [project, organizationRow] = await Promise.all([require_dist$4.selectProjectForOrganization(organization.organizationId, projectId), require_dist$4.selectOrganizationById(organization.organizationId)]);
+		const [project, organizationRow] = await Promise.all([(0, _keystrokehq_platform_database.selectProjectForOrganization)(organization.organizationId, projectId), (0, _keystrokehq_platform_database.selectOrganizationById)(organization.organizationId)]);
 		if (!project) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Project not found" }), 404);
 		if (!organizationRow) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Organization not found" }), 404);
 		c.set("project", project);
-		await require_dist$4.runWithWorkspaceContext({
+		await (0, _keystrokehq_platform_database.runWithWorkspaceContext)({
 			organizationId: organization.organizationId,
 			role: organization.role,
 			projectId: project.id,
@@ -48280,7 +51270,7 @@ function requireProjectMembership() {
 			await next();
 			return;
 		}
-		const membership = await require_dist$4.selectUserProjectMembership(c.get("user").id, project.id);
+		const membership = await (0, _keystrokehq_platform_database.selectUserProjectMembership)(c.get("user").id, project.id);
 		if (!membership) return notFound(c, "Project not found");
 		c.set("projectMember", { role: membership.role });
 		await next();
@@ -48319,9 +51309,9 @@ function requireSession(jwtVerifier) {
 		}
 		const apiKeySecret = extractWebhookApiKeyFromRequest(c.req.raw);
 		if (apiKeySecret) {
-			const verified = await require_dist$4.verifyOrgPlatformApiKeySecret(apiKeySecret);
+			const verified = await (0, _keystrokehq_platform_database.verifyOrgPlatformApiKeySecret)(apiKeySecret);
 			if (verified) {
-				const user = await require_dist$4.loadOrgPlatformApiKeyUser(verified.userId);
+				const user = await (0, _keystrokehq_platform_database.loadOrgPlatformApiKeyUser)(verified.userId);
 				if (user) {
 					const session = sessionFromApiKeyUser(user, apiKeySecret);
 					c.set("user", session.user);
@@ -48365,7 +51355,7 @@ function requireOrganizationParam() {
 	return async (c, next) => {
 		const organizationId = c.req.param("organizationId")?.trim();
 		if (!organizationId) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Organization id is required" }), 400);
-		const membership = await require_dist$4.selectUserOrganizationMembership(c.get("user").id, organizationId);
+		const membership = await (0, _keystrokehq_platform_database.selectUserOrganizationMembership)(c.get("user").id, organizationId);
 		if (!membership) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Forbidden" }), 403);
 		c.set("organization", {
 			organizationId: membership.organization.id,
@@ -48392,7 +51382,7 @@ async function flushRequestBackgroundTasks() {
 }
 /** Org DB connection options for `@keystrokehq/database` project scope (pg schema vs sqlite file). */
 function resolveOrgProjectDatabaseOptions(organization) {
-	const url = require_dist$4.resolveOrgDatabaseUrl(organization);
+	const url = (0, _keystrokehq_platform_database.resolveOrgDatabaseUrl)(organization);
 	if ((0, _keystrokehq_database.inferDialect)(url) === "postgres") return {
 		url,
 		searchPath: organization.dbSchema
@@ -48403,10 +51393,10 @@ function resolveOrgProjectDatabaseOptions(organization) {
 function withOrganizationProjectDatabase() {
 	return async (c, next) => {
 		const { organizationId } = c.get("organization");
-		const organization = await require_dist$4.selectOrganizationById(organizationId);
+		const organization = await (0, _keystrokehq_platform_database.selectOrganizationById)(organizationId);
 		if (!organization) return c.json({ error: "Organization not found" }, 404);
 		const dbOptions = resolveOrgProjectDatabaseOptions(organization);
-		await require_dist$4.runWithOrganizationScope(organizationId, () => (0, _keystrokehq_database.runWithProjectDatabase)(dbOptions, () => (0, _keystrokehq_database.runWithTenantScope)(organizationId, () => runWithRequestBackgroundTasks(async () => {
+		await (0, _keystrokehq_platform_database.runWithOrganizationScope)(organizationId, () => (0, _keystrokehq_database.runWithProjectDatabase)(dbOptions, () => (0, _keystrokehq_database.runWithTenantScope)(organizationId, () => runWithRequestBackgroundTasks(async () => {
 			await next();
 			await flushRequestBackgroundTasks();
 		}))));
@@ -48415,7 +51405,7 @@ function withOrganizationProjectDatabase() {
 //#endregion
 //#region src/routes/account/users/me/avatar/GET.ts
 const handler$60 = async (c) => {
-	const dbUser = await require_dist$4.selectUserById(c.get("user").id);
+	const dbUser = await (0, _keystrokehq_platform_database.selectUserById)(c.get("user").id);
 	if (!dbUser) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "User not found" }), 404);
 	return c.json(require_dist$2.UserAvatarSchema.parse({ url: dbUser.image ?? null }));
 };
@@ -48477,7 +51467,7 @@ const handler$58 = async (c) => {
 	const parsed = require_dist$2.UserAvatarPatchSchema.safeParse(await c.req.json().catch(() => null));
 	if (!parsed.success) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Invalid avatar update" }), 400);
 	const user = c.get("user");
-	const dbUser = await require_dist$4.selectUserById(user.id);
+	const dbUser = await (0, _keystrokehq_platform_database.selectUserById)(user.id);
 	if (!dbUser) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "User not found" }), 404);
 	const storage = require_dist$2.createAssetsStorageClient();
 	const { storageKey } = parsed.data;
@@ -48488,7 +51478,7 @@ const handler$58 = async (c) => {
 			isOwnedPublicUrl: require_dist$2.isKeystrokeAssetsAvatarPublicUrl,
 			keyFromPublicUrl: require_dist$2.keystrokeAssetsAvatarKeyFromPublicUrl
 		});
-		await require_dist$4.updateUserById(user.id, {
+		await (0, _keystrokehq_platform_database.updateUserById)(user.id, {
 			image: null,
 			updatedAt: /* @__PURE__ */ new Date()
 		});
@@ -48507,7 +51497,7 @@ const handler$58 = async (c) => {
 		isOwnedPublicUrl: require_dist$2.isKeystrokeAssetsAvatarPublicUrl,
 		keyFromPublicUrl: require_dist$2.keystrokeAssetsAvatarKeyFromPublicUrl
 	});
-	await require_dist$4.updateUserById(user.id, {
+	await (0, _keystrokehq_platform_database.updateUserById)(user.id, {
 		image: finalized.publicUrl,
 		updatedAt: /* @__PURE__ */ new Date()
 	});
@@ -48516,7 +51506,7 @@ const handler$58 = async (c) => {
 //#endregion
 //#region src/routes/account/users/me/preferences/GET.ts
 const handler$57 = async (c) => {
-	const dbUser = await require_dist$4.selectUserById(c.get("user").id);
+	const dbUser = await (0, _keystrokehq_platform_database.selectUserById)(c.get("user").id);
 	if (!dbUser) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "User not found" }), 404);
 	return c.json(require_dist$2.UserPreferencesSchema.parse(require_dist$2.normalizeUserPreferences(dbUser.preferences)));
 };
@@ -48526,10 +51516,10 @@ const handler$56 = async (c) => {
 	const parsed = require_dist$2.UserPreferencesPatchSchema.safeParse(await c.req.json().catch(() => null));
 	if (!parsed.success) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Invalid preferences update" }), 400);
 	const user = c.get("user");
-	const dbUser = await require_dist$4.selectUserById(user.id);
+	const dbUser = await (0, _keystrokehq_platform_database.selectUserById)(user.id);
 	if (!dbUser) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "User not found" }), 404);
 	const next = require_dist$2.mergeUserPreferences(require_dist$2.normalizeUserPreferences(dbUser.preferences), parsed.data);
-	await require_dist$4.updateUserById(user.id, {
+	await (0, _keystrokehq_platform_database.updateUserById)(user.id, {
 		preferences: next,
 		updatedAt: /* @__PURE__ */ new Date()
 	});
@@ -48538,14 +51528,14 @@ const handler$56 = async (c) => {
 //#endregion
 //#region src/routes/account/organizations/GET.ts
 const handler$55 = async (c) => {
-	const memberships = await require_dist$4.selectUserOrganizations(c.get("user").id);
+	const memberships = await (0, _keystrokehq_platform_database.selectUserOrganizations)(c.get("user").id);
 	return c.json(require_dist$2.ListOrganizationsResponseSchema.parse({ organizations: memberships.map(require_dist$2.mapUserOrganization) }));
 };
 //#endregion
 //#region src/services/create-organization.ts
 async function createOrganizationWithHosting(deps, userId, name, preferredSlug) {
 	const { hosting, storage } = deps;
-	const identity = await require_dist$4.resolveNewOrganizationIdentity(name, preferredSlug);
+	const identity = await (0, _keystrokehq_platform_database.resolveNewOrganizationIdentity)(name, preferredSlug);
 	let hostedAppName;
 	let provisionedStorage;
 	let organizationPersisted = false;
@@ -48558,15 +51548,15 @@ async function createOrganizationWithHosting(deps, userId, name, preferredSlug)
 			organizationId: identity.organizationId,
 			name: name.trim()
 		});
-		const membership = await require_dist$4.createOrganizationForUser(userId, name, preferredSlug, {
+		const membership = await (0, _keystrokehq_platform_database.createOrganizationForUser)(userId, name, preferredSlug, {
 			organizationId: identity.organizationId,
 			slug: identity.slug,
 			hostingAppName: hostedAppName ?? null,
 			storage: {
 				bucket: provisionedStorage.bucket,
 				endpoint: provisionedStorage.endpoint,
-				accessKeyIdCiphertext: (0, _keystrokehq_database.encryptCredentialPayload)(provisionedStorage.accessKeyId),
-				secretAccessKeyCiphertext: (0, _keystrokehq_database.encryptCredentialPayload)(provisionedStorage.secretAccessKey),
+				accessKeyIdCiphertext: (0, _keystrokehq_platform_database.encryptCredentialPayload)(provisionedStorage.accessKeyId),
+				secretAccessKeyCiphertext: (0, _keystrokehq_platform_database.encryptCredentialPayload)(provisionedStorage.secretAccessKey),
 				region: provisionedStorage.region ?? null,
 				forcePathStyle: provisionedStorage.forcePathStyle ?? null
 			}
@@ -48576,7 +51566,7 @@ async function createOrganizationWithHosting(deps, userId, name, preferredSlug)
 		return membership;
 	} catch (error) {
 		if (provisionedStorage && !organizationPersisted) {
-			if (!await require_dist$4.isOrganizationStorageBucketInUse(provisionedStorage.bucket)) await storage.deprovisionOrganization(provisionedStorage).catch(() => void 0);
+			if (!await (0, _keystrokehq_platform_database.isOrganizationStorageBucketInUse)(provisionedStorage.bucket)) await storage.deprovisionOrganization(provisionedStorage).catch(() => void 0);
 		}
 		if (hostedAppName && hosting.deprovisionOrganization) await hosting.deprovisionOrganization({ appName: hostedAppName }).catch(() => void 0);
 		throw error;
@@ -48585,7 +51575,7 @@ async function createOrganizationWithHosting(deps, userId, name, preferredSlug)
 //#endregion
 //#region src/routes/account/organizations/slug-errors.ts
 function organizationSlugErrorBody(error) {
-	if (error instanceof require_dist$4.OrganizationSlugTakenError) return {
+	if (error instanceof _keystrokehq_platform_database.OrganizationSlugTakenError) return {
 		error: error.message,
 		code: "slug_taken"
 	};
@@ -48607,7 +51597,7 @@ function createOrganizationHandler(deps) {
 			const membership = await createOrganizationWithHosting(deps, user.id, parsed.data.name, parsed.data.slug);
 			return c.json(require_dist$2.CreateOrganizationResponseSchema.parse({ organization: require_dist$2.mapUserOrganization(membership) }), 201);
 		} catch (error) {
-			if (error instanceof require_dist$4.OrganizationSlugTakenError) return c.json(require_dist$2.ErrorResponseSchema.parse(organizationSlugErrorBody(error)), 409);
+			if (error instanceof _keystrokehq_platform_database.OrganizationSlugTakenError) return c.json(require_dist$2.ErrorResponseSchema.parse(organizationSlugErrorBody(error)), 409);
 			if (error instanceof zod.ZodError) return c.json(require_dist$2.ErrorResponseSchema.parse(organizationSlugErrorBody(error)), 400);
 			throw error;
 		}
@@ -48621,14 +51611,14 @@ const handler$54 = async (c) => {
 		excludeOrganizationId: c.req.query("excludeOrganizationId")
 	});
 	if (!parsed.success) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Invalid slug query" }), 400);
-	const availability = await require_dist$4.checkOrganizationSlugAvailability(parsed.data.slug, parsed.data.excludeOrganizationId);
+	const availability = await (0, _keystrokehq_platform_database.checkOrganizationSlugAvailability)(parsed.data.slug, parsed.data.excludeOrganizationId);
 	return c.json(require_dist$2.SlugAvailabilityResponseSchema.parse(availability));
 };
 //#endregion
 //#region src/routes/account/organizations/[organizationId]/GET.ts
 const handler$53 = async (c) => {
 	const { organizationId } = c.get("organization");
-	const membership = await require_dist$4.selectUserOrganizationMembership(c.get("user").id, organizationId);
+	const membership = await (0, _keystrokehq_platform_database.selectUserOrganizationMembership)(c.get("user").id, organizationId);
 	if (!membership) throw new Error(`Organization membership missing after param guard: ${organizationId}`);
 	return c.json(require_dist$2.ActiveOrganizationResponseSchema.parse({ organization: require_dist$2.mapUserOrganization(membership) }));
 };
@@ -48644,15 +51634,15 @@ const handler$52 = async (c) => {
 	}
 	try {
 		let updated;
-		if (parsed.data.name !== void 0) updated = await require_dist$4.updateOrganizationName(organization.organizationId, parsed.data.name);
-		if (parsed.data.slug !== void 0) updated = await require_dist$4.updateOrganizationSlug(organization.organizationId, parsed.data.slug);
+		if (parsed.data.name !== void 0) updated = await (0, _keystrokehq_platform_database.updateOrganizationName)(organization.organizationId, parsed.data.name);
+		if (parsed.data.slug !== void 0) updated = await (0, _keystrokehq_platform_database.updateOrganizationSlug)(organization.organizationId, parsed.data.slug);
 		if (!updated) throw new Error(`Organization update produced no result: ${organization.organizationId}`);
 		return c.json(require_dist$2.ActiveOrganizationResponseSchema.parse({ organization: require_dist$2.mapUserOrganization({
 			organization: updated,
 			role: organization.role
 		}) }));
 	} catch (error) {
-		if (error instanceof require_dist$4.OrganizationSlugTakenError) return c.json(require_dist$2.ErrorResponseSchema.parse(organizationSlugErrorBody(error)), 409);
+		if (error instanceof _keystrokehq_platform_database.OrganizationSlugTakenError) return c.json(require_dist$2.ErrorResponseSchema.parse(organizationSlugErrorBody(error)), 409);
 		if (error instanceof zod.ZodError) return c.json(require_dist$2.ErrorResponseSchema.parse(organizationSlugErrorBody(error)), 400);
 		throw error;
 	}
@@ -48661,9 +51651,9 @@ const handler$52 = async (c) => {
 //#region src/routes/account/organizations/[organizationId]/branding/GET.ts
 const handler$51 = async (c) => {
 	const { organizationId } = c.get("organization");
-	const organization = await require_dist$4.selectOrganizationById(organizationId);
+	const organization = await (0, _keystrokehq_platform_database.selectOrganizationById)(organizationId);
 	if (!organization) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Organization not found" }), 404);
-	return c.json(require_dist$2.OrganizationSidebarBrandingSchema.parse(require_dist$4.organizationRowToSidebarBranding(organization)));
+	return c.json(require_dist$2.OrganizationSidebarBrandingSchema.parse((0, _keystrokehq_platform_database.organizationRowToSidebarBranding)(organization)));
 };
 //#endregion
 //#region src/routes/account/organizations/[organizationId]/branding/PATCH.ts
@@ -48712,7 +51702,7 @@ const handler$50 = async (c) => {
 	const parsed = require_dist$2.OrganizationSidebarBrandingPatchSchema.safeParse(await c.req.json().catch(() => null));
 	if (!parsed.success) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Invalid branding update" }), 400);
 	const { organizationId } = c.get("organization");
-	const organization = await require_dist$4.selectOrganizationById(organizationId);
+	const organization = await (0, _keystrokehq_platform_database.selectOrganizationById)(organizationId);
 	if (!organization) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Organization not found" }), 404);
 	const dbUpdate = {
 		customLogoEnabled: parsed.data.customLogoEnabled,
@@ -48731,8 +51721,8 @@ const handler$50 = async (c) => {
 		if (!result.ok) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: result.error }), 400);
 		dbUpdate[urlField] = result.publicUrl;
 	}
-	const updated = await require_dist$4.updateOrganizationSidebarBranding(organizationId, dbUpdate);
-	return c.json(require_dist$2.OrganizationSidebarBrandingSchema.parse(require_dist$4.organizationRowToSidebarBranding(updated)));
+	const updated = await (0, _keystrokehq_platform_database.updateOrganizationSidebarBranding)(organizationId, dbUpdate);
+	return c.json(require_dist$2.OrganizationSidebarBrandingSchema.parse((0, _keystrokehq_platform_database.organizationRowToSidebarBranding)(updated)));
 };
 //#endregion
 //#region src/routes/account/organizations/[organizationId]/branding/logo/presign/POST.ts
@@ -48764,7 +51754,7 @@ function listScope(c, capability) {
 async function grantedProjectIds(c, scope) {
 	if (scope.kind === "all") return;
 	const { organizationId } = c.get("organization");
-	return require_dist$4.selectProjectIdsForUser(organizationId, c.get("user").id);
+	return (0, _keystrokehq_platform_database.selectProjectIdsForUser)(organizationId, c.get("user").id);
 }
 async function resolveListProjectIds(c, scope, requested) {
 	const granted = await grantedProjectIds(c, scope);
@@ -48786,7 +51776,7 @@ async function canAccessProjectId(c, projectId, check) {
 //#region src/routes/account/history/enrich.ts
 async function resolveHistoryRunActor(ranByUserId) {
 	if (!ranByUserId) return null;
-	const user = await require_dist$4.selectUserById(ranByUserId);
+	const user = await (0, _keystrokehq_platform_database.selectUserById)(ranByUserId);
 	if (!user) return null;
 	return {
 		userId: user.id,
@@ -48844,7 +51834,7 @@ const handler$48 = async (c) => {
 		...query.kind ? { kind: query.kind } : {}
 	});
 	const grantedProjectIdsList = await grantedProjectIds(c, scope);
-	const projects = await require_dist$4.selectProjectsByOrganizationId(organization.organizationId, { grantedProjectIds: grantedProjectIdsList });
+	const projects = await (0, _keystrokehq_platform_database.selectProjectsByOrganizationId)(organization.organizationId, { grantedProjectIds: grantedProjectIdsList });
 	const historyRuns = await enrichHistoryRuns(runs, new Map(projects.map((project) => [project.id, project.name])));
 	return c.json(require_dist$2.HistoryRunListResponseSchema.parse(historyRuns));
 };
@@ -48940,11 +51930,11 @@ async function cancelHistoryRun(c, kind, cancel) {
 	if (!await canAccessProjectId(c, core.projectId, canAccessHistoryRun)) return c.json(null, 404);
 	const run = await (0, _keystrokehq_database.runWithProjectScope)(core.projectId, () => cancel(id));
 	if (!run) return c.json(null, 404);
-	const organization = await require_dist$4.selectOrganizationById(organizationContext.organizationId);
+	const organization = await (0, _keystrokehq_platform_database.selectOrganizationById)(organizationContext.organizationId);
 	if (!organization) return c.json(null, 404);
 	await (await (0, _keystrokehq_http.getProjectScheduler)(organization, core.projectId)).publishCancel(id);
 	const grantedProjectIdsList = await grantedProjectIds(c, historyListScope(accessContext(c)));
-	const projects = await require_dist$4.selectProjectsByOrganizationId(organizationContext.organizationId, { grantedProjectIds: grantedProjectIdsList });
+	const projects = await (0, _keystrokehq_platform_database.selectProjectsByOrganizationId)(organizationContext.organizationId, { grantedProjectIds: grantedProjectIdsList });
 	const historyRun = await enrichHistoryRun(run, new Map(projects.map((project) => [project.id, project.name])));
 	return c.json(require_dist$2.HistoryRunCancelResponseSchema.parse(historyRun));
 }
@@ -49075,7 +52065,7 @@ const handler$38 = async (c) => {
 		(0, _keystrokehq_database.selectActiveAgentsByIds)(agentIds),
 		(0, _keystrokehq_database.selectActiveWorkflowsByIds)(workflowIds),
 		(0, _keystrokehq_database.selectActiveSkillsByIds)(skillIds),
-		require_dist$4.selectProjectsByOrganizationId(organization.organizationId, { grantedProjectIds: grantedProjectIdsList })
+		(0, _keystrokehq_platform_database.selectProjectsByOrganizationId)(organization.organizationId, { grantedProjectIds: grantedProjectIdsList })
 	]);
 	const projectNameById = new Map(projects.map((project) => [project.id, project.name]));
 	const lookup = {
@@ -49091,7 +52081,7 @@ const handler$38 = async (c) => {
 const handler$37 = async (c) => {
 	const organization = c.get("organization");
 	const grantedProjectIdsList = await grantedProjectIds(c, listScope(c, projectListScope(accessContext(c))));
-	const projects = await require_dist$4.selectProjectsByOrganizationId(organization.organizationId, { grantedProjectIds: grantedProjectIdsList });
+	const projects = await (0, _keystrokehq_platform_database.selectProjectsByOrganizationId)(organization.organizationId, { grantedProjectIds: grantedProjectIdsList });
 	return c.json(require_dist$2.ListProjectsResponseSchema.parse({ projects: projects.map(require_dist$2.mapProject) }));
 };
 //#endregion
@@ -49117,7 +52107,7 @@ function mergeProjectListMetrics(input) {
 const handler$36 = async (c) => {
 	const organization = c.get("organization");
 	const grantedProjectIdsList = await grantedProjectIds(c, listScope(c, projectListScope(accessContext(c))));
-	const [resourceCounts, lastDeploymentAtByProject] = await Promise.all([(0, _keystrokehq_database.selectProjectResourceCounts)(grantedProjectIdsList !== void 0 ? { projectIds: grantedProjectIdsList } : void 0), require_dist$4.selectLastDeploymentAtByProject(organization.organizationId)]);
+	const [resourceCounts, lastDeploymentAtByProject] = await Promise.all([(0, _keystrokehq_database.selectProjectResourceCounts)(grantedProjectIdsList !== void 0 ? { projectIds: grantedProjectIdsList } : void 0), (0, _keystrokehq_platform_database.selectLastDeploymentAtByProject)(organization.organizationId)]);
 	let metrics = mergeProjectListMetrics({
 		resourceCounts,
 		lastDeploymentAtByProject
@@ -49136,7 +52126,7 @@ const handler$35 = async (c) => {
 	const body = await c.req.json().catch(() => null);
 	const parsed = require_dist$2.CreateProjectRequestSchema.safeParse(body);
 	if (!parsed.success) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Project name is required" }), 400);
-	const project = await require_dist$4.createProjectForOrganization(organization.organizationId, parsed.data.name, parsed.data.description, user.id);
+	const project = await (0, _keystrokehq_platform_database.createProjectForOrganization)(organization.organizationId, parsed.data.name, parsed.data.description, user.id);
 	return c.json(require_dist$2.CreateProjectResponseSchema.parse({ project: require_dist$2.mapProject(project) }), 201);
 };
 //#endregion
@@ -49148,7 +52138,7 @@ const handler$34 = async (c) => {
 		excludeProjectId: c.req.query("excludeProjectId")
 	});
 	if (!parsed.success) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Invalid slug query" }), 400);
-	const availability = await require_dist$4.checkProjectSlugAvailability(organization.organizationId, parsed.data.slug, parsed.data.excludeProjectId);
+	const availability = await (0, _keystrokehq_platform_database.checkProjectSlugAvailability)(organization.organizationId, parsed.data.slug, parsed.data.excludeProjectId);
 	return c.json(require_dist$2.ProjectSlugAvailabilityResponseSchema.parse(availability));
 };
 //#endregion
@@ -49166,9 +52156,9 @@ const handler$32 = async (c) => {
 	if (!parsed.success) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Invalid project update request" }), 400);
 	let updated;
 	try {
-		updated = await require_dist$4.updateProjectForOrganization(organization.organizationId, project.id, parsed.data);
+		updated = await (0, _keystrokehq_platform_database.updateProjectForOrganization)(organization.organizationId, project.id, parsed.data);
 	} catch (error) {
-		if (error instanceof require_dist$4.ProjectSlugTakenError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: require_dist$2.PROJECT_SLUG_TAKEN_MESSAGE }), 409);
+		if (error instanceof _keystrokehq_platform_database.ProjectSlugTakenError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: require_dist$2.PROJECT_SLUG_TAKEN_MESSAGE }), 409);
 		throw error;
 	}
 	if (!updated) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Project not found" }), 404);
@@ -49179,13 +52169,13 @@ const handler$32 = async (c) => {
 const handler$31 = async (c) => {
 	const organization = c.get("organization");
 	const project = c.get("project");
-	if (!await require_dist$4.deleteProjectForOrganization(organization.organizationId, project.id)) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Project not found" }), 404);
+	if (!await (0, _keystrokehq_platform_database.deleteProjectForOrganization)(organization.organizationId, project.id)) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Project not found" }), 404);
 	return c.body(null, 204);
 };
 //#endregion
 //#region src/routes/account/projects/[projectId]/deployments/GET.ts
 const handler$30 = async (c) => {
-	const rows = await require_dist$4.selectProjectDeployments(c.get("project").id);
+	const rows = await (0, _keystrokehq_platform_database.selectProjectDeployments)(c.get("project").id);
 	return c.json(require_dist$2.ListProjectDeploymentsResponseSchema.parse({ deployments: rows.map(require_dist$2.mapProjectDeployment) }));
 };
 //#endregion
@@ -49195,12 +52185,12 @@ const ARTIFACT_CONTENT_TYPE = "application/gzip";
 const handler$29 = async (c) => {
 	const project = c.get("project");
 	const { organizationId } = c.get("organization");
-	const organization = await require_dist$4.selectOrganizationById(organizationId);
+	const organization = await (0, _keystrokehq_platform_database.selectOrganizationById)(organizationId);
 	if (!organization) return c.json({ error: "Organization not found" }, 404);
 	const artifactId = crypto.randomUUID();
 	const storageKey = require_dist$2.projectArtifactKey(project.id, artifactId);
-	const storage = require_dist$4.createOrgStorageClient(organization);
-	const artifact = await require_dist$4.insertProjectArtifact({
+	const storage = (0, _keystrokehq_platform_database.createOrgStorageClient)(organization);
+	const artifact = await (0, _keystrokehq_platform_database.insertProjectArtifact)({
 		id: artifactId,
 		projectId: project.id,
 		storageKey,
@@ -49223,11 +52213,11 @@ const DEFAULT_PRESIGN_TTL_SECONDS = 900;
 const handler$28 = async (c) => {
 	const project = c.get("project");
 	const { organizationId } = c.get("organization");
-	const organization = await require_dist$4.selectOrganizationById(organizationId);
+	const organization = await (0, _keystrokehq_platform_database.selectOrganizationById)(organizationId);
 	if (!organization) return c.json({ error: "Organization not found" }, 404);
-	const artifact = await require_dist$4.selectActiveProjectArtifactForProject(project.id);
+	const artifact = await (0, _keystrokehq_platform_database.selectActiveProjectArtifactForProject)(project.id);
 	if (!artifact) return c.json({ error: "No active artifact for project" }, 404);
-	const downloadUrl = await require_dist$4.createOrgStorageClient(organization).presignGet({
+	const downloadUrl = await (0, _keystrokehq_platform_database.createOrgStorageClient)(organization).presignGet({
 		key: artifact.storageKey,
 		expiresInSeconds: DEFAULT_PRESIGN_TTL_SECONDS
 	});
@@ -49243,20 +52233,20 @@ const handler$27 = async (c) => {
 	const project = c.get("project");
 	const artifactId = c.req.param("artifactId");
 	if (!artifactId) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Artifact id is required" }), 400);
-	const existing = await require_dist$4.selectProjectArtifactForProject(artifactId, project.id);
+	const existing = await (0, _keystrokehq_platform_database.selectProjectArtifactForProject)(artifactId, project.id);
 	if (!existing) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Artifact not found" }), 404);
 	if (existing.status === "ready") return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Artifact already completed" }), 409);
 	const { organizationId } = c.get("organization");
-	const organization = await require_dist$4.selectOrganizationById(organizationId);
+	const organization = await (0, _keystrokehq_platform_database.selectOrganizationById)(organizationId);
 	if (!organization) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Organization not found" }), 404);
-	const storage = require_dist$4.createOrgStorageClient(organization);
+	const storage = (0, _keystrokehq_platform_database.createOrgStorageClient)(organization);
 	const head = await storage.headObject(existing.storageKey);
 	if (!head || head.contentLength <= 0) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Artifact upload not found in storage" }), 400);
 	try {
 		const artifactBytes = await storage.getObject(existing.storageKey);
 		if (!artifactBytes || artifactBytes.byteLength <= 0) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Artifact upload not found in storage" }), 400);
 		const manifestJson = require_dist$2.parseStoredRouteManifest(require_dist$2.extractRouteManifestFromArtifact(Buffer.from(artifactBytes)));
-		const result = await require_dist$4.completeProjectArtifact({
+		const result = await (0, _keystrokehq_platform_database.completeProjectArtifact)({
 			artifactId,
 			projectId: project.id,
 			manifestJson
@@ -49282,13 +52272,13 @@ const handler$26 = async (c) => {
 	const project = c.get("project");
 	const artifactId = c.req.param("artifactId");
 	if (!artifactId) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Artifact id is required" }), 400);
-	if (!await require_dist$4.selectProjectArtifactForProject(artifactId, project.id)) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Artifact not found" }), 404);
+	if (!await (0, _keystrokehq_platform_database.selectProjectArtifactForProject)(artifactId, project.id)) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Artifact not found" }), 404);
 	const parsed = require_dist$2.PresignProjectSourceRequestSchema.safeParse(await c.req.json().catch(() => null));
 	if (!parsed.success) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Invalid blob list" }), 400);
 	const { organizationId } = c.get("organization");
-	const organization = await require_dist$4.selectOrganizationById(organizationId);
+	const organization = await (0, _keystrokehq_platform_database.selectOrganizationById)(organizationId);
 	if (!organization) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Organization not found" }), 404);
-	const storage = require_dist$4.createOrgStorageClient(organization);
+	const storage = (0, _keystrokehq_platform_database.createOrgStorageClient)(organization);
 	const hashes = [...new Set(parsed.data.blobs.map((blob) => blob.hash))];
 	const uploads = await Promise.all(hashes.map(async (hash) => {
 		const key = require_dist$2.projectSourceBlobKey(project.id, hash);
@@ -49310,7 +52300,7 @@ const handler$25 = async (c) => {
 	const project = c.get("project");
 	const artifactId = c.req.param("artifactId");
 	if (!artifactId) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Artifact id is required" }), 400);
-	if (!await require_dist$4.selectProjectArtifactForProject(artifactId, project.id)) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Artifact not found" }), 404);
+	if (!await (0, _keystrokehq_platform_database.selectProjectArtifactForProject)(artifactId, project.id)) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Artifact not found" }), 404);
 	const parsed = require_dist$2.UploadProjectSourceManifestRequestSchema.safeParse(await c.req.json().catch(() => null));
 	if (!parsed.success) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Invalid source manifest" }), 400);
 	const manifest = require_dist$2.StoredProjectSourceManifestSchema.parse({
@@ -49321,7 +52311,7 @@ const handler$25 = async (c) => {
 		})),
 		generatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	});
-	await require_dist$4.updateProjectArtifactSourceManifest({
+	await (0, _keystrokehq_platform_database.updateProjectArtifactSourceManifest)({
 		artifactId,
 		projectId: project.id,
 		sourceManifestJson: manifest
@@ -49353,7 +52343,7 @@ function resolveSourcePaths(rows, kindDir, filePaths) {
 }
 const handler$24 = async (c) => {
 	const project = c.get("project");
-	const active = await require_dist$4.selectActiveArtifactSourceManifestForProject(project.id);
+	const active = await (0, _keystrokehq_platform_database.selectActiveArtifactSourceManifestForProject)(project.id);
 	if (!active || !active.sourceManifestJson) return c.json(require_dist$2.ListProjectFilesResponseSchema.parse({
 		artifactId: active?.artifactId ?? null,
 		files: []
@@ -49391,14 +52381,14 @@ const handler$23 = async (c) => {
 	if (!artifactId) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Artifact id is required" }), 400);
 	const path = c.req.query("path");
 	if (!path) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "File path is required" }), 400);
-	const artifact = await require_dist$4.selectProjectArtifactForProject(artifactId, project.id);
+	const artifact = await (0, _keystrokehq_platform_database.selectProjectArtifactForProject)(artifactId, project.id);
 	if (!artifact || !artifact.sourceManifestJson) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Artifact not found" }), 404);
 	const file = require_dist$2.StoredProjectSourceManifestSchema.parse(artifact.sourceManifestJson).files.find((entry) => entry.path === path);
 	if (!file) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "File not found" }), 404);
 	const { organizationId } = c.get("organization");
-	const organization = await require_dist$4.selectOrganizationById(organizationId);
+	const organization = await (0, _keystrokehq_platform_database.selectOrganizationById)(organizationId);
 	if (!organization) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Organization not found" }), 404);
-	const storage = require_dist$4.createOrgStorageClient(organization);
+	const storage = (0, _keystrokehq_platform_database.createOrgStorageClient)(organization);
 	let bytes;
 	try {
 		bytes = await storage.getObject(require_dist$2.projectSourceBlobKey(project.id, file.hash));
@@ -49414,7 +52404,7 @@ function createProjectReachabilityHandler(hosting) {
 	return async (c) => {
 		const project = c.get("project");
 		if (project.status !== "active") return c.json(require_dist$2.ProjectReachabilityResponseSchema.parse({ reachable: false }));
-		const reachable = await require_dist$3.pingProjectTarget({
+		const reachable = await require_dist$2.pingProjectTarget({
 			baseUrl: project.baseUrl,
 			runtimeId: project.runtimeId
 		}, { plugin: hosting });
@@ -49426,7 +52416,7 @@ function createProjectReachabilityHandler(hosting) {
 const handler$22 = async (c) => {
 	const project = c.get("project");
 	const currentUserId = c.get("user").id;
-	const members = await require_dist$4.selectProjectMembers(project.id);
+	const members = await (0, _keystrokehq_platform_database.selectProjectMembers)(project.id);
 	return c.json(require_dist$2.ListProjectMembersResponseSchema.parse({ members: members.map((member) => require_dist$2.mapProjectMember(member, { isCurrentUser: member.id === currentUserId })) }));
 };
 //#endregion
@@ -49437,7 +52427,7 @@ const handler$21 = async (c) => {
 	const body = await c.req.json().catch(() => null);
 	const parsed = require_dist$2.InviteProjectMembersRequestSchema.safeParse(body);
 	if (!parsed.success) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Invalid invite request" }), 400);
-	const results = await require_dist$4.inviteProjectMembers({
+	const results = await (0, _keystrokehq_platform_database.inviteProjectMembers)({
 		projectId: project.id,
 		organizationId: organization.organizationId,
 		emails: parsed.data.emails,
@@ -49455,10 +52445,10 @@ const handler$20 = async (c) => {
 	if (!userId) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "User id is required" }), 400);
 	if (!parsed.success) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Invalid member update request" }), 400);
 	try {
-		const member = await require_dist$4.updateProjectMemberRole(project.id, userId, parsed.data.role);
+		const member = await (0, _keystrokehq_platform_database.updateProjectMemberRole)(project.id, userId, parsed.data.role);
 		return c.json(require_dist$2.UpdateProjectMemberResponseSchema.parse({ member: require_dist$2.mapProjectMember(member) }));
 	} catch (error) {
-		if (error instanceof require_dist$4.ProjectMemberNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 400);
+		if (error instanceof _keystrokehq_platform_database.ProjectMemberNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 400);
 		throw error;
 	}
 };
@@ -49469,10 +52459,10 @@ const handler$19 = async (c) => {
 	const userId = c.req.param("userId");
 	if (!userId) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "User id is required" }), 400);
 	try {
-		await require_dist$4.removeProjectMember(project.id, userId);
+		await (0, _keystrokehq_platform_database.removeProjectMember)(project.id, userId);
 		return c.body(null, 204);
 	} catch (error) {
-		if (error instanceof require_dist$4.ProjectMemberNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 400);
+		if (error instanceof _keystrokehq_platform_database.ProjectMemberNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 400);
 		throw error;
 	}
 };
@@ -49482,10 +52472,10 @@ const handler$18 = async (c) => {
 	const project = c.get("project");
 	const userId = c.get("user").id;
 	try {
-		await require_dist$4.removeProjectMember(project.id, userId);
+		await (0, _keystrokehq_platform_database.removeProjectMember)(project.id, userId);
 		return c.body(null, 204);
 	} catch (error) {
-		if (error instanceof require_dist$4.ProjectMemberNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 400);
+		if (error instanceof _keystrokehq_platform_database.ProjectMemberNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 400);
 		throw error;
 	}
 };
@@ -49503,7 +52493,7 @@ const handler$16 = async (c) => {
 	const body = await c.req.json().catch(() => null);
 	const parsed = require_dist$2.UpdateProjectSettingsRequestSchema.safeParse(body);
 	if (!parsed.success) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Invalid project settings request" }), 400);
-	const updated = await require_dist$4.updateProjectSettings(organization.organizationId, project.id, {
+	const updated = await (0, _keystrokehq_platform_database.updateProjectSettings)(organization.organizationId, project.id, {
 		description: parsed.data.description,
 		defaultMemberRole: parsed.data.defaultRole,
 		invitePermission: parsed.data.invitePermission
@@ -49573,9 +52563,9 @@ function uniqueIds(rows, pick) {
 /** Cross-database lookups: instances live in the org DB; projects/users/connections in the platform DB. */
 async function loadCredentialLookups(rows, organizationId) {
 	const [projects, owners, connections] = await Promise.all([
-		require_dist$4.selectProjectsByOrganizationId(organizationId),
-		require_dist$4.selectUsersByIds(uniqueIds(rows, (row) => row.scopeType === "user" ? row.scopeId : null)),
-		require_dist$4.selectOAuthConnectionsByIds(uniqueIds(rows, (row) => row.authKind === "oauth_managed" ? row.connectionId : null))
+		(0, _keystrokehq_platform_database.selectProjectsByOrganizationId)(organizationId),
+		(0, _keystrokehq_platform_database.selectUsersByIds)(uniqueIds(rows, (row) => row.scopeType === "user" ? row.scopeId : null)),
+		(0, _keystrokehq_platform_database.selectOAuthConnectionsByIds)(uniqueIds(rows, (row) => row.authKind === "oauth_managed" ? row.connectionId : null))
 	]);
 	return {
 		projectNameById: new Map(projects.map((project) => [project.id, project.name])),
@@ -49641,7 +52631,7 @@ const handler$14 = async (c) => {
 	const input = parsed.data;
 	const resolvedProjects = [];
 	for (const slug of input.projects) {
-		const project = await require_dist$4.selectProjectForOrganizationBySlug(organization.organizationId, slug);
+		const project = await (0, _keystrokehq_platform_database.selectProjectForOrganizationBySlug)(organization.organizationId, slug);
 		if (!project) return c.json({ error: `Project "${slug}" not found` }, 400);
 		resolvedProjects.push({
 			id: project.id,
@@ -49780,7 +52770,7 @@ function createDeleteCredentialHandler(options = {}) {
 		if (!canManageCredential(existing, user.id)) return c.json({ error: "Forbidden" }, 403);
 		if (existing.authKind === "oauth_managed") {
 			if (existing.connectionId) {
-				if ((await (0, _keystrokehq_database.listCredentialInstancesByConnectionId)(existing.connectionId)).every((row) => row.id === existing.id)) await require_dist$4.deleteOAuthConnectionById(existing.connectionId);
+				if ((await (0, _keystrokehq_database.listCredentialInstancesByConnectionId)(existing.connectionId)).every((row) => row.id === existing.id)) await (0, _keystrokehq_platform_database.deleteOAuthConnectionById)(existing.connectionId);
 			}
 		} else if (existing.authKind === "keystroke") {
 			if (existing.connectionId) {
@@ -49798,7 +52788,7 @@ function createDeleteCredentialHandler(options = {}) {
 //#region src/routes/account/members/GET.ts
 const handler$11 = async (c) => {
 	const { organizationId } = c.get("organization");
-	const members = await require_dist$4.selectOrganizationMembers(organizationId);
+	const members = await (0, _keystrokehq_platform_database.selectOrganizationMembers)(organizationId);
 	return c.json(require_dist$2.ListOrganizationMembersResponseSchema.parse({ members: members.map(require_dist$2.mapOrganizationMember) }));
 };
 //#endregion
@@ -49850,13 +52840,13 @@ const handler$10 = async (c) => {
 	const body = await c.req.json().catch(() => null);
 	const parsed = require_dist$2.InviteOrganizationMembersRequestSchema.safeParse(body);
 	if (!parsed.success) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Invalid invite request" }), 400);
-	const results = await require_dist$4.inviteOrganizationMembers({
+	const results = await (0, _keystrokehq_platform_database.inviteOrganizationMembers)({
 		organizationId: organization.organizationId,
 		invitedByUserId: user.id,
 		emails: parsed.data.emails,
 		role: parsed.data.role
 	});
-	const inviter = await require_dist$4.selectUserById(user.id);
+	const inviter = await (0, _keystrokehq_platform_database.selectUserById)(user.id);
 	for (const result of results) {
 		if (!result.invitationId || result.status !== "sent" && result.status !== "pending") continue;
 		await sendOrganizationInviteEmail({
@@ -49878,10 +52868,10 @@ const handler$9 = async (c) => {
 	if (!userId) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "User id is required" }), 400);
 	if (!parsed.success) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Invalid member update request" }), 400);
 	try {
-		const member = await require_dist$4.updateOrganizationMemberRole(organizationId, userId, parsed.data.role);
+		const member = await (0, _keystrokehq_platform_database.updateOrganizationMemberRole)(organizationId, userId, parsed.data.role);
 		return c.json(require_dist$2.UpdateOrganizationMemberResponseSchema.parse({ member: require_dist$2.mapOrganizationMember(member) }));
 	} catch (error) {
-		if (error instanceof require_dist$4.CannotModifyOwnerError || error instanceof require_dist$4.OrganizationMemberNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 400);
+		if (error instanceof _keystrokehq_platform_database.CannotModifyOwnerError || error instanceof _keystrokehq_platform_database.OrganizationMemberNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 400);
 		throw error;
 	}
 };
@@ -49892,17 +52882,17 @@ const handler$8 = async (c) => {
 	const userId = c.req.param("userId");
 	if (!userId) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "User id is required" }), 400);
 	try {
-		await require_dist$4.removeOrganizationMember(organizationId, userId);
+		await (0, _keystrokehq_platform_database.removeOrganizationMember)(organizationId, userId);
 		return c.body(null, 204);
 	} catch (error) {
-		if (error instanceof require_dist$4.CannotModifyOwnerError || error instanceof require_dist$4.OrganizationMemberNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 400);
+		if (error instanceof _keystrokehq_platform_database.CannotModifyOwnerError || error instanceof _keystrokehq_platform_database.OrganizationMemberNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 400);
 		throw error;
 	}
 };
 //#endregion
 //#region src/routes/account/invitations/GET.ts
 const handler$7 = async (c) => {
-	const invitations = await require_dist$4.selectPendingInvitationsForUser(c.get("user").id);
+	const invitations = await (0, _keystrokehq_platform_database.selectPendingInvitationsForUser)(c.get("user").id);
 	return c.json(require_dist$2.ListOrganizationInvitationsResponseSchema.parse({ invitations: invitations.map(require_dist$2.mapOrganizationInvitation) }));
 };
 //#endregion
@@ -49912,12 +52902,12 @@ const handler$6 = async (c) => {
 	const invitationId = c.req.param("invitationId");
 	if (!invitationId) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Invitation id is required" }), 400);
 	try {
-		const membership = await require_dist$4.acceptInvitation(invitationId, user.id);
+		const membership = await (0, _keystrokehq_platform_database.acceptInvitation)(invitationId, user.id);
 		return c.json(require_dist$2.AcceptOrganizationInvitationResponseSchema.parse({ organization: require_dist$2.mapUserOrganization(membership) }));
 	} catch (error) {
-		if (error instanceof require_dist$4.OrganizationInvitationNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 404);
-		if (error instanceof require_dist$4.OrganizationInvitationForbiddenError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 403);
-		if (error instanceof require_dist$4.OrganizationInvitationExpiredError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 410);
+		if (error instanceof _keystrokehq_platform_database.OrganizationInvitationNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 404);
+		if (error instanceof _keystrokehq_platform_database.OrganizationInvitationForbiddenError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 403);
+		if (error instanceof _keystrokehq_platform_database.OrganizationInvitationExpiredError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 410);
 		throw error;
 	}
 };
@@ -49928,11 +52918,11 @@ const handler$5 = async (c) => {
 	const invitationId = c.req.param("invitationId");
 	if (!invitationId) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "Invitation id is required" }), 400);
 	try {
-		await require_dist$4.declineInvitation(invitationId, user.id);
+		await (0, _keystrokehq_platform_database.declineInvitation)(invitationId, user.id);
 		return c.json(require_dist$2.DeclineOrganizationInvitationResponseSchema.parse({ success: true }));
 	} catch (error) {
-		if (error instanceof require_dist$4.OrganizationInvitationNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 404);
-		if (error instanceof require_dist$4.OrganizationInvitationForbiddenError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 403);
+		if (error instanceof _keystrokehq_platform_database.OrganizationInvitationNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 404);
+		if (error instanceof _keystrokehq_platform_database.OrganizationInvitationForbiddenError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 403);
 		throw error;
 	}
 };
@@ -49954,7 +52944,7 @@ function appRowToCatalogEntry(row) {
 //#endregion
 //#region src/routes/account/apps/GET.ts
 const handler$4 = async (c) => {
-	const apps = (await require_dist$4.listOfficialApps()).map(appRowToCatalogEntry);
+	const apps = (await (0, _keystrokehq_platform_database.listOfficialApps)()).map(appRowToCatalogEntry);
 	return c.json(require_dist$2.ListAppsResponseSchema.parse({ apps }));
 };
 //#endregion
@@ -49962,15 +52952,15 @@ const handler$4 = async (c) => {
 const handler$3 = async (c) => {
 	const { organizationId } = c.get("organization");
 	const user = c.get("user");
-	const records = apiKeyListScope(accessContext(c)).kind === "all" ? await require_dist$4.listOrgPlatformApiKeysForOrganization(organizationId) : await require_dist$4.listOrgPlatformApiKeysForUser(organizationId, user.id);
-	const creators = await require_dist$4.selectUsersByIds([...new Set(records.map((record) => record.createdByUserId))]);
+	const records = apiKeyListScope(accessContext(c)).kind === "all" ? await (0, _keystrokehq_platform_database.listOrgPlatformApiKeysForOrganization)(organizationId) : await (0, _keystrokehq_platform_database.listOrgPlatformApiKeysForUser)(organizationId, user.id);
+	const creators = await (0, _keystrokehq_platform_database.selectUsersByIds)([...new Set(records.map((record) => record.createdByUserId))]);
 	const creatorsById = new Map(creators.map((creator) => [creator.id, creator]));
 	return c.json(require_dist$2.ListApiKeysResponseSchema.parse({ apiKeys: records.map((record) => ({
 		id: record.id,
 		name: record.name,
 		keyPreview: record.keyPreview,
 		createdAt: record.createdAt.toISOString(),
-		createdBy: require_dist$4.mapOrgPlatformApiKeyCreatorOrDeleted(record.createdByUserId, creatorsById.get(record.createdByUserId)),
+		createdBy: (0, _keystrokehq_platform_database.mapOrgPlatformApiKeyCreatorOrDeleted)(record.createdByUserId, creatorsById.get(record.createdByUserId)),
 		isCreatedByCurrentUser: record.createdByUserId === user.id
 	})) }));
 };
@@ -49980,19 +52970,19 @@ const handler$2 = async (c) => {
 	const { organizationId } = c.get("organization");
 	const user = c.get("user");
 	const body = require_dist$2.CreateApiKeyRequestSchema.parse(await c.req.json());
-	const created = await require_dist$4.createOrgPlatformApiKey({
+	const created = await (0, _keystrokehq_platform_database.createOrgPlatformApiKey)({
 		organizationId,
 		userId: user.id,
 		name: body.name
 	});
-	const creator = await require_dist$4.loadOrgPlatformApiKeyUser(user.id);
+	const creator = await (0, _keystrokehq_platform_database.loadOrgPlatformApiKeyUser)(user.id);
 	if (!creator) return c.json({ error: "User not found" }, 404);
 	return c.json(require_dist$2.CreateApiKeyResponseSchema.parse({
 		id: created.id,
 		name: created.name,
 		keyPreview: created.keyPreview,
 		createdAt: created.createdAt.toISOString(),
-		createdBy: require_dist$4.mapOrgPlatformApiKeyCreator(creator),
+		createdBy: (0, _keystrokehq_platform_database.mapOrgPlatformApiKeyCreator)(creator),
 		isCreatedByCurrentUser: true,
 		secret: created.secret
 	}), 201);
@@ -50004,7 +52994,7 @@ const handler$1 = async (c) => {
 	const user = c.get("user");
 	const apiKeyId = c.req.param("apiKeyId");
 	if (!apiKeyId) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "API key id is required" }), 400);
-	const apiKey = await require_dist$4.selectOrgPlatformApiKeyForOrganization(apiKeyId, organizationId);
+	const apiKey = await (0, _keystrokehq_platform_database.selectOrgPlatformApiKeyForOrganization)(apiKeyId, organizationId);
 	if (!apiKey) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: "API key not found" }), 404);
 	if (!canReadApiKey(accessContext(c), {
 		userId: user.id,
@@ -50015,10 +53005,10 @@ const handler$1 = async (c) => {
 		createdByUserId: apiKey.createdByUserId
 	})) return forbidden(c);
 	try {
-		await require_dist$4.revokeOrgPlatformApiKey(apiKeyId, organizationId);
+		await (0, _keystrokehq_platform_database.revokeOrgPlatformApiKey)(apiKeyId, organizationId);
 		return c.body(null, 204);
 	} catch (error) {
-		if (error instanceof require_dist$4.OrgPlatformApiKeyNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 404);
+		if (error instanceof _keystrokehq_platform_database.OrgPlatformApiKeyNotFoundError) return c.json(require_dist$2.ErrorResponseSchema.parse({ error: error.message }), 404);
 		throw error;
 	}
 };
@@ -50101,7 +53091,7 @@ const handler = async (c) => {
 		const message = parsed.error.issues[0]?.message ?? "Invalid request body";
 		return c.json({ error: message }, 400);
 	}
-	const organization = await require_dist$4.selectOrganizationById(organizationContext.organizationId);
+	const organization = await (0, _keystrokehq_platform_database.selectOrganizationById)(organizationContext.organizationId);
 	if (!organization) return c.json({ error: "Organization not found" }, 404);
 	try {
 		await postTeamRequestToSlack({
@@ -50269,13 +53259,13 @@ async function proxyExaWebSearchRequest(options) {
 //#endregion
 //#region src/routes/internal/with-project-scope.ts
 async function withProjectScope(projectId, fn) {
-	const project = await require_dist$4.selectProjectById(projectId);
+	const project = await (0, _keystrokehq_platform_database.selectProjectById)(projectId);
 	if (!project) return;
-	const organization = await require_dist$4.selectOrganizationById(project.organizationId);
+	const organization = await (0, _keystrokehq_platform_database.selectOrganizationById)(project.organizationId);
 	if (!organization) return;
-	const url = require_dist$4.resolveOrgDatabaseUrl(organization);
+	const url = (0, _keystrokehq_platform_database.resolveOrgDatabaseUrl)(organization);
 	let result;
-	await require_dist$4.runWithOrganizationScope(project.organizationId, () => (0, _keystrokehq_database.runWithProjectDatabase)({
+	await (0, _keystrokehq_platform_database.runWithOrganizationScope)(project.organizationId, () => (0, _keystrokehq_database.runWithProjectDatabase)({
 		url,
 		searchPath: organization.dbSchema
 	}, () => (0, _keystrokehq_database.runWithProjectScope)(project.id, () => (0, _keystrokehq_database.runWithTenantScope)(project.organizationId, async () => {
@@ -50434,7 +53424,7 @@ function mountInternalRoutes(workerToken, tokenRefresh, llmProxy, sandboxProxy)
 		const origin = (0, _keystrokehq_http.platformWebhookOrigin)(projectId, (0, _keystrokehq_http.externalPlatformOrigin)());
 		if (!origin) return c.json({ error: "PUBLIC_PLATFORM_URL is not configured" }, 500);
 		try {
-			const token = await require_dist$4.ensureWebhookApiKeyForRoute(projectId, parsed.data.route, parsed.data.attachmentKeys);
+			const token = await (0, _keystrokehq_platform_database.ensureWebhookApiKeyForRoute)(projectId, parsed.data.route, parsed.data.attachmentKeys);
 			return c.json({ webhookUrl: (0, _keystrokehq_runtime.buildWebhookUrl)(origin, parsed.data.route, token) });
 		} catch (error) {
 			const message = error instanceof Error ? error.message : "Failed to ensure webhook API key.";
@@ -50484,19 +53474,19 @@ async function usesPgBossScheduler() {
 }
 async function startPlatformServer(platformConfig, hooks = {}) {
 	const runtime = platformConfig.hosting.createRuntime();
-	await require_dist$4.initDatabase();
+	await (0, _keystrokehq_platform_database.initDatabase)();
 	await require_dist$2.ensureKeystrokeAssetsBucket();
 	await (0, _keystrokehq_runtime.seedOAuthAppsFromEnvForAllOrganizations)();
-	if (await usesPgBossScheduler()) await require_dist$4.ensureProjectPgBossGrants();
+	if (await usesPgBossScheduler()) await (0, _keystrokehq_platform_database.ensureProjectPgBossGrants)();
 	await startProjectRuntimeWorker(runtime, { resolveStartInput: async (job) => {
-		const project = await require_dist$4.selectProjectById(job.projectId);
+		const project = await (0, _keystrokehq_platform_database.selectProjectById)(job.projectId);
 		if (!project) throw new Error(`Project ${job.projectId} not found`);
 		const resolved = resolveRuntimeArtifact(project, job.artifactId);
 		if (resolved.action === "error") throw new Error(resolved.message);
 		if (resolved.action === "skip") throw new Error(`Project ${job.projectId} has no deploy artifact to start`);
-		const artifact = await require_dist$4.selectProjectArtifactById(resolved.artifactId);
+		const artifact = await (0, _keystrokehq_platform_database.selectProjectArtifactById)(resolved.artifactId);
 		if (!artifact || artifact.status !== "ready") throw new Error(`Project ${job.projectId} pending artifact is not ready`);
-		const organization = await require_dist$4.selectOrganizationById(project.organizationId);
+		const organization = await (0, _keystrokehq_platform_database.selectOrganizationById)(project.organizationId);
 		if (!organization) throw new Error(`Organization not found for project ${job.projectId}`);
 		const workerRuntime = platformConfig.hosting.workerRuntime;
 		return {
@@ -50504,12 +53494,12 @@ async function startPlatformServer(platformConfig, hooks = {}) {
 			name: job.name,
 			artifactId: resolved.artifactId,
 			artifactStorageKey: artifact.storageKey,
-			database: await require_dist$4.resolveProjectRuntimeDatabase({
+			database: await (0, _keystrokehq_platform_database.resolveProjectRuntimeDatabase)({
 				organizationId: project.organizationId,
 				projectId: project.id
 			}),
 			env: {
-				...require_dist$4.orgWorkspacesRuntimeEnv(organization, { containerEnv: process.env }),
+				...(0, _keystrokehq_platform_database.orgWorkspacesRuntimeEnv)(organization, { containerEnv: process.env }),
 				...platformConfig.llmProxy?.workerEnv({
 					platformUrl: workerRuntime.platformUrl,
 					workerToken: workerRuntime.workerToken,
@@ -50691,4 +53681,4 @@ Object.defineProperty(exports, "x$1", {
 	}
 });
 
-//# sourceMappingURL=start-BQ0b7Zex.cjs.map
+//# sourceMappingURL=start-Cm1hxyF_.cjs.map