@clivly/core 0.9.7 → 0.10.0

package/dist/index.mjs

@@ -1,217 +1,153 @@
 import { authCustom } from "./auth-adapter.mjs";
-import { a as projectionSchema, i as identityRefs, n as PROJECTION_KEY_MESSAGE, r as PROJECTION_KEY_PATTERN, t as BASE_REF } from "./projection-BXw_iiw5.mjs";
-import { _ as columnMetaFor, a as MATERIALIZING_CONCEPTS, b as primaryKeyColumns, c as entitiesConfigSchema, d as relationshipSchema, f as relationshipsSchema, g as joinFansOut, h as fanOutJoins, i as ClivlyConfigError, l as filterSchema, m as validateProjection, n as CRM_CONCEPTS, p as validateEntitiesConfig, s as defineClivlyConfig, t as CANONICAL_FIELDS, v as coversUniqueKey, y as hasRichMeta } from "./entity-config-DwGXbUo_.mjs";
+import { i as projectionSchema, n as PROJECTION_KEY_PATTERN, r as identityRefs, t as BASE_REF } from "./projection-SCNrLJMV.mjs";
+import { i as primaryKeyColumns, n as coversUniqueKey, r as hasRichMeta, t as columnMetaFor } from "./schema-meta-Ac7938mT.mjs";
+import { _ as joinFansOut, a as MATERIALIZING_CONCEPTS, c as entitiesConfigSchema, d as relationshipSchema, f as relationshipsSchema, g as fanOutJoins, h as validateProjectionFilter, i as ClivlyConfigError, l as filterSchema, m as validateProjection, n as CRM_CONCEPTS, p as validateEntitiesConfig, s as defineClivlyConfig, t as CANONICAL_FIELDS, u as projectionFields } from "./entity-config-DpHPMFIS.mjs";
 import { buildFilterFromDiscriminator, buildRelationships, relationshipViaSignature } from "./mapping-form.mjs";
 import { mappingsToEntitiesConfig } from "./mappings-config.mjs";
-import { c as compileProjectionIdentity, d as compileProjectionSelect, f as quoteIdent, i as explainEntitiesConfig, l as compileProjectionJoins, n as compileEntityView, o as PREVIEW_MAX_ROWS, r as compileEntityViews, s as compileProjectionFrom, t as DEFAULT_VIEW_PREFIX, u as compileProjectionPreview } from "./view-compiler-u3GGRgnv.mjs";
+import { c as compileProjectionIdentity, d as compileProjectionSelect, f as quoteIdent, i as explainEntitiesConfig, l as compileProjectionJoins, n as compileEntityView, o as PREVIEW_MAX_ROWS, r as compileEntityViews, s as compileProjectionFrom, t as DEFAULT_VIEW_PREFIX, u as compileProjectionPreview } from "./view-compiler-CLvZ0wJW.mjs";
 import { reconcile, runSync } from "./sync-engine.mjs";
-//#region src/projection-draft.ts
-function emptyProjectionDraft(baseTable) {
-	return {
-		baseTable,
-		entityKey: "",
-		fieldBindings: {},
-		identity: { kind: "base_pk" },
-		joins: []
-	};
-}
+import { OPEN_STAGE_TYPE, isClosedStageType } from "./types.mjs";
+//#region src/slug.ts
 /**
-* The ON conditions implied by a foreign key between the two tables, so the
-* builder can pre-fill a join instead of making the user hand-pick columns.
-* Returns [] when no FK relates them — the user then picks manually.
+* The one `slugify`.
+*
+* Three byte-identical copies existed before this module — in `@clivly/api`
+* (the custom object-type slug), in `apps/web`'s onboarding route (the
+* organisation slug), and in `@clivly/sdk`. The first two now import this; the
+* SDK's copy stays where it is on purpose, because `@clivly/sdk` cannot depend
+* on this package and its own comment records that its pattern is deliberately
+* kept in step with the server's by hand.
+*
+* Note that the two callers this replaces slug *different things* — an
+* object type and an organisation. They share a transform, not a namespace.
+* Sharing the function stops the transform drifting; it does not make those two
+* identifiers the same identifier.
 */
