@wildo-ai/saas-models 1.0.1 → 1.1.0

package/dist/esm/resources/utils/duplicate-relationship-registration.validation.d.ts

@@ -0,0 +1,111 @@
+import type { ResourceRelationship, ResourceType } from '../resources.shared.schemas';
+/**
+ * Registry-ASSEMBLY guardrail: the same relationship edge must be registered exactly
+ * once in the flat relationship list the registry hands to every resource factory.
+ *
+ * ## Why this needs a guard at all
+ *
+ * The registry concatenates four relationship sources (custom-shared, custom-backend,
+ * core-shared, core-backend) into one flat list. The resource-config factory then
+ * BUCKETS that list by `filter` (`transformResourceRelationships`) — so a list entry
+ * that appears twice appears twice in the child's `parentRelationships` and twice in
+ * the parent's `childRelationships`. Nothing downstream deduplicates, because nothing
+ * downstream can: two entries are indistinguishable, so a consumer cannot tell "the
+ * author declared this edge twice" from "there are genuinely two edges here".
+ *
+ * That is a SILENT corruption at assembly time, and the consequences are not uniform.
+ * Three distinct classes of damage, none of which needs a lifecycle to fire:
+ *
+ * **1. Broken addressing — throws at REQUEST time.** Several runtime paths assert a
+ * cardinality on the relationship buckets and fail closed when it does not hold. A
+ * duplicate turns each of those assertions into a `CONFIGURATION` throw on a normal
+ * request:
+ *  - Complete-association authorization and mutation-target resolution require
+ *    EXACTLY TWO eligible parent relationships (`length !== 2` → throw). A duplicated
+ *    M:N declaration is worse than a doubled list entry: the factory's
+ *    many-to-many decomposition runs twice, giving the junction FOUR parent edges.
+ *  - Context-addressed singleton authorization and mutation reject an AMBIGUOUS target
+ *    (`length > 1` → throw), and one selector path silently DENIES the operation
+ *    instead of throwing.
+ *  - Bulk relationship-field resolution rejects ambiguous matches read straight off the
+ *    assembled list.
+ *
+ * **2. Lost or doubled semantics — at RENDER time (frontend).** Frontend form semantics
+ * throw in development and return `undefined` in production when two relationships
+ * resolve to one relationship-object field identity; quick-create affordances,
+ * `PARENT_CONTEXT_SINGLETON` / complete-association addressing modes, and preset
+ * relationship-display overrides are dropped by the same ambiguity checks; and a nested
+ * child section renders TWICE, with a duplicated React key and a duplicated LIST fetch.
+ *
+ * **3. Doubled execution — when a lifecycle does fire.**
+ *  - **Composition seeding** (`onParentCreate`) creates one child per relationship in
+ *    the list → a duplicated edge seeds the child TWICE, producing a duplicate row for
+ *    what is usually a 1:1 singleton. This is a data-integrity break.
+ *  - **The delete cascade** (`onParentDelete`) dispatches once per relationship, each
+ *    with a fresh visited-set → the teardown runs twice inside the parent's delete
+ *    transaction.
+ *
+ * What genuinely absorbs duplicates — and is therefore NOT a signal that the registry is
+ * healthy: URL parent-path generation (collapsed into a Map keyed by resource type),
+ * Mongoose index derivation (a Set), DTO nested-field shaping (a Record keyed by field
+ * name), and resource-context traversal (which re-runs the child query per duplicate and
+ * then drops the rows on its circular-reference guard — wasted I/O, not wrong data).
+ * Startup guards report the same violation once per duplicate, which reads as several
+ * distinct problems and trains operators to discount the channel.
+ *
+ * Do NOT downgrade this guard to a warning on the theory that duplicates are inert until
+ * a lifecycle runs. They are not: classes 1 and 2 above are reachable on an ordinary
+ * request against an app that never declares a single lifecycle.
+ *
+ * ## How the duplication happens in practice
+ *
+ * Not by declaring the same edge twice in one file — by COMPOSING lists. A host that
+ * folds the shared relationship list into the bundle it passes as the BACKEND list,
+ * while the shared list also still flows through its own slot, registers every shared
+ * edge twice. That is precisely how `platform-apps-manager` doubled its four
+ * `wildoApplication` composition edges (surfaced by the cascade-deletability guard on a
+ * live boot, 2026-07-29).
+ *
+ * ## Conservative identity: reference-equal functions, structural everything else
+ *
+ * Two edges between the same pair of resources are frequently LEGITIMATE and must never
+ * be merged — different `foreignKeyField` (two FKs from the child to the same parent),
+ * different `discriminator` / `condition`, different `jointResourceType`. So the
+ * duplicate key is the WHOLE authored declaration, compared with
+ * {@link isSameRelationshipDeclaration}: every own property must match, functions are
+ * compared by REFERENCE (never by source), and `resolvedSemantics` is ignored because it
+ * is derived, not authored.
+ *
+ * Comparing functions by reference is the deliberate conservative choice. It catches the
+ * real-world failure — the same declaration objects reaching the registry through two
+ * slots — while guaranteeing that two independently authored edges can never collide,
+ * because their `condition` / `initialData.override` closures are distinct objects. The
+ * guard therefore under-detects rather than over-detects: a missed duplicate keeps
+ * today's behavior, whereas a false positive would refuse to boot a correct registry.
+ *
+ * Pure and side-effect free; the caller decides to throw (the registry does, fail-closed).
+ */
+/** One edge that was registered more than once, with its repeat count. */
+export interface DuplicateRelationshipRegistration {
+    parentResourceType: ResourceType;
+    childResourceType: ResourceType;
+    /** How many times the identical declaration appears in the assembled list (always >= 2). */
+    occurrences: number;
+    /** The first occurrence, so callers can report the nature / cardinality / FK of the edge. */
+    relationship: ResourceRelationship;
+    message: string;
+}
+/**
+ * Find every relationship declaration registered more than once in an assembled
+ * registry list. Returns one entry per duplicated edge (not one per extra occurrence),
+ * empty when the list is clean.
+ *
+ * Bucketing by `parent → child` first keeps the comparison cost proportional to the
+ * number of edges that actually share a resource pair, instead of comparing every
+ * relationship against every other one.
+ *
+ * @param relationships - the flat, pre-compilation concatenation of every relationship
+ *   source the registry was given.
+ */
+export declare function findDuplicateRelationshipRegistrations(relationships: readonly ResourceRelationship[]): DuplicateRelationshipRegistration[];
+//# sourceMappingURL=duplicate-relationship-registration.validation.d.ts.map

