svelte-origin 1.0.0-next.20 → 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

@@ -2238,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;
@@ -2274,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);

package/dist/plugin.js

@@ -2232,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;
@@ -2268,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);
@@ -3162,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

@@ -2236,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;
@@ -2272,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

@@ -2232,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;
@@ -2268,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);
@@ -3162,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.20",
+	"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",