@shipload/sdk 1.0.0-next.26 → 1.0.0-next.28

package/src/derivation/stars.test.ts

@@ -0,0 +1,51 @@
+import {expect, test} from 'bun:test'
+import {
+    MAX_STARS_PER_STAT,
+    MAX_STAR_RATING,
+    starRating,
+    starsForStat,
+    statMagnitude,
+    STAR_STEP,
+} from './stars'
+
+test('starsForStat bands at the 250 boundaries', () => {
+    expect(starsForStat(0)).toBe(0)
+    expect(starsForStat(1)).toBe(0)
+    expect(starsForStat(249)).toBe(0)
+    expect(starsForStat(250)).toBe(1)
+    expect(starsForStat(499)).toBe(1)
+    expect(starsForStat(500)).toBe(2)
+    expect(starsForStat(749)).toBe(2)
+    expect(starsForStat(750)).toBe(3)
+})
+
+test('starsForStat clamps to MAX_STARS_PER_STAT', () => {
+    expect(starsForStat(999)).toBe(MAX_STARS_PER_STAT)
+    expect(starsForStat(1000)).toBe(MAX_STARS_PER_STAT)
+    expect(starsForStat(10_000)).toBe(MAX_STARS_PER_STAT)
+})
+
+test('starsForStat never goes negative', () => {
+    expect(starsForStat(-50)).toBe(0)
+})
+
+test('starRating sums per-stat stars to a 0-9 grade', () => {
+    expect(starRating(0, 0, 0)).toBe(0)
+    expect(starRating(250, 0, 0)).toBe(1)
+    expect(starRating(750, 750, 750)).toBe(MAX_STAR_RATING)
+    expect(starRating(999, 999, 999)).toBe(MAX_STAR_RATING)
+    expect(starRating(599, 599, 599)).toBe(6)
+    expect(starRating(251, 251, 251)).toBe(3)
+})
+
+test('statMagnitude sums raw values for tiebreaking', () => {
+    expect(statMagnitude(599, 599, 599)).toBe(1797)
+    expect(statMagnitude(251, 251, 251)).toBe(753)
+    expect(statMagnitude(599, 599, 599)).toBeGreaterThan(statMagnitude(251, 251, 251))
+})
+
+test('constants hold their documented values', () => {
+    expect(STAR_STEP).toBe(250)
+    expect(MAX_STARS_PER_STAT).toBe(3)
+    expect(MAX_STAR_RATING).toBe(9)
+})

package/src/derivation/stars.ts

@@ -0,0 +1,15 @@
+export const STAR_STEP = 250
+export const MAX_STARS_PER_STAT = 3
+export const MAX_STAR_RATING = MAX_STARS_PER_STAT * 3
+
+export function starsForStat(value: number): number {
+    return Math.max(0, Math.min(MAX_STARS_PER_STAT, Math.floor(value / STAR_STEP)))
+}
+
+export function starRating(stat1: number, stat2: number, stat3: number): number {
+    return starsForStat(stat1) + starsForStat(stat2) + starsForStat(stat3)
+}
+
+export function statMagnitude(stat1: number, stat2: number, stat3: number): number {
+    return stat1 + stat2 + stat3
+}

package/src/derivation/stats.ts

