@hyperscale0/udl 4.0.0 → 4.1.0

package/src/diagnostics.ts

@@ -9,8 +9,6 @@ export type UdlIssueCode =
   | "staff_role_unknown"
   | "product_party_unbound"
   | "product_party_invalid"
-  | "approval_initiator_missing"
-  | "approval_same_initiator"
   | "UDL1001"
   | "UDL1002"
   | "UDL1003"
@@ -40,16 +38,12 @@ const fixes: Record<UdlIssueCode, string> = {
     "Bind the parameter to a subject role or declared party.",
   party_name_reserved:
     "Choose a party name other than owner, actor or operator.",
-  party_kind_mismatch:
-    "Use a business or subject role for money and staff with a role for approval.",
+  party_kind_mismatch: "Use a business or subject role for money.",
   staff_role_unknown: "Use a registered staff permission role.",
   product_party_unbound:
     "Supply the consumed business in the Build party bindings.",
   product_party_invalid:
     "Bind a business participant in the same tenant and environment.",
-  approval_initiator_missing: "Provide authenticated request attribution.",
-  approval_same_initiator:
-    "Have a different human approve the protected request.",
 
   UDL1001: "Encode the source as UTF-8.",
   UDL1002: "Repair JSON syntax.",

package/src/object-contract.ts

@@ -2,7 +2,6 @@ import * as z from "zod";
 import {
   udlExternalIdSchema,
   udlObjectIdSchema,
-  udlPartyNameSchema,
   type UdlDocument,
   type UdlField,
   type UdlObjectField,
@@ -30,16 +29,6 @@ export const requestAttributionSchema = z.union([
 ]);
 export type RequestAttribution = z.infer<typeof requestAttributionSchema>;
 
-export const objectApprovalRequirementSchema = z.strictObject({
-  target: z.string().min(1),
-  action: udlPartyNameSchema,
-  party: udlPartyNameSchema,
-  role: udlPartyNameSchema,
-  decision: z.enum(["approved", "declined"]),
-  protectedRequest: z.string().min(1),
-  differentFromInitiator: z.boolean(),
-});
-
 export type JsonSchemaDocument = z.core.JSONSchema.BaseSchema;
 
 export interface ObjectKindDiscovery {
@@ -61,9 +50,6 @@ export interface ObjectActionContext {
   target: ObjectActionTarget;
 }
 export interface ObjectActionDiscovery extends ObjectActionContext {
-  approvalRequirements: readonly z.infer<
-    typeof objectApprovalRequirementSchema
-  >[];
   name: string;
   title: string;
   instrument: string;
@@ -340,26 +326,6 @@ export function projectObjectDiscovery(
                 title: action.summary,
                 instrument: instrument.id,
                 action: name,
-                approvalRequirements: action.requires.flatMap((rule) => {
-                  if (rule.kind !== "approval") return [];
-                  const party = document.parties[rule.party];
-                  if (party?.kind !== "staff" || !party.role)
-                    throw new Error(
-                      `Approval party ${rule.party} has no staff authority`,
-                    );
-                  return [
-                    {
-                      target: rule.target ?? "self",
-                      action: rule.action ?? name,
-                      party: rule.party,
-                      role: party.role,
-                      decision: rule.decision,
-                      protectedRequest: rule.protectedRequest ?? "self",
-                      differentFromInitiator:
-                        rule.differentFromInitiator === true,
-                    },
-                  ];
-                }),
                 requirements: mergedReqs.map(
                   (requirement) =>
                     ({

package/src/reporting.ts

@@ -171,7 +171,6 @@ export const reportDefinitionSchema = z.strictObject({
     request: z.array(name).min(1).max(64),
     read: z.array(name).min(1).max(64),
     release: z.array(name).max(64),
-    independentApproval: z.literal(true),
     retention: z.strictObject({ policy: name, years: integer.min(1).max(100) }),
   }),
 });

package/src/schema.ts

@@ -328,15 +328,6 @@ export const udlRequirementSchema = z.discriminatedUnion("kind", [
     operator: z.enum(["==", "<=", ">=", "<", ">"]),
     value,
   }),
-  z.strictObject({
-    kind: z.literal("approval"),
-    target: path.default("self"),
-    party: name,
-    action: name.optional(),
-    decision: z.enum(["approved", "declined"]),
-    differentFromInitiator: z.literal(true).optional(),
-    protectedRequest: path.default("self"),
-  }),
   z.strictObject({
     kind: z.literal("evidence"),
     instruction: path.optional(),
@@ -401,7 +392,6 @@ export const udlActionSchema = z.strictObject({
   summary: text,
   publicAction: name.optional(),
   expansionLimit: z.literal(8192).optional(),
-  humanApproval: z.literal("distinct_member").optional(),
   reminder: z
     .strictObject({
       installment: path,
@@ -466,17 +456,6 @@ export const udlActionSchema = z.strictObject({
     )
     .max(16)
     .optional(),
-  approval: z
-    .strictObject({
-      protectedRequest: path.default("self"),
-      target: path,
-      action: name,
-      party: name,
-      expires: path,
-      input: z.record(name, value),
-      decision: z.enum(["approved", "declined"]),
-    })
-    .optional(),
 });
 export const udlLifecycleSchema = z.strictObject({
   states: z.array(name).min(1).max(64),

package/src/validation.ts

@@ -61,10 +61,6 @@ function moneyParty(
       (!instrument?.subject && document.parties[name]?.kind === "person"))
   );
 }
-function approvalParty(document: UdlDocument, name: string): boolean {
-  const party = document.parties[name];
-  return party?.kind === "staff" && !!party.role;
-}
 
 export type UdlValidationResult =
   | { ok: true; value: UdlDocument }
@@ -1039,38 +1035,6 @@ export function validateUdl(value: unknown): UdlValidationResult {
           for (const p of req.fields)
             if (!field(p, input, act))
               add(where, `unknown identity field ${p}`);
-        } else if (req.kind === "approval") {
-          const request = expect(
-            req.protectedRequest,
-            "ref",
-            where,
-            input,
-            act,
-          );
-          if (request?.type === "ref" && request.targetKind !== "instrument")
-            add(
-              where,
-              "protectedRequest must reference an instrument",
-              "UDL5001",
-            );
-          const target = expect(req.target, "ref", where, input, act);
-          if (!approvalParty(document, req.party))
-            add(
-              where,
-              `approval requires staff with a role: ${req.party}`,
-              hasParty(document, inst, req.party)
-                ? "party_kind_mismatch"
-                : "subject_party_unbound",
-            );
-          if (
-            req.action &&
-            target?.type === "ref" &&
-            target.targetKind === "instrument" &&
-            targetIds(target.target).some(
-              (id) => !byId.get(id)?.actions[req.action!],
-            )
-          )
-            add(where, `unknown approved action ${req.action}`);
         } else if (req.kind === "evidence") {
           if (req.instruction) {
             expect(req.instruction, "text", where, input, act);
@@ -1376,48 +1340,6 @@ export function validateUdl(value: unknown): UdlValidationResult {
           }
         }
       };
-      if (action.approval) {
-        const request = expect(
-          action.approval.protectedRequest,
-          "ref",
-          where,
-          action.input,
-          action,
-        );
-        if (request?.type === "ref" && request.targetKind !== "instrument")
-          add(
-            where,
-            "protectedRequest must reference an instrument",
-            "UDL5001",
-          );
-        const reference = expect(
-          action.approval.target,
-          "ref",
-          where,
-          action.input,
-          action,
-        );
-        if (
-          reference?.type === "ref" &&
-          reference.targetKind === "instrument" &&
-          targetIds(reference.target).some(
-            (id) => !byId.get(id)?.actions[action.approval!.action],
-          )
-        )
-          add(where, "approval target action does not exist");
-        if (reference?.type === "ref" && reference.targetKind === "instrument")
-          for (const id of targetIds(reference.target))
-            checkArguments(id, action.approval.action, action.approval.input);
-        expect(action.approval.expires, "date", where, action.input, action);
-        if (!approvalParty(document, action.approval.party))
-          add(
-            where,
-            "approval requires staff with a role",
-            hasParty(document, inst, action.approval.party)
-              ? "party_kind_mismatch"
-              : "subject_party_unbound",
-          );
-      }
       const targets: { targets: string[]; count: number }[] = [];
       for (const call of action.invoke ?? []) {
         if (call.guard)