@fastybird/smart-panel-backend 1.0.0-beta.3 → 1.1.0-alpha.1

package/dist/modules/buddy/services/context-planner/buddy-context-message-analysis.js

@@ -0,0 +1,673 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getActionMessage = getActionMessage;
+exports.getActionReferenceMessage = getActionReferenceMessage;
+exports.classifyDomains = classifyDomains;
+exports.hasDomainSignalOutsideEntityName = hasDomainSignalOutsideEntityName;
+exports.hasEnergyReadClause = hasEnergyReadClause;
+exports.getEnergyReadClauses = getEnergyReadClauses;
+exports.getMessageEnergyReadClauses = getMessageEnergyReadClauses;
+exports.isEnergyEllipsisReadClause = isEnergyEllipsisReadClause;
+exports.hasDirectEnergyReadClause = hasDirectEnergyReadClause;
+exports.isPowerStateRead = isPowerStateRead;
+exports.hasPowerStateReadSegment = hasPowerStateReadSegment;
+exports.isPowerEventStateRead = isPowerEventStateRead;
+exports.hasDomainSignalInClause = hasDomainSignalInClause;
+exports.isScopedIndoorFutureTemperatureClause = isScopedIndoorFutureTemperatureClause;
+exports.hasHistorySignalInClause = hasHistorySignalInClause;
+exports.splitPlannerClauses = splitPlannerClauses;
+exports.mergeLeadingTemporalAdjuncts = mergeLeadingTemporalAdjuncts;
+exports.mergeActionTargetDurationContinuations = mergeActionTargetDurationContinuations;
+exports.getActionClausesWithTargetContinuations = getActionClausesWithTargetContinuations;
+exports.getActionSourceClausesWithTargetContinuations = getActionSourceClausesWithTargetContinuations;
+exports.getActionClauseSelection = getActionClauseSelection;
+exports.hasActionTargetContinuationValue = hasActionTargetContinuationValue;
+exports.findConjoinedSpaceTargetRanges = findConjoinedSpaceTargetRanges;
+exports.hasCurrentStateReadClause = hasCurrentStateReadClause;
+exports.hasHomeStateReadClause = hasHomeStateReadClause;
+exports.hasHomeActionConditionClause = hasHomeActionConditionClause;
+exports.hasSupportedActionConditionClause = hasSupportedActionConditionClause;
+exports.isGeneralExplanation = isGeneralExplanation;
+exports.hasOnlyGroundedActionTokens = hasOnlyGroundedActionTokens;
+exports.isStatePredicateQuestion = isStatePredicateQuestion;
+exports.resolveConjoinedTemporalSpaceIds = resolveConjoinedTemporalSpaceIds;
+exports.expandCoordinatedTemporalPropertySpaceIds = expandCoordinatedTemporalPropertySpaceIds;
+exports.resolveConjoinedEnergySpaceIds = resolveConjoinedEnergySpaceIds;
+exports.expandConjoinedSpaceIds = expandConjoinedSpaceIds;
+exports.resolveTemporalExplicitSpaceIds = resolveTemporalExplicitSpaceIds;
+const buddy_context_language_1 = require("./buddy-context-language");
+const buddy_context_planner_grammar_1 = require("./buddy-context-planner-grammar");
+const INDEPENDENT_ALTERNATIVE_AUXILIARY_PATTERN = new RegExp(String.raw `^\s*${buddy_context_language_1.CONDITIONAL_OUTCOME_AUXILIARY_PATTERN_SOURCE}\s+`, 'u');
+const INDEPENDENT_ALTERNATIVE_DETERMINED_SUBJECT_PATTERN = new RegExp(String.raw `^(?:a|an|her|his|its|my|our|the|their|this|these|those|your|${buddy_context_planner_grammar_1.AGGREGATE_SUBJECT_QUANTIFIER_PATTERN_SOURCE})\s+[\p{Letter}\p{Number}'’-]+\b`, 'u');
+const INDEPENDENT_ALTERNATIVE_PRONOUN_SUBJECT_PATTERN = /^(?:anybody|anyone|everybody|everyone|he|i|it|nobody|no\s+one|she|somebody|someone|there|they|we|you)\b/u;
+const INDEPENDENT_ALTERNATIVE_INTERROGATIVE_PATTERN_SOURCE = String.raw `(?:how\s+many|what|which)\s+[\p{Letter}\p{Number}'’-]+\b`;
+const INDEPENDENT_ALTERNATIVE_INTERROGATIVE_PATTERN = new RegExp(String.raw `^${INDEPENDENT_ALTERNATIVE_INTERROGATIVE_PATTERN_SOURCE}`, 'u');
+const INDEPENDENT_ALTERNATIVE_CONNECTOR_PATTERN_SOURCE = String.raw `(?:but|or|yet)`;
+const INDEPENDENT_ALTERNATIVE_CONNECTOR_PATTERN = new RegExp(String.raw `\b${INDEPENDENT_ALTERNATIVE_CONNECTOR_PATTERN_SOURCE}$`, 'u');
+const INDEPENDENT_ALTERNATIVE_BARE_HOME_STATE_SUBJECT_PATTERN = new RegExp(String.raw `^${buddy_context_planner_grammar_1.HOME_STATE_PATTERN.source}`, 'u');
+const INDEPENDENT_ALTERNATIVE_BARE_HOME_SUBJECT_PATTERN = new RegExp(String.raw `^(?:${buddy_context_planner_grammar_1.AGGREGATE_DEVICE_CATEGORY_PATTERN_SOURCE}|${buddy_context_planner_grammar_1.DEVICE_ACTION_TARGET_PATTERN.source}|${buddy_context_planner_grammar_1.HOME_ENTITY_PATTERN.source}|${buddy_context_planner_grammar_1.PLAUSIBLE_CUSTOM_HOME_TARGET_PATTERN.source}|${buddy_context_planner_grammar_1.SECURITY_SUBJECT_PATTERN.source})\b`, 'u');
+const INDEPENDENT_ALTERNATIVE_BARE_DOMAIN_SUBJECT_PATTERN = new RegExp(String.raw `^(?:${buddy_context_planner_grammar_1.ENERGY_PATTERN.source}|${buddy_context_planner_grammar_1.WEATHER_PATTERN.source})`, 'u');
+const INDEPENDENT_ALTERNATIVE_NAMED_OUTCOME_SUBJECT_PATTERN = new RegExp(String.raw `^(?:[\p{Letter}\p{Number}'’-]+\s+){1,4}(?:(?:already|currently|still)\s+)?${buddy_context_planner_grammar_1.OUTCOME_PREDICATE_PATTERN_SOURCE}\b`, 'u');
+const INDEPENDENT_ALTERNATIVE_SUBJECTLESS_PREDICATE_PATTERN = new RegExp(String.raw `^${buddy_context_planner_grammar_1.SUBJECTLESS_POWER_PREDICATE_PATTERN_SOURCE}\b`, 'u');
+const INDEPENDENT_ALTERNATIVE_SUBJECTLESS_MODAL_PATTERN = /^(?:can(?:not|'t)?|could(?:n't)?|may|might(?:n't)?|must(?:n't)?|ought(?:n't)?|shall|shan't|should(?:n't)?|will|won't|would(?:n't)?)$/u;
+function hasIndependentAlternativeSubject(alternative, explicitSpaces) {
+    if (INDEPENDENT_ALTERNATIVE_INTERROGATIVE_PATTERN.test(alternative.trimStart()))
+        return true;
+    const auxiliaryMatch = INDEPENDENT_ALTERNATIVE_AUXILIARY_PATTERN.exec(alternative);
+    if (!auxiliaryMatch)
+        return false;
+    const subject = alternative.slice(auxiliaryMatch[0].length);
+    if (INDEPENDENT_ALTERNATIVE_SUBJECTLESS_MODAL_PATTERN.test(auxiliaryMatch[0].trim()) &&
+        INDEPENDENT_ALTERNATIVE_SUBJECTLESS_PREDICATE_PATTERN.test(subject)) {
+        return false;
+    }
+    return (INDEPENDENT_ALTERNATIVE_DETERMINED_SUBJECT_PATTERN.test(subject) ||
+        INDEPENDENT_ALTERNATIVE_PRONOUN_SUBJECT_PATTERN.test(subject) ||
+        INDEPENDENT_ALTERNATIVE_BARE_HOME_STATE_SUBJECT_PATTERN.test(subject) ||
+        INDEPENDENT_ALTERNATIVE_BARE_HOME_SUBJECT_PATTERN.test(subject) ||
+        INDEPENDENT_ALTERNATIVE_BARE_DOMAIN_SUBJECT_PATTERN.test(subject) ||
+        INDEPENDENT_ALTERNATIVE_NAMED_OUTCOME_SUBJECT_PATTERN.test(subject) ||
+        buddy_context_planner_grammar_1.POWER_STATE_READ_PATTERN.test(subject) ||
+        (0, buddy_context_language_1.findExplicitSpaceOccurrences)(subject, explicitSpaces).some((occurrence) => occurrence.range.start === 0));
+}
+function getActionMessage(message, trailingActionMatch) {
+    if (trailingActionMatch)
+        return message.slice(trailingActionMatch.index);
+    if (buddy_context_planner_grammar_1.LEADING_UNSUPPORTED_ACTION_TEMPORAL_PATTERN.test(message)) {
+        const action = new RegExp(String.raw `\b(?:${buddy_context_planner_grammar_1.ACTION_SIGNAL_PATTERN_SOURCE})\b`, 'u').exec(message);
+        if (action)
+            return message.slice(action.index);
+    }
+    if (!buddy_context_planner_grammar_1.LEADING_CONDITION_PATTERN.test(message))
+        return message;
+    const unpunctuatedActionIndex = (0, buddy_context_language_1.findLeadingConditionalActionIndex)(message);
+    return unpunctuatedActionIndex === undefined ? message : message.slice(unpunctuatedActionIndex);
+}
+function getActionReferenceMessage(message, explicitSpaces = []) {
+    return splitPlannerClauses(message, explicitSpaces)
+        .filter((clause) => buddy_context_planner_grammar_1.ACTION_COMMAND_PATTERN.test(clause))
+        .map((clause) => {
+        const actionOnlyClause = clause.replace(new RegExp(buddy_context_planner_grammar_1.ACTION_COMMAND_PREFIX_PATTERN_SOURCE, 'u'), '');
+        return (0, buddy_context_language_1.getActionTargetClause)(actionOnlyClause);
+    })
+        .join(' and ');
+}
+function classifyDomains(message, hasHomeActionOrPredicate, isGenericExplanation, hasRecentReferencePronoun = false, explicitSpaces = [], hasAction = false, hasConversationSpace = false) {
+    if (isGenericExplanation)
+        return ['general'];
+    const domains = new Set();
+    const clauses = splitPlannerClauses(message, explicitSpaces);
+    const hasWeather = clauses.some((clause) => !isScopedIndoorFutureTemperatureClause(clause, explicitSpaces) &&
+        hasDomainSignalInClause((0, buddy_context_language_1.removeExplicitSpaceOccurrencesForDomain)((0, buddy_context_language_1.getRetrievalClause)(clause), explicitSpaces), buddy_context_planner_grammar_1.WEATHER_PATTERN, buddy_context_planner_grammar_1.WEATHER_ENTITY_NAME_PATTERN));
+    const hasEnergy = clauses.some((clause) => hasEnergyReadClause(clause, explicitSpaces));
+    const hasSecurity = hasDomainSignalOutsideEntityName(message, buddy_context_planner_grammar_1.SECURITY_PATTERN, buddy_context_planner_grammar_1.SECURITY_ENTITY_NAME_PATTERN, explicitSpaces);
+    const inheritedEnergyClauses = new Set(getMessageEnergyReadClauses(message, explicitSpaces).map((clause) => clause.trim()));
+    const hasOnlyEnergyReads = clauses.every((clause) => inheritedEnergyClauses.has(clause.trim()));
+    const conjoinedEnergySpaceIds = new Set(resolveConjoinedEnergySpaceIds(message, explicitSpaces));
+    const hasHomeEntity = clauses.some((clause) => {
+        const retrievalClause = (0, buddy_context_language_1.removeExplicitSpaceOccurrencesForDomain)((0, buddy_context_language_1.getRetrievalClause)(clause), explicitSpaces.filter((space) => conjoinedEnergySpaceIds.has(space.id)));
+        const hasHomeSignal = buddy_context_planner_grammar_1.HOME_ENTITY_PATTERN.test(retrievalClause) || buddy_context_planner_grammar_1.HOME_VOCABULARY_PATTERN.test(retrievalClause);
+        const hasNonHomeSignal = hasDomainSignalInClause(retrievalClause, buddy_context_planner_grammar_1.WEATHER_PATTERN, buddy_context_planner_grammar_1.WEATHER_ENTITY_NAME_PATTERN) ||
+            hasDomainSignalInClause(retrievalClause, buddy_context_planner_grammar_1.ENERGY_PATTERN, buddy_context_planner_grammar_1.ENERGY_ENTITY_NAME_PATTERN) ||
+            hasDomainSignalInClause(retrievalClause, buddy_context_planner_grammar_1.SECURITY_PATTERN, buddy_context_planner_grammar_1.SECURITY_ENTITY_NAME_PATTERN) ||
+            buddy_context_planner_grammar_1.UNSUPPORTED_MEASUREMENT_READ_PATTERN.test(retrievalClause) ||
+            inheritedEnergyClauses.has(clause.trim());
+        const hasDeviceSpecificDomainRead = hasNonHomeSignal && buddy_context_planner_grammar_1.HOME_ENTITY_PATTERN.test(retrievalClause);
+        return (hasHomeSignal &&
+            (!hasNonHomeSignal || buddy_context_planner_grammar_1.CONTEXTUAL_SCOPE_PATTERN.test(retrievalClause) || hasDeviceSpecificDomainRead));
+    });
+    const hasInstallationHome = clauses.some((clause) => buddy_context_planner_grammar_1.HOME_INSTALLATION_PATTERN.test(clause) &&
+        !hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.WEATHER_PATTERN, buddy_context_planner_grammar_1.WEATHER_ENTITY_NAME_PATTERN) &&
+        !hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.ENERGY_PATTERN, buddy_context_planner_grammar_1.ENERGY_ENTITY_NAME_PATTERN) &&
+        !hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.SECURITY_PATTERN, buddy_context_planner_grammar_1.SECURITY_ENTITY_NAME_PATTERN));
+    const hasContextualHomeState = clauses.some((clause) => buddy_context_planner_grammar_1.HOME_STATE_PATTERN.test(clause) &&
+        (!hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.WEATHER_PATTERN, buddy_context_planner_grammar_1.WEATHER_ENTITY_NAME_PATTERN) ||
+            buddy_context_planner_grammar_1.CONTEXTUAL_SCOPE_PATTERN.test(clause)));
+    const hasRecentReferenceHome = hasRecentReferencePronoun &&
+        (hasAction ||
+            clauses.some((clause) => {
+                const referenceClause = (0, buddy_context_language_1.stripContextualScopeReferences)(clause);
+                return ((0, buddy_context_language_1.hasReferencePronoun)(referenceClause) &&
+                    !hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.WEATHER_PATTERN, buddy_context_planner_grammar_1.WEATHER_ENTITY_NAME_PATTERN) &&
+                    !hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.ENERGY_PATTERN, buddy_context_planner_grammar_1.ENERGY_ENTITY_NAME_PATTERN) &&
+                    !hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.SECURITY_PATTERN, buddy_context_planner_grammar_1.SECURITY_ENTITY_NAME_PATTERN));
+            }));
+    const hasCategoryFreeHomeState = clauses.some((clause) => {
+        const normalizedClause = clause.trim();
+        if (hasPowerStateReadSegment(normalizedClause) || isPowerEventStateRead(normalizedClause, explicitSpaces))
+            return true;
+        return (buddy_context_planner_grammar_1.PREDICATE_QUESTION_PATTERN.test(normalizedClause) &&
+            (buddy_context_planner_grammar_1.GROUNDED_STATE_PATTERN.test(normalizedClause) || buddy_context_planner_grammar_1.STATE_SIGNAL_PATTERN.test(normalizedClause)) &&
+            (hasConversationSpace || hasRecentReferencePronoun || explicitSpaces.length > 0) &&
+            !hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.WEATHER_PATTERN, buddy_context_planner_grammar_1.WEATHER_ENTITY_NAME_PATTERN) &&
+            !hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.ENERGY_PATTERN, buddy_context_planner_grammar_1.ENERGY_ENTITY_NAME_PATTERN) &&
+            !hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.SECURITY_PATTERN, buddy_context_planner_grammar_1.SECURITY_ENTITY_NAME_PATTERN));
+    });
+    const hasExplicitHomeSpace = explicitSpaces.some((space) => clauses.some((clause) => {
+        if (!(0, buddy_context_language_1.hasExplicitSpaceOccurrence)(clause, space, explicitSpaces))
+            return false;
+        const clauseWithoutSpace = (0, buddy_context_language_1.removeExplicitSpaceOccurrencesForDomain)(clause, conjoinedEnergySpaceIds.has(space.id)
+            ? explicitSpaces.filter((candidate) => conjoinedEnergySpaceIds.has(candidate.id))
+            : [space]);
+        const hasNonHomeSignal = hasDomainSignalInClause(clauseWithoutSpace, buddy_context_planner_grammar_1.WEATHER_PATTERN, buddy_context_planner_grammar_1.WEATHER_ENTITY_NAME_PATTERN) ||
+            hasDomainSignalInClause(clauseWithoutSpace, buddy_context_planner_grammar_1.ENERGY_PATTERN, buddy_context_planner_grammar_1.ENERGY_ENTITY_NAME_PATTERN) ||
+            hasDomainSignalInClause(clauseWithoutSpace, buddy_context_planner_grammar_1.SECURITY_PATTERN, buddy_context_planner_grammar_1.SECURITY_ENTITY_NAME_PATTERN) ||
+            buddy_context_planner_grammar_1.UNSUPPORTED_MEASUREMENT_READ_PATTERN.test(clauseWithoutSpace) ||
+            inheritedEnergyClauses.has(clause.trim());
+        const hasHomeSignal = buddy_context_planner_grammar_1.HOME_ENTITY_PATTERN.test(clauseWithoutSpace) ||
+            buddy_context_planner_grammar_1.HOME_VOCABULARY_PATTERN.test(clauseWithoutSpace) ||
+            buddy_context_planner_grammar_1.HOME_STATE_PATTERN.test(clauseWithoutSpace) ||
+            buddy_context_planner_grammar_1.CONTEXTUAL_SCOPE_PATTERN.test(clauseWithoutSpace);
+        if (conjoinedEnergySpaceIds.has(space.id) && !hasHomeSignal)
+            return false;
+        return !hasNonHomeSignal || hasHomeSignal;
+    }));
+    if (!hasOnlyEnergyReads &&
+        (hasHomeEntity ||
+            hasContextualHomeState ||
+            hasHomeActionOrPredicate ||
+            hasRecentReferenceHome ||
+            hasCategoryFreeHomeState ||
+            hasExplicitHomeSpace ||
+            hasInstallationHome)) {
+        domains.add('home');
+    }
+    if (hasWeather)
+        domains.add('weather');
+    if (hasEnergy)
+        domains.add('energy');
+    if (hasSecurity)
+        domains.add('security');
+    if (clauses.some((clause) => hasHistorySignalInClause(clause))) {
+        const historySegments = clauses.flatMap((clause) => (0, buddy_context_language_1.splitConditionSegments)(clause));
+        const hasHomeSpecificHistory = historySegments.some((clause) => {
+            if (!hasHistorySignalInClause(clause))
+                return false;
+            const hasExplicitSpace = explicitSpaces.some((space) => (0, buddy_context_language_1.hasExplicitSpaceOccurrence)(clause, space, explicitSpaces));
+            const clauseWithoutExplicitSpaces = (0, buddy_context_language_1.removeExplicitSpaceOccurrencesForDomain)(clause, explicitSpaces);
+            const hasHomeSignal = buddy_context_planner_grammar_1.HOME_ENTITY_PATTERN.test(clause) ||
+                buddy_context_planner_grammar_1.HOME_VOCABULARY_PATTERN.test(clause) ||
+                buddy_context_planner_grammar_1.HOME_INSTALLATION_PATTERN.test(clause) ||
+                buddy_context_planner_grammar_1.HOME_STATE_PATTERN.test(clause) ||
+                hasExplicitSpace ||
+                (hasRecentReferenceHome && (0, buddy_context_language_1.hasReferencePronoun)(clause));
+            const hasIndependentHomeSignal = buddy_context_planner_grammar_1.HOME_ENTITY_PATTERN.test(clauseWithoutExplicitSpaces) ||
+                buddy_context_planner_grammar_1.HOME_VOCABULARY_PATTERN.test(clauseWithoutExplicitSpaces) ||
+                buddy_context_planner_grammar_1.HOME_INSTALLATION_PATTERN.test(clauseWithoutExplicitSpaces) ||
+                buddy_context_planner_grammar_1.HOME_STATE_PATTERN.test(clauseWithoutExplicitSpaces) ||
+                (hasRecentReferenceHome && (0, buddy_context_language_1.hasReferencePronoun)(clauseWithoutExplicitSpaces));
+            const hasNonHomeSignal = hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.WEATHER_PATTERN, buddy_context_planner_grammar_1.WEATHER_ENTITY_NAME_PATTERN) ||
+                hasEnergyReadClause(clause, explicitSpaces) ||
+                hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.SECURITY_PATTERN, buddy_context_planner_grammar_1.SECURITY_ENTITY_NAME_PATTERN);
+            return (hasHomeSignal &&
+                (!hasNonHomeSignal || buddy_context_planner_grammar_1.CONTEXTUAL_SCOPE_PATTERN.test(clause) || (hasExplicitSpace && hasIndependentHomeSignal)));
+        });
+        if (hasHomeSpecificHistory) {
+            domains.add('home');
+            domains.add('history');
+        }
+    }
+    if (domains.size === 0)
+        domains.add('general');
+    return buddy_context_planner_grammar_1.DOMAIN_ORDER.filter((domain) => domains.has(domain));
+}
+function hasDomainSignalOutsideEntityName(message, domainPattern, entityNamePattern, explicitSpaces = []) {
+    return splitPlannerClauses(message, explicitSpaces).some((clause) => hasDomainSignalInClause((0, buddy_context_language_1.removeExplicitSpaceOccurrencesForDomain)((0, buddy_context_language_1.getRetrievalClause)(clause), explicitSpaces), domainPattern, entityNamePattern));
+}
+function hasEnergyReadClause(clause, explicitSpaces = []) {
+    return getEnergyReadClauses(clause, explicitSpaces).length > 0;
+}
+function getEnergyReadClauses(clause, explicitSpaces = []) {
+    const retrievalClause = (0, buddy_context_language_1.getRetrievalClause)(clause);
+    return (0, buddy_context_language_1.splitConditionSegments)(retrievalClause).filter((segment) => hasDirectEnergyReadClause(segment, explicitSpaces));
+}
+function getMessageEnergyReadClauses(message, explicitSpaces = []) {
+    const energyClauses = [];
+    let hasPriorEnergyRead = false;
+    for (const clause of splitPlannerClauses(message, explicitSpaces)) {
+        const directEnergyClauses = getEnergyReadClauses(clause, explicitSpaces);
+        if (directEnergyClauses.length > 0) {
+            energyClauses.push(...directEnergyClauses);
+            hasPriorEnergyRead = true;
+            continue;
+        }
+        const retrievalClause = (0, buddy_context_language_1.getRetrievalClause)(clause).trim();
+        if (hasPriorEnergyRead && isEnergyEllipsisReadClause(retrievalClause, explicitSpaces)) {
+            energyClauses.push(retrievalClause);
+            continue;
+        }
+        hasPriorEnergyRead = false;
+    }
+    return energyClauses;
+}
+function isEnergyEllipsisReadClause(clause, explicitSpaces) {
+    const clauseWithoutSpaces = (0, buddy_context_language_1.removeExplicitSpaceOccurrencesForDomain)(clause, explicitSpaces)
+        .replace(/[?!.]/gu, ' ')
+        .trim();
+    if (buddy_context_planner_grammar_1.ENERGY_ELLIPSIS_READ_PATTERN.test(clause) &&
+        /^how\s+much\s+(?:(?:did|does|has|have|it|they|we|you)\s+)*(?:consume|consumed|consumes|produce|produced|produces|use|used|uses)\b/u.test(clauseWithoutSpaces)) {
+        return true;
+    }
+    if (!explicitSpaces.some((space) => (0, buddy_context_language_1.hasExplicitSpaceOccurrence)(clause, space, explicitSpaces)))
+        return false;
+    return /^(?:what\s+about)?$/u.test(clauseWithoutSpaces);
+}
+function hasDirectEnergyReadClause(retrievalClause, explicitSpaces = []) {
+    if (buddy_context_planner_grammar_1.POWER_USAGE_READ_PATTERN.test(retrievalClause))
+        return true;
+    if (isPowerEventStateRead(retrievalClause, explicitSpaces))
+        return false;
+    const energyClause = isPowerStateRead(retrievalClause)
+        ? retrievalClause.replace(/\bpower\b/gu, ' ')
+        : retrievalClause;
+    return hasDomainSignalInClause((0, buddy_context_language_1.removeExplicitSpaceOccurrencesForDomain)(energyClause, explicitSpaces), buddy_context_planner_grammar_1.ENERGY_PATTERN, buddy_context_planner_grammar_1.ENERGY_ENTITY_NAME_PATTERN);
+}
+function isPowerStateRead(message) {
+    return (buddy_context_planner_grammar_1.POWER_STATE_READ_PATTERN.test(message) &&
+        !buddy_context_planner_grammar_1.POWER_USAGE_READ_PATTERN.test(message) &&
+        !buddy_context_planner_grammar_1.POWER_MEASUREMENT_READ_PATTERN.test(message));
+}
+function hasPowerStateReadSegment(message) {
+    return (0, buddy_context_language_1.splitConditionSegments)(message).some((segment) => isPowerStateRead(segment));
+}
+function isPowerEventStateRead(message, explicitSpaces = []) {
+    if (!buddy_context_planner_grammar_1.POWER_EVENT_STATE_READ_PATTERN.test(message) || buddy_context_planner_grammar_1.POWER_USAGE_READ_PATTERN.test(message))
+        return false;
+    const withoutPowerEvent = (0, buddy_context_language_1.removeExplicitSpaceOccurrencesForDomain)(message.replace(new RegExp(buddy_context_planner_grammar_1.POWER_EVENT_STATE_READ_PATTERN.source, 'gu'), ' '), explicitSpaces);
+    return !hasDomainSignalInClause(withoutPowerEvent, buddy_context_planner_grammar_1.ENERGY_PATTERN, buddy_context_planner_grammar_1.ENERGY_ENTITY_NAME_PATTERN);
+}
+function hasDomainSignalInClause(clause, domainPattern, entityNamePattern) {
+    return domainPattern.test(clause.replace(entityNamePattern, ' '));
+}
+function isScopedIndoorFutureTemperatureClause(clause, explicitSpaces) {
+    return (buddy_context_planner_grammar_1.FUTURE_TEMPERATURE_PATTERN.test(clause) &&
+        !buddy_context_planner_grammar_1.EXPLICIT_WEATHER_PATTERN.test(clause) &&
+        explicitSpaces.some((space) => (0, buddy_context_language_1.hasExplicitSpaceOccurrence)(clause, space, explicitSpaces)));
+}
+function hasHistorySignalInClause(clause) {
+    const historyClause = buddy_context_planner_grammar_1.ACTION_COMMAND_PATTERN.test(clause) ? clause.replace(buddy_context_planner_grammar_1.ACTION_DURATION_PATTERN, ' ') : clause;
+    return (buddy_context_planner_grammar_1.HISTORY_PATTERN.test(historyClause) ||
+        buddy_context_planner_grammar_1.LEADING_WEEKDAY_HISTORY_PATTERN.test(historyClause) ||
+        (!buddy_context_planner_grammar_1.ACTION_COMMAND_PATTERN.test(clause) && buddy_context_planner_grammar_1.CLOCK_TIME_HISTORY_PATTERN.test(historyClause)));
+}
+function splitPlannerClauses(message, protectedSpaces = []) {
+    const protectedRanges = [
+        ...(0, buddy_context_language_1.findExplicitSpaceOccurrences)(message, protectedSpaces).map((occurrence) => occurrence.range),
+        ...findConjoinedSpaceTargetRanges(message, protectedSpaces),
+        ...(0, buddy_context_language_1.findPatternRanges)(message, buddy_context_planner_grammar_1.CLOCK_TIME_HISTORY_PATTERN),
+        ...(0, buddy_context_language_1.findPatternRanges)(message, buddy_context_planner_grammar_1.ACTION_RANGE_PATTERN),
+        ...(0, buddy_context_language_1.findPatternRanges)(message, buddy_context_planner_grammar_1.ACTION_DURATION_PATTERN),
+        ...(0, buddy_context_language_1.findPatternRanges)(message, buddy_context_planner_grammar_1.AGGREGATE_STATE_COORDINATION_PATTERN),
+        ...(0, buddy_context_language_1.findPatternRanges)(message, buddy_context_planner_grammar_1.AGGREGATE_SUFFIX_COMMA_PATTERN),
+        ...(0, buddy_context_language_1.findPatternRanges)(message, /\b(?:current|currently|now|today)\s+and\s+(?:yesterday|(?:last|previous)\s+(?:day|hour|month|night|week|weekend|year))\b/u),
+        ...(0, buddy_context_language_1.findPatternRanges)(message, /\d+\.\d+/u),
+    ];
+    const separatorPattern = new RegExp(String.raw `(?:,\s*(?:${buddy_context_planner_grammar_1.COMPOUND_CONNECTOR_PATTERN_SOURCE})(?:\s+then)?\b|(?:,\s*)?\b${INDEPENDENT_ALTERNATIVE_CONNECTOR_PATTERN_SOURCE}\b(?=\s+(?:${buddy_context_language_1.CONDITIONAL_OUTCOME_AUXILIARY_PATTERN_SOURCE}\s+|${INDEPENDENT_ALTERNATIVE_INTERROGATIVE_PATTERN_SOURCE}))|[?!,.;]|\band\s+then\b|\b(?:${buddy_context_planner_grammar_1.COMPOUND_CONNECTOR_PATTERN_SOURCE})\b|\ba\b(?=\s*(?:${buddy_context_planner_grammar_1.ACTION_SIGNAL_PATTERN_SOURCE})\b))`, 'gu');
+    const clauses = [];
+    let clauseStart = 0;
+    for (const separator of message.matchAll(separatorPattern)) {
+        const separatorStart = separator.index;
+        const separatorEnd = separatorStart + separator[0].length;
+        if (protectedRanges.some((range) => range.start <= separatorStart && range.end >= separatorEnd))
+            continue;
+        if (INDEPENDENT_ALTERNATIVE_CONNECTOR_PATTERN.test(separator[0]) &&
+            !hasIndependentAlternativeSubject(message.slice(separatorEnd), protectedSpaces)) {
+            continue;
+        }
+        clauses.push(message.slice(clauseStart, separatorStart));
+        clauseStart = separatorEnd;
+    }
+    clauses.push(message.slice(clauseStart));
+    const preservesConditionalOutcomeQuestion = buddy_context_planner_grammar_1.LEADING_CONDITION_PATTERN.test(message) &&
+        /\?\s*$/u.test(message) &&
+        (0, buddy_context_language_1.findLeadingConditionalActionIndex)(message) === undefined;
+    const conditionalClauses = preservesConditionalOutcomeQuestion
+        ? clauses
+        : clauses.flatMap((clause) => {
+            const actionIndex = (0, buddy_context_language_1.findLeadingConditionalActionIndex)(clause);
+            return actionIndex === undefined || actionIndex === 0
+                ? [clause]
+                : [clause.slice(0, actionIndex), clause.slice(actionIndex)];
+        });
+    return mergeActionTargetDurationContinuations(mergeLeadingTemporalAdjuncts(conditionalClauses));
+}
+function mergeLeadingTemporalAdjuncts(clauses) {
+    const merged = [...clauses];
+    while (merged.length > 1 &&
+        hasHistorySignalInClause(merged[0].trim()) &&
+        !buddy_context_planner_grammar_1.HOME_ENTITY_PATTERN.test(merged[0]) &&
+        !buddy_context_planner_grammar_1.HOME_STATE_PATTERN.test(merged[0]) &&
+        !hasDomainSignalInClause(merged[0], buddy_context_planner_grammar_1.WEATHER_PATTERN, buddy_context_planner_grammar_1.WEATHER_ENTITY_NAME_PATTERN) &&
+        !hasDomainSignalInClause(merged[0], buddy_context_planner_grammar_1.ENERGY_PATTERN, buddy_context_planner_grammar_1.ENERGY_ENTITY_NAME_PATTERN) &&
+        !hasDomainSignalInClause(merged[0], buddy_context_planner_grammar_1.SECURITY_PATTERN, buddy_context_planner_grammar_1.SECURITY_ENTITY_NAME_PATTERN) &&
+        !buddy_context_planner_grammar_1.ACTION_COMMAND_PATTERN.test(merged[0])) {
+        merged.splice(0, 2, `${merged[0]} ${merged[1]}`);
+    }
+    return merged;
+}
+function mergeActionTargetDurationContinuations(clauses) {
+    const merged = [];
+    for (const clause of clauses) {
+        const previousClause = merged.at(-1);
+        const isDurationContinuation = previousClause !== undefined &&
+            buddy_context_planner_grammar_1.ACTION_COMMAND_PATTERN.test(previousClause) &&
+            buddy_context_planner_grammar_1.WRITE_PATTERN.test(previousClause) &&
+            !buddy_context_planner_grammar_1.ACTION_COMMAND_PATTERN.test(clause) &&
+            !buddy_context_planner_grammar_1.READ_PATTERN.test(clause.trim()) &&
+            !buddy_context_planner_grammar_1.PREDICATE_QUESTION_PATTERN.test(clause.trim()) &&
+            !hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.WEATHER_PATTERN, buddy_context_planner_grammar_1.WEATHER_ENTITY_NAME_PATTERN) &&
+            !hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.ENERGY_PATTERN, buddy_context_planner_grammar_1.ENERGY_ENTITY_NAME_PATTERN) &&
+            !hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.SECURITY_PATTERN, buddy_context_planner_grammar_1.SECURITY_ENTITY_NAME_PATTERN) &&
+            (buddy_context_planner_grammar_1.HOME_ENTITY_PATTERN.test(clause) || buddy_context_planner_grammar_1.HOME_VOCABULARY_PATTERN.test(clause)) &&
+            buddy_context_planner_grammar_1.GROUNDED_STATE_PATTERN.test(clause) &&
+            (buddy_context_planner_grammar_1.ACTION_DURATION_PATTERN.test(clause) ||
+                buddy_context_planner_grammar_1.NONNUMERIC_ACTION_DURATION_PATTERN.test(clause) ||
+                buddy_context_planner_grammar_1.QUALIFIED_ACTION_DURATION_PATTERN.test(clause));
+        if (isDurationContinuation) {
+            merged[merged.length - 1] = `${previousClause} and ${clause}`;
+            continue;
+        }
+        merged.push(clause);
+    }
+    return merged;
+}
+function getActionClausesWithTargetContinuations(clauses, sourceMessage) {
+    return getActionClauseSelection(clauses, sourceMessage).map(({ validationClause }) => validationClause);
+}
+function getActionSourceClausesWithTargetContinuations(clauses, sourceMessage) {
+    return getActionClauseSelection(clauses, sourceMessage).map(({ sourceClause }) => sourceClause);
+}
+function getActionClauseSelection(clauses, sourceMessage) {
+    const actionClauses = [];
+    let inheritedAction;
+    let previousClauseEnd = 0;
+    let searchStart = 0;
+    for (const clause of clauses) {
+        const clauseStart = sourceMessage.indexOf(clause, searchStart);
+        const connector = clauseStart >= 0 ? sourceMessage.slice(previousClauseEnd, clauseStart) : '';
+        const hasContinuationConnector = buddy_context_planner_grammar_1.ACTION_CONTINUATION_CONNECTOR_PATTERN.test(connector);
+        if (clauseStart >= 0) {
+            previousClauseEnd = clauseStart + clause.length;
+            searchStart = previousClauseEnd;
+        }
+        const prefixedActionClause = getTemporallyPrefixedActionClause(clause);
+        if (buddy_context_planner_grammar_1.ACTION_COMMAND_PATTERN.test(clause) || prefixedActionClause) {
+            actionClauses.push({ sourceClause: clause, validationClause: clause });
+            inheritedAction = new RegExp(String.raw `\b(?:${buddy_context_planner_grammar_1.ACTION_SIGNAL_PATTERN_SOURCE})\b`, 'u').exec(prefixedActionClause ?? clause)?.[0];
+            continue;
+        }
+        const isActionTargetContinuation = Boolean(inheritedAction &&
+            hasContinuationConnector &&
+            !buddy_context_planner_grammar_1.READ_PATTERN.test(clause.trim()) &&
+            !buddy_context_planner_grammar_1.PREDICATE_QUESTION_PATTERN.test(clause.trim()) &&
+            !hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.WEATHER_PATTERN, buddy_context_planner_grammar_1.WEATHER_ENTITY_NAME_PATTERN) &&
+            !hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.ENERGY_PATTERN, buddy_context_planner_grammar_1.ENERGY_ENTITY_NAME_PATTERN) &&
+            !hasDomainSignalInClause(clause, buddy_context_planner_grammar_1.SECURITY_PATTERN, buddy_context_planner_grammar_1.SECURITY_ENTITY_NAME_PATTERN) &&
+            (buddy_context_planner_grammar_1.HOME_ENTITY_PATTERN.test(clause) || buddy_context_planner_grammar_1.HOME_VOCABULARY_PATTERN.test(clause)) &&
+            hasActionTargetContinuationValue(clause));
+        if (isActionTargetContinuation && inheritedAction) {
+            actionClauses.push({ sourceClause: clause, validationClause: `${inheritedAction} ${clause}` });
+        }
+        if (!isActionTargetContinuation)
+            inheritedAction = undefined;
+    }
+    return actionClauses;
+}
+function getTemporallyPrefixedActionClause(clause) {
+    const actionSignal = new RegExp(String.raw `\b(?:${buddy_context_planner_grammar_1.ACTION_SIGNAL_PATTERN_SOURCE})\b`, 'u').exec(clause);
+    if (!actionSignal || actionSignal.index === 0)
+        return undefined;
+    const temporalPrefix = clause.slice(0, actionSignal.index).trim();
+    const actionClause = clause.slice(actionSignal.index);
+    return buddy_context_planner_grammar_1.SCHEDULED_ACTION_PATTERN.test(temporalPrefix) && buddy_context_planner_grammar_1.ACTION_COMMAND_PATTERN.test(actionClause)
+        ? actionClause
+        : undefined;
+}
+function hasActionTargetContinuationValue(clause) {
+    const targetRange = (0, buddy_context_language_1.findPatternRanges)(clause, buddy_context_planner_grammar_1.HOME_ENTITY_PATTERN).at(-1);
+    if (!targetRange)
+        return false;
+    const value = clause.slice(targetRange.end).trim();
+    const directStatePattern = new RegExp(String.raw `^(?:${buddy_context_planner_grammar_1.GROUNDED_STATE_PATTERN.source})$`, 'u');
+    return (directStatePattern.test(value) ||
+        /^(?:at|by|to)\s+[^?!,.;]{1,40}$/u.test(value) ||
+        /^[-+]?\d+(?:\.\d+)?\s*(?:%|celsius\b|degrees?\b|fahrenheit\b|percent\b|°\s*(?:c|f)?)?$/u.test(value));
+}
+function findConjoinedSpaceTargetRanges(message, spaces) {
+    const occurrences = (0, buddy_context_language_1.findExplicitSpaceOccurrences)(message, spaces).sort((left, right) => left.range.start - right.range.start);
+    const sharedTargetPattern = new RegExp(String.raw `^\s*(?:temperatures?\b|${buddy_context_planner_grammar_1.HOME_ENTITY_PATTERN.source}|${buddy_context_planner_grammar_1.HOME_STATE_PATTERN.source}|${buddy_context_planner_grammar_1.ENERGY_PATTERN.source}|${buddy_context_planner_grammar_1.SECURITY_PATTERN.source}|${buddy_context_planner_grammar_1.EXPLICIT_WEATHER_PATTERN.source})`, 'u');
+    const precedingSharedTargetPattern = new RegExp(String.raw `(?:temperatures?|${buddy_context_planner_grammar_1.HOME_ENTITY_PATTERN.source}|${buddy_context_planner_grammar_1.HOME_STATE_PATTERN.source}|${buddy_context_planner_grammar_1.ENERGY_PATTERN.source}|${buddy_context_planner_grammar_1.SECURITY_PATTERN.source}|${buddy_context_planner_grammar_1.EXPLICIT_WEATHER_PATTERN.source})\b[^?!,.;]{0,40}$`, 'u');
+    const ranges = [];
+    for (let index = 0; index < occurrences.length - 1; index += 1) {
+        const left = occurrences[index];
+        const right = occurrences[index + 1];
+        const connector = message.slice(left.range.end, right.range.start);
+        const hasRepeatedEnergyPredicate = buddy_context_planner_grammar_1.REPEATED_ENERGY_CONNECTOR_PATTERN.test(connector) &&
+            buddy_context_planner_grammar_1.LEADING_ENERGY_PREDICATE_PATTERN.test(message.slice(right.range.end)) &&
+            hasDomainSignalInClause((0, buddy_context_language_1.removeExplicitSpaceOccurrencesForDomain)(message.slice(0, left.range.start), spaces), buddy_context_planner_grammar_1.ENERGY_PATTERN, buddy_context_planner_grammar_1.ENERGY_ENTITY_NAME_PATTERN);
+        if (hasRepeatedEnergyPredicate) {
+            ranges.push({ start: left.range.end, end: right.range.start });
+            continue;
+        }
+        if (!/^\s*(?:,\s*|,?\s+(?:and|or)\s+)$/u.test(connector))
+            continue;
+        let chainEndIndex = index + 1;
+        while (chainEndIndex < occurrences.length - 1) {
+            const chainLeft = occurrences[chainEndIndex];
+            const chainRight = occurrences[chainEndIndex + 1];
+            if (!/^\s*(?:,\s*|,?\s+(?:and|or)\s+)$/u.test(message.slice(chainLeft.range.end, chainRight.range.start))) {
+                break;
+            }
+            chainEndIndex += 1;
+        }
+        const chainEnd = occurrences[chainEndIndex];
+        if (!sharedTargetPattern.test(message.slice(chainEnd.range.end)) &&
+            !precedingSharedTargetPattern.test(message.slice(0, left.range.start))) {
+            continue;
+        }
+        ranges.push({ start: left.range.end, end: right.range.start });
+    }
+    return ranges;
+}
+function hasCurrentStateReadClause(message, explicitSpaces = []) {
+    const conjoinedTemporalSpaceIds = new Set(resolveConjoinedTemporalSpaceIds(message, explicitSpaces));
+    return splitPlannerClauses(message, explicitSpaces).some((clause) => {
+        const normalizedClause = clause.trim();
+        if (hasHistorySignalInClause(normalizedClause) && !buddy_context_planner_grammar_1.CURRENT_STATE_PATTERN.test(normalizedClause))
+            return false;
+        if (!buddy_context_planner_grammar_1.CURRENT_STATE_PATTERN.test(normalizedClause) &&
+            explicitSpaces.some((space) => conjoinedTemporalSpaceIds.has(space.id) &&
+                (0, buddy_context_language_1.hasExplicitSpaceOccurrence)(normalizedClause, space, explicitSpaces))) {
+            return false;
+        }
+        return (buddy_context_planner_grammar_1.CURRENT_STATE_PATTERN.test(normalizedClause) ||
+            buddy_context_planner_grammar_1.READ_PATTERN.test(normalizedClause) ||
+            buddy_context_planner_grammar_1.PREDICATE_QUESTION_PATTERN.test(normalizedClause));
+    });
+}
+function hasHomeStateReadClause(message, explicitSpaces = []) {
+    return splitPlannerClauses(message, explicitSpaces).some((clause) => {
+        const normalizedClause = clause.trim();
+        if (hasPowerStateReadSegment(normalizedClause) || isPowerEventStateRead(normalizedClause, explicitSpaces))
+            return true;
+        const clauseWithoutExplicitSpaces = (0, buddy_context_language_1.removeExplicitSpaceOccurrencesForDomain)(normalizedClause, explicitSpaces);
+        const clauseWithoutDomainEntityNames = clauseWithoutExplicitSpaces
+            .replace(buddy_context_planner_grammar_1.WEATHER_ENTITY_NAME_PATTERN, ' ')
+            .replace(buddy_context_planner_grammar_1.ENERGY_ENTITY_NAME_PATTERN, ' ')
+            .replace(buddy_context_planner_grammar_1.SECURITY_ENTITY_NAME_PATTERN, ' ');
+        const hasNonHomeDomainSignal = hasDomainSignalInClause(normalizedClause, buddy_context_planner_grammar_1.WEATHER_PATTERN, buddy_context_planner_grammar_1.WEATHER_ENTITY_NAME_PATTERN) ||
+            hasDomainSignalInClause(normalizedClause, buddy_context_planner_grammar_1.ENERGY_PATTERN, buddy_context_planner_grammar_1.ENERGY_ENTITY_NAME_PATTERN) ||
+            hasDomainSignalInClause(normalizedClause, buddy_context_planner_grammar_1.SECURITY_PATTERN, buddy_context_planner_grammar_1.SECURITY_ENTITY_NAME_PATTERN) ||
+            buddy_context_planner_grammar_1.UNSUPPORTED_MEASUREMENT_READ_PATTERN.test(normalizedClause);
+        const hasExplicitWeatherSignal = buddy_context_planner_grammar_1.EXPLICIT_WEATHER_PATTERN.test(clauseWithoutDomainEntityNames);
+        const hasIndependentHomeSignal = buddy_context_planner_grammar_1.HOME_ENTITY_PATTERN.test(clauseWithoutDomainEntityNames) ||
+            (!hasExplicitWeatherSignal &&
+                (buddy_context_planner_grammar_1.HOME_VOCABULARY_PATTERN.test(clauseWithoutDomainEntityNames) ||
+                    buddy_context_planner_grammar_1.HOME_STATE_PATTERN.test(clauseWithoutDomainEntityNames))) ||
+            buddy_context_planner_grammar_1.CONTEXTUAL_SCOPE_PATTERN.test(clauseWithoutDomainEntityNames);
+        if (hasNonHomeDomainSignal && !hasIndependentHomeSignal)
+            return false;
+        return (buddy_context_planner_grammar_1.HOME_ENTITY_PATTERN.test(normalizedClause) ||
+            buddy_context_planner_grammar_1.HOME_VOCABULARY_PATTERN.test(normalizedClause) ||
+            buddy_context_planner_grammar_1.HOME_STATE_PATTERN.test(normalizedClause) ||
+            buddy_context_planner_grammar_1.CONTEXTUAL_SCOPE_PATTERN.test(normalizedClause) ||
+            (buddy_context_planner_grammar_1.PREDICATE_QUESTION_PATTERN.test(normalizedClause) && buddy_context_planner_grammar_1.GROUNDED_STATE_PATTERN.test(normalizedClause)));
+    });
+}
+function hasHomeActionConditionClause(message, explicitSpaces = []) {
+    if (hasHomeStateReadClause(message, explicitSpaces))
+        return true;
+    if (!buddy_context_planner_grammar_1.GROUNDED_STATE_PATTERN.test(message) &&
+        !buddy_context_planner_grammar_1.STATE_SIGNAL_PATTERN.test(message) &&
+        !buddy_context_planner_grammar_1.ACTION_CONDITION_STATE_PATTERN.test(message)) {
+        return false;
+    }
+    return (!hasDomainSignalInClause(message, buddy_context_planner_grammar_1.WEATHER_PATTERN, buddy_context_planner_grammar_1.WEATHER_ENTITY_NAME_PATTERN) &&
+        !hasDomainSignalInClause(message, buddy_context_planner_grammar_1.ENERGY_PATTERN, buddy_context_planner_grammar_1.ENERGY_ENTITY_NAME_PATTERN) &&
+        !hasDomainSignalInClause(message, buddy_context_planner_grammar_1.SECURITY_PATTERN, buddy_context_planner_grammar_1.SECURITY_ENTITY_NAME_PATTERN));
+}
+function hasSupportedActionConditionClause(message, explicitSpaces = []) {
+    return (hasHomeActionConditionClause(message, explicitSpaces) ||
+        hasDomainSignalInClause(message, buddy_context_planner_grammar_1.WEATHER_PATTERN, buddy_context_planner_grammar_1.WEATHER_ENTITY_NAME_PATTERN) ||
+        hasEnergyReadClause(message, explicitSpaces) ||
+        hasDomainSignalInClause(message, buddy_context_planner_grammar_1.SECURITY_PATTERN, buddy_context_planner_grammar_1.SECURITY_ENTITY_NAME_PATTERN));
+}
+function isGeneralExplanation(message, explicitSpaces = []) {
+    const indefiniteDefinitionSubject = /^what (?:is|are) (?:a|an)\s+([\p{Letter}\p{Number}][\p{Letter}\p{Number}\s-]*?)[?!.]*$/u
+        .exec(message)?.[1]
+        ?.trim();
+    if (indefiniteDefinitionSubject &&
+        explicitSpaces.some((space) => (0, buddy_context_language_1.normalize)(space.name) === indefiniteDefinitionSubject)) {
+        return true;
+    }
+    if (explicitSpaces.length > 0 || buddy_context_planner_grammar_1.POSSESSIVE_HOME_ENTITY_PATTERN.test(message))
+        return false;
+    if (/\b(?:my|our)\b/u.test(message) && /\b(?:energy|power|secure|security|weather)\b/u.test(message))
+        return false;
+    const isConceptualDomainRequest = /^(?:define|describe|explain|tell me about|what (?:is|are))\b/u.test(message) &&
+        /\b(?:energy|power|security|weather)\b/u.test(message) &&
+        !buddy_context_planner_grammar_1.HOME_ENTITY_PATTERN.test(message) &&
+        !/\b(?:alarm|armed|consumption|current|currently|forecast|now|outside|production|rain|today|tonight|usage)\b/u.test(message);
+    return (buddy_context_planner_grammar_1.GENERAL_KNOWLEDGE_INVENTORY_PATTERN.test(message) ||
+        isConceptualDomainRequest ||
+        /^(?:explain|tell me about)\b.*\b(?:energy conservation|website security)\b/u.test(message) ||
+        /^what is (?:electrical|kinetic|potential|renewable) (?:energy|power)[?!.]*$/u.test(message) ||
+        /^what is (?:security|weather)[?!.]*$/u.test(message) ||
+        /^(?:explain|is)\b.*\b(?:password|website)\b.*\b(?:secure|security)\b/u.test(message) ||
+        /^what (?:is|are) (?:smart )?(?:device|devices|home|home automation|lighting|scene|scenes|sensor|sensors|thermostat|thermostats)[?!.]*$/u.test(message) ||
+        /^how (?:can|could|did|do|does|would)\b.*\b(?:work|works|working|i)\b/u.test(message) ||
+        /^explain (?:how|what|why)\b/u.test(message) ||
+        /^(?:explain|show me|tell me) how to\b/u.test(message) ||
+        /^what (?:do|does) (?:a|an)\b.*\bdo\b/u.test(message) ||
+        /^what (?:do|does) .+ mean\b/u.test(message) ||
+        /^what (?:is|are) (?:a|an)\b/u.test(message));
+}
+function hasOnlyGroundedActionTokens(message) {
+    const tokens = new Set(message.split(/[^\p{Letter}\p{Number}]+/u).filter((token) => token.length > 0));
+    let hasActionToken = false;
+    for (const token of tokens) {
+        if (!buddy_context_planner_grammar_1.WRITE_PATTERN.test(token))
+            continue;
+        hasActionToken = true;
+        if (!/^(?:close|closed|lock|locked|off|on|open|unlock|unlocked)$/u.test(token))
+            return false;
+    }
+    return hasActionToken;
+}
+function isStatePredicateQuestion(message) {
+    return (buddy_context_planner_grammar_1.PREDICATE_QUESTION_PATTERN.test(message) &&
+        (buddy_context_planner_grammar_1.WRITE_PATTERN.test(message) || buddy_context_planner_grammar_1.TRIGGER_PATTERN.test(message)) &&
+        !buddy_context_planner_grammar_1.ACTION_REQUEST_PATTERN.test(message));
+}
+function resolveConjoinedTemporalSpaceIds(message, explicitSpaces) {
+    const temporalClauses = splitPlannerClauses(message, explicitSpaces).filter((clause) => hasHistorySignalInClause(clause));
+    const directlyTemporalSpaceIds = resolveTemporalExplicitSpaceIds(temporalClauses, explicitSpaces, buddy_context_planner_grammar_1.TEMPORAL_HISTORY_PATTERN);
+    const coordinatedTemporalSpaceIds = expandCoordinatedTemporalPropertySpaceIds(message, explicitSpaces, directlyTemporalSpaceIds);
+    return expandConjoinedSpaceIds(message, explicitSpaces, coordinatedTemporalSpaceIds).filter((spaceId) => !directlyTemporalSpaceIds.includes(spaceId));
+}
+function expandCoordinatedTemporalPropertySpaceIds(message, explicitSpaces, selectedSpaceIds) {
+    const occurrences = (0, buddy_context_language_1.findExplicitSpaceOccurrences)(message, explicitSpaces).sort((left, right) => left.range.start - right.range.start);
+    const selectedIds = new Set(selectedSpaceIds);
+    const propertySource = buddy_context_planner_grammar_1.HOME_STATE_PATTERN.source;
+    const coordinatedPropertyConnector = new RegExp(String.raw `^\s*(?:${propertySource})\s*,?\s+(?:and|or)\s+$`, 'u');
+    const trailingTemporalProperty = new RegExp(String.raw `^\s*(?:${propertySource})\b[^?!,.;]*${buddy_context_planner_grammar_1.TEMPORAL_HISTORY_PATTERN.source}`, 'u');
+    for (let index = occurrences.length - 2; index >= 0; index -= 1) {
+        const left = occurrences[index];
+        const right = occurrences[index + 1];
+        if (!selectedIds.has(right.space.id))
+            continue;
+        if (!coordinatedPropertyConnector.test(message.slice(left.range.end, right.range.start)))
+            continue;
+        if (!trailingTemporalProperty.test(message.slice(right.range.end)))
+            continue;
+        selectedIds.add(left.space.id);
+    }
+    return explicitSpaces.filter((space) => selectedIds.has(space.id)).map((space) => space.id);
+}
+function resolveConjoinedEnergySpaceIds(message, explicitSpaces) {
+    const energyClauses = getMessageEnergyReadClauses(message, explicitSpaces);
+    const directlyEnergySpaceIds = explicitSpaces
+        .filter((space) => energyClauses.some((clause) => (0, buddy_context_language_1.hasExplicitSpaceOccurrence)(clause, space, explicitSpaces)))
+        .map((space) => space.id);
+    return expandConjoinedSpaceIds(message, explicitSpaces, directlyEnergySpaceIds);
+}
+function expandConjoinedSpaceIds(message, explicitSpaces, selectedSpaceIds) {
+    const occurrences = (0, buddy_context_language_1.findExplicitSpaceOccurrences)(message, explicitSpaces).sort((left, right) => left.range.start - right.range.start);
+    const selectedIds = new Set(selectedSpaceIds);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (let index = 0; index < occurrences.length - 1; index += 1) {
+            const left = occurrences[index];
+            const right = occurrences[index + 1];
+            const connector = message.slice(left.range.end, right.range.start);
+            if (!/^\s*(?:,\s*|,?\s+(?:and|or)\s+)$/u.test(connector))
+                continue;
+            if (selectedIds.has(left.space.id) === selectedIds.has(right.space.id))
+                continue;
+            selectedIds.add(left.space.id);
+            selectedIds.add(right.space.id);
+            changed = true;
+        }
+    }
+    return explicitSpaces.filter((space) => selectedIds.has(space.id)).map((space) => space.id);
+}
+function resolveTemporalExplicitSpaceIds(clauses, explicitSpaces, temporalPattern) {
+    const spaceIds = [];
+    for (const clause of clauses) {
+        const clauseOccurrences = (0, buddy_context_language_1.findExplicitSpaceOccurrences)(clause, explicitSpaces);
+        const clauseSpaces = explicitSpaces
+            .map((space) => ({
+            space,
+            ranges: clauseOccurrences
+                .filter((occurrence) => occurrence.space.id === space.id)
+                .map((occurrence) => occurrence.range),
+        }))
+            .filter(({ ranges }) => ranges.length > 0);
+        if (!buddy_context_planner_grammar_1.CURRENT_STATE_PATTERN.test(clause) || !hasHistorySignalInClause(clause) || clauseSpaces.length <= 1) {
+            spaceIds.push(...clauseSpaces.map(({ space }) => space.id));
+            continue;
+        }
+        const globalFlags = temporalPattern.flags.includes('g') ? temporalPattern.flags : `${temporalPattern.flags}g`;
+        const matches = clause.matchAll(new RegExp(temporalPattern.source, globalFlags));
+        for (const match of matches) {
+            const start = match.index;
+            const temporalCenter = start + match[0].length / 2;
+            const spaceRanges = clauseSpaces.flatMap(({ space, ranges }) => ranges.map((range) => ({ space, range })));
+            const precedingSpace = spaceRanges
+                .filter(({ range }) => range.end <= start)
+                .sort((left, right) => right.range.end - left.range.end)[0]?.space;
+            const nearestSpace = spaceRanges
+                .map(({ space, range }) => ({
+                space,
+                distance: Math.abs((range.start + range.end) / 2 - temporalCenter),
+            }))
+                .sort((left, right) => left.distance - right.distance)[0]?.space;
+            const selectedSpace = precedingSpace ?? nearestSpace;
+            if (selectedSpace)
+                spaceIds.push(selectedSpace.id);
+        }
+    }
+    return [...new Set(spaceIds)];
+}
+//# sourceMappingURL=buddy-context-message-analysis.js.map