@drawcall/market 0.6.14 → 0.7.1

package/src/pack.ts

@@ -3,7 +3,6 @@ import * as fs from 'fs/promises'
 import * as path from 'path'
 import { unzipSync, zipSync } from 'fflate'
 import ignore from 'ignore'
-import pMap from 'p-map'
 import semver from 'semver'
 import {
   ALWAYS_IGNORED_DIRS,
@@ -14,6 +13,7 @@ import {
   type GitignoreMatcher,
 } from './project-walk.js'
 import type { MarketClient } from './client.js'
+import { lookupAssets } from './refs.js'
 import type { AssetInstallMetadata } from './contract.js'
 import {
   packageJsonAssetDependencies,
@@ -102,35 +102,29 @@ const MANIFEST_VERSION_CAP = 20
 export function fileManifestForRange(asset: MarketClient['asset']): FetchFileManifest {
   return async (name, range) => {
     const exact = exactRangeVersion(range)
-    if (exact) return fileIndexHashes(asset, name, exact)
-
-    const { versions } = await asset.versions({ name })
-    const inRange = versions
-      .map((entry) => entry.version)
-      .filter((version) => semver.satisfies(version, range))
-      .sort(semver.compare)
-      .slice(-MANIFEST_VERSION_CAP)
+    const inRange = exact
+      ? [exact]
+      : ((await lookupAssets(asset, [{ name }]))[0]?.versions ?? [])
+          .filter((version) => semver.satisfies(version, range))
+          .sort(semver.compare)
+          .slice(-MANIFEST_VERSION_CAP)
 
     // Oldest first, so a newer version's hash wins when a path recurs across versions.
+    const entries = await lookupAssets(
+      asset,
+      inRange.map((version) => ({ name, version })),
+    )
     const merged: Record<string, string> = {}
-    for (const hashes of await pMap(inRange, (version) => fileIndexHashes(asset, name, version), {
-      concurrency: 4,
-    })) {
-      Object.assign(merged, hashes)
+    for (const entry of entries) {
+      Object.assign(
+        merged,
+        Object.fromEntries((entry?.files ?? []).map((file) => [file.path, file.etag])),
+      )
     }
     return merged
   }
 }
 
-async function fileIndexHashes(
-  asset: MarketClient['asset'],
-  name: string,
-  version: string,
-): Promise<Record<string, string>> {
-  const index = await asset.files({ name, version })
-  return Object.fromEntries(index.files.map((file) => [file.path, file.etag]))
-}
-
 function exactRangeVersion(range: string): string | null {
   const candidate = range.trim().replace(/^=/u, '')
   return semverSchema.safeParse(candidate).success ? candidate : null

package/src/refs.ts

@@ -0,0 +1,44 @@
+import type { MarketClient } from './client.js'
+import type { AssetRefEntry } from './v1/index.js'
+
+export interface AssetRef {
+  name: string
+  version?: string
+}
+
+/** The one call the refs read needs — lets tests fake a single function. */
+export interface RefsReader {
+  search: MarketClient['asset']['search']
+}
+
+/** The server accepts up to 100 refs per read; larger sets chunk transparently. */
+const MAX_REFS_PER_CALL = 100
+
+/**
+ * The collection read in refs mode: full entries (metadata, version history,
+ * files with data-plane URLs) for exactly the given refs — order-preserved,
+ * null per miss. Version omitted resolves to the latest visible version.
+ */
+export async function lookupAssets(
+  asset: RefsReader,
+  refs: AssetRef[],
+  opts: { includeUnapproved?: boolean; key?: string } = {},
+): Promise<(AssetRefEntry | null)[]> {
+  const chunks: AssetRef[][] = []
+  for (let i = 0; i < refs.length; i += MAX_REFS_PER_CALL) {
+    chunks.push(refs.slice(i, i + MAX_REFS_PER_CALL))
+  }
+
+  const results = await Promise.all(
+    chunks.map(async (chunk) => {
+      const result = await asset.search({
+        refs: chunk.map((ref) => (ref.version ? `${ref.name}@${ref.version}` : ref.name)).join(','),
+        includeUnapproved: opts.includeUnapproved ?? false,
+        ...(opts.key ? { key: opts.key } : {}),
+      })
+      if (!('assets' in result)) throw new Error('refs read unexpectedly returned a search result')
+      return result.assets
+    }),
+  )
+  return results.flat()
+}

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'