n8n-nodes-lifespace 0.1.3 → 0.1.5

package/README.md

@@ -70,7 +70,9 @@ 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.
 
-Calendar-backed models use canonical `capabilityBindings.calendar` field roles instead of Event-specific field names. Date-only values are normalized to `YYYY-MM-DD`, and contradictory all-day/timed state is rejected locally before the mutation request while Core remains the final validation authority.
+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.
+
+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.
 
 ## LifeSpace contract compatibility
 
@@ -93,17 +95,21 @@ The UX depends on these Kernel capabilities:
 - `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.
 
-The adapter prefers the `0.27+` progressive flow:
+The adapter prefers the `0.27+` progressive flow while configuring a node:
 
 ```text
 GET /me/_discovery/inventory
   -> choose current Space / Record Type
   -> GET /spaces/{spaceId}/_discovery/models/{modelKey}
   -> relation target lookup / reference resolution only when needed
-  -> canonical Runtime request
+  -> persist stable workflow configuration
 ```
 
-The legacy aggregate `GET /me/_discovery` remains an intentional compatibility fallback. Neither cached Discovery nor relation lookup is treated as authorization proof; every mutation still goes through canonical LifeSpace Runtime enforcement.
+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.
+
+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.
+
+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.
 
 Ordinary Record CRUD/Action routes remain model-contract surfaces derived from published Model Definitions; the n8n adapter does not maintain a second copy of those schemas.
 
@@ -116,10 +122,11 @@ Examples:
 ```text
 {{$json.spaceId}}
 {{$json.recordId}}
