@shipload/sdk 1.0.0-next.70 → 1.0.0-next.72

package/src/scheduling/jobs.ts

@@ -1,4 +1,6 @@
 import type {ServerContract} from '../contracts'
+import {TaskType} from '../types'
+import type {OrderedTask} from './schedule'
 
 type CargoItem = ServerContract.Types.cargo_item
 
@@ -8,12 +10,18 @@ export interface JobWindow {
     owner: string
     startsAt: Date
     completesAt: Date
+    /** Contract-recorded completion of the input Drop-off. */
+    arrivesAt?: Date
     recipeId: number
     quantity: number
-    /** False while the job is In Line: booked, with its inputs still in transit to the building. */
+    /** False while the job's inputs are still in transit to the building. */
     deposited: boolean
     /** Packed stat roll of the job's output, when the source carried the job's cargo. */
     outputStats?: bigint
+    /** Ship that booked the job; lets a caller find its Drop-off on that ship's schedule. */
+    shipId?: number
+    /** Inputs the Drop-off carries; matched against the task cargo to find the right Drop-off. */
+    inputs?: CargoItem[]
 }
 
 export interface JobLaneEntry {
@@ -59,18 +67,26 @@ export function socketTail(jobs: JobWindow[], socket: number, now: Date): Date {
     return last && last.completesAt > now ? last.completesAt : now
 }
 
+// Display-only estimate of the window a booking would receive; the contract picks the socket.
 export function pickFabricator(
     jobs: JobWindow[],
     sockets: Array<{open: boolean}>,
     durationBySocketMinutes: number[],
-    now: Date
+    arrival: Date,
+    now: Date = arrival
 ): {slot: number; startsAt: Date; completesAt: Date} | null {
     let best: {slot: number; startsAt: Date; completesAt: Date} | null = null
     for (let slot = 0; slot < sockets.length; slot++) {
         if (!sockets[slot].open) continue
         if (activeOn(jobs, slot, now).length >= JOB_QUEUE_CAP) continue
-        const startsAt = socketTail(jobs, slot, now)
-        const completesAt = new Date(startsAt.getTime() + durationBySocketMinutes[slot] * 60_000)
+        const durationMs = durationBySocketMinutes[slot] * 60_000
+        let startsAt = arrival
+        for (const job of activeOn(jobs, slot, now)) {
+            if (job.completesAt <= startsAt) continue
+            if (job.startsAt.getTime() - startsAt.getTime() >= durationMs) break
+            startsAt = job.completesAt
+        }
+        const completesAt = new Date(startsAt.getTime() + durationMs)
         if (!best || completesAt < best.completesAt) {
             best = {slot, startsAt, completesAt}
         }
@@ -78,24 +94,212 @@ export function pickFabricator(
     return best
 }
 
-export type JobStatus = 'inline' | 'waiting' | 'crafting' | 'ready'
+export function workshopAvailability(
+    jobs: JobWindow[],
+    socketCount: number,
+    now: Date
+): {open: number; nextOpeningAt: Date | null} {
+    let open = 0
+    let nextOpeningAt: Date | null = null
+    for (let socket = 0; socket < socketCount; socket++) {
+        const tail = socketTail(jobs, socket, now)
+        if (tail <= now) {
+            open++
+        } else if (!nextOpeningAt || tail < nextOpeningAt) {
+            nextOpeningAt = tail
+        }
+    }
+    return {open, nextOpeningAt: open > 0 ? null : nextOpeningAt}
+}
+
+export type JobStatus = 'booked' | 'dropping' | 'queued' | 'crafting' | 'ready' | 'pickingup'
+
+export interface JobStatusInput {
+    startsAt: Date
+    completesAt: Date
+    /** Contract-recorded completion of the input Drop-off. */
+    arrivesAt?: Date
+    deposited?: boolean
+    quantity?: number
+    building?: number
+    inputs?: readonly CargoItem[]
+}
 
-// A job In Line has no window yet, so the window alone would read it as long since ready.
+function modulesEqual(a: CargoItem['modules'], b: CargoItem['modules']): boolean {
+    const length = Math.max(a?.length ?? 0, b?.length ?? 0)
+    for (let i = 0; i < length; i++) {
+        const installed = a?.[i]?.installed
+        const other = b?.[i]?.installed
+        if (Boolean(installed) !== Boolean(other)) return false
+        if (
+            installed &&
+            other &&
+            (String(installed.item_id) !== String(other.item_id) ||
+                String(installed.stats) !== String(other.stats))
+        ) {
+            return false
+        }
+    }
+    return true
+}
+
+function cargoEquals(a: readonly CargoItem[], b: readonly CargoItem[]): boolean {
+    if (a.length !== b.length) return false
+    return a.every((x, i) => {
+        const y = b[i]
+        if (
+            String(x.item_id) !== String(y.item_id) ||
+            String(x.stats) !== String(y.stats) ||
+            String(x.quantity) !== String(y.quantity) ||
+            String(x.entity_id ?? 0) !== String(y.entity_id ?? 0) ||
+            !modulesEqual(x.modules, y.modules)
+        ) {
+            return false
+        }
+        return true
+    })
+}
+
+function matchesJob(t: OrderedTask, job: JobStatusInput): boolean {
+    const subject = t.task.subject
+    if (job.building !== undefined && Number(subject?.entity_id) !== job.building) return false
+    if (job.inputs !== undefined && !cargoEquals(t.task.cargo, job.inputs)) return false
+    return true
+}
+
+export function jobDropoffTask(
+    job: JobStatusInput,
+    tasks: readonly OrderedTask[] | undefined
+): OrderedTask | undefined {
+    const matches = tasks?.filter(
+        (t) =>
+            Number(t.task.type) === TaskType.CIVIC_DEPOSIT &&
+            matchesJob(t, job) &&
+            (job.arrivesAt === undefined || t.completesAt.getTime() === job.arrivesAt.getTime())
+    )
+    return matches?.length === 1 ? matches[0] : undefined
+}
+
+// Without the ship's schedule an undeposited row reads as Dropping off: the transfer usually starts at once.
 export function jobStatus(
-    job: {startsAt: Date; completesAt: Date; deposited?: boolean},
-    now: Date
+    job: JobStatusInput,
+    now: Date,
+    tasks?: readonly OrderedTask[]
 ): JobStatus {
-    if (job.deposited === false) return 'inline'
-    if (now < job.startsAt) return 'waiting'
+    if (job.deposited === false) {
+        const dropoff = jobDropoffTask(job, tasks)
+        return dropoff && now < dropoff.startsAt ? 'booked' : 'dropping'
+    }
+    if (job.quantity === 0) return 'ready'
+    if (now < job.startsAt) return 'queued'
     if (now < job.completesAt) return 'crafting'
     return 'ready'
 }
 
+export function jobCancellable(status: JobStatus): boolean {
+    return status === 'booked' || status === 'dropping' || status === 'queued'
+}
+
+export type JobCancellationBlockReason = 'legacy-inputs-unavailable' | 'ambiguous-dropoff'
+
+/** A migrated output-only job has no retained inputs that modern cancellation could return. */
+export function jobCancellationBlockReason(
+    job: JobStatusInput,
+    tasks?: readonly OrderedTask[]
+): JobCancellationBlockReason | null {
+    if (
+        job.deposited === true &&
+        (job.quantity ?? 0) > 0 &&
+        job.inputs !== undefined &&
+        job.inputs.length === 0
+    ) {
+        return 'legacy-inputs-unavailable'
+    }
+    if (job.deposited === false && job.arrivesAt !== undefined && tasks) {
+        const matches = tasks.filter(
+            (task) =>
+                Number(task.task.type) === TaskType.CIVIC_DEPOSIT &&
+                matchesJob(task, job) &&
+                task.completesAt.getTime() === job.arrivesAt?.getTime()
+        )
+        if (matches.length > 1) return 'ambiguous-dropoff'
+    }
+    return null
+}
+
+export type JobCancelRoute =
+    | {kind: 'dropoff'; shipId: number; laneKey: number; count: number}
+    | {kind: 'craft'; jobId: number}
+    | {kind: 'build'; jobId: number}
+
+// The ship's cancel pops from the lane tail, so the count reaches from the Drop-off through every task queued behind it.
+function cancelRoute(
+    job: JobStatusInput & {id: number; shipId?: number},
+    queued: 'craft' | 'build',
+    now: Date,
+    tasks?: readonly OrderedTask[]
+): JobCancelRoute | null {
+    if (!jobCancellable(jobStatus(job, now, tasks))) return null
+    if (queued === 'craft' && jobCancellationBlockReason(job, tasks)) return null
+    if (job.deposited !== false) return {kind: queued, jobId: job.id}
+    if (job.shipId === undefined || !tasks) return null
+    const dropoff = jobDropoffTask(job, tasks)
+    if (!dropoff || dropoff.completesAt <= now) return null
+    const laneLength = tasks.filter((t) => t.laneKey === dropoff.laneKey).length
+    return {
+        kind: 'dropoff',
+        shipId: job.shipId,
+        laneKey: dropoff.laneKey,
+        count: laneLength - dropoff.taskIndex,
+    }
+}
+
+export function jobCancelRoute(
+    job: JobStatusInput & {id: number; shipId?: number},
+    now: Date,
+    tasks?: readonly OrderedTask[]
+): JobCancelRoute | null {
+    return cancelRoute(job, 'craft', now, tasks)
+}
+
+// A Build Job's Drop-off rides on the upgrade target itself, so the target plays the ship's part.
+export function buildJobCancelRoute(
+    job: JobStatusInput & {id: number; targetId?: number},
+    now: Date,
+    tasks?: readonly OrderedTask[]
+): JobCancelRoute | null {
+    return cancelRoute({...job, shipId: job.targetId}, 'build', now, tasks)
+}
+
+export interface PickupInFlight {
+    building: number
+    cargo: CargoItem[]
+    startsAt: Date
+    completesAt: Date
+}
+
+export function pickupsInFlight(tasks: OrderedTask[], building?: number): PickupInFlight[] {
+    return tasks
+        .filter(
+            (t) =>
+                Number(t.task.type) === TaskType.CIVIC_WITHDRAW &&
+                (building === undefined || Number(t.task.subject?.entity_id) === building)
+        )
+        .map((t) => ({
+            building: Number(t.task.subject?.entity_id),
+            cargo: [...t.task.cargo],
+            startsAt: t.startsAt,
+            completesAt: t.completesAt,
+        }))
+}
+
 const JOB_STATUS_LABELS: Record<JobStatus, string> = {
-    inline: 'In Line',
-    waiting: 'Waiting',
+    booked: 'Booked',
+    dropping: 'Dropping off',
+    queued: 'Queued',
     crafting: 'Crafting',
     ready: 'Ready for Pickup',
+    pickingup: 'Picking up',
 }
 
 export function jobStatusLabel(status: JobStatus): string {
@@ -108,14 +312,15 @@ export function jobDeposited(value: unknown): boolean {
     return Boolean(value)
 }
 
-// A job row holds the inputs while In Line and the output once its drop-off has landed.
+// A deposited row's output is the cargo tail; a cancelled row (quantity 0) holds only its inputs.
 export function splitJobCargo<T>(
     cargo: readonly T[],
-    deposited: boolean
+    deposited: boolean,
+    quantity: number
 ): {output: T | null; inputs: T[]} {
     if (cargo.length === 0) return {output: null, inputs: []}
-    if (!deposited) return {output: null, inputs: [...cargo]}
-    return {output: cargo[0], inputs: []}
+    if (!deposited || quantity === 0) return {output: null, inputs: [...cargo]}
+    return {output: cargo[cargo.length - 1], inputs: cargo.slice(0, -1)}
 }
 
 export interface OwnedJob {
@@ -126,6 +331,7 @@ export interface OwnedJob {
     coords: {x: number; y: number}
     startsAt: Date
     completesAt: Date
+    arrivesAt: Date
     recipeId: number
     quantity: number
     status: JobStatus

package/src/scheduling/lanes.ts

@@ -13,7 +13,7 @@ import {
     computeBuilderSpeed,
     computeBuilderDrain,
 } from '../nft/description'
-import type {ModuleType} from '../types'
+import {TaskType, type ModuleType} from '../types'
 import {getLane, LANE_MOBILITY, type ScheduleData} from './schedule'
 
 type ModuleEntry = ServerContract.Types.module_entry
@@ -225,3 +225,55 @@ export function candidateLaneCompletesAt(
 
     return new Date(startMs + durationSec * 1000)
 }
+
+/** Mirrors append.cpp for the position-bound civic Drop-off queued by craftjob. */
+export function candidateCivicDepositWindow(
+    entity: ScheduleData & {modules: ModuleEntry[]},
+    durationSec: number,
+    now: Date,
+    minStartsAt: Date = now
+): {laneKey: number; startsAt: Date; completesAt: Date} {
+    const lanes = entity.lanes ?? []
+    let lowestLoader: number | undefined
+    let laneKey: number | undefined
+    for (let slotIndex = 0; slotIndex < entity.modules.length; slotIndex++) {
+        const installed = entity.modules[slotIndex].installed
+        if (!installed || getItem(installed.item_id).moduleType !== 'loader') continue
+        const key = laneKeyForModule(slotIndex)
+        if (lowestLoader === undefined) lowestLoader = key
+        if (laneIsFree(lanes, key)) {
+            laneKey = key
+            break
+        }
+    }
+    laneKey ??= lowestLoader ?? LANE_MOBILITY
+    const floorNowMs = Math.floor(now.getTime() / 1000) * 1000
+    const lane = getLane(entity, laneKey)
+    const laneEndMs = lane ? rawScheduleEnd(lane.schedule).getTime() : floorNowMs
+    let barrierMs = minStartsAt.getTime()
+
+    for (const entry of lanes) {
+        let completesMs = entry.schedule.started.toDate().getTime()
+        for (const task of entry.schedule.tasks) {
+            completesMs += task.duration.toNumber() * 1000
+            const type = task.type.toNumber()
+            if (
+                type === TaskType.TRAVEL ||
+                type === TaskType.WARP ||
+                type === TaskType.TRANSIT ||
+                type === TaskType.RECHARGE
+            ) {
+                barrierMs = Math.max(barrierMs, completesMs)
+            }
+        }
+    }
+    let startMs = Math.max(laneEndMs, barrierMs)
+    if (startMs > laneEndMs) {
+        startMs = laneEndMs + Math.ceil((startMs - laneEndMs) / 1000) * 1000
+    }
+    return {
+        laneKey,
+        startsAt: new Date(startMs),
+        completesAt: new Date(startMs + durationSec * 1000),
+    }
+}

package/src/shipload.ts

@@ -13,6 +13,7 @@ import type {ActionsManager} from './managers/actions'
 import type {ClusterManager} from './managers/cluster'
 import type {NftManager} from './managers/nft'
 import type {BalancesManager} from './managers/balances'
+import type {FundManager} from './managers/fund'
 import type {JobsManager} from './managers/jobs'
 import type {InfluenceManager} from './managers/influence'
 import type {SubscriptionsManager} from './subscriptions/manager'
@@ -154,6 +155,10 @@ export class Shipload {
         return this._context.nft
     }
 
+    get funds(): FundManager {
+        return this._context.funds
+    }
+
     get balances(): BalancesManager {
         return this._context.balances
     }