clivly 0.9.7 → 0.10.1

package/internal-BAOG5eE4.d.mts

@@ -0,0 +1,226 @@
+import { F as ProjectionMapping, P as ProjectionJoin, h as FilterExpr, l as ConfigValidationError, m as DiscoveredSchemaTable, p as DiscoveredColumnMeta } from "./entity-config-DNQAMbMS.mjs";
+//#region ../core/src/projection-cardinality.d.ts
+declare function joinFansOut(join: ProjectionJoin, joinTable: DiscoveredSchemaTable): boolean;
+/** Every join in the projection that can multiply rows. */
+declare function fanOutJoins(projection: ProjectionMapping, tablesByName: Map<string, DiscoveredSchemaTable>): ProjectionJoin[];
+//#endregion
+//#region ../core/src/projection-sql.d.ts
+/**
+ * SQL generation for projection-backed entities.
+ *
+ * Base and joins are aliased by their ref key (`base`, then each join's `key`),
+ * which is what allows the same table to be joined twice and keeps generated
+ * SQL independent of host table names.
+ *
+ * Pure string generation — no DB access. Identifiers are escaped so output is
+ * deterministic and injection-safe.
+ */
+/** Quote a single identifier part, escaping embedded double-quotes. */
+declare function quoteIdent(name: string): string;
+/**
+ * The identity expression. Composite identities concatenate their parts with
+ * `::`; validation guarantees every part is NOT NULL and non-text, which is
+ * what makes the concatenation collision-free.
+ *
+ * Exported unaliased because two paths need the same expression under different
+ * names: the view compiler aliases it `id`, and the SDK's projection push source
+ * also orders and keyset-paginates by it. Sharing one definition is what keeps
+ * a pushed row's `id` identical to the one the view would have produced.
+ */
+declare function compileProjectionIdentity(projection: ProjectionMapping, basePkColumn: string): string;
+declare function compileProjectionSelect(projection: ProjectionMapping, basePkColumn: string): {
+  columns: string[];
+  selectItems: string[];
+};
+declare function compileProjectionJoins(projection: ProjectionMapping): string[];
+/** `FROM <baseTable> AS "base"` — the alias every ref resolves against. */
+declare function compileProjectionFrom(projection: ProjectionMapping): string;
+/**
+ * Hard ceiling on preview rows, regardless of what a caller asks for.
+ *
+ * A preview runs against a production database from a button a user can click
+ * as often as they like, so the cap belongs beside the query rather than in
+ * whichever caller happens to be passing a limit today.
+ */
+declare const PREVIEW_MAX_ROWS = 50;
+/**
+ * One SELECT reading a few rows through an UNSAVED projection, for the derived
+ * object builder's preview.
+ *
+ * Lives here, beside the view compiler, because both sides of the round trip
+ * need the identical statement: an embedded org runs it against its own
+ * database from `@clivly.com/api`, and a cloud org's host app runs it from
+ * `@clivly/sdk`. Two copies would be free to disagree about what the user is
+ * being shown, which is the whole value of a preview.
+ *
+ * Columns are aliased by FIELD NAME, not by ref token. That is the deliberate
+ * difference from the push source, which aliases by token because cloud ingest
+ * reads `row[token]`; a preview is read by a person, in a table whose headers
+ * are the field names they just typed.
+ */
+declare function compileProjectionPreview(projection: ProjectionMapping, limit: number): string;
+//#endregion
+//#region ../core/src/projection-validate.d.ts
+/**
+ * A derived object's filter is evaluated in the cloud against pushed rows, so
+ * it can only name columns of the base table.
+ *
+ * Every rejected shape here fails *silently* today, which is the whole reason
+ * the check exists — a filter that cannot be honoured must error, never quietly
+ * return the wrong rows. The three shapes fail in different directions:
+ *
+ * - `$raw` is opaque SQL meant for the embedded model. The cloud path cannot
+ *   evaluate it and passes every row, so the filter is ignored and the object
+ *   syncs UNFILTERED.
+ * - A joined-table column resolves to nothing on a pushed row, so under a
+ *   positive operator (`eq`, `in`) no row matches and the object syncs EMPTY.
+ * - The same unresolvable column under a NEGATIVE operator (`ne`, `isNull`,
+ *   `notIn`) is the dangerous one: the missing cell reads as null, so the
+ *   predicate is true for every row and a filter meant to narrow the sync
+ *   ADMITS EVERYTHING. Nobody notices extra rows arriving.
+ *
+ * Rejecting an unresolvable column closes the last two together.
+ */
+declare function validateProjectionFilter(filter: FilterExpr | undefined, projection: ProjectionMapping, schema: DiscoveredSchemaTable[], base: string): ConfigValidationError[];
+/**
+ * Validate a projection against the discovered schema. Returns every error
+ * found (not just the first) so a builder UI can show them all at once.
+ */
+declare function validateProjection(projection: ProjectionMapping, schema: DiscoveredSchemaTable[], base: string): ConfigValidationError[];
+//#endregion
+//#region ../core/src/schema-meta.d.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.
+ */
+declare function columnMetaFor(table: DiscoveredSchemaTable, column: string): DiscoveredColumnMeta | undefined;
+/**
+ * Every primary-key column. More than one entry means a composite PK, which is
+ * why `base_pk` identity is rejected for such tables.
+ */
+declare function primaryKeyColumns(table: DiscoveredSchemaTable): string[];
+/**
+ * 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.
+ */
+declare function coversUniqueKey(table: DiscoveredSchemaTable, columns: string[]): boolean;
+/**
+ * A discovered table whose enrichment metadata is known to be present.
+ *
+ * This narrows only the *presence* of the two optional fields. It says nothing
+ * about their contents — an empty `uniqueConstraints` is a known-empty fact
+ * (the table genuinely has no unique keys), which is exactly the distinction
+ * `hasRichMeta` has always drawn and must keep drawing.
+ */
+type RichMetaTable = DiscoveredSchemaTable & {
+  columnsMeta: DiscoveredColumnMeta[];
+  uniqueConstraints: string[][];
+};
+/**
+ * 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.
+ */
+declare function hasRichMeta(table: DiscoveredSchemaTable): table is RichMetaTable;
+//#endregion
+//#region ../core/src/slug.d.ts
+/**
+ * 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.
+ */
+/**
+ * Lowercase, trim, collapse every run of non-alphanumerics to one hyphen, and
+ * drop leading/trailing hyphens. `"Participant Info"` becomes
+ * `"participant-info"`.
+ *
+ * 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`.
+ */
+declare function slugify(value: string): string;
+/**
+ * A slug the server will accept, derived from a display name.
+ *
+ * `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.
+ */
+declare function toObjectTypeSlug(displayName: string): string;
+//#endregion
+//#region ../core/src/stage-rules.d.ts
+type ConditionOp = "is_empty" | "is_not_empty" | "equals" | "not_equals" | "greater_than" | "less_than" | "before" | "after";
+interface Condition {
+  field: string;
+  op: ConditionOp;
+  value?: string;
+}
+interface EvaluableRule {
+  conditions: Condition[];
+  id: string;
+}
+/**
+ * Whether one condition holds for a host row.
+ *
+ * `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.
+ */
+declare function matchesCondition(condition: Condition, fields: Record<string, string | null>, mappedFields: Set<string>): boolean;
+/**
+ * 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.
+ *
+ * `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.
+ */
+declare function evaluateStage(rules: EvaluableRule[], fields: Record<string, string | null>, mappedFields: Set<string>): string | null;
+//#endregion
+export { joinFansOut as S, compileProjectionJoins as _, matchesCondition as a, quoteIdent as b, columnMetaFor as c, primaryKeyColumns as d, validateProjection as f, compileProjectionIdentity as g, compileProjectionFrom as h, evaluateStage as i, coversUniqueKey as l, PREVIEW_MAX_ROWS as m, ConditionOp as n, slugify as o, validateProjectionFilter as p, EvaluableRule as r, toObjectTypeSlug as s, Condition as t, hasRichMeta as u, compileProjectionPreview as v, fanOutJoins as x, compileProjectionSelect as y };

