bazis 0.96.1

package/library/boundary/json/normalizeBoundedJsonV1.ts

@@ -0,0 +1,256 @@
+import { types as nodeUtilTypes } from "node:util";
+import {
+  appendJsonPointerV1,
+  finalizeBazisDiagnosticsV1,
+  bazisDiagnosticV1,
+  type BazisDiagnosticsV1,
+  type BazisDiagnosticV1,
+} from "../diagnostics-v1";
+import {
+  boundaryJsonLimitsV1,
+  type BoundaryJsonLimitOverridesV1,
+  type BoundaryJsonLimitsV1,
+} from "./limits-v1";
+import type { BoundaryJsonObject, BoundaryJsonValue } from "./types-v1";
+
+export interface NormalizeBoundedJsonV1Options {
+  readonly limits?: BoundaryJsonLimitOverridesV1;
+}
+
+export type NormalizeBoundedJsonV1Result =
+  | ({ readonly ok: true; readonly value: BoundaryJsonValue } & BazisDiagnosticsV1)
+  | ({ readonly ok: false } & BazisDiagnosticsV1);
+
+const FORBIDDEN_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+const UTF8 = new TextEncoder();
+
+export function normalizeBoundedJsonV1(
+  input: unknown,
+  options: NormalizeBoundedJsonV1Options = {},
+): NormalizeBoundedJsonV1Result {
+  const limits = boundaryJsonLimitsV1(options.limits);
+  try {
+    const normalizer = new JsonValueNormalizerV1(limits);
+    const value = normalizer.normalize(input, "", 1);
+    const encodedBytes = UTF8.encode(JSON.stringify(value)).byteLength;
+    if (encodedBytes > limits.maxEncodedBytes) {
+      return failure(diagnostic(
+        "WF_JSON_TOO_LARGE",
+        "Normalized JSON input exceeds the encoded byte ceiling.",
+        "",
+      ));
+    }
+    return Object.freeze({
+      ok: true,
+      value,
+      diagnostics: Object.freeze([]),
+      truncated: false,
+    });
+  } catch (error) {
+    if (error instanceof JsonNormalizeFailureV1) {
+      return failure(error.diagnostic);
+    }
+    throw error;
+  }
+}
+
+class JsonValueNormalizerV1 {
+  private values = 0;
+  private objectMembers = 0;
+  private arrayItems = 0;
+  private totalStringBytes = 0;
+  private readonly active = new WeakSet<object>();
+
+  constructor(private readonly limits: BoundaryJsonLimitsV1) {}
+
+  normalize(value: unknown, pointer: string, depth: number): BoundaryJsonValue {
+    if (depth > this.limits.maxDepth) {
+      this.fail("WF_JSON_DEPTH_LIMIT", "JSON nesting depth exceeds the framework ceiling.", pointer);
+    }
+    this.values += 1;
+    if (this.values > this.limits.maxValues) {
+      this.fail("WF_JSON_VALUE_LIMIT", "JSON value count exceeds the framework ceiling.", pointer);
+    }
+
+    if (value === null || typeof value === "boolean") return value;
+    if (typeof value === "string") {
+      this.checkString(value, pointer, false);
+      return value;
+    }
+    if (typeof value === "number") {
+      if (!Number.isFinite(value) || (Number.isInteger(value) && !Number.isSafeInteger(value))) {
+        this.fail("WF_JSON_NUMBER_OUT_OF_RANGE", "JSON number is outside the supported finite safe range.", pointer);
+      }
+      return Object.is(value, -0) ? 0 : value;
+    }
+    if (typeof value !== "object") {
+      this.fail("WF_JSON_MALFORMED", "Value is not representable in the bounded JSON data model.", pointer);
+    }
+    if (nodeUtilTypes.isProxy(value)) {
+      this.fail("WF_JSON_MALFORMED", "Proxy objects are not representable in the bounded JSON data model.", pointer);
+    }
+    if (this.active.has(value)) {
+      this.fail("WF_JSON_MALFORMED", "Circular references are not representable in JSON.", pointer);
+    }
+
+    this.active.add(value);
+    try {
+      return Array.isArray(value)
+        ? this.normalizeArray(value, pointer, depth)
+        : this.normalizeObject(value, pointer, depth);
+    } finally {
+      this.active.delete(value);
+    }
+  }
+
+  private normalizeArray(value: readonly unknown[], pointer: string, depth: number): readonly BoundaryJsonValue[] {
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      this.fail("WF_JSON_MALFORMED", "JSON arrays cannot contain symbol properties.", pointer);
+    }
+    if (value.length > this.limits.maxItemsPerArray) {
+      this.fail("WF_JSON_ARRAY_LIMIT", "JSON array item count exceeds the framework ceiling.", pointer);
+    }
+    this.arrayItems += value.length;
+    if (this.arrayItems > this.limits.maxArrayItems) {
+      this.fail("WF_JSON_ARRAY_LIMIT", "Total JSON array items exceed the framework ceiling.", pointer);
+    }
+
+    for (const key in value) {
+      if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+      if (!isArrayIndex(key) || Number(key) >= value.length) {
+        this.fail("WF_JSON_MALFORMED", "JSON arrays cannot contain custom properties.", pointer);
+      }
+    }
+
+    const output: BoundaryJsonValue[] = [];
+    for (let index = 0; index < value.length; index += 1) {
+      const itemPointer = appendJsonPointerV1(pointer, index);
+      const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+      if (descriptor === undefined) {
+        this.fail("WF_JSON_MALFORMED", "Sparse arrays are not representable in JSON.", itemPointer);
+      }
+      if (!descriptor.enumerable || !("value" in descriptor)) {
+        this.fail("WF_JSON_MALFORMED", "JSON array items must be enumerable data properties.", itemPointer);
+      }
+      output.push(this.normalize(descriptor.value, itemPointer, depth + 1));
+    }
+    return Object.freeze(output);
+  }
+
+  private normalizeObject(value: object, pointer: string, depth: number): BoundaryJsonObject {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      this.fail("WF_JSON_MALFORMED", "JSON objects must be plain or null-prototype objects.", pointer);
+    }
+    const keys: string[] = [];
+    for (const key in value as Record<string, unknown>) {
+      if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+      keys.push(key);
+      if (keys.length > this.limits.maxMembersPerObject) {
+        this.fail("WF_JSON_OBJECT_LIMIT", "JSON object member count exceeds the framework ceiling.", pointer);
+      }
+    }
+    keys.sort(compareUtf16);
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      this.fail("WF_JSON_MALFORMED", "JSON objects cannot contain symbol properties.", pointer);
+    }
+    this.objectMembers += keys.length;
+    if (this.objectMembers > this.limits.maxObjectMembers) {
+      this.fail("WF_JSON_OBJECT_LIMIT", "Total JSON object members exceed the framework ceiling.", pointer);
+    }
+
+    const output = Object.create(null) as Record<string, BoundaryJsonValue>;
+    for (const key of keys) {
+      const propertyPointer = appendJsonPointerV1(pointer, key);
+      this.checkString(key, propertyPointer, true);
+      if (FORBIDDEN_KEYS.has(key)) {
+        this.fail(
+          "WF_JSON_FORBIDDEN_PROPERTY",
+          "The JSON property name is forbidden at every nesting level.",
+          propertyPointer,
+        );
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor === undefined || !descriptor.enumerable || !("value" in descriptor)) {
+        this.fail("WF_JSON_MALFORMED", "JSON object members must be enumerable data properties.", propertyPointer);
+      }
+      output[key] = this.normalize(descriptor.value, propertyPointer, depth + 1);
+    }
+    return Object.freeze(output);
+  }
+
+  private checkString(value: string, pointer: string, key: boolean): void {
+    const byteCeiling = key ? this.limits.maxKeyBytes : this.limits.maxStringBytes;
+    if (value.length > byteCeiling) {
+      this.fail(
+        key ? "WF_JSON_KEY_LIMIT" : "WF_JSON_STRING_LIMIT",
+        key
+          ? "JSON property name exceeds the framework byte ceiling."
+          : "JSON string exceeds the framework byte ceiling.",
+        pointer,
+      );
+    }
+    if (hasLoneSurrogate(value)) {
+      this.fail("WF_JSON_INVALID_UNICODE", "JSON strings must contain Unicode scalar values.", pointer);
+    }
+    const byteLength = UTF8.encode(value).byteLength;
+    if (byteLength > byteCeiling) {
+      this.fail(
+        key ? "WF_JSON_KEY_LIMIT" : "WF_JSON_STRING_LIMIT",
+        key
+          ? "JSON property name exceeds the framework byte ceiling."
+          : "JSON string exceeds the framework byte ceiling.",
+        pointer,
+      );
+    }
+    this.totalStringBytes += byteLength;
+    if (this.totalStringBytes > this.limits.maxTotalStringBytes) {
+      this.fail("WF_JSON_STRING_LIMIT", "Total decoded JSON string bytes exceed the framework ceiling.", pointer);
+    }
+  }
+
+  private fail(code: string, message: string, pointer: string): never {
+    throw new JsonNormalizeFailureV1(diagnostic(code, message, pointer));
+  }
+}
+
+class JsonNormalizeFailureV1 extends Error {
+  constructor(readonly diagnostic: BazisDiagnosticV1) {
+    super(diagnostic.message);
+    this.name = "JsonNormalizeFailureV1";
+  }
+}
+
+function failure(diagnosticValue: BazisDiagnosticV1): NormalizeBoundedJsonV1Result {
+  const finalized = finalizeBazisDiagnosticsV1([diagnosticValue]);
+  return Object.freeze({ ok: false, ...finalized });
+}
+
+function diagnostic(code: string, message: string, pointer: string): BazisDiagnosticV1 {
+  return bazisDiagnosticV1({ severity: "error", stage: "decode", code, message, pointer });
+}
+
+function hasLoneSurrogate(value: string): boolean {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 0xd800 && code <= 0xdbff) {
+      if (index + 1 >= value.length) return true;
+      const next = value.charCodeAt(index + 1);
+      if (next < 0xdc00 || next > 0xdfff) return true;
+      index += 1;
+      continue;
+    }
+    if (code >= 0xdc00 && code <= 0xdfff) return true;
+  }
+  return false;
+}
+
+function isArrayIndex(key: string): boolean {
+  if (!/^(0|[1-9][0-9]*)$/.test(key)) return false;
+  const index = Number(key);
+  return Number.isSafeInteger(index) && index >= 0;
+}
+
+function compareUtf16(left: string, right: string): number {
+  return left < right ? -1 : left > right ? 1 : 0;
+}

