@promptbook/core 0.112.0-125 → 0.112.0-127

package/umd/index.umd.js

@@ -29,7 +29,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-125';
+    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-127';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -10093,8 +10093,11 @@
             if (!trimmedContent) {
                 return requirements;
             }
-            // Add goal as a proper h2 section to the system message
-            const goalSection = `## Goal\n\n${trimmedContent}`;
+            const goalSection = spacetrim.spaceTrim((block) => `
+                ## Goal
+
+                ${block(trimmedContent)}
+            `);
             const requirementsWithGoal = this.appendToSystemMessage(requirements, goalSection, '\n\n');
             return this.appendToPromptSuffix(requirementsWithGoal, trimmedContent);
         }
@@ -10616,8 +10619,11 @@
             if (!trimmedContent) {
                 return requirements;
             }
-            // Add language as a bullet under a ## Language section
-            const languageSection = `## Language\n\n-   Your language is ${trimmedContent}`;
+            const languageSection = spacetrim.spaceTrim((block) => `
+                ## Language
+
+                -   Your language is ${block(trimmedContent)}
+            `);
             return this.appendToSystemMessage(requirements, languageSection, '\n\n');
         }
     }
@@ -15563,41 +15569,91 @@
         context.fill();
         context.restore();
     }
+    /**
+     * Number of latitude segments used by the single blobby octopus mesh.
+     *
+     * @private helper of `octopus3d2AvatarVisual`
+     */
+    const LATITUDE_PATCH_COUNT$1 = 12;
+    /**
+     * Number of longitude segments used by the single blobby octopus mesh.
+     *
+     * @private helper of `octopus3d2AvatarVisual`
+     */
+    const LONGITUDE_PATCH_COUNT$1 = 24;
     /**
      * Resolves all visible projected patches for the single blobby octopus mesh.
      *
+     * Within a single frame, mesh corner samples and longitude-only lobe-wave values are
+     * quantized to the patch grid and computed once each rather than re-evaluated for every
+     * patch corner — the patch loop alone would call `sampleBlobbyOctopusSurfacePoint`
+     * `latitudePatchCount * longitudePatchCount * 4` times without caching, even though most
+     * corners are shared between neighboring patches.
+     *
      * @private helper of `octopus3d2AvatarVisual`
      */
     function resolveVisibleBlobbyOctopusPatches(options) {
         const { center, rotationX, rotationY, sceneCenterX, sceneCenterY, size, palette, morphologyProfile, animationPhase, timeMs, } = options;
-        const latitudePatchCount = 12;
-        const longitudePatchCount = 24;
+        const latitudePatchCount = LATITUDE_PATCH_COUNT$1;
+        const longitudePatchCount = LONGITUDE_PATCH_COUNT$1;
         const surfacePatches = [];
+        const latitudeBoundaries = new Float64Array(latitudePatchCount + 1);
+        const longitudeBoundaries = new Float64Array(longitudePatchCount + 1);
+        for (let boundaryIndex = 0; boundaryIndex <= latitudePatchCount; boundaryIndex++) {
+            latitudeBoundaries[boundaryIndex] = -Math.PI / 2 + (boundaryIndex / latitudePatchCount) * Math.PI;
+        }
+        for (let boundaryIndex = 0; boundaryIndex <= longitudePatchCount; boundaryIndex++) {
+            longitudeBoundaries[boundaryIndex] = -Math.PI + (boundaryIndex / longitudePatchCount) * Math.PI * 2;
+        }
+        const cachedLobeWavesByCornerLongitude = new Float64Array(longitudePatchCount + 1);
+        for (let boundaryIndex = 0; boundaryIndex <= longitudePatchCount; boundaryIndex++) {
+            cachedLobeWavesByCornerLongitude[boundaryIndex] = resolveLowerLobeWave(longitudeBoundaries[boundaryIndex], morphologyProfile, animationPhase, timeMs);
+        }
+        const cornerCount = (latitudePatchCount + 1) * (longitudePatchCount + 1);
+        const transformedCornerSamples = new Array(cornerCount);
+        for (let latitudeBoundaryIndex = 0; latitudeBoundaryIndex <= latitudePatchCount; latitudeBoundaryIndex++) {
+            const cornerLatitude = latitudeBoundaries[latitudeBoundaryIndex];
+            for (let longitudeBoundaryIndex = 0; longitudeBoundaryIndex <= longitudePatchCount; longitudeBoundaryIndex++) {
+                const cornerLongitude = longitudeBoundaries[longitudeBoundaryIndex];
+                const cornerIndex = latitudeBoundaryIndex * (longitudePatchCount + 1) + longitudeBoundaryIndex;
+                const cornerSample = sampleBlobbyOctopusSurfacePointWithLongitudeCache(options, cornerLatitude, cornerLongitude, cachedLobeWavesByCornerLongitude[longitudeBoundaryIndex]);
+                transformedCornerSamples[cornerIndex] = transformScenePoint(cornerSample, center, rotationX, rotationY);
+            }
+        }
         for (let latitudeIndex = 0; latitudeIndex < latitudePatchCount; latitudeIndex++) {
-            const startLatitude = -Math.PI / 2 + (latitudeIndex / latitudePatchCount) * Math.PI;
-            const endLatitude = -Math.PI / 2 + ((latitudeIndex + 1) / latitudePatchCount) * Math.PI;
+            const startLatitude = latitudeBoundaries[latitudeIndex];
+            const endLatitude = latitudeBoundaries[latitudeIndex + 1];
             const centerLatitude = (startLatitude + endLatitude) / 2;
             const verticalProgress = (Math.sin(centerLatitude) + 1) / 2;
+            const startCornerRowOffset = latitudeIndex * (longitudePatchCount + 1);
+            const endCornerRowOffset = (latitudeIndex + 1) * (longitudePatchCount + 1);
             for (let longitudeIndex = 0; longitudeIndex < longitudePatchCount; longitudeIndex++) {
-                const startLongitude = -Math.PI + (longitudeIndex / longitudePatchCount) * Math.PI * 2;
-                const endLongitude = -Math.PI + ((longitudeIndex + 1) / longitudePatchCount) * Math.PI * 2;
+                const startLongitude = longitudeBoundaries[longitudeIndex];
+                const endLongitude = longitudeBoundaries[longitudeIndex + 1];
                 const centerLongitude = (startLongitude + endLongitude) / 2;
-                const localCorners = [
-                    sampleBlobbyOctopusSurfacePoint(options, startLatitude, startLongitude),
-                    sampleBlobbyOctopusSurfacePoint(options, startLatitude, endLongitude),
-                    sampleBlobbyOctopusSurfacePoint(options, endLatitude, endLongitude),
-                    sampleBlobbyOctopusSurfacePoint(options, endLatitude, startLongitude),
+                const transformedCorners = [
+                    transformedCornerSamples[startCornerRowOffset + longitudeIndex],
+                    transformedCornerSamples[startCornerRowOffset + longitudeIndex + 1],
+                    transformedCornerSamples[endCornerRowOffset + longitudeIndex + 1],
+                    transformedCornerSamples[endCornerRowOffset + longitudeIndex],
                 ];
-                const transformedCorners = localCorners.map((localCorner) => transformScenePoint(localCorner, center, rotationX, rotationY));
                 const surfaceNormal = normalizeVector3(crossProduct3D(subtractPoint3D(transformedCorners[1], transformedCorners[0]), subtractPoint3D(transformedCorners[2], transformedCorners[0])));
                 if (surfaceNormal.z <= 0.01) {
                     continue;
                 }
-                const projectedCorners = transformedCorners.map((transformedCorner) => projectScenePoint(transformedCorner, size, sceneCenterX, sceneCenterY));
+                const projectedCorners = [
+                    projectScenePoint(transformedCorners[0], size, sceneCenterX, sceneCenterY),
+                    projectScenePoint(transformedCorners[1], size, sceneCenterX, sceneCenterY),
+                    projectScenePoint(transformedCorners[2], size, sceneCenterX, sceneCenterY),
+                    projectScenePoint(transformedCorners[3], size, sceneCenterX, sceneCenterY),
+                ];
                 surfacePatches.push({
                     corners: projectedCorners,
-                    averageDepth: transformedCorners.reduce((depthSum, transformedCorner) => depthSum + transformedCorner.z, 0) /
-                        transformedCorners.length,
+                    averageDepth: (transformedCorners[0].z +
+                        transformedCorners[1].z +
+                        transformedCorners[2].z +
+                        transformedCorners[3].z) /
+                        4,
                     lightIntensity: clampNumber$1(dotProduct3D(surfaceNormal, LIGHT_DIRECTION$1), -1, 1),
                     fillStyle: resolveBlobbySurfacePatchFillStyle(palette, verticalProgress, Math.max(0, Math.cos(centerLongitude)), resolveLowerLobeWave(centerLongitude, morphologyProfile, animationPhase, timeMs)),
                     outlineColor: verticalProgress < 0.58 ? `${palette.highlight}73` : `${palette.shadow}8a`,
@@ -15615,12 +15671,21 @@
      * @private helper of `octopus3d2AvatarVisual`
      */
     function sampleBlobbyOctopusSurfacePoint(options, latitude, longitude) {
+        const { morphologyProfile, animationPhase, timeMs } = options;
+        return sampleBlobbyOctopusSurfacePointWithLongitudeCache(options, latitude, longitude, resolveLowerLobeWave(longitude, morphologyProfile, animationPhase, timeMs));
+    }
+    /**
+     * Samples one point on the continuous Octopus 3D 2 surface using a precomputed lower-lobe wave
+     * to skip the per-call trig evaluation for `latitudePatchCount + 1` longitude-shared corners.
+     *
+     * @private helper of `octopus3d2AvatarVisual`
+     */
+    function sampleBlobbyOctopusSurfacePointWithLongitudeCache(options, latitude, longitude, lowerLobeWave) {
         const { radiusX, radiusY, radiusZ, morphologyProfile, timeMs, animationPhase } = options;
         const cosineLatitude = Math.max(0, Math.cos(latitude));
         const verticalProgress = (Math.sin(latitude) + 1) / 2;
         const upperBlend = Math.pow(1 - verticalProgress, 1.2);
         const lowerBlend = Math.pow(verticalProgress, 1.42);
-        const lowerLobeWave = resolveLowerLobeWave(longitude, morphologyProfile, animationPhase, timeMs);
         const skirtEnvelope = Math.pow(cosineLatitude, 0.5) * lowerBlend;
         const horizontalScale = 1.02 +
             skirtEnvelope * (0.34 + (morphologyProfile.tentacles.rootSpreadScale - 1) * 0.22 + lowerLobeWave * 0.22) -
@@ -15917,45 +15982,102 @@
         context.fill();
         context.restore();
     }
+    /**
+     * Number of latitude segments used by the continuous Octopus 3D 3 mesh.
+     *
+     * @private helper of `octopus3d3AvatarVisual`
+     */
+    const LATITUDE_PATCH_COUNT = 16;
+    /**
+     * Number of longitude segments used by the continuous Octopus 3D 3 mesh.
+     *
+     * @private helper of `octopus3d3AvatarVisual`
+     */
+    const LONGITUDE_PATCH_COUNT = 40;
     /**
      * Resolves visible projected patches for the continuous octopus mesh.
      *
+     * Within a single frame, mesh corner samples and longitude-only computations (tentacle
+     * influence and lobe wave) are quantized to the patch grid and computed once each rather
+     * than re-evaluated for every patch corner — the patch loop alone calls `sampleContinuousOctopusSurfacePoint`
+     * for `latitudePatchCount * longitudePatchCount * 4` corners without caching, and each call
+     * triggers an inner 8-iteration `Math.exp` loop, which dominates the per-frame cost.
+     *
      * @private helper of `octopus3d3AvatarVisual`
      */
     function resolveVisibleContinuousOctopusPatches(options) {
         const { center, rotationX, rotationY, sceneCenterX, sceneCenterY, size, palette } = options;
-        const latitudePatchCount = 16;
-        const longitudePatchCount = 40;
+        const latitudePatchCount = LATITUDE_PATCH_COUNT;
+        const longitudePatchCount = LONGITUDE_PATCH_COUNT;
         const surfacePatches = [];
+        const latitudeBoundaries = new Float64Array(latitudePatchCount + 1);
+        const longitudeBoundaries = new Float64Array(longitudePatchCount + 1);
+        for (let boundaryIndex = 0; boundaryIndex <= latitudePatchCount; boundaryIndex++) {
+            latitudeBoundaries[boundaryIndex] = -Math.PI / 2 + (boundaryIndex / latitudePatchCount) * Math.PI;
+        }
+        for (let boundaryIndex = 0; boundaryIndex <= longitudePatchCount; boundaryIndex++) {
+            longitudeBoundaries[boundaryIndex] = -Math.PI + (boundaryIndex / longitudePatchCount) * Math.PI * 2;
+        }
+        const cachedTentacleInfluencesByCornerLongitude = new Array(longitudePatchCount + 1);
+        const cachedLobeWavesByCornerLongitude = new Float64Array(longitudePatchCount + 1);
+        const cachedTentacleInfluencesByPatchCenterLongitude = new Array(longitudePatchCount);
+        const cachedLobeWavesByPatchCenterLongitude = new Float64Array(longitudePatchCount);
+        const cachedCosByPatchCenterLongitude = new Float64Array(longitudePatchCount);
+        for (let boundaryIndex = 0; boundaryIndex <= longitudePatchCount; boundaryIndex++) {
+            const cornerLongitude = longitudeBoundaries[boundaryIndex];
+            cachedTentacleInfluencesByCornerLongitude[boundaryIndex] = resolveContinuousTentacleInfluence(options, cornerLongitude);
+            cachedLobeWavesByCornerLongitude[boundaryIndex] = resolveContinuousLobeWave(options, cornerLongitude);
+        }
+        for (let longitudeIndex = 0; longitudeIndex < longitudePatchCount; longitudeIndex++) {
+            const patchCenterLongitude = (longitudeBoundaries[longitudeIndex] + longitudeBoundaries[longitudeIndex + 1]) / 2;
+            cachedTentacleInfluencesByPatchCenterLongitude[longitudeIndex] = resolveContinuousTentacleInfluence(options, patchCenterLongitude);
+            cachedLobeWavesByPatchCenterLongitude[longitudeIndex] = resolveContinuousLobeWave(options, patchCenterLongitude);
+            cachedCosByPatchCenterLongitude[longitudeIndex] = Math.max(0, Math.cos(patchCenterLongitude));
+        }
+        const cornerCount = (latitudePatchCount + 1) * (longitudePatchCount + 1);
+        const transformedCornerSamples = new Array(cornerCount);
+        for (let latitudeBoundaryIndex = 0; latitudeBoundaryIndex <= latitudePatchCount; latitudeBoundaryIndex++) {
+            const cornerLatitude = latitudeBoundaries[latitudeBoundaryIndex];
+            for (let longitudeBoundaryIndex = 0; longitudeBoundaryIndex <= longitudePatchCount; longitudeBoundaryIndex++) {
+                const cornerLongitude = longitudeBoundaries[longitudeBoundaryIndex];
+                const cornerIndex = latitudeBoundaryIndex * (longitudePatchCount + 1) + longitudeBoundaryIndex;
+                const cornerSample = sampleContinuousOctopusSurfacePointWithLongitudeCache(options, cornerLatitude, cornerLongitude, cachedTentacleInfluencesByCornerLongitude[longitudeBoundaryIndex], cachedLobeWavesByCornerLongitude[longitudeBoundaryIndex]);
+                transformedCornerSamples[cornerIndex] = transformScenePoint(cornerSample, center, rotationX, rotationY);
+            }
+        }
         for (let latitudeIndex = 0; latitudeIndex < latitudePatchCount; latitudeIndex++) {
-            const startLatitude = -Math.PI / 2 + (latitudeIndex / latitudePatchCount) * Math.PI;
-            const endLatitude = -Math.PI / 2 + ((latitudeIndex + 1) / latitudePatchCount) * Math.PI;
+            const startLatitude = latitudeBoundaries[latitudeIndex];
+            const endLatitude = latitudeBoundaries[latitudeIndex + 1];
             const centerLatitude = (startLatitude + endLatitude) / 2;
             const verticalProgress = (Math.sin(centerLatitude) + 1) / 2;
+            const startCornerRowOffset = latitudeIndex * (longitudePatchCount + 1);
+            const endCornerRowOffset = (latitudeIndex + 1) * (longitudePatchCount + 1);
             for (let longitudeIndex = 0; longitudeIndex < longitudePatchCount; longitudeIndex++) {
-                const startLongitude = -Math.PI + (longitudeIndex / longitudePatchCount) * Math.PI * 2;
-                const endLongitude = -Math.PI + ((longitudeIndex + 1) / longitudePatchCount) * Math.PI * 2;
-                const centerLongitude = (startLongitude + endLongitude) / 2;
-                const localCorners = [
-                    sampleContinuousOctopusSurfacePoint(options, startLatitude, startLongitude),
-                    sampleContinuousOctopusSurfacePoint(options, startLatitude, endLongitude),
-                    sampleContinuousOctopusSurfacePoint(options, endLatitude, endLongitude),
-                    sampleContinuousOctopusSurfacePoint(options, endLatitude, startLongitude),
+                const transformedCorners = [
+                    transformedCornerSamples[startCornerRowOffset + longitudeIndex],
+                    transformedCornerSamples[startCornerRowOffset + longitudeIndex + 1],
+                    transformedCornerSamples[endCornerRowOffset + longitudeIndex + 1],
+                    transformedCornerSamples[endCornerRowOffset + longitudeIndex],
                 ];
-                const transformedCorners = localCorners.map((localCorner) => transformScenePoint(localCorner, center, rotationX, rotationY));
                 const surfaceNormal = normalizeVector3(crossProduct3D(subtractPoint3D(transformedCorners[1], transformedCorners[0]), subtractPoint3D(transformedCorners[2], transformedCorners[0])));
                 if (surfaceNormal.z <= 0.008) {
                     continue;
                 }
-                const projectedCorners = transformedCorners.map((transformedCorner) => projectScenePoint(transformedCorner, size, sceneCenterX, sceneCenterY));
-                const tentacleInfluence = resolveContinuousTentacleInfluence(options, centerLongitude);
-                const lowerLobeWave = resolveContinuousLobeWave(options, centerLongitude);
+                const projectedCorners = [
+                    projectScenePoint(transformedCorners[0], size, sceneCenterX, sceneCenterY),
+                    projectScenePoint(transformedCorners[1], size, sceneCenterX, sceneCenterY),
+                    projectScenePoint(transformedCorners[2], size, sceneCenterX, sceneCenterY),
+                    projectScenePoint(transformedCorners[3], size, sceneCenterX, sceneCenterY),
+                ];
                 surfacePatches.push({
                     corners: projectedCorners,
-                    averageDepth: transformedCorners.reduce((depthSum, transformedCorner) => depthSum + transformedCorner.z, 0) /
-                        transformedCorners.length,
+                    averageDepth: (transformedCorners[0].z +
+                        transformedCorners[1].z +
+                        transformedCorners[2].z +
+                        transformedCorners[3].z) /
+                        4,
                     lightIntensity: clampNumber$1(dotProduct3D(surfaceNormal, LIGHT_DIRECTION), -1, 1),
-                    fillStyle: resolveContinuousSurfacePatchFillStyle(palette, verticalProgress, Math.max(0, Math.cos(centerLongitude)), tentacleInfluence.core, lowerLobeWave),
+                    fillStyle: resolveContinuousSurfacePatchFillStyle(palette, verticalProgress, cachedCosByPatchCenterLongitude[longitudeIndex], cachedTentacleInfluencesByPatchCenterLongitude[longitudeIndex].core, cachedLobeWavesByPatchCenterLongitude[longitudeIndex]),
                     outlineColor: verticalProgress < 0.54 ? `${palette.highlight}69` : `${palette.shadow}78`,
                 });
             }
@@ -15971,16 +16093,27 @@
      * @private helper of `octopus3d3AvatarVisual`
      */
     function sampleContinuousOctopusSurfacePoint(options, latitude, longitude) {
+        return sampleContinuousOctopusSurfacePointWithLongitudeCache(options, latitude, longitude, resolveContinuousTentacleInfluence(options, longitude), resolveContinuousLobeWave(options, longitude));
+    }
+    /**
+     * Samples one point on the continuous Octopus 3D 3 surface using precomputed longitude-only
+     * values to skip the per-call `Math.exp` tentacle-influence loop and the lobe-wave trig call.
+     *
+     * The patch loop quantizes the mesh into a fixed `(latitudePatchCount + 1) * (longitudePatchCount + 1)`
+     * corner grid, so the same longitude is reused across every latitude row and each
+     * tentacle/lobe value can be computed once per frame instead of `latitudePatchCount * 4` times.
+     *
+     * @private helper of `octopus3d3AvatarVisual`
+     */
+    function sampleContinuousOctopusSurfacePointWithLongitudeCache(options, latitude, longitude, tentacleInfluence, lowerLobeWave) {
         const { radiusX, radiusY, radiusZ, morphologyProfile, timeMs, animationPhase } = options;
         const cosineLatitude = Math.max(0, Math.cos(latitude));
         const verticalProgress = (Math.sin(latitude) + 1) / 2;
         const upperBlend = Math.pow(1 - verticalProgress, 1.28);
         const lowerBlend = smoothStep(0.38, 1, verticalProgress);
         const tipBlend = smoothStep(0.68, 1, verticalProgress);
-        const tentacleInfluence = resolveContinuousTentacleInfluence(options, longitude);
         const centerPull = resolveSignedAngularDistance(longitude, tentacleInfluence.centerLongitude);
         const effectiveLongitude = longitude + centerPull * lowerBlend * tentacleInfluence.core * (0.24 + tipBlend * 0.2);
-        const lowerLobeWave = resolveContinuousLobeWave(options, longitude);
         const mantleRipple = Math.sin(longitude * morphologyProfile.body.lobeCount +
             animationPhase * 0.6 +
             timeMs / (1750 + morphologyProfile.body.lobeCount * 30)) *
@@ -19311,7 +19444,15 @@
      * Builds the teammate request text, optionally including context.
      */
     function buildTeammateRequest(message, context) {
-        return context ? `${message}\n\nContext:\n${context}` : message;
+        if (!context) {
+            return message;
+        }
+        return spacetrim.spaceTrim((block) => `
+            ${block(message)}
+
+            Context:
+            ${block(context)}
+        `);
     }
     /**
      * Builds a minimal chat prompt for teammate calls.
@@ -23137,7 +23278,11 @@
                     const lineRangedContent = applyOptionalLineRange(decodedContent, args.startLine, args.endLine);
                     const wasCharacterTruncated = lineRangedContent.length > MAX_PROJECT_FILE_CONTENT_CHARACTERS;
                     const contentToReturn = wasCharacterTruncated
-                        ? `${lineRangedContent.slice(0, MAX_PROJECT_FILE_CONTENT_CHARACTERS)}\n\n[...truncated...]`
+                        ? spacetrim.spaceTrim((block) => `
+                              ${block(lineRangedContent.slice(0, MAX_PROJECT_FILE_CONTENT_CHARACTERS))}
+
+                              [...truncated...]
+                          `)
                         : lineRangedContent;
                     const wasTruncated = decoded.isTruncated || wasCharacterTruncated;
                     if (wasCharacterTruncated) {
@@ -26673,11 +26818,19 @@
             try {
                 const json = JSON.parse(content);
                 const formattedJson = JSON.stringify(json, null, 4);
-                return `\`\`\`json\n${formattedJson}\n\`\`\``;
+                return spacetrim.spaceTrim((block) => `
+                    \`\`\`json
+                    ${block(formattedJson)}
+                    \`\`\`
+                `);
             }
             catch (error) {
                 // If JSON is invalid, still import it but maybe not as pretty JSON
-                return `\`\`\`json\n${content}\n\`\`\``;
+                return spacetrim.spaceTrim((block) => `
+                    \`\`\`json
+                    ${block(content)}
+                    \`\`\`
+                `);
             }
         },
     };
@@ -26701,7 +26854,11 @@
         import(content, mimeType) {
             const extension = mimeTypeToExtension(mimeType);
             const codeBlockType = extension || 'txt';
-            return `\`\`\`${codeBlockType}\n${content}\n\`\`\``;
+            return spacetrim.spaceTrim((block) => `
+                \`\`\`${codeBlockType}
+                ${block(content)}
+                \`\`\`
+            `);
         },
     };
 
@@ -26948,11 +27105,19 @@
         const examples = [];
         const initialMessage = (_a = parseResult.commitments.find((commitment) => commitment.type === 'INITIAL MESSAGE')) === null || _a === void 0 ? void 0 : _a.content;
         if (initialMessage) {
-            examples.push(`**Agent:**\n${initialMessage}`);
+            examples.push(spacetrim.spaceTrim((block) => `
+                    **Agent:**
+                    ${block(initialMessage)}
+                `));
         }
         if (samples && samples.length > 0) {
             for (const sample of samples) {
-                examples.push(`**User:** ${sample.question}\n\n**Agent:**\n${sample.answer}`);
+                examples.push(spacetrim.spaceTrim((block) => `
+                        **User:** ${block(String(sample.question))}
+
+                        **Agent:**
+                        ${block(sample.answer)}
+                    `));
             }
         }
         return examples;
@@ -28667,7 +28832,11 @@
      * @private internal utility of `createStandaloneBookLanguageMarkdown`
      */
     function renderDocumentationSection(title, documentation) {
-        return `#### ${title}\n\n${removeLeadingTopLevelHeading(documentation)}`;
+        return spacetrim.spaceTrim((block) => `
+            #### ${title}
+
+            ${block(removeLeadingTopLevelHeading(documentation))}
+        `);
     }
     /**
      * Renders the documentation body for one grouped commitment entry.
@@ -35136,7 +35305,8 @@
      * @private internal function of `$registeredLlmToolsMessage`
      */
     function createUsedEnvMessage() {
-        return `Unknown \`.env\` file` ;
+        return `Unknown \`.env\` file`
+            ;
     }
     // TODO: [®] DRY Register logic
     // TODO: [🧠][⚛] Maybe pass env as argument
@@ -41824,7 +41994,11 @@
             };
         }
         return {
-            content: `${content.slice(0, Math.max(0, maxCharacters))}\n\n[...truncated...]`,
+            content: spacetrim.spaceTrim((block) => `
+                ${block(content.slice(0, Math.max(0, maxCharacters)))}
+
+                [...truncated...]
+            `),
             isTruncated: true,
         };
     }