svelte-origin 1.0.0-next.22 → 1.0.0-next.23

package/dist/cli.js

@@ -2842,7 +2842,34 @@ function getElementTypeImport(element) {
 }
 
 // src/transform/attrs-for-transform.ts
-function transformAttrsForCalls(s, source, neededImports) {
+function generateReactiveAttrsWrapper(attrs) {
+  const parts = [];
+  for (const attr of attrs) {
+    parts.push(`get ${attr.key}() { return ${attr.key} }`);
+    if (attr.bindable) {
+      parts.push(`set ${attr.key}(v) { ${attr.key} = v }`);
+    }
+  }
+  return `{ ${parts.join(", ")} }`;
+}
+function generateAttrsForMerge(attrs) {
+  const parts = [];
+  for (const attr of attrs) {
+    if (attr.bindable) {
+      if (attr.hasDefault) {
+        parts.push(`${attr.key} = $bindable(${attr.defaultValue})`);
+      } else {
+        parts.push(`${attr.key} = $bindable()`);
+      }
+    } else if (attr.hasDefault) {
+      parts.push(`${attr.key} = ${attr.defaultValue}`);
+    } else {
+      parts.push(attr.key);
+    }
+  }
+  return parts.join(", ");
+}
+function transformAttrsForCallsSync(s, source, neededImports) {
   let changed = false;
   const existingPropsMatch = source.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
   let restVarName = null;
@@ -2908,6 +2935,111 @@ function transformAttrsForCalls(s, source, neededImports) {
   }
   return changed;
 }
+async function transformAttrsForCalls(s, source, neededImports, schemaResolver) {
+  let changed = false;
+  const existingPropsMatch = source.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
+  let restVarName = null;
+  let existingPropsStart = -1;
+  let existingDestructureContent = "";
+  if (existingPropsMatch) {
+    existingPropsStart = existingPropsMatch.index;
+    existingDestructureContent = existingPropsMatch[1];
+    const restMatch = existingDestructureContent.match(/\.\.\.\s*(\w+)\s*$/);
+    if (restMatch) {
+      restVarName = restMatch[1];
+    }
+  }
+  const declarations = findVariableDeclarationsWithMacro(source, "$attrs.for");
+  for (const decl of declarations) {
+    const { varName, startIndex, macroOpenParen } = decl;
+    const closeParenIndex = findMatchingBracket(source, macroOpenParen);
+    if (closeParenIndex === -1)
+      continue;
+    const arg = source.slice(macroOpenParen + 1, closeParenIndex).trim();
+    const endIndex = closeParenIndex + 1;
+    const stringMatch = arg.match(/^['"](\w+)['"]$/);
+    if (stringMatch) {
+      const element = stringMatch[1];
+      const typeImport = getElementTypeImport(element);
+      if (existingPropsMatch && existingPropsStart !== -1) {
+        if (!restVarName) {
+          restVarName = "___restAttrs";
+          const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+          const braceEnd = source.indexOf("}", existingPropsStart + 5);
+          if (braceEnd !== -1) {
+            s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+          }
+        }
+        s.overwrite(startIndex, endIndex, `let ${varName} = ${restVarName} as ${typeImport}`);
+      } else {
+        const expansion = `let { ...${varName} } = $props<${typeImport}>()`;
+        s.overwrite(startIndex, endIndex, expansion);
+      }
+    } else {
+      const factoryName = arg;
+      let transformed = false;
+      if (schemaResolver) {
+        const importPath = findImportPath(source, factoryName);
+        if (importPath) {
+          const schema = await schemaResolver.resolve(importPath, factoryName);
+          if (schema && schema.attrs.length > 0) {
+            if (existingPropsMatch && existingPropsStart !== -1) {
+              const additionalAttrs = generateAttrsForMerge(schema.attrs);
+              const restMatch = existingDestructureContent.match(/,?\s*\.\.\.\s*(\w+)\s*$/);
+              let baseContent = existingDestructureContent;
+              let restPart = "";
+              if (restMatch) {
+                restPart = restMatch[0];
+                baseContent = existingDestructureContent.slice(0, restMatch.index);
+              }
+              const mergedDestructure = baseContent.trimEnd() ? `${baseContent.trimEnd()}, ${additionalAttrs}${restPart}` : `${additionalAttrs}${restPart}`;
+              const braceEnd = source.indexOf("}", existingPropsStart + 5);
+              if (braceEnd !== -1) {
+                s.overwrite(existingPropsStart + 5, braceEnd, ` ${mergedDestructure} `);
+              }
+              const wrapper = generateReactiveAttrsWrapper(schema.attrs);
+              s.overwrite(startIndex, endIndex, `let ${varName} = __attrsFor(${factoryName}, ${wrapper})`);
+              transformed = true;
+            } else {
+              const propsDestructure = generatePropsDestructuring(schema.attrs, factoryName);
+              const wrapper = generateReactiveAttrsWrapper(schema.attrs);
+              const expansion = [
+                propsDestructure,
+                `let ${varName} = __attrsFor(${factoryName}, ${wrapper})`
+              ].join(`
+`);
+              s.overwrite(startIndex, endIndex, expansion);
+              transformed = true;
+            }
+          }
+        }
+      }
+      if (!transformed) {
+        if (existingPropsMatch && existingPropsStart !== -1) {
+          if (!restVarName) {
+            restVarName = "___restAttrs";
+            const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+            const braceEnd = source.indexOf("}", existingPropsStart + 5);
+            if (braceEnd !== -1) {
+              s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+            }
+          }
+          s.overwrite(startIndex, endIndex, `let ${varName} = __attrsFor(${factoryName}, ${restVarName})`);
+        } else {
+          const expansion = [
+            `let ___attrs: $attrs.Of<typeof ${factoryName}> = $props()`,
+            `let ${varName} = __attrsFor(${factoryName}, ___attrs)`
+          ].join(`
+`);
+          s.overwrite(startIndex, endIndex, expansion);
+        }
+      }
+      neededImports.add("__attrsFor");
+    }
+    changed = true;
+  }
+  return changed;
+}
 
 // src/transform/core.ts
 function transformScript(source, options = {}) {
@@ -2933,7 +3065,7 @@ function transformScript(source, options = {}) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+    changed = transformAttrsForCallsSync(s, source, neededImports) || changed;
   }
   const needsPropsInjection = propsTypeDeclaration && propsTypeDeclaration.length > 0;
   if (isComponent && (neededImports.size > 0 || needsPropsInjection)) {
@@ -3004,7 +3136,7 @@ async function transformScriptAsync(source, options) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+    changed = await transformAttrsForCalls(s, source, neededImports, schemaResolver) || changed;
   }
   const needsPropsInjectionAsync = propsTypeDeclaration && propsTypeDeclaration.length > 0;
   if (isComponent && (neededImports.size > 0 || needsPropsInjectionAsync)) {
@@ -3074,7 +3206,7 @@ async function transformScriptContent(source, options) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+    changed = await transformAttrsForCalls(s, source, neededImports, schemaResolver) || changed;
   }
   if (neededImports.size > 0) {
     const importStatement = generateRuntimeImport([...neededImports]);

package/dist/index.js

@@ -3473,34 +3473,22 @@ function __attrsFor(factory, rawAttrs) {
   const factoryWithSchema = factory;
   const schema = getMergedAttrSchema(factoryWithSchema);
   const wrapper = {};
-  const localValues = {};
-  const hasLocalValue = {};
   const defineExposedProp = (key2, info) => {
     if (Object.prototype.hasOwnProperty.call(wrapper, key2))
       return;
-    const base = {
+    const descriptor = {
       get() {
-        if (hasLocalValue[key2])
-          return localValues[key2];
         return rawAttrs[key2];
       },
       enumerable: true,
       configurable: true
     };
     if (info.bindable) {
-      Object.defineProperty(wrapper, key2, {
-        ...base,
-        set(value) {
-          localValues[key2] = value;
-          hasLocalValue[key2] = true;
-          try {
-            rawAttrs[key2] = value;
-          } catch {}
-        }
-      });
-    } else {
-      Object.defineProperty(wrapper, key2, base);
+      descriptor.set = function(value) {
+        rawAttrs[key2] = value;
+      };
     }
+    Object.defineProperty(wrapper, key2, descriptor);
   };
   for (const [key2, info] of Object.entries(schema)) {
     const parentValue = rawAttrs[key2];
@@ -3521,8 +3509,6 @@ function __attrsFor(factory, rawAttrs) {
   return new Proxy(wrapper, {
     get(target, prop2) {
       if (typeof prop2 === "string" && prop2 in schema) {
-        if (hasLocalValue[prop2])
-          return localValues[prop2];
         return rawAttrs[prop2];
       }
       if (prop2 in target)
@@ -3531,15 +3517,11 @@ function __attrsFor(factory, rawAttrs) {
     },
     set(target, prop2, value) {
       if (typeof prop2 === "string" && prop2 in schema) {
-        localValues[prop2] = value;
-        hasLocalValue[prop2] = true;
         if (!Object.prototype.hasOwnProperty.call(wrapper, prop2)) {
           defineExposedProp(prop2, schema[prop2]);
         }
         if (schema[prop2].bindable) {
-          try {
-            rawAttrs[prop2] = value;
-          } catch {}
+          rawAttrs[prop2] = value;
         }
         return true;
       }
@@ -3551,18 +3533,10 @@ function __attrsFor(factory, rawAttrs) {
       }
       try {
         rawAttrs[prop2] = value;
-      } catch {
-        if (typeof prop2 === "string") {
-          localValues[prop2] = value;
-          hasLocalValue[prop2] = true;
-        }
-      }
+      } catch {}
       return true;
     },
     has(target, prop2) {
-      if (typeof prop2 === "string" && prop2 in schema) {
-        return prop2 in target || hasLocalValue[prop2];
-      }
       return prop2 in target || prop2 in rawAttrs;
     },
     ownKeys() {
@@ -6661,7 +6635,34 @@ function getElementTypeImport(element2) {
 }
 
 // src/transform/attrs-for-transform.ts
-function transformAttrsForCalls(s, source2, neededImports) {
+function generateReactiveAttrsWrapper(attrs) {
+  const parts = [];
+  for (const attr2 of attrs) {
+    parts.push(`get ${attr2.key}() { return ${attr2.key} }`);
+    if (attr2.bindable) {
+      parts.push(`set ${attr2.key}(v) { ${attr2.key} = v }`);
+    }
+  }
+  return `{ ${parts.join(", ")} }`;
+}
+function generateAttrsForMerge(attrs) {
+  const parts = [];
+  for (const attr2 of attrs) {
+    if (attr2.bindable) {
+      if (attr2.hasDefault) {
+        parts.push(`${attr2.key} = $bindable(${attr2.defaultValue})`);
+      } else {
+        parts.push(`${attr2.key} = $bindable()`);
+      }
+    } else if (attr2.hasDefault) {
+      parts.push(`${attr2.key} = ${attr2.defaultValue}`);
+    } else {
+      parts.push(attr2.key);
+    }
+  }
+  return parts.join(", ");
+}
+function transformAttrsForCallsSync(s, source2, neededImports) {
   let changed = false;
   const existingPropsMatch = source2.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
   let restVarName = null;
@@ -6727,6 +6728,111 @@ function transformAttrsForCalls(s, source2, neededImports) {
   }
   return changed;
 }
+async function transformAttrsForCalls(s, source2, neededImports, schemaResolver) {
+  let changed = false;
+  const existingPropsMatch = source2.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
+  let restVarName = null;
+  let existingPropsStart = -1;
+  let existingDestructureContent = "";
+  if (existingPropsMatch) {
+    existingPropsStart = existingPropsMatch.index;
+    existingDestructureContent = existingPropsMatch[1];
+    const restMatch = existingDestructureContent.match(/\.\.\.\s*(\w+)\s*$/);
+    if (restMatch) {
+      restVarName = restMatch[1];
+    }
+  }
+  const declarations = findVariableDeclarationsWithMacro(source2, "$attrs.for");
+  for (const decl of declarations) {
+    const { varName, startIndex, macroOpenParen } = decl;
+    const closeParenIndex = findMatchingBracket(source2, macroOpenParen);
+    if (closeParenIndex === -1)
+      continue;
+    const arg = source2.slice(macroOpenParen + 1, closeParenIndex).trim();
+    const endIndex = closeParenIndex + 1;
+    const stringMatch = arg.match(/^['"](\w+)['"]$/);
+    if (stringMatch) {
+      const element2 = stringMatch[1];
+      const typeImport = getElementTypeImport(element2);
+      if (existingPropsMatch && existingPropsStart !== -1) {
+        if (!restVarName) {
+          restVarName = "___restAttrs";
+          const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+          const braceEnd = source2.indexOf("}", existingPropsStart + 5);
+          if (braceEnd !== -1) {
+            s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+          }
+        }
+        s.overwrite(startIndex, endIndex, `let ${varName} = ${restVarName} as ${typeImport}`);
+      } else {
+        const expansion = `let { ...${varName} } = $props<${typeImport}>()`;
+        s.overwrite(startIndex, endIndex, expansion);
+      }
+    } else {
+      const factoryName = arg;
+      let transformed = false;
+      if (schemaResolver) {
+        const importPath = findImportPath(source2, factoryName);
+        if (importPath) {
+          const schema = await schemaResolver.resolve(importPath, factoryName);
+          if (schema && schema.attrs.length > 0) {
+            if (existingPropsMatch && existingPropsStart !== -1) {
+              const additionalAttrs = generateAttrsForMerge(schema.attrs);
+              const restMatch = existingDestructureContent.match(/,?\s*\.\.\.\s*(\w+)\s*$/);
+              let baseContent = existingDestructureContent;
+              let restPart = "";
+              if (restMatch) {
+                restPart = restMatch[0];
+                baseContent = existingDestructureContent.slice(0, restMatch.index);
+              }
+              const mergedDestructure = baseContent.trimEnd() ? `${baseContent.trimEnd()}, ${additionalAttrs}${restPart}` : `${additionalAttrs}${restPart}`;
+              const braceEnd = source2.indexOf("}", existingPropsStart + 5);
+              if (braceEnd !== -1) {
+                s.overwrite(existingPropsStart + 5, braceEnd, ` ${mergedDestructure} `);
+              }
+              const wrapper = generateReactiveAttrsWrapper(schema.attrs);
+              s.overwrite(startIndex, endIndex, `let ${varName} = __attrsFor(${factoryName}, ${wrapper})`);
+              transformed = true;
+            } else {
+              const propsDestructure = generatePropsDestructuring(schema.attrs, factoryName);
+              const wrapper = generateReactiveAttrsWrapper(schema.attrs);
+              const expansion = [
+                propsDestructure,
+                `let ${varName} = __attrsFor(${factoryName}, ${wrapper})`
+              ].join(`
+`);
+              s.overwrite(startIndex, endIndex, expansion);
+              transformed = true;
+            }
+          }
+        }
+      }
+      if (!transformed) {
+        if (existingPropsMatch && existingPropsStart !== -1) {
+          if (!restVarName) {
+            restVarName = "___restAttrs";
+            const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+            const braceEnd = source2.indexOf("}", existingPropsStart + 5);
+            if (braceEnd !== -1) {
+              s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+            }
+          }
+          s.overwrite(startIndex, endIndex, `let ${varName} = __attrsFor(${factoryName}, ${restVarName})`);
+        } else {
+          const expansion = [
+            `let ___attrs: $attrs.Of<typeof ${factoryName}> = $props()`,
+            `let ${varName} = __attrsFor(${factoryName}, ___attrs)`
+          ].join(`
+`);
+          s.overwrite(startIndex, endIndex, expansion);
+        }
+      }
+      neededImports.add("__attrsFor");
+    }
+    changed = true;
+  }
+  return changed;
+}
 
 // src/transform/core.ts
 function transformScript(source2, options = {}) {
@@ -6752,7 +6858,7 @@ function transformScript(source2, options = {}) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source2, neededImports) || changed;
+    changed = transformAttrsForCallsSync(s, source2, neededImports) || changed;
   }
   const needsPropsInjection = propsTypeDeclaration && propsTypeDeclaration.length > 0;
   if (isComponent && (neededImports.size > 0 || needsPropsInjection)) {
@@ -6823,7 +6929,7 @@ async function transformScriptAsync(source2, options) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source2, neededImports) || changed;
+    changed = await transformAttrsForCalls(s, source2, neededImports, schemaResolver) || changed;
   }
   const needsPropsInjectionAsync = propsTypeDeclaration && propsTypeDeclaration.length > 0;
   if (isComponent && (neededImports.size > 0 || needsPropsInjectionAsync)) {
@@ -6893,7 +6999,7 @@ async function transformScriptContent(source2, options) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source2, neededImports) || changed;
+    changed = await transformAttrsForCalls(s, source2, neededImports, schemaResolver) || changed;
   }
   if (neededImports.size > 0) {
     const importStatement = generateRuntimeImport([...neededImports]);

package/dist/plugin.js

@@ -2836,7 +2836,34 @@ function getElementTypeImport(element) {
 }
 
 // src/transform/attrs-for-transform.ts
-function transformAttrsForCalls(s, source, neededImports) {
+function generateReactiveAttrsWrapper(attrs) {
+  const parts = [];
+  for (const attr of attrs) {
+    parts.push(`get ${attr.key}() { return ${attr.key} }`);
+    if (attr.bindable) {
+      parts.push(`set ${attr.key}(v) { ${attr.key} = v }`);
+    }
+  }
+  return `{ ${parts.join(", ")} }`;
+}
+function generateAttrsForMerge(attrs) {
+  const parts = [];
+  for (const attr of attrs) {
+    if (attr.bindable) {
+      if (attr.hasDefault) {
+        parts.push(`${attr.key} = $bindable(${attr.defaultValue})`);
+      } else {
+        parts.push(`${attr.key} = $bindable()`);
+      }
+    } else if (attr.hasDefault) {
+      parts.push(`${attr.key} = ${attr.defaultValue}`);
+    } else {
+      parts.push(attr.key);
+    }
+  }
+  return parts.join(", ");
+}
+function transformAttrsForCallsSync(s, source, neededImports) {
   let changed = false;
   const existingPropsMatch = source.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
   let restVarName = null;
@@ -2902,6 +2929,111 @@ function transformAttrsForCalls(s, source, neededImports) {
   }
   return changed;
 }
+async function transformAttrsForCalls(s, source, neededImports, schemaResolver) {
+  let changed = false;
+  const existingPropsMatch = source.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
+  let restVarName = null;
+  let existingPropsStart = -1;
+  let existingDestructureContent = "";
+  if (existingPropsMatch) {
+    existingPropsStart = existingPropsMatch.index;
+    existingDestructureContent = existingPropsMatch[1];
+    const restMatch = existingDestructureContent.match(/\.\.\.\s*(\w+)\s*$/);
+    if (restMatch) {
+      restVarName = restMatch[1];
+    }
+  }
+  const declarations = findVariableDeclarationsWithMacro(source, "$attrs.for");
+  for (const decl of declarations) {
+    const { varName, startIndex, macroOpenParen } = decl;
+    const closeParenIndex = findMatchingBracket(source, macroOpenParen);
+    if (closeParenIndex === -1)
+      continue;
+    const arg = source.slice(macroOpenParen + 1, closeParenIndex).trim();
+    const endIndex = closeParenIndex + 1;
+    const stringMatch = arg.match(/^['"](\w+)['"]$/);
+    if (stringMatch) {
+      const element = stringMatch[1];
+      const typeImport = getElementTypeImport(element);
+      if (existingPropsMatch && existingPropsStart !== -1) {
+        if (!restVarName) {
+          restVarName = "___restAttrs";
+          const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+          const braceEnd = source.indexOf("}", existingPropsStart + 5);
+          if (braceEnd !== -1) {
+            s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+          }
+        }
+        s.overwrite(startIndex, endIndex, `let ${varName} = ${restVarName} as ${typeImport}`);
+      } else {
+        const expansion = `let { ...${varName} } = $props<${typeImport}>()`;
+        s.overwrite(startIndex, endIndex, expansion);
+      }
+    } else {
+      const factoryName = arg;
+      let transformed = false;
+      if (schemaResolver) {
+        const importPath = findImportPath(source, factoryName);
+        if (importPath) {
+          const schema = await schemaResolver.resolve(importPath, factoryName);
+          if (schema && schema.attrs.length > 0) {
+            if (existingPropsMatch && existingPropsStart !== -1) {
+              const additionalAttrs = generateAttrsForMerge(schema.attrs);
+              const restMatch = existingDestructureContent.match(/,?\s*\.\.\.\s*(\w+)\s*$/);
+              let baseContent = existingDestructureContent;
+              let restPart = "";
+              if (restMatch) {
+                restPart = restMatch[0];
+                baseContent = existingDestructureContent.slice(0, restMatch.index);
+              }
+              const mergedDestructure = baseContent.trimEnd() ? `${baseContent.trimEnd()}, ${additionalAttrs}${restPart}` : `${additionalAttrs}${restPart}`;
+              const braceEnd = source.indexOf("}", existingPropsStart + 5);
+              if (braceEnd !== -1) {
+                s.overwrite(existingPropsStart + 5, braceEnd, ` ${mergedDestructure} `);
+              }
+              const wrapper = generateReactiveAttrsWrapper(schema.attrs);
+              s.overwrite(startIndex, endIndex, `let ${varName} = __attrsFor(${factoryName}, ${wrapper})`);
+              transformed = true;
+            } else {
+              const propsDestructure = generatePropsDestructuring(schema.attrs, factoryName);
+              const wrapper = generateReactiveAttrsWrapper(schema.attrs);
+              const expansion = [
+                propsDestructure,
+                `let ${varName} = __attrsFor(${factoryName}, ${wrapper})`
+              ].join(`
+`);
+              s.overwrite(startIndex, endIndex, expansion);
+              transformed = true;
+            }
+          }
+        }
+      }
+      if (!transformed) {
+        if (existingPropsMatch && existingPropsStart !== -1) {
+          if (!restVarName) {
+            restVarName = "___restAttrs";
+            const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+            const braceEnd = source.indexOf("}", existingPropsStart + 5);
+            if (braceEnd !== -1) {
+              s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+            }
+          }
+          s.overwrite(startIndex, endIndex, `let ${varName} = __attrsFor(${factoryName}, ${restVarName})`);
+        } else {
+          const expansion = [
+            `let ___attrs: $attrs.Of<typeof ${factoryName}> = $props()`,
+            `let ${varName} = __attrsFor(${factoryName}, ___attrs)`
+          ].join(`
+`);
+          s.overwrite(startIndex, endIndex, expansion);
+        }
+      }
+      neededImports.add("__attrsFor");
+    }
+    changed = true;
+  }
+  return changed;
+}
 
 // src/transform/core.ts
 function transformScript(source, options = {}) {
@@ -2927,7 +3059,7 @@ function transformScript(source, options = {}) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+    changed = transformAttrsForCallsSync(s, source, neededImports) || changed;
   }
   const needsPropsInjection = propsTypeDeclaration && propsTypeDeclaration.length > 0;
   if (isComponent && (neededImports.size > 0 || needsPropsInjection)) {
@@ -2998,7 +3130,7 @@ async function transformScriptAsync(source, options) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+    changed = await transformAttrsForCalls(s, source, neededImports, schemaResolver) || changed;
   }
   const needsPropsInjectionAsync = propsTypeDeclaration && propsTypeDeclaration.length > 0;
   if (isComponent && (neededImports.size > 0 || needsPropsInjectionAsync)) {
@@ -3068,7 +3200,7 @@ async function transformScriptContent(source, options) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+    changed = await transformAttrsForCalls(s, source, neededImports, schemaResolver) || changed;
   }
   if (neededImports.size > 0) {
     const importStatement = generateRuntimeImport([...neededImports]);
@@ -3766,15 +3898,53 @@ async function resolveSchema(importPath, exportName, importerId, cache, debug, a
     }
     if (schema.propsRef) {
       const propsRefImportPath = findImportPath(source, schema.propsRef);
+      let propsRefSchema = null;
       if (propsRefImportPath) {
-        const propsRefSchema = await resolveAttrsSchema(propsRefImportPath, schema.propsRef, filePath, cache, debug, aliases);
-        if (propsRefSchema) {
+        if (debug) {
+          console.log(`[svelte-origin] Resolving propsRef: ${schema.propsRef} from import ${propsRefImportPath}`);
+        }
+        propsRefSchema = await resolveAttrsSchema(propsRefImportPath, schema.propsRef, filePath, cache, debug, aliases);
+      } else {
+        if (debug) {
+          console.log(`[svelte-origin] Resolving propsRef: ${schema.propsRef} from same file`);
+        }
+        propsRefSchema = parseAttrsSchemaFromSource(source, schema.propsRef);
+        if (propsRefSchema && propsRefSchema.parentNames.length > 0) {
+          const resolvedParentAttrs = [];
+          for (const parentName of propsRefSchema.parentNames) {
+            const parentImportPath = findImportPath(source, parentName);
+            let parentSchema = null;
+            if (parentImportPath) {
+              parentSchema = await resolveAttrsSchema(parentImportPath, parentName, filePath, cache, debug, aliases);
+            } else {
+              parentSchema = parseAttrsSchemaFromSource(source, parentName);
+            }
+            if (parentSchema) {
+              for (const attr of parentSchema.attrs) {
+                const existingIndex = resolvedParentAttrs.findIndex((a) => a.key === attr.key);
+                if (existingIndex === -1) {
+                  resolvedParentAttrs.push(attr);
+                }
+              }
+            }
+          }
           for (const attr of propsRefSchema.attrs) {
-            const existingIndex = mergedAttrs.findIndex((a) => a.key === attr.key);
-            if (existingIndex === -1) {
-              mergedAttrs.push(attr);
+            const existingIndex = resolvedParentAttrs.findIndex((a) => a.key === attr.key);
+            if (existingIndex !== -1) {
+              resolvedParentAttrs[existingIndex] = attr;
+            } else {
+              resolvedParentAttrs.push(attr);
             }
           }
+          propsRefSchema = { attrs: resolvedParentAttrs, parentNames: propsRefSchema.parentNames };
+        }
+      }
+      if (propsRefSchema) {
+        for (const attr of propsRefSchema.attrs) {
+          const existingIndex = mergedAttrs.findIndex((a) => a.key === attr.key);
+          if (existingIndex === -1) {
+            mergedAttrs.push(attr);
+          }
         }
       }
     }

package/dist/post-process.js

@@ -2840,7 +2840,34 @@ function getElementTypeImport(element) {
 }
 
 // src/transform/attrs-for-transform.ts
-function transformAttrsForCalls(s, source, neededImports) {
+function generateReactiveAttrsWrapper(attrs) {
+  const parts = [];
+  for (const attr of attrs) {
+    parts.push(`get ${attr.key}() { return ${attr.key} }`);
+    if (attr.bindable) {
+      parts.push(`set ${attr.key}(v) { ${attr.key} = v }`);
+    }
+  }
+  return `{ ${parts.join(", ")} }`;
+}
+function generateAttrsForMerge(attrs) {
+  const parts = [];
+  for (const attr of attrs) {
+    if (attr.bindable) {
+      if (attr.hasDefault) {
+        parts.push(`${attr.key} = $bindable(${attr.defaultValue})`);
+      } else {
+        parts.push(`${attr.key} = $bindable()`);
+      }
+    } else if (attr.hasDefault) {
+      parts.push(`${attr.key} = ${attr.defaultValue}`);
+    } else {
+      parts.push(attr.key);
+    }
+  }
+  return parts.join(", ");
+}
+function transformAttrsForCallsSync(s, source, neededImports) {
   let changed = false;
   const existingPropsMatch = source.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
   let restVarName = null;
@@ -2906,6 +2933,111 @@ function transformAttrsForCalls(s, source, neededImports) {
   }
   return changed;
 }
+async function transformAttrsForCalls(s, source, neededImports, schemaResolver) {
+  let changed = false;
+  const existingPropsMatch = source.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
+  let restVarName = null;
+  let existingPropsStart = -1;
+  let existingDestructureContent = "";
+  if (existingPropsMatch) {
+    existingPropsStart = existingPropsMatch.index;
+    existingDestructureContent = existingPropsMatch[1];
+    const restMatch = existingDestructureContent.match(/\.\.\.\s*(\w+)\s*$/);
+    if (restMatch) {
+      restVarName = restMatch[1];
+    }
+  }
+  const declarations = findVariableDeclarationsWithMacro(source, "$attrs.for");
+  for (const decl of declarations) {
+    const { varName, startIndex, macroOpenParen } = decl;
+    const closeParenIndex = findMatchingBracket(source, macroOpenParen);
+    if (closeParenIndex === -1)
+      continue;
+    const arg = source.slice(macroOpenParen + 1, closeParenIndex).trim();
+    const endIndex = closeParenIndex + 1;
+    const stringMatch = arg.match(/^['"](\w+)['"]$/);
+    if (stringMatch) {
+      const element = stringMatch[1];
+      const typeImport = getElementTypeImport(element);
+      if (existingPropsMatch && existingPropsStart !== -1) {
+        if (!restVarName) {
+          restVarName = "___restAttrs";
+          const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+          const braceEnd = source.indexOf("}", existingPropsStart + 5);
+          if (braceEnd !== -1) {
+            s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+          }
+        }
+        s.overwrite(startIndex, endIndex, `let ${varName} = ${restVarName} as ${typeImport}`);
+      } else {
+        const expansion = `let { ...${varName} } = $props<${typeImport}>()`;
+        s.overwrite(startIndex, endIndex, expansion);
+      }
+    } else {
+      const factoryName = arg;
+      let transformed = false;
+      if (schemaResolver) {
+        const importPath = findImportPath(source, factoryName);
+        if (importPath) {
+          const schema = await schemaResolver.resolve(importPath, factoryName);
+          if (schema && schema.attrs.length > 0) {
+            if (existingPropsMatch && existingPropsStart !== -1) {
+              const additionalAttrs = generateAttrsForMerge(schema.attrs);
+              const restMatch = existingDestructureContent.match(/,?\s*\.\.\.\s*(\w+)\s*$/);
+              let baseContent = existingDestructureContent;
+              let restPart = "";
+              if (restMatch) {
+                restPart = restMatch[0];
+                baseContent = existingDestructureContent.slice(0, restMatch.index);
+              }
+              const mergedDestructure = baseContent.trimEnd() ? `${baseContent.trimEnd()}, ${additionalAttrs}${restPart}` : `${additionalAttrs}${restPart}`;
+              const braceEnd = source.indexOf("}", existingPropsStart + 5);
+              if (braceEnd !== -1) {
+                s.overwrite(existingPropsStart + 5, braceEnd, ` ${mergedDestructure} `);
+              }
+              const wrapper = generateReactiveAttrsWrapper(schema.attrs);
+              s.overwrite(startIndex, endIndex, `let ${varName} = __attrsFor(${factoryName}, ${wrapper})`);
+              transformed = true;
+            } else {
+              const propsDestructure = generatePropsDestructuring(schema.attrs, factoryName);
+              const wrapper = generateReactiveAttrsWrapper(schema.attrs);
+              const expansion = [
+                propsDestructure,
+                `let ${varName} = __attrsFor(${factoryName}, ${wrapper})`
+              ].join(`
+`);
+              s.overwrite(startIndex, endIndex, expansion);
+              transformed = true;
+            }
+          }
+        }
+      }
+      if (!transformed) {
+        if (existingPropsMatch && existingPropsStart !== -1) {
+          if (!restVarName) {
+            restVarName = "___restAttrs";
+            const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+            const braceEnd = source.indexOf("}", existingPropsStart + 5);
+            if (braceEnd !== -1) {
+              s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+            }
+          }
+          s.overwrite(startIndex, endIndex, `let ${varName} = __attrsFor(${factoryName}, ${restVarName})`);
+        } else {
+          const expansion = [
+            `let ___attrs: $attrs.Of<typeof ${factoryName}> = $props()`,
+            `let ${varName} = __attrsFor(${factoryName}, ___attrs)`
+          ].join(`
+`);
+          s.overwrite(startIndex, endIndex, expansion);
+        }
+      }
+      neededImports.add("__attrsFor");
+    }
+    changed = true;
+  }
+  return changed;
+}
 
 // src/transform/core.ts
 function transformScript(source, options = {}) {
@@ -2931,7 +3063,7 @@ function transformScript(source, options = {}) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+    changed = transformAttrsForCallsSync(s, source, neededImports) || changed;
   }
   const needsPropsInjection = propsTypeDeclaration && propsTypeDeclaration.length > 0;
   if (isComponent && (neededImports.size > 0 || needsPropsInjection)) {
@@ -3002,7 +3134,7 @@ async function transformScriptAsync(source, options) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+    changed = await transformAttrsForCalls(s, source, neededImports, schemaResolver) || changed;
   }
   const needsPropsInjectionAsync = propsTypeDeclaration && propsTypeDeclaration.length > 0;
   if (isComponent && (neededImports.size > 0 || needsPropsInjectionAsync)) {
@@ -3072,7 +3204,7 @@ async function transformScriptContent(source, options) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+    changed = await transformAttrsForCalls(s, source, neededImports, schemaResolver) || changed;
   }
   if (neededImports.size > 0) {
     const importStatement = generateRuntimeImport([...neededImports]);

package/dist/preprocess.js

@@ -2836,7 +2836,34 @@ function getElementTypeImport(element) {
 }
 
 // src/transform/attrs-for-transform.ts
-function transformAttrsForCalls(s, source, neededImports) {
+function generateReactiveAttrsWrapper(attrs) {
+  const parts = [];
+  for (const attr of attrs) {
+    parts.push(`get ${attr.key}() { return ${attr.key} }`);
+    if (attr.bindable) {
+      parts.push(`set ${attr.key}(v) { ${attr.key} = v }`);
+    }
+  }
+  return `{ ${parts.join(", ")} }`;
+}
+function generateAttrsForMerge(attrs) {
+  const parts = [];
+  for (const attr of attrs) {
+    if (attr.bindable) {
+      if (attr.hasDefault) {
+        parts.push(`${attr.key} = $bindable(${attr.defaultValue})`);
+      } else {
+        parts.push(`${attr.key} = $bindable()`);
+      }
+    } else if (attr.hasDefault) {
+      parts.push(`${attr.key} = ${attr.defaultValue}`);
+    } else {
+      parts.push(attr.key);
+    }
+  }
+  return parts.join(", ");
+}
+function transformAttrsForCallsSync(s, source, neededImports) {
   let changed = false;
   const existingPropsMatch = source.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
   let restVarName = null;
@@ -2902,6 +2929,111 @@ function transformAttrsForCalls(s, source, neededImports) {
   }
   return changed;
 }
+async function transformAttrsForCalls(s, source, neededImports, schemaResolver) {
+  let changed = false;
+  const existingPropsMatch = source.match(/let\s*\{([^}]*)\}\s*(?::\s*[^=]+)?\s*=\s*\$props\s*\(\s*\)/);
+  let restVarName = null;
+  let existingPropsStart = -1;
+  let existingDestructureContent = "";
+  if (existingPropsMatch) {
+    existingPropsStart = existingPropsMatch.index;
+    existingDestructureContent = existingPropsMatch[1];
+    const restMatch = existingDestructureContent.match(/\.\.\.\s*(\w+)\s*$/);
+    if (restMatch) {
+      restVarName = restMatch[1];
+    }
+  }
+  const declarations = findVariableDeclarationsWithMacro(source, "$attrs.for");
+  for (const decl of declarations) {
+    const { varName, startIndex, macroOpenParen } = decl;
+    const closeParenIndex = findMatchingBracket(source, macroOpenParen);
+    if (closeParenIndex === -1)
+      continue;
+    const arg = source.slice(macroOpenParen + 1, closeParenIndex).trim();
+    const endIndex = closeParenIndex + 1;
+    const stringMatch = arg.match(/^['"](\w+)['"]$/);
+    if (stringMatch) {
+      const element = stringMatch[1];
+      const typeImport = getElementTypeImport(element);
+      if (existingPropsMatch && existingPropsStart !== -1) {
+        if (!restVarName) {
+          restVarName = "___restAttrs";
+          const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+          const braceEnd = source.indexOf("}", existingPropsStart + 5);
+          if (braceEnd !== -1) {
+            s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+          }
+        }
+        s.overwrite(startIndex, endIndex, `let ${varName} = ${restVarName} as ${typeImport}`);
+      } else {
+        const expansion = `let { ...${varName} } = $props<${typeImport}>()`;
+        s.overwrite(startIndex, endIndex, expansion);
+      }
+    } else {
+      const factoryName = arg;
+      let transformed = false;
+      if (schemaResolver) {
+        const importPath = findImportPath(source, factoryName);
+        if (importPath) {
+          const schema = await schemaResolver.resolve(importPath, factoryName);
+          if (schema && schema.attrs.length > 0) {
+            if (existingPropsMatch && existingPropsStart !== -1) {
+              const additionalAttrs = generateAttrsForMerge(schema.attrs);
+              const restMatch = existingDestructureContent.match(/,?\s*\.\.\.\s*(\w+)\s*$/);
+              let baseContent = existingDestructureContent;
+              let restPart = "";
+              if (restMatch) {
+                restPart = restMatch[0];
+                baseContent = existingDestructureContent.slice(0, restMatch.index);
+              }
+              const mergedDestructure = baseContent.trimEnd() ? `${baseContent.trimEnd()}, ${additionalAttrs}${restPart}` : `${additionalAttrs}${restPart}`;
+              const braceEnd = source.indexOf("}", existingPropsStart + 5);
+              if (braceEnd !== -1) {
+                s.overwrite(existingPropsStart + 5, braceEnd, ` ${mergedDestructure} `);
+              }
+              const wrapper = generateReactiveAttrsWrapper(schema.attrs);
+              s.overwrite(startIndex, endIndex, `let ${varName} = __attrsFor(${factoryName}, ${wrapper})`);
+              transformed = true;
+            } else {
+              const propsDestructure = generatePropsDestructuring(schema.attrs, factoryName);
+              const wrapper = generateReactiveAttrsWrapper(schema.attrs);
+              const expansion = [
+                propsDestructure,
+                `let ${varName} = __attrsFor(${factoryName}, ${wrapper})`
+              ].join(`
+`);
+              s.overwrite(startIndex, endIndex, expansion);
+              transformed = true;
+            }
+          }
+        }
+      }
+      if (!transformed) {
+        if (existingPropsMatch && existingPropsStart !== -1) {
+          if (!restVarName) {
+            restVarName = "___restAttrs";
+            const newDestructure = existingDestructureContent.trimEnd() ? `${existingDestructureContent.trimEnd()}, ...${restVarName}` : `...${restVarName}`;
+            const braceEnd = source.indexOf("}", existingPropsStart + 5);
+            if (braceEnd !== -1) {
+              s.overwrite(existingPropsStart + 5, braceEnd, ` ${newDestructure} `);
+            }
+          }
+          s.overwrite(startIndex, endIndex, `let ${varName} = __attrsFor(${factoryName}, ${restVarName})`);
+        } else {
+          const expansion = [
+            `let ___attrs: $attrs.Of<typeof ${factoryName}> = $props()`,
+            `let ${varName} = __attrsFor(${factoryName}, ___attrs)`
+          ].join(`
+`);
+          s.overwrite(startIndex, endIndex, expansion);
+        }
+      }
+      neededImports.add("__attrsFor");
+    }
+    changed = true;
+  }
+  return changed;
+}
 
 // src/transform/core.ts
 function transformScript(source, options = {}) {
@@ -2927,7 +3059,7 @@ function transformScript(source, options = {}) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+    changed = transformAttrsForCallsSync(s, source, neededImports) || changed;
   }
   const needsPropsInjection = propsTypeDeclaration && propsTypeDeclaration.length > 0;
   if (isComponent && (neededImports.size > 0 || needsPropsInjection)) {
@@ -2998,7 +3130,7 @@ async function transformScriptAsync(source, options) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+    changed = await transformAttrsForCalls(s, source, neededImports, schemaResolver) || changed;
   }
   const needsPropsInjectionAsync = propsTypeDeclaration && propsTypeDeclaration.length > 0;
   if (isComponent && (neededImports.size > 0 || needsPropsInjectionAsync)) {
@@ -3068,7 +3200,7 @@ async function transformScriptContent(source, options) {
     propsTypeDeclaration = result.propsTypeDeclaration;
   }
   if (isComponent) {
-    changed = transformAttrsForCalls(s, source, neededImports) || changed;
+    changed = await transformAttrsForCalls(s, source, neededImports, schemaResolver) || changed;
   }
   if (neededImports.size > 0) {
     const importStatement = generateRuntimeImport([...neededImports]);
@@ -3565,20 +3697,55 @@ async function resolveSchema(importPath, exportName, importerId, cache, debug, a
     }
     if (schema.propsRef) {
       const propsRefImportPath = findImportPath(source, schema.propsRef);
+      let propsRefSchema = null;
       if (propsRefImportPath) {
         if (debug) {
-          console.log(`[svelte-origin-preprocess] Resolving propsRef: ${schema.propsRef} from ${propsRefImportPath}`);
+          console.log(`[svelte-origin-preprocess] Resolving propsRef: ${schema.propsRef} from import ${propsRefImportPath}`);
+        }
+        propsRefSchema = await resolveAttrsSchema(propsRefImportPath, schema.propsRef, filePath, cache, debug, aliases);
+      } else {
+        if (debug) {
+          console.log(`[svelte-origin-preprocess] Resolving propsRef: ${schema.propsRef} from same file`);
         }
-        const propsRefSchema = await resolveAttrsSchema(propsRefImportPath, schema.propsRef, filePath, cache, debug, aliases);
-        if (propsRefSchema) {
+        propsRefSchema = parseAttrsSchemaFromSource(source, schema.propsRef);
+        if (propsRefSchema && propsRefSchema.parentNames.length > 0) {
+          const resolvedParentAttrs = [];
+          for (const parentName of propsRefSchema.parentNames) {
+            const parentImportPath = findImportPath(source, parentName);
+            let parentSchema = null;
+            if (parentImportPath) {
+              parentSchema = await resolveAttrsSchema(parentImportPath, parentName, filePath, cache, debug, aliases);
+            } else {
+              parentSchema = parseAttrsSchemaFromSource(source, parentName);
+            }
+            if (parentSchema) {
+              for (const attr of parentSchema.attrs) {
+                const existingIndex = resolvedParentAttrs.findIndex((a) => a.key === attr.key);
+                if (existingIndex === -1) {
+                  resolvedParentAttrs.push(attr);
+                }
+              }
+            }
+          }
           for (const attr of propsRefSchema.attrs) {
-            const existingIndex = mergedAttrs.findIndex((a) => a.key === attr.key);
-            if (existingIndex === -1) {
-              mergedAttrs.push(attr);
+            const existingIndex = resolvedParentAttrs.findIndex((a) => a.key === attr.key);
+            if (existingIndex !== -1) {
+              resolvedParentAttrs[existingIndex] = attr;
             } else {
-              mergedAttrs[existingIndex] = attr;
+              resolvedParentAttrs.push(attr);
             }
           }
+          propsRefSchema = { attrs: resolvedParentAttrs, parentNames: propsRefSchema.parentNames };
+        }
+      }
+      if (propsRefSchema) {
+        for (const attr of propsRefSchema.attrs) {
+          const existingIndex = mergedAttrs.findIndex((a) => a.key === attr.key);
+          if (existingIndex === -1) {
+            mergedAttrs.push(attr);
+          } else {
+            mergedAttrs[existingIndex] = attr;
+          }
         }
       }
     }

package/dist/runtime/index.js

@@ -3473,34 +3473,22 @@ function __attrsFor(factory, rawAttrs) {
   const factoryWithSchema = factory;
   const schema = getMergedAttrSchema(factoryWithSchema);
   const wrapper = {};
-  const localValues = {};
-  const hasLocalValue = {};
   const defineExposedProp = (key2, info) => {
     if (Object.prototype.hasOwnProperty.call(wrapper, key2))
       return;
-    const base = {
+    const descriptor = {
       get() {
-        if (hasLocalValue[key2])
-          return localValues[key2];
         return rawAttrs[key2];
       },
       enumerable: true,
       configurable: true
     };
     if (info.bindable) {
-      Object.defineProperty(wrapper, key2, {
-        ...base,
-        set(value) {
-          localValues[key2] = value;
-          hasLocalValue[key2] = true;
-          try {
-            rawAttrs[key2] = value;
-          } catch {}
-        }
-      });
-    } else {
-      Object.defineProperty(wrapper, key2, base);
+      descriptor.set = function(value) {
+        rawAttrs[key2] = value;
+      };
     }
+    Object.defineProperty(wrapper, key2, descriptor);
   };
   for (const [key2, info] of Object.entries(schema)) {
     const parentValue = rawAttrs[key2];
@@ -3521,8 +3509,6 @@ function __attrsFor(factory, rawAttrs) {
   return new Proxy(wrapper, {
     get(target, prop2) {
       if (typeof prop2 === "string" && prop2 in schema) {
-        if (hasLocalValue[prop2])
-          return localValues[prop2];
         return rawAttrs[prop2];
       }
       if (prop2 in target)
@@ -3531,15 +3517,11 @@ function __attrsFor(factory, rawAttrs) {
     },
     set(target, prop2, value) {
       if (typeof prop2 === "string" && prop2 in schema) {
-        localValues[prop2] = value;
-        hasLocalValue[prop2] = true;
         if (!Object.prototype.hasOwnProperty.call(wrapper, prop2)) {
           defineExposedProp(prop2, schema[prop2]);
         }
         if (schema[prop2].bindable) {
-          try {
-            rawAttrs[prop2] = value;
-          } catch {}
+          rawAttrs[prop2] = value;
         }
         return true;
       }
@@ -3551,18 +3533,10 @@ function __attrsFor(factory, rawAttrs) {
       }
       try {
         rawAttrs[prop2] = value;
-      } catch {
-        if (typeof prop2 === "string") {
-          localValues[prop2] = value;
-          hasLocalValue[prop2] = true;
-        }
-      }
+      } catch {}
       return true;
     },
     has(target, prop2) {
-      if (typeof prop2 === "string" && prop2 in schema) {
-        return prop2 in target || hasLocalValue[prop2];
-      }
       return prop2 in target || prop2 in rawAttrs;
     },
     ownKeys() {

package/dist/transform/attrs-for-transform.d.ts

@@ -6,12 +6,13 @@
  * - $attrs.for('input') - get typed element attrs
  */
 import type MagicString from 'magic-string';
+import { type SchemaResolver } from './schema';
 /**
- * Transform $attrs.for(X) calls.
- * Handles both origin factories ($attrs.for(OriginFactory)) and element names ($attrs.for('input'))
+ * Transform $attrs.for(X) calls (sync fallback version).
  *
- * If $props() already exists, we extend the existing destructuring with rest syntax.
- * Otherwise, we generate a new $props() call.
+ * This version always uses the fallback approach since no schema resolver is provided.
+ * Fallback generates a raw $props() proxy which does NOT support two-way binding
+ * through parent components (the props proxy is read-only for non-destructured props).
  *
  * Supports all TypeScript declaration patterns:
  * - let x = $attrs.for(Factory)
@@ -21,4 +22,34 @@ import type MagicString from 'magic-string';
  * - export let x = $attrs.for(Factory)
  * - export const x: Type = $attrs.for('input')
  */
-export declare function transformAttrsForCalls(s: MagicString, source: string, neededImports: Set<string>): boolean;
+export declare function transformAttrsForCallsSync(s: MagicString, source: string, neededImports: Set<string>): boolean;
+/**
+ * Transform $attrs.for(X) calls (async version with schema resolution).
+ *
+ * When schema is available via static resolution:
+ * ```svelte
+ * let childAttrs = $attrs.for(Counter)
+ * ```
+ * Becomes:
+ * ```svelte
+ * let { label = 'Counter', count = $bindable(0), step = 1 }: $attrs.Of<typeof Counter> = $props()
+ * let childAttrs = __attrsFor(Counter, { get label() { return label }, get count() { return count }, set count(v) { count = v }, get step() { return step } })
+ * ```
+ *
+ * This approach works because:
+ * 1. Props are destructured with $bindable(), making them writable
+ * 2. The getter/setter wrapper passes reactive accessors to __attrsFor
+ * 3. When child components update bindable props, the setters propagate changes back
+ *
+ * Fallback (when schema isn't statically known):
+ * ```svelte
+ * let ___attrs: $attrs.Of<typeof Counter> = $props()
+ * let childAttrs = __attrsFor(Counter, ___attrs)
+ * ```
+ *
+ * @param s MagicString instance for source manipulation
+ * @param source Original source code
+ * @param neededImports Set to track required runtime imports
+ * @param schemaResolver Optional resolver for static schema extraction
+ */
+export declare function transformAttrsForCalls(s: MagicString, source: string, neededImports: Set<string>, schemaResolver?: SchemaResolver): Promise<boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "svelte-origin",
-	"version": "1.0.0-next.22",
+	"version": "1.0.0-next.23",
 	"description": "Compiler-assisted state and prop ergonomics for Svelte 5",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",