package/internal-BHJ0X3fC.d.cts

@@ -0,0 +1,226 @@
+import { F as ProjectionMapping, P as ProjectionJoin, h as FilterExpr, l as ConfigValidationError, m as DiscoveredSchemaTable, p as DiscoveredColumnMeta } from "./entity-config-DNQAMbMS.cjs";
+//#region ../core/src/projection-cardinality.d.ts
+declare function joinFansOut(join: ProjectionJoin, joinTable: DiscoveredSchemaTable): boolean;
+/** Every join in the projection that can multiply rows. */
+declare function fanOutJoins(projection: ProjectionMapping, tablesByName: Map<string, DiscoveredSchemaTable>): ProjectionJoin[];
+//#endregion
+//#region ../core/src/projection-sql.d.ts
+/**
+ * SQL generation for projection-backed entities.
+ *
+ * Base and joins are aliased by their ref key (`base`, then each join's `key`),
+ * which is what allows the same table to be joined twice and keeps generated
+ * SQL independent of host table names.
+ *
+ * Pure string generation — no DB access. Identifiers are escaped so output is
+ * deterministic and injection-safe.
+ */
+/** Quote a single identifier part, escaping embedded double-quotes. */
+declare function quoteIdent(name: string): string;
+/**
+ * The identity expression. Composite identities concatenate their parts with
+ * `::`; validation guarantees every part is NOT NULL and non-text, which is
+ * what makes the concatenation collision-free.
+ *
+ * Exported unaliased because two paths need the same expression under different
+ * names: the view compiler aliases it `id`, and the SDK's projection push source
+ * also orders and keyset-paginates by it. Sharing one definition is what keeps
+ * a pushed row's `id` identical to the one the view would have produced.
+ */
+declare function compileProjectionIdentity(projection: ProjectionMapping, basePkColumn: string): string;
+declare function compileProjectionSelect(projection: ProjectionMapping, basePkColumn: string): {
+  columns: string[];
+  selectItems: string[];
+};
+declare function compileProjectionJoins(projection: ProjectionMapping): string[];
+/** `FROM <baseTable> AS "base"` — the alias every ref resolves against. */
+declare function compileProjectionFrom(projection: ProjectionMapping): string;
+/**
+ * Hard ceiling on preview rows, regardless of what a caller asks for.
+ *
+ * A preview runs against a production database from a button a user can click
+ * as often as they like, so the cap belongs beside the query rather than in
+ * whichever caller happens to be passing a limit today.
+ */
+declare const PREVIEW_MAX_ROWS = 50;
+/**
+ * One SELECT reading a few rows through an UNSAVED projection, for the derived
+ * object builder's preview.
+ *
+ * Lives here, beside the view compiler, because both sides of the round trip
+ * need the identical statement: an embedded org runs it against its own
+ * database from `@clivly.com/api`, and a cloud org's host app runs it from
+ * `@clivly/sdk`. Two copies would be free to disagree about what the user is
+ * being shown, which is the whole value of a preview.
+ *
+ * Columns are aliased by FIELD NAME, not by ref token. That is the deliberate
+ * difference from the push source, which aliases by token because cloud ingest
+ * reads `row[token]`; a preview is read by a person, in a table whose headers
+ * are the field names they just typed.
+ */
+declare function compileProjectionPreview(projection: ProjectionMapping, limit: number): string;
+//#endregion
+//#region ../core/src/projection-validate.d.ts
+/**
+ * A derived object's filter is evaluated in the cloud against pushed rows, so
+ * it can only name columns of the base table.
+ *
+ * Every rejected shape here fails *silently* today, which is the whole reason
+ * the check exists — a filter that cannot be honoured must error, never quietly
+ * return the wrong rows. The three shapes fail in different directions:
+ *
+ * - `$raw` is opaque SQL meant for the embedded model. The cloud path cannot
+ *   evaluate it and passes every row, so the filter is ignored and the object
+ *   syncs UNFILTERED.
+ * - A joined-table column resolves to nothing on a pushed row, so under a
+ *   positive operator (`eq`, `in`) no row matches and the object syncs EMPTY.
+ * - The same unresolvable column under a NEGATIVE operator (`ne`, `isNull`,
+ *   `notIn`) is the dangerous one: the missing cell reads as null, so the
+ *   predicate is true for every row and a filter meant to narrow the sync
+ *   ADMITS EVERYTHING. Nobody notices extra rows arriving.
+ *
+ * Rejecting an unresolvable column closes the last two together.
+ */
+declare function validateProjectionFilter(filter: FilterExpr | undefined, projection: ProjectionMapping, schema: DiscoveredSchemaTable[], base: string): ConfigValidationError[];
+/**
+ * Validate a projection against the discovered schema. Returns every error
+ * found (not just the first) so a builder UI can show them all at once.
+ */
+declare function validateProjection(projection: ProjectionMapping, schema: DiscoveredSchemaTable[], base: string): ConfigValidationError[];
+//#endregion
+//#region ../core/src/schema-meta.d.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.
+ */
+declare function columnMetaFor(table: DiscoveredSchemaTable, column: string): DiscoveredColumnMeta | undefined;
+/**
+ * Every primary-key column. More than one entry means a composite PK, which is
+ * why `base_pk` identity is rejected for such tables.
+ */
+declare function primaryKeyColumns(table: DiscoveredSchemaTable): string[];
+/**
+ * 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.
+ */
+declare function coversUniqueKey(table: DiscoveredSchemaTable, columns: string[]): boolean;
+/**
+ * A discovered table whose enrichment metadata is known to be present.
+ *
+ * This narrows only the *presence* of the two optional fields. It says nothing
+ * about their contents — an empty `uniqueConstraints` is a known-empty fact
+ * (the table genuinely has no unique keys), which is exactly the distinction
+ * `hasRichMeta` has always drawn and must keep drawing.
+ */
+type RichMetaTable = DiscoveredSchemaTable & {
+  columnsMeta: DiscoveredColumnMeta[];
+  uniqueConstraints: string[][];
+};
+/**
+ * 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.
+ */
+declare function hasRichMeta(table: DiscoveredSchemaTable): table is RichMetaTable;
+//#endregion
+//#region ../core/src/slug.d.ts
+/**
+ * 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.
+ */
+/**
+ * Lowercase, trim, collapse every run of non-alphanumerics to one hyphen, and
+ * drop leading/trailing hyphens. `"Participant Info"` becomes
+ * `"participant-info"`.
+ *
+ * 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`.
+ */
+declare function slugify(value: string): string;
+/**
+ * A slug the server will accept, derived from a display name.
+ *
+ * `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.
+ */
+declare function toObjectTypeSlug(displayName: string): string;
+//#endregion
+//#region ../core/src/stage-rules.d.ts
+type ConditionOp = "is_empty" | "is_not_empty" | "equals" | "not_equals" | "greater_than" | "less_than" | "before" | "after";
+interface Condition {
+  field: string;
+  op: ConditionOp;
+  value?: string;
+}
+interface EvaluableRule {
+  conditions: Condition[];
+  id: string;
+}
+/**
+ * Whether one condition holds for a host row.
+ *
+ * `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.
+ */
+declare function matchesCondition(condition: Condition, fields: Record<string, string | null>, mappedFields: Set<string>): boolean;
+/**
+ * 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.
+ *
+ * `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.
+ */
+declare function evaluateStage(rules: EvaluableRule[], fields: Record<string, string | null>, mappedFields: Set<string>): string | null;
+//#endregion
+export { joinFansOut as S, compileProjectionJoins as _, matchesCondition as a, quoteIdent as b, columnMetaFor as c, primaryKeyColumns as d, validateProjection as f, compileProjectionIdentity as g, compileProjectionFrom as h, evaluateStage as i, coversUniqueKey as l, PREVIEW_MAX_ROWS as m, ConditionOp as n, slugify as o, validateProjectionFilter as p, EvaluableRule as r, toObjectTypeSlug as s, Condition as t, hasRichMeta as u, compileProjectionPreview as v, fanOutJoins as x, compileProjectionSelect as y };

