n8n-nodes-lifespace 0.1.5 → 0.1.7

package/README.md

@@ -70,13 +70,23 @@ Create/Update keep scalar fields in n8n Resource Mapper while using native n8n c
 
 The node displays the authorized human-readable `spaceName` when present while continuing to submit the stable `spc_*` ID.
 
-Record Type identity and REST routing remain distinct. LifeSpace `modelKey` is the stable semantic identity, while the Discovery `route` is a REST transport detail. The n8n adapter persists an adapter-local `recordType` selector containing both values when the workflow is configured. At execution time the selector is decoded locally, so Get/List/Delete do not add a Discovery request merely to translate `modelKey` to a REST route.
+Record Type is the LifeSpace `modelKey` (for example `task`). Design-time options, expressions, Trigger output and downstream Record nodes all use that plain value. CRUD calls go directly to `/spaces/{spaceId}/models/{modelKey}/records/...`, so execution adds no Discovery request and the adapter maintains no modelKey-to-route mapping. Existing `lsrt1...` workflow values are decoded only as a deprecated read-compatibility path and are never emitted or written by new configuration.
 
 Calendar-backed models use canonical `capabilityBindings.calendar` field roles instead of Event-specific field names while the node is being configured. Date-only values are normalized to `YYYY-MM-DD`. Create/Update execution does not fetch fresh semantic Discovery solely to produce an adapter-local Calendar conflict error; the canonical mutation goes directly to LifeSpace Core, which remains authoritative for Calendar validation and current authorization.
 
+## AI Agent Tool
+
+`LifeSpace Tool` is the metadata-driven AI Agent sub-node. Configure one fixed Space, Record Type and semantic operation per Tool instance, then connect multiple instances to the same n8n AI Agent. The Tool name, default description and structured AI input schema are generated from LifeSpace Progressive Runtime Discovery; hand-written descriptions are optional.
+
+- Query exposes published search/filter/comparison/local-date-window/sort/pagination semantics. Capability Query mode exposes only the capability-owned parameters and ordering that LifeSpace explicitly publishes; generic-facet composition stays narrowed until LifeSpace #228 defines it.
+- Create/Update schemas come from writable Model fields. Required fields with LifeSpace defaults are optional AI inputs, and fields the AI omits are absent from the outgoing request rather than synthesized as empty/null placeholders.
+- Delete and Action hide optimistic-concurrency `version` from the AI. The Adapter reads the current record version when required and Core remains the final authorization/concurrency/semantic authority.
+- No Task/Event/Wish-specific Tool nodes or field maps are shipped. New models become available through Discovery without source changes.
+- The ordinary `LifeSpace` workflow node remains `usableAsTool` for manually configured `$fromAI(...)` workflows, but `LifeSpace Tool` is the canonical path when the AI should receive the complete dynamic LifeSpace schema.
+
 ## LifeSpace contract compatibility
 
-This package follows the current LifeSpace Core Kernel `0.31.0` contract family. It consumes Runtime/Discovery semantics only; Eventing configuration and webhook delivery semantics are owned independently by Integration/Eventing `0.1.0`.
+This package follows the current LifeSpace Core Kernel `0.35.0` contract family. It consumes Runtime/Discovery semantics only; Eventing configuration and webhook delivery semantics are owned independently by Integration/Eventing `0.1.0`.
 
 The UX depends on these Kernel capabilities:
 
@@ -94,6 +104,10 @@ The UX depends on these Kernel capabilities:
 - `0.29.0`: canonical ordinary-record `referenceLabel` semantics plus `record` / `record_list` lookup and resolution;
 - `0.30.0`: explicit paginated Change History collection and Model Control Plane ownership split;
 - `0.31.0`: Integration/Eventing wire representation moves to the independent Integration/Eventing `0.1.0` contract while Core remains the Runtime authority.
+- `0.32.0`: `modelKey` becomes the sole Runtime address and canonical CRUD/Action paths move under `/models/{modelKey}/records`.
+- `0.33.0`: canonical structural `timeRanges` become available in progressive semantic detail without implying an overlap query API.
+- `0.34.0`: explicit `eq/lt/lte/gt/gte` comparison transports, first-class `createdAt` / `updatedAt` envelope comparisons and Core-owned datetime local-date-window conversion become discoverable.
+- `0.35.0`: grouped `query.capabilityQueries` adds the preferred `calendar.window` viewing-window query with explicit IANA viewing timezone and deterministic mixed all-day/timed ordering.
 
 The adapter prefers the `0.27+` progressive flow while configuring a node:
 
