npm - ae-agent-setup - Versions diffs - 0.2.0 - Mend

ae-agent-setup 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (34) hide show

package/CSXS/manifest.xml +44 -0
package/README.ja.md +249 -0
package/README.md +249 -0
package/bin/ae-agent-setup.mjs +337 -0
package/client/CSInterface.js +1291 -0
package/client/index.html +64 -0
package/client/lib/bridge_utils.js +56 -0
package/client/lib/logging.js +10 -0
package/client/lib/request_handlers.js +468 -0
package/client/lib/request_handlers_essential.js +35 -0
package/client/lib/request_handlers_layer_structure.js +180 -0
package/client/lib/request_handlers_scene.js +38 -0
package/client/lib/request_handlers_shape.js +288 -0
package/client/lib/request_handlers_timeline.js +115 -0
package/client/lib/runtime.js +35 -0
package/client/lib/server.js +33 -0
package/client/main.js +1 -0
package/host/index.jsx +11 -0
package/host/json2.js +504 -0
package/host/lib/common.jsx +128 -0
package/host/lib/mutation_handlers.jsx +358 -0
package/host/lib/mutation_keyframe_handlers.jsx +265 -0
package/host/lib/mutation_layer_structure_handlers.jsx +235 -0
package/host/lib/mutation_scene_handlers.jsx +1226 -0
package/host/lib/mutation_shape_handlers.jsx +358 -0
package/host/lib/mutation_timeline_handlers.jsx +137 -0
package/host/lib/property_utils.jsx +105 -0
package/host/lib/query_handlers.jsx +427 -0
package/package.json +21 -0
package/scripts/signing/build-zxp.sh +56 -0
package/scripts/signing/create-dev-cert.sh +97 -0
package/scripts/signing/install-zxp.sh +29 -0
package/templates/skills/aftereffects-cli.SKILL.md +74 -0
package/templates/skills/aftereffects-declarative.SKILL.md +112 -0

package/client/index.html ADDED Viewed

@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>ae-agent-skill</title>
+    <style>
+        body {
+            font-family: sans-serif;
+            background-color: #323232;
+            color: #E0E0E0;
+            padding: 0;
+            margin: 0;
+            height: 100vh;
+            display: flex;
+            flex-direction: column;
+        }
+        h1 {
+            font-size: 14px;
+            padding: 10px;
+            margin: 0;
+            border-bottom: 1px solid #444;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        .version {
+            font-size: 12px;
+            color: #B0B0B0;
+        }
+        #log {
+            flex-grow: 1;
+            box-sizing: border-box;
+            width: 100%;
+            padding: 10px;
+            background-color: #282828;
+            color: #E0E0E0;
+            border: none;
+            font-family: monospace;
+            white-space: pre-wrap;
+            resize: none;
+        }
+    </style>
+</head>
+<body>
+    <h1>
+        <span>ae-agent-skill Logs</span>
+        <span class="version">v0.2.0</span>
+    </h1>
+    <textarea id="log" readonly></textarea>
+    <script type="text/javascript" src="./CSInterface.js"></script>
+    <script type="text/javascript" src="./lib/runtime.js"></script>
+    <script type="text/javascript" src="./lib/logging.js"></script>
+    <script type="text/javascript" src="./lib/bridge_utils.js"></script>
+    <script type="text/javascript" src="./lib/request_handlers_shape.js"></script>
+    <script type="text/javascript" src="./lib/request_handlers_scene.js"></script>
+    <script type="text/javascript" src="./lib/request_handlers_essential.js"></script>
+    <script type="text/javascript" src="./lib/request_handlers_timeline.js"></script>
+    <script type="text/javascript" src="./lib/request_handlers_layer_structure.js"></script>
+    <script type="text/javascript" src="./lib/request_handlers.js"></script>
+    <script type="text/javascript" src="./lib/server.js"></script>
+    <script type="text/javascript" src="./main.js"></script>
+</body>
+</html>

package/client/lib/bridge_utils.js ADDED Viewed

