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

package/dist/preprocess.js

@@ -1969,6 +1969,7 @@ function transformOriginDefinition(content, svelteImports) {
   let attrsContent = "";
   let contentWithoutAttrs = bodyContent;
   let attrPropertyName = "props";
+  let propsRef = null;
   if (attrsMatch) {
     attrPropertyName = attrsMatch[1];
     const attrsStart = attrsMatch.index;
@@ -1999,13 +2000,31 @@ function transformOriginDefinition(content, svelteImports) {
       }
       contentWithoutAttrs = bodyContent.slice(0, attrsStart) + bodyContent.slice(cutEnd);
     }
+  } else {
+    const externalRefMatch = bodyContent.match(/(\w+)\s*:\s*(\w+)\s*,/);
+    if (externalRefMatch) {
+      const propName = externalRefMatch[1];
+      const refName = externalRefMatch[2];
+      if ((propName === "props" || propName === "attrs") && /^[A-Z]/.test(refName) && !["$state", "$derived", "$effect", "$bindable"].includes(refName)) {
+        attrPropertyName = propName;
+        propsRef = refName;
+        const refStart = externalRefMatch.index;
+        const refEnd = refStart + externalRefMatch[0].length;
+        contentWithoutAttrs = bodyContent.slice(0, refStart) + bodyContent.slice(refEnd);
+      }
+    }
   }
   const attrDetails = parseAttrsSource(attrsContent);
   const { body: createFnBody, attachments } = transformOriginBody(contentWithoutAttrs.trim(), parents, attrDetails, attrPropertyName, svelteImports);
   const parentsCode = parents.length > 0 ? `[${parents.join(", ")}]` : "undefined";
   let configCode = `{
 	__attrSchema: ${attrSchemaCode},
-	__parents: ${parentsCode},
+	__parents: ${parentsCode},`;
+  if (propsRef) {
+    configCode += `
+	__propsRef: ${propsRef},`;
+  }
+  configCode += `
 	__create: (__inputAttrs${parents.length > 0 ? ", __super" : ""}) => {
 ${createFnBody}
 	}`;
