pict-section-recordset 1.18.0 → 1.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pict-section-recordset",
-  "version": "1.18.0",
+  "version": "1.20.0",
   "description": "Pict dynamic record set management views",
   "main": "source/Pict-Section-RecordSet.js",
   "files": [

package/source/providers/RecordSet-AssociationManager.js

@@ -78,10 +78,20 @@ class PictRecordSetAssociationManager extends libPictProvider
 		const tmpSide = pSide || {};
 		const tmpEntity = tmpSide.Entity || tmpSide.RecordSet;
 		const tmpDisplayField = tmpSide.DisplayField || 'Name';
+		const tmpIDField = tmpSide.IDField || `ID${tmpEntity}`;
 		return {
 			RecordSet: tmpSide.RecordSet || tmpEntity,
 			Entity: tmpEntity,
-			IDField: tmpSide.IDField || `ID${tmpEntity}`,
+			// The field on THIS SIDE's record that identifies it for association purposes — the picker
+			// value, the display lookup key, and (by default) the value stored in the join. Usually the
+			// primary key (`ID<Entity>`), but can be any unique field (e.g. ObservationManifest is keyed
+			// by 'Name' on its join, so its side is { IDField: 'Name' }).
+			IDField: tmpIDField,
+			// The column on the JOIN ENTITY that references this side. Defaults to IDField — the common
+			// case where the join column has the same name as the side's id field. Set it when the join
+			// names this side differently: ProjectObservationManifestJoin stores the manifest by
+			// 'ObservationManifestName', so the manifest side is { IDField: 'Name', JoinField: 'ObservationManifestName' }.
+			JoinField: tmpSide.JoinField || tmpIDField,
 			DisplayField: tmpDisplayField,
 			SearchFields: (Array.isArray(tmpSide.SearchFields) && tmpSide.SearchFields.length > 0) ? tmpSide.SearchFields : [ tmpDisplayField ],
 			// No default sort: alphabetical-by-display sorts empty values first (blank rows). The picker's
@@ -135,6 +145,17 @@ class PictRecordSetAssociationManager extends libPictProvider
 		return `FOP~0~(~0~${tmpInner}~FCP~0~)~0`;
 	}
 
+	/**
+	 * URL-encode each value and comma-join, for `INN`/`NIN` filter lists. Numeric ids pass through; this
+	 * keeps string keys (e.g. manifest names with spaces) intact when a side is keyed by a name column.
+	 * @param {Array<string|number>} pValues
+	 * @return {string}
+	 */
+	_encodeList(pValues)
+	{
+		return (Array.isArray(pValues) ? pValues : []).map((pValue) => encodeURIComponent(pValue)).join(',');
+	}
+
 	/**
 	 * Fetch one page of a side's records for the matrix table (search across its SearchFields + optional
 	 * Sort, offset/limit paging). Returns the raw records + a `hasMore` flag.
@@ -186,6 +207,17 @@ class PictRecordSetAssociationManager extends libPictProvider
 			JoinEntity: pDefinition.JoinEntity,
 			JoinURLPrefix: pDefinition.JoinURLPrefix || '',
 			DefaultJoinValues: pDefinition.DefaultJoinValues || {},
+			// Per-join config columns the editor renders as inline-editable on each association row — for
+			// "rich" joins that carry settings (e.g. Journal/Spreadsheet/Ordinal). Each entry:
+			// { Field, Label?, Type? ('checkbox'|'number'|'text'|'select'), Options?, Width? }.
+			JoinEditableFields: Array.isArray(pDefinition.JoinEditableFields) ? pDefinition.JoinEditableFields : [],
+			// The defaults lifecycle hook — the overridable seam the host implements. An async
+			// `(context) => Array<{ value, joinValues? }>` returning the OTHER side's key values (+ optional
+			// per-join config) to seed for an anchor record. PSRS owns APPLYING them (dedupe + createJoin),
+			// so every association synthesizes defaults the same way; the host only decides what they are.
+			SynthesizeDefaults: (typeof pDefinition.SynthesizeDefaults === 'function') ? pDefinition.SynthesizeDefaults : false,
+			// Opt-in: auto-run synthesizeDefaults the first time the editor opens an anchor with zero joins.
+			AutoSynthesizeWhenEmpty: (pDefinition.AutoSynthesizeWhenEmpty === true),
 			SideA: this._normalizeSide(pDefinition.SideA),
 			SideB: this._normalizeSide(pDefinition.SideB),
 		};
@@ -308,7 +340,7 @@ class PictRecordSetAssociationManager extends libPictProvider
 			return Promise.resolve([]);
 		}
 		const tmpEntityProvider = this._entityProvider(tmpSides.association.JoinURLPrefix);
-		const tmpFilter = `FBV~${tmpSides.thisSide.IDField}~EQ~${encodeURIComponent(pThisID)}`;
+		const tmpFilter = `FBV~${tmpSides.thisSide.JoinField}~EQ~${encodeURIComponent(pThisID)}`;
 		return new Promise((resolve) =>
 		{
 			tmpEntityProvider.getEntitySet(tmpSides.association.JoinEntity, tmpFilter, (pError, pRecords) =>
@@ -340,7 +372,7 @@ class PictRecordSetAssociationManager extends libPictProvider
 			return Promise.resolve([]);
 		}
 		const tmpEntityProvider = this._entityProvider(tmpSides.association.JoinURLPrefix);
-		const tmpFilter = `FBL~${tmpSides.thisSide.IDField}~INN~${pThisIDs.join(',')}`;
+		const tmpFilter = `FBL~${tmpSides.thisSide.JoinField}~INN~${this._encodeList(pThisIDs)}`;
 		return new Promise((resolve) =>
 		{
 			tmpEntityProvider.getEntitySet(tmpSides.association.JoinEntity, tmpFilter, (pError, pRecords) =>
@@ -372,7 +404,7 @@ class PictRecordSetAssociationManager extends libPictProvider
 		}
 		const tmpJoins = await this.listJoinRecords(pAssociationHash, pThisRecordSetName, pThisID);
 		return tmpJoins
-			.map((pJoin) => pJoin[tmpSides.otherSide.IDField])
+			.map((pJoin) => pJoin[tmpSides.otherSide.JoinField])
 			.filter((pValue) => (pValue !== undefined && pValue !== null && pValue !== ''));
 	}
 
@@ -397,14 +429,14 @@ class PictRecordSetAssociationManager extends libPictProvider
 		const tmpJoinIDField = this.getJoinIDField(tmpSides.association);
 		const tmpJoins = await this.listJoinRecords(pAssociationHash, pThisRecordSetName, pThisID);
 		const tmpOtherIDs = tmpJoins
-			.map((pJoin) => pJoin[tmpSides.otherSide.IDField])
+			.map((pJoin) => pJoin[tmpSides.otherSide.JoinField])
 			.filter((pValue) => (pValue !== undefined && pValue !== null && pValue !== ''));
 
 		let tmpByID = {};
 		if (tmpOtherIDs.length > 0)
 		{
 			const tmpEntityProvider = this._entityProvider(tmpSides.otherSide.URLPrefix);
-			const tmpFilter = `FBL~${tmpSides.otherSide.IDField}~INN~${tmpOtherIDs.join(',')}`;
+			const tmpFilter = `FBL~${tmpSides.otherSide.IDField}~INN~${this._encodeList(tmpOtherIDs)}`;
 			const tmpOthers = await new Promise((resolve) =>
 			{
 				tmpEntityProvider.getEntitySet(tmpSides.otherSide.Entity, tmpFilter, (pError, pRecords) =>
@@ -424,10 +456,10 @@ class PictRecordSetAssociationManager extends libPictProvider
 		}
 
 		return tmpJoins
-			.filter((pJoin) => (pJoin[tmpSides.otherSide.IDField] !== undefined && pJoin[tmpSides.otherSide.IDField] !== null && pJoin[tmpSides.otherSide.IDField] !== ''))
+			.filter((pJoin) => (pJoin[tmpSides.otherSide.JoinField] !== undefined && pJoin[tmpSides.otherSide.JoinField] !== null && pJoin[tmpSides.otherSide.JoinField] !== ''))
 			.map((pJoin) =>
 			{
-				const tmpOtherID = pJoin[tmpSides.otherSide.IDField];
+				const tmpOtherID = pJoin[tmpSides.otherSide.JoinField];
 				const tmpOtherRecord = tmpByID[tmpOtherID] || {};
 				const tmpDisplay = (tmpOtherRecord[tmpSides.otherSide.DisplayField] !== undefined && tmpOtherRecord[tmpSides.otherSide.DisplayField] !== null && tmpOtherRecord[tmpSides.otherSide.DisplayField] !== '')
 					? tmpOtherRecord[tmpSides.otherSide.DisplayField]
@@ -451,18 +483,20 @@ class PictRecordSetAssociationManager extends libPictProvider
 	 * @param {string} pThisRecordSetName
 	 * @param {string|number} pThisID
 	 * @param {string|number} pOtherID
+	 * @param {Record<string, any>} [pJoinValues] - Optional extra columns to stamp on the join row (e.g.
+	 *   per-association config like { Journal: 1, Ordinal: 3 } from a synthesized default).
 	 * @return {Promise<Record<string, any>>}
 	 */
-	createJoin(pAssociationHash, pThisRecordSetName, pThisID, pOtherID)
+	createJoin(pAssociationHash, pThisRecordSetName, pThisID, pOtherID, pJoinValues)
 	{
 		const tmpSides = this.resolveSides(pAssociationHash, pThisRecordSetName);
 		if (!tmpSides)
 		{
 			return Promise.reject(new Error(`AssociationManager: cannot create join for [${pAssociationHash}] from [${pThisRecordSetName}].`));
 		}
-		const tmpRecord = Object.assign({}, tmpSides.association.DefaultJoinValues);
-		tmpRecord[tmpSides.thisSide.IDField] = pThisID;
-		tmpRecord[tmpSides.otherSide.IDField] = pOtherID;
+		const tmpRecord = Object.assign({}, tmpSides.association.DefaultJoinValues, pJoinValues || {});
+		tmpRecord[tmpSides.thisSide.JoinField] = pThisID;
+		tmpRecord[tmpSides.otherSide.JoinField] = pOtherID;
 		const tmpEntityProvider = this._entityProvider(tmpSides.association.JoinURLPrefix);
 		return new Promise((resolve, reject) =>
 		{
@@ -508,6 +542,146 @@ class PictRecordSetAssociationManager extends libPictProvider
 		});
 	}
 
+	/**
+	 * Update the config columns of an existing join row (a "rich" join's per-association settings, e.g.
+	 * Journal / Spreadsheet / Ordinal). Merges pValues over the join record and PUTs it.
+	 *
+	 * @param {string} pAssociationHash
+	 * @param {Record<string, any>} pJoinRecord - the full join row (as carried by listAssociatedRecords).
+	 * @param {Record<string, any>} pValues - the columns to change.
+	 * @return {Promise<Record<string, any>>}
+	 */
+	updateJoin(pAssociationHash, pJoinRecord, pValues)
+	{
+		const tmpAssociation = this.associations[pAssociationHash];
+		if (!tmpAssociation || !pJoinRecord)
+		{
+			return Promise.reject(new Error(`AssociationManager: cannot update join for [${pAssociationHash}].`));
+		}
+		// Minimal update — the join id + only the changed columns. The read-decorated join row can carry
+		// derived, non-column fields (e.g. a joined ModuleConfig) that the server rejects on write; Meadow
+		// updates only the fields provided, so a minimal record is both correct and safe.
+		const tmpJoinIDField = this.getJoinIDField(tmpAssociation);
+		const tmpRecord = Object.assign({ [tmpJoinIDField]: pJoinRecord[tmpJoinIDField] }, pValues || {});
+		const tmpEntityProvider = this._entityProvider(tmpAssociation.JoinURLPrefix);
+		return new Promise((resolve, reject) =>
+		{
+			tmpEntityProvider.updateEntity(tmpAssociation.JoinEntity, tmpRecord, (pError, pBody) =>
+			{
+				if (pError)
+				{
+					return reject(pError);
+				}
+				// Meadow returns a non-2xx error in the body (not the callback) — surface it as a failure.
+				if (pBody && pBody.ErrorCode)
+				{
+					return reject(new Error(`AssociationManager: join update rejected (ErrorCode ${pBody.ErrorCode}).`));
+				}
+				this._clearAssociationCache(tmpEntityProvider);
+				return resolve(pBody);
+			});
+		});
+	}
+
+	/**
+	 * The per-join config columns an association exposes as inline-editable (empty for a plain join).
+	 * @param {string} pAssociationHash
+	 * @return {Array<Record<string, any>>}
+	 */
+	getJoinEditableFields(pAssociationHash)
+	{
+		const tmpAssociation = this.associations[pAssociationHash];
+		return (tmpAssociation && Array.isArray(tmpAssociation.JoinEditableFields)) ? tmpAssociation.JoinEditableFields : [];
+	}
+
+	/**
+	 * Whether an association has a host-provided defaults synthesizer registered.
+	 * @param {string} pAssociationHash
+	 * @return {boolean}
+	 */
+	hasDefaultSynthesizer(pAssociationHash)
+	{
+		const tmpAssociation = this.associations[pAssociationHash];
+		return !!(tmpAssociation && (typeof tmpAssociation.SynthesizeDefaults === 'function'));
+	}
+
+	/**
+	 * Synthesize default associations for one anchor record — THE consistent defaults lifecycle function.
+	 * PSRS owns the "apply" half (dedupe against existing joins, then createJoin each new one with its
+	 * config); the host owns only WHAT the defaults are, via the association's overridable
+	 * `SynthesizeDefaults(context)` hook. No-op when no hook is registered.
+	 *
+	 * The hook receives `{ association, thisSide, otherSide, thisID, existingJoins, manager, pict }` and
+	 * returns `Array<{ value, joinValues? }>` — `value` is the OTHER side's key value (what goes in the
+	 * join's other JoinField), `joinValues` is optional extra config to stamp on that join row.
+	 *
+	 * @param {string} pAssociationHash
+	 * @param {string} pThisRecordSetName
+	 * @param {string|number} pThisID
+	 * @return {Promise<{ created: number, skipped: number }>}
+	 */
+	async synthesizeDefaults(pAssociationHash, pThisRecordSetName, pThisID)
+	{
+		const tmpSides = this.resolveSides(pAssociationHash, pThisRecordSetName);
+		if (!tmpSides || !this.hasDefaultSynthesizer(pAssociationHash) || pThisID === undefined || pThisID === null || pThisID === '')
+		{
+			return { created: 0, skipped: 0 };
+		}
+		const tmpExistingJoins = await this.listJoinRecords(pAssociationHash, pThisRecordSetName, pThisID);
+		const tmpExisting = {};
+		tmpExistingJoins.forEach((pJoin) =>
+		{
+			const tmpValue = pJoin[tmpSides.otherSide.JoinField];
+			if (tmpValue !== undefined && tmpValue !== null && tmpValue !== '') { tmpExisting[`${tmpValue}`] = true; }
+		});
+
+		let tmpDefaults = [];
+		try
+		{
+			tmpDefaults = await tmpSides.association.SynthesizeDefaults(
+				{
+					association: tmpSides.association,
+					thisSide: tmpSides.thisSide,
+					otherSide: tmpSides.otherSide,
+					thisID: pThisID,
+					existingJoins: tmpExistingJoins,
+					manager: this,
+					pict: this.pict,
+				});
+		}
+		catch (pError)
+		{
+			this.pict.log.error(`AssociationManager: SynthesizeDefaults hook for [${pAssociationHash}] threw: ${pError.message || pError}`);
+			return { created: 0, skipped: 0 };
+		}
+
+		let tmpCreated = 0;
+		let tmpSkipped = 0;
+		const tmpList = Array.isArray(tmpDefaults) ? tmpDefaults : [];
+		for (let i = 0; i < tmpList.length; i++)
+		{
+			const tmpDefault = tmpList[i] || {};
+			const tmpValue = (tmpDefault.value !== undefined) ? tmpDefault.value : tmpDefault.Value;
+			if (tmpValue === undefined || tmpValue === null || tmpValue === '' || tmpExisting[`${tmpValue}`])
+			{
+				tmpSkipped++;
+				continue;
+			}
+			try
+			{
+				await this.createJoin(pAssociationHash, pThisRecordSetName, pThisID, tmpValue, tmpDefault.joinValues || tmpDefault.JoinValues || {});
+				tmpExisting[`${tmpValue}`] = true;
+				tmpCreated++;
+			}
+			catch (pError)
+			{
+				this.pict.log.warn(`AssociationManager: synthesize createJoin failed for [${pAssociationHash}] value [${tmpValue}]: ${pError.message || pError}`);
+				tmpSkipped++;
+			}
+		}
+		return { created: tmpCreated, skipped: tmpSkipped };
+	}
+
 	/**
 	 * Build a `createEntityPicker` config for one side, optionally culling a live set of ids (a function
 	 * so the cull re-evaluates on every search as associations change).
@@ -538,7 +712,7 @@ class PictRecordSetAssociationManager extends libPictProvider
 			tmpConfig.BaseFilter = () =>
 			{
 				const tmpIDs = pGetExcludedIDsFn();
-				return (Array.isArray(tmpIDs) && tmpIDs.length > 0) ? `FBL~${pSide.IDField}~NIN~${tmpIDs.join(',')}` : '';
+				return (Array.isArray(tmpIDs) && tmpIDs.length > 0) ? `FBL~${pSide.IDField}~NIN~${this._encodeList(tmpIDs)}` : '';
 			};
 		}
 		return Object.assign(tmpConfig, pOverrides || {});

package/source/views/associate/RecordSet-AssociationEditor.js

@@ -65,6 +65,16 @@ const _DEFAULT_CONFIGURATION_AssociationEditor = (
 		.prsp-assoc-remove:hover { color: var(--theme-color-status-error, #b62828); background: color-mix(in srgb, var(--theme-color-status-error, #b62828) 10%, transparent); }
 		.prsp-assoc-empty { padding: 0.7rem 0.2rem; color: var(--theme-color-text-muted, #6b7686); font-size: 0.88rem; font-style: italic; }
 		.prsp-assoc-note { color: var(--theme-color-status-error, #b62828); font-size: 0.86rem; }
+		.prsp-assoc-head-right { display: flex; align-items: center; gap: 0.6rem; }
+		.prsp-assoc-synth-btn { display: inline-flex; align-items: center; gap: 0.3rem; cursor: pointer; font: inherit; font-size: 0.76rem; font-weight: 600;
+			padding: 0.2rem 0.55rem; border-radius: 6px; border: 1px solid var(--theme-color-border-default, #d7dce3);
+			background: var(--theme-color-background-tertiary, #eceef2); color: var(--theme-color-text-secondary, #45596b); }
+		.prsp-assoc-synth-btn:hover { background: var(--theme-color-background-secondary, #e2e6ec); }
+		.prsp-assoc-row-cfg { flex: 0 0 auto; display: flex; align-items: center; gap: 0.65rem; }
+		.prsp-assoc-cfg { display: inline-flex; align-items: center; gap: 0.25rem; font-size: 0.78rem; color: var(--theme-color-text-secondary, #45596b); white-space: nowrap; cursor: default; }
+		.prsp-assoc-cfg input[type="checkbox"] { cursor: pointer; }
+		.prsp-assoc-cfg-num { width: 3.4rem; font: inherit; font-size: 0.8rem; padding: 0.1rem 0.3rem; border: 1px solid var(--theme-color-border-light, #e8ebf0); border-radius: 5px; }
+		.prsp-assoc-cfg-sel { font: inherit; font-size: 0.8rem; padding: 0.05rem 0.2rem; border: 1px solid var(--theme-color-border-light, #e8ebf0); border-radius: 5px; }
 		`,
 		CSSPriority: 500,
 
@@ -86,7 +96,10 @@ const _DEFAULT_CONFIGURATION_AssociationEditor = (
 			<div class="prsp-assoc-list">
 				<div class="prsp-assoc-list-head">
 					<span class="prsp-assoc-list-title">{~D:Record.ListLabel~}</span>
-					<span class="prsp-assoc-count">{~D:Record.Count~}</span>
+					<span class="prsp-assoc-head-right">
+						<span class="prsp-assoc-count">{~D:Record.Count~}</span>
+						{~TS:PRSP-AssociationEditor-SynthBtn:Record.SynthesizeSlot~}
+					</span>
 				</div>
 				{~TS:PRSP-AssociationEditor-Row:Record.Items~}
 				{~TS:PRSP-AssociationEditor-Empty:Record.EmptySlot~}
@@ -105,6 +118,7 @@ const _DEFAULT_CONFIGURATION_AssociationEditor = (
 		<div class="prsp-assoc-row">
 			<span class="prsp-assoc-row-name">{~D:Record.Display~}</span>
 			<span class="prsp-assoc-row-chips">{~TS:PRSP-AssociationEditor-Chip:Record.Chips~}</span>
+			<span class="prsp-assoc-row-cfg">{~TS:PRSP-AssociationEditor-EditField:Record.EditFields~}</span>
 			<span class="prsp-assoc-row-id">#{~D:Record.OtherID~}</span>
 			<button type="button" class="prsp-assoc-remove" title="Remove association" onclick="_Pict.views['{~D:Record.ViewHash~}'].removeItem({~D:Record.JoinID~})">{~I:Trash~}</button>
 		</div>
@@ -113,6 +127,36 @@ const _DEFAULT_CONFIGURATION_AssociationEditor = (
 			{
 				Hash: 'PRSP-AssociationEditor-Chip',
 				Template: /*html*/`<span class="prsp-assoc-chip">{~D:Record.Text~}</span>`
+			},
+			{
+				Hash: 'PRSP-AssociationEditor-SynthBtn',
+				Template: /*html*/`<button type="button" class="prsp-assoc-synth-btn" title="Add the default associations" onclick="_Pict.views['{~D:Record.ViewHash~}'].synthesizeDefaults()">{~I:Download~} Add defaults</button>`
+			},
+			{
+				// One editable per-join config control (a "rich" join's settings, e.g. Journal / Spreadsheet
+				// / Ordinal). The kind flags pick the input; onchange writes through to the join row.
+				Hash: 'PRSP-AssociationEditor-EditField',
+				Template: /*html*/`{~TIfAbs:PRSP-AssociationEditor-EditCheckbox:Record:Record.IsCheckbox^TRUE^~}{~TIfAbs:PRSP-AssociationEditor-EditNumber:Record:Record.IsNumber^TRUE^~}{~TIfAbs:PRSP-AssociationEditor-EditSelect:Record:Record.IsSelect^TRUE^~}{~TIfAbs:PRSP-AssociationEditor-EditText:Record:Record.IsText^TRUE^~}`
+			},
+			{
+				Hash: 'PRSP-AssociationEditor-EditCheckbox',
+				Template: /*html*/`<label class="prsp-assoc-cfg"><input type="checkbox" {~D:Record.CheckedAttr~} onchange="_Pict.views['{~D:Record.ViewHash~}'].updateField({~D:Record.JoinID~},'{~D:Record.Field~}',this.checked)" />{~D:Record.Label~}</label>`
+			},
+			{
+				Hash: 'PRSP-AssociationEditor-EditNumber',
+				Template: /*html*/`<label class="prsp-assoc-cfg">{~D:Record.Label~}<input type="number" class="prsp-assoc-cfg-num" value="{~D:Record.Value~}" onchange="_Pict.views['{~D:Record.ViewHash~}'].updateField({~D:Record.JoinID~},'{~D:Record.Field~}',this.value)" /></label>`
+			},
+			{
+				Hash: 'PRSP-AssociationEditor-EditSelect',
+				Template: /*html*/`<label class="prsp-assoc-cfg">{~D:Record.Label~}<select class="prsp-assoc-cfg-sel" onchange="_Pict.views['{~D:Record.ViewHash~}'].updateField({~D:Record.JoinID~},'{~D:Record.Field~}',this.value)">{~TS:PRSP-AssociationEditor-EditOption:Record.Options~}</select></label>`
+			},
+			{
+				Hash: 'PRSP-AssociationEditor-EditText',
+				Template: /*html*/`<label class="prsp-assoc-cfg">{~D:Record.Label~}<input type="text" class="prsp-assoc-cfg-sel" value="{~D:Record.Value~}" onchange="_Pict.views['{~D:Record.ViewHash~}'].updateField({~D:Record.JoinID~},'{~D:Record.Field~}',this.value)" /></label>`
+			},
+			{
+				Hash: 'PRSP-AssociationEditor-EditOption',
+				Template: /*html*/`<option value="{~D:Record.Value~}" {~D:Record.SelectedAttr~}>{~D:Record.Label~}</option>`
 			}
 		],
 