@@ -105,9 +119,9 @@ GET /me/_discovery/inventory
   -> persist stable workflow configuration
 ```
 
-Design-time callbacks prefer n8n editor-current parameters, so Fields and Actions refresh immediately after Record Type selection. A legacy 0.1.3 `modelRoute` is still readable for design-time compatibility; re-selecting Record Type moves configuration to the composable selector.
+Design-time callbacks prefer n8n editor-current parameters, so Fields and Actions refresh immediately after Record Type selection. A legacy 0.1.3 `modelRoute` remains readable only for the four previously deployed baseline models; re-selecting Record Type writes the plain `modelKey`.
 
-Execution is deliberately narrower. Get/List/Delete derive the REST route locally from the persisted Record Type selector. Create/Update submit the configured mutation without a fresh Runtime Discovery preflight. Execute Action loads only the selected model's `0.26+` static semantic detail, and reuses that detail within the same node execution for repeated items using the same Space/Record Type. No cached Discovery result is treated as authorization proof; every CRUD or Action request still goes through canonical LifeSpace Core current-state enforcement.
+Execution is deliberately narrower. Get/List/Create/Update/Delete call the canonical modelKey-addressed Runtime path directly without a fresh Runtime Discovery preflight. Execute Action loads only the selected model's `0.26+` static semantic detail, and reuses that detail within the same node execution for repeated items using the same Space/Record Type. No cached Discovery result is treated as authorization proof; every CRUD or Action request still goes through canonical LifeSpace Core current-state enforcement.
 
 The legacy aggregate `GET /me/_discovery` remains an intentional design-time compatibility fallback. Neither cached Discovery nor relation lookup is treated as authorization proof; every mutation still goes through canonical LifeSpace Runtime enforcement.
 
@@ -126,7 +140,7 @@ Examples:
 {{$vars.lifeSpaceRecordType}}
 ```
 
-Discovery-backed selectors such as **Space**, **Filter Field**, **Sort Field** and **Action** support the normal n8n pattern: choose a value from the list, or switch the parameter to an expression and provide the corresponding stable ID/key. **Record Type** uses the adapter-local `recordType` selector so a LifeSpace Trigger can feed a Record node directly without a mapping step or an extra Discovery request.
+Discovery-backed selectors such as **Space**, **Filter Field**, **Sort Field** and **Action** support the normal n8n pattern: choose a value from the list, or switch the parameter to an expression and provide the corresponding stable ID/key. **Record Type** stores the plain LifeSpace `modelKey`, so a LifeSpace Trigger can feed a Record node directly without a mapping step or an extra Discovery request.
 
 The same applies to ordinary values such as Record ID, Search, Filter Value, Return All, Limit, Sort Direction, Cursor, explicit Version, API Method, API Path and JSON Body.
 
@@ -198,9 +212,14 @@ The normal UI supports:
 
 - optional **Search**;
 - one or more typed **Filters**;
+- Discovery-driven explicit **Number Comparison** and **Date / Time Comparison** rows using the exact LifeSpace-published operator transport;
+- generic **Local Date Windows** for datetime fields advertised by Time Semantics, including envelope `createdAt` / `updatedAt`, with local dates + IANA timezone sent unchanged to Core;
+- optional grouped **Semantic Query** input generated from `query.capabilityQueries` (for example `calendar.window`) plus its published semantic ordering;
 - **Return All** to follow `nextCursor` automatically;
 - **Limit** when Return All is disabled.
 
+The adapter never derives explicit comparison parameter names from field naming and never converts local calendar windows to UTC. Those transport names and timezone/DST semantics come from LifeSpace Runtime Semantic Detail. Existing `exact/from/to` filters remain available as compatibility UI and preserve the legacy inclusive `To` behavior.
+
 Use **Sorts → Add Sort** to add zero or more sort criteria in priority order. Sortable model fields use authoritative `title` metadata from Runtime Discovery, while envelope fields such as `createdAt` / `updatedAt` are offered only when Discovery advertises them. Multiple criteria are sent as ordered repeated `sort=field:direction` query parameters.
 
 Advanced **Options** contain manual **Cursor** as an escape hatch.
@@ -256,7 +275,7 @@ One Webhook Endpoint can therefore carry events for multiple Record Types throug
 
 The Trigger verifies `X-LifeSpace-Timestamp` and `X-LifeSpace-Signature` with the LifeSpace HMAC-SHA256 contract before emitting workflow data. `endpoint.test` payloads are always accepted after signature verification.
 
-For ordinary record events, the Trigger preserves the LifeSpace `modelKey` exactly as delivered and additionally emits the n8n adapter-local `recordType` selector for the matching configured Record Type. Pass `{{$json.recordType}}` and `{{$json.recordId}}` directly to a downstream LifeSpace Record node. The downstream node derives the REST route locally from that selector.
+For ordinary record events, the Trigger preserves the LifeSpace `modelKey` exactly as delivered and emits the same plain value as `recordType` for n8n composition. Pass `{{$json.recordType}}` and `{{$json.recordId}}` directly to a downstream LifeSpace Record node; it calls the canonical modelKey-addressed Runtime path with zero Discovery.
 
 Webhook Endpoint / Event Subscription creation is intentionally not performed by the n8n Service API Token today because LifeSpace treats that configuration as a Space-management operation. The adapter does not bypass that authority boundary.
 
