@hyperscale0/udl 1.0.342 → 1.0.347

package/src/canonical.ts

@@ -1,18 +1,88 @@
-import { assertValidUdl } from "./validation.js";
-import { writeJson } from "./json.js";
+import { hash } from "fast-sha256";
 
-export function serializeUdl(value: unknown): string {
-  const document = assertValidUdl(value);
-  return `${writeJson(document, 0)}\n`;
+/**
+ * Canonical JSON, the one encoder behind every hashed value in Arc. Keys sort
+ * by UTF-16 code unit and scalars encode as `JSON.stringify` writes them. Only
+ * plain data encodes: non-finite numbers, `bigint`, functions, symbols,
+ * `undefined`, missing array items, non-plain objects and cycles throw.
+ */
+export function canonicalJson(value: unknown): string {
+  return write(value, "$", new WeakSet<object>());
 }
 
-/** SHA-256 over the canonical UTF-8 bytes, encoded as lowercase hexadecimal. */
-export async function canonicalDigest(value: unknown): Promise<string> {
-  const digest = await globalThis.crypto.subtle.digest(
-    "SHA-256",
-    new TextEncoder().encode(serializeUdl(value)),
-  );
-  return [...new Uint8Array(digest)]
-    .map((byte) => byte.toString(16).padStart(2, "0"))
-    .join("");
+/**
+ * The UDL document layout: canonical JSON with a two-space indent. Every
+ * stored `documentDigest` hashes these bytes.
+ */
+export function writeJson(value: unknown): string {
+  return write(value, "$", new WeakSet<object>(), "");
+}
+
+function write(
+  value: unknown,
+  path: string,
+  ancestors: WeakSet<object>,
+  indent?: string,
+): string {
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "boolean":
+    case "string":
+      return JSON.stringify(value);
+    case "number":
+      if (!Number.isFinite(value)) refuse("non finite numbers", path);
+      return JSON.stringify(value);
+    case "object":
+      break;
+    default:
+      refuse(typeof value, path);
+  }
+  const array = Array.isArray(value);
+  if (!array) {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+      refuse("objects other than plain ones", path);
+    if (Object.getOwnPropertySymbols(value).length > 0)
+      refuse("symbol keys", path);
+  }
+  if (ancestors.has(value)) refuse("cycles", path);
+  ancestors.add(value);
+  try {
+    const inner = indent === undefined ? undefined : `${indent}  `;
+    const items: string[] = [];
+    if (array) {
+      for (let index = 0; index < value.length; index += 1) {
+        if (!Object.hasOwn(value, index))
+          refuse("missing array items", `${path}[${index}]`);
+        items.push(write(value[index], `${path}[${index}]`, ancestors, inner));
+      }
+    } else {
+      const record = value as Record<string, unknown>;
+      for (const key of Object.keys(record).sort())
+        items.push(
+          `${JSON.stringify(key)}:${inner === undefined ? "" : " "}${write(record[key], `${path}.${key}`, ancestors, inner)}`,
+        );
+    }
+    const [open, close] = array ? ["[", "]"] : ["{", "}"];
+    if (inner === undefined || items.length === 0)
+      return `${open}${items.join(",")}${close}`;
+    return `${open}\n${inner}${items.join(`,\n${inner}`)}\n${indent}${close}`;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+
+function refuse(what: string, path: string): never {
+  throw new TypeError(`canonical JSON does not support ${what} at ${path}`);
+}
+
+/** SHA-256 over canonical JSON, encoded as lowercase hexadecimal. */
+export function digest(value: unknown): string {
+  return sha256(canonicalJson(value));
+}
+
+export function sha256(text: string): string {
+  return Array.from(hash(new TextEncoder().encode(text)), (byte) =>
+    byte.toString(16).padStart(2, "0"),
+  ).join("");
 }

package/src/diagnostics.ts

@@ -11,6 +11,8 @@ export type UdlIssueCode =
   | "party_kind_mismatch"
   | "staff_role_unknown"
   | "product_party_invalid"
+  | "udl_format_unknown"
+  | "udl_format_not_current"
   | "UDL1003"
   | "UDL1004"
   | "UDL2001"
@@ -53,6 +55,10 @@ const fixes: Record<UdlIssueCode, string> = {
   staff_role_unknown: "Use a registered staff permission role.",
   product_party_invalid:
     "Bind a business participant in the same tenant and environment.",
+  udl_format_unknown:
+    "Run the document on an engine that ships a reader for its format.",
+  udl_format_not_current:
+    "Recompile the HSX program, which emits the current UDL format.",
 
   UDL1003: "Use the UDL 1 typed grammar.",
   UDL1004: "Reduce the declared structure or expansion.",

package/src/formats.ts

@@ -0,0 +1,56 @@
+import type * as z from "zod";
+import {
+  UDL_FORMAT_VERSION,
+  udlDocumentSchema,
+  udlFormat1DocumentSchema,
+  type UdlAnyFamily,
+} from "./schema.js";
+
+/**
+ * How this engine reads one UDL format. A Build is bytecode and keeps the
+ * format it compiled to. The current format parses straight into the engine's
+ * document; an older one parses with its own schema, then `upgrade`, a pure
+ * and deterministic step, turns it into the next format.
+ */
+export interface UdlFormatReader {
+  readonly schema: z.ZodType;
+  readonly upgrade?: (document: unknown) => unknown;
+}
+
+/**
+ * One reader per format a stored Build uses, keyed by `document.udl`. A format
+ * bump adds its schema here and gives the previous format an upgrade step. A
+ * new Build admits only `UDL_FORMAT_VERSION` (`validateNewBuildUdl`).
+ */
+export const udlFormatReaders = new Map<number, UdlFormatReader>([
+  [1, { schema: udlFormat1DocumentSchema }],
+  [UDL_FORMAT_VERSION, { schema: udlDocumentSchema }],
+]);
+
+/**
+ * Whether two families name the same std declaration. Two format 2 families
+ * compare digests. When either is format 1, module and export path decide,
+ * which is what a stored revision decided: every stored revision is 1.
+ */
+export function sameFamily(
+  a: UdlAnyFamily | undefined,
+  b: UdlAnyFamily,
+): boolean {
+  return (
+    a !== undefined &&
+    a.module === b.module &&
+    a.exportPath === b.exportPath &&
+    (!("digest" in a) || !("digest" in b) || a.digest === b.digest)
+  );
+}
+
+/** The format a stored document declares, when this engine can read it. */
+export function readableUdlFormat(document: unknown): number | undefined {
+  const format =
+    document !== null && typeof document === "object"
+      ? (document as { udl?: unknown }).udl
+      : undefined;
+  return typeof format === "number" && udlFormatReaders.has(format)
+    ? format
+    : undefined;
+}

package/src/index.ts

@@ -1,8 +1,16 @@
 export * from "./schema.js";
 export { sarCurrency, sarMinorUnitExponent, currencySchema } from "./money.js";
-export { serializeUdl, canonicalDigest } from "./canonical.js";
+export { serializeUdl, documentDigest } from "./serialize.js";
+export { canonicalJson, digest } from "./canonical.js";
+export {
+  udlFormatReaders,
+  readableUdlFormat,
+  sameFamily,
+  type UdlFormatReader,
+} from "./formats.js";
 export {
   validateUdl,
+  validateNewBuildUdl,
   RESERVED_OBJECT_NAMES,
   assertValidUdl,
   resolveField,

package/src/object-contract.ts

@@ -29,7 +29,10 @@ export interface ObjectKindDiscovery {
     title: string;
     instrument: string;
     parentAttachment: string | null;
-    block: { key: string; recordPath: string; headerDigest: string } | null;
+    block:
+      | { key: string; recordPath: string; digest: string }
+      | { key: string; recordPath: string; headerDigest: string }
+      | null;
   }[];
   productBuildId: string;
   digest: string;

package/src/schema.ts

@@ -1,9 +1,9 @@
 import * as z from "zod";
 import { currencySchema } from "./money.js";
 import { reportDefinitionSchema } from "./reporting.js";
-import { writeJson } from "./json.js";
+import { canonicalJson } from "./canonical.js";
 
-export const UDL_FORMAT_VERSION = 1 as const;
+export const UDL_FORMAT_VERSION = 2 as const;
 /** Counts the root and every nested invocation, including selected and ranged children. */
 export const MAX_ACTION_EXPANSION = 8192;
 const name = z
@@ -33,12 +33,23 @@ export const udlPartySchema = z.strictObject({
   role: name.optional(),
 });
 
+/** Format 2 names a std declaration by the digest of its normal form. */
 export const udlFamilySchema = z.strictObject({
+  module: name,
+  exportPath: path,
+  digest: z.string().regex(/^[a-f0-9]{64}$/),
+});
+
+/** Format 1 named it by a hand-written revision. Stored Builds keep it. */
+export const udlFormat1FamilySchema = z.strictObject({
   module: name,
   exportPath: path,
   revision: integer.positive(),
 });
 
+// One tree serves both formats; each document schema checks its families.
+const family = z.union([udlFamilySchema, udlFormat1FamilySchema]);
+
 const fieldBase = {
   name,
   label: text.optional(),
@@ -51,7 +62,7 @@ const referenceField = z.strictObject({
   ...fieldBase,
   type: z.literal("ref"),
   targetKind: z.enum(["instrument", "object"]),
-  targetFamily: udlFamilySchema.optional(),
+  targetFamily: family.optional(),
   target: z.union([name, z.array(name).min(1).max(16)]),
 });
 
@@ -60,7 +71,7 @@ const listField = z.strictObject({
   type: z.literal("list"),
   item: z.enum(["money", "date", "text", "integer", "ref"]),
   targetKind: z.enum(["instrument", "object"]).optional(),
-  targetFamily: udlFamilySchema.optional(),
+  targetFamily: family.optional(),
   target: name.optional(),
   maxItems: integer.min(1).max(366),
 });
@@ -254,7 +265,7 @@ export const udlObjectKindSchema = z.strictObject({
 const values = z.array(value).min(1).max(256);
 
 const selection = z.strictObject({
-  family: udlFamilySchema.optional(),
+  family: family.optional(),
   instrument: z.union([instrumentId, z.array(instrumentId).min(1).max(16)]),
   reference: name,
   anchor: path,
@@ -551,7 +562,7 @@ export const udlInstrumentSchema = z.strictObject({
   scope: z.literal("product").optional(),
   reports: z.array(reportDefinitionSchema).max(16).optional(),
   revisioned: z.literal(true).optional(),
-  family: udlFamilySchema.optional(),
+  family: family.optional(),
   id: instrumentId,
   subject: objectKindId.optional(),
   // The authored instrument an attachment instantiates, when its scoped id
@@ -570,8 +581,7 @@ export const udlInstrumentSchema = z.strictObject({
     .max(16)
     .optional(),
 });
-export const udlDocumentSchema = z.strictObject({
-  udl: z.literal(UDL_FORMAT_VERSION),
+const documentShape = {
   version: integer.positive(),
   product: name,
   title: text,
@@ -579,10 +589,60 @@ export const udlDocumentSchema = z.strictObject({
   parties: z.record(name, udlPartySchema),
   objects: z.array(udlObjectKindSchema).max(256),
   instruments: z.array(udlInstrumentSchema).max(256),
-});
+};
+
+/** Every family a document names: instruments, reference fields, selections. */
+function families(instruments: unknown[]): [PropertyKey[], object][] {
+  const found: [PropertyKey[], object][] = [];
+  const visit = (value: unknown, path: PropertyKey[]): void => {
+    if (!value || typeof value !== "object") return;
+    for (const [key, child] of Object.entries(value)) {
+      // An evidence `family` is a name, not a std family.
+      if (
+        (key === "family" || key === "targetFamily") &&
+        child &&
+        typeof child === "object"
+      )
+        found.push([[...path, key], child]);
+      else if (key !== "examples")
+        visit(child, [...path, Array.isArray(value) ? Number(key) : key]);
+    }
+  };
+  visit(instruments, ["instruments"]);
+  return found;
+}
+
+const familiesIn =
+  (key: "digest" | "revision") =>
+  (document: { instruments: unknown[] }, context: z.RefinementCtx) => {
+    for (const [path, item] of families(document.instruments))
+      if (!(key in item))
+        context.addIssue({
+          code: "custom",
+          path,
+          message: `a format ${key === "digest" ? 2 : 1} family names its ${key}`,
+        });
+  };
+
+export const udlDocumentSchema = z
+  .strictObject({ udl: z.literal(UDL_FORMAT_VERSION), ...documentShape })
+  .superRefine(familiesIn("digest"));
+
+/** The format 1 reader: families carry the revision they were stored with. */
+export const udlFormat1DocumentSchema = z
+  .strictObject({ udl: z.literal(1), ...documentShape })
+  .superRefine(familiesIn("revision"));
+
+/** Any document a stored Build may hold, in the format it compiled to. */
+export const udlStoredDocumentSchema = z.discriminatedUnion("udl", [
+  udlDocumentSchema,
+  udlFormat1DocumentSchema,
+]);
 
 export type UdlFamily = z.infer<typeof udlFamilySchema>;
-export type UdlDocument = z.infer<typeof udlDocumentSchema>;
+export type UdlFormat1Family = z.infer<typeof udlFormat1FamilySchema>;
+export type UdlAnyFamily = UdlFamily | UdlFormat1Family;
+export type UdlDocument = z.infer<typeof udlStoredDocumentSchema>;
 export type UdlInstrument = z.infer<typeof udlInstrumentSchema>;
 export type UdlField = z.infer<typeof udlFieldSchema>;
 export type UdlValue = z.infer<typeof udlValueSchema>;
@@ -606,7 +666,7 @@ export function sameObjectField(
   right: UdlObjectField,
 ): boolean {
   const signature = (field: UdlObjectField) =>
-    writeJson(
+    canonicalJson(
       Object.fromEntries(
         Object.entries(field).filter(
           ([key, value]) =>

package/src/serialize.ts

@@ -0,0 +1,14 @@
+import { readUdl, UdlError } from "./validation.js";
+import { sha256, writeJson } from "./canonical.js";
+
+/** The stored bytes of a UDL document: its own format's layout, with a trailing newline. */
+export function serializeUdl(value: unknown): string {
+  const read = readUdl(value);
+  if (!read.ok) throw new UdlError(read.issues);
+  return `${writeJson(read.stored)}\n`;
+}
+
+/** SHA-256 over the stored document bytes, the `documentDigest` every Build carries. */
+export function documentDigest(value: unknown): string {
+  return sha256(serializeUdl(value));
+}

package/src/validation.ts

@@ -1,9 +1,8 @@
 import {
-  udlDocumentSchema,
+  UDL_FORMAT_VERSION,
   subjectPartyRoles,
   sameObjectField,
   type UdlDocument,
-  type UdlFamily,
   type UdlField,
   type UdlInstrument,
   type UdlValue,
@@ -16,6 +15,7 @@ import {
   type UdlObjectKind,
 } from "./schema.js";
 import { issue, type UdlIssue } from "./diagnostics.js";
+import { readableUdlFormat, sameFamily, udlFormatReaders } from "./formats.js";
 import { validateReportDefinition } from "./reporting-validation.js";
 import { analyzeInstrumentFinance } from "./finance.js";
 import { UDL_LIMITS } from "./limits.js";
@@ -140,11 +140,6 @@ function bounded(value: unknown): boolean {
 
 const overlap = (a: string | string[], b: string | string[]) =>
   targetIds(a).some((id) => targetIds(b).includes(id));
-const sameFamily = (actual: UdlFamily | undefined, expected: UdlFamily) =>
-  actual !== undefined &&
-  actual.module === expected.module &&
-  actual.exportPath === expected.exportPath &&
-  actual.revision === expected.revision;
 
 /** Union paths retain only fields with compatible types on every member. */
 function commonField(
@@ -449,6 +444,44 @@ function resolvePath(
 }
 
 export function validateUdl(value: unknown): UdlValidationResult {
+  const read = readUdl(value);
+  return read.ok ? { ok: true, value: read.document } : read;
+}
+
+/**
+ * Admit a document for a new Build. A new Build is the current format; the
+ * older formats in `udlFormatReaders` are readable only as stored Builds,
+ * through `validateUdl`.
+ */
+export function validateNewBuildUdl(value: unknown): UdlValidationResult {
+  const format =
+    value !== null && typeof value === "object"
+      ? (value as { udl?: unknown }).udl
+      : undefined;
+  if (format !== UDL_FORMAT_VERSION)
+    return {
+      ok: false,
+      issues: [
+        issue(
+          "udl_format_not_current",
+          "$.udl",
+          `a new Build is UDL format ${UDL_FORMAT_VERSION}; this document is format ${String(format)}`,
+        ),
+      ],
+    };
+  return validateUdl(value);
+}
+
+/**
+ * Read a document in the format it declares, then run the upgrade chain to
+ * the current format. `stored` is the parsed document in its own format, the
+ * one its digests cover; `document` is what the engine runs.
+ */
+export function readUdl(
+  value: unknown,
+):
+  | { ok: true; stored: unknown; document: UdlDocument }
+  | { ok: false; issues: UdlIssue[] } {
   if (!bounded(value))
     return {
       ok: false,
@@ -460,7 +493,29 @@ export function validateUdl(value: unknown): UdlValidationResult {
         ),
       ],
     };
-  const parsed = udlDocumentSchema.safeParse(value);
+  let format = readableUdlFormat(value);
+  if (format === undefined)
+    return {
+      ok: false,
+      issues: [
+        issue(
+          "udl_format_unknown",
+          "$.udl",
+          `UDL format ${String((value as { udl?: unknown }).udl)} has no reader in this engine`,
+        ),
+      ],
+    };
+  let reader = udlFormatReaders.get(format)!;
+  let parsed = reader.schema.safeParse(value);
+  const stored = parsed.data;
+  while (parsed.success && reader.upgrade) {
+    const next = reader.upgrade(parsed.data);
+    format = readableUdlFormat(next);
+    if (format === undefined)
+      throw new Error("a UDL upgrade step produced a format with no reader");
+    reader = udlFormatReaders.get(format)!;
+    parsed = reader.schema.safeParse(next);
+  }
   if (!parsed.success)
     return {
       ok: false,
@@ -475,7 +530,7 @@ export function validateUdl(value: unknown): UdlValidationResult {
         ),
       ),
     };
-  const document = parsed.data;
+  const document = parsed.data as UdlDocument;
   const issues: UdlIssue[] = [];
   const add = (
     path: string,
@@ -1765,7 +1820,7 @@ export function validateUdl(value: unknown): UdlValidationResult {
     visited.add(key);
   };
   for (const key of calls.keys()) visit(key);
-  return issues.length ? { ok: false, issues } : { ok: true, value: document };
+  return issues.length ? { ok: false, issues } : { ok: true, stored, document };
 }
 export function assertValidUdl(value: unknown): UdlDocument {
   const result = validateUdl(value);

package/dist/json.d.ts

@@ -1,2 +0,0 @@
-export declare function writeJson(value: unknown, depth?: number): string;
-//# sourceMappingURL=json.d.ts.map

package/dist/json.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAEA,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,SAAI,GAAG,MAAM,CA2B3D"}

package/dist/json.js

@@ -1,30 +0,0 @@
-const INDENT = "  ";
-export function writeJson(value, depth = 0) {
-    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;
-    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, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-//# sourceMappingURL=json.js.map

package/dist/json.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"json.js","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,GAAG,IAAI,CAAC;AAEpB,MAAM,UAAU,SAAS,CAAC,KAAc,EAAE,KAAK,GAAG,CAAC;IACjD,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAChD,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,MAAM,IAAI,SAAS,CAAC,8CAA8C,CAAC,CAAC;QACtE,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACpC,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;IAC7C,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QACpC,OAAO,MAAM,KAAK;aACf,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,GAAG,WAAW,GAAG,SAAS,CAAC,IAAI,EAAE,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC;aAC5D,IAAI,CAAC,KAAK,CAAC,KAAK,MAAM,GAAG,CAAC;IAC/B,CAAC;IAED,MAAM,MAAM,GAAG,KAAgC,CAAC;IAChD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IACxD,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACnC,OAAO,MAAM,IAAI;SACd,GAAG,CACF,CAAC,GAAG,EAAE,EAAE,CACN,GAAG,WAAW,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,EAAE,CAC/E;SACA,IAAI,CAAC,KAAK,CAAC,KAAK,MAAM,GAAG,CAAC;AAC/B,CAAC;AAED,SAAS,gBAAgB,CAAC,IAAY,EAAE,KAAa;IACnD,OAAO,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAClD,CAAC"}

package/src/json.ts

@@ -1,34 +0,0 @@
-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;
-}