-function suggestJoinConditions(baseTable, joinTable, schema, joinKey) {
-	const join = schema.find((t) => t.name === joinTable);
-	const conditions = [];
-	for (const column of join?.columnsMeta ?? []) if (column.references?.table === baseTable) conditions.push({
-		left: {
-			table: joinKey,
-			column: column.name
-		},
-		op: "eq",
-		right: {
-			table: BASE_REF,
-			column: column.references.column
-		}
-	});
-	return conditions;
-}
+const NON_ALNUM = /[^a-z0-9]+/g;
+const EDGE_HYPHENS = /(^-|-$)/g;
 /**
-* Add a join on `joinTable`, keyed and pre-filled.
+* Lowercase, trim, collapse every run of non-alphanumerics to one hyphen, and
+* drop leading/trailing hyphens. `"Participant Info"` becomes
+* `"participant-info"`.
 *
-* The key is the table's own name where that is free, because it is what the
-* user already calls the table; a collision falls back to `_2`, `_3` and so on.
-* Uniqueness is not cosmetic — the key is the SQL alias and the name every ref
-* addresses the table by, so two joins sharing one would make every ref
-* ambiguous. `base` is reserved for the base table and can never be taken.
+* The result is NOT guaranteed to be an acceptable slug. Both
+* `OBJECT_TYPE_SLUG_PATTERN` (server) and `PROJECTION_KEY_PATTERN` (this
+* package) require a leading letter, and this function happily returns
+* `"2024-invoices"` for `"2024 Invoices"`. Callers that need an
+* acceptance-guaranteed identifier want `toObjectTypeSlug`.
 */
