biz-a-cli 2.3.80-15419 → 2.3.80

package/engine/cc/layer3Behavior.js

@@ -33,8 +33,7 @@ export const PRESENTATION = {
 	INDEX: [],
 	RELATIONSHIP: ["uiIntent", "label", "description"],
 	TENANCY: [],
-	/* A list's search box and print button change how it is read, not what may be done with its records. */
-	STRUCTURE: ["caption", "styleRef", "captionOK", "captionCancel", "width", "height", "label", "description", "search", "print"],
+	STRUCTURE: ["caption", "styleRef", "captionOK", "captionCancel", "width", "height", "label", "description"],
 	ITEM: ["label", "title", "hidden", "styleRef", "className", "template", "icon", "variant"],
 	ENTRY_POINT: ["version", "caption", "label", "description"],
 	BINDING: [],

package/engine/cc/layer3Schema.js

@@ -123,9 +123,7 @@ export const STYLE_PROFILE = [f("className", "text"), f("style", "keyValue"), f(
 const STRUCTURE_COMMON = [f("type", "enum", ["form", "list", "dialog"]), f("entity", "ref"), f("caption", "text"), f("styleRef", "ref")];
 export const STRUCTURE = {
 	form: STRUCTURE_COMMON,
-	/* Doc 8 M2: `search` (true, or { columns, placeholder }) and `print` (true, or { title }) are the list engine's own
-	   features. `selection` and `dbIndex` are Layer 2 only: mass actions call application handlers. */
-	list: [...STRUCTURE_COMMON, f("filter", "json"), f("distinct", "boolean"), f("buttons", "json"), f("search", "json"), f("print", "json")],
+	list: [...STRUCTURE_COMMON, f("filter", "json"), f("distinct", "boolean"), f("buttons", "json")],
 	dialog: [...STRUCTURE_COMMON, f("captionOK", "text"), f("captionCancel", "text"), f("width", "text"), f("height", "text")],
 };
 

package/engine/cc/livePipelines.js

@@ -8,17 +8,11 @@
  *   workflow     the engine's save (DRAFT) → publish (it validates again and assigns the version)
  *
  * Built per call for the verified caller (userId is the principal's, never the request's).
- *
- * Atomic publish (Agung 2026-10-08): `transaction` runs the whole publish in ONE transaction on the tenant database
- * (dialect.withPostgresTransaction — every call inside joins it). Trusted, as `biza add --publish` is: the DDL must not
- * run as biza_app on a tenant that declares tenancy. The principal gate (ccGate) has already run by then.
  */
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { buildDomainDdlPreview, publishConfigs, resolveConfigFromPayload, saveConfigRow } from "../domain/appConfig.js";
-import { withPostgresTransaction } from "../domain/dialect.js";
-import { runTrusted } from "../orm/tenantContext.js";
+import { buildDomainDdlPreview, deleteConfigRow, publishConfigs, resolveConfigFromPayload, saveConfigRow } from "../domain/appConfig.js";
 import { publishApplicationConfig } from "../domain/applicationConfig.js";
 import { validateTenancyDeclaration } from "../orm/tenancyDeclaration.js";
 import * as workflow from "../bpm/workflow.js";
@@ -33,9 +27,9 @@ export const createLivePipelines = ({ argv, userId }) => {
 	return {
 		ruleMode: ruleModeOf(argv),
 
-		transaction: (fn) => runTrusted(() => withPostgresTransaction(dbIndex, fn)),
-
 		saveConfig: (name, version, text) => saveConfigRow(name, version, text, config),
+		/* A domain whose DDL failed takes back the row it saved (publish.js). */
+		removeConfig: (name, version) => deleteConfigRow(name, version, config),
 
 		publishDomain: (name, version) => publishConfigs({ domainName: name, domainVersion: version, dbIndex, migrationMode: "safe" }, argv),
 

package/engine/cc/publish.js

@@ -14,10 +14,8 @@
  *   6. workflows     — engine `save` (DRAFT) → `publish` (the engine assigns the version);
  *   each draft is marked PUBLISHED as it lands.
  *
- * Atomic (Agung 2026-10-08): steps 4–6 run inside ONE transaction (`pipelines.transaction`). The first part that
- * fails ends it, and the whole publish is rolled back — rows, DDL, SYS$APPS, workflows, draft marks — and REPORTED
- * as `{ published: [], failed, rolledBack: true }`. (Found live 2026-10-07: a failed DDL left marketing@0.1.13
- * recorded, and a failed FK left the ALTERs before it.)
+ * ⚠️ The pipelines are not one transaction. A failure stops at that part and is REPORTED with what was
+ * already published; the drafts not reached stay OPEN, and publishing them again skips what is unchanged.
  *
  * Everything that writes is injected (`pipelines`), so this module decides and orders, and never talks
  * to a database itself.
@@ -26,7 +24,6 @@ import { validateWorkflow } from "../bpm/validateWorkflow.js";
 import { APPLICATION_NAME, layerOf, sha256, tryParse } from "./published.js";
 import { domainIndexOf, menuProblems } from "./appMenus.js";
 import { SNAKE_CASE, toSnakeCase } from "./layer3Schema.js";
-import { bumpPatch, registerDomainVersions, sourceName } from "../domain/domainRegistration.js";
 
 export const CC_PUBLISH_STALE = "CC_PUBLISH_STALE";
 export const CC_PUBLISH_INVALID = "CC_PUBLISH_INVALID";
@@ -36,8 +33,10 @@ const SEMVER = /^(\d+)\.(\d+)\.(\d+)$/;
 const isObj = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
 const refuse = (problems, code) => ({ ok: false, problems, ...(code ? { code } : {}) });
 
-/* The registration rule is shared with `biza add --register` (engine/domain/domainRegistration.js). */
-export { bumpPatch };
+export const bumpPatch = (version) => {
+	const m = SEMVER.exec(String(version ?? ""));
+	return m ? `${m[1]}.${m[2]}.${Number(m[3]) + 1}` : "0.1.0";
+};
 
 const newer = (a, b) => {
 	const pa = SEMVER.exec(String(a ?? ""));
@@ -54,6 +53,8 @@ const withoutEngineKeys = (wf) => {
 	return rest;
 };
 
+/* A domain's source "name@version" → name. */
+const sourceName = (source) => String(source ?? "").split("@")[0];
 
 async function publishedOf(repo, draft) {
 	if (draft.kind === "DOMAIN") return repo.publishedDomain(draft.name);
@@ -188,107 +189,125 @@ export async function publishDrafts({ repo, userId, ids, listing, pipelines }) {
 	}
 	if (problems.length) return refuse(problems, CC_PUBLISH_INVALID);
 
-	/* ---------------- 4–6. publish, in order — one transaction ------------------------------------ */
-	if (typeof pipelines.transaction !== "function") return refuse(["The publish needs a transaction to run in; these pipelines do not provide one."]);
+	/* ---------------- 4–6. publish, in order ------------------------------------------------- */
 	const result = { published: [], skipped: [], failed: null };
-	/* The part being written: a failure anywhere in it — the pipeline, or marking its draft — is that part's. */
-	let part = null;
-	const PartFailed = class extends Error {};
-	const fail = (kind, name, error) => {
-		throw Object.assign(new PartFailed(String(error?.message ?? error)), { part: { kind, name } });
-	};
 	const landed = (d, version, skipped = false) => {
 		(skipped ? result.skipped : result.published).push({ kind: d.kind, name: d.name, version: String(version) });
 		return repo.markPublished(d.id, String(version), userId);
 	};
+	const fail = (kind, name, error) => {
+		result.failed = { kind, name, error: String(error?.message ?? error) };
+		return { ok: true, data: result };
+	};
 
-	const writeAll = async () => {
-		/* Domains. */
-		const domainVersions = new Map();
-		for (const d of domainDrafts) {
-			part = { kind: "DOMAIN", name: d.name };
-			const p = published.get(d.id);
-			const current = p ? tryParse("DOMAIN", p.text) : null;
-			if (current && same(current, d.content)) {
-				domainVersions.set(d.name, p.version);
-				await landed(d, p.version, true);
-				continue;
+	/* Domains. */
+	const domainVersions = new Map();
+	for (const d of domainDrafts) {
+		const p = published.get(d.id);
+		const current = p ? tryParse("DOMAIN", p.text) : null;
+		if (current && same(current, d.content)) {
+			domainVersions.set(d.name, p.version);
+			await landed(d, p.version, true);
+			continue;
+		}
+		const { version, content } = plan.get(d.id);
+		/* Found live 2026-10-06: the DDL failed AFTER the row was saved, and the row stayed — publishing the fixed draft
+		   again was then refused as "published by someone else". The row this attempt saved is removed again (the
+		   version is new: the conflict check above refuses a draft whose published row moved). */
+		let saved = false;
+		const undo = async () => {
+			if (!saved) return;
+			try {
+				await pipelines.removeConfig?.(d.name, version);
+			} catch {
+				/* reported with the failure below; the draft stays OPEN either way */
 			}
-			const { version, content } = plan.get(d.id);
+		};
+		try {
 			await pipelines.saveConfig(d.name, version, JSON.stringify(content));
+			saved = true;
 			const r = await pipelines.publishDomain(d.name, version);
-			/* `publishConfigs` reports a failure rather than throwing it: thrown here, it rolls the publish back. */
-			if (!r || r.success !== true) fail("DOMAIN", d.name, r?.error ?? "the domain publish reported no success.");
-			domainVersions.set(d.name, version);
-			await landed(d, version);
+			if (!r || r.success !== true) {
+				await undo();
+				return fail("DOMAIN", d.name, r?.error ?? "the domain publish reported no success.");
+			}
+		} catch (error) {
+			await undo();
+			return fail("DOMAIN", d.name, error);
 		}
+		domainVersions.set(d.name, version);
+		await landed(d, version);
+	}
 
-		/* Found live 2026-10-06: domains were published WITHOUT the open application draft that held their menu. The
-		   registration below wrote a new app row, and that draft — current until then — became "published by someone
-		   else". It is carried along: the same registration, its base moved to the row just written. A draft that was
-		   already stale is left alone (that conflict is the implementor's). */
-		const carryOpenAppDraft = async (version, text, previousText) => {
-			const open = ((await repo.openDrafts?.()) ?? []).find((x) => x.kind === "APPLICATION");
-			if (!open || !isObj(open.content) || !repo.rebaseDraft) return;
-			if (previousText == null || open.baseHash !== sha256(previousText)) return;
-			const content = JSON.parse(JSON.stringify(open.content));
-			content.domains = isObj(content.domains) ? content.domains : {};
-			for (const [name, v] of domainVersions) {
-				const key = Object.keys(content.domains).find((k) => sourceName(content.domains[k]?.source) === name) ?? name;
-				content.domains[key] = { ...(content.domains[key] ?? {}), source: `${name}@${v}` };
-			}
-			const rebased = await repo.rebaseDraft(open.id, open.revision, { content, baseVersion: version, baseHash: sha256(text) }, userId);
-			if (rebased) (result.rebased ??= []).push({ kind: "APPLICATION", id: open.id, baseVersion: version });
-		};
+	/* Found live 2026-10-06: domains were published WITHOUT the open application draft that held their menu. The
+	   registration below wrote a new app row, and that draft — current until then — became "published by someone
+	   else". It is carried along: the same registration, its base moved to the row just written. A draft that was
+	   already stale is left alone (that conflict is the implementor's). */
+	const carryOpenAppDraft = async (version, text, previousText) => {
+		const open = ((await repo.openDrafts?.()) ?? []).find((x) => x.kind === "APPLICATION");
+		if (!open || !isObj(open.content) || !repo.rebaseDraft) return;
+		if (previousText == null || open.baseHash !== sha256(previousText)) return;
+		const content = JSON.parse(JSON.stringify(open.content));
+		content.domains = isObj(content.domains) ? content.domains : {};
+		for (const [name, v] of domainVersions) {
+			const key = Object.keys(content.domains).find((k) => sourceName(content.domains[k]?.source) === name) ?? name;
+			content.domains[key] = { ...(content.domains[key] ?? {}), source: `${name}@${v}` };
+		}
+		const rebased = await repo.rebaseDraft(open.id, open.revision, { content, baseVersion: version, baseHash: sha256(text) }, userId);
+		if (rebased) (result.rebased ??= []).push({ kind: "APPLICATION", id: open.id, baseVersion: version });
+	};
 
-		/* The application config: its domain entries, then SYS$APPS. */
-		part = { kind: "APPLICATION", name: APPLICATION_NAME };
-		const appDraft = drafts.find((d) => d.kind === "APPLICATION");
-		const appRow = appDraft ? published.get(appDraft.id) : await repo.publishedApplication();
-		const appBase = appDraft ? appDraft.content : appRow ? tryParse("APPLICATION", appRow.text) : null;
-		if (domainVersions.size > 0 || appDraft) {
-			if (!isObj(appBase)) fail("APPLICATION", APPLICATION_NAME, "there is no application config to add the domains to.");
-			const app = registerDomainVersions(appBase, domainVersions);
-			const currentApp = appRow ? tryParse("APPLICATION", appRow.text) : null;
-			if (!appDraft && currentApp && same(currentApp, app)) {
-				/* Every domain entry already names its version: nothing to rewrite. */
-			} else if (appDraft && currentApp && same(currentApp, app)) {
-				await landed(appDraft, appRow.version, true);
-			} else {
-				const version = bumpPatch(appRow?.version ?? appDraft?.baseVersion);
-				if (isObj(app.metadata) && app.metadata.version !== undefined) app.metadata.version = version;
+	/* The application config: its domain entries, then SYS$APPS. */
+	const appDraft = drafts.find((d) => d.kind === "APPLICATION");
+	const appRow = appDraft ? published.get(appDraft.id) : await repo.publishedApplication();
+	const appBase = appDraft ? appDraft.content : appRow ? tryParse("APPLICATION", appRow.text) : null;
+	if (domainVersions.size > 0 || appDraft) {
+		if (!isObj(appBase)) return fail("APPLICATION", APPLICATION_NAME, "there is no application config to add the domains to.");
+		const app = JSON.parse(JSON.stringify(appBase));
+		app.domains = isObj(app.domains) ? app.domains : {};
+		for (const [name, version] of domainVersions) {
+			const key = Object.keys(app.domains).find((k) => sourceName(app.domains[k]?.source) === name) ?? name;
+			app.domains[key] = { ...(app.domains[key] ?? {}), source: `${name}@${version}` };
+		}
+		const currentApp = appRow ? tryParse("APPLICATION", appRow.text) : null;
+		if (!appDraft && currentApp && same(currentApp, app)) {
+			/* Every domain entry already names its version: nothing to rewrite. */
+		} else if (appDraft && currentApp && same(currentApp, app)) {
+			await landed(appDraft, appRow.version, true);
+		} else {
+			const version = bumpPatch(appRow?.version ?? appDraft?.baseVersion);
+			if (isObj(app.metadata) && app.metadata.version !== undefined) app.metadata.version = version;
+			try {
 				await pipelines.saveConfig(APPLICATION_NAME, version, JSON.stringify(app));
 				await pipelines.publishApplication(version);
-				if (appDraft) await landed(appDraft, version);
-				else {
-					result.published.push({ kind: "APPLICATION", name: APPLICATION_NAME, version });
-					await carryOpenAppDraft(version, JSON.stringify(app), appRow?.text);
-				}
+			} catch (error) {
+				return fail("APPLICATION", APPLICATION_NAME, error);
+			}
+			if (appDraft) await landed(appDraft, version);
+			else {
+				result.published.push({ kind: "APPLICATION", name: APPLICATION_NAME, version });
+				await carryOpenAppDraft(version, JSON.stringify(app), appRow?.text);
 			}
 		}
+	}
 
-		/* Workflows, through the engine: it validates again and assigns the version. */
-		for (const d of drafts.filter((x) => x.kind === "WORKFLOW")) {
-			part = { kind: "WORKFLOW", name: d.name };
-			const p = published.get(d.id);
-			const current = p ? tryParse("WORKFLOW", p.text) : null;
-			if (current && same(withoutEngineKeys(current), withoutEngineKeys(d.content))) {
-				await landed(d, p.version, true);
-				continue;
-			}
-			const json = { ...d.content, status: "DRAFT" };
+	/* Workflows, through the engine: it validates again and assigns the version. */
+	for (const d of drafts.filter((x) => x.kind === "WORKFLOW")) {
+		const p = published.get(d.id);
+		const current = p ? tryParse("WORKFLOW", p.text) : null;
+		if (current && same(withoutEngineKeys(current), withoutEngineKeys(d.content))) {
+			await landed(d, p.version, true);
+			continue;
+		}
+		const json = { ...d.content, status: "DRAFT" };
+		try {
 			const id = await pipelines.saveWorkflow(json);
 			await pipelines.publishWorkflow(id, json);
 			const row = await repo.publishedWorkflow(d.name);
 			await landed(d, row?.version ?? "?");
+		} catch (error) {
+			return fail("WORKFLOW", d.name, error);
 		}
-	};
-
-	try {
-		await pipelines.transaction(writeAll);
-	} catch (error) {
-		const failed = error instanceof PartFailed ? error.part : (part ?? { kind: "DOMAIN", name: "?" });
-		return { ok: true, data: { published: [], skipped: [], failed: { ...failed, error: String(error?.message ?? error) }, rolledBack: true } };
 	}
 	return { ok: true, data: result };
 }

package/engine/domain/appConfig.js

@@ -269,50 +269,11 @@ export const buildPostgresConfigUpsertSql = (name, version, content, appendOnUpd
    SYS$CONFIG row through FINA and picks the APPLICATION_CONFIG one; here it is a direct lookup. */
 export const buildPostgresApplicationConfigLookupSql = () =>
 	[
-		`SELECT name, version, data FROM ${PG_CONFIG_TABLE}`,
+		`SELECT name, data FROM ${PG_CONFIG_TABLE}`,
 		`WHERE upper(name) = '${APP_CONFIG_NAME}'`,
 		"ORDER BY id DESC LIMIT 1;",
 	].join("\n");
 
-/*
- * Doc 8 (Agung 2026-10-10) — MORE THAN ONE APPLICATION ON A TENANT.
- *
- * The host app is `APPLICATION_CONFIG`, as it always was. Another app declares itself with
- * `metadata.app` in its application.js and lives under `APPLICATION_CONFIG.<app>`; its SYS$APPS row is
- * `<app>`. The client already runs several SYS$APPS rows side by side.
- *
- * ⚠️ `<app>` is lower-case letters and digits only. The client splits a link on `-` to find the app
- * (`<app>-<form>`), and `.` would make the config name ambiguous.
- */
-const SECONDARY_APP_NAME = /^[a-z][a-z0-9]*$/;
-
-export const appConfigNameFor = (metadata) => {
-	const app = metadata?.app;
-	if (app == null || app === "") return APP_CONFIG_NAME;
-	if (typeof app !== "string" || !SECONDARY_APP_NAME.test(app)) {
-		throw new Error(
-			`metadata.app "${app}" is not a valid application name: use lower-case letters and digits only (no spaces, '-' or '.').`,
-		);
-	}
-	return `${APP_CONFIG_NAME}.${app}`;
-};
-
-/* `APPLICATION_CONFIG.finacloud` → `finacloud`; the host config, or any other row, → null. */
-export const secondaryAppNameOf = (configName) => {
-	const match = /^APPLICATION_CONFIG\.([a-z0-9]+)$/i.exec(String(configName ?? "").trim());
-	return match ? match[1].toLowerCase() : null;
-};
-
-/* The newest row of EVERY application config — the host's and each secondary app's — in one read.
-   ⚠️ An exact pattern, not a prefix: the sibling rows `APPLICATION_CONFIG.<app>__UPLOAD_SOURCE` /
-   `__PUBLISH_STATUS` share the prefix and are not application configs. */
-export const buildPostgresApplicationConfigsLookupSql = () =>
-	[
-		`SELECT DISTINCT ON (upper(name)) name, version, data FROM ${PG_CONFIG_TABLE}`,
-		`WHERE upper(name) ~ '^${APP_CONFIG_NAME}(\\.[A-Z0-9]+)?$'`,
-		"ORDER BY upper(name), id DESC;",
-	].join("\n");
-
 /* The client app bundle. On Firebird this goes through the FINA stored procedure
    TOrmMethod/"setApp"; SYS$APPS is a Biz-A table (created by migrations/postgres/…__apps.sql), so
    on PostgreSQL the CLI writes it directly. UPDATEAT is left to the BEFORE UPDATE trigger that
@@ -2014,20 +1975,6 @@ const applyDirectRelationship = (relationship, entityInfos, warnings, adjustment
 	const fromForeignKey = resolveEntityColumnName(fromInfo, relationship.foreignKey);
 
 	let ownerInfo = toForeignKey ? toInfo : fromForeignKey ? fromInfo : toInfo;
-	/*
-	 * Doc 8 M3 — an EXTERNAL table is never altered, so it never owns the foreign key: when the other side can, it does
-	 * (a Biz-A table looking up FINA's GLACCNT by GLACCOUNT, a column both declare). When neither side can, the
-	 * relationship is the screens' business only and nothing is built for it.
-	 */
-	if (ownerInfo.external) {
-		const other = ownerInfo === toInfo ? fromInfo : toInfo;
-		const otherHasKey = other === fromInfo ? fromForeignKey : toForeignKey;
-		if (other.external || !otherHasKey) {
-			adjustments.push(`Relationship "${relationship.from}->${relationship.to}": no column or foreign key is built on the external table ${ownerInfo.tableName}.`);
-			return;
-		}
-		ownerInfo = other;
-	}
 	const foreignKey =
 		ownerInfo === toInfo
 			? (toForeignKey ?? toDbName(relationship.foreignKey))
@@ -2075,9 +2022,7 @@ const applyDirectRelationship = (relationship, entityInfos, warnings, adjustment
 		onDelete,
 		onUpdate: "NO ACTION",
 	};
-	/* Doc 8 M3 — the referenced table is another system's (often in another database): the column and its index are
-	   Biz-A's, a constraint pointing at a table this database does not have is not. */
-	if (!referenceInfo.external) ensureForeignKey(ownerInfo.table, fk);
+	ensureForeignKey(ownerInfo.table, fk);
 
 	const relationIndexColumns = [foreignKey];
 	if (
@@ -2182,27 +2127,22 @@ const applyManyToManyRelationship = (relationship, entityInfos, tableInfos, tabl
 	}
 
 	const onDelete = relationship.ownership === "parent" ? "CASCADE" : "NO ACTION";
-	/* Doc 8 M3 — no constraint points at an EXTERNAL side; the through table's columns and indexes stay. */
-	if (!fromInfo.external) {
-		ensureForeignKey(throughInfo.table, {
-			name: buildObjectName("FK", throughInfo.tableName, fromInfo.tableName, through.fromKey),
-			columns: [through.fromKey],
-			referenceTable: fromInfo.tableName,
-			referenceColumns: [fromPk],
-			onDelete,
-			onUpdate: "NO ACTION",
-		});
-	}
-	if (!toInfo.external) {
-		ensureForeignKey(throughInfo.table, {
-			name: buildObjectName("FK", throughInfo.tableName, toInfo.tableName, through.toKey),
-			columns: [through.toKey],
-			referenceTable: toInfo.tableName,
-			referenceColumns: [toPk],
-			onDelete,
-			onUpdate: "NO ACTION",
-		});
-	}
+	ensureForeignKey(throughInfo.table, {
+		name: buildObjectName("FK", throughInfo.tableName, fromInfo.tableName, through.fromKey),
+		columns: [through.fromKey],
+		referenceTable: fromInfo.tableName,
+		referenceColumns: [fromPk],
+		onDelete,
+		onUpdate: "NO ACTION",
+	});
+	ensureForeignKey(throughInfo.table, {
+		name: buildObjectName("FK", throughInfo.tableName, toInfo.tableName, through.toKey),
+		columns: [through.toKey],
+		referenceTable: toInfo.tableName,
+		referenceColumns: [toPk],
+		onDelete,
+		onUpdate: "NO ACTION",
+	});
 
 	ensureIndex(throughInfo.table, {
 		name: buildObjectName("IDX", throughInfo.tableName, through.fromKey),
@@ -2261,26 +2201,6 @@ const applyServerValueFacts = (entities, relationships, entityInfos, warnings) =
 	}
 };
 
-/* Doc 8 M3 — `external: true`: Biz-A reads the table and never creates, alters or links to it. */
-export const isExternalEntity = (entity) => entity?.external === true || String(entity?.external ?? "").trim().toLowerCase() === "true";
-
-/*
- * What only a Biz-A table can carry. Each is a model WARNING — the publish stops, as for any declaration the database
- * cannot keep — never silently dropped: a `numbering` or `follows` is a trigger Biz-A would have to install on the
- * other system's table, and tenancy is a column and a policy it would have to add.
- */
-const externalEntityProblems = (entityName, entity, tableName, tenantTable) => {
-	const problems = [];
-	const at = `${entityName} is external (another system's table, which Biz-A never alters)`;
-	for (const [attributeName, attribute] of Object.entries(entity?.attributes ?? {})) {
-		if (attribute?.numbering !== undefined) problems.push(`${at}: ${attributeName} cannot declare numbering.`);
-		if (attribute?.follows !== undefined) problems.push(`${at}: ${attributeName} cannot declare follows.`);
-	}
-	if (entity?.tenanted || entity?.multiTenant) problems.push(`${at}: it cannot be tenanted.`);
-	if (tenantTable && String(tableName ?? "").trim().toLowerCase() === tenantTable) problems.push(`${at}: it cannot be the tenancy entity.`);
-	return problems;
-};
-
 const buildDomainSchemaInternal = (domainConfigContent, defaultDbIndex, tenancy = null) => {
 	const parsed = parseDomainConfig(domainConfigContent);
 	const model = parsed?.model ?? {};
@@ -2305,16 +2225,6 @@ const buildDomainSchemaInternal = (domainConfigContent, defaultDbIndex, tenancy
 		const runtime = buildEntityTable(entityName, entity, defaultDbIndex, tenantTable);
 		entityInfos.set(entityName, runtime);
 		tableInfos.set(runtime.tableName, runtime);
-		/*
-		 * Doc 8 M3 — an EXTERNAL entity is a table another system owns (FINA's GLACCNT…): declared for the screens,
-		 * never created, altered or linked to. Its runtime info stays, so relationships can still resolve its columns;
-		 * its table never reaches the schema the DDL sync runs.
-		 */
-		if (isExternalEntity(entity)) {
-			runtime.external = true;
-			warnings.push(...externalEntityProblems(entityName, entity, runtime.tableName, tenantTable));
-			continue;
-		}
 		tables.push(runtime.table);
 	}