@aephia/atlas-kit 0.6.0-next.4 → 0.6.0-next.40

package/dist/planning/index.js

@@ -1,6 +1,10 @@
+import { normalizeArrivalGuard, arrivalGuardToJSON, validateArrivalInstructions, } from '../internal/planning/arrival-guards.js';
+import { isRuntimeGuard, normalizeRuntimeGuard, runtimeGuardToJSON, validateRuntimeInstructions, } from '../internal/planning/runtime-guards.js';
+import { isTradeBuyGuard, isTradeSellGuard, isTradeMeterGuard, isFactionTradeGuard, } from '../internal/planning/faction-trade-guards.js';
 import { AccountRole, getBase64Decoder, getBase64Encoder, isAddress, isWritableRole, } from '@solana/kit';
-import { InvalidActionInputError } from '../client/errors.js';
+import { InvalidActionInputError, SageSdkError } from '../client/errors.js';
 import { deepFreeze } from '../internal/immutable-tree.js';
+import { validateMiningStopInstructions } from '../internal/planning/mining-stop.js';
 import { validatePlanComposition } from './composition.js';
 import { isPlanInstance, registerPlanInstance } from './plan-instances.js';
 const PLAN_BRAND = Symbol('AephiaSagePlan');
@@ -159,9 +163,333 @@ function normalizeSemanticFact(value, field) {
     }
     return invalid(`${field}.kind`, semantic.kind, 'one of exclusive, requires, invalidates, or transition');
 }
