@drawcall/market 0.1.48 → 0.1.50

package/src/cli.ts

@@ -5,12 +5,14 @@ import { Command, Option } from 'commander'
 import chalk from 'chalk'
 import open from 'open'
 import * as oauthClient from 'openid-client'
-import { ASSET_TYPES, type AssetType } from './schemas.js'
+import { ASSET_TYPES, type AssetAccess, type AssetType } from './schemas.js'
 import { installCommand } from './commands/install.js'
 import { searchCommand } from './commands/search.js'
 import { agentCommand } from './commands/agent.js'
 import { generateCommand } from './commands/generate.js'
+import { generateInstallCommand } from './commands/generate-install.js'
 import { listCommand } from './commands/list.js'
+import { packCommand } from './commands/pack.js'
 import { previewCommand } from './commands/preview.js'
 import { uploadCommand } from './commands/upload.js'
 import { logout } from './commands/logout.js'
@@ -30,6 +32,12 @@ const DEVICE_CLIENT_ID = 'market-cli'
 const collect = (value: string, previous: string[]): string[] => previous.concat(value)
 
 const typeOption = new Option('--type <type>', 'Asset type').choices([...ASSET_TYPES])
+// Omitted → the server picks the default from your entitlement (private if you hold market:private,
+// else public). `--access private` requires that entitlement.
+const accessOption = new Option('--access <access>', 'Asset visibility').choices([
+  'public',
+  'private',
+])
 const apiOption = new Option('--api <url>', 'API URL').default(
   process.env.MARKET_API_URL,
   'from MARKET_API_URL / config / default',
@@ -107,6 +115,39 @@ program
     })
   })
 
+program
+  .command('pack')
+  .description('Create a Market asset zip using the same packaging step as upload')
+  .argument('<zip-filter>', '.zip path or glob')
+  .addOption(typeOption)
+  .option('--out <file>', 'Output zip path')
+  .option('--cwd <dir>', 'Project directory')
+  .option('--npm <dep>', 'npm dependency name@range (repeatable)', collect, [])
+  .option('--asset <dep>', 'asset dependency name@range (repeatable)', collect, [])
+  .option('--skill <dep>', 'skill dependency label=source (repeatable)', collect, [])
+  .action(
+    async (
+      zipFilter: string,
+      opts: {
+        type?: AssetType
+        out?: string
+        cwd?: string
+        npm: string[]
+        asset: string[]
+        skill: string[]
+      },
+    ) => {
+      await packCommand(zipFilter, {
+        type: opts.type,
+        out: opts.out,
+        cwd: opts.cwd,
+        npm: opts.npm,
+        asset: opts.asset,
+        skill: opts.skill,
+      })
+    },
+  )
+
 program
   .command('search')
   .description('Find assets')
@@ -159,6 +200,7 @@ program
   .option('--npm <dep>', 'npm dependency name@range (repeatable)', collect, [])
   .option('--asset <dep>', 'asset dependency name@range (repeatable)', collect, [])
   .option('--skill <dep>', 'skill dependency label=source (repeatable)', collect, [])
+  .addOption(accessOption)
   .action(
     async (
       name: string,
@@ -172,6 +214,7 @@ program
         npm: string[]
         asset: string[]
         skill: string[]
+        access?: AssetAccess
       },
     ) => {
       requireType(opts.type, 'Upload')
@@ -183,6 +226,7 @@ program
         npm: opts.npm,
         asset: opts.asset,
         skill: opts.skill,
+        access: opts.access,
       })
     },
   )
@@ -202,20 +246,49 @@ program
     })
   })
 
-program
+const generate = program
   .command('generate')
-  .description('Generate and install')
-  .argument('<description>', 'Asset prompt')
+  .description('Generate and install an asset, or check a generation job')
+  .argument('[description]', 'Asset prompt (omit when using a subcommand)')
   .addOption(typeOption)
   .addOption(apiOption)
   .option('--cwd <dir>', 'Project directory')
