better-supabase 0.13.0 → 0.15.0

package/dist/live-C21DgbsD.js

@@ -0,0 +1,275 @@
+import { t as refreshRealtimeAuth } from "./auth-DyF_LRxd.js";
+import { REALTIME_SUBSCRIBE_STATES } from "@supabase/supabase-js";
+//#region src/realtime/live.ts
+/**
+* Topic a `realtime-tables` trigger broadcasts on:
+* `bsb:t:<schema>.<table>[:<tenant>]`, or `bsb:t:<schema>.<table>:u:<user>` for
+* a `realtime.users` table.
+*/
+function liveTopic(meta, table, tenant, user) {
+	const found = meta.tables[table];
+	if (!found) throw new TypeError(`better-supabase: unknown table "${table}"`);
+	const base = `bsb:t:${found.schema}.${found.name}`;
+	if (meta.realtime?.[table]?.user) {
+		if (user === void 0) throw new TypeError(`better-supabase: "${table}" broadcasts per user; pass \`user\` to watch it`);
+		return `${base}:u:${user}`;
+	}
+	if (!meta.realtime?.[table]?.tenant) return base;
+	if (tenant === void 0) throw new TypeError(`better-supabase: "${table}" broadcasts per tenant; pass \`tenant\` to watch it`);
+	return `${base}:${tenant}`;
+}
+const channels = /* @__PURE__ */ new WeakMap();
+function join(client, topic, listener, onStatus) {
+	let byTopic = channels.get(client);
+	if (!byTopic) {
+		byTopic = /* @__PURE__ */ new Map();
+		channels.set(client, byTopic);
+	}
+	let shared = byTopic.get(topic);
+	if (!shared) {
+		const channel = client.channel(topic, { config: { private: true } });
+		const listeners = /* @__PURE__ */ new Set();
+		const statuses = /* @__PURE__ */ new Set();
+		channel.on("broadcast", { event: "change" }, () => {
+			for (const notify of listeners) notify();
+		});
+		let joined = false;
+		const evict = () => {
+			if (byTopic.get(topic) !== entry) return;
+			byTopic.delete(topic);
+			client.removeChannel(channel);
+		};
+		const ready = (async () => {
+			await refreshRealtimeAuth(client);
+			await new Promise((resolve, reject) => {
+				channel.subscribe((status, error) => {
+					switch (status) {
+						case REALTIME_SUBSCRIBE_STATES.SUBSCRIBED:
+							if (joined) {
+								for (const notify of listeners) notify();
+								for (const notify of statuses) notify("subscribed");
+							}
+							joined = true;
+							resolve();
+							return;
+						case REALTIME_SUBSCRIBE_STATES.CLOSED:
+							resolve();
+							return;
+						case REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR:
+						case REALTIME_SUBSCRIBE_STATES.TIMED_OUT: {
+							const failure = error ?? /* @__PURE__ */ new Error(`Realtime ${status.toLowerCase()} on ${topic}`);
+							if (joined) for (const notify of statuses) notify("error", failure);
+							reject(failure);
+							if (!joined) evict();
+							return;
+						}
+						default: reject(/* @__PURE__ */ new Error(`Unknown realtime status ${String(status)}`));
+					}
+				});
+			});
+		})();
+		ready.catch(() => void 0);
+		const entry = {
+			channel,
+			listeners,
+			statuses,
+			ready
+		};
+		shared = entry;
+		byTopic.set(topic, entry);
+	}
+	const current = shared;
+	current.listeners.add(listener);
+	if (onStatus) current.statuses.add(onStatus);
+	let left = false;
+	return {
+		ready: current.ready,
+		leave: async () => {
+			if (left) return;
+			left = true;
+			current.listeners.delete(listener);
+			if (onStatus) current.statuses.delete(onStatus);
+			if (current.listeners.size > 0) return;
+			await new Promise((resolve) => {
+				setTimeout(resolve, 0);
+			});
+			if (current.listeners.size > 0 || byTopic.get(topic) !== current) return;
+			byTopic.delete(topic);
+			await client.removeChannel(current.channel);
+		}
+	};
+}
+/**
+* Calls `onChange` when a table the spec reads changes, so you can refetch.
+* Needs the `realtime-tables` SQL module and the tables in `realtime.tables`.
+* Live queries on the same client share one channel per table, so any number of
+* them can run at once.
+*
+* ```ts
+* using live = liveQuery(betterSupabase, supabase, spec, {
+*   onChange: () => refetch(),
+* });
+* ```
+*/
+function liveQuery(betterSupabase, client, spec, options) {
+	const touched = Array.isArray(spec) ? spec : betterSupabase.tablesOf(spec);
+	const tables = touched.filter((table) => betterSupabase.meta.realtime?.[table]);
+	const unwatched = touched.filter((table) => !betterSupabase.meta.realtime?.[table]);
+	const debounceMs = options.debounceMs ?? 100;
+	const changed = /* @__PURE__ */ new Set();
+	let timer;
+	let closed = false;
+	const flush = () => {
+		timer = void 0;
+		if (closed || changed.size === 0) return;
+		const batch = [...changed];
+		changed.clear();
+		options.onChange(batch);
+	};
+	const onTableChange = (table) => () => {
+		changed.add(table);
+		if (timer !== void 0) clearTimeout(timer);
+		timer = setTimeout(flush, debounceMs);
+	};
+	const failed = /* @__PURE__ */ new Set();
+	const onChannelStatus = (topic) => (status, error) => {
+		if (closed) return;
+		if (status === "error") failed.add(topic);
+		else failed.delete(topic);
+		if (status === "error") options.onStatus?.("error", error);
+		else if (failed.size === 0) options.onStatus?.("subscribed");
+	};
+	const topics = tables.map((table) => ({
+		table,
+		topic: liveTopic(betterSupabase.meta, table, options.tenant, options.user)
+	}));
+	const joinAll = () => topics.map(({ table, topic }) => join(client, topic, onTableChange(table), onChannelStatus(topic)));
+	let memberships = joinAll();
+	let retryTimer;
+	let delay = 1e3;
+	const settle = (attempt) => Promise.all(attempt.map((member) => member.ready)).then(() => {
+		if (!closed && tables.length > 0) options.onStatus?.("subscribed");
+	}, (cause) => {
+		const error = cause instanceof Error ? cause : new Error(String(cause));
+		if (!closed) {
+			options.onStatus?.("error", error);
+			if (options.retry !== false) scheduleRetry(attempt);
+		}
+		throw error;
+	});
+	const scheduleRetry = (attempt) => {
+		retryTimer = setTimeout(() => {
+			retryTimer = void 0;
+			if (closed || attempt !== memberships) return;
+			Promise.all(attempt.map((member) => member.leave()));
+			memberships = joinAll();
+			options.onStatus?.("joining");
+			settle(memberships).then(() => {
+				if (closed) return;
+				for (const table of tables) changed.add(table);
+				flush();
+			}, () => void 0);
+		}, delay);
+		delay = Math.min(delay * 2, 3e4);
+	};
+	options.onStatus?.(tables.length === 0 ? "closed" : "joining");
+	const ready = settle(memberships);
+	ready.catch(() => void 0);
+	const unsubscribe = async () => {
+		if (closed) return;
+		closed = true;
+		if (timer !== void 0) clearTimeout(timer);
+		if (retryTimer !== void 0) clearTimeout(retryTimer);
+		await Promise.all(memberships.map((member) => member.leave()));
+		options.onStatus?.("closed");
+	};
+	return {
+		tables,
+		unwatched,
+		ready,
+		unsubscribe,
+		[Symbol.dispose]: () => void unsubscribe(),
+		[Symbol.asyncDispose]: unsubscribe
+	};
+}
+/**
+* Keeps a count current: runs the `count` spec (a HEAD request) now, after each
+* debounced change to a table it reads, and after the channel rejoins.
+* Responses that arrive out of order are dropped.
+*
+* ```ts
+* using live = liveCount(
+*   betterSupabase,
+*   supabase,
+*   db,
+*   betterSupabase.spec.notes.count(),
+*   { onCount: (count) => render(count) },
+* );
+* ```
+*/
+function liveCount(betterSupabase, client, db, spec, options) {
+	let latest = 0;
+	let closed = false;
+	const refetch = () => {
+		latest += 1;
+		const call = latest;
+		Promise.resolve(db.$run(spec)).then((result) => {
+			if (closed || call !== latest) return;
+			if (result.ok) options.onCount(result.data);
+			else options.onError?.(result.error);
+		});
+	};
+	const live = liveQuery(betterSupabase, client, spec, {
+		onChange: refetch,
+		...options.tenant === void 0 ? {} : { tenant: options.tenant },
+		...options.user === void 0 ? {} : { user: options.user },
+		...options.debounceMs === void 0 ? {} : { debounceMs: options.debounceMs },
+		...options.onStatus ? { onStatus: options.onStatus } : {}
+	});
+	if (options.immediate ?? true) refetch();
+	const since = options.since;
+	if (since !== void 0) live.ready.then(() => {
+		if (!closed && Date.now() - since > 1e3) refetch();
+	}, () => void 0);
+	const unsubscribe = async () => {
+		closed = true;
+		await live.unsubscribe();
+	};
+	return {
+		...live,
+		unsubscribe,
+		[Symbol.dispose]: () => void unsubscribe(),
+		[Symbol.asyncDispose]: unsubscribe
+	};
+}
+const valueOf = (value) => typeof value === "function" ? value() : value;
+/**
+* Supabase Realtime changes for an engine's `live` option: the data hooks read
+* a source again when another client changes its table. It joins while a hook
+* follows a read and leaves after the last one.
+*
+* ```ts
+* export const bsb = createClient(betterSupabase, {
+*   engine: memoryEngine({
+*     live: realtimeChanges(betterSupabase, supabase),
+*   }),
+* });
+* ```
+*/
+function realtimeChanges(betterSupabase, client, options = {}) {
+	return { subscribe: (onChange) => {
+		const tenant = valueOf(options.tenant);
+		const user = valueOf(options.user);
+		const subscription = liveQuery(betterSupabase, client, options.tables ?? Object.keys(betterSupabase.meta.realtime ?? {}), {
+			onChange,
+			...tenant === void 0 ? {} : { tenant },
+			...user === void 0 ? {} : { user },
+			...options.debounceMs === void 0 ? {} : { debounceMs: options.debounceMs }
+		});
+		return () => {
+			subscription.unsubscribe();
+		};
+	} };
+}
+//#endregion
+export { realtimeChanges as i, liveQuery as n, liveTopic as r, liveCount as t };

