@rebasepro/server-postgres 0.24.0 → 0.24.1-canary.g19596ef

package/dist/source-DB6xJv3p.js

@@ -0,0 +1,873 @@
+import { createRequire as __createRequire } from "module";
+__createRequire(import.meta.url);
+import { n as __exportAll } from "./rolldown-runtime-V7rFbMRe.js";
+import { isPostgresCollectionConfig, parseEnvBoolean } from "@rebasepro/types";
+import { getTableName, resolveCollectionRelations } from "@rebasepro/common";
+import { sha1Hex, truncateToBytes } from "@rebasepro/utils";
+import process$1 from "node:process";
+import os from "node:os";
+import tty from "node:tty";
+//#region src/schema/collection-index.ts
+var collection_index_exports = /* @__PURE__ */ __exportAll({
+	CollectionIndexConfigError: () => CollectionIndexConfigError,
+	FOREIGN_KEY_INDEX_REASON: () => FOREIGN_KEY_INDEX_REASON,
+	MAX_INDEX_KEYS: () => 5,
+	buildCollectionIndexPlan: () => buildCollectionIndexPlan,
+	buildCollectionIndexSpecs: () => buildCollectionIndexSpecs,
+	collectionIndexStatement: () => collectionIndexStatement,
+	collectionIndexStatements: () => collectionIndexStatements,
+	deriveIndexName: () => deriveIndexName,
+	foreignKeyIndexSpec: () => foreignKeyIndexSpec,
+	indexFingerprint: () => indexFingerprint,
+	isRebaseIndexName: () => isRebaseIndexName,
+	leadsWithColumn: () => leadsWithColumn,
+	renderPredicate: () => renderPredicate,
+	resolveIndexableColumn: () => resolveIndexableColumn,
+	sortIndexSpecs: () => sortIndexSpecs
+});
+/**
+* A declaration that cannot become an index.
+*
+* Thrown at build time, naming the collection and the array position, because
+* the alternative is a `CREATE INDEX` that fails during a push with a Postgres
+* error mentioning a column the author never wrote.
+*/
+var CollectionIndexConfigError = class extends Error {
+	collectionSlug;
+	position;
+	constructor(collectionSlug, position, message) {
+		super(`${collectionSlug}.indexes[${position}]: ${message}`);
+		this.name = "CollectionIndexConfigError";
+		this.collectionSlug = collectionSlug;
+		this.position = position;
+	}
+};
+/**
+* `_ix`/`_ux` plus `_` plus 7 hex — the part of the name that must always
+* survive truncation, and therefore is never inside the truncated portion.
+*/
+var NAME_SUFFIX_BYTES = 11;
+/**
+* Every Rebase-managed index name, and nothing else.
+*
+* The terminal `_ix_`/`_ux_` plus exactly seven lowercase hex characters is
+* what separates this scheme from every other producer in the codebase —
+* `_fkey`, `_gin`, `_trgm`, `_pkey`, `_key`, the vector distances, and the
+* `idx_` prefix auth uses. `_idx` was rejected as a tail because it is already
+* taken for real: `users_email_verification_token_idx` is byte-for-byte what a
+* naive `<table>_<column>_idx` derives on an auth-enabled `users` collection.
+*
+* Load-bearing for safety, not just tidiness. An index that does NOT match this
+* belongs to somebody else — a hand-written one, or one an introspected
+* database arrived with — and is excluded from the Atlas diff so the push
+* cannot drop it.
+*/
+var isRebaseIndexName = (name) => /_(?:ix|ux)_[0-9a-f]{7}$/.test(name);
+var isOrderedMethod = (method) => method === "btree";
+/**
+* The parts of an index that decide what it *is*.
+*
+* A semantic projection, not the rendered statement — the same arrangement as
+* `getPolicyNameHash`, and for the same reason. A change to how this file
+* formats SQL (eliding a default `USING btree`, quoting differently, emitting
+* `NULLS LAST` explicitly) must not silently rename every index in every
+* deployed database. Hashing generator output would make every cosmetic edit a
+* fleet-wide DROP + CREATE.
+*
+* `reason` is deliberately absent: rewording a comment must not rebuild an
+* index. `nulls` is the *effective* placement, so writing Postgres's own
+* default down is a no-op rather than a redefinition.
+*
+* `v` is the only escape hatch, and it is expensive on purpose: bumping it
+* renames every index in the field.
+*/
+var indexFingerprint = (spec) => sha1Hex(JSON.stringify({
+	v: 1,
+	s: spec.schema,
+	t: spec.table,
+	m: spec.method,
+	u: spec.unique,
+	k: spec.keys.map((k) => [
+		k.column,
+		k.direction,
+		k.nulls
+	]),
+	i: spec.include,
+	w: spec.predicate
+})).substring(0, 7);
+/**
+* `<table>_<columns>_ix_<hash>`, or `_ux_` when unique.
+*
+* Truncation eats the readable head and never the hash. `toPostgresIdentifier`
+* truncates the whole string at 63 bytes, which on a hashed name would cut off
+* the one part that makes it unique — the failure already frozen into
+* `contracts/derived-names.txt`, where a foreign key is recorded with its
+* `_fkey` suffix truncated away, so a second foreign key on that table would
+* derive a byte-identical name.
+*/
+var deriveIndexName = (spec) => {
+	const suffix = `_${spec.unique ? "ux" : "ix"}_${indexFingerprint(spec)}`;
+	return `${truncateToBytes(`${spec.table}_${spec.keys.map((k) => k.column).join("_")}`, 63 - NAME_SUFFIX_BYTES)}${suffix}`;
+};
+var quoteLiteral = (value) => {
+	if (typeof value === "number") return String(value);
+	if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+	return `'${value.replace(/'/g, "''")}'`;
+};
+/** Render a resolved predicate as the body of a `WHERE` clause. */
+var renderPredicate = (predicate) => {
+	if ("and" in predicate) return predicate.and.map(renderPredicate).join(" AND ");
+	switch (predicate.op) {
+		case "is null":
+		case "is not null": return `"${predicate.column}" ${predicate.op.toUpperCase()}`;
+		case "in": return `"${predicate.column}" IN (${predicate.value.map(quoteLiteral).join(", ")})`;
+		default: return `"${predicate.column}" ${predicate.op} ${quoteLiteral(predicate.value)}`;
+	}
+};
+/**
+* The `CREATE INDEX` for one spec.
+*
+* `concurrently` is a parameter rather than a string replacement on the way
+* out. `search-column.ts` and `vector-index.ts` both reach for
+* `.replace("CREATE INDEX IF NOT EXISTS", …)` instead, which silently does
+* nothing for a UNIQUE index — the rendered text is `CREATE UNIQUE INDEX …`
+* and the pattern never matches.
+*/
+var collectionIndexStatement = (spec, options = {}) => {
+	const unique = spec.unique ? "UNIQUE " : "";
+	const concurrently = options.concurrently ? "CONCURRENTLY " : "";
+	const ifNotExists = options.ifNotExists ? "IF NOT EXISTS " : "";
+	const using = spec.method === "btree" ? "" : ` USING ${spec.method}`;
+	const keys = spec.keys.map((k) => {
+		if (!isOrderedMethod(spec.method)) return `"${k.column}"`;
+		const direction = k.direction === "desc" ? " DESC" : "";
+		const impliedNulls = k.direction === "desc" ? "first" : "last";
+		const nulls = k.nulls === impliedNulls ? "" : ` NULLS ${k.nulls.toUpperCase()}`;
+		return `"${k.column}"${direction}${nulls}`;
+	}).join(", ");
+	const include = spec.include.length > 0 ? ` INCLUDE (${spec.include.map((c) => `"${c}"`).join(", ")})` : "";
+	const where = spec.predicate ? ` WHERE ${renderPredicate(spec.predicate)}` : "";
+	return `CREATE ${unique}INDEX ${concurrently}${ifNotExists}"${spec.indexName}" ON "${spec.schema}"."${spec.table}"${using} (${keys})${include}${where};`;
+};
+var collectionIndexStatements = (specs, options = {}) => specs.map((spec) => collectionIndexStatement(spec, options));
+var relationOf = (collection, propKey) => resolveCollectionRelations(collection)[propKey];
+/**
+* The column a property key indexes.
+*
+* A `belongsTo` resolves to its `localKey` — `primaryCategory` becomes
+* `primary_category_id` — which is the case an index is most often wanted for
+* and the case where the property key and the column differ. Everything else
+* goes through `resolveColumnName`.
+*
+* The other relation kinds have no local column at all: the foreign key lives
+* on the target's table, or in a junction. Indexing them here is refused
+* rather than resolved to a column that does not exist.
+*/
+var resolveIndexableColumn = (collection, propKey, resolveColumnName, fail) => {
+	const relation = relationOf(collection, propKey);
+	if (relation) {
+		if (relation.kind === "belongsTo") return relation.localKey;
+		fail(`"${propKey}" is a ${relation.kind} relation, which has no column on this table — the foreign key lives on "${relation.targetSlug}". Declare the index there.`);
+	}
+	const property = collection.properties?.[propKey];
+	if (!property) fail(`"${propKey}" is not a property of this collection.`);
+	return resolveColumnName(propKey, property);
+};
+var resolvePredicate = (collection, predicate, resolveColumnName, fail) => {
+	if ("and" in predicate) return { and: predicate.and.map((p) => resolvePredicate(collection, p, resolveColumnName, fail)) };
+	const column = resolveIndexableColumn(collection, predicate.prop, resolveColumnName, fail);
+	switch (predicate.op) {
+		case "is null":
+		case "is not null": return {
+			column,
+			op: predicate.op
+		};
+		case "in":
+			if (new Set(predicate.value).size !== predicate.value.length) fail(`the \`in\` list for "${predicate.prop}" repeats a value, which changes nothing.`);
+			return {
+				column,
+				op: "in",
+				value: [...predicate.value]
+			};
+		default: return {
+			column,
+			op: predicate.op,
+			value: predicate.value
+		};
+	}
+};
+/** The primary key columns of a collection, for the "you already have this" refusal. */
+var primaryKeyColumns = (collection, resolveColumnName) => Object.entries(collection.properties ?? {}).filter(([, prop]) => prop && typeof prop === "object" && "isId" in prop && Boolean(prop.isId)).map(([key, prop]) => resolveColumnName(key, prop));
+/**
+* Every index one collection declares, resolved and named.
+*
+* Throws {@link CollectionIndexConfigError} rather than dropping a bad entry:
+* an index that silently does not exist is the failure mode this whole feature
+* is here to remove.
+*/
+var buildCollectionIndexSpecs = (collection, resolveColumnName) => {
+	if (!isPostgresCollectionConfig(collection)) return [];
+	const declared = collection.indexes;
+	if (!declared || declared.length === 0) return [];
+	const slug = collection.slug ?? getTableName(collection);
+	const schema = collection.schema ?? "public";
+	const table = getTableName(collection);
+	const pk = primaryKeyColumns(collection, resolveColumnName).sort().join(",");
+	const specs = [];
+	const byName = /* @__PURE__ */ new Map();
+	declared.forEach((index, position) => {
+		const fail = (message) => {
+			throw new CollectionIndexConfigError(slug, position, message);
+		};
+		if (typeof index.reason !== "string" || index.reason.trim() === "") fail("`reason` is required — see the doc comment. An index nobody can justify is one nobody can delete.");
+		if (!Array.isArray(index.on) || index.on.length === 0) fail("`on` must name at least one property.");
+		if (index.on.length > 5) fail(`\`on\` has ${index.on.length} keys; the limit is 5. Payload columns belong in \`include\`.`);
+		const method = index.using ?? "btree";
+		const unique = method === "btree" && Boolean(index.unique);
+		if (!isOrderedMethod(method)) {
+			for (const key of index.on) if (typeof key !== "string" && ("direction" in key || "nulls" in key)) fail(`access method "${method}" does not support ASC/DESC or NULLS options.`);
+		}
+		const keys = index.on.map((key) => {
+			const column = resolveIndexableColumn(collection, typeof key === "string" ? key : key.prop, resolveColumnName, fail);
+			const direction = (typeof key === "string" ? void 0 : key.direction) ?? "asc";
+			return {
+				column,
+				direction,
+				nulls: (typeof key === "string" ? void 0 : key.nulls) ?? (direction === "desc" ? "first" : "last")
+			};
+		});
+		const duplicateKey = keys.map((k) => k.column).find((c, i, all) => all.indexOf(c) !== i);
+		if (duplicateKey) fail(`"${duplicateKey}" appears twice in \`on\`.`);
+		if (keys.map((k) => k.column).sort().join(",") === pk && pk !== "") fail(`this is the primary key — "${table}_pkey" already indexes exactly these columns.`);
+		const include = (index.include ?? []).map((propKey) => resolveIndexableColumn(collection, propKey, resolveColumnName, fail));
+		const overlap = include.find((c) => keys.some((k) => k.column === c));
+		if (overlap) fail(`"${overlap}" is in both \`on\` and \`include\`; Postgres rejects the overlap.`);
+		if (unique && keys.length === 1) {
+			const propKey = typeof index.on[0] === "string" ? index.on[0] : index.on[0].prop;
+			if ((collection.properties?.[propKey])?.validation?.unique) fail(`"${propKey}" already declares \`validation.unique\`, which compiles to an inline UNIQUE. Two declarations of one guarantee — remove one.`);
+		}
+		const predicate = index.where ? resolvePredicate(collection, index.where, resolveColumnName, fail) : null;
+		const withoutName = {
+			schema,
+			table,
+			method,
+			unique,
+			keys,
+			include,
+			predicate,
+			reason: index.reason
+		};
+		const indexName = deriveIndexName(withoutName);
+		const clash = byName.get(indexName);
+		if (clash !== void 0) fail(`derives the same name as indexes[${clash}] — they are the same index declared twice.`);
+		byName.set(indexName, position);
+		specs.push({
+			...withoutName,
+			indexName
+		});
+	});
+	return specs;
+};
+/**
+* Every declared index across a set of collections, in a stable order.
+*
+* Sorted because the result reaches `schema.sql`, which `doctor` string-
+* compares against a regenerated copy — `generatePostgresDdl` does not sort its
+* collections, so leaving this in declaration order would make the artifact
+* depend on the order files happened to load in.
+*/
+var buildCollectionIndexPlan = (collections, resolveColumnName) => sortIndexSpecs(collections.flatMap((collection) => buildCollectionIndexSpecs(collection, resolveColumnName)));
+/**
+* The stable order every consumer of a set of index specs uses.
+*
+* Exported because the boot-time diff reads the specs off the schema plan
+* rather than rebuilding them, and it has to reach the same order the CLI's
+* exclude list and `schema.sql` do — a second sort written out beside this one
+* is a second order the moment either is edited.
+*/
+var sortIndexSpecs = (specs) => [...specs].sort((a, b) => a.schema.localeCompare(b.schema) || a.table.localeCompare(b.table) || a.indexName.localeCompare(b.indexName));
+/**
+* The `reason` a derived foreign-key index carries. Never part of the name —
+* see {@link indexFingerprint} — so rewording it renames nothing.
+*/
+var FOREIGN_KEY_INDEX_REASON = "Derived for a foreign key: Postgres indexes the key a constraint points at, never the column holding it.";
+/**
+* Whether an index already serves an equality lookup on `column` alone.
+*
+* A btree whose *leading* key is the column does, unique or not — that is the
+* prefix rule, and it is why a composite `(author_id, created_at)` makes a
+* second index on `author_id` pure write amplification. A partial index does
+* not: it serves only the rows its predicate admits, and a foreign-key lookup
+* has to reach every row. Nor does GIN or BRIN, which answer different
+* questions than "the rows whose key is one of these".
+*/
+var leadsWithColumn = (spec, column) => spec.method === "btree" && spec.predicate === null && spec.keys[0]?.column === column;
+/**
+* The btree a foreign-key column gets when nothing else already leads with it.
+*
+* Postgres creates the index a foreign key *references* (the target's primary
+* key) and never the one on the column *holding* it. Every read from the other
+* side of the link filters on that column — a `hasMany`/`hasOne` include, a
+* nested listing (`/authors/5/posts`, page and count), the reverse side of a
+* many-to-many — and so does the `ON DELETE` check when a target row goes. With
+* no index each of those is a sequential scan of the child table: measured at
+* 13 ms for 25 parents over 100k children, and about 250 ms per nested listing
+* at a million.
+*
+* Named by {@link deriveIndexName} like every other index, so it is a
+* Rebase-managed name (`_ix_<fingerprint>`), it is in the Atlas diff, and it
+* is byte-for-byte the name an author's own plain index on the column would
+* derive. That identity is what makes the derived index and a declared one the
+* same object rather than two.
+*/
+var foreignKeyIndexSpec = (schema, table, column) => {
+	const withoutName = {
+		schema,
+		table,
+		method: "btree",
+		unique: false,
+		keys: [{
+			column,
+			direction: "asc",
+			nulls: "last"
+		}],
+		include: [],
+		predicate: null,
+		reason: FOREIGN_KEY_INDEX_REASON
+	};
+	return {
+		...withoutName,
+		indexName: deriveIndexName(withoutName),
+		derived: "foreign-key"
+	};
+};
+//#endregion
+//#region src/schema/atlas-exclude.ts
+/**
+* The names `db push` hands Atlas's `--exclude`, spelled so they match.
+*
+* An exclude is the only thing between `atlas schema apply --auto-approve` and
+* an object Rebase does not own: a table no collection backs, a hand-written
+* index, a CHECK constraint, the search and vector columns Rebase applies
+* itself. Atlas reads each one as a glob split on `.`, so a name is not a
+* pattern as it stands. Measured against the pinned 1.2.3:
+*
+*  - a `.` in a name makes one more part, and Atlas refuses the whole command,
+*    `too many parts in pattern` — so every push fails on that database;
+*  - `[`, `]`, `*` and `?` are glob syntax. `[v1]` is a class matching `v` or
+*    `1`, so `idx[v1]` matches `idxv` and not the index called `idx[v1]`:
+*    nothing is excluded, nothing is reported, and Atlas plans the drop. For
+*    an index that drop is not gated, so it applied without a word.
+*
+* So each part is escaped on its own and the parts are joined: a `.` becomes
+* `?`, which matches it (and any one character, so a pattern that also keeps a
+* near-namesake errs on the side of keeping), and glob syntax is escaped with
+* `\`, which Atlas reads as the literal.
+*
+* Code that reads these patterns back — the migration stripper, the generated
+* column ownership check, the index ownership check — reads them with
+* {@link excludePatternParts}, the exact inverse for a pattern built here.
+*/
+/** One part of an Atlas `--exclude` pattern that matches exactly this name. */
+function atlasExcludeSegment(name) {
+	return name.replace(/[\\*?[\]]/g, (ch) => `\\${ch}`).replace(/\./g, "?");
+}
+/**
+* The pattern that matches exactly the object these names qualify:
+* `(schema, table)` for a table, `(schema, table, object)` for a column, an
+* index or a constraint. Three parts for anything on a table: a two-part
+* pattern reads as a table, matches nothing, and reports no error.
+*/
+function atlasExcludePattern(...parts) {
+	return parts.map(atlasExcludeSegment).join(".");
+}
+/**
+* The names a pattern from {@link atlasExcludePattern} was built from, or
+* `undefined` for one that is not a plain name — a wildcard such as `auth.*`.
+*
+* Exact for every pattern built there: a `\` escapes the character after it,
+* and an unescaped `?` can only be a dot.
+*/
+function excludePatternParts(pattern) {
+	const parts = [];
+	for (const segment of pattern.split(".")) {
+		let name = "";
+		for (let i = 0; i < segment.length; i++) {
+			const ch = segment[i];
+			if (ch === "\\" && i + 1 < segment.length) name += segment[++i];
+			else if (ch === "?") name += ".";
+			else if (ch === "*" || ch === "[" || ch === "]") return;
+			else name += ch;
+		}
+		parts.push(name);
+	}
+	return parts;
+}
+//#endregion
+//#region src/cli-output.ts
+/**
+* Terminal output for the `rebase db|schema|doctor` commands.
+*
+* These commands used to write every line through `logger`, and that is a
+* category error with three separate consequences:
+*
+*  - `logger` prefixes each line with its own level, so a box-drawn report
+*    arrived as `ℹ️ [INFO]   ┌─ ✗ Missing Column ───` and the frame no longer
+*    lined up with anything;
+*  - `logger` is gated by `LOG_LEVEL`, which ships in the scaffold's own
+*    `.env.example` — a developer who quietened their dev server with
+*    `LOG_LEVEL=warn` got a `rebase db push` that printed almost nothing and
+*    still exited non-zero, indistinguishable from a crash;
+*  - under `NODE_ENV=production` `logger` emits JSON, so the whole report
+*    became log records with the chalk escape codes embedded in them.
+*
+* A CLI's report *is* its return value. It goes to the terminal unconditionally
+* and unadorned. `packages/cli` has always written its output this way; this is
+* the same three functions for the plugin CLI that `rebase` delegates to.
+*
+* `logger` still belongs in this package's *runtime* — a request handler has no
+* terminal and its lines want levels, timestamps and redaction. The rule is the
+* caller, not the severity: anything a developer reads because they typed a
+* command goes here, anything a server emits while running goes to `logger`.
+*
+* Errors and warnings go to stderr so `rebase db push > plan.txt` keeps the
+* diagnosis on the terminal where it is readable.
+*/
+/** One line of human-facing output on stdout. */
+var out = (line = "") => {
+	console.log(line);
+};
+/** One line of human-facing warning output on stderr. */
+var outWarn = (line = "") => {
+	console.warn(line);
+};
+/** One line of human-facing error output on stderr. */
+var outError = (line = "") => {
+	console.error(line);
+};
+/**
+* Whether a failure should be printed with its stack — `rebase --debug`, which
+* the launcher passes down as `REBASE_DEBUG`, or `REBASE_DEBUG` set by hand.
+*/
+var wantsStack = () => parseEnvBoolean(process.env.REBASE_DEBUG) === true;
+/**
+* An error as a person reads it: its message, and its stack only under
+* `--debug`.
+*
+* The rule `rebase` itself follows (`bin/rebase.js`). These commands run in a
+* child process the launcher's handler never sees, so a syntax error in a
+* collection file reached the terminal as `Doctor failed CollectionConfigError:`
+* followed by twenty frames of loader internals, under a sentence that already
+* said which file and which line.
+*/
+var describeFailure = (error) => {
+	if (!(error instanceof Error)) return String(error);
+	if (wantsStack() && error.stack) return error.stack;
+	return `${error.message}\n  Re-run with --debug for the stack trace.`;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\u001B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\u001B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+var styles$1 = {
+	modifier: {
+		reset: [0, 0],
+		bold: [1, 22],
+		dim: [2, 22],
+		italic: [3, 23],
+		underline: [4, 24],
+		overline: [53, 55],
+		inverse: [7, 27],
+		hidden: [8, 28],
+		strikethrough: [9, 29]
+	},
+	color: {
+		black: [30, 39],
+		red: [31, 39],
+		green: [32, 39],
+		yellow: [33, 39],
+		blue: [34, 39],
+		magenta: [35, 39],
+		cyan: [36, 39],
+		white: [37, 39],
+		blackBright: [90, 39],
+		gray: [90, 39],
+		grey: [90, 39],
+		redBright: [91, 39],
+		greenBright: [92, 39],
+		yellowBright: [93, 39],
+		blueBright: [94, 39],
+		magentaBright: [95, 39],
+		cyanBright: [96, 39],
+		whiteBright: [97, 39]
+	},
+	bgColor: {
+		bgBlack: [40, 49],
+		bgRed: [41, 49],
+		bgGreen: [42, 49],
+		bgYellow: [43, 49],
+		bgBlue: [44, 49],
+		bgMagenta: [45, 49],
+		bgCyan: [46, 49],
+		bgWhite: [47, 49],
+		bgBlackBright: [100, 49],
+		bgGray: [100, 49],
+		bgGrey: [100, 49],
+		bgRedBright: [101, 49],
+		bgGreenBright: [102, 49],
+		bgYellowBright: [103, 49],
+		bgBlueBright: [104, 49],
+		bgMagentaBright: [105, 49],
+		bgCyanBright: [106, 49],
+		bgWhiteBright: [107, 49]
+	}
+};
+Object.keys(styles$1.modifier);
+var foregroundColorNames = Object.keys(styles$1.color);
+var backgroundColorNames = Object.keys(styles$1.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+	const codes = /* @__PURE__ */ new Map();
+	for (const [groupName, group] of Object.entries(styles$1)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles$1[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`
+			};
+			group[styleName] = styles$1[styleName];
+			codes.set(style[0], style[1]);
+		}
+		Object.defineProperty(styles$1, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
+	Object.defineProperty(styles$1, "codes", {
+		value: codes,
+		enumerable: false
+	});
+	styles$1.color.close = "\x1B[39m";
+	styles$1.bgColor.close = "\x1B[49m";
+	styles$1.color.ansi = wrapAnsi16();
+	styles$1.color.ansi256 = wrapAnsi256();
+	styles$1.color.ansi16m = wrapAnsi16m();
+	styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+	Object.defineProperties(styles$1, {
+		rgbToAnsi256: {
+			value(red, green, blue) {
+				if (red === green && green === blue) {
+					if (red < 8) return 16;
+					if (red > 248) return 231;
+					return Math.round((red - 8) / 247 * 24) + 232;
+				}
+				return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+			},
+			enumerable: false
+		},
+		hexToRgb: {
+			value(hex) {
+				const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+				if (!matches) return [
+					0,
+					0,
+					0
+				];
+				let [colorString] = matches;
+				if (colorString.length === 3) colorString = [...colorString].map((character) => character + character).join("");
+				const integer = Number.parseInt(colorString, 16);
+				return [
+					integer >> 16 & 255,
+					integer >> 8 & 255,
+					integer & 255
+				];
+			},
+			enumerable: false
+		},
+		hexToAnsi256: {
+			value: (hex) => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
+			enumerable: false
+		},
+		ansi256ToAnsi: {
+			value(code) {
+				if (code < 8) return 30 + code;
+				if (code < 16) return 90 + (code - 8);
+				let red;
+				let green;
+				let blue;
+				if (code >= 232) {
+					red = ((code - 232) * 10 + 8) / 255;
+					green = red;
+					blue = red;
+				} else {
+					code -= 16;
+					const remainder = code % 36;
+					red = Math.floor(code / 36) / 5;
+					green = Math.floor(remainder / 6) / 5;
+					blue = remainder % 6 / 5;
+				}
+				const value = Math.max(red, green, blue) * 2;
+				if (value === 0) return 30;
+				let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+				if (value === 2) result += 60;
+				return result;
+			},
+			enumerable: false
+		},
+		rgbToAnsi: {
+			value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
+			enumerable: false
+		},
+		hexToAnsi: {
+			value: (hex) => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
+			enumerable: false
+		}
+	});
+	return styles$1;
+}
+var ansiStyles = assembleStyles();
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process$1.argv) {
+	const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf("--");
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = process$1;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) flagForceColor = 0;
+else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) flagForceColor = 1;
+function envForceColor() {
+	if ("FORCE_COLOR" in env) {
+		if (env.FORCE_COLOR === "true") return 1;
+		if (env.FORCE_COLOR === "false") return 0;
+		return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+	}
+}
+function translateLevel(level) {
+	if (level === 0) return false;
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+	const noFlagForceColor = envForceColor();
+	if (noFlagForceColor !== void 0) flagForceColor = noFlagForceColor;
+	const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+	if (forceColor === 0) return 0;
+	if (sniffFlags) {
+		if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) return 3;
+		if (hasFlag("color=256")) return 2;
+	}
+	if ("TF_BUILD" in env && "AGENT_NAME" in env) return 1;
+	if (haveStream && !streamIsTTY && forceColor === void 0) return 0;
+	const min = forceColor || 0;
+	if (env.TERM === "dumb") return min;
+	if (process$1.platform === "win32") {
+		const osRelease = os.release().split(".");
+		if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) return Number(osRelease[2]) >= 14931 ? 3 : 2;
+		return 1;
+	}
+	if ("CI" in env) {
+		if ([
+			"GITHUB_ACTIONS",
+			"GITEA_ACTIONS",
+			"CIRCLECI"
+		].some((key) => key in env)) return 3;
+		if ([
+			"TRAVIS",
+			"APPVEYOR",
+			"GITLAB_CI",
+			"BUILDKITE",
+			"DRONE"
+		].some((sign) => sign in env) || env.CI_NAME === "codeship") return 1;
+		return min;
+	}
+	if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	if (env.COLORTERM === "truecolor") return 3;
+	if (env.TERM === "xterm-kitty") return 3;
+	if (env.TERM === "xterm-ghostty") return 3;
+	if (env.TERM === "wezterm") return 3;
+	if ("TERM_PROGRAM" in env) {
+		const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+		switch (env.TERM_PROGRAM) {
+			case "iTerm.app": return version >= 3 ? 3 : 2;
+			case "Apple_Terminal": return 2;
+		}
+	}
+	if (/-256(color)?$/i.test(env.TERM)) return 2;
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) return 1;
+	if ("COLORTERM" in env) return 1;
+	return min;
+}
+function createSupportsColor(stream, options = {}) {
+	return translateLevel(_supportsColor(stream, {
+		streamIsTTY: stream && stream.isTTY,
+		...options
+	}));
+}
+var supportsColor = {
+	stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+	stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+	let index = string.indexOf(substring);
+	if (index === -1) return string;
+	const substringLength = substring.length;
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		returnValue += string.slice(endIndex, index) + substring + replacer;
+		endIndex = index + substringLength;
+		index = string.indexOf(substring, endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+	let endIndex = 0;
+	let returnValue = "";
+	do {
+		const gotCR = string[index - 1] === "\r";
+		returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+		endIndex = index + 1;
+		index = string.indexOf("\n", endIndex);
+	} while (index !== -1);
+	returnValue += string.slice(endIndex);
+	return returnValue;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supportsColor;
+var GENERATOR = Symbol("GENERATOR");
+var STYLER = Symbol("STYLER");
+var IS_EMPTY = Symbol("IS_EMPTY");
+var levelMapping = [
+	"ansi",
+	"ansi",
+	"ansi256",
+	"ansi16m"
+];
+var styles = Object.create(null);
+var applyOptions = (object, options = {}) => {
+	if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) throw new Error("The `level` option should be an integer from 0 to 3");
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
+	object.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+	const chalk = (...strings) => strings.join(" ");
+	applyOptions(chalk, options);
+	Object.setPrototypeOf(chalk, createChalk.prototype);
+	return chalk;
+};
+function createChalk(options) {
+	return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansiStyles)) styles[styleName] = { get() {
+	const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+	Object.defineProperty(this, styleName, { value: builder });
+	return builder;
+} };
+styles.visible = { get() {
+	const builder = createBuilder(this, this[STYLER], true);
+	Object.defineProperty(this, "visible", { value: builder });
+	return builder;
+} };
+var getModelAnsi = (model, level, type, ...arguments_) => {
+	if (model === "rgb") {
+		if (level === "ansi16m") return ansiStyles[type].ansi16m(...arguments_);
+		if (level === "ansi256") return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+		return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+	}
+	if (model === "hex") return getModelAnsi("rgb", level, type, ...ansiStyles.hexToRgb(...arguments_));
+	return ansiStyles[type][model](...arguments_);
+};
+for (const model of [
+	"rgb",
+	"hex",
+	"ansi256"
+]) {
+	styles[model] = { get() {
+		const { level } = this;
+		return function(...arguments_) {
+			const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansiStyles.color.close, this[STYLER]);
+			return createBuilder(this, styler, this[IS_EMPTY]);
+		};
+	} };
+	const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+	styles[bgModel] = { get() {
+		const { level } = this;
+		return function(...arguments_) {
+			const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
+			return createBuilder(this, styler, this[IS_EMPTY]);
+		};
+	} };
+}
+var proto = Object.defineProperties(() => {}, {
+	...styles,
+	level: {
+		enumerable: true,
+		get() {
+			return this[GENERATOR].level;
+		},
+		set(level) {
+			this[GENERATOR].level = level;
+		}
+	}
+});
+var createStyler = (open, close, parent) => {
+	let openAll;
+	let closeAll;
+	if (parent === void 0) {
+		openAll = open;
+		closeAll = close;
+	} else {
+		openAll = parent.openAll + open;
+		closeAll = close + parent.closeAll;
+	}
+	return {
+		open,
+		close,
+		openAll,
+		closeAll,
+		parent
+	};
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+	const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+	Object.setPrototypeOf(builder, proto);
+	builder[GENERATOR] = self;
+	builder[STYLER] = _styler;
+	builder[IS_EMPTY] = _isEmpty;
+	return builder;
+};
+var applyStyle = (self, string) => {
+	if (self.level <= 0 || !string) return self[IS_EMPTY] ? "" : string;
+	let styler = self[STYLER];
+	if (styler === void 0) return string;
+	const { openAll, closeAll } = styler;
+	if (string.includes("\x1B")) while (styler !== void 0) {
+		string = stringReplaceAll(string, styler.close, styler.open);
+		styler = styler.parent;
+	}
+	const lfIndex = string.indexOf("\n");
+	if (lfIndex !== -1) string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+	return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles);
+var chalk = createChalk();
+createChalk({ level: stderrColor ? stderrColor.level : 0 });
+//#endregion
+export { sortIndexSpecs as _, outWarn as a, buildCollectionIndexSpecs as c, collection_index_exports as d, deriveIndexName as f, renderPredicate as g, leadsWithColumn as h, outError as i, collectionIndexStatement as l, isRebaseIndexName as m, describeFailure as n, atlasExcludePattern as o, foreignKeyIndexSpec as p, out as r, excludePatternParts as s, chalk as t, collectionIndexStatements as u };
+
+//# sourceMappingURL=source-DB6xJv3p.js.map