@@ -0,0 +1,56 @@
+const ENCODE_PREFIX = '__ENC__';
+function parseBridgeResult(result) {
+    if (typeof result !== 'string' || result.length === 0) {
+        throw new Error('ExtendScript returned an empty result.');
+    }
+    let decoded = result;
+    if (result.startsWith(ENCODE_PREFIX)) {
+        const encodedPayload = result.slice(ENCODE_PREFIX.length);
+        try {
+            decoded = decodeURIComponent(encodedPayload);
+        } catch (e) {
+            throw new Error(`Failed to decode ExtendScript payload: ${e.toString()}`);
+        }
+    }
+    return JSON.parse(decoded);
+}
+function sendJson(res, statusCode, payload) {
+    res.writeHead(statusCode);
+    res.end(JSON.stringify(payload));
+}
+function sendBadRequest(res, message, error) {
+    const payload = { status: 'error', message };
+    if (error) {
+        payload.error = error.toString();
+    }
+    sendJson(res, 400, payload);
+}
+function sendBridgeParseError(res, result, error) {
+    sendJson(res, 500, {
+        status: 'error',
+        message: 'Failed to parse ExtendScript result.',
+        error: error.toString(),
+        rawResult: result,
+    });
+}
+function readJsonBody(req, res, onParsed) {
+    let body = '';
+    req.on('data', (chunk) => {
+        body += chunk.toString();
+    });
+    req.on('end', () => {
+        try {
+            const parsed = JSON.parse(body);
+            onParsed(parsed);
+        } catch (e) {
+            sendBadRequest(res, 'Invalid JSON', e);
+        }
+    });
+}

package/client/lib/logging.js ADDED Viewed

@@ -0,0 +1,10 @@
+function appendLog(source, message) {
+    const logTextarea = document.getElementById('log');
+    const timestamp = new Date().toLocaleTimeString();
+    const prefix = source ? `[${source}] ` : '';
+    logTextarea.value = `${timestamp} ${prefix}${message}\n` + logTextarea.value;
+}
+function log(message) {
+    appendLog('Panel', message);
+}

package/client/lib/request_handlers.js ADDED Viewed

