Skip to main content
Package resolution types are used to retrieve all component and asset data needed to render content. Choose between full resolution (simpler) or reference resolution (efficient caching).

​
ResolvedPackage

Full package data with all resolved dependencies inline. 
type ResolvedPackage {
  package: ResolvedPackageData!
  dependencies: [ResolvedPackageData!]!
}
FieldTypeDescription
packageResolvedPackageData!Main package data
dependencies[ResolvedPackageData!]!All dependency package data
Use when you want all data in a single request: 
query GetContentResolved($id: ID!) {
  content(id: $id) {
    compiled
    resolved {
      package {
        version
        components
        assets
      }
      dependencies {
        version
        components
        assets
      }
    }
  }
}

​
ResolvedPackageRef

Package IDs only, for normalized caching. 
type ResolvedPackageRef {
  package: ID!
  dependencies: [ID!]!
}
FieldTypeDescription
packageID!Main package ID (content-addressed hash)
dependencies[ID!]!Dependency package IDs
Use for efficient caching (smaller payloads): 
query GetContentWithCaching($id: ID!) {
  content(id: $id) {
    compiled
    resolvedRef {
      package
      dependencies
    }
  }
}
Response: 
{
  "data": {
    "content": {
      "compiled": "const body = () => { ... }",
      "resolvedRef": {
        "package": "abc123def456...",
        "dependencies": ["xyz789ghi012..."]
      }
    }
  }
}
Then fetch package data separately using resolvedPackageData.

​
ResolvedPackageData

Package data identified by content-addressed hash. 
type ResolvedPackageData {
  id: ID!
  version: String!
  components: String!
  assets: String!
}
FieldTypeDescription
idID!SHA-256 hash, or draft:{projectId}:{orgId} for drafts
versionString!Semantic version
componentsString!JSON object mapping component names to compiled code
assetsString!JSON object mapping component names to asset arrays

​
Components Field

JSON object with component name as key and compiled code as value: 
{
  "ProductCard": "const body = (props) => { return VStack([...]) }",
  "ArticleLayout": "const body = (props) => { return ScrollView([...]) }"
}

​
Assets Field

JSON object with component name as key and asset array as value: 
{
  "ProductCard": [
    { "name": "placeholder", "url": "https://cdn.metabind.ai/..." }
  ],
  "ArticleLayout": []
}

​
Draft Package IDs

Draft packages use a special ID format instead of a content hash: 
draft:{projectId}:{organizationId}
Example: draft:proj123:org456
Draft packages should not be cached long-term as they change frequently during development.
function isDraftPackage(id) {
  return id.startsWith('draft:');
}

// Only cache published packages
if (!isDraftPackage(packageId)) {
  cache.set(packageId, data);
}

​
Caching Strategy

Content-addressed IDs (SHA-256 hashes) mean published packages never change: 
const packageCache = new Map();

async function getPackageData(id) {
  // Draft packages: always fetch fresh
  if (id.startsWith('draft:')) {
    return await fetchPackageData(id);
  }

  // Published packages: cache forever
  if (packageCache.has(id)) {
    return packageCache.get(id);
  }

  const data = await fetchPackageData(id);
  packageCache.set(id, data);
  return data;
}
  • Package - Package type with resolution fields
  • Content - Content with resolved packages