feat(loader): support entry.id with separator

packages/loader/src/entry.ts

@@ -44,7 +44,7 @@ function sortKeys<T extends {}>(object: T, prepend = ['id', 'name'], append = ['
 }
 
 export class Entry {
-  static key = Symbol.for('cordis.entry')
+  static readonly key = Symbol.for('cordis.entry')
 
   public fork?: ForkScope
   public suspend = false
@@ -54,9 +54,17 @@ export class Entry {
 
   constructor(public loader: Loader, public parent: EntryGroup) {}
 
+  get id() {
+    let id = this.options.id
+    if (this.parent.tree.ctx.scope.entry) {
+      id = this.parent.tree.ctx.scope.entry.id + EntryTree.sep + id
+    }
+    return id
+  }
+
   resolveRealm(label: string | true) {
     if (label === true) {
-      return '#' + this.options.id
+      return '#' + this.id
     } else {
       return '@' + label
     }
@@ -87,7 +95,7 @@ export class Entry {
     for (const key in { ...oldMap, ...newMap, ...this.loader.delims }) {
       if (newMap[key] === oldMap[key]) continue
       const delim = this.loader.delims[key] ??= Symbol(`delim:${key}`)
-      ctx[delim] = Symbol(`${key}#${this.options.id}`)
+      ctx[delim] = Symbol(`${key}#${this.id}`)
       for (const symbol of [oldMap[key], newMap[key]]) {
         const value = symbol && ctx[symbol]
         if (!(value instanceof Object)) continue

packages/loader/src/group.ts

@@ -17,7 +17,7 @@ export class EntryGroup {
     // so we need to update the parent reference.
     entry.parent = this
     await entry.update(options, true)
-    return id
+    return entry.id
   }
 
   unlink(options: Entry.Options) {

packages/loader/src/loader.ts

@@ -131,7 +131,7 @@ export abstract class Loader extends ImportTree {
   }
 
   locate(ctx = this[Context.current]) {
-    return this._locate(ctx.scope).map(entry => entry.options.id)
+    return this._locate(ctx.scope).map(entry => entry.id)
   }
 
   _locate(scope: EffectScope): Entry[] {

packages/loader/src/tree.ts

@@ -4,6 +4,8 @@ import { Entry } from './entry.ts'
 import { EntryGroup } from './group.ts'
 
 export abstract class EntryTree {
+  static readonly sep = ':'
+
   public url!: string
   public root: EntryGroup
   public store: Dict<Entry> = Object.create(null)
@@ -31,10 +33,24 @@ export abstract class EntryTree {
     return options.id!
   }
 
+  resolve(id: string) {
+    const parts = id.split(EntryTree.sep)
+    let tree: EntryTree | undefined = this
+    const final = parts.pop()!
+    for (const part of parts) {
+      tree = tree.store[part]?.subtree
+      if (!tree) throw new Error(`cannot resolve entry ${id}`)
+    }
+    const entry = tree.store[final]
+    if (!entry) throw new Error(`cannot resolve entry ${id}`)
+    return entry
+  }
+
   resolveGroup(id: string | null) {
-    const group = id ? this.store[id]?.subgroup : this.root
-    if (!group) throw new Error(`entry ${id} not found`)
-    return group
+    if (!id) return this.root
+    const entry = this.resolve(id)
+    if (!entry.subgroup) throw new Error(`entry ${id} is not a group`)
+    return entry.subgroup
   }
 
   async create(options: Omit<Entry.Options, 'id'>, parent: string | null = null, position = Infinity) {
@@ -45,24 +61,22 @@ export abstract class EntryTree {
   }
 
   remove(id: string) {
-    const entry = this.store[id]
-    if (!entry) throw new Error(`entry ${id} not found`)
+    const entry = this.resolve(id)
     entry.parent.remove(id)
     entry.parent.tree.write()
   }
 
   async update(id: string, options: Omit<Entry.Options, 'id' | 'name'>, parent?: string | null, position?: number) {
-    const entry = this.store[id]
-    if (!entry) throw new Error(`entry ${id} not found`)
+    const entry = this.resolve(id)
     const source = entry.parent
-    source.tree.write()
     if (parent !== undefined) {
       const target = this.resolveGroup(parent)
       source.unlink(entry.options)
       target.data.splice(position ?? Infinity, 0, entry.options)
       target.tree.write()
       entry.parent = target
     }
+    source.tree.write()
     return entry.update(options)
   }