@drawcall/market 0.6.14 → 0.7.0

package/src/resolve.ts

@@ -11,7 +11,9 @@
 
 import * as semver from 'semver'
 import type { MarketClient } from './client.js'
-import type { AssetExactResult } from './contract.js'
+import type { AssetFileEntry } from './contract.js'
+import { lookupAssets } from './refs.js'
+import type { AssetRefEntry } from './v1/index.js'
 import {
   assetDependencyAlias,
   type AssetDependencyAlias,
@@ -28,6 +30,8 @@ export interface ResolvedAsset {
   npmDependencies: Record<string, string>
   assetDependencies: AssetDependencies
   skillDependencies: Record<string, string>
+  /** The resolved version's file index, carried from resolution so install needs no further reads. */
+  files: AssetFileEntry[]
 }
 
 export interface ResolveResult {
@@ -74,7 +78,7 @@ export async function resolve(
   requests: AssetRequest[],
   opts: { includeUnapproved?: boolean; key?: string } = {},
 ): Promise<ResolveResult> {
-  const metaCache = new Map<string, AssetExactResult>()
+  const metaCache = new Map<string, AssetRefEntry>()
   const includeUnapproved = opts.includeUnapproved ?? false
   let exactPins = exactPinsFor(rootConstraints(requests))
   const seenPinSets = new Set<string>()
@@ -122,7 +126,7 @@ async function resolvePass(
   requests: AssetRequest[],
   initialPins: ExactPins,
   includeUnapproved: boolean,
-  metaCache: Map<string, AssetExactResult>,
+  metaCache: Map<string, AssetRefEntry>,
   key?: string,
 ): Promise<ResolutionPass> {
   const constraints = rootConstraints(requests)
@@ -138,19 +142,34 @@ async function resolvePass(
     const names = [...new Set(wave)].filter((name) => !resolved.has(name))
     wave = []
 
-    const metas = await Promise.all(
-      names.map(async (assetName) => {
-        const constrainedExact = requiredExactVersion(assetName, constraints.get(assetName) ?? [])
-        const exactVersion = constrainedExact ?? initialPins.get(assetName) ?? null
-        return {
-          assetName,
-          exactVersion,
-          meta: await fetchMeta(client, metaCache, assetName, exactVersion, includeUnapproved, key),
-        }
-      }),
-    )
+    const wanted = names.map((assetName) => {
+      const constrainedExact = requiredExactVersion(assetName, constraints.get(assetName) ?? [])
+      const exactVersion = constrainedExact ?? initialPins.get(assetName) ?? null
+      return { assetName, exactVersion }
+    })
 
-    for (const { assetName, exactVersion, meta } of metas) {
+    // One collection read per wave; the cache spans convergence passes, so a
+    // re-pass that pins already-seen versions makes no further requests.
+    const misses = wanted.filter(
+      ({ assetName, exactVersion }) => !metaCache.has(metaKey(assetName, exactVersion)),
+    )
+    const fetched = await lookupAssets(
+      client,
+      misses.map(({ assetName, exactVersion }) => ({
+        name: assetName,
+        version: exactVersion ?? undefined,
+      })),
+      { includeUnapproved, key },
+    )
+    misses.forEach(({ assetName, exactVersion }, index) => {
+      const entry = fetched[index]
+      if (!entry) return
+      metaCache.set(metaKey(assetName, exactVersion), entry)
+      metaCache.set(metaKey(assetName, entry.version), entry)
+    })
+
+    for (const { assetName, exactVersion } of wanted) {
+      const meta = metaCache.get(metaKey(assetName, exactVersion)) ?? null
       if (!meta) {
         if (exactVersion) {
           throw new ResolutionError(
@@ -166,12 +185,13 @@ async function resolvePass(
         throw new ResolutionError(`Asset "${assetName}" has no approved versions.`)
       }
 
-      const selectedVersion = exactVersion
-        ? exactMetadataVersion(meta, assetName, exactVersion)
-        : latestMetadataVersion(meta)
-      // The meta demonstrably answers for this version; caching it under the exact key makes the
-      // convergence re-pass (which pins every asset) resolve without a single further request.
-      metaCache.set(`${assetName}@${selectedVersion}`, meta)
+      if (exactVersion && meta.version !== exactVersion) {
+        throw new ResolutionError(
+          `Market API did not return requested version "${assetName}@${exactVersion}". ` +
+            'Refusing to fall back to a different version.',
+        )
+      }
+      const selectedVersion = meta.version
       const assetDependencies = meta.assetDependencies
       resolved.set(assetName, {
         name: assetName,
@@ -181,6 +201,7 @@ async function resolvePass(
         npmDependencies: meta.npmDependencies,
         assetDependencies,
         skillDependencies: meta.skillDependencies,
+        files: meta.files,
       })
 
       for (const [dependencyName, dependencyValue] of Object.entries(assetDependencies)) {
@@ -293,28 +314,8 @@ function pinSignature(pins: ExactPins): string {
   return JSON.stringify([...pins].sort(([left], [right]) => left.localeCompare(right)))
 }
 
-async function fetchMeta(
-  client: MarketClient['asset'],
-  cache: Map<string, AssetExactResult>,
-  name: string,
-  version: string | null,
-  includeUnapproved: boolean,
-  key?: string,
-): Promise<AssetExactResult | null> {
-  const cacheKey = version ? `${name}@${version}` : name
-  const cached = cache.get(cacheKey)
-  if (cached) return cached
-  // The key is sent with every lookup in the tree; it only unlocks the asset it belongs to and is
-  // inert for the rest, so no per-asset routing is needed.
-  const meta = await client.exact({
-    name,
-    ...(version ? { version } : {}),
-    includeUnapproved,
-    ...(key ? { key } : {}),
-  })
-  if (meta) cache.set(cacheKey, meta)
-  return meta
-}
+const metaKey = (name: string, version: string | null): string =>
+  version ? `${name}@${version}` : name
 
 function requiredExactVersion(assetName: string, constraints: Constraint[]): string | null {
   const exactVersions = new Set(
@@ -335,24 +336,6 @@ function exactVersion(range: string): string | null {
   return semverSchema.safeParse(candidate).success ? candidate : null
 }
 
-function exactMetadataVersion(
-  meta: AssetExactResult,
-  assetName: string,
-  requestedVersion: string,
-): string {
-  if (meta.version === requestedVersion) return meta.version
-  throw new ResolutionError(
-    `Market API did not return requested version "${assetName}@${requestedVersion}". ` +
-      'Refusing to fall back to a different version.',
-  )
-}
-
-function latestMetadataVersion(meta: AssetExactResult): string {
-  // Older workers do not return `version`. Range requests can retain their established latest-
-  // version behavior; exact requests instead fail closed in exactMetadataVersion above.
-  return meta.version ?? meta.latestVersion
-}
-
 /**
  * Merge npm dependency ranges from all resolved assets.
  * For each package, check that all declared ranges are compatible

package/src/v1/contract.ts

@@ -38,6 +38,7 @@ export interface AssetVersionManifest {
   name: string
   type: string
   version: string
+  ownerId: string
   description: string | null
   approved: boolean
   access: 'public' | 'private'