@@ -141,8 +185,10 @@ class viewRecordSetAssociationEditor extends libPictView
 
 		// The other-side ids currently associated (the live cull set the picker reads via a closure).
 		this._otherIDs = [];
-		// The current list items (so removeItem can find the exact join record by JoinID).
+		// The current list items (so removeItem/updateField can find the exact join record by JoinID).
 		this._lastItems = [];
+		// Guard so AutoSynthesizeWhenEmpty runs at most once per anchor (no re-synthesize loop).
+		this._autoSynthesizedFor = null;
 	}
 
 	/** @return {any} The association manager provider. */
@@ -178,12 +224,28 @@ class viewRecordSetAssociationEditor extends libPictView
 		if (tmpThisID !== undefined && tmpThisID !== null && tmpThisID !== '')
 		{
 			tmpItems = await this.manager.listAssociatedRecords(this.options.AssociationHash, this.options.ThisRecordSet, tmpThisID);
+
+			// Opt-in: synthesize the default associations the first time an empty anchor is opened.
+			const tmpAssociation = this.manager.getAssociation(this.options.AssociationHash);
+			if (tmpAssociation && tmpAssociation.AutoSynthesizeWhenEmpty && (tmpItems.length === 0)
+				&& this.manager.hasDefaultSynthesizer(this.options.AssociationHash) && (this._autoSynthesizedFor !== `${tmpThisID}`))
+			{
+				this._autoSynthesizedFor = `${tmpThisID}`;
+				const tmpSynth = await this.manager.synthesizeDefaults(this.options.AssociationHash, this.options.ThisRecordSet, tmpThisID);
+				if (tmpSynth && (tmpSynth.created > 0))
+				{
+					tmpItems = await this.manager.listAssociatedRecords(this.options.AssociationHash, this.options.ThisRecordSet, tmpThisID);
+				}
+			}
 		}
 
