@helia/unixfs 7.0.4 → 7.1.0

package/src/commands/utils/add-link.ts

@@ -7,23 +7,21 @@ import { sha256 } from 'multiformats/hashes/sha2'
 // @ts-expect-error no types
 import SparseArray from 'sparse-array'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { DEFAULT_SHARD_SPLIT_THRESHOLD_BYTES } from '../../constants.ts'
-import { AlreadyExistsError, InvalidParametersError, InvalidPBNodeError } from '../../errors.js'
-import { wrapHash } from './consumable-hash.js'
-import { hamtBucketBits, hamtHashFn } from './hamt-constants.js'
+import { AlreadyExistsError, InvalidParametersError, InvalidPBNodeError } from '../../errors.ts'
+import { wrapHash } from './consumable-hash.ts'
+import { hamtBucketBits, hamtHashFn } from './hamt-constants.ts'
 import {
   createShard,
   recreateShardedDirectory,
   toPrefix,
   updateShardedDirectory
-} from './hamt-utils.js'
-import { isOverShardThreshold } from './is-over-shard-threshold.js'
-import type { Directory } from './cid-to-directory.js'
-import type { GetStore, PutStore } from '../../unixfs.js'
+} from './hamt-utils.ts'
+import { isOverShardThreshold } from './is-over-shard-threshold.ts'
+import type { Directory } from './cid-to-directory.ts'
+import type { GetStore, PutStore } from '../../unixfs.ts'
 import type { PBNode, PBLink } from '@ipld/dag-pb'
 import type { AbortOptions } from '@libp2p/interface'
-import type { ImportResult } from 'ipfs-unixfs-importer'
-import type { Version } from 'multiformats/cid'
+import type { ImporterOptions, ImportResult } from 'ipfs-unixfs-importer'
 
 const log = logger('helia:unixfs:components:utils:add-link')
 
@@ -32,10 +30,8 @@ export interface AddLinkResult {
   cid: CID
 }
 