@@ -0,0 +1,468 @@
+function applyCommonResponseHeaders(res) {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Content-Type', 'application/json');
+}
+function handleCorsPreflight(req, res) {
+    if (req.method !== 'OPTIONS') {
+        return false;
+    }
+    res.writeHead(204, {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type',
+    });
+    res.end();
+    return true;
+}
+function handleBridgeDataCall(script, res, contextLabel) {
+    log(`Calling ExtendScript: ${contextLabel}`);
+    evalHostScript(script, (result) => {
+        try {
+            const parsedResult = parseBridgeResult(result);
+            sendJson(res, 200, { status: 'success', data: parsedResult });
+            log(`${contextLabel} successful.`);
+        } catch (e) {
+            sendBridgeParseError(res, result, e);
+            log(`${contextLabel} failed: ${e.toString()}`);
+        }
+    });
+}
+function handleBridgeMutationCall(script, res, contextLabel, fallbackMessage) {
+    log(`Calling ExtendScript: ${contextLabel}`);
+    evalHostScript(script, (result) => {
+        try {
+            const parsedResult = parseBridgeResult(result);
+            if (parsedResult && parsedResult.status === 'error') {
+                sendJson(res, 500, {
+                    status: 'error',
+                    message: parsedResult.message || fallbackMessage,
+                });
+                log(`${contextLabel} failed: ${parsedResult.message || 'Unknown error'}`);
+                return;
+            }
+            sendJson(res, 200, { status: 'success', data: parsedResult });
+            log(`${contextLabel} successful.`);
+        } catch (e) {
+            sendBridgeParseError(res, result, e);
+            log(`${contextLabel} failed: ${e.toString()}`);
+        }
+    });
+}
+function normalizeLayerSelector(layerIdRaw, layerNameRaw) {
+    const hasLayerId = layerIdRaw !== undefined && layerIdRaw !== null;
+    const hasLayerName = typeof layerNameRaw === 'string' && layerNameRaw.trim().length > 0;
+    if ((hasLayerId && hasLayerName) || (!hasLayerId && !hasLayerName)) {
+        return { ok: false, error: 'Provide exactly one of layerId or layerName' };
+    }
+    if (hasLayerId) {
+        if (typeof layerIdRaw !== 'number' || !Number.isInteger(layerIdRaw) || layerIdRaw <= 0) {
+            return { ok: false, error: 'layerId must be a positive integer when specified' };
+        }
+        return { ok: true, layerIdLiteral: String(layerIdRaw), layerNameLiteral: 'null' };
+    }
+    return {
+        ok: true,
+        layerIdLiteral: 'null',
+        layerNameLiteral: toExtendScriptStringLiteral(layerNameRaw.trim()),
+    };
+}
+function handleHealth(res) {
+    sendJson(res, 200, { status: 'ok' });
+    log('Health check responded with ok.');
+}
+function handleGetLayers(res) {
+    handleBridgeDataCall('getLayers()', res, 'getLayers()');
+}
+function handleGetComps(res) {
+    handleBridgeDataCall('listComps()', res, 'listComps()');
+}
+function handleGetSelectedProperties(res) {
+    handleBridgeDataCall('getSelectedProperties()', res, 'getSelectedProperties()');
+}
+function handleGetExpressionErrors(res) {
+    handleBridgeDataCall('getExpressionErrors()', res, 'getExpressionErrors()');
+}
+function handleCreateComp(req, res) {
+    readJsonBody(req, res, ({ name, width, height, duration, frameRate, pixelAspect }) => {
+        if (!name || typeof name !== 'string') {
+            sendBadRequest(res, 'name is required and must be a string');
+            log('createComp failed: invalid name');
+            return;
+        }
+        if (typeof width !== 'number' || width <= 0) {
+            sendBadRequest(res, 'width is required and must be a positive number');
+            log('createComp failed: invalid width');
+            return;
+        }
+        if (typeof height !== 'number' || height <= 0) {
+            sendBadRequest(res, 'height is required and must be a positive number');
+            log('createComp failed: invalid height');
+            return;
+        }
+        if (typeof duration !== 'number' || duration <= 0) {
+            sendBadRequest(res, 'duration is required and must be a positive number');
+            log('createComp failed: invalid duration');
+            return;
+        }
+        if (typeof frameRate !== 'number' || frameRate <= 0) {
+            sendBadRequest(res, 'frameRate is required and must be a positive number');
+            log('createComp failed: invalid frameRate');
+            return;
+        }
+        if (pixelAspect !== undefined && (typeof pixelAspect !== 'number' || pixelAspect <= 0)) {
+            sendBadRequest(res, 'pixelAspect must be a positive number when specified');
+            log('createComp failed: invalid pixelAspect');
+            return;
+        }
+        const nameLiteral = toExtendScriptStringLiteral(name);
+        const pixelAspectValue = pixelAspect === undefined ? 1.0 : pixelAspect;
+        const script = `createComp(${nameLiteral}, ${width}, ${height}, ${pixelAspectValue}, ${duration}, ${frameRate})`;
+        handleBridgeMutationCall(script, res, 'createComp()', 'Failed to create comp');
+    });
+}
+function handleSetActiveComp(req, res) {
+    readJsonBody(req, res, ({ compId, compName }) => {
+        const hasCompId = compId !== undefined;
+        const hasCompName = compName !== undefined && compName !== null && compName !== '';
+        if ((hasCompId && hasCompName) || (!hasCompId && !hasCompName)) {
+            sendBadRequest(res, 'Provide exactly one of compId or compName');
+            log('setActiveComp failed: invalid selector');
+            return;
+        }
+        if (hasCompId && typeof compId !== 'number') {
+            sendBadRequest(res, 'compId must be a number');
+            log('setActiveComp failed: compId must be number');
+            return;
+        }
+        if (hasCompName && typeof compName !== 'string') {
+            sendBadRequest(res, 'compName must be a string');
+            log('setActiveComp failed: compName must be string');
+            return;
+        }
+        const compIdLiteral = hasCompId ? String(compId) : 'null';
+        const compNameLiteral = hasCompName ? toExtendScriptStringLiteral(compName) : 'null';
+        const script = `setActiveComp(${compIdLiteral}, ${compNameLiteral})`;
+        handleBridgeMutationCall(script, res, 'setActiveComp()', 'Failed to set active comp');
+    });
+}
+function handleGetProperties(searchParams, res) {
+    const layerIdParam = searchParams.get('layerId');
+    const layerNameParam = searchParams.get('layerName');
+    const hasLayerId = layerIdParam !== null && layerIdParam !== '';
+    const hasLayerName = layerNameParam !== null && layerNameParam.trim() !== '';
+    if ((hasLayerId && hasLayerName) || (!hasLayerId && !hasLayerName)) {
+        sendBadRequest(res, 'Provide exactly one of layerId or layerName');
+        log('getProperties failed: invalid layer selector');
+        return;
+    }
+    let layerId = null;
+    if (hasLayerId) {
+        const parsedLayerId = parseInt(layerIdParam, 10);
+        if (isNaN(parsedLayerId) || parsedLayerId <= 0) {
+            sendBadRequest(res, 'layerId must be a positive integer');
+            log('getProperties failed: invalid layerId');
+            return;
+        }
+        layerId = parsedLayerId;
+    }
+    const includeGroups = searchParams.getAll('includeGroup').filter(Boolean);
+    const excludeGroups = searchParams.getAll('excludeGroup').filter(Boolean);
+    const maxDepthParam = searchParams.get('maxDepth');
+    const includeGroupChildrenParam = searchParams.get('includeGroupChildren');
+    const timeParam = searchParams.get('time');
+    let maxDepth;
+    if (maxDepthParam !== null) {
+        const parsedDepth = parseInt(maxDepthParam, 10);
+        if (isNaN(parsedDepth) || parsedDepth <= 0) {
+            sendBadRequest(res, 'maxDepth must be a positive integer');
+            log('getProperties failed: Invalid maxDepth');
+            return;
+        }
+        maxDepth = parsedDepth;
+    }
+    let includeGroupChildren;
+    if (includeGroupChildrenParam !== null) {
+        if (!['true', 'false'].includes(includeGroupChildrenParam)) {
+            sendBadRequest(res, 'includeGroupChildren must be true or false');
+            log('getProperties failed: invalid includeGroupChildren');
+            return;
+        }
+        includeGroupChildren = includeGroupChildrenParam === 'true';
+    }
+    let time;
+    if (timeParam !== null) {
+        const parsedTime = Number(timeParam);
+        if (!isFinite(parsedTime)) {
+            sendBadRequest(res, 'time must be a finite number');
+            log('getProperties failed: invalid time');
+            return;
+        }
+        time = parsedTime;
+    }
+    const options = {};
+    if (hasLayerName) options.layerName = layerNameParam.trim();
+    if (includeGroups.length > 0) options.includeGroups = includeGroups;
+    if (excludeGroups.length > 0) options.excludeGroups = excludeGroups;
+    if (maxDepth !== undefined) options.maxDepth = maxDepth;
+    if (includeGroupChildren !== undefined) options.includeGroupChildren = includeGroupChildren;
+    if (time !== undefined) options.time = time;
+    const optionsLiteral = Object.keys(options).length > 0
+        ? toExtendScriptStringLiteral(JSON.stringify(options))
+        : 'null';
+    const optionsLabel = optionsLiteral === 'null' ? 'null' : 'custom';
+    const layerIdLiteral = layerId === null ? 'null' : String(layerId);
+    const script = `getProperties(${layerIdLiteral}, ${optionsLiteral})`;
+    handleBridgeDataCall(script, res, `getProperties(${layerIdLiteral}, options=${optionsLabel})`);
+}
+function handleSetExpression(req, res) {
+    readJsonBody(req, res, ({ layerId, layerName, propertyPath, expression }) => {
+        if (!propertyPath || expression === undefined) {
+            sendBadRequest(res, 'Missing parameters');
+            log('setExpression failed: Missing parameters');
+            return;
+        }
+        const selector = normalizeLayerSelector(layerId, layerName);
+        if (!selector.ok) {
+            sendBadRequest(res, selector.error);
+            log(`setExpression failed: ${selector.error}`);
+            return;
+        }
+        if (typeof expression !== 'string') {
+            sendBadRequest(res, 'Expression must be a string');
+            log('setExpression failed: Expression must be a string');
+            return;
+        }
+        const escapedPath = escapeForExtendScript(propertyPath);
+        const expressionLiteral = toExtendScriptStringLiteral(expression);
+        const script = `setExpression(${selector.layerIdLiteral}, ${selector.layerNameLiteral}, "${escapedPath}", ${expressionLiteral})`;
+        log(`Calling ExtendScript: ${script}`);
+        evalHostScript(script, (result) => {
+            if (result === 'success') {
+                sendJson(res, 200, { status: 'success', message: 'Expression set successfully' });
+                log('setExpression successful.');
+                return;
+            }
+            sendJson(res, 500, { status: 'error', message: result });
+            log(`setExpression failed: ${result}`);
+        });
+    });
+}
+function handleSetPropertyValue(req, res) {
+    readJsonBody(req, res, ({ layerId, layerName, propertyPath, value }) => {
+        if (!propertyPath || value === undefined) {
+            sendBadRequest(res, 'Missing parameters');
+            log('setPropertyValue failed: Missing parameters');
+            return;
+        }
+        const selector = normalizeLayerSelector(layerId, layerName);
+        if (!selector.ok) {
+            sendBadRequest(res, selector.error);
+            log(`setPropertyValue failed: ${selector.error}`);
+            return;
+        }
+        const pathLiteral = toExtendScriptStringLiteral(propertyPath);
+        const valueLiteral = toExtendScriptStringLiteral(JSON.stringify(value));
+        const script = `setPropertyValue(${selector.layerIdLiteral}, ${selector.layerNameLiteral}, ${pathLiteral}, ${valueLiteral})`;
+        handleBridgeMutationCall(script, res, 'setPropertyValue()', 'Failed to set property value');
+    });
+}
+function handleSetKeyframe(req, res) {
+    readJsonBody(req, res, ({ layerId, layerName, propertyPath, time, value, inInterp, outInterp, easeIn, easeOut }) => {
+        if (!propertyPath || time === undefined || value === undefined) {
+            sendBadRequest(res, 'Missing parameters');
+            log('setKeyframe failed: Missing parameters');
+            return;
+        }
+        const selector = normalizeLayerSelector(layerId, layerName);
+        if (!selector.ok) {
+            sendBadRequest(res, selector.error);
+            log(`setKeyframe failed: ${selector.error}`);
+            return;
+        }
+        if (typeof time !== 'number' || !isFinite(time)) {
+            sendBadRequest(res, 'time must be a number');
+            log('setKeyframe failed: invalid time');
+            return;
+        }
+        if (inInterp !== undefined && !['linear', 'bezier', 'hold'].includes(inInterp)) {
+            sendBadRequest(res, 'inInterp must be one of: linear, bezier, hold');
+            log('setKeyframe failed: invalid inInterp');
+            return;
+        }
+        if (outInterp !== undefined && !['linear', 'bezier', 'hold'].includes(outInterp)) {
+            sendBadRequest(res, 'outInterp must be one of: linear, bezier, hold');
+            log('setKeyframe failed: invalid outInterp');
+            return;
+        }
+        const pathLiteral = toExtendScriptStringLiteral(propertyPath);
+        const valueLiteral = toExtendScriptStringLiteral(JSON.stringify(value));
+        const options = {};
+        if (inInterp !== undefined) options.inInterp = inInterp;
+        if (outInterp !== undefined) options.outInterp = outInterp;
+        if (easeIn !== undefined) options.easeIn = easeIn;
+        if (easeOut !== undefined) options.easeOut = easeOut;
+        const optionsLiteral = Object.keys(options).length === 0
+            ? 'null'
+            : toExtendScriptStringLiteral(JSON.stringify(options));
+        const script = `setKeyframe(${selector.layerIdLiteral}, ${selector.layerNameLiteral}, ${pathLiteral}, ${time}, ${valueLiteral}, ${optionsLiteral})`;
+        handleBridgeMutationCall(script, res, 'setKeyframe()', 'Failed to set keyframe');
+    });
+}
+function handleAddEffect(req, res) {
+    readJsonBody(req, res, ({ layerId, layerName, effectMatchName, effectName }) => {
+        if (!effectMatchName) {
+            sendBadRequest(res, 'Missing parameters');
+            log('addEffect failed: Missing parameters');
+            return;
+        }
+        const selector = normalizeLayerSelector(layerId, layerName);
+        if (!selector.ok) {
+            sendBadRequest(res, selector.error);
+            log(`addEffect failed: ${selector.error}`);
+            return;
+        }
+        if (effectName !== undefined && typeof effectName !== 'string') {
+            sendBadRequest(res, 'effectName must be a string when specified');
+            log('addEffect failed: effectName must be a string');
+            return;
+        }
+        const matchNameLiteral = toExtendScriptStringLiteral(effectMatchName);
+        const effectNameLiteral = effectName === undefined
+            ? 'null'
+            : toExtendScriptStringLiteral(effectName);
+        const script = `addEffect(${selector.layerIdLiteral}, ${selector.layerNameLiteral}, ${matchNameLiteral}, ${effectNameLiteral})`;
+        log(`Calling ExtendScript: ${script}`);
+        evalHostScript(script, (result) => {
+            try {
+                const parsedResult = parseBridgeResult(result);
+                if (parsedResult && parsedResult.status === 'error') {
+                    sendJson(res, 500, {
+                        status: 'error',
+                        message: parsedResult.message || 'Failed to add effect',
+                    });
+                    log(`addEffect failed: ${parsedResult.message || 'Unknown error'}`);
+                    return;
+                }
+                sendJson(res, 200, { status: 'success', data: parsedResult });
+                log('addEffect successful.');
+            } catch (e) {
+                sendBridgeParseError(res, result, e);
+                log(`addEffect failed: ${e.toString()}`);
+            }
+        });
+    });
+}
+function handleNotFound(req, res) {
+    sendJson(res, 404, { status: 'error', message: 'Not Found' });
+    log(`404 Not Found: ${req.method} ${req.url}`);
+}
+function routeRequest(req, res) {
+    log(`Request received: ${req.method} ${req.url}`);
+    if (handleCorsPreflight(req, res)) {
+        return;
+    }
+    applyCommonResponseHeaders(res);
+    const [pathname, queryString = ''] = req.url.split('?');
+    const method = (req.method || 'GET').toUpperCase();
+    const searchParams = new URLSearchParams(queryString);
+    if (pathname === '/health' && method === 'GET') {
+        handleHealth(res);
+        return;
+    }
+    if (pathname === '/layers' && method === 'GET') {
+        handleGetLayers(res);
+        return;
+    }
+    if (pathname === '/comps' && method === 'GET') {
+        handleGetComps(res);
+        return;
+    }
+    if (typeof routeShapeRequest === 'function' && routeShapeRequest(pathname, method, req, res)) {
+        return;
+    }
+    if (typeof routeSceneRequest === 'function' && routeSceneRequest(pathname, method, req, res)) {
+        return;
+    }
+    if (pathname === '/comps' && method === 'POST') {
+        handleCreateComp(req, res);
+        return;
+    }
+    if (pathname === '/active-comp' && method === 'POST') {
+        handleSetActiveComp(req, res);
+        return;
+    }
+    if (pathname === '/properties' && method === 'GET') {
+        handleGetProperties(searchParams, res);
+        return;
+    }
+    if (pathname === '/selected-properties' && method === 'GET') {
+        handleGetSelectedProperties(res);
+        return;
+    }
+    if (pathname === '/expression-errors' && method === 'GET') {
+        handleGetExpressionErrors(res);
+        return;
+    }
+    if (pathname === '/expression' && method === 'POST') {
+        handleSetExpression(req, res);
+        return;
+    }
+    if (pathname === '/property-value' && method === 'POST') {
+        handleSetPropertyValue(req, res);
+        return;
+    }
+    if (pathname === '/keyframes' && method === 'POST') {
+        handleSetKeyframe(req, res);
+        return;
+    }
+    if (typeof routeEssentialRequest === 'function' && routeEssentialRequest(pathname, method, req, res)) {
+        return;
+    }
+    if (pathname === '/effects' && method === 'POST') {
+        handleAddEffect(req, res);
+        return;
+    }
+    if (typeof routeTimelineRequest === 'function' && routeTimelineRequest(pathname, method, req, res)) {
+        return;
+    }
+    if (typeof routeLayerStructureRequest === 'function'
+        && routeLayerStructureRequest(pathname, method, req, res)) {
+        return;
+    }
+    handleNotFound(req, res);
+}

