@tailor-platform/sdk 1.56.1 → 1.57.0

package/dist/cli/index.mjs

@@ -2,13 +2,13 @@
 
 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 { 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 trnPrefix, 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 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 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-1YuaoNr8.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-CdkoGX27.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 { 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";
@@ -3105,378 +3107,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 +3549,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 +3579,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 +3934,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,