svelte-origin 1.0.0-next.19 → 1.0.0-next.21

package/dist/aliases.d.ts

@@ -36,6 +36,7 @@ export declare function resolveAliases(config?: AliasConfig): ResolvedAliases;
  * - Exact matches: "$lib" -> "src/lib"
  * - Prefix matches: "$lib/utils" -> "src/lib/utils"
  * - Longest match wins: "$lib/components" before "$lib"
+ * - npm package imports via node_modules resolution
  */
 export declare function resolveImportPath(importPath: string, aliases: Record<string, string>, importerDir: string): string | null;
 /**

package/dist/cli.js

@@ -2032,65 +2032,15 @@ function transformOriginBody(content, parents = [], attrDetails = [], propName =
   const hasParents = parents.length > 0;
   const propsLines = [];
   if (attrDetails.length > 0) {
-    const initialProps = [];
+    const propDefs = [];
     for (const attr of attrDetails) {
       const defaultExpr = attr.hasDefault ? ` ?? ${attr.defaultValue}` : "";
-      initialProps.push(`${attr.key}: __inputAttrs.${attr.key}${defaultExpr}`);
-    }
-    propsLines.push(`let __props = $state({ ${initialProps.join(", ")} })`);
-    for (const attr of attrDetails) {
-      const defaultExpr = attr.hasDefault ? ` ?? ${attr.defaultValue}` : "";
-      const parentLast = `__last_parent_${attr.key}`;
-      const localLast = `__last_local_${attr.key}`;
-      propsLines.push(`let ${parentLast} = __inputAttrs.${attr.key}`, `let ${localLast} = __props.${attr.key}`, `$effect(() => {
-` + `			const __parent = __inputAttrs.${attr.key}
-` + `			const __local = __props.${attr.key}
-
-` + `			// Parent -> local
-` + `			if (__parent !== ${parentLast}) {
-` + `				${parentLast} = __parent
-` + `				if (__local !== __parent) {
-` + `					__props.${attr.key} = __parent${defaultExpr}
-` + `				}
-` + `				${localLast} = __props.${attr.key}
-` + `				return
-` + `			}
-
-` + `			// Local -> parent
-` + `			if (__local !== ${localLast}) {
-` + `				${localLast} = __local
-` + (attr.bindable ? `				try { __inputAttrs.${attr.key} = __local } catch {}
-				${parentLast} = __inputAttrs.${attr.key}
-` : "") + `			}
-` + `})`);
+      propDefs.push(`get ${attr.key}() { return __inputAttrs.${attr.key}${defaultExpr} }`);
+      propDefs.push(`set ${attr.key}(v) { __inputAttrs.${attr.key} = v }`);
     }
+    propsLines.push(`const __props = { ${propDefs.join(", ")} }`);
   } else {
-    propsLines.push("let __props = $state({ ...__inputAttrs })", "const __syncState = new Map()", `$effect.pre(() => {
-` + `			// Bidirectional sync between __inputAttrs and __props
-` + `			for (const key of Object.keys(__inputAttrs)) {
-` + `				const parentVal = __inputAttrs[key]
-` + `				const localVal = __props[key]
-` + `				const state = __syncState.get(key) ?? { parent: parentVal, local: localVal }
-` + `				__syncState.set(key, state)
-
-` + `				// Parent changed -> update local
-` + `				if (parentVal !== state.parent) {
-` + `					state.parent = parentVal
-` + `					if (localVal !== parentVal) {
-` + `						__props[key] = parentVal
-` + `						state.local = parentVal
-` + `					}
-` + `					continue
-` + `				}
-
-` + `				// Local changed -> update parent (for bindable props)
-` + `				if (localVal !== state.local) {
-` + `					state.local = localVal
-` + `					try { __inputAttrs[key] = localVal } catch {}
-` + `					state.parent = __inputAttrs[key]
-` + `				}
-` + `			}
-` + `		})`);
+    propsLines.push("const __props = __inputAttrs");
   }
   const propsObjectCode = "\t\t" + propsLines.join(`
 		`);
@@ -2288,7 +2238,16 @@ function transformStandaloneAttrsDefinition(content) {
 
 // src/transform/schema.ts
 function parseOriginSchemaFromSource(source, exportName) {
-  const exportPattern = new RegExp(`export\\s+const\\s+${exportName}\\s*=\\s*\\$origin\\s*\\(`, "s");
+  const sourceResult = parseSourceOrigin(source, exportName);
+  if (sourceResult)
+    return sourceResult;
+  const compiledResult = parseCompiledOrigin(source, exportName);
+  if (compiledResult)
+    return compiledResult;
+  return null;
+}
+function parseSourceOrigin(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*\\$origin\\s*\\(`, "s");
   const match = exportPattern.exec(source);
   if (!match)
     return null;
@@ -2324,6 +2283,94 @@ function parseOriginSchemaFromSource(source, exportName) {
   const attrs = parseAttrsContent(attrsContent);
   return { attrs, parentNames };
 }
+function parseCompiledOrigin(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*__createOrigin\\s*\\(\\s*\\{`, "s");
+  const match = exportPattern.exec(source);
+  if (!match)
+    return null;
+  const braceStart = match.index + match[0].length - 1;
+  const braceEnd = findMatchingBracket(source, braceStart, "{", "}");
+  if (braceEnd === -1)
+    return null;
+  const configContent = source.slice(braceStart + 1, braceEnd);
+  const schemaMatch = configContent.match(/__attrSchema\s*:\s*\{/);
+  if (!schemaMatch)
+    return { attrs: [], parentNames: [] };
+  const schemaStart = schemaMatch.index + schemaMatch[0].length - 1;
+  const schemaEnd = findMatchingBracket(configContent, schemaStart, "{", "}");
+  if (schemaEnd === -1)
+    return { attrs: [], parentNames: [] };
+  const schemaContent = configContent.slice(schemaStart + 1, schemaEnd);
+  const attrs = parseCompiledAttrSchema(schemaContent);
+  const parentsMatch = configContent.match(/__parents\s*:\s*\[([^\]]*)\]/);
+  let parentNames = [];
+  if (parentsMatch && parentsMatch[1].trim()) {
+    parentNames = parentsMatch[1].split(",").map((p) => p.trim()).filter((p) => p && /^\w+$/.test(p));
+  }
+  return { attrs, parentNames };
+}
+function parseCompiledAttrSchema(content) {
+  const result = [];
+  let pos = 0;
+  while (pos < content.length) {
+    while (pos < content.length && /[\s,]/.test(content[pos]))
+      pos++;
+    if (pos >= content.length)
+      break;
+    if (content.slice(pos, pos + 2) === "/*") {
+      const endComment = content.indexOf("*/", pos + 2);
+      if (endComment !== -1) {
+        pos = endComment + 2;
+        continue;
+      }
+    }
+    const keyMatch = content.slice(pos).match(/^(\w+)\s*:/);
+    if (!keyMatch)
+      break;
+    const key = keyMatch[1];
+    pos += keyMatch[0].length;
+    while (pos < content.length && /\s/.test(content[pos]))
+      pos++;
+    if (content[pos] !== "{")
+      break;
+    const valueStart = pos;
+    const valueEnd = findMatchingBracket(content, valueStart, "{", "}");
+    if (valueEnd === -1)
+      break;
+    const valueContent = content.slice(valueStart + 1, valueEnd);
+    let defaultValue = "undefined";
+    let bindable = false;
+    let hasDefault = false;
+    const defaultMatch = valueContent.match(/\bdefault\s*:\s*/);
+    if (defaultMatch) {
+      const defaultStart = defaultMatch.index + defaultMatch[0].length;
+      let depth = 0;
+      let i = defaultStart;
+      while (i < valueContent.length) {
+        const char = valueContent[i];
+        if (char === "{" || char === "(" || char === "[")
+          depth++;
+        else if (char === "}" || char === ")" || char === "]")
+          depth--;
+        else if (char === "," && depth === 0)
+          break;
+        i++;
+      }
+      defaultValue = valueContent.slice(defaultStart, i).trim();
+    }
+    const bindableMatch = valueContent.match(/\bbindable\s*:\s*(true|false)/);
+    if (bindableMatch) {
+      bindable = bindableMatch[1] === "true";
+    }
+    const hasDefaultMatch = valueContent.match(/\bhasDefault\s*:\s*(true|false)/);
+    if (hasDefaultMatch) {
+      hasDefault = hasDefaultMatch[1] === "true";
+    }
+    result.push({ key, defaultValue, bindable, hasDefault });
+    pos = valueEnd + 1;
+  }
+  return result;
+}
 function parseAttrsContent(content) {
   const result = [];
   const parts = splitByTopLevelCommas(content);

package/dist/index.js

@@ -3891,7 +3891,16 @@ function findMatchingBracket(source2, openIndex, openChar = "(", closeChar = ")"
 
 // src/transform/schema.ts
 function parseOriginSchemaFromSource(source2, exportName) {
-  const exportPattern = new RegExp(`export\\s+const\\s+${exportName}\\s*=\\s*\\$origin\\s*\\(`, "s");
+  const sourceResult = parseSourceOrigin(source2, exportName);
+  if (sourceResult)
+    return sourceResult;
+  const compiledResult = parseCompiledOrigin(source2, exportName);
+  if (compiledResult)
+    return compiledResult;
+  return null;
+}
+function parseSourceOrigin(source2, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*\\$origin\\s*\\(`, "s");
   const match = exportPattern.exec(source2);
   if (!match)
     return null;
@@ -3927,6 +3936,94 @@ function parseOriginSchemaFromSource(source2, exportName) {
   const attrs = parseAttrsContent(attrsContent);
   return { attrs, parentNames };
 }
+function parseCompiledOrigin(source2, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*__createOrigin\\s*\\(\\s*\\{`, "s");
+  const match = exportPattern.exec(source2);
+  if (!match)
+    return null;
+  const braceStart = match.index + match[0].length - 1;
+  const braceEnd = findMatchingBracket(source2, braceStart, "{", "}");
+  if (braceEnd === -1)
+    return null;
+  const configContent = source2.slice(braceStart + 1, braceEnd);
+  const schemaMatch = configContent.match(/__attrSchema\s*:\s*\{/);
+  if (!schemaMatch)
+    return { attrs: [], parentNames: [] };
+  const schemaStart = schemaMatch.index + schemaMatch[0].length - 1;
+  const schemaEnd = findMatchingBracket(configContent, schemaStart, "{", "}");
+  if (schemaEnd === -1)
+    return { attrs: [], parentNames: [] };
+  const schemaContent = configContent.slice(schemaStart + 1, schemaEnd);
+  const attrs = parseCompiledAttrSchema(schemaContent);
+  const parentsMatch = configContent.match(/__parents\s*:\s*\[([^\]]*)\]/);
+  let parentNames = [];
+  if (parentsMatch && parentsMatch[1].trim()) {
+    parentNames = parentsMatch[1].split(",").map((p) => p.trim()).filter((p) => p && /^\w+$/.test(p));
+  }
+  return { attrs, parentNames };
+}
+function parseCompiledAttrSchema(content) {
+  const result = [];
+  let pos = 0;
+  while (pos < content.length) {
+    while (pos < content.length && /[\s,]/.test(content[pos]))
+      pos++;
+    if (pos >= content.length)
+      break;
+    if (content.slice(pos, pos + 2) === "/*") {
+      const endComment = content.indexOf("*/", pos + 2);
+      if (endComment !== -1) {
+        pos = endComment + 2;
+        continue;
+      }
+    }
+    const keyMatch = content.slice(pos).match(/^(\w+)\s*:/);
+    if (!keyMatch)
+      break;
+    const key2 = keyMatch[1];
+    pos += keyMatch[0].length;
+    while (pos < content.length && /\s/.test(content[pos]))
+      pos++;
+    if (content[pos] !== "{")
+      break;
+    const valueStart = pos;
+    const valueEnd = findMatchingBracket(content, valueStart, "{", "}");
+    if (valueEnd === -1)
+      break;
+    const valueContent = content.slice(valueStart + 1, valueEnd);
+    let defaultValue = "undefined";
+    let bindable2 = false;
+    let hasDefault = false;
+    const defaultMatch = valueContent.match(/\bdefault\s*:\s*/);
+    if (defaultMatch) {
+      const defaultStart = defaultMatch.index + defaultMatch[0].length;
+      let depth = 0;
+      let i = defaultStart;
+      while (i < valueContent.length) {
+        const char = valueContent[i];
+        if (char === "{" || char === "(" || char === "[")
+          depth++;
+        else if (char === "}" || char === ")" || char === "]")
+          depth--;
+        else if (char === "," && depth === 0)
+          break;
+        i++;
+      }
+      defaultValue = valueContent.slice(defaultStart, i).trim();
+    }
+    const bindableMatch = valueContent.match(/\bbindable\s*:\s*(true|false)/);
+    if (bindableMatch) {
+      bindable2 = bindableMatch[1] === "true";
+    }
+    const hasDefaultMatch = valueContent.match(/\bhasDefault\s*:\s*(true|false)/);
+    if (hasDefaultMatch) {
+      hasDefault = hasDefaultMatch[1] === "true";
+    }
+    result.push({ key: key2, defaultValue, bindable: bindable2, hasDefault });
+    pos = valueEnd + 1;
+  }
+  return result;
+}
 function parseAttrsContent(content) {
   const result = [];
   const parts = splitByTopLevelCommas(content);
@@ -6120,65 +6217,15 @@ function transformOriginBody(content, parents = [], attrDetails = [], propName =
   const hasParents = parents.length > 0;
   const propsLines = [];
   if (attrDetails.length > 0) {
-    const initialProps = [];
+    const propDefs = [];
     for (const attr2 of attrDetails) {
       const defaultExpr = attr2.hasDefault ? ` ?? ${attr2.defaultValue}` : "";
-      initialProps.push(`${attr2.key}: __inputAttrs.${attr2.key}${defaultExpr}`);
-    }
-    propsLines.push(`let __props = $state({ ${initialProps.join(", ")} })`);
-    for (const attr2 of attrDetails) {
-      const defaultExpr = attr2.hasDefault ? ` ?? ${attr2.defaultValue}` : "";
-      const parentLast = `__last_parent_${attr2.key}`;
-      const localLast = `__last_local_${attr2.key}`;
-      propsLines.push(`let ${parentLast} = __inputAttrs.${attr2.key}`, `let ${localLast} = __props.${attr2.key}`, `$effect(() => {
-` + `			const __parent = __inputAttrs.${attr2.key}
-` + `			const __local = __props.${attr2.key}
-
-` + `			// Parent -> local
-` + `			if (__parent !== ${parentLast}) {
-` + `				${parentLast} = __parent
-` + `				if (__local !== __parent) {
-` + `					__props.${attr2.key} = __parent${defaultExpr}
-` + `				}
-` + `				${localLast} = __props.${attr2.key}
-` + `				return
-` + `			}
-
-` + `			// Local -> parent
-` + `			if (__local !== ${localLast}) {
-` + `				${localLast} = __local
-` + (attr2.bindable ? `				try { __inputAttrs.${attr2.key} = __local } catch {}
-				${parentLast} = __inputAttrs.${attr2.key}
-` : "") + `			}
-` + `})`);
+      propDefs.push(`get ${attr2.key}() { return __inputAttrs.${attr2.key}${defaultExpr} }`);
+      propDefs.push(`set ${attr2.key}(v) { __inputAttrs.${attr2.key} = v }`);
     }
+    propsLines.push(`const __props = { ${propDefs.join(", ")} }`);
   } else {
-    propsLines.push("let __props = $state({ ...__inputAttrs })", "const __syncState = new Map()", `$effect.pre(() => {
-` + `			// Bidirectional sync between __inputAttrs and __props
-` + `			for (const key of Object.keys(__inputAttrs)) {
-` + `				const parentVal = __inputAttrs[key]
-` + `				const localVal = __props[key]
-` + `				const state = __syncState.get(key) ?? { parent: parentVal, local: localVal }
-` + `				__syncState.set(key, state)
-
-` + `				// Parent changed -> update local
-` + `				if (parentVal !== state.parent) {
-` + `					state.parent = parentVal
-` + `					if (localVal !== parentVal) {
-` + `						__props[key] = parentVal
-` + `						state.local = parentVal
-` + `					}
-` + `					continue
-` + `				}
-
-` + `				// Local changed -> update parent (for bindable props)
-` + `				if (localVal !== state.local) {
-` + `					state.local = localVal
-` + `					try { __inputAttrs[key] = localVal } catch {}
-` + `					state.parent = __inputAttrs[key]
-` + `				}
-` + `			}
-` + `		})`);
+    propsLines.push("const __props = __inputAttrs");
   }
   const propsObjectCode = "\t\t" + propsLines.join(`
 		`);

package/dist/plugin.js

@@ -2026,65 +2026,15 @@ function transformOriginBody(content, parents = [], attrDetails = [], propName =
   const hasParents = parents.length > 0;
   const propsLines = [];
   if (attrDetails.length > 0) {
-    const initialProps = [];
+    const propDefs = [];
     for (const attr of attrDetails) {
       const defaultExpr = attr.hasDefault ? ` ?? ${attr.defaultValue}` : "";
-      initialProps.push(`${attr.key}: __inputAttrs.${attr.key}${defaultExpr}`);
-    }
-    propsLines.push(`let __props = $state({ ${initialProps.join(", ")} })`);
-    for (const attr of attrDetails) {
-      const defaultExpr = attr.hasDefault ? ` ?? ${attr.defaultValue}` : "";
-      const parentLast = `__last_parent_${attr.key}`;
-      const localLast = `__last_local_${attr.key}`;
-      propsLines.push(`let ${parentLast} = __inputAttrs.${attr.key}`, `let ${localLast} = __props.${attr.key}`, `$effect(() => {
-` + `			const __parent = __inputAttrs.${attr.key}
-` + `			const __local = __props.${attr.key}
-
-` + `			// Parent -> local
-` + `			if (__parent !== ${parentLast}) {
-` + `				${parentLast} = __parent
-` + `				if (__local !== __parent) {
-` + `					__props.${attr.key} = __parent${defaultExpr}
-` + `				}
-` + `				${localLast} = __props.${attr.key}
-` + `				return
-` + `			}
-
-` + `			// Local -> parent
-` + `			if (__local !== ${localLast}) {
-` + `				${localLast} = __local
-` + (attr.bindable ? `				try { __inputAttrs.${attr.key} = __local } catch {}
-				${parentLast} = __inputAttrs.${attr.key}
-` : "") + `			}
-` + `})`);
+      propDefs.push(`get ${attr.key}() { return __inputAttrs.${attr.key}${defaultExpr} }`);
+      propDefs.push(`set ${attr.key}(v) { __inputAttrs.${attr.key} = v }`);
     }
+    propsLines.push(`const __props = { ${propDefs.join(", ")} }`);
   } else {
-    propsLines.push("let __props = $state({ ...__inputAttrs })", "const __syncState = new Map()", `$effect.pre(() => {
-` + `			// Bidirectional sync between __inputAttrs and __props
-` + `			for (const key of Object.keys(__inputAttrs)) {
-` + `				const parentVal = __inputAttrs[key]
-` + `				const localVal = __props[key]
-` + `				const state = __syncState.get(key) ?? { parent: parentVal, local: localVal }
-` + `				__syncState.set(key, state)
-
-` + `				// Parent changed -> update local
-` + `				if (parentVal !== state.parent) {
-` + `					state.parent = parentVal
-` + `					if (localVal !== parentVal) {
-` + `						__props[key] = parentVal
-` + `						state.local = parentVal
-` + `					}
-` + `					continue
-` + `				}
-
-` + `				// Local changed -> update parent (for bindable props)
-` + `				if (localVal !== state.local) {
-` + `					state.local = localVal
-` + `					try { __inputAttrs[key] = localVal } catch {}
-` + `					state.parent = __inputAttrs[key]
-` + `				}
-` + `			}
-` + `		})`);
+    propsLines.push("const __props = __inputAttrs");
   }
   const propsObjectCode = "\t\t" + propsLines.join(`
 		`);
@@ -2282,7 +2232,16 @@ function transformStandaloneAttrsDefinition(content) {
 
 // src/transform/schema.ts
 function parseOriginSchemaFromSource(source, exportName) {
-  const exportPattern = new RegExp(`export\\s+const\\s+${exportName}\\s*=\\s*\\$origin\\s*\\(`, "s");
+  const sourceResult = parseSourceOrigin(source, exportName);
+  if (sourceResult)
+    return sourceResult;
+  const compiledResult = parseCompiledOrigin(source, exportName);
+  if (compiledResult)
+    return compiledResult;
+  return null;
+}
+function parseSourceOrigin(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*\\$origin\\s*\\(`, "s");
   const match = exportPattern.exec(source);
   if (!match)
     return null;
@@ -2318,6 +2277,94 @@ function parseOriginSchemaFromSource(source, exportName) {
   const attrs = parseAttrsContent(attrsContent);
   return { attrs, parentNames };
 }
+function parseCompiledOrigin(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*__createOrigin\\s*\\(\\s*\\{`, "s");
+  const match = exportPattern.exec(source);
+  if (!match)
+    return null;
+  const braceStart = match.index + match[0].length - 1;
+  const braceEnd = findMatchingBracket(source, braceStart, "{", "}");
+  if (braceEnd === -1)
+    return null;
+  const configContent = source.slice(braceStart + 1, braceEnd);
+  const schemaMatch = configContent.match(/__attrSchema\s*:\s*\{/);
+  if (!schemaMatch)
+    return { attrs: [], parentNames: [] };
+  const schemaStart = schemaMatch.index + schemaMatch[0].length - 1;
+  const schemaEnd = findMatchingBracket(configContent, schemaStart, "{", "}");
+  if (schemaEnd === -1)
+    return { attrs: [], parentNames: [] };
+  const schemaContent = configContent.slice(schemaStart + 1, schemaEnd);
+  const attrs = parseCompiledAttrSchema(schemaContent);
+  const parentsMatch = configContent.match(/__parents\s*:\s*\[([^\]]*)\]/);
+  let parentNames = [];
+  if (parentsMatch && parentsMatch[1].trim()) {
+    parentNames = parentsMatch[1].split(",").map((p) => p.trim()).filter((p) => p && /^\w+$/.test(p));
+  }
+  return { attrs, parentNames };
+}
+function parseCompiledAttrSchema(content) {
+  const result = [];
+  let pos = 0;
+  while (pos < content.length) {
+    while (pos < content.length && /[\s,]/.test(content[pos]))
+      pos++;
+    if (pos >= content.length)
+      break;
+    if (content.slice(pos, pos + 2) === "/*") {
+      const endComment = content.indexOf("*/", pos + 2);
+      if (endComment !== -1) {
+        pos = endComment + 2;
+        continue;
+      }
+    }
+    const keyMatch = content.slice(pos).match(/^(\w+)\s*:/);
+    if (!keyMatch)
+      break;
+    const key = keyMatch[1];
+    pos += keyMatch[0].length;
+    while (pos < content.length && /\s/.test(content[pos]))
+      pos++;
+    if (content[pos] !== "{")
+      break;
+    const valueStart = pos;
+    const valueEnd = findMatchingBracket(content, valueStart, "{", "}");
+    if (valueEnd === -1)
+      break;
+    const valueContent = content.slice(valueStart + 1, valueEnd);
+    let defaultValue = "undefined";
+    let bindable = false;
+    let hasDefault = false;
+    const defaultMatch = valueContent.match(/\bdefault\s*:\s*/);
+    if (defaultMatch) {
+      const defaultStart = defaultMatch.index + defaultMatch[0].length;
+      let depth = 0;
+      let i = defaultStart;
+      while (i < valueContent.length) {
+        const char = valueContent[i];
+        if (char === "{" || char === "(" || char === "[")
+          depth++;
+        else if (char === "}" || char === ")" || char === "]")
+          depth--;
+        else if (char === "," && depth === 0)
+          break;
+        i++;
+      }
+      defaultValue = valueContent.slice(defaultStart, i).trim();
+    }
+    const bindableMatch = valueContent.match(/\bbindable\s*:\s*(true|false)/);
+    if (bindableMatch) {
+      bindable = bindableMatch[1] === "true";
+    }
+    const hasDefaultMatch = valueContent.match(/\bhasDefault\s*:\s*(true|false)/);
+    if (hasDefaultMatch) {
+      hasDefault = hasDefaultMatch[1] === "true";
+    }
+    result.push({ key, defaultValue, bindable, hasDefault });
+    pos = valueEnd + 1;
+  }
+  return result;
+}
 function parseAttrsContent(content) {
   const result = [];
   const parts = splitByTopLevelCommas(content);
@@ -3212,6 +3259,108 @@ function resolveImportPath(importPath, aliases, importerDir) {
       return join(aliasPath, remainder);
     }
   }
+  const npmResolved = resolveNpmPackageImport(importPath, importerDir);
+  if (npmResolved) {
+    return npmResolved;
+  }
+  return null;
+}
+function resolveNpmPackageImport(importPath, importerDir) {
+  if (importPath.startsWith(".") || importPath.startsWith("/") || /^[a-zA-Z]:/.test(importPath)) {
+    return null;
+  }
+  let packageName;
+  let subpath;
+  if (importPath.startsWith("@")) {
+    const parts = importPath.split("/");
+    if (parts.length < 2)
+      return null;
+    packageName = `${parts[0]}/${parts[1]}`;
+    subpath = parts.slice(2).join("/");
+  } else {
+    const slashIndex = importPath.indexOf("/");
+    if (slashIndex === -1) {
+      packageName = importPath;
+      subpath = "";
+    } else {
+      packageName = importPath.slice(0, slashIndex);
+      subpath = importPath.slice(slashIndex + 1);
+    }
+  }
+  let currentDir = importerDir;
+  const root = isAbsolute(importerDir) ? (importerDir.match(/^[a-zA-Z]:[/\\]/) || ["/"])[0] : "/";
+  while (currentDir !== root && currentDir !== dirname(currentDir)) {
+    const nodeModulesDir = join(currentDir, "node_modules");
+    const packageDir = join(nodeModulesDir, packageName);
+    if (existsSync(packageDir)) {
+      const packageJsonPath = join(packageDir, "package.json");
+      const exportKey = subpath ? `./${subpath}` : ".";
+      if (existsSync(packageJsonPath)) {
+        try {
+          const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+          if (packageJson.exports) {
+            const resolvedExport = resolvePackageExports(packageJson.exports, exportKey);
+            if (resolvedExport) {
+              return join(packageDir, resolvedExport);
+            }
+          }
+          if (!subpath) {
+            const mainEntry = packageJson.module || packageJson.main || "index.js";
+            return join(packageDir, mainEntry);
+          }
+        } catch {}
+      }
+      if (subpath) {
+        const resolvedSubpath = join(packageDir, subpath);
+        return resolvedSubpath;
+      }
+      return join(packageDir, "index.js");
+    }
+    currentDir = dirname(currentDir);
+  }
+  return null;
+}
+function resolvePackageExports(exports, subpath) {
+  if (typeof exports === "string") {
+    return subpath === "." ? exports : null;
+  }
+  if (typeof exports !== "object" || exports === null) {
+    return null;
+  }
+  const exportEntry = exports[subpath];
+  if (exportEntry) {
+    return resolveExportCondition(exportEntry);
+  }
+  if (subpath === "." && exports["."]) {
+    return resolveExportCondition(exports["."]);
+  }
+  if (subpath === ".") {
+    const resolved = resolveExportCondition(exports);
+    if (resolved)
+      return resolved;
+  }
+  return null;
+}
+function resolveExportCondition(condition) {
+  if (typeof condition === "string") {
+    return condition;
+  }
+  if (typeof condition !== "object" || condition === null) {
+    return null;
+  }
+  const condObj = condition;
+  const preferredConditions = ["svelte", "import", "module", "default", "require"];
+  for (const cond of preferredConditions) {
+    if (cond in condObj) {
+      const value = condObj[cond];
+      if (typeof value === "string") {
+        return value;
+      }
+      const resolved = resolveExportCondition(value);
+      if (resolved)
+        return resolved;
+    }
+  }
   return null;
 }
 function resolveFilePath(basePath) {

package/dist/post-process.js

@@ -2030,65 +2030,15 @@ function transformOriginBody(content, parents = [], attrDetails = [], propName =
   const hasParents = parents.length > 0;
   const propsLines = [];
   if (attrDetails.length > 0) {
-    const initialProps = [];
+    const propDefs = [];
     for (const attr of attrDetails) {
       const defaultExpr = attr.hasDefault ? ` ?? ${attr.defaultValue}` : "";
-      initialProps.push(`${attr.key}: __inputAttrs.${attr.key}${defaultExpr}`);
-    }
-    propsLines.push(`let __props = $state({ ${initialProps.join(", ")} })`);
-    for (const attr of attrDetails) {
-      const defaultExpr = attr.hasDefault ? ` ?? ${attr.defaultValue}` : "";
-      const parentLast = `__last_parent_${attr.key}`;
-      const localLast = `__last_local_${attr.key}`;
-      propsLines.push(`let ${parentLast} = __inputAttrs.${attr.key}`, `let ${localLast} = __props.${attr.key}`, `$effect(() => {
-` + `			const __parent = __inputAttrs.${attr.key}
-` + `			const __local = __props.${attr.key}
-
-` + `			// Parent -> local
-` + `			if (__parent !== ${parentLast}) {
-` + `				${parentLast} = __parent
-` + `				if (__local !== __parent) {
-` + `					__props.${attr.key} = __parent${defaultExpr}
-` + `				}
-` + `				${localLast} = __props.${attr.key}
-` + `				return
-` + `			}
-
-` + `			// Local -> parent
-` + `			if (__local !== ${localLast}) {
-` + `				${localLast} = __local
-` + (attr.bindable ? `				try { __inputAttrs.${attr.key} = __local } catch {}
-				${parentLast} = __inputAttrs.${attr.key}
-` : "") + `			}
-` + `})`);
+      propDefs.push(`get ${attr.key}() { return __inputAttrs.${attr.key}${defaultExpr} }`);
+      propDefs.push(`set ${attr.key}(v) { __inputAttrs.${attr.key} = v }`);
     }
+    propsLines.push(`const __props = { ${propDefs.join(", ")} }`);
   } else {
-    propsLines.push("let __props = $state({ ...__inputAttrs })", "const __syncState = new Map()", `$effect.pre(() => {
-` + `			// Bidirectional sync between __inputAttrs and __props
-` + `			for (const key of Object.keys(__inputAttrs)) {
-` + `				const parentVal = __inputAttrs[key]
-` + `				const localVal = __props[key]
-` + `				const state = __syncState.get(key) ?? { parent: parentVal, local: localVal }
-` + `				__syncState.set(key, state)
-
-` + `				// Parent changed -> update local
-` + `				if (parentVal !== state.parent) {
-` + `					state.parent = parentVal
-` + `					if (localVal !== parentVal) {
-` + `						__props[key] = parentVal
-` + `						state.local = parentVal
-` + `					}
-` + `					continue
-` + `				}
-
-` + `				// Local changed -> update parent (for bindable props)
-` + `				if (localVal !== state.local) {
-` + `					state.local = localVal
-` + `					try { __inputAttrs[key] = localVal } catch {}
-` + `					state.parent = __inputAttrs[key]
-` + `				}
-` + `			}
-` + `		})`);
+    propsLines.push("const __props = __inputAttrs");
   }
   const propsObjectCode = "\t\t" + propsLines.join(`
 		`);
@@ -2286,7 +2236,16 @@ function transformStandaloneAttrsDefinition(content) {
 
 // src/transform/schema.ts
 function parseOriginSchemaFromSource(source, exportName) {
-  const exportPattern = new RegExp(`export\\s+const\\s+${exportName}\\s*=\\s*\\$origin\\s*\\(`, "s");
+  const sourceResult = parseSourceOrigin(source, exportName);
+  if (sourceResult)
+    return sourceResult;
+  const compiledResult = parseCompiledOrigin(source, exportName);
+  if (compiledResult)
+    return compiledResult;
+  return null;
+}
+function parseSourceOrigin(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*\\$origin\\s*\\(`, "s");
   const match = exportPattern.exec(source);
   if (!match)
     return null;
@@ -2322,6 +2281,94 @@ function parseOriginSchemaFromSource(source, exportName) {
   const attrs = parseAttrsContent(attrsContent);
   return { attrs, parentNames };
 }
+function parseCompiledOrigin(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*__createOrigin\\s*\\(\\s*\\{`, "s");
+  const match = exportPattern.exec(source);
+  if (!match)
+    return null;
+  const braceStart = match.index + match[0].length - 1;
+  const braceEnd = findMatchingBracket(source, braceStart, "{", "}");
+  if (braceEnd === -1)
+    return null;
+  const configContent = source.slice(braceStart + 1, braceEnd);
+  const schemaMatch = configContent.match(/__attrSchema\s*:\s*\{/);
+  if (!schemaMatch)
+    return { attrs: [], parentNames: [] };
+  const schemaStart = schemaMatch.index + schemaMatch[0].length - 1;
+  const schemaEnd = findMatchingBracket(configContent, schemaStart, "{", "}");
+  if (schemaEnd === -1)
+    return { attrs: [], parentNames: [] };
+  const schemaContent = configContent.slice(schemaStart + 1, schemaEnd);
+  const attrs = parseCompiledAttrSchema(schemaContent);
+  const parentsMatch = configContent.match(/__parents\s*:\s*\[([^\]]*)\]/);
+  let parentNames = [];
+  if (parentsMatch && parentsMatch[1].trim()) {
+    parentNames = parentsMatch[1].split(",").map((p) => p.trim()).filter((p) => p && /^\w+$/.test(p));
+  }
+  return { attrs, parentNames };
+}
+function parseCompiledAttrSchema(content) {
+  const result = [];
+  let pos = 0;
+  while (pos < content.length) {
+    while (pos < content.length && /[\s,]/.test(content[pos]))
+      pos++;
+    if (pos >= content.length)
+      break;
+    if (content.slice(pos, pos + 2) === "/*") {
+      const endComment = content.indexOf("*/", pos + 2);
+      if (endComment !== -1) {
+        pos = endComment + 2;
+        continue;
+      }
+    }
+    const keyMatch = content.slice(pos).match(/^(\w+)\s*:/);
+    if (!keyMatch)
+      break;
+    const key = keyMatch[1];
+    pos += keyMatch[0].length;
+    while (pos < content.length && /\s/.test(content[pos]))
+      pos++;
+    if (content[pos] !== "{")
+      break;
+    const valueStart = pos;
+    const valueEnd = findMatchingBracket(content, valueStart, "{", "}");
+    if (valueEnd === -1)
+      break;
+    const valueContent = content.slice(valueStart + 1, valueEnd);
+    let defaultValue = "undefined";
+    let bindable = false;
+    let hasDefault = false;
+    const defaultMatch = valueContent.match(/\bdefault\s*:\s*/);
+    if (defaultMatch) {
+      const defaultStart = defaultMatch.index + defaultMatch[0].length;
+      let depth = 0;
+      let i = defaultStart;
+      while (i < valueContent.length) {
+        const char = valueContent[i];
+        if (char === "{" || char === "(" || char === "[")
+          depth++;
+        else if (char === "}" || char === ")" || char === "]")
+          depth--;
+        else if (char === "," && depth === 0)
+          break;
+        i++;
+      }
+      defaultValue = valueContent.slice(defaultStart, i).trim();
+    }
+    const bindableMatch = valueContent.match(/\bbindable\s*:\s*(true|false)/);
+    if (bindableMatch) {
+      bindable = bindableMatch[1] === "true";
+    }
+    const hasDefaultMatch = valueContent.match(/\bhasDefault\s*:\s*(true|false)/);
+    if (hasDefaultMatch) {
+      hasDefault = hasDefaultMatch[1] === "true";
+    }
+    result.push({ key, defaultValue, bindable, hasDefault });
+    pos = valueEnd + 1;
+  }
+  return result;
+}
 function parseAttrsContent(content) {
   const result = [];
   const parts = splitByTopLevelCommas(content);

package/dist/preprocess.js

@@ -2026,65 +2026,15 @@ function transformOriginBody(content, parents = [], attrDetails = [], propName =
   const hasParents = parents.length > 0;
   const propsLines = [];
   if (attrDetails.length > 0) {
-    const initialProps = [];
+    const propDefs = [];
     for (const attr of attrDetails) {
       const defaultExpr = attr.hasDefault ? ` ?? ${attr.defaultValue}` : "";
-      initialProps.push(`${attr.key}: __inputAttrs.${attr.key}${defaultExpr}`);
-    }
-    propsLines.push(`let __props = $state({ ${initialProps.join(", ")} })`);
-    for (const attr of attrDetails) {
-      const defaultExpr = attr.hasDefault ? ` ?? ${attr.defaultValue}` : "";
-      const parentLast = `__last_parent_${attr.key}`;
-      const localLast = `__last_local_${attr.key}`;
-      propsLines.push(`let ${parentLast} = __inputAttrs.${attr.key}`, `let ${localLast} = __props.${attr.key}`, `$effect(() => {
-` + `			const __parent = __inputAttrs.${attr.key}
-` + `			const __local = __props.${attr.key}
-
-` + `			// Parent -> local
-` + `			if (__parent !== ${parentLast}) {
-` + `				${parentLast} = __parent
-` + `				if (__local !== __parent) {
-` + `					__props.${attr.key} = __parent${defaultExpr}
-` + `				}
-` + `				${localLast} = __props.${attr.key}
-` + `				return
-` + `			}
-
-` + `			// Local -> parent
-` + `			if (__local !== ${localLast}) {
-` + `				${localLast} = __local
-` + (attr.bindable ? `				try { __inputAttrs.${attr.key} = __local } catch {}
-				${parentLast} = __inputAttrs.${attr.key}
-` : "") + `			}
-` + `})`);
+      propDefs.push(`get ${attr.key}() { return __inputAttrs.${attr.key}${defaultExpr} }`);
+      propDefs.push(`set ${attr.key}(v) { __inputAttrs.${attr.key} = v }`);
     }
+    propsLines.push(`const __props = { ${propDefs.join(", ")} }`);
   } else {
-    propsLines.push("let __props = $state({ ...__inputAttrs })", "const __syncState = new Map()", `$effect.pre(() => {
-` + `			// Bidirectional sync between __inputAttrs and __props
-` + `			for (const key of Object.keys(__inputAttrs)) {
-` + `				const parentVal = __inputAttrs[key]
-` + `				const localVal = __props[key]
-` + `				const state = __syncState.get(key) ?? { parent: parentVal, local: localVal }
-` + `				__syncState.set(key, state)
-
-` + `				// Parent changed -> update local
-` + `				if (parentVal !== state.parent) {
-` + `					state.parent = parentVal
-` + `					if (localVal !== parentVal) {
-` + `						__props[key] = parentVal
-` + `						state.local = parentVal
-` + `					}
-` + `					continue
-` + `				}
-
-` + `				// Local changed -> update parent (for bindable props)
-` + `				if (localVal !== state.local) {
-` + `					state.local = localVal
-` + `					try { __inputAttrs[key] = localVal } catch {}
-` + `					state.parent = __inputAttrs[key]
-` + `				}
-` + `			}
-` + `		})`);
+    propsLines.push("const __props = __inputAttrs");
   }
   const propsObjectCode = "\t\t" + propsLines.join(`
 		`);
@@ -2282,7 +2232,16 @@ function transformStandaloneAttrsDefinition(content) {
 
 // src/transform/schema.ts
 function parseOriginSchemaFromSource(source, exportName) {
-  const exportPattern = new RegExp(`export\\s+const\\s+${exportName}\\s*=\\s*\\$origin\\s*\\(`, "s");
+  const sourceResult = parseSourceOrigin(source, exportName);
+  if (sourceResult)
+    return sourceResult;
+  const compiledResult = parseCompiledOrigin(source, exportName);
+  if (compiledResult)
+    return compiledResult;
+  return null;
+}
+function parseSourceOrigin(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*\\$origin\\s*\\(`, "s");
   const match = exportPattern.exec(source);
   if (!match)
     return null;
@@ -2318,6 +2277,94 @@ function parseOriginSchemaFromSource(source, exportName) {
   const attrs = parseAttrsContent(attrsContent);
   return { attrs, parentNames };
 }
+function parseCompiledOrigin(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*__createOrigin\\s*\\(\\s*\\{`, "s");
+  const match = exportPattern.exec(source);
+  if (!match)
+    return null;
+  const braceStart = match.index + match[0].length - 1;
+  const braceEnd = findMatchingBracket(source, braceStart, "{", "}");
+  if (braceEnd === -1)
+    return null;
+  const configContent = source.slice(braceStart + 1, braceEnd);
+  const schemaMatch = configContent.match(/__attrSchema\s*:\s*\{/);
+  if (!schemaMatch)
+    return { attrs: [], parentNames: [] };
+  const schemaStart = schemaMatch.index + schemaMatch[0].length - 1;
+  const schemaEnd = findMatchingBracket(configContent, schemaStart, "{", "}");
+  if (schemaEnd === -1)
+    return { attrs: [], parentNames: [] };
+  const schemaContent = configContent.slice(schemaStart + 1, schemaEnd);
+  const attrs = parseCompiledAttrSchema(schemaContent);
+  const parentsMatch = configContent.match(/__parents\s*:\s*\[([^\]]*)\]/);
+  let parentNames = [];
+  if (parentsMatch && parentsMatch[1].trim()) {
+    parentNames = parentsMatch[1].split(",").map((p) => p.trim()).filter((p) => p && /^\w+$/.test(p));
+  }
+  return { attrs, parentNames };
+}
+function parseCompiledAttrSchema(content) {
+  const result = [];
+  let pos = 0;
+  while (pos < content.length) {
+    while (pos < content.length && /[\s,]/.test(content[pos]))
+      pos++;
+    if (pos >= content.length)
+      break;
+    if (content.slice(pos, pos + 2) === "/*") {
+      const endComment = content.indexOf("*/", pos + 2);
+      if (endComment !== -1) {
+        pos = endComment + 2;
+        continue;
+      }
+    }
+    const keyMatch = content.slice(pos).match(/^(\w+)\s*:/);
+    if (!keyMatch)
+      break;
+    const key = keyMatch[1];
+    pos += keyMatch[0].length;
+    while (pos < content.length && /\s/.test(content[pos]))
+      pos++;
+    if (content[pos] !== "{")
+      break;
+    const valueStart = pos;
+    const valueEnd = findMatchingBracket(content, valueStart, "{", "}");
+    if (valueEnd === -1)
+      break;
+    const valueContent = content.slice(valueStart + 1, valueEnd);
+    let defaultValue = "undefined";
+    let bindable = false;
+    let hasDefault = false;
+    const defaultMatch = valueContent.match(/\bdefault\s*:\s*/);
+    if (defaultMatch) {
+      const defaultStart = defaultMatch.index + defaultMatch[0].length;
+      let depth = 0;
+      let i = defaultStart;
+      while (i < valueContent.length) {
+        const char = valueContent[i];
+        if (char === "{" || char === "(" || char === "[")
+          depth++;
+        else if (char === "}" || char === ")" || char === "]")
+          depth--;
+        else if (char === "," && depth === 0)
+          break;
+        i++;
+      }
+      defaultValue = valueContent.slice(defaultStart, i).trim();
+    }
+    const bindableMatch = valueContent.match(/\bbindable\s*:\s*(true|false)/);
+    if (bindableMatch) {
+      bindable = bindableMatch[1] === "true";
+    }
+    const hasDefaultMatch = valueContent.match(/\bhasDefault\s*:\s*(true|false)/);
+    if (hasDefaultMatch) {
+      hasDefault = hasDefaultMatch[1] === "true";
+    }
+    result.push({ key, defaultValue, bindable, hasDefault });
+    pos = valueEnd + 1;
+  }
+  return result;
+}
 function parseAttrsContent(content) {
   const result = [];
   const parts = splitByTopLevelCommas(content);
@@ -3212,6 +3259,108 @@ function resolveImportPath(importPath, aliases, importerDir) {
       return join(aliasPath, remainder);
     }
   }
+  const npmResolved = resolveNpmPackageImport(importPath, importerDir);
+  if (npmResolved) {
+    return npmResolved;
+  }
+  return null;
+}
+function resolveNpmPackageImport(importPath, importerDir) {
+  if (importPath.startsWith(".") || importPath.startsWith("/") || /^[a-zA-Z]:/.test(importPath)) {
+    return null;
+  }
+  let packageName;
+  let subpath;
+  if (importPath.startsWith("@")) {
+    const parts = importPath.split("/");
+    if (parts.length < 2)
+      return null;
+    packageName = `${parts[0]}/${parts[1]}`;
+    subpath = parts.slice(2).join("/");
+  } else {
+    const slashIndex = importPath.indexOf("/");
+    if (slashIndex === -1) {
+      packageName = importPath;
+      subpath = "";
+    } else {
+      packageName = importPath.slice(0, slashIndex);
+      subpath = importPath.slice(slashIndex + 1);
+    }
+  }
+  let currentDir = importerDir;
+  const root = isAbsolute(importerDir) ? (importerDir.match(/^[a-zA-Z]:[/\\]/) || ["/"])[0] : "/";
+  while (currentDir !== root && currentDir !== dirname(currentDir)) {
+    const nodeModulesDir = join(currentDir, "node_modules");
+    const packageDir = join(nodeModulesDir, packageName);
+    if (existsSync(packageDir)) {
+      const packageJsonPath = join(packageDir, "package.json");
+      const exportKey = subpath ? `./${subpath}` : ".";
+      if (existsSync(packageJsonPath)) {
+        try {
+          const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+          if (packageJson.exports) {
+            const resolvedExport = resolvePackageExports(packageJson.exports, exportKey);
+            if (resolvedExport) {
+              return join(packageDir, resolvedExport);
+            }
+          }
+          if (!subpath) {
+            const mainEntry = packageJson.module || packageJson.main || "index.js";
+            return join(packageDir, mainEntry);
+          }
+        } catch {}
+      }
+      if (subpath) {
+        const resolvedSubpath = join(packageDir, subpath);
+        return resolvedSubpath;
+      }
+      return join(packageDir, "index.js");
+    }
+    currentDir = dirname(currentDir);
+  }
+  return null;
+}
+function resolvePackageExports(exports, subpath) {
+  if (typeof exports === "string") {
+    return subpath === "." ? exports : null;
+  }
+  if (typeof exports !== "object" || exports === null) {
+    return null;
+  }
+  const exportEntry = exports[subpath];
+  if (exportEntry) {
+    return resolveExportCondition(exportEntry);
+  }
+  if (subpath === "." && exports["."]) {
+    return resolveExportCondition(exports["."]);
+  }
+  if (subpath === ".") {
+    const resolved = resolveExportCondition(exports);
+    if (resolved)
+      return resolved;
+  }
+  return null;
+}
+function resolveExportCondition(condition) {
+  if (typeof condition === "string") {
+    return condition;
+  }
+  if (typeof condition !== "object" || condition === null) {
+    return null;
+  }
+  const condObj = condition;
+  const preferredConditions = ["svelte", "import", "module", "default", "require"];
+  for (const cond of preferredConditions) {
+    if (cond in condObj) {
+      const value = condObj[cond];
+      if (typeof value === "string") {
+        return value;
+      }
+      const resolved = resolveExportCondition(value);
+      if (resolved)
+        return resolved;
+    }
+  }
   return null;
 }
 function resolveFilePath(basePath) {

package/dist/vite-dts.js

@@ -202,7 +202,16 @@ function findMatchingBracket(source, openIndex, openChar = "(", closeChar = ")")
 
 // src/transform/schema.ts
 function parseOriginSchemaFromSource(source, exportName) {
-  const exportPattern = new RegExp(`export\\s+const\\s+${exportName}\\s*=\\s*\\$origin\\s*\\(`, "s");
+  const sourceResult = parseSourceOrigin(source, exportName);
+  if (sourceResult)
+    return sourceResult;
+  const compiledResult = parseCompiledOrigin(source, exportName);
+  if (compiledResult)
+    return compiledResult;
+  return null;
+}
+function parseSourceOrigin(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*\\$origin\\s*\\(`, "s");
   const match = exportPattern.exec(source);
   if (!match)
     return null;
@@ -238,6 +247,94 @@ function parseOriginSchemaFromSource(source, exportName) {
   const attrs = parseAttrsContent(attrsContent);
   return { attrs, parentNames };
 }
+function parseCompiledOrigin(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*__createOrigin\\s*\\(\\s*\\{`, "s");
+  const match = exportPattern.exec(source);
+  if (!match)
+    return null;
+  const braceStart = match.index + match[0].length - 1;
+  const braceEnd = findMatchingBracket(source, braceStart, "{", "}");
+  if (braceEnd === -1)
+    return null;
+  const configContent = source.slice(braceStart + 1, braceEnd);
+  const schemaMatch = configContent.match(/__attrSchema\s*:\s*\{/);
+  if (!schemaMatch)
+    return { attrs: [], parentNames: [] };
+  const schemaStart = schemaMatch.index + schemaMatch[0].length - 1;
+  const schemaEnd = findMatchingBracket(configContent, schemaStart, "{", "}");
+  if (schemaEnd === -1)
+    return { attrs: [], parentNames: [] };
+  const schemaContent = configContent.slice(schemaStart + 1, schemaEnd);
+  const attrs = parseCompiledAttrSchema(schemaContent);
+  const parentsMatch = configContent.match(/__parents\s*:\s*\[([^\]]*)\]/);
+  let parentNames = [];
+  if (parentsMatch && parentsMatch[1].trim()) {
+    parentNames = parentsMatch[1].split(",").map((p) => p.trim()).filter((p) => p && /^\w+$/.test(p));
+  }
+  return { attrs, parentNames };
+}
+function parseCompiledAttrSchema(content) {
+  const result = [];
+  let pos = 0;
+  while (pos < content.length) {
+    while (pos < content.length && /[\s,]/.test(content[pos]))
+      pos++;
+    if (pos >= content.length)
+      break;
+    if (content.slice(pos, pos + 2) === "/*") {
+      const endComment = content.indexOf("*/", pos + 2);
+      if (endComment !== -1) {
+        pos = endComment + 2;
+        continue;
+      }
+    }
+    const keyMatch = content.slice(pos).match(/^(\w+)\s*:/);
+    if (!keyMatch)
+      break;
+    const key = keyMatch[1];
+    pos += keyMatch[0].length;
+    while (pos < content.length && /\s/.test(content[pos]))
+      pos++;
+    if (content[pos] !== "{")
+      break;
+    const valueStart = pos;
+    const valueEnd = findMatchingBracket(content, valueStart, "{", "}");
+    if (valueEnd === -1)
+      break;
+    const valueContent = content.slice(valueStart + 1, valueEnd);
+    let defaultValue = "undefined";
+    let bindable = false;
+    let hasDefault = false;
+    const defaultMatch = valueContent.match(/\bdefault\s*:\s*/);
+    if (defaultMatch) {
+      const defaultStart = defaultMatch.index + defaultMatch[0].length;
+      let depth = 0;
+      let i = defaultStart;
+      while (i < valueContent.length) {
+        const char = valueContent[i];
+        if (char === "{" || char === "(" || char === "[")
+          depth++;
+        else if (char === "}" || char === ")" || char === "]")
+          depth--;
+        else if (char === "," && depth === 0)
+          break;
+        i++;
+      }
+      defaultValue = valueContent.slice(defaultStart, i).trim();
+    }
+    const bindableMatch = valueContent.match(/\bbindable\s*:\s*(true|false)/);
+    if (bindableMatch) {
+      bindable = bindableMatch[1] === "true";
+    }
+    const hasDefaultMatch = valueContent.match(/\bhasDefault\s*:\s*(true|false)/);
+    if (hasDefaultMatch) {
+      hasDefault = hasDefaultMatch[1] === "true";
+    }
+    result.push({ key, defaultValue, bindable, hasDefault });
+    pos = valueEnd + 1;
+  }
+  return result;
+}
 function parseAttrsContent(content) {
   const result = [];
   const parts = splitByTopLevelCommas(content);

package/package.json

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