@aephia/atlas-kit 0.6.0-next.17 → 0.6.0-next.170

package/dist/crafting/actions/index.js

@@ -1,15 +1,26 @@
-import { getAddressEncoder, getBytesEncoder, getProgramDerivedAddress, isAddress, } from '@solana/kit';
+import { deriveCurrencyCache, validateCurrencyCache, } from '../../internal/c4/currency-cache.js';
+import { validateStarbaseSystem } from '../../internal/planning/starbase-system.js';
+import { SYSTEM_PROGRAM } from '../../internal/system-program.js';
+import { isAddress } from '@solana/kit';
+import { resolveActionRuntime } from '../../internal/planning/action-runtime.js';
+import { requireProfileStarbasePlayer } from '../../internal/planning/starbase-player-owner.js';
 import { InvalidActionInputError, SageSdkError } from '../../client/errors.js';
 import { readContextRawAccounts } from '../../client/reconciliation.js';
-import { sage } from '../../internal/c4/bindings.js';
+import { SAGE_PROGRAM_ADDRESS } from '../../internal/c4/runtime-bindings.js';
 import { craftingHabAccountDefinition, craftingProcessAccountDefinition, deriveRecipeAddress, recipeAccountDefinition, } from '../../internal/c4/crafting.js';
-import { characterAccountDefinition, findCharacterPda, } from '../../internal/c4/identity.js';
+import { characterAccountDefinition, findCharacterPda, } from '../../internal/c4/character.js';
 import { deriveStarbasePlayerAddress, starbasePlayerAccountDefinition, } from '../../internal/c4/starbase.js';
 import { deriveInternalCraftingProcessState } from '../../internal/crafting-process-state.js';
 import { requireGameAddress } from '../../internal/game-context.js';
