@drawcall/market 0.6.11 → 0.6.14

package/src/pack.ts

@@ -3,6 +3,7 @@ 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,
@@ -112,9 +113,9 @@ export function fileManifestForRange(asset: MarketClient['asset']): FetchFileMan
 
     // Oldest first, so a newer version's hash wins when a path recurs across versions.
     const merged: Record<string, string> = {}
-    for (const hashes of await mapWithConcurrency(inRange, 4, (version) =>
-      fileIndexHashes(asset, name, version),
-    )) {
+    for (const hashes of await pMap(inRange, (version) => fileIndexHashes(asset, name, version), {
+      concurrency: 4,
+    })) {
       Object.assign(merged, hashes)
     }
     return merged
@@ -135,22 +136,6 @@ function exactRangeVersion(range: string): string | null {
   return semverSchema.safeParse(candidate).success ? candidate : null
 }
 
-async function mapWithConcurrency<T, R>(
-  items: readonly T[],
-  concurrency: number,
-  fn: (item: T) => Promise<R>,
-): Promise<R[]> {
-  const results = new Array<R>(items.length)
-  let next = 0
-  async function worker(): Promise<void> {
-    for (let index = next++; index < items.length; index = next++) {
-      results[index] = await fn(items[index])
-    }
-  }
-  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, () => worker()))
-  return results
-}
-
 export async function packAsset(zipFilter: string, opts: PackAssetOptions): Promise<PackedAsset> {
   const cwd = opts.cwd ?? process.cwd()
 
@@ -499,12 +484,12 @@ async function withoutInstalledDependencyFiles(
   }
 }
 
-export interface DependencyFile {
+interface DependencyFile {
   name: string
   canonicalPath: string
 }
 
-export interface DependencyFileEntry extends DependencyFile {
+interface DependencyFileEntry extends DependencyFile {
   /** md5 hex of the file's canonical content — its R2 etag, from the file index. */
   hash: string
 }

package/src/package-json.ts

@@ -1,17 +1,18 @@
 import { z } from 'zod'
 import { assetDependencyValueSchema, type AssetDependencies } from './schemas.js'
 
-export interface PackageJson {
-  name?: string
-  private?: boolean
-  dependencies?: Record<string, string>
-  assetDependencies?: AssetDependencies
-  [key: string]: unknown
-}
-
 const stringRecordSchema = z.record(z.string(), z.string())
-
 const assetDependenciesRecordSchema = z.record(z.string(), assetDependencyValueSchema)
+const packageJsonSchema = z
+  .object({
+    name: z.string().optional(),
+    private: z.boolean().optional(),
+    dependencies: stringRecordSchema.optional(),
+    assetDependencies: assetDependenciesRecordSchema.optional(),
+  })
+  .catchall(z.unknown())
+
+export type PackageJson = z.infer<typeof packageJsonSchema>
 
 export function packageJsonAssetDependenciesFromFiles(
   files: Record<string, Uint8Array>,
@@ -48,10 +49,9 @@ export function packageJsonNpmDependenciesFromFiles(
 }
 
 export function parsePackageJson(json: string, source: string): PackageJson {
-  const parsed = JSON.parse(json) as unknown
-  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    throw new Error(`${source} must contain a JSON object`)
+  const parsed = packageJsonSchema.safeParse(JSON.parse(json))
+  if (!parsed.success) {
+    throw new Error(`${source} must contain a valid package.json object`)
   }
-
-  return parsed as PackageJson
+  return parsed.data
 }

package/src/schemas.ts

@@ -111,7 +111,7 @@ export const listAssetsSchema = z.object({
 // An asset's capability key — embedded in file URL paths and in the preview URL's `?key=` query.
 // Accepted by exact reads as an alternative credential to identity, so "sharing an asset" is
 // sharing this one string.
-export const accessKeySchema = z.string().min(1).max(128)
+const accessKeySchema = z.string().min(1).max(128)
 
 export const exactAssetSchema = z.object({
   name: assetNameSchema,
@@ -121,6 +121,15 @@ export const exactAssetSchema = z.object({
   key: accessKeySchema.optional(),
 })
 
+// The refs mode of the collection read: `?refs=name[@version],…` returns exactly those assets —
+// full entries with files and version history — order-preserved, null per miss. Reads are plural
+// by default; a single asset is the plural of one.
+export const assetRefsSchema = z.object({
+  refs: z.string().min(1).max(4000),
+  includeUnapproved: z.boolean().default(false),
+  key: accessKeySchema.optional(),
+})
+
 export const uploadZipSchema = z.object({
   name: assetNameSchema,
   type: assetTypeSchema,
@@ -165,7 +174,7 @@ const MAX_REFERENCE_IMAGE_CHARS = 10_000_000
 // Reference images the generated asset should match, each an http(s) URL or a
 // `data:image/<type>;base64,<data>` URI. Only providers that declare
 // `acceptsReferenceImages` take them, and none takes more than four.
-export const referenceImagesSchema = z
+const referenceImagesSchema = z
   .array(
     z
       .string()

package/src/v1/contract.ts

@@ -16,6 +16,7 @@ import {
   agentStartSchema,
   agentStatusSchema,
   assetFilesSchema,
+  assetRefsSchema,
   assetVersionsSchema,
   exactAssetSchema,
   generateAssetSchema,
@@ -48,6 +49,16 @@ export interface AssetVersionManifest {
   zipUrl: string
 }
 
+/** One entry of the refs read: the version's full manifest plus the asset's version history
+ *  (oldest first), so range selection and multi-version hashing need no further calls. */
+export interface AssetRefEntry extends AssetVersionManifest {
+  versions: string[]
+}
+
+export interface AssetRefsResult {
+  assets: (AssetRefEntry | null)[]
+}
+
 /**
  * The v1 contract: the same procedure tree as the legacy RPC surface (so call sites migrate by
  * swapping only the client), with HTTP routes attached — served as plain REST under `/api/v1`.
@@ -55,10 +66,13 @@ export interface AssetVersionManifest {
  */
 export const contract = {
   asset: {
+    // The one collection read, discriminated by params: `?refs=name[@version],…`
+    // returns exactly those assets (full entries, order-preserved, null per
+    // miss); everything else is a search. Reads are plural by default.
     search: oc
       .route({ method: 'GET', path: '/assets' })
-      .input(listAssetsSchema)
-      .output(z.custom<PaginatedList<AssetSearchResult>>()),
+      .input(z.union([assetRefsSchema, listAssetsSchema]))
+      .output(z.custom<PaginatedList<AssetSearchResult> | AssetRefsResult>()),
 
     exact: oc
       .route({ method: 'GET', path: '/assets/{name}' })

package/src/v1/index.ts

@@ -1,2 +1,8 @@
-export { contract, type V1Contract, type AssetVersionManifest } from './contract.js'
+export {
+  contract,
+  type V1Contract,
+  type AssetVersionManifest,
+  type AssetRefEntry,
+  type AssetRefsResult,
+} from './contract.js'
 export { createClient, type MarketV1Client, type MarketV1ClientOptions } from './client.js'