-function addDraftJoin(draft, joinTable, schema) {
-	const taken = /* @__PURE__ */ new Set([BASE_REF, ...draft.joins.map((j) => j.key)]);
-	let key = joinTable;
-	let suffix = 2;
-	while (taken.has(key)) {
-		key = `${joinTable}_${suffix}`;
-		suffix += 1;
-	}
-	return {
-		...draft,
-		joins: [...draft.joins, {
-			key,
-			table: joinTable,
-			type: "left",
-			on: suggestJoinConditions(draft.baseTable, joinTable, schema, key)
-		}]
-	};
+function slugify(value) {
+	return value.toLowerCase().trim().replace(NON_ALNUM, "-").replace(EDGE_HYPHENS, "");
 }
 /**
-* Remove a join, and everything that addressed it.
+* Prefixed onto a slug that would otherwise not start with a letter.
 *
-* Refs to a removed join are refs to a table the projection no longer declares.
-* Left in place they fail validation as "unknown ref table", which blames the
-* field — or, worse, the identity — for the join's removal. Identity falls back
-* to the base primary key, the same default a new draft starts from.
+* Chosen over trimming the offending characters because dropping them loses
+* information the user typed: `"2024 Invoices"` would become `"invoices"`,
+* which collides with a genuinely different object of that name.
 */
-function removeDraftJoin(draft, joinKey) {
-	const fieldBindings = Object.fromEntries(Object.entries(draft.fieldBindings).filter(([, binding]) => binding.from.table !== joinKey));
-	const identityDependsOnJoin = identityRefs(draft.identity, "").some((ref) => ref.table === joinKey);
-	return {
-		...draft,
-		joins: draft.joins.filter((join) => join.key !== joinKey),
-		fieldBindings,
-		identity: identityDependsOnJoin ? { kind: "base_pk" } : draft.identity
-	};
-}
+const LEADING_DIGIT_PREFIX = "obj-";
+/** Mirrors `PROJECTION_KEY_PATTERN` / the server's `OBJECT_TYPE_SLUG_PATTERN`. */
+const MUST_START_WITH_LETTER = /^[a-z]/;
 /**
-* Every table a field or identity may currently read from, in ref order: the
-* base table first, then each join.
+* A slug the server will accept, derived from a display name.
 *
-* Returns [] when the base table is not in the discovered schema — there is
-* nothing truthful to offer, and inventing columns would let someone build a
-* projection that cannot compile.
+* `slugify` alone is not enough: the server's `OBJECT_TYPE_SLUG_PATTERN`
+* (`apps/server/src/index.ts`) demands a leading letter, so a name beginning
+* with a digit slugs to something the platform rejects at push time — long
+* after the object was authored. `@clivly/sdk`'s `custom-slug.ts` already knows
+* this case and deliberately withholds `"2024-invoices"` as a suggestion
+* because it would be rejected too.
+*
+* The prefix is applied ONLY when the derived slug does not already start with
+* a letter, so the overwhelmingly common name is untouched.
+*
+* This value must be shown to whoever authored the name. It is the identifier
+* the host app declares as its `objectType`, so a slug derived silently is a
+* slug the developer cannot copy into their config.
+*
+* Returns an empty string for a name with no alphanumerics at all — the caller
+* decides whether that is "keep typing" or an error, since only it knows
+* whether the field is still being edited.
 */
-function draftRefOptions(draft, schema) {
-	const byName = new Map(schema.map((table) => [table.name, table]));
-	const base = byName.get(draft.baseTable);
-	if (!base) return [];
-	const options = [{
-		ref: BASE_REF,
-		label: `${base.name} (${BASE_REF})`,
-		columns: base.columns
-	}];
-	for (const join of draft.joins) {
-		const table = byName.get(join.table);
-		if (table) options.push({
-			ref: join.key,
-			label: `${table.name} (${join.key})`,
-			columns: table.columns
-		});
-	}
-	return options;
+function toObjectTypeSlug(displayName) {
+	const slug = slugify(displayName);
+	if (slug === "") return "";
+	return MUST_START_WITH_LETTER.test(slug) ? slug : `${LEADING_DIGIT_PREFIX}${slug}`;
+}
+//#endregion
+//#region src/stage-rules.ts
+const CONDITION_OPS = /* @__PURE__ */ new Set([
+	"is_empty",
+	"is_not_empty",
+	"equals",
+	"not_equals",
+	"greater_than",
+	"less_than",
+	"before",
+	"after"
+]);
+function isCondition(value) {
+	if (!value || typeof value !== "object") return false;
+	const condition = value;
+	return typeof condition.field === "string" && condition.field.length > 0 && typeof condition.op === "string" && CONDITION_OPS.has(condition.op) && (condition.value === void 0 || typeof condition.value === "string");
 }
-/** A draft becomes a projection once it has a valid key and ≥1 binding. */
-function draftToProjection(draft) {
-	if (!PROJECTION_KEY_PATTERN.test(draft.entityKey)) return null;
-	if (Object.keys(draft.fieldBindings).length === 0) return null;
-	return {
-		version: 1,
-		kind: "projection",
-		entityKey: draft.entityKey,
-		baseTable: draft.baseTable,
-		joins: draft.joins,
-		fieldBindings: draft.fieldBindings,
-		identity: draft.identity
-	};
+/** Host fields arrive as strings; null and "" are both absent. */
+function isEmpty(value) {
+	return value === null || value === void 0 || value === "";
 }
-const PROBE_KEY = "draft";
-/**
-* A draft rendered as a projection so the semantic checks can run against it
-* while it is being written, not only once it is finished.
-*
-* `entityKey` is stood in for rather than taken from the draft: it is the one
-* field `validateProjection` never looks at, and a half-typed key would
-* otherwise have to be valid before any join or identity could be checked. The
-* missing or malformed key is reported separately, by `draftErrors`.
-*/
-function probeProjection(draft) {
-	return {
-		version: 1,
-		kind: "projection",
-		entityKey: PROBE_KEY,
-		baseTable: draft.baseTable,
-		joins: draft.joins,
-		fieldBindings: draft.fieldBindings,
-		identity: draft.identity
-	};
+function compareNumbers(raw, operand, op) {
+	const left = Number(raw);
+	const right = Number(operand);
+	if (Number.isNaN(left) || Number.isNaN(right)) return false;
+	return op === "greater_than" ? left > right : left < right;
 }
-/**
-* `validateProjection` appends its own `projection.` segment to the base path it
-* is given, because in a config the base is the entity that owns the projection
-* (`entities.accounts` → `entities.accounts.projection.identity`). A draft has
-* no owning entity, so passing "projection" as the base produced
-* `projection.projection.identity` — a path no caller could match against, and
-* the reason `draftErrors` was only ever consumed as a flat list of messages.
-*
-* Passing an empty base and dropping the leading separator leaves one
-* convention: every path here starts `projection.` exactly once, whether it came
-* from this module or from the validator.
-*/
-function semanticErrors(draft, schema) {
-	return validateProjection(probeProjection(draft), schema, "").map((error) => ({
-		...error,
-		path: error.path.startsWith(".") ? error.path.slice(1) : error.path
-	}));
+function compareDates(raw, operand, op) {
+	const left = new Date(raw).getTime();
+	const right = new Date(operand ?? "").getTime();
+	if (Number.isNaN(left) || Number.isNaN(right)) return false;
+	return op === "before" ? left < right : left > right;
 }
 /**
-* Every reason this draft cannot be saved, one per cause and each anchored to
-* the section that owns it.
+* Whether one condition holds for a host row.
 *
-* One lumped "Name the object and map a field." was all this used to return for
-* an incomplete draft, at the bare path "projection". Two consequences, both
-* bad: a builder had nowhere to attach the message, and — because it returned
-* before validating — a fanning join under a `base_pk` identity stayed silent
-* until the draft was otherwise complete, which is well after the point where
-* the user chose the join.
+* `mappedFields` is the set of columns the organization actually exposed. A
+* condition naming anything outside it never matches, whatever the operator: a
+* rule referencing a dropped column must fail safe, because treating the field
+* as null would make `is_empty` match every deal.
 */
-function draftErrors(draft, schema) {
-	const errors = [];
-	if (draft.entityKey === "") errors.push({
-		path: "projection.entityKey",
-		message: "Key is required."
-	});
-	else if (!PROJECTION_KEY_PATTERN.test(draft.entityKey)) errors.push({
-		path: "projection.entityKey",
-		message: `Key ${PROJECTION_KEY_MESSAGE}.`
-	});
-	if (Object.keys(draft.fieldBindings).length === 0) errors.push({
-		path: "projection.fieldBindings",
-		message: "Map at least one field."
-	});
-	if (draft.baseTable === "") {
-		errors.push({
-			path: "projection.baseTable",
-			message: "Pick a base table."
-		});
-		return errors;
-	}
-	errors.push(...semanticErrors(draft, schema));
-	return errors;
+function matchesCondition(condition, fields, mappedFields) {
+	if (!mappedFields.has(condition.field)) return false;
+	const raw = fields[condition.field] ?? null;
+	if (condition.op === "is_empty") return isEmpty(raw);
+	if (condition.op === "is_not_empty") return !isEmpty(raw);
+	if (isEmpty(raw)) return false;
+	const value = raw;
+	if (condition.op === "equals") return value === condition.value;
+	if (condition.op === "not_equals") return value !== condition.value;
+	if (condition.op === "greater_than" || condition.op === "less_than") return compareNumbers(value, condition.value, condition.op);
+	return compareDates(value, condition.value, condition.op);
 }
 /**
-* Per-join fan-out, for the builder's inline cardinality hints.
+* The id of the first rule whose conditions all hold, or null when none do.
+*
+* Returns a rule id rather than a stage key because the caller needs the
+* matched rule's `allowClose` before it may move a deal into a closed stage.
 *
-* Answered from the joins alone. Joins are chosen before the key and the fields
-* are filled in, and a fan-out warning is precisely what should steer the
-* identity choice while it is being made — requiring a complete draft put the
-* hint after the decision it exists to inform.
+* `rules` must arrive already ordered — stage position first, then rule
+* position within a stage. Sorting needs stage rows this module deliberately
+* does not see.
+*
+* A rule with no conditions never matches: an empty list would otherwise
+* vacuously AND to true and capture every deal, which is the opposite of what
+* a half-written rule should do.
 */
-function describeCardinality(draft, schema) {
-	const projection = probeProjection(draft);
-	const tablesByName = new Map(schema.map((t) => [t.name, t]));
-	const fanning = new Set(fanOutJoins(projection, tablesByName).map((j) => j.key));
-	return projection.joins.map((join) => ({
-		joinKey: join.key,
-		fansOut: fanning.has(join.key)
-	}));
+function evaluateStage(rules, fields, mappedFields) {
+	for (const rule of rules) {
+		if (!Array.isArray(rule.conditions) || rule.conditions.length === 0 || !rule.conditions.every(isCondition)) continue;
+		if (rule.conditions.every((condition) => matchesCondition(condition, fields, mappedFields))) return rule.id;
+	}
+	return null;
 }
 //#endregion
-export { BASE_REF, CANONICAL_FIELDS, CRM_CONCEPTS, ClivlyConfigError, DEFAULT_VIEW_PREFIX, MATERIALIZING_CONCEPTS, PREVIEW_MAX_ROWS, addDraftJoin, authCustom, buildFilterFromDiscriminator, buildRelationships, columnMetaFor, compileEntityView, compileEntityViews, compileProjectionFrom, compileProjectionIdentity, compileProjectionJoins, compileProjectionPreview, compileProjectionSelect, coversUniqueKey, defineClivlyConfig, describeCardinality, draftErrors, draftRefOptions, draftToProjection, emptyProjectionDraft, entitiesConfigSchema, explainEntitiesConfig, fanOutJoins, filterSchema, hasRichMeta, identityRefs, joinFansOut, mappingsToEntitiesConfig, primaryKeyColumns, projectionSchema, quoteIdent, reconcile, relationshipSchema, relationshipViaSignature, relationshipsSchema, removeDraftJoin, runSync, suggestJoinConditions, validateEntitiesConfig, validateProjection };
+export { BASE_REF, CANONICAL_FIELDS, CRM_CONCEPTS, ClivlyConfigError, DEFAULT_VIEW_PREFIX, MATERIALIZING_CONCEPTS, OPEN_STAGE_TYPE, PREVIEW_MAX_ROWS, PROJECTION_KEY_PATTERN, authCustom, buildFilterFromDiscriminator, buildRelationships, columnMetaFor, compileEntityView, compileEntityViews, compileProjectionFrom, compileProjectionIdentity, compileProjectionJoins, compileProjectionPreview, compileProjectionSelect, coversUniqueKey, defineClivlyConfig, entitiesConfigSchema, evaluateStage, explainEntitiesConfig, fanOutJoins, filterSchema, hasRichMeta, identityRefs, isClosedStageType, joinFansOut, mappingsToEntitiesConfig, matchesCondition, primaryKeyColumns, projectionFields, projectionSchema, quoteIdent, reconcile, relationshipSchema, relationshipViaSignature, relationshipsSchema, runSync, slugify, toObjectTypeSlug, validateEntitiesConfig, validateProjection, validateProjectionFilter };

package/dist/mapping-form.d.cts

@@ -1,4 +1,4 @@
-import { b as RelationshipVia, h as FilterExpr, x as RelationshipsMap } from "./entity-config-buOIVtMM.cjs";
+import { b as RelationshipVia, h as FilterExpr, x as RelationshipsMap } from "./entity-config-DCa785OE.cjs";
 //#region src/mapping-form.d.ts
 /**
  * A relationship the mapping UI can offer or has configured, in the shape the

package/dist/mapping-form.d.mts

@@ -1,4 +1,4 @@
-import { b as RelationshipVia, h as FilterExpr, x as RelationshipsMap } from "./entity-config-buOIVtMM.mjs";
+import { b as RelationshipVia, h as FilterExpr, x as RelationshipsMap } from "./entity-config-DCa785OE.mjs";
 //#region src/mapping-form.d.ts
 /**
  * A relationship the mapping UI can offer or has configured, in the shape the

package/dist/mappings-config.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_entity_config = require("./entity-config-25v_udeY.cjs");
+const require_entity_config = require("./entity-config-C5jBmG2C.cjs");
 //#region src/mappings-config.ts
 const RESERVED_FIELD = "id";
 /**
@@ -48,26 +48,12 @@ function uniquify(base, used) {
 	used.add(key);
 	return key;
 }
-/**
-* A projection's `fields` map, derived mechanically from its bindings.
-*
-* `ClivlyEntityConfig.fields` is required and read by existing consumers, so a
-* projection entity must populate it. The values are ref *tokens*
-* (`"base.full_name"`), never host column names — the compiler reads
-* `projection.fieldBindings`, and `validateEntitiesConfig` skips the legacy
-* column check for projection entities precisely because of this.
-*/
-function projectionFields(projection) {
-	const fields = {};
-	for (const [field, binding] of Object.entries(projection.fieldBindings)) fields[field] = `${binding.from.table}.${binding.from.column}`;
-	return fields;
-}
 function buildEntity(row, refIndex) {
 	const entity = {
 		concept: row.targetConcept,
 		source: row.projection?.baseTable ?? row.sourceTable,
 		role: row.role ?? DEFAULT_ROLE,
-		fields: row.projection ? projectionFields(row.projection) : canonicalFields(row.targetConcept, row.fieldMap)
+		fields: row.projection ? require_entity_config.projectionFields(row.projection) : canonicalFields(row.targetConcept, row.fieldMap)
 	};
 	if (row.projection) entity.projection = row.projection;
 	if (row.targetConcept === "custom" && row.targetObjectTypeId) entity.targetObjectTypeId = row.targetObjectTypeId;

package/dist/mappings-config.d.cts

@@ -1,4 +1,4 @@
-import { P as ProjectionMapping, a as ClivlyEntitiesConfig, h as FilterExpr, x as RelationshipsMap } from "./entity-config-buOIVtMM.cjs";
+import { F as ProjectionMapping, a as ClivlyEntitiesConfig, h as FilterExpr, x as RelationshipsMap } from "./entity-config-DCa785OE.cjs";
 //#region src/mappings-config.d.ts
 /**
  * Mappings → Entity Config bridge.

package/dist/mappings-config.d.mts

@@ -1,4 +1,4 @@
-import { P as ProjectionMapping, a as ClivlyEntitiesConfig, h as FilterExpr, x as RelationshipsMap } from "./entity-config-buOIVtMM.mjs";
+import { F as ProjectionMapping, a as ClivlyEntitiesConfig, h as FilterExpr, x as RelationshipsMap } from "./entity-config-DCa785OE.mjs";
 //#region src/mappings-config.d.ts
 /**
  * Mappings → Entity Config bridge.

package/dist/mappings-config.mjs

@@ -1,4 +1,4 @@
-import { t as CANONICAL_FIELDS } from "./entity-config-DwGXbUo_.mjs";
+import { t as CANONICAL_FIELDS, u as projectionFields } from "./entity-config-DpHPMFIS.mjs";
 //#region src/mappings-config.ts
 const RESERVED_FIELD = "id";
 /**
@@ -47,20 +47,6 @@ function uniquify(base, used) {
 	used.add(key);
 	return key;
 }
-/**
-* A projection's `fields` map, derived mechanically from its bindings.
-*
-* `ClivlyEntityConfig.fields` is required and read by existing consumers, so a
-* projection entity must populate it. The values are ref *tokens*
-* (`"base.full_name"`), never host column names — the compiler reads
-* `projection.fieldBindings`, and `validateEntitiesConfig` skips the legacy
-* column check for projection entities precisely because of this.
-*/
-function projectionFields(projection) {
-	const fields = {};
-	for (const [field, binding] of Object.entries(projection.fieldBindings)) fields[field] = `${binding.from.table}.${binding.from.column}`;
-	return fields;
-}
 function buildEntity(row, refIndex) {
 	const entity = {
 		concept: row.targetConcept,

package/dist/{projection-OJYCYmS_.cjs → projection-DFgCoyZl.cjs}

@@ -99,12 +99,6 @@ Object.defineProperty(exports, "BASE_REF", {
 		return BASE_REF;
 	}
 });
-Object.defineProperty(exports, "PROJECTION_KEY_MESSAGE", {
-	enumerable: true,
-	get: function() {
-		return PROJECTION_KEY_MESSAGE;
-	}
-});
 Object.defineProperty(exports, "PROJECTION_KEY_PATTERN", {
 	enumerable: true,
 	get: function() {

package/dist/{projection-BXw_iiw5.mjs → projection-SCNrLJMV.mjs}

@@ -93,4 +93,4 @@ function identityRefs(identity, basePkColumn) {
 	return identity.parts;
 }
 //#endregion
-export { projectionSchema as a, identityRefs as i, PROJECTION_KEY_MESSAGE as n, PROJECTION_KEY_PATTERN as r, BASE_REF as t };
+export { projectionSchema as i, PROJECTION_KEY_PATTERN as n, identityRefs as r, BASE_REF as t };

package/dist/schema-meta-Ac7938mT.mjs

@@ -0,0 +1,46 @@
+//#region src/schema-meta.ts
+/**
+* Accessors over a discovered table's schema-v2 metadata.
+*
+* Every helper treats *absent* metadata as **unknown**, never as a negative
+* fact. `coversUniqueKey` returning false on a v1 payload is what makes
+* projection validation fail closed: we cannot prove a join is many-to-one, so
+* we refuse to compile it rather than guess.
+*/
+function columnMetaFor(table, column) {
+	return table.columnsMeta?.find((c) => c.name === column);
+}
+/**
+* Every primary-key column. More than one entry means a composite PK, which is
+* why `base_pk` identity is rejected for such tables.
+*/
+function primaryKeyColumns(table) {
+	return (table.columnsMeta ?? []).filter((c) => c.isPrimaryKey).map((c) => c.name);
+}
+/**
+* Do `columns` contain every column of at least one unique key on `table`?
+*
+* This is the fan-out test. A join whose ON columns cover a unique key of the
+* joined table matches at most one row per base row; one that does not can
+* match many.
+*/
+function coversUniqueKey(table, columns) {
+	const present = new Set(columns);
+	return (table.uniqueConstraints ?? []).some((key) => key.length > 0 && key.every((column) => present.has(column)));
+}
+/**
+* Is this table's payload rich enough to validate a projection against?
+*
+* A type predicate rather than a plain boolean so the narrowing is visible to
+* the compiler: callers that guard on this can iterate `columnsMeta` directly
+* instead of casting, and a cast that outlives its guard becomes a type error
+* rather than a silent walk over `undefined`.
+*
+* The invariant is unchanged: this reports whether the metadata is *known*,
+* never whether the table has keys. Absent metadata stays UNKNOWN.
+*/
+function hasRichMeta(table) {
+	return Boolean(table.columnsMeta && table.uniqueConstraints);
+}
+//#endregion
+export { primaryKeyColumns as i, coversUniqueKey as n, hasRichMeta as r, columnMetaFor as t };

package/dist/schema-meta-Cgi0MnHh.cjs

@@ -0,0 +1,69 @@
+//#region src/schema-meta.ts
+/**
+* Accessors over a discovered table's schema-v2 metadata.
+*
+* Every helper treats *absent* metadata as **unknown**, never as a negative
+* fact. `coversUniqueKey` returning false on a v1 payload is what makes
+* projection validation fail closed: we cannot prove a join is many-to-one, so
+* we refuse to compile it rather than guess.
+*/
+function columnMetaFor(table, column) {
+	return table.columnsMeta?.find((c) => c.name === column);
+}
+/**
+* Every primary-key column. More than one entry means a composite PK, which is
+* why `base_pk` identity is rejected for such tables.
+*/
+function primaryKeyColumns(table) {
+	return (table.columnsMeta ?? []).filter((c) => c.isPrimaryKey).map((c) => c.name);
+}
+/**
+* Do `columns` contain every column of at least one unique key on `table`?
+*
+* This is the fan-out test. A join whose ON columns cover a unique key of the
+* joined table matches at most one row per base row; one that does not can
+* match many.
+*/
+function coversUniqueKey(table, columns) {
+	const present = new Set(columns);
+	return (table.uniqueConstraints ?? []).some((key) => key.length > 0 && key.every((column) => present.has(column)));
+}
+/**
+* Is this table's payload rich enough to validate a projection against?
+*
+* A type predicate rather than a plain boolean so the narrowing is visible to
+* the compiler: callers that guard on this can iterate `columnsMeta` directly
+* instead of casting, and a cast that outlives its guard becomes a type error
+* rather than a silent walk over `undefined`.
+*
+* The invariant is unchanged: this reports whether the metadata is *known*,
+* never whether the table has keys. Absent metadata stays UNKNOWN.
+*/
+function hasRichMeta(table) {
+	return Boolean(table.columnsMeta && table.uniqueConstraints);
+}
+//#endregion
+Object.defineProperty(exports, "columnMetaFor", {
+	enumerable: true,
+	get: function() {
+		return columnMetaFor;
+	}
+});
+Object.defineProperty(exports, "coversUniqueKey", {
+	enumerable: true,
+	get: function() {
+		return coversUniqueKey;
+	}
+});
+Object.defineProperty(exports, "hasRichMeta", {
+	enumerable: true,
+	get: function() {
+		return hasRichMeta;
+	}
+});
+Object.defineProperty(exports, "primaryKeyColumns", {
+	enumerable: true,
+	get: function() {
+		return primaryKeyColumns;
+	}
+});

package/dist/sync-engine.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_view_compiler = require("./view-compiler-D30HNRnA.cjs");
+const require_view_compiler = require("./view-compiler-DP4Fbj7-.cjs");
 //#region src/sync-engine.ts
 /**
 * Diff a view's rows against the current mirror population for one entity.

package/dist/sync-engine.d.cts

@@ -1,4 +1,4 @@
-import { a as ClivlyEntitiesConfig } from "./entity-config-buOIVtMM.cjs";
+import { a as ClivlyEntitiesConfig } from "./entity-config-DCa785OE.cjs";
 import { CompileOptions, CompiledView } from "./view-compiler.cjs";
 //#region src/sync-engine.d.ts
 /**

package/dist/sync-engine.d.mts

@@ -1,4 +1,4 @@
-import { a as ClivlyEntitiesConfig } from "./entity-config-buOIVtMM.mjs";
+import { a as ClivlyEntitiesConfig } from "./entity-config-DCa785OE.mjs";
 import { CompileOptions, CompiledView } from "./view-compiler.mjs";
 //#region src/sync-engine.d.ts
 /**

package/dist/sync-engine.mjs

@@ -1,4 +1,4 @@
-import { r as compileEntityViews } from "./view-compiler-u3GGRgnv.mjs";
+import { r as compileEntityViews } from "./view-compiler-CLvZ0wJW.mjs";
 //#region src/sync-engine.ts
 /**
 * Diff a view's rows against the current mirror population for one entity.

package/dist/types.cjs

@@ -0,0 +1,11 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/types.ts
+/** Named once so SQL predicates and UI fallbacks cannot drift apart. */
+const OPEN_STAGE_TYPE = "open";
+/** A closed deal is a historical fact: automation never reopens one. */
+function isClosedStageType(type) {
+	return type === "won" || type === "lost";
+}
+//#endregion
+exports.OPEN_STAGE_TYPE = OPEN_STAGE_TYPE;
+exports.isClosedStageType = isClosedStageType;