-  .action(async (description: string, opts: { type?: AssetType; api?: string; cwd?: string }) => {
-    requireType(opts.type, 'Generate')
-    await generateCommand(description, {
-      type: opts.type,
-      baseUrl: opts.api,
-      cwd: opts.cwd,
-    })
+  .addOption(accessOption)
+  .action(
+    async (
+      description: string | undefined,
+      opts: { type?: AssetType; api?: string; cwd?: string; access?: AssetAccess },
+    ) => {
+      if (!description) {
+        generate.help({ error: true })
+        return
+      }
+      requireType(opts.type, 'Generate')
+      await generateCommand(description, {
+        type: opts.type,
+        baseUrl: opts.api,
+        cwd: opts.cwd,
+        access: opts.access,
+      })
+    },
+  )
+
+// `generate install <jobId>` finishes a slow (job-based) generation: it checks the job once and, when
+// it has completed, installs the produced asset into the project. Still running → prints a note and
+// exits 0 (run again later); failed → exits 1. Fast asset types never need this — `generate` installs
+// them inline. ("install" over "status": the command's job is to integrate the asset, not just report.)
+generate
+  .command('install')
+  .description('Install the asset from a generation job once it has completed')
+  .argument('<jobId>', 'Job id printed by `market generate`')
+  .addOption(apiOption)
+  .option('--cwd <dir>', 'Project directory')
+  // Read merged options: `--cwd`/`--api` after `generate install` are otherwise captured by the
+  // parent `generate` command (which declares the same options), leaving this subcommand's own opts
+  // undefined. `optsWithGlobals()` surfaces whichever level parsed them.
+  .action(async (jobId: string, _options, command: Command) => {
+    const { api, cwd } = command.optsWithGlobals()
+    await generateInstallCommand(jobId, { baseUrl: api, cwd })
   })
 
 if (process.argv.length <= 2) {

package/src/commands/agent.ts

@@ -4,7 +4,7 @@ import ora from 'ora'
 import { getCliClient } from '../cli-client.js'
 import { agentAndWait } from '../agent.js'
 import { assetVersionRef } from '../output.js'
-import type { AgentResult } from '../index.js'
+import type { AgentResult } from '../schemas.js'
 
 export interface AgentCommandOptions {
   images?: string[]

package/src/commands/generate-install.ts

@@ -0,0 +1,36 @@
+import { getCliClient } from '../cli-client.js'
+import { waitForGeneration } from '../generate.js'
+import { generationRunningResult } from '../output.js'
+import { finishGeneration, startSpinner } from './generate.js'
+
+export interface GenerateInstallCommandOptions {
+  cwd?: string
+  baseUrl?: string
+}
+
+// Install the asset from a generation job. Block-and-polls for a bounded window (the command waits,
+// not the agent): installs on completion, fails loudly on error, or prints a note so the caller runs
+// it again to continue the same job.
+export async function generateInstallCommand(
+  jobId: string,
+  opts: GenerateInstallCommandOptions,
+): Promise<void> {
+  const { client, baseUrl } = await getCliClient({ baseUrl: opts.baseUrl, requireAuth: true })
+  const spinner = startSpinner('Generating asset')
+  try {
+    const outcome = await waitForGeneration(client, jobId, {
+      onProgress: (message) => {
+        spinner.text = message
+      },
+    })
+    await finishGeneration(client, outcome, {
+      cwd: opts.cwd,
+      baseUrl,
+      spinner,
+      stillRunning: generationRunningResult(jobId),
+    })
+  } catch (err) {
+    spinner.stop()
+    throw err
+  }
+}

package/src/commands/generate.ts

@@ -1,15 +1,17 @@
-import ora from 'ora'
+import ora, { type Ora } from 'ora'
 import { getCliClient } from '../cli-client.js'
-import { generateAndWait } from '../generate.js'
+import { GenerateError, startGeneration, waitForGeneration, type PollOutcome } from '../generate.js'
+import type { MarketClient } from '../client.js'
 import { resolve } from '../resolve.js'
 import { install as runInstall } from '../install.js'
-import { generatedInstallResult } from '../output.js'
-import type { AssetType } from '../schemas.js'
+import { generatedInstallResult, generationStartedResult } from '../output.js'
+import type { AssetAccess, AssetType } from '../schemas.js'
 
 export interface GenerateCommandOptions {
   type?: AssetType
   cwd?: string
   baseUrl?: string
+  access?: AssetAccess
 }
 
 export async function generateCommand(
@@ -17,40 +19,86 @@ export async function generateCommand(
   opts: GenerateCommandOptions,
 ): Promise<void> {
   const { client, baseUrl } = await getCliClient({ baseUrl: opts.baseUrl, requireAuth: true })
-
-  const spinner = ora({
-    text: `Generating "${description}"`,
-    isEnabled: Boolean(process.stderr.isTTY),
-    isSilent: !process.stderr.isTTY,
-  }).start()
+  const spinner = startSpinner(`Generating "${description}"`)
   try {
-    const generated = await generateAndWait(
-      client,
-      { description, type: opts.type },
-      {
-        onProgress: (msg) => {
-          spinner.text = msg
-        },
+    const started = await startGeneration(client, {
+      description,
+      type: opts.type,
+      access: opts.access,
+    })
+    // Fast providers finish inline; slow, job-based ones return a job to poll.
+    if (started.status === 'completed') {
+      await installGenerated(client, started, { cwd: opts.cwd, baseUrl, spinner })
+      return
+    }
+    // Block-and-poll for a bounded window (the command waits, not the agent). If the job outlasts the
+    // window, hand back its id so the caller continues with `generate install`.
+    const outcome = await waitForGeneration(client, started.jobId, {
+      onProgress: (message) => {
+        spinner.text = message
       },
-    )
-
-    spinner.text = `Resolving ${generated.assetName}@${generated.version}`
-    const resolution = await resolve(client.asset, [
-      { name: generated.assetName, range: generated.version },
-    ])
-
-    await runInstall(client, resolution, {
+    })
+    await finishGeneration(client, outcome, {
       cwd: opts.cwd,
       baseUrl,
-      onProgress: (msg) => {
-        spinner.text = msg
-      },
+      spinner,
+      stillRunning: generationStartedResult(started.jobId),
     })
-
-    spinner.stop()
-    console.log(generatedInstallResult(generated.assetName, generated.version))
   } catch (err) {
     spinner.stop()
     throw err
   }
 }
+
+interface InstallContext {
+  cwd?: string
+  baseUrl: string
+  spinner: Ora
+}
+
+// Finish a poll outcome: install on completion, fail loudly on error, or print the still-running note
+// (the job keeps running server-side). Shared by `generate` and `generate install`.
+export async function finishGeneration(
+  client: MarketClient,
+  outcome: PollOutcome,
+  ctx: InstallContext & { stillRunning: string },
+): Promise<void> {
+  if (outcome.status === 'completed') {
+    await installGenerated(client, outcome, ctx)
+    return
+  }
+  ctx.spinner.stop()
+  if (outcome.status === 'failed') {
+    throw new GenerateError(outcome.error)
+  }
+  console.log(ctx.stillRunning)
+}
+
+// Install a finished generation into the project and report it.
+async function installGenerated(
+  client: MarketClient,
+  generated: { assetName: string; version: string },
+  ctx: InstallContext,
+): Promise<void> {
+  ctx.spinner.text = `Resolving ${generated.assetName}@${generated.version}`
+  const resolution = await resolve(client.asset, [
+    { name: generated.assetName, range: generated.version },
+  ])
+  await runInstall(client, resolution, {
+    cwd: ctx.cwd,
+    baseUrl: ctx.baseUrl,
+    onProgress: (message) => {
+      ctx.spinner.text = message
+    },
+  })
+  ctx.spinner.stop()
+  console.log(generatedInstallResult(generated.assetName, generated.version))
+}
+
+export function startSpinner(text: string): Ora {
+  return ora({
+    text,
+    isEnabled: Boolean(process.stderr.isTTY),
+    isSilent: !process.stderr.isTTY,
+  }).start()
+}

package/src/commands/pack.ts

@@ -0,0 +1,55 @@
+import * as fs from 'fs/promises'
+import * as path from 'path'
+import ora from 'ora'
+import { packAsset, packPolicyForType, parsePackDependencies } from '../pack.js'
+import { packResult } from '../output.js'
+import type { AssetType } from '../schemas.js'
+
+export interface PackCommandOptions {
+  type?: AssetType
+  cwd?: string
+  out?: string
+  /** npm dependencies, each `name@range` (range defaults to `*`). */
+  npm?: string[]
+  /** asset dependencies, each `name@range` (range defaults to `*`). */
+  asset?: string[]
+  /** skill dependencies, each `label=source` passed to `skills add`. */
+  skill?: string[]
+}
+
+export async function packCommand(zipFilter: string, opts: PackCommandOptions): Promise<void> {
+  const spinner = ora({
+    text: 'Preparing pack',
+    isEnabled: Boolean(process.stderr.isTTY),
+    isSilent: !process.stderr.isTTY,
+  }).start()
+
+  try {
+    const cwd = opts.cwd ?? process.cwd()
+    const packed = await packAsset(zipFilter, {
+      cwd,
+      dependencies: parsePackDependencies({
+        npm: opts.npm,
+        asset: opts.asset,
+        skill: opts.skill,
+      }),
+      policy: packPolicyForType(opts.type),
+    })
+    const out = opts.out ? path.resolve(cwd, opts.out) : defaultPackPath(packed.sourcePath)
+
+    spinner.text = `Writing ${path.relative(cwd, out) || out}`
+    await fs.mkdir(path.dirname(out), { recursive: true })
+    await fs.writeFile(out, packed.zip)
+
+    spinner.stop()
+    console.log(packResult(out, packed))
+  } catch (err) {
+    spinner.stop()
+    throw err
+  }
+}
+
+function defaultPackPath(sourcePath: string): string {
+  const ext = path.extname(sourcePath)
+  return path.join(path.dirname(sourcePath), `${path.basename(sourcePath, ext)}.packed${ext}`)
+}

package/src/commands/upload.ts

@@ -1,21 +1,14 @@
-import * as fs from 'fs/promises'
-import * as path from 'path'
-import { unzipSync, zipSync } from 'fflate'
 import ora from 'ora'
 import semver from 'semver'
 import { getCliClient } from '../cli-client.js'
-import { findInstallRoot } from '../install.js'
-import { readMarketLock, sha256 } from '../market-lock.js'
-import {
-  packageJsonAssetDependenciesFromFiles,
-  packageJsonNpmDependenciesFromFiles,
-} from '../package-json.js'
-import { MAX_ASSET_DESCRIPTION_LENGTH, MAX_UPLOAD_ZIP_SIZE_BYTES } from '../schemas.js'
+import { packAsset, packPolicyFromInstallMetadata, parsePackDependencies } from '../pack.js'
 import { unchangedUploadResult, uploadResult } from '../output.js'
 import {
   assetDescriptionSchema,
   assetNameSchema,
   semverSchema,
+  MAX_ASSET_DESCRIPTION_LENGTH,
+  type AssetAccess,
   type AssetType,
 } from '../schemas.js'
 
@@ -30,6 +23,8 @@ export interface UploadCommandOptions {
   asset?: string[]
   /** skill dependencies, each `label=source` passed to `skills add`. */
   skill?: string[]
+  /** Requested visibility; omitted lets the server resolve it from entitlement. */
+  access?: AssetAccess
 }
 
 export async function uploadCommand(
@@ -49,37 +44,21 @@ export async function uploadCommand(
     const parsedVersion = opts.version ? semverSchema.parse(opts.version) : undefined
     const parsedDescription = parseUploadDescription(description)
     // Parse dep flags before any network work so a malformed spec fails fast.
-    const explicitNpmDependencies = parseVersionedDeps(opts.npm ?? [], 'npm')
-    const explicitAssetDependencies = parseVersionedDeps(opts.asset ?? [], 'asset')
-    const skillDependencies = parseSkillDeps(opts.skill ?? [])
+    const dependencies = parsePackDependencies({
+      npm: opts.npm,
+      asset: opts.asset,
+      skill: opts.skill,
+    })
     const cwd = opts.cwd ?? process.cwd()
     const type = opts.type
-    const zipFile = await resolveOneZipFile(cwd, zipFilter)
-    const zipStat = await fs.stat(zipFile)
-    if (zipStat.size >= MAX_UPLOAD_ZIP_SIZE_BYTES) {
-      throw new Error('Upload zip must be smaller than 1 GB')
-    }
-    const sourceZip = new Uint8Array(await fs.readFile(zipFile))
     const { client } = await getCliClient({ baseUrl: opts.baseUrl, requireAuth: true })
     const installMetadata = await client.asset.installMetadata()
-    const typeMetadata = installMetadata[type]
-    const sourceFiles = unzipSync(sourceZip)
-    const packageJsonAssetDependencies = typeMetadata?.readAssetDependenciesFromPackageJson
-      ? packageJsonAssetDependenciesFromFiles(sourceFiles)
-      : {}
-    const assetDependencies = mergeAssetDependencies(
-      packageJsonAssetDependencies,
-      explicitAssetDependencies,
-    )
-    // A type that ships a package.json (templates) also carries its npm dependencies there; capture
-    // them so an install over an existing package.json brings them. Explicit --npm wins on conflict.
-    const packageJsonNpmDependencies = typeMetadata?.readAssetDependenciesFromPackageJson
-      ? packageJsonNpmDependenciesFromFiles(sourceFiles)
-      : {}
-    const npmDependencies = { ...packageJsonNpmDependencies, ...explicitNpmDependencies }
-    const zip = typeMetadata?.omitUnchangedInstalledFilesOnUpload
-      ? await omitUnchangedInstalledFiles(sourceZip, sourceFiles, assetDependencies, cwd)
-      : sourceZip
+    const packed = await packAsset(zipFilter, {
+      cwd,
+      dependencies,
+      policy: packPolicyFromInstallMetadata(installMetadata[type]),
+    })
+    const { zip, npmDependencies, assetDependencies, skillDependencies } = packed
     const profile = await client.user.getProfile()
     if (!profile) {
       throw new Error('Not logged in. Run `market login` first.')
@@ -124,6 +103,7 @@ export async function uploadCommand(
       assetDependencies,
       skillDependencies,
       tags: [],
+      access: opts.access,
       zip: new File([toArrayBuffer(zip)], `${parsedName}-${version}.zip`, {
         type: 'application/zip',
       }),
@@ -147,118 +127,6 @@ export function parseUploadDescription(description: string): string {
   }
 }
 
-/**
- * Parse `name@range` specs (npm or asset deps) into a name→range record. The
- * range is optional and defaults to `*`. A leading `@` is treated as a scope
- * marker, so `@scope/pkg@^1.0.0` splits into `@scope/pkg` and `^1.0.0`.
- */
-export function parseVersionedDeps(specs: string[], kind: 'npm' | 'asset'): Record<string, string> {
-  const out: Record<string, string> = {}
-  for (const spec of specs) {
-    const at = spec.lastIndexOf('@')
-    const hasRange = at > 0
-    const name = hasRange ? spec.slice(0, at) : spec
-    const range = hasRange ? spec.slice(at + 1) : '*'
-    if (!name || !range) {
-      throw new Error(`Invalid ${kind} dependency "${spec}". Use name@range (e.g. three@^0.178.0).`)
-    }
-    if (name in out) {
-      throw new Error(`Duplicate ${kind} dependency "${name}".`)
-    }
-    out[name] = range
-  }
-  return out
-}
-
-/**
- * Parse `label=source` specs into a label→source record. The source is passed
- * verbatim to `skills add` (a GitHub/git ref or a local path), so only the
- * first `=` is treated as the separator.
- */
-export function parseSkillDeps(specs: string[]): Record<string, string> {
-  const out: Record<string, string> = {}
-  for (const spec of specs) {
-    const eq = spec.indexOf('=')
-    if (eq <= 0 || eq === spec.length - 1) {
-      throw new Error(
-        `Invalid skill dependency "${spec}". Use label=source ` +
-          `(e.g. web-design=vercel-labs/agent-skills).`,
-      )
-    }
-    const label = spec.slice(0, eq)
-    if (label in out) {
-      throw new Error(`Duplicate skill dependency "${label}".`)
-    }
-    out[label] = spec.slice(eq + 1)
-  }
-  return out
-}
-
-function mergeAssetDependencies(
-  fromPackageJson: Record<string, string>,
-  explicit: Record<string, string>,
-): Record<string, string> {
-  const merged = { ...fromPackageJson }
-  for (const [name, range] of Object.entries(explicit)) {
-    if (name in merged && merged[name] !== range) {
-      throw new Error(
-        `Conflicting asset dependency "${name}": package.json has ${merged[name]}, --asset has ${range}`,
-      )
-    }
-    merged[name] = range
-  }
-  return merged
-}
-
-async function omitUnchangedInstalledFiles(
-  sourceZip: Uint8Array,
-  sourceFiles: Record<string, Uint8Array>,
-  assetDependencies: Record<string, string>,
-  cwd: string,
-): Promise<Uint8Array> {
-  const dependencyNames = new Set(Object.keys(assetDependencies))
-  if (dependencyNames.size === 0) return sourceZip
-
-  const installRoot = await findInstallRoot(cwd)
-  const lock = await readMarketLock(installRoot)
-  const hashesByPath = new Map<string, string>()
-
-  for (const [name, asset] of Object.entries(lock.assets)) {
-    if (!dependencyNames.has(name)) continue
-    for (const [file, metadata] of Object.entries(asset.files)) {
-      hashesByPath.set(file, metadata.sha256)
-    }
-  }
-
-  if (hashesByPath.size === 0) return sourceZip
-
-  let omitted = false
-  const filtered: Record<string, Uint8Array> = {}
-  for (const [file, content] of Object.entries(sourceFiles)) {
-    const normalizedPath = normalizedZipPath(file)
-    const lockedHash = normalizedPath ? hashesByPath.get(normalizedPath) : undefined
-    if (lockedHash && lockedHash === sha256(content)) {
-      omitted = true
-      continue
-    }
-    filtered[file] = content
-  }
-
-  return omitted ? zipSync(filtered) : sourceZip
-}
-
-function normalizedZipPath(file: string): string | null {
-  const zipPath = file.replace(/\\/g, '/')
-  if (
-    zipPath.split('/').includes('..') ||
-    path.posix.isAbsolute(zipPath) ||
-    path.win32.isAbsolute(zipPath)
-  ) {
-    return null
-  }
-  return path.posix.normalize(zipPath)
-}
-
 /** Compare a stored dependency JSON string against a freshly parsed record. */
 function depsEqual(storedJson: string, next: Record<string, string>): boolean {
   let stored: Record<string, string>
@@ -271,71 +139,6 @@ function depsEqual(storedJson: string, next: Record<string, string>): boolean {
   return keys.length === Object.keys(next).length && keys.every((key) => stored[key] === next[key])
 }
 
-async function resolveOneZipFile(cwd: string, zipFilter: string): Promise<string> {
-  const absolute = path.resolve(cwd, zipFilter)
-  const stat = await maybeStat(absolute)
-  if (stat?.isFile()) return assertZipFile(absolute)
-
-  const files = await listFiles(cwd)
-  const matches = files
-    .filter((file) => matchesFilter(path.relative(cwd, file), zipFilter))
-    .filter(isZipFile)
-    .sort()
-
-  if (matches.length === 0) {
-    throw new Error(`No .zip files matched "${zipFilter}"`)
-  }
-  if (matches.length > 1) {
-    throw new Error(`File filter matched ${matches.length} zips; upload one asset at a time`)
-  }
-
-  return matches[0]
-}
-
-function assertZipFile(file: string): string {
-  if (!isZipFile(file)) throw new Error(`Upload file must be a .zip: ${file}`)
-  return file
-}
-
-function isZipFile(file: string): boolean {
-  return /\.zip$/i.test(file)
-}
-
-async function maybeStat(file: string) {
-  try {
-    return await fs.stat(file)
-  } catch {
-    return null
-  }
-}
-
-async function listFiles(dir: string): Promise<string[]> {
-  const entries = await fs.readdir(dir, { withFileTypes: true })
-  const files: string[] = []
-  for (const entry of entries) {
-    if (entry.name === 'node_modules' || entry.name === '.git') continue
-    const fullPath = path.join(dir, entry.name)
-    if (entry.isDirectory()) {
-      files.push(...(await listFiles(fullPath)))
-    } else if (entry.isFile()) {
-      files.push(fullPath)
-    }
-  }
-  return files
-}
-
-function matchesFilter(file: string, filter: string): boolean {
-  const normalizedFile = file.split(path.sep).join('/')
-  const normalizedFilter = filter.split(path.sep).join('/')
-  const pattern =
-    '^' +
-    escapeRegExp(normalizedFilter)
-      .replace(/\\\*\\\*/g, '.*')
-      .replace(/\\\*/g, '[^/]*') +
-    '$'
-  return new RegExp(pattern).test(normalizedFile)
-}
-
 function nextVersion(latest?: string): string {
   if (!latest) return '1.0.0'
   const version = semver.inc(latest, 'patch')
@@ -352,9 +155,5 @@ function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
 }
 
 function toArrayBuffer(bytes: Uint8Array): ArrayBuffer {
-  return new Uint8Array(bytes).buffer
-}
-
-function escapeRegExp(value: string): string {
-  return value.replace(/[|\\{}()[\]^$+?.*]/g, '\\$&')
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer
 }