-		// Stamp the view hash on each row so the row template's remove button can reach this instance.
+		// Per-join editable config controls (for "rich" joins) — empty array for a plain link.
+		const tmpEditableFields = this.manager.getJoinEditableFields(this.options.AssociationHash);
+		// Stamp the view hash + the editable controls on each row.
 		for (let i = 0; i < tmpItems.length; i++)
 		{
 			tmpItems[i].ViewHash = this.Hash;
+			tmpItems[i].EditFields = this._buildEditFields(tmpEditableFields, tmpItems[i]);
 		}
 		this._lastItems = tmpItems;
 		this._otherIDs = tmpItems.map((pItem) => pItem.OtherID);
@@ -203,6 +265,8 @@ class viewRecordSetAssociationEditor extends libPictView
 			// One-or-zero-element slot drives the empty-state line (TS parses inner tags; NE would not).
 			EmptySlot: (tmpItems.length === 0) ? [ { EmptyText: `No ${tmpOtherLabel} associated yet — use the search above to add some.` } ] : [],
 			PickerMissing: !tmpPickerPresent,
+			// The "Add defaults" button shows only when the host registered a defaults synthesizer.
+			SynthesizeSlot: this.manager.hasDefaultSynthesizer(this.options.AssociationHash) ? [ { ViewHash: this.Hash } ] : [],
 		};
 
 		return new Promise((resolve) =>
@@ -351,6 +415,98 @@ class viewRecordSetAssociationEditor extends libPictView
 		return fRemove();
 	}
 