package/dist/esm/resources/utils/duplicate-relationship-registration.validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-relationship-registration.validation.d.ts","sourceRoot":"","sources":["../../../../../src/resources/utils/duplicate-relationship-registration.validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEtF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqFG;AAEH,0EAA0E;AAC1E,MAAM,WAAW,iCAAiC;IAChD,kBAAkB,EAAE,YAAY,CAAC;IACjC,iBAAiB,EAAE,YAAY,CAAC;IAChC,4FAA4F;IAC5F,WAAW,EAAE,MAAM,CAAC;IACpB,6FAA6F;IAC7F,YAAY,EAAE,oBAAoB,CAAC;IACnC,OAAO,EAAE,MAAM,CAAC;CACjB;AAqDD;;;;;;;;;;;GAWG;AACH,wBAAgB,sCAAsC,CACpD,aAAa,EAAE,SAAS,oBAAoB,EAAE,GAC7C,iCAAiC,EAAE,CAgErC"}

package/dist/esm/resources/utils/duplicate-relationship-registration.validation.js

@@ -0,0 +1,109 @@
+/**
+ * Structural equality for a relationship DECLARATION.
+ *
+ * - `resolvedSemantics` is skipped: it is compiled from the declaration, and the same
+ *   authored edge can legitimately arrive pre-compiled through one slot and raw through
+ *   another.
+ * - Functions compare by reference (see the rationale in the module JSDoc).
+ * - Arrays and plain objects recurse; everything else uses `Object.is` (so `NaN` matches
+ *   itself and `+0`/`-0` stay distinct).
+ */
+function isSameRelationshipDeclaration(left, right) {
+    if (Object.is(left, right)) {
+        return true;
+    }
+    if (typeof left === 'function' || typeof right === 'function') {
+        // Reference-inequality already established above: distinct closures are distinct
+        // declarations, even when their source text matches.
+        return false;
+    }
+    if (typeof left !== 'object' || left === null ||
+        typeof right !== 'object' || right === null) {
+        return false;
+    }
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+            return false;
+        }
+        return left.every((entry, index) => isSameRelationshipDeclaration(entry, right[index]));
+    }
+    const leftRecord = left;
+    const rightRecord = right;
+    const leftKeys = Object.keys(leftRecord).filter((key) => key !== 'resolvedSemantics');
+    const rightKeys = Object.keys(rightRecord).filter((key) => key !== 'resolvedSemantics');
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    return leftKeys.every((key) => Object.prototype.hasOwnProperty.call(rightRecord, key) &&
+        isSameRelationshipDeclaration(leftRecord[key], rightRecord[key]));
+}
+/**
+ * Find every relationship declaration registered more than once in an assembled
+ * registry list. Returns one entry per duplicated edge (not one per extra occurrence),
+ * empty when the list is clean.
+ *
+ * Bucketing by `parent → child` first keeps the comparison cost proportional to the
+ * number of edges that actually share a resource pair, instead of comparing every
+ * relationship against every other one.
+ *
+ * @param relationships - the flat, pre-compilation concatenation of every relationship
+ *   source the registry was given.
+ */
+export function findDuplicateRelationshipRegistrations(relationships) {
+    const byResourcePair = new Map();
+    for (const relationship of relationships) {
+        const pairKey = `${String(relationship.resourceType1)}→${String(relationship.resourceType2)}`;
+        const bucket = byResourcePair.get(pairKey);
+        if (bucket) {
+            bucket.push(relationship);
+        }
+        else {
+            byResourcePair.set(pairKey, [relationship]);
+        }
+    }
+    const duplicates = [];
+    for (const bucket of byResourcePair.values()) {
+        if (bucket.length < 2) {
+            continue;
+        }
+        // Group the pair's edges into classes of identical declarations. A pair legitimately
+        // holding several DISTINCT edges (two FK fields, a discriminated pair, an M:N
+        // junction side) produces several classes of size 1 and reports nothing.
+        const identityClasses = [];
+        for (const relationship of bucket) {
+            const identityClass = identityClasses.find((candidate) => isSameRelationshipDeclaration(candidate.representative, relationship));
+            if (identityClass) {
+                identityClass.occurrences += 1;
+            }
+            else {
+                identityClasses.push({ representative: relationship, occurrences: 1 });
+            }
+        }
+        for (const identityClass of identityClasses) {
+            if (identityClass.occurrences < 2) {
+                continue;
+            }
+            const { representative, occurrences } = identityClass;
+            duplicates.push({
+                parentResourceType: representative.resourceType1,
+                childResourceType: representative.resourceType2,
+                occurrences,
+                relationship: representative,
+                message: `Relationship '${String(representative.resourceType1)}' → ` +
+                    `'${String(representative.resourceType2)}' is registered ${occurrences} times with an ` +
+                    `identical declaration. The registry buckets relationships by filtering the assembled ` +
+                    `list, so this edge lands ${occurrences} times in the child's parentRelationships and in ` +
+                    `the parent's childRelationships — composition seeding would create ${occurrences} child ` +
+                    `rows per parent create, the onParentDelete cascade would dispatch ${occurrences} times, ` +
+                    `and every startup guard reports it ${occurrences} times. This is almost always a list ` +
+                    `COMPOSITION mistake in the application/platform host: the same relationship array reaching ` +
+                    `the registry through two of its slots (e.g. the shared list folded into the bundle passed ` +
+                    `as the backend list, while it also still flows through the shared slot). Pass each list ` +
+                    `through exactly one slot. To declare two genuinely different edges between the same pair, ` +
+                    `make them differ (distinct foreignKeyField, discriminator/condition, or jointResourceType).`,
+            });
+        }
+    }
+    return duplicates;
+}
+//# sourceMappingURL=duplicate-relationship-registration.validation.js.map

