@wildo-ai/platform-core-shared 1.1.1 → 1.1.2

package/dist/esm/workbench/workbench-aspect-resources.custom.shared.schemas.js

@@ -0,0 +1,578 @@
+import { CoreResourceOperation, CoreResourceType, IntrospectionTenancyStance, PersistenceAdapter, RelationshipNature, ResourceParentResourceRequirement, ResourceRelationshipAccessScopeStrategy, ResourceRelationshipCardinality, createResourceConfiguration_Initialization, createResourcesRelationship, } from '@wildo-ai/saas-models';
+import { z } from 'zod';
+import { initZodDecorators } from '@wildo-ai/zod-decorators';
+// Decorator methods must exist before the module-load-time envelope builds below.
+initZodDecorators();
+import { WorkbenchShared_ResourceFieldIdentifier, WorkbenchShared_ResourceType, } from './workbench-resources-types.custom.shared.schemas.js';
+import { createReadOnlyApiVariant, createReadOnlyListApiVariant, } from './workbench-resources.custom.shared.resources-config.schemas.js';
+/**
+ * FAMILY ASPECT RESOURCES — the spine's schema-agnostic transcription of
+ * `FAMILY_ASPECTS_REGISTRY` (`@wildo-ai/saas-specifications`, `_core/family-aspects.*`).
+ *
+ * ## The split, restated where it is enforced
+ *
+ * The registry is AUTHORITATIVE: item schemas, business keys, edges, all declared beside the
+ * `_core` family schemas (decided 2026-09-01). The spine cannot import it — platform-core-shared
+ * deliberately never depends on saas-specifications — so this module carries plain DATA: which
+ * aspects exist, which envelope fields carry references, and which resource each reference
+ * resolves to. A companion-side parity test holds this table to the registry; drift between the
+ * two is a failing test, never a silent divergence.
+ *
+ * ## The envelope
+ *
+ * Aspect rows share ONE envelope shape (identity, family backlink, headline, the full item as a
+ * raw record) plus the aspect's own FLATTENED reference fields. Flattening is the projection's
+ * job and is what makes every edge a PLAIN foreign key the engine already resolves:
+ *
+ * - weighted edge objects flatten to key arrays (`jobs[].jobRef` → `jobIds`),
+ * - multi-target fields split per target (`deliversRequirementRefs` →
+ *   `deliversFunctionalRequirementIds` + `deliversNonFunctionalRequirementIds`), because the
+ *   frontend resolves an FK field name to ONE resource — a mixed-kind array has no honest single
+ *   answer, and split fields read better anyway,
+ * - every field name below maps to exactly one target across ALL aspects (collision-audited at
+ *   generation; the parity test re-checks it).
+ *
+ * The `family` field is the artifact BACKLINK for free: it is the specification-artifacts
+ * resource's own field identifier, so the global field-identifier map already resolves it.
+ */
+/**
+ * How an aspect row gets its identity — mirrors the registry's `businessKey` contract.
+ *
+ * The three are not interchangeable and the fallback order between them is the point: a collection
+ * whose schema declares a single-field key is addressed by it, a singleton has one row per family so
+ * the aspect key IS the identity, and a keyless collection falls back to a positional address that is
+ * stable per landed snapshot and honest about carrying no business meaning.
+ */
+export var WorkbenchAspectIdentityKind;
+(function (WorkbenchAspectIdentityKind) {
+    /** The item's own business key (`ref`, `taskRef`, …), unique within the aspect. */
+    WorkbenchAspectIdentityKind["BUSINESS_KEY"] = "business-key";
+    /** One row per family — identity is the aspect key itself. */
+    WorkbenchAspectIdentityKind["SINGLETON"] = "singleton";
+    /** Keyless collection (locale × jurisdictions): `<aspectKey>[<index>]`, stable per snapshot. */
+    WorkbenchAspectIdentityKind["INDEXED"] = "indexed";
+})(WorkbenchAspectIdentityKind || (WorkbenchAspectIdentityKind = {}));
+export const WORKBENCH_ASPECT_DESCRIPTORS = [
+    {
+        aspectKey: 'vision.idea',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_VISION_IDEA,
+        rowsPath: 'visionIdeas',
+        identity: WorkbenchAspectIdentityKind.SINGLETON,
+        edges: [],
+    },
+    {
+        aspectKey: 'vision.problem',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_VISION_PROBLEM,
+        rowsPath: 'visionProblems',
+        identity: WorkbenchAspectIdentityKind.SINGLETON,
+        edges: [],
+    },
+    {
+        aspectKey: 'vision.mission',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_VISION_MISSION,
+        rowsPath: 'visionMissions',
+        identity: WorkbenchAspectIdentityKind.SINGLETON,
+        edges: [],
+    },
+    {
+        aspectKey: 'vision.success-criterion',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_VISION_SUCCESS_CRITERION,
+        rowsPath: 'visionSuccessCriteria',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'vision.constraint',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_VISION_CONSTRAINT,
+        rowsPath: 'visionConstraints',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'market.category',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_CATEGORY,
+        rowsPath: 'marketCategories',
+        identity: WorkbenchAspectIdentityKind.SINGLETON,
+        edges: [],
+    },
+    {
+        aspectKey: 'market.icp',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_ICP,
+        rowsPath: 'marketIcps',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'personaIds', targetAspectKey: 'market.persona', many: true },
+            { field: 'jobIds', targetAspectKey: 'market.job', many: true },
+            { field: 'painIds', targetAspectKey: 'market.pain', many: true },
+            { field: 'gainIds', targetAspectKey: 'market.gain', many: true },
+            { field: 'channelIds', targetAspectKey: 'market.channel', many: true },
+            { field: 'triggerIds', targetAspectKey: 'market.trigger', many: true },
+            { field: 'alternativeIds', targetAspectKey: 'market.alternative', many: true },
+            { field: 'proofIds', targetAspectKey: 'market.proof', many: true },
+            { field: 'objectionIds', targetAspectKey: 'market.objection', many: true },
+            { field: 'preferredVoiceId', targetAspectKey: 'market.tone-of-voice', many: false },
+        ],
+    },
+    {
+        aspectKey: 'market.persona',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_PERSONA,
+        rowsPath: 'marketPersonas',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'belongsToIcpIds', targetAspectKey: 'market.icp', many: true },
+            { field: 'jobIds', targetAspectKey: 'market.job', many: true },
+            { field: 'painIds', targetAspectKey: 'market.pain', many: true },
+            { field: 'gainIds', targetAspectKey: 'market.gain', many: true },
+            { field: 'channelIds', targetAspectKey: 'market.channel', many: true },
+            { field: 'preferredVoiceId', targetAspectKey: 'market.tone-of-voice', many: false },
+        ],
+    },
+    {
+        aspectKey: 'market.job',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_JOB,
+        rowsPath: 'marketJobs',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'market.pain',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_PAIN,
+        rowsPath: 'marketPains',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'market.gain',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_GAIN,
+        rowsPath: 'marketGains',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'market.tone-of-voice',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_TONE_OF_VOICE,
+        rowsPath: 'marketTonesOfVoice',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'market.benefit',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_BENEFIT,
+        rowsPath: 'marketBenefits',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'deliveredByFeatureIds', targetAspectKey: 'feature-drafts.draft', many: true },
+            { field: 'painIds', targetAspectKey: 'market.pain', many: true },
+            { field: 'gainIds', targetAspectKey: 'market.gain', many: true },
+            { field: 'jobIds', targetAspectKey: 'market.job', many: true },
+            { field: 'icpIds', targetAspectKey: 'market.icp', many: true },
+            { field: 'proofIds', targetAspectKey: 'market.proof', many: true },
+            { field: 'addressesObjectionIds', targetAspectKey: 'market.objection', many: true },
+        ],
+    },
+    {
+        aspectKey: 'market.positioning',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_POSITIONING,
+        rowsPath: 'marketPositionings',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'icpId', targetAspectKey: 'market.icp', many: false },
+            { field: 'preferredVoiceId', targetAspectKey: 'market.tone-of-voice', many: false },
+            { field: 'benefitIds', targetAspectKey: 'market.benefit', many: true },
+            { field: 'alternativeIds', targetAspectKey: 'market.alternative', many: true },
+        ],
+    },
+    {
+        aspectKey: 'market.channel',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_CHANNEL,
+        rowsPath: 'marketChannels',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'market.alternative',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_ALTERNATIVE,
+        rowsPath: 'marketAlternatives',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'market.trigger',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_TRIGGER,
+        rowsPath: 'marketTriggers',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'affectedIcpIds', targetAspectKey: 'market.icp', many: true },
+            { field: 'recommendedChannelIds', targetAspectKey: 'market.channel', many: true },
+        ],
+    },
+    {
+        aspectKey: 'market.buying-journey',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_BUYING_JOURNEY,
+        rowsPath: 'marketBuyingJourneys',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'icpId', targetAspectKey: 'market.icp', many: false },
+        ],
+    },
+    {
+        aspectKey: 'market.proof',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_PROOF,
+        rowsPath: 'marketProofs',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'supportsBenefitIds', targetAspectKey: 'market.benefit', many: true },
+            { field: 'supportsIcpIds', targetAspectKey: 'market.icp', many: true },
+        ],
+    },
+    {
+        aspectKey: 'market.objection',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_OBJECTION,
+        rowsPath: 'marketObjections',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'raisedByIcpIds', targetAspectKey: 'market.icp', many: true },
+            { field: 'raisedByPersonaIds', targetAspectKey: 'market.persona', many: true },
+            { field: 'proofIds', targetAspectKey: 'market.proof', many: true },
+            { field: 'relatedBenefitIds', targetAspectKey: 'market.benefit', many: true },
+        ],
+    },
+    {
+        aspectKey: 'market.message-template',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_MARKET_MESSAGE_TEMPLATE,
+        rowsPath: 'marketMessageTemplates',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'preferredVoiceId', targetAspectKey: 'market.tone-of-voice', many: false },
+        ],
+    },
+    {
+        aspectKey: 'requirements.functional',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_REQUIREMENT_FUNCTIONAL,
+        rowsPath: 'functionalRequirements',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'icpIds', targetAspectKey: 'market.icp', many: true },
+            { field: 'jobIds', targetAspectKey: 'market.job', many: true },
+        ],
+    },
+    {
+        aspectKey: 'requirements.non-functional',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_REQUIREMENT_NON_FUNCTIONAL,
+        rowsPath: 'nonFunctionalRequirements',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'icpIds', targetAspectKey: 'market.icp', many: true },
+            { field: 'jobIds', targetAspectKey: 'market.job', many: true },
+        ],
+    },
+    {
+        aspectKey: 'feature-drafts.draft',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_FEATURE_DRAFT,
+        rowsPath: 'featureDrafts',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'roadmap.phase',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_ROADMAP_PHASE,
+        rowsPath: 'roadmapPhases',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'deliversFunctionalRequirementIds', targetAspectKey: 'requirements.functional', many: true },
+            { field: 'deliversNonFunctionalRequirementIds', targetAspectKey: 'requirements.non-functional', many: true },
+            { field: 'deliversSuccessCriterionIds', targetAspectKey: 'vision.success-criterion', many: true },
+        ],
+    },
+    {
+        aspectKey: 'business-model.plan',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_PRICING_PLAN,
+        rowsPath: 'pricingPlans',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'targetIcpIds', targetAspectKey: 'market.icp', many: true },
+            { field: 'includesFunctionalRequirementIds', targetAspectKey: 'requirements.functional', many: true },
+            { field: 'includesNonFunctionalRequirementIds', targetAspectKey: 'requirements.non-functional', many: true },
+        ],
+    },
+    {
+        aspectKey: 'brand.name',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_BRAND_NAME,
+        rowsPath: 'brandNames',
+        identity: WorkbenchAspectIdentityKind.SINGLETON,
+        edges: [],
+    },
+    {
+        aspectKey: 'brand.logo-direction',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_BRAND_LOGO_DIRECTION,
+        rowsPath: 'brandLogoDirections',
+        identity: WorkbenchAspectIdentityKind.SINGLETON,
+        edges: [],
+    },
+    {
+        aspectKey: 'brand.visual-tone',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_BRAND_VISUAL_TONE,
+        rowsPath: 'brandVisualTones',
+        identity: WorkbenchAspectIdentityKind.SINGLETON,
+        edges: [],
+    },
+    {
+        aspectKey: 'brand.asset',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_BRAND_ASSET,
+        rowsPath: 'brandAssets',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'derivedFromId', targetAspectKey: 'brand.asset', many: false },
+        ],
+    },
+    {
+        aspectKey: 'domain-plan.module',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_DOMAIN_PLAN_MODULE,
+        rowsPath: 'domainPlanModules',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'domain-plan.relationship',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_DOMAIN_PLAN_RELATIONSHIP,
+        rowsPath: 'domainPlanRelationships',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'build-plan.task',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_BUILD_TASK,
+        rowsPath: 'buildTasks',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'prerequisiteTaskIds', targetAspectKey: 'build-plan.task', many: true },
+            { field: 'servesFunctionalRequirementIds', targetAspectKey: 'requirements.functional', many: true },
+            { field: 'servesNonFunctionalRequirementIds', targetAspectKey: 'requirements.non-functional', many: true },
+            { field: 'servesRoadmapPhaseIds', targetAspectKey: 'roadmap.phase', many: true },
+        ],
+    },
+    {
+        aspectKey: 'placement.group',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_PLACEMENT_GROUP,
+        rowsPath: 'placementGroups',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'placement.decision',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_PLACEMENT_DECISION,
+        rowsPath: 'placementDecisions',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [
+            { field: 'groupId', targetAspectKey: 'placement.group', many: false },
+        ],
+    },
+    {
+        aspectKey: 'compliance-candidate.section',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_CANDIDATE_SECTION,
+        rowsPath: 'complianceCandidateSections',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'compliance-candidate.variant-selection',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_COMPLIANCE_CANDIDATE_VARIANT_SELECTION,
+        rowsPath: 'complianceCandidateVariantSelections',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'document-facts.declaration',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_DOCUMENT_FACT_DECLARATION,
+        rowsPath: 'documentFactDeclarations',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    /*
+     * The same row shape as the descriptor above and a SEPARATE resource, because the two families it
+     * transcribes are separate (#192): one is regenerated by a producer, the other is only ever written
+     * by a person. Merging them into one browsable list would erase exactly the provenance the split
+     * exists to keep, and a reader could no longer tell which declarations survive the next producer run.
+     */
+    {
+        aspectKey: 'document-facts-authored.declaration',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_AUTHORED_DOCUMENT_FACT_DECLARATION,
+        rowsPath: 'authoredDocumentFactDeclarations',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        /*
+         * INDEXED, not BUSINESS_KEY, and that is the registry's own answer rather than a simplification
+         * here: the row is a union whose two arms key on different fields (`providerRef` vs
+         * `subprocessorRef`), so no single field identifies a row across it.
+         */
+        aspectKey: 'processor-register.processor',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_PROCESSOR_REGISTER_ENTRY,
+        rowsPath: 'processorRegisterEntries',
+        identity: WorkbenchAspectIdentityKind.INDEXED,
+        edges: [],
+    },
+    {
+        aspectKey: 'release-policy.selection',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_RELEASE_POLICY_SELECTION,
+        rowsPath: 'releasePolicySelections',
+        identity: WorkbenchAspectIdentityKind.BUSINESS_KEY,
+        edges: [],
+    },
+    {
+        aspectKey: 'document-publication.variant',
+        resourceType: WorkbenchShared_ResourceType.ASPECT_DOCUMENT_PUBLICATION_VARIANT,
+        rowsPath: 'documentPublicationVariants',
+        identity: WorkbenchAspectIdentityKind.INDEXED,
+        edges: [],
+    },
+];
+const DESCRIPTOR_BY_ASPECT_KEY = new Map(WORKBENCH_ASPECT_DESCRIPTORS.map((descriptor) => [descriptor.aspectKey, descriptor]));
+export function getWorkbenchAspectDescriptor(aspectKey) {
+    return DESCRIPTOR_BY_ASPECT_KEY.get(aspectKey);
+}
+/**
+ * The shared envelope, instantiated per aspect with its identity field and reference fields.
+ *
+ * `content` stays a RAW record for the same reason the artifact resource's does: the spine never
+ * sees the item schemas; the workbench frontend renders `content` through the REAL `_core` schema
+ * from the registry, so typed rendering happens where the type authority is a dependency.
+ */
+export function buildWorkbenchAspectEnvelopeSchema(descriptor) {
+    const identityField = WorkbenchShared_ResourceFieldIdentifier[descriptor.resourceType];
+    const shape = {
+        /**
+         * The composed address the projection emits, and the ONLY field a row click can resolve by.
+         *
+         * `.isSummaryField()` is not decoration here. A list renders SUMMARIES, and the frontend resolves
+         * a clicked row's target by reading this field off the item — so an id that does not survive the
+         * projection makes every row in every aspect list silently stop responding to a click, while READ
+         * still answers 200 (the adapter filters by `identityFields`, not by this name). The only symptom
+         * is one console line. Pinned for the whole population by the addressing-field contract test.
+         */
+        [identityField]: z.string().min(1).isPrimaryKey().isSummaryField(),
+        /**
+         * The owning artifact family id — a LIVE reference: `family` is the artifacts resource's own
+         * field identifier, so the global map resolves it, and the artifacts READ is addressable —
+         * the one link out of any popup back to the document the aspect lives in.
+         */
+        family: z.string().isForeignKey().isSummaryField(),
+        /** The registry aspect key (`market.icp`) — which KIND of aspect this row is. */
+        aspectKey: z.string().isSummaryField(),
+        /** The item's headline value (the registry's `headlineField`), projected for lists/summaries. */
+        title: z.string().isSummaryField(),
+        /**
+         * The full item as landed — rendered frontend-side through the family's own `_core` schema.
+         *
+         * Deliberately NOT a summary field: it is the whole item, and carrying it in every list row is
+         * what the summary projection exists to avoid.
+         */
+        content: z.record(z.string(), z.unknown()),
+    };
+    for (const edge of descriptor.edges) {
+        // FK marking rides the ELEMENT for arrays (the decorator's home is the string type); the
+        // display pipeline accepts `string | string[]` values on a reference field either way.
+        shape[edge.field] = edge.many
+            ? z.array(z.string().isForeignKey())
+            : z.string().isForeignKey().optional();
+    }
+    return z.object(shape);
+}
+/**
+ * One introspection resource-configuration factory per aspect, all from the same mold as their
+ * two siblings: READ/LIST only, `APPLICATION_STRUCTURE` tenancy, rows served by the companion's
+ * family-aspects behavior at this aspect's `rowsPath`. Identity is always the COMPOSED field the
+ * projection emits (see the identifier-map note in the types module).
+ */
+export function buildWorkbenchAspectConfigurationFactory(descriptor) {
+    const envelopeSchema = buildWorkbenchAspectEnvelopeSchema(descriptor);
+    return (resourcesRelationships) => createResourceConfiguration_Initialization({
+        mainSchema: envelopeSchema,
+        resourceIdentifier: descriptor.resourceType,
+        resourceFieldIdentifier: WorkbenchShared_ResourceFieldIdentifier[descriptor.resourceType],
+        resourceRelationships: resourcesRelationships,
+        isSystemResource: false,
+        persistenceAdapter: PersistenceAdapter.INTROSPECTION,
+        introspectionBinding: {
+            behavior: 'family-aspects',
+            rowsPath: descriptor.rowsPath,
+            tenancy: IntrospectionTenancyStance.APPLICATION_STRUCTURE,
+        },
+        coreOperations: [CoreResourceOperation.READ, CoreResourceOperation.LIST],
+        customOperation: undefined,
+        operationsConfiguration: {
+            [CoreResourceOperation.READ]: { variants: [createReadOnlyApiVariant()] },
+            [CoreResourceOperation.LIST]: {
+                variants: [{
+                        ...createReadOnlyListApiVariant(),
+                        /* The two slices every aspect list needs: which family, which kind. */
+                        filterFields: {
+                            family: z.string(),
+                            aspectKey: z.string(),
+                        },
+                    }],
+            },
+        },
+    });
+}
+/**
+ * Every aspect's relationships:
+ *
+ * - the STANDALONE application anchor each INTROSPECTION resource needs (primary scope derives
+ *   from it; STANDALONE keeps the route flat — the established pattern of its two siblings), and
+ * - one REFERENCE relationship per edge, carrying `foreignKeyField`: that is what teaches the
+ *   frontend's field-identifier map to resolve the envelope field to its target resource, which
+ *   is the entire navigation story (labels, popups, links) with no bespoke lookup anywhere.
+ */
+export function buildWorkbenchAspectRelationships() {
+    const relationships = [];
+    for (const descriptor of WORKBENCH_ASPECT_DESCRIPTORS) {
+        relationships.push(createResourcesRelationship(CoreResourceType.APPLICATION, descriptor.resourceType, ResourceRelationshipCardinality.ONE, ResourceRelationshipCardinality.MANY, {
+            nature: RelationshipNature.COMPOSITION,
+            isPrimaryScope: true,
+            accessScopeStrategy: ResourceRelationshipAccessScopeStrategy.STANDALONE,
+            contextPolicy: {},
+        }));
+        for (const edge of descriptor.edges) {
+            const target = DESCRIPTOR_BY_ASPECT_KEY.get(edge.targetAspectKey);
+            if (!target) {
+                throw new Error(`workbench aspect ${descriptor.aspectKey}: edge ${edge.field} targets unknown aspect ${edge.targetAspectKey}`);
+            }
+            relationships.push(createResourcesRelationship(target.resourceType, descriptor.resourceType, ResourceRelationshipCardinality.ONE, edge.many ? ResourceRelationshipCardinality.MANY : ResourceRelationshipCardinality.ONE, {
+                nature: RelationshipNature.REFERENCE,
+                foreignKeyField: edge.field,
+                contextPolicy: {},
+                /*
+                 * STANDALONE here too, not only on the application anchor: a relationship without it
+                 * makes the router mount the holder NESTED under its target and drop the flat route —
+                 * measured on this very sweep (every edge-carrying aspect 404'd flat while its
+                 * edge-free siblings answered 200). A reference edge is navigation metadata, never a
+                 * URL parent.
+                 */
+                accessScopeStrategy: ResourceRelationshipAccessScopeStrategy.STANDALONE,
+                /*
+                 * The aspect graph is CYCLIC by nature — an ICP names its triggers and a trigger names
+                 * the ICPs it affects; a task prerequisites tasks; an asset derives from an asset. These
+                 * are REFERENCES in a knowledge graph, not a containment tree, so every edge declares
+                 * the cycle admissible rather than pretending the graph is a DAG.
+                 */
+                allowCycle: true,
+                /*
+                 * The two self-edges (a task's prerequisites, an asset's derivation source) are graphs
+                 * with roots — a MASTER asset derives from nothing — and the factory refuses a
+                 * self-reference whose parent is mandatory for exactly that reason. Harmless on the
+                 * non-self edges: every aspect reference is optional by nature (dangling-tolerant).
+                 */
+                parentResourceRequirement: ResourceParentResourceRequirement.OPTIONAL,
+            }));
+        }
+    }
+    return relationships;
+}
+/** The factory-map slice for all aspect resources — merged into the workbench map by its owner. */
+export const workbenchAspectResources_ConfigurationsFactoryMap = Object.fromEntries(WORKBENCH_ASPECT_DESCRIPTORS.map((descriptor) => [
+    descriptor.resourceType,
+    buildWorkbenchAspectConfigurationFactory(descriptor),
+]));
+//# sourceMappingURL=workbench-aspect-resources.custom.shared.schemas.js.map