@@ -318,4 +337,4 @@ The adapter now consumes generic `person`, `person_list`, `record` and `record_l
 
 ## License
 
-MIT
+MIT

package/dist/nodes/LifeSpace/LifeSpace.node.d.ts

@@ -16,6 +16,12 @@ export declare class LifeSpace implements INodeType {
             getBooleanFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getNumericFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getTemporalFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getNumericComparisonFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getTemporalComparisonFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getComparisonOperatorsForCurrentField(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getLocalDateWindowFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getCapabilityQueries(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getSemanticSorts(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getPersonFilterableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getEnumValuesForCurrentFilter(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
             getSortableFields(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
@@ -23,6 +29,7 @@ export declare class LifeSpace implements INodeType {
         resourceMapping: {
             getRecordFields(this: ILoadOptionsFunctions): Promise<ResourceMapperFields>;
             getActionInputFields(this: ILoadOptionsFunctions): Promise<ResourceMapperFields>;
+            getSemanticQueryInputFields(this: ILoadOptionsFunctions): Promise<ResourceMapperFields>;
         };
     };
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;

package/dist/nodes/LifeSpace/LifeSpace.node.js

@@ -3,6 +3,81 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LifeSpace = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
 const lifespaceDiscovery_1 = require("../lifespaceDiscovery");
+const LEGACY_MODEL_ROUTE_TO_KEY = Object.freeze({
+    tasks: 'task',
+    wishes: 'wish',
+    'day-records': 'day_record',
+    events: 'event',
+});
+const LOCAL_DATE_WINDOW_SELECTOR_PREFIX = 'lsqw1.';
+const COMPARISON_OPERATOR_LABELS = Object.freeze({
+    eq: 'Equals',
+    lt: 'Less Than',
+    lte: 'Less Than or Equal',
+    gt: 'Greater Than',
+    gte: 'Greater Than or Equal',
+});
+function comparisonFieldParts(value) {
+    const raw = String(value !== null && value !== void 0 ? value : '').trim();
+    const separator = raw.indexOf(':');
+    if (separator <= 0)
+        return { field: raw, valueType: '' };
+    return { valueType: raw.slice(0, separator), field: raw.slice(separator + 1) };
+}
+function encodeLocalDateWindowSelector(comparison) {
+    const window = comparison.localDateWindow;
+    if (!window || comparison.valueType !== 'datetime')
+        return '';
+    return `${LOCAL_DATE_WINDOW_SELECTOR_PREFIX}${Buffer.from(JSON.stringify([
+        comparison.field,
+        comparison.valueType,
+        window.dateStartParameter,
+        window.dateEndExclusiveParameter,
+        window.timezoneParameter,
+    ])).toString('base64url')}`;
+}
+function decodeLocalDateWindowSelector(value) {
+    const raw = String(value !== null && value !== void 0 ? value : '').trim();
+    if (!raw.startsWith(LOCAL_DATE_WINDOW_SELECTOR_PREFIX))
+        return null;
+    try {
+        const decoded = JSON.parse(Buffer.from(raw.slice(LOCAL_DATE_WINDOW_SELECTOR_PREFIX.length), 'base64url').toString('utf8'));
+        if (!Array.isArray(decoded) || decoded.length !== 5 || decoded.some((entry) => typeof entry !== 'string' || !entry))
+            return null;
+        if (decoded[1] !== 'datetime')
+            return null;
+        return {
+            field: decoded[0],
+            valueType: 'datetime',
+            dateStartParameter: decoded[2],
+            dateEndExclusiveParameter: decoded[3],
+            timezoneParameter: decoded[4],
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function semanticQueryMapperType(parameter) {
+    if (parameter.type === 'boolean')
+        return 'boolean';
+    if (parameter.type === 'integer' || parameter.type === 'number')
+        return 'number';
+    return 'string';
+}
+function semanticQueryMapperField(parameter) {
+    var _a;
+    return {
+        id: parameter.parameter,
+        displayName: (0, lifespaceDiscovery_1.humanizeKey)(((_a = parameter.role) === null || _a === void 0 ? void 0 : _a.trim()) || parameter.parameter),
+        required: parameter.required === true,
+        defaultMatch: false,
+        canBeUsedToMatch: false,
+        display: true,
+        type: semanticQueryMapperType(parameter),
+        description: `${parameter.type}${parameter.role ? ` · ${parameter.role}` : ''} · LifeSpace query parameter ${parameter.parameter}`,
+    };
+}
 function parseJsonObject(context, itemIndex, value, fieldName) {
     const parsed = typeof value === 'string' ? JSON.parse(value) : value;
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
@@ -96,14 +171,15 @@ function normalizeActionInput(context, itemIndex, value, fields) {
     return result;
 }
 function queryParameters(context, itemIndex, limit, cursorOverride) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5;
     const qs = {};
     const search = String(context.getNodeParameter('search', itemIndex, '')).trim();
     const options = context.getNodeParameter('options', itemIndex, {});
     const configuredSorts = context.getNodeParameter('sorts.sort', itemIndex, []);
-    const legacySortField = String((_a = options.sortField) !== null && _a !== void 0 ? _a : '').trim();
-    const legacySortDirection = String((_b = options.sortDirection) !== null && _b !== void 0 ? _b : 'desc').trim();
-    const configuredCursor = String((_c = options.cursor) !== null && _c !== void 0 ? _c : '').trim();
+    const semanticSort = String((_a = context.getNodeParameter('semanticSort', itemIndex, '')) !== null && _a !== void 0 ? _a : '').trim();
+    const legacySortField = String((_b = options.sortField) !== null && _b !== void 0 ? _b : '').trim();
+    const legacySortDirection = String((_c = options.sortDirection) !== null && _c !== void 0 ? _c : 'desc').trim();
+    const configuredCursor = String((_d = options.cursor) !== null && _d !== void 0 ? _d : '').trim();
     const cursor = cursorOverride !== null && cursorOverride !== void 0 ? cursorOverride : configuredCursor;
     const filters = context.getNodeParameter('filters.filter', itemIndex, []);
     if (search)
@@ -111,10 +187,10 @@ function queryParameters(context, itemIndex, limit, cursorOverride) {
     const orderedSorts = [];
     const usedSortFields = new Set();
     for (const sort of configuredSorts) {
-        const field = String((_d = sort.field) !== null && _d !== void 0 ? _d : '').trim();
+        const field = String((_e = sort.field) !== null && _e !== void 0 ? _e : '').trim();
         if (!field)
             continue;
-        const direction = String((_e = sort.direction) !== null && _e !== void 0 ? _e : 'asc').trim();
+        const direction = String((_f = sort.direction) !== null && _f !== void 0 ? _f : 'asc').trim();
         if (direction !== 'asc' && direction !== 'desc') {
             throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Sort direction for ${field} must be asc or desc`, { itemIndex });
         }
