@operato/scene-storage 10.0.0-beta.32 → 10.0.0-beta.34

package/src/{asrs-rack.ts → storage-rack.ts}

@@ -14,10 +14,10 @@ import {
   type PlacementArchetype
 } from '@operato/scene-base'
 
-import { AsrsRack3D } from './asrs-rack-3d.js'
+import { StorageRack3D } from './storage-rack-3d.js'
 
-/** AsrsRack 컴포넌트 state */
-export interface AsrsRackState extends State {
+/** Rack 컴포넌트 state */
+export interface StorageRackState extends State {
   // ── 토폴로지 ──
   bays?: number
   levels?: number
@@ -47,12 +47,12 @@ const NATURE: ComponentNature = {
       placeholder: '# of horizontal bays (default 5)'
     }
   ],
-  help: 'scene/component/asrs-rack'
+  help: 'scene/component/rack'
 }
 
 // `ContainerAbstract` (not `Container`) — Container = MixinHTMLElement(ContainerAbstract),
 // which forces `isHTMLElement(): true` and trips the 3D pipeline's
-// addObject DOM-skip gate. ASRS rack lives only in the 3D scene graph.
+// addObject DOM-skip gate. Rack lives only in the 3D scene graph.
 //
 // Mixin chain: CellContainer → CarrierHolder → Placeable → ContainerAbstract
 //   CellContainer: cell topology (cellMap, cell(), findAvailableCell(), occupiedCellIds())
