@promptbook/core 0.114.0-5 → 0.114.0-7

package/umd/index.umd.js

@@ -28,7 +28,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-5';
+    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-7';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -11038,6 +11038,13 @@
     }
 
     /* eslint-disable no-magic-numbers */
+    // Note: [💞] Ignore a discrepancy between file name and entity name
+    /**
+     * Default square size used by avatar renderers.
+     *
+     * @private utility of the avatar rendering system
+     */
+    const DEFAULT_AVATAR_SIZE = 192;
     /**
      * Corner radius ratio used for the common rounded card frame.
      *
@@ -11408,6 +11415,15 @@
      * @private helper of `asciiOctopusAvatarVisual`
      */
     const ATMOSPHERE_GLYPHS = ['.', ':', "'", '`'];
+    /**
+     * Coordinate space the octopus layout is generated in when it is painted into a terminal.
+     *
+     * The terminal renderer has its own character grid, so the geometry only needs one stable
+     * square coordinate space which the grid is then sampled from.
+     *
+     * @private helper of `asciiOctopusAvatarVisual`
+     */
+    const TERMINAL_ASCII_OCTOPUS_LAYOUT_SIZE = DEFAULT_AVATAR_SIZE;
     /**
      * AsciiOctopus avatar visual.
      *
@@ -11424,41 +11440,115 @@
             const staticRandom = createRandom('ascii-octopus-static');
             const gridMetrics = createAsciiGridMetrics(size, gridRandom);
             const layout = createAsciiOctopusLayout(size, timeMs, createRandom, staticRandom, interaction);
+            const glyphGrid = createAsciiOctopusGlyphGrid({
+                sampleGrid: gridMetrics,
+                layout,
+                palette,
+                cellRandom: createRandom('ascii-octopus-cells'),
+                timeMs,
+            });
             drawAvatarFrame(context, size, palette);
             drawAsciiBackdrop(context, size, palette, layout, timeMs);
             context.save();
             context.font = `600 ${gridMetrics.fontSize}px monospace`;
             context.textAlign = 'center';
             context.textBaseline = 'middle';
-            // The ASCII renderer samples the morphing octopus field on a low-resolution grid so the shape stays organic
-            // while the glyph layout remains deterministic for the same avatar input.
-            const cellRandom = createRandom('ascii-octopus-cells');
             for (let rowIndex = 0; rowIndex < gridMetrics.rowCount; rowIndex++) {
                 for (let columnIndex = 0; columnIndex < gridMetrics.columnCount; columnIndex++) {
-                    const point = {
-                        x: gridMetrics.offsetX + columnIndex * gridMetrics.cellWidth,
-                        y: gridMetrics.offsetY + rowIndex * gridMetrics.cellHeight,
-                    };
-                    const noise = cellRandom();
-                    const glyphDescriptor = resolveAsciiGlyph({
-                        point,
-                        layout,
-                        palette,
-                        cellWidth: gridMetrics.cellWidth,
-                        cellHeight: gridMetrics.cellHeight,
-                        noise,
-                        timeMs,
-                    });
+                    const glyphDescriptor = glyphGrid[rowIndex][columnIndex];
                     if (!glyphDescriptor) {
                         continue;
                     }
+                    const point = resolveAsciiSampleGridPoint(gridMetrics, columnIndex, rowIndex);
                     context.fillStyle = glyphDescriptor.color;
                     context.fillText(glyphDescriptor.character, point.x, point.y);
                 }
             }
             context.restore();
         },
+        renderTerminalText({ columns, rows, palette, createRandom, timeMs, interaction }) {
+            const staticRandom = createRandom('ascii-octopus-static');
+            const layout = createAsciiOctopusLayout(TERMINAL_ASCII_OCTOPUS_LAYOUT_SIZE, timeMs, createRandom, staticRandom, interaction);
+            return createAsciiOctopusGlyphGrid({
+                sampleGrid: createAsciiTerminalSampleGrid(columns, rows),
+                layout,
+                palette,
+                cellRandom: createRandom('ascii-octopus-cells'),
+                timeMs,
+            });
+        },
     };
+    /**
+     * Resolves the geometry point sampled for one cell of the grid.
+     *
+     * @param sampleGrid Character-cell sampling grid.
+     * @param columnIndex Zero-based cell column.
+     * @param rowIndex Zero-based cell row.
+     * @returns Sampled point in the octopus coordinate space.
+     *
+     * @private helper of `asciiOctopusAvatarVisual`
+     */
+    function resolveAsciiSampleGridPoint(sampleGrid, columnIndex, rowIndex) {
+        return {
+            x: sampleGrid.offsetX + columnIndex * sampleGrid.cellWidth,
+            y: sampleGrid.offsetY + rowIndex * sampleGrid.cellHeight,
+        };
+    }
+    /**
+     * Builds the sampling grid used when the octopus is painted straight into terminal character cells.
+     *
+     * @param columns Available terminal columns.
+     * @param rows Available terminal rows.
+     * @returns Character-cell sampling grid covering the whole octopus coordinate space.
+     *
+     * @private helper of `asciiOctopusAvatarVisual`
+     */
+    function createAsciiTerminalSampleGrid(columns, rows) {
+        const cellWidth = TERMINAL_ASCII_OCTOPUS_LAYOUT_SIZE / columns;
+        const cellHeight = TERMINAL_ASCII_OCTOPUS_LAYOUT_SIZE / rows;
+        return {
+            cellWidth,
+            cellHeight,
+            columnCount: columns,
+            rowCount: rows,
+            offsetX: cellWidth / 2,
+            offsetY: cellHeight / 2,
+        };
+    }
+    /**
+     * Samples the morphing octopus field into one deterministic grid of ASCII glyphs.
+     *
+     * The field is sampled on a low-resolution grid so the shape stays organic while the glyph
+     * layout remains deterministic for the same avatar input. Both the canvas visual and the
+     * terminal visual share this single sampling pass so they always describe the same octopus.
+     *
+     * @param options Sampling grid, prepared octopus layout, palette, per-cell noise, and animation time.
+     * @returns Resolved glyph of every sampled cell, where `null` means an empty cell.
+     *
+     * @private helper of `asciiOctopusAvatarVisual`
+     */
+    function createAsciiOctopusGlyphGrid(options) {
+        const { sampleGrid, layout, palette, cellRandom, timeMs } = options;
+        const glyphGrid = [];
+        for (let rowIndex = 0; rowIndex < sampleGrid.rowCount; rowIndex++) {
+            const glyphRow = [];
+            for (let columnIndex = 0; columnIndex < sampleGrid.columnCount; columnIndex++) {
+                const point = resolveAsciiSampleGridPoint(sampleGrid, columnIndex, rowIndex);
+                const noise = cellRandom();
+                glyphRow.push(resolveAsciiGlyph({
+                    point,
+                    layout,
+                    palette,
+                    cellWidth: sampleGrid.cellWidth,
+                    cellHeight: sampleGrid.cellHeight,
+                    noise,
+                    timeMs,
+                }));
+            }
+            glyphGrid.push(glyphRow);
+        }
+        return glyphGrid;
+    }
     /**
      * Draws the dark terminal-like glow behind the ASCII octopus.
      *
@@ -27108,12 +27198,7 @@
         const parsedSource = parseAgentSourceWithCommitments(source);
         const commitmentTypes = new Set([group.primary.type, ...group.aliases]);
         const isOpenClosedCommitmentFamily = commitmentTypes.has(OPEN_COMMITMENT_TYPE) && commitmentTypes.has(CLOSED_COMMITMENT_TYPE);
-        const allowedCommitmentTypes = new Set([
-            group.primary.type,
-            ...group.aliases,
-            'GOAL',
-            CLOSED_COMMITMENT_TYPE,
-        ]);
+        const allowedCommitmentTypes = new Set([group.primary.type, ...group.aliases, 'GOAL', CLOSED_COMMITMENT_TYPE]);
         const canonicalTypeByCommitmentType = createCanonicalCommitmentTypeByCommitmentType(group, isOpenClosedCommitmentFamily);
         const focusedCommitments = parsedSource.commitments
             .filter((commitment) => allowedCommitmentTypes.has(commitment.type))
@@ -27220,9 +27305,7 @@
         if (!isClosedCommitmentIncluded && !isOpenCommitmentIncluded) {
             normalizedFocusedCommitments.push(CLOSED_COMMITMENT_TYPE);
         }
-        return [agentName, ...normalizedFocusedCommitments]
-            .filter((line) => Boolean(line))
-            .join('\n\n');
+        return [agentName, ...normalizedFocusedCommitments].filter((line) => Boolean(line)).join('\n\n');
     }
     /**
      * Keeps an example title unless the parser interpreted a commitment-only
@@ -27514,9 +27597,7 @@
 
             ${block(dictionary.tutorialSections.checklistBody)}
 
-            ${block(isLowLevelCommitmentsIncluded
-        ? renderLowLevelCommitmentsChapter(lowLevelCommitments, dictionary)
-        : '')}
+            ${block(isLowLevelCommitmentsIncluded ? renderLowLevelCommitmentsChapter(lowLevelCommitments, dictionary) : '')}
 
             ---
 
@@ -29562,8 +29643,8 @@
          */
         $applyToTaskJson(command, $taskJson) {
             if ($taskJson.format !== undefined && command.format !== $taskJson.format) {
-                throw new ParseError(`Format format is already defined to "${$taskJson.format}".
-                Now you try to redefine it by "${command.format}"`);
+                throw new ParseError(spacetrim.spaceTrim(`Format format is already defined to "${$taskJson.format}".
+                Now you try to redefine it by "${command.format}"`));
             }
             $taskJson.format = command.format;
         },