+	/**
+	 * Shape an association's editable join-config fields into per-row render data (current value + the
+	 * kind flags the row template dispatches on).
+	 * @param {Array<Record<string, any>>} pFields - the association's JoinEditableFields.
+	 * @param {Record<string, any>} pItem - one decorated association row (carries its JoinRecord).
+	 * @return {Array<Record<string, any>>}
+	 */
+	_buildEditFields(pFields, pItem)
+	{
+		if (!Array.isArray(pFields) || pFields.length < 1)
+		{
+			return [];
+		}
+		const tmpJoin = pItem.JoinRecord || {};
+		return pFields.map((pField) =>
+		{
+			const tmpType = pField.Type || 'text';
+			const tmpRaw = tmpJoin[pField.Field];
+			return {
+				ViewHash: this.Hash,
+				JoinID: pItem.JoinID,
+				Field: pField.Field,
+				Label: pField.Label || pField.Field,
+				IsCheckbox: (tmpType === 'checkbox'),
+				IsNumber: (tmpType === 'number'),
+				IsSelect: (tmpType === 'select'),
+				IsText: (tmpType === 'text'),
+				CheckedAttr: ((tmpType === 'checkbox') && (tmpRaw === 1 || tmpRaw === true || tmpRaw === '1')) ? 'checked' : '',
+				Value: (tmpRaw === undefined || tmpRaw === null) ? '' : tmpRaw,
+				Options: (Array.isArray(pField.Options) ? pField.Options : []).map((pOption) =>
+				{
+					const tmpValue = (pOption && typeof pOption === 'object') ? pOption.Value : pOption;
+					return { Value: tmpValue, Label: (pOption && typeof pOption === 'object') ? (pOption.Label || pOption.Value) : pOption, SelectedAttr: (`${tmpRaw}` === `${tmpValue}`) ? 'selected' : '' };
+				}),
+			};
+		});
+	}
+
+	/**
+	 * Persist one per-join config change (a "rich" join's editable column). Writes through to the join
+	 * row in place so focus is kept; reverts to the server state on failure.
+	 * @param {string|number} pJoinID @param {string} pField @param {any} pValue
+	 * @return {Promise<void>}
+	 */
+	async updateField(pJoinID, pField, pValue)
+	{
+		const tmpItem = this._lastItems.find((pItem) => String(pItem.JoinID) === String(pJoinID));
+		if (!tmpItem || !tmpItem.JoinRecord)
+		{
+			return;
+		}
+		// Meadow booleans are 1/0.
+		const tmpValue = (pValue === true) ? 1 : ((pValue === false) ? 0 : pValue);
+		try
+		{
+			await this.manager.updateJoin(this.options.AssociationHash, tmpItem.JoinRecord, { [pField]: tmpValue });
+			tmpItem.JoinRecord[pField] = tmpValue;
+		}
+		catch (pError)
+		{
+			this.pict.log.error(`AssociationEditor [${this.Hash}]: failed to update join field ${pField}.`, pError);
+			this._toast('Could not save the change.', 'error');
+			await this.renderEditor();
+		}
+	}
+
+	/**
+	 * Seed the default associations for this anchor via the association's `SynthesizeDefaults` hook (the
+	 * "Add defaults" button). PSRS dedupes + creates; the host decides what the defaults are. Reloads after.
+	 * @return {Promise<void>}
+	 */
+	async synthesizeDefaults()
+	{
+		if (!this.manager.hasDefaultSynthesizer(this.options.AssociationHash))
+		{
+			return;
+		}
+		let tmpResult = { created: 0, skipped: 0 };
+		try
+		{
+			tmpResult = await this.manager.synthesizeDefaults(this.options.AssociationHash, this.options.ThisRecordSet, this.options.ThisID);
+		}
+		catch (pError)
+		{
+			this.pict.log.error(`AssociationEditor [${this.Hash}]: synthesize defaults failed.`, pError);
+			this._toast('Could not add the defaults.', 'error');
+			return;
+		}
+		this._toast((tmpResult.created > 0) ? `Added ${tmpResult.created} default${tmpResult.created === 1 ? '' : 's'}.` : 'No new defaults to add.', (tmpResult.created > 0) ? 'success' : 'info');
+		await this.renderEditor();
+	}
+
 	/**
 	 * Non-blocking notification via the host modal's toast, when available.
 	 * @param {string} pMessage @param {string} pType