@hyperscale0/udl 2.3.0 → 2.4.0

package/dist/schema.js

@@ -1,3 +1,4 @@
+import { referencePatternPrefix } from "./reference.js";
 import { z } from "zod";
 import { udlCheckEvidenceProfiles } from "./check-profiles.js";
 export const udlEffectKinds = [
@@ -17,6 +18,9 @@ const eventNamePattern = /^[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)+$/;
 const udlSnakeCaseSchema = z
     .string()
     .regex(snakeCasePattern, "must be a snake_case identifier");
+const udlInstrumentIdSchema = udlSnakeCaseSchema.meta({
+    "x-udl-reference": "instrument",
+});
 const udlActionNameSchema = z
     .string()
     .regex(snakeCasePattern, "must be a snake_case action identifier");
@@ -30,10 +34,6 @@ export const udlInstrumentActionIdSchema = z
     .string()
     .max(160)
     .regex(/^[a-z][a-z0-9_]*\.[a-z][a-z0-9_]*$/, "must name an instrument action as instrument_id.action_key");
-const udlJourneyOperationNameSchema = z
-    .string()
-    .max(160)
-    .regex(/^[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)+$/, "must name a dotted operation");
 const nonEmptyTextSchema = z
     .string()
     .refine((value) => value.trim().length > 0, "must not be blank");
@@ -85,18 +85,6 @@ const udlExampleSchema = z.strictObject({
     name: nonEmptyTextSchema,
     output: z.json().optional(),
 });
-const udlJourneyStepSchema = z.strictObject({
-    bind: z.record(fieldPathSchema, udlSnakeCaseSchema),
-    example: udlSnakeCaseSchema,
-    id: udlSnakeCaseSchema.optional(),
-    operation: udlJourneyOperationNameSchema,
-});
-export const udlJourneySchema = z.strictObject({
-    id: udlSnakeCaseSchema,
-    label: nonEmptyTextSchema,
-    steps: z.array(udlJourneyStepSchema).min(1),
-    summary: nonEmptyTextSchema,
-});
 const udlLifecycleTransitionSchema = z.strictObject({
     from: z.array(udlSnakeCaseSchema).min(1),
     to: udlSnakeCaseSchema,
@@ -117,10 +105,26 @@ const udlDateComparisonSchema = z.strictObject({
     operator: udlDateComparisonOperatorSchema,
     referencedPath: fieldPathSchema,
 });
+const udlStoredFieldSchema = z.strictObject({ field: udlFieldNameSchema });
+const udlOffsetSchema = z.union([nonEmptyTextSchema, udlStoredFieldSchema]);
+const udlAttestationSchema = z.strictObject({
+    forAction: udlActionNameSchema.optional(),
+    action: instanceValuePathSchema,
+    digest: instanceValuePathSchema,
+    role: instanceValuePathSchema,
+    expiresAt: instanceValuePathSchema,
+    instrument: instanceValuePathSchema,
+    party: z.string().regex(/^[a-z][A-Za-z0-9_]*$/),
+    consume: udlActionNameSchema,
+});
 const udlGateSchema = z.strictObject({
+    attests: udlAttestationSchema.optional(),
     /** Local field key <- referenced instance path; create actions only. */
     bind: z.record(udlFieldNameSchema, fieldPathSchema).optional(),
     dateComparison: udlDateComparisonSchema.optional(),
+    dueBefore: z
+        .strictObject({ field: udlFieldNameSchema, offset: nonEmptyTextSchema })
+        .optional(),
     field: udlFieldNameSchema,
     /** Local instance path === referenced instance path at admission. */
     match: z.record(fieldPathSchema, fieldPathSchema).optional(),
@@ -128,7 +132,15 @@ const udlGateSchema = z.strictObject({
     optional: z.literal(true).optional(),
     statuses: z.array(udlSnakeCaseSchema).min(1),
     /** One dependent ever per referenced instance; create actions only. */
-    unique: z.literal(true).optional(),
+    unique: z
+        .union([
+        z.literal(true),
+        z.strictObject({
+            namespace: udlSnakeCaseSchema,
+            byFields: z.array(udlFieldNameSchema).min(1).max(8),
+        }),
+    ])
+        .optional(),
 });
 const udlBindingSchema = z.discriminatedUnion("from", [
     z.strictObject({ from: z.literal("const"), value: z.string() }),
@@ -178,19 +190,19 @@ const udlDueRecurrenceSchema = z.strictObject({
     untilField: udlFieldNameSchema.optional(),
 });
 const udlDueParentStatusSchema = z.strictObject({
-    instrumentId: udlSnakeCaseSchema,
+    instrumentId: udlInstrumentIdSchema,
     refField: udlFieldNameSchema,
     statuses: z.array(udlSnakeCaseSchema).min(1),
 });
 const udlDueSchema = z.strictObject({
     every: udlDueRecurrenceSchema.optional(),
     field: udlFieldNameSchema,
-    offset: nonEmptyTextSchema.optional(),
+    offset: udlOffsetSchema.optional(),
     whenParentStatus: udlDueParentStatusSchema.optional(),
 });
 const udlDeadlineSchema = z.strictObject({
     field: udlFieldNameSchema,
-    offset: nonEmptyTextSchema.optional(),
+    offset: udlOffsetSchema.optional(),
 });
 const udlSetsAtSchema = z.strictObject({
     field: udlFieldNameSchema,
@@ -294,6 +306,29 @@ const udlAggregateCheckSchema = z.discriminatedUnion("kind", [
         kind: z.literal("count_at_least"),
         targetField: udlFieldNameSchema,
     }),
+    z.strictObject({
+        kind: z.literal("count_exactly"),
+        value: z.number().int().min(0),
+    }),
+    z.strictObject({
+        kind: z.literal("ordered"),
+        field: udlFieldNameSchema,
+        positionField: udlFieldNameSchema,
+    }),
+    z.strictObject({
+        kind: z.literal("schedule"),
+        positionField: udlFieldNameSchema,
+        dateField: udlFieldNameSchema,
+        datesField: udlFieldNameSchema,
+        amounts: z
+            .array(z.strictObject({
+            amountField: udlFieldNameSchema,
+            totalField: udlFieldNameSchema,
+        }))
+            .min(1)
+            .max(8),
+        remainder: z.literal("first"),
+    }),
     z.strictObject({ kind: z.literal("all_in") }),
     z.strictObject({
         field: udlFieldNameSchema,
@@ -301,18 +336,28 @@ const udlAggregateCheckSchema = z.discriminatedUnion("kind", [
     }),
 ]);
 const udlAggregateConditionSchema = z.strictObject({
+    anchorField: udlFieldNameSchema.optional(),
+    dueBefore: z
+        .strictObject({
+        field: udlFieldNameSchema,
+        offset: udlOffsetSchema.optional(),
+    })
+        .optional(),
     check: udlAggregateCheckSchema,
-    instrumentId: udlSnakeCaseSchema.optional(),
+    instrumentId: udlInstrumentIdSchema.optional(),
     over: z.enum(["children", "siblings"]),
     refField: udlFieldNameSchema,
     statuses: z.array(udlSnakeCaseSchema).min(1),
 });
 const udlExposureRequirementSchema = z.strictObject({
+    groupField: udlFieldNameSchema.optional(),
+    minimumField: udlFieldNameSchema.optional(),
+    measure: z.strictObject({ allocation: udlSnakeCaseSchema }).optional(),
     amountField: udlFieldNameSchema,
     anchorField: udlFieldNameSchema,
     capField: udlFieldNameSchema,
     capOnAnchor: z.literal(true).optional(),
-    childInstrumentId: udlSnakeCaseSchema,
+    childInstrumentId: udlInstrumentIdSchema,
     statuses: z.array(udlSnakeCaseSchema).min(1),
 });
 // The tenant-backend decision port: the action's caller asserts the acting
@@ -321,6 +366,7 @@ const udlExposureRequirementSchema = z.strictObject({
 const udlPartyRoleSchema = z.string().regex(/^[a-z][A-Za-z0-9_]*$/);
 const udlPortSchema = z.strictObject({
     allowedParties: z.array(udlPartyRoleSchema).min(1),
+    capture: udlFieldNameSchema.optional(),
 });
 const udlPayoutSchema = z.strictObject({
     amount: instanceValuePathSchema,
@@ -357,7 +403,7 @@ const udlReconcileSchema = z.strictObject({
      */
     exception: z.strictObject({
         amountField: udlFieldNameSchema,
-        childInstrumentId: udlSnakeCaseSchema,
+        childInstrumentId: udlInstrumentIdSchema,
         maxOpen: z.number().int().min(1).max(1_000),
         reasonField: udlFieldNameSchema,
         refField: udlFieldNameSchema,
@@ -384,7 +430,7 @@ const udlReconcileSchema = z.strictObject({
 });
 const udlSignedSumSourceSchema = z.strictObject({
     amountField: udlFieldNameSchema,
-    instrumentId: udlSnakeCaseSchema,
+    instrumentId: udlInstrumentIdSchema,
     refField: udlFieldNameSchema,
     sign: z.enum(["add", "subtract"]),
     statuses: z.array(udlSnakeCaseSchema).min(1),
@@ -409,7 +455,7 @@ const udlDistributeSchema = z.strictObject({
 });
 const udlRemainderCollectedSchema = z.strictObject({
     amountField: udlFieldNameSchema,
-    instrumentId: udlSnakeCaseSchema,
+    instrumentId: udlInstrumentIdSchema,
     path: z.literal("refs").optional(),
     refField: udlFieldNameSchema,
     statuses: z.array(udlSnakeCaseSchema).min(1),
@@ -421,6 +467,7 @@ const udlRemainderSchema = z.strictObject({
     inputKey: udlFieldNameSchema.optional(),
     onZero: z.enum(["refuse", "skip_steps"]),
     totalPath: instanceValuePathSchema,
+    subtractPaths: z.array(instanceValuePathSchema).min(1).max(16).optional(),
 });
 const udlCheckRequirementVariants = udlCheckEvidenceProfiles.map((profile) => z.strictObject({
     checkKind: z.literal(profile.checkKind),
@@ -486,10 +533,16 @@ const udlPartitionSchema = z.strictObject({
 const udlDerivedAmountSchema = z.strictObject({
     field: udlFieldNameSchema,
     rounding: z.literal("floor"),
-    rule: z.strictObject({
-        bps: z.number().int().min(1).max(9_999),
-        kind: z.literal("percentage_of"),
-    }),
+    rule: z.discriminatedUnion("kind", [
+        z.strictObject({
+            bps: z.union([z.number().int().min(1).max(9_999), udlStoredFieldSchema]),
+            kind: z.literal("percentage_of"),
+        }),
+        z.strictObject({
+            kind: z.literal("minimum"),
+            capField: udlFieldNameSchema,
+        }),
+    ]),
     sourceField: udlFieldNameSchema,
 });
 const udlFeeLeafRuleSchema = z.discriminatedUnion("kind", [
@@ -620,7 +673,162 @@ export const udlActionLibraryModuleSchema = z.strictObject({
     actions: z.record(udlSnakeCaseSchema, udlPrivateActionSchema),
 });
 export const udlActionLibrarySchema = z.record(udlSnakeCaseSchema, udlActionLibraryModuleSchema);
+const templateParametersSchema = z.record(udlFieldNameSchema, z.union([z.string(), z.number().int(), z.boolean()]));
+const udlAllocationBucketSchema = z.strictObject({
+    key: z.enum(["principal", "profit", "cost", "fine"]),
+    source: z.union([
+        z.strictObject({
+            from: z.literal("slice"),
+            amountField: udlFieldNameSchema,
+            destinationField: udlFieldNameSchema,
+        }),
+        z.strictObject({
+            from: z.literal("children"),
+            instrumentId: udlInstrumentIdSchema,
+            refField: udlFieldNameSchema,
+            statuses: z.array(udlSnakeCaseSchema).min(1),
+            amountField: udlFieldNameSchema,
+            destinationField: udlFieldNameSchema,
+        }),
+        z.strictObject({
+            from: z.literal("children"),
+            template: udlSnakeCaseSchema,
+            parameters: templateParametersSchema,
+            refField: udlFieldNameSchema,
+            statuses: z.array(udlSnakeCaseSchema).min(1),
+            amountField: udlFieldNameSchema,
+            destinationField: udlFieldNameSchema,
+        }),
+    ]),
+});
+const udlAllocationSchema = z.strictObject({
+    sliceInstrumentId: udlInstrumentIdSchema,
+    sliceRefField: udlFieldNameSchema,
+    sliceStatuses: z.array(udlSnakeCaseSchema).min(1),
+    dueField: udlFieldNameSchema,
+    positionField: udlFieldNameSchema,
+    earningRuleField: udlFieldNameSchema,
+    buckets: z.array(udlAllocationBucketSchema).min(2).max(4),
+});
+const udlAllocateSchema = z.union([
+    z.strictObject({
+        refField: udlFieldNameSchema.optional(),
+        mode: z.literal("refund"),
+        action: udlActionNameSchema.optional(),
+        assessmentField: udlFieldNameSchema.optional(),
+        capture: udlFieldNameSchema,
+    }),
+    z.strictObject({
+        refField: udlFieldNameSchema,
+        mode: z.literal("payment"),
+        assessment: z.literal("self").optional(),
+        amountField: udlFieldNameSchema.optional(),
+        sourceAccountField: udlFieldNameSchema,
+        paymentIdentityField: udlFieldNameSchema,
+        capture: udlFieldNameSchema,
+    }),
+    z.strictObject({
+        refField: udlFieldNameSchema.optional(),
+        mode: z.literal("payoff"),
+        amountField: udlFieldNameSchema.optional(),
+        sourceAccountField: udlFieldNameSchema,
+        paymentIdentityField: udlFieldNameSchema,
+        capture: udlFieldNameSchema,
+    }),
+    z.strictObject({
+        refField: udlFieldNameSchema.optional(),
+        mode: z.literal("write_off"),
+        capture: udlFieldNameSchema,
+    }),
+]);
+const udlContributionsSchema = z.strictObject({
+    field: udlFieldNameSchema,
+    amountKey: udlFieldNameSchema,
+    accountKey: udlFieldNameSchema,
+    totalField: udlFieldNameSchema,
+});
+// These clauses are opt-in. Absent clauses never add defaults to older documents.
+const udlFundingSchema = z.strictObject({
+    obligationField: udlFieldNameSchema,
+    ticketInstrumentId: udlInstrumentIdSchema,
+    ticketRefField: udlFieldNameSchema,
+    ticketAmountField: udlFieldNameSchema,
+    ticketInvestorField: udlFieldNameSchema,
+    ticketAccountField: udlFieldNameSchema,
+    ticketStatus: udlSnakeCaseSchema,
+    collectAction: udlActionNameSchema,
+    principalField: udlFieldNameSchema,
+    sourceAccountPath: instanceValuePathSchema,
+    destinationAccountField: udlFieldNameSchema,
+    terms: z.record(udlFieldNameSchema, udlFieldNameSchema),
+    capture: udlFieldNameSchema,
+});
+const udlReceiptDistributionSchema = z.strictObject({
+    roundField: udlFieldNameSchema,
+    snapshotRef: udlFieldNameSchema,
+    receiptField: udlFieldNameSchema,
+    receiptPath: instanceValuePathSchema,
+    mode: z.enum(["cash", "loss"]),
+    feeBps: z.number().int().min(0).max(10000),
+    vatBps: z.number().int().min(0).max(10000),
+    feeAccountField: udlFieldNameSchema,
+    taxAccountField: udlFieldNameSchema,
+    residualAccountField: udlFieldNameSchema,
+    capture: udlFieldNameSchema,
+});
+const udlRequestAuthoritySchema = z.strictObject({
+    instrumentField: udlFieldNameSchema,
+    instanceField: udlFieldNameSchema,
+    actionField: udlFieldNameSchema,
+    inputField: udlFieldNameSchema,
+    digestField: udlFieldNameSchema,
+    roleField: udlFieldNameSchema,
+    party: udlPartyRoleSchema,
+    expiresField: udlFieldNameSchema,
+});
 const udlActionShape = {
+    requestAuthority: udlRequestAuthoritySchema.optional(),
+    funding: udlFundingSchema.optional(),
+    receiptDistribution: udlReceiptDistributionSchema.optional(),
+    requiresAllocation: z
+        .strictObject({
+        refField: udlFieldNameSchema.optional(),
+        slice: z.union([z.literal("self"), udlStoredFieldSchema]),
+        buckets: z
+            .array(z.enum(["principal", "profit", "cost", "fine"]))
+            .min(1)
+            .max(4),
+        check: z.enum(["settled", "outstanding"]),
+    })
+        .optional(),
+    unique: z
+        .strictObject({
+        namespace: udlSnakeCaseSchema,
+        byFields: z.array(udlFieldNameSchema).min(1).max(8),
+    })
+        .optional(),
+    requiresInput: z
+        .record(udlFieldNameSchema, instanceValuePathSchema)
+        .optional(),
+    engineOwned: z.literal(true).optional(),
+    captureEngine: z
+        .record(udlFieldNameSchema, z.enum(["operationId"]))
+        .optional(),
+    allocate: udlAllocateSchema.optional(),
+    contributionStage: z
+        .strictObject({
+        stage: z.enum(["fund", "refund"]),
+        accountPath: instanceValuePathSchema,
+    })
+        .optional(),
+    transitionsRefs: z
+        .array(z.strictObject({
+        field: udlFieldNameSchema,
+        action: udlActionNameSchema,
+    }))
+        .min(1)
+        .max(16)
+        .optional(),
     agentDescription: udlAgentDescriptionSchema.optional(),
     calls: z.array(udlCallSchema).min(1).optional(),
     captureInput: z.record(udlFieldNameSchema, udlFieldNameSchema).optional(),
@@ -634,7 +842,11 @@ const udlActionShape = {
     due: udlDueSchema.optional(),
     earnable: z.boolean().optional(),
     effects: udlEffectsSchema.optional(),
-    eventName: z.string().regex(eventNamePattern).optional(),
+    eventName: z
+        .string()
+        .regex(eventNamePattern)
+        .meta({ "x-udl-reference": "instrument_event" })
+        .optional(),
     examples: z.array(udlExampleSchema).min(1).optional(),
     input: jsonObjectSchema.optional(),
     moves: z.array(udlMoveSchema).default([]),
@@ -662,7 +874,7 @@ const udlActionShape = {
 };
 const udlActionSchema = z.strictObject(udlActionShape);
 const udlAggregateBaseShape = {
-    childInstrumentId: udlSnakeCaseSchema,
+    childInstrumentId: udlInstrumentIdSchema,
     childRefField: udlFieldNameSchema,
     childStatuses: z.array(udlSnakeCaseSchema).min(1),
     parentField: udlFieldNameSchema,
@@ -687,6 +899,23 @@ const udlAggregateSchema = z.union([
     }),
 ]);
 const udlInstrumentShape = {
+    templateBinding: z
+        .strictObject({
+        id: udlSnakeCaseSchema,
+        parameters: templateParametersSchema,
+    })
+        .optional(),
+    allocation: udlAllocationSchema.optional(),
+    contributions: udlContributionsSchema.optional(),
+    dateOrder: z
+        .array(z.strictObject({
+        beforeField: udlFieldNameSchema,
+        afterField: udlFieldNameSchema,
+        operator: z.enum(["<", "<="]),
+    }))
+        .min(1)
+        .max(16)
+        .optional(),
     actionLibrary: udlActionLibrarySchema.optional(),
     actionOrder: z.array(udlActionNameSchema).min(1),
     agentDescription: udlAgentDescriptionSchema.optional(),
@@ -697,15 +926,14 @@ const udlInstrumentShape = {
     description: nonEmptyTextSchema.optional(),
     dials: z.array(udlDialSchema).optional(),
     distinctParties: z.literal(true).optional(),
-    derivedAmounts: z.array(udlDerivedAmountSchema).min(1).max(4).optional(),
+    derivedAmounts: z.array(udlDerivedAmountSchema).min(1).max(64).optional(),
     feeRules: z.array(udlFeeRuleSchema).min(1).max(4).optional(),
     fields: z.record(udlFieldNameSchema, jsonObjectSchema),
-    id: udlSnakeCaseSchema,
+    id: udlInstrumentIdSchema,
     idPrefix: z
         .string()
         .regex(idPrefixPattern, "must contain 2 to 8 lowercase letters"),
     lifecycle: udlLifecycleSchema,
-    journeys: z.array(udlJourneySchema).min(1).optional(),
     nav: z.array(nonEmptyTextSchema).min(1).optional(),
     parties: z.record(udlPartyRoleSchema, udlFieldNameSchema).optional(),
     partitions: z.array(udlPartitionSchema).min(1).optional(),
@@ -721,6 +949,105 @@ const udlInstrumentShape = {
 };
 const udlInstrumentSchema = z.strictObject(udlInstrumentShape);
 export const udlClauseVocabulary = [
+    {
+        scope: "action",
+        spelling: "funding",
+        target: "funding",
+        cardinality: "one",
+        effects: [
+            {
+                kind: "moves",
+                per: "clause",
+                signature: { fixed: "transfer.internal" },
+            },
+        ],
+    },
+    {
+        scope: "action",
+        spelling: "receipt distribution",
+        target: "receiptDistribution",
+        cardinality: "one",
+        effects: [
+            { kind: "decides", per: "clause", signature: { fixed: "allocation" } },
+            { kind: "moves", per: "clause", signature: { fixed: "allocation" } },
+        ],
+    },
+    {
+        cardinality: "one",
+        scope: "action",
+        spelling: "requires allocation",
+        target: "requiresAllocation",
+        effects: [
+            { kind: "decides", per: "clause", signature: { fixed: "allocation" } },
+        ],
+    },
+    {
+        cardinality: "one",
+        scope: "instrument",
+        spelling: "allocation",
+        target: "allocation",
+    },
+    {
+        cardinality: "one",
+        scope: "instrument",
+        spelling: "contributions",
+        target: "contributions",
+    },
+    {
+        cardinality: "one",
+        scope: "action",
+        spelling: "allocate",
+        target: "allocate",
+        effects: [
+            { kind: "decides", per: "clause", signature: { fixed: "allocation" } },
+            { kind: "moves", per: "clause", signature: { fixed: "allocation" } },
+        ],
+    },
+    {
+        cardinality: "one",
+        scope: "action",
+        spelling: "contribution stage",
+        target: "contributionStage",
+        effects: [
+            {
+                kind: "moves",
+                per: "clause",
+                signature: { fixed: "transfer.internal" },
+            },
+        ],
+    },
+    {
+        cardinality: "many",
+        scope: "instrument",
+        spelling: "date order",
+        target: "dateOrder",
+    },
+    {
+        cardinality: "one",
+        scope: "action",
+        spelling: "unique",
+        target: "unique",
+        effects: [
+            {
+                kind: "decides",
+                per: "clause",
+                signature: { fixed: "subject_unique" },
+            },
+        ],
+    },
+    {
+        cardinality: "many",
+        scope: "action",
+        spelling: "transitions refs",
+        target: "transitionsRefs",
+        effects: [
+            {
+                kind: "decides",
+                per: "element",
+                signature: { fixed: "referenced_transition" },
+            },
+        ],
+    },
     {
         cardinality: "one",
         literalKeys: true,
@@ -741,6 +1068,26 @@ export const udlClauseVocabulary = [
         spelling: "calls",
         target: "calls",
     },
+    {
+        cardinality: "one",
+        scope: "action",
+        spelling: "requires input",
+        target: "requiresInput",
+        literalKeys: true,
+    },
+    {
+        cardinality: "one",
+        scope: "action",
+        spelling: "engine owned",
+        target: "engineOwned",
+    },
+    {
+        cardinality: "one",
+        scope: "action",
+        spelling: "capture engine",
+        target: "captureEngine",
+        literalKeys: true,
+    },
     {
         cardinality: "one",
         scope: "action",
@@ -1106,12 +1453,6 @@ export const udlClauseVocabulary = [
         spelling: "id prefix",
         target: "idPrefix",
     },
-    {
-        cardinality: "many",
-        scope: "instrument",
-        spelling: "journeys",
-        target: "journeys",
-    },
     {
         cardinality: "many",
         scope: "instrument",
@@ -1142,6 +1483,12 @@ export const udlClauseVocabulary = [
         spelling: "surface visibility",
         target: "surfaceVisibility",
     },
+    {
+        cardinality: "one",
+        scope: "instrument",
+        spelling: "template binding",
+        target: "templateBinding",
+    },
     {
         cardinality: "one",
         scope: "instrument",
@@ -1160,6 +1507,13 @@ export const udlClauseVocabulary = [
         spelling: "update",
         target: "update",
     },
+    {
+        cardinality: "one",
+        effects: [],
+        scope: "action",
+        spelling: "request authority",
+        target: "requestAuthority",
+    },
 ];
 const udlDocumentShapeSchema = z.strictObject({
     dials: z.array(udlCompositionDialSchema).min(1).optional(),
@@ -1175,26 +1529,10 @@ function isMoneyField(schema) {
     return (typeof schema?.pattern === "string" && moneyPatterns.has(schema.pattern));
 }
 function referenceTargets(schema, instruments) {
-    if (schema.type !== "string" || typeof schema.pattern !== "string")
-        return [];
-    // Parse the scoped-ID pattern. Executing an author regex here would bypass
-    // the semantic validator's branch and quantifier budgets.
-    const match = /^\^([a-z]{2,8})_\(sandbox\|live\)_\[a-z0-9\]\{8,64\}\$$/.exec(schema.pattern);
-    if (!match)
-        return [];
-    const prefix = match[1];
-    const probe = `${prefix}_sandbox_0123456789abcdef`;
-    if (typeof schema.const === "string" && schema.const !== probe)
-        return [];
-    if (Array.isArray(schema.enum) && !schema.enum.includes(probe))
-        return [];
-    if (typeof schema.minLength === "number" && probe.length < schema.minLength) {
-        return [];
-    }
-    if (typeof schema.maxLength === "number" && probe.length > schema.maxLength) {
-        return [];
-    }
-    return instruments.filter((instrument) => instrument.idPrefix === prefix);
+    const prefix = referencePatternPrefix(schema);
+    return prefix
+        ? instruments.filter((instrument) => instrument.idPrefix === prefix)
+        : [];
 }
 function declaredMoneyRefKeys(instrument) {
     return new Set([