package/dist/esm/resources/utils/duplicate-relationship-registration.validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-relationship-registration.validation.js","sourceRoot":"","sources":["../../../../../src/resources/utils/duplicate-relationship-registration.validation.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ResourceRelationship, ResourceType } from '../resources.shared.schemas';\n\n/**\n * Registry-ASSEMBLY guardrail: the same relationship edge must be registered exactly\n * once in the flat relationship list the registry hands to every resource factory.\n *\n * ## Why this needs a guard at all\n *\n * The registry concatenates four relationship sources (custom-shared, custom-backend,\n * core-shared, core-backend) into one flat list. The resource-config factory then\n * BUCKETS that list by `filter` (`transformResourceRelationships`) — so a list entry\n * that appears twice appears twice in the child's `parentRelationships` and twice in\n * the parent's `childRelationships`. Nothing downstream deduplicates, because nothing\n * downstream can: two entries are indistinguishable, so a consumer cannot tell \"the\n * author declared this edge twice\" from \"there are genuinely two edges here\".\n *\n * That is a SILENT corruption at assembly time, and the consequences are not uniform.\n * Three distinct classes of damage, none of which needs a lifecycle to fire:\n *\n * **1. Broken addressing — throws at REQUEST time.** Several runtime paths assert a\n * cardinality on the relationship buckets and fail closed when it does not hold. A\n * duplicate turns each of those assertions into a `CONFIGURATION` throw on a normal\n * request:\n *  - Complete-association authorization and mutation-target resolution require\n *    EXACTLY TWO eligible parent relationships (`length !== 2` → throw). A duplicated\n *    M:N declaration is worse than a doubled list entry: the factory's\n *    many-to-many decomposition runs twice, giving the junction FOUR parent edges.\n *  - Context-addressed singleton authorization and mutation reject an AMBIGUOUS target\n *    (`length > 1` → throw), and one selector path silently DENIES the operation\n *    instead of throwing.\n *  - Bulk relationship-field resolution rejects ambiguous matches read straight off the\n *    assembled list.\n *\n * **2. Lost or doubled semantics — at RENDER time (frontend).** Frontend form semantics\n * throw in development and return `undefined` in production when two relationships\n * resolve to one relationship-object field identity; quick-create affordances,\n * `PARENT_CONTEXT_SINGLETON` / complete-association addressing modes, and preset\n * relationship-display overrides are dropped by the same ambiguity checks; and a nested\n * child section renders TWICE, with a duplicated React key and a duplicated LIST fetch.\n *\n * **3. Doubled execution — when a lifecycle does fire.**\n *  - **Composition seeding** (`onParentCreate`) creates one child per relationship in\n *    the list → a duplicated edge seeds the child TWICE, producing a duplicate row for\n *    what is usually a 1:1 singleton. This is a data-integrity break.\n *  - **The delete cascade** (`onParentDelete`) dispatches once per relationship, each\n *    with a fresh visited-set → the teardown runs twice inside the parent's delete\n *    transaction.\n *\n * What genuinely absorbs duplicates — and is therefore NOT a signal that the registry is\n * healthy: URL parent-path generation (collapsed into a Map keyed by resource type),\n * Mongoose index derivation (a Set), DTO nested-field shaping (a Record keyed by field\n * name), and resource-context traversal (which re-runs the child query per duplicate and\n * then drops the rows on its circular-reference guard — wasted I/O, not wrong data).\n * Startup guards report the same violation once per duplicate, which reads as several\n * distinct problems and trains operators to discount the channel.\n *\n * Do NOT downgrade this guard to a warning on the theory that duplicates are inert until\n * a lifecycle runs. They are not: classes 1 and 2 above are reachable on an ordinary\n * request against an app that never declares a single lifecycle.\n *\n * ## How the duplication happens in practice\n *\n * Not by declaring the same edge twice in one file — by COMPOSING lists. A host that\n * folds the shared relationship list into the bundle it passes as the BACKEND list,\n * while the shared list also still flows through its own slot, registers every shared\n * edge twice. That is precisely how `platform-apps-manager` doubled its four\n * `wildoApplication` composition edges (surfaced by the cascade-deletability guard on a\n * live boot, 2026-07-29).\n *\n * ## Conservative identity: reference-equal functions, structural everything else\n *\n * Two edges between the same pair of resources are frequently LEGITIMATE and must never\n * be merged — different `foreignKeyField` (two FKs from the child to the same parent),\n * different `discriminator` / `condition`, different `jointResourceType`. So the\n * duplicate key is the WHOLE authored declaration, compared with\n * {@link isSameRelationshipDeclaration}: every own property must match, functions are\n * compared by REFERENCE (never by source), and `resolvedSemantics` is ignored because it\n * is derived, not authored.\n *\n * Comparing functions by reference is the deliberate conservative choice. It catches the\n * real-world failure — the same declaration objects reaching the registry through two\n * slots — while guaranteeing that two independently authored edges can never collide,\n * because their `condition` / `initialData.override` closures are distinct objects. The\n * guard therefore under-detects rather than over-detects: a missed duplicate keeps\n * today's behavior, whereas a false positive would refuse to boot a correct registry.\n *\n * Pure and side-effect free; the caller decides to throw (the registry does, fail-closed).\n */\n\n/** One edge that was registered more than once, with its repeat count. */\nexport interface DuplicateRelationshipRegistration {\n  parentResourceType: ResourceType;\n  childResourceType: ResourceType;\n  /** How many times the identical declaration appears in the assembled list (always >= 2). */\n  occurrences: number;\n  /** The first occurrence, so callers can report the nature / cardinality / FK of the edge. */\n  relationship: ResourceRelationship;\n  message: string;\n}\n\n/**\n * Structural equality for a relationship DECLARATION.\n *\n * - `resolvedSemantics` is skipped: it is compiled from the declaration, and the same\n *   authored edge can legitimately arrive pre-compiled through one slot and raw through\n *   another.\n * - Functions compare by reference (see the rationale in the module JSDoc).\n * - Arrays and plain objects recurse; everything else uses `Object.is` (so `NaN` matches\n *   itself and `+0`/`-0` stay distinct).\n */\nfunction isSameRelationshipDeclaration(left: unknown, right: unknown): boolean {\n  if (Object.is(left, right)) {\n    return true;\n  }\n\n  if (typeof left === 'function' || typeof right === 'function') {\n    // Reference-inequality already established above: distinct closures are distinct\n    // declarations, even when their source text matches.\n    return false;\n  }\n\n  if (\n    typeof left !== 'object' || left === null ||\n    typeof right !== 'object' || right === null\n  ) {\n    return false;\n  }\n\n  if (Array.isArray(left) || Array.isArray(right)) {\n    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {\n      return false;\n    }\n    return left.every((entry, index) => isSameRelationshipDeclaration(entry, right[index]));\n  }\n\n  const leftRecord = left as Record<string, unknown>;\n  const rightRecord = right as Record<string, unknown>;\n  const leftKeys = Object.keys(leftRecord).filter((key) => key !== 'resolvedSemantics');\n  const rightKeys = Object.keys(rightRecord).filter((key) => key !== 'resolvedSemantics');\n\n  if (leftKeys.length !== rightKeys.length) {\n    return false;\n  }\n\n  return leftKeys.every(\n    (key) =>\n      Object.prototype.hasOwnProperty.call(rightRecord, key) &&\n      isSameRelationshipDeclaration(leftRecord[key], rightRecord[key]),\n  );\n}\n\n/**\n * Find every relationship declaration registered more than once in an assembled\n * registry list. Returns one entry per duplicated edge (not one per extra occurrence),\n * empty when the list is clean.\n *\n * Bucketing by `parent → child` first keeps the comparison cost proportional to the\n * number of edges that actually share a resource pair, instead of comparing every\n * relationship against every other one.\n *\n * @param relationships - the flat, pre-compilation concatenation of every relationship\n *   source the registry was given.\n */\nexport function findDuplicateRelationshipRegistrations(\n  relationships: readonly ResourceRelationship[],\n): DuplicateRelationshipRegistration[] {\n  const byResourcePair = new Map<string, ResourceRelationship[]>();\n\n  for (const relationship of relationships) {\n    const pairKey = `${String(relationship.resourceType1)}→${String(relationship.resourceType2)}`;\n    const bucket = byResourcePair.get(pairKey);\n    if (bucket) {\n      bucket.push(relationship);\n    } else {\n      byResourcePair.set(pairKey, [relationship]);\n    }\n  }\n\n  const duplicates: DuplicateRelationshipRegistration[] = [];\n\n  for (const bucket of byResourcePair.values()) {\n    if (bucket.length < 2) {\n      continue;\n    }\n\n    // Group the pair's edges into classes of identical declarations. A pair legitimately\n    // holding several DISTINCT edges (two FK fields, a discriminated pair, an M:N\n    // junction side) produces several classes of size 1 and reports nothing.\n    const identityClasses: { representative: ResourceRelationship; occurrences: number }[] = [];\n\n    for (const relationship of bucket) {\n      const identityClass = identityClasses.find((candidate) =>\n        isSameRelationshipDeclaration(candidate.representative, relationship),\n      );\n      if (identityClass) {\n        identityClass.occurrences += 1;\n      } else {\n        identityClasses.push({ representative: relationship, occurrences: 1 });\n      }\n    }\n\n    for (const identityClass of identityClasses) {\n      if (identityClass.occurrences < 2) {\n        continue;\n      }\n      const { representative, occurrences } = identityClass;\n      duplicates.push({\n        parentResourceType: representative.resourceType1,\n        childResourceType: representative.resourceType2,\n        occurrences,\n        relationship: representative,\n        message:\n          `Relationship '${String(representative.resourceType1)}' → ` +\n          `'${String(representative.resourceType2)}' is registered ${occurrences} times with an ` +\n          `identical declaration. The registry buckets relationships by filtering the assembled ` +\n          `list, so this edge lands ${occurrences} times in the child's parentRelationships and in ` +\n          `the parent's childRelationships — composition seeding would create ${occurrences} child ` +\n          `rows per parent create, the onParentDelete cascade would dispatch ${occurrences} times, ` +\n          `and every startup guard reports it ${occurrences} times. This is almost always a list ` +\n          `COMPOSITION mistake in the application/platform host: the same relationship array reaching ` +\n          `the registry through two of its slots (e.g. the shared list folded into the bundle passed ` +\n          `as the backend list, while it also still flows through the shared slot). Pass each list ` +\n          `through exactly one slot. To declare two genuinely different edges between the same pair, ` +\n          `make them differ (distinct foreignKeyField, discriminator/condition, or jointResourceType).`,\n      });\n    }\n  }\n\n  return duplicates;\n}\n"]}

package/dist/esm/resources/utils/persistence-adapter-discrimination.shared.utils.d.ts

@@ -0,0 +1,52 @@
+import { PersistenceAdapter, type PersistenceAdapterType } from '../resources-config.shared.schemas';
+/**
+ * One value per {@link PersistenceAdapter} member — the shape every adapter DECISION routes
+ * through.
+ *
+ * Mapped over the enum so that adding a member makes every literal cases object a COMPILE error
+ * (missing key) at each decision site, instead of a silent fall-through into whichever arm an
+ * `else` happened to mean. Measured 2026-08-25 before this seam existed: 21 of 30 comparisons
+ * tested `=== POSTGRESQL` with an `else` arm that silently meant "MongoDB" — a third backing kind
+ * would have taken the MongoDB lane at all of them with no compile error and no runtime refusal.
+ */
+export type PersistenceAdapterCases<T> = {
+    readonly [K in PersistenceAdapter]: T;
+};
+/**
+ * Exhaustive discrimination on a persistence adapter.
+ *
+ * Prefer this over `adapter === PersistenceAdapter.X ? … : …` whenever BOTH arms carry a real
+ * answer (dispatching to a database service, choosing a primary-key column, choosing a compiler).
+ * A plain binary comparison stays correct only where one side is a genuinely adapter-specific
+ * feature gate ("does this resource need the PostgreSQL migration door?") — there, the negative
+ * arm means "not that feature", not "the other adapter", and such sites carry a justified comment
+ * instead of this helper.
+ *
+ * Two guarantees, one per failure direction:
+ * - **New enum member** → every call site's `cases` object misses a key → compile error
+ *   (see {@link PersistenceAdapterCases}).
+ * - **Unknown string at runtime** (erased config, a serialized value from an older or foreign
+ *   writer) → throws instead of returning either arm. Thrown as a plain `Error` because this
+ *   module is shared-tier (no `ErrorBuilder` here — same precedent as the factory's
+ *   configuration errors); backend callers surface it through their ordinary error projection.
+ *   It names the value and the supported set so the remedy is legible at the boundary it crossed.
+ *
+ * Branch values are eagerly evaluated; pass thunks (`() => …`) when construction is expensive or
+ * side-effectful and invoke the selected one.
+ */
+export declare function selectByPersistenceAdapter<T>(adapter: PersistenceAdapterType, cases: PersistenceAdapterCases<T>): T;
+/**
+ * Parse an adapter declaration arriving as a RAW string (an env var, a stored configuration
+ * document, any erased boundary).
+ *
+ * - absent (`undefined` / `null`) or empty string (the compose-interpolation contract for
+ *   "not set") → {@link DEFAULT_PERSISTENCE_ADAPTER}. An undeclared deployment keeps today's
+ *   behavior exactly.
+ * - a known member's value → that member.
+ * - **present but unknown → throws.** This is the provisioning-door contract: a declaration that
+ *   IS authored but names a backing kind this deployment does not know must refuse loudly, never
+ *   collapse to MongoDB the way `x === POSTGRESQL ? POSTGRESQL : MONGODB` did — that collapse is
+ *   how a platform would have provisioned a MongoDB database for a resource that has none.
+ */
+export declare function parseDeclaredPersistenceAdapter(raw: string | undefined | null): PersistenceAdapterType;
+//# sourceMappingURL=persistence-adapter-discrimination.shared.utils.d.ts.map

package/dist/esm/resources/utils/persistence-adapter-discrimination.shared.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence-adapter-discrimination.shared.utils.d.ts","sourceRoot":"","sources":["../../../../../src/resources/utils/persistence-adapter-discrimination.shared.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,kBAAkB,EAElB,KAAK,sBAAsB,EAC5B,MAAM,oCAAoC,CAAC;AAE5C;;;;;;;;;GASG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,IAAI;IAAE,QAAQ,EAAE,CAAC,IAAI,kBAAkB,GAAG,CAAC;CAAE,CAAC;AAEnF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAC1C,OAAO,EAAE,sBAAsB,EAC/B,KAAK,EAAE,uBAAuB,CAAC,CAAC,CAAC,GAChC,CAAC,CAUH;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,+BAA+B,CAC7C,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAC7B,sBAAsB,CAYxB"}

package/dist/esm/resources/utils/persistence-adapter-discrimination.shared.utils.js

@@ -0,0 +1,57 @@
+import { DEFAULT_PERSISTENCE_ADAPTER, PersistenceAdapter, isPersistenceAdapter, } from '../resources-config.shared.schemas.js';
+/**
+ * Exhaustive discrimination on a persistence adapter.
+ *
+ * Prefer this over `adapter === PersistenceAdapter.X ? … : …` whenever BOTH arms carry a real
+ * answer (dispatching to a database service, choosing a primary-key column, choosing a compiler).
+ * A plain binary comparison stays correct only where one side is a genuinely adapter-specific
+ * feature gate ("does this resource need the PostgreSQL migration door?") — there, the negative
+ * arm means "not that feature", not "the other adapter", and such sites carry a justified comment
+ * instead of this helper.
+ *
+ * Two guarantees, one per failure direction:
+ * - **New enum member** → every call site's `cases` object misses a key → compile error
+ *   (see {@link PersistenceAdapterCases}).
+ * - **Unknown string at runtime** (erased config, a serialized value from an older or foreign
+ *   writer) → throws instead of returning either arm. Thrown as a plain `Error` because this
+ *   module is shared-tier (no `ErrorBuilder` here — same precedent as the factory's
+ *   configuration errors); backend callers surface it through their ordinary error projection.
+ *   It names the value and the supported set so the remedy is legible at the boundary it crossed.
+ *
+ * Branch values are eagerly evaluated; pass thunks (`() => …`) when construction is expensive or
+ * side-effectful and invoke the selected one.
+ */
+export function selectByPersistenceAdapter(adapter, cases) {
+    if (!Object.prototype.hasOwnProperty.call(cases, adapter)) {
+        throw new Error(`Unknown persistence adapter '${String(adapter)}' reached an adapter decision. `
+            + `Supported adapters: ${Object.values(PersistenceAdapter).join(', ')}. `
+            + 'This is a framework configuration defect: a backing kind was declared or stored that this '
+            + 'deployment does not implement, and refusing here prevents it from being silently treated as one of the known adapters.');
+    }
+    return cases[adapter];
+}
+/**
+ * Parse an adapter declaration arriving as a RAW string (an env var, a stored configuration
+ * document, any erased boundary).
+ *
+ * - absent (`undefined` / `null`) or empty string (the compose-interpolation contract for
+ *   "not set") → {@link DEFAULT_PERSISTENCE_ADAPTER}. An undeclared deployment keeps today's
+ *   behavior exactly.
+ * - a known member's value → that member.
+ * - **present but unknown → throws.** This is the provisioning-door contract: a declaration that
+ *   IS authored but names a backing kind this deployment does not know must refuse loudly, never
+ *   collapse to MongoDB the way `x === POSTGRESQL ? POSTGRESQL : MONGODB` did — that collapse is
+ *   how a platform would have provisioned a MongoDB database for a resource that has none.
+ */
+export function parseDeclaredPersistenceAdapter(raw) {
+    if (raw === undefined || raw === null || raw === '') {
+        return DEFAULT_PERSISTENCE_ADAPTER;
+    }
+    if (!isPersistenceAdapter(raw)) {
+        throw new Error(`Unknown persistence adapter declaration '${raw}'. `
+            + `Supported adapters: ${Object.values(PersistenceAdapter).join(', ')}. `
+            + 'Remove the declaration to use the framework default, or declare a supported adapter.');
+    }
+    return raw;
+}
+//# sourceMappingURL=persistence-adapter-discrimination.shared.utils.js.map

package/dist/esm/resources/utils/persistence-adapter-discrimination.shared.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence-adapter-discrimination.shared.utils.js","sourceRoot":"","sources":["../../../../../src/resources/utils/persistence-adapter-discrimination.shared.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,kBAAkB,EAClB,oBAAoB,GAErB,MAAM,oCAAoC,CAAC;AAc5C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,0BAA0B,CACxC,OAA+B,EAC/B,KAAiC;IAEjC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC;QAC1D,MAAM,IAAI,KAAK,CACb,gCAAgC,MAAM,CAAC,OAAO,CAAC,iCAAiC;cAC9E,uBAAuB,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;cACvE,4FAA4F;cAC5F,wHAAwH,CAC3H,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC,OAA6B,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,+BAA+B,CAC7C,GAA8B;IAE9B,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,EAAE,EAAE,CAAC;QACpD,OAAO,2BAA2B,CAAC;IACrC,CAAC;IACD,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,EAAE,CAAC;QAC/B,MAAM,IAAI,KAAK,CACb,4CAA4C,GAAG,KAAK;cAClD,uBAAuB,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;cACvE,sFAAsF,CACzF,CAAC;IACJ,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import {\n  DEFAULT_PERSISTENCE_ADAPTER,\n  PersistenceAdapter,\n  isPersistenceAdapter,\n  type PersistenceAdapterType,\n} from '../resources-config.shared.schemas';\n\n/**\n * One value per {@link PersistenceAdapter} member — the shape every adapter DECISION routes\n * through.\n *\n * Mapped over the enum so that adding a member makes every literal cases object a COMPILE error\n * (missing key) at each decision site, instead of a silent fall-through into whichever arm an\n * `else` happened to mean. Measured 2026-08-25 before this seam existed: 21 of 30 comparisons\n * tested `=== POSTGRESQL` with an `else` arm that silently meant \"MongoDB\" — a third backing kind\n * would have taken the MongoDB lane at all of them with no compile error and no runtime refusal.\n */\nexport type PersistenceAdapterCases<T> = { readonly [K in PersistenceAdapter]: T };\n\n/**\n * Exhaustive discrimination on a persistence adapter.\n *\n * Prefer this over `adapter === PersistenceAdapter.X ? … : …` whenever BOTH arms carry a real\n * answer (dispatching to a database service, choosing a primary-key column, choosing a compiler).\n * A plain binary comparison stays correct only where one side is a genuinely adapter-specific\n * feature gate (\"does this resource need the PostgreSQL migration door?\") — there, the negative\n * arm means \"not that feature\", not \"the other adapter\", and such sites carry a justified comment\n * instead of this helper.\n *\n * Two guarantees, one per failure direction:\n * - **New enum member** → every call site's `cases` object misses a key → compile error\n *   (see {@link PersistenceAdapterCases}).\n * - **Unknown string at runtime** (erased config, a serialized value from an older or foreign\n *   writer) → throws instead of returning either arm. Thrown as a plain `Error` because this\n *   module is shared-tier (no `ErrorBuilder` here — same precedent as the factory's\n *   configuration errors); backend callers surface it through their ordinary error projection.\n *   It names the value and the supported set so the remedy is legible at the boundary it crossed.\n *\n * Branch values are eagerly evaluated; pass thunks (`() => …`) when construction is expensive or\n * side-effectful and invoke the selected one.\n */\nexport function selectByPersistenceAdapter<T>(\n  adapter: PersistenceAdapterType,\n  cases: PersistenceAdapterCases<T>,\n): T {\n  if (!Object.prototype.hasOwnProperty.call(cases, adapter)) {\n    throw new Error(\n      `Unknown persistence adapter '${String(adapter)}' reached an adapter decision. `\n      + `Supported adapters: ${Object.values(PersistenceAdapter).join(', ')}. `\n      + 'This is a framework configuration defect: a backing kind was declared or stored that this '\n      + 'deployment does not implement, and refusing here prevents it from being silently treated as one of the known adapters.',\n    );\n  }\n  return cases[adapter as PersistenceAdapter];\n}\n\n/**\n * Parse an adapter declaration arriving as a RAW string (an env var, a stored configuration\n * document, any erased boundary).\n *\n * - absent (`undefined` / `null`) or empty string (the compose-interpolation contract for\n *   \"not set\") → {@link DEFAULT_PERSISTENCE_ADAPTER}. An undeclared deployment keeps today's\n *   behavior exactly.\n * - a known member's value → that member.\n * - **present but unknown → throws.** This is the provisioning-door contract: a declaration that\n *   IS authored but names a backing kind this deployment does not know must refuse loudly, never\n *   collapse to MongoDB the way `x === POSTGRESQL ? POSTGRESQL : MONGODB` did — that collapse is\n *   how a platform would have provisioned a MongoDB database for a resource that has none.\n */\nexport function parseDeclaredPersistenceAdapter(\n  raw: string | undefined | null,\n): PersistenceAdapterType {\n  if (raw === undefined || raw === null || raw === '') {\n    return DEFAULT_PERSISTENCE_ADAPTER;\n  }\n  if (!isPersistenceAdapter(raw)) {\n    throw new Error(\n      `Unknown persistence adapter declaration '${raw}'. `\n      + `Supported adapters: ${Object.values(PersistenceAdapter).join(', ')}. `\n      + 'Remove the declaration to use the framework default, or declare a supported adapter.',\n    );\n  }\n  return raw;\n}\n"]}

package/dist/esm/resources/utils/repository-dto-builder.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"repository-dto-builder.utils.d.ts","sourceRoot":"","sources":["../../../../src/resources/utils/repository-dto-builder.utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB;;;;;;;;;;GAUG;AACH,qBAAa,yBAAyB;IAEpC;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,mBAAmB,CACxB,YAAY,EAAE,CAAC,CAAC,UAAU,EAC1B,UAAU,EAAE,CAAC,CAAC,UAAU,GACvB,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC;IAiD7B;;;;;;OAMG;IACH,MAAM,CAAC,0BAA0B,CAC/B,YAAY,EAAE,CAAC,CAAC,UAAU,EAC1B,UAAU,EAAE,CAAC,CAAC,UAAU,GACvB,MAAM,EAAE;IAyBX;;;;;;;OAOG;IACH,MAAM,CAAC,8BAA8B,CACnC,YAAY,EAAE,CAAC,CAAC,UAAU,EAC1B,UAAU,EAAE,CAAC,CAAC,UAAU,GACvB,OAAO;CAuBX"}
+{"version":3,"file":"repository-dto-builder.utils.d.ts","sourceRoot":"","sources":["../../../../../src/resources/utils/repository-dto-builder.utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB;;;;;;;;;;GAUG;AACH,qBAAa,yBAAyB;IAEpC;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,mBAAmB,CACxB,YAAY,EAAE,CAAC,CAAC,UAAU,EAC1B,UAAU,EAAE,CAAC,CAAC,UAAU,GACvB,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC;IAiD7B;;;;;;OAMG;IACH,MAAM,CAAC,0BAA0B,CAC/B,YAAY,EAAE,CAAC,CAAC,UAAU,EAC1B,UAAU,EAAE,CAAC,CAAC,UAAU,GACvB,MAAM,EAAE;IAyBX;;;;;;;OAOG;IACH,MAAM,CAAC,8BAA8B,CACnC,YAAY,EAAE,CAAC,CAAC,UAAU,EAC1B,UAAU,EAAE,CAAC,CAAC,UAAU,GACvB,OAAO;CAuBX"}

package/dist/esm/resources/utils/repository-dto-builder.utils.js

@@ -154,4 +154,4 @@ export class RepositoryDtoBuilderUtils {
         return false;
     }
 }
-//# sourceMappingURL=repository-dto-builder.utils.js.map
+//# sourceMappingURL=repository-dto-builder.utils.js.map

package/dist/esm/resources/utils/repository-dto-builder.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"repository-dto-builder.utils.js","sourceRoot":"","sources":["../../../../src/resources/utils/repository-dto-builder.utils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"repository-dto-builder.utils.js","sourceRoot":"","sources":["../../../../../src/resources/utils/repository-dto-builder.utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Repository DTO Builder Utilities\n * \n * Utilities for deriving repository-level DTOs from schemas.\n * Repository DTOs exclude virtual fields and populated placeholders,\n * while including fields needed for virtual field computation.\n * \n * Repository DTO Derivation Process:\n * \n * 1. Identify Virtual Fields:\n *    - Virtual fields are computed at runtime, not stored in DB\n *    - They are excluded from the repository DTO\n * \n * 2. Identify Virtual Dependencies:\n *    - Virtual fields may depend on other stored fields for computation\n *    - These dependencies must be included in the repository projection\n *    - Dependencies are declared via isVirtual({ dependencies: ['field1', 'field2'] })\n * \n * 3. Exclude Populated Placeholders:\n *    - Fields that exist only for population (not in mainSchema) are excluded\n *    - These are added after repository fetch during population phase\n * \n * 4. Final Repository DTO:\n *    - Contains: storable fields + virtual dependencies\n *    - Excludes: virtual fields + population placeholders\n *    - Used for MongoDB projection to minimize data transfer\n * \n * Example flow:\n *   mainSchema: { _id, title, assignedToUserId, displayName (virtual) }\n *   summarySchema: { _id, title, displayName, assignedTo (placeholder) }\n *   repositoryDto: { _id, title } + dependencies of displayName\n */\n\nimport { z } from 'zod';\nimport { \n  getZodObjectShape, \n  isVirtualField,\n  getVirtualFieldDependencies\n} from '@wildo-ai/zod-decorators';\n\n/**\n * Mutable shape type for building schemas\n */\ntype MutableZodShape = Record<string, z.ZodTypeAny>;\n\n/**\n * Utility class for deriving repository-level DTOs.\n * \n * Repository DTOs are used for MongoDB projections and represent\n * the actual fields to fetch from the database, excluding:\n * - Virtual fields (computed at runtime)\n * - Populated placeholders (fields not in mainSchema, added for population)\n * \n * And including:\n * - Virtual field dependencies (fields needed for virtual computation)\n */\nexport class RepositoryDtoBuilderUtils {\n  \n  /**\n   * Derive repositoryDto from a target schema.\n   * \n   * @param targetSchema - The schema to derive from (e.g., summary schema)\n   * @param mainSchema - The main resource schema (used to identify real vs placeholder fields)\n   * @returns A Zod schema containing only storable/fetchable fields\n   * \n   * @example\n   * ```typescript\n   * const summarySchema = ResourcesSummaryUtils.deriveSummarySchema(MainSchema);\n   * const repoDto = RepositoryDtoBuilderUtils.deriveRepositoryDto(summarySchema, MainSchema);\n   * // repoDto excludes virtuals but includes their dependencies\n   * ```\n   */\n  static deriveRepositoryDto(\n    targetSchema: z.ZodTypeAny,\n    mainSchema: z.ZodTypeAny\n  ): z.ZodObject<z.ZodRawShape> {\n    const targetShape = getZodObjectShape(targetSchema);\n    const mainShape = getZodObjectShape(mainSchema);\n    \n    if (!targetShape || !mainShape) {\n      // Return empty schema if either is not an object\n      return z.object({});\n    }\n    \n    const repoShape: MutableZodShape = {};\n    const virtualDeps = new Set<string>();\n    \n    // First pass: identify all virtual field dependencies\n    for (const [fieldName, fieldSchema] of Object.entries(targetShape)) {\n      if (isVirtualField(fieldSchema)) {\n        const deps = getVirtualFieldDependencies(fieldSchema);\n        for (const dep of deps) {\n          virtualDeps.add(dep);\n        }\n      }\n    }\n    \n    // Second pass: include non-virtual fields that exist in mainSchema\n    for (const [fieldName, fieldSchema] of Object.entries(targetShape)) {\n      // Skip virtual fields - they're computed, not stored\n      if (isVirtualField(fieldSchema)) {\n        continue;\n      }\n      \n      // Skip populated placeholders (fields that don't exist in main schema)\n      if (!mainShape[fieldName]) {\n        continue;\n      }\n      \n      // Include this field\n      repoShape[fieldName] = fieldSchema;\n    }\n    \n    // Third pass: add virtual field dependencies from mainSchema\n    // (Only if they're not already included and exist in mainSchema)\n    for (const dep of virtualDeps) {\n      if (mainShape[dep] && !repoShape[dep]) {\n        repoShape[dep] = mainShape[dep];\n      }\n    }\n    \n    return z.object(repoShape);\n  }\n  \n  /**\n   * Get all fields needed for virtual field computation.\n   * \n   * @param targetSchema - The schema containing virtual fields\n   * @param mainSchema - The main resource schema\n   * @returns Array of field names needed for virtual computation\n   */\n  static getVirtualDependencyFields(\n    targetSchema: z.ZodTypeAny,\n    mainSchema: z.ZodTypeAny\n  ): string[] {\n    const targetShape = getZodObjectShape(targetSchema);\n    const mainShape = getZodObjectShape(mainSchema);\n    \n    if (!targetShape || !mainShape) {\n      return [];\n    }\n    \n    const deps = new Set<string>();\n    \n    for (const [_fieldName, fieldSchema] of Object.entries(targetShape)) {\n      if (isVirtualField(fieldSchema)) {\n        const fieldDeps = getVirtualFieldDependencies(fieldSchema);\n        for (const dep of fieldDeps) {\n          // Only include if it exists in mainSchema\n          if (mainShape[dep]) {\n            deps.add(dep);\n          }\n        }\n      }\n    }\n    \n    return Array.from(deps);\n  }\n  \n  /**\n   * Check if a target schema has any virtual fields that require\n   * fields not already in the target schema.\n   * \n   * @param targetSchema - The schema to check\n   * @param mainSchema - The main resource schema\n   * @returns True if additional fields are needed for virtual computation\n   */\n  static hasExternalVirtualDependencies(\n    targetSchema: z.ZodTypeAny,\n    mainSchema: z.ZodTypeAny\n  ): boolean {\n    const targetShape = getZodObjectShape(targetSchema);\n    const mainShape = getZodObjectShape(mainSchema);\n    \n    if (!targetShape || !mainShape) {\n      return false;\n    }\n    \n    for (const [_fieldName, fieldSchema] of Object.entries(targetShape)) {\n      if (isVirtualField(fieldSchema)) {\n        const deps = getVirtualFieldDependencies(fieldSchema);\n        for (const dep of deps) {\n          // If a dependency exists in mainSchema but not in targetShape,\n          // we have external dependencies\n          if (mainShape[dep] && !targetShape[dep]) {\n            return true;\n          }\n        }\n      }\n    }\n    \n    return false;\n  }\n}\n"]}

package/dist/esm/resources/utils/required-fk-fillability.validation.d.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+import { ResourceRelationship } from '../resources.shared.schemas';
+import { ResourceType } from '../resources.shared.core.definitions';
+/**
+ * Registry-level guardrail: a REQUIRED composition-parent foreign key must be
+ * **user-fillable on CREATE**.
+ *
+ * ## Why this exists
+ *
+ * A resource whose structural (COMPOSITION) parent relationship is
+ * `OPTIONAL_CONTEXT` (or `STANDALONE`) can be created WITHOUT that parent in the
+ * URL — e.g. a todo created from the org-wide collection rather than from inside
+ * a specific list. In that mode the parent FK is NOT seeded from routing context,
+ * so the create form must let the user supply it through a resource-reference
+ * picker. If the FK is also REQUIRED, the create is impossible unless that picker
+ * can actually be rendered and populated. Two ways it silently can't:
+ *
+ * - the FK field is `excludeFromCreate` → there is no form control at all; or
+ * - the FK's target resource exposes no `LIST`/`SEARCH` operation → the picker
+ *   has no operation to load its options from.
+ *
+ * Either way the org-wide create form is dead on arrival. This validator surfaces
+ * that at registry-assembly time instead of as a confusing client-side validation
+ * failure with no visible error (the exact symptom of the 2026-06-27
+ * `todoListId`-create bug — see `selectMatchingRoutePath` routing fix and
+ * `.claude/plans/todos-required-fk-optional-context-create.md`).
+ *
+ * ## Why it is restricted to `COMPOSITION` parents
+ *
+ * `REFERENCE` foreign keys (`assignedToUserId`, `createdByUserId`,
+ * `postedByUserId`, …) are NOT user-picked structural parents — they are
+ * cross-references that are typically seeded by the backend (author/creator) or
+ * are optional. The framework has no schema-level "user fills this vs the backend
+ * sets this" marker, so including REFERENCE FKs here would false-positive on
+ * backend-set required FKs. Limiting to `COMPOSITION` isolates the genuine
+ * "a child belongs to a parent the user must choose" case.
+ *
+ * ## Fail-open by construction
+ *
+ * Every ambiguity skips the relationship rather than flagging it: a missing
+ * `foreignKeyField`, an FK column that is not actually present on the resource's
+ * own schema (e.g. an inbound FK reference where another resource holds the key),
+ * an FK whose requiredness cannot be determined, or an unknown target resource.
+ * This keeps the guardrail noise-free and safe to run across every app registry.
+ */
+export declare enum ForeignKeyFillabilityViolationKind {
+    /** The required FK is `excludeFromCreate` yet the parent is not guaranteed in context — no way to supply it. */
+    EXCLUDED_FROM_CREATE = "required-composition-fk-excluded-from-create",
+    /** The required FK needs a picker (parent is `OPTIONAL_CONTEXT`/`STANDALONE`) but its target exposes no LIST/SEARCH op to populate one. */
+    TARGET_NOT_SEARCHABLE = "required-composition-fk-target-not-searchable"
+}
+/**
+ * Severity a consumer should apply to a violation. `EXCLUDED_FROM_CREATE` is a
+ * genuinely impossible-to-create config (no context, no control) → `FAIL` so the
+ * backend crashes loud at boot rather than shipping a dead create form.
+ * `TARGET_NOT_SEARCHABLE` degrades the picker but a custom create surface might
+ * still supply the FK → `WARN`.
+ */
+export declare enum ForeignKeyFillabilityViolationSeverity {
+    FAIL = "fail",
+    WARN = "warn"
+}
+export interface ForeignKeyFillabilityViolation {
+    kind: ForeignKeyFillabilityViolationKind;
+    severity: ForeignKeyFillabilityViolationSeverity;
+    /** The child resource that declares the required FK. */
+    resourceType: ResourceType;
+    /** The FK field on `resourceType` (e.g. `todoListId`). */
+    foreignKeyField: string;
+    /** The FK target / structural parent (e.g. `todoLists`). */
+    parentResourceType: ResourceType;
+    message: string;
+}
+/**
+ * Structural subset of a resource configuration this validator needs. The real
+ * `ResourceConfiguration` (and its frontend/backend variants) satisfy this shape,
+ * so callers can pass `registry.resourceConfigurations` directly.
+ */
+export interface ForeignKeyFillabilityResourceInput {
+    resourceIdentifier: ResourceType;
+    mainSchema: z.ZodTypeAny;
+    resourceRelationships: {
+        parentRelationships: ResourceRelationship[];
+    };
+    operations: ReadonlyArray<{
+        operationIdentifier: string | number;
+        resourceOperationLike?: string | number;
+    }>;
+}
+/**
+ * Resolve a field schema by name from a resource's `mainSchema`, transparently
+ * handling discriminated-union (polymorphic / schema-family) resources where a
+ * plain `getObjectShape` returns `null`. The FK lives in the family's common
+ * base, so it is present on every variant — the first variant that carries it
+ * wins. Returns `undefined` when the field is genuinely absent (fail-open).
+ */
+export declare function findForeignKeyFieldSchema(mainSchema: z.ZodTypeAny, foreignKeyField: string): z.ZodTypeAny | undefined;
+/**
+ * Validate that every required COMPOSITION-parent foreign key in the registry is
+ * user-fillable on CREATE. Returns the list of violations (empty when clean);
+ * the caller decides how to surface them (warn vs fail). Pure and side-effect
+ * free.
+ *
+ * @param resourceConfigurations - the registry's `resourceConfigurations` map
+ *   (`resourceType → configuration`).
+ */
+export declare function validateRequiredForeignKeyFillability(resourceConfigurations: Record<string, ForeignKeyFillabilityResourceInput>): ForeignKeyFillabilityViolation[];
+//# sourceMappingURL=required-fk-fillability.validation.d.ts.map

package/dist/esm/resources/utils/required-fk-fillability.validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-fk-fillability.validation.d.ts","sourceRoot":"","sources":["../../../../../src/resources/utils/required-fk-fillability.validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,OAAO,EACL,oBAAoB,EAGrB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,YAAY,EAAyB,MAAM,sCAAsC,CAAC;AAE3F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,oBAAY,kCAAkC;IAC5C,gHAAgH;IAChH,oBAAoB,iDAAiD;IACrE,2IAA2I;IAC3I,qBAAqB,kDAAkD;CACxE;AAED;;;;;;GAMG;AACH,oBAAY,sCAAsC;IAChD,IAAI,SAAS;IACb,IAAI,SAAS;CACd;AAOD,MAAM,WAAW,8BAA8B;IAC7C,IAAI,EAAE,kCAAkC,CAAC;IACzC,QAAQ,EAAE,sCAAsC,CAAC;IACjD,wDAAwD;IACxD,YAAY,EAAE,YAAY,CAAC;IAC3B,0DAA0D;IAC1D,eAAe,EAAE,MAAM,CAAC;IACxB,4DAA4D;IAC5D,kBAAkB,EAAE,YAAY,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,WAAW,kCAAkC;IACjD,kBAAkB,EAAE,YAAY,CAAC;IACjC,UAAU,EAAE,CAAC,CAAC,UAAU,CAAC;IACzB,qBAAqB,EAAE;QACrB,mBAAmB,EAAE,oBAAoB,EAAE,CAAC;KAC7C,CAAC;IACF,UAAU,EAAE,aAAa,CAAC;QACxB,mBAAmB,EAAE,MAAM,GAAG,MAAM,CAAC;QACrC,qBAAqB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACzC,CAAC,CAAC;CACJ;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,CAAC,CAAC,UAAU,EACxB,eAAe,EAAE,MAAM,GACtB,CAAC,CAAC,UAAU,GAAG,SAAS,CAoB1B;AAeD;;;;;;;;GAQG;AACH,wBAAgB,qCAAqC,CACnD,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,kCAAkC,CAAC,GACzE,8BAA8B,EAAE,CAiFlC"}