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

package/src/index-module.ts

@@ -35,13 +35,9 @@ export type cargo_item = ServerContract.Types.cargo_item
 export type entity_row = ServerContract.Types.entity_row
 export type craftjob_row = ServerContract.Types.craftjob_row
 export type buildjob_row = ServerContract.Types.buildjob_row
-export type booking_receipt = ServerContract.Types.booking_receipt
-export {
-    decodeBookingReceipt,
-    bookingReceiptLandsAtMs,
-    bookingReceiptRuntimeSeconds,
-} from './receipts'
-export type {BookingReceipt} from './receipts'
+export type window_receipt = ServerContract.Types.window_receipt
+export {decodeWindowReceipt, windowReceiptStartsAtMs, windowReceiptCompletesAtMs} from './receipts'
+export type {WindowReceipt} from './receipts'
 
 export type location_static = ServerContract.Types.location_static
 export type location_derived = ServerContract.Types.location_derived
@@ -289,6 +285,7 @@ export type {
 } from './scheduling/schedule'
 export {
     candidateLaneCompletesAt,
+    candidateCivicDepositWindow,
     laneKeyForModule,
     rawScheduleEnd,
     resolveLaneGatherer,
@@ -335,10 +332,27 @@ export {
     JOB_QUEUE_CAP,
     jobStatus,
     jobStatusLabel,
+    jobDropoffTask,
+    jobCancelRoute,
+    buildJobCancelRoute,
+    jobCancellable,
+    jobCancellationBlockReason,
     jobDeposited,
     splitJobCargo,
+    workshopAvailability,
+    pickupsInFlight,
+} from './scheduling/jobs'
+export type {
+    JobWindow,
+    JobLane,
+    JobLaneEntry,
+    JobStatus,
+    JobStatusInput,
+    JobCancelRoute,
+    JobCancellationBlockReason,
+    OwnedJob,
+    PickupInFlight,
 } from './scheduling/jobs'
-export type {JobWindow, JobLane, JobLaneEntry, JobStatus, OwnedJob} from './scheduling/jobs'
 
 export {composeIdleResolve} from './scheduling/idle-resolve'
 export type {CounterpartLookup, IdleResolveTarget} from './scheduling/idle-resolve'

package/src/managers/actions.ts

@@ -24,6 +24,7 @@ import {Coordinates, PRECISION, type ClusterSlotType, type CoordinatesType} from
 import {ServerContract, TokenContract} from '../contracts'
 import {ATOMICASSETS_ABI, SHIPLOAD_COLLECTION} from '../nft/atomicassets'
 import {getItem} from '../data/catalog'
+import type {JobCancelRoute} from '../scheduling/jobs'
 
 const CHARGE_K = 100n
 const ENERGY_DIVISOR = 10n
@@ -515,7 +516,6 @@ export class ActionsManager extends BaseManager {
     craftjob(
         shipId: UInt64Type,
         workshopId: UInt64Type,
-        slot: UInt8Type,
         recipeId: UInt16Type,
         quantity: UInt32Type,
         inputs: ServerContract.ActionParams.Type.cargo_item[]
@@ -523,7 +523,6 @@ export class ActionsManager extends BaseManager {
         const params: ServerContract.ActionParams.craftjob = {
             ship_id: UInt64.from(shipId),
             workshop_id: UInt64.from(workshopId),
-            slot: UInt8.from(slot),
             recipe_id: UInt16.from(recipeId),
             quantity: UInt32.from(quantity),
             inputs,
@@ -531,6 +530,19 @@ export class ActionsManager extends BaseManager {
         return this.server.action('craftjob', params)
     }
 
+    cancelcraft(jobId: UInt64Type): Action {
+        const params: ServerContract.ActionParams.cancelcraft = {
+            job_id: UInt64.from(jobId),
+        }
+        return this.server.action('cancelcraft', params)
+    }
+
+    canceljob(route: JobCancelRoute): Action {
+        if (route.kind === 'dropoff') return this.cancel(route.shipId, route.laneKey, route.count)
+        if (route.kind === 'build') return this.cancelbuild(route.jobId)
+        return this.cancelcraft(route.jobId)
+    }
+
     clustercraft(
         entityId: UInt64Type,
         recipeId: number,
@@ -565,14 +577,12 @@ export class ActionsManager extends BaseManager {
     buildjob(
         targetId: UInt64Type,
         dockId: UInt64Type,
-        slot: UInt8Type,
         targetItemId: UInt16Type,
         inputs: ServerContract.ActionParams.Type.cargo_item[]
     ): Action {
         const params: ServerContract.ActionParams.buildjob = {
             target_id: UInt64.from(targetId),
             dock_id: UInt64.from(dockId),
-            slot: UInt8.from(slot),
             target_item_id: UInt16.from(targetItemId),
             inputs,
         }

package/src/managers/jobs.test.ts

@@ -12,6 +12,7 @@ const row = (over: Record<string, unknown> = {}) => ({
     coords: {x: {toNumber: () => 12}, y: {toNumber: () => 34}},
     starts_at: {toDate: () => new Date('2026-07-26T10:00:00Z')},
     completes_at: {toDate: () => new Date('2026-07-26T11:00:00Z')},
+    arrives_at: {toDate: () => new Date('2026-07-26T09:45:00Z')},
     recipe_id: {toNumber: () => 10001},
     quantity: {toNumber: () => 5},
     energy_paid: {toNumber: () => 0},
@@ -26,37 +27,52 @@ function managerWith(queryImpl: () => Promise<unknown[]>, allImpl: () => Promise
 }
 
 describe('JobsManager.getOwnedJobs', () => {
-    it('parses a landed row: cargo is the output, no inputs, status derived', async () => {
+    it('parses a deposited row: inputs then the output tail, status derived', async () => {
         const m = managerWith(
-            async () => [row()],
+            async () => [row({cargo: [{item: 'in'}, {item: 'out'}]})],
             async () => []
         )
         const jobs = await m.getOwnedJobs(OWNER, {now: new Date('2026-07-26T11:30:00Z')})
         expect(jobs).toHaveLength(1)
         expect(jobs[0]).toMatchObject({id: 7, building: 42, quantity: 5, status: 'ready'})
+        expect(jobs[0].arrivesAt).toEqual(new Date('2026-07-26T09:45:00Z'))
         expect(jobs[0].coords).toEqual({x: 12, y: 34})
         expect(jobs[0].output).toEqual({item: 'out'} as never)
-        expect(jobs[0].inputs).toEqual([] as never)
+        expect(jobs[0].inputs).toEqual([{item: 'in'}] as never)
     })
 
-    it('reports a job In Line rather than ready, whatever its zero window says', async () => {
-        const inLine = row({
-            starts_at: {toDate: () => new Date(0)},
-            completes_at: {toDate: () => new Date(0)},
+    it('reports an undeposited row as dropping off, whatever its window says', async () => {
+        const inFlight = row({
             deposited: false,
             cargo: [{item: 'in'}],
         })
         const m = managerWith(
-            async () => [inLine],
+            async () => [inFlight],
             async () => []
         )
         const jobs = await m.getOwnedJobs(OWNER, {now: new Date('2026-07-26T11:30:00Z')})
-        expect(jobs[0].status).toBe('inline')
+        expect(jobs[0].status).toBe('dropping')
         expect(jobs[0].deposited).toBe(false)
         expect(jobs[0].output).toBeNull()
         expect(jobs[0].inputs).toEqual([{item: 'in'}] as never)
     })
 
+    it('reports a cancelled row as ready with its inputs held', async () => {
+        const cancelled = row({
+            quantity: {toNumber: () => 0},
+            deposited: true,
+            cargo: [{item: 'in'}],
+        })
+        const m = managerWith(
+            async () => [cancelled],
+            async () => []
+        )
+        const jobs = await m.getOwnedJobs(OWNER, {now: new Date('2026-07-26T09:00:00Z')})
+        expect(jobs[0].status).toBe('ready')
+        expect(jobs[0].output).toBeNull()
+        expect(jobs[0].inputs).toEqual([{item: 'in'}] as never)
+    })
+
     it('drops rows whose owner does not match (positional-index safety re-filter)', async () => {
         const other = row({owner: Name.from('someoneelse.gm')})
         const m = managerWith(

package/src/managers/jobs.ts

@@ -32,19 +32,23 @@ export class JobsManager extends BaseManager {
     private parseOwnedJob(r: JobRow, now: Date): OwnedJob {
         const startsAt = r.starts_at.toDate()
         const completesAt = r.completes_at.toDate()
+        const arrivesAt = r.arrives_at.toDate()
         const deposited = jobDeposited(r.deposited)
-        const {output, inputs} = splitJobCargo(r.cargo, deposited)
+        const quantity = r.quantity.toNumber()
+        const building = r.building.toNumber()
+        const {output, inputs} = splitJobCargo(r.cargo, deposited, quantity)
         return {
             id: r.id.toNumber(),
-            building: r.building.toNumber(),
+            building,
             socket: r.socket.toNumber(),
             shipId: r.ship_id.toNumber(),
             coords: {x: r.coords.x.toNumber(), y: r.coords.y.toNumber()},
             startsAt,
             completesAt,
+            arrivesAt,
             recipeId: r.recipe_id.toNumber(),
-            quantity: r.quantity.toNumber(),
-            status: jobStatus({startsAt, completesAt, deposited}, now),
+            quantity,
+            status: jobStatus({startsAt, completesAt, deposited, quantity, building, inputs}, now),
             deposited,
             output,
             inputs,

package/src/receipts.ts

@@ -1,22 +1,22 @@
 import {Serializer} from '@wharfkit/antelope'
 import {ServerContract} from './contracts'
 
-export type BookingReceipt = ServerContract.Types.booking_receipt
+export type WindowReceipt = ServerContract.Types.window_receipt
 
-export function decodeBookingReceipt(data: unknown): BookingReceipt {
+export function decodeWindowReceipt(data: unknown): WindowReceipt {
     if (data === null || data === undefined) {
-        throw new Error('decodeBookingReceipt: no return value')
+        throw new Error('decodeWindowReceipt: no return value')
     }
     if (data instanceof Uint8Array || typeof data === 'string') {
-        return Serializer.decode({data, type: ServerContract.Types.booking_receipt})
+        return Serializer.decode({data, type: ServerContract.Types.window_receipt})
     }
-    return ServerContract.Types.booking_receipt.from(data as ServerContract.Types.booking_receipt)
+    return ServerContract.Types.window_receipt.from(data as ServerContract.Types.window_receipt)
 }
 
-export function bookingReceiptLandsAtMs(receipt: BookingReceipt): number {
-    return receipt.lands_at.toMilliseconds()
+export function windowReceiptStartsAtMs(receipt: WindowReceipt): number {
+    return receipt.starts_at.toMilliseconds()
 }
 
-export function bookingReceiptRuntimeSeconds(receipt: BookingReceipt): number {
-    return Number(receipt.runtime)
+export function windowReceiptCompletesAtMs(receipt: WindowReceipt): number {
+    return receipt.completes_at.toMilliseconds()
 }