ochre-sdk 0.21.5 → 0.21.7

package/dist/index.d.mts

@@ -677,7 +677,7 @@ type QueryLeaf = {
   target: "property";
   propertyVariable?: string;
   dataType: Exclude<Exclude<PropertyValueContentType, "coordinate">, "date" | "dateTime">;
-  propertyValues?: Array<string>;
+  value?: string;
   from?: never;
   to?: never;
   matchMode: "includes" | "exact";
@@ -688,7 +688,6 @@ type QueryLeaf = {
   target: "property";
   propertyVariable: string;
   dataType: "date" | "dateTime";
-  propertyValues?: never;
   value: string;
   from?: never;
   to?: never;
@@ -700,7 +699,6 @@ type QueryLeaf = {
   target: "property";
   propertyVariable: string;
   dataType: "date" | "dateTime";
-  propertyValues?: never;
   value?: never;
   from: string;
   to?: string;
@@ -712,7 +710,6 @@ type QueryLeaf = {
   target: "property";
   propertyVariable: string;
   dataType: "date" | "dateTime";
-  propertyValues?: never;
   value?: never;
   from?: string;
   to: string;
@@ -720,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;

package/dist/index.mjs

@@ -768,15 +768,15 @@ const setQueryLeafSchema = z.union([
 			"time",
 			"IDREF"
 		]),
-		propertyValues: z.array(z.string()).min(1, "At least one property value is required").optional(),
+		value: z.string().optional(),
 		matchMode: z.enum(["includes", "exact"]),
 		isCaseSensitive: z.boolean(),
 		language: z.string().default("eng"),
 		isNegated: z.boolean().optional().default(false)
 	}).strict().superRefine((value, ctx) => {
-		if (value.propertyVariable == null && value.propertyValues == null) ctx.addIssue({
+		if (value.propertyVariable == null && value.value == null) ctx.addIssue({
 			code: "custom",
-			message: "Property queries must include at least one propertyVariable or propertyValue"
+			message: "Property queries must include at least one propertyVariable or value"
 		});
 	}),
 	z.object({
@@ -815,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(),
@@ -2172,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 (
@@ -2190,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.
@@ -2210,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.
@@ -2221,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.
@@ -2268,8 +2332,8 @@ function buildTokenizedSearchDeclarations(params) {
 		termsVar
 	};
 }
-function buildCtsIncludesPredicate(params) {
-	const { searchableNodesExpression, fallbackValueExpression, value, isCaseSensitive, queryKey, buildCandidateTermQuery } = params;
+function buildCtsCandidateQuery(params) {
+	const { value, isCaseSensitive, queryKey, buildCandidateTermQuery } = params;
 	const tokenizedSearchDeclarations = buildTokenizedSearchDeclarations({
 		value,
 		isCaseSensitive,
@@ -2277,18 +2341,12 @@ function buildCtsIncludesPredicate(params) {
 	});
 	const termQueriesVar = `$query${queryKey}TermQueries`;
 	const candidateQueryVar = `$query${queryKey}CandidateQuery`;
-	const fallbackPredicate = buildRawStringMatchPredicate({
-		valueExpression: fallbackValueExpression,
-		value,
-		matchMode: "includes",
-		isCaseSensitive
-	});
 	if (tokenizeIncludesSearchValue({
 		value,
 		isCaseSensitive
 	}).length === 0) return {
 		declarations: [],
-		predicate: fallbackPredicate,
+		termsVar: tokenizedSearchDeclarations.termsVar,
 		candidateQueryVar: null
 	};
 	return {
@@ -2304,14 +2362,43 @@ function buildCtsIncludesPredicate(params) {
   then cts:and-query(${termQueriesVar})
   else ()`
 		],
-		predicate: buildTokenizedSearchPredicate({
-			searchableNodesExpression,
-			termsExpression: tokenizedSearchDeclarations.termsVar,
-			isCaseSensitive
-		}),
+		termsVar: tokenizedSearchDeclarations.termsVar,
 		candidateQueryVar
 	};
 }
+function buildCtsIncludesPredicate(params) {
+	const { searchableNodesExpression, fallbackValueExpression, value, isCaseSensitive, queryKey, buildCandidateTermQuery } = params;
+	const candidateQuery = buildCtsCandidateQuery({
+		value,
+		isCaseSensitive,
+		queryKey,
+		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.
 */
@@ -2364,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
@@ -2468,75 +2555,28 @@ function buildPropertyStringCandidateBranch(params) {
         )
       )`;
 }
-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 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 getGroupableIncludesValue(query) {
 	switch (query.target) {
 		case "string":
@@ -2546,14 +2586,8 @@ function getGroupableIncludesValue(query) {
 		case "periods":
 		case "bibliography": return query.value;
 		case "property":
-			if (query.dataType === "string") {
-				if (query.propertyValues?.length !== 1) return null;
-				return query.propertyValues[0] ?? null;
-			}
-			if (query.dataType === "IDREF") return null;
-			if (query.dataType === "date" || query.dataType === "dateTime") return "value" in query && query.value != null ? query.value : null;
-			if (query.propertyValues?.length !== 1) return null;
-			return query.propertyValues[0] ?? null;
+			if (query.dataType !== "string" || query.value == null) return null;
+			return query.value;
 	}
 }
 function isCompatibleIncludesGroupQuery(params) {
@@ -2571,11 +2605,6 @@ function buildContentTargetIncludesGroupMember(params) {
 			matchMode: "includes",
 			isCaseSensitive
 		}),
-		buildTokenPredicate: (termsExpression) => buildTokenizedSearchPredicate({
-			searchableNodesExpression: buildSearchableContentNodesExpression(contentNodesExpression),
-			termsExpression,
-			isCaseSensitive
-		}),
 		buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
 			containerElementName,
 			termExpression,
@@ -2592,11 +2621,6 @@ function buildItemStringIncludesGroupMember(query) {
 			matchMode: "includes",
 			isCaseSensitive: query.isCaseSensitive
 		}),
-		buildTokenPredicate: (termsExpression) => buildTokenizedSearchPredicate({
-			searchableNodesExpression: buildItemStringSearchableNodesExpression(query.language),
-			termsExpression,
-			isCaseSensitive: query.isCaseSensitive
-		}),
 		buildCandidateTermQuery: (termExpression) => `cts:or-query((
         ${buildItemStringIdentificationBranch({
 			termExpression,
@@ -2614,22 +2638,18 @@ function buildItemStringIncludesGroupMember(query) {
 function buildPropertyStringIncludesGroupMember(query) {
 	const propertyVariable = query.propertyVariable;
 	const predicateParts = [];
-	const propertyContentNodesExpression = `value[not(@inherited="true")]/content[@xml:lang="${query.language}"]`;
-	const valueExpression = buildFlattenedContentValuesExpression(propertyContentNodesExpression);
-	const propertyValue = query.propertyValues[0] ?? "";
+	const valueExpression = buildPropertyValueContentValuesExpression({
+		language: query.language,
+		excludeInherited: true
+	});
 	if (propertyVariable != null) predicateParts.push(buildPropertyLabelPredicate(propertyVariable));
 	return {
 		rawPredicate: buildPropertyPredicateExpression([...predicateParts, buildRawStringMatchPredicate({
 			valueExpression,
-			value: propertyValue,
+			value: query.value,
 			matchMode: "includes",
 			isCaseSensitive: query.isCaseSensitive
 		})]),
-		buildTokenPredicate: (termsExpression) => buildPropertyPredicateExpression([...predicateParts, buildTokenizedSearchPredicate({
-			searchableNodesExpression: buildSearchableContentNodesExpression(propertyContentNodesExpression),
-			termsExpression,
-			isCaseSensitive: query.isCaseSensitive
-		})]),
 		buildCandidateTermQuery: (termExpression) => buildPropertyStringCandidateBranch({
 			termExpression,
 			isCaseSensitive: query.isCaseSensitive,
@@ -2637,31 +2657,6 @@ function buildPropertyStringIncludesGroupMember(query) {
 		})
 	};
 }
-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 buildIncludesGroupMember(query) {
 	switch (query.target) {
 		case "string": return buildItemStringIncludesGroupMember(query);
@@ -2701,8 +2696,8 @@ function buildIncludesGroupMember(query) {
 			containerElementName: "image"
 		});
 		case "property":
-			if (query.dataType === "string") return buildPropertyStringIncludesGroupMember(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) {
@@ -2768,7 +2763,7 @@ function buildIncludesGroupClause(params) {
   then cts:and-query(${termQueriesVar})
   else ()`
 		],
-		predicate: buildOrPredicate(members.map((member) => member.buildTokenPredicate(tokenizedSearchDeclarations.termsVar))),
+		predicate: `cts:contains(., ${candidateQueryVar})`,
 		candidateQueryVar
 	};
 }
@@ -2776,9 +2771,9 @@ function buildIncludesGroupClause(params) {
 * 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,
@@ -2797,163 +2792,113 @@ function buildStringMatchClause(params) {
 		candidateQueryVar: null
 	};
 }
-function buildPropertyValueAttributePredicate(params) {
-	const { propertyValues, attributeName } = params;
-	const valuePredicates = [];
-	for (const propertyValue of propertyValues) valuePredicates.push(`value[@${attributeName}=${stringLiteral(propertyValue)}]`);
-	return buildOrPredicate(valuePredicates);
-}
-function buildPropertyRawValueOrTextMatchClause(params) {
-	const { value, matchMode, isCaseSensitive, version, queryKey } = params;
-	const fallbackPredicate = buildPropertyRawValueOrTextRawPredicate({
+function buildCombinedRawStringMatchClause(params) {
+	const { valueExpressions, value, matchMode, isCaseSensitive, version, queryKey, allowCtsPredicates, buildCandidateTermQuery } = params;
+	const predicate = buildCombinedRawStringMatchPredicate({
+		valueExpressions,
 		value,
 		matchMode,
 		isCaseSensitive
 	});
-	if (matchMode !== "includes" || version !== 2) return {
-		declarations: [],
-		predicate: fallbackPredicate,
-		candidateQueryVar: null
-	};
-	const tokenizedSearchDeclarations = buildTokenizedSearchDeclarations({
-		value,
-		isCaseSensitive,
-		queryKey
-	});
-	const tokenizedTerms = tokenizeIncludesSearchValue({
-		value,
-		isCaseSensitive
-	});
-	const termQueriesVar = `$query${queryKey}TermQueries`;
-	const candidateQueryVar = `$query${queryKey}CandidateQuery`;
-	if (tokenizedTerms.length === 0) return {
-		declarations: [],
-		predicate: fallbackPredicate,
-		candidateQueryVar: null
-	};
-	return {
-		declarations: [
-			...tokenizedSearchDeclarations.declarations,
-			`let ${termQueriesVar} :=
-  for $term in ${tokenizedSearchDeclarations.termsVar}
-    return ${buildOrCtsQueryExpression([buildPropertyRawValueCandidateBranch({
-				termExpression: "$term",
-				isCaseSensitive
-			}), buildPropertySimpleValueTextCandidateBranch({
-				termExpression: "$term",
-				isCaseSensitive
-			})])}`,
-			`let ${candidateQueryVar} :=
-  if (count(${tokenizedSearchDeclarations.termsVar}) = 1)
-  then ${termQueriesVar}[1]
-  else if (count(${tokenizedSearchDeclarations.termsVar}) gt 1)
-  then cts:and-query(${termQueriesVar})
-  else ()`
-		],
-		predicate: buildPropertyRawValueOrTextTokenPredicate({
-			termsExpression: tokenizedSearchDeclarations.termsVar,
-			isCaseSensitive
-		}),
-		candidateQueryVar
-	};
-}
-function buildPropertyRawValueOrTextClause(params) {
-	const { values, matchMode, isCaseSensitive, version, queryKey } = params;
-	const declarations = [];
-	const valuePredicates = [];
-	const candidateQueryVars = [];
-	for (const [valueIndex, value] of values.entries()) {
-		const compiledClause = buildPropertyRawValueOrTextMatchClause({
+	if (allowCtsPredicates && matchMode === "includes" && version === 2 && buildCandidateTermQuery != null) {
+		const candidateQuery = buildCtsCandidateQuery({
 			value,
-			matchMode,
 			isCaseSensitive,
-			version,
-			queryKey: `${queryKey}_${valueIndex + 1}`
+			queryKey,
+			buildCandidateTermQuery
 		});
-		declarations.push(...compiledClause.declarations);
-		valuePredicates.push(compiledClause.predicate);
-		if (compiledClause.candidateQueryVar != null) candidateQueryVars.push(compiledClause.candidateQueryVar);
-	}
-	let candidateQueryVar = null;
-	if (candidateQueryVars.length > 0) {
-		const candidateQueriesExpression = `(${candidateQueryVars.join(", ")})`;
-		candidateQueryVar = `$query${queryKey}CandidateQuery`;
-		declarations.push(`let ${candidateQueryVar} :=
-  if (count(${candidateQueriesExpression}) = 1)
-  then ${candidateQueriesExpression}[1]
-  else if (count(${candidateQueriesExpression}) gt 1)
-  then cts:or-query(${candidateQueriesExpression})
-  else ()`);
+		return {
+			declarations: candidateQuery.declarations,
+			predicate,
+			candidateQueryVar: candidateQuery.candidateQueryVar
+		};
 	}
 	return {
-		declarations,
-		predicate: buildOrPredicate(valuePredicates),
-		candidateQueryVar
+		declarations: [],
+		predicate,
+		candidateQueryVar: null
 	};
 }
+function buildPropertyValueAttributePredicate(params) {
+	const { propertyValue, attributeName } = params;
+	return `value[@${attributeName}=${stringLiteral(propertyValue)}]`;
+}
 function buildPropertyPredicateExpression(propertyPredicates) {
 	let propertyExpression = ".//properties//property";
 	for (const propertyPredicate of propertyPredicates) propertyExpression += `[${propertyPredicate}]`;
 	return propertyExpression;
 }
 function buildPropertyStringValueClause(params) {
-	const { query, version, queryKey } = params;
-	const propertyContentNodesExpression = query.matchMode === "includes" && version === 2 ? `value[not(@inherited="true")]/content[@xml:lang="${query.language}"]` : `value/content[@xml:lang="${query.language}"]`;
-	const declarations = [];
-	const valuePredicates = [];
-	const candidateQueryVars = [];
-	for (const [propertyValueIndex, propertyValue] of query.propertyValues.entries()) {
-		const compiledStringClause = buildStringMatchClause({
-			contentNodesExpression: propertyContentNodesExpression,
-			value: propertyValue,
-			matchMode: query.matchMode,
+	const { query, version, queryKey, allowCtsPredicates } = params;
+	return buildStringMatchClause({
+		contentNodesExpression: buildPropertyValueContentNodesExpression({
+			language: query.language,
+			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,
-			version,
-			queryKey: `${queryKey}_${propertyValueIndex + 1}`,
-			buildCandidateTermQuery: (termExpression) => buildPropertyStringCandidateBranch({
-				termExpression,
-				isCaseSensitive: query.isCaseSensitive,
-				language: query.language
-			})
-		});
-		declarations.push(...compiledStringClause.declarations);
-		valuePredicates.push(compiledStringClause.predicate);
-		if (compiledStringClause.candidateQueryVar != null) candidateQueryVars.push(compiledStringClause.candidateQueryVar);
-	}
-	let candidateQueryVar = null;
-	if (candidateQueryVars.length > 0) {
-		const candidateQueriesExpression = `(${candidateQueryVars.join(", ")})`;
-		candidateQueryVar = `$query${queryKey}CandidateQuery`;
-		declarations.push(`let ${candidateQueryVar} :=
-  if (count(${candidateQueriesExpression}) = 1)
-  then ${candidateQueriesExpression}[1]
-  else if (count(${candidateQueriesExpression}) gt 1)
-  then cts:or-query(${candidateQueriesExpression})
-  else ()`);
-	}
+			language: query.language
+		})
+	});
+}
+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: buildOrPredicate(valuePredicates),
-		candidateQueryVar
+		declarations: [],
+		predicate: buildCombinedRawStringMatchPredicate({
+			valueExpressions: buildAllPropertyValueExpressions(query.language),
+			value: query.value,
+			matchMode: query.matchMode,
+			isCaseSensitive: query.isCaseSensitive
+		}),
+		candidateQueryVar: null
 	};
 }
 /**
 * 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 = buildPropertyRawValueOrTextClause({
-			values: [query.value],
+	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);
@@ -2962,10 +2907,10 @@ function buildPropertyClause(params) {
 		from: query.from,
 		to: query.to
 	}));
-	else if (query.propertyValues != null) switch (query.dataType) {
+	else if (query.value != null) switch (query.dataType) {
 		case "IDREF":
 			predicateParts.push(buildPropertyValueAttributePredicate({
-				propertyValues: query.propertyValues,
+				propertyValue: query.value,
 				attributeName: "uuid"
 			}));
 			break;
@@ -2973,12 +2918,13 @@ function buildPropertyClause(params) {
 		case "decimal":
 		case "time":
 		case "boolean": {
-			const compiledScalarClause = buildPropertyRawValueOrTextClause({
-				values: query.propertyValues,
+			const compiledScalarClause = buildPropertyScalarValueClause({
+				value: query.value,
 				matchMode: query.matchMode,
 				isCaseSensitive: query.isCaseSensitive,
 				version,
-				queryKey
+				queryKey,
+				allowCtsPredicates
 			});
 			declarations.push(...compiledScalarClause.declarations);
 			predicateParts.push(compiledScalarClause.predicate);
@@ -2989,7 +2935,8 @@ function buildPropertyClause(params) {
 			const compiledStringClause = buildPropertyStringValueClause({
 				query,
 				version,
-				queryKey
+				queryKey,
+				allowCtsPredicates
 			});
 			declarations.push(...compiledStringClause.declarations);
 			predicateParts.push(compiledStringClause.predicate);
@@ -3007,12 +2954,13 @@ 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": return buildStringMatchClause({
 			contentNodesExpression: `identification/label/content[@xml:lang="${query.language}"]`,
@@ -3021,6 +2969,7 @@ function buildQueryClause(params) {
 			isCaseSensitive: query.isCaseSensitive,
 			version,
 			queryKey,
+			allowCtsPredicates,
 			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
 				containerElementName: "identification",
 				termExpression,
@@ -3035,6 +2984,7 @@ function buildQueryClause(params) {
 			isCaseSensitive: query.isCaseSensitive,
 			version,
 			queryKey,
+			allowCtsPredicates,
 			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
 				containerElementName: "description",
 				termExpression,
@@ -3049,6 +2999,7 @@ function buildQueryClause(params) {
 			isCaseSensitive: query.isCaseSensitive,
 			version,
 			queryKey,
+			allowCtsPredicates,
 			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
 				containerElementName: "period",
 				termExpression,
@@ -3063,6 +3014,7 @@ function buildQueryClause(params) {
 			isCaseSensitive: query.isCaseSensitive,
 			version,
 			queryKey,
+			allowCtsPredicates,
 			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
 				containerElementName: "bibliography",
 				termExpression,
@@ -3077,6 +3029,7 @@ function buildQueryClause(params) {
 			isCaseSensitive: query.isCaseSensitive,
 			version,
 			queryKey,
+			allowCtsPredicates,
 			buildCandidateTermQuery: (termExpression) => buildContentTargetCandidateBranch({
 				containerElementName: "image",
 				termExpression,
@@ -3087,7 +3040,8 @@ function buildQueryClause(params) {
 		case "property": return buildPropertyClause({
 			query,
 			version,
-			queryKey
+			queryKey,
+			allowCtsPredicates
 		});
 	}
 }
@@ -3095,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 {
@@ -3109,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({
@@ -3130,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
@@ -3146,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
 	};
 }
@@ -3172,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;
@@ -3353,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.5",
+  "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",