@@ -2232,7 +2251,83 @@ 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 parseAttrsSchemaFromSource(source, exportName) {
+  const sourceResult = parseSourceAttrs(source, exportName);
+  if (sourceResult)
+    return sourceResult;
+  const compiledResult = parseCompiledAttrs(source, exportName);
+  if (compiledResult)
+    return compiledResult;
+  return null;
+}
+function parseSourceAttrs(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*\\$attrs\\s*\\(`, "s");
+  const match = exportPattern.exec(source);
+  if (!match)
+    return null;
+  const attrsStart = match.index + match[0].length - 1;
+  const attrsEnd = findMatchingBracket(source, attrsStart);
+  if (attrsEnd === -1)
+    return null;
+  let attrsContent = source.slice(attrsStart + 1, attrsEnd).trim();
+  let parentNames = [];
+  if (attrsContent.startsWith("[")) {
+    const closeBracket = findMatchingBracket(attrsContent, 0, "[", "]");
+    if (closeBracket !== -1) {
+      const parentsContent = attrsContent.slice(1, closeBracket);
+      parentNames = parentsContent.split(",").map((p) => p.trim()).filter((p) => p && /^\w+$/.test(p));
+      let i = closeBracket + 1;
+      while (i < attrsContent.length && /[\s,]/.test(attrsContent[i]))
+        i++;
+      attrsContent = attrsContent.slice(i);
+    }
+  }
+  if (!attrsContent.startsWith("{")) {
+    return { attrs: [], parentNames };
+  }
+  const objEnd = findMatchingBracket(attrsContent, 0, "{", "}");
+  if (objEnd === -1)
+    return { attrs: [], parentNames };
+  const objContent = attrsContent.slice(1, objEnd);
+  const attrs = parseAttrsContent(objContent);
+  return { attrs, parentNames };
+}
+function parseCompiledAttrs(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*__createAttrs\\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 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;
@@ -2256,6 +2351,13 @@ function parseOriginSchemaFromSource(source, exportName) {
   }
   const attrsMatch = bodyContent.match(/(\w+)\s*:\s*\$attrs\s*\(\s*\{/);
   if (!attrsMatch) {
+    const externalRefMatch = bodyContent.match(/(?:props|attrs)\s*:\s*([A-Z]\w*)\b/);
+    if (externalRefMatch) {
+      const propsRef = externalRefMatch[1];
+      if (!["Object", "Array", "String", "Number", "Boolean"].includes(propsRef)) {
+        return { attrs: [], parentNames, propsRef };
+      }
+    }
     return { attrs: [], parentNames };
   }
   const attrsStart = attrsMatch.index;
@@ -2268,6 +2370,96 @@ 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));
+  }
+  const propsRefMatch = configContent.match(/__propsRef\s*:\s*(\w+)/);
+  const propsRef = propsRefMatch ? propsRefMatch[1] : undefined;
+  return { attrs, parentNames, propsRef };
+}
+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 +3354,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) {
@@ -3269,6 +3563,25 @@ async function resolveSchema(importPath, exportName, importerId, cache, debug, a
         }
       }
     }
+    if (schema.propsRef) {
+      const propsRefImportPath = findImportPath(source, schema.propsRef);
+      if (propsRefImportPath) {
+        if (debug) {
+          console.log(`[svelte-origin-preprocess] Resolving propsRef: ${schema.propsRef} from ${propsRefImportPath}`);
+        }
+        const propsRefSchema = await resolveAttrsSchema(propsRefImportPath, schema.propsRef, filePath, cache, debug, aliases);
+        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;
+            }
+          }
+        }
+      }
+    }
     for (const attr of schema.attrs) {
       const existingIndex = mergedAttrs.findIndex((a) => a.key === attr.key);
       if (existingIndex !== -1) {
@@ -3294,6 +3607,75 @@ async function resolveSchema(importPath, exportName, importerId, cache, debug, a
     return null;
   }
 }
+async function resolveAttrsSchema(importPath, exportName, importerId, cache, debug, aliases) {
+  const cacheKey = `attrs::${importPath}::${exportName}`;
+  if (cache.has(cacheKey)) {
+    if (debug) {
+      console.log(`[svelte-origin-preprocess] Cache hit for ${cacheKey}`);
+    }
+    return cache.get(cacheKey) || null;
+  }
+  try {
+    const importerDir = dirname2(importerId);
+    if (debug) {
+      console.log(`[svelte-origin-preprocess] Resolving attrs: ${exportName} from ${importPath}`);
+    }
+    const resolvedPath = resolveImportPath(importPath, aliases, importerDir);
+    if (!resolvedPath) {
+      cache.set(cacheKey, null);
+      return null;
+    }
+    const filePath = resolveFilePath(resolvedPath);
+    if (!filePath) {
+      cache.set(cacheKey, null);
+      return null;
+    }
+    const source = readFileSync2(filePath, "utf-8");
+    const schema = parseAttrsSchemaFromSource(source, exportName);
+    if (!schema) {
+      cache.set(cacheKey, null);
+      return null;
+    }
+    const mergedAttrs = [];
+    for (const parentName of schema.parentNames) {
+      const parentImportPath = findImportPath(source, parentName);
+      if (parentImportPath) {
+        const parentSchema = await resolveAttrsSchema(parentImportPath, parentName, filePath, cache, debug, aliases);
+        if (parentSchema) {
+          for (const attr of parentSchema.attrs) {
+            const existingIndex = mergedAttrs.findIndex((a) => a.key === attr.key);
+            if (existingIndex === -1) {
+              mergedAttrs.push(attr);
+            }
+          }
+        }
+      }
+    }
+    for (const attr of schema.attrs) {
+      const existingIndex = mergedAttrs.findIndex((a) => a.key === attr.key);
+      if (existingIndex !== -1) {
+        mergedAttrs[existingIndex] = attr;
+      } else {
+        mergedAttrs.push(attr);
+      }
+    }
+    const mergedSchema = {
+      attrs: mergedAttrs,
+      parentNames: schema.parentNames
+    };
+    if (debug) {
+      console.log(`[svelte-origin-preprocess] Resolved attrs schema for ${exportName}:`, mergedSchema.attrs.map((a) => a.key));
+    }
+    cache.set(cacheKey, mergedSchema);
+    return mergedSchema;
+  } catch (error) {
+    if (debug) {
+      console.error(`[svelte-origin-preprocess] Error resolving attrs schema for ${importPath}:`, error);
+    }
+    cache.set(cacheKey, null);
+    return null;
+  }
+}
 function svelteOriginPreprocess(options = {}) {
   const {
     debug = false,

package/dist/transform/schema.d.ts

@@ -19,6 +19,8 @@ export interface ParsedAttrInfo {
 export interface ParsedOriginSchema {
     attrs: ParsedAttrInfo[];
     parentNames: string[];
+    /** Reference to external $attrs factory (e.g., 'TextAttrs' when props: TextAttrs is used) */
+    propsRef?: string;
 }
 /**
  * Parse an origin's schema from its source code.
@@ -40,6 +42,21 @@ export interface ParsedOriginSchema {
  * @returns Parsed schema or null if not found
  */
 export declare function parseOriginSchemaFromSource(source: string, exportName: string): ParsedOriginSchema | null;
+/**
+ * Parse an $attrs factory's schema from its source code.
+ *
+ * Looks for patterns like:
+ * ```ts
+ * export const TextAttrs = $attrs({ ... })
+ * export const TextAttrs = $attrs([BaseAttrs], { ... })
+ * ```
+ *
+ * Or compiled:
+ * ```js
+ * export var TextAttrs = __createAttrs({ __attrSchema: {...}, __parents: [...] })
+ * ```
+ */
+export declare function parseAttrsSchemaFromSource(source: string, exportName: string): ParsedOriginSchema | null;
 /**
  * Generate $props() destructuring code from parsed attrs
  *

package/dist/vite-dts.js

@@ -202,7 +202,83 @@ 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 parseAttrsSchemaFromSource(source, exportName) {
+  const sourceResult = parseSourceAttrs(source, exportName);
+  if (sourceResult)
+    return sourceResult;
+  const compiledResult = parseCompiledAttrs(source, exportName);
+  if (compiledResult)
+    return compiledResult;
+  return null;
+}
+function parseSourceAttrs(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*\\$attrs\\s*\\(`, "s");
+  const match = exportPattern.exec(source);
+  if (!match)
+    return null;
+  const attrsStart = match.index + match[0].length - 1;
+  const attrsEnd = findMatchingBracket(source, attrsStart);
+  if (attrsEnd === -1)
+    return null;
+  let attrsContent = source.slice(attrsStart + 1, attrsEnd).trim();
+  let parentNames = [];
+  if (attrsContent.startsWith("[")) {
+    const closeBracket = findMatchingBracket(attrsContent, 0, "[", "]");
+    if (closeBracket !== -1) {
+      const parentsContent = attrsContent.slice(1, closeBracket);
+      parentNames = parentsContent.split(",").map((p) => p.trim()).filter((p) => p && /^\w+$/.test(p));
+      let i = closeBracket + 1;
+      while (i < attrsContent.length && /[\s,]/.test(attrsContent[i]))
+        i++;
+      attrsContent = attrsContent.slice(i);
+    }
+  }
+  if (!attrsContent.startsWith("{")) {
+    return { attrs: [], parentNames };
+  }
+  const objEnd = findMatchingBracket(attrsContent, 0, "{", "}");
+  if (objEnd === -1)
+    return { attrs: [], parentNames };
+  const objContent = attrsContent.slice(1, objEnd);
+  const attrs = parseAttrsContent(objContent);
+  return { attrs, parentNames };
+}
+function parseCompiledAttrs(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+(?:const|var|let)\\s+${exportName}\\s*=\\s*__createAttrs\\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 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;
@@ -226,6 +302,13 @@ function parseOriginSchemaFromSource(source, exportName) {
   }
   const attrsMatch = bodyContent.match(/(\w+)\s*:\s*\$attrs\s*\(\s*\{/);
   if (!attrsMatch) {
+    const externalRefMatch = bodyContent.match(/(?:props|attrs)\s*:\s*([A-Z]\w*)\b/);
+    if (externalRefMatch) {
+      const propsRef = externalRefMatch[1];
+      if (!["Object", "Array", "String", "Number", "Boolean"].includes(propsRef)) {
+        return { attrs: [], parentNames, propsRef };
+      }
+    }
     return { attrs: [], parentNames };
   }
   const attrsStart = attrsMatch.index;
@@ -238,6 +321,96 @@ 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));
+  }
+  const propsRefMatch = configContent.match(/__propsRef\s*:\s*(\w+)/);
+  const propsRef = propsRefMatch ? propsRefMatch[1] : undefined;
+  return { attrs, parentNames, propsRef };
+}
+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.22",
 	"description": "Compiler-assisted state and prop ergonomics for Svelte 5",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",