package/dist/mapper/bin.js

@@ -0,0 +1,380 @@
+import { t as VERSION } from "../cli/version-Du4CgONY.js";
+import { a as lastTypesModule, c as writeAtomic, s as typesModuleKey } from "../cli/cache-CXgR_Ahi.js";
+import { t as loadSnapshot } from "../cli/snapshot-C8MVPyO8.js";
+import { i as renderTypesModule, t as mapperFilePath } from "../cli/render-ucJmUyuM.js";
+import { i as discoverConfig, s as loadConfig } from "../cli/config-9t5ec_N7.js";
+import { i as parseEnv, n as configEnvironment } from "../cli/env-DMgjB_4y.js";
+import { s as schemaStampPath } from "../cli/content-mapper-DNs7lTu7.js";
+import { existsSync, realpathSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+//#region src/mapper/rpc.ts
+const HEADER_END = "\r\n\r\n";
+const CONTENT_LENGTH = /content-length:\s*(\d+)/i;
+/** Frames a JSON-RPC message with the `Content-Length` header tsc reads. */
+function encodeFrame(message) {
+	const body = Buffer.from(JSON.stringify(message), "utf-8");
+	return Buffer.concat([Buffer.from(`Content-Length: ${body.length}${HEADER_END}`, "ascii"), body]);
+}
+/**
+* Splits a byte stream into the JSON bodies of its frames. A chunk may hold
+* part of a frame or several, so the reader keeps what it hasn't consumed.
+*/
+function frameReader(onMessage) {
+	let buffer = Buffer.alloc(0);
+	return (chunk) => {
+		buffer = Buffer.concat([buffer, chunk]);
+		for (;;) {
+			const headerEnd = buffer.indexOf(HEADER_END);
+			if (headerEnd === -1) return;
+			const header = buffer.subarray(0, headerEnd).toString("ascii");
+			const length = Number(CONTENT_LENGTH.exec(header)?.[1] ?? NaN);
+			if (Number.isNaN(length)) throw new TypeError(`The frame header has no Content-Length: ${header}`);
+			const start = headerEnd + 4;
+			if (buffer.length < start + length) return;
+			const body = buffer.subarray(start, start + length).toString("utf-8");
+			buffer = buffer.subarray(start + length);
+			onMessage(JSON.parse(body));
+		}
+	};
+}
+const isRequest = (value) => typeof value === "object" && value !== null;
+/**
+* Answers one message. A notification (no `id`) gets no response; a failing
+* handler answers with a JSON-RPC internal error instead of throwing, so tsc
+* reports it on the file.
+*/
+async function dispatch(handlers, message) {
+	const request = isRequest(message) ? message : {};
+	const method = typeof request.method === "string" ? request.method : "";
+	const handler = Object.hasOwn(handlers, method) ? handlers[method] : void 0;
+	let response;
+	try {
+		if (handler === void 0) throw new Error(`Unknown method ${method}`);
+		const result = await handler(request.params);
+		response = {
+			jsonrpc: "2.0",
+			id: request.id,
+			result: result ?? null
+		};
+	} catch (error) {
+		response = {
+			jsonrpc: "2.0",
+			id: request.id,
+			error: {
+				code: -32603,
+				message: error instanceof Error ? error.message : String(error)
+			}
+		};
+	}
+	return request.id === void 0 ? void 0 : response;
+}
+/**
+* Serves `handlers` over a pair of streams until the input ends. tsc closes the
+* pipe when it's done with the mapper, and `onEnd` lets the bin exit then.
+*/
+function serve(handlers, input, output, onEnd = () => {}) {
+	const read = frameReader((message) => {
+		dispatch(handlers, message).then((response) => {
+			if (response !== void 0) output.write(encodeFrame(response));
+		});
+	});
+	input.on("data", (chunk) => {
+		read(chunk);
+	});
+	input.on("end", onEnd);
+}
+//#endregion
+//#region src/core/spec-pins.ts
+/**
+* Versions of evolving specs and conventions the code follows. Moving a pin is
+* a minor release with a changeset (see the standards docs page).
+*/
+const SPEC_PINS = {
+	otelSemconv: "1.37.0",
+	otlp: "1.7.0",
+	mcp: "2026-07-28",
+	openapi: "3.1.2",
+	openapi30: "3.0.4",
+	openapi31: "3.1.2",
+	openapi32: "3.2.1",
+	openapi33Preview: "aa2f6c0",
+	securityProfiles: "sig-security#50@2026-05-05",
+	overlay10: "1.0.0",
+	overlay11: "1.1.0",
+	overlay12: "1.2.0",
+	arazzo10: "1.0.1",
+	arazzo11: "1.1.0",
+	asyncapi30: "3.0.0",
+	asyncapi31: "3.1.0",
+	authzen: "1.0",
+	cloudevents: "1.0.2",
+	standardWebhooks: "1.0.0",
+	sarif: "2.1.0",
+	jsonSchema: "2020-12",
+	postgrestAggregates: "12",
+	serverTiming: "WD-20260407",
+	stripeSyncEngine: "0.48.5",
+	pgvector: "0.8",
+	ocsf: "1.9.0",
+	openfeature: "0.9.0",
+	scim: "2.0",
+	supabaseSdkCapabilities: "1.14.0",
+	aiMessage: "1",
+	aiSdkUiMessageStream: "v1",
+	anthropicMemoryTool: "20250818",
+	rfc5545: "2009-09",
+	rfc4180: "2005-10",
+	iso4217: "2026-09-17",
+	rfc6902: "2013-04",
+	rfc9396: "2023-05",
+	rfc9864: "2025-10",
+	rfc8417: "2018-07",
+	rfc8935: "2020-11",
+	rfc8936: "2020-11",
+	ssf: "1.0",
+	caep: "1.0",
+	risc: "1.0",
+	rfc9068: "2021-10",
+	rfc7591: "2015-07",
+	rfc7636: "2015-09",
+	rfc8628: "2019-08",
+	rfc9700: "2025-01",
+	ratelimitHeaders: "draft-11",
+	shadcnRegistry: "4.21.4",
+	typescriptContentMapper: "1"
+};
+//#endregion
+//#region src/mapper/project.ts
+/**
+* The BS codes the mapper reports, on the `.bsb` file or on the tsconfig
+* entry's options. The docs list them on the content mapper page.
+*/
+const MAPPER_CODES = {
+	/** No config, an invalid one, or no schema and no earlier types. */
+	noTypes: 603,
+	/** The source failed, so the types are the ones the last `gen` rendered. */
+	lastTypes: 604,
+	/** A `.bsb` file other than the one `gen` writes for the config. */
+	otherFile: 605,
+	/** An option the tsconfig entry passes that the mapper doesn't read. */
+	unknownOption: 606
+};
+/** The options the tsconfig entry may pass in `options`. */
+const OPTIONS = /* @__PURE__ */ new Set(["config"]);
+/** A module that declares nothing, served when there are no types to serve. */
+const EMPTY_MODULE = "export {};\n";
+const sha256 = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+const message = (error) => error instanceof Error ? error.message : String(error);
+/**
+* `path` with its symlinks resolved, for `watchedFiles`: tsc watches the real
+* path and ignores a change seen through a link (such as macOS's `/tmp`). A
+* file that doesn't exist yet keeps its name under its nearest real parent.
+*/
+function realPath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		const parent = dirname(path);
+		return parent === path ? path : join(realPath(parent), basename(path));
+	}
+}
+function optionDiagnostics(options) {
+	const diagnostics = Object.keys(options).filter((key) => !OPTIONS.has(key)).map((key) => ({
+		path: [key],
+		messageText: `better-supabase reads its settings from its config file; the content mapper only takes "config", the path to that file. Remove "${key}".`,
+		code: MAPPER_CODES.unknownOption
+	}));
+	if (options["config"] !== void 0 && typeof options["config"] !== "string") diagnostics.push({
+		path: ["config"],
+		messageText: "\"config\" is the path to the better-supabase config file, relative to the tsconfig.",
+		code: MAPPER_CODES.unknownOption
+	});
+	return diagnostics;
+}
+/**
+* The files whose change makes tsc open the project again: the config, the
+* saved snapshot, `supabase/config.toml` and the stamp `gen` rewrites when the
+* schema types change.
+*/
+function watched(config, configFile) {
+	return [
+		configFile,
+		...config.source.snapshot === void 0 ? [] : [resolve(config.root, config.source.snapshot)],
+		join(config.root, "supabase/config.toml"),
+		schemaStampPath(config.root, config.output)
+	].map((path) => realPath(path));
+}
+/** Writes the stamp when it's missing, so tsc watches a file that exists. */
+async function ensureStamp(config, key) {
+	const stamp = schemaStampPath(config.root, config.output);
+	if (!existsSync(stamp)) await writeAtomic(stamp, key).catch(() => void 0);
+}
+/**
+* Loads the project a tsconfig opens: its better-supabase config (found from
+* the tsconfig's folder, or at `options.config`), the schema snapshot through
+* the same caches as `gen`, and the module the mapper serves. It never throws:
+* a failure comes back as a diagnostic on the file, because tsc stops calling a
+* mapper that fails five times in a project.
+*/
+async function loadProject(configFileName, options, processEnv) {
+	const projectDir = dirname(configFileName);
+	const optionIssues = optionDiagnostics(options);
+	const explicit = typeof options["config"] === "string" ? resolve(projectDir, options["config"]) : void 0;
+	const failed = (messageText, watchedFiles = []) => ({
+		text: EMPTY_MODULE,
+		configIdentity: sha256([
+			VERSION,
+			"failed",
+			messageText,
+			options
+		]),
+		watchedFiles,
+		diagnostics: [{
+			messageText,
+			code: MAPPER_CODES.noTypes
+		}],
+		optionDiagnostics: optionIssues
+	});
+	const configFile = discoverConfig(projectDir, explicit);
+	if (configFile === void 0) return failed(`No better-supabase config found from ${projectDir}. Run \`better-supabase init\`, or set "config" in the tsconfig's contentMappers options.`);
+	let config;
+	let env;
+	try {
+		env = parseEnv(processEnv);
+		config = await loadConfig(projectDir, explicit, configEnvironment(void 0, env), configFile);
+	} catch (error) {
+		return failed(message(error), [realPath(configFile)]);
+	}
+	const watchedFiles = watched(config, configFile);
+	const file = realPath(resolve(config.root, mapperFilePath(config)));
+	const configText = await readFile(configFile, "utf-8").catch(() => void 0);
+	try {
+		const snapshot = await loadSnapshot(config, env, { cache: true });
+		const key = typesModuleKey(config, configText, snapshot);
+		const text = await renderTypesModule(config, snapshot, configText);
+		await ensureStamp(config, key);
+		return {
+			text,
+			file,
+			configIdentity: sha256([key, options]),
+			watchedFiles,
+			diagnostics: [],
+			optionDiagnostics: optionIssues
+		};
+	} catch (error) {
+		const last = await lastTypesModule(config.root, config.output);
+		if (last === void 0) return failed(`The schema types could not be read: ${message(error)}. Run \`better-supabase gen\` once the source is reachable.`, watchedFiles);
+		return {
+			text: last,
+			file,
+			configIdentity: sha256([
+				VERSION,
+				"last",
+				sha256(last),
+				options
+			]),
+			watchedFiles,
+			diagnostics: [{
+				messageText: `The schema could not be read (${message(error)}), so these are the types the last \`better-supabase gen\` rendered.`,
+				code: MAPPER_CODES.lastTypes
+			}],
+			optionDiagnostics: optionIssues
+		};
+	}
+}
+//#endregion
+//#region src/mapper/server.ts
+/** The protocol version this mapper speaks, as `initialize` answers it. */
+const PROTOCOL_VERSION = Number(SPEC_PINS.typescriptContentMapper);
+/** The `mappings` span kind and the feature flags one span carries. */
+const ATOM = 1;
+const NAVIGATION = 56;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const field = (params, key) => isRecord(params) ? params[key] : void 0;
+const text = (params, key) => {
+	const value = field(params, key);
+	return typeof value === "string" ? value : "";
+};
+/**
+* The content mapper's methods. `openProject` does the work (the config, the
+* snapshot and the render, all cached), so `transform` only hands back the
+* module for the project.
+*/
+function mapperHandlers(options = {}) {
+	const env = options.env ?? {};
+	const load = options.load ?? loadProject;
+	const projects = /* @__PURE__ */ new Map();
+	let encoding = "utf-16";
+	const size = (value) => encoding === "utf-8" ? Buffer.byteLength(value, "utf-8") : value.length;
+	/** A diagnostic on the file, kept inside its `content`. */
+	const onFile = (content, diagnostic) => ({
+		...diagnostic,
+		start: 0,
+		length: Math.min(1, size(content))
+	});
+	const module = (source, content, diagnostics) => ({
+		extension: ".ts",
+		text: source,
+		mappings: [[
+			0,
+			size(source),
+			0,
+			size(content),
+			ATOM,
+			NAVIGATION
+		]],
+		diagnostics: diagnostics.map((diagnostic) => onFile(content, diagnostic))
+	});
+	return {
+		initialize(params) {
+			const offered = field(params, "positionEncodings");
+			const version = field(params, "protocolVersion");
+			encoding = Array.isArray(offered) && !offered.includes("utf-16") ? "utf-8" : "utf-16";
+			return {
+				protocolVersion: typeof version === "number" ? version : PROTOCOL_VERSION,
+				positionEncoding: encoding,
+				diagnosticSource: "BS"
+			};
+		},
+		async openProject(params) {
+			const handle = text(params, "projectHandle");
+			const entry = field(params, "options");
+			const loaded = load(text(params, "configFileName"), isRecord(entry) ? entry : {}, env);
+			projects.set(handle, loaded);
+			const project = await loaded;
+			return {
+				configIdentity: project.configIdentity,
+				watchedFiles: project.watchedFiles,
+				optionDiagnostics: project.optionDiagnostics
+			};
+		},
+		async transform(params) {
+			const content = text(params, "content");
+			const loaded = projects.get(text(params, "projectHandle"));
+			if (loaded === void 0) return module(EMPTY_MODULE, content, [{
+				messageText: "The content mapper has no project for this file. Restart the TypeScript server.",
+				code: MAPPER_CODES.noTypes
+			}]);
+			const project = await loaded;
+			const fileName = realPath(text(params, "fileName"));
+			if (project.file !== void 0 && fileName !== project.file) return module(EMPTY_MODULE, content, [{
+				messageText: `better-supabase serves the schema types at ${project.file}, the schema.bsb next to gen's output. Import the types from there.`,
+				code: MAPPER_CODES.otherFile
+			}]);
+			return module(project.text, content, project.diagnostics);
+		},
+		closeProject(params) {
+			projects.delete(text(params, "projectHandle"));
+			return null;
+		}
+	};
+}
+//#endregion
+//#region src/mapper/bin.ts
+serve(mapperHandlers({ env: process.env }), process.stdin, process.stdout, () => {
+	process.exit(0);
+});
+//#endregion
+export {};