package/internal-Bgiimp5D.mjs

@@ -0,0 +1,144 @@
+//#region ../core/src/slug.ts
+/**
+* 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.
+*/
+const NON_ALNUM = /[^a-z0-9]+/g;
+const EDGE_HYPHENS = /(^-|-$)/g;
+/**
+* Lowercase, trim, collapse every run of non-alphanumerics to one hyphen, and
+* drop leading/trailing hyphens. `"Participant Info"` becomes
+* `"participant-info"`.
+*
+* 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 slugify(value) {
+	return value.toLowerCase().trim().replace(NON_ALNUM, "-").replace(EDGE_HYPHENS, "");
+}
+/**
+* Prefixed onto a slug that would otherwise not start with a letter.
+*
+* 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.
+*/
+const LEADING_DIGIT_PREFIX = "obj-";
+/** Mirrors `PROJECTION_KEY_PATTERN` / the server's `OBJECT_TYPE_SLUG_PATTERN`. */
+const MUST_START_WITH_LETTER = /^[a-z]/;
+/**
+* A slug the server will accept, derived from a display name.
+*
+* `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 toObjectTypeSlug(displayName) {
+	const slug = slugify(displayName);
+	if (slug === "") return "";
+	return MUST_START_WITH_LETTER.test(slug) ? slug : `${LEADING_DIGIT_PREFIX}${slug}`;
+}
+//#endregion
+//#region ../core/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");
+}
+/** Host fields arrive as strings; null and "" are both absent. */
+function isEmpty(value) {
+	return value === null || value === void 0 || value === "";
+}
+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;
+}
+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;
+}
+/**
+* Whether one condition holds for a host row.
+*
+* `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 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);
+}
+/**
+* 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.
+*
+* `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 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 { toObjectTypeSlug as i, matchesCondition as n, slugify as r, evaluateStage as t };