package/library/boundary/json/types-v1.ts

@@ -0,0 +1,11 @@
+export type BoundaryJsonPrimitive = null | boolean | number | string;
+export type BoundaryJsonValue = BoundaryJsonPrimitive | BoundaryJsonArray | BoundaryJsonObject;
+export type BoundaryJsonArray = readonly BoundaryJsonValue[];
+
+export interface BoundaryJsonObject {
+  readonly [key: string]: BoundaryJsonValue;
+}
+
+export function isBoundaryJsonObject(value: BoundaryJsonValue): value is BoundaryJsonObject {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/library/boundary/schema/boundarySchemaHashV1.ts

@@ -0,0 +1,6 @@
+import { canonicalJsonHashV1 } from "../serialization/canonicalJsonV1";
+import { BOUNDARY_SCHEMA_V1_DOMAIN, type BoundarySchemaV1 } from "./types-v1";
+
+export function boundarySchemaHashV1(schema: BoundarySchemaV1): string {
+  return canonicalJsonHashV1(BOUNDARY_SCHEMA_V1_DOMAIN, schema);
+}

package/library/boundary/schema/collectBoundaryValueDiagnosticsV1.ts

@@ -0,0 +1,325 @@
+import {
+  appendJsonPointerV1,
+  BAZIS_DIAGNOSTIC_LIMIT_V1,
+  bazisDiagnosticV1,
+  type BazisDiagnosticV1,
+} from "../diagnostics-v1";
+import { canonicalBoundaryJsonV1 } from "../serialization/canonicalJsonV1";
+import type { BoundaryJsonValue } from "../json/types-v1";
+import type {
+  BoundaryNumberSchemaV1,
+  BoundarySchemaV1,
+  BoundaryStringFormatV1,
+} from "./types-v1";
+
+export function collectBoundaryValueDiagnosticsV1(
+  schema: BoundarySchemaV1,
+  value: BoundaryJsonValue,
+  pointer: string,
+  diagnostics: BazisDiagnosticV1[],
+): void {
+  if (diagnostics.length > BAZIS_DIAGNOSTIC_LIMIT_V1) return;
+  if (value === null && (schema.type === "null" || schema.nullable === true)) {
+    return;
+  }
+
+  switch (schema.type) {
+    case "null":
+      diagnostics.push(valueDiagnostic(
+        "BSV1_VALUE_TYPE",
+        "Value must be null.",
+        pointer,
+      ));
+      return;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        diagnostics.push(valueDiagnostic("BSV1_VALUE_TYPE", "Value must be a boolean.", pointer));
+        return;
+      }
+      validateScalarEnum(schema.enum, value, pointer, diagnostics);
+      return;
+    case "string":
+      if (typeof value !== "string") {
+        diagnostics.push(valueDiagnostic("BSV1_VALUE_TYPE", "Value must be a string.", pointer));
+        return;
+      }
+      validateScalarEnum(schema.enum, value, pointer, diagnostics);
+      validateString(schema, value, pointer, diagnostics);
+      return;
+    case "number":
+      if (!isSupportedNumber(value)) {
+        diagnostics.push(valueDiagnostic("BSV1_VALUE_TYPE", "Value must be a finite supported number.", pointer));
+        return;
+      }
+      validateScalarEnum(schema.enum, value, pointer, diagnostics);
+      validateNumber(schema, value, pointer, diagnostics);
+      return;
+    case "integer":
+      if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+        diagnostics.push(valueDiagnostic("BSV1_VALUE_TYPE", "Value must be a safe integer.", pointer));
+        return;
+      }
+      validateScalarEnum(schema.enum, value, pointer, diagnostics);
+      validateNumber(schema, value, pointer, diagnostics);
+      return;
+    case "array":
+      if (!Array.isArray(value)) {
+        diagnostics.push(valueDiagnostic("BSV1_VALUE_TYPE", "Value must be an array.", pointer));
+        return;
+      }
+      if (schema.minItems !== undefined && value.length < schema.minItems) {
+        addDiagnostic(diagnostics, valueDiagnostic("BSV1_VALUE_MIN_ITEMS", "Array has fewer items than minItems.", pointer));
+      }
+      if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+        addDiagnostic(diagnostics, valueDiagnostic("BSV1_VALUE_MAX_ITEMS", "Array has more items than maxItems.", pointer));
+      }
+      if (schema.uniqueItems === true) {
+        validateUniqueItems(value, pointer, diagnostics);
+      }
+      for (let index = 0; index < value.length; index += 1) {
+        if (diagnostics.length > BAZIS_DIAGNOSTIC_LIMIT_V1) break;
+        collectBoundaryValueDiagnosticsV1(
+          schema.items,
+          value[index]!,
+          appendJsonPointerV1(pointer, index),
+          diagnostics,
+        );
+      }
+      return;
+    case "object":
+      if (!isJsonObject(value)) {
+        diagnostics.push(valueDiagnostic("BSV1_VALUE_TYPE", "Value must be an object.", pointer));
+        return;
+      }
+      validateObject(schema, value, pointer, diagnostics);
+  }
+}
+
+function validateString(
+  schema: Extract<BoundarySchemaV1, { readonly type: "string" }>,
+  value: string,
+  pointer: string,
+  diagnostics: BazisDiagnosticV1[],
+): void {
+  const length = [...value].length;
+  if (schema.minLength !== undefined && length < schema.minLength) {
+    addDiagnostic(diagnostics, valueDiagnostic("BSV1_VALUE_MIN_LENGTH", "String is shorter than minLength.", pointer));
+  }
+  if (schema.maxLength !== undefined && length > schema.maxLength) {
+    addDiagnostic(diagnostics, valueDiagnostic("BSV1_VALUE_MAX_LENGTH", "String is longer than maxLength.", pointer));
+  }
+  if (schema.format !== undefined && !matchesStringFormat(value, schema.format)) {
+    addDiagnostic(diagnostics, valueDiagnostic(
+      "BSV1_VALUE_FORMAT",
+      `String does not match the ${schema.format} format.`,
+      pointer,
+    ));
+  }
+}
+
+function validateNumber(
+  schema: BoundaryNumberSchemaV1 | Extract<BoundarySchemaV1, { readonly type: "integer" }>,
+  value: number,
+  pointer: string,
+  diagnostics: BazisDiagnosticV1[],
+): void {
+  if (schema.minimum !== undefined && value < schema.minimum) {
+    addDiagnostic(diagnostics, valueDiagnostic("BSV1_VALUE_MINIMUM", "Number is below minimum.", pointer));
+  }
+  if (schema.maximum !== undefined && value > schema.maximum) {
+    addDiagnostic(diagnostics, valueDiagnostic("BSV1_VALUE_MAXIMUM", "Number is above maximum.", pointer));
+  }
+  if (schema.exclusiveMinimum !== undefined && value <= schema.exclusiveMinimum) {
+    addDiagnostic(diagnostics, valueDiagnostic("BSV1_VALUE_EXCLUSIVE_MINIMUM", "Number is not above exclusiveMinimum.", pointer));
+  }
+  if (schema.exclusiveMaximum !== undefined && value >= schema.exclusiveMaximum) {
+    addDiagnostic(diagnostics, valueDiagnostic("BSV1_VALUE_EXCLUSIVE_MAXIMUM", "Number is not below exclusiveMaximum.", pointer));
+  }
+}
+
+function validateObject(
+  schema: Extract<BoundarySchemaV1, { readonly type: "object" }>,
+  value: Readonly<Record<string, BoundaryJsonValue>>,
+  pointer: string,
+  diagnostics: BazisDiagnosticV1[],
+): void {
+  const keys = Object.keys(value).sort(compareText);
+  if (schema.minProperties !== undefined && keys.length < schema.minProperties) {
+    addDiagnostic(diagnostics, valueDiagnostic(
+      "BSV1_VALUE_MIN_PROPERTIES",
+      "Object has fewer properties than minProperties.",
+      pointer,
+    ));
+  }
+  if (schema.maxProperties !== undefined && keys.length > schema.maxProperties) {
+    addDiagnostic(diagnostics, valueDiagnostic(
+      "BSV1_VALUE_MAX_PROPERTIES",
+      "Object has more properties than maxProperties.",
+      pointer,
+    ));
+  }
+
+  for (const required of schema.required ?? []) {
+    if (diagnostics.length > BAZIS_DIAGNOSTIC_LIMIT_V1) break;
+    if (!Object.prototype.hasOwnProperty.call(value, required)) {
+      addDiagnostic(diagnostics, valueDiagnostic(
+        "BSV1_VALUE_REQUIRED",
+        "Required object property is missing.",
+        appendJsonPointerV1(pointer, required),
+      ));
+    }
+  }
+
+  const properties = schema.properties ?? Object.freeze(Object.create(null)) as Readonly<Record<string, BoundarySchemaV1>>;
+  const additional = schema.additionalProperties ?? false;
+  for (const key of keys) {
+    if (diagnostics.length > BAZIS_DIAGNOSTIC_LIMIT_V1) break;
+    const propertyPointer = appendJsonPointerV1(pointer, key);
+    const propertySchema = properties[key];
+    if (propertySchema !== undefined) {
+      collectBoundaryValueDiagnosticsV1(propertySchema, value[key]!, propertyPointer, diagnostics);
+      continue;
+    }
+    if (additional === false) {
+      addDiagnostic(diagnostics, valueDiagnostic(
+        "BSV1_VALUE_ADDITIONAL_PROPERTY",
+        "Additional object properties are not allowed.",
+        propertyPointer,
+      ));
+      continue;
+    }
+    collectBoundaryValueDiagnosticsV1(additional, value[key]!, propertyPointer, diagnostics);
+  }
+}
+
+function validateScalarEnum<T extends null | boolean | number | string>(
+  values: readonly T[] | undefined,
+  value: T,
+  pointer: string,
+  diagnostics: BazisDiagnosticV1[],
+): void {
+  if (values !== undefined && !values.some((candidate) => Object.is(candidate, value))) {
+    addDiagnostic(diagnostics, valueDiagnostic("BSV1_VALUE_ENUM", "Value is not one of the allowed enum values.", pointer));
+  }
+}
+
+function validateUniqueItems(
+  values: readonly BoundaryJsonValue[],
+  pointer: string,
+  diagnostics: BazisDiagnosticV1[],
+): void {
+  const firstByCanonicalValue = new Map<string, number>();
+  for (let index = 0; index < values.length; index += 1) {
+    if (diagnostics.length > BAZIS_DIAGNOSTIC_LIMIT_V1) break;
+    const canonical = canonicalBoundaryJsonV1(values[index]);
+    const first = firstByCanonicalValue.get(canonical);
+    if (first !== undefined) {
+      addDiagnostic(diagnostics, valueDiagnostic(
+        "BSV1_VALUE_UNIQUE_ITEMS",
+        `Array item duplicates item at index ${first}.`,
+        appendJsonPointerV1(pointer, index),
+      ));
+    } else {
+      firstByCanonicalValue.set(canonical, index);
+    }
+  }
+}
+
+function matchesStringFormat(value: string, format: BoundaryStringFormatV1): boolean {
+  switch (format) {
+    case "date":
+      return isDate(value);
+    case "time":
+      return isTime(value);
+    case "date-time": {
+      const separator = value.indexOf("T");
+      return separator > 0 && isDate(value.slice(0, separator)) && isTime(value.slice(separator + 1));
+    }
+    case "uuid":
+      return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(value);
+    case "email":
+      return isEmail(value);
+    case "decimal":
+      return /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?$/.test(value);
+    case "int64-string":
+      return isInt64String(value);
+  }
+}
+
+function isDate(value: string): boolean {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (match === null) return false;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  if (month < 1 || month > 12) return false;
+  const days = [31, isLeapYear(year) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  return day >= 1 && day <= days[month - 1]!;
+}
+
+function isTime(value: string): boolean {
+  const match = /^(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:Z|([+-])(\d{2}):(\d{2}))$/.exec(value);
+  if (match === null) return false;
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  const second = Number(match[3]);
+  const offsetHour = match[5] === undefined ? 0 : Number(match[5]);
+  const offsetMinute = match[6] === undefined ? 0 : Number(match[6]);
+  return hour <= 23 && minute <= 59 && second <= 59 && offsetHour <= 23 && offsetMinute <= 59;
+}
+
+function isEmail(value: string): boolean {
+  if (value.length > 254 || /[\u0000-\u0020\u007f]/.test(value)) return false;
+  const separator = value.lastIndexOf("@");
+  if (separator <= 0 || separator !== value.indexOf("@")) return false;
+  const local = value.slice(0, separator);
+  const domain = value.slice(separator + 1);
+  if (local.length > 64 || local.startsWith(".") || local.endsWith(".") || local.includes("..")) return false;
+  if (!/^[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+$/.test(local)) return false;
+  if (domain.length === 0 || domain.length > 253) return false;
+  return domain.split(".").every((label) => (
+    label.length >= 1
+    && label.length <= 63
+    && /^[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?$/.test(label)
+  ));
+}
+
+function isInt64String(value: string): boolean {
+  if (!/^-?(?:0|[1-9][0-9]*)$/.test(value)) return false;
+  try {
+    const integer = BigInt(value);
+    return integer >= -9_223_372_036_854_775_808n && integer <= 9_223_372_036_854_775_807n;
+  } catch {
+    return false;
+  }
+}
+
+function isLeapYear(year: number): boolean {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+
+function isSupportedNumber(value: BoundaryJsonValue): value is number {
+  return typeof value === "number"
+    && Number.isFinite(value)
+    && (!Number.isInteger(value) || Number.isSafeInteger(value));
+}
+
+function isJsonObject(value: BoundaryJsonValue): value is Readonly<Record<string, BoundaryJsonValue>> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function valueDiagnostic(code: string, message: string, pointer: string): BazisDiagnosticV1 {
+  return bazisDiagnosticV1({ severity: "error", stage: "schema", code, message, pointer });
+}
+
+function addDiagnostic(
+  diagnostics: BazisDiagnosticV1[],
+  diagnostic: BazisDiagnosticV1,
+): void {
+  if (diagnostics.length > BAZIS_DIAGNOSTIC_LIMIT_V1) return;
+  diagnostics.push(diagnostic);
+}
+
+function compareText(left: string, right: string): number {
+  return left < right ? -1 : left > right ? 1 : 0;
+}