@honua/react 0.1.0-beta.0 → 0.1.2-beta.0

package/contract/schema.js

@@ -0,0 +1,2483 @@
+/**
+ * Experimental vendor-neutral source schema v2.
+ *
+ * This module is the production projection of the contract accepted in
+ * `docs/decisions/vendor-neutral-source-contract-v2.md`. It deliberately lives
+ * beside, rather than replacing, the legacy Esri-shaped `SourceSchema`: the
+ * discovery rollout dual-reads both contracts until the 1.0 cutover.
+ *
+ * @experimental
+ * @module
+ */
+import { canonicalStringify, sha256, toJsonValue } from "../query-planner/canonical.js";
+import validateProjJsonV07Crs from "./generated/projjson-v0.7-crs-validator.js";
+import { SOURCE_SCHEMA_V2_KIND, SOURCE_SCHEMA_V2_VERSION } from "./schema-envelope.js";
+import { PROTOCOLS } from "./types.js";
+export { SOURCE_SCHEMA_V2_KIND, SOURCE_SCHEMA_V2_VERSION } from "./schema-envelope.js";
+export const SOURCE_SCHEMA_V2_FINGERPRINT_DOMAIN = "honua:schema:2.0";
+const SHA256_PATTERN = /^sha256:[0-9a-f]{64}$/;
+const EXTENSION_ID_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9_-]*\.)+[A-Za-z0-9][A-Za-z0-9_-]*$/;
+const MAX_NATIVE_DEFINITION_BYTES = 64 * 1024;
+const MAX_PROJJSON_BYTES = 64 * 1024;
+const MAX_FIELD_DOMAIN_BYTES = 1024 * 1024;
+const MAX_CODED_DOMAIN_VALUES = 10_000;
+const MAX_SCHEMA_BYTES = 4 * 1024 * 1024;
+const MAX_TYPE_DEPTH = 32;
+// A struct level adds a type object, fields array, and field object to the raw
+// graph. Keep this defensive prewalk high enough for the independently
+// enforced 32-level logical-type limit while still bounding adversarial input.
+const MAX_SCHEMA_GRAPH_DEPTH = MAX_TYPE_DEPTH * 4 + 32;
+const MAX_JSON_VALUE_DEPTH = 32;
+const MAX_JSON_NODE_COUNT = 100_000;
+const PROJJSON_V07_SCHEMA = "https://proj.org/schemas/v0.7/projjson.schema.json";
+const PROJJSON_V07_TYPES = new Set([
+    "GeographicCRS",
+    "GeodeticCRS",
+    "ProjectedCRS",
+    "VerticalCRS",
+    "CompoundCRS",
+    "BoundCRS",
+    "EngineeringCRS",
+    "ParametricCRS",
+    "TemporalCRS",
+    "DerivedProjectedCRS",
+    "DerivedGeographicCRS",
+    "DerivedGeodeticCRS",
+    "DerivedVerticalCRS",
+    "DerivedEngineeringCRS",
+    "DerivedTemporalCRS",
+    "DerivedParametricCRS",
+]);
+/** Create, validate, canonicalize, fingerprint, and deeply freeze a schema. */
+export function createSourceSchemaV2(input) {
+    const plainInput = object(toPlainJson(input), "$");
+    const candidate = {
+        ...plainInput,
+        kind: SOURCE_SCHEMA_V2_KIND,
+        version: SOURCE_SCHEMA_V2_VERSION,
+    };
+    const normalized = normalizeSchema(candidate, false);
+    const fingerprint = schemaFingerprint(normalized);
+    const schema = { ...normalized, fingerprint };
+    assertSchemaByteBound(schema);
+    return deepFreeze(schema);
+}
+/** Parse a serialized/object schema, rejecting future versions and fingerprint drift. */
+export function parseSourceSchemaV2(value) {
+    let parsed;
+    if (typeof value === "string") {
+        if (value.length > MAX_SCHEMA_BYTES || utf8ByteLength(value) > MAX_SCHEMA_BYTES) {
+            throw new TypeError(`Serialized SourceSchemaV2 exceeds the ${MAX_SCHEMA_BYTES}-byte bound`);
+        }
+        try {
+            parsed = JSON.parse(value);
+        }
+        catch (cause) {
+            throw new TypeError("SourceSchemaV2 must be valid JSON", { cause });
+        }
+        assertUniqueJsonObjectNames(value);
+    }
+    else {
+        parsed = value;
+    }
+    const candidate = toPlainJson(parsed);
+    const record = object(candidate, "$", [
+        "kind",
+        "version",
+        "fingerprint",
+        "fields",
+        "key",
+        "geometry",
+        "temporal",
+        "openContent",
+        "provenance",
+        "extensions",
+    ]);
+    if (record.kind !== SOURCE_SCHEMA_V2_KIND || record.version !== SOURCE_SCHEMA_V2_VERSION) {
+        throw new TypeError(`Unsupported source schema discriminator; expected ${SOURCE_SCHEMA_V2_KIND}@${SOURCE_SCHEMA_V2_VERSION}`);
+    }
+    if (typeof record.fingerprint !== "string" || !SHA256_PATTERN.test(record.fingerprint)) {
+        throw new TypeError("SourceSchemaV2.fingerprint must be a lowercase SHA-256 digest");
+    }
+    const normalized = normalizeSchema(record, true);
+    const computed = schemaFingerprint(normalized);
+    if (record.fingerprint !== computed)
+        throw new TypeError("SourceSchemaV2 fingerprint does not match canonical content");
+    const schema = { ...normalized, fingerprint: computed };
+    assertSchemaByteBound(schema);
+    return deepFreeze(schema);
+}
+/** Canonical JSON form suitable for cache/storage interchange. */
+export function serializeSourceSchemaV2(schema) {
+    const verified = parseSourceSchemaV2(schema);
+    return canonicalStringify(toJsonValue(verified));
+}
+/** JSON-safe clone whose fingerprint and nested immutability are revalidated. */
+export function cloneSourceSchemaV2(schema) {
+    return parseSourceSchemaV2(serializeSourceSchemaV2(schema));
+}
+export function sourceSchemaIdentity(schema) {
+    if (schema.state === "known") {
+        const verified = parseSourceSchemaV2(schema.value);
+        return deepFreeze({ state: "known", fingerprint: verified.fingerprint });
+    }
+    if (!includes(["not-requested", "request-failed", "not-advertised", "invalid"], schema.reason)) {
+        throw new TypeError("SchemaState.reason is invalid");
+    }
+    return deepFreeze({ state: "unavailable", reason: schema.reason, provenance: cloneProvenance(schema.provenance) });
+}
+/** @internal Adapter boundary for degrading malformed CRS metadata without losing its enclosing schema. */
+export function validateSourceCrsDefinition(value) {
+    return deepFreeze(normalizeCrsDefinition(toPlainJson(value), "$.crs"));
+}
+/** @internal Query/spatial boundary for a fully validated executable CRS binding. */
+export function validateExecutableCrsBinding(value, path = "$.crs") {
+    const binding = normalizeCrsBinding(toPlainJson(value), path);
+    if (!isResolvedCrsDefinition(binding.definition)) {
+        throw new TypeError(`${path}.definition must be resolved before spatial execution`);
+    }
+    if (binding.coordinateOrder.state !== "known") {
+        throw new TypeError(`${path}.coordinateOrder must be known before spatial execution`);
+    }
+    return deepFreeze({
+        definition: binding.definition,
+        coordinateOrder: binding.coordinateOrder,
+        ...(binding.coordinateEpoch === undefined ? {} : { coordinateEpoch: binding.coordinateEpoch }),
+        provenance: binding.provenance,
+    });
+}
+function normalizeSchema(value, hasFingerprint) {
+    const allowed = [
+        "kind",
+        "version",
+        ...(hasFingerprint ? ["fingerprint"] : []),
+        "fields",
+        "key",
+        "geometry",
+        "temporal",
+        "openContent",
+        "provenance",
+        "extensions",
+    ];
+    const record = object(value, "$", allowed);
+    if (record.kind !== SOURCE_SCHEMA_V2_KIND || record.version !== SOURCE_SCHEMA_V2_VERSION) {
+        throw new TypeError(`SourceSchemaV2 must use ${SOURCE_SCHEMA_V2_KIND}@${SOURCE_SCHEMA_V2_VERSION}`);
+    }
+    const fields = array(record.fields, "$.fields").map((field, index) => normalizeField(field, `$.fields[${index}]`, 0));
+    fields.sort(compareFields);
+    unique(fields.map((field) => field.name), "SourceSchemaV2 field names");
+    unique(fields.map((field) => canonicalStringify(toJsonValue(field.path))), "SourceSchemaV2 field paths");
+    const names = new Set(fields.map((field) => field.name));
+    const key = normalizeKey(record.key, names);
+    const geometry = normalizeGeometrySchema(record.geometry, names, fields);
+    const temporal = normalizeTemporalSchema(record.temporal, names, fields);
+    validateFieldSemantics(fields, key, geometry, temporal);
+    if (record.openContent !== "closed" && record.openContent !== "open" && record.openContent !== "unknown") {
+        throw new TypeError("SourceSchemaV2.openContent is invalid");
+    }
+    const provenance = normalizeProvenanceArray(record.provenance, "$.provenance");
+    const extensions = record.extensions === undefined ? undefined : normalizeExtensions(record.extensions, "$.extensions");
+    return {
+        kind: SOURCE_SCHEMA_V2_KIND,
+        version: SOURCE_SCHEMA_V2_VERSION,
+        fields,
+        key,
+        geometry,
+        temporal,
+        openContent: record.openContent,
+        provenance,
+        ...(extensions ? { extensions } : {}),
+    };
+}
+function normalizeField(value, path, depth) {
+    const record = object(value, path, [
+        "name",
+        "path",
+        "title",
+        "description",
+        "type",
+        "nullability",
+        "mutability",
+        "roles",
+        "defaultValue",
+        "domain",
+        "constraints",
+        "native",
+        "extensions",
+    ]);
+    const name = text(record.name, `${path}.name`);
+    const fieldPath = nonEmptyTextArray(record.path, `${path}.path`);
+    const type = normalizeLogicalType(record.type, `${path}.type`, depth + 1);
+    if (!includes(["nullable", "non-nullable", "unknown"], record.nullability)) {
+        throw new TypeError(`${path}.nullability is invalid`);
+    }
+    if (!includes(["read-only", "read-write", "write-once", "unknown"], record.mutability)) {
+        throw new TypeError(`${path}.mutability is invalid`);
+    }
+    const roles = [
+        ...new Set(array(record.roles, `${path}.roles`).map((role, index) => fieldRole(role, `${path}.roles[${index}]`))),
+    ].sort(compareCanonical);
+    const domain = normalizeDomain(record.domain, `${path}.domain`, type);
+    const constraints = normalizeConstraints(record.constraints, `${path}.constraints`, type);
+    const native = array(record.native, `${path}.native`).map((item, index) => normalizeNative(item, `${path}.native[${index}]`));
+    const extensions = record.extensions === undefined ? undefined : normalizeExtensions(record.extensions, `${path}.extensions`);
+    const defaultValue = Object.hasOwn(record, "defaultValue")
+        ? jsonValue(record.defaultValue, `${path}.defaultValue`)
+        : undefined;
+    if (defaultValue === null && record.nullability === "non-nullable") {
+        throw new TypeError(`${path}.defaultValue cannot be null for a non-nullable field`);
+    }
+    if (defaultValue !== undefined && !logicalValueCompatible(defaultValue, type)) {
+        throw new TypeError(`${path}.defaultValue is incompatible with logical type ${type.kind}`);
+    }
+    const normalized = {
+        name,
+        path: fieldPath,
+        ...(record.title === undefined ? {} : { title: text(record.title, `${path}.title`) }),
+        ...(record.description === undefined ? {} : { description: text(record.description, `${path}.description`) }),
+        type,
+        nullability: record.nullability,
+        mutability: record.mutability,
+        roles,
+        ...(Object.hasOwn(record, "defaultValue") ? { defaultValue: defaultValue } : {}),
+        domain,
+        constraints,
+        native,
+        ...(extensions ? { extensions } : {}),
+    };
+    const domainBytes = new TextEncoder().encode(canonicalStringify(toJsonValue({ domain: normalized.domain, constraints: normalized.constraints }))).byteLength;
+    if (domainBytes > MAX_FIELD_DOMAIN_BYTES) {
+        throw new TypeError(`${path} domain and constraints exceed the ${MAX_FIELD_DOMAIN_BYTES}-byte bound`);
+    }
+    return normalized;
+}
+function normalizeLogicalType(value, path, depth) {
+    if (depth > MAX_TYPE_DEPTH)
+        throw new TypeError(`${path} exceeds maximum logical-type depth ${MAX_TYPE_DEPTH}`);
+    const record = object(value, path);
+    const kind = record.kind;
+    switch (kind) {
+        case "boolean":
+        case "uuid":
+        case "date":
+        case "json":
+        case "geometry":
+            exactKeys(record, path, ["kind"]);
+            return { kind };
+        case "integer": {
+            exactKeys(record, path, ["kind", "bits", "signed", "jsonEncoding"]);
+            if (!includes([8, 16, 32, 64], record.bits))
+                throw new TypeError(`${path}.bits is invalid`);
+            if (typeof record.signed !== "boolean")
+                throw new TypeError(`${path}.signed must be boolean`);
+            if (record.jsonEncoding !== "number" && record.jsonEncoding !== "string") {
+                throw new TypeError(`${path}.jsonEncoding is invalid`);
+            }
+            return { kind, bits: record.bits, signed: record.signed, jsonEncoding: record.jsonEncoding };
+        }
+        case "float":
+            exactKeys(record, path, ["kind", "bits"]);
+            if (record.bits !== 32 && record.bits !== 64)
+                throw new TypeError(`${path}.bits is invalid`);
+            return { kind, bits: record.bits };
+        case "decimal": {
+            exactKeys(record, path, ["kind", "precision", "scale", "jsonEncoding"]);
+            if (record.jsonEncoding !== "number" && record.jsonEncoding !== "string") {
+                throw new TypeError(`${path}.jsonEncoding is invalid`);
+            }
+            const precision = optionalPositiveInteger(record.precision, `${path}.precision`);
+            const scale = optionalNonNegativeInteger(record.scale, `${path}.scale`);
+            if (precision !== undefined && scale !== undefined && scale > precision) {
+                throw new TypeError(`${path}.scale must not exceed precision`);
+            }
+            return {
+                kind,
+                ...(precision === undefined ? {} : { precision }),
+                ...(scale === undefined ? {} : { scale }),
+                jsonEncoding: record.jsonEncoding,
+            };
+        }
+        case "string": {
+            exactKeys(record, path, ["kind", "maxLength", "encoding"]);
+            const maxLength = optionalNonNegativeInteger(record.maxLength, `${path}.maxLength`);
+            return {
+                kind,
+                ...(maxLength === undefined ? {} : { maxLength }),
+                ...(record.encoding === undefined ? {} : { encoding: text(record.encoding, `${path}.encoding`) }),
+            };
+        }
+        case "binary":
+            exactKeys(record, path, ["kind", "encoding"]);
+            if (!includes(["base64", "url", "opaque"], record.encoding)) {
+                throw new TypeError(`${path}.encoding is invalid`);
+            }
+            return { kind, encoding: record.encoding };
+        case "time":
+        case "duration":
+            exactKeys(record, path, ["kind", "unit"]);
+            return { kind, unit: temporalUnit(record.unit, `${path}.unit`) };
+        case "timestamp":
+            exactKeys(record, path, ["kind", "unit", "timezone"]);
+            if (!includes(["utc", "offset", "local", "unknown"], record.timezone)) {
+                throw new TypeError(`${path}.timezone is invalid`);
+            }
+            return { kind, unit: temporalUnit(record.unit, `${path}.unit`), timezone: record.timezone };
+        case "list":
+            exactKeys(record, path, ["kind", "element"]);
+            return { kind, element: normalizeLogicalType(record.element, `${path}.element`, depth + 1) };
+        case "struct": {
+            exactKeys(record, path, ["kind", "fields"]);
+            const fields = array(record.fields, `${path}.fields`).map((field, index) => 
+            // normalizeField advances once when it enters the child's logical
+            // type. Passing the current type depth avoids counting a struct field
+            // wrapper as a second logical-type level.
+            normalizeField(field, `${path}.fields[${index}]`, depth));
+            fields.sort(compareFields);
+            unique(fields.map((field) => field.name), `${path} field names`);
+            unique(fields.map((field) => canonicalStringify(toJsonValue(field.path))), `${path} field paths`);
+            return { kind, fields };
+        }
+        case "union": {
+            exactKeys(record, path, ["kind", "members"]);
+            const members = array(record.members, `${path}.members`).map((member, index) => normalizeLogicalType(member, `${path}.members[${index}]`, depth + 1));
+            if (members.length < 2)
+                throw new TypeError(`${path}.members must contain at least two types`);
+            members.sort(compareCanonical);
+            unique(members.map((member) => canonicalStringify(toJsonValue(typeFingerprintProjection(member)))), `${path}.members`);
+            return { kind, members: members };
+        }
+        case "unknown":
+            exactKeys(record, path, ["kind", "reason", "native"]);
+            if (!includes(["missing", "unrecognized", "conflicting", "unsupported"], record.reason)) {
+                throw new TypeError(`${path}.reason is invalid`);
+            }
+            return {
+                kind,
+                reason: record.reason,
+                ...(record.native === undefined ? {} : { native: normalizeNative(record.native, `${path}.native`) }),
+            };
+        default:
+            throw new TypeError(`${path}.kind is not a recognized logical type`);
+    }
+}
+function normalizeDomain(value, path, type) {
+    const record = object(value, path);
+    switch (record.state) {
+        case "none":
+            exactKeys(record, path, ["state", "reason"]);
+            if (record.reason !== "unconstrained" && record.reason !== "not-applicable") {
+                throw new TypeError(`${path}.reason is invalid`);
+            }
+            return { state: "none", reason: record.reason };
+        case "coded": {
+            exactKeys(record, path, ["state", "values", "openness"]);
+            if (!includes(["closed", "open", "unknown"], record.openness)) {
+                throw new TypeError(`${path}.openness is invalid`);
+            }
+            const rawValues = array(record.values, `${path}.values`);
+            if (rawValues.length === 0 || rawValues.length > MAX_CODED_DOMAIN_VALUES) {
+                throw new TypeError(`${path}.values must contain 1-${MAX_CODED_DOMAIN_VALUES} entries`);
+            }
+            const values = rawValues.map((entry, index) => {
+                const coded = object(entry, `${path}.values[${index}]`, ["value", "label", "description", "extensions"]);
+                const domainValue = coded.value;
+                if (domainValue === null ||
+                    (typeof domainValue !== "string" && typeof domainValue !== "number" && typeof domainValue !== "boolean") ||
+                    (typeof domainValue === "number" && !Number.isFinite(domainValue))) {
+                    throw new TypeError(`${path}.values[${index}].value must be a finite JSON scalar`);
+                }
+                if (!domainValueCompatible(domainValue, type)) {
+                    throw new TypeError(`${path}.values[${index}].value is incompatible with logical type ${type.kind}`);
+                }
+                const extensions = coded.extensions === undefined
+                    ? undefined
+                    : normalizeExtensions(coded.extensions, `${path}.values[${index}].extensions`);
+                return {
+                    value: domainValue,
+                    ...(coded.label === undefined ? {} : { label: text(coded.label, `${path}.values[${index}].label`) }),
+                    ...(coded.description === undefined
+                        ? {}
+                        : { description: text(coded.description, `${path}.values[${index}].description`) }),
+                    ...(extensions ? { extensions } : {}),
+                };
+            });
+            values.sort((left, right) => compareCanonical(left.value, right.value));
+            unique(values.map((entry) => canonicalStringify(toJsonValue(entry.value))), `${path}.values`);
+            return { state: "coded", values: values, openness: record.openness };
+        }
+        case "range": {
+            exactKeys(record, path, ["state", "minimum", "maximum", "unit"]);
+            if (record.minimum === undefined && record.maximum === undefined) {
+                throw new TypeError(`${path} must include a minimum or maximum`);
+            }
+            const minimum = record.minimum === undefined ? undefined : normalizeRangeEndpoint(record.minimum, `${path}.minimum`);
+            const maximum = record.maximum === undefined ? undefined : normalizeRangeEndpoint(record.maximum, `${path}.maximum`);
+            if (!rangeType(type))
+                throw new TypeError(`${path} range is incompatible with logical type ${type.kind}`);
+            if (minimum && !domainValueCompatible(minimum.value, type)) {
+                throw new TypeError(`${path}.minimum is incompatible with logical type ${type.kind}`);
+            }
+            if (maximum && !domainValueCompatible(maximum.value, type)) {
+                throw new TypeError(`${path}.maximum is incompatible with logical type ${type.kind}`);
+            }
+            if (minimum && maximum) {
+                if (typeof minimum.value !== typeof maximum.value)
+                    throw new TypeError(`${path} endpoints use conflicting encodings`);
+                const comparison = compareDomainValues(minimum.value, maximum.value, type);
+                if (comparison === undefined) {
+                    throw new TypeError(`${path} endpoints cannot be ordered deterministically`);
+                }
+                if (comparison > 0) {
+                    throw new TypeError(`${path}.minimum must not exceed maximum`);
+                }
+                if (comparison === 0 && (!minimum.inclusive || !maximum.inclusive)) {
+                    throw new TypeError(`${path} equal endpoints must both be inclusive`);
+                }
+            }
+            return {
+                state: "range",
+                ...(minimum ? { minimum } : {}),
+                ...(maximum ? { maximum } : {}),
+                ...(record.unit === undefined ? {} : { unit: text(record.unit, `${path}.unit`) }),
+            };
+        }
+        case "unknown":
+            exactKeys(record, path, ["state", "reason", "native"]);
+            if (!includes(["not-reported", "unrecognized", "conflicting", "limit-exceeded"], record.reason)) {
+                throw new TypeError(`${path}.reason is invalid`);
+            }
+            return {
+                state: "unknown",
+                reason: record.reason,
+                ...(record.native === undefined ? {} : { native: normalizeNative(record.native, `${path}.native`) }),
+            };
+        default:
+            throw new TypeError(`${path}.state is invalid`);
+    }
+}
+function normalizeRangeEndpoint(value, path) {
+    const record = object(value, path, ["value", "inclusive"]);
+    if ((typeof record.value !== "number" && typeof record.value !== "string") || record.value === "") {
+        throw new TypeError(`${path}.value must be a number or non-empty string`);
+    }
+    if (typeof record.value === "number" && !Number.isFinite(record.value))
+        throw new TypeError(`${path}.value must be finite`);
+    if (typeof record.inclusive !== "boolean")
+        throw new TypeError(`${path}.inclusive must be boolean`);
+    return { value: record.value, inclusive: record.inclusive };
+}
+function normalizeConstraints(value, path, type) {
+    const record = object(value, path);
+    if (record.state === "none") {
+        exactKeys(record, path, ["state"]);
+        return { state: "none" };
+    }
+    if (record.state === "unknown") {
+        exactKeys(record, path, ["state", "reason", "native"]);
+        if (!includes(["not-reported", "unrecognized", "conflicting", "limit-exceeded"], record.reason)) {
+            throw new TypeError(`${path}.reason is invalid`);
+        }
+        return {
+            state: "unknown",
+            reason: record.reason,
+            ...(record.native === undefined ? {} : { native: normalizeNative(record.native, `${path}.native`) }),
+        };
+    }
+    if (record.state !== "known" && record.state !== "partial")
+        throw new TypeError(`${path}.state is invalid`);
+    exactKeys(record, path, record.state === "known" ? ["state", "values"] : ["state", "values", "reason", "native"]);
+    const values = array(record.values, `${path}.values`).map((entry, index) => normalizeConstraint(entry, `${path}.values[${index}]`, type));
+    if (values.length === 0)
+        throw new TypeError(`${path}.values must be non-empty`);
+    values.sort((left, right) => compareCanonical(left.kind, right.kind));
+    unique(values.map((entry) => entry.kind), `${path}.values constraint kinds`);
+    if (record.state === "known")
+        return { state: "known", values: values };
+    if (!includes(["unrecognized", "conflicting", "limit-exceeded"], record.reason)) {
+        throw new TypeError(`${path}.reason is invalid`);
+    }
+    const native = array(record.native, `${path}.native`).map((entry, index) => normalizeNative(entry, `${path}.native[${index}]`));
+    if (native.length === 0)
+        throw new TypeError(`${path}.native must be non-empty`);
+    native.sort((left, right) => compareCanonical(nativeIdentity(left), nativeIdentity(right)));
+    unique(native.map((entry) => canonicalStringify(nativeIdentity(entry))), `${path}.native identities`);
+    return {
+        state: "partial",
+        values: values,
+        reason: record.reason,
+        native: native,
+    };
+}
+function normalizeConstraint(value, path, type) {
+    const record = object(value, path);
+    const kind = text(record.kind, `${path}.kind`);
+    if (kind === "length") {
+        exactKeys(record, path, ["kind", "minimum", "maximum"]);
+        if (type.kind !== "string" && type.kind !== "binary" && type.kind !== "list") {
+            throw new TypeError(`${path} length constraint is incompatible with ${type.kind}`);
+        }
+        const minimum = optionalNonNegativeInteger(record.minimum, `${path}.minimum`);
+        const maximum = optionalNonNegativeInteger(record.maximum, `${path}.maximum`);
+        if (minimum === undefined && maximum === undefined)
+            throw new TypeError(`${path} requires a bound`);
+        if (minimum !== undefined && maximum !== undefined && minimum > maximum)
+            throw new TypeError(`${path} bounds conflict`);
+        if (type.kind === "string" && type.maxLength !== undefined && maximum !== undefined && type.maxLength !== maximum) {
+            throw new TypeError(`${path}.maximum conflicts with logical string maxLength`);
+        }
+        return { kind, ...(minimum === undefined ? {} : { minimum }), ...(maximum === undefined ? {} : { maximum }) };
+    }
+    if (kind === "pattern") {
+        exactKeys(record, path, ["kind", "syntax", "expression", "flags"]);
+        if (type.kind !== "string")
+            throw new TypeError(`${path} pattern constraint requires a string type`);
+        if (record.syntax !== "ecma-262")
+            throw new TypeError(`${path}.syntax must be ecma-262`);
+        const expression = text(record.expression, `${path}.expression`, true);
+        const flags = record.flags === undefined ? undefined : text(record.flags, `${path}.flags`, true);
+        try {
+            void new RegExp(expression, flags);
+        }
+        catch (cause) {
+            throw new TypeError(`${path} contains an invalid ECMA-262 pattern`, { cause });
+        }
+        return { kind, syntax: "ecma-262", expression, ...(flags === undefined ? {} : { flags }) };
+    }
+    if (kind === "multiple-of") {
+        exactKeys(record, path, ["kind", "value"]);
+        if (type.kind !== "integer" && type.kind !== "float" && type.kind !== "decimal") {
+            throw new TypeError(`${path} multiple-of constraint requires a numeric type`);
+        }
+        if (typeof record.value !== "number" || !Number.isFinite(record.value) || record.value <= 0) {
+            throw new TypeError(`${path}.value must be finite and positive`);
+        }
+        return { kind, value: record.value };
+    }
+    if (kind === "unique") {
+        exactKeys(record, path, ["kind"]);
+        return { kind };
+    }
+    extensionIdentifier(kind, `${path}.kind`);
+    exactKeys(record, path, ["kind", "value"]);
+    return { kind: kind, value: jsonValue(record.value, `${path}.value`) };
+}
+function normalizeKey(value, names) {
+    const record = object(value, "$.key");
+    if (record.state === "none") {
+        exactKeys(record, "$.key", ["state"]);
+        return { state: "none" };
+    }
+    if (record.state === "known") {
+        exactKeys(record, "$.key", ["state", "fields"]);
+        const fields = nonEmptyTextArray(record.fields, "$.key.fields");
+        unique(fields, "$.key.fields");
+        for (const field of fields)
+            if (!names.has(field))
+                throw new TypeError(`$.key.fields references unknown field ${field}`);
+        return { state: "known", fields };
+    }
+    if (record.state === "unknown") {
+        exactKeys(record, "$.key", ["state", "reason"]);
+        if (!includes(["metadata-unavailable", "not-declared", "conflicting"], record.reason)) {
+            throw new TypeError("$.key.reason is invalid");
+        }
+        return { state: "unknown", reason: record.reason };
+    }
+    throw new TypeError("$.key.state is invalid");
+}
+function normalizeGeometrySchema(value, names, fields) {
+    const record = object(value, "$.geometry");
+    const hasDescendantGeometry = fields.some((field) => logicalTypeHasDescendantGeometry(field.type));
+    if (hasDescendantGeometry && (record.state !== "unknown" || record.reason !== "unrecognized")) {
+        throw new TypeError("$.geometry must be unknown/unrecognized while geometry exists below a top-level field path");
+    }
+    if (record.state === "none") {
+        exactKeys(record, "$.geometry", ["state", "reason"]);
+        if (record.reason !== "declared-non-spatial" && record.reason !== "no-geometry-fields") {
+            throw new TypeError("$.geometry.reason is invalid");
+        }
+        if (fields.some((field) => field.type.kind === "geometry")) {
+            throw new TypeError("$.geometry cannot be none while a logical geometry field exists");
+        }
+        return { state: "none", reason: record.reason };
+    }
+    if (record.state === "unknown") {
+        exactKeys(record, "$.geometry", ["state", "reason", "native"]);
+        if (!includes(["metadata-unavailable", "missing", "unrecognized", "conflicting"], record.reason)) {
+            throw new TypeError("$.geometry.reason is invalid");
+        }
+        return {
+            state: "unknown",
+            reason: record.reason,
+            ...(record.native === undefined ? {} : { native: normalizeNative(record.native, "$.geometry.native") }),
+        };
+    }
+    if (record.state !== "known")
+        throw new TypeError("$.geometry.state is invalid");
+    exactKeys(record, "$.geometry", ["state", "fields", "primaryField"]);
+    const geometryFields = array(record.fields, "$.geometry.fields").map((entry, index) => normalizeGeometryField(entry, `$.geometry.fields[${index}]`));
+    if (geometryFields.length === 0)
+        throw new TypeError("$.geometry.fields must be non-empty");
+    geometryFields.sort((left, right) => compareUtf8(left.field, right.field));
+    unique(geometryFields.map((field) => field.field), "$.geometry.fields");
+    for (const field of geometryFields) {
+        if (!names.has(field.field))
+            throw new TypeError(`$.geometry.fields references unknown field ${field.field}`);
+        if (fields.find((candidate) => candidate.name === field.field)?.type.kind !== "geometry") {
+            throw new TypeError(`$.geometry.fields ${field.field} is not logically typed as geometry`);
+        }
+    }
+    const primary = normalizePrimaryGeometry(record.primaryField, new Set(geometryFields.map((field) => field.field)));
+    return {
+        state: "known",
+        fields: geometryFields,
+        primaryField: primary,
+    };
+}
+function normalizeGeometryField(value, path) {
+    const record = object(value, path, ["field", "geometryTypes", "crs", "layout", "allowsEmpty"]);
+    const geometryTypes = normalizeGeometryTypes(record.geometryTypes, `${path}.geometryTypes`);
+    if (!includes(["xy", "xyz", "xym", "xyzm", "unknown"], record.layout)) {
+        throw new TypeError(`${path}.layout is invalid`);
+    }
+    if (typeof record.allowsEmpty !== "boolean" && record.allowsEmpty !== "unknown") {
+        throw new TypeError(`${path}.allowsEmpty is invalid`);
+    }
+    return {
+        field: text(record.field, `${path}.field`),
+        geometryTypes,
+        crs: normalizeCrsBinding(record.crs, `${path}.crs`),
+        layout: record.layout,
+        allowsEmpty: record.allowsEmpty,
+    };
+}
+function normalizeGeometryTypes(value, path) {
+    const record = object(value, path);
+    if (record.state === "known") {
+        exactKeys(record, path, ["state", "type"]);
+        return { state: "known", type: geometryKind(record.type, `${path}.type`) };
+    }
+    if (record.state === "mixed") {
+        exactKeys(record, path, ["state", "types"]);
+        const types = array(record.types, `${path}.types`).map((entry, index) => geometryKind(entry, `${path}.types[${index}]`));
+        if (types.length < 2)
+            throw new TypeError(`${path}.types must contain at least two kinds`);
+        types.sort(compareCanonical);
+        unique(types, `${path}.types`);
+        return { state: "mixed", types: types };
+    }
+    if (record.state === "unknown") {
+        exactKeys(record, path, ["state", "reason", "native"]);
+        if (!includes(["missing", "unrecognized", "conflicting", "unsupported"], record.reason)) {
+            throw new TypeError(`${path}.reason is invalid`);
+        }
+        return {
+            state: "unknown",
+            reason: record.reason,
+            ...(record.native === undefined ? {} : { native: normalizeNative(record.native, `${path}.native`) }),
+        };
+    }
+    throw new TypeError(`${path}.state is invalid`);
+}
+function normalizePrimaryGeometry(value, geometryFields) {
+    const record = object(value, "$.geometry.primaryField");
+    if (record.state === "known") {
+        exactKeys(record, "$.geometry.primaryField", ["state", "field"]);
+        const field = text(record.field, "$.geometry.primaryField.field");
+        if (!geometryFields.has(field))
+            throw new TypeError("$.geometry.primaryField references an unknown geometry field");
+        return { state: "known", field };
+    }
+    if (record.state === "none") {
+        exactKeys(record, "$.geometry.primaryField", ["state", "reason"]);
+        if (record.reason !== "not-declared" && record.reason !== "no-default") {
+            throw new TypeError("$.geometry.primaryField.reason is invalid");
+        }
+        return { state: "none", reason: record.reason };
+    }
+    if (record.state === "unknown") {
+        exactKeys(record, "$.geometry.primaryField", ["state", "reason"]);
+        if (record.reason !== "metadata-unavailable" && record.reason !== "conflicting") {
+            throw new TypeError("$.geometry.primaryField.reason is invalid");
+        }
+        return { state: "unknown", reason: record.reason };
+    }
+    throw new TypeError("$.geometry.primaryField.state is invalid");
+}
+function normalizeTemporalSchema(value, names, fields) {
+    const record = object(value, "$.temporal");
+    const requireTemporal = (field) => {
+        if (!names.has(field))
+            throw new TypeError(`$.temporal references unknown field ${field}`);
+        const kind = fields.find((candidate) => candidate.name === field)?.type.kind;
+        if (kind !== "date" && kind !== "time" && kind !== "timestamp") {
+            throw new TypeError(`$.temporal field ${field} is not an instant or endpoint type`);
+        }
+    };
+    if (record.state === "none") {
+        exactKeys(record, "$.temporal", ["state"]);
+        return { state: "none" };
+    }
+    if (record.state === "instant") {
+        exactKeys(record, "$.temporal", ["state", "field"]);
+        const field = text(record.field, "$.temporal.field");
+        requireTemporal(field);
+        return { state: "instant", field };
+    }
+    if (record.state === "interval") {
+        exactKeys(record, "$.temporal", ["state", "startField", "endField"]);
+        const startField = text(record.startField, "$.temporal.startField");
+        const endField = text(record.endField, "$.temporal.endField");
+        requireTemporal(startField);
+        requireTemporal(endField);
+        if (startField === endField)
+            throw new TypeError("$.temporal interval fields must differ");
+        return { state: "interval", startField, endField };
+    }
+    if (record.state === "mixed") {
+        exactKeys(record, "$.temporal", ["state", "fields"]);
+        const temporalFields = [...nonEmptyTextArray(record.fields, "$.temporal.fields")].sort(compareCanonical);
+        unique(temporalFields, "$.temporal.fields");
+        for (const field of temporalFields)
+            requireTemporal(field);
+        return { state: "mixed", fields: temporalFields };
+    }
+    if (record.state === "unknown") {
+        exactKeys(record, "$.temporal", ["state", "reason"]);
+        if (!includes(["metadata-unavailable", "not-declared", "conflicting"], record.reason)) {
+            throw new TypeError("$.temporal.reason is invalid");
+        }
+        return { state: "unknown", reason: record.reason };
+    }
+    throw new TypeError("$.temporal.state is invalid");
+}
+function validateFieldSemantics(fields, key, geometry, temporal) {
+    const keyFields = new Set(key.state === "known" ? key.fields : []);
+    const geometryFields = new Set(geometry.state === "known" ? geometry.fields.map((field) => field.field) : []);
+    const instantFields = new Set(temporal.state === "instant" ? [temporal.field] : []);
+    const mixedFields = new Set(temporal.state === "mixed" ? temporal.fields : []);
+    const simultaneouslyAddressablePaths = new Set(fields.map((field) => canonicalStringify(toJsonValue(field.path))));
+    for (const field of fields) {
+        const has = (role) => field.roles.includes(role);
+        if (has("geometry") !== (field.type.kind === "geometry")) {
+            throw new TypeError(`Field ${field.name} geometry type, role, and schema membership must agree`);
+        }
+        if (geometry.state === "known" && geometryFields.has(field.name) !== (field.type.kind === "geometry")) {
+            throw new TypeError(`Field ${field.name} geometry type, role, and schema membership must agree`);
+        }
+        if (has("primary-key") !== keyFields.has(field.name)) {
+            throw new TypeError(`Field ${field.name} primary-key role must agree with schema.key`);
+        }
+        if (keyFields.has(field.name)) {
+            if (field.nullability !== "non-nullable") {
+                throw new TypeError(`Known key field ${field.name} must be non-nullable`);
+            }
+            if (!featureIdentityLogicalType(field.type)) {
+                throw new TypeError(`Known key field ${field.name} cannot produce a FeatureIdentityValue`);
+            }
+        }
+        const temporalType = field.type.kind === "date" || field.type.kind === "time" || field.type.kind === "timestamp";
+        if ((has("time-instant") || has("time-start") || has("time-end") || has("created-at") || has("updated-at")) &&
+            !temporalType) {
+            throw new TypeError(`Field ${field.name} has a temporal role but is not temporally typed`);
+        }
+        if (temporal.state === "interval") {
+            if (has("time-start") !== (field.name === temporal.startField)) {
+                throw new TypeError(`Field ${field.name} time-start role must agree with schema.temporal`);
+            }
+            if (has("time-end") !== (field.name === temporal.endField)) {
+                throw new TypeError(`Field ${field.name} time-end role must agree with schema.temporal`);
+            }
+        }
+        else if (temporal.state !== "mixed" && (has("time-start") || has("time-end"))) {
+            throw new TypeError(`Field ${field.name} interval role requires interval temporal schema`);
+        }
+        if (temporal.state !== "mixed" && has("time-instant") !== instantFields.has(field.name)) {
+            throw new TypeError(`Field ${field.name} time-instant role must agree with schema.temporal`);
+        }
+        if (temporal.state === "mixed") {
+            const hasTemporalRole = has("time-instant") || has("time-start") || has("time-end") || has("created-at") || has("updated-at");
+            if (mixedFields.has(field.name) !== hasTemporalRole) {
+                throw new TypeError(`Field ${field.name} temporal role must agree with mixed schema.temporal`);
+            }
+        }
+        if (field.type.kind === "geometry" && Object.hasOwn(field, "defaultValue") && field.defaultValue !== null) {
+            const geometryField = geometry.state === "known" ? geometry.fields.find((item) => item.field === field.name) : undefined;
+            const summary = canonicalGeometrySummary(field.defaultValue);
+            const expectedArity = geometryField?.layout === "xy"
+                ? 2
+                : geometryField?.layout === "xyz" || geometryField?.layout === "xym"
+                    ? 3
+                    : geometryField?.layout === "xyzm"
+                        ? 4
+                        : undefined;
+            if (expectedArity !== undefined && summary?.arity !== expectedArity) {
+                throw new TypeError(`Field ${field.name} defaultValue ordinate arity does not match declared ${geometryField.layout} layout`);
+            }
+            if (summary &&
+                geometryField?.geometryTypes.state === "known" &&
+                summary.type !== geometryField.geometryTypes.type) {
+                throw new TypeError(`Field ${field.name} defaultValue type ${summary.type} does not match declared ${geometryField.geometryTypes.type}`);
+            }
+            if (summary &&
+                geometryField?.geometryTypes.state === "mixed" &&
+                !geometryField.geometryTypes.types.includes(summary.type)) {
+                throw new TypeError(`Field ${field.name} defaultValue type ${summary.type} is not in the declared mixed types`);
+            }
+        }
+        validateDescendantFieldSemantics(field.type, field.path, simultaneouslyAddressablePaths);
+    }
+}
+function featureIdentityLogicalType(type) {
+    if (type.kind === "union")
+        return type.members.every(featureIdentityLogicalType);
+    return includes([
+        "boolean",
+        "integer",
+        "float",
+        "decimal",
+        "string",
+        "binary",
+        "uuid",
+        "date",
+        "time",
+        "timestamp",
+        "duration",
+    ], type.kind);
+}
+function logicalTypeContainsGeometry(type) {
+    if (type.kind === "geometry")
+        return true;
+    if (type.kind === "list")
+        return logicalTypeContainsGeometry(type.element);
+    if (type.kind === "union")
+        return type.members.some(logicalTypeContainsGeometry);
+    if (type.kind === "struct")
+        return type.fields.some((field) => logicalTypeContainsGeometry(field.type));
+    return false;
+}
+function logicalTypeHasDescendantGeometry(type) {
+    return type.kind !== "geometry" && logicalTypeContainsGeometry(type);
+}
+function validateDescendantFieldSemantics(type, parentPath, simultaneouslyAddressablePaths) {
+    if (type.kind === "list") {
+        validateDescendantFieldSemantics(type.element, parentPath, simultaneouslyAddressablePaths);
+        return;
+    }
+    if (type.kind === "union") {
+        const branchPaths = new Set();
+        for (const member of type.members) {
+            const branchAddressablePaths = new Set(simultaneouslyAddressablePaths);
+            validateDescendantFieldSemantics(member, parentPath, branchAddressablePaths);
+            for (const path of branchAddressablePaths) {
+                if (!simultaneouslyAddressablePaths.has(path))
+                    branchPaths.add(path);
+            }
+        }
+        for (const path of branchPaths)
+            simultaneouslyAddressablePaths.add(path);
+        return;
+    }
+    if (type.kind !== "struct")
+        return;
+    for (const field of type.fields) {
+        const label = field.path.join(".");
+        if (!strictPathDescendant(field.path, parentPath)) {
+            throw new TypeError(`Nested field ${label} path must strictly extend parent path ${parentPath.join(".")}`);
+        }
+        const pathIdentity = canonicalStringify(toJsonValue(field.path));
+        if (simultaneouslyAddressablePaths.has(pathIdentity)) {
+            throw new TypeError(`Logical field path ${label} collides with another simultaneously addressable field`);
+        }
+        simultaneouslyAddressablePaths.add(pathIdentity);
+        if (field.roles.includes("geometry") !== (field.type.kind === "geometry")) {
+            throw new TypeError(`Nested field ${label} geometry type and role must agree`);
+        }
+        const unreachableRole = field.roles.find((role) => role !== "geometry" &&
+            includes(["primary-key", "feature-id", "time-instant", "time-start", "time-end", "created-at", "updated-at"], role));
+        if (unreachableRole) {
+            throw new TypeError(`Nested field ${label} cannot carry ${unreachableRole}; source key/time identity is top-level string-addressed`);
+        }
+        validateDescendantFieldSemantics(field.type, field.path, simultaneouslyAddressablePaths);
+    }
+}
+function strictPathDescendant(path, parentPath) {
+    return path.length > parentPath.length && parentPath.every((segment, index) => path[index] === segment);
+}
+function normalizeCrsBinding(value, path) {
+    const record = object(value, path, ["definition", "coordinateOrder", "coordinateEpoch", "provenance"]);
+    const coordinateEpoch = record.coordinateEpoch === undefined ? undefined : finiteNumber(record.coordinateEpoch, `${path}.coordinateEpoch`);
+    const definition = normalizeCrsDefinition(record.definition, `${path}.definition`);
+    const provenance = normalizeCrsProvenance(record.provenance, `${path}.provenance`);
+    if (provenance.method === "reprojected" &&
+        canonicalStringify(crsDefinitionFingerprintProjection(definition)) !==
+            canonicalStringify(crsDefinitionFingerprintProjection(provenance.reprojection.target))) {
+        throw new TypeError(`${path}.definition must semantically match provenance.reprojection.target`);
+    }
+    return {
+        definition,
+        coordinateOrder: normalizeAxisOrder(record.coordinateOrder, `${path}.coordinateOrder`),
+        ...(coordinateEpoch === undefined ? {} : { coordinateEpoch }),
+        provenance,
+    };
+}
+function normalizeCrsDefinition(value, path) {
+    const record = object(value, path);
+    switch (record.kind) {
+        case "authority":
+            exactKeys(record, path, ["kind", "authority", "code", "version", "uri", "wkt", "definitionAxisOrder"]);
+            return {
+                kind: "authority",
+                authority: text(record.authority, `${path}.authority`),
+                code: text(record.code, `${path}.code`),
+                ...(record.version === undefined ? {} : { version: text(record.version, `${path}.version`) }),
+                ...(record.uri === undefined ? {} : { uri: absoluteUri(record.uri, `${path}.uri`) }),
+                ...(record.wkt === undefined ? {} : { wkt: text(record.wkt, `${path}.wkt`) }),
+                definitionAxisOrder: normalizeAxisOrder(record.definitionAxisOrder, `${path}.definitionAxisOrder`),
+            };
+        case "wkt":
+            exactKeys(record, path, ["kind", "wkt", "dialect", "validation", "name", "definitionAxisOrder"]);
+            if (!includes(["wkt1", "wkt2", "unknown"], record.dialect))
+                throw new TypeError(`${path}.dialect is invalid`);
+            if (!includes(["unverified", "engine"], record.validation)) {
+                throw new TypeError(`${path}.validation is invalid`);
+            }
+            return {
+                kind: "wkt",
+                wkt: text(record.wkt, `${path}.wkt`),
+                dialect: record.dialect,
+                validation: record.validation,
+                ...(record.name === undefined ? {} : { name: text(record.name, `${path}.name`) }),
+                definitionAxisOrder: normalizeAxisOrder(record.definitionAxisOrder, `${path}.definitionAxisOrder`),
+            };
+        case "uri":
+            exactKeys(record, path, ["kind", "uri", "name", "definitionAxisOrder"]);
+            return {
+                kind: "uri",
+                uri: absoluteUri(record.uri, `${path}.uri`),
+                ...(record.name === undefined ? {} : { name: text(record.name, `${path}.name`) }),
+                definitionAxisOrder: normalizeAxisOrder(record.definitionAxisOrder, `${path}.definitionAxisOrder`),
+            };
+        case "projjson": {
+            exactKeys(record, path, ["kind", "projjson", "name", "definitionAxisOrder"]);
+            const projjson = jsonObject(record.projjson, `${path}.projjson`);
+            if (new TextEncoder().encode(canonicalStringify(toJsonValue(projjson))).byteLength > MAX_PROJJSON_BYTES) {
+                throw new TypeError(`${path}.projjson exceeds ${MAX_PROJJSON_BYTES} bytes`);
+            }
+            validateProjJson(projjson, `${path}.projjson`);
+            return {
+                kind: "projjson",
+                projjson,
+                ...(record.name === undefined ? {} : { name: text(record.name, `${path}.name`) }),
+                definitionAxisOrder: normalizeAxisOrder(record.definitionAxisOrder, `${path}.definitionAxisOrder`),
+            };
+        }
+        case "unknown":
+            exactKeys(record, path, ["kind", "reason", "native"]);
+            if (!includes(["missing", "unrecognized", "conflicting"], record.reason)) {
+                throw new TypeError(`${path}.reason is invalid`);
+            }
+            return {
+                kind: "unknown",
+                reason: record.reason,
+                ...(record.native === undefined ? {} : { native: normalizeNative(record.native, `${path}.native`) }),
+            };
+        default:
+            throw new TypeError(`${path}.kind is invalid`);
+    }
+}
+function normalizeAxisOrder(value, path) {
+    const record = object(value, path);
+    if (record.state === "known") {
+        exactKeys(record, path, ["state", "source", "axes"]);
+        if (!includes(["crs-definition", "protocol", "encoding", "declared"], record.source)) {
+            throw new TypeError(`${path}.source is invalid`);
+        }
+        const axes = array(record.axes, `${path}.axes`).map((axis, index) => normalizeAxis(axis, `${path}.axes[${index}]`));
+        if (axes.length < 2)
+            throw new TypeError(`${path}.axes must contain at least two axes`);
+        return {
+            state: "known",
+            source: record.source,
+            axes: axes,
+        };
+    }
+    if (record.state === "unknown") {
+        exactKeys(record, path, ["state", "reason", "native"]);
+        if (!includes(["missing", "unrecognized", "conflicting"], record.reason)) {
+            throw new TypeError(`${path}.reason is invalid`);
+        }
+        return {
+            state: "unknown",
+            reason: record.reason,
+            ...(record.native === undefined ? {} : { native: normalizeNative(record.native, `${path}.native`) }),
+        };
+    }
+    throw new TypeError(`${path}.state is invalid`);
+}
+function normalizeAxis(value, path) {
+    const record = object(value, path, ["name", "abbreviation", "direction", "unit"]);
+    if (!includes(["east", "west", "north", "south", "up", "down", "future", "past", "other"], record.direction)) {
+        throw new TypeError(`${path}.direction is invalid`);
+    }
+    return {
+        name: text(record.name, `${path}.name`),
+        ...(record.abbreviation === undefined ? {} : { abbreviation: text(record.abbreviation, `${path}.abbreviation`) }),
+        direction: record.direction,
+        unit: text(record.unit, `${path}.unit`),
+    };
+}
+function normalizeCrsProvenance(value, path) {
+    const record = object(value, path);
+    if (record.method === "reprojected") {
+        exactKeys(record, path, ["method", "native", "reprojection"]);
+        const reprojection = object(record.reprojection, `${path}.reprojection`, [
+            "source",
+            "target",
+            "operation",
+            "engine",
+            "accuracyMeters",
+            "transformedAt",
+        ]);
+        const source = normalizeCrsDefinition(reprojection.source, `${path}.reprojection.source`);
+        const target = normalizeCrsDefinition(reprojection.target, `${path}.reprojection.target`);
+        if (!isResolvedCrsDefinition(source) || !isResolvedCrsDefinition(target))
+            throw new TypeError(`${path}.reprojection CRS must be resolved`);
+        return {
+            method: "reprojected",
+            ...(record.native === undefined ? {} : { native: normalizeNative(record.native, `${path}.native`) }),
+            reprojection: {
+                source,
+                target,
+                ...(reprojection.operation === undefined
+                    ? {}
+                    : { operation: text(reprojection.operation, `${path}.reprojection.operation`) }),
+                engine: text(reprojection.engine, `${path}.reprojection.engine`),
+                ...(reprojection.accuracyMeters === undefined
+                    ? {}
+                    : {
+                        accuracyMeters: nonNegativeFiniteNumber(reprojection.accuracyMeters, `${path}.reprojection.accuracyMeters`),
+                    }),
+                ...(reprojection.transformedAt === undefined
+                    ? {}
+                    : { transformedAt: rfc3339Timestamp(reprojection.transformedAt, `${path}.reprojection.transformedAt`) }),
+            },
+        };
+    }
+    if (!includes(["metadata", "payload", "standard-default", "declared"], record.method)) {
+        throw new TypeError(`${path}.method is invalid`);
+    }
+    exactKeys(record, path, ["method", "native"]);
+    return {
+        method: record.method,
+        ...(record.native === undefined ? {} : { native: normalizeNative(record.native, `${path}.native`) }),
+    };
+}
+function isResolvedCrsDefinition(definition) {
+    return definition.kind !== "unknown" && (definition.kind !== "wkt" || definition.validation === "engine");
+}
+function normalizeNative(value, path) {
+    const record = object(value, path, ["protocol", "name", "namespace", "path", "definition"]);
+    const protocol = sourceProtocol(record.protocol, `${path}.protocol`);
+    const rawDefinition = record.definition === undefined ? undefined : jsonValue(record.definition, `${path}.definition`);
+    if (rawDefinition !== undefined &&
+        new TextEncoder().encode(canonicalStringify(toJsonValue(rawDefinition))).byteLength > MAX_NATIVE_DEFINITION_BYTES) {
+        throw new TypeError(`${path}.definition exceeds ${MAX_NATIVE_DEFINITION_BYTES} bytes`);
+    }
+    const definition = rawDefinition === undefined ? undefined : sanitizeNativeDefinition(rawDefinition);
+    return {
+        protocol,
+        name: text(record.name, `${path}.name`),
+        ...(record.namespace === undefined ? {} : { namespace: text(record.namespace, `${path}.namespace`) }),
+        ...(record.path === undefined ? {} : { path: textArray(record.path, `${path}.path`) }),
+        ...(definition === undefined ? {} : { definition }),
+    };
+}
+const REDACTED_NATIVE_VALUE = "[REDACTED]";
+const MAX_NATIVE_SANITIZER_DEPTH = 8;
+const SENSITIVE_NATIVE_KEY = /^(?:authorization|proxy[-_]?authorization|auth[-_]?token|bearer|bearer[-_]?token|jwt|token|access[-_]?token|refresh[-_]?token|id[-_]?token|api[-_]?key|apikey|subscription[-_]?key|ocp[-_]?apim[-_]?subscription[-_]?key|secret|client[-_]?secret|password|passwd|pwd|credential|private[-_]?key|session(?:[-_]?id|[-_]?token)?|cookie|set[-_]?cookie|aws[-_]?access[-_]?key[-_]?id|aws[-_]?secret[-_]?access[-_]?key)$/i;
+const SENSITIVE_QUERY_NAMES = new Set([
+    "authorization",
+    "auth",
+    "authtoken",
+    "bearer",
+    "jwt",
+    "token",
+    "accesstoken",
+    "refreshtoken",
+    "idtoken",
+    "apikey",
+    "key",
+    "secret",
+    "clientsecret",
+    "password",
+    "pwd",
+    "credential",
+    "session",
+    "sessionid",
+    "subscriptionkey",
+    "ocpapimsubscriptionkey",
+    "signature",
+    "sig",
+    "policy",
+    "expires",
+    "sas",
+    "se",
+    "sp",
+    "spr",
+    "sr",
+    "sv",
+    "code",
+]);
+function sanitizeNativeDefinition(value) {
+    if (typeof value === "string")
+        return sanitizeNativeString(value);
+    if (value === null || typeof value === "number" || typeof value === "boolean")
+        return value;
+    if (Array.isArray(value))
+        return value.map(sanitizeNativeDefinition);
+    const sanitized = Object.create(null);
+    for (const [key, child] of Object.entries(value)) {
+        sanitized[key] =
+            SENSITIVE_NATIVE_KEY.test(key) && !credentialPlaceholder(child)
+                ? REDACTED_NATIVE_VALUE
+                : sanitizeNativeDefinition(child);
+    }
+    return sanitized;
+}
+function sanitizeNativeString(value, depth = 0) {
+    if (/-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----/.test(value))
+        return REDACTED_NATIVE_VALUE;
+    let sanitized = replaceNativeUrls(value, depth);
+    sanitized = replaceUnqualifiedUserInfo(sanitized);
+    sanitized = sanitized.replace(/\b(Bearer|Basic)\s+[^\s,;]+/gi, `$1 ${REDACTED_NATIVE_VALUE}`);
+    sanitized = sanitized.replace(/\b(?:eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}|(?:AKIA|ASIA|AIDA|AROA|AIPA|ANPA|ANVA|ASCA)[A-Z0-9]{16}|gh[pousr]_[A-Za-z0-9]{20,})\b/g, REDACTED_NATIVE_VALUE);
+    sanitized = sanitized.replace(/\b(auth[-_]?token|bearer|jwt|token|access[-_]?token|refresh[-_]?token|id[-_]?token|api[-_]?key|apikey|subscription[-_]?key|secret|client[-_]?secret|password|passwd|pwd|credential|session(?:[-_]?id|[-_]?token)?|signature|sig|aws[-_]?access[-_]?key[-_]?id|aws[-_]?secret[-_]?access[-_]?key)\s*([=:])\s*([^\s&,;"']+)/gi, (_match, key, separator, credential) => credentialPlaceholder(credential)
+        ? `${key}${separator}${credential}`
+        : `${key}${separator}${REDACTED_NATIVE_VALUE}`);
+    return sanitized;
+}
+function replaceNativeUrls(value, depth) {
+    let output = "";
+    let copiedThrough = 0;
+    let cursor = 0;
+    while (cursor < value.length) {
+        if (!asciiLetter(value.charCodeAt(cursor))) {
+            cursor += 1;
+            continue;
+        }
+        const start = cursor;
+        cursor += 1;
+        while (cursor < value.length && asciiSchemeCharacter(value.charCodeAt(cursor)))
+            cursor += 1;
+        if (!schemeAuthorityAt(value, start, cursor))
+            continue;
+        let end = cursor + 3;
+        while (end < value.length && !nativeUrlTerminator(value.charCodeAt(end)))
+            end += 1;
+        output += value.slice(copiedThrough, start);
+        output += sanitizeNativeUrl(value.slice(start, end), depth);
+        copiedThrough = end;
+        cursor = end;
+    }
+    return copiedThrough === 0 ? value : output + value.slice(copiedThrough);
+}
+function sanitizeNativeUrl(value, depth) {
+    const colon = value.indexOf(":");
+    if (colon < 1 || !schemeAuthorityAt(value, 0, colon))
+        return value;
+    if (value.includes("\\"))
+        return REDACTED_NATIVE_VALUE;
+    try {
+        const url = new URL(value);
+        url.username = "";
+        url.password = "";
+        const sanitizedQuery = new URLSearchParams();
+        for (const [key, entry] of url.searchParams) {
+            sanitizedQuery.append(key, sensitiveQueryParameter(key) && !credentialPlaceholder(entry) ? REDACTED_NATIVE_VALUE : entry);
+        }
+        url.search = sanitizedQuery.toString();
+        if (url.hash) {
+            url.hash =
+                depth >= MAX_NATIVE_SANITIZER_DEPTH ? REDACTED_NATIVE_VALUE : sanitizeNativeString(url.hash, depth + 1);
+        }
+        return url.toString();
+    }
+    catch {
+        // A malformed authority/port cannot be safely decomposed. Native evidence
+        // is diagnostic-only, so fail closed rather than preserve possible userinfo.
+        return REDACTED_NATIVE_VALUE;
+    }
+}
+function replaceUnqualifiedUserInfo(value) {
+    let output = "";
+    let cursor = 0;
+    while (cursor < value.length) {
+        if (nativeCredentialBoundary(value.charCodeAt(cursor))) {
+            output += value[cursor];
+            cursor += 1;
+            continue;
+        }
+        const start = cursor;
+        let end = cursor + 1;
+        while (end < value.length && !nativeCredentialBoundary(value.charCodeAt(end)))
+            end += 1;
+        output += nativeSegmentContainsUserInfo(value, start, end) ? REDACTED_NATIVE_VALUE : value.slice(start, end);
+        cursor = end;
+    }
+    return output;
+}
+function nativeSegmentContainsUserInfo(value, start, end) {
+    let colon = -1;
+    for (let cursor = start; cursor < end; cursor += 1) {
+        const code = value.charCodeAt(cursor);
+        if (code === 58)
+            colon = cursor;
+        else if (code === 64 && colon > start && colon < cursor && cursor + 1 < end)
+            return true;
+    }
+    return false;
+}
+function nativeCredentialBoundary(code) {
+    return (code <= 32 ||
+        code === 34 ||
+        code === 39 ||
+        code === 40 ||
+        code === 41 ||
+        code === 44 ||
+        code === 59 ||
+        code === 60 ||
+        code === 61 ||
+        code === 62);
+}
+function schemeAuthorityAt(value, start, colon) {
+    if (colon <= start || value.charCodeAt(colon) !== 58 || !asciiLetter(value.charCodeAt(start)))
+        return false;
+    for (let index = start + 1; index < colon; index += 1) {
+        if (!asciiSchemeCharacter(value.charCodeAt(index)))
+            return false;
+    }
+    return slashOrBackslash(value.charCodeAt(colon + 1)) && slashOrBackslash(value.charCodeAt(colon + 2));
+}
+function asciiLetter(code) {
+    return (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+}
+function asciiSchemeCharacter(code) {
+    return asciiLetter(code) || (code >= 48 && code <= 57) || code === 43 || code === 45 || code === 46;
+}
+function slashOrBackslash(code) {
+    return code === 47 || code === 92;
+}
+function nativeUrlTerminator(code) {
+    return code <= 32 || code === 34 || code === 39 || code === 44 || code === 60 || code === 62;
+}
+function sensitiveQueryParameter(key) {
+    const normalized = key.replace(/[^A-Za-z0-9]/g, "").toLowerCase();
+    return SENSITIVE_QUERY_NAMES.has(normalized) || normalized.startsWith("xamz") || normalized.startsWith("xgoog");
+}
+function credentialPlaceholder(value) {
+    if (value === null || value === "")
+        return true;
+    if (typeof value !== "string")
+        return false;
+    const normalized = value.trim();
+    return (/^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/.test(normalized) ||
+        /^\{\{[A-Za-z_][A-Za-z0-9_]*\}\}$/.test(normalized) ||
+        /^<[A-Za-z_][A-Za-z0-9_-]*>$/.test(normalized) ||
+        /^\[[A-Za-z_][A-Za-z0-9_-]*\]$/.test(normalized) ||
+        /^(?:YOUR|EXAMPLE|PLACEHOLDER|REDACTED|CHANGEME)(?:[_-][A-Za-z0-9_-]+)?$/i.test(normalized));
+}
+function normalizeProvenanceArray(value, path) {
+    const provenance = array(value, path).map((entry, index) => normalizeProvenance(entry, `${path}[${index}]`));
+    if (provenance.length === 0)
+        throw new TypeError(`${path} must be non-empty`);
+    return provenance;
+}
+function normalizeProvenance(value, path) {
+    const record = object(value, path, ["method", "protocol", "source", "observedAt", "validator", "detail"]);
+    if (!includes(["observed", "declared", "standard-default", "inferred", "unavailable"], record.method)) {
+        throw new TypeError(`${path}.method is invalid`);
+    }
+    const validator = record.validator === undefined ? undefined : normalizeValidator(record.validator, `${path}.validator`);
+    return {
+        method: record.method,
+        protocol: sourceProtocol(record.protocol, `${path}.protocol`),
+        source: sanitizeProvenanceText(text(record.source, `${path}.source`)),
+        ...(record.observedAt === undefined
+            ? {}
+            : { observedAt: rfc3339Timestamp(record.observedAt, `${path}.observedAt`) }),
+        ...(validator ? { validator } : {}),
+        ...(record.detail === undefined ? {} : { detail: sanitizeProvenanceText(text(record.detail, `${path}.detail`)) }),
+    };
+}
+function sanitizeProvenanceText(value) {
+    return sanitizeNativeString(value);
+}
+function normalizeValidator(value, path) {
+    const record = object(value, path, ["kind", "value"]);
+    if (!includes(["etag", "last-modified", "version"], record.kind))
+        throw new TypeError(`${path}.kind is invalid`);
+    return { kind: record.kind, value: text(record.value, `${path}.value`) };
+}
+function normalizeExtensions(value, path) {
+    const record = object(value, path);
+    const out = {};
+    for (const key of Object.keys(record).sort()) {
+        extensionIdentifier(key, `${path}.${key}`);
+        out[key] = jsonValue(record[key], `${path}.${key}`);
+    }
+    return out;
+}
+function schemaFingerprint(schema) {
+    const projection = {
+        kind: schema.kind,
+        version: schema.version,
+        openContent: schema.openContent,
+        ...(schema.extensions ? { extensions: schema.extensions } : {}),
+        fields: schema.fields.map(fieldFingerprintProjection),
+        key: schema.key,
+        geometry: geometryFingerprintProjection(schema.geometry),
+        temporal: schema.temporal,
+    };
+    return sha256(`${SOURCE_SCHEMA_V2_FINGERPRINT_DOMAIN}\n${canonicalStringify(toJsonValue(projection))}`);
+}
+function fieldFingerprintProjection(field) {
+    return toJsonValue({
+        name: field.name,
+        path: field.path,
+        type: typeFingerprintProjection(field.type),
+        nullability: field.nullability,
+        mutability: field.mutability,
+        defaultValuePresent: Object.hasOwn(field, "defaultValue"),
+        ...(Object.hasOwn(field, "defaultValue") ? { defaultValue: field.defaultValue } : {}),
+        roles: [...field.roles].sort(compareCanonical),
+        domain: domainFingerprintProjection(field.domain),
+        constraints: constraintFingerprintProjection(field.constraints),
+        ...(field.extensions ? { extensions: field.extensions } : {}),
+    });
+}
+function typeFingerprintProjection(type) {
+    if (type.kind === "unknown")
+        return { kind: type.kind, reason: type.reason };
+    if (type.kind === "list")
+        return { kind: type.kind, element: typeFingerprintProjection(type.element) };
+    if (type.kind === "struct") {
+        return { kind: type.kind, fields: [...type.fields].sort(compareFields).map(fieldFingerprintProjection) };
+    }
+    if (type.kind === "union") {
+        return { kind: type.kind, members: [...type.members].map(typeFingerprintProjection).sort(compareCanonical) };
+    }
+    return toJsonValue(type);
+}
+function domainFingerprintProjection(domain) {
+    if (domain.state === "unknown") {
+        return {
+            state: domain.state,
+            reason: domain.reason,
+            nativePresent: domain.native !== undefined,
+            ...(domain.native ? { native: nativeIdentity(domain.native) } : {}),
+        };
+    }
+    return toJsonValue(domain);
+}
+function constraintFingerprintProjection(constraints) {
+    if (constraints.state === "unknown") {
+        return {
+            state: constraints.state,
+            reason: constraints.reason,
+            nativePresent: constraints.native !== undefined,
+            ...(constraints.native ? { native: nativeIdentity(constraints.native) } : {}),
+        };
+    }
+    if (constraints.state === "partial") {
+        return {
+            state: constraints.state,
+            reason: constraints.reason,
+            values: constraints.values,
+            native: constraints.native.map(nativeIdentity).sort(compareCanonical),
+        };
+    }
+    return toJsonValue(constraints);
+}
+function nativeIdentity(native) {
+    return {
+        protocol: native.protocol,
+        name: native.name,
+        ...(native.namespace === undefined ? {} : { namespace: native.namespace }),
+        ...(native.path === undefined ? {} : { path: native.path }),
+    };
+}
+function geometryFingerprintProjection(geometry) {
+    if (geometry.state !== "known") {
+        return geometry.state === "unknown"
+            ? { state: geometry.state, reason: geometry.reason }
+            : { state: geometry.state, reason: geometry.reason };
+    }
+    return toJsonValue({
+        state: geometry.state,
+        fields: geometry.fields.map((field) => ({
+            field: field.field,
+            geometryTypes: field.geometryTypes.state === "mixed"
+                ? { state: "mixed", types: [...field.geometryTypes.types].sort(compareCanonical) }
+                : field.geometryTypes.state === "unknown"
+                    ? { state: "unknown", reason: field.geometryTypes.reason }
+                    : field.geometryTypes,
+            crs: crsFingerprintProjection(field.crs),
+            layout: field.layout,
+            allowsEmpty: field.allowsEmpty,
+        })),
+        primaryField: geometry.primaryField,
+    });
+}
+function crsFingerprintProjection(binding) {
+    return {
+        definition: crsDefinitionFingerprintProjection(binding.definition),
+        coordinateOrder: axisFingerprintProjection(binding.coordinateOrder),
+        ...(binding.coordinateEpoch === undefined ? {} : { coordinateEpoch: binding.coordinateEpoch }),
+        provenance: binding.provenance.method === "reprojected"
+            ? {
+                method: "reprojected",
+                reprojection: {
+                    source: crsDefinitionFingerprintProjection(binding.provenance.reprojection.source),
+                    target: crsDefinitionFingerprintProjection(binding.provenance.reprojection.target),
+                    ...(binding.provenance.reprojection.operation === undefined
+                        ? {}
+                        : { operation: binding.provenance.reprojection.operation }),
+                    engine: binding.provenance.reprojection.engine,
+                    ...(binding.provenance.reprojection.accuracyMeters === undefined
+                        ? {}
+                        : { accuracyMeters: binding.provenance.reprojection.accuracyMeters }),
+                },
+            }
+            : { method: binding.provenance.method },
+    };
+}
+function crsDefinitionFingerprintProjection(definition) {
+    switch (definition.kind) {
+        case "authority":
+            return {
+                kind: definition.kind,
+                authority: definition.authority,
+                code: definition.code,
+                ...(definition.version === undefined ? {} : { version: definition.version }),
+                ...(definition.uri === undefined ? {} : { uri: definition.uri }),
+                ...(definition.wkt === undefined ? {} : { wkt: definition.wkt }),
+                definitionAxisOrder: axisFingerprintProjection(definition.definitionAxisOrder),
+            };
+        case "wkt":
+            return {
+                kind: definition.kind,
+                wkt: definition.wkt,
+                dialect: definition.dialect,
+                validation: definition.validation,
+                definitionAxisOrder: axisFingerprintProjection(definition.definitionAxisOrder),
+            };
+        case "uri":
+            return {
+                kind: definition.kind,
+                uri: definition.uri,
+                definitionAxisOrder: axisFingerprintProjection(definition.definitionAxisOrder),
+            };
+        case "projjson":
+            return {
+                kind: definition.kind,
+                projjson: definition.projjson,
+                definitionAxisOrder: axisFingerprintProjection(definition.definitionAxisOrder),
+            };
+        case "unknown":
+            return { kind: definition.kind, reason: definition.reason };
+    }
+}
+function axisFingerprintProjection(order) {
+    return order.state === "known"
+        ? {
+            state: order.state,
+            source: order.source,
+            axes: order.axes.map((axis) => ({
+                // Axis display names/abbreviations do not define semantic identity.
+                direction: axis.direction,
+                unit: axis.unit,
+            })),
+        }
+        : { state: order.state, reason: order.reason };
+}
+function cloneProvenance(value) {
+    return normalizeProvenanceArray(toPlainJson(value), "$.provenance");
+}
+function toPlainJson(value) {
+    assertBoundedGraphDepth(value, "$", MAX_SCHEMA_GRAPH_DEPTH);
+    return toJsonValue(value);
+}
+function jsonValue(value, path) {
+    assertBoundedGraphDepth(value, path, MAX_JSON_VALUE_DEPTH);
+    return toJsonValue(value, path);
+}
+function jsonObject(value, path) {
+    const json = jsonValue(value, path);
+    if (json === null || Array.isArray(json) || typeof json !== "object")
+        throw new TypeError(`${path} must be an object`);
+    return json;
+}
+function object(value, path, allowed) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new TypeError(`${path} must be an object`);
+    const record = value;
+    if (allowed)
+        exactKeys(record, path, allowed);
+    return record;
+}
+function exactKeys(record, path, allowed) {
+    const set = new Set(allowed);
+    const unexpected = Object.keys(record).find((key) => !set.has(key));
+    if (unexpected)
+        throw new TypeError(`${path}.${unexpected} is not part of SourceSchemaV2`);
+}
+function array(value, path) {
+    if (!Array.isArray(value))
+        throw new TypeError(`${path} must be an array`);
+    return value;
+}
+function text(value, path, allowEmpty = false) {
+    if (typeof value !== "string" || (!allowEmpty && value.trim() === ""))
+        throw new TypeError(`${path} must be a non-empty string`);
+    return value;
+}
+function textArray(value, path) {
+    return array(value, path).map((entry, index) => text(entry, `${path}[${index}]`));
+}
+function nonEmptyTextArray(value, path) {
+    const out = textArray(value, path);
+    if (out.length === 0)
+        throw new TypeError(`${path} must be non-empty`);
+    return out;
+}
+function optionalPositiveInteger(value, path) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(value) || value <= 0)
+        throw new TypeError(`${path} must be a positive safe integer`);
+    return value;
+}
+function optionalNonNegativeInteger(value, path) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new TypeError(`${path} must be a non-negative safe integer`);
+    return value;
+}
+function finiteNumber(value, path) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        throw new TypeError(`${path} must be finite`);
+    return value;
+}
+function nonNegativeFiniteNumber(value, path) {
+    const number = finiteNumber(value, path);
+    if (number < 0)
+        throw new TypeError(`${path} must be non-negative`);
+    return number;
+}
+function rfc3339Timestamp(value, path) {
+    const timestamp = text(value, path);
+    if (!timestampValue(timestamp, "nanosecond", "offset")) {
+        throw new TypeError(`${path} must be an RFC 3339 timestamp`);
+    }
+    return timestamp;
+}
+function temporalUnit(value, path) {
+    if (!includes(["second", "millisecond", "microsecond", "nanosecond"], value)) {
+        throw new TypeError(`${path} is invalid`);
+    }
+    return value;
+}
+function geometryKind(value, path) {
+    if (!includes([
+        "Point",
+        "MultiPoint",
+        "LineString",
+        "MultiLineString",
+        "Polygon",
+        "MultiPolygon",
+        "GeometryCollection",
+    ], value)) {
+        throw new TypeError(`${path} is invalid`);
+    }
+    return value;
+}
+function fieldRole(value, path) {
+    if (includes([
+        "primary-key",
+        "feature-id",
+        "geometry",
+        "time-instant",
+        "time-start",
+        "time-end",
+        "created-at",
+        "updated-at",
+    ], value)) {
+        return value;
+    }
+    return extensionIdentifier(value, path);
+}
+function sourceProtocol(value, path) {
+    if (typeof value === "string" && PROTOCOLS.includes(value)) {
+        return value;
+    }
+    return extensionIdentifier(value, path);
+}
+function extensionIdentifier(value, path) {
+    if (typeof value !== "string" || !EXTENSION_ID_PATTERN.test(value)) {
+        throw new TypeError(`${path} must be a reverse-DNS extension identifier`);
+    }
+    return value;
+}
+function absoluteUri(value, path) {
+    const textValue = text(value, path);
+    if (textValue.trim() !== textValue ||
+        [...textValue].some((character) => character.charCodeAt(0) <= 0x20 || character.charCodeAt(0) === 0x7f)) {
+        throw new TypeError(`${path} must not contain whitespace or control characters`);
+    }
+    let parsed;
+    try {
+        parsed = new URL(textValue);
+    }
+    catch {
+        // URL parse errors retain the full input, including credentials, on their
+        // `input` property. Keep validation errors path-only so they are safe to
+        // serialize or log.
+        throw new TypeError(`${path} must be an absolute URI`);
+    }
+    if (!parsed.protocol || !["http:", "https:", "urn:"].includes(parsed.protocol)) {
+        throw new TypeError(`${path} uses an unsafe or unsupported URI scheme`);
+    }
+    if (parsed.username || parsed.password)
+        throw new TypeError(`${path} must not include user-info`);
+    if (textValue.includes("?"))
+        throw new TypeError(`${path} must not include a query`);
+    if (textValue.includes("#"))
+        throw new TypeError(`${path} must not include a fragment`);
+    if (/%(?![0-9A-Fa-f]{2})/.test(textValue))
+        throw new TypeError(`${path} contains malformed percent encoding`);
+    for (const match of textValue.matchAll(/%([0-9A-Fa-f]{2})/g)) {
+        const encoded = match[1];
+        const decoded = String.fromCharCode(Number.parseInt(encoded, 16));
+        if (encoded !== encoded.toUpperCase() || /^[A-Za-z0-9._~-]$/.test(decoded)) {
+            throw new TypeError(`${path} contains a non-canonical percent encoding`);
+        }
+    }
+    const canonical = parsed.toString();
+    if (canonical !== textValue)
+        throw new TypeError(`${path} must use the canonical RFC 3986 serialization`);
+    return canonical;
+}
+function logicalValueCompatible(value, type) {
+    if (value === null)
+        return true;
+    if (type.kind === "list")
+        return Array.isArray(value) && value.every((entry) => logicalValueCompatible(entry, type.element));
+    if (type.kind === "struct") {
+        if (Array.isArray(value) || typeof value !== "object")
+            return false;
+        const record = value;
+        const fields = new Map(type.fields.map((field) => [field.name, field]));
+        if (Object.keys(record).some((key) => !fields.has(key)))
+            return false;
+        return type.fields.every((field) => {
+            if (!Object.hasOwn(record, field.name))
+                return field.nullability !== "non-nullable";
+            const child = record[field.name];
+            return !(child === null && field.nullability === "non-nullable") && logicalValueCompatible(child, field.type);
+        });
+    }
+    if (type.kind === "union")
+        return type.members.some((member) => logicalValueCompatible(value, member));
+    if (type.kind === "json" || type.kind === "unknown")
+        return true;
+    if (type.kind === "geometry")
+        return canonicalGeometryValue(value);
+    if (Array.isArray(value) || typeof value === "object")
+        return false;
+    return domainValueCompatible(value, type);
+}
+/**
+ * Test a JSON scalar against the canonical SourceSchemaV2 logical-type value
+ * semantics. Query admission imports this internal seam so binary encodings,
+ * numeric precision, and temporal precision cannot drift from schema truth.
+ *
+ * @internal
+ */
+export function isLogicalDomainValueCompatible(value, type) {
+    if (value === null || Array.isArray(value) || typeof value === "object")
+        return false;
+    return domainValueCompatible(value, type);
+}
+/**
+ * Compare two canonical scalar values with the exact ordering used by
+ * SourceSchemaV2 range domains. Timestamp offsets, leap seconds, and up to
+ * nanosecond precision are preserved; no comparison is routed through
+ * millisecond-limited `Date` arithmetic.
+ *
+ * `undefined` means that the values are invalid for the logical type or do
+ * not share a deterministic timeline (for example, a local timestamp and an
+ * offset timestamp under `timezone: "unknown"`).
+ *
+ * @internal
+ */
+export function compareLogicalDomainValues(left, right, type) {
+    if (!isLogicalDomainValueCompatible(left, type) || !isLogicalDomainValueCompatible(right, type)) {
+        return undefined;
+    }
+    return compareDomainValues(left, right, type);
+}
+function canonicalGeometryValue(value) {
+    return canonicalGeometrySummary(value) !== undefined;
+}
+function canonicalGeometrySummary(value) {
+    const state = {};
+    if (!inspectCanonicalGeometry(value, state) || state.arity === undefined)
+        return undefined;
+    return { arity: state.arity, type: value.type };
+}
+function inspectCanonicalGeometry(value, state) {
+    if (value === null || Array.isArray(value) || typeof value !== "object")
+        return false;
+    const record = value;
+    if (typeof record.type !== "string")
+        return false;
+    if (record.type === "GeometryCollection") {
+        return (exactJsonKeys(record, ["type", "geometries"]) &&
+            Array.isArray(record.geometries) &&
+            record.geometries.length > 0 &&
+            record.geometries.every((geometry) => inspectCanonicalGeometry(geometry, state)));
+    }
+    if (!exactJsonKeys(record, ["type", "coordinates"]))
+        return false;
+    const position = (candidate) => {
+        if (!Array.isArray(candidate) ||
+            candidate.length < 2 ||
+            candidate.length > 4 ||
+            !candidate.every((ordinate) => typeof ordinate === "number" && Number.isFinite(ordinate))) {
+            return false;
+        }
+        const arity = candidate.length;
+        if (state.arity !== undefined && state.arity !== arity)
+            return false;
+        state.arity = arity;
+        return true;
+    };
+    const positions = (candidate, minimum) => Array.isArray(candidate) && candidate.length >= minimum && candidate.every(position);
+    const rings = (candidate) => {
+        if (!Array.isArray(candidate) || candidate.length === 0)
+            return false;
+        return candidate.every((ring) => {
+            if (!positions(ring, 4))
+                return false;
+            const first = ring[0];
+            const last = ring[ring.length - 1];
+            return (Array.isArray(first) &&
+                Array.isArray(last) &&
+                first.length === last.length &&
+                first.every((ordinate, index) => ordinate === last[index]));
+        });
+    };
+    switch (record.type) {
+        case "Point":
+            return position(record.coordinates);
+        case "MultiPoint":
+            return positions(record.coordinates, 1);
+        case "LineString":
+            return positions(record.coordinates, 2);
+        case "MultiLineString":
+            return (Array.isArray(record.coordinates) &&
+                record.coordinates.length > 0 &&
+                record.coordinates.every((line) => positions(line, 2)));
+        case "Polygon":
+            return rings(record.coordinates);
+        case "MultiPolygon":
+            return Array.isArray(record.coordinates) && record.coordinates.length > 0 && record.coordinates.every(rings);
+        default:
+            return false;
+    }
+}
+function exactJsonKeys(record, expected) {
+    const keys = Object.keys(record);
+    return keys.length === expected.length && expected.every((key) => Object.hasOwn(record, key));
+}
+function domainValueCompatible(value, type) {
+    switch (type.kind) {
+        case "boolean":
+            return typeof value === "boolean";
+        case "integer":
+            if (type.jsonEncoding === "string") {
+                return typeof value === "string" && integerString(value, type.bits, type.signed);
+            }
+            return typeof value === "number" && integerNumber(value, type.bits, type.signed);
+        case "float":
+            return typeof value === "number" && Number.isFinite(value);
+        case "decimal":
+            return type.jsonEncoding === "string"
+                ? typeof value === "string" && decimalString(value, type.precision, type.scale)
+                : typeof value === "number" && decimalNumber(value, type.precision, type.scale);
+        case "string":
+            return typeof value === "string" && (type.maxLength === undefined || value.length <= type.maxLength);
+        case "binary":
+            return typeof value === "string" && binaryValue(value, type.encoding);
+        case "uuid":
+            return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(value);
+        case "date":
+            return typeof value === "string" && calendarDate(value);
+        case "time":
+            return typeof value === "string" && timeOfDay(value, type.unit);
+        case "timestamp":
+            return typeof value === "string" && timestampValue(value, type.unit, type.timezone);
+        case "duration":
+            return typeof value === "string" && durationValue(value);
+        case "json":
+        case "unknown":
+            return true;
+        case "union":
+            return type.members.some((member) => domainValueCompatible(value, member));
+        case "geometry":
+        case "list":
+        case "struct":
+            return false;
+    }
+}
+function rangeType(type) {
+    return (type.kind === "integer" ||
+        type.kind === "float" ||
+        type.kind === "decimal" ||
+        type.kind === "string" ||
+        type.kind === "date" ||
+        type.kind === "time" ||
+        type.kind === "timestamp" ||
+        type.kind === "unknown");
+}
+function compareDomainValues(left, right, type) {
+    if (typeof left === "number" && typeof right === "number")
+        return left === right ? 0 : left < right ? -1 : 1;
+    if (typeof left !== "string" || typeof right !== "string")
+        return 0;
+    if (type.kind === "integer" || type.kind === "decimal")
+        return compareDecimalStrings(left, right);
+    if (type.kind === "timestamp") {
+        const leftTime = exactTimestampKey(left);
+        const rightTime = exactTimestampKey(right);
+        if (!leftTime || !rightTime || leftTime.zoned !== rightTime.zoned)
+            return undefined;
+        if (leftTime.epochSecond !== rightTime.epochSecond) {
+            return leftTime.epochSecond < rightTime.epochSecond ? -1 : 1;
+        }
+        if (leftTime.leapSecond !== rightTime.leapSecond)
+            return leftTime.leapSecond ? -1 : 1;
+        return leftTime.fraction === rightTime.fraction ? 0 : leftTime.fraction < rightTime.fraction ? -1 : 1;
+    }
+    if (type.kind === "time") {
+        const leftTime = exactTimeKey(left);
+        const rightTime = exactTimeKey(right);
+        if (leftTime === undefined || rightTime === undefined)
+            return undefined;
+        return leftTime === rightTime ? 0 : leftTime < rightTime ? -1 : 1;
+    }
+    return left === right ? 0 : left < right ? -1 : 1;
+}
+function exactTimeKey(value) {
+    const match = /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)(?:\.(\d{1,9}))?$/.exec(value);
+    if (!match)
+        return undefined;
+    const seconds = Number(match[1]) * 3_600 + Number(match[2]) * 60 + Number(match[3]);
+    return BigInt(seconds) * 1000000000n + BigInt((match[4] ?? "").padEnd(9, "0") || "0");
+}
+function exactTimestampKey(value) {
+    const timestamp = parseTimestampValue(value, "nanosecond");
+    if (!timestamp)
+        return undefined;
+    const localSecond = BigInt(daysFromCivil(timestamp.year, timestamp.month, timestamp.day)) * 86400n +
+        BigInt(timestamp.hour * 3_600 + timestamp.minute * 60 + timestamp.second);
+    return {
+        epochSecond: localSecond - BigInt(timestamp.offsetSeconds ?? 0),
+        fraction: BigInt(timestamp.fraction.padEnd(9, "0") || "0"),
+        leapSecond: timestamp.second === 60,
+        zoned: timestamp.zone !== undefined,
+    };
+}
+/** Proleptic-Gregorian civil day number, based on Howard Hinnant's days-from-civil algorithm. */
+function daysFromCivil(year, month, day) {
+    const adjustedYear = year - (month <= 2 ? 1 : 0);
+    const era = Math.floor(adjustedYear / 400);
+    const yearOfEra = adjustedYear - era * 400;
+    const monthPrime = month + (month > 2 ? -3 : 9);
+    const dayOfYear = Math.floor((153 * monthPrime + 2) / 5) + day - 1;
+    const dayOfEra = yearOfEra * 365 + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100) + dayOfYear;
+    return era * 146_097 + dayOfEra - 719_468;
+}
+function integerString(value, bits, signed) {
+    if (value.length > 20)
+        return false;
+    if (!(signed ? /^-?(?:0|[1-9]\d*)$/ : /^(?:0|[1-9]\d*)$/).test(value) || value === "-0")
+        return false;
+    return integerBigInt(BigInt(value), bits, signed);
+}
+function integerNumber(value, bits, signed) {
+    return Number.isSafeInteger(value) && integerBigInt(BigInt(value), bits, signed);
+}
+function integerBigInt(value, bits, signed) {
+    const width = BigInt(bits);
+    const minimum = signed ? -(1n << (width - 1n)) : 0n;
+    const maximum = signed ? (1n << (width - 1n)) - 1n : (1n << width) - 1n;
+    return value >= minimum && value <= maximum;
+}
+function decimalString(value, precision, scale) {
+    const match = /^(-?)(0|[1-9]\d*)(?:\.(\d+))?$/.exec(value);
+    if (!match)
+        return false;
+    const integer = match[2];
+    const fraction = match[3] ?? "";
+    if (match[1] === "-" && integer === "0" && !/[1-9]/.test(fraction))
+        return false;
+    return decimalDigitsFit(integer, fraction, precision, scale);
+}
+function binaryValue(value, encoding) {
+    if (encoding === "opaque")
+        return true;
+    if (encoding === "base64") {
+        return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value);
+    }
+    try {
+        absoluteUri(value, "binary URL");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function decimalNumber(value, precision, scale) {
+    if (!Number.isFinite(value))
+        return false;
+    const expanded = expandExponentialNumber(Object.is(value, -0) ? 0 : value);
+    const match = /^-?(0|[1-9]\d*)(?:\.(\d+))?$/.exec(expanded);
+    return match !== null && decimalDigitsFit(match[1], match[2] ?? "", precision, scale);
+}
+function decimalDigitsFit(integer, fraction, precision, scale) {
+    if (scale !== undefined && fraction.length > scale)
+        return false;
+    const integerDigits = integer === "0" ? 0 : integer.length;
+    if (precision !== undefined && scale !== undefined && integerDigits > precision - scale)
+        return false;
+    const totalDigits = Math.max(1, integerDigits + fraction.length);
+    return precision === undefined || totalDigits <= precision;
+}
+function expandExponentialNumber(value) {
+    const lexical = String(value);
+    const match = /^(-?)(\d+)(?:\.(\d+))?[eE]([+-]?\d+)$/.exec(lexical);
+    if (!match)
+        return lexical;
+    const sign = match[1];
+    const integer = match[2];
+    const fraction = match[3] ?? "";
+    const exponent = Number(match[4]);
+    const digits = `${integer}${fraction}`;
+    const point = integer.length + exponent;
+    if (point <= 0)
+        return `${sign}0.${"0".repeat(-point)}${digits}`;
+    if (point >= digits.length)
+        return `${sign}${digits}${"0".repeat(point - digits.length)}`;
+    return `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;
+}
+function calendarDate(value) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+    if (!match)
+        return false;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    if (month < 1 || month > 12 || day < 1)
+        return false;
+    const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    return day <= days[month - 1];
+}
+function timeOfDay(value, unit) {
+    const match = /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)(?:\.(\d{1,9}))?$/.exec(value);
+    if (!match)
+        return false;
+    const fractionLength = match[4]?.length ?? 0;
+    return fractionLength <= temporalFractionDigits(unit);
+}
+function timestampValue(value, unit, timezone) {
+    const timestamp = parseTimestampValue(value, unit);
+    if (!timestamp)
+        return false;
+    if (timezone === "utc" && timestamp.zone !== "Z")
+        return false;
+    if (timezone === "offset" && timestamp.zone === undefined)
+        return false;
+    if (timezone === "local" && timestamp.zone !== undefined)
+        return false;
+    return true;
+}
+function parseTimestampValue(value, unit) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})T([01]\d|2[0-3]):([0-5]\d):([0-5]\d|60)(?:\.(\d{1,9}))?(Z|[+-]\d{2}:\d{2})?$/.exec(value);
+    if (!match)
+        return undefined;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const hour = Number(match[4]);
+    const minute = Number(match[5]);
+    const second = Number(match[6]);
+    const fraction = match[7] ?? "";
+    const zone = match[8];
+    if (!calendarDate(`${match[1]}-${match[2]}-${match[3]}`) || fraction.length > temporalFractionDigits(unit)) {
+        return undefined;
+    }
+    const offsetSeconds = zone === undefined ? undefined : timestampOffsetSeconds(zone);
+    if (zone !== undefined && offsetSeconds === undefined)
+        return undefined;
+    if (second === 60 &&
+        (offsetSeconds === undefined || !isUtcLeapSecondBoundary(year, month, day, hour, minute, offsetSeconds))) {
+        return undefined;
+    }
+    return {
+        year,
+        month,
+        day,
+        hour,
+        minute,
+        second,
+        fraction,
+        ...(zone === undefined ? {} : { zone, offsetSeconds: offsetSeconds }),
+    };
+}
+function timestampOffsetSeconds(zone) {
+    if (zone === "Z")
+        return 0;
+    if (!validOffset(zone))
+        return undefined;
+    const match = /^([+-])(\d{2}):(\d{2})$/.exec(zone);
+    const magnitude = Number(match[2]) * 3_600 + Number(match[3]) * 60;
+    return match[1] === "-" ? -magnitude : magnitude;
+}
+function isUtcLeapSecondBoundary(year, month, day, hour, minute, offsetSeconds) {
+    const localSecondBeforeLeap = BigInt(daysFromCivil(year, month, day)) * 86400n + BigInt(hour * 3_600 + minute * 60 + 59);
+    const utcSecondBeforeLeap = localSecondBeforeLeap - BigInt(offsetSeconds);
+    for (let candidateYear = year - 1; candidateYear <= year + 1; candidateYear++) {
+        for (const [candidateMonth, candidateDay] of [
+            [6, 30],
+            [12, 31],
+        ]) {
+            const boundary = BigInt(daysFromCivil(candidateYear, candidateMonth, candidateDay)) * 86400n + 86399n;
+            if (utcSecondBeforeLeap === boundary)
+                return true;
+        }
+    }
+    return false;
+}
+function temporalFractionDigits(unit) {
+    switch (unit) {
+        case "second":
+            return 0;
+        case "millisecond":
+            return 3;
+        case "microsecond":
+            return 6;
+        case "nanosecond":
+            return 9;
+    }
+}
+function validOffset(value) {
+    const match = /^[+-](\d{2}):(\d{2})$/.exec(value);
+    return match !== null && Number(match[1]) <= 23 && Number(match[2]) <= 59;
+}
+function durationValue(value) {
+    return /^-?P(?=\d|T\d)(?:\d+(?:\.\d+)?Y)?(?:\d+(?:\.\d+)?M)?(?:\d+(?:\.\d+)?W)?(?:\d+(?:\.\d+)?D)?(?:T(?=\d)(?:\d+(?:\.\d+)?H)?(?:\d+(?:\.\d+)?M)?(?:\d+(?:\.\d+)?S)?)?$/.test(value);
+}
+function compareDecimalStrings(left, right) {
+    const normalizedLeft = decimalParts(left);
+    const normalizedRight = decimalParts(right);
+    if (normalizedLeft.negative !== normalizedRight.negative)
+        return normalizedLeft.negative ? -1 : 1;
+    const direction = normalizedLeft.negative ? -1 : 1;
+    if (normalizedLeft.integer.length !== normalizedRight.integer.length) {
+        return normalizedLeft.integer.length < normalizedRight.integer.length ? -direction : direction;
+    }
+    if (normalizedLeft.integer !== normalizedRight.integer) {
+        return normalizedLeft.integer < normalizedRight.integer ? -direction : direction;
+    }
+    const fractionalLength = Math.max(normalizedLeft.fraction.length, normalizedRight.fraction.length);
+    const leftFraction = normalizedLeft.fraction.padEnd(fractionalLength, "0");
+    const rightFraction = normalizedRight.fraction.padEnd(fractionalLength, "0");
+    if (leftFraction === rightFraction)
+        return 0;
+    return leftFraction < rightFraction ? -direction : direction;
+}
+function decimalParts(value) {
+    const negative = value.startsWith("-");
+    const unsigned = negative ? value.slice(1) : value;
+    const [integer = "0", fraction = ""] = unsigned.split(".");
+    let integerStart = 0;
+    while (integerStart < integer.length - 1 && integer.charCodeAt(integerStart) === 48)
+        integerStart += 1;
+    let fractionEnd = fraction.length;
+    while (fractionEnd > 0 && fraction.charCodeAt(fractionEnd - 1) === 48)
+        fractionEnd -= 1;
+    const normalizedInteger = integer.slice(integerStart);
+    const normalizedFraction = fraction.slice(0, fractionEnd);
+    const zero = normalizedInteger === "0" && normalizedFraction === "";
+    return { negative: zero ? false : negative, integer: normalizedInteger, fraction: normalizedFraction };
+}
+function validateProjJson(projjson, path) {
+    assertBoundedGraphDepth(projjson, path, 32);
+    if (projjson.$schema !== undefined && projjson.$schema !== PROJJSON_V07_SCHEMA) {
+        throw new TypeError(`${path}.$schema must identify the supported PROJJSON v0.7 schema`);
+    }
+    if (typeof projjson.type !== "string" || !PROJJSON_V07_TYPES.has(projjson.type)) {
+        throw new TypeError(`${path}.type is not a supported PROJJSON v0.7 CRS root`);
+    }
+    const validator = validateProjJsonV07Crs;
+    if (!validator(projjson)) {
+        const selected = selectProjJsonError(projjson.type, validator.errors ?? []);
+        const instancePath = selected?.instancePath ? jsonPointerPath(selected.instancePath) : "";
+        const missing = selected?.params?.missingProperty;
+        const additional = selected?.params?.additionalProperty;
+        const selectedPath = missing
+            ? `${instancePath}.${missing}`
+            : additional
+                ? `${instancePath}.${additional}`
+                : instancePath;
+        const detail = selected?.message ? `: ${selected.message}` : "";
+        throw new TypeError(`${path}${selectedPath} does not satisfy the official PROJJSON v0.7 CRS schema${detail}`);
+    }
+    validateProjJsonUris(projjson, path);
+}
+function validateProjJsonUris(projjson, path) {
+    const stack = [{ value: projjson, path }];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current.value === null || typeof current.value !== "object")
+            continue;
+        if (Array.isArray(current.value)) {
+            for (const [index, child] of current.value.entries()) {
+                stack.push({ value: child, path: `${current.path}[${index}]` });
+            }
+            continue;
+        }
+        for (const [key, child] of Object.entries(current.value)) {
+            const childPath = `${current.path}.${key}`;
+            if (key === "uri")
+                absoluteUri(child, childPath);
+            else
+                stack.push({ value: child, path: childPath });
+        }
+    }
+}
+function selectProjJsonError(type, errors) {
+    // Ajv's standalone code preserves precise instance paths but referenced
+    // branch validators use local schema paths (for example `#/required`). Pick
+    // a missing property from the selected root vocabulary before considering
+    // deeper errors from the other oneOf branches.
+    const rootRequired = {
+        GeographicCRS: ["name", "datum", "datum_ensemble"],
+        GeodeticCRS: ["name", "datum", "datum_ensemble"],
+        ProjectedCRS: ["name", "base_crs", "conversion", "coordinate_system"],
+        VerticalCRS: ["name", "datum", "datum_ensemble"],
+        CompoundCRS: ["name", "components"],
+        BoundCRS: ["source_crs", "target_crs", "transformation"],
+        EngineeringCRS: ["name", "datum"],
+        ParametricCRS: ["name", "datum"],
+        TemporalCRS: ["name", "datum"],
+        DerivedProjectedCRS: ["name", "base_crs", "conversion", "coordinate_system"],
+        DerivedGeographicCRS: ["name", "base_crs", "conversion", "coordinate_system"],
+        DerivedGeodeticCRS: ["name", "base_crs", "conversion", "coordinate_system"],
+        DerivedVerticalCRS: ["name", "base_crs", "conversion", "coordinate_system"],
+        DerivedEngineeringCRS: ["name", "base_crs", "conversion", "coordinate_system"],
+        DerivedTemporalCRS: ["name", "base_crs", "conversion", "coordinate_system"],
+        DerivedParametricCRS: ["name", "base_crs", "conversion", "coordinate_system"],
+    };
+    const expected = rootRequired[type] ?? [];
+    const missingRoot = errors.find((error) => error.instancePath === "" &&
+        error.keyword === "required" &&
+        error.params?.missingProperty !== undefined &&
+        expected.includes(error.params.missingProperty));
+    if (missingRoot)
+        return missingRoot;
+    const officialRootMembers = new Set([
+        "$schema",
+        "type",
+        "name",
+        "datum",
+        "datum_ensemble",
+        "coordinate_system",
+        "deformation_models",
+        "base_crs",
+        "conversion",
+        "components",
+        "source_crs",
+        "target_crs",
+        "transformation",
+        "geoid_model",
+        "geoid_models",
+        "scope",
+        "area",
+        "bbox",
+        "vertical_extent",
+        "temporal_extent",
+        "usages",
+        "remarks",
+        "id",
+        "ids",
+    ]);
+    const unknownAdditional = errors.find((error) => error.instancePath === "" &&
+        error.keyword === "additionalProperties" &&
+        error.params?.additionalProperty !== undefined &&
+        !officialRootMembers.has(error.params.additionalProperty));
+    if (unknownAdditional)
+        return unknownAdditional;
+    return ([...errors]
+        .filter((error) => error.keyword !== "oneOf" && error.instancePath !== "/type")
+        .sort((left, right) => (right.instancePath?.length ?? 0) - (left.instancePath?.length ?? 0))[0] ?? errors[0]);
+}
+function jsonPointerPath(pointer) {
+    return pointer
+        .split("/")
+        .slice(1)
+        .map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"))
+        .map((part) => (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(part) ? `.${part}` : `[${JSON.stringify(part)}]`))
+        .join("");
+}
+function assertBoundedGraphDepth(value, path, maximum) {
+    const stack = [{ kind: "enter", value, depth: 0, path }];
+    const ancestors = new WeakSet();
+    let nodes = 0;
+    let scalarAndKeyBytes = 0;
+    const consumeBytes = (textValue, valuePath) => {
+        assertUnicodeScalarString(textValue, valuePath);
+        const remaining = MAX_SCHEMA_BYTES - scalarAndKeyBytes;
+        if (remaining < 0 || textValue.length > remaining) {
+            throw new TypeError(`${path} exceeds the ${MAX_SCHEMA_BYTES}-byte bound`);
+        }
+        scalarAndKeyBytes += utf8ByteLength(textValue);
+        if (scalarAndKeyBytes > MAX_SCHEMA_BYTES) {
+            throw new TypeError(`${path} exceeds the ${MAX_SCHEMA_BYTES}-byte bound`);
+        }
+    };
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current.kind === "leave") {
+            ancestors.delete(current.value);
+            continue;
+        }
+        if (current.value === null) {
+            consumeBytes("null", current.path);
+            continue;
+        }
+        if (typeof current.value === "string") {
+            consumeBytes(current.value, current.path);
+            continue;
+        }
+        if (typeof current.value === "boolean") {
+            consumeBytes(current.value ? "true" : "false", current.path);
+            continue;
+        }
+        if (typeof current.value === "number") {
+            if (!Number.isFinite(current.value))
+                throw new TypeError(`${current.path} must contain only finite numbers`);
+            consumeBytes(String(current.value), current.path);
+            continue;
+        }
+        if (typeof current.value !== "object") {
+            throw new TypeError(`${current.path} contains unsupported ${typeof current.value}`);
+        }
+        if (current.depth > maximum)
+            throw new TypeError(`${current.path} exceeds maximum JSON nesting depth ${maximum}`);
+        if (++nodes > MAX_JSON_NODE_COUNT)
+            throw new TypeError(`${path} exceeds the bounded JSON node count`);
+        if (ancestors.has(current.value))
+            throw new TypeError(`${current.path} must not contain cycles`);
+        const prototype = Object.getPrototypeOf(current.value);
+        if (!Array.isArray(current.value) && prototype !== Object.prototype && prototype !== null) {
+            throw new TypeError(`${current.path} must contain only plain JSON objects`);
+        }
+        if (Object.getOwnPropertySymbols(current.value).length > 0) {
+            throw new TypeError(`${current.path} must not contain symbol keys`);
+        }
+        ancestors.add(current.value);
+        stack.push({ kind: "leave", value: current.value });
+        if (Array.isArray(current.value)) {
+            const arrayValue = current.value;
+            if (arrayValue.length > MAX_JSON_NODE_COUNT) {
+                throw new TypeError(`${current.path} exceeds the bounded JSON array length`);
+            }
+            const extraKey = Object.keys(arrayValue).find((key) => !/^(?:0|[1-9]\d*)$/.test(key) || Number(key) >= arrayValue.length);
+            if (extraKey !== undefined)
+                throw new TypeError(`${current.path}.${extraKey} is not a JSON array element`);
+            for (let index = arrayValue.length - 1; index >= 0; index--) {
+                const descriptor = Object.getOwnPropertyDescriptor(arrayValue, String(index));
+                if (!descriptor || !("value" in descriptor)) {
+                    throw new TypeError(`${current.path}[${index}] must be a plain JSON value`);
+                }
+                stack.push({
+                    kind: "enter",
+                    value: descriptor.value,
+                    depth: current.depth + 1,
+                    path: `${current.path}[${index}]`,
+                });
+            }
+            continue;
+        }
+        const descriptors = Object.getOwnPropertyDescriptors(current.value);
+        const keys = Object.keys(current.value);
+        for (let index = keys.length - 1; index >= 0; index--) {
+            const key = keys[index];
+            consumeBytes(key, `${current.path} object key`);
+            const descriptor = descriptors[key];
+            if (!descriptor || !("value" in descriptor)) {
+                throw new TypeError(`${current.path}.${key} must be a plain JSON value`);
+            }
+            stack.push({
+                kind: "enter",
+                value: descriptor.value,
+                depth: current.depth + 1,
+                path: `${current.path}.${key}`,
+            });
+        }
+    }
+}
+function assertUnicodeScalarString(value, path) {
+    for (let index = 0; index < value.length; index++) {
+        const codeUnit = value.charCodeAt(index);
+        if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (!(next >= 0xdc00 && next <= 0xdfff)) {
+                throw new TypeError(`${path} contains an unpaired high Unicode surrogate`);
+            }
+            index++;
+        }
+        else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+            throw new TypeError(`${path} contains an unpaired low Unicode surrogate`);
+        }
+    }
+}
+/** Reject non-I-JSON duplicate names before JSON.parse's last-name-wins object is trusted. */
+function assertUniqueJsonObjectNames(source) {
+    let index = 0;
+    const whitespace = () => {
+        while (index < source.length && /\s/.test(source[index]))
+            index++;
+    };
+    const stringToken = () => {
+        const start = index++;
+        while (index < source.length) {
+            const character = source[index++];
+            if (character === "\\")
+                index++;
+            else if (character === '"')
+                break;
+        }
+        return JSON.parse(source.slice(start, index));
+    };
+    const value = (depth) => {
+        if (depth > MAX_SCHEMA_GRAPH_DEPTH) {
+            throw new TypeError(`Serialized SourceSchemaV2 exceeds maximum JSON nesting depth ${MAX_SCHEMA_GRAPH_DEPTH}`);
+        }
+        whitespace();
+        const character = source[index];
+        if (character === '"') {
+            stringToken();
+            return;
+        }
+        if (character === "{") {
+            index++;
+            whitespace();
+            const names = new Set();
+            if (source[index] === "}") {
+                index++;
+                return;
+            }
+            while (index < source.length) {
+                const name = stringToken();
+                if (names.has(name))
+                    throw new TypeError("SourceSchemaV2 JSON contains a duplicate object name");
+                names.add(name);
+                whitespace();
+                index++; // colon; JSON syntax was already validated by the native parser.
+                value(depth + 1);
+                whitespace();
+                if (source[index] === "}") {
+                    index++;
+                    return;
+                }
+                index++; // comma
+                whitespace();
+            }
+            return;
+        }
+        if (character === "[") {
+            index++;
+            whitespace();
+            if (source[index] === "]") {
+                index++;
+                return;
+            }
+            while (index < source.length) {
+                value(depth + 1);
+                whitespace();
+                if (source[index] === "]") {
+                    index++;
+                    return;
+                }
+                index++; // comma
+            }
+            return;
+        }
+        while (index < source.length && !/[\s,}\]]/.test(source[index]))
+            index++;
+    };
+    value(0);
+}
+function assertSchemaByteBound(schema) {
+    const serialized = canonicalStringify(toJsonValue(schema));
+    if (utf8ByteLength(serialized) > MAX_SCHEMA_BYTES) {
+        throw new TypeError(`SourceSchemaV2 exceeds the ${MAX_SCHEMA_BYTES}-byte bound`);
+    }
+}
+function utf8ByteLength(value) {
+    return new TextEncoder().encode(value).byteLength;
+}
+function compareFields(left, right) {
+    const leftPath = canonicalStringify(toJsonValue(left.path));
+    const rightPath = canonicalStringify(toJsonValue(right.path));
+    return leftPath === rightPath ? compareUtf8(left.name, right.name) : compareUtf8(leftPath, rightPath);
+}
+function compareCanonical(left, right) {
+    return compareUtf8(canonicalStringify(toJsonValue(left)), canonicalStringify(toJsonValue(right)));
+}
+function compareUtf8(left, right) {
+    const leftBytes = new TextEncoder().encode(left);
+    const rightBytes = new TextEncoder().encode(right);
+    const length = Math.min(leftBytes.length, rightBytes.length);
+    for (let index = 0; index < length; index++) {
+        const difference = leftBytes[index] - rightBytes[index];
+        if (difference !== 0)
+            return difference;
+    }
+    return leftBytes.length - rightBytes.length;
+}
+function unique(values, label) {
+    const seen = new Set();
+    for (const value of values) {
+        if (seen.has(value))
+            throw new TypeError(`${label} must not contain duplicates`);
+        seen.add(value);
+    }
+}
+function includes(values, value) {
+    return values.includes(value);
+}
+function deepFreeze(value) {
+    if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+        for (const child of Object.values(value))
+            deepFreeze(child);
+        Object.freeze(value);
+    }
+    return value;
+}