@@ -60,25 +60,31 @@ const NATURE: ComponentNature = {
 //   Placeable:     floor-archetype positioning
 //   ContainerAbstract: child component management
 /**
- * AsrsRack — a multi-level high-bay storage rack, the structural backbone of
- * an AS/RS (Automated Storage / Retrieval System).
+ * Rack — a multi-level storage shelf system. A *Storage* whose role is to hold
+ * carriers in a (bay × level) grid of cells.
  *
  * `levels` × `bays` cells form a vertical grid. Each cell holds one logistics
- * package (Pallet / Box / Parcel). A pair of AsrsRacks separated by an aisle
- * (where an AsrsCrane runs) is the typical AS/RS configuration.
+ * package (Pallet / Box / Parcel). A picker (Crane / Forklift / robot arm)
+ * accesses individual cells via Phase G/H Pickable contract — the picker is
+ * Rack-agnostic, knowing only how to interact with a cell.
  *
- * **Monitoring mode** (default): pallets/boxes are direct children of the rack,
- * placed by the WCS data binding. No RackCell children are created.
+ * **Monitoring mode** (default): carriers are direct children of the rack,
+ * placed by external data binding. No RackCell children are created.
  *
  * **Simulation mode**: call `rack._buildCells()` after placing the rack on the
- * scene. This creates RackCell children at the correct 3D positions. The
- * AsrsCrane then navigates to individual RackCells for pick-and-place.
+ * scene. This creates RackCell children at the correct 3D positions. A picker
+ * (Crane / Forklift / ...) then navigates to individual RackCells for
+ * pick-and-place.
  *
  * **Placement**: `floor` archetype, full ceiling depth by default.
+ *
+ * **Mobility**: this Rack is stationary. A `MobileRack = Mover(Rack)` mixin
+ * extension can be added later for AGV-mounted or cart-mounted variants —
+ * the cell topology and pickable contract stay the same.
  */
-@sceneComponent('asrs-rack')
-export default class AsrsRack extends CellContainer(CarrierHolder(Placeable(ContainerAbstract))) {
-  declare state: AsrsRackState
+@sceneComponent('storage-rack')
+export default class Rack extends CellContainer(CarrierHolder(Placeable(ContainerAbstract))) {
+  declare state: StorageRackState
 
   static placement: PlacementArchetype = 'floor'
   static align: Alignment = 'bottom'
@@ -125,7 +131,7 @@ export default class AsrsRack extends CellContainer(CarrierHolder(Placeable(Cont
    * Create RackCell child components for each cell in the CellMap.
    *
    * Called explicitly to enter simulation mode — monitoring-mode racks
-   * never call this (pallets are direct children, no explicit cells).
+   * never call this (carriers are direct children, no explicit cells).
    *
    * Idempotent: removes existing rack-cell children first.
    */
@@ -133,22 +139,22 @@ export default class AsrsRack extends CellContainer(CarrierHolder(Placeable(Cont
     // Remove existing rack-cell children
     const existing = (this.components as Component[] | undefined) ?? []
     for (const child of [...existing]) {
-      if ((child as any).state?.type === 'rack-cell') {
+      if ((child as any).state?.type === 'storage-cell') {
         this.removeComponent(child)
       }
     }
 
     // Create a RackCell for each cell in the map
-    const RackCellClass = (Component as any).register('rack-cell') as (new (...args: any[]) => Component) | undefined
+    const RackCellClass = (Component as any).register('storage-cell') as (new (...args: any[]) => Component) | undefined
     if (!RackCellClass) {
-      console.warn('AsrsRack._buildCells: rack-cell type not registered. Import rack-cell.ts first.')
+      console.warn('Rack._buildCells: rack-cell type not registered. Import rack-cell.ts first.')
       return
     }
 
     const context = this._app
     for (const cell of this.cellMap.cells) {
       const model = {
-        type: 'rack-cell',
+        type: 'storage-cell',
         cellId: cell.id,
         width: cell.size.width,
         height: cell.size.depth,  // 2D height = 3D Z depth
@@ -170,7 +176,7 @@ export default class AsrsRack extends CellContainer(CarrierHolder(Placeable(Cont
    *   - Everything else (sensors, labels, etc. can be siblings of the rack, not children).
    */
   containable(component: Component): boolean {
-    if ((component as any).state?.type === 'rack-cell') return true
+    if ((component as any).state?.type === 'storage-cell') return true
     const archetype = (component.constructor as any).placement
     if (archetype === 'operation') return true
     return component.isDescendible(this)
@@ -180,7 +186,7 @@ export default class AsrsRack extends CellContainer(CarrierHolder(Placeable(Cont
 
   /**
    * Attach frame for carriers that are DIRECT children of the rack
-   * (monitoring mode, where pallets go directly into the rack without
+   * (monitoring mode, where carriers go directly into the rack without
    * explicit RackCell components).
    *
    * In simulation mode, carriers become children of their RackCell,
@@ -198,7 +204,7 @@ export default class AsrsRack extends CellContainer(CarrierHolder(Placeable(Cont
 
   /**
    * 2D — top-down rectangle showing the rack footprint, with subdivisions
-   * suggesting the bay layout (lines parallel to the aisle).
+   * suggesting the bay layout.
    */
   render(ctx: CanvasRenderingContext2D) {
     const { width, height, left, top } = this.state
@@ -222,6 +228,6 @@ export default class AsrsRack extends CellContainer(CarrierHolder(Placeable(Cont
   // ── 3D ───────────────────────────────────────────────────────────────────
 
   buildRealObject(): RealObject | undefined {
-    return new AsrsRack3D(this)
+    return new StorageRack3D(this)
   }
 }

package/src/templates/index.ts

@@ -1,13 +1,20 @@
 /*
- * things-scene catalog templates for the storage domain — pallet/box/parcel
- * variants, ASRS rack/crane, ASRS aisle composite, and the virtual `spot` placement marker.
+ * things-scene catalog templates for the storage domain.
+ *
+ * Components:
+ *   - pallet / box / parcel — carriers
+ *   - rack — multi-level storage shelf (bays × levels)
+ *   - rack-table — bulk layout (rows × columns × shelves) helper
+ *   - crane — stacker picker (Mover + CarrierHolder + ContainerCapacity)
+ *   - mobile-rack — Mover(Rack), an AGV-mounted / cart-mounted moving rack
+ *   - spot — virtual placement marker
  */
 import spot from './spot.js'
 const pallet = new URL('../../icons/pallet.png', import.meta.url).href
 const box = new URL('../../icons/box.png', import.meta.url).href
 const parcel = new URL('../../icons/parcel.png', import.meta.url).href
-const asrsRack = new URL('../../icons/asrs-rack.png', import.meta.url).href
-const asrsCrane = new URL('../../icons/asrs-crane.png', import.meta.url).href
+const rack = new URL('../../icons/storage-rack.png', import.meta.url).href
+const crane = new URL('../../icons/crane.png', import.meta.url).href
 
 export default [
   {
@@ -80,12 +87,12 @@ export default [
     }
   },
   {
-    type: 'asrs-rack',
-    description: 'AS/RS storage rack (multi-level)',
+    type: 'storage-rack',
+    description: 'storage rack — multi-level shelves',
     group: 'storage',
-    icon: asrsRack,
+    icon: rack,
     model: {
-      type: 'asrs-rack',
+      type: 'storage-rack',
       top: 300,
       left: 100,
       width: 800,
@@ -95,12 +102,32 @@ export default [
     }
   },
   {
-    type: 'asrs-crane',
-    description: 'AS/RS stacker crane',
+    type: 'rack-grid',
+    description: 'rack table — N×M rack layout + auto location IDs',
     group: 'storage',
-    icon: asrsCrane,
+    icon: rack,
     model: {
-      type: 'asrs-crane',
+      type: 'rack-grid',
+      top: 100,
+      left: 100,
+      width: 1200,
+      height: 600,
+      rows: 2,
+      columns: 4,
+      shelves: 4,
+      zone: 'A',
+      locPattern: '{z}{s}-{u}-{sh}',
+      sectionDigits: 2,
+      unitDigits: 2
+    }
+  },
+  {
+    type: 'crane',
+    description: 'stacker crane — picker actor',
+    group: 'storage',
+    icon: crane,
+    model: {
+      type: 'crane',
       top: 550,
       left: 400,
       width: 100,
@@ -109,11 +136,26 @@ export default [
       carriageHeight: 100
     }
   },
+  {
+    type: 'mobile-storage-rack',
+    description: 'mobile rack — Mover(Rack), AGV/cart-mounted',
+    group: 'storage',
+    icon: rack,
+    model: {
+      type: 'mobile-storage-rack',
+      top: 300,
+      left: 100,
+      width: 400,
+      height: 200,
+      levels: 3,
+      bays: 3
+    }
+  },
   {
     type: 'group',
-    description: 'AS/RS aisle — 4-level rack pair + stacker crane',
+    description: 'storage aisle — rack pair + crane',
     group: 'storage',
-    icon: asrsRack,
+    icon: rack,
     model: {
       type: 'group',
       top: 100,
@@ -122,7 +164,7 @@ export default [
       height: 220,
       components: [
         {
-          type: 'asrs-rack',
+          type: 'storage-rack',
           top: 100,
           left: 100,
           width: 800,
@@ -131,7 +173,7 @@ export default [
           bays: 8
         },
         {
-          type: 'asrs-crane',
+          type: 'crane',
           top: 140,
           left: 420,
           width: 60,
@@ -140,7 +182,7 @@ export default [
           carriageHeight: 0
         },
         {
-          type: 'asrs-rack',
+          type: 'storage-rack',
           top: 320,
           left: 100,
           width: 800,

package/test/test-rack-grid-crane.ts

@@ -0,0 +1,212 @@
+/*
+ * Copyright © HatioLab Inc. All rights reserved.
+ *
+ * RackTable + Crane integration scenario — uses fake/minimal components to
+ * verify the location-based addressing flow:
+ *
+ *   1. RackTable owns N RackCells, each tagged with a locationId
+ *   2. Caller looks up source / target cells by locationId
+ *   3. Crane.fetch(sourceCell) — pick from source
+ *   4. Crane.deposit(carrier, targetCell) — place to target
+ *
+ * The fake infra mirrors test-rack-crane.ts so the actor (Crane) is the same
+ * concrete mixin chain; only the Cell wiring is RackTable-flavored.
+ */
+
+import 'should'
+import { ContainerCapacity, TRANSFER_SLOT_KEY } from '@hatiolab/things-scene'
+import Mover from '../../scene-base/src/mover.js'
+
+// ── Shared fake infrastructure ─────────────────────────────────────────────────
+
+class FakeBase {
+  _components: any[] = []
+  state: Record<string, any>
+  parent: any = null
+  root: any = null
+
+  constructor(state: Record<string, any> = {}) {
+    this.state = state
+  }
+
+  get components() {
+    return this._components
+  }
+
+  setState(keyOrObj: string | Record<string, any>, value?: any) {
+    if (typeof keyOrObj === 'object') {
+      Object.assign(this.state, keyOrObj)
+    } else {
+      this.state[keyOrObj as string] = value
+    }
+  }
+
+  getState(key: string) {
+    return this.state[key]
+  }
+
+  set(keyOrObj: string | Record<string, any>, value?: any) {
+    // mimic things-scene Component.set()
+    if (typeof keyOrObj === 'object') {
+      Object.assign(this.state, keyOrObj)
+    } else {
+      this.state[keyOrObj as string] = value
+    }
+  }
+
+  addComponent(child: any) {
+    if (child.parent && child.parent !== this) {
+      const idx = child.parent._components?.indexOf(child) ?? -1
+      if (idx >= 0) child.parent._components.splice(idx, 1)
+      child.parent = null
+    }
+    if (!this._components.includes(child)) {
+      this._components.push(child)
+    }
+    child.parent = this
+  }
+
+  removeComponent(child: any) {
+    const idx = this._components.indexOf(child)
+    if (idx >= 0) this._components.splice(idx, 1)
+    if (child.parent === this) child.parent = null
+  }
+
+  reparent(child: any, _options?: any) {
+    this.addComponent(child)
+  }
+
+  trigger(_name: string, ..._args: any[]) {}
+}
+
+function makeCarrier(zPos?: number) {
+  return {
+    parent: null as any,
+    state: { type: 'pallet', ...(zPos !== undefined ? { zPos } : {}) },
+    type: 'pallet',
+    [TRANSFER_SLOT_KEY]: undefined as any,
+    setState(_s: any) {},
+    set(_s: any) {}
+  }
+}
+
+class FakeRackCell extends ContainerCapacity(FakeBase as any) {
+  declare state: Record<string, any>
+
+  constructor(cellId: string, locationId: string) {
+    super({ type: 'storage-cell', cellId, locationId })
+  }
+
+  get slots() {
+    return [{ id: 'main', maxCount: 1 }]
+  }
+}
+
+class FakeCrane extends Mover(ContainerCapacity(FakeBase as any)) {
+  declare state: Record<string, any>
+
+  constructor() {
+    super({ status: 'idle' })
+  }
+
+  get slots() {
+    return [{ id: 'forks', maxCount: 1 }]
+  }
+
+  // Instant moveTo — bypasses things-scene's compile/path machinery which is
+  // not available in this Node-only test harness.
+  moveTo(_target: any, _options: any = {}): Promise<void> {
+    return Promise.resolve()
+  }
+
+  async engage(target: any, kind: 'pick' | 'place'): Promise<void> {
+    if (kind === 'pick') {
+      this.setState({ status: 'loading' })
+      const zPos = (target as any)?.state?.zPos
+      if (typeof zPos === 'number') this.setState({ carriageHeight: zPos })
+    } else {
+      this.setState({ status: 'unloading' })
+    }
+  }
+
+  fetch(carrier: any) {
+    return (this as any).pick(carrier)
+  }
+
+  deposit(carrier: any, cell: any) {
+    return (this as any).place(carrier, cell)
+  }
+}
+
+/**
+ * Fake RackTable — owns N FakeRackCells and exposes `getCellByLocation` that
+ * mimics RackTable.getCellByLocation (children iteration → state.locationId).
+ */
+class FakeRackTable extends FakeBase {
+  _cells = new Map<string, FakeRackCell>()
+
+  populate(cells: { cellId: string; locationId: string }[]) {
+    for (const { cellId, locationId } of cells) {
+      const cell = new FakeRackCell(cellId, locationId)
+      this.addComponent(cell)
+      this._cells.set(locationId, cell)
+    }
+  }
+
+  getCellByLocation(locationId: string): FakeRackCell | null {
+    return this._cells.get(locationId) ?? null
+  }
+}
+
+// ── Tests ──────────────────────────────────────────────────────────────────────
+
+describe('RackTable + Crane: locationId 기반 fetch / deposit 시나리오', () => {
+  it('locationId 로 cell 찾고 carrier 이동', async () => {
+    const table = new FakeRackTable()
+    table.populate([
+      { cellId: '0-0-0', locationId: 'A01-01-1' },
+      { cellId: '0-0-1', locationId: 'A01-01-2' },
+      { cellId: '0-0-2', locationId: 'A01-01-3' }
+    ])
+
+    const carrier = makeCarrier(100)
+    const cellA = table.getCellByLocation('A01-01-1')
+    cellA!.addComponent(carrier as any)
+
+    const crane = new FakeCrane()
+    await crane.fetch(carrier as any)
+    crane.state.status.should.equal('loading')
+    carrier.parent.should.equal(crane)
+
+    const cellB = table.getCellByLocation('A01-01-3')!
+    await crane.deposit(carrier as any, cellB as any)
+    crane.state.status.should.equal('unloading')
+    carrier.parent.should.equal(cellB)
+  })
+
+  it('존재하지 않는 locationId → null', () => {
+    const table = new FakeRackTable()
+    table.populate([{ cellId: '0-0-0', locationId: 'A01-01-1' }])
+    ;(table.getCellByLocation('X99-99-9') === null).should.be.true()
+  })
+
+  it('동일 carrier 를 동일 RackTable 안에서 cell-to-cell 이동', async () => {
+    const table = new FakeRackTable()
+    table.populate([
+      { cellId: '0-0-0', locationId: 'A01-01-1' },
+      { cellId: '0-1-0', locationId: 'A01-02-1' },
+      { cellId: '0-2-0', locationId: 'A01-03-1' }
+    ])
+
+    const carrier = makeCarrier()
+    const start = table.getCellByLocation('A01-01-1')!
+    start.addComponent(carrier as any)
+
+    const crane = new FakeCrane()
+    await (crane as any).pickAndPlace(carrier, table.getCellByLocation('A01-02-1') as any)
+    carrier.parent.should.equal(table.getCellByLocation('A01-02-1'))
+
+    await (crane as any).pickAndPlace(carrier, table.getCellByLocation('A01-03-1') as any)
+    carrier.parent.should.equal(table.getCellByLocation('A01-03-1'))
+  })
+})

package/test/test-rack-grid.ts

@@ -0,0 +1,77 @@
+/*
+ * Copyright © HatioLab Inc. All rights reserved.
+ *
+ * RackTable unit tests — pure helpers (parseShelfLabels, formatLocationId)
+ * + state-derived topology accessors (columnWidths, rowHeights).
+ *
+ * The full _buildRacks() + assignLocations() integration is exercised in
+ * test-rack-table-crane.ts where minimal fake Rack/RackCell mocks are
+ * wired through a Crane.
+ */
+
+import 'should'
+
+import { parseShelfLabels, formatLocationId, distribute } from '../src/rack-grid-helpers.js'
+
+describe('RackTable: parseShelfLabels', () => {
+  it('빈 문자열 → 1-based index fallback', () => {
+    parseShelfLabels('', 4).should.deepEqual(['1', '2', '3', '4'])
+  })
+  it('undefined → 1-based index fallback', () => {
+    parseShelfLabels(undefined, 3).should.deepEqual(['1', '2', '3'])
+  })
+  it('완전 명시 라벨 그대로', () => {
+    parseShelfLabels('A,B,C', 3).should.deepEqual(['A', 'B', 'C'])
+  })
+  it('부분 empty entries 는 default 로 fallback', () => {
+    parseShelfLabels(',,,04', 4).should.deepEqual(['1', '2', '3', '04'])
+  })
+  it('input 보다 levels 가 많으면 나머지는 default', () => {
+    parseShelfLabels('A,B', 4).should.deepEqual(['A', 'B', '3', '4'])
+  })
+  it('input 이 levels 보다 많으면 잘림', () => {
+    parseShelfLabels('A,B,C,D,E', 3).should.deepEqual(['A', 'B', 'C'])
+  })
+  it('공백 trim', () => {
+    parseShelfLabels(' A , B , C ', 3).should.deepEqual(['A', 'B', 'C'])
+  })
+})
+
+describe('RackTable: formatLocationId', () => {
+  it('default 패턴 {z}{s}-{u}-{sh}', () => {
+    formatLocationId('A', '01', '02', '3', '{z}{s}-{u}-{sh}').should.equal('A01-02-3')
+  })
+  it('zone 빈 값', () => {
+    formatLocationId('', '01', '02', '1', '{z}{s}-{u}-{sh}').should.equal('01-02-1')
+  })
+  it('section/unit zero-padded 4자리', () => {
+    formatLocationId('Z', '0042', '0007', '3', '{z}S{s}U{u}-{sh}').should.equal('ZS0042U0007-3')
+  })
+  it('placeholder 없는 패턴 그대로', () => {
+    formatLocationId('A', '01', '02', '3', 'fixed').should.equal('fixed')
+  })
+  it('동일 placeholder 여러 번', () => {
+    formatLocationId('A', '01', '02', '3', '{z}{z}{s}{s}').should.equal('AA0101')
+  })
+  it('shelf 라벨 문자', () => {
+    formatLocationId('A', '01', '02', 'TOP', '{z}{s}-{u}-{sh}').should.equal('A01-02-TOP')
+  })
+})
+
+describe('RackTable: distribute (per-column / per-row sizing)', () => {
+  it('declared 없음 → 모두 균등', () => {
+    distribute(1000, 4).should.deepEqual([250, 250, 250, 250])
+  })
+  it('전부 declared → 그대로', () => {
+    distribute(1000, 3, [100, 200, 300]).should.deepEqual([100, 200, 300])
+  })
+  it('일부 declared → 나머지가 remaining 균등 분배', () => {
+    distribute(1000, 4, [200, undefined, 300, undefined]).should.deepEqual([200, 250, 300, 250])
+  })
+  it('declared 합이 total 초과 → 나머지는 0', () => {
+    distribute(500, 3, [400, 200, undefined]).should.deepEqual([400, 200, 0])
+  })
+  it('n=1 + declared 비어있음', () => {
+    distribute(800, 1).should.deepEqual([800])
+  })
+})

package/test/{test-asrs-crane.ts → test-storage-rack-crane.ts}

@@ -1,14 +1,14 @@
 /*
  * Copyright © HatioLab Inc. All rights reserved.
  *
- * AsrsCrane integration tests — pick/place data-flow for the ASRS crane.
+ * Crane integration tests — pick/place data-flow for the crane.
  *
  * Uses fake/minimal containers (no DOM, no Three.js, no RAF) so they run in
  * Node with tsx.
  *
  * Test infrastructure mirrors test-transfer-scenarios.ts in scene-base:
  *   - FakeBase: minimal child-tracking container with setState support
- *   - FakeCrane: Mover(ContainerCapacity(FakeBase)) — instant moveTo, AsrsCrane
+ *   - FakeCrane: Mover(ContainerCapacity(FakeBase)) — instant moveTo, Crane
  *     engage() semantics (status + carriageHeight), slots = [{id:'forks', maxCount:1}]
  *   - FakeRackCell: mimics RackCell.receive / dispatch / canReceive protocol
  */
@@ -81,7 +81,7 @@ function makeCarrier(zPos?: number) {
 }
 
 // FakeCrane: Mover(ContainerCapacity(FakeBase)) with instant moveTo +
-// AsrsCrane engage() semantics (status + carriageHeight snap from carrier.state.zPos).
+// Crane engage() semantics (status + carriageHeight snap from carrier.state.zPos).
 const FakeCraneBase = Mover(ContainerCapacity(FakeBase as any))
 
 class FakeCrane extends (FakeCraneBase as any) {
@@ -107,12 +107,12 @@ class FakeCrane extends (FakeCraneBase as any) {
     }
   }
 
-  /** Semantic alias for pick (matches AsrsCrane.fetch). */
+  /** Semantic alias for pick (matches Crane.fetch). */
   fetch(carrier: any, options?: any): Promise<void> {
     return (this as any).pick(carrier, options)
   }
 
-  /** Semantic alias for place (matches AsrsCrane.deposit). */
+  /** Semantic alias for place (matches Crane.deposit). */
   deposit(carrier: any, cell: any, options?: any): Promise<void> {
     return (this as any).place(carrier, cell, options)
   }
@@ -150,7 +150,7 @@ class FakeRackCell extends FakeBase {
 
 // ── Scenario 1: fetch (pick) ──────────────────────────────────────────────────
 
-describe('AsrsCrane: fetch (pick)', () => {
+describe('Crane: fetch (pick)', () => {
   it('fetch 후 carrier가 crane의 child', async () => {
     const crane = new FakeCrane()
     const carrier = makeCarrier()
@@ -220,7 +220,7 @@ describe('AsrsCrane: fetch (pick)', () => {
 
 // ── Scenario 2: deposit (place) ───────────────────────────────────────────────
 
-describe('AsrsCrane: deposit (place)', () => {
+describe('Crane: deposit (place)', () => {
   it('deposit 후 carrier가 rackCell의 child', async () => {
     const crane = new FakeCrane()
     const cell = new FakeRackCell({ cellId: 'cell-1-0-2' })
@@ -264,7 +264,7 @@ describe('AsrsCrane: deposit (place)', () => {
 
 // ── Scenario 3: fetch → deposit 전체 사이클 ──────────────────────────────────
 
-describe('AsrsCrane: fetch → deposit 전체 사이클', () => {
+describe('Crane: fetch → deposit 전체 사이클', () => {
   it('cell-A → crane → cell-B', async () => {
     const crane = new FakeCrane()
     const cellA = new FakeRackCell({ cellId: 'cell-0-0-0' })