-function normalizePrecondition(value, field, version = 3) {
+function normalizePrecondition(value, field, version = 17) {
     const precondition = readRecord(value, field);
-    if (precondition.kind === 'token-account-or-absent' && version === 3) {
+    if (version >= 17 && precondition.kind === 'fleet-arrival')
+        return normalizeArrivalGuard(precondition, field);
+    if (version >= 16 && isRuntimeGuard(precondition))
+        return normalizeRuntimeGuard(precondition, field);
+    if (version >= 15 && precondition.kind === 'ship-import-funding') {
+        assertKeys(precondition, field, [
+            'kind',
+            'address',
+            'game',
+            'profile',
+            'system',
+            'shipId',
+            'maximumProfileDebit',
+            'describes',
+        ]);
+        const shipId = precondition.shipId;
+        if (typeof shipId !== 'number' ||
+            !Number.isInteger(shipId) ||
+            shipId < 0 ||
+            shipId > 65535)
+            invalid(`${field}.shipId`, shipId, 'an unsigned u16 ship configuration ID');
+        const maximumProfileDebit = precondition.maximumProfileDebit;
+        if (typeof maximumProfileDebit !== 'bigint' || maximumProfileDebit < 0n)
+            invalid(`${field}.maximumProfileDebit`, maximumProfileDebit, 'a nonnegative bigint');
+        return Object.freeze({
+            kind: 'ship-import-funding',
+            address: readAddress(precondition.address, `${field}.address`),
+            game: readAddress(precondition.game, `${field}.game`),
+            profile: readAddress(precondition.profile, `${field}.profile`),
+            system: readAddress(precondition.system, `${field}.system`),
+            shipId,
+            maximumProfileDebit,
+            describes: readString(precondition.describes, `${field}.describes`),
+        });
+    }
+    if (version >= 13 && precondition.kind === 'fleet-mining') {
+        assertKeys(precondition, field, [
+            'kind',
+            'address',
+            'game',
+            'profile',
+            'asteroid',
+            'describes',
+        ]);
+        return Object.freeze({
+            kind: 'fleet-mining',
+            address: readAddress(precondition.address, `${field}.address`),
+            game: readAddress(precondition.game, `${field}.game`),
+            profile: readAddress(precondition.profile, `${field}.profile`),
+            asteroid: readAddress(precondition.asteroid, `${field}.asteroid`),
+            describes: readString(precondition.describes, `${field}.describes`),
+        });
+    }
+    if (version >= 12 &&
+        isFactionTradeGuard(precondition) &&
+        (version >= 14 || !precondition.kind.endsWith('-versioned'))) {
+        const kind = precondition.kind;
+        const versioned = kind.endsWith('-versioned');
+        assertKeys(precondition, field, [
+            'kind',
+            'address',
+            'game',
+            'factionId',
+            'describes',
+            ...(versioned ? ['schemaVersion'] : []),
+            ...(isTradeBuyGuard(precondition)
+                ? ['cargoId', 'floorRaw']
+                : isTradeSellGuard(precondition)
+                    ? ['atlasOutCapPerEpochRaw', 'epochLengthSeconds']
+                    : []),
+        ]);
+        const unsigned = (key, max = 65535) => {
+            const n = precondition[key];
+            if (typeof n !== 'number' || !Number.isInteger(n) || n < 0 || n > max)
+                invalid(`${field}.${key}`, n, `an unsigned ${max === 255 ? 'u8' : 'u16'} integer`);
+            return n;
+        };
+        const integer = (key, signed = false) => {
+            const n = precondition[key];
+            const min = signed ? -(1n << 63n) : 0n;
+            const max = signed ? (1n << 63n) - 1n : (1n << 64n) - 1n;
+            if (typeof n !== 'bigint' || n < min || n > max)
+                invalid(`${field}.${key}`, n, signed ? 'an i64 bigint' : 'a u64 bigint');
+            return n;
+        };
+        const common = {
+            address: readAddress(precondition.address, `${field}.address`),
+            game: readAddress(precondition.game, `${field}.game`),
+            factionId: unsigned('factionId'),
+            ...(versioned ? { schemaVersion: unsigned('schemaVersion', 255) } : {}),
+            describes: readString(precondition.describes, `${field}.describes`),
+        };
+        if (isTradeBuyGuard(precondition))
+            return Object.freeze({
+                kind,
+                ...common,
+                cargoId: unsigned('cargoId'),
+                floorRaw: integer('floorRaw'),
+            });
+        if (isTradeSellGuard(precondition))
+            return Object.freeze({
+                kind,
+                ...common,
+                atlasOutCapPerEpochRaw: integer('atlasOutCapPerEpochRaw'),
+                epochLengthSeconds: integer('epochLengthSeconds', true),
+            });
+        return Object.freeze({ kind, ...common });
+    }
+    if (version >= 11 && precondition.kind === 'fleet-add-ship') {
+        assertKeys(precondition, field, [
+            'kind',
+            'address',
+            'game',
+            'profile',
+            'authority',
+            'system',
+            'shipId',
+            'amount',
+            'keyIndex',
+            'configHash',
+            'maximumProfileDebit',
+            'describes',
+        ]);
+        const keyIndex = precondition.keyIndex;
+        if (typeof keyIndex !== 'number' ||
+            !Number.isInteger(keyIndex) ||
+            keyIndex < 0 ||
+            keyIndex > 65535)
+            invalid(`${field}.keyIndex`, keyIndex, 'an integer from 0 through 65535');
+        const shipId = precondition.shipId;
+        if (typeof shipId !== 'number' ||
+            !Number.isInteger(shipId) ||
+            shipId < 0 ||
+            shipId > 65535)
+            invalid(`${field}.shipId`, shipId, 'a u16 ship configuration ID');
+        const amount = precondition.amount;
+        if (typeof amount !== 'bigint' || amount < 1n || amount > 255n)
+            invalid(`${field}.amount`, amount, 'a whole ship quantity from 1n through 255n');
+        const maximumProfileDebit = precondition.maximumProfileDebit;
+        if (typeof maximumProfileDebit !== 'bigint' || maximumProfileDebit < 0n)
+            invalid(`${field}.maximumProfileDebit`, maximumProfileDebit, 'a nonnegative bigint');
+        return Object.freeze({
+            kind: 'fleet-add-ship',
+            address: readAddress(precondition.address, `${field}.address`),
+            game: readAddress(precondition.game, `${field}.game`),
+            profile: readAddress(precondition.profile, `${field}.profile`),
+            authority: readAddress(precondition.authority, `${field}.authority`),
+            system: readAddress(precondition.system, `${field}.system`),
+            keyIndex,
+            shipId,
+            amount,
+            maximumProfileDebit,
+            configHash: readDataHash(precondition.configHash, `${field}.configHash`),
+            describes: readString(precondition.describes, `${field}.describes`),
+        });
+    }
+    if (version >= 10 && precondition.kind === 'fleet-create') {
+        assertKeys(precondition, field, [
+            'kind',
+            'address',
+            'game',
+            'profile',
+            'authority',
+            'system',
+            'keyIndex',
+            'label',
+            'maximumProfileDebit',
+            'describes',
+        ]);
+        const keyIndex = precondition.keyIndex;
+        if (typeof keyIndex !== 'number' ||
+            !Number.isSafeInteger(keyIndex) ||
+            keyIndex < 0 ||
+            keyIndex > 65_535)
+            invalid(`${field}.keyIndex`, keyIndex, 'an integer from 0 through 65535');
+        const label = readString(precondition.label, `${field}.label`);
+        const bytes = new TextEncoder().encode(label);
+        if (label.trim().length === 0 ||
+            label.includes('\0') ||
+            bytes.length > 64 ||
+            new TextDecoder('utf-8', { ignoreBOM: true }).decode(bytes) !== label)
+            invalid(`${field}.label`, label, 'a nonblank, NUL-free Unicode label of at most 64 UTF-8 bytes');
+        const maximumProfileDebit = precondition.maximumProfileDebit;
+        if (typeof maximumProfileDebit !== 'bigint' || maximumProfileDebit < 0n)
+            invalid(`${field}.maximumProfileDebit`, maximumProfileDebit, 'a nonnegative bigint');
+        return Object.freeze({
+            kind: 'fleet-create',
+            address: readAddress(precondition.address, `${field}.address`),
+            game: readAddress(precondition.game, `${field}.game`),
+            profile: readAddress(precondition.profile, `${field}.profile`),
+            authority: readAddress(precondition.authority, `${field}.authority`),
+            system: readAddress(precondition.system, `${field}.system`),
+            keyIndex,
+            label,
+            maximumProfileDebit,
+            describes: readString(precondition.describes, `${field}.describes`),
+        });
+    }
+    if (version >= 8 && precondition.kind === 'system-account-or-absent') {
+        assertKeys(precondition, field, ['kind', 'address', 'describes']);
+        return Object.freeze({
+            kind: 'system-account-or-absent',
+            address: readAddress(precondition.address, `${field}.address`),
+            describes: readString(precondition.describes, `${field}.describes`),
+        });
+    }
+    if (version >= 7 && precondition.kind === 'token-mint') {
+        assertKeys(precondition, field, [
+            'kind',
+            'address',
+            'decimals',
+            'describes',
+        ]);
+        const decimals = precondition.decimals;
+        if (typeof decimals !== 'number' ||
+            !Number.isInteger(decimals) ||
+            decimals < 0 ||
+            decimals > 255)
+            invalid(`${field}.decimals`, decimals, 'an unsigned u8 mint decimals value');
+        return Object.freeze({
+            kind: 'token-mint',
+            address: readAddress(precondition.address, `${field}.address`),
+            decimals,
+            describes: readString(precondition.describes, `${field}.describes`),
+        });
+    }
+    if (version >= 6 && precondition.kind === 'game-ship-config') {
+        assertKeys(precondition, field, [
+            'kind',
+            'address',
+            'shipId',
+            'configHash',
+            'describes',
+        ]);
+        const id = precondition.shipId;
+        if (typeof id !== 'number' || !Number.isInteger(id) || id < 0 || id > 65535)
+            invalid(`${field}.shipId`, id, 'a u16 ship configuration ID');
+        return Object.freeze({
+            kind: 'game-ship-config',
+            address: readAddress(precondition.address, `${field}.address`),
+            shipId: id,
+            configHash: readDataHash(precondition.configHash, `${field}.configHash`),
+            describes: readString(precondition.describes, `${field}.describes`),
+        });
+    }
+    if (version >= 5 && precondition.kind === 'game-account') {
+        assertKeys(precondition, field, ['kind', 'address', 'describes']);
+        return Object.freeze({
+            kind: 'game-account',
+            address: readAddress(precondition.address, `${field}.address`),
+            describes: readString(precondition.describes, `${field}.describes`),
+        });
+    }
+    if ((version >= 9 && precondition.kind === 'game-cargo-bytes-config') ||
+        (version >= 4 &&
+            ['token-account', 'game-cargo-config', 'cargo-cache'].includes(String(precondition.kind)))) {
+        const base = {
+            address: readAddress(precondition.address, `${field}.address`),
+            describes: readString(precondition.describes, `${field}.describes`),
+        };
+        if (precondition.kind === 'token-account') {
+            assertKeys(precondition, field, [
+                'kind',
+                'address',
+                'mint',
+                'owner',
+                'minimumBalance',
+                'describes',
+            ]);
+            const amount = precondition.minimumBalance;
+            if (typeof amount !== 'bigint' ||
+                amount < 0n ||
+                amount > (1n << 64n) - 1n)
+                invalid(`${field}.minimumBalance`, amount, 'an unsigned u64 bigint');
+            return Object.freeze({
+                ...base,
+                kind: 'token-account',
+                mint: readAddress(precondition.mint, `${field}.mint`),
+                owner: readAddress(precondition.owner, `${field}.owner`),
+                minimumBalance: amount,
+            });
+        }
+        if (precondition.kind === 'game-cargo-config' ||
+            precondition.kind === 'game-cargo-bytes-config') {
+            assertKeys(precondition, field, [
+                'kind',
+                'address',
+                'cargoId',
+                'configHash',
+                'describes',
+            ]);
+            const id = precondition.cargoId;
+            if (typeof id !== 'number' ||
+                !Number.isInteger(id) ||
+                id < 0 ||
+                id > 65535)
+                invalid(`${field}.cargoId`, id, 'a u16 cargo ID');
+            return Object.freeze({
+                ...base,
+                kind: precondition.kind,
+                cargoId: id,
+                configHash: readDataHash(precondition.configHash, `${field}.configHash`),
+            });
+        }
+        assertKeys(precondition, field, [
+            'kind',
+            'address',
+            'game',
+            'bump',
+            'describes',
+        ]);
+        const bump = precondition.bump;
+        if (typeof bump !== 'number' ||
+            !Number.isInteger(bump) ||
+            bump < 0 ||
+            bump > 255)
+            invalid(`${field}.bump`, bump, 'a u8 PDA bump');
+        return Object.freeze({
+            ...base,
+            kind: 'cargo-cache',
+            game: readAddress(precondition.game, `${field}.game`),
+            bump,
+        });
+    }
+    if (precondition.kind === 'token-account-or-absent' && version >= 3) {
         assertKeys(precondition, field, [
             'kind',
             'address',
@@ -186,11 +514,45 @@ function normalizePrecondition(value, field, version = 3) {
         });
     }
     if (precondition.kind !== 'account-state') {
-        invalid(`${field}.kind`, precondition.kind, version === 3
-            ? 'one of account-state, account-absent, or token-account-or-absent'
-            : version === 2
-                ? 'one of account-state or account-absent'
-                : 'the value account-state');
+        invalid(`${field}.kind`, precondition.kind, version === 1
+            ? 'the value account-state'
+            : `one of ${[
+                ...(version >= 17 ? ['fleet-arrival'] : []),
+                ...(version >= 16
+                    ? ['democracy-history', 'xp-runtime', 'governance-fees']
+                    : []),
+                ...(version >= 15 ? ['ship-import-funding'] : []),
+                ...(version >= 14
+                    ? [
+                        'faction-treasury-buy-versioned',
+                        'faction-treasury-sell-versioned',
+                        'faction-epoch-meter-versioned',
+                    ]
+                    : []),
+                ...(version >= 13 ? ['fleet-mining'] : []),
+                ...(version >= 12
+                    ? [
+                        'faction-treasury-buy',
+                        'faction-treasury-sell',
+                        'faction-epoch-meter',
+                    ]
+                    : []),
+                ...(version >= 11 ? ['fleet-add-ship'] : []),
+                ...(version >= 10 ? ['fleet-create'] : []),
+                'account-state',
+                'account-absent',
+                ...(version >= 8 ? ['system-account-or-absent'] : []),
+                ...(version >= 3 ? ['token-account-or-absent'] : []),
+                ...(version >= 4 ? ['token-account'] : []),
+                ...(version >= 7 ? ['token-mint'] : []),
+                ...(version >= 4 ? ['game-cargo-config'] : []),
+                ...(version >= 9 ? ['game-cargo-bytes-config'] : []),
+                ...(version >= 4 ? ['cargo-cache'] : []),
+                ...(version >= 5 ? ['game-account'] : []),
+                ...(version >= 6 ? ['game-ship-config'] : []),
+            ]
+                .join(', ')
+                .replace(/, ([^,]+)$/u, version === 2 ? ' or $1' : ', or $1')}`);
     }
     assertKeys(precondition, field, ['kind', 'address', 'dataHash', 'describes']);
     return Object.freeze({
@@ -242,12 +604,163 @@ function planToJSON(plan) {
             : {}),
         signers: [...step.signers],
     }));
+    const hasArrivalGuard = plan.preconditions.some(({ kind }) => kind === 'fleet-arrival');
+    const hasRuntimeGuard = plan.preconditions.some(isRuntimeGuard);
+    const hasShipImportFunding = plan.preconditions.some(({ kind }) => kind === 'ship-import-funding');
+    const hasMiningGuard = plan.preconditions.some(({ kind }) => kind === 'fleet-mining');
+    if (hasArrivalGuard ||
+        hasRuntimeGuard ||
+        hasShipImportFunding ||
+        hasMiningGuard ||
+        plan.preconditions.some(isFactionTradeGuard)) {
+        return deepFreeze({
+            v: hasArrivalGuard
+                ? 17
+                : hasRuntimeGuard
+                    ? 16
+                    : hasShipImportFunding
+                        ? 15
+                        : plan.preconditions.some((guard) => 'schemaVersion' in guard)
+                            ? 14
+                            : hasMiningGuard
+                                ? 13
+                                : 12,
+            ...common,
+            steps,
+            preconditions: plan.preconditions.map((guard) => {
+                if (guard.kind === 'fleet-arrival')
+                    return arrivalGuardToJSON(guard);
+                if (isRuntimeGuard(guard))
+                    return runtimeGuardToJSON(guard);
+                if (isTradeBuyGuard(guard))
+                    return { ...guard, floorRaw: String(guard.floorRaw) };
+                if (isTradeSellGuard(guard))
+                    return {
+                        ...guard,
+                        atlasOutCapPerEpochRaw: String(guard.atlasOutCapPerEpochRaw),
+                        epochLengthSeconds: String(guard.epochLengthSeconds),
+                    };
+                if (guard.kind === 'fleet-add-ship')
+                    return {
+                        ...guard,
+                        amount: String(guard.amount),
+                        maximumProfileDebit: String(guard.maximumProfileDebit),
+                    };
+                if (guard.kind === 'fleet-create' ||
+                    guard.kind === 'ship-import-funding')
+                    return {
+                        ...guard,
+                        maximumProfileDebit: String(guard.maximumProfileDebit),
+                    };
+                if (guard.kind === 'token-account')
+                    return { ...guard, minimumBalance: String(guard.minimumBalance) };
+                return { ...guard };
+            }),
+        });
+    }
+    if (plan.preconditions.some(({ kind }) => kind === 'fleet-add-ship')) {
+        return deepFreeze({
+            v: 11,
+            ...common,
+            steps,
+            preconditions: plan.preconditions.map((guard) => guard.kind === 'fleet-add-ship'
+                ? {
+                    ...guard,
+                    amount: String(guard.amount),
+                    maximumProfileDebit: String(guard.maximumProfileDebit),
+                }
+                : guard.kind === 'fleet-create'
+                    ? {
+                        ...guard,
+                        maximumProfileDebit: String(guard.maximumProfileDebit),
+                    }
+                    : guard.kind === 'token-account'
+                        ? { ...guard, minimumBalance: String(guard.minimumBalance) }
+                        : { ...guard }),
+        });
+    }
+    if (plan.preconditions.some(({ kind }) => kind === 'fleet-create')) {
+        return deepFreeze({
+            v: 10,
+            ...common,
+            steps,
+            preconditions: plan.preconditions.map((guard) => guard.kind === 'fleet-create'
+                ? { ...guard, maximumProfileDebit: String(guard.maximumProfileDebit) }
+                : guard.kind === 'token-account'
+                    ? { ...guard, minimumBalance: String(guard.minimumBalance) }
+                    : { ...guard }),
+        });
+    }
+    if (plan.preconditions.some(({ kind }) => kind === 'game-cargo-bytes-config')) {
+        return deepFreeze({
+            v: 9,
+            ...common,
+            steps,
+            preconditions: plan.preconditions.map((guard) => guard.kind === 'token-account'
+                ? { ...guard, minimumBalance: String(guard.minimumBalance) }
+                : { ...guard }),
+        });
+    }
+    if (plan.preconditions.some(({ kind }) => kind === 'system-account-or-absent')) {
+        return deepFreeze({
+            v: 8,
+            ...common,
+            steps,
+            preconditions: plan.preconditions.map((guard) => guard.kind === 'token-account'
+                ? { ...guard, minimumBalance: String(guard.minimumBalance) }
+                : { ...guard }),
+        });
+    }
+    if (plan.preconditions.some(({ kind }) => kind === 'token-mint')) {
+        return deepFreeze({
+            v: 7,
+            ...common,
+            steps,
+            preconditions: plan.preconditions.map((guard) => guard.kind === 'token-account'
+                ? { ...guard, minimumBalance: String(guard.minimumBalance) }
+                : { ...guard }),
+        });
+    }
+    if (plan.preconditions.some(({ kind }) => kind === 'game-ship-config')) {
+        return deepFreeze({
+            v: 6,
+            ...common,
+            steps,
+            preconditions: plan.preconditions.map((guard) => guard.kind === 'token-account'
+                ? { ...guard, minimumBalance: String(guard.minimumBalance) }
+                : { ...guard }),
+        });
+    }
+    if (plan.preconditions.some(({ kind }) => kind === 'game-account')) {
+        return deepFreeze({
+            v: 5,
+            ...common,
+            steps,
+            preconditions: plan.preconditions.map((guard) => guard.kind === 'token-account'
+                ? { ...guard, minimumBalance: String(guard.minimumBalance) }
+                : { ...guard }),
+        });
+    }
+    if (plan.preconditions.some(({ kind }) => kind === 'token-account' ||
+        kind === 'game-cargo-config' ||
+        kind === 'cargo-cache')) {
+        return deepFreeze({
+            v: 4,
+            ...common,
+            steps,
+            preconditions: plan.preconditions.map((guard) => guard.kind === 'token-account'
+                ? { ...guard, minimumBalance: String(guard.minimumBalance) }
+                : { ...guard }),
+        });
+    }
     if (plan.preconditions.some(({ kind }) => kind === 'token-account-or-absent')) {
         return deepFreeze({
             v: 3,
             ...common,
             steps,
-            preconditions: plan.preconditions.map((guard) => ({ ...guard })),
+            preconditions: plan.preconditions.map((guard) => ({
+                ...guard,
+            })),
         });
     }
     if (hasSemantics || hasAbsentPrecondition) {
@@ -291,6 +804,7 @@ export function createPlan(input) {
     assertKeys(value, 'plan', ['kind', 'summary', 'steps', 'preconditions']);
     const steps = Object.freeze(readArray(value.steps, 'plan.steps').map((step, index) => normalizeStep(step, `plan.steps[${String(index)}]`)));
     const preconditions = Object.freeze(readArray(value.preconditions, 'plan.preconditions').map((precondition, index) => normalizePrecondition(precondition, `plan.preconditions[${String(index)}]`)));
+    validateShipImportFundingComposition(preconditions);
     const descriptions = Object.freeze(steps.map((step) => step.describes));
     const plan = {
         kind: readString(value.kind, 'plan.kind'),
@@ -337,13 +851,13 @@ function sameAddresses(actual, encoded) {
  *
  * @example
  * ```ts
- * declare const wire: PlanJsonV1 | PlanJsonV2 | PlanJsonV3;
+ * declare const wire: PlanJsonV1 | PlanJsonV2 | PlanJsonV3 | PlanJsonV4 | PlanJsonV5 | PlanJsonV6 | PlanJsonV7 | PlanJsonV8 | PlanJsonV9 | PlanJsonV10 | PlanJsonV11 | PlanJsonV12 | PlanJsonV13 | PlanJsonV14 | PlanJsonV15 | PlanJsonV16 | PlanJsonV17;
  * const plan = planFromJSON(wire);
  * console.log(plan.describe());
  * ```
  */
 export function planFromJSON(json) {
-    const value = readRecord(json, 'planJson');
+    const value = { ...readRecord(json, 'planJson') };
     assertKeys(value, 'planJson', [
         'v',
         'kind',
@@ -353,10 +867,79 @@ export function planFromJSON(json) {
         'affected',
         'requiredSigners',
     ]);
-    if (value.v !== 1 && value.v !== 2 && value.v !== 3) {
-        invalid('planJson.v', value.v, 'the Plan wire version 1, 2, or 3');
+    if (value.v !== 1 &&
+        value.v !== 2 &&
+        value.v !== 3 &&
+        value.v !== 4 &&
+        value.v !== 5 &&
+        value.v !== 6 &&
+        value.v !== 7 &&
+        value.v !== 8 &&
+        value.v !== 9 &&
+        value.v !== 10 &&
+        value.v !== 11 &&
+        value.v !== 12 &&
+        value.v !== 13 &&
+        value.v !== 14 &&
+        value.v !== 15 &&
+        value.v !== 16 &&
+        value.v !== 17) {
+        invalid('planJson.v', value.v, 'the Plan wire version 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, or 17');
     }
     const version = value.v;
+    if (version >= 4 && Array.isArray(value.preconditions)) {
+        value.preconditions = value.preconditions.map((entry) => {
+            const guard = readRecord(entry, 'precondition');
+            if (version >= 17 && guard.kind === 'fleet-arrival')
+                return normalizeArrivalGuard(guard, 'precondition', true);
+            if (version >= 16 && isRuntimeGuard(guard))
+                return normalizeRuntimeGuard(guard, 'precondition', true);
+            if (version >= 12 &&
+                (isTradeBuyGuard(guard) || isTradeSellGuard(guard))) {
+                const keys = isTradeBuyGuard(guard)
+                    ? ['floorRaw']
+                    : ['atlasOutCapPerEpochRaw', 'epochLengthSeconds'];
+                const decoded = { ...guard };
+                for (const key of keys) {
+                    const raw = guard[key];
+                    const pattern = key === 'epochLengthSeconds'
+                        ? /^(0|[1-9][0-9]*|-[1-9][0-9]*)$/
+                        : /^(0|[1-9][0-9]*)$/;
+                    if (typeof raw !== 'string' || !pattern.test(raw))
+                        invalid(key, raw, 'a canonical decimal string');
+                    decoded[key] = BigInt(raw);
+                }
+                return decoded;
+            }
+            if (version >= 11 && guard.kind === 'fleet-add-ship') {
+                for (const field of ['amount', 'maximumProfileDebit'])
+                    if (typeof guard[field] !== 'string' ||
+                        !/^(0|[1-9][0-9]*)$/.test(guard[field]))
+                        invalid(field, guard[field], 'a canonical unsigned decimal string');
+                return {
+                    ...guard,
+                    amount: BigInt(guard.amount),
+                    maximumProfileDebit: BigInt(guard.maximumProfileDebit),
+                };
+            }
+            if ((version >= 10 && guard.kind === 'fleet-create') ||
+                (version >= 15 && guard.kind === 'ship-import-funding')) {
+                if (typeof guard.maximumProfileDebit !== 'string' ||
+                    !/^(0|[1-9][0-9]*)$/.test(guard.maximumProfileDebit))
+                    invalid('maximumProfileDebit', guard.maximumProfileDebit, 'a canonical unsigned decimal string');
+                return {
+                    ...guard,
+                    maximumProfileDebit: BigInt(guard.maximumProfileDebit),
+                };
+            }
+            if (guard.kind !== 'token-account')
+                return guard;
+            if (typeof guard.minimumBalance !== 'string' ||
+                !/^(0|[1-9][0-9]*)$/.test(guard.minimumBalance))
+                invalid('minimumBalance', guard.minimumBalance, 'a canonical unsigned decimal string');
+            return { ...guard, minimumBalance: BigInt(guard.minimumBalance) };
+        });
+    }
     const steps = readArray(value.steps, 'planJson.steps').map((candidate, index) => {
         const field = `planJson.steps[${String(index)}]`;
         const step = readRecord(candidate, field);
@@ -397,6 +980,53 @@ function assertPlan(value, index) {
 function combinedSummary(steps) {
     return steps.map((step) => step.describes).join(' ');
 }
+function validateShipImportFundingComposition(guards) {
+    const targets = new Map();
+    for (const guard of guards) {
+        if (guard.kind !== 'ship-import-funding')
+            continue;
+        const identity = `${guard.game}:${guard.profile}:${guard.system}:${String(guard.shipId)}`;
+        const previous = targets.get(guard.address);
+        if (previous !== undefined && previous !== identity)
+            throw new SageSdkError('INCOMPATIBLE_PLAN_COMPOSITION', 'Ship imports retain conflicting identities or different configurations for one StarbasePlayer. Use separate confirmed imports, then refresh inventory and replan; prefunding cannot be shared across independently estimated storage growth.');
+        targets.set(guard.address, identity);
+    }
+}
+function validateFactionGuardComposition(guards) {
+    const retained = new Map();
+    for (const guard of guards) {
+        if (!isFactionTradeGuard(guard))
+            continue;
+        const constraints = [
+            [
+                `${isTradeMeterGuard(guard) ? 'meter' : 'treasury'}:${guard.address}:identity`,
+                `${guard.game}:${String(guard.factionId)}`,
+            ],
+        ];
+        if (!isTradeMeterGuard(guard)) {
+            constraints.push(isTradeBuyGuard(guard)
+                ? [
+                    `${guard.address}:buy:${String(guard.cargoId)}`,
+                    String(guard.floorRaw),
+                ]
+                : [
+                    `${guard.address}:sell`,
+                    `${String(guard.atlasOutCapPerEpochRaw)}:${String(guard.epochLengthSeconds)}`,
+                ]);
+        }
+        if ('schemaVersion' in guard)
+            constraints.push([
+                `${guard.address}:schema`,
+                String(guard.schemaVersion),
+            ]);
+        for (const [key, value] of constraints) {
+            const previous = retained.get(key);
+            if (previous !== undefined && previous !== value)
+                throw new SageSdkError('INCOMPATIBLE_PLAN_COMPOSITION', 'Faction Market Plans retain incompatible Treasury policy or shared account identity. Refresh the affected Markets and prepare compatible Plans, or use separate confirmed transactions.');
+            retained.set(key, value);
+        }
+    }
+}
 /** Combines one or more Plans with deterministic associative flattening.
  *
  * Semantic validation is eager. Conflict indices are relative to the flattened
@@ -417,11 +1047,16 @@ export function combinePlans(...plans) {
     plans.forEach(assertPlan);
     const steps = plans.flatMap((plan) => plan.steps);
     validatePlanComposition(steps);
+    const preconditions = plans.flatMap((plan) => plan.preconditions);
+    validateFactionGuardComposition(preconditions);
+    validateMiningStopInstructions(steps, preconditions);
+    validateArrivalInstructions(steps, preconditions);
+    validateRuntimeInstructions(steps, preconditions);
     return createPlan({
         kind: 'combined',
         summary: combinedSummary(steps),
         steps,
-        preconditions: plans.flatMap((plan) => plan.preconditions),
+        preconditions,
     });
 }
 export { assemblePlan } from './assembly.js';