@drawcall/market 0.1.0

package/src/index.ts

@@ -0,0 +1,46 @@
+// Client
+export { createMarketClient, createInternalClient } from './client.js'
+export type { MarketClient, InternalClient, MarketClientOptions } from './client.js'
+
+// Contracts
+export { contract } from './contract.js'
+export type { AppContract } from './contract.js'
+export { internalContract } from './internal-contract.js'
+export type { InternalContract } from './internal-contract.js'
+
+// Contract output types
+export type {
+  Asset,
+  AssetVersion,
+  AssetWithVersionsAndTags,
+  AssetWithVersions,
+  AssetListItem,
+  PaginatedList,
+  User,
+  UnapprovedItem,
+  TagWithCount,
+  FileTreeEntry,
+} from './contract.js'
+
+// Resolve
+export { resolve, ResolutionError } from './resolve.js'
+export type { ResolvedAsset, ResolveResult } from './resolve.js'
+
+// Schemas
+export {
+  ASSET_TYPES,
+  assetTypeSchema,
+  semverSchema,
+  assetNameSchema,
+  npmDependenciesSchema,
+  assetDependenciesSchema,
+  uploadGenericSchema,
+  uploadTypedSchema,
+  uploadMaterialSchema,
+  updateProfileSchema,
+  listAssetsSchema,
+} from './schemas.js'
+export type { AssetType } from './schemas.js'
+
+// Constants
+export { MAX_FILE_SIZE, ALLOWED_EXTENSIONS, ASSET_TYPE_LABELS } from './constants.js'

package/src/install.ts

@@ -0,0 +1,101 @@
+/**
+ * Install resolved assets into a local project.
+ *
+ * 1. Downloads asset files into ./src/{assetName}/ via the oRPC client.
+ * 2. Merges npm dependencies into package.json.
+ * 3. Runs the package manager to install npm deps.
+ *
+ * NOTE: This module uses Node.js APIs (fs, path, nypm) and is only
+ * used by the CLI binary — it is NOT exported from the package index.
+ */
+
+import * as fs from 'fs/promises'
+import * as path from 'path'
+import { detectPackageManager, installDependencies } from 'nypm'
+import type { MarketClient } from './client.js'
+import type { ResolveResult } from './resolve.js'
+
+export interface InstallOptions {
+  /** Project root directory (default: cwd) */
+  cwd?: string
+  /** Log progress */
+  onProgress?: (message: string) => void
+}
+
+export async function install(
+  client: MarketClient,
+  resolution: ResolveResult,
+  opts: InstallOptions = {},
+): Promise<void> {
+  const cwd = opts.cwd ?? process.cwd()
+  const log = opts.onProgress ?? (() => {})
+
+  // Run asset file downloads and npm dep installation in parallel
+  await Promise.all([
+    downloadAssets(client, resolution, cwd, log),
+    installNpmDeps(resolution, cwd, log),
+  ])
+}
+
+async function downloadAssets(
+  client: MarketClient,
+  resolution: ResolveResult,
+  cwd: string,
+  log: (msg: string) => void,
+): Promise<void> {
+  for (const asset of resolution.assets) {
+    const destDir = path.join(cwd, 'src', asset.name)
+    await fs.mkdir(destDir, { recursive: true })
+
+    log(`Downloading ${asset.name}@${asset.version}...`)
+
+    const tree = await client.asset.getVersionTree({ name: asset.name, version: asset.version })
+
+    for (const file of tree) {
+      const filePath = path.join(destDir, file.path)
+      await fs.mkdir(path.dirname(filePath), { recursive: true })
+
+      const blob = await client.asset.getRawFile({
+        name: asset.name,
+        version: asset.version,
+        path: file.path,
+      })
+      const content = Buffer.from(await blob.arrayBuffer())
+      await fs.writeFile(filePath, content)
+    }
+
+    log(`  ${tree.length} files → src/${asset.name}/`)
+  }
+}
+
+async function installNpmDeps(
+  resolution: ResolveResult,
+  cwd: string,
+  log: (msg: string) => void,
+): Promise<void> {
+  const deps = resolution.npmDependencies
+  if (Object.keys(deps).length === 0) return
+
+  // Read existing package.json
+  const pkgPath = path.join(cwd, 'package.json')
+  let pkg: any
+  try {
+    pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'))
+  } catch {
+    pkg = { name: 'my-project', private: true, dependencies: {} }
+  }
+
+  // Merge dependencies
+  pkg.dependencies = { ...pkg.dependencies, ...deps }
+  await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
+
+  log(`Installing npm dependencies: ${Object.keys(deps).join(', ')}`)
+
+  // Detect package manager, fall back to npm
+  const pm = await detectPackageManager(cwd).catch(() => null)
+  const pmName = pm?.name ?? 'npm'
+
+  log(`Using ${pmName}...`)
+  await installDependencies({ cwd, packageManager: { name: pmName, command: pmName } })
+  log('npm dependencies installed.')
+}

