@hyperscale0/udl 4.4.1 → 4.5.0

package/src/diagnostics.ts

@@ -75,19 +75,21 @@ export function issue(
     path,
     message,
     fix: fixes[code],
-    category:
-      code === "UDL1003"
-        ? "invalid_shape"
-        : code === "UDL1004"
-          ? "resource_limit"
-          : "invalid_semantics",
+    category: category(code),
   };
 }
+function category(code: string): string {
+  return code === "UDL1003"
+    ? "invalid_shape"
+    : code === "UDL1004"
+      ? "resource_limit"
+      : "invalid_semantics";
+}
 export const udlDiagnostics = Object.entries(fixes).map(([code, fix]) => ({
   code,
   fix,
   title: fix,
-  category: "invalid_semantics",
+  category: category(code),
   family: "document",
 }));
 export const udlDiagnostic = (code: string) =>

package/src/evolution.ts

@@ -1,19 +1,6 @@
 import type { UdlDocument } from "./schema.js";
 import { issue, type UdlIssue } from "./diagnostics.js";
-
-function stable(value: unknown): string {
-  if (Array.isArray(value)) return "[" + value.map(stable).join(",") + "]";
-  if (value && typeof value === "object")
-    return (
-      "{" +
-      Object.entries(value)
-        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
-        .map(([key, entry]) => JSON.stringify(key) + ":" + stable(entry))
-        .join(",") +
-      "}"
-    );
-  return JSON.stringify(value) ?? "undefined";
-}
+import { writeJson } from "./json.js";
 
 /** Existing instruments are frozen; a live document may add independent instruments. */
 export function diffValidatedUdlEvolution(
@@ -26,11 +13,14 @@ export function diffValidatedUdlEvolution(
   if (live.product !== next.product || live.currency !== next.currency)
     refuse("$", "product identity and currency are immutable");
   for (const [name, party] of Object.entries(live.parties))
-    if (stable(party) !== stable(next.parties[name]))
+    if (
+      !Object.hasOwn(next.parties, name) ||
+      writeJson(party) !== writeJson(next.parties[name])
+    )
       refuse(`$.parties.${name}`, "a live party cannot change or disappear");
   for (const object of live.objects) {
     const updated = next.objects.find((o) => o.id === object.id);
-    if (!updated || stable(object) !== stable(updated))
+    if (!updated || writeJson(object) !== writeJson(updated))
       refuse(
         `$.objects.${object.id}`,
         "a live object kind cannot change or disappear; recreate development estates",
@@ -38,13 +28,13 @@ export function diffValidatedUdlEvolution(
   }
   for (const instrument of live.instruments) {
     const updated = next.instruments.find((i) => i.id === instrument.id);
-    if (!updated || stable(instrument) !== stable(updated))
+    if (!updated || writeJson(instrument) !== writeJson(updated))
       refuse(
         `$.instruments.${instrument.id}`,
         "a live instrument cannot change or disappear; recreate development estates",
       );
   }
-  if (stable(live) !== stable(next) && next.version <= live.version)
+  if (writeJson(live) !== writeJson(next) && next.version <= live.version)
     issues.push(
       issue(
         "UDL7002",

package/src/json.ts

@@ -0,0 +1,34 @@
+const INDENT = "  ";
+
+export function writeJson(value: unknown, depth = 0): string {
+  if (value === null || typeof value !== "object") {
+    const encoded = JSON.stringify(value);
+    if (encoded === undefined) {
+      throw new TypeError("UDL canonical JSON received a non-JSON value");
+    }
+    return encoded;
+  }
+
+  const indent = INDENT.repeat(depth);
+  const childIndent = INDENT.repeat(depth + 1);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    return `[\n${value
+      .map((item) => `${childIndent}${writeJson(item, depth + 1)}`)
+      .join(",\n")}\n${indent}]`;
+  }
+
+  const record = value as Record<string, unknown>;
+  const keys = Object.keys(record).sort(compareCodeUnits);
+  if (keys.length === 0) return "{}";
+  return `{\n${keys
+    .map(
+      (key) =>
+        `${childIndent}${JSON.stringify(key)}: ${writeJson(record[key], depth + 1)}`,
+    )
+    .join(",\n")}\n${indent}}`;
+}
+
+function compareCodeUnits(left: string, right: string): number {
+  return left < right ? -1 : left > right ? 1 : 0;
+}

package/src/limits.ts

@@ -1,34 +1,7 @@
 export const UDL_LIMITS = Object.freeze({
-  financeAccounts: 16,
-  financeEffects: 128,
-  financePathVariants: 256,
-  financeStates: 32,
-  financeTransitionEdges: 128,
-  financeTransitions: 64,
-  financeActions: 64,
-  financeWork: 4_096,
-  maxActionExpansion: 256,
-  maxActionLeaves: 256,
-  maxDepth: 24,
-  maxKeyLength: 128,
-  maxNodes: 20_000,
-  maxPatternLength: 320,
-  /**
-   * Upper bound on the match attempts a document-authored `pattern` can force
-   * the backtracking engine to explore at its single anchored start position.
-   * Every admitted pattern's search space is multiplied out at admission
-   * (alternation branches x optional atoms x variable-quantifier spans), so
-   * worst-case matching cost is this budget times the pattern length, not an
-   * exponential in the document author's choice of grammar.
-   */
-  maxPatternPaths: 4_096,
-  /**
-   * Reference-shape classifications one `ReferenceShapeBudget` may buy. Each
-   * one classifies canonical reference pattern text without compiling a validator.
-   * This safety net covers a catalogue plus hundreds of authored instruments.
-   */
-  maxSchemaProbes: 131_072,
+  maxDepth: 32,
+  maxKeyLength: 240,
+  maxNodes: 100_000,
   maxSourceBytes: 1_024 * 1_024,
-  maxStringLength: 2_048,
-  maxTotalStringLength: 512 * 1_024,
+  maxTotalStringLength: 1_024 * 1_024,
 });

package/src/object-contract.ts

@@ -511,7 +511,11 @@ export function objectActionState(
     ...action,
     requiredNow: action.requirements
       .filter((field) => {
-        const conditions = action.requirementConditions?.[field.name];
+        const conditions =
+          action.requirementConditions &&
+          Object.hasOwn(action.requirementConditions, field.name)
+            ? action.requirementConditions[field.name]
+            : undefined;
         if (
           conditions &&
           !requirementPossible(

package/src/parser.ts

@@ -40,6 +40,28 @@ function parseUdlText(source: string): UdlDocument {
       ),
     ]);
   }
+  // JSON.parse has already checked syntax. Scan member names before its
+  // last-value-wins behavior can erase an authored declaration.
+  const members: (Set<string> | null)[] = [];
+  let name = "";
+  for (const token of source.matchAll(/"(?:[^"\\]|\\.)*"|[{}[\]:]/g)) {
+    const text = token[0];
+    if (text === "{") members.push(new Set());
+    else if (text === "[") members.push(null);
+    else if (text === "}" || text === "]") members.pop();
+    else if (text === ":") {
+      const keys = members[members.length - 1];
+      if (keys?.has(name))
+        throw new UdlError([
+          issue(
+            "UDL1002",
+            "$",
+            `duplicate JSON member ${name} at offset ${token.index}`,
+          ),
+        ]);
+      keys?.add(name);
+    } else name = JSON.parse(text) as string;
+  }
   return assertValidUdl(value);
 }
 

package/src/reporting-validation.ts

@@ -6,6 +6,11 @@ import type {
 } from "./reporting.js";
 
 type Types = Map<string, ReportType>;
+const sealedFields = new Map([
+  ["id", "text"],
+  ["status", "text"],
+  ["createdAt", "date"],
+]);
 const integer: ReportType = { kind: "integer" };
 const boolean: ReportType = { kind: "boolean" };
 const date: ReportType = { kind: "date" };
@@ -195,21 +200,18 @@ export function validateReportDefinition(
           const field = instrument.fields.find(
             (entry) => entry.name === parts[0],
           );
-          const sealed = (
-            { id: "text", status: "text", createdAt: "date" } as Record<
-              string,
-              string
-            >
-          )[column.field];
+          const sealed = sealedFields.get(column.field);
           const actual =
             parts.length === 2 &&
             parts[1] === "balance" &&
             field?.type === "account"
               ? "money"
-              : (sealed ??
-                (field && ["ref", "account", "enum"].includes(field.type)
-                  ? "text"
-                  : field?.type));
+              : parts.length === 1
+                ? (sealed ??
+                  (field && ["ref", "account", "enum"].includes(field.type)
+                    ? "text"
+                    : field?.type))
+                : undefined;
           requireRule(
             actual === column.type.kind,
             `Unknown or mistyped report field ${id}.${column.field}`,

package/src/schema.ts

@@ -1,5 +1,6 @@
 import * as z from "zod";
 import { reportDefinitionSchema } from "./reporting.js";
+import { writeJson } from "./json.js";
 
 export const UDL_FORMAT_VERSION = 4 as const;
 /** Counts the root and every nested invocation, including selected and ranged children. */
@@ -546,17 +547,13 @@ export function sameObjectField(
   right: UdlObjectField,
 ): boolean {
   const signature = (field: UdlObjectField) =>
-    JSON.stringify(
+    writeJson(
       Object.fromEntries(
-        Object.entries(field)
-          .filter(
-            ([key, value]) =>
-              !["name", "description", "optional"].includes(key) &&
-              value !== undefined,
-          )
-          .sort(([left], [right]) =>
-            left < right ? -1 : left > right ? 1 : 0,
-          ),
+        Object.entries(field).filter(
+          ([key, value]) =>
+            !["name", "description", "optional"].includes(key) &&
+            value !== undefined,
+        ),
       ),
     );
   return signature(left) === signature(right);