@sixb/core 0.0.1

package/dist/chunk-tsk2bxs3.js

@@ -0,0 +1,1254 @@
+// @bun
+import {
+  isDecimalString,
+  normalizeDecimalValue
+} from "./chunk-04b07a9q.js";
+import {
+  OntologyValidationError
+} from "./chunk-dktq02ne.js";
+import {
+  isFileRef
+} from "./chunk-4pycxcj3.js";
+import {
+  assertJsonValue,
+  cloneJsonValue
+} from "./chunk-1vffvydj.js";
+
+// src/ontology/validation/schema.ts
+function validateSchemaValue(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`);
+        }
+        return;
+      }
+      case "boolean": {
+        if (typeof value !== "boolean") {
+          throw new OntologyValidationError(`[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`);
+        }
+        return;
+      }
+      case "double": {
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+          throw new OntologyValidationError(`[Sixb] Property ${path} must be numeric`);
+        }
+        return;
+      }
+      case "decimal": {
+        if (!isDecimalString(value)) {
+          throw new OntologyValidationError(`[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`);
+        }
+        return;
+      }
+      case "fileRef": {
+        if (!isFileRef(value)) {
+          throw new OntologyValidationError(`[Sixb] Property ${path} must be a fileRef`);
+        }
+        return;
+      }
+    }
+  }
+  if (schema.type === "enum") {
+    if (!schema.values.includes(value)) {
+      throw new OntologyValidationError(`[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`);
+    }
+    for (let index = 0;index < value.length; index += 1) {
+      validateSchemaValue(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`);
+    }
+    for (const [key, entry] of Object.entries(value)) {
+      validateSchemaValue(schema.valueSchema, entry, `${path}.${key}`, valueTypesById);
+    }
+    return;
+  }
+  if (schema.type === "object") {
+    if (!isRecord(value)) {
+      throw new OntologyValidationError(`[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}'`);
+      }
+    }
+    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}'`);
+        }
+        continue;
+      }
+      validateFieldValue(field, fieldValue, `${path}.${fieldId}`, valueTypesById);
+    }
+    return;
+  }
+  if (schema.type === "valueTypeRef") {
+    validateSchemaValue(resolveValueTypeSchema(schema, valueTypesById, path), value, path, valueTypesById);
+  }
+}
+function validateFieldValue(field, value, path, valueTypesById) {
+  if (value === null) {
+    if (field.nullable) {
+      return;
+    }
+    throw new OntologyValidationError(`[Sixb] Field ${path} cannot be null`);
+  }
+  validateSchemaValue(field.schema, value, path, valueTypesById);
+}
+function resolveValueTypeRef(schema) {
+  if (typeof schema === "string") {
+    return;
+  }
+  if (schema.type === "valueTypeRef") {
+    return schema.valueTypeId;
+  }
+  return;
+}
+function resolveValueTypeSchema(schema, valueTypesById, path) {
+  const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
+  if (!resolved) {
+    throw new OntologyValidationError(`[Sixb] Unknown valueTypeRef '${schema.valueTypeId}' at ${path}`);
+  }
+  return resolved;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/ontology/validation/normalize.ts
+function normalizeObjectProperties(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);
+  }
+  return normalized;
+}
+function normalizeSchemaValue(schema, value, path, valueTypesById) {
+  if (typeof schema === "string") {
+    switch (schema) {
+      case "date":
+        return normalizeDateValue(value, path);
+      case "timestamp":
+        return normalizeTimestampValue(value, path);
+      case "decimal":
+        return normalizeDecimal(value, path);
+      default:
+        assertJsonValue(value, path);
+        return cloneJsonValue(value);
+    }
+  }
+  if (schema.type === "valueTypeRef") {
+    return normalizeSchemaValue(resolveValueTypeSchema(schema, valueTypesById, path), value, path, valueTypesById);
+  }
+  if (schema.type === "enum") {
+    assertJsonValue(value, path);
+    return cloneJsonValue(value);
+  }
+  if (schema.type === "array") {
+    if (!Array.isArray(value)) {
+      throw new OntologyValidationError(`[Sixb] Property ${path} must be an array`);
+    }
+    return value.map((entry, index) => normalizeSchemaValue(schema.items, entry, `${path}[${index}]`, valueTypesById));
+  }
+  if (schema.type === "map") {
+    const record2 = assertPlainRecord(value, path);
+    const entries = Object.entries(record2).map(([key, entry]) => [
+      key,
+      normalizeSchemaValue(schema.valueSchema, entry, `${path}.${key}`, valueTypesById)
+    ]);
+    return Object.fromEntries(entries);
+  }
+  const fields = schema.properties;
+  const record = assertPlainRecord(value, path);
+  const output = {};
+  for (const [fieldId, field] of Object.entries(fields)) {
+    const fieldValue = record[fieldId];
+    if (fieldValue === undefined) {
+      continue;
+    }
+    output[fieldId] = normalizeObjectFieldValue(field, fieldValue, `${path}.${fieldId}`, valueTypesById);
+  }
+  return output;
+}
+function normalizeObjectFieldValue(field, value, path, valueTypesById) {
+  if (value === null) {
+    return null;
+  }
+  return normalizeSchemaValue(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`);
+  }
+  return value;
+}
+function normalizeDateValue(value, path) {
+  const date = normalizeDateLike(value, path);
+  return date.toISOString().slice(0, 10);
+}
+function normalizeTimestampValue(value, path) {
+  return normalizeDateLike(value, path).toISOString();
+}
+function normalizeDecimal(value, path) {
+  if (typeof value !== "string") {
+    throw new OntologyValidationError(`[Sixb] Property ${path} must be an exact decimal string`);
+  }
+  try {
+    return normalizeDecimalValue(value);
+  } catch {
+    throw new OntologyValidationError(`[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`);
+  }
+  return date;
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function coerceSchemaValueToTyped(schema, value, valueTypesById) {
+  if (value === null || value === undefined) {
+    return value;
+  }
+  if (typeof schema === "string") {
+    if (schema === "date" || schema === "timestamp") {
+      return value instanceof Date ? value : new Date(String(value));
+    }
+    return value;
+  }
+  if (schema.type === "valueTypeRef") {
+    return coerceSchemaValueToTyped(resolveValueTypeSchema(schema, valueTypesById, ""), value, valueTypesById);
+  }
+  if (schema.type === "enum") {
+    return value;
+  }
+  if (schema.type === "array") {
+    if (!Array.isArray(value))
+      return value;
+    return value.map((entry) => coerceSchemaValueToTyped(schema.items, entry, valueTypesById));
+  }
+  if (schema.type === "map") {
+    if (!isPlainRecord(value))
+      return value;
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+      key,
+      coerceSchemaValueToTyped(schema.valueSchema, entry, valueTypesById)
+    ]));
+  }
+  if (!isPlainRecord(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);
+  }
+  return output;
+}
+
+// src/ontology/validation/properties.ts
+function assertObjectTypeRegistered(objectTypesById, objectType) {
+  if (!objectTypesById.has(objectType.id)) {
+    throw new OntologyValidationError(`[Sixb] Object type is not registered in this runtime: ${objectType.id}`);
+  }
+}
+function assertPropertyTokenBelongsToObjectType(objectType, property) {
+  if (property.objectTypeId !== objectType.id) {
+    throw new OntologyValidationError(`[Sixb] Property token ${property.objectTypeId}.${property.id} cannot be used with ${objectType.id}`);
+  }
+}
+function assertLinkTokenBelongsToObjectType(objectType, link) {
+  if (!isLinkTokenLike(link)) {
+    throw new OntologyValidationError(`[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}`);
+  }
+}
+function isLinkTokenLike(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (!("objectTypeId" in value) || !("id" in value) || !("targetObjectTypeId" in value) || !("link" in value)) {
+    return false;
+  }
+  return typeof value.objectTypeId === "string" && typeof value.id === "string" && isLinkTargetTypeId(value.targetObjectTypeId) && typeof value.link === "object" && value.link !== null;
+}
+function isLinkTargetTypeId(value) {
+  return typeof value === "string" || Array.isArray(value) && value.every(isString);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function assertKnownProperties(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}'`);
+    }
+  }
+}
+function assertRequiredProperties(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}'`);
+    }
+  }
+}
+function validateObjectProperties(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);
+  }
+}
+function validatePrimaryProperties(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 }).`);
+    }
+    if (primaries.length > 1) {
+      throw new OntologyValidationError(`[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`);
+    }
+    if (primary.schema !== "string") {
+      throw new OntologyValidationError(`[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) {
+  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`);
+      }
+    }
+  }
+}
+function validatePropertyValue(property, value, path, valueTypesById) {
+  if (value === undefined) {
+    throw new OntologyValidationError(`[Sixb] Property ${path} cannot be undefined`);
+  }
+  if (value === null) {
+    if (property.nullable) {
+      return;
+    }
+    throw new OntologyValidationError(`[Sixb] Property ${path} cannot be null`);
+  }
+  validateSchemaValue(property.schema, value, path, valueTypesById);
+}
+function schemaContainsFileRef(schema, valueTypesById, seenValueTypeIds = new Set) {
+  if (schema === "fileRef") {
+    return true;
+  }
+  if (typeof schema === "string") {
+    return false;
+  }
+  if (schema.type === "array") {
+    return schemaContainsFileRef(schema.items, valueTypesById, seenValueTypeIds);
+  }
+  if (schema.type === "map") {
+    return schemaContainsFileRef(schema.valueSchema, valueTypesById, seenValueTypeIds);
+  }
+  if (schema.type === "object") {
+    return Object.values(schema.properties).some((field) => schemaContainsFileRef(field.schema, valueTypesById, seenValueTypeIds));
+  }
+  if (schema.type === "valueTypeRef") {
+    if (seenValueTypeIds.has(schema.valueTypeId)) {
+      return false;
+    }
+    seenValueTypeIds.add(schema.valueTypeId);
+    const resolved = schema._resolved ?? valueTypesById.get(schema.valueTypeId)?.schema;
+    return resolved ? schemaContainsFileRef(resolved, valueTypesById, seenValueTypeIds) : false;
+  }
+  return false;
+}
+
+// src/ontology/validation/links.ts
+function assertLinkTargetType(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}'`);
+  }
+}
+function assertTargetTypeCompatible(getSubTypes, declaredTarget, actualTarget, context) {
+  if (declaredTarget === "*")
+    return;
+  const types = Array.isArray(declaredTarget) ? declaredTarget : [declaredTarget];
+  if (types.includes("*"))
+    return;
+  for (const type of types) {
+    if (actualTarget === type || getSubTypes(type).includes(actualTarget))
+      return;
+  }
+  const expected = types.join(" | ");
+  throw new OntologyValidationError(`[Sixb] ${context}: target type '${actualTarget}' is not compatible with declared target '${expected}'`);
+}
+function normalizeLinkProperties(objectType, link, properties, valueTypesById) {
+  if (properties === undefined)
+    return;
+  return normalizeObjectProperties(link.properties ?? [], properties, valueTypesById, `${objectType.id}.${link.id}`);
+}
+function validateLinkProperties(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`);
+    }
+    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}'`);
+    }
+  }
+  for (const [propertyId, value] of Object.entries(provided)) {
+    const property = linkProperties.find((candidate) => candidate.id === propertyId);
+    if (!property) {
+      continue;
+    }
+    validatePropertyValue(property, value, `${objectType.id}.${link.id}.${propertyId}`, valueTypesById);
+  }
+  const merged = {
+    ...existingProperties ?? {},
+    ...provided
+  };
+  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}'`);
+    }
+  }
+}
+
+// src/ontology/validation/query.ts
+var queryFeatures = [
+  "filterable",
+  "sortable",
+  "text",
+  "exact",
+  "facet",
+  "vector"
+];
+function validateQueryMetadata(objectTypesById, valueTypesById) {
+  for (const [typeId, objectType] of objectTypesById) {
+    validatePropertiesQueryMetadata(typeId, objectType.properties, valueTypesById);
+    for (const link of objectType.links) {
+      if (link.properties) {
+        validatePropertiesQueryMetadata(`${typeId}.${link.id}`, link.properties, valueTypesById);
+      }
+    }
+    validateObjectSearchMetadata(typeId, objectType, valueTypesById);
+  }
+}
+function validatePropertiesQueryMetadata(ownerPath, properties, valueTypesById) {
+  for (const property of properties) {
+    validatePropertyQueryMetadata(ownerPath, property, valueTypesById);
+  }
+}
+function validatePropertyQueryMetadata(ownerPath, property, valueTypesById) {
+  const query = property.query;
+  if (!query)
+    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`);
+  }
+  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.`);
+    }
+    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`);
+    }
+  }
+  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`);
+  }
+  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`);
+  }
+  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`);
+  }
+  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`);
+  }
+  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`);
+  }
+  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`);
+  }
+}
+function validateObjectSearchMetadata(typeId, objectType, valueTypesById) {
+  const search = objectType.search;
+  if (!search)
+    return;
+  const primaryPropertyId = objectType.properties.find((property) => property.primary)?.id;
+  if (search.title) {
+    const title = requireObjectProperty(typeId, objectType, search.title, "search.title");
+    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`);
+    }
+  }
+  for (const propertyId of search.defaultText ?? []) {
+    const property = requireObjectProperty(typeId, objectType, propertyId, "search.defaultText");
+    assertStaticSearchProfileProperty(typeId, property, "search.defaultText");
+    assertPropertyQueryFlag(typeId, property, "text", "search.defaultText");
+  }
+  for (const propertyId of search.exact ?? []) {
+    const property = requireObjectProperty(typeId, objectType, propertyId, "search.exact");
+    assertStaticSearchProfileProperty(typeId, property, "search.exact");
+    if (property.id !== primaryPropertyId) {
+      assertPropertyQueryFlag(typeId, property, "exact", "search.exact");
+    }
+  }
+  if (search.vector) {
+    const vectorProperty = requireObjectProperty(typeId, objectType, search.vector.property, "search.vector.property");
+    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`);
+    }
+    for (const sourceId of search.vector.source) {
+      const sourceProperty = requireObjectProperty(typeId, objectType, sourceId, "search.vector.source");
+      assertStaticSearchProfileProperty(typeId, sourceProperty, "search.vector.source");
+      assertPropertyQueryFlag(typeId, sourceProperty, "text", "search.vector.source");
+    }
+  }
+}
+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}'`);
+  }
+  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.`);
+  }
+}
+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`);
+}
+function resolveQueryableSchema(property, ownerPath, valueTypesById) {
+  return resolveSchema(property.schema, valueTypesById, `${ownerPath}.${property.id}`);
+}
+function resolveSchema(schema, valueTypesById, path, seenValueTypeIds = new Set) {
+  if (typeof schema === "string") {
+    return schema;
+  }
+  if (schema.type !== "valueTypeRef") {
+    return schema;
+  }
+  if (seenValueTypeIds.has(schema.valueTypeId)) {
+    throw new OntologyValidationError(`[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}'`);
+  }
+  seenValueTypeIds.add(schema.valueTypeId);
+  return resolveSchema(resolved, valueTypesById, path, seenValueTypeIds);
+}
+function isTextSearchableSchema(schema) {
+  if (schema === "string")
+    return true;
+  return typeof schema !== "string" && schema.type === "enum" && schema.valueType === "string";
+}
+function isExactSearchableSchema(schema) {
+  if (typeof schema === "string") {
+    return schema !== "fileRef";
+  }
+  return schema.type === "enum";
+}
+function isFilterableSchema(schema) {
+  return isExactSearchableSchema(schema) || typeof schema !== "string" && (schema.type === "array" || schema.type === "map");
+}
+function isSortableSchema(schema) {
+  if (typeof schema === "string") {
+    return schema === "string" || schema === "uuid" || schema === "integer" || schema === "double" || schema === "decimal" || schema === "date" || schema === "timestamp";
+  }
+  return schema.type === "enum";
+}
+function isFacetSchema(schema) {
+  return isExactSearchableSchema(schema);
+}
+function isVectorSchema(schema, valueTypesById) {
+  if (typeof schema === "string")
+    return false;
+  if (schema.type !== "array")
+    return false;
+  const itemSchema = resolveSchema(schema.items, valueTypesById, "vector item");
+  return itemSchema === "integer" || itemSchema === "double" || itemSchema === "decimal";
+}
+
+// src/ontology/units/quantitative-types.ts
+var angleUnits = {
+  degreeOfArc: { name: "Degree of Arc", symbol: "\xB0" },
+  minuteOfArc: { name: "Minute of Arc", symbol: "\u2032" },
+  radian: { name: "Radian", symbol: "rad" },
+  secondOfArc: { name: "Second of Arc", symbol: "\u2033" },
+  turn: { name: "Turn", symbol: "rev" }
+};
+var densityUnits = {
+  gramPerCubicMetre: { name: "Gram per Cubic Metre", symbol: "g/m\xB3" },
+  kilogramPerCubicMetre: { name: "Kilogram per Cubic Metre", symbol: "kg/m\xB3" },
+  microgramPerCubicMetre: { name: "Microgram per Cubic Metre", symbol: "\xB5g/m\xB3" },
+  milligramPerCubicMetre: { name: "Milligram per Cubic Metre", symbol: "mg/m\xB3" }
+};
+var forceUnits = {
+  newton: { name: "Newton", symbol: "N" },
+  ounce: { name: "Ounce", symbol: "oz" },
+  pound: { name: "Pound", symbol: "lbf" },
+  ton: { name: "Ton", symbol: "t" }
+};
+var lengthUnits = {
+  astronomicalUnit: { name: "Astronomical Unit", symbol: "AU" },
+  centimetre: { name: "Centimetre", symbol: "cm" },
+  foot: { name: "Foot", symbol: "ft" },
+  inch: { name: "Inch", symbol: "in" },
+  kilometre: { name: "Kilometre", symbol: "km" },
+  metre: { name: "Metre", symbol: "m" },
+  micrometre: { name: "Micrometre", symbol: "\xB5m" },
+  mile: { name: "Mile", symbol: "mi" },
+  millimetre: { name: "Millimetre", symbol: "mm" },
+  nanometre: { name: "Nanometre", symbol: "nm" },
+  nauticalMile: { name: "Nautical Mile", symbol: "nmi" }
+};
+var powerUnits = {
+  britishThermalUnitPerHour: { name: "British Thermal Unit per Hour", symbol: "BTU/h" },
+  gigajoulePerHour: { name: "Gigajoule per Hour", symbol: "GJ/h" },
+  gigawatt: { name: "Gigawatt", symbol: "GW" },
+  horsepower: { name: "Horsepower", symbol: "hp" },
+  joulePerHour: { name: "Joule per Hour", symbol: "J/h" },
+  joulePerSecond: { name: "Joule per Second", symbol: "J/s" },
+  kiloBritishThermalUnitPerHour: { name: "Kilo British Thermal Unit per Hour", symbol: "kBTU/h" },
+  kilojoulePerHour: { name: "Kilojoule per Hour", symbol: "kJ/h" },
+  kilojoulePerSecond: { name: "Kilojoule per Second", symbol: "kJ/s" },
+  kilowatt: { name: "Kilowatt", symbol: "kW" },
+  kilowattHourPerYear: { name: "Kilowatt Hour per Year", symbol: "kWh/yr" },
+  megajoulePerHour: { name: "Megajoule per Hour", symbol: "MJ/h" },
+  megawatt: { name: "Megawatt", symbol: "MW" },
+  microwatt: { name: "Microwatt", symbol: "\xB5W" },
+  milliwatt: { name: "Milliwatt", symbol: "mW" },
+  tonOfRefrigeration: { name: "Ton of Refrigeration", symbol: "TR" },
+  watt: { name: "Watt", symbol: "W" }
+};
+var unitlessUnits = {
+  partsPerBillion: { name: "Parts per Billion", symbol: "ppb" },
+  partsPerMillion: { name: "Parts per Million", symbol: "ppm" },
+  partsPerQuadrillion: { name: "Parts per Quadrillion", symbol: "ppq" },
+  partsPerTrillion: { name: "Parts per Trillion", symbol: "ppt" },
+  percent: { name: "Percent", symbol: "%" },
+  unity: { name: "Unity", symbol: "" }
+};
+var quantitativeTypes = {
+  Acceleration: {
+    name: "Acceleration",
+    description: "Rate of change of velocity.",
+    units: {
+      centimetrePerSecondSquared: { name: "Centimetre per Second Squared", symbol: "cm/s\xB2" },
+      gForce: { name: "G-Force", symbol: "g" },
+      metrePerSecondSquared: { name: "Metre per Second Squared", symbol: "m/s\xB2" }
+    }
+  },
+  Angle: {
+    name: "Angle",
+    description: "Measure of rotation between two rays.",
+    units: angleUnits
+  },
+  AngularAcceleration: {
+    name: "Angular Acceleration",
+    description: "Rate of change of angular velocity.",
+    units: {
+      radianPerSecondSquared: { name: "Radian per Second Squared", symbol: "rad/s\xB2" }
+    }
+  },
+  AngularVelocity: {
+    name: "Angular Velocity",
+    description: "Rate of rotation around an axis.",
+    units: {
+      degreePerSecond: { name: "Degree per Second", symbol: "\xB0/s" },
+      radianPerSecond: { name: "Radian per Second", symbol: "rad/s" },
+      revolutionPerMinute: { name: "Revolution per Minute", symbol: "rpm" },
+      revolutionPerSecond: { name: "Revolution per Second", symbol: "rps" }
+    }
+  },
+  ApparentEnergy: {
+    name: "Apparent Energy",
+    description: "Integral of apparent power over time.",
+    units: {
+      gigavoltAmpereHour: { name: "Gigavolt Ampere Hour", symbol: "GVAh" },
+      kilovoltAmpereHour: { name: "Kilovolt Ampere Hour", symbol: "kVAh" },
+      megavoltAmpereHour: { name: "Megavolt Ampere Hour", symbol: "MVAh" },
+      voltAmpereHour: { name: "Volt Ampere Hour", symbol: "VAh" }
+    }
+  },
+  ApparentPower: {
+    name: "Apparent Power",
+    description: "Product of RMS voltage and RMS current in an AC circuit.",
+    units: {
+      gigavoltAmpere: { name: "Gigavolt Ampere", symbol: "GVA" },
+      kilovoltAmpere: { name: "Kilovolt Ampere", symbol: "kVA" },
+      megavoltAmpere: { name: "Megavolt Ampere", symbol: "MVA" },
+      millivoltAmpere: { name: "Millivolt Ampere", symbol: "mVA" },
+      voltAmpere: { name: "Volt Ampere", symbol: "VA" }
+    }
+  },
+  Area: {
+    name: "Area",
+    description: "Extent of a two-dimensional surface.",
+    units: {
+      acre: { name: "Acre", symbol: "ac" },
+      hectare: { name: "Hectare", symbol: "ha" },
+      squareCentimetre: { name: "Square Centimetre", symbol: "cm\xB2" },
+      squareFoot: { name: "Square Foot", symbol: "ft\xB2" },
+      squareInch: { name: "Square Inch", symbol: "in\xB2" },
+      squareKilometre: { name: "Square Kilometre", symbol: "km\xB2" },
+      squareMetre: { name: "Square Metre", symbol: "m\xB2" },
+      squareMillimetre: { name: "Square Millimetre", symbol: "mm\xB2" }
+    }
+  },
+  Capacitance: {
+    name: "Capacitance",
+    description: "Ability to store an electric charge.",
+    units: {
+      farad: { name: "Farad", symbol: "F" },
+      microfarad: { name: "Microfarad", symbol: "\xB5F" },
+      millifarad: { name: "Millifarad", symbol: "mF" },
+      nanofarad: { name: "Nanofarad", symbol: "nF" },
+      picofarad: { name: "Picofarad", symbol: "pF" }
+    }
+  },
+  Concentration: {
+    name: "Concentration",
+    description: "Amount of substance per unit volume or mass (dimensionless ratio).",
+    units: unitlessUnits
+  },
+  Current: {
+    name: "Current",
+    description: "Flow of electric charge.",
+    units: {
+      ampere: { name: "Ampere", symbol: "A" },
+      kiloampere: { name: "Kiloampere", symbol: "kA" },
+      microampere: { name: "Microampere", symbol: "\xB5A" },
+      milliampere: { name: "Milliampere", symbol: "mA" }
+    }
+  },
+  DataRate: {
+    name: "Data Rate",
+    description: "Amount of data transferred per unit time.",
+    units: {
+      bitPerSecond: { name: "Bit per Second", symbol: "bps" },
+      bytePerSecond: { name: "Byte per Second", symbol: "B/s" },
+      exbibitPerSecond: { name: "Exbibit per Second", symbol: "Eibit/s" },
+      exbibytePerSecond: { name: "Exbibyte per Second", symbol: "EiB/s" },
+      gibibitPerSecond: { name: "Gibibit per Second", symbol: "Gibit/s" },
+      gibibytePerSecond: { name: "Gibibyte per Second", symbol: "GiB/s" },
+      kibibitPerSecond: { name: "Kibibit per Second", symbol: "Kibit/s" },
+      kibibytePerSecond: { name: "Kibibyte per Second", symbol: "KiB/s" },
+      mebibitPerSecond: { name: "Mebibit per Second", symbol: "Mibit/s" },
+      mebibytePerSecond: { name: "Mebibyte per Second", symbol: "MiB/s" },
+      tebibitPerSecond: { name: "Tebibit per Second", symbol: "Tibit/s" },
+      tebibytePerSecond: { name: "Tebibyte per Second", symbol: "TiB/s" },
+      yobibitPerSecond: { name: "Yobibit per Second", symbol: "Yibit/s" },
+      yobibytePerSecond: { name: "Yobibyte per Second", symbol: "YiB/s" },
+      zebibitPerSecond: { name: "Zebibit per Second", symbol: "Zibit/s" },
+      zebibytePerSecond: { name: "Zebibyte per Second", symbol: "ZiB/s" }
+    }
+  },
+  DataSize: {
+    name: "Data Size",
+    description: "Amount of digital information.",
+    units: {
+      bit: { name: "Bit", symbol: "bit" },
+      byte: { name: "Byte", symbol: "B" },
+      exbibit: { name: "Exbibit", symbol: "Eibit" },
+      exbibyte: { name: "Exbibyte", symbol: "EiB" },
+      gibibit: { name: "Gibibit", symbol: "Gibit" },
+      gibibyte: { name: "Gibibyte", symbol: "GiB" },
+      kibibit: { name: "Kibibit", symbol: "Kibit" },
+      kibibyte: { name: "Kibibyte", symbol: "KiB" },
+      mebibit: { name: "Mebibit", symbol: "Mibit" },
+      mebibyte: { name: "Mebibyte", symbol: "MiB" },
+      tebibit: { name: "Tebibit", symbol: "Tibit" },
+      tebibyte: { name: "Tebibyte", symbol: "TiB" },
+      yobibit: { name: "Yobibit", symbol: "Yibit" },
+      yobibyte: { name: "Yobibyte", symbol: "YiB" },
+      zebibit: { name: "Zebibit", symbol: "Zibit" },
+      zebibyte: { name: "Zebibyte", symbol: "ZiB" }
+    }
+  },
+  Density: {
+    name: "Density",
+    description: "Mass per unit volume.",
+    units: densityUnits
+  },
+  Distance: {
+    name: "Distance",
+    description: "Scalar measure of how far apart two points are.",
+    units: lengthUnits
+  },
+  ElectricCharge: {
+    name: "Electric Charge",
+    description: "Quantity of electric charge.",
+    units: {
+      ampereHour: { name: "Ampere Hour", symbol: "Ah" },
+      coulomb: { name: "Coulomb", symbol: "C" },
+      milliampereHour: { name: "Milliampere Hour", symbol: "mAh" }
+    }
+  },
+  Energy: {
+    name: "Energy",
+    description: "Capacity to do work.",
+    units: {
+      britishThermalUnit: { name: "British Thermal Unit", symbol: "BTU" },
+      electronvolt: { name: "Electronvolt", symbol: "eV" },
+      gigajoule: { name: "Gigajoule", symbol: "GJ" },
+      gigawattHour: { name: "Gigawatt Hour", symbol: "GWh" },
+      joule: { name: "Joule", symbol: "J" },
+      kiloBritishThermalUnit: { name: "Kilo British Thermal Unit", symbol: "kBTU" },
+      kilojoule: { name: "Kilojoule", symbol: "kJ" },
+      kilowattHour: { name: "Kilowatt Hour", symbol: "kWh" },
+      megaelectronvolt: { name: "Megaelectronvolt", symbol: "MeV" },
+      megajoule: { name: "Megajoule", symbol: "MJ" },
+      megawattHour: { name: "Megawatt Hour", symbol: "MWh" },
+      milliwattHour: { name: "Milliwatt Hour", symbol: "mWh" },
+      terawattHour: { name: "Terawatt Hour", symbol: "TWh" },
+      wattHour: { name: "Watt Hour", symbol: "Wh" }
+    }
+  },
+  EnergyRate: {
+    name: "Energy Rate",
+    description: "Rate of energy transfer or conversion.",
+    units: powerUnits
+  },
+  Force: {
+    name: "Force",
+    description: "Interaction that changes the motion of an object.",
+    units: forceUnits
+  },
+  Frequency: {
+    name: "Frequency",
+    description: "Number of occurrences per unit time.",
+    units: {
+      gigahertz: { name: "Gigahertz", symbol: "GHz" },
+      hertz: { name: "Hertz", symbol: "Hz" },
+      kilohertz: { name: "Kilohertz", symbol: "kHz" },
+      megahertz: { name: "Megahertz", symbol: "MHz" },
+      millihertz: { name: "Millihertz", symbol: "mHz" }
+    }
+  },
+  Humidity: {
+    name: "Humidity",
+    description: "Absolute moisture content expressed as mass per volume.",
+    units: densityUnits
+  },
+  Illuminance: {
+    name: "Illuminance",
+    description: "Luminous flux incident on a surface per unit area.",
+    units: {
+      footcandle: { name: "Footcandle", symbol: "fc" },
+      lux: { name: "Lux", symbol: "lx" }
+    }
+  },
+  Inductance: {
+    name: "Inductance",
+    description: "Property of a conductor to oppose change in current.",
+    units: {
+      henry: { name: "Henry", symbol: "H" },
+      microhenry: { name: "Microhenry", symbol: "\xB5H" },
+      millihenry: { name: "Millihenry", symbol: "mH" }
+    }
+  },
+  IonizingRadiationDose: {
+    name: "Ionizing Radiation Dose",
+    description: "Absorbed dose of ionizing radiation.",
+    units: {
+      gray: { name: "Gray", symbol: "Gy" },
+      microgray: { name: "Microgray", symbol: "\xB5Gy" },
+      microsievert: { name: "Microsievert", symbol: "\xB5Sv" },
+      milligray: { name: "Milligray", symbol: "mGy" },
+      millisievert: { name: "Millisievert", symbol: "mSv" },
+      sievert: { name: "Sievert", symbol: "Sv" }
+    }
+  },
+  Irradiance: {
+    name: "Irradiance",
+    description: "Power of electromagnetic radiation per unit area.",
+    units: {
+      wattPerSquareMetre: { name: "Watt per Square Metre", symbol: "W/m\xB2" }
+    }
+  },
+  Latitude: {
+    name: "Latitude",
+    description: "Angular distance north or south of the equator.",
+    units: angleUnits
+  },
+  Length: {
+    name: "Length",
+    description: "Measure of a one-dimensional extent.",
+    units: lengthUnits
+  },
+  Longitude: {
+    name: "Longitude",
+    description: "Angular distance east or west of the prime meridian.",
+    units: angleUnits
+  },
+  Luminance: {
+    name: "Luminance",
+    description: "Luminous intensity per unit area of light in a given direction.",
+    units: {
+      candelaPerSquareMetre: { name: "Candela per Square Metre", symbol: "cd/m\xB2" }
+    }
+  },
+  Luminosity: {
+    name: "Luminosity",
+    description: "Total amount of electromagnetic energy emitted per unit time.",
+    units: powerUnits
+  },
+  LuminousFlux: {
+    name: "Luminous Flux",
+    description: "Total quantity of visible light emitted by a source.",
+    units: {
+      lumen: { name: "Lumen", symbol: "lm" }
+    }
+  },
+  LuminousIntensity: {
+    name: "Luminous Intensity",
+    description: "Luminous flux emitted per unit solid angle.",
+    units: {
+      candela: { name: "Candela", symbol: "cd" }
+    }
+  },
+  MagneticFlux: {
+    name: "Magnetic Flux",
+    description: "Total magnetic field passing through an area.",
+    units: {
+      maxwell: { name: "Maxwell", symbol: "Mx" },
+      weber: { name: "Weber", symbol: "Wb" }
+    }
+  },
+  MagneticInduction: {
+    name: "Magnetic Induction",
+    description: "Magnetic flux density.",
+    units: {
+      gauss: { name: "Gauss", symbol: "G" },
+      tesla: { name: "Tesla", symbol: "T" }
+    }
+  },
+  Mass: {
+    name: "Mass",
+    description: "Quantity of matter.",
+    units: {
+      gram: { name: "Gram", symbol: "g" },
+      kilogram: { name: "Kilogram", symbol: "kg" },
+      massPound: { name: "Pound (mass)", symbol: "lb" },
+      microgram: { name: "Microgram", symbol: "\xB5g" },
+      milligram: { name: "Milligram", symbol: "mg" },
+      slug: { name: "Slug", symbol: "slug" },
+      tonne: { name: "Tonne", symbol: "t" }
+    }
+  },
+  MassFlowRate: {
+    name: "Mass Flow Rate",
+    description: "Mass of substance passing a point per unit time.",
+    units: {
+      gramPerHour: { name: "Gram per Hour", symbol: "g/h" },
+      gramPerSecond: { name: "Gram per Second", symbol: "g/s" },
+      kilogramPerHour: { name: "Kilogram per Hour", symbol: "kg/h" },
+      kilogramPerSecond: { name: "Kilogram per Second", symbol: "kg/s" },
+      massPoundPerHour: { name: "Pound per Hour", symbol: "lb/h" }
+    }
+  },
+  Power: {
+    name: "Power",
+    description: "Rate of energy transfer or work.",
+    units: powerUnits
+  },
+  Pressure: {
+    name: "Pressure",
+    description: "Force applied per unit area.",
+    units: {
+      bar: { name: "Bar", symbol: "bar" },
+      decapascal: { name: "Decapascal", symbol: "daPa" },
+      hectopascal: { name: "Hectopascal", symbol: "hPa" },
+      inchesOfMercury: { name: "Inches of Mercury", symbol: "inHg" },
+      inchesOfWater: { name: "Inches of Water", symbol: "inH\u2082O" },
+      kilopascal: { name: "Kilopascal", symbol: "kPa" },
+      millibar: { name: "Millibar", symbol: "mbar" },
+      millimetresOfMercury: { name: "Millimetres of Mercury", symbol: "mmHg" },
+      pascal: { name: "Pascal", symbol: "Pa" },
+      poundPerSquareInch: { name: "Pound per Square Inch", symbol: "psi" }
+    }
+  },
+  Radioactivity: {
+    name: "Radioactivity",
+    description: "Rate of radioactive decay.",
+    units: {
+      becquerel: { name: "Becquerel", symbol: "Bq" },
+      gigabecquerel: { name: "Gigabecquerel", symbol: "GBq" },
+      kilobecquerel: { name: "Kilobecquerel", symbol: "kBq" },
+      megabecquerel: { name: "Megabecquerel", symbol: "MBq" }
+    }
+  },
+  ReactiveEnergy: {
+    name: "Reactive Energy",
+    description: "Integral of reactive power over time.",
+    units: {
+      gigavoltAmpereReactiveHour: { name: "Gigavolt Ampere Reactive Hour", symbol: "GVARh" },
+      kilovoltAmpereReactiveHour: { name: "Kilovolt Ampere Reactive Hour", symbol: "kVARh" },
+      megavoltAmpereReactiveHour: { name: "Megavolt Ampere Reactive Hour", symbol: "MVARh" },
+      voltAmpereReactiveHour: { name: "Volt Ampere Reactive Hour", symbol: "VARh" }
+    }
+  },
+  ReactivePower: {
+    name: "Reactive Power",
+    description: "Power oscillating between source and load in an AC circuit.",
+    units: {
+      gigavoltAmpereReactive: { name: "Gigavolt Ampere Reactive", symbol: "GVAR" },
+      kilovoltAmpereReactive: { name: "Kilovolt Ampere Reactive", symbol: "kVAR" },
+      megavoltAmpereReactive: { name: "Megavolt Ampere Reactive", symbol: "MVAR" },
+      millivoltAmpereReactive: { name: "Millivolt Ampere Reactive", symbol: "mVAR" },
+      voltAmpereReactive: { name: "Volt Ampere Reactive", symbol: "VAR" }
+    }
+  },
+  RelativeDensity: {
+    name: "Relative Density",
+    description: "Ratio of a substance's density to a reference substance.",
+    units: unitlessUnits
+  },
+  RelativeHumidity: {
+    name: "Relative Humidity",
+    description: "Ratio of current moisture content to saturation capacity.",
+    units: unitlessUnits
+  },
+  Resistance: {
+    name: "Resistance",
+    description: "Opposition to flow of electric current.",
+    units: {
+      kiloohm: { name: "Kiloohm", symbol: "k\u03A9" },
+      megaohm: { name: "Megaohm", symbol: "M\u03A9" },
+      milliohm: { name: "Milliohm", symbol: "m\u03A9" },
+      ohm: { name: "Ohm", symbol: "\u03A9" }
+    }
+  },
+  SoundPressure: {
+    name: "Sound Pressure",
+    description: "Local pressure deviation from ambient caused by sound.",
+    units: {
+      bel: { name: "Bel", symbol: "B" },
+      decibel: { name: "Decibel", symbol: "dB" }
+    }
+  },
+  Temperature: {
+    name: "Temperature",
+    description: "Degree of hotness or coldness.",
+    units: {
+      degreeCelsius: { name: "Degree Celsius", symbol: "\xB0C" },
+      degreeFahrenheit: { name: "Degree Fahrenheit", symbol: "\xB0F" },
+      kelvin: { name: "Kelvin", symbol: "K" }
+    }
+  },
+  Thrust: {
+    name: "Thrust",
+    description: "Reaction force from expelling mass.",
+    units: forceUnits
+  },
+  TimeSpan: {
+    name: "Time Span",
+    description: "Duration of time (numeric, not ISO 8601 calendar duration).",
+    units: {
+      day: { name: "Day", symbol: "d" },
+      hour: { name: "Hour", symbol: "h" },
+      microsecond: { name: "Microsecond", symbol: "\xB5s" },
+      millisecond: { name: "Millisecond", symbol: "ms" },
+      minute: { name: "Minute", symbol: "min" },
+      nanosecond: { name: "Nanosecond", symbol: "ns" },
+      second: { name: "Second", symbol: "s" },
+      year: { name: "Year", symbol: "yr" }
+    }
+  },
+  Torque: {
+    name: "Torque",
+    description: "Rotational force.",
+    units: {
+      newtonMetre: { name: "Newton Metre", symbol: "N\xB7m" }
+    }
+  },
+  Velocity: {
+    name: "Velocity",
+    description: "Speed in a given direction.",
+    units: {
+      centimetrePerSecond: { name: "Centimetre per Second", symbol: "cm/s" },
+      kilometrePerHour: { name: "Kilometre per Hour", symbol: "km/h" },
+      kilometrePerSecond: { name: "Kilometre per Second", symbol: "km/s" },
+      knot: { name: "Knot", symbol: "kn" },
+      metrePerHour: { name: "Metre per Hour", symbol: "m/h" },
+      metrePerSecond: { name: "Metre per Second", symbol: "m/s" },
+      milePerHour: { name: "Mile per Hour", symbol: "mph" },
+      milePerSecond: { name: "Mile per Second", symbol: "mi/s" }
+    }
+  },
+  Voltage: {
+    name: "Voltage",
+    description: "Electric potential difference.",
+    units: {
+      kilovolt: { name: "Kilovolt", symbol: "kV" },
+      megavolt: { name: "Megavolt", symbol: "MV" },
+      microvolt: { name: "Microvolt", symbol: "\xB5V" },
+      millivolt: { name: "Millivolt", symbol: "mV" },
+      volt: { name: "Volt", symbol: "V" }
+    }
+  },
+  Volume: {
+    name: "Volume",
+    description: "Extent of a three-dimensional space.",
+    units: {
+      cubicCentimetre: { name: "Cubic Centimetre", symbol: "cm\xB3" },
+      cubicFoot: { name: "Cubic Foot", symbol: "ft\xB3" },
+      cubicInch: { name: "Cubic Inch", symbol: "in\xB3" },
+      cubicMetre: { name: "Cubic Metre", symbol: "m\xB3" },
+      fluidOunce: { name: "Fluid Ounce", symbol: "fl oz" },
+      gallon: { name: "Gallon", symbol: "gal" },
+      litre: { name: "Litre", symbol: "L" },
+      millilitre: { name: "Millilitre", symbol: "mL" }
+    }
+  },
+  VolumeFlowRate: {
+    name: "Volume Flow Rate",
+    description: "Volume of fluid passing a point per unit time.",
+    units: {
+      cubicFootPerMinute: { name: "Cubic Foot per Minute", symbol: "cfm" },
+      cubicMetrePerHour: { name: "Cubic Metre per Hour", symbol: "m\xB3/h" },
+      cubicMetrePerMinute: { name: "Cubic Metre per Minute", symbol: "m\xB3/min" },
+      cubicMetrePerSecond: { name: "Cubic Metre per Second", symbol: "m\xB3/s" },
+      gallonPerHour: { name: "Gallon per Hour", symbol: "gal/h" },
+      gallonPerMinute: { name: "Gallon per Minute", symbol: "gal/min" },
+      litrePerHour: { name: "Litre per Hour", symbol: "L/h" },
+      litrePerMinute: { name: "Litre per Minute", symbol: "L/min" },
+      litrePerSecond: { name: "Litre per Second", symbol: "L/s" },
+      millilitrePerHour: { name: "Millilitre per Hour", symbol: "mL/h" },
+      millilitrePerMinute: { name: "Millilitre per Minute", symbol: "mL/min" },
+      millilitrePerSecond: { name: "Millilitre per Second", symbol: "mL/s" }
+    }
+  }
+};
+// src/ontology/units/index.ts
+var unitIndex = new Map;
+for (const [qtId, qt] of Object.entries(quantitativeTypes)) {
+  for (const [unitId, unit] of Object.entries(qt.units)) {
+    if (!unitIndex.has(unitId)) {
+      unitIndex.set(unitId, { ...unit, quantitativeTypeId: qtId });
+    }
+  }
+}
+function getUnit(unitId) {
+  return unitIndex.get(unitId);
+}
+function getUnitsFor(quantitativeTypeId) {
+  const qt = quantitativeTypes[quantitativeTypeId];
+  return qt?.units;
+}
+function isValidUnit(quantitativeTypeId, unitId) {
+  const units = getUnitsFor(quantitativeTypeId);
+  return units != null && unitId in units;
+}
+function getUnitSymbol(unitId) {
+  return unitIndex.get(unitId)?.symbol;
+}
+function isQuantitativeTypeId(value) {
+  return value in quantitativeTypes;
+}
+function isUnitId(value) {
+  return unitIndex.has(value);
+}
+
+// src/ontology/validation/telemetry.ts
+function assertTelemetryProperty(property) {
+  if (property.mode !== "telemetry") {
+    throw new OntologyValidationError(`[Sixb] Property ${property.id} is not telemetry-enabled`);
+  }
+}
+function resolveSemanticType(property, valueTypesById) {
+  if (property.semanticType) {
+    return property.semanticType;
+  }
+  const valueTypeId = resolveValueTypeRef(property.schema);
+  if (!valueTypeId) {
+    return;
+  }
+  return valueTypesById.get(valueTypeId)?.semanticType;
+}
+function validateTelemetryUnit(property, propertyPath, unit, valueTypesById) {
+  const semanticType = resolveSemanticType(property, valueTypesById);
+  if (semanticType) {
+    if (!unit) {
+      throw new OntologyValidationError(`[Sixb] Missing unit for telemetry property ${propertyPath}`);
+    }
+    if (!isValidUnit(semanticType, unit)) {
+      throw new OntologyValidationError(`[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`);
+  }
+}
+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 };
+
+//# debugId=AABC3DC1F69E74EB64756E2164756E21