@hyperscale0/udl 4.0.0 → 4.2.0

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,19 +29,11 @@ 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 {
+  productBuildId: string;
+  digest: string;
   creation: true;
   kind: string;
   title: string;
@@ -61,9 +52,7 @@ export interface ObjectActionContext {
   target: ObjectActionTarget;
 }
 export interface ObjectActionDiscovery extends ObjectActionContext {
-  approvalRequirements: readonly z.infer<
-    typeof objectApprovalRequirementSchema
-  >[];
+  summary: string;
   name: string;
   title: string;
   instrument: string;
@@ -111,6 +100,7 @@ export type RetainedObjectKind = Pick<
   creation: false;
 };
 export interface ObjectDiscovery {
+  navigation: readonly { kind: string; title: string; creation: boolean }[];
   retainedKinds: readonly RetainedObjectKind[];
   productBuildId: string;
   digest: string;
@@ -248,8 +238,14 @@ export function projectObjectDiscovery(
 ): ObjectDiscovery {
   return {
     ...build,
+    navigation: document.objects.map((kind) => ({
+      kind: kind.id,
+      title: kind.title,
+      creation: true,
+    })),
     retainedKinds: [],
     kinds: document.objects.map((kind) => ({
+      ...build,
       creation: true,
       kind: kind.id,
       title: kind.title,
@@ -337,29 +333,12 @@ export function projectObjectDiscovery(
                   )!.name,
                 },
                 name: action.publicAction,
-                title: action.summary,
+                title: action.publicAction
+                  .replace(/_/g, " ")
+                  .replace(/^./, (letter) => letter.toUpperCase()),
+                summary: 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(),
@@ -398,10 +389,10 @@ const clock = z.strictObject({
     .optional(),
 });
 export const udlActionSchema = z.strictObject({
+  allowZero: z.literal(true).optional(),
   summary: text,
   publicAction: name.optional(),
   expansionLimit: z.literal(8192).optional(),
-  humanApproval: z.literal("distinct_member").optional(),
   reminder: z
     .strictObject({
       installment: path,
@@ -466,17 +457,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)
@@ -1502,9 +1424,10 @@ export function validateUdl(value: unknown): UdlValidationResult {
     }
     if (!issues.some((i) => i.path.startsWith(base)))
       issues.push(
-        ...analyzeInstrumentFinance(inst, document).map((i) =>
-          issue("UDL4001", base + i.path, i.message),
-        ),
+        ...analyzeInstrumentFinance(inst, document).map((i) => ({
+          ...issue("UDL4001", base + i.path, i.message),
+          ...(i.stranded ? { stranded: i.stranded } : {}),
+        })),
       );
   }
   const active = new Set<string>();