package/src/internal-contract.ts

@@ -0,0 +1,26 @@
+import { oc } from '@orpc/contract'
+import { z } from 'zod'
+
+export const internalContract = {
+  buildUpload: oc
+    .input(
+      z.object({
+        key: z.string(),
+        content: z.string(), // base64-encoded
+        contentType: z.string(),
+      }),
+    )
+    .output(z.object({ ok: z.boolean() })),
+
+  buildComplete: oc
+    .input(
+      z.object({
+        assetName: z.string(),
+        version: z.string(),
+        buildOutputKey: z.string(),
+      }),
+    )
+    .output(z.object({ ok: z.boolean() })),
+}
+
+export type InternalContract = typeof internalContract

package/src/resolve.ts

@@ -0,0 +1,215 @@
+/**
+ * Dependency resolver for market assets.
+ *
+ * 1. Collects the target assets and all transitive asset dependencies.
+ * 2. For each asset, finds a version that satisfies ALL constraints from
+ *    every dependent.
+ * 3. Merges npm dependency ranges across all resolved assets and checks
+ *    that they are compatible.
+ */
+
+import * as semver from 'semver'
+import type { MarketClient } from './client.js'
+import type { AssetWithVersionsAndTags } from './contract.js'
+
+export interface ResolvedAsset {
+  name: string
+  version: string
+  npmDependencies: Record<string, string>
+  assetDependencies: Record<string, string>
+}
+
+export interface ResolveResult {
+  assets: ResolvedAsset[]
+  npmDependencies: Record<string, string>
+}
+
+interface AssetRequest {
+  name: string
+  range: string // semver range, e.g. "^1.0.0" or "*"
+}
+
+export class ResolutionError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'ResolutionError'
+  }
+}
+
+export async function resolve(
+  client: MarketClient['asset'],
+  requests: AssetRequest[],
+  opts: { includeUnapproved?: boolean } = {},
+): Promise<ResolveResult> {
+  // constraints[assetName] = list of { range, from } constraints
+  const constraints: Map<string, { range: string; from: string }[]> = new Map()
+  // resolved[assetName] = ResolvedAsset
+  const resolved: Map<string, ResolvedAsset> = new Map()
+  // cache of fetched metadata
+  const metaCache: Map<string, AssetWithVersionsAndTags> = new Map()
+
+  // Seed constraints from the requested assets
+  for (const req of requests) {
+    addConstraint(constraints, req.name, req.range, '<root>')
+  }
+
+  // Iteratively resolve until stable
+  let unresolved = getUnresolved(constraints, resolved)
+  while (unresolved.length > 0) {
+    for (const assetName of unresolved) {
+      const meta = await fetchMeta(client, metaCache, assetName)
+      if (!meta) {
+        throw new ResolutionError(`Asset "${assetName}" not found.`)
+      }
+
+      // Filter to approved versions (unless --unapproved)
+      const candidates = meta.versions.filter((v) => opts.includeUnapproved || v.approved)
+
+      if (candidates.length === 0) {
+        throw new ResolutionError(
+          `Asset "${assetName}" has no ${opts.includeUnapproved ? '' : 'approved '}versions.`,
+        )
+      }
+
+      // Collect all constraints for this asset
+      const assetConstraints = constraints.get(assetName) ?? []
+
+      // Find the best (highest) version that satisfies ALL constraints
+      const candidateVersions = candidates.map((c) => c.version)
+      const satisfying = candidateVersions.filter((v) =>
+        assetConstraints.every((c) => semver.satisfies(v, c.range)),
+      )
+
+      if (satisfying.length === 0) {
+        const constraintDesc = assetConstraints
+          .map((c) => `  ${c.range} (from ${c.from})`)
+          .join('\n')
+        throw new ResolutionError(
+          `No version of "${assetName}" satisfies all constraints:\n${constraintDesc}\n` +
+            `Available${opts.includeUnapproved ? '' : ' approved'}: ${candidateVersions.join(', ')}`,
+        )
+      }
+
+      const best = semver.maxSatisfying(satisfying, '*')!
+      const versionMeta = candidates.find((c) => c.version === best)!
+
+      const npmDeps: Record<string, string> = JSON.parse(versionMeta.npmDependencies)
+      const assetDeps: Record<string, string> = JSON.parse(versionMeta.assetDependencies)
+
+      resolved.set(assetName, {
+        name: assetName,
+        version: best,
+        npmDependencies: npmDeps,
+        assetDependencies: assetDeps,
+      })
+
+      // Add transitive asset dependency constraints
+      for (const [depName, depRange] of Object.entries(assetDeps)) {
+        addConstraint(constraints, depName, depRange, `${assetName}@${best}`)
+      }
+    }
+
+    unresolved = getUnresolved(constraints, resolved)
+  }
+
+  // Verify all resolved versions still satisfy constraints (transitive deps
+  // may have added new constraints after we resolved a version)
+  for (const [assetName, asset] of resolved) {
+    const assetConstraints = constraints.get(assetName) ?? []
+    for (const c of assetConstraints) {
+      if (!semver.satisfies(asset.version, c.range)) {
+        throw new ResolutionError(
+          `Conflict: "${assetName}@${asset.version}" does not satisfy ` +
+            `${c.range} (required by ${c.from}).`,
+        )
+      }
+    }
+  }
+
+  // Merge npm dependencies across all resolved assets
+  const mergedNpm = mergeNpmDependencies(Array.from(resolved.values()))
+
+  return {
+    assets: Array.from(resolved.values()),
+    npmDependencies: mergedNpm,
+  }
+}
+
+function addConstraint(
+  constraints: Map<string, { range: string; from: string }[]>,
+  name: string,
+  range: string,
+  from: string,
+) {
+  const existing = constraints.get(name) ?? []
+  existing.push({ range, from })
+  constraints.set(name, existing)
+}
+
+function getUnresolved(
+  constraints: Map<string, { range: string; from: string }[]>,
+  resolved: Map<string, ResolvedAsset>,
+): string[] {
+  return Array.from(constraints.keys()).filter((name) => !resolved.has(name))
+}
+
+async function fetchMeta(
+  client: MarketClient['asset'],
+  cache: Map<string, AssetWithVersionsAndTags>,
+  name: string,
+): Promise<AssetWithVersionsAndTags | null> {
+  if (cache.has(name)) return cache.get(name)!
+  const meta = await client.getByName({ name })
+  if (meta) cache.set(name, meta)
+  return meta
+}
+
+/**
+ * Merge npm dependency ranges from all resolved assets.
+ * For each package, check that all declared ranges are compatible
+ * (using semver.intersects). Return the narrowest range.
+ */
+function mergeNpmDependencies(assets: ResolvedAsset[]): Record<string, string> {
+  // Collect all ranges per package
+  const rangesPerPkg: Map<string, { range: string; from: string }[]> = new Map()
+
+  for (const asset of assets) {
+    for (const [pkg, range] of Object.entries(asset.npmDependencies)) {
+      const existing = rangesPerPkg.get(pkg) ?? []
+      existing.push({ range, from: `${asset.name}@${asset.version}` })
+      rangesPerPkg.set(pkg, existing)
+    }
+  }
+
+  const merged: Record<string, string> = {}
+
+  for (const [pkg, ranges] of rangesPerPkg) {
+    // Check pairwise compatibility
+    for (let i = 0; i < ranges.length; i++) {
+      for (let j = i + 1; j < ranges.length; j++) {
+        if (!semver.intersects(ranges[i].range, ranges[j].range)) {
+          throw new ResolutionError(
+            `npm dependency conflict for "${pkg}":\n` +
+              `  ${ranges[i].range} (from ${ranges[i].from})\n` +
+              `  ${ranges[j].range} (from ${ranges[j].from})`,
+          )
+        }
+      }
+    }
+
+    // Use the narrowest (most constrained) range.
+    // Simple heuristic: pick the range with the highest minimum version.
+    let narrowest = ranges[0].range
+    for (const r of ranges.slice(1)) {
+      const minCurrent = semver.minVersion(narrowest)
+      const minNew = semver.minVersion(r.range)
+      if (minCurrent && minNew && semver.gt(minNew, minCurrent)) {
+        narrowest = r.range
+      }
+    }
+
+    merged[pkg] = narrowest
+  }
+
+  return merged
+}

