@tailor-platform/sdk 1.56.1 → 1.58.0

package/dist/cli/index.mjs

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
-import { G as PATScope, R as AuthInvokerSchema, c as fetchUserInfo, d as initOperatorClient, h as userAgent, i as fetchAll, j as FunctionExecution_Type, n as closeConnectionPool, o as fetchPaged, s as fetchPlatformMachineUserToken, u as initOAuth2Client } from "../client-DLPEPJ_s.mjs";
+import { E as CustomDomainStatus, K as PATScope, M as FunctionExecution_Type, c as fetchUserInfo, d as initOperatorClient, h as userAgent, i as fetchAll, n as closeConnectionPool, o as fetchPaged, s as fetchPlatformMachineUserToken, u as initOAuth2Client, z as AuthInvokerSchema } from "../client-62B-r3MN.mjs";
 import { n as logger, r as styles } from "../logger-DpJyJvNz.mjs";
-import { $ as listCommand$10, An as workspaceArgs, At as startCommand, B as logBetaWarning, C as listCommand$13, Cn as configArg, Dn as pagedLogArgs, Dt as jobsCommand, E as resumeCommand, En as isVerbose, F as writeDbTypesFile, Gt as parseMigrationLabelNumber, H as removeCommand$1, Ht as executeScript, I as getConfiguredEditorCommand, K as treeCommand, L as openInConfiguredEditor, Lt as functionExecutionStatusToString, Mt as getCommand$6, N as generateCommand$1, O as listCommand$12, On as paginationArgs, P as generateMigrationScript, Pt as executionsCommand, Rt as formatKeyValueTable, Sn as commonArgs, St as triggerCommand, T as healthCommand, Tn as deploymentArgs, U as updateCommand$3, Vt as deploy, Y as getCommand$5, Yt as INITIAL_SCHEMA_NUMBER, Z as updateCommand$2, _n as prompt, at as createCommand$3, b as createCommand$4, bn as assertWritable, c as listCommand$14, cn as reconstructSnapshotFromMigrations, f as restoreCommand, ft as tokenCommand, g as getCommand$7, gt as listCommand$7, hn as trnPrefix, ht as generate, i as updateCommand$4, in as getMigrationFiles, j as truncateCommand, kn as toPageDirection, ln as formatMigrationNumber, lt as getCommand$3, m as listCommand$15, mn as sdkNameLabelKey, o as removeCommand, on as isValidMigrationNumber, pn as getNamespacesWithMigrations, pt as listCommand$8, q as listCommand$11, r as queryCommand, rn as getMigrationFilePath, rt as deleteCommand$3, sn as loadDiff, st as listCommand$9, t as isNativeTypeScriptRuntime, tt as getCommand$4, u as inviteCommand, v as deleteCommand$4, vn as apiCommand, vt as getCommand$2, wn as confirmationArgs, wt as listCommand$6, xn as defineAppCommand, xt as webhookCommand, z as showCommand, zt as getCommand$1 } from "../runtime-745lvg7i.mjs";
-import { A as saveUserTokens, C as deleteUserTokens, D as loadWorkspaceId, O as readPlatformConfig, S as loadConfig, T as loadAccessToken, _ as createLogLevelTreeshakeOptions, a as WorkflowJobSchema, b as getDistDir, g as composeFunctionTreeshakeOptions, i as resolveInlineSourcemap, j as writePlatformConfig, k as resolveTokens, l as ExecutorSchema, o as ResolverSchema, u as INVOKER_EXPR, v as resolveBundleLogLevel, w as fetchLatestToken } from "../application-DuT_ae02.mjs";
+import { $ as listCommand$10, An as toPageDirection, At as startCommand, B as logBetaWarning, C as listCommand$13, Cn as commonArgs, Dn as isVerbose, Dt as jobsCommand, E as resumeCommand, En as deploymentArgs, F as writeDbTypesFile, Gt as parseMigrationLabelNumber, H as removeCommand$1, Ht as executeScript, I as getConfiguredEditorCommand, K as treeCommand, L as openInConfiguredEditor, Lt as functionExecutionStatusToString, Mt as getCommand$6, N as generateCommand$1, O as listCommand$12, On as pagedLogArgs, P as generateMigrationScript, Pt as executionsCommand, Rt as formatKeyValueTable, Sn as defineAppCommand, St as triggerCommand, T as healthCommand, Tn as confirmationArgs, U as updateCommand$3, Vt as deploy, Y as getCommand$5, Yt as INITIAL_SCHEMA_NUMBER, Z as updateCommand$2, _n as generateUserTypes, at as createCommand$3, b as createCommand$4, c as listCommand$14, cn as reconstructSnapshotFromMigrations, f as restoreCommand, ft as tokenCommand, g as getCommand$7, gn as PluginManager, gt as listCommand$7, hn as sdkNameLabelKey, ht as generate, i as updateCommand$4, in as getMigrationFiles, j as truncateCommand, jn as workspaceArgs, kn as paginationArgs, ln as formatMigrationNumber, lt as getCommand$3, m as listCommand$15, mn as resourceTrn, o as removeCommand, on as isValidMigrationNumber, pn as getNamespacesWithMigrations, pt as listCommand$8, q as listCommand$11, r as queryCommand, rn as getMigrationFilePath, rt as deleteCommand$3, sn as loadDiff, st as listCommand$9, t as isNativeTypeScriptRuntime, tt as getCommand$4, u as inviteCommand, v as deleteCommand$4, vn as prompt, vt as getCommand$2, wn as configArg, wt as listCommand$6, xn as assertWritable, xt as webhookCommand, yn as apiCommand, z as showCommand, zt as getCommand$1 } from "../runtime-BC-FbQkg.mjs";
+import { A as resolveTokens, C as loadConfig, E as loadAccessToken, M as writePlatformConfig, O as loadWorkspaceId, T as fetchLatestToken, _ as createLogLevelTreeshakeOptions, a as WorkflowJobSchema, b as getDistDir, g as composeFunctionTreeshakeOptions, i as resolveInlineSourcemap, j as saveUserTokens, k as readPlatformConfig, l as ExecutorSchema, o as ResolverSchema, t as defineApplication, u as INVOKER_EXPR, v as resolveBundleLogLevel, w as deleteUserTokens, x as hashContent } from "../application-B59TaTk_.mjs";
 import { t as multiline } from "../multiline-Cf9ODpr1.mjs";
+import { r as isPluginGeneratedType } from "../seed-C0fE2sJB.mjs";
 import { t as readPackageJson } from "../package-json-DcQApfPQ.mjs";
 import { n as isCLIError } from "../errors-EsY4XO6O.mjs";
-import { a as JSON_FOOTER_MARKER, i as CRASH_LOG_EXTENSION, o as parseCrashReportConfig, r as sendCrashReport, t as initCrashReporting } from "../crashreport-Bm2mN5tg.mjs";
-import { createRequire } from "node:module";
+import { a as JSON_FOOTER_MARKER, i as CRASH_LOG_EXTENSION, o as parseCrashReportConfig, r as sendCrashReport, t as initCrashReporting } from "../crashreport-CCGpLUlP.mjs";
 import { arg, defineCommand, runCommand, runMain } from "politty";
 import { withCompletionCommand } from "politty/completion";
 import { z } from "zod";
@@ -17,7 +17,7 @@ import * as fs$1 from "node:fs";
 import { timestampDate } from "@bufbuild/protobuf/wkt";
 import * as path from "pathe";
 import { dirname, resolve } from "pathe";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { generateCodeVerifier } from "@badgateway/oauth2-client";
 import { Code, ConnectError } from "@connectrpc/connect";
 import { resolvePackageJSON, resolveTSConfig } from "pkg-types";
@@ -26,9 +26,11 @@ import * as http from "node:http";
 import open from "open";
 import * as rolldown from "rolldown";
 import * as fsPromises from "node:fs/promises";
+import { glob } from "node:fs/promises";
 import pLimit from "p-limit";
 import { TraceMap, generatedPositionFor, originalPositionFor } from "@jridgewell/trace-mapping";
 import { spawn, spawnSync } from "node:child_process";
