@terminalfour/terminalfour-js 1.0.2 → 1.1.0

package/dist/cjs/resources/navigation-resource.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NavigationResource = exports.NavigationObject = exports.NAVIGATION_TYPE_NAMES = void 0;
+const utils_js_1 = require("../utils.js");
 /** Maps SDK type codes to API type codes */
 const SDK_TO_API = {
     'a-to-z': 'a2z',
@@ -988,6 +989,8 @@ class NavigationObject {
         this.enabled = raw.isEnabled;
         this.cachingEnabled = raw.isCachingEnabled;
         this.previewEnabled = raw.isPreviewModeEnabled;
+        this.primaryGroup = (0, utils_js_1.readPrimaryGroup)(raw.primaryGroup);
+        this.sharedGroups = (0, utils_js_1.readSharedGroups)(raw.sharedGroups);
         // Convert properties to camelCase keys with string values
         const originalKeys = [];
         const rawCamelProps = {};
@@ -1003,6 +1006,7 @@ class NavigationObject {
     }
     /** Persists current property values to the server via PUT. */
     async save() {
+        (0, utils_js_1.assertGroupsValid)(this.primaryGroup, this.sharedGroups);
         // Apply type-aware write transformation (coerce back to strings, derive hidden fields)
         const camelStringProps = transformPropertiesWrite(this.type, this.properties);
         // Rebuild properties in API format
@@ -1022,6 +1026,8 @@ class NavigationObject {
             isEnabled: this.enabled,
             isCachingEnabled: this.cachingEnabled,
             isPreviewModeEnabled: this.previewEnabled,
+            primaryGroup: (0, utils_js_1.writePrimaryGroup)(this.primaryGroup),
+            sharedGroups: (0, utils_js_1.writeSharedGroups)(this.sharedGroups),
             properties: apiProperties,
         };
         await this._httpClient.request({
@@ -1239,6 +1245,7 @@ class NavigationResource {
             throw new Error('Navigation object type is required');
         if (!exports.NAVIGATION_TYPE_NAMES[data.type])
             throw new Error(`Unknown navigation type "${data.type}"`);
+        (0, utils_js_1.assertGroupsValid)(data.primaryGroup ?? 0, data.sharedGroups);
         const apiType = SDK_TO_API[data.type];
         const properties = await this.buildProperties(data.type, (data.properties ?? {}));
         const body = {
@@ -1248,8 +1255,8 @@ class NavigationResource {
             name: data.name,
             description: data.description ?? '',
             navigationType: apiType,
-            sharedGroups: [],
-            primaryGroup: { id: 0 },
+            sharedGroups: (0, utils_js_1.writeSharedGroups)(data.sharedGroups),
+            primaryGroup: (0, utils_js_1.writePrimaryGroup)(data.primaryGroup ?? 0),
             properties,
         };
         // CSS Selector quirk: requires "section-name": "on" at the top level
@@ -1293,6 +1300,10 @@ class NavigationResource {
             nav.previewEnabled = data.previewEnabled;
         if (data.cachingEnabled !== undefined)
             nav.cachingEnabled = data.cachingEnabled;
+        if (data.primaryGroup !== undefined)
+            nav.primaryGroup = data.primaryGroup;
+        if (data.sharedGroups !== undefined)
+            nav.sharedGroups = data.sharedGroups;
         // Merge properties rather than replace — callers pass only what changes
         if (data.properties !== undefined) {
             nav.properties = {

package/dist/cjs/resources/page-layout-resource.d.ts

@@ -1,4 +1,5 @@
 import { HttpClient } from '../http-client.js';
+import { RawPrimaryGroup } from '../utils.js';
 /** Raw page layout detail from GET /pageLayout/{id} */
 interface RawPageLayoutDetail {
     id: number;
@@ -10,6 +11,10 @@ interface RawPageLayoutDetail {
     fileExtension?: string;
     syntaxType?: number;
     layoutProcessor?: number;
+    primaryGroup?: RawPrimaryGroup;
+    sharedGroups?: Array<{
+        id: number;
+    }>;
     [key: string]: unknown;
 }
 /** A page layout summary returned from list() */
@@ -28,6 +33,10 @@ export declare class PageLayout {
     fileExtension: string;
     syntax: string;
     processor: string;
+    /** Owning group ID. 0 = no primary group (Global). */
+    primaryGroup: number;
+    /** Group IDs this page layout is shared with. */
+    sharedGroups: number[];
     private readonly _httpClient;
     private _rawData;
     private _syntaxMap;
@@ -63,6 +72,8 @@ export declare class PageLayoutResource {
         fileExtension?: string;
         syntax?: string;
         processor?: string;
+        primaryGroup?: number;
+        sharedGroups?: number[];
     }): Promise<PageLayout>;
     /** Creates a new page layout. */
     create(data: {

package/dist/cjs/resources/page-layout-resource.js

@@ -22,6 +22,8 @@ class PageLayout {
         const procName = processorMap.get(raw.layoutProcessor ?? 0) ?? '';
         const procEntry = Object.entries(PAGE_PROCESSOR_MAP).find(([, apiName]) => apiName === procName);
         this.processor = procEntry ? procEntry[0] : procName || `unknown (${raw.layoutProcessor})`;
+        this.primaryGroup = (0, utils_js_1.readPrimaryGroup)(raw.primaryGroup);
+        this.sharedGroups = (0, utils_js_1.readSharedGroups)(raw.sharedGroups);
         Object.defineProperty(this, '_httpClient', { value: httpClient, enumerable: false });
         Object.defineProperty(this, '_rawData', { value: raw, enumerable: false, writable: true });
         Object.defineProperty(this, '_syntaxMap', { value: syntaxMap, enumerable: false });
@@ -29,6 +31,7 @@ class PageLayout {
     }
     /** Persists current property values to the server via PUT. */
     async save() {
+        (0, utils_js_1.assertGroupsValid)(this.primaryGroup, this.sharedGroups);
         // Resolve syntax name to ID
         let syntaxId = this._rawData.syntaxType;
         if (this._syntaxMap) {
@@ -53,6 +56,8 @@ class PageLayout {
             fileExtension: this.fileExtension,
             syntaxType: String(syntaxId),
             layoutProcessor: String(processorId),
+            primaryGroup: (0, utils_js_1.writePrimaryGroup)(this.primaryGroup),
+            sharedGroups: (0, utils_js_1.writeSharedGroups)(this.sharedGroups),
         };
         await this._httpClient.request({
             method: 'PUT',
@@ -136,6 +141,10 @@ class PageLayoutResource {
             layout.syntax = data.syntax;
         if (data.processor !== undefined)
             layout.processor = data.processor;
+        if (data.primaryGroup !== undefined)
+            layout.primaryGroup = data.primaryGroup;
+        if (data.sharedGroups !== undefined)
+            layout.sharedGroups = data.sharedGroups;
         await layout.save();
         return layout;
     }
@@ -143,6 +152,7 @@ class PageLayoutResource {
     async create(data) {
         if (!data.name?.trim())
             throw new Error('Page layout name is required');
+        (0, utils_js_1.assertGroupsValid)(data.primaryGroup ?? 0, data.sharedGroups);
         const [syntaxMap, processorMap] = await Promise.all([
             this.getSyntaxMap(),
             this.getProcessorMap(),
@@ -196,8 +206,8 @@ class PageLayoutResource {
                 fileExtension: extensionValue,
                 syntaxType: syntaxId,
                 layoutProcessor: processorId,
-                sharedGroups: (data.sharedGroups ?? []).map((id) => ({ id })),
-                primaryGroup: { id: data.primaryGroup ?? null },
+                sharedGroups: (0, utils_js_1.writeSharedGroups)(data.sharedGroups),
+                primaryGroup: (0, utils_js_1.writePrimaryGroup)(data.primaryGroup ?? 0),
             },
         });
         return new PageLayout(raw, this.httpClient, syntaxMap, processorMap);

package/dist/cjs/section-ref.d.ts

@@ -3,6 +3,7 @@ import { LanguageOption, SectionChannel, Owner, AddSectionData } from './types.j
 import { ContentResource } from './resources/content-resource.js';
 import { SectionItem } from './models/section-item.js';
 import { MediaCreateFn } from './element-resolver.js';
+import { ContentCache } from './content-cache.js';
 /** A node in the section hierarchy tree */
 export interface SectionTreeNode {
     id: number;
@@ -23,7 +24,8 @@ export declare class SectionRef {
     private readonly sectionId;
     private readonly defaultLanguage;
     private readonly mediaCreateFn;
-    constructor(httpClient: HttpClient, sectionId: number, defaultLanguage: string, mediaCreateFn?: MediaCreateFn | null);
+    private readonly cache;
+    constructor(httpClient: HttpClient, sectionId: number, defaultLanguage: string, mediaCreateFn?: MediaCreateFn | null, cache?: ContentCache);
     /** Returns a mutable section object. Modify properties and call save() to persist. */
     get(options?: LanguageOption): Promise<SectionItem>;
     /** Returns the list of channels associated with this section. */

package/dist/cjs/section-ref.js

@@ -57,12 +57,13 @@ async function resolveMetaDataTypeId(httpClient, sectionMetaDataType) {
  * child section creation, and deletion — all from a single entry point.
  */
 class SectionRef {
-    constructor(httpClient, sectionId, defaultLanguage, mediaCreateFn) {
+    constructor(httpClient, sectionId, defaultLanguage, mediaCreateFn, cache) {
         this.httpClient = httpClient;
         this.sectionId = sectionId;
         this.defaultLanguage = defaultLanguage;
         this.mediaCreateFn = mediaCreateFn ?? null;
-        this.content = new content_resource_js_1.ContentResource(httpClient, sectionId, defaultLanguage, this.mediaCreateFn);
+        this.cache = cache;
+        this.content = new content_resource_js_1.ContentResource(httpClient, sectionId, defaultLanguage, this.mediaCreateFn, this.cache);
     }
     // ── Section metadata ──
     /** Returns a mutable section object. Modify properties and call save() to persist. */
@@ -77,7 +78,7 @@ class SectionRef {
         const meta = raw.metaData;
         if (meta?.enabled && meta.id) {
             try {
-                const metaContent = new content_resource_js_1.ContentResource(this.httpClient, this.sectionId, this.defaultLanguage, this.mediaCreateFn);
+                const metaContent = new content_resource_js_1.ContentResource(this.httpClient, this.sectionId, this.defaultLanguage, this.mediaCreateFn, this.cache);
                 const item = await metaContent.get(meta.id, { language });
                 customFields = stripNameField(item.fields ?? null);
             }
@@ -645,7 +646,7 @@ class SectionRef {
         if (metaContentTypeId) {
             // Use a ContentResource on the new section to get full element resolution
             // (list values, SS links, file uploads, etc.)
-            const metadataContentResource = new content_resource_js_1.ContentResource(this.httpClient, newSectionId, this.defaultLanguage, this.mediaCreateFn);
+            const metadataContentResource = new content_resource_js_1.ContentResource(this.httpClient, newSectionId, this.defaultLanguage, this.mediaCreateFn, this.cache);
             // Create the metadata content item (ContentResource.create handles the full body)
             const metaItem = await metadataContentResource.create({
                 type: metaContentTypeId,
@@ -734,7 +735,7 @@ class SectionRef {
             if (!metaDataTypeId) {
                 throw new Error('Cannot update customFields: no Section Meta Data content type is configured on this T4 instance');
             }
-            const contentResource = new content_resource_js_1.ContentResource(this.httpClient, this.sectionId, this.defaultLanguage, this.mediaCreateFn);
+            const contentResource = new content_resource_js_1.ContentResource(this.httpClient, this.sectionId, this.defaultLanguage, this.mediaCreateFn, this.cache);
             const metaContentId = meta?.id ?? 0;
             if (metaContentId > 0) {
                 await contentResource.update(metaContentId, { fields: data.customFields });

package/dist/cjs/t4-client.d.ts

@@ -35,6 +35,7 @@ export declare class T4Client {
     private readonly httpClient;
     private readonly defaultLanguage;
     private readonly mediaCreateFn;
+    private readonly contentCache;
     constructor(config: T4ClientConfig);
     /**
      * Returns a section reference scoped to the given section ID.

package/dist/cjs/t4-client.js

@@ -16,6 +16,7 @@ const page_layout_resource_js_1 = require("./resources/page-layout-resource.js")
 const media_type_resource_js_1 = require("./resources/media-type-resource.js");
 const navigation_resource_js_1 = require("./resources/navigation-resource.js");
 const handlebars_js_1 = require("./handlebars.js");
+const content_cache_js_1 = require("./content-cache.js");
 const utils_js_1 = require("./utils.js");
 /**
  * Main entry point for the T4 SDK.
@@ -57,12 +58,16 @@ class T4Client {
             });
             return item.id;
         };
+        // Shared content caches (element TypeRegistry, content type templates).
+        // Threaded into every SectionRef/ContentResource so hierarchy traversal
+        // doesn't re-fetch instance-wide data on each t4.section(id) call.
+        this.contentCache = new content_cache_js_1.ContentCache(this.httpClient, this.defaultLanguage, this.mediaCreateFn);
     }
     /**
      * Returns a section reference scoped to the given section ID.
      */
     section(id) {
-        return new section_ref_js_1.SectionRef(this.httpClient, id, this.defaultLanguage, this.mediaCreateFn);
+        return new section_ref_js_1.SectionRef(this.httpClient, id, this.defaultLanguage, this.mediaCreateFn, this.contentCache);
     }
     /**
      * Returns a media category reference scoped to the given category ID.

package/dist/cjs/utils.d.ts

@@ -68,6 +68,45 @@ export declare function flattenGroups(groups: Array<{
     name: string;
     groupChildren?: unknown[];
 }>, map?: Map<number, string>): Map<number, string>;
+/**
+ * Group/visibility mapping helpers.
+ *
+ * The T4 API represents an asset's owning group as `primaryGroup` (an object,
+ * where the id may be direct or nested under `group`) and its shared groups as
+ * `sharedGroups` (an array of `{ id }`). The SDK exposes these as a plain
+ * `primaryGroup: number` (0 = none) and `sharedGroups: number[]`. These helpers
+ * centralise the read/write mapping so content types, lists, page layouts, and
+ * navigation objects all handle groups identically.
+ */
+/** Raw shape of the API `primaryGroup` field. */
+export interface RawPrimaryGroup {
+    id: number | null;
+    group?: {
+        id: number;
+    };
+}
+/** Reads the API `primaryGroup` object into a plain group id (0 = none). */
+export declare function readPrimaryGroup(raw?: RawPrimaryGroup): number;
+/** Reads the API `sharedGroups` array into a plain array of group ids. */
+export declare function readSharedGroups(raw?: Array<{
+    id: number;
+}>): number[];
+/** Writes a plain group id back to the API `primaryGroup` shape (0/falsy = none). */
+export declare function writePrimaryGroup(id: number): {
+    id: number | null;
+};
+/** Writes a plain array of group ids back to the API `sharedGroups` shape. */
+export declare function writeSharedGroups(ids?: number[]): Array<{
+    id: number;
+}>;
+/**
+ * Validates that group/visibility values are acceptable to the T4 API before a
+ * write. The API returns an opaque 500 when `sharedGroups` contains the same id
+ * as `primaryGroup` (a group cannot be both the owner and a shared group), so we
+ * catch it here with a clear message. A `primaryGroup` of 0 means "no owning
+ * group" and is never a conflict.
+ */
+export declare function assertGroupsValid(primaryGroup: number, sharedGroups?: number[]): void;
 /** Accepted file input: a file path, URL, Blob, ReadableStream, or { file, filename } object */
 export type FileInput = string | Blob | NodeJS.ReadableStream | {
     file: string | Blob | NodeJS.ReadableStream;

package/dist/cjs/utils.js

@@ -42,6 +42,11 @@ exports.parseFileSize = parseFileSize;
 exports.parseElementKey = parseElementKey;
 exports.mapStatus = mapStatus;
 exports.flattenGroups = flattenGroups;
+exports.readPrimaryGroup = readPrimaryGroup;
+exports.readSharedGroups = readSharedGroups;
+exports.writePrimaryGroup = writePrimaryGroup;
+exports.writeSharedGroups = writeSharedGroups;
+exports.assertGroupsValid = assertGroupsValid;
 exports.resolveFileToBlob = resolveFileToBlob;
 exports.deriveFilename = deriveFilename;
 exports.debugWarn = debugWarn;
@@ -221,6 +226,38 @@ function flattenGroups(groups, map = new Map()) {
     }
     return map;
 }
+/** Reads the API `primaryGroup` object into a plain group id (0 = none). */
+function readPrimaryGroup(raw) {
+    return raw?.group?.id ?? raw?.id ?? 0;
+}
+/** Reads the API `sharedGroups` array into a plain array of group ids. */
+function readSharedGroups(raw) {
+    return (raw ?? []).map((g) => g.id);
+}
+/** Writes a plain group id back to the API `primaryGroup` shape (0/falsy = none). */
+function writePrimaryGroup(id) {
+    return { id: id || null };
+}
+/** Writes a plain array of group ids back to the API `sharedGroups` shape. */
+function writeSharedGroups(ids) {
+    return (ids ?? []).map((id) => ({ id }));
+}
+/**
+ * Validates that group/visibility values are acceptable to the T4 API before a
+ * write. The API returns an opaque 500 when `sharedGroups` contains the same id
+ * as `primaryGroup` (a group cannot be both the owner and a shared group), so we
+ * catch it here with a clear message. A `primaryGroup` of 0 means "no owning
+ * group" and is never a conflict.
+ */
+function assertGroupsValid(primaryGroup, sharedGroups) {
+    if (!primaryGroup)
+        return;
+    if ((sharedGroups ?? []).includes(primaryGroup)) {
+        throw new Error(`sharedGroups cannot contain the primaryGroup id (${primaryGroup}). ` +
+            'A group cannot be both the primary (owning) group and a shared group. ' +
+            'Remove it from sharedGroups or choose a different primaryGroup.');
+    }
+}
 /**
  * Resolves a file input (path, URL, Blob, or ReadableStream) to a Blob.
  */

package/dist/esm/content-cache.d.ts

@@ -0,0 +1,38 @@
+import { HttpClient } from './http-client.js';
+import { TypeRegistry } from './type-registry.js';
+import { ElementResolver, MediaCreateFn } from './element-resolver.js';
+import { TtlMap } from './utils.js';
+/**
+ * Client-level shared caches for content operations.
+ *
+ * A single instance is created per `T4Client` and threaded into every
+ * `ContentResource` (including the short-lived ones created by
+ * `SectionRef.get()` / `addSection()`). This ensures that traversing the
+ * hierarchy — which creates many `ContentResource` instances via
+ * `t4.section(id)` — does not re-fetch instance-wide data on every hop.
+ *
+ * Two things previously lived on each `ContentResource` and were rebuilt per
+ * section, causing repeated API calls (`GET /type/`, `GET /contenttype/{id}`,
+ * `GET /content/type/{ct}/{section}`):
+ *
+ * - The element `TypeRegistry` (`GET /type/`) — instance-wide, so shared here
+ *   as a single registry and a single `ElementResolver`.
+ * - Content type templates — split into:
+ *   - `contentTypeDefinitions`: the section-independent `GET /contenttype/{id}`
+ *     response, keyed by content type ID.
+ *   - `sectionTemplates`: the section-specific `GET /content/type/{ct}/{section}`
+ *     response (carries channels), keyed by `"{contentTypeId}:{sectionId}"`.
+ *
+ * All caches respect the global cache epoch, so `T4Client.clearCache()`
+ * invalidates them the same way it always has.
+ */
+export declare class ContentCache {
+    readonly typeRegistry: TypeRegistry;
+    readonly resolver: ElementResolver;
+    /** `GET /content/type/{ct}/{section}` responses, keyed by `"{ct}:{section}"`. */
+    readonly sectionTemplates: TtlMap<string, unknown>;
+    /** `GET /contenttype/{id}` responses, keyed by content type ID. */
+    readonly contentTypeDefinitions: TtlMap<number, unknown>;
+    constructor(httpClient: HttpClient, defaultLanguage: string, mediaCreateFn?: MediaCreateFn | null);
+}
+//# sourceMappingURL=content-cache.d.ts.map

package/dist/esm/content-cache.js

@@ -0,0 +1,38 @@
+import { TypeRegistry } from './type-registry.js';
+import { ElementResolver } from './element-resolver.js';
+import { TtlMap } from './utils.js';
+/**
+ * Client-level shared caches for content operations.
+ *
+ * A single instance is created per `T4Client` and threaded into every
+ * `ContentResource` (including the short-lived ones created by
+ * `SectionRef.get()` / `addSection()`). This ensures that traversing the
+ * hierarchy — which creates many `ContentResource` instances via
+ * `t4.section(id)` — does not re-fetch instance-wide data on every hop.
+ *
+ * Two things previously lived on each `ContentResource` and were rebuilt per
+ * section, causing repeated API calls (`GET /type/`, `GET /contenttype/{id}`,
+ * `GET /content/type/{ct}/{section}`):
+ *
+ * - The element `TypeRegistry` (`GET /type/`) — instance-wide, so shared here
+ *   as a single registry and a single `ElementResolver`.
+ * - Content type templates — split into:
+ *   - `contentTypeDefinitions`: the section-independent `GET /contenttype/{id}`
+ *     response, keyed by content type ID.
+ *   - `sectionTemplates`: the section-specific `GET /content/type/{ct}/{section}`
+ *     response (carries channels), keyed by `"{contentTypeId}:{sectionId}"`.
+ *
+ * All caches respect the global cache epoch, so `T4Client.clearCache()`
+ * invalidates them the same way it always has.
+ */
+export class ContentCache {
+    constructor(httpClient, defaultLanguage, mediaCreateFn) {
+        /** `GET /content/type/{ct}/{section}` responses, keyed by `"{ct}:{section}"`. */
+        this.sectionTemplates = new TtlMap();
+        /** `GET /contenttype/{id}` responses, keyed by content type ID. */
+        this.contentTypeDefinitions = new TtlMap();
+        this.typeRegistry = new TypeRegistry(httpClient);
+        this.resolver = new ElementResolver(httpClient, defaultLanguage, this.typeRegistry, mediaCreateFn);
+    }
+}
+//# sourceMappingURL=content-cache.js.map

package/dist/esm/element-resolver.d.ts

@@ -83,6 +83,22 @@ export declare class ElementResolver {
      * Uses the TypeRegistry to look up type names instead of hardcoded IDs.
      */
     resolveValue(value: unknown, element: TemplateElement, language: string, allElements?: TemplateElement[], context?: ResolveContext): Promise<unknown>;
+    /**
+     * Builds the T4 elements map from developer-friendly field names and values.
+     * Resolves list values, dates, repeaters, etc. automatically.
+     *
+     * Shared by both write paths: `ContentResource` (create/update) and
+     * `ContentItem.save()`. Keeping a single implementation here prevents the two
+     * paths from drifting — the reason repeaters previously only resolved on one
+     * of them.
+     */
+    buildElements(fields: Record<string, unknown>, elements: TemplateElement[], name: string, language: string, sectionId: number, context?: ResolveContext): Promise<Record<string, unknown>>;
+    /**
+     * Builds a repeater value array from developer-friendly input.
+     * Each repeater item gets its own element key resolution using the
+     * repeater's sub-content-type elements from contentTypeElementConfiguration.
+     */
+    buildRepeaterValue(items: RepeaterInput[], element: TemplateElement, language: string, sectionId: number): Promise<unknown[]>;
     getList(listId: number, language: string): Promise<ListResponse>;
     private resolveItemName;
     private resolveDate;

package/dist/esm/element-resolver.js

@@ -79,11 +79,87 @@ export class ElementResolver {
             case 'Keyword Selector':
                 return this.resolveKeywordSelector(value, element.listId, language);
             case 'Repeater':
-                return value; // handled separately in buildElements
+                return value; // handled separately in buildElements / buildRepeaterValue
             default:
                 return value;
         }
     }
+    /**
+     * Builds the T4 elements map from developer-friendly field names and values.
+     * Resolves list values, dates, repeaters, etc. automatically.
+     *
+     * Shared by both write paths: `ContentResource` (create/update) and
+     * `ContentItem.save()`. Keeping a single implementation here prevents the two
+     * paths from drifting — the reason repeaters previously only resolved on one
+     * of them.
+     */
+    async buildElements(fields, elements, name, language, sectionId, context) {
+        const result = {};
+        // Name element
+        const nameEl = elements.find((el) => el.name.toLowerCase() === 'name');
+        if (nameEl) {
+            result[`${nameEl.name}#${nameEl.id}:${nameEl.type}`] = name;
+        }
+        for (const [fieldName, value] of Object.entries(fields)) {
+            const fieldLower = fieldName.toLowerCase();
+            const element = elements.find((el) => el.name.toLowerCase() === fieldLower
+                || (el.alias && el.alias.toLowerCase() === fieldLower));
+            if (!element) {
+                const validNames = elements
+                    .filter((el) => el.name.toLowerCase() !== 'name')
+                    .map((el) => `"${el.alias || el.name}"`)
+                    .join(', ');
+                throw new Error(`Unknown field "${fieldName}" on this content type. Valid fields are: ${validNames}`);
+            }
+            const key = `${element.name}#${element.id}:${element.type}`;
+            // Repeater — special handling (no maxSize validation)
+            const typeName = await this.typeRegistry.getNameById(element.type);
+            if (typeName === 'Repeater' && Array.isArray(value)) {
+                result[key] = await this.buildRepeaterValue(value, element, language, sectionId);
+                continue;
+            }
+            const resolved = await this.resolveValue(value, element, language, elements, context);
+            // Validate maxSize on the resolved value (what actually gets sent to the API)
+            if (element.maxSize) {
+                const resolvedStr = String(resolved ?? '');
+                if (resolvedStr.length > element.maxSize) {
+                    const friendlyName = element.alias || element.name;
+                    throw new Error(`Field "${friendlyName}" exceeds max size: ${resolvedStr.length} characters (max ${element.maxSize})`);
+                }
+            }
+            result[key] = resolved;
+        }
+        return result;
+    }
+    /**
+     * Builds a repeater value array from developer-friendly input.
+     * Each repeater item gets its own element key resolution using the
+     * repeater's sub-content-type elements from contentTypeElementConfiguration.
+     */
+    async buildRepeaterValue(items, element, language, sectionId) {
+        const config = element.contentTypeElementConfiguration;
+        const repeaterElements = config?.contentTypeDTO?.contentTypeElements;
+        if (!repeaterElements || repeaterElements.length === 0)
+            return items;
+        const result = [];
+        for (const item of items) {
+            const repeaterId = -Math.floor(Math.random() * 100000);
+            // Repeater items use their own repeaterId as fromContentId for SS links
+            const repeaterContext = {
+                fromSectionId: sectionId,
+                fromContentId: repeaterId,
+            };
+            const elements = await this.buildElements(item.fields, repeaterElements, item.name, language, sectionId, repeaterContext);
+            result.push({
+                repeaterId,
+                repeaterContent: {
+                    name: item.name,
+                    elements,
+                },
+            });
+        }
+        return result;
+    }
     // ── List fetching ──
     async getList(listId, language) {
         const cached = this.listCache.get(listId);

package/dist/esm/models/content-item.js

@@ -526,7 +526,19 @@ export class ContentItem {
             }
             let resolved;
             if (templateEl && this._resolver) {
-                resolved = await this._resolver.resolveValue(value, templateEl, this.language, this._templateElements ?? undefined, context);
+                // Repeater fields need the same dedicated resolution ContentResource
+                // uses on create/update — each item's sub-fields resolved into element
+                // keys and wrapped in { repeaterId, repeaterContent }. resolveValue()
+                // passes repeater arrays through untouched, so branch here explicitly.
+                const typeName = this._typeRegistry
+                    ? await this._typeRegistry.getNameById(templateEl.type)
+                    : null;
+                if (typeName === 'Repeater' && Array.isArray(value)) {
+                    resolved = await this._resolver.buildRepeaterValue(value, templateEl, this.language, this._sectionId);
+                }
+                else {
+                    resolved = await this._resolver.resolveValue(value, templateEl, this.language, this._templateElements ?? undefined, context);
+                }
             }
             else {
                 resolved = value;

package/dist/esm/resources/content-resource.d.ts

@@ -2,6 +2,7 @@ import { HttpClient } from '../http-client.js';
 import { LanguageOption, CreateContentData, UpdateContentData } from '../types.js';
 import { ContentItem } from '../models/content-item.js';
 import { MediaCreateFn } from '../element-resolver.js';
+import { ContentCache } from '../content-cache.js';
 /**
  * Section-scoped resource for content CRUD operations.
  * All requests are scoped to the section ID provided at construction time.
@@ -10,23 +11,18 @@ export declare class ContentResource {
     private readonly httpClient;
     private readonly sectionId;
     private readonly defaultLanguage;
-    private readonly resolver;
-    private readonly typeRegistry;
-    /** Cache of content type templates keyed by content type ID */
-    private templateCache;
-    constructor(httpClient: HttpClient, sectionId: number, defaultLanguage: string, mediaCreateFn?: MediaCreateFn | null);
+    private readonly cache;
+    constructor(httpClient: HttpClient, sectionId: number, defaultLanguage: string, mediaCreateFn?: MediaCreateFn | null, cache?: ContentCache);
+    private get resolver();
+    private get typeRegistry();
     private getTemplate;
+    /** Fetches the section-independent content type definition, cached by content type ID. */
+    private getContentTypeDefinition;
     /**
      * Builds the T4 elements map from developer-friendly field names and values.
      * Resolves list values, dates, repeaters, etc. automatically.
      */
     private buildElements;
-    /**
-     * Builds repeater value array from developer-friendly input.
-     * Each repeater item gets its own element key resolution using the
-     * repeater's sub-content-type elements from contentTypeElementConfiguration.
-     */
-    private buildRepeaterValue;
     /** Lists all content items in this section. */
     list(options?: LanguageOption): Promise<ContentItem[]>;
     /** Retrieves a single content item by ID. */