-export interface AddLinkOptions extends AbortOptions {
+export interface AddLinkOptions extends AbortOptions, Pick<ImporterOptions, 'profile' | 'shardSplitThresholdBytes' | 'shardSplitStrategy' | 'shardFanoutBits' | 'cidVersion'> {
   allowOverwriting?: boolean
-  shardSplitThresholdBytes?: number
-  cidVersion?: Version
 }
 
 export async function addLink (parent: Directory, child: Required<PBLink>, blockstore: GetStore & PutStore, options: AddLinkOptions): Promise<AddLinkResult> {
@@ -55,10 +51,10 @@ export async function addLink (parent: Directory, child: Required<PBLink>, block
 
   const result = await addToDirectory(parent, child, blockstore, options)
 
-  if (await isOverShardThreshold(result.node, blockstore, options.shardSplitThresholdBytes ?? DEFAULT_SHARD_SPLIT_THRESHOLD_BYTES, options)) {
+  if (await isOverShardThreshold(result.node, blockstore, options)) {
     log('converting directory to sharded directory')
 
-    const converted = await convertToShardedDirectory(result, blockstore)
+    const converted = await convertToShardedDirectory(result, blockstore, options)
     result.cid = converted.cid
     result.node = dagPB.decode(await toBuffer(blockstore.get(converted.cid, options)))
   }
@@ -66,7 +62,7 @@ export async function addLink (parent: Directory, child: Required<PBLink>, block
   return result
 }
 
-const convertToShardedDirectory = async (parent: Directory, blockstore: PutStore): Promise<ImportResult> => {
+const convertToShardedDirectory = async (parent: Directory, blockstore: PutStore, options: AddLinkOptions): Promise<ImportResult> => {
   if (parent.node.Data == null) {
     throw new InvalidParametersError('Invalid parent passed to convertToShardedDirectory')
   }
@@ -78,6 +74,7 @@ const convertToShardedDirectory = async (parent: Directory, blockstore: PutStore
     size: BigInt(link.Tsize ?? 0),
     cid: link.Hash
   })), {
+    ...options,
     mode: unixfs.mode,
     mtime: unixfs.mtime,
     cidVersion: parent.cid.version
@@ -130,9 +127,11 @@ const addToDirectory = async (parent: Directory, child: PBLink, blockstore: PutS
   // Persist the new parent PbNode
   const buf = dagPB.encode(parent.node)
   const hash = await sha256.digest(buf)
+  options?.signal?.throwIfAborted()
+
   const cid = CID.create(parent.cid.version, dagPB.code, hash)
 
-  await blockstore.put(cid, buf)
+  await blockstore.put(cid, buf, options)
 
   return {
     node: parent.node,
@@ -157,6 +156,7 @@ const addToShardedDirectory = async (parent: Directory, child: Required<PBLink>,
 
   const linkName = `${prefix}${child.Name}`
   const existingLink = finalSegment.node.Links.find(l => (l.Name ?? '').startsWith(prefix))
+  const prefixLength = prefix.length
 
   if (existingLink != null) {
     log('link %s was present in shard', linkName)
@@ -175,7 +175,7 @@ const addToShardedDirectory = async (parent: Directory, child: Required<PBLink>,
         Hash: child.Hash,
         Tsize: child.Tsize
       })
-    } else if (existingLink.Name?.length === 2) {
+    } else if (existingLink.Name?.length === prefixLength) {
       throw new Error('Existing link was sub-shard?!')
     } else {
       // conflict, add a new HAMT segment
@@ -185,23 +185,29 @@ const addToShardedDirectory = async (parent: Directory, child: Required<PBLink>,
       const sibling = finalSegment.node.Links.splice(index, 1)[0]
 
       // give the sibling a new HAMT prefix
-      const siblingName = (sibling.Name ?? '').substring(2)
+      const siblingName = (sibling.Name ?? '').substring(prefixLength)
       const wrapped = wrapHash(hamtHashFn)
       const siblingHash = wrapped(uint8ArrayFromString(siblingName))
+      const hashBits = options.shardFanoutBits ?? hamtBucketBits
 
       // discard hash bits until we reach the sub-shard depth
       for (let i = 0; i < path.length; i++) {
-        await siblingHash.take(hamtBucketBits)
+        await siblingHash.take(hashBits)
+        options?.signal?.throwIfAborted()
       }
 
       while (true) {
-        const siblingIndex = await siblingHash.take(hamtBucketBits)
-        const siblingPrefix = toPrefix(siblingIndex)
+        const siblingIndex = await siblingHash.take(hashBits)
+        options?.signal?.throwIfAborted()
+
+        const siblingPrefix = toPrefix(siblingIndex, hashBits)
         sibling.Name = `${siblingPrefix}${siblingName}`
 
         // calculate the target file's HAMT prefix in the new sub-shard
-        const newIndex = await hash.take(hamtBucketBits)
-        const newPrefix = toPrefix(newIndex)
+        const newIndex = await hash.take(hashBits)
+        options?.signal?.throwIfAborted()
+
+        const newPrefix = toPrefix(newIndex, hashBits)
 
         if (siblingPrefix === newPrefix) {
           // the two sibling names have caused another conflict - add an intermediate node to

package/src/commands/utils/cid-to-directory.ts

@@ -1,6 +1,6 @@
 import { exporter } from 'ipfs-unixfs-exporter'
-import { NotADirectoryError } from '../../errors.js'
-import type { GetStore } from '../../unixfs.js'
+import { NotADirectoryError } from '../../errors.ts'
+import type { GetStore } from '../../unixfs.ts'
 import type { PBNode } from '@ipld/dag-pb'
 import type { ExporterOptions } from 'ipfs-unixfs-exporter'
 import type { CID } from 'multiformats/cid'

package/src/commands/utils/cid-to-pblink.ts

@@ -1,7 +1,7 @@
 import * as dagPb from '@ipld/dag-pb'
 import { exporter } from 'ipfs-unixfs-exporter'
-import { NotUnixFSError } from '../../errors.js'
-import type { GetStore } from '../../unixfs.js'
+import { NotUnixFSError } from '../../errors.ts'
+import type { GetStore } from '../../unixfs.ts'
 import type { PBNode, PBLink } from '@ipld/dag-pb'
 import type { ExporterOptions } from 'ipfs-unixfs-exporter'
 import type { CID } from 'multiformats/cid'

package/src/commands/utils/hamt-utils.ts

@@ -1,40 +1,41 @@
 import * as dagPB from '@ipld/dag-pb'
 import { logger } from '@libp2p/logger'
 import { UnixFS } from 'ipfs-unixfs'
+import { DirSharded } from 'ipfs-unixfs-importer/utils'
 import last from 'it-last'
 import toBuffer from 'it-to-buffer'
 // @ts-expect-error no types
 import SparseArray from 'sparse-array'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { wrapHash } from './consumable-hash.js'
-import { DirSharded } from './dir-sharded.js'
+import { wrapHash } from './consumable-hash.ts'
 import {
   hamtHashCode,
   hamtHashFn,
   hamtBucketBits
-} from './hamt-constants.js'
-import { persist } from './persist.js'
-import type { InfiniteHash } from './consumable-hash.js'
-import type { PersistOptions } from './persist.js'
-import type { GetStore, PutStore } from '../../unixfs.js'
+} from './hamt-constants.ts'
+import { persist } from './persist.ts'
+import type { InfiniteHash } from './consumable-hash.ts'
+import type { GetStore, PutStore } from '../../unixfs.ts'
 import type { AbortOptions } from '@libp2p/interface'
 import type { Blockstore } from 'interface-blockstore'
 import type { Mtime } from 'ipfs-unixfs'
-import type { ImportResult } from 'ipfs-unixfs-importer'
+import type { ImporterOptions, ImportResult } from 'ipfs-unixfs-importer'
 import type { CID, Version } from 'multiformats/cid'
 
 const log = logger('helia:unixfs:commands:utils:hamt-utils')
 
-export interface UpdateHamtDirectoryOptions extends AbortOptions {
+export interface UpdateHamtDirectoryOptions extends HAMTOptions {
   cidVersion?: Version
 }
 
-export const toPrefix = (position: number): string => {
+export const toPrefix = (position: number, bits = hamtBucketBits): string => {
+  const length = (Math.pow(2, bits) - 1).toString(16).length
+
   return position
     .toString(16)
     .toUpperCase()
-    .padStart(2, '0')
-    .substring(0, 2)
+    .padStart(length, '0')
+    .substring(0, length)
 }
 
 export interface CreateShardOptions {
@@ -57,7 +58,7 @@ export const createShard = async (blockstore: PutStore, contents: Array<{ name:
   }, options)
 
   for (let i = 0; i < contents.length; i++) {
-    await shard._bucket.put(contents[i].name, {
+    await shard.bucket.put(contents[i].name, {
       size: contents[i].size,
       cid: contents[i].cid
     })
@@ -78,12 +79,12 @@ export interface HAMTPath {
   node: dagPB.PBNode
 }
 
-export const updateShardedDirectory = async (path: HAMTPath[], blockstore: GetStore & PutStore, options: PersistOptions): Promise<{ cid: CID, node: dagPB.PBNode }> => {
+export const updateShardedDirectory = async (path: HAMTPath[], blockstore: GetStore & PutStore, options: HAMTOptions): Promise<{ cid: CID, node: dagPB.PBNode }> => {
   // persist any metadata on the shard root
   const shardRoot = UnixFS.unmarshal(path[0].node.Data ?? new Uint8Array(0))
 
   // this is always the same
-  const fanout = BigInt(Math.pow(2, hamtBucketBits))
+  const fanout = BigInt(Math.pow(2, options.shardFanoutBits ?? hamtBucketBits))
 
   // start from the leaf and ascend to the root
   path.reverse()
@@ -145,18 +146,23 @@ export const updateShardedDirectory = async (path: HAMTPath[], blockstore: GetSt
   return { cid, node }
 }
 
-export const recreateShardedDirectory = async (cid: CID, fileName: string, blockstore: Pick<Blockstore, 'get'>, options: AbortOptions): Promise<{ path: HAMTPath[], hash: InfiniteHash }> => {
+export interface HAMTOptions extends AbortOptions, Pick<ImporterOptions, 'shardFanoutBits' | 'shardSplitStrategy' | 'shardSplitThresholdBytes'> {
+
+}
+
+export const recreateShardedDirectory = async (cid: CID, fileName: string, blockstore: Pick<Blockstore, 'get'>, options: HAMTOptions): Promise<{ path: HAMTPath[], hash: InfiniteHash }> => {
   const wrapped = wrapHash(hamtHashFn)
   const hash = wrapped(uint8ArrayFromString(fileName))
   const path: HAMTPath[] = []
+  const hashBits = options.shardFanoutBits ?? hamtBucketBits
 
   // descend the HAMT, loading each layer as we head towards the target child
   while (true) {
     const block = await toBuffer(blockstore.get(cid, options))
     const node = dagPB.decode(block)
     const children = new SparseArray()
-    const index = await hash.take(hamtBucketBits)
-    const prefix = toPrefix(index)
+    const index = await hash.take(hashBits)
+    const prefix = toPrefix(index, hashBits)
 
     path.push({
       prefix,
@@ -171,11 +177,11 @@ export const recreateShardedDirectory = async (cid: CID, fileName: string, block
     for (const link of node.Links) {
       const linkName = link.Name ?? ''
 
-      if (linkName.length < 2) {
+      if (linkName.length < prefix.length) {
         throw new Error('Invalid HAMT - link name was too short')
       }
 
-      const position = parseInt(linkName.substring(0, 2), 16)
+      const position = parseInt(linkName.substring(0, prefix.length), 16)
       children.set(position, true)
 
       // we found the child we are looking for
@@ -186,17 +192,17 @@ export const recreateShardedDirectory = async (cid: CID, fileName: string, block
 
     if (childLink == null) {
       log('no link found with prefix %s for %s', prefix, fileName)
-      // hash.untake(hamtBucketBits)
+      // hash.untake(hashBits)
       break
     }
 
     const linkName = childLink.Name ?? ''
 
-    if (linkName.length < 2) {
+    if (linkName.length < prefix.length) {
       throw new Error('Invalid HAMT - link name was too short')
     }
 
-    if (linkName.length === 2) {
+    if (linkName.length === prefix.length) {
       // found sub-shard
       cid = childLink.Hash
       log('descend into sub-shard with prefix %s', linkName)

package/src/commands/utils/is-over-shard-threshold.ts

@@ -1,31 +1,54 @@
 import * as dagPb from '@ipld/dag-pb'
+import { InvalidParametersError } from '@libp2p/interface'
 import { UnixFS } from 'ipfs-unixfs'
+import { dataFieldSerializedSize, linkSerializedSize, utf8ByteLength } from 'ipfs-unixfs-importer/utils'
 import toBuffer from 'it-to-buffer'
-import { CID_V0, CID_V1 } from './dir-sharded.js'
+import { DEFAULT_SHARD_SPLIT_THRESHOLD_BYTES } from '../../constants.ts'
+import { hamtBucketBits } from './hamt-constants.ts'
 import type { GetStore } from '../../unixfs.js'
 import type { PBNode } from '@ipld/dag-pb'
 import type { AbortOptions } from '@libp2p/interface'
+import type { ImporterOptions, ShardSplitStrategy } from 'ipfs-unixfs-importer'
+
+export interface IsOverShardThresholdOptions extends AbortOptions, Pick<ImporterOptions, 'profile' | 'shardSplitThresholdBytes' | 'shardSplitStrategy' | 'shardFanoutBits'> {
+
+}
 
 /**
  * Estimate node size only based on DAGLink name and CID byte lengths
  * https://github.com/ipfs/go-unixfsnode/blob/37b47f1f917f1b2f54c207682f38886e49896ef9/data/builder/directory.go#L81-L96
  *
- * If the node is a hamt sharded directory the calculation is based on if it was a regular directory.
+ * If the node is a hamt sharded directory the calculation is based on if it was
+ * a regular directory.
  */
-export async function isOverShardThreshold (node: PBNode, blockstore: GetStore, threshold: number, options: AbortOptions): Promise<boolean> {
+export async function isOverShardThreshold (node: PBNode, blockstore: GetStore, options: IsOverShardThresholdOptions): Promise<boolean> {
   if (node.Data == null) {
     throw new Error('DagPB node had no data')
   }
 
+  const threshold = options.shardSplitThresholdBytes ?? DEFAULT_SHARD_SPLIT_THRESHOLD_BYTES
+  let strategy: ShardSplitStrategy = options.shardSplitStrategy ?? 'links-bytes'
+
+  if (options.profile === 'unixfs-v0-2015') {
+    strategy = 'links-bytes'
+  }
+
   const unixfs = UnixFS.unmarshal(node.Data)
-  let size: number
+
+  if (!unixfs.isDirectory()) {
+    throw new Error('Can only estimate the size of directories or shards')
+  }
+
+  if (strategy !== 'links-bytes' && strategy !== 'block-bytes') {
+    throw new InvalidParametersError(`Invalid shard split threshold "${strategy}"`)
+  }
+
+  let size: number = 0
 
   if (unixfs.type === 'directory') {
-    size = estimateNodeSize(node)
+    size = strategy === 'links-bytes' ? estimateNodeSize(node) : calculateNodeSize(unixfs, node)
   } else if (unixfs.type === 'hamt-sharded-directory') {
-    size = await estimateShardSize(node, 0, threshold, blockstore, options)
-  } else {
-    throw new Error('Can only estimate the size of directories or shards')
+    size = strategy === 'links-bytes' ? await estimateShardSize(node, 0, threshold, blockstore, options) : await calculateShardSize(node, dataFieldSerializedSize(unixfs.mode, unixfs.mtime), threshold, blockstore, options)
   }
 
   return size > threshold
@@ -37,14 +60,26 @@ function estimateNodeSize (node: PBNode): number {
   // estimate size only based on DAGLink name and CID byte lengths
   // https://github.com/ipfs/go-unixfsnode/blob/37b47f1f917f1b2f54c207682f38886e49896ef9/data/builder/directory.go#L81-L96
   for (const link of node.Links) {
-    size += (link.Name ?? '').length
-    size += link.Hash.version === 1 ? CID_V1.bytes.byteLength : CID_V0.bytes.byteLength
+    size += utf8ByteLength(link.Name ?? '')
+    size += link.Hash.byteLength
   }
 
   return size
 }
 
-async function estimateShardSize (node: PBNode, current: number, max: number, blockstore: GetStore, options: AbortOptions): Promise<number> {
+function calculateNodeSize (unixfs: UnixFS, node: PBNode): number {
+  let size = dataFieldSerializedSize(unixfs.mode, unixfs.mtime)
+
+  for (const link of node.Links) {
+    size += linkSerializedSize(
+      utf8ByteLength(link.Name ?? ''), link.Hash.byteLength, Number(link.Tsize ?? 0)
+    )
+  }
+
+  return size
+}
+
+async function estimateShardSize (node: PBNode, current: number, max: number, blockstore: GetStore, options: IsOverShardThresholdOptions): Promise<number> {
   if (current > max) {
     return max
   }
@@ -59,13 +94,15 @@ async function estimateShardSize (node: PBNode, current: number, max: number, bl
     return current
   }
 
+  const prefixLength = (Math.pow(2, options.shardFanoutBits ?? hamtBucketBits) - 1).toString(16).length
+
   for (const link of node.Links) {
     let name = link.Name ?? ''
 
     // remove hamt hash prefix from name
-    name = name.substring(2)
+    name = name.substring(prefixLength)
 
-    current += name.length
+    current += utf8ByteLength(name)
     current += link.Hash.bytes.byteLength
 
     if (link.Hash.code === dagPb.code) {
@@ -78,3 +115,41 @@ async function estimateShardSize (node: PBNode, current: number, max: number, bl
 
   return current
 }
+
+async function calculateShardSize (node: PBNode, current: number, max: number, blockstore: GetStore, options: IsOverShardThresholdOptions): Promise<number> {
+  if (current > max) {
+    return max
+  }
+
+  if (node.Data == null) {
+    return current
+  }
+
+  const unixfs = UnixFS.unmarshal(node.Data)
+
+  if (!unixfs.isDirectory()) {
+    return current
+  }
+
+  const prefixLength = (Math.pow(2, options.shardFanoutBits ?? hamtBucketBits) - 1).toString(16).length
+
+  for (const link of node.Links) {
+    let name = link.Name ?? ''
+
+    // remove hamt hash prefix from name
+    name = name.substring(prefixLength)
+
+    current += linkSerializedSize(
+      utf8ByteLength(name), link.Hash.byteLength, Number(link.Tsize ?? 0)
+    )
+
+    if (link.Hash.code === dagPb.code) {
+      const block = await toBuffer(blockstore.get(link.Hash, options))
+      const node = dagPb.decode(block)
+
+      current += await calculateShardSize(node, current, max, blockstore, options)
+    }
+  }
+
+  return current
+}

package/src/commands/utils/persist.ts

@@ -2,14 +2,14 @@ import * as dagPb from '@ipld/dag-pb'
 import { CID } from 'multiformats/cid'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { DEFAULT_CID_VERSION } from '../../constants.ts'
-import type { PutStore } from '../../unixfs.js'
+import type { PutStore } from '../../unixfs.ts'
+import type { AbortOptions } from '@libp2p/interface'
 import type { Version as CIDVersion } from 'multiformats/cid'
 import type { BlockCodec } from 'multiformats/codecs/interface'
 
-export interface PersistOptions {
+export interface PersistOptions extends AbortOptions {
   codec?: BlockCodec<any, any>
   cidVersion?: CIDVersion
-  signal?: AbortSignal
 }
 
 export const persist = async (buffer: Uint8Array, blockstore: PutStore, options: PersistOptions): Promise<CID> => {

package/src/commands/utils/remove-link.ts

@@ -2,27 +2,26 @@ import * as dagPB from '@ipld/dag-pb'
 import { logger } from '@libp2p/logger'
 import { UnixFS } from 'ipfs-unixfs'
 import { exporter } from 'ipfs-unixfs-exporter'
-import { DEFAULT_SHARD_SPLIT_THRESHOLD_BYTES } from '../../constants.ts'
-import { InvalidParametersError, InvalidPBNodeError } from '../../errors.js'
+import { InvalidParametersError, InvalidPBNodeError } from '../../errors.ts'
+import { hamtBucketBits } from './hamt-constants.ts'
 import {
   recreateShardedDirectory,
-
   updateShardedDirectory
-} from './hamt-utils.js'
-import { isOverShardThreshold } from './is-over-shard-threshold.js'
-import { persist } from './persist.js'
-import type { Directory } from './cid-to-directory.js'
-import type { UpdateHamtDirectoryOptions } from './hamt-utils.js'
-import type { GetStore, PutStore } from '../../unixfs.js'
+} from './hamt-utils.ts'
+import { isOverShardThreshold } from './is-over-shard-threshold.ts'
+import { persist } from './persist.ts'
+import type { Directory } from './cid-to-directory.ts'
+import type { UpdateHamtDirectoryOptions } from './hamt-utils.ts'
+import type { GetStore, PutStore } from '../../unixfs.ts'
 import type { PBNode } from '@ipld/dag-pb'
 import type { AbortOptions } from '@libp2p/interface'
-import type { CID, Version } from 'multiformats/cid'
+import type { ImporterOptions } from 'ipfs-unixfs-importer'
+import type { CID } from 'multiformats/cid'
 
 const log = logger('helia:unixfs:utils:remove-link')
 
-export interface RmLinkOptions extends AbortOptions {
-  shardSplitThresholdBytes?: number
-  cidVersion?: Version
+export interface RmLinkOptions extends AbortOptions, Pick<ImporterOptions, 'profile' | 'shardSplitThresholdBytes' | 'shardSplitStrategy' | 'shardFanoutBits' | 'cidVersion'> {
+
 }
 
 export interface RemoveLinkResult {
@@ -42,7 +41,7 @@ export async function removeLink (parent: Directory, name: string, blockstore: P
 
     const result = await removeFromShardedDirectory(parent, name, blockstore, options)
 
-    if (!(await isOverShardThreshold(result.node, blockstore, options.shardSplitThresholdBytes ?? DEFAULT_SHARD_SPLIT_THRESHOLD_BYTES, options))) {
+    if (!(await isOverShardThreshold(result.node, blockstore, options))) {
       log('converting shard to flat directory %c', parent.cid)
 
       return convertToFlatDirectory(result, blockstore, options)
@@ -84,13 +83,14 @@ const removeFromShardedDirectory = async (parent: Directory, name: string, block
     throw new Error('Invalid HAMT, could not generate path')
   }
 
-  const linkName = finalSegment.node.Links.filter(l => (l.Name ?? '').substring(2) === name).map(l => l.Name).pop()
+  const prefixLength = (Math.pow(2, options.shardFanoutBits ?? hamtBucketBits) - 1).toString(16).length
+  const linkName = finalSegment.node.Links.filter(l => (l.Name ?? '').substring(prefixLength) === name).map(l => l.Name).pop()
 
   if (linkName == null) {
     throw new Error('File not found')
   }
 
-  const prefix = linkName.substring(0, 2)
+  const prefix = linkName.substring(0, prefixLength)
   const index = parseInt(prefix, 16)
 
   // remove the file from the shard
@@ -124,7 +124,7 @@ const removeFromShardedDirectory = async (parent: Directory, name: string, block
       nextSegment.node.Links = nextSegment.node.Links.filter(l => !(l.Name ?? '').startsWith(nextSegment.prefix))
       nextSegment.node.Links.push({
         Hash: link.Hash,
-        Name: `${nextSegment.prefix}${(link.Name ?? '').substring(2)}`,
+        Name: `${nextSegment.prefix}${(link.Name ?? '').substring(prefixLength)}`,
         Tsize: link.Tsize
       })
     }

package/src/commands/utils/resolve.ts

@@ -1,11 +1,11 @@
 import { logger } from '@libp2p/logger'
 import { walkPath } from 'ipfs-unixfs-exporter'
 import all from 'it-all'
-import { DoesNotExistError } from '../../errors.js'
-import { addLink } from './add-link.js'
-import { cidToDirectory } from './cid-to-directory.js'
-import { cidToPBLink } from './cid-to-pblink.js'
-import type { GetStore, PutStore } from '../../unixfs.js'
+import { DoesNotExistError } from '../../errors.ts'
+import { addLink } from './add-link.ts'
+import { cidToDirectory } from './cid-to-directory.ts'
+import { cidToPBLink } from './cid-to-pblink.ts'
+import type { GetStore, PutStore } from '../../unixfs.ts'
 import type { AbortOptions } from '@libp2p/interface'
 import type { PathEntry } from 'ipfs-unixfs-exporter'
 import type { CID } from 'multiformats/cid'