package/client/lib/request_handlers_essential.js ADDED Viewed

@@ -0,0 +1,35 @@
+function handleAddEssentialProperty(req, res) {
+    readJsonBody(req, res, ({ layerId, layerName, propertyPath, essentialName }) => {
+        if (!propertyPath || typeof propertyPath !== 'string') {
+            sendBadRequest(res, 'propertyPath is required and must be a string');
+            log('addEssentialProperty failed: invalid propertyPath');
+            return;
+        }
+        const selector = normalizeLayerSelector(layerId, layerName);
+        if (!selector.ok) {
+            sendBadRequest(res, selector.error);
+            log(`addEssentialProperty failed: ${selector.error}`);
+            return;
+        }
+        if (essentialName !== undefined && typeof essentialName !== 'string') {
+            sendBadRequest(res, 'essentialName must be a string when specified');
+            log('addEssentialProperty failed: invalid essentialName');
+            return;
+        }
+        const pathLiteral = toExtendScriptStringLiteral(propertyPath);
+        const essentialNameLiteral = essentialName === undefined
+            ? 'null'
+            : toExtendScriptStringLiteral(essentialName);
+        const script = `addEssentialProperty(${selector.layerIdLiteral}, ${selector.layerNameLiteral}, ${pathLiteral}, ${essentialNameLiteral})`;
+        handleBridgeMutationCall(script, res, 'addEssentialProperty()', 'Failed to add essential property');
+    });
+}
+function routeEssentialRequest(pathname, method, req, res) {
+    if (pathname === '/essential-property' && method === 'POST') {
+        handleAddEssentialProperty(req, res);
+        return true;
+    }
+    return false;
+}