@shipload/sdk 1.0.0-next.4 → 1.0.0-next.5

package/src/data/metadata.ts

@@ -11,7 +11,7 @@ export interface EntityMetadata {
 }
 
 export const itemMetadata: Record<number, ItemMetadata> = {
-    // === Resources (raw) ===
+    // === Resources / Ore ===
     101: {name: 'Ore', description: 'Crude metallic ore.', color: '#C26D3F'},
     102: {name: 'Ore', description: 'Refined metallic ore with improved purity.', color: '#C26D3F'},
     103: {
@@ -19,6 +19,15 @@ export const itemMetadata: Record<number, ItemMetadata> = {
         description: 'High-grade metallic ore with exceptional density.',
         color: '#C26D3F',
     },
+    104: {name: 'Ore', description: '', color: '#C26D3F'},
+    105: {name: 'Ore', description: '', color: '#C26D3F'},
+    106: {name: 'Ore', description: '', color: '#C26D3F'},
+    107: {name: 'Ore', description: '', color: '#C26D3F'},
+    108: {name: 'Ore', description: '', color: '#C26D3F'},
+    109: {name: 'Ore', description: '', color: '#C26D3F'},
+    110: {name: 'Ore', description: '', color: '#C26D3F'},
+
+    // === Resources / Crystal ===
     201: {name: 'Crystal', description: 'Raw resonant crystal.', color: '#4ADBFF'},
     202: {
         name: 'Crystal',
@@ -30,6 +39,15 @@ export const itemMetadata: Record<number, ItemMetadata> = {
         description: 'High-grade resonant crystal with exceptional purity.',
         color: '#4ADBFF',
     },
+    204: {name: 'Crystal', description: '', color: '#4ADBFF'},
+    205: {name: 'Crystal', description: '', color: '#4ADBFF'},
+    206: {name: 'Crystal', description: '', color: '#4ADBFF'},
+    207: {name: 'Crystal', description: '', color: '#4ADBFF'},
+    208: {name: 'Crystal', description: '', color: '#4ADBFF'},
+    209: {name: 'Crystal', description: '', color: '#4ADBFF'},
+    210: {name: 'Crystal', description: '', color: '#4ADBFF'},
+
+    // === Resources / Gas ===
     301: {name: 'Gas', description: 'Raw volatile gas.', color: '#B8E4A0'},
     302: {
         name: 'Gas',
@@ -41,6 +59,15 @@ export const itemMetadata: Record<number, ItemMetadata> = {
         description: 'High-grade volatile gas with exceptional energy density.',
         color: '#B8E4A0',
     },
+    304: {name: 'Gas', description: '', color: '#B8E4A0'},
+    305: {name: 'Gas', description: '', color: '#B8E4A0'},
+    306: {name: 'Gas', description: '', color: '#B8E4A0'},
+    307: {name: 'Gas', description: '', color: '#B8E4A0'},
+    308: {name: 'Gas', description: '', color: '#B8E4A0'},
+    309: {name: 'Gas', description: '', color: '#B8E4A0'},
+    310: {name: 'Gas', description: '', color: '#B8E4A0'},
+
+    // === Resources / Regolith ===
     401: {name: 'Regolith', description: 'Crude regolith dust.', color: '#C4A57B'},
     402: {
         name: 'Regolith',
@@ -52,6 +79,15 @@ export const itemMetadata: Record<number, ItemMetadata> = {
         description: 'High-grade regolith with exceptional uniformity.',
         color: '#C4A57B',
     },
+    404: {name: 'Regolith', description: '', color: '#C4A57B'},
+    405: {name: 'Regolith', description: '', color: '#C4A57B'},
+    406: {name: 'Regolith', description: '', color: '#C4A57B'},
+    407: {name: 'Regolith', description: '', color: '#C4A57B'},
+    408: {name: 'Regolith', description: '', color: '#C4A57B'},
+    409: {name: 'Regolith', description: '', color: '#C4A57B'},
+    410: {name: 'Regolith', description: '', color: '#C4A57B'},
+
+    // === Resources / Biomass ===
     501: {name: 'Biomass', description: 'Crude organic biomass.', color: '#5A8B3E'},
     502: {
         name: 'Biomass',
@@ -63,6 +99,13 @@ export const itemMetadata: Record<number, ItemMetadata> = {
         description: 'High-grade biomass with exceptional saturation.',
         color: '#5A8B3E',
     },
+    504: {name: 'Biomass', description: '', color: '#5A8B3E'},
+    505: {name: 'Biomass', description: '', color: '#5A8B3E'},
+    506: {name: 'Biomass', description: '', color: '#5A8B3E'},
+    507: {name: 'Biomass', description: '', color: '#5A8B3E'},
+    508: {name: 'Biomass', description: '', color: '#5A8B3E'},
+    509: {name: 'Biomass', description: '', color: '#5A8B3E'},
+    510: {name: 'Biomass', description: '', color: '#5A8B3E'},
 
     // === Components (T1) ===
     10001: {

package/src/derivation/resources.ts

@@ -1,10 +1,15 @@
 import {getItem} from '../data/catalog'
 
 export const DEPTH_THRESHOLD_T1 = 0
-export const DEPTH_THRESHOLD_T2 = 2000
-export const DEPTH_THRESHOLD_T3 = 10000
-export const DEPTH_THRESHOLD_T4 = 30000
-export const DEPTH_THRESHOLD_T5 = 55000
+export const DEPTH_THRESHOLD_T2 = 1500
+export const DEPTH_THRESHOLD_T3 = 5000
+export const DEPTH_THRESHOLD_T4 = 12000
+export const DEPTH_THRESHOLD_T5 = 22000
+export const DEPTH_THRESHOLD_T6 = 32000
+export const DEPTH_THRESHOLD_T7 = 42000
+export const DEPTH_THRESHOLD_T8 = 50000
+export const DEPTH_THRESHOLD_T9 = 57000
+export const DEPTH_THRESHOLD_T10 = 63000
 
 export const LOCATION_MIN_DEPTH = 500
 export const LOCATION_MAX_DEPTH = 65535
@@ -18,19 +23,22 @@ export const PLANET_SUBTYPE_ICY = 3
 export const PLANET_SUBTYPE_OCEAN = 4
 export const PLANET_SUBTYPE_INDUSTRIAL = 5
 
+const DEPTH_THRESHOLD_TABLE = [
+    DEPTH_THRESHOLD_T1,
+    DEPTH_THRESHOLD_T2,
+    DEPTH_THRESHOLD_T3,
+    DEPTH_THRESHOLD_T4,
+    DEPTH_THRESHOLD_T5,
+    DEPTH_THRESHOLD_T6,
+    DEPTH_THRESHOLD_T7,
+    DEPTH_THRESHOLD_T8,
+    DEPTH_THRESHOLD_T9,
+    DEPTH_THRESHOLD_T10,
+]
+
 export function getDepthThreshold(tier: number): number {
-    switch (tier) {
-        case 1:
-            return DEPTH_THRESHOLD_T1
-        case 2:
-            return DEPTH_THRESHOLD_T2
-        case 3:
-            return DEPTH_THRESHOLD_T3
-        case 4:
-            return DEPTH_THRESHOLD_T4
-        default:
-            return DEPTH_THRESHOLD_T5
-    }
+    if (tier < 1 || tier > 10) return 65535
+    return DEPTH_THRESHOLD_TABLE[tier - 1]
 }
 
 export function getResourceTier(itemId: number): number {
@@ -46,9 +54,9 @@ export function getResourceWeight(itemId: number, stratum: number): number {
 
     switch (tier) {
         case 1:
-            if (stratum < 2000) return 100
-            if (stratum < 10000) return 80
-            if (stratum < 30000) return 50
+            if (stratum < DEPTH_THRESHOLD_T2) return 100
+            if (stratum < DEPTH_THRESHOLD_T3) return 80
+            if (stratum < DEPTH_THRESHOLD_T4) return 50
             return 30
         case 2:
             if (depthAbove < 3000) return 40

package/src/entities/container.ts

@@ -1,6 +1,7 @@
 import {UInt64, type UInt64Type} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
 import type {CoordinatesType} from '../types'
+import {type FloatPosition, getInterpolatedPosition} from '../travel/travel'
 import {Location} from './location'
 import {ScheduleAccessor} from '../scheduling/accessor'
 import * as schedule from '../scheduling/schedule'
@@ -24,6 +25,14 @@ export class Container extends ServerContract.Types.entity_info {
         return this.entity_name
     }
 
+    get entityClass(): 'mobile' {
+        return 'mobile'
+    }
+
+    get canUndeploy(): boolean {
+        return true
+    }
+
     get sched(): ScheduleAccessor {
         this._sched ??= new ScheduleAccessor(this)
         return this._sched
@@ -33,6 +42,12 @@ export class Container extends ServerContract.Types.entity_info {
         return this.is_idle
     }
 
+    interpolatedPositionAt(now: Date): FloatPosition {
+        const taskIndex = this.sched.currentTaskIndex(now)
+        const progress = this.sched.currentTaskProgressFloat(now)
+        return getInterpolatedPosition(this, taskIndex, progress)
+    }
+
     isLoading(now: Date): boolean {
         return schedule.isLoading(this, now)
     }

package/src/entities/ship-deploy.ts

@@ -8,6 +8,7 @@ import {
     MODULE_HAULER,
     MODULE_LOADER,
 } from '../capabilities/modules'
+import {getItem} from '../data/catalog'
 
 export function computeShipHullCapabilities(stats: Record<string, number>): {
     hullmass: number
@@ -52,7 +53,38 @@ export function computeGeneratorCapabilities(stats: Record<string, number>): {
     }
 }
 
-export function computeGathererCapabilities(stats: Record<string, number>): {
+export interface GathererDepthParams {
+    readonly floor: number
+    readonly slope: number
+}
+
+export const GATHERER_DEPTH_TABLE: readonly GathererDepthParams[] = [
+    {floor: 500, slope: 5},
+    {floor: 2000, slope: 11},
+    {floor: 7000, slope: 16},
+    {floor: 15000, slope: 18},
+    {floor: 25000, slope: 19},
+    {floor: 35000, slope: 16},
+    {floor: 46000, slope: 12},
+    {floor: 53500, slope: 10},
+    {floor: 60000, slope: 5},
+    {floor: 63500, slope: 2},
+]
+
+export const GATHERER_DEPTH_MAX_TIER = 10
+
+export function gathererDepthForTier(tol: number, tier: number): number {
+    if (tier < 1 || tier > GATHERER_DEPTH_MAX_TIER) {
+        throw new Error(`gatherer tier out of range: ${tier}`)
+    }
+    const p = GATHERER_DEPTH_TABLE[tier - 1]
+    return p.floor + tol * p.slope
+}
+
+export function computeGathererCapabilities(
+    stats: Record<string, number>,
+    tier: number
+): {
     yield: number
     drain: number
     depth: number
@@ -66,7 +98,7 @@ export function computeGathererCapabilities(stats: Record<string, number>): {
     return {
         yield: 200 + str,
         drain: Math.max(250, 1250 - Math.floor((con * 25) / 20)),
-        depth: 200 + Math.floor((tol * 3) / 2),
+        depth: gathererDepthForTier(tol, tier),
         speed: 100 + Math.floor((ref * 4) / 5),
     }
 }
@@ -197,16 +229,20 @@ export function computeShipCapabilities(
     if (gathererModules.length > 0) {
         let totalYield = 0
         let totalDrain = 0
-        let totalDepth = 0
+        let maxDepth = 0
         let totalSpeed = 0
         for (const m of gathererModules) {
-            const caps = computeGathererCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            const tier = getItem(m.itemId).tier
+            const caps = computeGathererCapabilities(
+                decodeCraftedItemStats(m.itemId, m.stats),
+                tier
+            )
             totalYield += caps.yield
             totalDrain += caps.drain
-            totalDepth += caps.depth
+            if (caps.depth > maxDepth) maxDepth = caps.depth
             totalSpeed += caps.speed
         }
-        ship.gatherer = {yield: totalYield, drain: totalDrain, depth: totalDepth, speed: totalSpeed}
+        ship.gatherer = {yield: totalYield, drain: totalDrain, depth: maxDepth, speed: totalSpeed}
     }
 
     const haulerModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_HAULER)

package/src/entities/ship.ts

@@ -2,7 +2,9 @@ import {type UInt16, type UInt16Type, UInt32, UInt64, type UInt64Type} from '@wh
 import {ServerContract} from '../contracts'
 import {Coordinates, type CoordinatesType} from '../types'
 import {
+    type FloatPosition,
     getDestinationLocation,
+    getInterpolatedPosition,
     getPositionAt,
     getFlightOrigin as travelGetFlightOrigin,
 } from '../travel/travel'
@@ -55,6 +57,14 @@ export class Ship extends ServerContract.Types.entity_info {
         return this.entity_name
     }
 
+    get entityClass(): 'mobile' {
+        return 'mobile'
+    }
+
+    get canUndeploy(): boolean {
+        return true
+    }
+
     get inv(): InventoryAccessor {
         this._inv ??= new InventoryAccessor(this)
         return this._inv
@@ -87,12 +97,19 @@ export class Ship extends ServerContract.Types.entity_info {
         return dest ? Coordinates.from(dest) : undefined
     }
 
+    /** Chain-tile coordinates at `now`. For smooth visual position use interpolatedPositionAt. */
     positionAt(now: Date): Coordinates {
         const taskIndex = this.sched.currentTaskIndex(now)
         const progress = this.sched.currentTaskProgress(now)
         return Coordinates.from(getPositionAt(this, taskIndex, progress))
     }
 
+    interpolatedPositionAt(now: Date): FloatPosition {
+        const taskIndex = this.sched.currentTaskIndex(now)
+        const progress = this.sched.currentTaskProgressFloat(now)
+        return getInterpolatedPosition(this, taskIndex, progress)
+    }
+
     isInFlight(now: Date): boolean {
         return schedule.isInFlight(this, now)
     }

package/src/entities/warehouse.ts

@@ -31,6 +31,14 @@ export class Warehouse extends ServerContract.Types.entity_info {
         return this.entity_name
     }
 
+    get entityClass(): 'building' {
+        return 'building'
+    }
+
+    get canDemolish(): boolean {
+        return true
+    }
+
     get inv(): InventoryAccessor {
         this._inv ??= new InventoryAccessor(this)
         return this._inv

package/src/index-module.ts

@@ -117,30 +117,35 @@ export {
     distanceBetweenCoordinates,
     distanceBetweenPoints,
     findNearbyPlanets,
-    lerp,
-    rotation,
-    calc_ship_mass,
     calc_acceleration,
+    calc_energyusage,
     calc_flighttime,
-    calc_ship_flighttime,
-    calc_ship_acceleration,
-    calc_rechargetime,
-    calc_ship_rechargetime,
-    calc_loader_flighttime,
     calc_loader_acceleration,
-    calc_energyusage,
+    calc_loader_flighttime,
     calc_orbital_altitude,
+    calc_rechargetime,
+    calc_ship_acceleration,
+    calc_ship_flighttime,
+    calc_ship_mass,
+    calc_ship_rechargetime,
     calc_transfer_duration,
-    calculateTransferTime,
+    calculateFlightTime,
     calculateLoadTimeBreakdown,
     calculateRefuelingTime,
-    calculateFlightTime,
-    estimateTravelTime,
+    calculateTransferTime,
+    easeFlightProgress,
     estimateDealTravelTime,
-    hasEnergyForDistance,
-    getFlightOrigin,
+    estimateTravelTime,
+    flightSpeedFactor,
+    type FloatPosition,
     getDestinationLocation,
+    getFlightOrigin,
+    getInterpolatedPosition,
     getPositionAt,
+    hasEnergyForDistance,
+    interpolateFlightPosition,
+    lerp,
+    rotation,
 } from './travel/travel'
 export type {
     LoadTimeBreakdown,
@@ -246,8 +251,11 @@ export {
     computeWarehouseHullCapabilities,
     computeStorageCapabilities,
     computeShipCapabilities,
+    GATHERER_DEPTH_TABLE,
+    GATHERER_DEPTH_MAX_TIER,
+    gathererDepthForTier,
 } from './entities/ship-deploy'
-export type {ShipCapabilities} from './entities/ship-deploy'
+export type {ShipCapabilities, GathererDepthParams} from './entities/ship-deploy'
 
 export {resolveItem} from './resolution/resolve-item'
 export type {

package/src/managers/actions.ts

@@ -15,7 +15,7 @@ import {type CoordinatesType, EntityType, type EntityTypeName} from '../types'
 import {ServerContract} from '../contracts'
 
 export type EntityRefInput = {
-    entityType: EntityTypeName
+    entityType: NameType
     entityId: UInt64Type
 }
 
@@ -244,6 +244,29 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    undeploy(host: EntityRefInput, target: EntityRefInput): Action {
+        return this.server.action('undeploy', {
+            host_type: Name.from(host.entityType),
+            host_id: UInt64.from(host.entityId),
+            target_type: Name.from(target.entityType),
+            target_id: UInt64.from(target.entityId),
+        })
+    }
+
+    wrapEntity(entity: EntityRefInput): Action {
+        return this.server.action('wrapentity', {
+            entity_type: Name.from(entity.entityType),
+            entity_id: UInt64.from(entity.entityId),
+        })
+    }
+
+    demolish(entity: EntityRefInput): Action {
+        return this.server.action('demolish', {
+            entity_type: Name.from(entity.entityType),
+            entity_id: UInt64.from(entity.entityId),
+        })
+    }
+
     joinGame(account: NameType, companyName: string): Action[] {
         return [this.foundCompany(account, companyName), this.join(account)]
     }

package/src/nft/description.ts

@@ -4,6 +4,7 @@ import {
     MODULE_ENGINE,
     MODULE_GATHERER,
     MODULE_GENERATOR,
+    MODULE_HAULER,
     MODULE_LOADER,
     MODULE_STORAGE,
     MODULE_WARP,
@@ -15,6 +16,7 @@ import {
     ITEM_ENGINE_T1,
     ITEM_GATHERER_T1,
     ITEM_GENERATOR_T1,
+    ITEM_HAULER_T1,
     ITEM_LOADER_T1,
     ITEM_SHIP_T1_PACKED,
     ITEM_STORAGE_T1,
@@ -22,6 +24,8 @@ import {
     ITEM_WARP_T1,
 } from '../data/item-ids'
 import {decodeStat} from '../derivation/crafting'
+import {gathererDepthForTier} from '../entities/ship-deploy'
+import {getItem} from '../data/catalog'
 
 function idiv(a: number, b: number): number {
     return Math.floor(a / b)
@@ -49,12 +53,16 @@ export const computeGeneratorRech = (fin: number): number => 1 + idiv(fin * 3, 1
 export const computeGathererYield = (str: number): number => 200 + str
 export const computeGathererDrain = (con: number): number =>
     Math.max(250, 1250 - idiv(con * 25, 20))
-export const computeGathererDepth = (tol: number): number => 200 + idiv(tol * 3, 2)
+export const computeGathererDepth = (tol: number, tier: number): number =>
+    gathererDepthForTier(tol, tier)
 export const computeGathererSpeed = (ref: number): number => 100 + idiv(ref * 4, 5)
 export const computeLoaderMass = (ins: number): number => Math.max(200, 2000 - ins * 2)
 export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla, 500)
 export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
 export const computeCrafterDrain = (fin: number): number => Math.max(5, 30 - idiv(fin, 33))
+export const computeHaulerCapacity = (fin: number): number => Math.max(1, 1 + idiv(fin, 400))
+export const computeHaulerEfficiency = (con: number): number => 2000 + con * 6
+export const computeHaulerDrain = (com: number): number => Math.max(3, 15 - idiv(com, 80))
 export const computeWarpRange = (stat: number): number => 100 + stat * 3
 
 export function entityDisplayName(itemId: number): string {
@@ -86,6 +94,8 @@ export function moduleDisplayName(itemId: number): string {
             return 'Crafter'
         case ITEM_STORAGE_T1:
             return 'Storage'
+        case ITEM_HAULER_T1:
+            return 'Hauler'
         case ITEM_WARP_T1:
             return 'Warp'
         default:
@@ -121,8 +131,10 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             const tol = decodeStat(stats, 1)
             const con = decodeStat(stats, 3)
             const ref = decodeStat(stats, 4)
+            const tier = getItem(itemId).tier
             out += `  Yield ${computeGathererYield(str)}  Depth ${computeGathererDepth(
-                tol
+                tol,
+                tier
             )}  Speed ${computeGathererSpeed(ref)}  Drain ${computeGathererDrain(con)}`
             break
         }
@@ -147,6 +159,13 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             out += `  +${pct}% capacity`
             break
         }
+        case MODULE_HAULER: {
+            const fin = decodeStat(stats, 0)
+            const con = decodeStat(stats, 1)
+            const com = decodeStat(stats, 2)
+            out += `  Capacity ${computeHaulerCapacity(fin)}  Efficiency ${computeHaulerEfficiency(con)}  Drain ${computeHaulerDrain(com)}`
+            break
+        }
         case MODULE_WARP: {
             const stat = decodeStat(stats, 0)
             out += `  Range ${computeWarpRange(stat)}`

package/src/resolution/resolve-item.ts

@@ -155,7 +155,8 @@ function resolveComponent(id: number, stats?: UInt64Type): ResolvedItem {
 
 function computeCapabilityGroup(
     moduleType: number,
-    stats: Record<string, number>
+    stats: Record<string, number>,
+    tier: number
 ): ResolvedAttributeGroup | undefined {
     switch (moduleType) {
         case MODULE_ENGINE: {
@@ -179,7 +180,7 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_GATHERER: {
-            const caps = computeGathererCapabilities(stats)
+            const caps = computeGathererCapabilities(stats, tier)
             return {
                 capability: 'Gatherer',
                 attributes: [
@@ -242,7 +243,7 @@ function resolveModule(id: number, stats?: UInt64Type): ResolvedItem {
     if (stats !== undefined) {
         const decoded = decodeCraftedItemStats(id, toBigStats(stats))
         const modType = getModuleCapabilityType(id)
-        const group = computeCapabilityGroup(modType, decoded)
+        const group = computeCapabilityGroup(modType, decoded, item.tier)
         if (group) attributes = [group]
     }
     return {
@@ -311,13 +312,16 @@ function resolveEntity(
                 const modStats = BigInt(mod.installed.stats.toString())
                 const decodedStats = decodeCraftedItemStats(modItemId, modStats)
                 const modType = getModuleCapabilityType(modItemId)
-                const group = computeCapabilityGroup(modType, decodedStats)
                 let modName = 'Module'
+                let modTier = 1
                 try {
-                    modName = getItem(modItemId).name
+                    const modItem = getItem(modItemId)
+                    modName = modItem.name
+                    modTier = modItem.tier
                 } catch {
                     modName = itemMetadata[modItemId]?.name ?? 'Module'
                 }
+                const group = computeCapabilityGroup(modType, decodedStats, modTier)
                 return {
                     name: modName,
                     installed: true,

package/src/scheduling/accessor.ts

@@ -72,6 +72,10 @@ export class ScheduleAccessor {
         return schedule.currentTaskProgress(this.entity, now)
     }
 
+    currentTaskProgressFloat(now: Date): number {
+        return schedule.currentTaskProgressFloat(this.entity, now)
+    }
+
     progress(now: Date): number {
         return schedule.scheduleProgress(this.entity, now)
     }

package/src/scheduling/projection.ts

@@ -267,6 +267,10 @@ function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task):
         case TaskType.DEPLOY:
             applyDeployTask(projected, task)
             break
+        case TaskType.UNDEPLOY:
+        case TaskType.WRAP_ENTITY:
+        case TaskType.DEMOLISH:
+            break
     }
 }
 
@@ -448,6 +452,10 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
             case TaskType.DEPLOY:
                 if (taskComplete) applyDeployTask(projected, task)
                 break
+            case TaskType.UNDEPLOY:
+            case TaskType.WRAP_ENTITY:
+            case TaskType.DEMOLISH:
+                break
         }
     }
 

package/src/scheduling/schedule.ts

@@ -77,7 +77,7 @@ export function currentTaskIndex(entity: ScheduleData, now: Date): number {
         timeAccum += taskDuration
     }
 
-    return entity.schedule.tasks.length - 1
+    return -1
 }
 
 export function currentTask(entity: ScheduleData, now: Date): Task | undefined {
@@ -147,6 +147,20 @@ export function currentTaskProgress(entity: ScheduleData, now: Date): number {
     return Math.min(1, elapsed / duration)
 }
 
+export function currentTaskProgressFloat(entity: ScheduleData, now: Date): number {
+    if (!entity.schedule || entity.schedule.tasks.length === 0) return 0
+    const index = currentTaskIndex(entity, now)
+    if (index < 0) return 0
+    const task = entity.schedule.tasks[index]
+    const durationMs = task.duration.toNumber() * 1000
+    if (durationMs === 0) return 1
+    const startedMs = entity.schedule.started.toDate().getTime()
+    const taskStartMs = startedMs + getTaskStartTime(entity, index) * 1000
+    const elapsedMs = now.getTime() - taskStartMs
+    if (elapsedMs <= 0) return 0
+    return Math.min(1, elapsedMs / durationMs)
+}
+
 export function scheduleProgress(entity: ScheduleData, now: Date): number {
     const duration = scheduleDuration(entity)
     if (duration === 0) return hasSchedule(entity) ? 1 : 0

package/src/subscriptions/manager.ts

@@ -34,6 +34,12 @@ export interface BoundsSubscriptionHandle {
     current: Map<number, EntityInstance>
 }
 
+export interface OwnerSubscriptionHandle {
+    readonly subId: string
+    unsubscribe(): void
+    current: Map<number, EntityInstance>
+}
+
 export interface EntitySubscriptionHandle {
     readonly subId: string
     readonly entityType: SubscriptionEntityType
@@ -62,7 +68,7 @@ export class SubscriptionsManager {
             onSnapshot?: (entities: EntityInstance[]) => void
             onUpdate?: (entity: EntityInstance) => void
             onBoundsDelta?: (entered: EntityInstance[], exited: number[]) => void
-            handle: BoundsSubscriptionHandle
+            handle: BoundsSubscriptionHandle | OwnerSubscriptionHandle
         }
     >()
     private subCounter = 0
@@ -162,6 +168,36 @@ export class SubscriptionsManager {
         return handle
     }
 
+    subscribeOwner(
+        owner: string,
+        handlers: {
+            onSnapshot?: (entities: EntityInstance[]) => void
+            onUpdate?: (entity: EntityInstance) => void
+        } = {}
+    ): OwnerSubscriptionHandle {
+        const subId = this.generateSubID('own')
+        const msg: SubscribeMessage = {
+            type: 'subscribe',
+            sub_id: subId,
+            owner,
+        }
+        const handle: OwnerSubscriptionHandle = {
+            subId,
+            unsubscribe: () => this.unsubscribeBounds(subId),
+            current: new Map(),
+        }
+        this.boundsSubs.set(subId, {
+            bounds: undefined,
+            owner,
+            prioritizeOwner: undefined,
+            onSnapshot: handlers.onSnapshot,
+            onUpdate: handlers.onUpdate,
+            handle,
+        })
+        this.sendMessage(msg)
+        return handle
+    }
+
     private unsubscribeBounds(subId: string) {
         this.boundsSubs.delete(subId)
         this.sendMessage({type: 'unsubscribe', sub_id: subId})