package/src/schemas.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod'
+
+export const ASSET_TYPES = ['generic', 'model', 'hdri', 'material', 'music'] as const
+export type AssetType = (typeof ASSET_TYPES)[number]
+
+export const assetTypeSchema = z.enum(ASSET_TYPES)
+
+export const semverSchema = z
+  .string()
+  .regex(
+    /^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?(\+[a-zA-Z0-9.]+)?$/,
+    'Must be a valid semver version (e.g. 1.0.0)',
+  )
+
+export const assetNameSchema = z
+  .string()
+  .min(1)
+  .max(128)
+  .regex(
+    /^[a-z0-9][a-z0-9-]*[a-z0-9]$/,
+    'Must be lowercase alphanumeric with hyphens, no leading/trailing hyphens',
+  )
+  .refine((name) => !name.endsWith('-example'), {
+    message: "Asset names cannot end with '-example' (reserved for generated examples)",
+  })
+
+export const npmDependenciesSchema = z.record(z.string(), z.string()).default({})
+
+export const assetDependenciesSchema = z.record(z.string(), z.string()).default({})
+
+export const uploadGenericSchema = z.object({
+  name: assetNameSchema,
+  version: semverSchema,
+  description: z.string().max(1000).optional(),
+  npmDependencies: npmDependenciesSchema,
+  assetDependencies: assetDependenciesSchema,
+  tags: z.array(z.string()).default([]),
+})
+
+export const uploadTypedSchema = z.object({
+  name: assetNameSchema,
+  version: semverSchema,
+  description: z.string().max(1000).optional(),
+  tags: z.array(z.string()).default([]),
+})
+
+export const uploadMaterialSchema = uploadTypedSchema.extend({
+  properties: z.object({
+    color: z.string().default('#ffffff'),
+    roughness: z.number().min(0).max(1).default(0.5),
+    metalness: z.number().min(0).max(1).default(0),
+    normalScale: z.number().min(0).max(2).default(1),
+    emissive: z.string().default('#000000'),
+    emissiveIntensity: z.number().min(0).max(10).default(0),
+  }),
+})
+
+export const updateProfileSchema = z.object({
+  name: z.string().min(1).max(100).optional(),
+  image: z.string().url().optional(),
+})
+
+export const listAssetsSchema = z.object({
+  page: z.number().int().min(1).default(1),
+  limit: z.number().int().min(1).max(100).default(20),
+  type: assetTypeSchema.optional(),
+  tag: z.string().optional(),
+  search: z.string().max(200).optional(),
+  sort: z.enum(['newest', 'alphabetical', 'relevance']).default('newest'),
+})

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}