@@ -73,10 +73,11 @@ const GAS_STATS: StatDefinition[] = [
 
 const REGOLITH_STATS: StatDefinition[] = [
     {
-        key: 'composition',
-        label: 'Composition',
-        abbreviation: 'COM',
-        purpose: 'Mineral/metal mix — drives sensor, chip, and optic crafting quality',
+        key: 'cohesion',
+        label: 'Cohesion',
+        abbreviation: 'COH',
+        purpose:
+            'Binding strength of the loose aggregate; higher cohesion yields more rigid frames and hulls',
     },
     {
         key: 'hardness',

package/src/entities/entity.ts

@@ -28,7 +28,7 @@ export class Entity extends ServerContract.Types.entity_info {
     }
 
     get isIdle(): boolean {
-        return this.is_idle
+        return schedule.isIdle(this)
     }
 
     get sched(): ScheduleAccessor {

package/src/entities/makers.ts

@@ -11,6 +11,7 @@ import {getItem} from '../data/catalog'
 import {getModuleCapabilityType, moduleAccepts, moduleSlotTypeToCode} from '../capabilities/modules'
 import {computeEntityCapabilities} from '../derivation/capabilities'
 import {packedModulesToInstalled} from './slot-multiplier'
+import {LANE_MOBILITY} from '../scheduling/schedule'
 
 export interface PackedModuleInput {
     itemId: number
@@ -29,6 +30,7 @@ export interface EntityStateInput {
     energy?: number
     modules?: PackedModuleInput[]
     schedule?: ServerContract.Types.schedule
+    lanes?: ServerContract.Types.lane[]
     cargo?: ServerContract.Types.cargo_item[]
 }
 
@@ -73,7 +75,7 @@ const ZERO_HULL_STATS: Record<string, number> = {
     density: 0,
     strength: 0,
     hardness: 0,
-    saturation: 0,
+    cohesion: 0,
 }
 
 export function makeEntity(packedItemId: number, state: EntityStateInput): Entity {
@@ -86,6 +88,17 @@ export function makeEntity(packedItemId: number, state: EntityStateInput): Entit
     const layout = getEntityLayout(packedItemId)?.slots ?? []
     const mods = state.modules ?? []
 
+    const lanes =
+        state.lanes ??
+        (state.schedule
+            ? [
+                  ServerContract.Types.lane.from({
+                      lane_key: UInt8.from(LANE_MOBILITY),
+                      schedule: state.schedule,
+                  }),
+              ]
+            : [])
+
     const info: Record<string, unknown> = {
         type: template.kind,
         id: UInt64.from(state.id),
@@ -95,14 +108,10 @@ export function makeEntity(packedItemId: number, state: EntityStateInput): Entit
         item_id: UInt16.from(state.itemId ?? template.itemId),
         cargomass: UInt32.from(state.cargomass ?? 0),
         cargo: state.cargo || [],
-        is_idle: !state.schedule,
-        current_task_elapsed: UInt32.from(0),
-        current_task_remaining: UInt32.from(0),
-        pending_tasks: [],
+        lanes,
     }
 
     if (state.energy !== undefined) info.energy = UInt16.from(state.energy)
-    if (state.schedule) info.schedule = state.schedule
 
     if (kind === 'container') {
         info.modules = []

package/src/index-module.ts

@@ -28,6 +28,7 @@ export type movement_stats = ServerContract.Types.movement_stats
 export type energy_stats = ServerContract.Types.energy_stats
 export type loader_stats = ServerContract.Types.loader_stats
 export type schedule = ServerContract.Types.schedule
+export type lane = ServerContract.Types.lane
 export type task = ServerContract.Types.task
 export type cargo_item = ServerContract.Types.cargo_item
 export type entity_row = ServerContract.Types.entity_row
@@ -132,6 +133,15 @@ export type {EffectiveReserveInput} from './derivation'
 export {getStatDefinitions, getStatName, resolveStats} from './derivation'
 export type {StatDefinition, NamedStats} from './derivation'
 
+export {
+    STAR_STEP,
+    MAX_STARS_PER_STAT,
+    MAX_STAR_RATING,
+    starsForStat,
+    starRating,
+    statMagnitude,
+} from './derivation'
+
 export {hash, hash512} from './utils/hash'
 
 export {
@@ -177,7 +187,19 @@ export type {
 } from './travel/travel'
 
 export * as schedule from './scheduling/schedule'
-export type {Scheduleable, ScheduleData} from './scheduling/schedule'
+export {LANE_MOBILITY, LANE_BARRIER} from './scheduling/schedule'
+export type {
+    ScheduleData,
+    LaneView,
+    OrderedTask,
+    ResolvedEvent,
+} from './scheduling/schedule'
+export {
+    candidateLaneCompletesAt,
+    laneKeyForModule,
+    rawScheduleEnd,
+    workerLaneKey,
+} from './scheduling/lanes'
 export {ScheduleAccessor, createScheduleAccessor} from './scheduling/accessor'
 export {InventoryAccessor, createInventoryAccessor} from './entities/inventory-accessor'
 export type {HasCargo} from './entities/inventory-accessor'
@@ -191,13 +213,11 @@ export {
     createProjectedEntity,
     projectEntity,
     projectEntityAt,
-    projectFromCurrentState,
-    projectFromCurrentStateAt,
+    projectRemainingAt,
     validateSchedule,
 } from './scheduling/projection'
 export type {
     Projectable,
-    ProjectableSnapshot,
     ProjectedEntity,
     ProjectionOptions,
 } from './scheduling/projection'
@@ -205,6 +225,15 @@ export type {
 export {taskCargoChanges} from './scheduling/task-cargo'
 export type {TaskCargoChange, TaskCargoDirection} from './scheduling/task-cargo'
 
+export {
+    projectedCargoAvailableAt,
+    availableForItem,
+    cargoReadyAt,
+    taskCargoEffect,
+} from './scheduling/availability'
+
+export {maxCraftable} from './capabilities/craftable'
+
 export {energyAtTime} from './scheduling/energy'
 
 export * from './types/capabilities'

package/src/managers/actions.ts

@@ -65,13 +65,22 @@ export class ActionsManager extends BaseManager {
         return this.server.action('resolve', params)
     }
 
-    cancel(entityId: UInt64Type, count: UInt64Type): Action {
+    cancel(entityId: UInt64Type, laneKey: number, count: UInt64Type): Action {
         return this.server.action('cancel', {
             id: UInt64.from(entityId),
+            lane_key: UInt8.from(laneKey),
             count: UInt64.from(count),
         })
     }
 
+    retarget(sourceId: UInt64Type, taskIndex: UInt64Type, newDestId: UInt64Type): Action {
+        return this.server.action('retarget', {
+            source_id: UInt64.from(sourceId),
+            task_index: UInt64.from(taskIndex),
+            new_dest_id: UInt64.from(newDestId),
+        })
+    }
+
     recharge(entityId: UInt64Type): Action {
         return this.server.action('recharge', {
             id: UInt64.from(entityId),

package/src/managers/construction.ts

@@ -4,6 +4,7 @@ import type {ServerContract} from '../contracts'
 import {PlotManager} from './plot'
 import {getItem} from '../data/catalog'
 import {calc_craft_duration} from '../capabilities/crafting'
+import {getLanes, getTasks} from '../scheduling/schedule'
 import {TaskType} from '../types'
 import type {
     BuildableTarget,
@@ -94,43 +95,43 @@ export class ConstructionManager extends BaseManager {
         const buckets = new Map<string, Map<string, InboundTransfer>>()
         const nowMs = now.getTime()
         for (const entity of entities) {
-            const schedule = entity.schedule
-            if (!schedule) continue
             const entityIdStr = entity.id.toString()
             const sourceName = entity.entity_name || entityIdStr
-            const startedMs = schedule.started.toDate().getTime()
-            let cumulativeSec = 0
-            for (const task of schedule.tasks) {
-                cumulativeSec += task.duration.toNumber()
-                if (!isTransferTask(task)) continue
-                if (!task.entitytarget) continue
-                const projectedEndMs = startedMs + cumulativeSec * 1000
-                if (projectedEndMs < nowMs) continue
-                const targetIdStr = task.entitytarget.entity_id.toString()
-                const etaSeconds = Math.max(0, Math.round((projectedEndMs - nowMs) / 1000))
-                let perTarget = buckets.get(targetIdStr)
-                if (!perTarget) {
-                    perTarget = new Map()
-                    buckets.set(targetIdStr, perTarget)
-                }
-                for (const c of task.cargo) {
-                    const itemId = c.item_id.toNumber()
-                    const quantity = c.quantity.toNumber()
-                    if (quantity === 0) continue
-                    const key = `${entityIdStr}#${itemId}`
-                    const existing = perTarget.get(key)
-                    if (existing) {
-                        existing.quantity += quantity
-                        existing.etaSeconds = Math.min(existing.etaSeconds, etaSeconds)
-                    } else {
-                        perTarget.set(key, {
-                            sourceEntityId: entity.id,
-                            sourceEntityType: entity.type,
-                            sourceName,
-                            itemId,
-                            quantity,
-                            etaSeconds,
-                        })
+            for (const lane of getLanes(entity)) {
+                const startedMs = lane.schedule.started.toDate().getTime()
+                let cumulativeSec = 0
+                for (const task of lane.schedule.tasks) {
+                    cumulativeSec += task.duration.toNumber()
+                    if (!isTransferTask(task)) continue
+                    if (!task.entitytarget) continue
+                    const projectedEndMs = startedMs + cumulativeSec * 1000
+                    if (projectedEndMs < nowMs) continue
+                    const targetIdStr = task.entitytarget.entity_id.toString()
+                    const etaSeconds = Math.max(0, Math.round((projectedEndMs - nowMs) / 1000))
+                    let perTarget = buckets.get(targetIdStr)
+                    if (!perTarget) {
+                        perTarget = new Map()
+                        buckets.set(targetIdStr, perTarget)
+                    }
+                    for (const c of task.cargo) {
+                        const itemId = c.item_id.toNumber()
+                        const quantity = c.quantity.toNumber()
+                        if (quantity === 0) continue
+                        const key = `${entityIdStr}#${itemId}`
+                        const existing = perTarget.get(key)
+                        if (existing) {
+                            existing.quantity += quantity
+                            existing.etaSeconds = Math.min(existing.etaSeconds, etaSeconds)
+                        } else {
+                            perTarget.set(key, {
+                                sourceEntityId: entity.id,
+                                sourceEntityType: entity.type,
+                                sourceName,
+                                itemId,
+                                quantity,
+                                etaSeconds,
+                            })
+                        }
                     }
                 }
             }
@@ -152,25 +153,24 @@ export class ConstructionManager extends BaseManager {
         completesAt: number
         hasStarted: boolean
     } | null {
-        const schedule = plot.schedule
-        if (!schedule) return null
-        const tasks = schedule.tasks
-        const startedMs = schedule.started.toDate().getTime()
-        let startSec = 0
-        for (const task of tasks) {
-            if (task.type.toNumber() === TaskType.RESERVED) {
-                if (!task.entitytarget) return null
-                const startsAt = startedMs + startSec * 1000
-                const completesAt = startsAt + task.duration.toNumber() * 1000
-                return {
-                    builderId: task.entitytarget.entity_id,
-                    group: task.entitygroup ?? undefined,
-                    startsAt,
-                    completesAt,
-                    hasStarted: startsAt <= now.getTime(),
+        for (const lane of getLanes(plot)) {
+            const startedMs = lane.schedule.started.toDate().getTime()
+            let startSec = 0
+            for (const task of lane.schedule.tasks) {
+                if (task.type.toNumber() === TaskType.RESERVED) {
+                    if (!task.entitytarget) return null
+                    const startsAt = startedMs + startSec * 1000
+                    const completesAt = startsAt + task.duration.toNumber() * 1000
+                    return {
+                        builderId: task.entitytarget.entity_id,
+                        group: task.entitygroup ?? undefined,
+                        startsAt,
+                        completesAt,
+                        hasStarted: startsAt <= now.getTime(),
+                    }
                 }
+                startSec += task.duration.toNumber()
             }
-            startSec += task.duration.toNumber()
         }
         return null
     }
@@ -179,19 +179,22 @@ export class ConstructionManager extends BaseManager {
         builder: ServerContract.Types.entity_info | undefined,
         group: UInt64 | undefined
     ): {cancelable: boolean; blockingTaskCount: number} {
-        if (!builder?.schedule || group === undefined) {
+        if (!builder || group === undefined) {
             return {cancelable: false, blockingTaskCount: 0}
         }
-        const tasks = builder.schedule.tasks
-        const buildIdx = tasks.findIndex(
-            (t) =>
-                t.type.toNumber() === TaskType.BUILDPLOT &&
-                t.entitygroup !== undefined &&
-                t.entitygroup.equals(group)
-        )
-        if (buildIdx < 0) return {cancelable: false, blockingTaskCount: 0}
-        const trailing = tasks.length - 1 - buildIdx
-        return {cancelable: trailing === 0, blockingTaskCount: trailing}
+        for (const lane of getLanes(builder)) {
+            const tasks = lane.schedule.tasks
+            const buildIdx = tasks.findIndex(
+                (t) =>
+                    t.type.toNumber() === TaskType.BUILDPLOT &&
+                    t.entitygroup !== undefined &&
+                    t.entitygroup.equals(group)
+            )
+            if (buildIdx < 0) continue
+            const trailing = tasks.length - 1 - buildIdx
+            return {cancelable: trailing === 0, blockingTaskCount: trailing}
+        }
+        return {cancelable: false, blockingTaskCount: 0}
     }
 
     private buildFromReservation(
@@ -357,9 +360,8 @@ function isTransferTask(task: ServerContract.Types.task): boolean {
 }
 
 function reservationsOf(source: ServerContract.Types.entity_info): Reservation[] {
-    if (!source.schedule) return []
     const out = new Map<string, Reservation>()
-    for (const task of source.schedule.tasks) {
+    for (const task of getTasks(source)) {
         if (!isTransferTask(task)) continue
         if (!task.entitytarget) continue
         const targetType = task.entitytarget.entity_type

package/src/nft/buildImmutableData.ts

@@ -224,21 +224,23 @@ export function buildModuleImmutable(
         }
         case MODULE_CRAFTER: {
             const rea = decodeStat(stats, 0)
-            const com = decodeStat(stats, 1)
+            const fin = decodeStat(stats, 1)
             base.push({first: 'reactivity', second: ['uint16', rea]})
-            base.push({first: 'composition', second: ['uint16', com]})
+            base.push({first: 'fineness', second: ['uint16', fin]})
             base.push({first: 'speed', second: ['uint16', computeCrafterSpeed(rea)]})
-            base.push({first: 'drain', second: ['uint16', computeCrafterDrain(com)]})
+            base.push({first: 'drain', second: ['uint16', computeCrafterDrain(fin)]})
             break
         }
         case MODULE_STORAGE: {
             const str = decodeStat(stats, 0)
-            const fin = decodeStat(stats, 1)
-            const sat = decodeStat(stats, 2)
-            const sum = str + fin + sat
+            const den = decodeStat(stats, 1)
+            const hrd = decodeStat(stats, 2)
+            const com = decodeStat(stats, 3)
+            const sum = str + den + hrd + com
             base.push({first: 'strength', second: ['uint16', str]})
-            base.push({first: 'fineness', second: ['uint16', fin]})
-            base.push({first: 'saturation', second: ['uint16', sat]})
+            base.push({first: 'density', second: ['uint16', den]})
+            base.push({first: 'hardness', second: ['uint16', hrd]})
+            base.push({first: 'cohesion', second: ['uint16', com]})
             base.push({
                 first: 'capacity_bonus_pct',
                 second: ['uint16', 10 + Math.floor((sum * 10) / 2997)],
@@ -247,13 +249,13 @@ export function buildModuleImmutable(
         }
         case MODULE_HAULER: {
             const res = decodeStat(stats, 0)
-            const con = decodeStat(stats, 1)
+            const pla = decodeStat(stats, 1)
             const ref = decodeStat(stats, 2)
             base.push({first: 'resonance', second: ['uint16', res]})
-            base.push({first: 'conductivity', second: ['uint16', con]})
+            base.push({first: 'plasticity', second: ['uint16', pla]})
             base.push({first: 'reflectivity', second: ['uint16', ref]})
             base.push({first: 'capacity', second: ['uint8', computeHaulerCapacity(res)]})
-            base.push({first: 'efficiency', second: ['uint16', computeHaulerEfficiency(con)]})
+            base.push({first: 'efficiency', second: ['uint16', computeHaulerEfficiency(pla)]})
             base.push({first: 'drain', second: ['uint16', computeHaulerDrain(ref)]})
             break
         }

package/src/nft/description.ts

@@ -162,9 +162,9 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
         }
         case MODULE_HAULER: {
             const res = decodeStat(stats, 0)
-            const con = decodeStat(stats, 1)
+            const pla = decodeStat(stats, 1)
             const ref = decodeStat(stats, 2)
-            out += `  Capacity ${computeHaulerCapacity(res)}  Efficiency ${computeHaulerEfficiency(con)}  Drain ${computeHaulerDrain(ref)}`
+            out += `  Capacity ${computeHaulerCapacity(res)}  Efficiency ${computeHaulerEfficiency(pla)}  Drain ${computeHaulerDrain(ref)}`
             break
         }
         case MODULE_WARP: {

package/src/resolution/resolve-item.ts

@@ -222,8 +222,8 @@ function computeCapabilityGroup(
             const str = stats.strength
             const den = stats.density
             const hrd = stats.hardness
-            const sat = stats.saturation
-            const statSum = str + den + hrd + sat
+            const com = stats.cohesion
+            const statSum = str + den + hrd + com
             const pct = 10 + Math.floor((statSum * 10) / 2997)
             return {capability: 'Storage', attributes: [{label: 'Capacity Bonus', value: pct}]}
         }

package/src/scheduling/accessor.ts

@@ -1,86 +1,128 @@
 import type {ServerContract} from '../contracts'
 import type {TaskType} from '../types'
-import type {ScheduleData} from './schedule'
-import * as schedule from './schedule'
+import * as core from './lane-core'
+import {
+    activeTasks,
+    getLane,
+    getLanes,
+    hasSchedule,
+    isIdle,
+    LANE_MOBILITY,
+    type LaneView,
+    type ScheduleData,
+} from './schedule'
 
 type Task = ServerContract.Types.task
 
 export class ScheduleAccessor {
-    constructor(private entity: ScheduleData) {}
+    private _laneResolved = false
+    private _lane: LaneView | undefined
+
+    constructor(
+        private entity: ScheduleData,
+        private laneKey: number = LANE_MOBILITY
+    ) {}
+
+    private get lane(): LaneView | undefined {
+        if (!this._laneResolved) {
+            this._lane = getLane(this.entity, this.laneKey)
+            this._laneResolved = true
+        }
+        return this._lane
+    }
+
+    forLane(laneKey: number): ScheduleAccessor {
+        return new ScheduleAccessor(this.entity, laneKey)
+    }
+
+    get lanes(): LaneView[] {
+        return getLanes(this.entity)
+    }
 
     get hasSchedule(): boolean {
-        return schedule.hasSchedule(this.entity)
+        return hasSchedule(this.entity)
     }
 
     get isIdle(): boolean {
-        return schedule.isIdle(this.entity)
+        return isIdle(this.entity)
     }
 
     get tasks(): Task[] {
-        return schedule.getTasks(this.entity)
+        return this.lane?.schedule.tasks ?? []
+    }
+
+    activeTasks(now: Date): Task[] {
+        return activeTasks(this.entity, now)
     }
 
     duration(): number {
-        return schedule.scheduleDuration(this.entity)
+        return this.lane ? core.laneDuration(this.lane.schedule) : 0
     }
 
     elapsed(now: Date): number {
-        return schedule.scheduleElapsed(this.entity, now)
+        return this.lane ? core.laneElapsed(this.lane.schedule, now) : 0
     }
 
     remaining(now: Date): number {
-        return schedule.scheduleRemaining(this.entity, now)
+        return this.lane ? core.laneRemaining(this.lane.schedule, now) : 0
+    }
+
+    startsIn(now: Date): number {
+        return this.lane ? core.laneStartsIn(this.lane.schedule, now) : 0
     }
 
     complete(now: Date): boolean {
-        return schedule.scheduleComplete(this.entity, now)
+        return this.lane ? core.laneComplete(this.lane.schedule, now) : false
     }
 
     currentTaskIndex(now: Date): number {
-        return schedule.currentTaskIndex(this.entity, now)
+        return this.lane ? core.currentTaskIndexForLane(this.lane.schedule, now) : -1
     }
 
     currentTask(now: Date): Task | undefined {
-        return schedule.currentTask(this.entity, now)
+        return this.lane ? core.currentTask(this.lane.schedule, now) : undefined
     }
 
     currentTaskType(now: Date): TaskType | undefined {
-        return schedule.currentTaskType(this.entity, now)
+        return this.lane ? core.currentTaskType(this.lane.schedule, now) : undefined
     }
 
     taskStartTime(index: number): number {
-        return schedule.getTaskStartTime(this.entity, index)
+        return this.lane ? core.laneTaskStartTime(this.lane.schedule, index) : 0
     }
 
     taskElapsed(index: number, now: Date): number {
-        return schedule.getTaskElapsed(this.entity, index, now)
+        return this.lane ? core.laneTaskElapsed(this.lane.schedule, index, now) : 0
     }
 
     taskRemaining(index: number, now: Date): number {
-        return schedule.getTaskRemaining(this.entity, index, now)
+        return this.lane ? core.laneTaskRemaining(this.lane.schedule, index, now) : 0
     }
 
     taskComplete(index: number, now: Date): boolean {
-        return schedule.isTaskComplete(this.entity, index, now)
+        return this.lane ? core.laneTaskComplete(this.lane.schedule, index, now) : false
     }
 
     taskInProgress(index: number, now: Date): boolean {
-        return schedule.isTaskInProgress(this.entity, index, now)
+        return this.lane ? core.laneTaskInProgress(this.lane.schedule, index, now) : false
     }
 
     currentTaskProgress(now: Date): number {
-        return schedule.currentTaskProgress(this.entity, now)
+        return this.lane ? core.currentTaskProgress(this.lane.schedule, now) : 0
     }
 
     currentTaskProgressFloat(now: Date): number {
-        return schedule.currentTaskProgressFloat(this.entity, now)
+        return this.lane ? core.currentTaskProgressFloatForLane(this.lane.schedule, now) : 0
     }
 
     progress(now: Date): number {
-        return schedule.scheduleProgress(this.entity, now)
+        return this.lane ? core.laneProgress(this.lane.schedule, now) : 0
     }
 }
 
-export function createScheduleAccessor(entity: ScheduleData): ScheduleAccessor {
-    return new ScheduleAccessor(entity)
+export function createScheduleAccessor(
+    entity: ScheduleData,
+    laneKey: number = LANE_MOBILITY
+): ScheduleAccessor {
+    return new ScheduleAccessor(entity, laneKey)
 }