package/dist/mcp/index.d.ts

@@ -1,11 +1,11 @@
-import { B as TableKey, a as AnyModels, i as AnyFunctions } from "../types-DmshMaXz.js";
-import { t as OperationTable } from "../operations-Cc27HkTG.js";
-import { D as ResourceOperation } from "../model-Btl8X9cs.js";
-import { s as PermissionRef, t as AnyAuthorizer } from "../authorizer-DFP3gHv8.js";
-import { t as BetterSupabase } from "../define-D0LSXmUP.js";
-import { a as ServerContext, c as ServerOptions, n as BetterServer } from "../server-types-D_cQ6OxZ.js";
-import { r as GuardOptions } from "../respond-QW-f1yio.js";
-import { l as ResourceRouteOptions } from "../resource-types-NXau9LJE.js";
+import { O as AnyFunctions, k as AnyModels, ut as TableKey } from "../types-DFdg_4yN.js";
+import { t as OperationTable } from "../operations-CSc_IsHO.js";
+import { l as PermissionRef, t as AnyAuthorizer } from "../authorizer-B6X09otb.js";
+import { t as BetterSupabase } from "../define-DFBnQyYg.js";
+import { a as ServerContext, c as ServerOptions, n as BetterServer } from "../server-types-CFtehAsr.js";
+import { r as GuardOptions } from "../respond-Dn1_YhC1.js";
+import { D as ResourceOperation } from "../model-hwpvole9.js";
+import { l as ResourceRouteOptions } from "../resource-types-DnKiH4G2.js";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 //#region src/mcp/dialect.d.ts
 /**