@cplace/mcp-server 1.7.11 → 1.8.6

package/dist/tools/layout-richstring-translator.js

@@ -0,0 +1,712 @@
+import { richstringExtractWidgets } from './richstring-widgets.js';
+import { isRichStringWidgetType, extractStringConfigValue, getScriptPropertyKey } from './layout-richstring-shared.js';
+import { determineApiEndpoint, buildRequestParams, findWidgetById } from './widget-tool-helpers.js';
+export class DecodedWidgetParseError extends Error {
+    constructor(msg) {
+        super(msg);
+        this.name = 'DecodedWidgetParseError';
+    }
+}
+const DECODED_TAG_REGEX_SRC = '<embeddedwidget\\b([^>]*)>([\\s\\S]*?)<\\/embeddedwidget>';
+const RAW_BASE64_TAG_REGEX = /<embeddedwidget>[-_a-zA-Z0-9]+<\/embeddedwidget>/;
+const RAW_BASE64_TAG_REGEX_GLOBAL = /<embeddedwidget>[-_a-zA-Z0-9]+<\/embeddedwidget>/g;
+export function formatDecodedTag(data) {
+    const idAttr = data.id ? ` id="${escapeAttr(data.id)}"` : '';
+    const typeAttr = ` type="${escapeAttr(data.widgetType)}"`;
+    const body = JSON.stringify({ properties: data.properties ?? {} });
+    return `<embeddedwidget${idAttr}${typeAttr}>${body}</embeddedwidget>`;
+}
+export function parseDecodedTag(tagText) {
+    const m = tagText.match(new RegExp(`^${DECODED_TAG_REGEX_SRC}$`));
+    if (!m)
+        throw new DecodedWidgetParseError('Not an embeddedwidget tag');
+    const attrs = parseAttrs(m[1]);
+    if (!attrs.type) {
+        throw new DecodedWidgetParseError('<embeddedwidget> requires type attribute in decoded form');
+    }
+    let body;
+    try {
+        body = JSON.parse(m[2]);
+    }
+    catch (e) {
+        throw new DecodedWidgetParseError(`Invalid JSON in embeddedwidget body (id=${attrs.id ?? 'new'}): ${e.message}`);
+    }
+    if (!body || typeof body !== 'object' || Array.isArray(body)) {
+        throw new DecodedWidgetParseError(`embeddedwidget body must be {"properties": {...}} (id=${attrs.id ?? 'new'})`);
+    }
+    const keys = Object.keys(body);
+    if (keys.length !== 1 || keys[0] !== 'properties') {
+        throw new DecodedWidgetParseError(`embeddedwidget body must have exactly one top-level key 'properties' (id=${attrs.id ?? 'new'})`);
+    }
+    if (!body.properties || typeof body.properties !== 'object' || Array.isArray(body.properties)) {
+        throw new DecodedWidgetParseError(`embeddedwidget body.properties must be an object (id=${attrs.id ?? 'new'})`);
+    }
+    return { id: attrs.id, widgetType: attrs.type, properties: body.properties };
+}
+export function findAllDecodedTags(content) {
+    const out = [];
+    if (!content)
+        return out;
+    const re = new RegExp(DECODED_TAG_REGEX_SRC, 'g');
+    let m;
+    while ((m = re.exec(content)) !== null) {
+        const raw = m[0];
+        out.push({
+            data: parseDecodedTag(raw),
+            raw,
+            start: m.index,
+            end: m.index + raw.length
+        });
+    }
+    return out;
+}
+export function containsRawBase64Tag(content) {
+    if (!content)
+        return false;
+    return RAW_BASE64_TAG_REGEX.test(content);
+}
+function parseAttrs(raw) {
+    const out = {};
+    const re = /(\w+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+    let m;
+    while ((m = re.exec(raw)) !== null) {
+        const key = m[1].toLowerCase();
+        const val = m[2] ?? m[3] ?? '';
+        if (key === 'id')
+            out.id = val;
+        else if (key === 'type')
+            out.type = val;
+    }
+    return out;
+}
+function escapeAttr(v) {
+    return v.replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+}
+export async function decodeRichStringsInLayout(client, layoutJson) {
+    if (!layoutJson || !Array.isArray(layoutJson.rows))
+        return layoutJson;
+    await walkLayoutRows(client, layoutJson.rows);
+    return layoutJson;
+}
+export async function decodeRichStringsInWidget(client, widget) {
+    if (!widget)
+        return widget;
+    if (isRichStringWidgetType(widget.widgetType)) {
+        await decodeConfigurationContent(client, widget.configuration);
+    }
+    if (widget.widgetsLayout?.rows) {
+        await walkLayoutRows(client, widget.widgetsLayout.rows);
+    }
+    return widget;
+}
+export async function decodeRichStringsInScript(client, script) {
+    if (!script)
+        return script;
+    if (!RAW_BASE64_TAG_REGEX.test(script))
+        return script;
+    return await decodeBase64TagsInScript(client, script);
+}
+async function walkLayoutRows(client, rows) {
+    for (const row of rows ?? []) {
+        for (const column of row?.columns ?? []) {
+            for (const widget of column?.widgets ?? []) {
+                await decodeRichStringsInWidget(client, widget);
+            }
+        }
+    }
+}
+async function decodeConfigurationContent(client, configuration) {
+    if (!configuration)
+        return;
+    const content = extractStringConfigValue(configuration, 'content');
+    if (!content || !RAW_BASE64_TAG_REGEX.test(content))
+        return;
+    const decoded = await decodeBase64TagsInString(client, content);
+    writeBackContent(configuration, 'content', decoded);
+}
+function writeBackContent(configuration, key, value) {
+    if (Array.isArray(configuration)) {
+        const entry = configuration.find((e) => e?.name === key);
+        if (entry?.values?.[0]) {
+            if (typeof entry.values[0] === 'string') {
+                entry.values[0] = value;
+            }
+            else if (entry.values[0].string !== undefined) {
+                entry.values[0].string = value;
+            }
+            else if (entry.values[0].markup !== undefined) {
+                entry.values[0].markup = value;
+            }
+            else {
+                entry.values[0].string = value;
+            }
+        }
+        return;
+    }
+    const existing = configuration[key];
+    if (existing && typeof existing === 'object' && 'markup' in existing) {
+        existing.markup = value;
+    }
+    else {
+        configuration[key] = value;
+    }
+}
+async function decodeBase64TagsInString(client, content) {
+    const extract = await richstringExtractWidgets(client, content);
+    const widgets = extract?.embeddedWidgets ?? [];
+    if (widgets.length === 0)
+        return content;
+    const matches = [...content.matchAll(RAW_BASE64_TAG_REGEX_GLOBAL)];
+    if (matches.length !== widgets.length) {
+        throw new Error(`richstring decode mismatch: ${matches.length} base64 tags vs ${widgets.length} extracted widgets`);
+    }
+    let out = '';
+    let cursor = 0;
+    for (let i = 0; i < matches.length; i++) {
+        const m = matches[i];
+        const w = widgets[i];
+        out += content.substring(cursor, m.index);
+        out += formatDecodedTag({
+            id: w.widgetId,
+            widgetType: w.widgetType,
+            properties: w.properties ?? {}
+        });
+        cursor = m.index + m[0].length;
+    }
+    out += content.substring(cursor);
+    return out;
+}
+async function decodeBase64TagsInScript(client, script) {
+    const extract = await richstringExtractWidgets(client, script);
+    const widgets = extract?.embeddedWidgets ?? [];
+    if (widgets.length === 0)
+        return script;
+    const matches = [...script.matchAll(RAW_BASE64_TAG_REGEX_GLOBAL)];
+    if (matches.length !== widgets.length) {
+        throw new Error(`richstring decode mismatch: ${matches.length} base64 tags vs ${widgets.length} extracted widgets`);
+    }
+    const mask = buildScriptMask(script);
+    let out = '';
+    let cursor = 0;
+    for (let i = 0; i < matches.length; i++) {
+        const m = matches[i];
+        const w = widgets[i];
+        const idx = m.index;
+        const decoded = formatDecodedTag({
+            id: w.widgetId,
+            widgetType: w.widgetType,
+            properties: w.properties ?? {}
+        });
+        let replacement = decoded;
+        if (mask[idx] === 1) {
+            const quote = findEnclosingLiteralQuote(script, mask, idx);
+            if (quote === '"' || quote === "'") {
+                replacement = escapeJsString(decoded, quote);
+            }
+        }
+        out += script.substring(cursor, idx) + replacement;
+        cursor = idx + m[0].length;
+    }
+    out += script.substring(cursor);
+    return out;
+}
+function findEnclosingLiteralQuote(script, mask, idx) {
+    let i = idx - 1;
+    while (i >= 0 && mask[i] === 1)
+        i--;
+    const q = i + 1;
+    if (q >= script.length)
+        return null;
+    const c = script[q];
+    return c === '"' || c === "'" || c === '`' ? c : null;
+}
+function buildScriptMask(script) {
+    const mask = new Uint8Array(script.length);
+    let i = 0;
+    while (i < script.length) {
+        const c = script[i];
+        if (c === '/' && script[i + 1] === '/') {
+            while (i < script.length && script[i] !== '\n') {
+                mask[i++] = 2;
+            }
+        }
+        else if (c === '/' && script[i + 1] === '*') {
+            mask[i++] = 2;
+            mask[i++] = 2;
+            while (i < script.length && !(script[i] === '*' && script[i + 1] === '/')) {
+                mask[i++] = 2;
+            }
+            if (i < script.length) {
+                mask[i++] = 2;
+                mask[i++] = 2;
+            }
+        }
+        else if (c === '"' || c === "'" || c === '`') {
+            const quote = c;
+            mask[i++] = 1;
+            while (i < script.length) {
+                mask[i] = 1;
+                if (script[i] === '\\') {
+                    i++;
+                    if (i < script.length) {
+                        mask[i] = 1;
+                        i++;
+                    }
+                    continue;
+                }
+                if (script[i] === quote) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+        }
+        else {
+            i++;
+        }
+    }
+    return mask;
+}
+export function unescapeJsString(raw, _quote) {
+    let out = '';
+    let i = 0;
+    while (i < raw.length) {
+        const c = raw[i];
+        if (c === '\\' && i + 1 < raw.length) {
+            const n = raw[i + 1];
+            switch (n) {
+                case 'n':
+                    out += '\n';
+                    break;
+                case 'r':
+                    out += '\r';
+                    break;
+                case 't':
+                    out += '\t';
+                    break;
+                case 'b':
+                    out += '\b';
+                    break;
+                case 'f':
+                    out += '\f';
+                    break;
+                case 'v':
+                    out += '\v';
+                    break;
+                case '0':
+                    out += '\0';
+                    break;
+                case '\\':
+                    out += '\\';
+                    break;
+                case '"':
+                    out += '"';
+                    break;
+                case "'":
+                    out += "'";
+                    break;
+                case '`':
+                    out += '`';
+                    break;
+                case 'x': {
+                    const hex = raw.substr(i + 2, 2);
+                    out += String.fromCharCode(parseInt(hex, 16));
+                    i += 4;
+                    continue;
+                }
+                case 'u': {
+                    if (raw[i + 2] === '{') {
+                        const end = raw.indexOf('}', i + 3);
+                        const hex = raw.substring(i + 3, end);
+                        out += String.fromCodePoint(parseInt(hex, 16));
+                        i = end + 1;
+                        continue;
+                    }
+                    else {
+                        const hex = raw.substr(i + 2, 4);
+                        out += String.fromCharCode(parseInt(hex, 16));
+                        i += 6;
+                        continue;
+                    }
+                }
+                default:
+                    out += n;
+                    break;
+            }
+            i += 2;
+        }
+        else {
+            out += c;
+            i++;
+        }
+    }
+    return out;
+}
+export function escapeJsString(value, quote) {
+    let out = '';
+    for (let i = 0; i < value.length; i++) {
+        const c = value[i];
+        if (c === '\\')
+            out += '\\\\';
+        else if (c === quote)
+            out += '\\' + quote;
+        else if (c === '\n')
+            out += '\\n';
+        else if (c === '\r')
+            out += '\\r';
+        else if (c === '\t')
+            out += '\\t';
+        else if (c === '\b')
+            out += '\\b';
+        else if (c === '\f')
+            out += '\\f';
+        else if (c.charCodeAt(0) < 0x20) {
+            out += '\\x' + c.charCodeAt(0).toString(16).padStart(2, '0');
+        }
+        else {
+            out += c;
+        }
+    }
+    return out;
+}
+function scanSimpleStringKeys(script, mask, bodyStart, bodyEnd) {
+    const out = {};
+    let depth = 0;
+    let i = bodyStart;
+    while (i < bodyEnd) {
+        if (mask[i] === 1 || mask[i] === 2) {
+            i++;
+            continue;
+        }
+        const c = script[i];
+        if (c === '{') {
+            depth++;
+            i++;
+            continue;
+        }
+        if (c === '}') {
+            depth--;
+            i++;
+            continue;
+        }
+        if (depth !== 0) {
+            i++;
+            continue;
+        }
+        if (/[A-Za-z_$]/.test(c)) {
+            let j = i;
+            while (j < bodyEnd && /[A-Za-z0-9_$.]/.test(script[j]))
+                j++;
+            const key = script.substring(i, j);
+            let k = j;
+            while (k < bodyEnd && /\s/.test(script[k]))
+                k++;
+            if (script[k] === ':') {
+                k++;
+                while (k < bodyEnd && /\s/.test(script[k]))
+                    k++;
+                if (script[k] === '"' || script[k] === "'") {
+                    const quote = script[k];
+                    const strStart = k + 1;
+                    let e = strStart;
+                    while (e < bodyEnd) {
+                        if (script[e] === '\\') {
+                            e += 2;
+                            continue;
+                        }
+                        if (script[e] === quote)
+                            break;
+                        e++;
+                    }
+                    out[key] = unescapeJsString(script.substring(strStart, e), quote);
+                    i = e + 1;
+                    continue;
+                }
+            }
+            i = j;
+            continue;
+        }
+        i++;
+    }
+    return out;
+}
+function findEnclosingObject(script, mask, anchor) {
+    let depth = 0;
+    let open = -1;
+    for (let i = anchor - 1; i >= 0; i--) {
+        if (mask[i] === 1 || mask[i] === 2)
+            continue;
+        const c = script[i];
+        if (c === '}')
+            depth++;
+        else if (c === '{') {
+            if (depth === 0) {
+                open = i;
+                break;
+            }
+            depth--;
+        }
+    }
+    if (open < 0)
+        return null;
+    let d = 1;
+    let close = -1;
+    for (let i = open + 1; i < script.length; i++) {
+        if (mask[i] === 1 || mask[i] === 2)
+            continue;
+        const c = script[i];
+        if (c === '{')
+            d++;
+        else if (c === '}') {
+            d--;
+            if (d === 0) {
+                close = i;
+                break;
+            }
+        }
+    }
+    if (close < 0)
+        return null;
+    return { open, close };
+}
+export function findRichStringContentLiterals(script) {
+    const mask = buildScriptMask(script);
+    const locations = [];
+    const seenLiteralStarts = new Set();
+    const keyRegex = /(?:['"]content['"]\s*:\s*|\bcontent\s*:\s*)/g;
+    let km;
+    while ((km = keyRegex.exec(script)) !== null) {
+        const matchStart = km.index;
+        const keyPos = (km[0][0] === "'" || km[0][0] === '"') ? matchStart + 1 : matchStart;
+        if (mask[keyPos] !== 0) {
+            const isQuotedKey = mask[keyPos] === 1 &&
+                keyPos >= 2 &&
+                mask[keyPos - 2] === 0 &&
+                (script[keyPos - 1] === "'" || script[keyPos - 1] === '"') &&
+                mask[keyPos - 1] === 1 &&
+                keyPos + 7 < script.length &&
+                script[keyPos + 7] === script[keyPos - 1] &&
+                mask[keyPos + 7] === 1;
+            if (!isQuotedKey)
+                continue;
+        }
+        const afterKey = matchStart + km[0].length;
+        const nextCh = script[afterKey];
+        if (nextCh !== '"' && nextCh !== "'") {
+            if (nextCh === '`') {
+                throw new DecodedWidgetParseError("richstring widget `content` must use a plain string literal, not a template literal.\n" +
+                    "  ✅ content: '<embeddedwidget type=\"...\">...</embeddedwidget>'\n" +
+                    "  ❌ content: `<embeddedwidget type=\"...\">...</embeddedwidget>`\n" +
+                    "Or use cplace_layout_richstring_* tools for programmatic edits.");
+            }
+            const enclosing = findEnclosingObject(script, mask, keyPos);
+            if (!enclosing)
+                continue;
+            const keys = scanSimpleStringKeys(script, mask, enclosing.open + 1, enclosing.close);
+            const widgetType = keys.type || keys.widgetType;
+            if (widgetType && isRichStringWidgetType(widgetType)) {
+                throw new DecodedWidgetParseError("richstring widget `content` must be a plain string literal — variables, concatenation, and expressions are not supported.\n" +
+                    "  ✅ content: '<embeddedwidget type=\"...\">...</embeddedwidget>'\n" +
+                    "  ❌ content: myVar\n" +
+                    "Or use cplace_layout_richstring_* tools for programmatic edits.");
+            }
+            continue;
+        }
+        const quote = nextCh;
+        const literalStart = afterKey;
+        let e = literalStart + 1;
+        while (e < script.length) {
+            if (script[e] === '\\') {
+                e += 2;
+                continue;
+            }
+            if (script[e] === quote)
+                break;
+            e++;
+        }
+        const literalEnd = e + 1;
+        if (seenLiteralStarts.has(literalStart))
+            continue;
+        let currentAnchor = keyPos;
+        let widgetType;
+        let widgetId;
+        let viaUpdateWidget = false;
+        let foundContext = false;
+        for (let hop = 0; hop < 6; hop++) {
+            const enclosing = findEnclosingObject(script, mask, currentAnchor);
+            if (!enclosing)
+                break;
+            const keys = scanSimpleStringKeys(script, mask, enclosing.open + 1, enclosing.close);
+            const ty = keys.type || keys.widgetType;
+            if (ty) {
+                if (isRichStringWidgetType(ty)) {
+                    widgetType = ty;
+                    widgetId = keys.id;
+                    foundContext = true;
+                }
+                break;
+            }
+            const uw = detectUpdateWidgetCall(script, mask, enclosing.open);
+            if (uw) {
+                widgetId = uw.widgetId;
+                viaUpdateWidget = true;
+                foundContext = true;
+                break;
+            }
+            currentAnchor = enclosing.open;
+        }
+        if (!foundContext) {
+            const literalText = unescapeJsString(script.substring(literalStart + 1, e), quote);
+            if (literalText.includes('<embeddedwidget')) {
+                throw new DecodedWidgetParseError(`Found a \`content:\` string literal at position ${literalStart} with a decoded <embeddedwidget> ` +
+                    `tag but could not resolve its richstring widget context. ` +
+                    `The enclosing object must have a \`type:\` or \`widgetType:\` key matching a richstring widget, ` +
+                    `or the literal must be the second argument of \`layout.updateWidget("<id>", { content: "..." })\`.`);
+            }
+            continue;
+        }
+        locations.push({
+            widgetId,
+            widgetType,
+            viaUpdateWidget,
+            literalStart,
+            literalEnd,
+            quote,
+            content: unescapeJsString(script.substring(literalStart + 1, e), quote)
+        });
+        seenLiteralStarts.add(literalStart);
+    }
+    return locations;
+}
+function detectUpdateWidgetCall(script, mask, objOpen) {
+    let i = objOpen - 1;
+    while (i >= 0 && (mask[i] === 1 || mask[i] === 2 || /\s/.test(script[i])))
+        i--;
+    if (i < 0 || script[i] !== ',')
+        return null;
+    i--;
+    while (i >= 0 && /\s/.test(script[i]) && mask[i] === 0)
+        i--;
+    if (i < 0 || (script[i] !== '"' && script[i] !== "'"))
+        return null;
+    const closeQuote = script[i];
+    let strStart = i - 1;
+    while (strStart >= 0 && !(script[strStart] === closeQuote && script[strStart - 1] !== '\\')) {
+        strStart--;
+    }
+    if (strStart < 0)
+        return null;
+    const widgetId = unescapeJsString(script.substring(strStart + 1, i), closeQuote);
+    i = strStart - 1;
+    while (i >= 0 && /\s/.test(script[i]) && mask[i] === 0)
+        i--;
+    if (i < 0 || script[i] !== '(')
+        return null;
+    i--;
+    const fnName = 'updateWidget';
+    const fnEnd = i + 1;
+    const fnStart = fnEnd - fnName.length;
+    if (fnStart < 0)
+        return null;
+    if (script.substring(fnStart, fnEnd) !== fnName)
+        return null;
+    return { widgetId };
+}
+export async function encodeRichStringsInScript(client, context, script) {
+    if (!script)
+        return script;
+    if (containsRawBase64Tag(script)) {
+        throw new DecodedWidgetParseError('Raw base64 <embeddedwidget> tags are not accepted on writes. Use the decoded form:\n' +
+            '  <embeddedwidget id="…" type="…">{"properties":{…}}</embeddedwidget>\n' +
+            'To fetch current decoded form, call cplace_get_layout_script or cplace_get_layout_widget_details.');
+    }
+    const locations = findRichStringContentLiterals(script);
+    const mask = buildScriptMask(script);
+    assertNoStrayDecodedTag(script, mask, locations);
+    if (locations.length === 0)
+        return script;
+    let cachedLayout = null;
+    const getLayout = async () => {
+        if (cachedLayout === null) {
+            const endpoint = determineApiEndpoint(context);
+            cachedLayout = await client.makeApiRequest(endpoint, 'GET', buildRequestParams(context));
+        }
+        return cachedLayout;
+    };
+    const sorted = [...locations].sort((a, b) => b.literalStart - a.literalStart);
+    let modifiedScript = script;
+    for (const loc of sorted) {
+        const encoded = await encodeSingleLocation(client, loc, getLayout);
+        if (encoded === null)
+            continue;
+        const replacement = loc.quote + escapeJsString(encoded, loc.quote) + loc.quote;
+        modifiedScript =
+            modifiedScript.substring(0, loc.literalStart) +
+                replacement +
+                modifiedScript.substring(loc.literalEnd);
+    }
+    return modifiedScript;
+}
+async function encodeSingleLocation(client, loc, getLayout) {
+    let currentContent;
+    if (loc.widgetId) {
+        const layout = await getLayout();
+        const normalized = loc.widgetId.startsWith('_') ? loc.widgetId : '_' + loc.widgetId;
+        const w = findWidgetById(layout.rows ?? [], normalized) ??
+            findWidgetById(layout.rows ?? [], loc.widgetId);
+        if (w) {
+            if (loc.viaUpdateWidget && !isRichStringWidgetType(w.widgetType)) {
+                return null;
+            }
+            currentContent = extractStringConfigValue(w.configuration, 'content') || undefined;
+        }
+        else if (loc.viaUpdateWidget) {
+            throw new DecodedWidgetParseError(`layout.updateWidget references unknown widget id '${loc.widgetId}'`);
+        }
+    }
+    for (const match of findAllDecodedTags(loc.content)) {
+        const scriptKey = getScriptPropertyKey(match.data.widgetType);
+        if (!scriptKey)
+            continue;
+        const value = match.data.properties[scriptKey];
+        if (Array.isArray(value)) {
+            const idFragment = match.data.id ? ` id="${match.data.id}"` : '';
+            throw new DecodedWidgetParseError(`<embeddedwidget type="${match.data.widgetType}"${idFragment}> has ` +
+                `"${scriptKey}" as an array — hand-built embeddedwidget JSON must use ` +
+                `a plain string here.\n` +
+                `❌ {"properties":{"${scriptKey}":["return 1;"]}}\n` +
+                `✅ {"properties":{"${scriptKey}":"return 1;"}}\n` +
+                `(The array form is an input convenience for cplace_richstring_insert_widget ` +
+                `that the backend unwraps. When you hand-build <embeddedwidget> JSON ` +
+                `inside layout scripts, use the plain-string form above.)`);
+        }
+    }
+    const response = await client.makeApiRequest('json/richstring-embedded-widget/encode-inline', 'POST', undefined, { content: loc.content, currentContent });
+    if (response?.error) {
+        throw new DecodedWidgetParseError(response.error);
+    }
+    return response.content;
+}
+function assertNoStrayDecodedTag(script, mask, locations) {
+    const ranges = locations
+        .map(l => [l.literalStart, l.literalEnd])
+        .sort((a, b) => a[0] - b[0]);
+    const needle = '<embeddedwidget';
+    let from = 0;
+    while (true) {
+        const idx = script.indexOf(needle, from);
+        if (idx < 0)
+            return;
+        from = idx + needle.length;
+        if (mask[idx] === 2)
+            continue;
+        const insideClassified = ranges.some(([s, e]) => idx >= s && idx < e);
+        if (insideClassified)
+            continue;
+        throw new DecodedWidgetParseError("<embeddedwidget> tag found outside a content: value. Tags must appear directly inline:\n" +
+            "  ✅ layout.updateWidget(\"id\", { content: '<embeddedwidget type=\"...\">...</embeddedwidget>' });\n" +
+            "  ❌ var tag = '<embeddedwidget ...>'; layout.updateWidget(\"id\", { content: tag });\n" +
+            "Or use cplace_layout_richstring_* tools for programmatic edits.");
+    }
+}
+//# sourceMappingURL=layout-richstring-translator.js.map