@sixb/core 0.1.7 → 0.1.9

package/dist/{chunk-d63tybny.js → chunk-ms2tmn1k.js}

@@ -1,64 +1,64 @@
 // @bun
 import {
-  isDecimalString,
-  normalizeDecimalValue
-} from "./chunk-04b07a9q.js";
+  OntologyValidationError2
+} from "./chunk-cqr3acm1.js";
 import {
-  OntologyValidationError
-} from "./chunk-dktq02ne.js";
+  normalizeDecimalValue2,
+  isDecimalString2
+} from "./chunk-3bh94gbw.js";
 import {
-  isFileRef
-} from "./chunk-08m3b6w8.js";
+  isFileRef2
+} from "./chunk-h3v76ams.js";
 import {
-  assertJsonValue,
-  cloneJsonValue
-} from "./chunk-n6jxh8sw.js";
+  assertJsonValue2,
+  cloneJsonValue2
+} from "./chunk-wy0qdqfm.js";
 
 // src/ontology/validation/schema.ts
-function validateSchemaValue(schema, value, path, valueTypesById) {
+function validateSchemaValue2(schema, value, path, valueTypesById) {
   if (typeof schema === "string") {
     switch (schema) {
       case "string":
       case "uuid": {
         if (typeof value !== "string") {
-          throw new OntologyValidationError(`[Sixb] Property ${path} must be a string`);
+          throw new OntologyValidationError2(`[Sixb] Property ${path} must be a string`);
         }
         return;
       }
       case "boolean": {
         if (typeof value !== "boolean") {
-          throw new OntologyValidationError(`[Sixb] Property ${path} must be a boolean`);
+          throw new OntologyValidationError2(`[Sixb] Property ${path} must be a boolean`);
         }
         return;
       }
       case "integer": {
         if (typeof value !== "number" || !Number.isInteger(value)) {
-          throw new OntologyValidationError(`[Sixb] Property ${path} must be an integer`);
+          throw new OntologyValidationError2(`[Sixb] Property ${path} must be an integer`);
         }
         return;
       }
       case "double": {
         if (typeof value !== "number" || !Number.isFinite(value)) {
-          throw new OntologyValidationError(`[Sixb] Property ${path} must be numeric`);
+          throw new OntologyValidationError2(`[Sixb] Property ${path} must be numeric`);
         }
         return;
       }
       case "decimal": {
-        if (!isDecimalString(value)) {
-          throw new OntologyValidationError(`[Sixb] Property ${path} must be an exact decimal string`);
+        if (!isDecimalString2(value)) {
+          throw new OntologyValidationError2(`[Sixb] Property ${path} must be an exact decimal string`);
         }
         return;
       }
       case "date":
       case "timestamp": {
         if (!(value instanceof Date) && typeof value !== "string") {
-          throw new OntologyValidationError(`[Sixb] Property ${path} must be a Date or ISO string`);
+          throw new OntologyValidationError2(`[Sixb] Property ${path} must be a Date or ISO string`);
         }
         return;
       }
       case "fileRef": {
-        if (!isFileRef(value)) {
-          throw new OntologyValidationError(`[Sixb] Property ${path} must be a fileRef`);
+        if (!isFileRef2(value)) {
+          throw new OntologyValidationError2(`[Sixb] Property ${path} must be a fileRef`);
         }
         return;
       }
@@ -66,44 +66,44 @@ function validateSchemaValue(schema, value, path, valueTypesById) {
   }
   if (schema.type === "enum") {
     if (!schema.values.includes(value)) {
-      throw new OntologyValidationError(`[Sixb] Property ${path} must be one of: ${schema.values.join(", ")}`);
+      throw new OntologyValidationError2(`[Sixb] Property ${path} must be one of: ${schema.values.join(", ")}`);
     }
     return;
   }
   if (schema.type === "array") {
     if (!Array.isArray(value)) {
-      throw new OntologyValidationError(`[Sixb] Property ${path} must be an array`);
+      throw new OntologyValidationError2(`[Sixb] Property ${path} must be an array`);
     }
     for (let index = 0;index < value.length; index += 1) {
-      validateSchemaValue(schema.items, value[index], `${path}[${index}]`, valueTypesById);
+      validateSchemaValue2(schema.items, value[index], `${path}[${index}]`, valueTypesById);
     }
     return;
   }
   if (schema.type === "map") {
-    if (!isRecord(value)) {
-      throw new OntologyValidationError(`[Sixb] Property ${path} must be an object map`);
+    if (!isRecord2(value)) {
+      throw new OntologyValidationError2(`[Sixb] Property ${path} must be an object map`);
     }
     for (const [key, entry] of Object.entries(value)) {
-      validateSchemaValue(schema.valueSchema, entry, `${path}.${key}`, valueTypesById);
+      validateSchemaValue2(schema.valueSchema, entry, `${path}.${key}`, valueTypesById);
     }
     return;
   }
   if (schema.type === "object") {
-    if (!isRecord(value)) {
-      throw new OntologyValidationError(`[Sixb] Property ${path} must be an object`);
+    if (!isRecord2(value)) {
+      throw new OntologyValidationError2(`[Sixb] Property ${path} must be an object`);
     }
     const fields = schema.properties;
     const fieldIds = new Set(Object.keys(fields));
     for (const fieldId of Object.keys(value)) {
       if (!fieldIds.has(fieldId)) {
-        throw new OntologyValidationError(`[Sixb] Unknown field '${path}.${fieldId}'`);
+        throw new OntologyValidationError2(`[Sixb] Unknown field '${path}.${fieldId}'`);
       }
     }
     for (const [fieldId, field] of Object.entries(fields)) {
       const fieldValue = value[fieldId];
       if (fieldValue === undefined) {
         if (field.required) {
-          throw new OntologyValidationError(`[Sixb] Missing required field '${path}.${fieldId}'`);
+          throw new OntologyValidationError2(`[Sixb] Missing required field '${path}.${fieldId}'`);
         }
         continue;
       }
@@ -112,7 +112,7 @@ function validateSchemaValue(schema, value, path, valueTypesById) {
     return;
   }
   if (schema.type === "valueTypeRef") {
-    validateSchemaValue(resolveValueTypeSchema(schema, valueTypesById, path), value, path, valueTypesById);
+    validateSchemaValue2(resolveValueTypeSchema2(schema, valueTypesById, path), value, path, valueTypesById);
   }
 }
 function validateFieldValue(field, value, path, valueTypesById) {
@@ -120,11 +120,11 @@ function validateFieldValue(field, value, path, valueTypesById) {
     if (field.nullable) {
       return;
     }
-    throw new OntologyValidationError(`[Sixb] Field ${path} cannot be null`);
+    throw new OntologyValidationError2(`[Sixb] Field ${path} cannot be null`);
   }
-  validateSchemaValue(field.schema, value, path, valueTypesById);
+  validateSchemaValue2(field.schema, value, path, valueTypesById);
 }
-function resolveValueTypeRef(schema) {
+function resolveValueTypeRef2(schema) {
   if (typeof schema === "string") {
     return;
   }
@@ -133,29 +133,29 @@ function resolveValueTypeRef(schema) {
   }
   return;
 }
-function resolveValueTypeSchema(schema, valueTypesById, path) {
+function resolveValueTypeSchema2(schema, valueTypesById, path) {
   const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
   if (!resolved) {
-    throw new OntologyValidationError(`[Sixb] Unknown valueTypeRef '${schema.valueTypeId}' at ${path}`);
+    throw new OntologyValidationError2(`[Sixb] Unknown valueTypeRef '${schema.valueTypeId}' at ${path}`);
   }
   return resolved;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/ontology/validation/normalize.ts
-function normalizeObjectProperties(definitions, properties, valueTypesById, path) {
+function normalizeObjectProperties2(definitions, properties, valueTypesById, path) {
   const normalized = {};
   for (const [propertyId, value] of Object.entries(properties)) {
     const property = definitions.find((candidate) => candidate.id === propertyId);
     if (!property)
       continue;
-    normalized[propertyId] = value === null ? null : normalizeSchemaValue(property.schema, value, `${path}.${propertyId}`, valueTypesById);
+    normalized[propertyId] = value === null ? null : normalizeSchemaValue2(property.schema, value, `${path}.${propertyId}`, valueTypesById);
   }
   return normalized;
 }
-function normalizeSchemaValue(schema, value, path, valueTypesById) {
+function normalizeSchemaValue2(schema, value, path, valueTypesById) {
   if (typeof schema === "string") {
     switch (schema) {
       case "date":
@@ -165,30 +165,30 @@ function normalizeSchemaValue(schema, value, path, valueTypesById) {
       case "decimal":
         return normalizeDecimal(value, path);
       default:
-        assertJsonValue(value, path);
-        return cloneJsonValue(value);
+        assertJsonValue2(value, path);
+        return cloneJsonValue2(value);
     }
   }
   if (schema.type === "valueTypeRef") {
-    return normalizeSchemaValue(resolveValueTypeSchema(schema, valueTypesById, path), value, path, valueTypesById);
+    return normalizeSchemaValue2(resolveValueTypeSchema2(schema, valueTypesById, path), value, path, valueTypesById);
   }
   if (schema.type === "enum") {
-    assertJsonValue(value, path);
-    return cloneJsonValue(value);
+    assertJsonValue2(value, path);
+    return cloneJsonValue2(value);
   }
   if (schema.type === "array") {
     if (!Array.isArray(value)) {
-      throw new OntologyValidationError(`[Sixb] Property ${path} must be an array`);
+      throw new OntologyValidationError2(`[Sixb] Property ${path} must be an array`);
     }
-    return value.map((entry, index) => normalizeSchemaValue(schema.items, entry, `${path}[${index}]`, valueTypesById));
+    return value.map((entry, index) => normalizeSchemaValue2(schema.items, entry, `${path}[${index}]`, valueTypesById));
   }
   if (schema.type === "map") {
-    const record2 = assertPlainRecord(value, path);
-    const entries2 = Object.entries(record2).map(([key, entry]) => [
+    const record = assertPlainRecord(value, path);
+    const entries = Object.entries(record).map(([key, entry]) => [
       key,
-      normalizeSchemaValue(schema.valueSchema, entry, `${path}.${key}`, valueTypesById)
+      normalizeSchemaValue2(schema.valueSchema, entry, `${path}.${key}`, valueTypesById)
     ]);
-    return Object.fromEntries(entries2);
+    return Object.fromEntries(entries);
   }
   const fields = schema.properties;
   const record = assertPlainRecord(value, path);
@@ -209,11 +209,11 @@ function normalizeObjectFieldValue(field, value, path, valueTypesById) {
   if (value === null) {
     return null;
   }
-  return normalizeSchemaValue(field.schema, value, path, valueTypesById);
+  return normalizeSchemaValue2(field.schema, value, path, valueTypesById);
 }
 function assertPlainRecord(value, path) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new OntologyValidationError(`[Sixb] Property ${path} must be an object`);
+    throw new OntologyValidationError2(`[Sixb] Property ${path} must be an object`);
   }
   return value;
 }
@@ -226,22 +226,22 @@ function normalizeTimestampValue(value, path) {
 }
 function normalizeDecimal(value, path) {
   if (typeof value !== "string") {
-    throw new OntologyValidationError(`[Sixb] Property ${path} must be an exact decimal string`);
+    throw new OntologyValidationError2(`[Sixb] Property ${path} must be an exact decimal string`);
   }
   try {
-    return normalizeDecimalValue(value);
+    return normalizeDecimalValue2(value);
   } catch {
-    throw new OntologyValidationError(`[Sixb] Property ${path} must be an exact decimal string`);
+    throw new OntologyValidationError2(`[Sixb] Property ${path} must be an exact decimal string`);
   }
 }
 function normalizeDateLike(value, path) {
   const date = value instanceof Date ? value : new Date(String(value));
   if (Number.isNaN(date.getTime())) {
-    throw new OntologyValidationError(`[Sixb] Property ${path} must be a valid date`);
+    throw new OntologyValidationError2(`[Sixb] Property ${path} must be a valid date`);
   }
   return date;
 }
-function coerceSchemaValueToTyped(schema, value, valueTypesById) {
+function coerceSchemaValueToTyped2(schema, value, valueTypesById) {
   if (value === null || value === undefined) {
     return value;
   }
@@ -252,7 +252,7 @@ function coerceSchemaValueToTyped(schema, value, valueTypesById) {
     return value;
   }
   if (schema.type === "valueTypeRef") {
-    return coerceSchemaValueToTyped(resolveValueTypeSchema(schema, valueTypesById, ""), value, valueTypesById);
+    return coerceSchemaValueToTyped2(resolveValueTypeSchema2(schema, valueTypesById, ""), value, valueTypesById);
   }
   if (schema.type === "enum") {
     return value;
@@ -260,44 +260,44 @@ function coerceSchemaValueToTyped(schema, value, valueTypesById) {
   if (schema.type === "array") {
     if (!Array.isArray(value))
       return value;
-    return value.map((entry) => coerceSchemaValueToTyped(schema.items, entry, valueTypesById));
+    return value.map((entry) => coerceSchemaValueToTyped2(schema.items, entry, valueTypesById));
   }
   if (schema.type === "map") {
-    if (!isRecord(value))
+    if (!isRecord2(value))
       return value;
     return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
       key,
-      coerceSchemaValueToTyped(schema.valueSchema, entry, valueTypesById)
+      coerceSchemaValueToTyped2(schema.valueSchema, entry, valueTypesById)
     ]));
   }
-  if (!isRecord(value))
+  if (!isRecord2(value))
     return value;
   const output = { ...value };
   for (const [fieldId, field] of Object.entries(schema.properties)) {
     if (value[fieldId] === undefined)
       continue;
-    output[fieldId] = coerceSchemaValueToTyped(field.schema, value[fieldId], valueTypesById);
+    output[fieldId] = coerceSchemaValueToTyped2(field.schema, value[fieldId], valueTypesById);
   }
   return output;
 }
 
 // src/ontology/validation/properties.ts
-function assertObjectTypeRegistered(objectTypesById, objectType) {
+function assertObjectTypeRegistered2(objectTypesById, objectType) {
   if (!objectTypesById.has(objectType.id)) {
-    throw new OntologyValidationError(`[Sixb] Object type is not registered in this runtime: ${objectType.id}`);
+    throw new OntologyValidationError2(`[Sixb] Object type is not registered in this runtime: ${objectType.id}`);
   }
 }
-function assertPropertyTokenBelongsToObjectType(objectType, property) {
+function assertPropertyTokenBelongsToObjectType2(objectType, property) {
   if (property.objectTypeId !== objectType.id) {
-    throw new OntologyValidationError(`[Sixb] Property token ${property.objectTypeId}.${property.id} cannot be used with ${objectType.id}`);
+    throw new OntologyValidationError2(`[Sixb] Property token ${property.objectTypeId}.${property.id} cannot be used with ${objectType.id}`);
   }
 }
-function assertLinkTokenBelongsToObjectType(objectType, link) {
+function assertLinkTokenBelongsToObjectType2(objectType, link) {
   if (!isLinkTokenLike(link)) {
-    throw new OntologyValidationError(`[Sixb] Expected a link token from ${objectType.id}.l.<linkId>, not a plain link id.`);
+    throw new OntologyValidationError2(`[Sixb] Expected a link token from ${objectType.id}.l.<linkId>, not a plain link id.`);
   }
   if (link.objectTypeId !== objectType.id) {
-    throw new OntologyValidationError(`[Sixb] Link token ${link.objectTypeId}.${link.id} cannot be used with ${objectType.id}`);
+    throw new OntologyValidationError2(`[Sixb] Link token ${link.objectTypeId}.${link.id} cannot be used with ${objectType.id}`);
   }
 }
 function isLinkTokenLike(value) {
@@ -314,71 +314,71 @@ function isLinkTargetTypeId(value) {
 function isString(value) {
   return typeof value === "string";
 }
-function assertKnownProperties(objectType, properties) {
+function assertKnownProperties2(objectType, properties) {
   const knownIds = new Set(objectType.properties.map((property) => property.id));
   for (const propertyId of Object.keys(properties)) {
     if (!knownIds.has(propertyId)) {
-      throw new OntologyValidationError(`[Sixb] Unknown property '${propertyId}' for object type '${objectType.id}'`);
+      throw new OntologyValidationError2(`[Sixb] Unknown property '${propertyId}' for object type '${objectType.id}'`);
     }
   }
 }
-function assertRequiredProperties(objectType, properties) {
+function assertRequiredProperties2(objectType, properties) {
   for (const property of objectType.properties) {
     if (property.required && properties[property.id] === undefined) {
-      throw new OntologyValidationError(`[Sixb] Missing required property '${property.id}' for object type '${objectType.id}'`);
+      throw new OntologyValidationError2(`[Sixb] Missing required property '${property.id}' for object type '${objectType.id}'`);
     }
   }
 }
-function validateObjectProperties(objectType, properties, valueTypesById) {
+function validateObjectProperties2(objectType, properties, valueTypesById) {
   for (const [propertyId, value] of Object.entries(properties)) {
     const property = objectType.properties.find((candidate) => candidate.id === propertyId);
     if (!property) {
       continue;
     }
-    validatePropertyValue(property, value, `${objectType.id}.${propertyId}`, valueTypesById);
+    validatePropertyValue2(property, value, `${objectType.id}.${propertyId}`, valueTypesById);
   }
 }
-function validatePrimaryProperties(objectTypesById) {
+function validatePrimaryProperties2(objectTypesById) {
   const result = new Map;
   for (const [typeId, objectType] of objectTypesById) {
     const primaries = objectType.properties.filter((p) => p.primary);
     if (primaries.length === 0) {
-      throw new OntologyValidationError(`[Sixb] Object type '${typeId}' has no primary property. ` + `Define one with prop("id", "string", { required: true, primary: true }).`);
+      throw new OntologyValidationError2(`[Sixb] Object type '${typeId}' has no primary property. ` + `Define one with prop("id", "string", { required: true, primary: true }).`);
     }
     if (primaries.length > 1) {
-      throw new OntologyValidationError(`[Sixb] Object type '${typeId}' has ${primaries.length} primary properties, expected 1`);
+      throw new OntologyValidationError2(`[Sixb] Object type '${typeId}' has ${primaries.length} primary properties, expected 1`);
     }
     const primary = primaries[0];
     if (!primary.required) {
-      throw new OntologyValidationError(`[Sixb] Primary property '${primary.id}' on '${typeId}' must be required`);
+      throw new OntologyValidationError2(`[Sixb] Primary property '${primary.id}' on '${typeId}' must be required`);
     }
     if (primary.schema !== "string") {
-      throw new OntologyValidationError(`[Sixb] Primary property '${primary.id}' on '${typeId}' must have schema "string", got "${String(primary.schema)}"`);
+      throw new OntologyValidationError2(`[Sixb] Primary property '${primary.id}' on '${typeId}' must have schema "string", got "${String(primary.schema)}"`);
     }
     result.set(typeId, primary.id);
   }
   return result;
 }
-function validatePropertyDefinitions(objectTypesById, valueTypesById) {
+function validatePropertyDefinitions2(objectTypesById, valueTypesById) {
   for (const [typeId, objectType] of objectTypesById) {
     for (const property of objectType.properties) {
       if (property.mode === "telemetry" && schemaContainsFileRef(property.schema, valueTypesById)) {
-        throw new OntologyValidationError(`[Sixb] Telemetry property '${property.id}' on '${typeId}' cannot use fileRef`);
+        throw new OntologyValidationError2(`[Sixb] Telemetry property '${property.id}' on '${typeId}' cannot use fileRef`);
       }
     }
   }
 }
-function validatePropertyValue(property, value, path, valueTypesById) {
+function validatePropertyValue2(property, value, path, valueTypesById) {
   if (value === undefined) {
-    throw new OntologyValidationError(`[Sixb] Property ${path} cannot be undefined`);
+    throw new OntologyValidationError2(`[Sixb] Property ${path} cannot be undefined`);
   }
   if (value === null) {
     if (property.nullable) {
       return;
     }
-    throw new OntologyValidationError(`[Sixb] Property ${path} cannot be null`);
+    throw new OntologyValidationError2(`[Sixb] Property ${path} cannot be null`);
   }
-  validateSchemaValue(property.schema, value, path, valueTypesById);
+  validateSchemaValue2(property.schema, value, path, valueTypesById);
 }
 function schemaContainsFileRef(schema, valueTypesById, seenValueTypeIds = new Set) {
   if (schema === "fileRef") {
@@ -408,14 +408,14 @@ function schemaContainsFileRef(schema, valueTypesById, seenValueTypeIds = new Se
 }
 
 // src/ontology/validation/links.ts
-function assertLinkTargetType(objectTypeId, linkId, linkDefinition, targetTypeId, isValidLinkTarget) {
+function assertLinkTargetType2(objectTypeId, linkId, linkDefinition, targetTypeId, isValidLinkTarget) {
   const valid = isValidLinkTarget ? isValidLinkTarget(linkDefinition.targetObjectTypeId, targetTypeId) : targetTypeId === linkDefinition.targetObjectTypeId;
   if (!valid) {
     const expected = Array.isArray(linkDefinition.targetObjectTypeId) ? linkDefinition.targetObjectTypeId.join(" | ") : linkDefinition.targetObjectTypeId;
-    throw new OntologyValidationError(`[Sixb] Link ${objectTypeId}.${linkId} must target '${expected}', got '${targetTypeId}'`);
+    throw new OntologyValidationError2(`[Sixb] Link ${objectTypeId}.${linkId} must target '${expected}', got '${targetTypeId}'`);
   }
 }
-function assertTargetTypeCompatible(getSubTypes, declaredTarget, actualTarget, context) {
+function assertTargetTypeCompatible2(getSubTypes, declaredTarget, actualTarget, context) {
   if (declaredTarget === "*")
     return;
   const types = Array.isArray(declaredTarget) ? declaredTarget : [declaredTarget];
@@ -426,26 +426,26 @@ function assertTargetTypeCompatible(getSubTypes, declaredTarget, actualTarget, c
       return;
   }
   const expected = types.join(" | ");
-  throw new OntologyValidationError(`[Sixb] ${context}: target type '${actualTarget}' is not compatible with declared target '${expected}'`);
+  throw new OntologyValidationError2(`[Sixb] ${context}: target type '${actualTarget}' is not compatible with declared target '${expected}'`);
 }
-function normalizeLinkProperties(objectType, link, properties, valueTypesById) {
+function normalizeLinkProperties2(objectType, link, properties, valueTypesById) {
   if (properties === undefined)
     return;
-  return normalizeObjectProperties(link.properties ?? [], properties, valueTypesById, `${objectType.id}.${link.id}`);
+  return normalizeObjectProperties2(link.properties ?? [], properties, valueTypesById, `${objectType.id}.${link.id}`);
 }
-function validateLinkProperties(objectType, link, properties, existingProperties, valueTypesById) {
+function validateLinkProperties2(objectType, link, properties, existingProperties, valueTypesById) {
   const linkProperties = link.properties ?? [];
   const provided = properties ?? {};
   if (linkProperties.length === 0) {
     if (Object.keys(provided).length > 0) {
-      throw new OntologyValidationError(`[Sixb] Link ${objectType.id}.${link.id} does not define link properties`);
+      throw new OntologyValidationError2(`[Sixb] Link ${objectType.id}.${link.id} does not define link properties`);
     }
     return;
   }
   const knownPropertyIds = new Set(linkProperties.map((property) => property.id));
   for (const propertyId of Object.keys(provided)) {
     if (!knownPropertyIds.has(propertyId)) {
-      throw new OntologyValidationError(`[Sixb] Unknown link property '${propertyId}' for link '${objectType.id}.${link.id}'`);
+      throw new OntologyValidationError2(`[Sixb] Unknown link property '${propertyId}' for link '${objectType.id}.${link.id}'`);
     }
   }
   for (const [propertyId, value] of Object.entries(provided)) {
@@ -453,7 +453,7 @@ function validateLinkProperties(objectType, link, properties, existingProperties
     if (!property) {
       continue;
     }
-    validatePropertyValue(property, value, `${objectType.id}.${link.id}.${propertyId}`, valueTypesById);
+    validatePropertyValue2(property, value, `${objectType.id}.${link.id}.${propertyId}`, valueTypesById);
   }
   const merged = {
     ...existingProperties ?? {},
@@ -461,7 +461,7 @@ function validateLinkProperties(objectType, link, properties, existingProperties
   };
   for (const property of linkProperties) {
     if (property.required && merged[property.id] === undefined) {
-      throw new OntologyValidationError(`[Sixb] Missing required link property '${property.id}' for link '${objectType.id}.${link.id}'`);
+      throw new OntologyValidationError2(`[Sixb] Missing required link property '${property.id}' for link '${objectType.id}.${link.id}'`);
     }
   }
 }
@@ -475,7 +475,7 @@ var queryFeatures = [
   "facet",
   "vector"
 ];
-function validateQueryMetadata(objectTypesById, valueTypesById) {
+function validateQueryMetadata2(objectTypesById, valueTypesById) {
   for (const [typeId, objectType] of objectTypesById) {
     validatePropertiesQueryMetadata(typeId, objectType.properties, valueTypesById);
     for (const link of objectType.links) {
@@ -497,36 +497,36 @@ function validatePropertyQueryMetadata(ownerPath, property, valueTypesById) {
     return;
   const enabledFeatures = queryFeatures.filter((feature) => query[feature] === true);
   if ((enabledFeatures.length > 0 || query.weight !== undefined) && query.searchable !== true) {
-    throw new OntologyValidationError(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' must set query.searchable: true before enabling query features`);
+    throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' must set query.searchable: true before enabling query features`);
   }
   if (query.weight !== undefined) {
     if (!Number.isFinite(query.weight) || query.weight <= 0) {
-      throw new OntologyValidationError(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' has invalid text weight. Expected a positive finite number.`);
+      throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' has invalid text weight. Expected a positive finite number.`);
     }
     if (query.text !== true) {
-      throw new OntologyValidationError(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' can only set weight when query.text is true`);
+      throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' can only set weight when query.text is true`);
     }
   }
   if (enabledFeatures.length === 0)
     return;
   const schema = resolveQueryableSchema(property, ownerPath, valueTypesById);
   if (query.text && !isTextSearchableSchema(schema)) {
-    throw new OntologyValidationError(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables text search, but its schema is not string-like`);
+    throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables text search, but its schema is not string-like`);
   }
   if (query.exact && !isExactSearchableSchema(schema)) {
-    throw new OntologyValidationError(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables exact search, but its schema cannot be exact-matched`);
+    throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables exact search, but its schema cannot be exact-matched`);
   }
   if (query.filterable && !isFilterableSchema(schema)) {
-    throw new OntologyValidationError(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables filtering, but its schema cannot be filtered`);
+    throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables filtering, but its schema cannot be filtered`);
   }
   if (query.sortable && !isSortableSchema(schema)) {
-    throw new OntologyValidationError(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables sorting, but its schema is not orderable`);
+    throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables sorting, but its schema is not orderable`);
   }
   if (query.facet && !isFacetSchema(schema)) {
-    throw new OntologyValidationError(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables faceting, but its schema cannot be faceted`);
+    throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables faceting, but its schema cannot be faceted`);
   }
   if (query.vector && !isVectorSchema(schema, valueTypesById)) {
-    throw new OntologyValidationError(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables vector search, but its schema is not a numeric array`);
+    throw new OntologyValidationError2(`[Sixb] Query metadata for property '${property.id}' on '${ownerPath}' enables vector search, but its schema is not a numeric array`);
   }
 }
 function validateObjectSearchMetadata(typeId, objectType, valueTypesById) {
@@ -539,7 +539,7 @@ function validateObjectSearchMetadata(typeId, objectType, valueTypesById) {
     assertStaticSearchProfileProperty(typeId, title, "search.title");
     const schema = resolveQueryableSchema(title, typeId, valueTypesById);
     if (!isTextSearchableSchema(schema)) {
-      throw new OntologyValidationError(`[Sixb] Object type '${typeId}' search.title references '${title.id}', but title fields must be string-like`);
+      throw new OntologyValidationError2(`[Sixb] Object type '${typeId}' search.title references '${title.id}', but title fields must be string-like`);
     }
   }
   for (const propertyId of search.defaultText ?? []) {
@@ -559,7 +559,7 @@ function validateObjectSearchMetadata(typeId, objectType, valueTypesById) {
     assertStaticSearchProfileProperty(typeId, vectorProperty, "search.vector.property");
     assertPropertyQueryFlag(typeId, vectorProperty, "vector", "search.vector.property");
     if (search.vector.source.length === 0) {
-      throw new OntologyValidationError(`[Sixb] Object type '${typeId}' search.vector.source must include at least one source property`);
+      throw new OntologyValidationError2(`[Sixb] Object type '${typeId}' search.vector.source must include at least one source property`);
     }
     for (const sourceId of search.vector.source) {
       const sourceProperty = requireObjectProperty(typeId, objectType, sourceId, "search.vector.source");
@@ -571,20 +571,20 @@ function validateObjectSearchMetadata(typeId, objectType, valueTypesById) {
 function requireObjectProperty(typeId, objectType, propertyId, metadataPath) {
   const property = objectType.properties.find((candidate) => candidate.id === propertyId);
   if (!property) {
-    throw new OntologyValidationError(`[Sixb] Object type '${typeId}' ${metadataPath} references unknown property '${propertyId}'`);
+    throw new OntologyValidationError2(`[Sixb] Object type '${typeId}' ${metadataPath} references unknown property '${propertyId}'`);
   }
   return property;
 }
 function assertStaticSearchProfileProperty(typeId, property, metadataPath) {
   if (property.mode === "telemetry") {
-    throw new OntologyValidationError(`[Sixb] Object type '${typeId}' ${metadataPath} references telemetry property '${property.id}'. Search profiles can only reference static properties because telemetry latest values are not object-query indexed.`);
+    throw new OntologyValidationError2(`[Sixb] Object type '${typeId}' ${metadataPath} references telemetry property '${property.id}'. Search profiles can only reference static properties because telemetry latest values are not object-query indexed.`);
   }
 }
 function assertPropertyQueryFlag(typeId, property, flag, metadataPath) {
   if (property.query?.searchable === true && property.query[flag] === true) {
     return;
   }
-  throw new OntologyValidationError(`[Sixb] Object type '${typeId}' ${metadataPath} references property '${property.id}', but that property must set query.searchable: true and query.${flag}: true`);
+  throw new OntologyValidationError2(`[Sixb] Object type '${typeId}' ${metadataPath} references property '${property.id}', but that property must set query.searchable: true and query.${flag}: true`);
 }
 function resolveQueryableSchema(property, ownerPath, valueTypesById) {
   return resolveSchema(property.schema, valueTypesById, `${ownerPath}.${property.id}`);
@@ -597,11 +597,11 @@ function resolveSchema(schema, valueTypesById, path, seenValueTypeIds = new Set)
     return schema;
   }
   if (seenValueTypeIds.has(schema.valueTypeId)) {
-    throw new OntologyValidationError(`[Sixb] Circular valueTypeRef '${schema.valueTypeId}' in query metadata at ${path}`);
+    throw new OntologyValidationError2(`[Sixb] Circular valueTypeRef '${schema.valueTypeId}' in query metadata at ${path}`);
   }
   const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
   if (!resolved) {
-    throw new OntologyValidationError(`[Sixb] Query metadata for ${path} references unknown valueTypeRef '${schema.valueTypeId}'`);
+    throw new OntologyValidationError2(`[Sixb] Query metadata for ${path} references unknown valueTypeRef '${schema.valueTypeId}'`);
   }
   seenValueTypeIds.add(schema.valueTypeId);
   return resolveSchema(resolved, valueTypesById, path, seenValueTypeIds);
@@ -698,7 +698,7 @@ var unitlessUnits = {
   percent: { name: "Percent", symbol: "%" },
   unity: { name: "Unity", symbol: "" }
 };
-var quantitativeTypes = {
+var quantitativeTypes2 = {
   Acceleration: {
     name: "Acceleration",
     description: "Rate of change of velocity.",
@@ -1192,63 +1192,63 @@ var quantitativeTypes = {
 };
 // src/ontology/units/index.ts
 var unitIndex = new Map;
-for (const [qtId, qt] of Object.entries(quantitativeTypes)) {
+for (const [qtId, qt] of Object.entries(quantitativeTypes2)) {
   for (const [unitId, unit] of Object.entries(qt.units)) {
     if (!unitIndex.has(unitId)) {
       unitIndex.set(unitId, { ...unit, quantitativeTypeId: qtId });
     }
   }
 }
-function getUnit(unitId) {
+function getUnit2(unitId) {
   return unitIndex.get(unitId);
 }
-function getUnitsFor(quantitativeTypeId) {
-  const qt = quantitativeTypes[quantitativeTypeId];
+function getUnitsFor2(quantitativeTypeId) {
+  const qt = quantitativeTypes2[quantitativeTypeId];
   return qt?.units;
 }
-function isValidUnit(quantitativeTypeId, unitId) {
-  const units = getUnitsFor(quantitativeTypeId);
+function isValidUnit2(quantitativeTypeId, unitId) {
+  const units = getUnitsFor2(quantitativeTypeId);
   return units != null && unitId in units;
 }
-function getUnitSymbol(unitId) {
+function getUnitSymbol2(unitId) {
   return unitIndex.get(unitId)?.symbol;
 }
-function isQuantitativeTypeId(value) {
-  return value in quantitativeTypes;
+function isQuantitativeTypeId2(value) {
+  return value in quantitativeTypes2;
 }
-function isUnitId(value) {
+function isUnitId2(value) {
   return unitIndex.has(value);
 }
 
 // src/ontology/validation/telemetry.ts
-function assertTelemetryProperty(property) {
+function assertTelemetryProperty2(property) {
   if (property.mode !== "telemetry") {
-    throw new OntologyValidationError(`[Sixb] Property ${property.id} is not telemetry-enabled`);
+    throw new OntologyValidationError2(`[Sixb] Property ${property.id} is not telemetry-enabled`);
   }
 }
-function resolveSemanticType(property, valueTypesById) {
+function resolveSemanticType2(property, valueTypesById) {
   if (property.semanticType) {
     return property.semanticType;
   }
-  const valueTypeId = resolveValueTypeRef(property.schema);
+  const valueTypeId = resolveValueTypeRef2(property.schema);
   if (!valueTypeId) {
     return;
   }
   return valueTypesById.get(valueTypeId)?.semanticType;
 }
-function validateTelemetryUnit(property, propertyPath, unit, valueTypesById) {
-  const semanticType = resolveSemanticType(property, valueTypesById);
+function validateTelemetryUnit2(property, propertyPath, unit, valueTypesById) {
+  const semanticType = resolveSemanticType2(property, valueTypesById);
   if (semanticType) {
     if (!unit) {
-      throw new OntologyValidationError(`[Sixb] Missing unit for telemetry property ${propertyPath}`);
+      throw new OntologyValidationError2(`[Sixb] Missing unit for telemetry property ${propertyPath}`);
     }
-    if (!isValidUnit(semanticType, unit)) {
-      throw new OntologyValidationError(`[Sixb] Invalid unit '${unit}' for ${propertyPath} (${semanticType})`);
+    if (!isValidUnit2(semanticType, unit)) {
+      throw new OntologyValidationError2(`[Sixb] Invalid unit '${unit}' for ${propertyPath} (${semanticType})`);
     }
   } else if (unit) {
-    throw new OntologyValidationError(`[Sixb] Property ${propertyPath} does not define semanticType and cannot accept a unit`);
+    throw new OntologyValidationError2(`[Sixb] Property ${propertyPath} does not define semanticType and cannot accept a unit`);
   }
 }
-export { validateSchemaValue, resolveValueTypeRef, resolveValueTypeSchema, isRecord, normalizeObjectProperties, normalizeSchemaValue, coerceSchemaValueToTyped, assertObjectTypeRegistered, assertPropertyTokenBelongsToObjectType, assertLinkTokenBelongsToObjectType, assertKnownProperties, assertRequiredProperties, validateObjectProperties, validatePrimaryProperties, validatePropertyDefinitions, validatePropertyValue, assertLinkTargetType, assertTargetTypeCompatible, normalizeLinkProperties, validateLinkProperties, validateQueryMetadata, quantitativeTypes, getUnit, getUnitsFor, isValidUnit, getUnitSymbol, isQuantitativeTypeId, isUnitId, assertTelemetryProperty, resolveSemanticType, validateTelemetryUnit };
+export { validateSchemaValue2, resolveValueTypeRef2, resolveValueTypeSchema2, isRecord2, normalizeObjectProperties2, normalizeSchemaValue2, coerceSchemaValueToTyped2, assertObjectTypeRegistered2, assertPropertyTokenBelongsToObjectType2, assertLinkTokenBelongsToObjectType2, assertKnownProperties2, assertRequiredProperties2, validateObjectProperties2, validatePrimaryProperties2, validatePropertyDefinitions2, validatePropertyValue2, assertLinkTargetType2, assertTargetTypeCompatible2, normalizeLinkProperties2, validateLinkProperties2, validateQueryMetadata2, quantitativeTypes2, getUnit2, getUnitsFor2, isValidUnit2, getUnitSymbol2, isQuantitativeTypeId2, isUnitId2, assertTelemetryProperty2, resolveSemanticType2, validateTelemetryUnit2 };
 
-//# debugId=5B90E5AA0618BD3064756E2164756E21
+//# debugId=D0967F53F58A924A64756E2164756E21