qubu 0.3.5 → 0.4.1

package/docs/troubleshooting.md

@@ -12,9 +12,9 @@ Check that the query includes the original source or use the columns exposed by
 the alias, CTE, or derived table you actually placed in the query:
 
 ```ts
-import { alias, from, select } from 'qubu'
+import { alias, from, select } from "qubu"
 
-const author = alias(users, 'author')
+const author = alias(users, "author")
 
 select({ name: author.name }, from(author))
 ```
@@ -27,9 +27,9 @@ identity after aliasing.
 This is the default mutation safety check. Add a source-aware predicate:
 
 ```ts
-import { deleteFrom, eq, update, where } from 'qubu'
+import { deleteFrom, eq, update, where } from "qubu"
 
-update(users, { name: 'Ada' }, where(eq(users.id, 7)))
+update(users, { name: "Ada" }, where(eq(users.id, 7)))
 deleteFrom(users, where(eq(users.id, 8)))
 ```
 
@@ -43,7 +43,7 @@ A scalar subquery must return one selected field. Reduce the projection before
 calling `scalar()`:
 
 ```ts
-import { from, scalar, select } from 'qubu'
+import { from, scalar, select } from "qubu"
 
 const idQuery = select({ id: users.id }, from(users))
 const idExpression = scalar(idQuery)
@@ -58,8 +58,8 @@ Render with the dialect that the adapter expects and inspect both fields of the
 result:
 
 ```ts
-import { render } from 'qubu'
-import { postgresDialect } from 'qubu/postgres'
+import { render } from "qubu"
+import { postgresDialect } from "qubu/postgres"
 
 const statement = render(query, postgresDialect())
 console.log(statement.text)
@@ -78,7 +78,7 @@ path, and hint before changing the query. The hint names the repair boundary;
 the path points to the clause or field that needs attention.
 
 ```ts
-import { QueryValidationError, fetchFirst } from 'qubu'
+import { QueryValidationError, fetchFirst } from "qubu"
 
 try {
   fetchFirst(-1)
@@ -140,10 +140,10 @@ placement. Rendering traverses that normalized statement, so inspect the final
 `text` and `parameters` together rather than assuming source argument order:
 
 ```ts