@@ -124,56 +200,64 @@ function queryParameters(context, itemIndex, limit, cursorOverride) {
         usedSortFields.add(field);
         orderedSorts.push(`${field}:${direction}`);
     }
-    if (orderedSorts.length === 1)
+    if (semanticSort && (orderedSorts.length > 0 || legacySortField)) {
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Semantic Sort cannot be combined with field Sorts', { itemIndex });
+    }
+    if (semanticSort)
+        qs.sort = semanticSort;
+    if (!semanticSort && orderedSorts.length === 1)
         qs.sort = orderedSorts[0];
-    if (orderedSorts.length > 1)
+    if (!semanticSort && orderedSorts.length > 1)
         qs.sort = orderedSorts;
-    if (orderedSorts.length === 0 && legacySortField)
+    if (!semanticSort && orderedSorts.length === 0 && legacySortField)
         qs.sort = `${legacySortField}:${legacySortDirection}`;
     qs.limit = limit;
     if (cursor)
         qs.cursor = cursor;
     const usedKeys = new Set();
-    const setFilter = (field, operator, value) => {
-        const key = operator === 'from' ? `${field}From` : operator === 'to' ? `${field}To` : field;
+    const setQueryParameter = (key, value) => {
         if (usedKeys.has(key)) {
-            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Query filter ${key} may be supplied only once`, { itemIndex });
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Query parameter ${key} may be supplied only once`, { itemIndex });
         }
         usedKeys.add(key);
         qs[key] = typeof value === 'boolean' ? String(value) : value;
     };
+    const setFilter = (field, operator, value) => {
+        const key = operator === 'from' ? `${field}From` : operator === 'to' ? `${field}To` : field;
+        setQueryParameter(key, value);
+    };
     for (const filter of filters) {
-        const field = String((_f = filter.field) !== null && _f !== void 0 ? _f : '').trim();
-        const value = String((_g = filter.value) !== null && _g !== void 0 ? _g : '');
-        const operator = (_h = filter.operator) !== null && _h !== void 0 ? _h : 'exact';
+        const field = String((_g = filter.field) !== null && _g !== void 0 ? _g : '').trim();
+        const value = String((_h = filter.value) !== null && _h !== void 0 ? _h : '');
+        const operator = (_j = filter.operator) !== null && _j !== void 0 ? _j : 'exact';
         if (field && value !== '')
             setFilter(field, operator, value);
     }
     const typedFilters = context.getNodeParameter('filters', itemIndex, {});
