ochre-sdk 0.21.6 → 0.21.7

package/dist/index.d.mts

@@ -670,15 +670,14 @@ type SetItemsSort = {
   direction?: SetItemsSortDirection;
   language?: string;
 };
-type QueryPropertyDataType = Exclude<PropertyValueContentType, "coordinate"> | "all";
 /**
  * Represents a leaf query for Set items
  */
 type QueryLeaf = {
   target: "property";
   propertyVariable?: string;
-  dataType: "all";
-  value: string;
+  dataType: Exclude<Exclude<PropertyValueContentType, "coordinate">, "date" | "dateTime">;
+  value?: string;
   from?: never;
   to?: never;
   matchMode: "includes" | "exact";
@@ -687,9 +686,9 @@ type QueryLeaf = {
   isNegated?: boolean;
 } | {
   target: "property";
-  propertyVariable?: string;
-  dataType: Exclude<PropertyValueContentType, "coordinate">;
-  value?: string;
+  propertyVariable: string;
+  dataType: "date" | "dateTime";
+  value: string;
   from?: never;
   to?: never;
   matchMode: "includes" | "exact";
@@ -718,6 +717,15 @@ type QueryLeaf = {
   isCaseSensitive: boolean;
   language: string;
   isNegated?: boolean;
+} | {
+  target: "property";
+  propertyVariable?: string;
+  dataType: "all";
+  value: string;
+  matchMode: "includes" | "exact";
+  isCaseSensitive: boolean;
+  language: string;
+  isNegated?: boolean;
 } | {
   target: "string";
   value: string;
@@ -1528,4 +1536,4 @@ declare const DEFAULT_PAGE_SIZE = 48;
  */
 declare function flattenItemProperties<T extends DataCategory = DataCategory, U extends DataCategory | Array<DataCategory> = (T extends "tree" ? Exclude<DataCategory, "tree"> : T extends "set" ? Array<DataCategory> : never)>(item: Item<T, U>): Item<T, U>;
 //#endregion
-export { ApiVersion, Bibliography, Concept, Context, ContextItem, ContextNode, Coordinate, DEFAULT_API_VERSION, DEFAULT_PAGE_SIZE, Data, DataCategory, Event, FileFormat, Gallery, Identification, Image, ImageMap, ImageMapArea, Interpretation, Item, LevelContext, LevelContextItem, License, Link, Metadata, Note, Observation, Period, Person, Property, PropertyContexts, PropertyValue, PropertyValueContent, PropertyValueContentType, PropertyValueQueryItem, PropertyVariable, Query, QueryGroup, QueryLeaf, QueryPropertyDataType, Resource, Scope, Section, Set, SetAttributeValueQueryItem, SetItemsSort, SetItemsSortDirection, SpatialUnit, Style, StylesheetCategory, StylesheetItem, Text, Tree, WebBlock, WebBlockLayout, WebElement, WebElementComponent, WebImage, WebSegment, WebSegmentItem, WebTitle, Webpage, Website, WebsitePropertyQuery, WebsitePropertyQueryNode, WebsiteType, fetchGallery, fetchItem, fetchSetItems, fetchSetPropertyValues, fetchWebsite, filterProperties, flattenItemProperties, getLeafPropertyValues, getPropertyByLabel, getPropertyByLabelAndValue, getPropertyByLabelAndValues, getPropertyByUuid, getPropertyValueByLabel, getPropertyValueByUuid, getPropertyValuesByLabel, getPropertyValuesByUuid, getUniqueProperties, getUniquePropertyLabels };
+export { ApiVersion, Bibliography, Concept, Context, ContextItem, ContextNode, Coordinate, DEFAULT_API_VERSION, DEFAULT_PAGE_SIZE, Data, DataCategory, Event, FileFormat, Gallery, Identification, Image, ImageMap, ImageMapArea, Interpretation, Item, LevelContext, LevelContextItem, License, Link, Metadata, Note, Observation, Period, Person, Property, PropertyContexts, PropertyValue, PropertyValueContent, PropertyValueContentType, PropertyValueQueryItem, PropertyVariable, Query, QueryGroup, QueryLeaf, Resource, Scope, Section, Set, SetAttributeValueQueryItem, SetItemsSort, SetItemsSortDirection, SpatialUnit, Style, StylesheetCategory, StylesheetItem, Text, Tree, WebBlock, WebBlockLayout, WebElement, WebElementComponent, WebImage, WebSegment, WebSegmentItem, WebTitle, Webpage, Website, WebsitePropertyQuery, WebsitePropertyQueryNode, WebsiteType, fetchGallery, fetchItem, fetchSetItems, fetchSetPropertyValues, fetchWebsite, filterProperties, flattenItemProperties, getLeafPropertyValues, getPropertyByLabel, getPropertyByLabelAndValue, getPropertyByLabelAndValues, getPropertyByUuid, getPropertyValueByLabel, getPropertyValueByUuid, getPropertyValuesByLabel, getPropertyValuesByUuid, getUniqueProperties, getUniquePropertyLabels };

package/dist/index.mjs

@@ -757,18 +757,6 @@ const boundsSchema = z.string().transform((str, ctx) => {
 * @internal
 */
 const setQueryLeafSchema = z.union([
-	z.object({
-		target: z.literal("property"),
-		propertyVariable: uuidSchema.optional(),
-		dataType: z.literal("all"),
-		value: z.string(),
-		from: z.never().optional(),
-		to: z.never().optional(),
-		matchMode: z.enum(["includes", "exact"]),
-		isCaseSensitive: z.boolean(),
-		language: z.string().default("eng"),
-		isNegated: z.boolean().optional().default(false)
-	}).strict(),
 	z.object({
 		target: z.literal("property"),
 		propertyVariable: uuidSchema.optional(),
@@ -777,14 +765,10 @@ const setQueryLeafSchema = z.union([
 			"integer",
 			"decimal",
 			"boolean",
-			"IDREF",
-			"date",
-			"dateTime",
-			"time"
+			"time",
+			"IDREF"
 		]),
 		value: z.string().optional(),
-		from: z.never().optional(),
-		to: z.never().optional(),
 		matchMode: z.enum(["includes", "exact"]),
 		isCaseSensitive: z.boolean(),
 		language: z.string().default("eng"),
@@ -795,6 +779,18 @@ const setQueryLeafSchema = z.union([
 			message: "Property queries must include at least one propertyVariable or value"
 		});
 	}),
+	z.object({
+		target: z.literal("property"),
+		propertyVariable: uuidSchema,
+		dataType: z.enum(["date", "dateTime"]),
+		value: z.string(),
+		from: z.never().optional(),
+		to: z.never().optional(),
+		matchMode: z.enum(["includes", "exact"]),
+		isCaseSensitive: z.boolean(),
+		language: z.string().default("eng"),
+		isNegated: z.boolean().optional().default(false)
+	}).strict(),
 	z.object({
 		target: z.literal("property"),
 		propertyVariable: uuidSchema,
@@ -819,6 +815,16 @@ const setQueryLeafSchema = z.union([
 		language: z.string().default("eng"),
 		isNegated: z.boolean().optional().default(false)
 	}).strict(),
+	z.object({
+		target: z.literal("property"),
+		propertyVariable: uuidSchema.optional(),
+		dataType: z.literal("all"),
+		value: z.string(),
+		matchMode: z.enum(["includes", "exact"]),
+		isCaseSensitive: z.boolean(),
+		language: z.string().default("eng"),
+		isNegated: z.boolean().optional().default(false)
+	}).strict(),
 	z.object({
 		target: z.literal("string"),
 		value: z.string(),
@@ -2162,28 +2168,6 @@ const CTS_INCLUDES_STOP_WORDS = [
 ];
 const CTS_INCLUDES_STOP_WORDS_VAR = "$ctsIncludesStopWords";
 const CTS_INCLUDES_TOKEN_SPLIT_REGEX = /\W+/u;
-const CONTENT_TARGET_CONFIGS = {
-	title: {
-		containerElementName: "identification",
-		getContentNodesExpression: (language) => `identification/label/content[@xml:lang="${language}"]`
-	},
-	description: {
-		containerElementName: "description",
-		getContentNodesExpression: (language) => `description/content[@xml:lang="${language}"]`
-	},
-	image: {
-		containerElementName: "image",
-		getContentNodesExpression: (language) => `image/identification/label/content[@xml:lang="${language}"]`
-	},
-	periods: {
-		containerElementName: "period",
-		getContentNodesExpression: (language) => `periods/period/identification/label/content[@xml:lang="${language}"]`
-	},
-	bibliography: {
-		containerElementName: "bibliography",
-		getContentNodesExpression: (language) => `bibliographies/bibliography/identification/label/content[@xml:lang="${language}"]`
-	}
-};
 function tokenizeIncludesSearchValue(params) {
 	const { value, isCaseSensitive } = params;
 	const rawTerms = (isCaseSensitive ? value : value.toLowerCase()).split(CTS_INCLUDES_TOKEN_SPLIT_REGEX);
@@ -2198,10 +2182,6 @@ function buildFlattenedContentValuesExpression(contentNodesExpression) {
 	return `for $content in ${contentNodesExpression}
     return string-join($content//text(), "")`;
 }
-function buildNodeStringValuesExpression(nodesExpression) {
-	return `for $node in ${nodesExpression}
-    return string($node)`;
-}
 function buildSearchableContentNodesExpression(contentNodesExpression) {
 	return `for $content in ${contentNodesExpression}
     return (
@@ -2216,17 +2196,46 @@ function buildCombinedSearchableContentNodesExpression(contentNodesExpressions)
 	if (searchableExpressions.length === 1) return searchableExpressions[0] ?? "()";
 	return `(${searchableExpressions.join(", ")})`;
 }
-function buildTokenizedSearchPredicate(params) {
-	const { searchableNodesExpression, termsExpression, isCaseSensitive } = params;
-	return `(every $term in ${termsExpression}
-  satisfies some $searchNode in (${searchableNodesExpression})
-    satisfies cts:contains(
-      $searchNode,
-      ${buildCtsWordQueryExpression({
-		termExpression: "$term",
-		isCaseSensitive
-	})}
-    ))`;
+function buildPropertyValueNodesExpression(params) {
+	const predicates = [];
+	if (params?.excludeInherited) predicates.push(`not(@inherited="true")`);
+	for (const excludedDataType of params?.excludedDataTypes ?? []) predicates.push(`not(@dataType=${stringLiteral(excludedDataType)})`);
+	if (predicates.length === 0) return "value";
+	return `value[${predicates.join(" and ")}]`;
+}
+function buildPropertyValueContentNodesExpression(params) {
+	const { language, excludeInherited, excludedDataTypes } = params;
+	return `${buildPropertyValueNodesExpression({
+		excludeInherited,
+		excludedDataTypes
+	})}/content[@xml:lang="${language}"]`;
+}
+function buildPropertyValueContentValuesExpression(params) {
+	return buildFlattenedContentValuesExpression(buildPropertyValueContentNodesExpression(params));
+}
+function buildPropertyValueRawValuesExpression(params) {
+	return `for $value in ${buildPropertyValueNodesExpression(params)}[@rawValue]
+    return string($value/@rawValue)`;
+}
+function buildPropertyValueDirectTextValuesExpression(params) {
+	return `for $value in ${buildPropertyValueNodesExpression(params)}
+    let $candidate := string-join($value/text(), "")
+    where normalize-space($candidate) != ""
+    return $candidate`;
+}
+function buildPropertyScalarValueExpressions() {
+	return [buildPropertyValueRawValuesExpression(), buildPropertyValueDirectTextValuesExpression()];
+}
+function buildAllPropertyValueExpressions(language) {
+	const params = { excludedDataTypes: ["IDREF"] };
+	return [
+		buildPropertyValueRawValuesExpression(params),
+		buildPropertyValueContentValuesExpression({
+			language,
+			...params
+		}),
+		buildPropertyValueDirectTextValuesExpression(params)
+	];
 }
 /**
 * Build a string match predicate for an XQuery string.
@@ -2236,10 +2245,16 @@ function buildRawStringMatchPredicate(params) {
 	const comparedValueLiteral = stringLiteral(isCaseSensitive ? value : value.toLowerCase());
 	const candidateVar = "$candidate";
 	const comparedCandidate = isCaseSensitive ? candidateVar : `lower-case(${candidateVar})`;
-	if (matchMode === "includes") return `some ${candidateVar} in (${valueExpression})
-  satisfies contains(${comparedCandidate}, ${comparedValueLiteral})`;
-	return `some ${candidateVar} in (${valueExpression})
-  satisfies ${comparedCandidate} = ${comparedValueLiteral}`;
+	if (matchMode === "includes") return `exists(
+  for ${candidateVar} in (${valueExpression})
+    where contains(${comparedCandidate}, ${comparedValueLiteral})
+    return ${candidateVar}
+)`;
+	return `exists(
+  for ${candidateVar} in (${valueExpression})
+    where ${comparedCandidate} = ${comparedValueLiteral}
+    return ${candidateVar}
+)`;
 }
 /**
 * Build a combined raw string match predicate for multiple paths.
@@ -2247,30 +2262,53 @@ function buildRawStringMatchPredicate(params) {
 function buildCombinedRawStringMatchPredicate(params) {
 	const { valueExpressions, value, matchMode, isCaseSensitive } = params;
 	const predicates = [];
-	for (const valueExpression of valueExpressions) predicates.push(buildRawStringMatchPredicate({
+	for (const valueExpression of valueExpressions) predicates.push(`(${buildRawStringMatchPredicate({
 		valueExpression,
 		value,
 		matchMode,
 		isCaseSensitive
-	}));
+	})})`);
 	return buildOrPredicate(predicates);
 }
 /**
 * Build CTS word-query options for API v2 includes search.
 */
-function buildCtsQueryOptionsExpression(isCaseSensitive) {
-	return `(${[
+function buildCtsQueryOptionsExpression(params) {
+	const { isCaseSensitive, isWildcarded } = params;
+	const options = [
 		isCaseSensitive ? "case-sensitive" : "case-insensitive",
 		"diacritic-insensitive",
 		"punctuation-insensitive"
-	].map((option) => stringLiteral(option)).join(", ")})`;
+	];
+	if (isWildcarded) options.push("wildcarded");
+	return `(${options.map((option) => stringLiteral(option)).join(", ")})`;
+}
+function buildWildcardedTermExpression(termExpression) {
+	return `fn:concat("*", ${termExpression}, "*")`;
 }
 /**
 * Build a CTS word-query expression for an XQuery term.
 */
 function buildCtsWordQueryExpression(params) {
-	const { termExpression, isCaseSensitive } = params;
-	return `cts:word-query(${termExpression}, ${buildCtsQueryOptionsExpression(isCaseSensitive)})`;
+	const { termExpression, isCaseSensitive, isWildcarded } = params;
+	return `cts:word-query(${isWildcarded ? buildWildcardedTermExpression(termExpression) : termExpression}, ${buildCtsQueryOptionsExpression({
+		isCaseSensitive,
+		isWildcarded
+	})})`;
+}
+function buildCtsElementWordQueryExpression(params) {
+	const { elementName, termExpression, isCaseSensitive, isWildcarded } = params;
+	return `cts:element-word-query(xs:QName("${elementName}"), ${isWildcarded ? buildWildcardedTermExpression(termExpression) : termExpression}, ${buildCtsQueryOptionsExpression({
+		isCaseSensitive,
+		isWildcarded
+	})})`;
+}
+function buildCtsElementAttributeWordQueryExpression(params) {
+	const { elementName, attributeName, termExpression, isCaseSensitive, isWildcarded } = params;
+	return `cts:element-attribute-word-query(xs:QName("${elementName}"), xs:QName("${attributeName}"), ${isWildcarded ? buildWildcardedTermExpression(termExpression) : termExpression}, ${buildCtsQueryOptionsExpression({
+		isCaseSensitive,
+		isWildcarded
+	})})`;
 }
 /**
 * Build tokenized search declarations for CTS-backed queries.
@@ -2294,8 +2332,8 @@ function buildTokenizedSearchDeclarations(params) {
 		termsVar
 	};
 }
-function buildTokenizedCtsClause(params) {
-	const { value, isCaseSensitive, queryKey, fallbackPredicate, buildTermQueryExpression, buildTokenPredicate } = params;
+function buildCtsCandidateQuery(params) {
+	const { value, isCaseSensitive, queryKey, buildCandidateTermQuery } = params;
 	const tokenizedSearchDeclarations = buildTokenizedSearchDeclarations({
 		value,
 		isCaseSensitive,
@@ -2308,7 +2346,7 @@ function buildTokenizedCtsClause(params) {
 		isCaseSensitive
 	}).length === 0) return {
 		declarations: [],
-		predicate: fallbackPredicate,
+		termsVar: tokenizedSearchDeclarations.termsVar,
 		candidateQueryVar: null
 	};
 	return {
@@ -2316,7 +2354,7 @@ function buildTokenizedCtsClause(params) {
 			...tokenizedSearchDeclarations.declarations,
 			`let ${termQueriesVar} :=
   for $term in ${tokenizedSearchDeclarations.termsVar}
-    return ${buildTermQueryExpression("$term")}`,
+    return ${buildCandidateTermQuery("$term")}`,
 			`let ${candidateQueryVar} :=
   if (count(${tokenizedSearchDeclarations.termsVar}) = 1)
   then ${termQueriesVar}[1]
@@ -2324,29 +2362,42 @@ function buildTokenizedCtsClause(params) {
   then cts:and-query(${termQueriesVar})
   else ()`
 		],
-		predicate: buildTokenPredicate(tokenizedSearchDeclarations.termsVar),
+		termsVar: tokenizedSearchDeclarations.termsVar,
 		candidateQueryVar
 	};
 }
 function buildCtsIncludesPredicate(params) {
 	const { searchableNodesExpression, fallbackValueExpression, value, isCaseSensitive, queryKey, buildCandidateTermQuery } = params;
-	return buildTokenizedCtsClause({
+	const candidateQuery = buildCtsCandidateQuery({
 		value,
 		isCaseSensitive,
 		queryKey,
-		fallbackPredicate: buildRawStringMatchPredicate({
-			valueExpression: fallbackValueExpression,
-			value,
-			matchMode: "includes",
-			isCaseSensitive
-		}),
-		buildTermQueryExpression: buildCandidateTermQuery,
-		buildTokenPredicate: (termsExpression) => buildTokenizedSearchPredicate({
-			searchableNodesExpression,
-			termsExpression,
-			isCaseSensitive
-		})
+		buildCandidateTermQuery
+	});
+	const fallbackPredicate = buildRawStringMatchPredicate({
+		valueExpression: fallbackValueExpression,
+		value,
+		matchMode: "includes",
+		isCaseSensitive
 	});
+	if (candidateQuery.candidateQueryVar == null) return {
+		declarations: [],
+		predicate: fallbackPredicate,
+		candidateQueryVar: null
+	};
+	return {
+		declarations: candidateQuery.declarations,
+		predicate: `(every $term in ${candidateQuery.termsVar}
+  satisfies some $searchNode in (${searchableNodesExpression})
+    satisfies cts:contains(
+      $searchNode,
+      ${buildCtsWordQueryExpression({
+			termExpression: "$term",
+			isCaseSensitive
+		})}
+    ))`,
+		candidateQueryVar: candidateQuery.candidateQueryVar
+	};
 }
 /**
 * Build the raw search paths for item-level string search.
@@ -2400,14 +2451,14 @@ function buildItemStringPropertyValueBranch(params) {
 * Build an item-level CTS string search predicate.
 */
 function buildItemStringSearchClause(params) {
-	const { query, version, queryKey } = params;
+	const { query, version, queryKey, allowCtsPredicates } = params;
 	const fallbackPredicate = buildCombinedRawStringMatchPredicate({
 		valueExpressions: buildItemStringSearchPaths(query.language),
 		value: query.value,
 		matchMode: query.matchMode,
 		isCaseSensitive: query.isCaseSensitive
 	});
-	if (query.matchMode !== "includes" || version !== 2) return {
+	if (!allowCtsPredicates || query.matchMode !== "includes" || version !== 2) return {
 		declarations: [],
 		predicate: fallbackPredicate,
 		candidateQueryVar: null
@@ -2471,9 +2522,6 @@ function getQueryGroupChildren(query) {
 function getQueryGroupOperator(query) {
 	return "and" in query ? "and" : "or";
 }
-function getContentTargetConfig(target) {
-	return CONTENT_TARGET_CONFIGS[target];
-}
 function buildContentTargetCandidateBranch(params) {
 	const { containerElementName, termExpression, isCaseSensitive, language } = params;
 	return `cts:element-query(xs:QName("${containerElementName}"),
@@ -2507,114 +2555,28 @@ function buildPropertyStringCandidateBranch(params) {
         )
       )`;
 }
-function buildPropertyContentNodesExpression(params) {
-	const { language, excludeInherited } = params;
-	return `${excludeInherited ? `value[not(@inherited="true")]` : "value"}/content[@xml:lang="${language}"]`;
-}
-function buildPropertyRawValueCandidateBranch(params) {
+function buildPropertyScalarCandidateBranch(params) {
 	const { termExpression, isCaseSensitive } = params;
 	return `cts:element-query(xs:QName("properties"),
         cts:element-query(xs:QName("property"),
-          cts:element-attribute-word-query(
-            xs:QName("value"),
-            xs:QName("rawValue"),
-            ${termExpression},
-            ${buildCtsQueryOptionsExpression(isCaseSensitive)}
-          )
-        )
-      )`;
-}
-function buildPropertySimpleValueTextCandidateBranch(params) {
-	const { termExpression, isCaseSensitive } = params;
-	return `cts:element-query(xs:QName("properties"),
-        cts:element-query(xs:QName("property"),
-          cts:element-word-query(
-            xs:QName("value"),
-            ${termExpression},
-            ${buildCtsQueryOptionsExpression(isCaseSensitive)}
-          )
+          cts:or-query((
+            ${buildCtsElementAttributeWordQueryExpression({
+		elementName: "value",
+		attributeName: "rawValue",
+		termExpression,
+		isCaseSensitive,
+		isWildcarded: true
+	})},
+            ${buildCtsElementWordQueryExpression({
+		elementName: "value",
+		termExpression,
+		isCaseSensitive,
+		isWildcarded: true
+	})}
+          ))
         )
       )`;
 }
-function buildPropertySimpleValueRawValueExpression() {
-	return buildNodeStringValuesExpression("value/@rawValue");
-}
-function buildPropertySimpleValueTextExpression() {
-	return buildNodeStringValuesExpression("value[not(*)]/text()");
-}
-function buildPropertySimpleValueSearchableNodesExpression() {
-	return "value[not(*)]";
-}
-function buildPropertyContentRawPredicate(params) {
-	const { value, matchMode, isCaseSensitive, language, excludeInherited } = params;
-	return buildRawStringMatchPredicate({
-		valueExpression: buildFlattenedContentValuesExpression(buildPropertyContentNodesExpression({
-			language,
-			excludeInherited
-		})),
-		value,
-		matchMode,
-		isCaseSensitive
-	});
-}
-function buildPropertyRawValueOrTextRawPredicate(params) {
-	const { value, matchMode, isCaseSensitive } = params;
-	return buildOrPredicate([buildRawStringMatchPredicate({
-		valueExpression: buildPropertySimpleValueRawValueExpression(),
-		value,
-		matchMode,
-		isCaseSensitive
-	}), buildRawStringMatchPredicate({
-		valueExpression: buildPropertySimpleValueTextExpression(),
-		value,
-		matchMode,
-		isCaseSensitive
-	})]);
-}
-function buildPropertyRawValueOrTextTokenPredicate(params) {
-	const { termsExpression, isCaseSensitive } = params;
-	const rawValueQuery = `cts:element-attribute-word-query(
-        xs:QName("value"),
-        xs:QName("rawValue"),
-        $term,
-        ${buildCtsQueryOptionsExpression(isCaseSensitive)}
-      )`;
-	const textQuery = `cts:element-word-query(
-        xs:QName("value"),
-        $term,
-        ${buildCtsQueryOptionsExpression(isCaseSensitive)}
-      )`;
-	return `(every $term in ${termsExpression}
-  satisfies some $searchNode in (${buildPropertySimpleValueSearchableNodesExpression()})
-    satisfies (
-      cts:contains($searchNode, ${rawValueQuery})
-      or
-      cts:contains($searchNode, ${textQuery})
-    ))`;
-}
-function buildPropertyContentTokenPredicate(params) {
-	const { termsExpression, isCaseSensitive, language, excludeInherited } = params;
-	return buildTokenizedSearchPredicate({
-		searchableNodesExpression: buildSearchableContentNodesExpression(buildPropertyContentNodesExpression({
-			language,
-			excludeInherited
-		})),
-		termsExpression,
-		isCaseSensitive
-	});
-}
-function buildIncludesGroupMemberFromTokenSource(params) {
-	const { rawPredicate, searchableNodesExpression, isCaseSensitive, buildCandidateTermQuery } = params;
-	return {
-		rawPredicate,
-		buildTokenPredicate: (termsExpression) => buildTokenizedSearchPredicate({
-			searchableNodesExpression,
-			termsExpression,
-			isCaseSensitive
-		}),
-		buildCandidateTermQuery
-	};
-}
 function getGroupableIncludesValue(query) {
 	switch (query.target) {
 		case "string":
@@ -2624,9 +2586,8 @@ function getGroupableIncludesValue(query) {
 		case "periods":
 		case "bibliography": return query.value;
 		case "property":
-			if (query.dataType === "IDREF") return null;
-			if (query.dataType === "date" || query.dataType === "dateTime") return "value" in query && query.value != null ? query.value : null;
-			return query.value ?? null;
+			if (query.dataType !== "string" || query.value == null) return null;
+			return query.value;
 	}
 }
 function isCompatibleIncludesGroupQuery(params) {
@@ -2636,36 +2597,30 @@ function isCompatibleIncludesGroupQuery(params) {
 	return queryValue != null && queryValue === value && query.isCaseSensitive === isCaseSensitive && query.language === language;
 }
 function buildContentTargetIncludesGroupMember(params) {
-	const { query } = params;
-	const config = getContentTargetConfig(query.target);
-	const contentNodesExpression = config.getContentNodesExpression(query.language);
-	return buildIncludesGroupMemberFromTokenSource({
+	const { contentNodesExpression, value, isCaseSensitive, language, containerElementName } = params;
+	return {
 		rawPredicate: buildRawStringMatchPredicate({
 			valueExpression: buildFlattenedContentValuesExpression(contentNodesExpression),
-			value: query.value,
+			value,
 			matchMode: "includes",
-			isCaseSensitive: query.isCaseSensitive
+			isCaseSensitive
 		}),
-		searchableNodesExpression: buildSearchableContentNodesExpression(contentNodesExpression),
-		isCaseSensitive: query.isCaseSensitive,
 		buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
-			containerElementName: config.containerElementName,
+			containerElementName,
 			termExpression,
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language
+			isCaseSensitive,
+			language
 		})
-	});
+	};
 }
 function buildItemStringIncludesGroupMember(query) {
-	return buildIncludesGroupMemberFromTokenSource({
+	return {
 		rawPredicate: buildCombinedRawStringMatchPredicate({
 			valueExpressions: buildItemStringSearchPaths(query.language),
 			value: query.value,
 			matchMode: "includes",
 			isCaseSensitive: query.isCaseSensitive
 		}),
-		searchableNodesExpression: buildItemStringSearchableNodesExpression(query.language),
-		isCaseSensitive: query.isCaseSensitive,
 		buildCandidateTermQuery: (termExpression) => `cts:or-query((
         ${buildItemStringIdentificationBranch({
 			termExpression,
@@ -2678,112 +2633,71 @@ function buildItemStringIncludesGroupMember(query) {
 			language: query.language
 		})}
       ))`
-	});
+	};
 }
 function buildPropertyStringIncludesGroupMember(query) {
 	const propertyVariable = query.propertyVariable;
 	const predicateParts = [];
-	const propertyValue = query.value;
+	const valueExpression = buildPropertyValueContentValuesExpression({
+		language: query.language,
+		excludeInherited: true
+	});
 	if (propertyVariable != null) predicateParts.push(buildPropertyLabelPredicate(propertyVariable));
-	return buildIncludesGroupMemberFromTokenSource({
-		rawPredicate: buildPropertyPredicateExpression([...predicateParts, buildPropertyContentRawPredicate({
-			value: propertyValue,
+	return {
+		rawPredicate: buildPropertyPredicateExpression([...predicateParts, buildRawStringMatchPredicate({
+			valueExpression,
+			value: query.value,
 			matchMode: "includes",
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language,
-			excludeInherited: true
+			isCaseSensitive: query.isCaseSensitive
 		})]),
-		searchableNodesExpression: buildPropertyPredicateExpression([...predicateParts, buildSearchableContentNodesExpression(buildPropertyContentNodesExpression({
-			language: query.language,
-			excludeInherited: true
-		}))]),
-		isCaseSensitive: query.isCaseSensitive,
 		buildCandidateTermQuery: (termExpression) => buildPropertyStringCandidateBranch({
 			termExpression,
 			isCaseSensitive: query.isCaseSensitive,
 			language: query.language
 		})
-	});
-}
-function buildPropertyRawValueOrTextIncludesGroupMember(query) {
-	const propertyVariable = query.propertyVariable;
-	const predicateParts = [];
-	const propertyValue = getGroupableIncludesValue(query);
-	if (propertyValue == null) throw new Error("Cannot build a rawValue/text includes group without a search value");
-	if (propertyVariable != null) predicateParts.push(buildPropertyLabelPredicate(propertyVariable));
-	return {
-		rawPredicate: buildPropertyPredicateExpression([...predicateParts, buildPropertyRawValueOrTextRawPredicate({
-			value: propertyValue,
-			matchMode: "includes",
-			isCaseSensitive: query.isCaseSensitive
-		})]),
-		buildTokenPredicate: (termsExpression) => buildPropertyPredicateExpression([...predicateParts, buildPropertyRawValueOrTextTokenPredicate({
-			termsExpression,
-			isCaseSensitive: query.isCaseSensitive
-		})]),
-		buildCandidateTermQuery: (termExpression) => buildOrCtsQueryExpression([buildPropertyRawValueCandidateBranch({
-			termExpression,
-			isCaseSensitive: query.isCaseSensitive
-		}), buildPropertySimpleValueTextCandidateBranch({
-			termExpression,
-			isCaseSensitive: query.isCaseSensitive
-		})])
 	};
 }
-function buildPropertyAllIncludesGroupMember(query) {
-	const propertyVariable = query.propertyVariable;
-	const predicateParts = [];
-	if (propertyVariable != null) predicateParts.push(buildPropertyLabelPredicate(propertyVariable));
-	return {
-		rawPredicate: buildPropertyPredicateExpression([...predicateParts, buildOrPredicate([buildPropertyRawValueOrTextRawPredicate({
+function buildIncludesGroupMember(query) {
+	switch (query.target) {
+		case "string": return buildItemStringIncludesGroupMember(query);
+		case "title": return buildContentTargetIncludesGroupMember({
+			contentNodesExpression: `identification/label/content[@xml:lang="${query.language}"]`,
 			value: query.value,
-			matchMode: "includes",
-			isCaseSensitive: query.isCaseSensitive
-		}), buildPropertyContentRawPredicate({
+			isCaseSensitive: query.isCaseSensitive,
+			language: query.language,
+			containerElementName: "identification"
+		});
+		case "description": return buildContentTargetIncludesGroupMember({
+			contentNodesExpression: `description/content[@xml:lang="${query.language}"]`,
 			value: query.value,
-			matchMode: "includes",
 			isCaseSensitive: query.isCaseSensitive,
 			language: query.language,
-			excludeInherited: true
-		})])]),
-		buildTokenPredicate: (termsExpression) => buildPropertyPredicateExpression([...predicateParts, buildOrPredicate([buildPropertyRawValueOrTextTokenPredicate({
-			termsExpression,
-			isCaseSensitive: query.isCaseSensitive
-		}), buildPropertyContentTokenPredicate({
-			termsExpression,
+			containerElementName: "description"
+		});
+		case "periods": return buildContentTargetIncludesGroupMember({
+			contentNodesExpression: `periods/period/identification/label/content[@xml:lang="${query.language}"]`,
+			value: query.value,
 			isCaseSensitive: query.isCaseSensitive,
 			language: query.language,
-			excludeInherited: true
-		})])]),
-		buildCandidateTermQuery: (termExpression) => buildOrCtsQueryExpression([
-			buildPropertyRawValueCandidateBranch({
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive
-			}),
-			buildPropertySimpleValueTextCandidateBranch({
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive
-			}),
-			buildPropertyStringCandidateBranch({
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive,
-				language: query.language
-			})
-		])
-	};
-}
-function buildIncludesGroupMember(query) {
-	switch (query.target) {
-		case "string": return buildItemStringIncludesGroupMember(query);
-		case "title":
-		case "description":
-		case "periods":
-		case "bibliography":
-		case "image": return buildContentTargetIncludesGroupMember({ query });
+			containerElementName: "period"
+		});
+		case "bibliography": return buildContentTargetIncludesGroupMember({
+			contentNodesExpression: `bibliographies/bibliography/identification/label/content[@xml:lang="${query.language}"]`,
+			value: query.value,
+			isCaseSensitive: query.isCaseSensitive,
+			language: query.language,
+			containerElementName: "bibliography"
+		});
+		case "image": return buildContentTargetIncludesGroupMember({
+			contentNodesExpression: `image/identification/label/content[@xml:lang="${query.language}"]`,
+			value: query.value,
+			isCaseSensitive: query.isCaseSensitive,
+			language: query.language,
+			containerElementName: "image"
+		});
 		case "property":
-			if (query.dataType === "string") return buildPropertyStringIncludesGroupMember(query);
-			if (query.dataType === "all") return buildPropertyAllIncludesGroupMember(query);
-			return buildPropertyRawValueOrTextIncludesGroupMember(query);
+			if (query.dataType === "all") throw new Error(`Property queries with dataType "all" are not compatible with includes-group optimization`);
+			return buildPropertyStringIncludesGroupMember(query);
 	}
 }
 function getCompatibleIncludesGroupLeaves(params) {
@@ -2820,22 +2734,46 @@ function buildIncludesGroupClause(params) {
 	const groupValue = getGroupableIncludesValue(firstQuery);
 	if (groupValue == null) throw new Error("Cannot build an includes group without a search value");
 	const members = queries.map((query) => buildIncludesGroupMember(query));
-	return buildTokenizedCtsClause({
+	const tokenizedSearchDeclarations = buildTokenizedSearchDeclarations({
 		value: groupValue,
 		isCaseSensitive: firstQuery.isCaseSensitive,
-		queryKey,
-		fallbackPredicate: buildOrPredicate(members.map((member) => member.rawPredicate)),
-		buildTermQueryExpression: (termExpression) => buildOrCtsQueryExpression(members.map((member) => member.buildCandidateTermQuery(termExpression))),
-		buildTokenPredicate: (termsExpression) => buildOrPredicate(members.map((member) => member.buildTokenPredicate(termsExpression)))
+		queryKey
 	});
+	const tokenizedTerms = tokenizeIncludesSearchValue({
+		value: groupValue,
+		isCaseSensitive: firstQuery.isCaseSensitive
+	});
+	const termQueriesVar = `$query${queryKey}TermQueries`;
+	const candidateQueryVar = `$query${queryKey}CandidateQuery`;
+	if (tokenizedTerms.length === 0) return {
+		declarations: [],
+		predicate: buildOrPredicate(members.map((member) => member.rawPredicate)),
+		candidateQueryVar: null
+	};
+	return {
+		declarations: [
+			...tokenizedSearchDeclarations.declarations,
+			`let ${termQueriesVar} :=
+  for $term in ${tokenizedSearchDeclarations.termsVar}
+    return ${buildOrCtsQueryExpression(members.map((member) => member.buildCandidateTermQuery("$term")))}`,
+			`let ${candidateQueryVar} :=
+  if (count(${tokenizedSearchDeclarations.termsVar}) = 1)
+  then ${termQueriesVar}[1]
+  else if (count(${tokenizedSearchDeclarations.termsVar}) gt 1)
+  then cts:and-query(${termQueriesVar})
+  else ()`
+		],
+		predicate: `cts:contains(., ${candidateQueryVar})`,
+		candidateQueryVar
+	};
 }
 /**
 * Build a string match predicate for an XQuery string.
 */
 function buildStringMatchClause(params) {
-	const { contentNodesExpression, value, matchMode, isCaseSensitive, version, queryKey, buildCandidateTermQuery } = params;
+	const { contentNodesExpression, value, matchMode, isCaseSensitive, version, queryKey, allowCtsPredicates, buildCandidateTermQuery } = params;
 	const valueExpression = buildFlattenedContentValuesExpression(contentNodesExpression);
-	if (matchMode === "includes" && version === 2 && buildCandidateTermQuery != null) return buildCtsIncludesPredicate({
+	if (allowCtsPredicates && matchMode === "includes" && version === 2 && buildCandidateTermQuery != null) return buildCtsIncludesPredicate({
 		searchableNodesExpression: buildSearchableContentNodesExpression(contentNodesExpression),
 		fallbackValueExpression: valueExpression,
 		value,
@@ -2854,35 +2792,36 @@ function buildStringMatchClause(params) {
 		candidateQueryVar: null
 	};
 }
-function buildPropertyValueAttributePredicate(params) {
-	const { value, attributeName } = params;
-	return `value[@${attributeName}=${stringLiteral(value)}]`;
-}
-function buildPropertyRawValueOrTextMatchClause(params) {
-	const { value, matchMode, isCaseSensitive, version, queryKey } = params;
-	const fallbackPredicate = buildPropertyRawValueOrTextRawPredicate(params);
-	if (matchMode !== "includes" || version !== 2) return {
+function buildCombinedRawStringMatchClause(params) {
+	const { valueExpressions, value, matchMode, isCaseSensitive, version, queryKey, allowCtsPredicates, buildCandidateTermQuery } = params;
+	const predicate = buildCombinedRawStringMatchPredicate({
+		valueExpressions,
+		value,
+		matchMode,
+		isCaseSensitive
+	});
+	if (allowCtsPredicates && matchMode === "includes" && version === 2 && buildCandidateTermQuery != null) {
+		const candidateQuery = buildCtsCandidateQuery({
+			value,
+			isCaseSensitive,
+			queryKey,
+			buildCandidateTermQuery
+		});
+		return {
+			declarations: candidateQuery.declarations,
+			predicate,
+			candidateQueryVar: candidateQuery.candidateQueryVar
+		};
+	}
+	return {
 		declarations: [],
-		predicate: fallbackPredicate,
+		predicate,
 		candidateQueryVar: null
 	};
-	return buildTokenizedCtsClause({
-		value,
-		isCaseSensitive,
-		queryKey,
-		fallbackPredicate,
-		buildTermQueryExpression: (termExpression) => buildOrCtsQueryExpression([buildPropertyRawValueCandidateBranch({
-			termExpression,
-			isCaseSensitive
-		}), buildPropertySimpleValueTextCandidateBranch({
-			termExpression,
-			isCaseSensitive
-		})]),
-		buildTokenPredicate: (termsExpression) => buildPropertyRawValueOrTextTokenPredicate({
-			termsExpression,
-			isCaseSensitive
-		})
-	});
+}
+function buildPropertyValueAttributePredicate(params) {
+	const { propertyValue, attributeName } = params;
+	return `value[@${attributeName}=${stringLiteral(propertyValue)}]`;
 }
 function buildPropertyPredicateExpression(propertyPredicates) {
 	let propertyExpression = ".//properties//property";
@@ -2890,17 +2829,18 @@ function buildPropertyPredicateExpression(propertyPredicates) {
 	return propertyExpression;
 }
 function buildPropertyStringValueClause(params) {
-	const { query, version, queryKey } = params;
+	const { query, version, queryKey, allowCtsPredicates } = params;
 	return buildStringMatchClause({
-		contentNodesExpression: buildPropertyContentNodesExpression({
+		contentNodesExpression: buildPropertyValueContentNodesExpression({
 			language: query.language,
-			excludeInherited: query.matchMode === "includes" && version === 2
+			excludeInherited: allowCtsPredicates && query.matchMode === "includes" && version === 2
 		}),
 		value: query.value,
 		matchMode: query.matchMode,
 		isCaseSensitive: query.isCaseSensitive,
 		version,
 		queryKey,
+		allowCtsPredicates,
 		buildCandidateTermQuery: (termExpression) => buildPropertyStringCandidateBranch({
 			termExpression,
 			isCaseSensitive: query.isCaseSensitive,
@@ -2908,73 +2848,57 @@ function buildPropertyStringValueClause(params) {
 		})
 	});
 }
-function buildPropertyAllValueClause(params) {
-	const { query, version, queryKey } = params;
-	const excludeInheritedContent = query.matchMode === "includes" && version === 2;
-	const fallbackPredicate = buildOrPredicate([buildPropertyRawValueOrTextRawPredicate({
-		value: query.value,
-		matchMode: query.matchMode,
-		isCaseSensitive: query.isCaseSensitive
-	}), buildPropertyContentRawPredicate({
-		value: query.value,
-		matchMode: query.matchMode,
-		isCaseSensitive: query.isCaseSensitive,
-		language: query.language,
-		excludeInherited: excludeInheritedContent
-	})]);
-	if (query.matchMode !== "includes" || version !== 2) return {
+function buildPropertyScalarValueClause(params) {
+	const { value, matchMode, isCaseSensitive, version, queryKey, allowCtsPredicates } = params;
+	return buildCombinedRawStringMatchClause({
+		valueExpressions: buildPropertyScalarValueExpressions(),
+		value,
+		matchMode,
+		isCaseSensitive,
+		version,
+		queryKey,
+		allowCtsPredicates,
+		buildCandidateTermQuery: (termExpression) => buildPropertyScalarCandidateBranch({
+			termExpression,
+			isCaseSensitive
+		})
+	});
+}
+function buildPropertyAllValueClause(query) {
+	return {
 		declarations: [],
-		predicate: fallbackPredicate,
+		predicate: buildCombinedRawStringMatchPredicate({
+			valueExpressions: buildAllPropertyValueExpressions(query.language),
+			value: query.value,
+			matchMode: query.matchMode,
+			isCaseSensitive: query.isCaseSensitive
+		}),
 		candidateQueryVar: null
 	};
-	return buildTokenizedCtsClause({
-		value: query.value,
-		isCaseSensitive: query.isCaseSensitive,
-		queryKey,
-		fallbackPredicate,
-		buildTermQueryExpression: (termExpression) => buildOrCtsQueryExpression([
-			buildPropertyRawValueCandidateBranch({
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive
-			}),
-			buildPropertySimpleValueTextCandidateBranch({
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive
-			}),
-			buildPropertyStringCandidateBranch({
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive,
-				language: query.language
-			})
-		]),
-		buildTokenPredicate: (termsExpression) => buildOrPredicate([buildPropertyRawValueOrTextTokenPredicate({
-			termsExpression,
-			isCaseSensitive: query.isCaseSensitive
-		}), buildPropertyContentTokenPredicate({
-			termsExpression,
-			isCaseSensitive: query.isCaseSensitive,
-			language: query.language,
-			excludeInherited: true
-		})])
-	});
 }
 /**
 * Build a property predicate for an XQuery string.
 */
 function buildPropertyClause(params) {
-	const { query, version, queryKey } = params;
+	const { query, version, queryKey, allowCtsPredicates } = params;
 	const predicateParts = [];
 	const declarations = [];
 	const propertyVariable = query.propertyVariable;
 	let candidateQueryVar = null;
 	if (propertyVariable != null) predicateParts.push(buildPropertyLabelPredicate(propertyVariable));
-	if (query.dataType === "date" || query.dataType === "dateTime") if ("value" in query && query.value != null) {
-		const compiledScalarClause = buildPropertyRawValueOrTextMatchClause({
+	if (query.dataType === "all") {
+		const compiledAllClause = buildPropertyAllValueClause(query);
+		declarations.push(...compiledAllClause.declarations);
+		predicateParts.push(compiledAllClause.predicate);
+		candidateQueryVar = compiledAllClause.candidateQueryVar;
+	} else if (query.dataType === "date" || query.dataType === "dateTime") if ("value" in query && query.value != null) {
+		const compiledScalarClause = buildPropertyScalarValueClause({
 			value: query.value,
 			matchMode: query.matchMode,
 			isCaseSensitive: query.isCaseSensitive,
 			version,
-			queryKey
+			queryKey,
+			allowCtsPredicates
 		});
 		declarations.push(...compiledScalarClause.declarations);
 		predicateParts.push(compiledScalarClause.predicate);
@@ -2986,31 +2910,21 @@ function buildPropertyClause(params) {
 	else if (query.value != null) switch (query.dataType) {
 		case "IDREF":
 			predicateParts.push(buildPropertyValueAttributePredicate({
-				value: query.value,
+				propertyValue: query.value,
 				attributeName: "uuid"
 			}));
 			break;
-		case "all": {
-			const compiledAllClause = buildPropertyAllValueClause({
-				query,
-				version,
-				queryKey
-			});
-			declarations.push(...compiledAllClause.declarations);
-			predicateParts.push(compiledAllClause.predicate);
-			candidateQueryVar = compiledAllClause.candidateQueryVar;
-			break;
-		}
 		case "integer":
 		case "decimal":
 		case "time":
 		case "boolean": {
-			const compiledScalarClause = buildPropertyRawValueOrTextMatchClause({
+			const compiledScalarClause = buildPropertyScalarValueClause({
 				value: query.value,
 				matchMode: query.matchMode,
 				isCaseSensitive: query.isCaseSensitive,
 				version,
-				queryKey
+				queryKey,
+				allowCtsPredicates
 			});
 			declarations.push(...compiledScalarClause.declarations);
 			predicateParts.push(compiledScalarClause.predicate);
@@ -3021,7 +2935,8 @@ function buildPropertyClause(params) {
 			const compiledStringClause = buildPropertyStringValueClause({
 				query,
 				version,
-				queryKey
+				queryKey,
+				allowCtsPredicates
 			});
 			declarations.push(...compiledStringClause.declarations);
 			predicateParts.push(compiledStringClause.predicate);
@@ -3039,38 +2954,94 @@ function buildPropertyClause(params) {
 * Build a query predicate for an XQuery string.
 */
 function buildQueryClause(params) {
-	const { query, version, queryKey } = params;
+	const { query, version, queryKey, allowCtsPredicates } = params;
 	switch (query.target) {
 		case "string": return buildItemStringSearchClause({
 			query,
 			version,
-			queryKey
+			queryKey,
+			allowCtsPredicates
 		});
-		case "title":
-		case "description":
-		case "periods":
-		case "bibliography":
-		case "image": {
-			const config = getContentTargetConfig(query.target);
-			return buildStringMatchClause({
-				contentNodesExpression: config.getContentNodesExpression(query.language),
-				value: query.value,
-				matchMode: query.matchMode,
+		case "title": return buildStringMatchClause({
+			contentNodesExpression: `identification/label/content[@xml:lang="${query.language}"]`,
+			value: query.value,
+			matchMode: query.matchMode,
+			isCaseSensitive: query.isCaseSensitive,
+			version,
+			queryKey,
+			allowCtsPredicates,
+			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
+				containerElementName: "identification",
+				termExpression,
 				isCaseSensitive: query.isCaseSensitive,
-				version,
-				queryKey,
-				buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
-					containerElementName: config.containerElementName,
-					termExpression,
-					isCaseSensitive: query.isCaseSensitive,
-					language: query.language
-				})
-			});
-		}
+				language: query.language
+			})
+		});
+		case "description": return buildStringMatchClause({
+			contentNodesExpression: `description/content[@xml:lang="${query.language}"]`,
+			value: query.value,
+			matchMode: query.matchMode,
+			isCaseSensitive: query.isCaseSensitive,
+			version,
+			queryKey,
+			allowCtsPredicates,
+			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
+				containerElementName: "description",
+				termExpression,
+				isCaseSensitive: query.isCaseSensitive,
+				language: query.language
+			})
+		});
+		case "periods": return buildStringMatchClause({
+			contentNodesExpression: `periods/period/identification/label/content[@xml:lang="${query.language}"]`,
+			value: query.value,
+			matchMode: query.matchMode,
+			isCaseSensitive: query.isCaseSensitive,
+			version,
+			queryKey,
+			allowCtsPredicates,
+			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
+				containerElementName: "period",
+				termExpression,
+				isCaseSensitive: query.isCaseSensitive,
+				language: query.language
+			})
+		});
+		case "bibliography": return buildStringMatchClause({
+			contentNodesExpression: `bibliographies/bibliography/identification/label/content[@xml:lang="${query.language}"]`,
+			value: query.value,
+			matchMode: query.matchMode,
+			isCaseSensitive: query.isCaseSensitive,
+			version,
+			queryKey,
+			allowCtsPredicates,
+			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
+				containerElementName: "bibliography",
+				termExpression,
+				isCaseSensitive: query.isCaseSensitive,
+				language: query.language
+			})
+		});
+		case "image": return buildStringMatchClause({
+			contentNodesExpression: `image/identification/label/content[@xml:lang="${query.language}"]`,
+			value: query.value,
+			matchMode: query.matchMode,
+			isCaseSensitive: query.isCaseSensitive,
+			version,
+			queryKey,
+			allowCtsPredicates,
+			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
+				containerElementName: "image",
+				termExpression,
+				isCaseSensitive: query.isCaseSensitive,
+				language: query.language
+			})
+		});
 		case "property": return buildPropertyClause({
 			query,
 			version,
-			queryKey
+			queryKey,
+			allowCtsPredicates
 		});
 	}
 }
@@ -3078,11 +3049,12 @@ function buildQueryClause(params) {
 * Build a boolean query clause for an XQuery string.
 */
 function buildBooleanQueryNode(params) {
-	const { query, version, queryKey } = params;
+	const { query, version, queryKey, allowCtsPredicates } = params;
 	const compiledQueryClause = buildQueryClause({
 		query,
 		version,
-		queryKey
+		queryKey,
+		allowCtsPredicates
 	});
 	const baseClause = `(${compiledQueryClause.predicate})`;
 	return {
@@ -3092,11 +3064,12 @@ function buildBooleanQueryNode(params) {
 	};
 }
 function buildQueryNode(params) {
-	const { query, version, queryKey } = params;
+	const { query, version, queryKey, allowCtsPredicates } = params;
 	if (isQueryLeaf(query)) return buildBooleanQueryNode({
 		query,
 		version,
-		queryKey
+		queryKey,
+		allowCtsPredicates
 	});
 	const groupQueries = getQueryGroupChildren(query);
 	const optimizedIncludesGroupQueries = getCompatibleIncludesGroupLeaves({
@@ -3113,10 +3086,11 @@ function buildQueryNode(params) {
 		return buildQueryNode({
 			query: onlyQuery,
 			version,
-			queryKey
+			queryKey,
+			allowCtsPredicates
 		});
 	}
-	if (optimizedIncludesGroupQueries != null) {
+	if (allowCtsPredicates && optimizedIncludesGroupQueries != null) {
 		const compiledClause = buildIncludesGroupClause({
 			queries: optimizedIncludesGroupQueries,
 			queryKey
@@ -3129,20 +3103,29 @@ function buildQueryNode(params) {
 	}
 	const declarations = [];
 	const predicates = [];
-	const candidateQueryVars = [];
-	for (const [groupIndex, groupQuery] of groupQueries.entries()) {
-		const compiledQueryNode = buildQueryNode({
-			query: groupQuery,
-			version,
-			queryKey: `${queryKey}_${groupIndex + 1}`
-		});
+	const groupOperator = getQueryGroupOperator(query);
+	let compiledChildNodes = groupQueries.map((groupQuery, groupIndex) => buildQueryNode({
+		query: groupQuery,
+		version,
+		queryKey: `${queryKey}_${groupIndex + 1}`,
+		allowCtsPredicates
+	}));
+	if (allowCtsPredicates && groupOperator === "or" && compiledChildNodes.some((node) => node.candidateQueryVars.length === 0)) compiledChildNodes = groupQueries.map((groupQuery, groupIndex) => buildQueryNode({
+		query: groupQuery,
+		version,
+		queryKey: `${queryKey}_${groupIndex + 1}`,
+		allowCtsPredicates: false
+	}));
+	const candidateQueryVarsByChild = [];
+	for (const compiledQueryNode of compiledChildNodes) {
 		declarations.push(...compiledQueryNode.declarations);
 		predicates.push(compiledQueryNode.predicate);
-		candidateQueryVars.push(...compiledQueryNode.candidateQueryVars);
+		candidateQueryVarsByChild.push(compiledQueryNode.candidateQueryVars);
 	}
+	const candidateQueryVars = groupOperator === "and" ? candidateQueryVarsByChild.flat() : candidateQueryVarsByChild.every((vars) => vars.length > 0) ? candidateQueryVarsByChild.flat() : [];
 	return {
 		declarations,
-		predicate: getQueryGroupOperator(query) === "and" ? buildAndPredicate(predicates) : buildOrPredicate(predicates),
+		predicate: groupOperator === "and" ? buildAndPredicate(predicates) : buildOrPredicate(predicates),
 		candidateQueryVars
 	};
 }
@@ -3155,7 +3138,8 @@ function buildQueryPlan(params) {
 		const compiledQueryNode = buildQueryNode({
 			query: queries,
 			version,
-			queryKey: "1"
+			queryKey: "1",
+			allowCtsPredicates: true
 		});
 		if (compiledQueryNode.declarations.length > 0) declarations.push(`let ${CTS_INCLUDES_STOP_WORDS_VAR} := (${CTS_INCLUDES_STOP_WORDS.map((stopWord) => stringLiteral(stopWord)).join(", ")})`, ...compiledQueryNode.declarations);
 		predicate = compiledQueryNode.predicate;
@@ -3336,7 +3320,7 @@ async function fetchSetItems(params, itemCategories, options) {
 		else response = await (options?.fetch ?? fetch)(`https://ochre.lib.uchicago.edu/ochre?xquery=${encodeURIComponent(xquery)}&format=json&lang="*"`);
 		if (!response.ok) throw new Error(`OCHRE API responded with status: ${response.status}`);
 		const data = await response.json();
-		if (Array.isArray(data.result) || Object.keys(data.result).length === 0) throw new Error("No items found");
+		if (Array.isArray(data.result) || Object.keys(data.result).length === 0) throw new Error("Invalid OCHRE API response");
 		if (itemCategories != null) {
 			const itemCategoriesSet = new Set(Object.keys(data.result.ochre.items));
 			const missingCategories = itemCategories.filter((category) => !itemCategoriesSet.has(category));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ochre-sdk",
-  "version": "0.21.6",
+  "version": "0.21.7",
   "type": "module",
   "license": "MIT",
   "description": "Node.js library for working with OCHRE (Online Cultural and Historical Research Environment) data",
@@ -46,8 +46,8 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^7.7.3",
-    "@types/node": "^24.12.0",
+    "@antfu/eslint-config": "^8.0.0",
+    "@types/node": "^24.12.2",
     "bumpp": "^11.0.1",
     "eslint": "^10.1.0",
     "prettier": "^3.8.1",