@johnmorrisdotca/houseki 0.0.0-stage → 0.1.0

package/dist/falling-triplets/content-types.d.ts

@@ -0,0 +1,72 @@
+import type { ChallengeGoal, ChallengeHint, Colour, Gem, Triplet } from './types.js';
+export interface LocalizedText {
+    readonly en: string;
+    readonly ja: string;
+}
+export interface DifficultyMetrics {
+    readonly seededGoalSuccesses: number;
+    readonly seededGoalSamples: number;
+    readonly seededGoalSuccessRate: number;
+    readonly legalChoiceBreadth: number;
+    readonly goalPreservingChoices: number;
+    readonly probedChoices: number;
+    readonly goalPreservingChoiceShare: number;
+    readonly forcedChoiceShare: number;
+    readonly setupPiecesBeforePayoff: number;
+    readonly requiredChainDepth: number;
+    readonly witnessPlanningLength: number;
+    readonly payoffDirections: number;
+}
+export interface CampaignLevel {
+    readonly id: string;
+    readonly seed: string;
+    readonly number: number;
+    readonly title: LocalizedText;
+    /** SHA-256 fingerprint of the colour- and mirror-canonical duplicate key. */
+    readonly canonicalKeyHash: string;
+    readonly width: number;
+    readonly height: number;
+    readonly colourCount: 4 | 5 | 6;
+    readonly goal: ChallengeGoal;
+    readonly board: readonly (Gem | null)[];
+    readonly queue: readonly Triplet[];
+    readonly witness: readonly ChallengeHint[];
+    readonly tags: readonly string[];
+    readonly rawMetrics: DifficultyMetrics;
+    readonly score: number;
+    readonly marks: 1 | 2 | 3 | 4 | 5;
+    readonly gradingVersion: string;
+    readonly proofStatus: 'engine-witness-verified';
+    readonly reviewStatus: 'human-review-pending' | 'human-reviewed';
+}
+export interface CampaignManifest {
+    readonly count: number;
+    readonly candidatePoolCount: number;
+    readonly generationRevision: string;
+    readonly gradingVersion: string;
+    readonly category: string;
+    readonly curationPolicy: string;
+    readonly orderingPolicy: string;
+    readonly grading: Readonly<Record<string, unknown>>;
+    readonly sampleBudget: number;
+    readonly checksum: string;
+    readonly levels: readonly CampaignLevel[];
+}
+export interface TutorialStep {
+    readonly instruction: LocalizedText;
+    readonly action: string;
+}
+export interface TutorialDefinition {
+    readonly id: string;
+    readonly title: LocalizedText;
+    readonly objective: LocalizedText;
+    readonly setup: {
+        readonly board: readonly (Gem | null)[];
+        readonly queue: readonly Triplet[];
+        readonly goal: ChallengeGoal;
+        readonly witness: readonly ChallengeHint[];
+    };
+    readonly steps: readonly TutorialStep[];
+    readonly tags: readonly string[];
+}
+export type { Colour };

package/dist/falling-triplets/content-types.js

@@ -0,0 +1 @@
+export {};

package/dist/falling-triplets/content.d.ts

@@ -0,0 +1,11 @@
+import type { CampaignLevel, CampaignManifest, TutorialDefinition } from './content-types.js';
+import type { GameState } from './types.js';
+export declare const campaignManifest: CampaignManifest;
+export declare const levelManifest: readonly CampaignLevel[];
+export declare const tutorialManifest: readonly TutorialDefinition[];
+/** Find a level by stable content ID or its current one-based display number. */
+export declare function getLevel(id: string | number): CampaignLevel | undefined;
+/** Construct a fresh validated challenge state for a stable level ID or display number. */
+export declare function createLevel(id: string | number): GameState;
+/** Find a lesson by its persistent ID. */
+export declare function getTutorial(id: string): TutorialDefinition | undefined;

package/dist/falling-triplets/content.js

@@ -0,0 +1,39 @@
+import { contentData } from './content-data.js';
+import { createChallenge } from './engine.js';
+function deepFreeze(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const child of Object.values(value))
+            deepFreeze(child);
+    }
+    return value;
+}
+export const campaignManifest = deepFreeze(contentData.campaign);
+export const levelManifest = campaignManifest.levels;
+export const tutorialManifest = deepFreeze(contentData.tutorials);
+/** Find a level by stable content ID or its current one-based display number. */
+export function getLevel(id) {
+    if (typeof id === 'number')
+        return Number.isInteger(id) ? levelManifest.find(level => level.number === id) : undefined;
+    return levelManifest.find(level => level.id === id);
+}
+/** Construct a fresh validated challenge state for a stable level ID or display number. */
+export function createLevel(id) {
+    const level = getLevel(id);
+    if (!level)
+        throw new RangeError(`Unknown Falling Triplets level: ${String(id)}`);
+    return createChallenge({
+        seed: level.seed,
+        width: level.width,
+        height: level.height,
+        colourCount: level.colourCount,
+        board: level.board,
+        queue: level.queue,
+        goal: level.goal,
+        witness: level.witness
+    });
+}
+/** Find a lesson by its persistent ID. */
+export function getTutorial(id) {
+    return tutorialManifest.find(tutorial => tutorial.id === id);
+}

package/dist/falling-triplets/engine.d.ts

@@ -0,0 +1,26 @@
+import type { Action, ChallengeOptions, CreateOptions, GameState, Transition } from './types.js';
+/** Returns the exact landing row for the current rigid triplet. */
+export declare function landingY(state: GameState): number | null;
+/** Creates a deterministic empty game with an active piece and three-piece preview. */
+export declare function createGame(options?: CreateOptions): GameState;
+/** Creates a challenge after validating its authored board, finite queue, goal, and witness. */
+export declare function createChallenge(options: ChallengeOptions): GameState;
+/** Applies and records one immutable action; rejected actions preserve state identity. */
+export declare function applyAction(state: GameState, action: Action): Transition;
+/** Advances fixed 60 Hz game ticks. Arcade timing is applied to the active piece. */
+export declare function advanceTicks(state: GameState, ticks: number): Transition;
+/** Lists the core actions currently available to the player. */
+export declare function legalActions(state: GameState): readonly Action[];
+/** Returns a plain status summary suitable for UI labels. */
+export declare function statusOf(state: GameState): Readonly<{
+    phase: GameState['phase'];
+    score: number;
+    maxChain: number;
+    reason?: string;
+}>;
+/** Recreates the same authored mode, seed, and challenge configuration from its original setup. */
+export declare function restartGame(state: GameState): GameState;
+/** Encodes the authoritative settings, action recording, and derived checkpoint. */
+export declare function encodeGame(state: GameState): string;
+/** Replays and validates a bounded save, then verifies its checkpoint against the derived state. */
+export declare function decodeGame(text: string): GameState;