+{{$json.recordType}}
 {{$vars.lifeSpaceRecordType}}
 ```
 
-Discovery-backed selectors such as **Space**, **Record Type**, **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.
+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.
 
 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.
 
@@ -173,13 +180,15 @@ Older compatible Discovery responses without relation lookup metadata retain the
 
 The current n8n UI loads bounded relation options when the relevant field is configured. Very large target sets should use expressions with stable IDs until n8n exposes a searchable dynamic relation option surface that can consume LifeSpace's paginated/searchable lookup directly.
 
+At execution time Create uses the already-configured Record Type selector and sends the canonical mutation directly. This avoids paying a current-principal inventory round trip merely to rediscover whether adapter-side semantic preflight would improve an error message. Core remains the final authority for schema, Capability, Policy and authorization checks.
+
 ### Update and Delete
 
 LifeSpace uses optimistic concurrency.
 
 By default the node reads the current Record version immediately before Update/Delete and sends that version with the mutation. This keeps the ordinary n8n UI free from mandatory internal `version` entry while preserving stale-write protection for the actual mutation race.
 
-For Calendar-backed Update, the node also combines the current record with the proposed patch and checks the discovered all-day/timed field roles before sending the mutation. Core validation remains authoritative.
+Update does not add a Runtime Discovery request before the mutation. When no explicit version is configured, the current-record read is for optimistic concurrency rather than semantic discovery. Core validates Calendar and other Capability semantics against the resulting mutation.
 
 If a workflow intentionally needs to bind a known version, add **Concurrency Options → Version**.
 
@@ -204,7 +213,7 @@ Choose an Action from Runtime Discovery.
 
 **Action Input** contains only semantic/domain inputs. LifeSpace concurrency metadata is not rendered as a business field. For the current `record-version` contract, the node reads the current Record version immediately before Action execution and sends it using the transport declared by Runtime Discovery.
 
-Execution-time Action metadata uses the same progressive inventory + selected-model detail path rather than loading the full cross-Space Discovery document.
+Execution-time Action metadata is loaded directly from the selected model's static semantic-detail endpoint rather than first loading the broad current-principal inventory. The static detail is reused for repeated items of the same Space/Record Type during one node execution. It is semantic input only, not cached authority; Core rechecks current Action authority on every invocation.
 
 This means actions such as `complete` / `reopen` no longer ask users to type an internal version value.
 
@@ -247,6 +256,8 @@ 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.
+
 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.
 
 ## What the package provides

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LifeSpace = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
-const calendarMutation_1 = require("../calendarMutation");
 const lifespaceDiscovery_1 = require("../lifespaceDiscovery");
 function parseJsonObject(context, itemIndex, value, fieldName) {
     const parsed = typeof value === 'string' ? JSON.parse(value) : value;
@@ -272,26 +271,24 @@ async function currentRecord(context, itemIndex, baseUrl, recordPath) {
 async function currentRecordVersion(context, itemIndex, baseUrl, recordPath) {
     return recordVersion(context, itemIndex, await currentRecord(context, itemIndex, baseUrl, recordPath));
 }
-async function mutationVersion(context, itemIndex, baseUrl, recordPath, loadedRecord) {
+async function mutationVersion(context, itemIndex, baseUrl, recordPath) {
     const options = context.getNodeParameter('mutationOptions', itemIndex, {});
     const configuredVersion = options.version;
     if (typeof configuredVersion === 'number' && Number.isInteger(configuredVersion) && configuredVersion >= 1) {
         return configuredVersion;
     }
-    return loadedRecord
-        ? recordVersion(context, itemIndex, loadedRecord)
-        : currentRecordVersion(context, itemIndex, baseUrl, recordPath);
+    return currentRecordVersion(context, itemIndex, baseUrl, recordPath);
 }
-async function executionModel(context, itemIndex, baseUrl, spaceId, modelRoute) {
-    const discovery = await (0, lifespaceDiscovery_1.loadExecutionRuntimeDiscovery)(context, baseUrl, spaceId, modelRoute);
-    const model = (0, lifespaceDiscovery_1.discoveryModel)(discovery, spaceId, modelRoute);
+async function executionModel(context, itemIndex, baseUrl, spaceId, modelKey) {
+    const discovery = await (0, lifespaceDiscovery_1.loadExecutionRuntimeDiscovery)(context, baseUrl, spaceId, modelKey);
+    const model = (0, lifespaceDiscovery_1.discoveryModel)(discovery, spaceId, modelKey);
     if (!model) {
-        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `LifeSpace Record Type ${modelRoute} is not available`, { itemIndex });
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `LifeSpace Record Type ${modelKey} is not available`, { itemIndex });
     }
     return model;
 }
-async function actionBodyWithConcurrency(context, itemIndex, baseUrl, spaceId, modelRoute, recordPath, actionKey, semanticInput) {
-    const model = await executionModel(context, itemIndex, baseUrl, spaceId, modelRoute);
+async function actionBodyWithConcurrency(context, itemIndex, baseUrl, spaceId, modelKey, recordPath, actionKey, semanticInput) {
+    const model = await executionModel(context, itemIndex, baseUrl, spaceId, modelKey);
     const action = model.actions.find((entry) => entry.key === actionKey);
     if (!action) {
         throw new n8n_workflow_1.NodeOperationError(context.getNode(), `LifeSpace Action ${actionKey} is not available`, { itemIndex });
@@ -316,12 +313,20 @@ function actionOption(action) {
     };
 }
 async function optionModel(context) {
-    const spaceId = String(context.getNodeParameter('spaceId', '')).trim();
-    const modelRoute = String(context.getNodeParameter('modelRoute', '')).trim();
-    if (!spaceId || !modelRoute)
+    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');
+    if (!spaceId || (!recordTypeValue && !legacyModelRoute))
         return null;
+    const recordType = recordTypeValue ? (0, lifespaceDiscovery_1.decodeRecordTypeSelector)(recordTypeValue) : null;
+    if (recordTypeValue && !recordType) {
+        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 model = (0, lifespaceDiscovery_1.discoveryModel)(discovery, spaceId, modelRoute);
+    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);
     return model ? { model, spaceId } : null;
 }
 async function filterFieldOptions(context, types, encodeType = false) {
@@ -344,7 +349,7 @@ async function relationFieldOptions(context, cardinality, filterableOnly = false
     const selected = await optionModel(context);
     if (!selected)
         return [];
-    const operation = String(context.getNodeParameter('operation', 'create'));
+    const operation = (0, lifespaceDiscovery_1.loadOptionParameter)(context, 'operation') || 'create';
     const filterable = new Set(selected.model.query.filterable);
     return selected.model.fields
         .filter((field) => { var _a; return ((_a = field.relation) === null || _a === void 0 ? void 0 : _a.lookup.supported) === true; })
@@ -419,7 +424,7 @@ class LifeSpace {
                     description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
                 },
                 {
-                    displayName: 'Record Type Name or ID', name: 'modelRoute', type: 'options',
+                    displayName: 'Record Type Name or ID', name: 'recordType', type: 'options',
                     typeOptions: { loadOptionsMethod: 'getRecordTypes', loadOptionsDependsOn: ['spaceId', 'operation'] },
                     options: [], default: '', required: true, displayOptions: { show: { resource: ['modelRecord'] } },
                     description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
@@ -432,7 +437,7 @@ class LifeSpace {
                     displayName: 'Fields', name: 'fields', type: 'resourceMapper',
                     default: { mappingMode: 'defineBelow', value: null }, noDataExpression: true, required: true,
                     typeOptions: {
-                        loadOptionsDependsOn: ['spaceId', 'modelRoute', 'operation'],
+                        loadOptionsDependsOn: ['spaceId', 'recordType', 'operation'],
                         resourceMapper: {
                             resourceMapperMethod: 'getRecordFields', mode: 'add',
                             fieldWords: { singular: 'field', plural: 'fields' }, addAllFields: true, supportAutoMap: false,
@@ -450,7 +455,7 @@ class LifeSpace {
                             displayName: 'Date', name: 'date', values: [
                                 {
                                     displayName: 'Field Name or ID', name: 'field', type: 'options',
-                                    typeOptions: { loadOptionsMethod: 'getWritableDateFields', loadOptionsDependsOn: ['spaceId', 'modelRoute', 'operation'] },
+                                    typeOptions: { loadOptionsMethod: 'getWritableDateFields', loadOptionsDependsOn: ['spaceId', 'recordType', 'operation'] },
                                     options: [], default: '', required: true,
                                     description: 'Choose a LifeSpace date field. The node submits calendar-date YYYY-MM-DD values. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
                                 },
@@ -466,12 +471,12 @@ class LifeSpace {
                                 {
                                     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: 'getSingleRelationFields', loadOptionsDependsOn: ['spaceId', 'modelRoute', 'operation'] },
+                                    typeOptions: { loadOptionsMethod: 'getSingleRelationFields', loadOptionsDependsOn: ['spaceId', 'recordType', 'operation'] },
                                     options: [], default: '', required: true,
                                 },
                                 {
                                     displayName: 'Target Name or ID', name: 'target', type: 'options',
-                                    typeOptions: { loadOptionsMethod: 'getRelationTargetsForCurrentField', loadOptionsDependsOn: ['spaceId', 'modelRoute', '&field'] },
+                                    typeOptions: { loadOptionsMethod: 'getRelationTargetsForCurrentField', loadOptionsDependsOn: ['spaceId', 'recordType', '&field'] },
                                     options: [], default: '',
                                     description: 'Choose an authorized relation target, or use an expression with a stable LifeSpace ID. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
                                 },
@@ -485,12 +490,12 @@ class LifeSpace {
                                 {
                                     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: 'getMultiRelationFields', loadOptionsDependsOn: ['spaceId', 'modelRoute', 'operation'] },
+                                    typeOptions: { loadOptionsMethod: 'getMultiRelationFields', loadOptionsDependsOn: ['spaceId', 'recordType', 'operation'] },
                                     options: [], default: '', required: true,
                                 },
                                 {
                                     displayName: 'Targets Names or IDs', name: 'targets', type: 'multiOptions',
-                                    typeOptions: { loadOptionsMethod: 'getRelationTargetsForCurrentField', loadOptionsDependsOn: ['spaceId', 'modelRoute', '&field'] },
+                                    typeOptions: { loadOptionsMethod: 'getRelationTargetsForCurrentField', loadOptionsDependsOn: ['spaceId', 'recordType', '&field'] },
                                     options: [], default: [],
                                     description: 'Choose authorized relation targets, or use an expression with stable LifeSpace IDs. Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
                                 },
@@ -507,30 +512,30 @@ class LifeSpace {
                     displayOptions: { show: { resource: ['modelRecord'], operation: ['list'] } },
                     options: [
                         { displayName: 'Text Filter', name: 'text', 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: 'getTextFilterableFields', loadOptionsDependsOn: ['spaceId', 'modelRoute'] }, options: [], default: '', required: true },
+                                { 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: 'getTextFilterableFields', loadOptionsDependsOn: ['spaceId', 'recordType'] }, options: [], default: '', required: true },
                                 { displayName: 'Value', name: 'value', type: 'string', default: '', required: true },
                             ] },
                         { displayName: 'Enum Filter', name: 'enum', 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: 'getEnumFilterableFields', loadOptionsDependsOn: ['spaceId', 'modelRoute'] }, options: [], default: '', required: true },
-                                { displayName: 'Value Names or IDs', name: 'values', type: 'multiOptions', description: 'Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>', typeOptions: { loadOptionsMethod: 'getEnumValuesForCurrentFilter', loadOptionsDependsOn: ['spaceId', 'modelRoute', '&field'] }, options: [], default: [], required: true },
+                                { 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: 'getEnumFilterableFields', loadOptionsDependsOn: ['spaceId', 'recordType'] }, options: [], default: '', required: true },
+                                { displayName: 'Value Names or IDs', name: 'values', type: 'multiOptions', description: 'Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>', typeOptions: { loadOptionsMethod: 'getEnumValuesForCurrentFilter', loadOptionsDependsOn: ['spaceId', 'recordType', '&field'] }, options: [], default: [], required: true },
                             ] },
                         { displayName: 'Boolean Filter', name: 'boolean', 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: 'getBooleanFilterableFields', loadOptionsDependsOn: ['spaceId', 'modelRoute'] }, options: [], default: '', required: true },
+                                { 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: 'getBooleanFilterableFields', loadOptionsDependsOn: ['spaceId', 'recordType'] }, options: [], default: '', required: true },
                                 { displayName: 'Value', name: 'value', type: 'boolean', default: true },
                             ] },
                         { displayName: 'Number Filter', name: 'number', 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: 'getNumericFilterableFields', loadOptionsDependsOn: ['spaceId', 'modelRoute'] }, options: [], default: '', required: true },
+                                { 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: 'getNumericFilterableFields', loadOptionsDependsOn: ['spaceId', 'recordType'] }, options: [], default: '', required: true },
                                 { 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: 'number', default: 0, required: true },
                             ] },
                         { displayName: 'Date / Time Filter', name: 'temporal', 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: 'getTemporalFilterableFields', loadOptionsDependsOn: ['spaceId', 'modelRoute'] }, options: [], default: '', required: true },
+                                { 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: 'getTemporalFilterableFields', loadOptionsDependsOn: ['spaceId', 'recordType'] }, options: [], default: '', required: true },
                                 { 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: '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', 'modelRoute'] }, 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', 'modelRoute', '&field'] }, options: [], default: '', required: true },
+                                { 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 },
                             ] },
                         { displayName: 'Raw / Legacy Filter', name: 'filter', values: [
                                 { displayName: 'Field Name or ID', name: 'field', type: 'options', typeOptions: { loadOptionsMethod: 'getFilterableFields' }, options: [], default: '', required: true, description: 'Compatibility and unsupported relation escape hatch. Prefer the typed filter variants above. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.' },
@@ -572,7 +577,7 @@ class LifeSpace {
                 },
                 {
                     displayName: 'Action Name or ID', name: 'actionKey', type: 'options',
-                    typeOptions: { loadOptionsMethod: 'getActions', loadOptionsDependsOn: ['spaceId', 'modelRoute'] },
+                    typeOptions: { loadOptionsMethod: 'getActions', loadOptionsDependsOn: ['spaceId', 'recordType'] },
                     options: [], default: '', required: true,
                     displayOptions: { show: { resource: ['modelRecord'], operation: ['executeAction'] } },
                     description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
@@ -581,7 +586,7 @@ class LifeSpace {
                     displayName: 'Action Input', name: 'actionInput', type: 'resourceMapper',
                     default: { mappingMode: 'defineBelow', value: null }, noDataExpression: true,
                     typeOptions: {
-                        loadOptionsDependsOn: ['spaceId', 'modelRoute', 'actionKey'],
+                        loadOptionsDependsOn: ['spaceId', 'recordType', 'actionKey'],
                         resourceMapper: { resourceMapperMethod: 'getActionInputFields', mode: 'add', fieldWords: { singular: 'input', plural: 'inputs' }, addAllFields: true, supportAutoMap: false, noFieldsError: 'This LifeSpace Action has no semantic input fields.' },
                     },
                     displayOptions: { show: { resource: ['modelRecord'], operation: ['executeAction'] } },
@@ -622,19 +627,26 @@ class LifeSpace {
                     });
                 },
                 async getRecordTypes() {
-                    const spaceId = String(this.getNodeParameter('spaceId', '')).trim();
+                    const spaceId = (0, lifespaceDiscovery_1.loadOptionParameter)(this, 'spaceId');
                     if (!spaceId)
                         return [];
                     const discovery = await lifespaceDiscovery_1.loadRuntimeDiscovery.call(this);
                     const space = (0, lifespaceDiscovery_1.discoverySpace)(discovery, spaceId);
                     if (!space)
                         return [];
-                    const operation = String(this.getNodeParameter('operation', 'list'));
+                    const operation = (0, lifespaceDiscovery_1.loadOptionParameter)(this, 'operation') || 'list';
                     return space.models
                         .filter((model) => operation === 'executeAction'
                         ? model.actions.length > 0
                         : model.access.includes(requiredAccessForOperation(operation)))
-                        .map((model) => { var _a; return ({ name: `${model.display.plural} (${model.route})`, value: model.route, description: (_a = model.description) !== null && _a !== void 0 ? _a : undefined }); });
+                        .map((model) => {
+                        var _a;
+                        return ({
+                            name: `${model.display.plural} (${model.key})`,
+                            value: (0, lifespaceDiscovery_1.encodeRecordTypeSelector)(model.key, model.route),
+                            description: (_a = model.description) !== null && _a !== void 0 ? _a : undefined,
+                        });
+                    });
                 },
                 async getActions() {
                     const selected = await optionModel(this);
@@ -658,7 +670,7 @@ class LifeSpace {
                     const selected = await optionModel(this);
                     if (!selected)
                         return [];
-                    const operation = String(this.getNodeParameter('operation', 'create'));
+                    const operation = (0, lifespaceDiscovery_1.loadOptionParameter)(this, 'operation') || 'create';
                     return selected.model.fields
                         .filter((field) => field.type === 'date' && !field.readOnly && (operation !== 'update' || !field.immutable))
                         .map((field) => { var _a; return ({ name: ((_a = field.title) === null || _a === void 0 ? void 0 : _a.trim()) || (0, lifespaceDiscovery_1.humanizeKey)(field.key), value: field.key, description: field.description }); });
@@ -713,7 +725,7 @@ class LifeSpace {
                     const selected = await optionModel(this);
                     if (!selected)
                         return { fields: [] };
-                    const operation = String(this.getNodeParameter('operation', 'create'));
+                    const operation = (0, lifespaceDiscovery_1.loadOptionParameter)(this, 'operation') || 'create';
                     const writableFields = selected.model.fields
                         .filter((field) => !field.readOnly && (operation !== 'update' || !field.immutable))
                         .filter((field) => field.type !== 'date')
@@ -724,7 +736,7 @@ class LifeSpace {
                 },
                 async getActionInputFields() {
                     const selected = await optionModel(this);
-                    const actionKey = String(this.getNodeParameter('actionKey', '')).trim();
+                    const actionKey = (0, lifespaceDiscovery_1.loadOptionParameter)(this, 'actionKey');
                     const action = selected === null || selected === void 0 ? void 0 : selected.model.actions.find((entry) => entry.key === actionKey);
                     return action
                         ? { fields: action.input.fields.map((field) => mapperField(field, field.required === true)) }
@@ -734,7 +746,6 @@ class LifeSpace {
         };
     }
     async execute() {
-        var _a;
         const items = this.getInputData();
         const output = [];
         const credentials = await this.getCredentials('lifeSpaceApi');
@@ -746,7 +757,12 @@ class LifeSpace {
                 if (resource === 'modelRecord') {
                     const operation = this.getNodeParameter('operation', itemIndex);
                     const rawSpaceId = String(this.getNodeParameter('spaceId', itemIndex));
-                    const rawModelRoute = String(this.getNodeParameter('modelRoute', itemIndex));
+                    const recordType = (0, lifespaceDiscovery_1.decodeRecordTypeSelector)(this.getNodeParameter('recordType', itemIndex));
+                    if (!recordType) {
+                        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}`;
@@ -787,8 +803,6 @@ class LifeSpace {
                     }
                     else if (operation === 'create') {
                         const body = mutationMappedValues(this, itemIndex);
-                        const model = await executionModel(this, itemIndex, baseUrl, rawSpaceId, rawModelRoute);
-                        (0, calendarMutation_1.validateCalendarMutation)(this, itemIndex, model, body);
                         response = await this.helpers.httpRequestWithAuthentication.call(this, 'lifeSpaceApi', { method: 'POST', url: `${baseUrl}${collectionPath}`, body, json: true });
                     }
                     else {
@@ -800,17 +814,12 @@ class LifeSpace {
                         }
                         else if (operation === 'update') {
                             const body = mutationMappedValues(this, itemIndex);
-                            const model = await executionModel(this, itemIndex, baseUrl, rawSpaceId, rawModelRoute);
-                            const loadedRecord = ((_a = model.capabilityBindings) === null || _a === void 0 ? void 0 : _a.calendar)
-                                ? await currentRecord(this, itemIndex, baseUrl, recordPath)
-                                : undefined;
-                            (0, calendarMutation_1.validateCalendarMutation)(this, itemIndex, model, body, loadedRecord);
                             options = {
                                 method: 'PATCH',
                                 url: `${baseUrl}${recordPath}`,
                                 body: {
                                     ...body,
-                                    version: await mutationVersion(this, itemIndex, baseUrl, recordPath, loadedRecord),
+                                    version: await mutationVersion(this, itemIndex, baseUrl, recordPath),
                                 },
                                 json: true,
                             };
@@ -829,7 +838,7 @@ class LifeSpace {
                             options = {
                                 method: 'POST',
                                 url: `${baseUrl}${recordPath}/actions/${actionKey}`,
-                                body: await actionBodyWithConcurrency(this, itemIndex, baseUrl, rawSpaceId, rawModelRoute, recordPath, rawActionKey, mappedValue(this, itemIndex, 'actionInput')),
+                                body: await actionBodyWithConcurrency(this, itemIndex, baseUrl, rawSpaceId, rawModelKey, recordPath, rawActionKey, mappedValue(this, itemIndex, 'actionInput')),
                                 json: true,
                             };
                         }