@coffre/cli 0.1.1 → 0.1.3

package/dist/schema-sqlite-Byp7B3yI.js

@@ -0,0 +1,1078 @@
+import { n as ROLE_NAMES, r as assignableToEnvironment } from "./access-CO1kGjWW.js";
+import { B as textDecoder, G as sql, J as Table, M as getColumnNameAndConfig, at as TableName, ct as entityKind, ot as ColumnBuilder, st as Column } from "./relations-CJCGPRst.js";
+import { i as relationsOf, r as ACTIVE_SUBJECT, t as asPostgres } from "./portable-CPh2thNN.js";
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/sqlite-core/checks.js
+var CheckBuilder = class {
+	constructor(name, value) {
+		this.name = name;
+		this.value = value;
+	}
+	static [entityKind] = "SQLiteCheckBuilder";
+	brand;
+	build(table) {
+		return new Check(table, this);
+	}
+};
+var Check = class {
+	constructor(table, builder) {
+		this.table = table;
+		this.name = builder.name;
+		this.value = builder.value;
+	}
+	static [entityKind] = "SQLiteCheck";
+	name;
+	value;
+};
+function check(name, value) {
+	return new CheckBuilder(name, value);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/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`;
+	}
+};
+function foreignKey(config) {
+	function mappedConfig() {
+		if (typeof config === "function") {
+			const { name, columns, foreignColumns } = config();
+			return {
+				name,
+				columns,
+				foreignColumns
+			};
+		}
+		return config;
+	}
+	return new ForeignKeyBuilder(mappedConfig);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/sqlite-core/unique-constraint.js
+function uniqueKeyName(table, columns) {
+	return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+function unique(name) {
+	return new UniqueOnConstraintBuilder(name);
+}
+var UniqueConstraintBuilder = class {
+	constructor(columns, name) {
+		this.name = name;
+		this.columns = columns;
+	}
+	static [entityKind] = "SQLiteUniqueConstraintBuilder";
+	/** @internal */
+	columns;
+	/** @internal */
+	build(table) {
+		return new UniqueConstraint(table, this.columns, this.name);
+	}
+};
+var UniqueOnConstraintBuilder = class {
+	static [entityKind] = "SQLiteUniqueOnConstraintBuilder";
+	/** @internal */
+	name;
+	constructor(name) {
+		this.name = name;
+	}
+	on(...columns) {
+		return new UniqueConstraintBuilder(columns, this.name);
+	}
+};
+var UniqueConstraint = class {
+	constructor(table, columns, name) {
+		this.table = table;
+		this.columns = columns;
+		this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
+	}
+	static [entityKind] = "SQLiteUniqueConstraint";
+	columns;
+	name;
+	getName() {
+		return this.name;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/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_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/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_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/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_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/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_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/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_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/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_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/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_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/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_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/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_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/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 uniqueIndex(name) {
+	return new IndexBuilderOn(name, true);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/drizzle-orm@0.45.2_@cloudflare+workers-types@5.20260920.1_@libsql+client@0.18.0_@types+pg@8.20.0_pg@8.16.3/node_modules/drizzle-orm/sqlite-core/primary-keys.js
+function primaryKey(...config) {
+	if (config[0].columns) return new PrimaryKeyBuilder(config[0].columns, config[0].name);
+	return new PrimaryKeyBuilder(config);
+}
+var PrimaryKeyBuilder = class {
+	static [entityKind] = "SQLitePrimaryKeyBuilder";
+	/** @internal */
+	columns;
+	/** @internal */
+	name;
+	constructor(columns, name) {
+		this.columns = columns;
+		this.name = name;
+	}
+	/** @internal */
+	build(table) {
+		return new PrimaryKey(table, this.columns, this.name);
+	}
+};
+var PrimaryKey = class {
+	constructor(table, columns, name) {
+		this.table = table;
+		this.columns = columns;
+		this.name = name;
+	}
+	static [entityKind] = "SQLitePrimaryKey";
+	columns;
+	name;
+	getName() {
+		return this.name ?? `${this.table[SQLiteTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
+	}
+};
+//#endregion
+//#region ../db/dist/schema-sqlite.js
+/**
+* The schema in schema.ts, for SQLite (through libsql). Same tables,
+* columns, keys and row types (portable.ts checks); only the storage
+* differs:
+*
+* - Ids and strings are `text`, with no default for ids: the application
+*   makes every id.
+* - Bytes are `blob`.
+* - Times are integer milliseconds since the epoch.
+* - Patterns are checked with GLOB, which is case-sensitive and needs no
+*   extension, rather than a regular expression.
+*/
+const bytes = (name) => blob(name, { mode: "buffer" });
+/** A 64-bit integer read as a bigint, like Postgres's bigint in 'bigint' mode. */
+const int64 = customType({
+	dataType: () => "integer",
+	fromDriver: (value) => BigInt(value)
+});
+const time = (name) => integer(name, { mode: "timestamp_ms" });
+const now = sql`(CAST(unixepoch('subsec') * 1000 AS INTEGER))`;
+const createdAt = () => time("created_at").notNull().default(now);
+const flag = (name) => integer(name, { mode: "boolean" });
+/** `^[a-z0-9][a-z0-9-]{0,max-1}$`, in GLOB. */
+const isSlug = (column, max) => sql`length(${column}) BETWEEN 1 AND ${sql.raw(String(max))} AND ${column} GLOB '[a-z0-9]*' AND ${column} NOT GLOB '*[^a-z0-9-]*'`;
+const projects = sqliteTable("projects", {
+	id: text().primaryKey(),
+	slug: text().notNull(),
+	name: text().notNull(),
+	createdAt: createdAt(),
+	archivedAt: time("archived_at")
+}, (table) => [unique("projects_slug_key").on(table.slug), check("projects_slug_check", isSlug(table.slug, 63))]);
+const environments = sqliteTable("environments", {
+	id: text().primaryKey(),
+	projectId: text("project_id").notNull(),
+	slug: text().notNull(),
+	name: text().notNull(),
+	createdAt: createdAt(),
+	archivedAt: time("archived_at")
+}, (table) => [
+	unique("environments_project_id_slug_key").on(table.projectId, table.slug),
+	unique("environments_project_scoped").on(table.id, table.projectId),
+	check("environments_slug_check", isSlug(table.slug, 63)),
+	foreignKey({
+		name: "environments_project_id_fkey",
+		columns: [table.projectId],
+		foreignColumns: [projects.id]
+	}).onDelete("restrict")
+]);
+const secrets = sqliteTable("secrets", {
+	id: text().primaryKey(),
+	projectId: text("project_id").notNull(),
+	environmentId: text("environment_id").notNull(),
+	key: text().notNull(),
+	createdAt: createdAt(),
+	updatedAt: time("updated_at").notNull().default(now),
+	currentVersionId: text("current_version_id").references(() => secretVersions.id, { onDelete: "no action" }),
+	currentVersion: integer("current_version").notNull().default(0),
+	archivedAt: time("archived_at")
+}, (table) => [
+	unique("secrets_project_id_environment_id_key_key").on(table.projectId, table.environmentId, table.key),
+	check("secrets_key_check", sql`length(${table.key}) BETWEEN 1 AND 128 AND ${table.key} GLOB '[A-Za-z_]*' AND ${table.key} NOT GLOB '*[^A-Za-z0-9_]*'`),
+	foreignKey({
+		name: "secrets_project_id_fkey",
+		columns: [table.projectId],
+		foreignColumns: [projects.id]
+	}).onDelete("restrict"),
+	foreignKey({
+		name: "secrets_environment_id_fkey",
+		columns: [table.environmentId],
+		foreignColumns: [environments.id]
+	}).onDelete("restrict"),
+	foreignKey({
+		name: "secrets_environment_in_project",
+		columns: [table.environmentId, table.projectId],
+		foreignColumns: [environments.id, environments.projectId]
+	}),
+	index("secrets_lookup_idx").on(table.projectId, table.environmentId, table.key)
+]);
+const secretVersions = sqliteTable("secret_versions", {
+	id: text().primaryKey(),
+	secretId: text("secret_id").notNull(),
+	version: integer().notNull(),
+	envelopeVersion: integer("envelope_version").notNull(),
+	ciphertext: bytes("ciphertext").notNull(),
+	iv: bytes("iv").notNull(),
+	authTag: bytes("auth_tag").notNull(),
+	wrappedDek: bytes("wrapped_dek").notNull(),
+	kekProvider: text("kek_provider").notNull(),
+	kekId: text("kek_id").notNull(),
+	kekVersion: text("kek_version").notNull(),
+	createdAt: createdAt(),
+	createdBy: text("created_by").notNull()
+}, (table) => [
+	unique("secret_versions_secret_id_version_key").on(table.secretId, table.version),
+	check("secret_versions_version_check", sql`${table.version} > 0`),
+	check("secret_versions_iv_check", sql`octet_length(${table.iv}) = 12`),
+	check("secret_versions_auth_tag_check", sql`octet_length(${table.authTag}) = 16`),
+	foreignKey({
+		name: "secret_versions_secret_id_fkey",
+		columns: [table.secretId],
+		foreignColumns: [secrets.id]
+	}).onDelete("restrict"),
+	index("secret_versions_secret_idx").on(table.secretId, table.version)
+]);
+const ROLES = sql.raw(ROLE_NAMES.map((role) => `'${role}'`).join(", "));
+const ENVIRONMENT_ROLES = sql.raw(ROLE_NAMES.filter(assignableToEnvironment).map((role) => `'${role}'`).join(", "));
+const vaultMembers = sqliteTable("vault_members", {
+	principal: text().primaryKey(),
+	status: text().notNull(),
+	owner: flag("owner").notNull().default(false),
+	generation: integer().notNull().default(0),
+	createdAt: integer("created_at", { mode: "number" }).notNull(),
+	createdBy: text("created_by").notNull(),
+	statusChangedAt: integer("status_changed_at", { mode: "number" }).notNull(),
+	statusChangedBy: text("status_changed_by").notNull(),
+	accessSeq: int64("access_seq").notNull(),
+	mac: bytes("mac").notNull()
+}, (table) => [
+	check("vault_members_mac_check", sql`octet_length(${table.mac}) = 32`),
+	check("vault_members_principal_check", sql`(${table.principal} GLOB 'user:?*' OR ${table.principal} GLOB 'token:?*' OR ${table.principal} GLOB 'sync:?*')
+        AND substr(${table.principal}, instr(${table.principal}, ':') + 1, 1) <> ':'
+        AND instr(${table.principal}, ' ') = 0 AND instr(${table.principal}, char(9)) = 0
+        AND instr(${table.principal}, char(10)) = 0 AND instr(${table.principal}, char(13)) = 0`),
+	check("vault_members_user_lowercase", sql`${table.principal} NOT LIKE 'user:%' OR ${table.principal} = lower(${table.principal})`),
+	check("vault_members_status_check", sql`${table.status} IN ('active', 'removed')`),
+	check("vault_members_owner_check", sql`NOT ${table.owner} OR (${table.status} = 'active' AND ${table.principal} LIKE 'user:%')`),
+	check("vault_members_generation_check", sql`${table.generation} >= 0`)
+]);
+const vaultGrants = sqliteTable("vault_grants", {
+	principal: text().notNull(),
+	projectId: text("project_id"),
+	environmentId: text("environment_id"),
+	role: text().notNull(),
+	expiresAt: integer("expires_at", { mode: "number" }),
+	grantedAt: integer("granted_at", { mode: "number" }).notNull(),
+	grantedBy: text("granted_by").notNull()
+}, (table) => [
+	check("vault_grants_one_place", sql`(${table.projectId} IS NULL) <> (${table.environmentId} IS NULL)`),
+	check("vault_grants_role_check", sql`${table.role} IN (${ROLES})`),
+	check("vault_grants_environment_role_check", sql`${table.environmentId} IS NULL OR ${table.role} IN (${ENVIRONMENT_ROLES})`),
+	unique("vault_grants_on_project").on(table.principal, table.projectId),
+	unique("vault_grants_on_environment").on(table.principal, table.environmentId),
+	foreignKey({
+		name: "vault_grants_principal_fkey",
+		columns: [table.principal],
+		foreignColumns: [vaultMembers.principal]
+	}).onDelete("restrict"),
+	foreignKey({
+		name: "vault_grants_project_id_fkey",
+		columns: [table.projectId],
+		foreignColumns: [projects.id]
+	}).onDelete("restrict"),
+	foreignKey({
+		name: "vault_grants_environment_id_fkey",
+		columns: [table.environmentId],
+		foreignColumns: [environments.id]
+	}).onDelete("restrict")
+]);
+const auditLog = sqliteTable("audit_log", {
+	seq: int64("seq").primaryKey(),
+	author: text().notNull(),
+	keyId: text("key_id").notNull(),
+	occurredAt: integer("occurred_at", { mode: "number" }).notNull(),
+	actor: text().notNull(),
+	action: text().notNull(),
+	decision: text().notNull(),
+	code: text(),
+	subjectPrincipal: text("subject_principal"),
+	projectId: text("project_id"),
+	environmentId: text("environment_id"),
+	secretId: text("secret_id"),
+	secretVersionId: text("secret_version_id"),
+	operationId: text("operation_id"),
+	requestId: text("request_id"),
+	sourceIp: text("source_ip"),
+	relatedSeq: int64("related_seq"),
+	metadata: text().notNull().default("{}"),
+	prevHash: bytes("prev_hash").notNull(),
+	mac: bytes("mac").notNull(),
+	hash: bytes("hash").notNull()
+}, (table) => [
+	check("audit_log_author_check", sql`${table.author} IN ('app', 'vault')`),
+	check("audit_log_actor_check", sql`${table.actor} GLOB 'user:?*' OR ${table.actor} GLOB 'token:?*' OR ${table.actor} GLOB 'sync:?*' OR ${table.actor} GLOB 'system:?*'`),
+	check("audit_log_decision_check", sql`${table.decision} IN ('allow', 'deny')`),
+	check("audit_log_metadata_check", sql`json_valid(${table.metadata})`),
+	check("audit_log_prev_hash_check", sql`octet_length(${table.prevHash}) = 32`),
+	check("audit_log_mac_check", sql`octet_length(${table.mac}) = 32`),
+	check("audit_log_hash_check", sql`octet_length(${table.hash}) = 32`),
+	foreignKey({
+		name: "audit_log_project_id_fkey",
+		columns: [table.projectId],
+		foreignColumns: [projects.id]
+	}).onDelete("restrict"),
+	foreignKey({
+		name: "audit_log_environment_id_fkey",
+		columns: [table.environmentId],
+		foreignColumns: [environments.id]
+	}).onDelete("restrict"),
+	foreignKey({
+		name: "audit_log_secret_id_fkey",
+		columns: [table.secretId],
+		foreignColumns: [secrets.id]
+	}).onDelete("restrict"),
+	foreignKey({
+		name: "audit_log_secret_version_id_fkey",
+		columns: [table.secretVersionId],
+		foreignColumns: [secretVersions.id]
+	}).onDelete("restrict"),
+	foreignKey({
+		name: "audit_log_related_seq_fkey",
+		columns: [table.relatedSeq],
+		foreignColumns: [table.seq]
+	}).onDelete("restrict"),
+	index("audit_log_project_idx").on(table.projectId, table.seq),
+	index("audit_log_environment_idx").on(table.environmentId, table.seq),
+	index("audit_log_secret_idx").on(table.secretId, table.seq),
+	index("audit_log_actor_idx").on(table.actor, table.seq),
+	index("audit_log_operation_idx").on(table.operationId, table.seq),
+	index("audit_log_action_idx").on(table.author, table.action, table.seq),
+	index("audit_log_releases_idx").on(table.author, table.actor, table.action, table.decision, table.occurredAt),
+	index("audit_log_subject_idx").on(table.author, table.subjectPrincipal, table.seq)
+]);
+const auditChainHead = sqliteTable("audit_chain_head", {
+	onlyRow: flag("only_row").primaryKey().default(true),
+	nextSeq: int64("next_seq").notNull().default(sql`0`),
+	headHash: bytes("head_hash").notNull()
+}, (table) => [
+	check("audit_chain_head_only_row_check", sql`${table.onlyRow}`),
+	check("audit_chain_head_next_seq_check", sql`${table.nextSeq} >= 0`),
+	check("audit_chain_head_head_hash_check", sql`octet_length(${table.headHash}) = 32`)
+]);
+const identities = sqliteTable("identities", {
+	id: text().primaryKey(),
+	provider: text().notNull(),
+	authMac: bytes("auth_mac").notNull(),
+	subject: text().notNull(),
+	issuerHash: text("issuer_hash").notNull(),
+	generation: integer().notNull(),
+	principal: text().notNull(),
+	email: text(),
+	createdAt: createdAt(),
+	createdBy: text("created_by").notNull(),
+	lastSignInAt: time("last_sign_in_at"),
+	revokedAt: time("revoked_at"),
+	revokedBy: text("revoked_by"),
+	activeSubject: text("active_subject").generatedAlwaysAs(ACTIVE_SUBJECT, { mode: "stored" })
+}, (table) => [
+	check("identities_principal_check", sql`${table.principal} LIKE 'user:%'`),
+	check("identities_provider_check", isSlug(table.provider, 32)),
+	check("identities_auth_mac_check", sql`octet_length(${table.authMac}) = 32`),
+	unique("identities_member_generation_key").on(table.id, table.principal, table.generation),
+	foreignKey({
+		name: "identities_principal_fkey",
+		columns: [table.principal],
+		foreignColumns: [vaultMembers.principal]
+	}).onDelete("restrict"),
+	uniqueIndex("identities_active_subject").on(table.provider, table.issuerHash, table.activeSubject),
+	index("identities_principal_idx").on(table.principal, table.generation)
+]);
+const credentials = sqliteTable("credentials", {
+	id: text().primaryKey(),
+	kind: text().notNull(),
+	authMac: bytes("auth_mac").notNull(),
+	tokenHash: bytes("token_hash").notNull(),
+	tokenHint: text("token_hint").notNull(),
+	generation: integer().notNull(),
+	principal: text().notNull(),
+	identityId: text("identity_id"),
+	label: text(),
+	createdAt: createdAt(),
+	createdBy: text("created_by").notNull(),
+	expiresAt: time("expires_at").notNull(),
+	lastUsedAt: time("last_used_at"),
+	lastUsedIp: text("last_used_ip"),
+	revokedAt: time("revoked_at"),
+	revokedBy: text("revoked_by")
+}, (table) => [
+	unique("credentials_token_hash_key").on(table.tokenHash),
+	check("credentials_kind_check", sql`${table.kind} IN ('browser', 'cli', 'service')`),
+	check("credentials_principal_check", sql`${table.principal} LIKE 'user:%' OR ${table.principal} LIKE 'token:%'`),
+	check("credentials_kind_matches_principal", sql`(${table.kind} = 'service') = (${table.principal} LIKE 'token:%')`),
+	check("credentials_token_hash_check", sql`octet_length(${table.tokenHash}) = 32`),
+	check("credentials_auth_mac_check", sql`octet_length(${table.authMac}) = 32`),
+	foreignKey({
+		name: "credentials_principal_fkey",
+		columns: [table.principal],
+		foreignColumns: [vaultMembers.principal]
+	}).onDelete("restrict"),
+	foreignKey({
+		name: "credentials_identity_id_fkey",
+		columns: [
+			table.identityId,
+			table.principal,
+			table.generation
+		],
+		foreignColumns: [
+			identities.id,
+			identities.principal,
+			identities.generation
+		]
+	}).onDelete("restrict"),
+	index("credentials_principal_idx").on(table.principal, table.generation)
+]);
+const deviceAuthorizations = sqliteTable("device_authorizations", {
+	id: text().primaryKey(),
+	deviceCodeHash: bytes("device_code_hash").notNull(),
+	authMac: bytes("auth_mac").notNull(),
+	userCode: text("user_code").notNull(),
+	clientLabel: text("client_label"),
+	clientIp: text("client_ip"),
+	createdAt: createdAt(),
+	expiresAt: time("expires_at").notNull(),
+	decidedAt: time("decided_at"),
+	decision: text(),
+	generation: integer().notNull().default(0),
+	principal: text(),
+	consumedAt: time("consumed_at")
+}, (table) => [
+	unique("device_authorizations_device_code_hash_key").on(table.deviceCodeHash),
+	unique("device_authorizations_user_code_key").on(table.userCode),
+	check("device_authorizations_auth_mac_check", sql`octet_length(${table.authMac}) = 32`),
+	check("device_authorizations_decision_check", sql`${table.decision} IS NULL OR ${table.decision} IN ('approved', 'denied')`),
+	check("device_authorizations_approval_names_principal", sql`(${table.decision} IS NULL AND ${table.decidedAt} IS NULL AND ${table.principal} IS NULL AND ${table.generation} = 0 AND ${table.consumedAt} IS NULL)
+        OR (${table.decision} IS NOT NULL AND ${table.decidedAt} IS NOT NULL AND (
+          (${table.decision} = 'denied' AND ${table.principal} IS NULL AND ${table.generation} = 0 AND ${table.consumedAt} IS NULL)
+          OR (${table.decision} = 'approved' AND ${table.principal} IS NOT NULL AND ${table.principal} LIKE 'user:%')
+        ))`),
+	foreignKey({
+		name: "device_authorizations_principal_fkey",
+		columns: [table.principal],
+		foreignColumns: [vaultMembers.principal]
+	}).onDelete("restrict")
+]);
+const syncs = sqliteTable("syncs", {
+	id: text().primaryKey(),
+	projectId: text("project_id").notNull(),
+	environmentId: text("environment_id").notNull(),
+	provider: text().notNull(),
+	config: text().notNull(),
+	credentialSecretId: text("credential_secret_id").notNull(),
+	createdAt: createdAt(),
+	createdBy: text("created_by").notNull(),
+	pausedAt: time("paused_at"),
+	archivedAt: time("archived_at"),
+	leaseUntil: time("lease_until"),
+	lastRunAt: time("last_run_at"),
+	lastStatus: text("last_status"),
+	lastError: text("last_error")
+}, (table) => [
+	check("syncs_config_check", sql`json_valid(${table.config})`),
+	check("syncs_last_status_check", sql`${table.lastStatus} IS NULL OR ${table.lastStatus} IN ('ok', 'partial', 'failed')`),
+	foreignKey({
+		name: "syncs_environment_in_project",
+		columns: [table.environmentId, table.projectId],
+		foreignColumns: [environments.id, environments.projectId]
+	}).onDelete("restrict"),
+	foreignKey({
+		name: "syncs_credential_secret_id_fkey",
+		columns: [table.credentialSecretId],
+		foreignColumns: [secrets.id]
+	}).onDelete("restrict"),
+	index("syncs_environment_idx").on(table.environmentId)
+]);
+const syncKeys = sqliteTable("sync_keys", {
+	syncId: text("sync_id").notNull(),
+	key: text().notNull(),
+	secretVersionId: text("secret_version_id"),
+	pushedAt: time("pushed_at").notNull().default(now),
+	removedAt: time("removed_at")
+}, (table) => [
+	primaryKey({
+		name: "sync_keys_pkey",
+		columns: [table.syncId, table.key]
+	}),
+	foreignKey({
+		name: "sync_keys_sync_id_fkey",
+		columns: [table.syncId],
+		foreignColumns: [syncs.id]
+	}).onDelete("restrict"),
+	foreignKey({
+		name: "sync_keys_secret_version_id_fkey",
+		columns: [table.secretVersionId],
+		foreignColumns: [secretVersions.id]
+	}).onDelete("restrict")
+]);
+const { environmentsRelations, secretsRelations, syncsRelations, syncKeysRelations } = relationsOf(asPostgres({
+	projects,
+	environments,
+	secrets,
+	secretVersions,
+	syncs,
+	syncKeys
+}));
+//#endregion
+export { auditChainHead, auditLog, credentials, deviceAuthorizations, environments, environmentsRelations, identities, projects, secretVersions, secrets, secretsRelations, syncKeys, syncKeysRelations, syncs, syncsRelations, vaultGrants, vaultMembers };