]*\\bdata-impeccable-css=(?:"${escapedId}"|'${escapedId}')[^>]*>`, 'i');
const styleMatch = styleOpen.exec(source);
let merged = source;
let newStyleBlock = null;
if (styleMatch) {
const styleContentStart = styleMatch.index + styleMatch[0].length;
const styleClose = source.indexOf('', styleContentStart);
if (styleClose < 0 || styleClose > wrapper.closeEnd) {
throw workerError('worker_output_source_delta_style_invalid');
}
const styleContent = source.slice(styleContentStart, styleClose);
let nextStyleContent;
const firstTick = styleContent.indexOf('`');
const lastTick = styleContent.lastIndexOf('`');
if (firstTick >= 0 || lastTick >= 0) {
if (firstTick < 0 || lastTick <= firstTick) {
throw workerError('worker_output_source_delta_style_invalid');
}
nextStyleContent = styleContent.slice(0, lastTick).trimEnd()
+ '\n' + [css, normalizedParameterCss].filter(Boolean).join('\n') + '\n'
+ styleContent.slice(lastTick);
} else {
nextStyleContent = styleContent.trimEnd()
+ '\n' + [css, normalizedParameterCss].filter(Boolean).join('\n') + '\n';
}
merged = source.slice(0, styleContentStart) + nextStyleContent + source.slice(styleClose);
} else {
if (variantId !== 1) throw workerError('worker_output_source_delta_style_missing');
const openingTag = String(styleTag || `'].join('\n')
: [openingTag, css, ''].join('\n');
}
const nextWrapper = findSessionWrapper(merged, id);
if (!nextWrapper) throw workerError('worker_output_source_delta_wrapper_missing');
const endMarker = findSessionEndMarker(merged, id, nextWrapper);
const closeLineStart = merged.lastIndexOf('\n', nextWrapper.closeStart) + 1;
const closeLinePrefix = merged.slice(closeLineStart, nextWrapper.closeStart);
const childIndent = endMarker?.indent || nextWrapper.indent + ' ';
const contentIndent = childIndent + ' ';
const indentedMarkup = markup.split('\n')
.map((line) => line.trim() ? contentIndent + line : '')
.join('\n');
const variantBlock = [
...(newStyleBlock
? newStyleBlock.split('\n').map((line) => childIndent + line)
: []),
`${childIndent}`,
indentedMarkup,
`${childIndent}
`,
].join('\n');
if (endMarker) {
merged = merged.slice(0, endMarker.lineStart) + variantBlock + '\n' + merged.slice(endMarker.lineStart);
} else if (/^\s*$/.test(closeLinePrefix)) {
merged = merged.slice(0, closeLineStart) + variantBlock + '\n' + merged.slice(closeLineStart);
} else {
merged = merged.slice(0, nextWrapper.closeStart)
+ '\n' + variantBlock + '\n' + nextWrapper.indent
+ merged.slice(nextWrapper.closeStart);
}
if (params) merged = applySourceParams(merged, id, params, variantCount);
return merged;
}
export function applyCodexSourceParameters({
source,
sessionId,
expectedVariants = 3,
styleMode = 'scoped',
parameterCss = '',
paramsJson,
}) {
const variantCount = Number(expectedVariants);
const params = normalizeSourceParams(paramsJson, variantCount);
const css = String(parameterCss || '').trim();
if (/<\/?style\b|`|\$\{/i.test(css)) {
throw workerError('worker_output_source_delta_css_unsafe');
}
if (css) {
validateSourceDeltaCss(css, {
variantIds: Array.from({ length: variantCount }, (_, index) => index + 1),
styleMode,
});
}
const id = String(sessionId || '');
if (!id) throw workerError('worker_output_source_delta_session_missing');
let merged = String(source || '');
if (css) {
const escapedId = escapeRegExp(id);
const styleOpen = new RegExp(`]*\\bdata-impeccable-css=(?:"${escapedId}"|'${escapedId}')[^>]*>`, 'i');
const styleMatch = styleOpen.exec(merged);
if (!styleMatch) throw workerError('worker_output_source_delta_style_missing');
const contentStart = styleMatch.index + styleMatch[0].length;
const styleClose = merged.indexOf('', contentStart);
if (styleClose < 0) throw workerError('worker_output_source_delta_style_invalid');
const styleContent = merged.slice(contentStart, styleClose);
const lastTick = styleContent.lastIndexOf('`');
const nextStyleContent = lastTick >= 0
? styleContent.slice(0, lastTick).trimEnd() + '\n' + css + '\n' + styleContent.slice(lastTick)
: styleContent.trimEnd() + '\n' + css + '\n';
merged = merged.slice(0, contentStart) + nextStyleContent + merged.slice(styleClose);
}
return applySourceParams(merged, id, params, variantCount);
}
function validateSourceDeltaCss(css, { variantIds, styleMode, requireVariantId = null }) {
const allowed = new Set(variantIds.map(String));
const refs = [...String(css).matchAll(/\[data-impeccable-variant=(?:"([^"]+)"|'([^']+)')\]/g)]
.map((match) => match[1] || match[2]);
if ((requireVariantId != null && !refs.includes(String(requireVariantId)))
|| refs.some((variant) => !allowed.has(variant))) {
throw workerError('worker_output_source_delta_css_unfenced');
}
if (!String(css).trim()) return;
const astroGlobal = styleMode === 'astro-global-prefixed';
if (astroGlobal ? /@scope\b/.test(css) : !/@scope\s*\(/.test(css)) {
throw workerError('worker_output_source_delta_css_strategy_invalid');
}
}
function normalizeSourceParams(paramsJson, expectedVariants) {
if (!Number.isInteger(expectedVariants) || expectedVariants < 1
|| Buffer.byteLength(String(paramsJson)) > 20_000) {
throw workerError('worker_output_source_delta_params_invalid');
}
let parsed;
try {
parsed = JSON.parse(String(paramsJson));
} catch {
throw workerError('worker_output_source_delta_params_invalid');
}
if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
throw workerError('worker_output_source_delta_params_invalid');
}
const expectedKeys = Array.from({ length: expectedVariants }, (_, index) => String(index + 1));
if (Object.keys(parsed).sort().join(',') !== expectedKeys.join(',')) {
throw workerError('worker_output_source_delta_params_invalid');
}
for (const key of expectedKeys) {
if (!Array.isArray(parsed[key]) || parsed[key].length > 4) {
throw workerError('worker_output_source_delta_params_invalid');
}
const ids = new Set();
for (const spec of parsed[key]) {
const id = String(spec?.id || '');
const kind = String(spec?.kind || '');
if (!/^[a-z][a-z0-9-]{0,31}$/.test(id) || ids.has(id)
|| !['range', 'steps', 'toggle'].includes(kind)
|| typeof spec?.label !== 'string' || !spec.label.trim()) {
throw workerError('worker_output_source_delta_params_invalid');
}
ids.add(id);
if (kind === 'range'
&& !['min', 'max', 'step', 'default'].every((field) => Number.isFinite(spec[field]))) {
throw workerError('worker_output_source_delta_params_invalid');
}
if (kind === 'steps' && (!Array.isArray(spec.options) || spec.options.length < 2
|| spec.options.some((option) => (
typeof option?.value !== 'string' || typeof option?.label !== 'string'
)))) {
throw workerError('worker_output_source_delta_params_invalid');
}
if (kind === 'toggle' && typeof spec.default !== 'boolean') {
throw workerError('worker_output_source_delta_params_invalid');
}
}
}
return parsed;
}
function applySourceParams(source, sessionId, params, expectedVariants) {
const wrapper = findSessionWrapper(source, sessionId);
if (!wrapper) throw workerError('worker_output_source_delta_wrapper_missing');
let body = source.slice(wrapper.openStart, wrapper.closeEnd);
for (let variant = 1; variant <= expectedVariants; variant += 1) {
const attr = escapeRegExp(String(variant));
const open = new RegExp(`]*\\bdata-impeccable-variant=(?:"${attr}"|'${attr}')[^>]*>`, 'i');
const match = open.exec(body);
if (!match) throw workerError('worker_output_source_delta_variant_missing', { variant });
const json = JSON.stringify(params[String(variant)])
.replaceAll('&', '&')
.replaceAll("'", ''');
const nextOpen = match[0]
.replace(/\sdata-impeccable-params=(?:"[^"]*"|'[^']*')/i, '')
.replace(/>$/, ` data-impeccable-params='${json}'>`);
body = body.slice(0, match.index) + nextOpen + body.slice(match.index + match[0].length);
}
return source.slice(0, wrapper.openStart) + body + source.slice(wrapper.closeEnd);
}
function findSessionEndMarker(source, sessionId, wrapper) {
const marker = `impeccable-variants-end ${sessionId}`;
const markerAt = source.indexOf(marker, wrapper.openStart);
if (markerAt < 0 || markerAt >= wrapper.closeStart) return null;
const lineStart = source.lastIndexOf('\n', markerAt) + 1;
const indent = source.slice(lineStart, markerAt).match(/^\s*/)?.[0] || '';
return { lineStart, indent };
}
function normalizeVariantPlan(plan, expectedVariants) {
if (!plan || typeof plan !== 'object' || Array.isArray(plan)) {
throw workerError('worker_output_plan_invalid');
}
const identityLock = Array.isArray(plan.identityLock)
? plan.identityLock.map((item) => String(item || '').trim()).filter(Boolean)
: [];
const directions = Array.isArray(plan.directions) ? plan.directions : [];
if (identityLock.length < 1 || identityLock.length > 8 || directions.length !== Number(expectedVariants)) {
throw workerError('worker_output_plan_invalid');
}
const normalizedDirections = directions.map((direction) => ({
variantId: Number(direction?.variantId),
name: String(direction?.name || '').trim(),
axis: String(direction?.axis || '').trim(),
intent: String(direction?.intent || '').trim(),
}));
const expectedIds = Array.from({ length: Number(expectedVariants) }, (_, index) => index + 1);
const sortedIds = normalizedDirections.map((direction) => direction.variantId).sort((a, b) => a - b);
if (normalizedDirections.some((direction) => (
!Number.isInteger(direction.variantId)
|| !direction.name
|| !direction.axis
|| !direction.intent
)) || sortedIds.some((id, index) => id !== expectedIds[index])) {
throw workerError('worker_output_plan_invalid');
}
return { identityLock, directions: normalizedDirections };
}
export function prepareCodexWorkerPhase({ id, sourceFile, cwd = process.cwd() }) {
const prepared = prepareGenerationArtifact({ id, sourceFile, cwd });
if (!prepared.ok) throw workerError(`prepare_${prepared.error}`, prepared);
return prepared;
}
export function publishCodexWorkerPhase({
event,
prepared,
arrivedVariants,
phase,
cwd = process.cwd(),
}) {
const published = publishGenerationArtifact({
id: event.id,
epoch: prepared.epoch,
sourceFile: event.scaffold.file,
artifactFile: prepared.artifactFile,
expectedSourceHash: prepared.expectedSourceHash,
arrivedVariants,
expectedVariants: Number(event.count || arrivedVariants),
publicationKind: ['remainder', 'params', 'atomic'].includes(phase) ? 'params' : 'variants',
cwd,
});
if (!published.ok) throw workerError(`publish_${published.error}`, published);
return published;
}
export function generationIsCanceled(eventId, { cwd = process.cwd() } = {}) {
const snapshot = createLiveSessionStore({ cwd, sessionId: eventId }).getSnapshot(eventId, { includeCompleted: true });
return snapshot?.generationCanceled === true;
}
export function codexWorkerStateIsOwned(state, cwd) {
return codexWorkerOwnerMatches(state, cwd)
&& typeof state?.threadId === 'string'
&& state.threadId.length > 0;
}
export function isCodexComponentPreviewMode(value) {
return value === 'svelte-component' || value === 'vue-component';
}
export function codexWorkerProcessStateIsOwned(state, cwd) {
return codexWorkerOwnerMatches(state, cwd)
&& Number.isInteger(state?.pid)
&& state.pid > 0;
}
function codexWorkerOwnerMatches(state, cwd) {
return state?.owner === CODEX_WORKER_OWNER
&& canonicalPath(state?.cwd) === canonicalPath(cwd);
}
function canonicalPath(value) {
if (!value || typeof value !== 'string') return null;
const resolved = path.resolve(value);
try { return fs.realpathSync.native(resolved); } catch { return resolved; }
}
function sanitizeEvent(event) {
const copy = { ...event };
delete copy.agentAction;
delete copy._acceptResult;
delete copy._completionAck;
return copy;
}
function findSessionWrapper(source, sessionId) {
const escapedId = escapeRegExp(sessionId);
const open = new RegExp(`]*\\bdata-impeccable-variants=(?:"${escapedId}"|'${escapedId}')[^>]*>`, 'i');
const wrapperOpen = open.exec(source);
if (!wrapperOpen) return null;
const token = /]*\/\s*>|]*>|<\/div\s*>/gi;
token.lastIndex = wrapperOpen.index;
let depth = 0;
let match;
while ((match = token.exec(source))) {
if (/^<\/div/i.test(match[0])) {
depth -= 1;
if (depth === 0) {
const lineStart = source.lastIndexOf('\n', wrapperOpen.index) + 1;
const indent = source.slice(lineStart, wrapperOpen.index).match(/^\s*/)?.[0] || '';
return {
openStart: wrapperOpen.index,
closeStart: match.index,
closeEnd: token.lastIndex,
indent,
};
}
} else if (!/\/\s*>$/.test(match[0])) {
depth += 1;
}
}
return null;
}
function extractSourceVariantBlock(source, variantId) {
const attr = escapeRegExp(String(variantId));
return new RegExp(`]*\\bdata-impeccable-variant=(?:"${attr}"|'${attr}')[^>]*>`, 'i').test(source);
}
function parseWorkerJson(value) {
const text = String(value || '').trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
try {
return JSON.parse(text);
} catch (error) {
throw workerError('worker_output_json_invalid', { message: error.message });
}
}
function parseBoolean(value) {
if (value == null || value === '') return null;
if (/^(?:1|true|yes|on)$/i.test(String(value))) return true;
if (/^(?:0|false|no|off)$/i.test(String(value))) return false;
return null;
}
function nonEmpty(value) {
return typeof value === 'string' && value.trim() ? value.trim() : null;
}
function positiveInteger(value, fallback) {
const parsed = Number(value);
return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
}
function resolveInside(root, value) {
if (!value || typeof value !== 'string') return null;
const resolvedRoot = path.resolve(root);
const resolved = path.resolve(resolvedRoot, value);
const relative = path.relative(resolvedRoot, resolved);
if (!relative || (!relative.startsWith('..') && !path.isAbsolute(relative))) return resolved;
return null;
}
function readBounded(file, maxBytes) {
const stat = fs.statSync(file);
if (stat.size > maxBytes) throw workerError('artifact_too_large', { bytes: stat.size });
return fs.readFileSync(file, 'utf-8');
}
function workerError(code, detail = {}) {
const error = new Error(code);
error.code = code;
Object.assign(error, detail);
return error;
}
function escapeRegExp(value) {
return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}