@johnmorrisdotca/houseki 0.3.0 → 0.4.1

package/dist/colour-chains/content-types.d.ts

@@ -14,6 +14,21 @@ export interface ChainDifficultyMetrics {
     readonly seededPlayoutVariablePrefixLength?: number;
     /** Number of later witnessed placements held fixed in each seeded playout. */
     readonly seededPlayoutFixedSuffixLength?: number;
+    readonly seededPlayoutPlacements?: number;
+    readonly fullPlanSuccessRate?: number;
+    readonly witnessedPlanPlacements?: number;
+    readonly singleStepDeviationProbes?: number;
+    readonly singleStepDeviationWins?: number;
+    readonly singleStepDeviationDeadEnds?: number;
+    readonly branchingDecisionPoints?: number;
+    readonly forcedSafeSteps?: number;
+    readonly forcedSafeShare?: number;
+    readonly branchingShare?: number;
+    readonly consequentialDecisionShare?: number;
+    readonly setupDeviationProbes?: number;
+    readonly setupDeviationLosses?: number;
+    readonly setupDeviationLossShare?: number;
+    readonly verifiedSetupDependencyShare?: number;
     readonly seededPlayoutSuccesses: number;
     readonly seededPlayoutSuccessRate: number;
     readonly setupPairsBeforePayoff: number;
@@ -21,7 +36,27 @@ export interface ChainDifficultyMetrics {
     readonly verifiedSetupDependencies: number;
     /** Number of pre-payoff steps checked by exhaustive single-step deviations. */
     readonly setupDependencyProbeSteps?: number;
+    /** A verified alternate far-side first placement followed by the witnessed recovery pair. */
+    readonly verifiedWrongFirstRecovery?: number;
+    readonly goalTargets?: number;
+    /** Number of distinct target-color components or explicitly required chain waves. */
+    readonly goalDependencyCount?: number;
+    readonly occupiedCells?: number;
+    readonly usableCells?: number;
+    readonly boardCoverage?: number;
+    readonly goalCoordinationShare?: number;
+    readonly cascadeShare?: number;
+    readonly weatherEventCount?: number;
+    readonly weatherDependency?: number;
+    readonly mechanicOffCounterfactualWon?: boolean;
+    readonly mechanicOffCounterfactualKind?: 'nature' | 'magnetism' | 'weather';
+    readonly mechanicOffCounterfactualPhase?: string;
+    readonly rawDifficultyScore?: number;
     readonly requiredChainDepth: number;
+    /** Highest chain observed in the exact authored witness. */
+    readonly witnessedChainDepth?: number;
+    /** Highest chain seen in the bounded random-play sample; not a requirement claim. */
+    readonly observedPotentialChainDepth?: number;
     readonly requiredRotations: number;
     readonly requiredWallKicks: number;
     readonly splitLandingDependencies: number;
@@ -52,12 +87,16 @@ export interface ChainCampaignLevel {
     readonly gradingVersion: string;
     readonly proofStatus: 'engine-witness-verified';
     readonly reviewStatus: 'human-review-pending' | 'human-reviewed';
+    readonly band?: 'entry' | 'easy' | 'intermediate' | 'hard' | 'expert';
+    readonly rawDifficultyScore?: number;
+    readonly normalizationCategory?: string;
 }
 export interface NatureChainCampaignLevel extends ChainCampaignLevel {
     readonly objective: LocalizedText;
     readonly nature: true;
     readonly weather?: 'frequent';
     readonly magneticQueue?: readonly (readonly [boolean, boolean])[];
+    readonly weatherTrace?: readonly Readonly<Record<string, unknown>>[];
 }
 export interface ChainCampaignManifest {
     readonly count: number;
@@ -72,8 +111,15 @@ export interface ChainCampaignManifest {
     readonly checksum: string;
     readonly levels: readonly ChainCampaignLevel[];
 }
+export interface NatureCampaignBand {
+    readonly id: 'entry' | 'easy' | 'intermediate' | 'hard' | 'expert';
+    readonly count: number;
+    readonly first: number;
+    readonly last: number;
+}
 export interface NatureChainCampaignManifest extends Omit<ChainCampaignManifest, 'levels'> {
     readonly levels: readonly NatureChainCampaignLevel[];
+    readonly bands?: readonly NatureCampaignBand[];
 }
 export interface ChainTutorialStep {
     readonly instruction: LocalizedText;

package/dist/colour-chains.d.ts

@@ -5,4 +5,4 @@ export { createChallenge } from './colour-chains/challenge.js';
 export { restartGame, encodeGame, decodeGame } from './colour-chains/persistence.js';
 export { createInputScheduler, setHeldInput, queueInputEdge, releaseAllInput, actionsForTick, applyScheduledActions, processInputTick } from './colour-chains/input.js';
 export { campaignManifest, levelManifest, tutorialManifest, getLevel, createLevel, getTutorial, shizenCampaignManifest, shizenLevelManifest, getShizenLevel, createShizenLevel, arashiCampaignManifest, arashiLevelManifest, getArashiLevel, createArashiLevel } from './colour-chains/content.js';
-export type { LocalizedText, ChainDifficultyMetrics, ChainCampaignLevel, ChainCampaignManifest, NatureChainCampaignLevel, NatureChainCampaignManifest, ChainTutorialStep, ChainTutorialDefinition, ChainContentData } from './colour-chains/content-types.js';
+export type { LocalizedText, ChainDifficultyMetrics, ChainCampaignLevel, ChainCampaignManifest, NatureChainCampaignLevel, NatureChainCampaignManifest, NatureCampaignBand, ChainTutorialStep, ChainTutorialDefinition, ChainContentData } from './colour-chains/content-types.js';

package/dist/gem-swap/persistence.js

@@ -8,12 +8,14 @@ export class ReplayError extends TypeError {
     code;
     constructor(code, message) { super(message); this.name = 'ReplayError'; this.code = code; }
 }
-function canonical(value) {
+function canonical(value, depth = 0) {
+    if (depth > 50)
+        throw new ReplayError('save-too-deep', 'Replay is nested too deeply');
     if (Array.isArray(value))
-        return `[${value.map(canonical).join(',')}]`;
+        return `[${value.map(item => canonical(item, depth + 1)).join(',')}]`;
     if (value && typeof value === 'object') {
         const object = value;
-        return `{${Object.keys(object).sort().map(key => `${JSON.stringify(key)}:${canonical(object[key])}`).join(',')}}`;
+        return `{${Object.keys(object).sort().map(key => `${JSON.stringify(key)}:${canonical(object[key], depth + 1)}`).join(',')}}`;
     }
     return JSON.stringify(value);
 }

package/dist/gem-swap/practice.js

@@ -35,7 +35,7 @@ export function reshuffleTransition(state) {
     const finishedRelaxed = state.mode === 'relaxed' && state.phase === 'finished' && state.outcome === 'finished' && !findMatches(state.board, state.settings).length;
     if (state.mode !== 'relaxed' || (!onReady(state) && !finishedRelaxed) || state.selectedTool)
         return rejected(state, 'reshuffle-unavailable');
-    const gems = state.board.filter((item) => item !== null);
+    const gems = state.board.filter((item, index) => item !== null && index !== state.blackHole?.cell);
     let randomState = state.randomState;
     for (let attempt = 0; attempt < 128; attempt++) {
         const shuffled = [...gems];
@@ -47,7 +47,7 @@ export function reshuffleTransition(state) {
         const board = [...state.board];
         let at = 0;
         for (let index = 0; index < board.length; index++)
-            if (state.settings.mask[index])
+            if (state.settings.mask[index] && index !== state.blackHole?.cell)
                 board[index] = shuffled[at++];
         if (!findMatches(board, state.settings).length && listLegalSwaps({ ...state, board }).length) {
             return { state: Object.freeze({ ...state, board: Object.freeze(board), randomState, assisted: true, phase: 'ready', outcome: null, selectedTool: null, toolTarget: null, toolPreview: Object.freeze([]) }), events: Object.freeze([{ type: 'board-reshuffled', attempts: attempt + 1, assisted: true }]), accepted: true };