-    for (const row of ((_j = typedFilters.text) !== null && _j !== void 0 ? _j : [])) {
-        const field = String((_k = row.field) !== null && _k !== void 0 ? _k : '').trim();
+    for (const row of ((_k = typedFilters.text) !== null && _k !== void 0 ? _k : [])) {
+        const field = String((_l = row.field) !== null && _l !== void 0 ? _l : '').trim();
         if (field && row.value !== undefined && row.value !== '')
             setFilter(field, 'exact', String(row.value));
     }
-    for (const row of ((_l = typedFilters.enum) !== null && _l !== void 0 ? _l : [])) {
-        const field = String((_m = row.field) !== null && _m !== void 0 ? _m : '').trim();
+    for (const row of ((_m = typedFilters.enum) !== null && _m !== void 0 ? _m : [])) {
+        const field = String((_o = row.field) !== null && _o !== void 0 ? _o : '').trim();
         const values = Array.isArray(row.values) ? row.values.map(String).filter(Boolean) : [];
         if (field && values.length)
             setFilter(field, 'exact', values.join(','));
     }
-    for (const row of ((_o = typedFilters.boolean) !== null && _o !== void 0 ? _o : [])) {
-        const field = String((_p = row.field) !== null && _p !== void 0 ? _p : '').trim();
+    for (const row of ((_p = typedFilters.boolean) !== null && _p !== void 0 ? _p : [])) {
+        const field = String((_q = row.field) !== null && _q !== void 0 ? _q : '').trim();
         if (field)
             setFilter(field, 'exact', Boolean(row.value));
     }
-    for (const row of ((_q = typedFilters.number) !== null && _q !== void 0 ? _q : [])) {
-        const field = String((_r = row.field) !== null && _r !== void 0 ? _r : '').trim();
+    for (const row of ((_r = typedFilters.number) !== null && _r !== void 0 ? _r : [])) {
+        const field = String((_s = row.field) !== null && _s !== void 0 ? _s : '').trim();
         const value = Number(row.value);
         if (field && Number.isFinite(value))
-            setFilter(field, (_s = row.operator) !== null && _s !== void 0 ? _s : 'exact', value);
+            setFilter(field, (_t = row.operator) !== null && _t !== void 0 ? _t : 'exact', value);
     }
-    for (const row of ((_t = typedFilters.temporal) !== null && _t !== void 0 ? _t : [])) {
-        const encoded = String((_u = row.field) !== null && _u !== void 0 ? _u : '').trim();
+    for (const row of ((_u = typedFilters.temporal) !== null && _u !== void 0 ? _u : [])) {
+        const encoded = String((_v = row.field) !== null && _v !== void 0 ? _v : '').trim();
         if (!encoded || row.value === undefined || row.value === '')
             continue;
         const separator = encoded.indexOf(':');
@@ -182,14 +266,59 @@ function queryParameters(context, itemIndex, limit, cursorOverride) {
         const raw = String(row.value);
         const value = fieldType === 'date' ? dateOnlyValue(context, itemIndex, raw, field) : raw;
         if (value !== null)
-            setFilter(field, (_v = row.operator) !== null && _v !== void 0 ? _v : 'exact', value);
+            setFilter(field, (_w = row.operator) !== null && _w !== void 0 ? _w : 'exact', value);
     }
-    for (const row of ((_w = typedFilters.person) !== null && _w !== void 0 ? _w : [])) {
-        const field = String((_x = row.field) !== null && _x !== void 0 ? _x : '').trim();
-        const target = String((_y = row.target) !== null && _y !== void 0 ? _y : '').trim();
+    for (const row of ((_x = typedFilters.person) !== null && _x !== void 0 ? _x : [])) {
+        const field = String((_y = row.field) !== null && _y !== void 0 ? _y : '').trim();
+        const target = String((_z = row.target) !== null && _z !== void 0 ? _z : '').trim();
         if (field && target)
             setFilter(field, 'exact', target);
     }
+    for (const row of ((_0 = typedFilters.numberComparison) !== null && _0 !== void 0 ? _0 : [])) {
+        const field = comparisonFieldParts(row.field).field;
+        const parameter = String((_1 = row.parameter) !== null && _1 !== void 0 ? _1 : '').trim();
+        const value = Number(row.value);
+        if (field && parameter && Number.isFinite(value))
+            setQueryParameter(parameter, value);
+    }
+    for (const row of ((_2 = typedFilters.temporalComparison) !== null && _2 !== void 0 ? _2 : [])) {
+        const { field, valueType } = comparisonFieldParts(row.field);
+        const parameter = String((_3 = row.parameter) !== null && _3 !== void 0 ? _3 : '').trim();
+        if (!field || !parameter || row.value === undefined || row.value === '')
+            continue;
+        const raw = String(row.value);
+        const value = valueType === 'date' ? dateOnlyValue(context, itemIndex, raw, field) : raw;
+        if (value !== null)
+            setQueryParameter(parameter, value);
+    }
+    const localDateWindows = context.getNodeParameter('localDateWindows.window', itemIndex, []);
+    for (const row of localDateWindows) {
+        const selector = decodeLocalDateWindowSelector(row.field);
+        if (!selector) {
+            if (String((_4 = row.field) !== null && _4 !== void 0 ? _4 : '').trim()) {
+                throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'Local Date Window selector is invalid. Re-select the field from Runtime Discovery.', { itemIndex });
+            }
+            continue;
+        }
+        const dateStart = dateOnlyValue(context, itemIndex, row.dateStart, selector.field);
+        const dateEndExclusive = dateOnlyValue(context, itemIndex, row.dateEndExclusive, selector.field);
+        const timezone = String((_5 = row.timezone) !== null && _5 !== void 0 ? _5 : '').trim();
+        if (dateStart !== null)
+            setQueryParameter(selector.dateStartParameter, dateStart);
+        if (dateEndExclusive !== null)
+            setQueryParameter(selector.dateEndExclusiveParameter, dateEndExclusive);
+        if (timezone)
+            setQueryParameter(selector.timezoneParameter, timezone);
+    }
+    const semanticQueryInput = mappedValue(context, itemIndex, 'semanticQueryInput');
+    for (const [parameter, value] of Object.entries(semanticQueryInput)) {
+        if (value === null || value === undefined || value === '')
+            continue;
+        if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
+            throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Semantic Query parameter ${parameter} must be a scalar value`, { itemIndex });
+        }
+        setQueryParameter(parameter, value);
+    }
     return qs;
 }
 function queryPage(context, itemIndex, response) {
@@ -313,6 +442,7 @@ function actionOption(action) {
     };
 }
 async function optionModel(context) {
+    var _a, _b;
     const spaceId = (0, lifespaceDiscovery_1.loadOptionParameter)(context, 'spaceId');
     const recordTypeValue = (0, lifespaceDiscovery_1.loadOptionParameter)(context, 'recordType');
     const legacyModelRoute = recordTypeValue ? '' : (0, lifespaceDiscovery_1.loadOptionParameter)(context, 'modelRoute');
@@ -323,10 +453,7 @@ async function optionModel(context) {
         throw new n8n_workflow_1.NodeOperationError(context.getNode(), 'LifeSpace Record Type selector is invalid. Choose a Record Type from Discovery or pass a Trigger recordType value.');
     }
     const discovery = await lifespaceDiscovery_1.loadRuntimeDiscovery.call(context);
-    const space = (0, lifespaceDiscovery_1.discoverySpace)(discovery, spaceId);
-    const model = recordType
-        ? (0, lifespaceDiscovery_1.discoveryModel)(discovery, spaceId, recordType.modelKey)
-        : space === null || space === void 0 ? void 0 : space.models.find((entry) => entry.route === legacyModelRoute);
+    const model = (0, lifespaceDiscovery_1.discoveryModel)(discovery, spaceId, (_b = (_a = recordType === null || recordType === void 0 ? void 0 : recordType.modelKey) !== null && _a !== void 0 ? _a : LEGACY_MODEL_ROUTE_TO_KEY[legacyModelRoute]) !== null && _b !== void 0 ? _b : '');
     return model ? { model, spaceId } : null;
 }
 async function filterFieldOptions(context, types, encodeType = false) {
@@ -345,6 +472,24 @@ async function filterFieldOptions(context, types, encodeType = false) {
         });
     });
 }
+async function comparisonFieldOptions(context, types) {
+    var _a;
+    const selected = await optionModel(context);
+    if (!selected)
+        return [];
+    const allowed = new Set(types);
+    return ((_a = selected.model.query.comparisons) !== null && _a !== void 0 ? _a : [])
+        .filter((comparison) => allowed.has(comparison.valueType))
+        .map((comparison) => {
+        var _a;
+        const field = selected.model.fields.find((entry) => entry.key === comparison.field);
+        return {
+            name: ((_a = field === null || field === void 0 ? void 0 : field.title) === null || _a === void 0 ? void 0 : _a.trim()) || (0, lifespaceDiscovery_1.humanizeKey)(comparison.field),
+            value: `${comparison.valueType}:${comparison.field}`,
+            description: `${comparison.source} · ${comparison.valueType} · explicit LifeSpace comparison operators`,
+        };
+    });
+}
 async function relationFieldOptions(context, cardinality, filterableOnly = false) {
     const selected = await optionModel(context);
     if (!selected)
@@ -533,6 +678,16 @@ class LifeSpace {
                                 { displayName: 'Operator', name: 'operator', type: 'options', options: [{ name: 'Equals', value: 'exact' }, { name: 'From / Greater Than or Equal', value: 'from' }, { name: 'To / Less Than or Equal', value: 'to' }], default: 'exact' },
                                 { displayName: 'Value', name: 'value', type: 'dateTime', default: '', required: true },
                             ] },
+                        { displayName: 'Number Comparison', name: 'numberComparison', values: [
+                                { displayName: 'Field Name or ID', name: 'field', type: 'options', description: 'Fields and envelope values advertised by LifeSpace explicit comparison semantics. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.', typeOptions: { loadOptionsMethod: 'getNumericComparisonFields', loadOptionsDependsOn: ['spaceId', 'recordType'] }, options: [], default: '', required: true },
+                                { displayName: 'Operator Name or ID', name: 'parameter', type: 'options', description: 'The option value is the exact query parameter published by LifeSpace; the adapter does not derive transport names. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.', typeOptions: { loadOptionsMethod: 'getComparisonOperatorsForCurrentField', loadOptionsDependsOn: ['spaceId', 'recordType', '&field'] }, options: [], default: '', required: true },
+                                { displayName: 'Value', name: 'value', type: 'number', default: 0, required: true },
+                            ] },
+                        { displayName: 'Date / Time Comparison', name: 'temporalComparison', values: [
+                                { displayName: 'Field Name or ID', name: 'field', type: 'options', description: 'Includes model date/datetime fields plus LifeSpace envelope timestamps such as createdAt/updatedAt when advertised. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.', typeOptions: { loadOptionsMethod: 'getTemporalComparisonFields', loadOptionsDependsOn: ['spaceId', 'recordType'] }, options: [], default: '', required: true },
+                                { displayName: 'Operator Name or ID', name: 'parameter', type: 'options', description: 'Uses the exact explicit comparison transport advertised by LifeSpace. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.', typeOptions: { loadOptionsMethod: 'getComparisonOperatorsForCurrentField', loadOptionsDependsOn: ['spaceId', 'recordType', '&field'] }, options: [], default: '', required: true },
+                                { displayName: 'Value', name: 'value', type: 'dateTime', default: '', required: true },
+                            ] },
                         { displayName: 'Person Filter', name: 'person', values: [
                                 { displayName: 'Field Name or ID', name: 'field', type: 'options', description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>', typeOptions: { loadOptionsMethod: 'getPersonFilterableFields', loadOptionsDependsOn: ['spaceId', 'recordType'] }, options: [], default: '', required: true },
                                 { displayName: 'Person Name or ID', name: 'target', type: 'options', description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>', typeOptions: { loadOptionsMethod: 'getRelationTargetsForCurrentField', loadOptionsDependsOn: ['spaceId', 'recordType', '&field'] }, options: [], default: '', required: true },
@@ -544,6 +699,45 @@ class LifeSpace {
                             ] },
                     ],
                 },
+                {
+                    displayName: 'Local Date Windows', name: 'localDateWindows', type: 'fixedCollection', default: {},
+                    placeholder: 'Add Local Date Window', typeOptions: { multipleValues: true },
+                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'] } },
+                    options: [{ displayName: 'Window', name: 'window', values: [
+                                { displayName: 'Field Name or ID', name: 'field', type: 'options', typeOptions: { loadOptionsMethod: 'getLocalDateWindowFields', loadOptionsDependsOn: ['spaceId', 'recordType'] }, options: [], default: '', required: true, description: 'Only datetime fields whose published comparison semantics include a local-date-window transport are offered. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.' },
+                                { displayName: 'Start Date', name: 'dateStart', type: 'dateTime', default: '', required: true, description: 'Inclusive local calendar start date. The adapter submits YYYY-MM-DD and does not calculate UTC boundaries.' },
+                                { displayName: 'End Date (Exclusive)', name: 'dateEndExclusive', type: 'dateTime', default: '', required: true, description: 'Exclusive local calendar end date' },
+                                { displayName: 'Viewing Timezone', name: 'timezone', type: 'string', default: '', required: true, placeholder: 'Europe/Amsterdam', description: 'IANA timezone passed unchanged to LifeSpace Core' },
+                            ] }],
+                },
+                {
+                    displayName: 'Semantic Query Name or ID', name: 'semanticQueryKey', type: 'options',
+                    typeOptions: { loadOptionsMethod: 'getCapabilityQueries', loadOptionsDependsOn: ['spaceId', 'recordType'] },
+                    options: [], default: '',
+                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'] } },
+                    description: 'Optional grouped capability query published by LifeSpace, for example Calendar Window. The adapter does not hard-code Event fields. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
+                {
+                    displayName: 'Semantic Query Input', name: 'semanticQueryInput', type: 'resourceMapper',
+                    default: { mappingMode: 'defineBelow', value: null }, noDataExpression: true,
+                    typeOptions: {
+                        loadOptionsDependsOn: ['spaceId', 'recordType', 'semanticQueryKey'],
+                        resourceMapper: {
+                            resourceMapperMethod: 'getSemanticQueryInputFields', mode: 'add',
+                            fieldWords: { singular: 'parameter', plural: 'parameters' }, addAllFields: true, supportAutoMap: false,
+                            noFieldsError: 'Choose a Semantic Query to load its LifeSpace-published parameters.',
+                        },
+                    },
+                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'] } },
+                    description: 'Parameters are projected directly from query.capabilityQueries. Calendar local dates/timezone are sent to Core unchanged; Core owns overlap and DST semantics.',
+                },
+                {
+                    displayName: 'Semantic Sort Name or ID', name: 'semanticSort', type: 'options',
+                    typeOptions: { loadOptionsMethod: 'getSemanticSorts', loadOptionsDependsOn: ['spaceId', 'recordType', 'semanticQueryKey'] },
+                    options: [], default: '',
+                    displayOptions: { show: { resource: ['modelRecord'], operation: ['list'] } },
+                    description: 'Optional capability-specific sort published with the selected Semantic Query. Do not combine with field Sorts. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                },
                 {
                     displayName: 'Return All', name: 'returnAll', type: 'boolean', default: false,
                     displayOptions: { show: { resource: ['modelRecord'], operation: ['list'] } },
@@ -643,7 +837,7 @@ class LifeSpace {
                         var _a;
                         return ({
                             name: `${model.display.plural} (${model.key})`,
-                            value: (0, lifespaceDiscovery_1.encodeRecordTypeSelector)(model.key, model.route),
+                            value: model.key,
                             description: (_a = model.description) !== null && _a !== void 0 ? _a : undefined,
                         });
                     });
@@ -698,6 +892,64 @@ class LifeSpace {
                 async getBooleanFilterableFields() { return filterFieldOptions(this, ['boolean']); },
                 async getNumericFilterableFields() { return filterFieldOptions(this, ['integer', 'number']); },
                 async getTemporalFilterableFields() { return filterFieldOptions(this, ['date', 'datetime'], true); },
+                async getNumericComparisonFields() { return comparisonFieldOptions(this, ['integer', 'number']); },
+                async getTemporalComparisonFields() { return comparisonFieldOptions(this, ['date', 'datetime']); },
+                async getComparisonOperatorsForCurrentField() {
+                    var _a, _b;
+                    const selected = await optionModel(this);
+                    const { field } = comparisonFieldParts(this.getCurrentNodeParameter('&field'));
+                    const comparison = (_a = selected === null || selected === void 0 ? void 0 : selected.model.query.comparisons) === null || _a === void 0 ? void 0 : _a.find((entry) => entry.field === field);
+                    return ((_b = comparison === null || comparison === void 0 ? void 0 : comparison.operators) !== null && _b !== void 0 ? _b : [])
+                        .filter((operator) => operator.transport === 'explicit')
+                        .map((operator) => {
+                        var _a;
+                        return ({
+                            name: (_a = COMPARISON_OPERATOR_LABELS[operator.operator]) !== null && _a !== void 0 ? _a : (0, lifespaceDiscovery_1.humanizeKey)(operator.operator),
+                            value: operator.parameter,
+                            description: `${operator.operator} · ${operator.transport} · ${operator.parameter}`,
+                        });
+                    });
+                },
+                async getLocalDateWindowFields() {
+                    var _a;
+                    const selected = await optionModel(this);
+                    if (!selected)
+                        return [];
+                    return ((_a = selected.model.query.comparisons) !== null && _a !== void 0 ? _a : [])
+                        .filter((comparison) => comparison.valueType === 'datetime' && comparison.localDateWindow)
+                        .map((comparison) => {
+                        var _a;
+                        const field = selected.model.fields.find((entry) => entry.key === comparison.field);
+                        return {
+                            name: ((_a = field === null || field === void 0 ? void 0 : field.title) === null || _a === void 0 ? void 0 : _a.trim()) || (0, lifespaceDiscovery_1.humanizeKey)(comparison.field),
+                            value: encodeLocalDateWindowSelector(comparison),
+                            description: `${comparison.source} · [start,end) local calendar window · Core resolves timezone/DST`,
+                        };
+                    });
+                },
+                async getCapabilityQueries() {
+                    var _a;
+                    const selected = await optionModel(this);
+                    return ((_a = selected === null || selected === void 0 ? void 0 : selected.model.query.capabilityQueries) !== null && _a !== void 0 ? _a : []).map((query) => ({
+                        name: `${(0, lifespaceDiscovery_1.humanizeKey)(query.capability)} · ${(0, lifespaceDiscovery_1.humanizeKey)(query.key)}`,
+                        value: query.key,
+                        description: `${query.semantics}${query.recurrenceExpansion === false ? ' · recurrence not expanded' : ''}`,
+                    }));
+                },
+                async getSemanticSorts() {
+                    var _a, _b, _c;
+                    const selected = await optionModel(this);
+                    const queryKey = (0, lifespaceDiscovery_1.loadOptionParameter)(this, 'semanticQueryKey');
+                    const query = (_a = selected === null || selected === void 0 ? void 0 : selected.model.query.capabilityQueries) === null || _a === void 0 ? void 0 : _a.find((entry) => entry.key === queryKey);
+                    return ((_c = (_b = query === null || query === void 0 ? void 0 : query.ordering) === null || _b === void 0 ? void 0 : _b.values) !== null && _c !== void 0 ? _c : []).map((value) => {
+                        var _a, _b;
+                        return ({
+                            name: value === ((_a = query === null || query === void 0 ? void 0 : query.ordering) === null || _a === void 0 ? void 0 : _a.default) ? `${value} (Default)` : value,
+                            value,
+                            description: `${(_b = query === null || query === void 0 ? void 0 : query.key) !== null && _b !== void 0 ? _b : 'semantic query'} ordering`,
+                        });
+                    });
+                },
                 async getPersonFilterableFields() { return relationFieldOptions(this, undefined, true); },
                 async getEnumValuesForCurrentFilter() {
                     var _a, _b;
@@ -742,10 +994,18 @@ class LifeSpace {
                         ? { fields: action.input.fields.map((field) => mapperField(field, field.required === true)) }
                         : { fields: [] };
                 },
+                async getSemanticQueryInputFields() {
+                    var _a;
+                    const selected = await optionModel(this);
+                    const queryKey = (0, lifespaceDiscovery_1.loadOptionParameter)(this, 'semanticQueryKey');
+                    const query = (_a = selected === null || selected === void 0 ? void 0 : selected.model.query.capabilityQueries) === null || _a === void 0 ? void 0 : _a.find((entry) => entry.key === queryKey);
+                    return query ? { fields: query.parameters.map(semanticQueryMapperField) } : { fields: [] };
+                },
             },
         };
     }
     async execute() {
+        var _a, _b;
         const items = this.getInputData();
         const output = [];
         const credentials = await this.getCredentials('lifeSpaceApi');
@@ -757,15 +1017,15 @@ class LifeSpace {
                 if (resource === 'modelRecord') {
                     const operation = this.getNodeParameter('operation', itemIndex);
                     const rawSpaceId = String(this.getNodeParameter('spaceId', itemIndex));
-                    const recordType = (0, lifespaceDiscovery_1.decodeRecordTypeSelector)(this.getNodeParameter('recordType', itemIndex));
-                    if (!recordType) {
+                    const recordType = (0, lifespaceDiscovery_1.decodeRecordTypeSelector)(this.getNodeParameter('recordType', itemIndex, ''));
+                    const legacyModelRoute = String((_a = this.getNodeParameter('modelRoute', itemIndex, '')) !== null && _a !== void 0 ? _a : '').trim();
+                    const rawModelKey = (_b = recordType === null || recordType === void 0 ? void 0 : recordType.modelKey) !== null && _b !== void 0 ? _b : LEGACY_MODEL_ROUTE_TO_KEY[legacyModelRoute];
+                    if (!rawModelKey) {
                         throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'LifeSpace Record Type selector is invalid. Choose a Record Type from Discovery or pass a Trigger recordType value.', { itemIndex });
                     }
-                    const rawModelKey = recordType.modelKey;
-                    const rawModelRoute = recordType.route;
                     const spaceId = encodeURIComponent(rawSpaceId);
-                    const modelRoute = encodeURIComponent(rawModelRoute);
-                    const collectionPath = `/spaces/${spaceId}/${modelRoute}`;
+                    const modelKey = encodeURIComponent(rawModelKey);
+                    const collectionPath = `/spaces/${spaceId}/models/${modelKey}/records`;
                     if (operation === 'list') {
                         const returnAll = this.getNodeParameter('returnAll', itemIndex, false);
                         if (!returnAll) {