@@ -34873,28 +34954,28 @@
      */
     function buildToolInvocationScript(options) {
         const { functionName, functionArgsExpression } = options;
-        return `
-        const args = ${functionArgsExpression};
-        const runtimeContextRaw =
-            typeof ${TOOL_RUNTIME_CONTEXT_PARAMETER} === 'undefined'
-                ? undefined
-                : ${TOOL_RUNTIME_CONTEXT_PARAMETER};
+        return spacetrim.spaceTrim((block) => `
+            const args = ${block(functionArgsExpression)};
+            const runtimeContextRaw =
+                typeof ${TOOL_RUNTIME_CONTEXT_PARAMETER} === 'undefined'
+                    ? undefined
+                    : ${TOOL_RUNTIME_CONTEXT_PARAMETER};
 
-        if (runtimeContextRaw !== undefined && args && typeof args === 'object' && !Array.isArray(args)) {
-            args.${TOOL_RUNTIME_CONTEXT_ARGUMENT} = runtimeContextRaw;
-        }
+            if (runtimeContextRaw !== undefined && args && typeof args === 'object' && !Array.isArray(args)) {
+                args.${TOOL_RUNTIME_CONTEXT_ARGUMENT} = runtimeContextRaw;
+            }
 
-        const toolProgressTokenRaw =
-            typeof ${TOOL_PROGRESS_TOKEN_PARAMETER} === 'undefined'
-                ? undefined
-                : ${TOOL_PROGRESS_TOKEN_PARAMETER};
+            const toolProgressTokenRaw =
+                typeof ${TOOL_PROGRESS_TOKEN_PARAMETER} === 'undefined'
+                    ? undefined
+                    : ${TOOL_PROGRESS_TOKEN_PARAMETER};
 
-        if (toolProgressTokenRaw !== undefined && args && typeof args === 'object' && !Array.isArray(args)) {
-            args.${TOOL_PROGRESS_TOKEN_ARGUMENT} = toolProgressTokenRaw;
-        }
+            if (toolProgressTokenRaw !== undefined && args && typeof args === 'object' && !Array.isArray(args)) {
+                args.${TOOL_PROGRESS_TOKEN_ARGUMENT} = toolProgressTokenRaw;
+            }
 
-        return await ${functionName}(args);
-    `;
+            return await ${functionName}(args);
+        `);
     }
 
     /**