@plumeria/turbopack-loader 18.4.2 → 18.5.1

package/dist/file-lock.d.ts

@@ -1,2 +1,2 @@
-export declare function acquireLock(lockDir: string, delayMs?: number, maxDelayMs?: number): Promise<void>;
+export declare function acquireLock(lockDir: string, delayMs?: number, maxDelayMs?: number, timeoutMs?: number): Promise<void>;
 export declare function releaseLockSync(lockDir: string): void;

package/dist/file-lock.js

@@ -37,7 +37,8 @@ exports.acquireLock = acquireLock;
 exports.releaseLockSync = releaseLockSync;
 const fs = __importStar(require("fs"));
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function acquireLock(lockDir, delayMs = 2, maxDelayMs = 50) {
+async function acquireLock(lockDir, delayMs = 2, maxDelayMs = 50, timeoutMs = 30_000) {
+    const started = Date.now();
     let delay = delayMs;
     while (true) {
         try {
@@ -46,7 +47,11 @@ async function acquireLock(lockDir, delayMs = 2, maxDelayMs = 50) {
         }
         catch (err) {
             if (err.code === 'EEXIST') {
-                await sleep(delay);
+                const remaining = timeoutMs - (Date.now() - started);
+                if (remaining <= 0) {
+                    throw new Error(`Plumeria: Timed out waiting for CSS lock "${lockDir}". If no build is running, remove the stale lock directory and retry.`, { cause: err });
+                }
+                await sleep(Math.min(delay, remaining));
                 delay = Math.min(delay * 2, maxDelayMs);
                 continue;
             }

package/dist/index.js

@@ -77,7 +77,10 @@ async function generateProductionCss(virtualFilePath, options) {
 }
 const ensureProductionCss = (virtualFilePath, options) => {
     if (!productionCss) {
-        productionCss = generateProductionCss(virtualFilePath, options);
+        productionCss = generateProductionCss(virtualFilePath, options).catch((error) => {
+            productionCss = null;
+            throw error;
+        });
     }
     return productionCss;
 };
@@ -127,6 +130,26 @@ const destructuredPropAliases = (fn) => {
     }
     return aliases;
 };
+const spreadStyleMessage = (source) => `Plumeria: Spread elements in a style array are not supported: "...${source}". ` +
+    `List each style explicitly.`;
+const resolveLocalStyleAlias = (aliases, expression) => {
+    let current = expression;
+    const seen = new Set();
+    while (utils_1.t.isIdentifier(current)) {
+        const name = current.value;
+        if (seen.has(name))
+            break;
+        seen.add(name);
+        const candidates = aliases[name];
+        if (!candidates || candidates.length === 0)
+            break;
+        const candidate = candidates.find((candidate) => candidate.context === current.ctxt);
+        if (!candidate)
+            break;
+        current = candidate.expression;
+    }
+    return current;
+};
 const isStaticArgValue = (node) => node.type === 'StringLiteral' ||
     node.type === 'NumericLiteral' ||
     node.type === 'BooleanLiteral' ||
@@ -213,6 +236,7 @@ async function loader(source) {
                 utils_1.t.isFunctionExpression(node)) {
                 const rootId = (0, utils_1.getRootIdentifier)(node);
                 const isPlumeriaStyle = rootId &&
+                    isVisibleReference(node) &&
                     ((localCreateStyles[rootId] !== undefined &&
                         localCreateStyles[rootId].type !== 'constant') ||
                         mergedCreateTable[rootId] !== undefined ||
@@ -229,6 +253,10 @@ async function loader(source) {
                 }
             }
         };
+        const scannedTables = (0, utils_1.scanAll)();
+        const ownFailure = (0, utils_1.resolveFileError)(resourcePath, '');
+        if (ownFailure)
+            throwCompilationError(`Plumeria: ${ownFailure.message}`);
         for (const node of ast.body) {
             if (node.type === 'ImportDeclaration') {
                 const sourcePath = node.source.value;
@@ -242,7 +270,6 @@ async function loader(source) {
                 }
             }
         }
-        const scannedTables = (0, utils_1.scanAll)();
         if (scannedTables.componentPropsTable) {
             const parentFiles = new Set();
             for (const compKey of Object.keys(scannedTables.componentPropsTable)) {
@@ -263,11 +290,32 @@ async function loader(source) {
         }
         const components = [];
         const propAliases = new Map();
+        const propDefaults = new Map();
+        const declaredProps = new Map();
         const addComponent = (name, fn) => {
             components.push({ name, node: fn });
+            const first = fn.params[0];
+            const pattern = unwrapPatternDefault(first?.pat ?? first);
+            const defaults = new Map();
+            for (const item of pattern?.properties ?? []) {
+                if (item.type === 'AssignmentPatternProperty' && item.value)
+                    defaults.set(item.key.value, item.value);
+                if (item.type === 'KeyValuePatternProperty' &&
+                    item.value?.type === 'AssignmentPattern')
+                    defaults.set(item.key.value, item.value.right);
+            }
+            propDefaults.set(name, defaults);
             const aliases = destructuredPropAliases(fn);
             if (aliases.size > 0)
                 propAliases.set(name, aliases);
+            const declared = new Set();
+            for (const item of pattern?.properties ?? []) {
+                const key = item.key;
+                if (utils_1.t.isIdentifier(key) || utils_1.t.isStringLiteral(key))
+                    declared.add(String(key.value));
+            }
+            if (declared.size > 0)
+                declaredProps.set(name, declared);
         };
         for (const node of ast.body) {
             const statement = unwrapExport(node);
@@ -500,24 +548,83 @@ async function loader(source) {
         const checkStyleAliasAssignment = (decl) => {
             if (!utils_1.t.isIdentifier(decl.id) || !decl.init)
                 return;
-            const init = decl.init;
+            const init = (0, utils_1.unwrapExpression)(decl.init);
             if (utils_1.t.isMemberExpression(init) && utils_1.t.isIdentifier(init.object)) {
                 const objName = init.object.value;
                 if (localCreateStyles[objName] !== undefined ||
                     mergedCreateTable[objName] !== undefined) {
-                    localStyleAliases[decl.id.value] = init;
+                    (localStyleAliases[decl.id.value] ??= []).push({
+                        expression: init,
+                        context: decl.id.ctxt,
+                    });
                 }
             }
         };
         const replacements = [];
+        const deferredSources = [];
+        const deferSource = (node, stripObject = false) => {
+            const token = `__plumeria_preserved_${deferredSources.length}__`;
+            deferredSources.push({
+                token,
+                start: node.span.start - baseByteOffset,
+                end: node.span.end - baseByteOffset,
+                stripObject,
+            });
+            return token;
+        };
         const dynamicFnCalls = [];
         const processedDecls = new Set();
+        const separatelyExported = new Set();
+        for (const statement of ast.body) {
+            if (statement.type !== 'ExportNamedDeclaration' || statement.source)
+                continue;
+            for (const specifier of statement.specifiers) {
+                if (specifier.type === 'ExportSpecifier' &&
+                    utils_1.t.isIdentifier(specifier.orig)) {
+                    separatelyExported.add(specifier.orig.value);
+                }
+            }
+        }
         const idSpans = new Set();
         const excludedSpans = new Set();
         const referenceIdents = (0, utils_1.collectReferenceIdentifiers)(ast);
+        const topLevelDeclarators = new Set();
+        for (const statement of ast.body) {
+            const declaration = unwrapExport(statement);
+            if (utils_1.t.isVariableDeclaration(declaration)) {
+                declaration.declarations.forEach((decl) => topLevelDeclarators.add(decl));
+            }
+        }
+        const unwrapStyleExpression = (node) => {
+            while (node &&
+                [
+                    'ParenthesisExpression',
+                    'TsAsExpression',
+                    'TsSatisfiesExpression',
+                    'TsNonNullExpression',
+                    'TsConstAssertion',
+                    'TsTypeAssertion',
+                ].includes(node.type))
+                node = node.expression;
+            return node;
+        };
+        const literalObjectArgument = (node, seen = new Set()) => {
+            node = unwrapStyleExpression(node);
+            if (utils_1.t.isObjectExpression(node))
+                return node;
+            if (!utils_1.t.isIdentifier(node) || seen.has(node.value))
+                return null;
+            seen.add(node.value);
+            const declaration = [...topLevelDeclarators].find((decl) => utils_1.t.isIdentifier(decl.id) &&
+                decl.id.value === node.value);
+            return declaration?.init
+                ? literalObjectArgument(declaration.init, seen)
+                : null;
+        };
+        const registeredStyleCalls = new Set();
         const registerStyle = (node, declSpan, isExported) => {
             let propName;
-            const init = node.init;
+            const init = unwrapStyleExpression(node.init);
             if (utils_1.t.isIdentifier(node.id) &&
                 init &&
                 utils_1.t.isCallExpression(init) &&
@@ -542,6 +649,19 @@ async function loader(source) {
                 }
             }
             if (propName && init && utils_1.t.isCallExpression(init)) {
+                if (['create', 'createTheme', 'createStatic'].includes(propName) &&
+                    !topLevelDeclarators.has(node)) {
+                    throwCompilationError(`Plumeria: css.${propName} must be assigned to a top-level variable so its styles can be resolved across files. Move this declaration outside the function or block.`, node);
+                }
+                if (['create', 'createTheme', 'createStatic'].includes(propName)) {
+                    const argumentIndex = propName === 'createTheme' ? 1 : 0;
+                    const argument = init.arguments[argumentIndex];
+                    const object = argument && literalObjectArgument(argument.expression);
+                    if (!object)
+                        throwCompilationError(`Plumeria: css.${propName} needs a style object it can read at build time. Pass an object literal or a top-level constant containing one.`, init);
+                    argument.expression = object;
+                    registeredStyleCalls.add(init.span.start);
+                }
                 if (propName === 'create' &&
                     utils_1.t.isObjectExpression(init.arguments[0].expression)) {
                     const obj = (0, utils_1.objectExpressionToObject)(init.arguments[0].expression, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable, mergedVariantsTable);
@@ -712,7 +832,9 @@ async function loader(source) {
                 if (processedDecls.has(node))
                     return;
                 node.declarations.forEach((decl) => {
-                    registerStyle(decl, node.span, false);
+                    registerStyle(decl, node.span, node.declarations.length > 1 ||
+                        (utils_1.t.isIdentifier(decl.id) &&
+                            separatelyExported.has(decl.id.value)));
                     checkStyleAliasAssignment(decl);
                 });
             },
@@ -737,6 +859,10 @@ async function loader(source) {
                     }
                 }
                 if (propName) {
+                    if (['create', 'createTheme', 'createStatic'].includes(propName) &&
+                        !registeredStyleCalls.has(node.span.start)) {
+                        throwCompilationError(`Plumeria: css.${propName} must be assigned to a named top-level variable. Destructuring, assignment statements, and default-exported calls cannot be compiled.`, node);
+                    }
                     const args = node.arguments;
                     if (propName === 'keyframes' && args.length > 0) {
                         const expr = args[0].expression;
@@ -802,12 +928,17 @@ async function loader(source) {
         const jsxOpeningElementMap = new Map();
         const componentParamNames = new Set();
         const addFirstParamName = (fn) => {
-            const p = fn.params[0];
+            const first = fn.params[0];
+            const p = unwrapPatternDefault(first?.pat ?? first);
             if (utils_1.t.isIdentifier(p)) {
                 componentParamNames.add(p.value);
             }
-            else if (p?.pat && utils_1.t.isIdentifier(p.pat)) {
-                componentParamNames.add(p.pat.value);
+            else if (p?.type === 'ObjectPattern') {
+                for (const item of p.properties) {
+                    if (item.type === 'RestElement' && utils_1.t.isIdentifier(item.argument)) {
+                        componentParamNames.add(item.argument.value);
+                    }
+                }
             }
         };
         for (const node of ast.body) {
@@ -843,7 +974,36 @@ async function loader(source) {
             const end = node.span.end - baseByteOffset;
             return sourceBuffer.subarray(start, end).toString('utf-8');
         };
+        const isVisibleReference = (expr) => {
+            if (utils_1.t.isIdentifier(expr))
+                return referenceIdents.references.has(expr.span.start);
+            if (utils_1.t.isMemberExpression(expr))
+                return isVisibleReference(expr.object);
+            if (utils_1.t.isCallExpression(expr) &&
+                expr.callee.type !== 'Super' &&
+                expr.callee.type !== 'Import')
+                return isVisibleReference(expr.callee);
+            return true;
+        };
         const resolveStyleObject = (expr) => {
+            expr = (0, utils_1.unwrapExpression)(expr);
+            expr = resolveLocalStyleAlias(localStyleAliases, expr);
+            if (!isVisibleReference(expr))
+                return null;
+            if (expr.type === 'ArrayExpression') {
+                let merged = {};
+                for (const element of expr.elements ?? []) {
+                    if (!element)
+                        continue;
+                    if (element.spread)
+                        throwCompilationError(spreadStyleMessage(getSource(element.expression)), element.expression);
+                    const style = resolveStyleObject(element.expression);
+                    if (!style)
+                        return null;
+                    merged = (0, utils_1.deepMerge)(merged, style);
+                }
+                return merged;
+            }
             if (utils_1.t.isObjectExpression(expr)) {
                 return (0, utils_1.objectExpressionToObject)(expr, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable, mergedVariantsTable);
             }
@@ -903,12 +1063,34 @@ async function loader(source) {
             return Boolean(localCreateStyles[callee.object.value]?.functions?.[callee.property.value] ??
                 createFunctionImportMap[callee.object.value]?.[callee.property.value]);
         };
+        const carriesStyleReference = (expression) => {
+            const node = (0, utils_1.unwrapExpression)(expression);
+            if (node.type === 'ArrayExpression')
+                return node.elements.some((element) => !!element && carriesStyleReference(element.expression));
+            if (isStyleFunctionCall(node))
+                return true;
+            if (utils_1.t.isObjectExpression(node))
+                return false;
+            return resolveStyleObject(node) !== null;
+        };
+        const assertNoStyleArraySpread = (expression) => {
+            const node = (0, utils_1.unwrapExpression)(expression);
+            if (node.type !== 'ArrayExpression')
+                return;
+            const spread = node.elements.find((element) => element?.spread);
+            if (!spread)
+                return;
+            if (carriesStyleReference(node))
+                throwCompilationError(spreadStyleMessage(getSource(spread.expression)), spread.expression);
+        };
         const resolveDynamicCall = (expr, forceRuntime = false) => {
             if (!utils_1.t.isCallExpression(expr) || !utils_1.t.isMemberExpression(expr.callee))
                 return null;
             const callee = expr.callee;
             if (!utils_1.t.isIdentifier(callee.object) || !utils_1.t.isIdentifier(callee.property))
                 return null;
+            if (!isVisibleReference(callee.object))
+                return null;
             const styleInfo = localCreateStyles[callee.object.value];
             const func = styleInfo?.functions?.[callee.property.value] ??
                 createFunctionImportMap[callee.object.value]?.[callee.property.value];
@@ -918,8 +1100,14 @@ async function loader(source) {
             if (callArgs.some((a) => a.spread))
                 return null;
             const tempStaticTable = { ...mergedStaticTable };
+            const providedParams = new Set();
             const runtime = [];
-            const resolveObjectArg = (argExpr) => (0, utils_1.objectExpressionToObject)(argExpr, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable, mergedVariantsTable);
+            const resolveObjectArg = (argExpr) => (0, utils_1.objectExpressionToObject)({
+                ...argExpr,
+                properties: argExpr.properties.filter((prop) => prop.type === 'Identifier' ||
+                    (prop.type === 'KeyValueProperty' &&
+                        isStaticArgValue(prop.value))),
+            }, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable, mergedVariantsTable);
             if (func.named) {
                 const argExpr = callArgs[0]?.expression;
                 if (callArgs.length > 1 ||
@@ -949,8 +1137,10 @@ async function loader(source) {
                     }
                     if (!forceRuntime &&
                         isStaticArgValue(source) &&
-                        argObj[key] !== undefined)
+                        argObj[key] !== undefined) {
                         tempStaticTable[local] = argObj[key];
+                        providedParams.add(local);
+                    }
                     else
                         runtime.push({ param: local, source });
                 });
@@ -961,8 +1151,10 @@ async function loader(source) {
                     return null;
                 const argObj = resolveObjectArg(callArgs[0].expression) ?? {};
                 func.params.forEach((p) => {
-                    if (argObj[p] !== undefined)
+                    if (argObj[p] !== undefined) {
                         tempStaticTable[p] = argObj[p];
+                        providedParams.add(p);
+                    }
                 });
             }
             else {
@@ -973,7 +1165,7 @@ async function loader(source) {
                     runtime.push({ param: p, source: callArg.expression });
                 });
             }
-            const resolved = (0, utils_1.resolveDynamicStyle)(func, runtime.map(({ param }) => param), tempStaticTable, dynamicStyleTables);
+            const resolved = (0, utils_1.resolveDynamicStyle)(func, runtime.map(({ param }) => param), tempStaticTable, dynamicStyleTables, providedParams);
             if (!resolved)
                 return null;
             const { style, varGroups } = resolved;
@@ -1010,10 +1202,7 @@ async function loader(source) {
         };
         const buildClassParts = (args, dynamicClassParts = [], existingClass = '', isStyleProp = false) => {
             args.forEach((arg) => {
-                const expr = arg.expression;
-                if (utils_1.t.isIdentifier(expr) && localStyleAliases[expr.value]) {
-                    arg.expression = localStyleAliases[expr.value];
-                }
+                arg.expression = resolveLocalStyleAlias(localStyleAliases, arg.expression);
             });
             const conditionals = [];
             const dynamicVars = [];
@@ -1041,6 +1230,8 @@ async function loader(source) {
                     utils_1.t.isStringLiteral(node.property.expression)) {
                     return null;
                 }
+                if (!isVisibleReference(node.object))
+                    return null;
                 const varName = node.object.value;
                 const obj = resolveCreateObject(varName);
                 return obj ? { varName, keyExpr: node.property.expression, obj } : null;
@@ -1134,8 +1325,19 @@ async function loader(source) {
                 return buildDecision(node, prefix, off, { n: 0 }, scoped);
             };
             const collectConditions = (node, currentTestStrings = [], argOrder) => {
+                node = (0, utils_1.unwrapExpression)(node);
+                node = resolveLocalStyleAlias(localStyleAliases, node);
                 if (isNoOpStyle(node))
                     return true;
+                if (node.type === 'ArrayExpression') {
+                    return node.elements.every((element) => {
+                        if (!element)
+                            return true;
+                        if (element.spread)
+                            throwCompilationError(spreadStyleMessage(getSource(element.expression)), element.expression);
+                        return collectConditions(element.expression, currentTestStrings, argOrder);
+                    });
+                }
                 let branchStyle = resolveStyleObject(node);
                 if (!branchStyle) {
                     const dynamic = resolveDynamicCall(node);
@@ -1188,13 +1390,12 @@ async function loader(source) {
                             return true;
                         }
                     }
-                    collectConditions(node.consequent, [...currentTestStrings, `(${testSource})`], argOrder);
-                    collectConditions(node.alternate, [...currentTestStrings, `!(${testSource})`], argOrder);
-                    return true;
+                    const consequentHandled = collectConditions(node.consequent, [...currentTestStrings, `(${testSource})`], argOrder);
+                    const alternateHandled = collectConditions(node.alternate, [...currentTestStrings, `!(${testSource})`], argOrder);
+                    return consequentHandled && alternateHandled;
                 }
                 else if (node.type === 'BinaryExpression' && node.operator === '&&') {
-                    collectConditions(node.right, [...currentTestStrings, `(${getSource(node.left)})`], argOrder);
-                    return true;
+                    return collectConditions(node.right, [...currentTestStrings, `(${getSource(node.left)})`], argOrder);
                 }
                 else if (node.type === 'ParenthesisExpression') {
                     return collectConditions(node.expression, currentTestStrings, argOrder);
@@ -1211,6 +1412,12 @@ async function loader(source) {
                     utils_1.t.isIdentifier(expr.property);
                 if (!utils_1.t.isIdentifier(expr) && !isParamMember)
                     return false;
+                const paramObject = isParamMember
+                    ? expr.object.value
+                    : undefined;
+                const isPropsMember = Boolean(paramObject &&
+                    localCreateStyles[paramObject] === undefined &&
+                    mergedCreateTable[paramObject] === undefined);
                 const varName = utils_1.t.isIdentifier(expr)
                     ? expr.value
                     : expr.property.value;
@@ -1235,8 +1442,42 @@ async function loader(source) {
                     if (candidates.length > 0)
                         possibilities = candidates;
                 }
-                if (!possibilities || possibilities.length === 0)
-                    return false;
+                const fallback = owner && propDefaults.get(owner)?.get(propName);
+                if (fallback) {
+                    const style = resolveStyleObject(fallback);
+                    if (style) {
+                        const atoms = {};
+                        (0, utils_1.getStyleRecords)(style).forEach((record) => {
+                            atoms[record.key] = record.hash;
+                        });
+                        const key = (0, zss_engine_1.genBase36Hash)(Object.values(atoms).join(' '), 1, 8);
+                        possibilities = [
+                            ...(possibilities ?? []),
+                            { key, styleObj: style },
+                        ];
+                        const span = fallback.span;
+                        {
+                            for (let i = replacements.length - 1; i >= 0; i--) {
+                                const replacement = replacements[i];
+                                if (replacement.start >= span.start - baseByteOffset &&
+                                    replacement.end <= span.end - baseByteOffset)
+                                    replacements.splice(i, 1);
+                            }
+                            excludeSubtreeSpans(fallback);
+                            replacements.push({
+                                start: span.start - baseByteOffset,
+                                end: span.end - baseByteOffset,
+                                content: JSON.stringify(key),
+                            });
+                        }
+                    }
+                    else {
+                        assertResolvable(fallback);
+                    }
+                }
+                if (!possibilities || possibilities.length === 0) {
+                    return Boolean(isPropsMember || (owner && declaredProps.get(owner)?.has(propName)));
+                }
                 const carriesVars = possibilities.some((entry) => entry.hasVars);
                 if (carriesVars && !isStyleProp) {
                     throwCompilationError(`Plumeria: "${varName}" carries a dynamic function key, and css.use() returns only a class name. ` +
@@ -1296,7 +1537,11 @@ async function loader(source) {
                         hash = mergedVariantsTable[varName];
                     if (hash && scannedTables.variantsObjectTable[hash])
                         variantObj = scannedTables.variantsObjectTable[hash];
-                    if (!variantObj && localCreateStyles[varName]?.obj)
+                    if (!isVisibleReference(expr))
+                        variantObj = undefined;
+                    if (isVisibleReference(expr) &&
+                        !variantObj &&
+                        localCreateStyles[varName]?.obj)
                         variantObj = localCreateStyles[varName].obj;
                     if (variantObj) {
                         const callArgs = expr.arguments;
@@ -1407,7 +1652,11 @@ async function loader(source) {
                         hash = mergedVariantsTable[varName];
                     if (hash && scannedTables.variantsObjectTable[hash])
                         variantObj = scannedTables.variantsObjectTable[hash];
-                    if (!variantObj && localCreateStyles[varName]?.obj)
+                    if (!isVisibleReference(expr))
+                        variantObj = undefined;
+                    if (isVisibleReference(expr) &&
+                        !variantObj &&
+                        localCreateStyles[varName]?.obj)
                         variantObj = localCreateStyles[varName].obj;
                     if (variantObj) {
                         Object.entries(variantObj).forEach(([groupName, groupVariants]) => {
@@ -1437,7 +1686,9 @@ async function loader(source) {
                     utils_1.t.isIdentifier(expr.object) &&
                     expr.property.type === 'Computed') {
                     const varName = expr.object.value;
-                    const styleObj = resolveCreateObject(varName);
+                    const styleObj = isVisibleReference(expr)
+                        ? resolveCreateObject(varName)
+                        : null;
                     if (styleObj) {
                         const dynExpr = expr.property.expression;
                         const dynSource = getSource(dynExpr);
@@ -1766,6 +2017,8 @@ async function loader(source) {
                 });
             },
             MemberExpression({ node }) {
+                if (!isVisibleReference(node))
+                    return;
                 if (utils_1.t.isIdentifier(node.object) &&
                     (utils_1.t.isIdentifier(node.property) || node.property.type === 'Computed')) {
                     const varName = node.object.value;
@@ -1952,50 +2205,61 @@ async function loader(source) {
                         }
                     }
                     if (compKey) {
+                        if (node.value?.type === 'JSXExpressionContainer')
+                            assertNoStyleArraySpread(node.value.expression);
                         const list = scannedTables.componentPropsTable?.[compKey]?.[attrName];
                         if (list &&
                             node.value &&
                             node.value.type === 'JSXExpressionContainer') {
                             const expr = node.value.expression;
-                            const carrierFor = (subNode) => {
+                            const carrierFor = (subNode, calls) => {
                                 const vars = [];
                                 let unresolved = false;
-                                (0, utils_1.traverse)(subNode, {
-                                    CallExpression({ node: call }) {
-                                        if (!isStyleFunctionCall(call))
-                                            return;
-                                        const resolved = resolveDynamicCall(call, true);
-                                        if (!resolved) {
-                                            unresolved = true;
-                                            return;
-                                        }
-                                        vars.push(...resolved.vars);
-                                    },
-                                });
+                                for (const expression of calls ?? [subNode])
+                                    (0, utils_1.traverse)(expression, {
+                                        CallExpression({ node: call }) {
+                                            if (!isStyleFunctionCall(call))
+                                                return;
+                                            const resolved = resolveDynamicCall(call, true);
+                                            if (!resolved) {
+                                                unresolved = true;
+                                                return;
+                                            }
+                                            vars.push(...resolved.vars);
+                                        },
+                                    });
                                 if (unresolved)
                                     return null;
                                 return `{ ${foldDynamicVars(vars).join(', ')} }`;
                             };
                             const replaceWithKey = (subNode) => {
-                                const entry = list.find((x) => x.spanStart === subNode.span.start &&
-                                    x.filePath === resourcePath);
-                                if (entry) {
-                                    let content = JSON.stringify(entry.key);
+                                const entries = list.filter((entry) => entry.spanStart === subNode.span.start &&
+                                    entry.filePath === resourcePath);
+                                if (!entries.length)
+                                    return false;
+                                let content = '""';
+                                for (const entry of [...entries].reverse()) {
+                                    let value = JSON.stringify(entry.key);
                                     if (entry.hasVars) {
-                                        const carrier = carrierFor(subNode);
+                                        const carrier = carrierFor(subNode, entry.dynamicCalls);
                                         if (!carrier)
                                             return false;
-                                        content = `{ key: ${content}, vars: ${carrier} }`;
+                                        value = `{ key: ${value}, vars: ${carrier} }`;
                                     }
-                                    replacements.push({
-                                        start: subNode.span.start - baseByteOffset,
-                                        end: subNode.span.end - baseByteOffset,
-                                        content,
-                                    });
+                                    const condition = entry.conditions
+                                        ?.map(({ test, truthy }) => `${truthy ? '' : '!'}(${getSource(test)})`)
+                                        .join(' && ');
+                                    content = condition
+                                        ? `((${condition}) ? ${value} : ${content})`
+                                        : value;
                                     processStyleRecords(entry.styleObj);
-                                    return true;
                                 }
-                                return false;
+                                replacements.push({
+                                    start: subNode.span.start - baseByteOffset,
+                                    end: subNode.span.end - baseByteOffset,
+                                    content,
+                                });
+                                return true;
                             };
                             (0, utils_1.traverse)(expr, {
                                 MemberExpression({ node: subNode }) {
@@ -2023,8 +2287,12 @@ async function loader(source) {
                 const expr = node.value.expression;
                 const args = expr.type === 'ArrayExpression'
                     ? expr.elements
-                        .filter((el) => el !== undefined)
-                        .map((el) => ({ expression: el.expression }))
+                        .filter((el) => el != null)
+                        .map((el) => {
+                        if (el.spread)
+                            throwCompilationError(spreadStyleMessage(getSource(el.expression)), el.expression);
+                        return { expression: el.expression };
+                    })
                     : [{ expression: expr }];
                 const dynamicClassParts = [];
                 const existingStyleParts = [];
@@ -2052,13 +2320,7 @@ async function loader(source) {
                         existingClassExpr = JSON.stringify(classNameAttr.value.value);
                     }
                     else if (classNameAttr.value?.type === 'JSXExpressionContainer') {
-                        const start = classNameAttr.value.expression.span.start -
-                            baseByteOffset;
-                        const end = classNameAttr.value.expression.span.end -
-                            baseByteOffset;
-                        existingClassExpr = `(${sourceBuffer
-                            .subarray(start, end)
-                            .toString('utf-8')})`;
+                        existingClassExpr = `(${deferSource(classNameAttr.value.expression)})`;
                     }
                 }
                 const styleAttrExisting = attributes.find((attr) => attr.type === 'JSXAttribute' &&
@@ -2073,22 +2335,19 @@ async function loader(source) {
                     });
                     if (styleAttrExisting.value?.type === 'JSXExpressionContainer') {
                         const innerExpr = styleAttrExisting.value?.expression;
-                        const start = innerExpr.span.start - baseByteOffset;
-                        const end = innerExpr.span.end - baseByteOffset;
-                        const innerSource = sourceBuffer
-                            .subarray(start, end)
-                            .toString('utf-8');
                         if (innerExpr.type === 'ObjectExpression') {
-                            const stripped = innerSource.slice(1, -1).trim();
-                            if (stripped)
-                                existingStyleParts.push(stripped);
+                            if (innerExpr.properties.length > 0)
+                                existingStyleParts.push(deferSource(innerExpr, true));
                         }
                         else {
-                            existingStyleExpr = `...(${innerSource})`;
+                            existingStyleExpr = `...(${deferSource(innerExpr)})`;
                         }
                     }
                 }
                 const { classParts, isOptimizable, baseStyle, dynamicVars, propVarSpreads, } = buildClassParts(args, dynamicClassParts, existingClassExpr, true);
+                if (!isOptimizable) {
+                    throwCompilationError(`Plumeria: Dynamic or unresolvable style object "${getSource(expr)}" is not supported.`, expr);
+                }
                 const styleParts = [
                     ...existingStyleParts,
                     ...foldDynamicVars(dynamicVars),
@@ -2227,6 +2486,22 @@ async function loader(source) {
                     `so it cannot be passed through another prop or read as a value.`, call);
             }
         });
+        for (const deferred of deferredSources) {
+            let cursor = deferred.start;
+            const pieces = [];
+            for (const replacement of [...replacements].sort((a, b) => a.start - b.start || b.end - a.end)) {
+                if (replacement.start < cursor || replacement.end > deferred.end)
+                    continue;
+                pieces.push(sourceBuffer.subarray(cursor, replacement.start).toString('utf-8'), replacement.content);
+                cursor = replacement.end;
+            }
+            pieces.push(sourceBuffer.subarray(cursor, deferred.end).toString('utf-8'));
+            let content = pieces.join('');
+            if (deferred.stripObject)
+                content = content.slice(1, -1).trim();
+            for (const replacement of replacements)
+                replacement.content = replacement.content.replaceAll(deferred.token, content);
+        }
         const buffer = Buffer.from(source);
         let offset = 0;
         const parts = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/turbopack-loader",
-  "version": "18.4.2",
+  "version": "18.5.1",
   "description": "Plumeria Turbopack-loader",
   "author": "Refirst 11",
   "license": "MIT",
@@ -29,8 +29,8 @@
     "zero-virtual.css"
   ],
   "dependencies": {
-    "@plumeria/compiler": "^18.4.2",
-    "@plumeria/utils": "^18.4.2"
+    "@plumeria/compiler": "^18.5.1",
+    "@plumeria/utils": "^18.5.1"
   },
   "devDependencies": {
     "@swc/core": "1.15.47",