-import { adaptCancelCraftingProcessInstruction, adaptStartCraftingProcessInstruction, adaptCompleteCraftingProcessInstruction, validatePlanAuthorization, } from '../../internal/planning/authorization-adapter.js';
-import { deriveStarSystemAddress, starSystemAccountDefinition, } from '../../internal/c4/world.js';
-import { createPlan, } from '../../planning/index.js';
+import { adaptCancelCraftingProcessInstruction, adaptStartCraftingProcessInstruction, adaptCompleteCraftingProcessInstruction, readPlanAuthorization, } from '../../internal/planning/authorization-adapter.js';
+import { starSystemAccountDefinition } from '../../internal/c4/world.js';
+import { buildPlannerPlan } from '../../planning/plan-construction.js';
+import { hashRecipeConfiguration, validateRecipeUsage, } from '../../internal/planning/recipe-state.js';
+import { accountStatePrecondition } from '../../internal/planning/account-state.js';
+import { GAME_DISCRIMINATOR } from '../../internal/c4/discriminators.js';
+import { readCraftingStorageAction } from '../../internal/planning/crafting-storage-actions.js';
+import { planStorageFunding } from '../../internal/planning/storage-actions.js';
+import { RENT_ADDRESS } from '../../internal/planning/rent.js';
 const U64_MAX = (1n << 64n) - 1n;
 const U32_MAX = 4_294_967_295;
 function invalid(field, value, acceptedRange, remedy) {
@@ -38,15 +49,7 @@ function readAddress(value, field) {
 function validateStartOptions(value) {
     const options = readRecord(value, 'options');
     assertKeys(options, 'options', ['authorization', 'craftingProcess', 'quantity', 'numCrew'], ['craftingHab']);
-    const authorizationRecord = readRecord(options.authorization, 'authorization');
-    assertKeys(authorizationRecord, 'authorization', ['profile', 'authority', 'keyIndex'], ['certificate']);
-    const authorization = authorizationRecord;
-    readAddress(authorization.profile, 'authorization.profile');
-    readAddress(authorization.authority, 'authorization.authority');
-    if (authorization.certificate !== undefined) {
-        readAddress(authorization.certificate, 'authorization.certificate');
-    }
-    validatePlanAuthorization(authorization);
+    const authorization = readPlanAuthorization(options.authorization);
     if (typeof options.quantity !== 'bigint' ||
         options.quantity <= 0n ||
         options.quantity > U64_MAX) {
@@ -54,9 +57,9 @@ function validateStartOptions(value) {
     }
     if (typeof options.numCrew !== 'number' ||
         !Number.isInteger(options.numCrew) ||
-        options.numCrew < 0 ||
+        options.numCrew < 1 ||
         options.numCrew > U32_MAX) {
-        invalid('numCrew', options.numCrew, `an integer from 0 through ${String(U32_MAX)} (unsigned u32)`, 'Set numCrew to the exact available crew count within the instruction codec range.');
+        invalid('numCrew', options.numCrew, `an integer from 1 through ${String(U32_MAX)} (unsigned u32)`, 'Set numCrew to at least one crew member, within the instruction codec range; a Crafting Process cannot start without crew.');
     }
     return {
         authorization,
@@ -68,18 +71,11 @@ function validateStartOptions(value) {
             : { craftingHab: options.craftingHab }),
     };
 }
-function validateCompleteOptions(value) {
+/** Validates completion or cancellation options, which share one shape. */
+function validateProcessOptions(value) {
     const options = readRecord(value, 'options');
     assertKeys(options, 'options', ['authorization', 'atUnixSeconds']);
-    const authorizationRecord = readRecord(options.authorization, 'authorization');
-    assertKeys(authorizationRecord, 'authorization', ['profile', 'authority', 'keyIndex'], ['certificate']);
-    const authorization = authorizationRecord;
-    readAddress(authorization.profile, 'authorization.profile');
-    readAddress(authorization.authority, 'authorization.authority');
-    if (authorization.certificate !== undefined) {
-        readAddress(authorization.certificate, 'authorization.certificate');
-    }
-    validatePlanAuthorization(authorization);
+    const authorization = readPlanAuthorization(options.authorization);
     if (typeof options.atUnixSeconds !== 'bigint' || options.atUnixSeconds < 0n) {
         invalid('atUnixSeconds', options.atUnixSeconds, 'a non-negative bigint Unix timestamp', 'Set atUnixSeconds to the explicit current Unix timestamp before retrying.');
     }
@@ -87,20 +83,8 @@ function validateCompleteOptions(value) {
 }
 function validateCancelOptions(value) {
     const options = readRecord(value, 'options');
-    assertKeys(options, 'options', ['authorization', 'atUnixSeconds']);
-    const authorizationRecord = readRecord(options.authorization, 'authorization');
-    assertKeys(authorizationRecord, 'authorization', ['profile', 'authority', 'keyIndex'], ['certificate']);
-    const authorization = authorizationRecord;
-    readAddress(authorization.profile, 'authorization.profile');
-    readAddress(authorization.authority, 'authorization.authority');
-    if (authorization.certificate !== undefined) {
-        readAddress(authorization.certificate, 'authorization.certificate');
-    }
-    validatePlanAuthorization(authorization);
-    if (typeof options.atUnixSeconds !== 'bigint' || options.atUnixSeconds < 0n) {
-        invalid('atUnixSeconds', options.atUnixSeconds, 'a non-negative bigint Unix timestamp', 'Set atUnixSeconds to the explicit current Unix timestamp before retrying.');
-    }
-    return { atUnixSeconds: options.atUnixSeconds, authorization };
+    assertKeys(options, 'options', ['authorization']);
+    return { authorization: readPlanAuthorization(options.authorization) };
 }
 function fail(message, address) {
     throw new SageSdkError('ACTION_PRECONDITION_FAILED', message, { address });
@@ -134,48 +118,19 @@ function validateKnownInputs(recipe, items, quantity, source, sourceAddress) {
         }
     }
 }
-async function deriveCurrencyCacheAddress(game) {
-    const [address] = await getProgramDerivedAddress({
-        programAddress: sage.SAGE_PROGRAM_ADDRESS,
-        seeds: [
-            getBytesEncoder().encode(new TextEncoder().encode('CurrencyConfig')),
-            getAddressEncoder().encode(game),
-        ],
-    });
-    return address;
-}
-function validateCurrencyCache(account, game, canonicalAddress) {
-    const decoder = sage.getCurrencyConfigCacheDecoder();
-    const validDiscriminator = sage.CURRENCY_CONFIG_CACHE_DISCRIMINATOR.every((byte, index) => account.data[index] === byte);
-    if (account.address !== canonicalAddress ||
-        account.owner !== sage.SAGE_PROGRAM_ADDRESS ||
-        account.data.length !== decoder.fixedSize ||
-        !validDiscriminator ||
-        decoder.decode(account.data).gameId !== game) {
-        fail(`CurrencyCache ${account.address} does not match the configured Game, canonical PDA, owner, or pinned account layout. Refresh the Game currency configuration and retry.`, account.address);
-    }
-}
-async function hashAccountState(account) {
-    const owner = getAddressEncoder().encode(account.owner);
-    const canonical = new Uint8Array(owner.length + account.data.length);
-    canonical.set(owner);
-    canonical.set(account.data, owner.length);
-    const digest = new Uint8Array(await globalThis.crypto.subtle.digest('SHA-256', canonical));
-    return [...digest].map((byte) => byte.toString(16).padStart(2, '0')).join('');
-}
-async function precondition(account, describes) {
-    return Object.freeze({
+async function recipePrecondition(account, describes, requiredUses = 0n) {
+    return {
+        kind: 'recipe-state',
         address: account.address,
-        dataHash: await hashAccountState(account),
+        configHash: await hashRecipeConfiguration(account),
+        requiredUses,
         describes,
-        kind: 'account-state',
-    });
+    };
 }
-async function resolveAccounts(ctx, recipe, player, options, game) {
-    const character = await findCharacterPda(options.authorization.profile, game);
+async function resolveAccounts(ctx, recipe, player, options, game, character) {
     const currencyCache = options.craftingHab === undefined
         ? undefined
-        : await deriveCurrencyCacheAddress(game);
+        : await deriveCurrencyCache(game).then(([address]) => address);
     const addresses = [
         character,
         player.address,
@@ -218,11 +173,12 @@ async function resolveAccounts(ctx, recipe, player, options, game) {
         recipeData.id !== recipe.id ||
         recipeData.status !== recipe.status ||
         recipeData.habRequired !== recipe.habRequired ||
-        recipeData.usageCountRaw !== recipe.usageCountRaw ||
         recipeData.usageLimitRaw !== recipe.usageLimitRaw ||
         !sameBalances(recipe.ingredients, recipeData.inputs)) {
         fail(`Recipe ${recipe.address} changed or does not match the configured Game, canonical PDA, status, limits, or ingredients. Refresh the Recipe through this context and retry.`, recipe.address);
     }
+    // One start consumes one Recipe use, independent of the crafted quantity.
+    validateRecipeUsage(recipeAccount, 1n);
     if (options.craftingHab === undefined) {
         return { character, characterAccount, playerAccount, recipeAccount };
     }
@@ -234,13 +190,22 @@ async function resolveAccounts(ctx, recipe, player, options, game) {
         habData.ownerProfile !== options.authorization.profile ||
         habData.system !== player.system.address ||
         habData.state.kind !== options.craftingHab.state.kind ||
+        // The crew reservation was computed from the snapshot's modifier.
+        habData.modifiers.crewCount.raw !==
+            options.craftingHab.modifiers.crewCount.raw ||
         Math.max(0, habData.jobCapacity - habData.jobsRunning) !==
             options.craftingHab.availableJobSlots ||
         !habData.unlockedRecipeIds.includes(recipe.id) ||
         !sameBalances(options.craftingHab.production.inventory.items, habData.production.inventory.amounts)) {
-        fail(`Crafting Hab ${options.craftingHab.address} changed or does not match its Game, Profile, System, active capacity, unlocked Recipe, or production inventory. Refresh the Crafting Hab through this context and retry.`, options.craftingHab.address);
+        fail(`Crafting Hab ${options.craftingHab.address} changed or does not match its Game, Profile, System, active capacity, crew-count modifier, unlocked Recipe, or production inventory. Refresh the Crafting Hab through this context and retry.`, options.craftingHab.address);
     }
-    validateCurrencyCache(currencyCacheAccount, game, currencyCache);
+    // The Character's research concurrency bonus raises the Hab's job limit.
+    const jobLimit = habData.jobCapacity +
+        characterData.modifiers.values.craftingJobConcurrencyBonus;
+    if (habData.jobsRunning >= jobLimit) {
+        fail(`Crafting Hab ${options.craftingHab.address} runs ${String(habData.jobsRunning)} jobs, its limit including the Character's concurrency bonus (${String(jobLimit)}). Complete or cancel another Hab job, refresh it, and retry.`, options.craftingHab.address);
+    }
+    await validateCurrencyCache(currencyCacheAccount, game, 'crafting');
     return {
         character,
         characterAccount,
@@ -254,9 +219,16 @@ async function resolveAccounts(ctx, recipe, player, options, game) {
 /** Plans one Crafting Process start without signing, simulation, or writes.
  *
  * The planner validates the loaded Recipe and Starbase Player, optional Hab,
- * known ingredient balances, available crew, and exact whole-account state. It
- * returns one inert Plan whose two required signer roles are bound only during
- * execution.
+ * known ingredient balances, the crew the job reserves, the Hab job limit
+ * including the Character's research concurrency bonus, and exact
+ * whole-account state. The ATLAS fee and any crew-roster bonuses remain
+ * chain-authoritative. It returns one inert Plan whose two required signer
+ * roles are bound only during execution.
+ *
+ * Each start consumes exactly one Recipe use, whatever its quantity, and needs
+ * the Recipe's fresh `usageCountRaw` to be below `usageLimitRaw`. A stored
+ * limit of `0n` is therefore never usable. Cancelling or destroying a process
+ * returns its use. See `docs/evidence/crafting-zero-usage-limit.md`.
  *
  * @example
  * ```ts
@@ -275,26 +247,19 @@ export async function planStartCraftingProcess(ctx, recipe, player, input) {
     if (recipe.game.address !== game || canonicalRecipe !== recipe.address) {
         fail(`Recipe ${recipe.address} does not match the configured Game ${game} or its canonical recipe-id PDA. Refresh the Recipe through this context and retry.`, recipe.address);
     }
-    if (player.playerProfile.address !== options.authorization.profile) {
-        fail(`Starbase Player ${player.address} does not belong to authorization Profile ${options.authorization.profile}. Refresh the Starbase Player for that Profile and retry.`, player.address);
-    }
-    const canonicalPlayer = await deriveStarbasePlayerAddress(player.system.address, player.character.address);
-    if (canonicalPlayer !== player.address) {
-        fail(`Starbase Player ${player.address} is not canonical for its Character and System. Refresh the Starbase Player through this context and retry.`, player.address);
-    }
+    const character = await requireProfileStarbasePlayer(player, options.authorization.profile, game);
     if (recipe.status !== 'active') {
         fail(`Recipe ${recipe.name} is ${recipe.status}, so it cannot start a Crafting Process. Choose an active Recipe, refresh it, and retry.`, recipe.address);
     }
-    if (recipe.usageLimitRaw !== 0n &&
-        (recipe.usageCountRaw >= recipe.usageLimitRaw ||
-            options.quantity > recipe.usageLimitRaw - recipe.usageCountRaw)) {
-        const remaining = recipe.usageCountRaw >= recipe.usageLimitRaw
-            ? 0n
-            : recipe.usageLimitRaw - recipe.usageCountRaw;
-        fail(`Recipe ${recipe.name} usage limit has remaining ${String(remaining)}, but requested ${String(options.quantity)}. Reduce quantity or choose another active Recipe before retrying.`, recipe.address);
-    }
-    if (options.numCrew > player.availableCrew) {
-        fail(`Starbase Player ${player.address} has only ${String(player.availableCrew)} crew available, but numCrew requested ${String(options.numCrew)}. Reduce numCrew or free crew, refresh the Starbase Player, and retry.`, player.address);
+    // A Crafting Hab scales the reserved crew by its crew-count modifier
+    // (U26F6, 64 raw units per 1.0), rounded up.
+    const reservedCrew = options.craftingHab === undefined
+        ? BigInt(options.numCrew)
+        : (BigInt(options.numCrew) * options.craftingHab.modifiers.crewCount.raw +
+            63n) /
+            64n;
+    if (reservedCrew > BigInt(player.availableCrew)) {
+        fail(`Starbase Player ${player.address} has only ${String(player.availableCrew)} crew available, but this job reserves ${String(reservedCrew)} (numCrew ${String(options.numCrew)}${options.craftingHab === undefined ? '' : ' scaled by the Crafting Hab crew-count modifier'}). Reduce numCrew or free crew, refresh the Starbase Player, and retry.`, player.address);
     }
     if (recipe.habRequired && options.craftingHab === undefined) {
         fail(`Recipe ${recipe.name} requires a Crafting Hab. Provide craftingHab from the same Profile and Star System before retrying.`, recipe.address);
@@ -312,57 +277,90 @@ export async function planStartCraftingProcess(ctx, recipe, player, input) {
         if (options.craftingHab.state.kind !== 'active') {
             fail(`Crafting Hab ${options.craftingHab.address} is ${options.craftingHab.state.kind}; it must be active before starting a Crafting Process. Refresh or reactivate the Hab and retry.`, options.craftingHab.address);
         }
-        if (options.craftingHab.availableJobSlots < 1) {
-            fail(`Crafting Hab ${options.craftingHab.address} has no available job slots. Complete or cancel another Hab job, refresh it, and retry.`, options.craftingHab.address);
-        }
         if (!options.craftingHab.unlockedRecipes.some(({ address }) => address === recipe.address)) {
             fail(`Crafting Hab ${options.craftingHab.address} has not unlocked Recipe ${recipe.name}. Choose an unlocked Recipe or update the Hab before retrying.`, options.craftingHab.address);
         }
-        validateKnownInputs(recipe, options.craftingHab.production.inventory.items, options.quantity, 'Crafting Hab', options.craftingHab.address);
-    }
-    else {
-        validateKnownInputs(recipe, player.cargo.items, options.quantity, 'Starbase Player', player.address);
     }
-    const resolved = await resolveAccounts(ctx, recipe, player, options, game);
+    // Inputs come from the Starbase Player's cargo whether or not a Hab is used.
+    validateKnownInputs(recipe, player.cargo.items, options.quantity, 'Starbase Player', player.address);
+    const resolved = await resolveAccounts(ctx, recipe, player, options, game, character);
+    const [runtimeSystem] = await readContextRawAccounts(ctx, [
+        player.system.address,
+    ]);
+    if (!runtimeSystem)
+        fail('The crafting System is missing. Refresh the Starbase and recreate this Plan.', player.system.address);
+    const runtime = await resolveActionRuntime(ctx, {
+        mode: 'crafting-start',
+        game,
+        system: player.system.address,
+        starbaseSeqId: starSystemAccountDefinition.decode(runtimeSystem).sequenceId,
+        ...(options.craftingHab === undefined
+            ? {}
+            : { structure: options.craftingHab.address }),
+    });
     const description = `Start crafting ${String(options.quantity)} units of ${recipe.name} with ${String(options.numCrew)} crew at Starbase Player ${player.address}.`;
     const preconditions = [
-        precondition(resolved.characterAccount, `The canonical Character remains assigned to Profile ${options.authorization.profile} in the configured Game.`),
-        precondition(resolved.playerAccount, `Starbase Player ${player.address} retains its Character, Profile, System, crew, and input inventory.`),
-        precondition(resolved.recipeAccount, `Recipe ${recipe.name} remains active with the validated usage limit and ingredients.`),
+        accountStatePrecondition(resolved.characterAccount, `The canonical Character remains assigned to Profile ${options.authorization.profile} in the configured Game.`),
+        accountStatePrecondition(resolved.playerAccount, `Starbase Player ${player.address} retains its Character, Profile, System, crew, and input inventory.`),
+        recipePrecondition(resolved.recipeAccount, `Recipe ${recipe.name} retains its configuration and at least one remaining use for this job.`, 1n),
         ...(resolved.habAccount === undefined
             ? []
             : [
-                precondition(resolved.habAccount, `Crafting Hab ${resolved.habAccount.address} remains active with an available job slot, the Recipe unlocked, and sufficient inputs.`),
-                precondition(resolved.currencyCacheAccount, 'The canonical CurrencyCache remains assigned to the configured Game for Hab crafting.'),
+                accountStatePrecondition(resolved.habAccount, `Crafting Hab ${resolved.habAccount.address} remains active with an available job slot and the Recipe unlocked; inputs come from the Starbase Player's cargo.`),
             ]),
     ];
-    return createPlan({
+    const instruction = adaptStartCraftingProcessInstruction({
+        ...runtime.accounts,
+        starbaseGovernance: runtime.accounts.starbaseGovernance,
+        authorization: options.authorization,
+        character: resolved.character,
+        craftingProcess: options.craftingProcess,
+        game,
+        numCrew: options.numCrew,
+        quantity: options.quantity,
+        recipe: recipe.address,
+        starbasePlayer: player.address,
+        system: player.system.address,
+        ...(options.craftingHab === undefined
+            ? {}
+            : {
+                craftingHabInstance: options.craftingHab.address,
+                currencyCache: resolved.currencyCache,
+            }),
+    });
+    // A start creates the Crafting Process and consumes inputs from the Starbase
+    // Player; the program funds the net growth from the Profile vault with the
+    // signing key.
+    const [profileAccount, rentAccount] = await readContextRawAccounts(ctx, [
+        options.authorization.profile,
+        RENT_ADDRESS,
+    ]);
+    const storageAccounts = new Map([
+        [resolved.recipeAccount.address, resolved.recipeAccount],
+        [resolved.playerAccount.address, resolved.playerAccount],
+        [options.authorization.profile, profileAccount],
+        [RENT_ADDRESS, rentAccount],
+    ]);
+    const storage = planStorageFunding({
+        action: readCraftingStorageAction(instruction, storageAccounts),
+        accounts: storageAccounts,
+        label: 'Crafting Process start',
+    });
+    return buildPlannerPlan({
         kind: 'crafting.start-process',
-        preconditions: await Promise.all(preconditions),
+        preconditions: [
+            ...runtime.guards,
+            ...(await Promise.all(preconditions)),
+            storage.guard,
+        ],
         steps: [
             {
-                describes: description,
-                instruction: adaptStartCraftingProcessInstruction({
-                    authorization: options.authorization,
-                    character: resolved.character,
-                    craftingProcess: options.craftingProcess,
-                    game,
-                    numCrew: options.numCrew,
-                    quantity: options.quantity,
-                    recipe: recipe.address,
-                    starbasePlayer: player.address,
-                    system: player.system.address,
-                    ...(options.craftingHab === undefined
-                        ? {}
-                        : {
-                            craftingHabInstance: options.craftingHab.address,
-                            currencyCache: resolved.currencyCache,
-                        }),
-                }),
+                describes: `${description} ${runtime.description} ${storage.disclosure}`,
+                instruction,
                 signers: [options.authorization.authority, options.craftingProcess],
             },
         ],
-        summary: description,
+        summary: `${description} ${runtime.description} ${storage.disclosure}`,
     });
 }
 function sameProcessSnapshot(process, account) {
@@ -372,7 +370,7 @@ function sameProcessSnapshot(process, account) {
         account.system === process.system.address &&
         account.starbasePlayer === process.starbasePlayer.address &&
         account.starbaseSequenceId === process.starbaseSequenceId &&
-        account.craftingHab === process.craftingHab.address &&
+        account.craftingHab === process.craftingHab?.address &&
         account.quantityRaw === process.quantityRaw &&
         account.numCrew === process.numCrew &&
         account.startsAtUnixSeconds === process.startsAtUnixSeconds &&
@@ -382,47 +380,64 @@ function sameProcessSnapshot(process, account) {
         account.inputs.storageCostRaw === process.inputs.usedStorageUnitsRaw &&
         sameBalances(process.inputs.items, account.inputs.amounts));
 }
+/** SDK reads omit `craftingHab` for a Process without a Hab; a caller-built
+ * snapshot carrying the raw stored System address is rejected with that cause
+ * instead of being read as a Hab and reported as a changed Process. */
+function processHabAddress(process) {
+    const habAddress = process.craftingHab?.address;
+    if (habAddress === SYSTEM_PROGRAM)
+        invalid('process.craftingHab', habAddress, 'a Crafting Hab address, or no craftingHab for a Process started without a Hab', 'The stored System address means this Process has no Hab. Use a snapshot from getCraftingProcess, which omits craftingHab, or omit craftingHab, then plan again.');
+    return habAddress;
+}
 function validateGameRead(account, game) {
     if (account.address !== game ||
-        account.owner !== sage.SAGE_PROGRAM_ADDRESS ||
-        account.data.length < sage.GAME_DISCRIMINATOR.length ||
-        !sage.GAME_DISCRIMINATOR.every((byte, index) => account.data[index] === byte)) {
+        account.owner !== SAGE_PROGRAM_ADDRESS ||
+        account.data.length < GAME_DISCRIMINATOR.length ||
+        !GAME_DISCRIMINATOR.every((byte, index) => account.data[index] === byte)) {
         fail(`Game ${account.address} does not match the configured address, owner, or pinned account layout. Refresh the configured Game and retry.`, account.address);
     }
 }
-async function resolveCompleteAccounts(ctx, process, options, game) {
-    const character = await findCharacterPda(options.authorization.profile, game);
-    const currencyCache = await deriveCurrencyCacheAddress(game);
-    const habAddress = process.craftingHab.address === sage.SAGE_PROGRAM_ADDRESS
-        ? undefined
-        : process.craftingHab.address;
-    const addresses = [
+/** Reads and validates the Crafting Process graph shared by completion and
+ * cancellation, with `extra` in the same read: the unchanged Process, its
+ * canonical System and Starbase, the unchanged Recipe and its Hab policy, the
+ * Profile's canonical Starbase Player and Character, and the Process Hab,
+ * active and owned, when present. `action` completes the remedies, and
+ * `staleStarbaseGuidance` adds advice for a replaced Starbase. With
+ * `readHab` false the Hab is passed by its stored address only and is not
+ * read, as cancellation tolerates a Hab in any state or none at all. */
+async function resolveProcessAccounts(ctx, process, profile, game, action, extra, staleStarbaseGuidance, readHab = true) {
+    const character = await findCharacterPda(profile, game);
+    const habAddress = processHabAddress(process);
+    const habRead = readHab ? habAddress : undefined;
+    // The SAGE program address is the omitted-account placeholder, so the
+    // program would see no Hab where the Process stores one.
+    if (!readHab && habAddress === SAGE_PROGRAM_ADDRESS)
+        fail(`Crafting Process ${process.address} stores the SAGE program address as its Crafting Hab, which the instruction cannot pass as a Hab. Refresh the Crafting Process; it cannot be cancelled while it stores that address.`, process.address);
+    const [processCandidate, recipeCandidate, playerCandidate, systemCandidate, characterCandidate, extraAccount, habCandidate,] = await readContextRawAccounts(ctx, [
         process.address,
         process.recipe.address,
         process.starbasePlayer.address,
         process.system.address,
-        ...(habAddress === undefined ? [] : [habAddress]),
         character,
-        game,
-        currencyCache,
-    ];
-    const reads = await readContextRawAccounts(ctx, addresses);
-    const byAddress = new Map(addresses.map((address, index) => [address, reads[index]]));
-    const processAccount = requireAccount(byAddress.get(process.address), process.address, `Crafting Process ${process.address} is missing, so it may already be cancelled or closed. Refresh the Crafting Process and retry only if it still exists.`);
-    const recipeAccount = requireAccount(byAddress.get(process.recipe.address), process.recipe.address, `Recipe ${process.recipe.address} is missing. Refresh the Crafting Process and its Recipe before retrying completion.`);
-    const playerAccount = requireAccount(byAddress.get(process.starbasePlayer.address), process.starbasePlayer.address, `Starbase Player ${process.starbasePlayer.address} is missing. Refresh the Crafting Process and Starbase Player before retrying completion.`);
-    const systemAccount = requireAccount(byAddress.get(process.system.address), process.system.address, `Star System ${process.system.address} is missing. Refresh the Crafting Process and Star System before retrying completion.`);
-    const characterAccount = requireAccount(byAddress.get(character), character, `Canonical Character ${character} is missing for Profile ${options.authorization.profile}. Create or repair the Character in the configured Game before retrying completion.`);
-    const gameAccount = requireAccount(byAddress.get(game), game, `Configured Game ${game} is missing. Refresh the configured Game before retrying completion.`);
-    const currencyCacheAccount = requireAccount(byAddress.get(currencyCache), currencyCache, `Canonical CurrencyCache ${currencyCache} is missing for the configured Game. Refresh the Game currency configuration before retrying completion.`);
-    const habAccount = habAddress === undefined
-        ? undefined
-        : requireAccount(byAddress.get(habAddress), habAddress, `Crafting Hab ${habAddress} is missing. Refresh the Crafting Process and Hab before retrying completion.`);
-    const processData = craftingProcessAccountDefinition.decode(processAccount);
+        extra,
+        ...(habRead === undefined ? [] : [habRead]),
+    ]);
+    const processAccount = requireAccount(processCandidate, process.address, `Crafting Process ${process.address} is missing, so it may already be completed, cancelled, or closed. Refresh the Crafting Process and retry only if it still exists.`);
     if (processAccount.address !== process.address ||
-        !sameProcessSnapshot(process, processData)) {
+        !sameProcessSnapshot(process, craftingProcessAccountDefinition.decode(processAccount))) {
         fail(`Crafting Process ${process.address} changed or no longer matches its relationships, timing, crew, quantity, fee, or inputs. Refresh the Crafting Process and retry.`, process.address);
     }
+    await validateStarbaseSystem(requireAccount(systemCandidate, process.system.address, `Star System ${process.system.address} is missing. Refresh the Crafting Process and Star System before retrying ${action}.`), {
+        address: process.system.address,
+        game,
+        starbaseSequenceId: process.starbaseSequenceId,
+    }, staleStarbaseGuidance);
+    const recipeAccount = requireAccount(recipeCandidate, process.recipe.address, `Recipe ${process.recipe.address} is missing. Refresh the Crafting Process and its Recipe before retrying ${action}.`);
+    const playerAccount = requireAccount(playerCandidate, process.starbasePlayer.address, `Starbase Player ${process.starbasePlayer.address} is missing. Refresh the Crafting Process and Starbase Player before retrying ${action}.`);
+    const characterAccount = requireAccount(characterCandidate, character, `Canonical Character ${character} is missing for Profile ${profile}. Create or repair the Character in the configured Game before retrying ${action}.`);
+    const habAccount = habRead === undefined
+        ? undefined
+        : requireAccount(habCandidate, habRead, `Crafting Hab ${habAddress} is missing. Refresh the Crafting Process and Hab before retrying ${action}.`);
     const recipeData = recipeAccountDefinition.decode(recipeAccount);
     const canonicalRecipe = await deriveRecipeAddress(game, recipeData.id);
     if (recipeAccount.address !== process.recipe.address ||
@@ -432,65 +447,73 @@ async function resolveCompleteAccounts(ctx, process, options, game) {
         recipeData.name !== process.recipe.name ||
         recipeData.status !== process.recipe.status ||
         recipeData.habRequired !== process.recipe.habRequired ||
-        recipeData.usageCountRaw !== process.recipe.usageCountRaw ||
         recipeData.usageLimitRaw !== process.recipe.usageLimitRaw ||
         !sameBalances(process.recipe.ingredients, recipeData.inputs) ||
         !sameBalances(process.recipe.outputs, recipeData.outputs)) {
-        fail(`Recipe ${process.recipe.address} changed or does not match the configured Game, canonical recipe-id PDA, status, Hab policy, limits, ingredients, or outputs. Refresh the Crafting Process and Recipe before retrying completion.`, process.recipe.address);
+        fail(`Recipe ${process.recipe.address} changed or does not match the configured Game, canonical recipe-id PDA, status, Hab policy, limits, ingredients, or outputs. Refresh the Crafting Process and Recipe before retrying ${action}.`, process.recipe.address);
     }
     if (recipeData.habRequired && habAddress === undefined) {
-        fail(`Recipe ${recipeData.name} requires a Crafting Hab, but Crafting Process ${process.address} omits one. Refresh or repair the Process relationship before retrying completion.`, process.address);
+        fail(`Recipe ${recipeData.name} requires a Crafting Hab, but Crafting Process ${process.address} omits one. Refresh or repair the Process relationship before retrying ${action}.`, process.address);
     }
     const playerData = starbasePlayerAccountDefinition.decode(playerAccount);
     const canonicalPlayer = await deriveStarbasePlayerAddress(process.system.address, character);
     if (playerAccount.address !== process.starbasePlayer.address ||
         canonicalPlayer !== process.starbasePlayer.address ||
-        playerData.playerProfile !== options.authorization.profile ||
+        playerData.playerProfile !== profile ||
         playerData.character !== character ||
         playerData.system !== process.system.address) {
-        fail(`Starbase Player ${process.starbasePlayer.address} does not match the authorization Profile, canonical Character, or Crafting Process System. Refresh the Crafting Process and Starbase Player before retrying completion.`, process.starbasePlayer.address);
-    }
-    const systemData = starSystemAccountDefinition.decode(systemAccount);
-    const canonicalSystem = await deriveStarSystemAddress(game, systemData.systemId);
-    if (systemAccount.address !== process.system.address ||
-        canonicalSystem !== process.system.address ||
-        systemData.game !== game ||
-        systemData.sequenceId !== process.starbaseSequenceId ||
-        systemData.starbase === undefined) {
-        fail(`Star System ${process.system.address} does not match the configured Game, canonical system-id PDA, active Starbase, or Crafting Process Starbase sequence. Refresh the Crafting Process and Star System before retrying completion.`, process.system.address);
+        fail(`Starbase Player ${process.starbasePlayer.address} does not match the authorization Profile, canonical Character, or Crafting Process System. Refresh the Crafting Process and Starbase Player before retrying ${action}.`, process.starbasePlayer.address);
     }
     if (habAccount !== undefined) {
         const habData = craftingHabAccountDefinition.decode(habAccount);
         if (habAccount.address !== habAddress ||
             habData.game !== game ||
-            habData.ownerProfile !== options.authorization.profile ||
+            habData.ownerProfile !== profile ||
             habData.system !== process.system.address ||
             habData.systemSequenceId !== process.starbaseSequenceId ||
             habData.state.kind !== 'active') {
-            fail(`Crafting Hab ${habAddress} is not active or does not match the configured Game, authorization Profile, Crafting Process System, or Starbase sequence. Refresh the Crafting Process and Hab before retrying completion.`, habAccount.address);
+            fail(`Crafting Hab ${habAddress} is not active or does not match the configured Game, authorization Profile, Crafting Process System, or Starbase sequence. Refresh the Crafting Process and Hab before retrying ${action}.`, habAccount.address);
         }
     }
     const characterData = characterAccountDefinition.decode(characterAccount);
     if (characterAccount.address !== character ||
-        characterData.playerProfile !== options.authorization.profile ||
+        characterData.playerProfile !== profile ||
         characterData.game !== game) {
-        fail(`The canonical Character does not match Profile ${options.authorization.profile} and the configured Game ${game}. Refresh or repair the Character relationship before retrying completion.`, characterAccount.address);
+        fail(`The canonical Character does not match Profile ${profile} and the configured Game ${game}. Refresh or repair the Character relationship before retrying ${action}.`, characterAccount.address);
     }
-    validateGameRead(gameAccount, game);
-    validateCurrencyCache(currencyCacheAccount, game, currencyCache);
     return {
         character,
         characterAccount,
-        currencyCache,
-        currencyCacheAccount,
-        gameAccount,
-        ...(habAccount === undefined ? {} : { habAccount }),
+        extraAccount,
+        habAccount,
+        habAddress,
         playerAccount,
         processAccount,
         recipeAccount,
-        systemAccount,
     };
 }
+/** The validated Process graph preconditions, with `systemGuard` after the
+ * Starbase Player when the action guards the Starbase separately. */
+function processPreconditions(process, resolved, profile, systemGuard = []) {
+    return [
+        accountStatePrecondition(resolved.processAccount, `Crafting Process ${process.address} retains its validated relationships, timing, crew, quantity, fee, and inputs.`),
+        recipePrecondition(resolved.recipeAccount, `Recipe ${process.recipe.name} retains its validated Game, Hab policy, ingredients, and outputs.`),
+        accountStatePrecondition(resolved.playerAccount, `Starbase Player ${process.starbasePlayer.address} retains its Profile, Character, and System relationships.`),
+        ...systemGuard.map((guard) => Promise.resolve(guard)),
+        ...(resolved.habAccount === undefined
+            ? []
+            : [
+                accountStatePrecondition(resolved.habAccount, `Crafting Hab ${resolved.habAccount.address} remains active in the validated Game, Profile, System, and Starbase sequence.`),
+            ]),
+        accountStatePrecondition(resolved.characterAccount, `The canonical Character remains assigned to Profile ${profile} in the configured Game.`),
+    ];
+}
+/** Requires the authorization Profile to own the Process. */
+function requireProcessOwner(process, profile) {
+    if (process.profile.address !== profile) {
+        fail(`Crafting Process ${process.address} does not belong to authorization Profile ${profile}. Use the owning Profile, refresh the Process, and retry.`, process.address);
+    }
+}
 /** Plans completion of one Crafting Process without signing, simulation, or writes.
  *
  * The planner resolves and validates the Process account graph, requires Profile
@@ -508,11 +531,10 @@ async function resolveCompleteAccounts(ctx, process, options, game) {
  * ```
  */
 export async function planCompleteCraftingProcess(ctx, process, input) {
-    const options = validateCompleteOptions(input);
+    const options = validateProcessOptions(input);
     const game = requireGameAddress(ctx);
-    if (process.profile.address !== options.authorization.profile) {
-        fail(`Crafting Process ${process.address} does not belong to authorization Profile ${options.authorization.profile}. Use the owning Profile, refresh the Process, and retry.`, process.address);
-    }
+    const { profile } = options.authorization;
+    requireProcessOwner(process, profile);
     const state = deriveInternalCraftingProcessState(process, options.atUnixSeconds);
     if (state.kind !== 'complete') {
         const timing = state.kind === 'scheduled'
@@ -520,33 +542,36 @@ export async function planCompleteCraftingProcess(ctx, process, input) {
             : `in-progress and not complete with ${String(state.remainingSeconds)} seconds remaining`;
         fail(`Crafting Process ${process.address} is ${timing} at Unix timestamp ${String(options.atUnixSeconds)}. Wait until it is complete, provide a current timestamp, and retry.`, process.address);
     }
-    const resolved = await resolveCompleteAccounts(ctx, process, options, game);
-    const description = `Complete crafting ${String(process.quantityRaw)} units of ${process.recipe.name} at Starbase Player ${process.starbasePlayer.address}, returning ${String(process.numCrew)} crew and producing the Recipe outputs.`;
-    const preconditions = [
-        precondition(resolved.processAccount, `Crafting Process ${process.address} retains its validated relationships, timing, crew, quantity, fee, and inputs.`),
-        precondition(resolved.recipeAccount, `Recipe ${process.recipe.name} retains its validated Game, Hab policy, ingredients, and outputs.`),
-        precondition(resolved.playerAccount, `Starbase Player ${process.starbasePlayer.address} retains its Profile, Character, and System relationships.`),
-        precondition(resolved.systemAccount, `Star System ${process.system.address} retains its active Starbase and validated sequence.`),
+    const [currencyCache] = await deriveCurrencyCache(game);
+    const resolved = await resolveProcessAccounts(ctx, process, profile, game, 'completion', currencyCache);
+    await validateCurrencyCache(requireAccount(resolved.extraAccount, currencyCache, `Canonical CurrencyCache ${currencyCache} is missing for the configured Game. Refresh the Game currency configuration before retrying completion.`), game, 'crafting');
+    const runtime = await resolveActionRuntime(ctx, {
+        mode: 'crafting-complete',
+        game,
+        system: process.system.address,
+        starbaseSeqId: process.starbaseSequenceId,
+        character: resolved.character,
+        process: process.address,
         ...(resolved.habAccount === undefined
-            ? []
-            : [
-                precondition(resolved.habAccount, `Crafting Hab ${resolved.habAccount.address} remains active in the validated Game, Profile, System, and Starbase sequence.`),
-            ]),
-        precondition(resolved.characterAccount, `The canonical Character remains assigned to Profile ${options.authorization.profile} in the configured Game.`),
-        precondition(resolved.gameAccount, `Game ${game} retains its pinned owner and account layout.`),
-        precondition(resolved.currencyCacheAccount, 'The canonical CurrencyCache remains assigned to the configured Game.'),
-    ];
-    return createPlan({
+            ? {}
+            : { structure: resolved.habAccount.address }),
+    });
+    const description = `Complete crafting ${String(process.quantityRaw)} units of ${process.recipe.name} at Starbase Player ${process.starbasePlayer.address}, returning ${String(process.numCrew)} crew and producing the Recipe outputs.`;
+    return buildPlannerPlan({
         kind: 'crafting.complete-process',
-        preconditions: await Promise.all(preconditions),
+        preconditions: [
+            ...runtime.guards,
+            ...(await Promise.all(processPreconditions(process, resolved, profile))),
+        ],
         steps: [
             {
-                describes: description,
+                describes: `${description} ${runtime.description}`,
                 instruction: adaptCompleteCraftingProcessInstruction({
+                    ...runtime.accounts,
                     authorization: options.authorization,
                     character: resolved.character,
                     craftingProcess: process.address,
-                    currencyCache: resolved.currencyCache,
+                    currencyCache,
                     game,
                     recipe: process.recipe.address,
                     starbasePlayer: process.starbasePlayer.address,
@@ -558,114 +583,18 @@ export async function planCompleteCraftingProcess(ctx, process, input) {
                 signers: [options.authorization.authority],
             },
         ],
-        summary: description,
+        summary: `${description} ${runtime.description}`,
     });
 }
-async function resolveCancelAccounts(ctx, process, options, game) {
-    const character = await findCharacterPda(options.authorization.profile, game);
-    const habAddress = process.craftingHab.address === sage.SAGE_PROGRAM_ADDRESS
-        ? undefined
-        : process.craftingHab.address;
-    const addresses = [
-        process.address,
-        process.recipe.address,
-        process.starbasePlayer.address,
-        process.system.address,
-        ...(habAddress === undefined ? [] : [habAddress]),
-        character,
-        game,
-    ];
-    const reads = await readContextRawAccounts(ctx, addresses);
-    const byAddress = new Map(addresses.map((address, index) => [address, reads[index]]));
-    const processAccount = requireAccount(byAddress.get(process.address), process.address, `Crafting Process ${process.address} is missing, so it may already be completed, cancelled, or closed. Refresh the Crafting Process and retry only if it still exists.`);
-    const systemAccount = requireAccount(byAddress.get(process.system.address), process.system.address, `Star System ${process.system.address} is missing. Refresh the Crafting Process and Star System before retrying cancellation.`);
-    const processData = craftingProcessAccountDefinition.decode(processAccount);
-    if (processAccount.address !== process.address ||
-        !sameProcessSnapshot(process, processData)) {
-        fail(`Crafting Process ${process.address} changed or no longer matches its relationships, timing, crew, quantity, fee, or inputs. Refresh the Crafting Process and retry.`, process.address);
-    }
-    const systemData = starSystemAccountDefinition.decode(systemAccount);
-    const canonicalSystem = await deriveStarSystemAddress(game, systemData.systemId);
-    if (systemAccount.address !== process.system.address ||
-        canonicalSystem !== process.system.address ||
-        systemData.game !== game) {
-        fail(`Star System ${process.system.address} does not match the configured Game or canonical system-id PDA. Refresh the Crafting Process and Star System before retrying cancellation.`, process.system.address);
-    }
-    if (systemData.sequenceId !== process.starbaseSequenceId) {
-        fail(`The Starbase sequence for Crafting Process ${process.address} is stale at ${String(process.starbaseSequenceId)}, while Star System ${process.system.address} is at sequence ${String(systemData.sequenceId)}. The program requires destroyCraftingProcess for this destroyed-Starbase cleanup case; do not cancel the Process.`, process.address);
-    }
-    if (systemData.starbase === undefined) {
-        fail(`Star System ${process.system.address} does not have an active Starbase. Refresh the Crafting Process and Star System before retrying cancellation.`, process.system.address);
-    }
-    const recipeAccount = requireAccount(byAddress.get(process.recipe.address), process.recipe.address, `Recipe ${process.recipe.address} is missing. Refresh the Crafting Process and its Recipe before retrying cancellation.`);
-    const playerAccount = requireAccount(byAddress.get(process.starbasePlayer.address), process.starbasePlayer.address, `Starbase Player ${process.starbasePlayer.address} is missing. Refresh the Crafting Process and Starbase Player before retrying cancellation.`);
-    const characterAccount = requireAccount(byAddress.get(character), character, `Canonical Character ${character} is missing for Profile ${options.authorization.profile}. Create or repair the Character in the configured Game before retrying cancellation.`);
-    const gameAccount = requireAccount(byAddress.get(game), game, `Configured Game ${game} is missing. Refresh the configured Game before retrying cancellation.`);
-    const habAccount = habAddress === undefined
-        ? undefined
-        : requireAccount(byAddress.get(habAddress), habAddress, `Crafting Hab ${habAddress} is missing. Refresh the Crafting Process and Hab before retrying cancellation.`);
-    const recipeData = recipeAccountDefinition.decode(recipeAccount);
-    const canonicalRecipe = await deriveRecipeAddress(game, recipeData.id);
-    if (recipeAccount.address !== process.recipe.address ||
-        canonicalRecipe !== process.recipe.address ||
-        recipeData.game !== game ||
-        recipeData.id !== process.recipe.id ||
-        recipeData.name !== process.recipe.name ||
-        recipeData.status !== process.recipe.status ||
-        recipeData.habRequired !== process.recipe.habRequired ||
-        recipeData.usageCountRaw !== process.recipe.usageCountRaw ||
-        recipeData.usageLimitRaw !== process.recipe.usageLimitRaw ||
-        !sameBalances(process.recipe.ingredients, recipeData.inputs) ||
-        !sameBalances(process.recipe.outputs, recipeData.outputs)) {
-        fail(`Recipe ${process.recipe.address} changed or does not match the configured Game, canonical recipe-id PDA, status, Hab policy, limits, ingredients, or outputs. Refresh the Crafting Process and Recipe before retrying cancellation.`, process.recipe.address);
-    }
-    if (recipeData.habRequired && habAddress === undefined) {
-        fail(`Recipe ${recipeData.name} requires a Crafting Hab, but Crafting Process ${process.address} omits one. Refresh or repair the Process relationship before retrying cancellation.`, process.address);
-    }
-    const playerData = starbasePlayerAccountDefinition.decode(playerAccount);
-    const canonicalPlayer = await deriveStarbasePlayerAddress(process.system.address, character);
-    if (playerAccount.address !== process.starbasePlayer.address ||
-        canonicalPlayer !== process.starbasePlayer.address ||
-        playerData.playerProfile !== options.authorization.profile ||
-        playerData.character !== character ||
-        playerData.system !== process.system.address) {
-        fail(`Starbase Player ${process.starbasePlayer.address} does not match the authorization Profile, canonical Character, or Crafting Process System. Refresh the Crafting Process and Starbase Player before retrying cancellation.`, process.starbasePlayer.address);
-    }
-    if (habAccount !== undefined) {
-        const habData = craftingHabAccountDefinition.decode(habAccount);
-        if (habAccount.address !== habAddress ||
-            habData.game !== game ||
-            habData.ownerProfile !== options.authorization.profile ||
-            habData.system !== process.system.address ||
-            habData.systemSequenceId !== process.starbaseSequenceId ||
-            habData.state.kind !== 'active') {
-            fail(`Crafting Hab ${habAddress} is not active or does not match the configured Game, authorization Profile, Crafting Process System, or Starbase sequence. Refresh the Crafting Process and Hab before retrying cancellation.`, habAccount.address);
-        }
-    }
-    const characterData = characterAccountDefinition.decode(characterAccount);
-    if (characterAccount.address !== character ||
-        characterData.playerProfile !== options.authorization.profile ||
-        characterData.game !== game) {
-        fail(`The canonical Character does not match Profile ${options.authorization.profile} and the configured Game ${game}. Refresh or repair the Character relationship before retrying cancellation.`, characterAccount.address);
-    }
-    validateGameRead(gameAccount, game);
-    return {
-        character,
-        characterAccount,
-        gameAccount,
-        ...(habAccount === undefined ? {} : { habAccount }),
-        playerAccount,
-        processAccount,
-        recipeAccount,
-        systemAccount,
-    };
-}
-/** Plans cancellation of one unfinished Crafting Process without signing or writes.
+/** Plans cancellation of one Crafting Process without signing or writes.
  *
  * The planner resolves and validates the Process account graph, requires Profile
- * ownership, and rejects completed or destroyed-Starbase Process snapshots.
- * Final inventory capacity, permissions, returned inputs and crew, and account
- * closure remain chain-authoritative.
+ * ownership, and rejects a Process whose Starbase was destroyed. Cancellation
+ * has no timing rule: a finished Process can still be cancelled, which returns
+ * its inputs and crew instead of producing outputs. A Process Hab is passed by
+ * its stored address in whatever state it is in, or even if it no longer
+ * exists. Final inventory capacity, permissions, returned inputs and crew, and
+ * account closure remain chain-authoritative.
  *
  * @example
  * ```ts
@@ -679,50 +608,67 @@ async function resolveCancelAccounts(ctx, process, options, game) {
 export async function planCancelCraftingProcess(ctx, process, input) {
     const options = validateCancelOptions(input);
     const game = requireGameAddress(ctx);
-    if (process.profile.address !== options.authorization.profile) {
-        fail(`Crafting Process ${process.address} does not belong to authorization Profile ${options.authorization.profile}. Use the owning Profile, refresh the Process, and retry.`, process.address);
-    }
-    const state = deriveInternalCraftingProcessState(process, options.atUnixSeconds);
-    if (state.kind === 'complete') {
-        fail(`Crafting Process ${process.address} is complete at Unix timestamp ${String(options.atUnixSeconds)} and cannot be cancelled. Use planCompleteCraftingProcess with a refreshed snapshot instead.`, process.address);
-    }
-    const resolved = await resolveCancelAccounts(ctx, process, options, game);
-    const description = `Cancel crafting ${String(process.quantityRaw)} units of ${process.recipe.name} at Starbase Player ${process.starbasePlayer.address}, returning all inputs and ${String(process.numCrew)} crew and closing the Crafting Process.`;
-    const preconditions = [
-        precondition(resolved.processAccount, `Crafting Process ${process.address} retains its validated relationships, timing, crew, quantity, fee, and inputs.`),
-        precondition(resolved.recipeAccount, `Recipe ${process.recipe.name} retains its validated Game, Hab policy, usage, ingredients, and outputs.`),
-        precondition(resolved.playerAccount, `Starbase Player ${process.starbasePlayer.address} retains its Profile, Character, and System relationships.`),
-        precondition(resolved.systemAccount, `Star System ${process.system.address} retains its active Starbase and validated sequence.`),
-        ...(resolved.habAccount === undefined
-            ? []
-            : [
-                precondition(resolved.habAccount, `Crafting Hab ${resolved.habAccount.address} remains active in the validated Game, Profile, System, and Starbase sequence.`),
-            ]),
-        precondition(resolved.characterAccount, `The canonical Character remains assigned to Profile ${options.authorization.profile} in the configured Game.`),
-        precondition(resolved.gameAccount, `Game ${game} retains its pinned owner and account layout.`),
-    ];
-    return createPlan({
+    const { profile } = options.authorization;
+    requireProcessOwner(process, profile);
+    const resolved = await resolveProcessAccounts(ctx, process, profile, game, 'cancellation', game, 'For a Crafting Process belonging to the destroyed Starbase, use destroyCraftingProcess; do not cancel the Process.', false);
+    const gameAccount = requireAccount(resolved.extraAccount, game, `Configured Game ${game} is missing. Refresh the configured Game before retrying cancellation.`);
+    validateGameRead(gameAccount, game);
+    const instruction = adaptCancelCraftingProcessInstruction({
+        authorization: options.authorization,
+        character: resolved.character,
+        craftingProcess: process.address,
+        game,
+        recipe: process.recipe.address,
+        starbasePlayer: process.starbasePlayer.address,
+        system: process.system.address,
+        ...(resolved.habAddress === undefined
+            ? {}
+            : { craftingHabInstance: resolved.habAddress }),
+    });
+    // Returned inputs can reopen Starbase Player lines, which the program funds
+    // from the Profile vault before the closed Process refunds its rent.
+    const [profileAccount, rentAccount] = await readContextRawAccounts(ctx, [
+        profile,
+        RENT_ADDRESS,
+    ]);
+    const storageAccounts = new Map([
+        [resolved.playerAccount.address, resolved.playerAccount],
+        [resolved.processAccount.address, resolved.processAccount],
+        [profile, profileAccount],
+        [RENT_ADDRESS, rentAccount],
+    ]);
+    const storage = planStorageFunding({
+        action: readCraftingStorageAction(instruction, storageAccounts),
+        accounts: storageAccounts,
+        label: 'Crafting Process cancellation',
+    });
+    const description = `Cancel crafting ${String(process.quantityRaw)} units of ${process.recipe.name} at Starbase Player ${process.starbasePlayer.address}, returning all inputs and ${String(process.numCrew)} crew and closing the Crafting Process. ${storage.disclosure}`;
+    return buildPlannerPlan({
         kind: 'crafting.cancel-process',
-        preconditions: await Promise.all(preconditions),
+        preconditions: [
+            ...(await Promise.all([
+                ...processPreconditions(process, resolved, profile, [
+                    {
+                        kind: 'starbase-system',
+                        address: process.system.address,
+                        game,
+                        starbaseSequenceId: process.starbaseSequenceId,
+                        describes: `Star System ${process.system.address} retains its canonical Game identity, active Starbase and sequence ${process.starbaseSequenceId}; unrelated shared activity may change.`,
+                    },
+                ]),
+                accountStatePrecondition(gameAccount, `Game ${game} retains its pinned owner and account layout.`),
+            ])),
+            storage.guard,
+        ],
         steps: [
             {
                 describes: description,
-                instruction: adaptCancelCraftingProcessInstruction({
-                    authorization: options.authorization,
-                    character: resolved.character,
-                    craftingProcess: process.address,
-                    game,
-                    recipe: process.recipe.address,
-                    starbasePlayer: process.starbasePlayer.address,
-                    system: process.system.address,
-                    ...(resolved.habAccount === undefined
-                        ? {}
-                        : { craftingHabInstance: resolved.habAccount.address }),
-                }),
+                instruction,
                 signers: [options.authorization.authority],
             },
         ],
         summary: description,
     });
 }
+export { getCraftingFeeRate } from './fee-rate.js';
 //# sourceMappingURL=index.js.map