-import { eq, fetchFirst, from, render, select, where } from 'qubu'
+import { eq, fetchFirst, from, render, select, where } from "qubu"
 
 const statement = render(
-  select({ id: users.id }, from(users), where(eq(users.id, 7)), fetchFirst(10))
+  select({ id: users.id }, from(users), where(eq(users.id, 7)), fetchFirst(10)),
 )
 ```
 

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "qubu",
-  "version": "0.3.5",
+  "version": "0.4.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/aleclarson/qubu"
   },
-  "type": "module",
   "files": [
     "dist",
     "docs",
     "skills"
   ],
+  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
@@ -32,10 +32,6 @@
       "types": "./dist/diff.d.mts",
       "import": "./dist/diff.mjs"
     },
-    "./drizzle": {
-      "types": "./dist/drizzle.d.mts",
-      "import": "./dist/drizzle.mjs"
-    },
     "./introspection": {
       "types": "./dist/introspection.d.mts",
       "import": "./dist/introspection.mjs"
@@ -69,34 +65,29 @@
       "import": "./dist/vite.mjs"
     },
     "./package.json": "./package.json",
-    "./drizzle/mysql": {
-      "types": "./dist/drizzle-mysql.d.mts",
-      "import": "./dist/drizzle-mysql.mjs"
-    },
-    "./drizzle/postgres": {
-      "types": "./dist/drizzle-postgres.d.mts",
-      "import": "./dist/drizzle-postgres.mjs"
-    },
-    "./drizzle/sqlite": {
-      "types": "./dist/drizzle-sqlite.d.mts",
-      "import": "./dist/drizzle-sqlite.mjs"
-    },
     "./globals": {
       "types": "./dist/vite/ambient.d.ts"
     }
   },
-  "prettier": "@alloc/prettier-config",
+  "dependencies": {
+    "@standard-schema/spec": "^1.0.0"
+  },
   "devDependencies": {
     "@alloc/prettier-config": "^1.0.0",
+    "@electric-sql/pglite": "^0.5.8",
+    "@libsql/client": "^0.17.4",
     "@pg-nano/pg-tmp": "^2.0.3",
+    "@stylistic/eslint-plugin": "^6.0.0-beta.6",
     "@types/bun": "^1.3.0",
     "@types/node": "^24.6.2",
     "@types/pg": "^8.23.1",
-    "drizzle-orm": "1.0.0-rc.4",
     "lildocs": "^0.1.27",
     "mysql2": "^3.23.4",
+    "oxfmt": "^0.58.0",
+    "oxlint": "1.73.0",
     "pg": "^8.23.0",
     "picospawn": "^0.3.10",
+    "postgres": "^3.4.9",
     "prettier": "^3.6.2",
     "qubu": "link:",
     "radashi": "^12.6.2",
@@ -106,30 +97,27 @@
     "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   },
-  "dependencies": {
-    "@standard-schema/spec": "^1.0.0"
-  },
-  "peerDependencies": {
-    "drizzle-orm": "^1.0.0-rc.4"
-  },
-  "peerDependenciesMeta": {
-    "drizzle-orm": {
-      "optional": true
-    }
-  },
+  "prettier": "@alloc/prettier-config",
   "scripts": {
     "build": "tsdown",
+    "build:workspace-packages": "pnpm --recursive --filter './adapters/*' build",
     "check:package": "node ./scripts/test-package.mjs --check-built",
+    "check:workspace-versions": "node ./scripts/set-release-version.mjs --check",
     "playground": "bun run ./playground/playground.ts",
     "test": "vitest",
-    "test:e2e": "vitest --run test/e2e/dialects.test.ts",
+    "test:e2e": "vitest --run test/e2e",
     "test:type-performance": "node ./scripts/test-type-performance.mjs",
     "diff-check": "vitest --run test/diff.test.ts test/migration.test.ts",
     "test:bun": "node ./scripts/test-package.mjs --runtime=bun",
     "test:package": "node ./scripts/test-package.mjs",
+    "test:workspace-children": "pnpm --recursive --filter './adapters/*' build && node ./scripts/test-workspace-packages.mjs",
+    "test:workspace-packages": "pnpm run test:package && pnpm run test:workspace-children",
     "test:package:node": "node ./scripts/test-package.mjs --runtime=node",
     "typecheck": "vitest --typecheck --run",
+    "typecheck:workspace-packages": "pnpm --recursive --filter './adapters/*' typecheck",
     "typecheck:playground": "tsc --project ./playground/tsconfig.json",
-    "lint": "prettier --check . && npm run typecheck"
+    "format": "oxlint --fix && oxfmt",
+    "release:version": "node ./scripts/set-release-version.mjs",
+    "release:publish": "node ./scripts/publish-workspace.mjs"
   }
 }

package/skills/qubu/agents/openai.yaml

@@ -1,6 +1,6 @@
 interface:
-  display_name: 'Qubu'
-  short_description: 'Route Qubu work to package docs'
-  default_prompt: 'Use $qubu to find the smallest canonical Qubu guide for this task.'
+  display_name: "Qubu"
+  short_description: "Route Qubu work to package docs"
+  default_prompt: "Use $qubu to find the smallest canonical Qubu guide for this task."
 policy:
   allow_implicit_invocation: true

package/dist/column-CXMxx8Hq.mjs

@@ -1,118 +0,0 @@
-import { a as assertDialectCapability } from "./json-CUZlv4HT.mjs";
-//#region src/core/fragment.ts
-function fragment(render) {
-	return Object.freeze({ render });
-}
-function sequence(parts, separator = " ") {
-	return fragment((context) => {
-		let first = true;
-		for (const part of parts) {
-			if (!first) context.append(separator);
-			context.render(part);
-			first = false;
-		}
-	});
-}
-function parenthesize(part) {
-	return fragment((context) => {
-		context.append("(");
-		context.render(part);
-		context.append(")");
-	});
-}
-function isFragment(value) {
-	return typeof value === "object" && value !== null && "render" in value && typeof value.render === "function";
-}
-//#endregion
-//#region src/expressions/types.ts
-/** Runtime/type-level proof that an expression is safe to use in schema SQL. */
-const schemaExpressionBrand = Symbol("qubu.schema-expression");
-/** Add a concrete dialect requirement without dropping expression metadata. */
-function withDialectCapability(expression, capability) {
-	const wrapped = makeExpression(expression.expressionKind, (context) => {
-		assertDialectCapability(context.dialect, capability);
-		context.render(expression);
-	});
-	return isSchemaExpression(expression) ? markSchemaExpression(wrapped) : wrapped;
-}
-function makeExpression(expressionKind, render, expressionCategory) {
-	return Object.freeze({
-		expressionKind,
-		...expressionCategory ? { expressionCategory } : {},
-		...fragment(render)
-	});
-}
-/** Mark a query-only expression category without changing its SQL renderer. */
-function markExpressionCategory(expression, category) {
-	return Object.freeze({
-		...expression,
-		expressionCategory: category
-	});
-}
-/**
-* Mark a built-in or explicitly audited renderer as schema-deterministic.
-* Prefer {@link defineSchemaExpression} for application extensions because it
-* supplies a restricted schema rendering context.
-*/
-function makeSchemaExpression(expressionKind, render) {
-	const expression = makeExpression(expressionKind, render);
-	return Object.freeze({
-		...expression,
-		[schemaExpressionBrand]: true
-	});
-}
-/** Add the schema-determinism brand to an explicitly audited expression. */
-function markSchemaExpression(expression) {
-	if (isSchemaExpression(expression)) return expression;
-	return Object.freeze({
-		...expression,
-		[schemaExpressionBrand]: true
-	});
-}
-/** Test the runtime brand used by schema rendering and validation. */
-function isSchemaExpression(value) {
-	return typeof value === "object" && value !== null && schemaExpressionBrand in value && value[schemaExpressionBrand] === true;
-}
-function isExpression(value) {
-	return typeof value === "object" && value !== null && "expressionKind" in value && "render" in value && typeof value.render === "function";
-}
-//#endregion
-//#region src/core/primitives/identifier.ts
-function identifier(name) {
-	return fragment((context) => context.append(context.dialect.quoteIdentifier(name)));
-}
-function qualifiedIdentifier(...parts) {
-	return fragment((context) => {
-		parts.forEach((part, index) => {
-			if (index > 0) context.append(".");
-			context.append(context.dialect.quoteIdentifier(part));
-		});
-	});
-}
-//#endregion
-//#region src/expressions/column.ts
-function createColumnReference(columnName, sourceReference, fieldName) {
-	const expression = makeSchemaExpression("column", (context) => {
-		if (context.renderColumnReference) {
-			context.renderColumnReference(columnName);
-			return;
-		}
-		context.render(sourceReference);
-		context.append(".");
-		context.render(identifier(columnName));
-	});
-	return Object.freeze({
-		...expression,
-		fieldName,
-		columnName
-	});
-}
-function isColumnReference(value) {
-	return typeof value === "object" && value !== null && "expressionKind" in value && value.expressionKind === "column";
-}
-/** Turn an expression into a fragment that renders it without changing it. */
-function expressionFragment(expression) {
-	return fragment((context) => context.render(expression));
-}
-//#endregion
-export { qualifiedIdentifier as a, makeExpression as c, markSchemaExpression as d, withDialectCapability as f, sequence as g, parenthesize as h, identifier as i, makeSchemaExpression as l, isFragment as m, expressionFragment as n, isExpression as o, fragment as p, isColumnReference as r, isSchemaExpression as s, createColumnReference as t, markExpressionCategory as u };

package/dist/column-CYMbKbOy.mjs

@@ -1,290 +0,0 @@
-import { s as isSchemaExpression } from "./column-CXMxx8Hq.mjs";
-import { O as freezeSchemaMetadata } from "./registry-BufIskVN.mjs";
-//#region src/schema/column-behavior.ts
-/** A column behavior error with a stable code and optional property path. */
-var ColumnBehaviorError = class extends TypeError {
-	code;
-	path;
-	constructor(code, message, path) {
-		super(message);
-		this.name = "ColumnBehaviorError";
-		this.code = code;
-		this.path = path;
-	}
-};
-/** Build a canonical literal node from a supported JavaScript scalar. */
-function canonicalLiteral(value) {
-	if (value === null) return Object.freeze({ kind: "null" });
-	if (typeof value === "boolean") return Object.freeze({
-		kind: "boolean",
-		value
-	});
-	if (typeof value === "string") return Object.freeze({
-		kind: "string",
-		value
-	});
-	if (typeof value === "bigint") return Object.freeze({
-		kind: "bigint",
-		value: String(value)
-	});
-	if (!Number.isFinite(value)) throw new ColumnBehaviorError("invalid-default", "Default literal numbers must be finite", "default.value");
-	return Object.freeze({
-		kind: "number",
-		value: Object.is(value, -0) ? "0" : String(value)
-	});
-}
-function literalDefault(value) {
-	return Object.freeze({
-		kind: "literal",
-		value: canonicalLiteral(value)
-	});
-}
-/** Normalize a public default input into its canonical snapshot descriptor. */
-function normalizeDefault(value) {
-	if (isSchemaExpression(value)) return Object.freeze({
-		kind: "expression",
-		expression: value
-	});
-	if (isExternalDefaultDescriptor(value)) return externalDefault();
-	return literalDefault(value);
-}
-/** Mark a legacy or externally managed database default explicitly. */
-function externalDefault() {
-	return Object.freeze({ kind: "external" });
-}
-/** Create an immutable generated-column descriptor. */
-function generatedColumn(expression, mode) {
-	assertSchemaExpression(expression, "generatedColumn.expression", "invalid-generated-column");
-	const resolvedMode = typeof mode === "string" ? mode : mode?.mode ?? "stored";
-	if (resolvedMode !== "stored" && resolvedMode !== "virtual") throw new ColumnBehaviorError("invalid-generated-column", `Generated-column mode must be "stored" or "virtual", received "${String(resolvedMode)}"`, "generatedColumn.mode");
-	return Object.freeze({
-		kind: "expression",
-		expression,
-		mode: resolvedMode
-	});
-}
-/** Mark a legacy or externally managed generated column explicitly. */
-function externalGeneratedColumn() {
-	return Object.freeze({ kind: "external" });
-}
-/** Describe a database identity column without inventing a generated SQL expression. */
-function identityColumn(generation, options) {
-	const resolvedGeneration = generation ?? "by-default";
-	if (resolvedGeneration !== "always" && resolvedGeneration !== "by-default") throw new ColumnBehaviorError("invalid-identity", `Identity generation must be "always" or "by-default", received "${String(resolvedGeneration)}"`, "identity.generation");
-	return Object.freeze({
-		kind: "identity",
-		generation: resolvedGeneration,
-		...options?.dialect === void 0 ? {} : { dialect: freezeSchemaMetadata(options.dialect) }
-	});
-}
-/** Normalize complete and legacy column behavior into immutable metadata. */
-function resolveColumnBehavior(options) {
-	const hasDefaultFlag = options.hasDefault === true;
-	const generatedFlag = options.generated === true;
-	const defaultDescriptor = options.default === void 0 ? void 0 : normalizeDefault(options.default);
-	const generatedDescriptor = options.generatedColumn;
-	const identityDescriptor = options.identity;
-	const onUpdateExpression = options.onUpdate;
-	if (onUpdateExpression !== void 0 && !isSchemaExpression(onUpdateExpression)) throw new ColumnBehaviorError("invalid-on-update", "Column onUpdate metadata must carry the deterministic schema-expression brand", "onUpdate");
-	if (defaultDescriptor !== void 0) {
-		assertDefaultDescriptor(defaultDescriptor);
-		if (options.hasDefault === false) throw new ColumnBehaviorError("default-flag-conflict", "A complete default descriptor cannot be combined with hasDefault: false", "hasDefault");
-		if (generatedDescriptor !== void 0 || identityDescriptor !== void 0) throw new ColumnBehaviorError("default-generated-conflict", "A column cannot declare a complete default together with generated-column or identity metadata", "default");
-		if (generatedFlag) throw new ColumnBehaviorError("default-generated-conflict", "A complete default descriptor cannot be combined with generated: true", "default");
-	}
-	if (generatedDescriptor !== void 0) {
-		assertGeneratedColumnDescriptor(generatedDescriptor);
-		if (options.generated === false) throw new ColumnBehaviorError("generated-flag-conflict", "A complete generated-column descriptor cannot be combined with generated: false", "generated");
-		if (identityDescriptor !== void 0) throw new ColumnBehaviorError("identity-generated-conflict", "A column cannot declare both generated-column and identity metadata", "generatedColumn");
-		if (hasDefaultFlag) throw new ColumnBehaviorError("default-generated-conflict", "A complete generated-column descriptor cannot be combined with hasDefault: true", "generatedColumn");
-	}
-	if (identityDescriptor !== void 0) {
-		assertIdentityDescriptor(identityDescriptor);
-		if (options.generated === false) throw new ColumnBehaviorError("generated-flag-conflict", "Identity metadata cannot be combined with generated: false", "generated");
-		if (hasDefaultFlag) throw new ColumnBehaviorError("identity-generated-conflict", "Identity metadata cannot be combined with hasDefault: true", "identity");
-	}
-	const normalizedDefault = defaultDescriptor === void 0 ? void 0 : freezeDefaultDescriptor(defaultDescriptor);
-	const normalizedGenerated = generatedDescriptor === void 0 ? void 0 : freezeGeneratedColumnDescriptor(generatedDescriptor);
-	const normalizedIdentity = identityDescriptor === void 0 ? void 0 : freezeIdentityDescriptor(identityDescriptor);
-	return Object.freeze({
-		hasDefault: hasDefaultFlag || normalizedDefault !== void 0,
-		generated: generatedFlag || normalizedGenerated !== void 0 || normalizedIdentity !== void 0,
-		default: normalizedDefault ?? (hasDefaultFlag ? externalDefault() : void 0),
-		generatedColumn: normalizedGenerated ?? (generatedFlag && normalizedIdentity === void 0 ? externalGeneratedColumn() : void 0),
-		identity: normalizedIdentity,
-		onUpdate: onUpdateExpression
-	});
-}
-function freezeDefaultDescriptor(value) {
-	if (value.kind === "external") return externalDefault();
-	if (value.kind === "expression") return Object.freeze({
-		kind: "expression",
-		expression: value.expression
-	});
-	return Object.freeze({
-		kind: "literal",
-		value: Object.freeze({ ...value.value })
-	});
-}
-function isExternalDefaultDescriptor(value) {
-	return typeof value === "object" && value !== null && value.kind === "external";
-}
-function freezeGeneratedColumnDescriptor(value) {
-	if (value.kind === "external") return externalGeneratedColumn();
-	return Object.freeze({
-		kind: "expression",
-		expression: value.expression,
-		mode: value.mode
-	});
-}
-function freezeIdentityDescriptor(value) {
-	return Object.freeze({
-		kind: "identity",
-		generation: value.generation,
-		...value.dialect === void 0 ? {} : { dialect: freezeSchemaMetadata(value.dialect) }
-	});
-}
-function assertSchemaExpression(expression, path, code = "invalid-default") {
-	if (!isSchemaExpression(expression)) throw new ColumnBehaviorError(code, "Schema behavior expressions must carry the deterministic schema-expression brand", path);
-}
-function assertDefaultDescriptor(value) {
-	if (!value || typeof value !== "object") throw new ColumnBehaviorError("invalid-default", "Column default metadata must be an object", "default");
-	if (value.kind === "external") return;
-	if (value.kind === "expression") {
-		assertSchemaExpression(value.expression, "default.expression");
-		return;
-	}
-	if (value.kind === "literal") {
-		assertCanonicalLiteral(value.value);
-		return;
-	}
-	throw new ColumnBehaviorError("invalid-default", "Unknown column default descriptor kind", "default.kind");
-}
-function assertGeneratedColumnDescriptor(value) {
-	if (!value || typeof value !== "object") throw new ColumnBehaviorError("invalid-generated-column", "Generated-column metadata must be an object", "generatedColumn");
-	if (value.kind === "external") return;
-	if (value.kind === "expression") {
-		assertSchemaExpression(value.expression, "generatedColumn.expression", "invalid-generated-column");
-		if (value.mode !== "stored" && value.mode !== "virtual") throw new ColumnBehaviorError("invalid-generated-column", "Generated-column mode must be \"stored\" or \"virtual\"", "generatedColumn.mode");
-		return;
-	}
-	throw new ColumnBehaviorError("invalid-generated-column", "Unknown generated-column descriptor kind", "generatedColumn.kind");
-}
-function assertIdentityDescriptor(value) {
-	if (!value || typeof value !== "object" || value.kind !== "identity" || value.generation !== "always" && value.generation !== "by-default") throw new ColumnBehaviorError("invalid-identity", "Identity metadata must use generation \"always\" or \"by-default\"", "identity.generation");
-	if (value.dialect !== void 0) {
-		if (typeof value.dialect !== "object" || value.dialect === null || typeof value.dialect.dialect !== "string" || value.dialect.dialect.length === 0) throw new ColumnBehaviorError("invalid-identity", "Identity dialect metadata must contain a non-empty dialect tag", "identity.dialect");
-	}
-}
-function assertCanonicalLiteral(value) {
-	if (!value || typeof value !== "object") throw new ColumnBehaviorError("invalid-default", "Literal defaults must contain a canonical literal node", "default.value");
-	switch (value.kind) {
-		case "null": return;
-		case "boolean":
-			if (typeof value.value === "boolean") return;
-			break;
-		case "string":
-			if (typeof value.value === "string") return;
-			break;
-		case "number":
-			if (typeof value.value === "string" && value.value.length > 0) return;
-			break;
-		case "bigint": if (/^-?(0|[1-9][0-9]*)$/.test(value.value)) return;
-	}
-	throw new ColumnBehaviorError("invalid-default", "Literal defaults must contain a valid canonical literal node", "default.value");
-}
-//#endregion
-//#region src/schema/column.ts
-/** Create an immutable portable physical storage descriptor. */
-function portableStorage(type) {
-	return Object.freeze({
-		kind: "portable",
-		type
-	});
-}
-function nativeStorage(dialectOrOptions, type) {
-	const dialect = typeof dialectOrOptions === "string" ? dialectOrOptions : dialectOrOptions.dialect;
-	const declaration = typeof dialectOrOptions === "string" ? type : "type" in dialectOrOptions ? dialectOrOptions.type : dialectOrOptions.declaration;
-	return Object.freeze({
-		kind: "native",
-		dialect,
-		type: declaration
-	});
-}
-function narrowColumnType() {
-	return this;
-}
-function withPortableCast(definition, type) {
-	return Object.freeze({
-		...definition,
-		castTarget: Object.freeze({
-			kind: "portable-cast",
-			type
-		})
-	});
-}
-function withPortableStorage(definition, type) {
-	return Object.freeze({
-		...definition,
-		storage: portableStorage(type)
-	});
-}
-function column(options) {
-	return Object.freeze({
-		definitionKind: "column",
-		nullable: options?.nullable === true,
-		...resolveColumnBehavior(options ?? {}),
-		sqlName: options?.sqlName,
-		storage: options?.storage ? Object.freeze({ ...options.storage }) : void 0,
-		$type: narrowColumnType,
-		castTarget: options?.castType ? Object.freeze({
-			kind: "named-cast",
-			typeName: options.castType
-		}) : void 0
-	});
-}
-function nativeColumn(storageOrDialect, typeOrOptions, maybeOptions) {
-	const storage = typeof storageOrDialect === "string" ? nativeStorage(storageOrDialect, typeOrOptions) : storageOrDialect;
-	return column({
-		...(typeof storageOrDialect === "string" ? maybeOptions : typeOrOptions) ?? {},
-		storage
-	});
-}
-function nullable(definition) {
-	return Object.freeze({
-		...definition,
-		nullable: true
-	});
-}
-function integer(options) {
-	return withPortableStorage(withPortableCast(column(options), "integer"), "integer");
-}
-function numeric(options) {
-	return withPortableStorage(withPortableCast(column(options), "decimal"), "numeric");
-}
-function text(options) {
-	return withPortableStorage(withPortableCast(column(options), "text"), "text");
-}
-function boolean(options) {
-	return withPortableStorage(withPortableCast(column(options), "boolean"), "boolean");
-}
-function date(options) {
-	return withPortableStorage(withPortableCast(column(options), "date"), "date");
-}
-function timestamp(options) {
-	return withPortableStorage(withPortableCast(column(options), "timestamp"), "timestamp");
-}
-function uuid(options) {
-	return withPortableStorage(withPortableCast(column(options), "uuid"), "uuid");
-}
-function json(options) {
-	return withPortableStorage(withPortableCast(column(options), "json"), "json");
-}
-function bigint(options) {
-	return withPortableStorage(withPortableCast(column(options), "bigint"), "bigint");
-}
-function binary(options) {
-	return withPortableStorage(withPortableCast(column(options), "binary"), "binary");
-}
-//#endregion
-export { resolveColumnBehavior as S, canonicalLiteral as _, date as a, generatedColumn as b, nativeColumn as c, numeric as d, portableStorage as f, ColumnBehaviorError as g, uuid as h, column as i, nativeStorage as l, timestamp as m, binary as n, integer as o, text as p, boolean as r, json as s, bigint as t, nullable as u, externalDefault as v, identityColumn as x, externalGeneratedColumn as y };

package/dist/drizzle-mysql.d.mts

@@ -1,24 +0,0 @@
-import { Pt as AnyTable, Xr as Schema, ni as SchemaTableRecord } from "./types-D8M1yZF4.mjs";
-import { r as DrizzleSchemaValidation, t as DrizzleColumnConfig } from "./types-Ctlxz1ip.mjs";
-import { MySqlColumn, MySqlTableWithColumns } from "drizzle-orm/mysql-core";
-//#region src/drizzle/mysql.d.ts
-type MysqlDrizzleColumn<TTableName extends string, TDefinition> = MySqlColumn<DrizzleColumnConfig<TTableName, TDefinition>>;
-type MysqlDrizzleColumns<TTable extends AnyTable> = { [TKey in keyof TTable['definitions']]: MysqlDrizzleColumn<TTable['tableName'], TTable['definitions'][TKey]>; };
-/** The Drizzle MySQL table produced for one Qubu table. */
-type MysqlDrizzleTable<TTable extends AnyTable> = MySqlTableWithColumns<{
-  name: TTable['tableName'];
-  schema: string | undefined;
-  columns: MysqlDrizzleColumns<TTable>;
-  dialect: 'mysql';
-}>;
-/** A MySQL Drizzle table record retaining Qubu's logical table keys. */
-type MysqlDrizzleSchema<TSchema extends Schema<any>> = { readonly [TKey in keyof TSchema['tables']]: MysqlDrizzleTable<TSchema['tables'][TKey]>; };
-/**
- * Convert a live Qubu schema registry into MySQL Drizzle table objects.
- *
- * @throws A snapshot validation error for invalid MySQL metadata, or a
- * DrizzleSchemaConversionError when Drizzle cannot represent required metadata.
- */
-declare function toMysqlDrizzleSchema<const TTables extends SchemaTableRecord>(schema: Schema<TTables> & DrizzleSchemaValidation<TTables, 'mysql'>): MysqlDrizzleSchema<Schema<TTables>>;
-//#endregion
-export { MysqlDrizzleSchema, MysqlDrizzleTable, toMysqlDrizzleSchema };