+import { watch } from "chokidar";
 import * as fs from "fs";
 import { lookup } from "mime-types";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
@@ -159,6 +161,45 @@ const authorizeAuthConnectionCommand = defineAppCommand({
 	}
 });
 
+//#endregion
+//#region src/cli/commands/authconnection/delete.ts
+const deleteAuthConnectionCommand = defineAppCommand({
+	name: "delete",
+	description: "Delete an auth connection entirely.",
+	args: z.object({
+		...workspaceArgs,
+		...connectionNameArgs,
+		...confirmationArgs
+	}).strict(),
+	run: async (args) => {
+		await assertWritable({ profile: args.profile });
+		const client = await initOperatorClient(await loadAccessToken({
+			useProfile: true,
+			profile: args.profile
+		}));
+		const workspaceId = await loadWorkspaceId({
+			workspaceId: args["workspace-id"],
+			profile: args.profile
+		});
+		if (!args.yes) {
+			if (await prompt.text({ message: `Enter the connection name to confirm deletion ("${args.name}"):` }) !== args.name) {
+				logger.info("Auth connection deletion cancelled.");
+				return;
+			}
+		}
+		try {
+			await client.deleteAuthConnection({
+				workspaceId,
+				connectionName: args.name
+			});
+		} catch (error) {
+			if (error instanceof ConnectError && error.code === Code.NotFound) throw new Error(`Auth connection "${args.name}" not found.`, { cause: error });
+			throw error;
+		}
+		logger.success(`Auth connection "${args.name}" deleted.`);
+	}
+});
+
 //#endregion
 //#region src/cli/commands/authconnection/list.ts
 function connectionInfo(connection) {
@@ -216,7 +257,8 @@ const listAuthConnectionCommand = defineAppCommand({
 //#region src/cli/commands/authconnection/revoke.ts
 const revokeAuthConnectionCommand = defineAppCommand({
 	name: "revoke",
-	description: "Revoke an auth connection.",
+	description: "Revoke an auth connection's tokens (keeps the connection; use 'delete' to remove it).",
+	notes: "Revoke invalidates the connection's active session and tokens but keeps the connection and its stored credentials, so it can be re-authorized later. Use `delete` to remove the connection entirely.",
 	args: z.object({
 		...workspaceArgs,
 		...connectionNameArgs,
@@ -259,7 +301,8 @@ const authconnectionCommand = defineCommand({
 	subCommands: {
 		authorize: authorizeAuthConnectionCommand,
 		list: listAuthConnectionCommand,
-		revoke: revokeAuthConnectionCommand
+		revoke: revokeAuthConnectionCommand,
+		delete: deleteAuthConnectionCommand
 	},
 	async run() {
 		await runCommand(listAuthConnectionCommand, []);
@@ -945,9 +988,9 @@ async function downloadScriptForMapping(options) {
 const logsCommand = defineAppCommand({
 	name: "logs",
 	description: "List or get function execution logs.",
-	notes: `When viewing a specific execution that failed, the command displays error details with the stack trace mapped back to original source files via the inline sourcemap (clickable file links and code snippets, matching \`function test-run\` output).
+	notes: `When viewing a specific execution that failed, the command displays error details with the stack trace mapped back to your original source files (clickable file links and code snippets, matching \`function test-run\` output).
 
-The download is pinned to the bundle that actually ran using the execution's content hash, so stack traces stay accurate across redeploys when the server retains old bundles. The command falls back to a plain-text error display when the pinned bundle cannot be retrieved, or when the execution was recorded before content hashes started being tracked and the function was redeployed after it ran.`,
+Stack traces stay accurate even after later redeploys, because the trace is resolved against the exact build that produced the execution. If that build is no longer available, the command falls back to a plain-text error display.`,
 	examples: [
 		{
 			cmd: "",
@@ -2082,7 +2125,7 @@ const secretValueArgs = {
 */
 async function checkVaultManaged(params) {
 	const { client, workspaceId, vaultName } = params;
-	const trn = `${trnPrefix(workspaceId)}:vault:${vaultName}`;
+	const trn = resourceTrn(workspaceId, "vault", vaultName);
 	const notManaged = {
 		isManaged: false,
 		trn,
@@ -2982,6 +3025,115 @@ const deployCommand = defineAppCommand({
 	}
 });
 
+//#endregion
+//#region src/cli/commands/staticwebsite/domain/status.ts
+const statusLabels = {
+	[CustomDomainStatus.UNSPECIFIED]: "unspecified",
+	[CustomDomainStatus.PENDING]: "pending",
+	[CustomDomainStatus.VERIFYING]: "verifying",
+	[CustomDomainStatus.CERT_ISSUED]: "cert_issued",
+	[CustomDomainStatus.ACTIVE]: "active",
+	[CustomDomainStatus.FAILED]: "failed"
+};
+
+//#endregion
+//#region src/cli/commands/staticwebsite/domain/get.ts
+const domainGetCommand = defineAppCommand({
+	name: "get",
+	description: "Get details of a custom domain.",
+	args: z.object({
+		...workspaceArgs,
+		domain: arg(z.string(), {
+			positional: true,
+			description: "Custom domain name"
+		})
+	}).strict(),
+	run: async (args) => {
+		const client = await initOperatorClient(await loadAccessToken({
+			useProfile: true,
+			profile: args.profile
+		}));
+		const workspaceId = await loadWorkspaceId({
+			workspaceId: args["workspace-id"],
+			profile: args.profile
+		});
+		const notFoundErrorMessage = `Custom domain "${args.domain}" not found.`;
+		try {
+			const { customDomain } = await client.getCustomDomain({
+				workspaceId,
+				domain: args.domain
+			});
+			if (!customDomain) throw new Error(notFoundErrorMessage);
+			const info = {
+				domain: customDomain.domain,
+				status: statusLabels[customDomain.status] ?? "unknown",
+				trafficCnameTarget: customDomain.trafficCnameTarget,
+				certificateCnameTarget: customDomain.certificateCnameTarget,
+				errorMessage: customDomain.errorMessage || void 0
+			};
+			logger.out(info);
+		} catch (error) {
+			if (error instanceof ConnectError && error.code === Code.NotFound) throw new Error(notFoundErrorMessage, { cause: error });
+			throw error;
+		}
+	}
+});
+
+//#endregion
+//#region src/cli/commands/staticwebsite/domain/list.ts
+const domainListCommand = defineAppCommand({
+	name: "list",
+	description: "List custom domains for a static website.",
+	args: z.object({
+		...workspaceArgs,
+		name: arg(z.string(), {
+			positional: true,
+			description: "Static website name"
+		})
+	}).strict(),
+	run: async (args) => {
+		const client = await initOperatorClient(await loadAccessToken({
+			useProfile: true,
+			profile: args.profile
+		}));
+		const workspaceId = await loadWorkspaceId({
+			workspaceId: args["workspace-id"],
+			profile: args.profile
+		});
+		try {
+			const { customDomains } = await client.listCustomDomains({
+				workspaceId,
+				staticWebsiteName: args.name
+			});
+			if (customDomains.length === 0) {
+				logger.info("No custom domains found.");
+				return;
+			}
+			const formatted = customDomains.map((d) => ({
+				domain: d.domain,
+				status: statusLabels[d.status] ?? "unknown",
+				trafficCnameTarget: d.trafficCnameTarget,
+				certificateCnameTarget: d.certificateCnameTarget
+			}));
+			logger.out(formatted);
+		} catch (error) {
+			if (error instanceof ConnectError && error.code === Code.NotFound) throw new Error(`Static website "${args.name}" not found.`, { cause: error });
+			throw error;
+		}
+	}
+});
+
+//#endregion
+//#region src/cli/commands/staticwebsite/domain/index.ts
+const domainCommand = defineCommand({
+	name: "domain",
+	description: "Manage custom domains for static websites.",
+	subCommands: {
+		list: domainListCommand,
+		get: domainGetCommand
+	}
+});
+
 //#endregion
 //#region src/cli/commands/staticwebsite/get.ts
 const getCommand = defineAppCommand({
@@ -3096,6 +3248,7 @@ const staticwebsiteCommand = defineCommand({
 	description: "Manage static websites in your workspace.",
 	subCommands: {
 		deploy: deployCommand,
+		domain: domainCommand,
 		list: listCommand$2,
 		get: getCommand
 	},
@@ -3105,378 +3258,430 @@ const staticwebsiteCommand = defineCommand({
 });
 
 //#endregion
-//#region src/cli/shared/resolve-cli-bin.ts
+//#region src/cli/commands/tailordb/erd/local-schema.ts
 /**
-* Resolve a CLI binary path from the SDK's dependencies.
-* @param options - Resolution options for locating the CLI binary.
-* @returns Absolute path to the CLI binary entry.
+* Resolve TailorDB namespaces that need local type loading for ERD generation.
+* @param config - Loaded Tailor config.
+* @param options - Namespace selection options.
+* @returns Namespace names to load, or undefined to load all owned namespaces.
 */
-function resolveCliBinPath(options) {
-	const { packageName, binName } = options;
-	const requireFromSdk = createRequire(import.meta.url);
-	let pkgJsonPath;
-	try {
-		pkgJsonPath = requireFromSdk.resolve(`${packageName}/package.json`);
-	} catch {
-		throw new Error(`Failed to resolve \`${packageName}\`.`);
+function resolveLocalErdSchemaNamespaces(config, options) {
+	if (options.namespaces) return options.namespaces;
+	if (!options.requireErdSite) return;
+	return Object.entries(config.db ?? {}).flatMap(([namespace, dbConfig]) => "external" in dbConfig || !dbConfig.erdSite ? [] : [namespace]);
+}
+/**
+* Load local TailorDB namespaces exactly as SDK generation/deploy sees them.
+* @param options - Local schema loading options.
+* @returns Loaded TailorDB namespace data.
+*/
+async function loadLocalErdSchema(options) {
+	const { config, plugins } = await loadConfig(options.configPath);
+	await generateUserTypes({
+		config,
+		configPath: config.path
+	});
+	const application = defineApplication({
+		config,
+		pluginManager: plugins.length > 0 ? new PluginManager(plugins) : void 0
+	});
+	const namespaceNames = resolveLocalErdSchemaNamespaces(config, {
+		namespaces: options.namespaces,
+		requireErdSite: options.requireErdSite
+	});
+	const namespaceFilter = namespaceNames ? new Set(namespaceNames) : void 0;
+	const services = namespaceFilter ? application.tailorDBServices.filter((db) => namespaceFilter.has(db.namespace)) : application.tailorDBServices;
+	if (namespaceFilter && services.length !== namespaceFilter.size) {
+		const available = application.tailorDBServices.map((db) => db.namespace).join(", ");
+		const requested = [...namespaceFilter].join(", ");
+		throw new Error(`TailorDB namespace "${requested}" not found in local config.db.` + (available ? ` Available owned namespaces: ${available}` : ""));
 	}
-	const binRelativePath = JSON.parse(fs$1.readFileSync(pkgJsonPath, "utf8")).bin?.[binName];
-	if (!binRelativePath) throw new Error(`\`${packageName}\` does not expose a \`${binName}\` binary entry.`);
-	return path.resolve(path.dirname(pkgJsonPath), binRelativePath);
+	const namespaces = [];
+	for (const db of services) {
+		await db.loadTypes();
+		await db.processNamespacePlugins();
+		namespaces.push({
+			namespace: db.namespace,
+			types: { ...db.types },
+			sourceInfo: new Map(Object.entries(db.typeSourceInfo)),
+			pluginAttachments: db.pluginAttachments
+		});
+	}
+	return {
+		config,
+		namespaces
+	};
 }
 
 //#endregion
 //#region src/cli/commands/tailordb/erd/schema.ts
-/**
-* Convert TailorDB field config to tbls column definition.
-* @param fieldName - Field name
-* @param fieldConfig - TailorDB field configuration
-* @returns tbls column definition
-*/
-function toTblsColumn(fieldName, fieldConfig) {
-	const baseType = fieldConfig.type || "string";
+const CLEAN_ROOM_NOTES = [
+	"Generated by a TailorDB-specific viewer implementation.",
+	"The implementation is based on TailorDB schema contracts, public Liam documentation, Liam CLI help, and black-box generated-output observation.",
+	"It does not copy Liam source code, generated JavaScript/CSS, parser internals, or layout internals."
+];
+function buildRevision(schema) {
+	return hashContent(JSON.stringify(schema)).slice(0, 16);
+}
+function toTypeSource(source) {
+	if (!source) return void 0;
+	if (isPluginGeneratedType(source)) return {
+		kind: "plugin",
+		exportName: source.exportName,
+		pluginId: source.pluginId,
+		pluginImportPath: source.pluginImportPath,
+		originalExportName: source.originalExportName,
+		generatedTypeKind: source.generatedTypeKind,
+		namespace: source.namespace
+	};
+	return {
+		kind: "user",
+		exportName: source.exportName
+	};
+}
+function toRelationships(relationships) {
+	return Object.entries(relationships).sort(([a], [b]) => a.localeCompare(b)).map(([name, relationship]) => ({
+		name,
+		targetType: relationship.targetType,
+		targetField: relationship.targetField,
+		sourceField: relationship.sourceField,
+		isArray: relationship.isArray,
+		...relationship.description && { description: relationship.description }
+	}));
+}
+function toIndexes(type) {
+	return Object.entries(type.indexes ?? {}).sort(([a], [b]) => a.localeCompare(b)).map(([name, index]) => ({
+		name,
+		fields: [...index.fields],
+		unique: index.unique === true
+	}));
+}
+function toColumnRelation(options) {
+	const { fieldConfig, parsedField } = options;
+	if (!fieldConfig.foreignKey || !fieldConfig.foreignKeyType) return;
+	const required = fieldConfig.required !== false;
+	const kind = parsedField?.relation || fieldConfig.rawRelation ? "relation" : "foreignKey";
+	return {
+		targetTable: fieldConfig.foreignKeyType,
+		targetColumn: fieldConfig.foreignKeyField || "id",
+		kind,
+		required,
+		...fieldConfig.rawRelation?.type && { relationType: fieldConfig.rawRelation.type },
+		...parsedField?.relation?.forwardName && { forwardName: parsedField.relation.forwardName },
+		...parsedField?.relation?.backwardName && { backwardName: parsedField.relation.backwardName }
+	};
+}
+function toColumn(options) {
+	const { fieldName, fieldConfig } = options;
+	const indexNames = options.indexEntries.filter(([, index]) => index.fields.includes(fieldName)).map(([name]) => name);
+	const uniqueIndexNames = options.indexEntries.filter(([, index]) => index.unique && index.fields.includes(fieldName)).map(([name]) => name);
+	const enumValues = fieldConfig.allowedValues?.map((value) => value.value) ?? [];
+	const enumValueDescriptions = Object.fromEntries((fieldConfig.allowedValues ?? []).flatMap((value) => value.description ? [[value.value, value.description]] : []));
+	const nestedFields = Object.entries(fieldConfig.fields ?? {}).map(([nestedName, nestedConfig]) => toColumn({
+		fieldName: nestedName,
+		fieldConfig: nestedConfig,
+		indexEntries: []
+	}));
+	const relation = toColumnRelation(options);
 	return {
 		name: fieldName,
-		type: fieldConfig.array ? `${baseType}[]` : baseType,
-		nullable: !fieldConfig.required,
-		comment: fieldConfig.description ?? ""
+		type: fieldConfig.type || "string",
+		required: fieldConfig.required !== false,
+		array: fieldConfig.array === true,
+		...fieldConfig.description && { description: fieldConfig.description },
+		...fieldConfig.unique && { unique: true },
+		...(fieldConfig.index || indexNames.length > 0) && { index: true },
+		...indexNames.length > 0 && { indexNames },
+		...uniqueIndexNames.length > 0 && { uniqueIndexNames },
+		...enumValues.length > 0 && { enumValues },
+		...Object.keys(enumValueDescriptions).length > 0 && { enumValueDescriptions },
+		...fieldConfig.vector && { vector: true },
+		...fieldConfig.serial && { serial: { ...fieldConfig.serial } },
+		...fieldConfig.scale !== void 0 && { scale: fieldConfig.scale },
+		...fieldConfig.validate?.length && { validations: fieldConfig.validate.length },
+		...fieldConfig.hooks && { hooks: {
+			...fieldConfig.hooks.create && { create: true },
+			...fieldConfig.hooks.update && { update: true }
+		} },
+		...nestedFields.length > 0 && { fields: nestedFields },
+		...relation && { relation }
 	};
 }
-/**
-* Build tbls schema JSON from TailorDB types.
-* @param types - TailorDB types fetched from platform
-* @param namespace - TailorDB namespace
-* @returns tbls-compatible schema representation
-*/
-function buildTblsSchema(types, namespace) {
-	const tables = [];
-	const relations = [];
-	const referencedByTable = {};
-	const constraintsByTable = {};
-	const enumsMap = /* @__PURE__ */ new Map();
-	for (const type of types) {
-		const tableName = type.name;
-		const schema = type.schema;
-		const columns = [];
-		const tableConstraints = [];
-		columns.push({
+function toTable(type, source) {
+	const indexes = toIndexes(type);
+	const indexEntries = indexes.map((index) => [index.name, index]);
+	const fieldColumns = Object.entries(type.fields).filter(([fieldName]) => fieldName !== "id").map(([fieldName, field]) => toColumn({
+		fieldName,
+		fieldConfig: field.config,
+		parsedField: field,
+		indexEntries
+	}));
+	const typeSource = toTypeSource(source);
+	return {
+		name: type.name,
+		pluralForm: type.pluralForm,
+		...type.description && { description: type.description },
+		...typeSource && { source: typeSource },
+		columns: [{
 			name: "id",
 			type: "uuid",
-			nullable: false,
-			comment: ""
-		});
-		tableConstraints.push({
-			name: `pk_${tableName}`,
-			type: "PRIMARY KEY",
-			def: "",
-			table: tableName,
-			columns: ["id"]
-		});
-		if (schema) for (const [fieldName, fieldConfig] of Object.entries(schema.fields ?? {})) {
-			columns.push(toTblsColumn(fieldName, fieldConfig));
-			if (fieldConfig.type === "enum" && fieldConfig.allowedValues.length > 0) {
-				const enumName = `${tableName}_${fieldName}`;
-				let values = enumsMap.get(enumName);
-				if (!values) {
-					values = /* @__PURE__ */ new Set();
-					enumsMap.set(enumName, values);
-				}
-				for (const value of fieldConfig.allowedValues) values.add(value.value);
-			}
-			if (fieldConfig.foreignKey && fieldConfig.foreignKeyType) {
-				const foreignTable = fieldConfig.foreignKeyType;
-				const foreignColumn = fieldConfig.foreignKeyField || "id";
-				const childCardinality = fieldConfig.required ? "exactly_one" : "zero_or_one";
-				relations.push({
-					table: tableName,
-					columns: [fieldName],
-					parent_table: foreignTable,
-					parent_columns: [foreignColumn],
-					cardinality: childCardinality,
-					parent_cardinality: "zero_or_more",
-					def: ""
-				});
-				tableConstraints.push({
-					name: `fk_${tableName}_${fieldName}`,
-					type: "FOREIGN KEY",
-					def: "",
-					table: tableName,
-					columns: [fieldName],
-					referenced_table: foreignTable,
-					referenced_columns: [foreignColumn]
-				});
-				if (!referencedByTable[tableName]) referencedByTable[tableName] = /* @__PURE__ */ new Set();
-				referencedByTable[tableName].add(foreignTable);
-			}
-		}
-		constraintsByTable[tableName] = tableConstraints;
-		tables.push({
-			name: tableName,
-			type: "table",
-			comment: schema?.description ?? "",
-			columns,
-			indexes: [],
-			constraints: constraintsByTable[tableName] ?? [],
-			triggers: [],
-			def: "",
-			referenced_tables: []
-		});
-	}
-	for (const table of tables) {
-		const referenced = referencedByTable[table.name];
-		table.referenced_tables = referenced ? Array.from(referenced) : [];
-	}
-	const enums = [];
-	for (const [name, values] of enumsMap.entries()) enums.push({
-		name,
-		values: Array.from(values)
+			required: true,
+			array: false,
+			primaryKey: true,
+			unique: true
+		}, ...fieldColumns],
+		indexes,
+		forwardRelationships: toRelationships(type.forwardRelationships),
+		backwardRelationships: toRelationships(type.backwardRelationships)
+	};
+}
+function toRelation(sourceTable, field) {
+	const relation = toColumnRelation({
+		fieldName: field.name,
+		fieldConfig: field.config,
+		parsedField: field,
+		indexEntries: []
 	});
+	if (!relation) return void 0;
 	return {
-		name: namespace,
-		tables,
-		relations,
-		enums
+		name: `${sourceTable}.${field.name}->${relation.targetTable}.${relation.targetColumn}`,
+		sourceTable,
+		sourceColumns: [field.name],
+		targetTable: relation.targetTable,
+		targetColumns: [relation.targetColumn],
+		required: relation.required,
+		unique: field.config.unique === true || field.relation?.unique === true,
+		kind: relation.kind,
+		...relation.relationType && { relationType: relation.relationType },
+		...relation.forwardName && { forwardName: relation.forwardName },
+		...relation.backwardName && { backwardName: relation.backwardName }
 	};
 }
-/**
-* Export apply-applied TailorDB schema for a namespace as tbls-compatible JSON.
-* @param options - Export options
-* @returns tbls schema representation
-*/
-async function exportTailorDBSchema(options) {
-	const { client, workspaceId, namespace } = options;
-	const types = await fetchAll(async (pageToken, maxPageSize) => {
-		try {
-			const { tailordbTypes, nextPageToken } = await client.listTailorDBTypes({
-				workspaceId,
-				namespaceName: namespace,
-				pageToken,
-				pageSize: maxPageSize
-			});
-			return [tailordbTypes, nextPageToken];
-		} catch (error) {
-			if (error instanceof ConnectError && error.code === Code.NotFound) return [[], ""];
-			throw error;
-		}
-	});
-	if (types.length === 0) logger.warn(`No TailorDB types found in namespace "${namespace}". Returning empty schema.`);
-	return buildTblsSchema(types, namespace);
+function buildRelations(types) {
+	const relations = [];
+	for (const type of Object.values(types)) for (const field of Object.values(type.fields)) {
+		const relation = toRelation(type.name, field);
+		if (relation) relations.push(relation);
+	}
+	return relations.sort((a, b) => a.name.localeCompare(b.name));
 }
 /**
-* Writes the TailorDB schema to a file in tbls-compatible JSON format.
-* @param options - The options for writing the schema file.
+* Build the TailorDB ERD viewer schema for one namespace.
+* @param options - Schema build options.
+* @returns TailorDB ERD viewer schema.
 */
-async function writeTblsSchemaToFile(options) {
-	const schema = await exportTailorDBSchema(options);
-	const json = JSON.stringify(schema, null, 2);
-	fs$1.mkdirSync(path.dirname(options.outputPath), { recursive: true });
-	fs$1.writeFileSync(options.outputPath, json, "utf8");
-	const relativePath = path.relative(process.cwd(), options.outputPath);
-	logger.success(`Wrote ERD schema to ${relativePath}`);
+function buildTailorDbErdSchema(options) {
+	const { namespaceData } = options;
+	const tables = Object.values(namespaceData.types).sort((a, b) => a.name.localeCompare(b.name)).map((type) => toTable(type, namespaceData.sourceInfo.get(type.name)));
+	const schemaWithoutRevision = {
+		version: 1,
+		namespace: namespaceData.namespace,
+		source: options.source ?? "local",
+		cleanRoom: {
+			implementation: "tailor-sdk",
+			notes: CLEAN_ROOM_NOTES
+		},
+		tables,
+		relations: buildRelations(namespaceData.types)
+	};
+	return {
+		...schemaWithoutRevision,
+		generatedAt: options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+		revision: buildRevision(schemaWithoutRevision)
+	};
 }
 
 //#endregion
 //#region src/cli/commands/tailordb/erd/utils.ts
 /**
-* Initialize shared ERD command context.
-* @param args - CLI arguments.
-* @returns Initialized context.
+* Initialize shared ERD command behavior.
 */
-async function initErdContext(args) {
+function initErdCommand() {
 	logBetaWarning("tailordb erd");
-	const client = await initOperatorClient(await loadAccessToken({
-		useProfile: true,
-		profile: args.profile
-	}));
-	const workspaceId = await loadWorkspaceId({
-		workspaceId: args.workspaceId,
-		profile: args.profile
-	});
-	const { config } = await loadConfig(args.config);
+}
+/**
+* Initialize platform context for ERD deployment.
+* @param args - CLI arguments.
+* @returns Initialized deploy context.
+*/
+async function initErdDeployContext(args) {
+	initErdCommand();
 	return {
-		client,
-		workspaceId,
-		config
+		client: await initOperatorClient(await loadAccessToken({
+			useProfile: true,
+			profile: args.profile
+		})),
+		workspaceId: await loadWorkspaceId({
+			workspaceId: args.workspaceId,
+			profile: args.profile
+		})
 	};
 }
 
 //#endregion
-//#region src/cli/commands/tailordb/erd/export.ts
-const DEFAULT_ERD_BASE_DIR = ".tailor-sdk/erd";
+//#region src/cli/commands/tailordb/erd/viewer.ts
+const VIEWER_ASSETS_DIR = "erd-viewer-assets";
+const STYLES_LINK = "<link rel=\"stylesheet\" href=\"./styles.css\" />";
+const APP_SCRIPT = "<script src=\"./app.js\" type=\"module\"><\/script>";
+function assetDirCandidates() {
+	const currentDir = path.dirname(fileURLToPath(import.meta.url));
+	return [
+		path.join(currentDir, "viewer-assets"),
+		path.join(currentDir, VIEWER_ASSETS_DIR),
+		path.join(currentDir, "commands", "tailordb", "erd", VIEWER_ASSETS_DIR),
+		path.resolve(process.cwd(), "packages/sdk/src/cli/commands/tailordb/erd/viewer-assets")
+	];
+}
 /**
-* Resolve TailorDB config and namespace.
-* @param config - Loaded Tailor SDK config.
-* @param explicitNamespace - Namespace override.
-* @returns Resolved namespace and erdSite.
+* Resolve the packaged ERD viewer asset directory.
+* @returns Absolute path to the viewer asset directory.
 */
-function resolveDbConfig(config, explicitNamespace) {
-	const namespace = explicitNamespace ?? Object.keys(config.db ?? {})[0];
-	if (!namespace) throw new Error("No TailorDB namespaces found in config. Please define db services in tailor.config.ts or pass --namespace.");
-	const dbConfig = config.db?.[namespace];
-	if (!dbConfig || typeof dbConfig !== "object" || "external" in dbConfig) throw new Error(`TailorDB namespace "${namespace}" not found in config.db.`);
-	return {
-		namespace,
-		erdSite: dbConfig.erdSite
-	};
+function resolveViewerAssetsDir() {
+	for (const candidate of assetDirCandidates()) if (fs$1.existsSync(path.join(candidate, "index.html"))) return candidate;
+	throw new Error(`ERD viewer assets not found. Checked: ${assetDirCandidates().join(", ")}`);
 }
 /**
-* Get all namespaces from config.
-* @param config - Loaded Tailor SDK config.
-* @param options - Options for filtering namespaces.
-* @returns All namespaces with optional erdSite.
+* Build the self-contained ERD viewer HTML document. CSS, JS, and the schema
+* are inlined as separately extractable blocks: a `<style>` element, a
+* `<script type="module">`, and a `<script type="application/json"
+* id="erd-schema">` data block. This renders without any sibling asset files
+* and lets external tooling (e.g. a future ERD diff) pull out the schema via
+* `JSON.parse`.
+* @param options - Viewer build options.
+* @returns The self-contained HTML document.
 */
-function resolveAllNamespaces(config, options) {
-	const results = [];
-	for (const [namespace, dbConfig] of Object.entries(config.db ?? {})) if (dbConfig && !("external" in dbConfig) && !(options?.requireErdSite && !dbConfig.erdSite)) results.push({
-		namespace,
-		erdSite: dbConfig.erdSite
-	});
-	return results;
+function buildViewerHtml(options) {
+	const assetsDir = resolveViewerAssetsDir();
+	const html = fs$1.readFileSync(path.join(assetsDir, "index.html"), "utf8");
+	const css = fs$1.readFileSync(path.join(assetsDir, "styles.css"), "utf8");
+	const appJs = fs$1.readFileSync(path.join(assetsDir, "app.js"), "utf8");
+	if (!html.includes(STYLES_LINK) || !html.includes(APP_SCRIPT)) throw new Error("ERD viewer index.html is missing expected asset references for inlining.");
+	const embedScript = `<script type="application/json" id="erd-schema">${JSON.stringify(options.schema).replaceAll("<", "\\u003c")}<\/script>`;
+	const inlineScript = `<script type="module">\n${appJs.replace(/<\/script/gi, "<\\/script")}\n<\/script>`;
+	return html.replace(STYLES_LINK, `<style>\n${css}\n</style>`).replace(APP_SCRIPT, `${embedScript}\n    ${inlineScript}`);
 }
 /**
-* Run the liam CLI to build an ERD static site from a schema file.
-* @param schemaPath - Path to the ERD schema JSON file
-* @param cwd - Working directory where liam will run (dist is created here)
-* @returns Resolves when the build completes successfully
+* Write the self-contained TailorDB ERD viewer to `<distDir>/index.html`.
+* @param options - Viewer dist write options.
 */
-async function runLiamBuild(schemaPath, cwd) {
-	fs$1.mkdirSync(cwd, { recursive: true });
-	return await new Promise((resolve, reject) => {
-		let liamBinPath;
-		try {
-			liamBinPath = resolveCliBinPath({
-				packageName: "@liam-hq/cli",
-				binName: "liam"
-			});
-		} catch (error) {
-			logger.error(String(error));
-			reject(error);
-			return;
-		}
-		const child = spawn(process.execPath, [
-			liamBinPath,
-			"erd",
-			"build",
-			"--format",
-			"tbls",
-			"--input",
-			schemaPath
-		], {
-			stdio: [
-				"pipe",
-				"ignore",
-				"pipe"
-			],
-			cwd
-		});
-		let stderrOutput = "";
-		child.stderr?.on("data", (data) => {
-			stderrOutput += data.toString();
-		});
-		child.on("error", (error) => {
-			logger.error("Failed to run `@liam-hq/cli`.");
-			reject(error);
-		});
-		child.on("close", (code) => {
-			if (code === 0) resolve();
-			else {
-				if (stderrOutput) logger.error(stderrOutput);
-				logger.error("liam CLI exited with a non-zero code. Ensure `@liam-hq/cli erd build --format tbls --input schema.json` works in your project.");
-				reject(/* @__PURE__ */ new Error(`liam CLI exited with code ${code ?? 1}`));
-			}
-		});
+function writeViewerDist(options) {
+	fs$1.rmSync(options.distDir, {
+		recursive: true,
+		force: true
 	});
+	fs$1.mkdirSync(options.distDir, { recursive: true });
+	fs$1.writeFileSync(path.join(options.distDir, "index.html"), buildViewerHtml({ schema: options.schema }), "utf8");
+}
+
+//#endregion
+//#region src/cli/commands/tailordb/erd/export.ts
+const DEFAULT_ERD_BASE_DIR$1 = ".tailor-sdk/erd";
+function getErdSite(context, namespace) {
+	const dbConfig = context.config.db?.[namespace];
+	if (!dbConfig || "external" in dbConfig) return;
+	return dbConfig.erdSite;
+}
+function resolveExplicitTarget(options) {
+	const namespaceData = options.context.namespaces.find((candidate) => candidate.namespace === options.namespace);
+	if (!namespaceData) {
+		const available = options.context.namespaces.map((candidate) => candidate.namespace).join(", ");
+		throw new Error(`TailorDB namespace "${options.namespace}" not found in local config.db.` + (available ? ` Available owned namespaces: ${available}` : ""));
+	}
+	const erdSite = getErdSite(options.context, namespaceData.namespace);
+	if (options.requireErdSite && !erdSite) throw new Error(`No erdSite configured for namespace "${namespaceData.namespace}". Add erdSite: "<static-website-name>" to db.${namespaceData.namespace} in tailor.config.ts.`);
+	return toTarget(options.outputDir, namespaceData, erdSite);
+}
+function resolveAllTargets(options) {
+	const namespaces = options.context.namespaces.filter((namespaceData) => !options.requireErdSite || getErdSite(options.context, namespaceData.namespace));
+	if (namespaces.length === 0) throw new Error(options.requireErdSite ? "No namespaces with erdSite configured found. Add erdSite: \"<static-website-name>\" to db.<namespace> in tailor.config.ts." : "No TailorDB namespaces found in config. Please define db services in tailor.config.ts.");
+	logger.info(`Found ${namespaces.length} namespace(s)${options.requireErdSite ? " with erdSite configured" : ""}.`);
+	return namespaces.map((namespaceData) => toTarget(options.outputDir, namespaceData, getErdSite(options.context, namespaceData.namespace)));
+}
+function toTarget(outputDir, namespaceData, erdSite) {
+	return {
+		namespaceData,
+		erdSite,
+		distDir: path.join(outputDir, namespaceData.namespace, "dist")
+	};
+}
+function resolveTargets(options) {
+	if (options.namespace) return [resolveExplicitTarget(options)];
+	return resolveAllTargets(options);
+}
+function prepareErdBuild(target) {
+	writeViewerDist({
+		schema: buildTailorDbErdSchema({ namespaceData: target.namespaceData }),
+		distDir: target.distDir
+	});
+	const relativePath = path.relative(process.cwd(), target.distDir);
+	logger.success(`Built ERD to ${relativePath}`);
+	return {
+		namespace: target.namespaceData.namespace,
+		erdSite: target.erdSite,
+		distDir: target.distDir
+	};
 }
 /**
-* Export TailorDB schema and build ERD artifacts via liam.
+* Prepare TailorDB ERD static viewer builds for one or more namespaces.
 * @param options - Build options.
+* @returns Build results by namespace.
 */
-async function prepareErdBuild(options) {
-	await writeTblsSchemaToFile(options);
-	await runLiamBuild(options.outputPath, options.erdDir);
-	const distDir = path.join(options.erdDir, "dist");
-	const relativePath = path.relative(process.cwd(), distDir);
-	logger.success(`Built ERD to ${relativePath}`);
+async function prepareErdBuilds(options) {
+	return prepareErdBuildsFromContext({
+		context: await loadLocalErdSchema({
+			configPath: options.configPath,
+			namespaces: options.namespace ? [options.namespace] : void 0,
+			requireErdSite: options.requireErdSite
+		}),
+		namespace: options.namespace,
+		outputDir: options.outputDir,
+		requireErdSite: options.requireErdSite
+	});
 }
 /**
-* Prepare ERD builds for one or more namespaces.
+* Prepare TailorDB ERD static viewer builds from an already loaded schema context.
 * @param options - Build options.
 * @returns Build results by namespace.
 */
-async function prepareErdBuilds(options) {
-	const { client, workspaceId, config } = options;
-	const baseDir = options.outputDir ?? path.resolve(process.cwd(), DEFAULT_ERD_BASE_DIR);
-	let targets;
-	if (options.namespace) {
-		const { namespace, erdSite } = resolveDbConfig(config, options.namespace);
-		if (options.requireErdSite && !erdSite) throw new Error(`No erdSite configured for namespace "${namespace}". Add erdSite: "<static-website-name>" to db.${namespace} in tailor.config.ts.`);
-		const erdDir = path.join(baseDir, namespace);
-		targets = [{
-			namespace,
-			erdSite,
-			schemaOutputPath: path.join(erdDir, "schema.json"),
-			distDir: path.join(erdDir, "dist"),
-			erdDir
-		}];
-	} else {
-		const namespaces = resolveAllNamespaces(config, { requireErdSite: options.requireErdSite });
-		if (namespaces.length === 0) throw new Error(options.requireErdSite ? "No namespaces with erdSite configured found. Add erdSite: \"<static-website-name>\" to db.<namespace> in tailor.config.ts." : "No TailorDB namespaces found in config. Please define db services in tailor.config.ts.");
-		logger.info(`Found ${namespaces.length} namespace(s)${options.requireErdSite ? " with erdSite configured" : ""}.`);
-		targets = namespaces.map(({ namespace, erdSite }) => {
-			const erdDir = path.join(baseDir, namespace);
-			return {
-				namespace,
-				erdSite,
-				schemaOutputPath: path.join(erdDir, "schema.json"),
-				distDir: path.join(erdDir, "dist"),
-				erdDir
-			};
-		});
-	}
-	await Promise.all(targets.map((target) => prepareErdBuild({
-		namespace: target.namespace,
-		client,
-		workspaceId,
-		outputPath: target.schemaOutputPath,
-		erdDir: target.erdDir
-	})));
-	return targets;
+function prepareErdBuildsFromContext(options) {
+	const outputDir = path.resolve(process.cwd(), options.outputDir ?? DEFAULT_ERD_BASE_DIR$1);
+	return resolveTargets({
+		context: options.context,
+		namespace: options.namespace,
+		outputDir,
+		requireErdSite: options.requireErdSite
+	}).map((target) => prepareErdBuild(target));
 }
 const erdExportCommand = defineAppCommand({
 	name: "export",
-	description: "Export Liam ERD dist from applied TailorDB schema.",
+	description: "Export TailorDB ERD static viewer from local TailorDB schema.",
 	args: z.object({
-		...deploymentArgs,
+		...configArg,
 		namespace: arg(z.string().optional(), {
 			alias: "n",
 			description: "TailorDB namespace name (optional if only one namespace is defined in config)"
 		}),
-		output: arg(z.string().default(DEFAULT_ERD_BASE_DIR), {
+		output: arg(z.string().default(DEFAULT_ERD_BASE_DIR$1), {
 			alias: "o",
-			description: "Output directory path for tbls-compatible ERD JSON (writes to `<outputDir>/<namespace>/schema.json`)",
+			description: "Output directory path for TailorDB ERD viewer files (writes to `<outputDir>/<namespace>/dist`)",
 			completion: { type: "directory" }
 		})
 	}).strict(),
 	run: async (args) => {
-		const { client, workspaceId, config } = await initErdContext(args);
-		const outputDir = path.resolve(process.cwd(), String(args.output));
+		initErdCommand();
 		const results = await prepareErdBuilds({
-			client,
-			workspaceId,
-			config,
+			configPath: args.config,
 			namespace: args.namespace,
-			outputDir
+			outputDir: args.output
 		});
 		logger.newline();
 		if (args.json) logger.out(results.map((result) => ({
 			namespace: result.namespace,
-			distDir: result.distDir,
-			schemaOutputPath: result.schemaOutputPath
+			distDir: result.distDir
 		})));
 		else for (const result of results) {
 			logger.out(`Exported ERD for namespace "${result.namespace}"`);
-			logger.out(`  - Liam ERD dist: ${result.distDir}`);
-			logger.out(`  - tbls schema.json: ${result.schemaOutputPath}`);
+			logger.out(`  - ERD viewer: ${path.join(result.distDir, "index.html")}`);
 		}
 	}
 });
@@ -3495,11 +3700,9 @@ const erdDeployCommand = defineAppCommand({
 	}).strict(),
 	run: async (args) => {
 		await assertWritable({ profile: args.profile });
-		const { client, workspaceId, config } = await initErdContext(args);
+		const { client, workspaceId } = await initErdDeployContext(args);
 		const buildResults = await prepareErdBuilds({
-			client,
-			workspaceId,
-			config,
+			configPath: args.config,
 			namespace: args.namespace,
 			requireErdSite: true
 		});
@@ -3527,65 +3730,354 @@ const erdDeployCommand = defineAppCommand({
 
 //#endregion
 //#region src/cli/commands/tailordb/erd/serve.ts
+const DEFAULT_ERD_BASE_DIR = ".tailor-sdk/erd";
+const LOCAL_HOST = "127.0.0.1";
+const GLOB_CHARS = /[*?[\]{}()!+@]/;
 function formatServeCommand(namespace) {
 	return `tailor-sdk tailordb erd serve --namespace ${namespace}`;
 }
-async function runServeDist(results) {
-	if (results.length === 0) throw new Error("No ERD build results found.");
+function getCacheControl(filePath) {
+	return filePath.endsWith(".html") || filePath.endsWith(".json") ? "no-cache" : "public, max-age=3600";
+}
+function resolveRequestPath(distDir, requestUrl) {
+	const url = new URL(requestUrl ?? "/", "http://localhost");
+	let pathname;
+	try {
+		pathname = decodeURIComponent(url.pathname);
+	} catch {
+		return;
+	}
+	if (pathname === "/" || pathname.endsWith("/")) pathname = path.join(pathname, "index.html");
+	const root = path.resolve(distDir);
+	const filePath = path.resolve(root, `.${pathname}`);
+	if (filePath !== root && !filePath.startsWith(`${root}${path.sep}`)) return;
+	return filePath;
+}
+function openStaticFile(filePath) {
+	let fd;
+	try {
+		fd = fs$1.openSync(filePath, "r");
+		if (!fs$1.fstatSync(fd).isFile()) {
+			fs$1.closeSync(fd);
+			return;
+		}
+		return {
+			filePath,
+			fd
+		};
+	} catch {
+		if (fd !== void 0) fs$1.closeSync(fd);
+		return;
+	}
+}
+function serveFile(distDir, req, res) {
+	const filePath = resolveRequestPath(distDir, req.url);
+	if (!filePath) {
+		res.writeHead(403);
+		res.end("Forbidden");
+		return;
+	}
+	const fallbackPath = path.join(distDir, "index.html");
+	const target = openStaticFile(filePath) ?? openStaticFile(fallbackPath);
+	if (!target) {
+		res.writeHead(503, {
+			"Content-Type": "text/plain; charset=utf-8",
+			"Cache-Control": "no-cache",
+			"Retry-After": "1"
+		});
+		res.end("ERD build is refreshing. Please retry.");
+		return;
+	}
+	const mimeType = lookup(target.filePath) || "application/octet-stream";
+	const stream = fs$1.createReadStream(target.filePath, {
+		fd: target.fd,
+		autoClose: true
+	});
+	stream.on("error", () => {
+		if (!res.headersSent) {
+			res.writeHead(503, {
+				"Content-Type": "text/plain; charset=utf-8",
+				"Cache-Control": "no-cache",
+				"Retry-After": "1"
+			});
+			res.end("ERD build is refreshing. Please retry.");
+			return;
+		}
+		res.destroy();
+	});
+	res.writeHead(200, {
+		"Content-Type": mimeType,
+		"Cache-Control": getCacheControl(target.filePath)
+	});
+	stream.pipe(res);
+}
+async function startStaticServer(options) {
+	const server = http.createServer((req, res) => {
+		serveFile(options.distDir, req, res);
+	});
+	return await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(options.port, LOCAL_HOST, () => {
+			server.off("error", reject);
+			const address = server.address();
+			if (!address || typeof address === "string") {
+				reject(/* @__PURE__ */ new Error("Failed to determine ERD server address."));
+				return;
+			}
+			resolve({
+				server,
+				url: `http://${LOCAL_HOST}:${address.port}`
+			});
+		});
+	});
+}
+function getWatchPatterns(config, results) {
+	const namespaces = new Set(results.map((result) => result.namespace));
+	const patterns = [config.path];
+	for (const namespace of namespaces) {
+		const dbConfig = config.db?.[namespace];
+		if (dbConfig && !("external" in dbConfig)) patterns.push(...dbConfig.files);
+	}
+	return [...new Set(patterns)];
+}
+function hasGlobPattern(pattern) {
+	return GLOB_CHARS.test(pattern);
+}
+function globBaseDir(pattern) {
+	const absolutePattern = path.resolve(pattern);
+	const parsed = path.parse(absolutePattern);
+	const relativePattern = absolutePattern.slice(parsed.root.length);
+	const literalParts = [];
+	for (const part of relativePattern.split(path.sep)) {
+		if (!part || GLOB_CHARS.test(part)) break;
+		literalParts.push(part);
+	}
+	const literalPath = literalParts.length > 0 ? path.join(parsed.root, ...literalParts) : parsed.root;
+	if (!literalPath || literalPath === parsed.root) return parsed.root || process.cwd();
+	if (!fs$1.existsSync(literalPath)) return path.dirname(literalPath);
+	return fs$1.statSync(literalPath).isDirectory() ? literalPath : path.dirname(literalPath);
+}
+async function expandWatchPattern(pattern) {
+	if (!hasGlobPattern(pattern)) return [path.resolve(pattern)];
+	const paths = /* @__PURE__ */ new Set();
+	for await (const file of glob(pattern)) paths.add(path.resolve(file));
+	const baseDir = globBaseDir(pattern);
+	if (fs$1.existsSync(baseDir) && fs$1.statSync(baseDir).isDirectory()) paths.add(baseDir);
+	return [...paths];
+}
+async function resolveWatchPathsFromConfig(config, results) {
+	const paths = /* @__PURE__ */ new Set();
+	for (const pattern of getWatchPatterns(config, results)) for (const watchPath of await expandWatchPattern(pattern)) paths.add(watchPath);
+	return [...paths];
+}
+async function resolveWatchPaths(context, results) {
+	return await resolveWatchPathsFromConfig(context.config, results);
+}
+function parseFreshErdExportResults(stdout) {
+	const lines = stdout.trim().split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+	for (const line of lines.toReversed()) try {
+		const parsed = JSON.parse(line);
+		if (!Array.isArray(parsed)) continue;
+		return parsed.map((entry) => {
+			const result = entry;
+			if (typeof result.namespace !== "string" || typeof result.distDir !== "string") throw new Error("Invalid ERD export JSON output.");
+			return {
+				namespace: result.namespace,
+				distDir: result.distDir
+			};
+		});
+	} catch {
+		continue;
+	}
+	throw new Error("Failed to parse ERD export JSON output.");
+}
+function freshErdExportArgs(options) {
+	const cliEntry = process.argv[1];
+	if (!cliEntry) throw new Error("Cannot rebuild ERD schema in a fresh process: CLI entrypoint is unavailable.");
+	const args = [
+		cliEntry,
+		"tailordb",
+		"erd",
+		"export",
+		"--output",
+		options.outputDir,
+		"--json"
+	];
+	if (options.configPath) args.push("--config", options.configPath);
+	if (options.namespace) args.push("--namespace", options.namespace);
+	return args;
+}
+async function runFreshErdExport(options) {
+	return await new Promise((resolve, reject) => {
+		const child = spawn(process.execPath, freshErdExportArgs(options), {
+			cwd: process.cwd(),
+			env: process.env,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk;
+		});
+		child.on("error", reject);
+		child.on("close", (code, signal) => {
+			if (code !== 0) {
+				const detail = stderr.trim() || signal || `exit code ${code}`;
+				reject(/* @__PURE__ */ new Error(`Fresh ERD export failed: ${detail}`));
+				return;
+			}
+			try {
+				resolve(parseFreshErdExportResults(stdout));
+			} catch (error) {
+				reject(error);
+			}
+		});
+	});
+}
+function selectPrimaryResult(results) {
 	const [primary, ...rest] = results;
+	if (!primary) throw new Error("No ERD build results found.");
 	logger.info(`Serving ERD for namespace "${primary.namespace}".`);
 	if (rest.length > 0) {
 		const commands = rest.map((result) => `  - ${formatServeCommand(result.namespace)}`).join("\n");
 		logger.warn(`Multiple namespaces found. To serve another namespace, run:\n${commands}`);
 	}
-	fs$1.mkdirSync(primary.erdDir, { recursive: true });
-	return await new Promise((resolve, reject) => {
-		let serveBinPath;
+	return primary;
+}
+async function createErdWatcher(options) {
+	let rebuilding = false;
+	let pending = false;
+	let watchPaths = await resolveWatchPaths(options.initialContext, options.initialResults);
+	let importNonce = 0;
+	const watcher = watch(watchPaths, {
+		ignored: /node_modules/,
+		ignoreInitial: true,
+		awaitWriteFinish: {
+			stabilityThreshold: 100,
+			pollInterval: 100
+		}
+	});
+	async function rebuild() {
+		if (rebuilding) {
+			pending = true;
+			return;
+		}
+		rebuilding = true;
 		try {
-			serveBinPath = resolveCliBinPath({
-				packageName: "serve",
-				binName: "serve"
+			const results = await runFreshErdExport({
+				configPath: options.configPath,
+				namespace: options.namespace,
+				outputDir: options.outputDir
 			});
+			const { config } = await loadConfig(options.configPath, { importNonce: String(importNonce += 1) });
+			const nextWatchPaths = await resolveWatchPathsFromConfig(config, results);
+			watcher.unwatch(watchPaths);
+			watcher.add(nextWatchPaths);
+			watchPaths = nextWatchPaths;
+			logger.success(`Rebuilt ERD schema (${results.map((result) => result.namespace).join(", ")})`, { mode: "stream" });
 		} catch (error) {
+			logger.error("Failed to rebuild ERD schema. Serving the last successful build.", { mode: "stream" });
 			logger.error(String(error));
-			reject(error);
-			return;
-		}
-		const child = spawn(process.execPath, [serveBinPath, "dist"], {
-			stdio: "inherit",
-			cwd: primary.erdDir
-		});
-		child.on("error", (error) => {
-			logger.error("Failed to run `serve dist`.");
-			reject(error);
-		});
-		child.on("exit", (code) => {
-			if (code === 0) resolve();
-			else {
-				logger.error("serve CLI exited with a non-zero code. Ensure `serve dist` works in your project.");
-				reject(/* @__PURE__ */ new Error(`serve CLI exited with code ${code ?? 1}`));
+		} finally {
+			rebuilding = false;
+			if (pending) {
+				pending = false;
+				await rebuild();
 			}
-		});
+		}
+	}
+	let debounceTimer;
+	const scheduleRebuild = (changedPath) => {
+		logger.info(`Schema source changed: ${path.relative(process.cwd(), changedPath)}`, { mode: "stream" });
+		if (debounceTimer) clearTimeout(debounceTimer);
+		debounceTimer = setTimeout(() => {
+			rebuild();
+		}, 150);
+	};
+	watcher.on("add", scheduleRebuild);
+	watcher.on("change", scheduleRebuild);
+	watcher.on("unlink", scheduleRebuild);
+	watcher.on("error", (error) => {
+		logger.error(`ERD watcher error: ${String(error)}`, { mode: "stream" });
+	});
+	return watcher;
+}
+async function waitForShutdown(server, watcher) {
+	return await new Promise((resolve) => {
+		const shutdown = () => {
+			watcher.close().finally(() => {
+				server.close(() => {
+					logger.info("ERD server stopped.");
+					resolve();
+				});
+			});
+		};
+		process.once("SIGINT", shutdown);
+		process.once("SIGTERM", shutdown);
 	});
 }
 const erdServeCommand = defineAppCommand({
 	name: "serve",
-	description: "Generate and serve ERD locally (liam build + serve dist). (beta)",
+	description: "Generate and serve TailorDB ERD locally with watch reload. (beta)",
 	args: z.object({
-		...deploymentArgs,
+		...configArg,
 		namespace: arg(z.string().optional(), {
 			alias: "n",
 			description: "TailorDB namespace name (uses first namespace in config if not specified)"
-		})
+		}),
+		port: arg(z.coerce.number().int().min(0).max(65535).default(0), { description: "Local server port (0 selects a free port)" }),
+		open: arg(z.boolean().default(false), { description: "Open the ERD viewer in the default browser" })
 	}).strict(),
 	run: async (args) => {
-		const { client, workspaceId, config } = await initErdContext(args);
-		await runServeDist(await prepareErdBuilds({
-			client,
-			workspaceId,
-			config,
-			namespace: args.namespace
-		}));
+		initErdCommand();
+		const outputDir = path.resolve(process.cwd(), DEFAULT_ERD_BASE_DIR);
+		const context = await loadLocalErdSchema({
+			configPath: args.config,
+			namespaces: args.namespace ? [args.namespace] : void 0
+		});
+		const results = prepareErdBuildsFromContext({
+			context,
+			namespace: args.namespace,
+			outputDir
+		});
+		const primary = selectPrimaryResult(results);
+		const { server, url } = await startStaticServer({
+			distDir: primary.distDir,
+			port: args.port
+		});
+		const watchUrl = `${url}/?watch=1`;
+		const watcher = await createErdWatcher({
+			configPath: args.config,
+			namespace: args.namespace,
+			outputDir,
+			initialContext: context,
+			initialResults: results
+		});
+		logger.newline();
+		if (args.json) logger.out({
+			namespace: primary.namespace,
+			url: watchUrl,
+			distDir: primary.distDir
+		});
+		else {
+			logger.success("ERD server started.");
+			logger.out(watchUrl);
+		}
+		if (args.open) try {
+			await open(watchUrl);
+		} catch {
+			logger.warn("Failed to open browser automatically. Please open the URL above manually.");
+		}
+		await waitForShutdown(server, watcher);
 	}
 });
 
@@ -3593,7 +4085,7 @@ const erdServeCommand = defineAppCommand({
 //#region src/cli/commands/tailordb/erd/index.ts
 const erdCommand = defineCommand({
 	name: "erd",
-	description: "Generate ERD artifacts for TailorDB namespaces using Liam ERD. (beta)",
+	description: "Generate TailorDB ERD viewer artifacts from local TailorDB schema. (beta)",
 	subCommands: {
 		export: erdExportCommand,
 		serve: erdServeCommand,
@@ -3714,10 +4206,10 @@ async function set(options) {
 		useProfile: false,
 		profile: options.profile
 	}));
-	const trn = `${trnPrefix(await loadWorkspaceId({
+	const trn = resourceTrn(await loadWorkspaceId({
 		workspaceId: options.workspaceId,
 		profile: options.profile
-	}))}:tailordb:${targetNamespace}`;
+	}), "tailordb", targetNamespace);
 	let currentMigration;
 	try {
 		const { metadata } = await client.getMetadata({ trn });
@@ -3806,7 +4298,7 @@ async function collectMigrationStatuses(options) {
 	});
 	const statuses = [];
 	for (const { namespace, migrationsDir } of targetNamespaces) {
-		const trn = `${trnPrefix(workspaceId)}:tailordb:${namespace}`;
+		const trn = resourceTrn(workspaceId, "tailordb", namespace);
 		let currentMigration;
 		try {
 			const { metadata } = await client.getMetadata({ trn });
@@ -4362,7 +4854,7 @@ runMain(mainCommand, {
 				if (isVerbose() && error.stack) logger.debug(`\nStack trace:\n${error.stack}`);
 			} else logger.error(`Unknown error: ${error}`);
 			if (!isCLIError(error) && (!(error instanceof Error) || error instanceof TypeError || error instanceof RangeError)) {
-				const { reportCrash } = await import("../crashreport-C5oHvHUC.mjs");
+				const { reportCrash } = await import("../crashreport-CXD_Kjk-.mjs");
 				await reportCrash(error, "handledError");
 			}
 		}